How do I round a float to a specified number of significant digits in Ruby?

Question

It would be nice to have an equivalent of R's signif function in Ruby.

For example:

>> (11.11).signif(1)
10
>> (22.22).signif(2)
22
>> (3.333).signif(2)
3.3
>> (4.4).signif(3)
4.4 # It's usually 4.40 but that's OK. R does not print the trailing 0's
    # because it returns the float data type. For Ruby we want the same.
>> (5.55).signif(2)
5.6

Would this question be suitable for http://scicomp.stackexchange.com/ ? — Andrew Grimm, Dec 10 '11 at 01:19

score 16 · Answer 1 · answered Dec 05 '11 at 13:57

16

There is probably better way, but this seems to work fine:

class Float
  def signif(signs)
    Float("%.#{signs}g" % self)
  end
end

(1.123).signif(2)                    # => 1.1
(11.23).signif(2)                    # => 11.0
(11.23).signif(1)                    # => 10.0

answered Dec 05 '11 at 13:57

Victor Deryagin

11,895
1
29
38

1

Brilliant! It's the "g" specifier of printf (a.k.a sprintf, a.k.a %) and then cast to float! Brilliant! – Aleksandr Levchuk Dec 11 '11 at 08:09
1

This implementation should be build-in to Ruby. Does anyone care to submit a patch? – Aleksandr Levchuk Dec 11 '11 at 08:09
1

Wait. A nuance: (5.55).signif(2) # should be => 5.6 but gives 5.5 – Aleksandr Levchuk Dec 11 '11 at 09:19
I'm more than half way to a good pull request to ruby 1.9 (https://github.com/alevchuk/ruby/commit/bc2253)! But need to take care of (5.55).signif(2) # => 5.6 – Aleksandr Levchuk Dec 11 '11 at 09:44
I'm thinking of adopting/integrating this code from R, http://svn.r-project.org/R/trunk/src/nmath/fprec.c into Ruby's numeric.c – Aleksandr Levchuk Dec 11 '11 at 20:06

score 8 · Answer 2 · answered Jul 03 '17 at 18:19

8

Here's an implementation that doesn't use strings or other libraries.

class Float
  def signif(digits)
    return 0 if self.zero?
    self.round(-(Math.log10(self).ceil - digits))
  end
end

answered Jul 03 '17 at 18:19

Bravoking

351
3
5

This does the underlying maths with the built-in library. I'd say this is the 'right' way. nb you can simplify the line that does the work: `self.round(digits - Math.log10(self).ceil)` – guy Feb 17 '23 at 11:28

score 3 · Answer 3 · answered Nov 25 '14 at 15:05

Some of the previous answers and comments have alluded to this solution but this is what worked for me:

# takes in a float value and returns another float value rounded to 
# given significant figures.    
def round_to_sig_figs(val, sig_figs)
  BigDecimal.new(val, sig_figs).to_f
end

score 3 · Answer 4 · answered Dec 05 '11 at 09:18

I don't see anything like that in Float. Float is mostly a wrapper for the native double type and given the usual binary/decimal issues, I'm not that surprised that Float doesn't allow you to manipulate the significant digits.

However, BigDecimal in the standard library does understand significant digits but again, I don't see anything that allows you to directly alter the significant digits in a BigDecimal: you can ask for it but you can't change it. But, you can kludge around that by using a no-op version of the mult or add methods:

require 'bigdecimal'
a = BigDecimal.new('11.2384')
a.mult(1, 2) # the result is 0.11E2   (i.e. 11)
a.add(0, 4)  # the result is 0.1124E2 (i.e. 11.24)

The second argument to these methods:

If specified and less than the number of significant digits of the result, the result is rounded to that number of digits, according to BigDecimal.mode.

Using BigDecimal will be slower but it might be your only choice if you need fine grained control or if you need to avoid the usual floating point problems.

[`BigDecimal#new`](http://www.ruby-doc.org/stdlib-1.9.3/libdoc/bigdecimal/rdoc/BigDecimal.html#method-c-new) takes a second parameter that limits the number of significant digits for the number. — jwadsack, Feb 13 '14 at 21:35
@jwadsack: But that only works when creating a new BigDecimal, you can't change the `digits` value of an existing BigDecimal. I think that's what I meant by "I don't see anything that allows you to directly alter the significant digits in a BigDecimal". — mu is too short, Feb 13 '14 at 22:13

score 3 · Answer 5 · edited May 04 '17 at 20:23

You are probably looking for Ruby's Decimal.

You could then write:

require 'decimal/shortcut'
num = 1.23541764
D.context.precision = 2
num_with_2_significant_digits = +D(num.to_s) #  => Decimal('1.2')
num_with_2_significant_digits.to_f #  => 1.2000000000000002

Or if you prefer to use the same syntax add this as a function to class Float like this:

class Float
  def signif num_digits
    require 'decimal/shortcut'
    D.context.precision = num_digits
    (+D(self.to_s)).to_f
  end
end

Usage would then be the same, i.e.

 (1.23333).signif 3
 # => 1.23

To use it, install the gem

gem install ruby-decimal

score 0 · Answer 6 · answered Jun 20 '17 at 16:33

0

@Blou91's answer is nearly there, but it returns a string, instead of a float. This below works for me:

(sprintf "%.2f", 1.23456).to_f

So as a function,

def round(val, sig_figs)
  (sprintf "%.#{sig_figs}f", val).to_f
end

answered Jun 20 '17 at 16:33

habudu

193
3
11

2

This rounds to the specific number of decimal places, but what's wanted is to round to a specific number of significant digits. – Wayne Conrad May 28 '19 at 18:29

score -2 · Answer 7 · answered Jun 08 '14 at 00:18

-2

Use sprintf if you want to print trailing zeros

2.0.0-p353 :001 > sprintf "%.3f", 500
 => "500.000"
2.0.0-p353 :002 > sprintf "%.4f", 500
 => "500.0000"
2.0.0-p353 :003 >

answered Jun 08 '14 at 00:18

Blou91

101
1
2
7

How do I round a float to a specified number of significant digits in Ruby?

7 Answers7

Linked