Strange Python 3 mod behavior for longs

Question

Consider this code snippet.

>>> n, m = 10011617, 100000000000006340
>>> s = lambda n: n * (n + 1) / 2
>>> s(n)
50116242483153.0
>>> s(n) == int(s(n))
True
>>> m % s(n)
18096246116101.0
>>> m % int(s(n))
18096246116105

As you can see, s(n) is an integer (mathematically), yet m % s(n) != m % int(s(n)).

Could this have to do with s(n) or m being a long under the hood? Even if that's the case, why does s(n) == int(s(n)) yet when I take the modulus the results are not equal?

P.S. I ran this in repl.it

Use integer division `n * (n + 1) / /2` rather than `n * (n + 1) / 2`. Floats have limited precision. — John Coleman, Jan 25 '21 at 23:20
Actually -- it isn't the same. For larger `n`, `(n+1)//2` might differ from `int((n+1)/2)`. — John Coleman, Jan 25 '21 at 23:24
@JohnColeman I see. Why then does python return True for `s(n) == int(s(n))` but returns different results when I take the modulus? — Daniel, Jan 25 '21 at 23:25
Because of how `==` is implemented when applied between a float and an int. — John Coleman, Jan 25 '21 at 23:26
Not quite a duplicate, but see: [Python modulo on floats](https://stackoverflow.com/q/14763722/4996248) since this is the operator that you are using in `%s(n)` — John Coleman, Jan 25 '21 at 23:28

score 2 · Accepted Answer · answered Jan 25 '21 at 23:36

In this particular case the problem is due more to m than s(n). When computing m % s(n), since s(n) is a float, m is coerced to a float. But -- float(m) loses precision. The clearest way to see this is that

m == 100000000000006340

but

int(float(m)) == 100000000000006336

Note that 100000000000006336 % 50116242483153 == 18096246116101, which shows where the mystery value comes from.

Strange Python 3 mod behavior for longs

1 Answers1