Rounding to n decimal digits

ruby-talk
1

I often do this:

  class Float
    def round_n(n=0)
      raise FloatDomainError unless self.finite?
      raise ArgumentError unless n.class == Fixnum && n >= 0
      sprintf("%.#{n}f", self).to_f
    end

    def ceil_n(n=0)
      raise FloatDomainError unless self.finite?
      raise ArgumentError unless n.class == Fixnum && n >= 0
      (self*10**n).ceil.to_f / 10**n
    end

    def floor_n(n=0)
      raise FloatDomainError unless self.finite?
      raise ArgumentError unless n.class == Fixnum && n >= 0
      (self*10**n).floor.to_f / 10**n
    end
  end

However I can't help get the feeling that Ruby already has something like this. Did I indeed miss it?

···

--
dave

2

David Garamond <lists@zara.6.isreserved.com> wrote in message news:<40DE9C9F.3030204@zara.6.isreserved.com>...

I often do this:

  class Float
    def round_n(n=0)
      raise FloatDomainError unless self.finite?
      raise ArgumentError unless n.class == Fixnum && n >= 0
      sprintf("%.#{n}f", self).to_f
    end

    def ceil_n(n=0)
      raise FloatDomainError unless self.finite?
      raise ArgumentError unless n.class == Fixnum && n >= 0
      (self*10**n).ceil.to_f / 10**n
    end

    def floor_n(n=0)
      raise FloatDomainError unless self.finite?
      raise ArgumentError unless n.class == Fixnum && n >= 0
      (self*10**n).floor.to_f / 10**n
    end
  end

However I can't help get the feeling that Ruby already has something
like this. Did I indeed miss it?

I don't know if this is what you want and I am thinking that there is
an easier way but this is pretty simple.

puts a=1.1568753256
puts digits=3
puts b=(a)*10**digits
puts c=(b).round
puts c.to_f/10**digits

Just my $0.02 worth,

Todd

3

David Garamond <lists@zara.6.isreserved.com> wrote in message news:<40DE9C9F.3030204@zara.6.isreserved.com>...

I often do this:

  class Float
    def round_n(n=0)
      raise FloatDomainError unless self.finite?
      raise ArgumentError unless n.class == Fixnum && n >= 0
      sprintf("%.#{n}f", self).to_f
    end

    def ceil_n(n=0)
      raise FloatDomainError unless self.finite?
      raise ArgumentError unless n.class == Fixnum && n >= 0
      (self*10**n).ceil.to_f / 10**n
    end

    def floor_n(n=0)
      raise FloatDomainError unless self.finite?
      raise ArgumentError unless n.class == Fixnum && n >= 0
      (self*10**n).floor.to_f / 10**n
    end
  end

However I can't help get the feeling that Ruby already has something
like this. Did I indeed miss it?

And you can combine the lines...

puts a=1.1568753256
puts digits=3
puts ((a).*10**digits).round.to_f/10**digits

Todd

4

David Garamond wrote:

I often do this:

class Float
   def round_n(n=0)
     raise FloatDomainError unless self.finite?
     raise ArgumentError unless n.class == Fixnum && n >= 0
     sprintf("%.#{n}f", self).to_f
   end

   def ceil_n(n=0)
     raise FloatDomainError unless self.finite?
     raise ArgumentError unless n.class == Fixnum && n >= 0
     (self*10**n).ceil.to_f / 10**n
   end

   def floor_n(n=0)
     raise FloatDomainError unless self.finite?
     raise ArgumentError unless n.class == Fixnum && n >= 0
     (self*10**n).floor.to_f / 10**n
   end
end

However I can't help get the feeling that Ruby already has something like this. Did I indeed miss it?

What I'm looking for in Ruby is a command causing all arithmetic to be rounded to special digits.
Like we do in Matlab:

···

Digits:=t;

5

That's the same technique he's using for ceil and floor-- seems like the
best approach available (the only thing left to do now is test whether
multiply and divide is faster than sprintf). Except that instead of
defining round_n, ceil_n, and floor_n, I would probably just redefine
the existing Float#round, Float#ceil and Float#floor methods. Because
he's got n=0 in the method signature existing code that depends on the
default behavior of Float should be fine.

It would be nice if Ruby had this type of thing built-in to those
commands, though.

-Michael Libby

···

On Sun, 2004-06-27 at 09:58, Todd Gardner wrote:

David Garamond <lists@zara.6.isreserved.com> wrote in message news:<40DE9C9F.3030204@zara.6.isreserved.com>...
> class Float
> def round_n(n=0)
> raise FloatDomainError unless self.finite?
> raise ArgumentError unless n.class == Fixnum && n >= 0
> sprintf("%.#{n}f", self).to_f
> end
>
> def ceil_n(n=0)
> raise FloatDomainError unless self.finite?
> raise ArgumentError unless n.class == Fixnum && n >= 0
> (self*10**n).ceil.to_f / 10**n
> end
>
> def floor_n(n=0)
> raise FloatDomainError unless self.finite?
> raise ArgumentError unless n.class == Fixnum && n >= 0
> (self*10**n).floor.to_f / 10**n
> end
> end
>
> However I can't help get the feeling that Ruby already has something
> like this. Did I indeed miss it?

And you can combine the lines...

puts a=1.1568753256
puts digits=3
puts ((a).*10**digits).round.to_f/10**digits

6

Michael C. Libby wrote:

class Float
   def round_n(n=0)
     raise FloatDomainError unless self.finite?
     raise ArgumentError unless n.class == Fixnum && n >= 0
     sprintf("%.#{n}f", self).to_f
   end

   def ceil_n(n=0)
     raise FloatDomainError unless self.finite?
     raise ArgumentError unless n.class == Fixnum && n >= 0
     (self*10**n).ceil.to_f / 10**n
   end

   def floor_n(n=0)
     raise FloatDomainError unless self.finite?
     raise ArgumentError unless n.class == Fixnum && n >= 0
     (self*10**n).floor.to_f / 10**n
   end
end

That's the same technique he's using for ceil and floor-- seems like the
best approach available (the only thing left to do now is test whether
multiply and divide is faster than sprintf). Except that instead of
defining round_n, ceil_n, and floor_n, I would probably just redefine
the existing Float#round, Float#ceil and Float#floor methods. Because
he's got n=0 in the method signature existing code that depends on the
default behavior of Float should be fine.

Btw, if you want to override #round, #ceil, #floor, remember to return a Fixnum if n=0 to avoid breaking other code.

···

--
dave