How to print full precision of floating numbers

Question

I had written the following function in which values of x,y were passed:

def check(x, y):
    print(type(x))
    print(type(y))
    print(x)
    print(y)
    if x == y:
        print "Yes"

Now when I called check(1.00000000000000001, 1.0000000000000002) it was printing:

<type 'float'>
<type 'float'>
1.0
1.0

Now from the print statements of variables x & y, it was hard for me to debug why x != y (though both were printing same values). Though I resolved it by printing x - y which gave me the difference but is there any way to modify print statement so that to know why x!=y in this particular use case without using any external print libraries and subtraction solution.

Answer 1

To get full precision and correct formatting do

format(2**(1/2), '.60g') 
# -> '1.4142135623730951454746218587388284504413604736328125'

and check it with

import decimal
print(decimal.Decimal.from_float(2**(1/2))
# -> '1.4142135623730951454746218587388284504413604736328125'

The g format type switchs to exponential notation when needed.

Answer 2

UPDATE: In Python 3 str on a float is guaranteed to produce a string literal with full precision

This was not the case in Python 2. For instance str(1.0000000000000002) was '1.0' in Python 2, but in Python 3 it gives '1.0000000000000002' as expected.

This has often been a source of confusion because a simply print(x) may not have printed x with the full precision, making wrong conclusions -- like in the example of the question.

For the background of this change see here.

---

Python 2 solution

A simple solution to get a string representation of a float with full precision is to use either repr or json.dumps.

JSON serialization/deserialization has to make sure that roundtrips are loss-less, and thus, the implementation produces a string representation you are looking for:

def check(x, y):
    print(repr(x))
    print(repr(y))
    print("x == y is {}".format(x == y))

In [1]: check(1.00000000000000001, 1.0000000000000002)
1.0
1.0000000000000002
x == y is False

In [2]: check(1e-300, 2e-300)
1e-300
2e-300
x == y is False

In [3]: check(1e+300, 2e+300)
1e+300
2e+300
x == y is False

This also clarifies that 1.00000000000000001 actually is 1.0. This can also be checked by enumerating the numbers around 1.0 using np.nextafter, which produces the next larger/smaller representable floating point value:

    0.9999999999999994
    0.9999999999999996
    0.9999999999999997
    0.9999999999999998
    0.9999999999999999
[*] 1.0               
    1.0000000000000002
    1.0000000000000004
    1.0000000000000007
    1.0000000000000009
    1.000000000000001 

---

In reply to @Robert:

json.dumps also works in your case. The formatting with '.60g' simply produces a literal that has more unnecessary digits than a IEEE double precision number can hold. The precision of the other literal produced by json.dumps is sufficient to represent that particular floating point number, which you can check by:

The two IEEE literals closest to 1./math.sqrt(3.) are:

The first one the closest possible representation already, storing further digits of 1./math.sqrt(3.) will always give you back that same number.

json.dumps has loss-less round-trips for 64-bit IEEE floating point numbers, so it is guaranteed that the number of digits it produces is sufficient.

Answer 3

What you really need here is decimals. Python float won't allow you for such precision.

In [28]: d= Decimal('1.00000000000000001')

In [29]: print d
1.00000000000000001

Answer 4

a solution to a similar case was discussed here: print float to n decimal places including trailing 0's

I don't know though if there is a way of printing the full length of the float. But I guess if you use like 100 values after a floating point, it will solve must of your problems.