1.000000000000001 ** float('inf') == float('inf')
while
1.0000000000000001 ** float('inf') == 1.0
What determines the exact threshold here? It seems to be an issue of float precision, where numbers below a certain threshold are considered the same as 1.0. Is there a way to get better precision in Python?
As others have said, this is due to IEEE754 floats not being able to represent your constants with the precision you're expecting.
Python provides some useful tools that lets you see what's going on, specifically the math.nextafter method and and decimal module.
The decimal module is useful to see the decimal expansion of a float (i.e. how us humans read/write numbers), e.g.:
from decimal import Decimal as D
a = 1.000000000000001
b = 1.0000000000000001
print(D(a), D(b))
which outputs:
1.0000000000000011102230246251565404236316680908203125 1
these are the actual values seen by your computer when you use those constants. As others have said, you can see that b is actually just 1 so it's "lost" the tailing digit you entered. You just have to know that it's going to do that as a programmer.
To see nearby values the nextafter method is very useful, e.g.:
import math
c = math.nextafter(1.0, math.inf)
print(c, D(c))
which outputs:
1.0000000000000002 1.0000000000000002220446049250313080847263336181640625
the first number is what Python prints by default and only includes enough precision to be able to unambiguously distinguish the value, the second uses the decimal module and is exact.
Having a play with these is a great way to further understand what you're actually telling your computer to do. Chux also talked about hex representations of floats, in my experience these take a bit longer for people to understand but are another tool to know about when your code seems to be misbehaving. In Python you use
float.hex()
to see the actual bits that make up a float, using the format defined by C99, e.g.:
one = 1.0
print(one.hex(), c.hex(), math.nextafter(c, math.inf).hex())
which will output:
0x1.0000000000000p+0 0x1.0000000000001p+0 0x1.0000000000002p+0
This output is closer to how your computer represents floats. The hexadecimal fractional digits can make these values somewhat awkward to interpret, but you can get there with some more magic numbers (i.e. these come from the spec). The second is saying something like 0x10000000000001 * 2**(0-52), the -52 is needed to "shift" the all but the first digit right into the fraction.