News for hackers. Stuff that matters.
Re:DEC64: Decimal Floating Point by StefanKarpinski on Saturday March 08, 2014 @09:14PM (#7367170)
The problem here is that Ruby is lying to you – if you enter 0.3 as a literal, you will not get that value.
Re:DEC64: Decimal Floating Point by haberman on Saturday March 08, 2014 @09:20PM (#7367181)
I would challenge you to name any software system that reliably shows you the precise value of a floating point number.

I couldn't find any (like not a single one), so I wrote a program myself to do it: http://blog.reverberate.org/2012/11/dumpfp-tool-to-inspect-f...

Re:DEC64: Decimal Floating Point by StefanKarpinski on Saturday March 08, 2014 @10:10PM (#7367281)
Python, JavaScript V8, Julia, Java.
Re:DEC64: Decimal Floating Point by haberman on Sunday March 09, 2014 @12:27AM (#7367571)
The precise value of double(0.1) is 0.1000000000000000055511151231257827021181583404541015625. That is precise, not an approximation.

If you know of a program in any of these languages that will print this value for "0.1" using built-in functionality, please let me know because I would love to know about it.

Likewise the precise value of double(1e50) is 100000000000000007629769841091887003294964970946560. Anything else is an approximation of its true value.

In another message you said that what's really important is that the string representation uniquely identifies the precise value. While that will help you reconstruct the value later, it does not help you understand why 0.1 + 0.2 != 0.3.

Re:DEC64: Decimal Floating Point by masida on Sunday March 09, 2014 @09:22AM (#7368377)
Python does it:

  >>> from decimal import Decimal
  >>> Decimal(0.1)
  Decimal('0.1000000000000000055511151231257827021181583404541015625')
  >>> Decimal(1e50)
  Decimal('100000000000000007629769841091887003294964970946560')
Re:DEC64: Decimal Floating Point by haberman on Sunday March 09, 2014 @11:35AM (#7368677)
Great to know, thanks!
Re:DEC64: Decimal Floating Point by PaulAJ on Sunday March 09, 2014 @06:07AM (#7368043)
Haskell will tell you that

    toRational 0.1 = 3602879701896397 % 36028797018963968
    toRational 1e50 = 100000000000000007629769841091887003294964970946560 % 1
Both of those values are precise, although I admit the first isn't really useful for human beings.
Re:DEC64: Decimal Floating Point by StefanKarpinski on Sunday March 09, 2014 @08:49PM (#7370702)
The easiest way to see this exact value in Julia is to convert the Float64 value 0.1 to BigFloat and then print that:

    julia> big(0.1)
    1.000000000000000055511151231257827021181583404541015625e-01

    julia> big(1e50)
    1.0000000000000000762976984109188700329496497094656e+50
Note that this is exactly why you don't normally want to construct BigFloats this way. Instead you want to do this:

    julia> BigFloat("0.1")
    1.000000000000000000000000000000000000000000000000000000000000000000000000000002e-01

    julia> BigFloat("1e50")
    1e+50
Re:DEC64: Decimal Floating Point by StefanKarpinski on Sunday March 09, 2014 @11:31AM (#7368662)
It helps because 0.1 + 0.2 produces 0.30000000000000004 for 64-bit floats – so at least you can see that this value isn't the same as 0.3. In Ruby you just get two values that print the same yet aren't equal, which is way more confusing. I agree that printing the minimal number of digits required for reconstruction does not help with explaining why 0.1, 0.2 and 0.3 in 64-bit floats aren't the real values 1/10, 2/10 and 3/10.
Re:DEC64: Decimal Floating Point by giovannibajo1 on Saturday March 08, 2014 @10:47PM (#7367347)
Python doesn't:

    rasky at monocle in ~
    ↪ python
    Python 2.7.5 (default, Sep  2 2013, 05:24:04)
    [GCC 4.2.1 Compatible Apple LLVM 5.0 (clang-500.0.68)] on darwin
    Type "help", "copyright", "credits" or "license" for more information.
    >>> 0.1
    0.1
    >>> ^D
    rasky at monocle in ~
    ↪ python3
    Python 3.3.3 (default, Dec 24 2013, 13:54:32)
    [GCC 4.2.1 Compatible Apple LLVM 5.0 (clang-500.2.79)] on darwin
    Type "help", "copyright", "credits" or "license" for more information.
    >>> 0.1
    0.1

It used to, but it was changed to reduce users' confusion.
Re:DEC64: Decimal Floating Point by StefanKarpinski on Saturday March 08, 2014 @11:29PM (#7367430)
We may be speaking across each other here. Ruby is lying in the sense that there are multiple distinct float values that it will print as 0.3 – in particular, confusion ensues when two values look the same but are unequal. These other languages print each distinct float value differently, using just enough decimal digits to reconstruct the exact binary value. Ruby doesn't give you enough digits to reconstruct the value you have. Nobody actually prints the full correct value because it's fifty digits long and is completely redundant given that you know you're dealing with a 64-bit float.
Re:DEC64: Decimal Floating Point by kzrdude on Sunday March 09, 2014 @02:43PM (#7369401)
You're right.

    Python 3.3.5rc1 (default, Feb 23 2014, 17:44:29)  
    >>> 0.3 == 0.2 + 0.1
    False
    >>> 0.2 + 0.1
    0.30000000000000004
    >>> 0.3
    0.3