Velocity Reviews > Ruby > Increase significant digits in Float

# Increase significant digits in Float

Jason Lillywhite
Guest
Posts: n/a

 03-02-2010
If I want to increase my significant digits beyond 15 in a result of a
math expression involving floats, how do I do it? So, for example, I
would like more than 15 sig digits in the result of:

irb(main):001:0> 4.005 / 7
=> 0.572142857142857

Thank you!
--
Posted via http://www.ruby-forum.com/.

Jesús Gabriel y Galán
Guest
Posts: n/a

 03-02-2010
On Tue, Mar 2, 2010 at 4:26 PM, Jason Lillywhite
<(E-Mail Removed)> wrote:
> If I want to increase my significant digits beyond 15 in a result of a
> math expression involving floats, how do I do it? So, for example, I
> would like more than 15 sig digits in the result of:
>
> irb(main):001:0> 4.005 / 7
> => 0.572142857142857

irb is calling inspect on the value of the expression. It's the
inspect method the one that truncates to 15 digits when it creates the
string. You can create your own strings with greater precision like
this:

irb(main):001:0> result = 4.005 / 7
=> 0.572142857142857
irb(main):002:0> "%.20f" % result
=> "0.57214285714285717521"
irb(main):003:0> "%.30f" % result
=> "0.572142857142857175212213860505"

Check the String#% method:

http://ruby-doc.org/core/classes/String.html#M000770

and the Kernel#sprintf method:

http://ruby-doc.org/core/classes/Kernel.html#M005962

Jesus.

Jason Lillywhite
Guest
Posts: n/a

 03-02-2010
JesÃºs Gabriel y GalÃ¡n wrote:

> irb is calling inspect on the value of the expression. It's the
> inspect method the one that truncates to 15 digits when it creates the
> string.

Thank you! I forgot that IRB is returning a truncated string to the
screen.

--
Posted via http://www.ruby-forum.com/.

Xavier Noria
Guest
Posts: n/a

 03-02-2010
On Tue, Mar 2, 2010 at 5:00 PM, Jason Lillywhite
<(E-Mail Removed)> wrote:

> Thank you! I forgot that IRB is returning a truncated string to the
> screen.

That 15 is hard-coded in the definition of Float#to_s.

Siep Korteling
Guest
Posts: n/a

 03-02-2010
Xavier Noria wrote:
> On Tue, Mar 2, 2010 at 5:00 PM, Jason Lillywhite
> <(E-Mail Removed)> wrote:
>
>> Thank you! I forgot that IRB is returning a truncated string to the
>> screen.

>
> That 15 is hard-coded in the definition of Float#to_s.

Yes, and exposing more digits is not accurate:

puts "%.70f"%(4.005 / 7)
#=>0.572142857142857175212213860504562035202980041 5039062500000000000000000
require 'bigdecimal'
a = BigDecimal.new("4.005")
b = a/7
puts b
#=>0.572142857142857142857143E0
p b.precs
#=>[24, 32]

#first number is the number of significant digits in b; the second
number is the maximum precision my system can handle (not sure about
this). The float is bogus after the 16th digit.

hth,

Siep
--
Posted via http://www.ruby-forum.com/.

Jason Lillywhite
Guest
Posts: n/a

 03-02-2010
Siep Korteling wrote:
> #first number is the number of significant digits in b; the second
> number is the maximum precision my system can handle (not sure about
> this). The float is bogus after the 16th digit.

Thank you Siep!

This is interesting - and good to know.

--
Posted via http://www.ruby-forum.com/.

Neve Le
Guest
Posts: n/a

 06-30-2010
Siep Korteling wrote:
>> Xavier Noria wrote:
>> That 15 is hard-coded in the definition of Float#to_s.

>
> Yes, and exposing more digits is not accurate:
> The float is bogus after the 16th digit.

Working with big numbers here, it seems that precision is only
guaranteed to 15 digits on either side of the decimal. When a whole
number >15 digits is divided the decimal is approximated, and anything
>17 digits prints a float of n.0 no matter how it's "%n.nf" formatted.

Is the hard-coded 15 just a "safe" limit? Would I be able to recompile
ruby with a higher definition? If possible, how high could I go?
--
Posted via http://www.ruby-forum.com/.

Brian Candler
Guest
Posts: n/a

 06-30-2010
Neve Le wrote:
> Is the hard-coded 15 just a "safe" limit? Would I be able to recompile
> ruby with a higher definition? If possible, how high could I go?

No, it's a limit of IEEE double-precision floating-point representation.

If you want more digits of precision, use BigDecimal.
--
Posted via http://www.ruby-forum.com/.

Giampiero Zanchi
Guest
Posts: n/a

 06-30-2010

http://www.ruby-forum.com/topic/208840#new

hope this help
--
Posted via http://www.ruby-forum.com/.

brabuhr@gmail.com
Guest
Posts: n/a

 06-30-2010
On Wed, Jun 30, 2010 at 8:06 AM, Neve Le <(E-Mail Removed)> wrote:
> Siep Korteling wrote:
>>> Xavier Noria wrote:
>>> That 15 is hard-coded in the definition of Float#to_s.

>>
>> Yes, and exposing more digits is not accurate:
>> The float is bogus =A0after the 16th digit.

>
> Working with big numbers here, it seems that precision is only
> guaranteed to 15 digits on either side of the decimal. When a whole
> number >15 digits is divided the decimal is approximated, and anything
>>17 digits prints a float of n.0 no matter how it's "%n.nf" formatted.

http://ruby-doc.org/core/classes/Float.html
"Float objects represent real numbers using the native architecture=91s
double-precision floating point representation."

http://en.wikipedia.org/wiki/Double_...g-point_format

You could try BigDecimal.