The whole fact that you're truncating down to 0.8 can be put down to "just FP things" - you simply can't rely on exact values here (you're dividing by a number (0.1) with no exact representation in binary to decimal 0.1) , so truncating close to exact integers is always going to be troublesome. However it does seem odd that a // b and floor(a/b) are different, especially when the documentation says they should be equivalent. Looking at the source , it looks like the discrepancy is due to // using divmod, rather than the same function as the / operator and then flooring it, which performs a somewhat different operation, and gives a different result due to the split between quotient and remainder. Ie: while // just does the IEEE division, divmod does something equivalent to: >>> mod = math.fmod(0.9, 0.1) # Gets ~ 0.1 >>> quotient = (0.9 - mod) / 0.1 >>> # (plus a bunch of sign fixing up etc due to, not really relevant here) And then using the quotient as the floor. The difference means slightly different approximations get done in the FP - specifically, the mod is just below 0.1, rather than 0. It does seem like this could be considered at minimum a documentation bug, in that it says the two should be equivalent. It does seem like actually doing floor(float_div(a,b)) in floor_div would be sensible - fewer operations being done, meaning less scope for accuracy loss, and more needless work being done. I'm not sure why it's using divmod instead. More on reddit.com

it looks like computers are unable to accurately represent 1.6 exactly, like how we can't write 1/3 in a finite amount of digits https://www.binaryconvert.com/result_double.html?decimal=049046054 so it's actually doing 1000 / 1.60000000000000008881784197001E0, which is something like 624.9999999999999, which floors to 624 More on reddit.com

-2.4 rounding down is -3.0 as -3 < -2.4 I know, it still hurts my brain, too. More on reddit.com

Integer division is // >>> 84//2 42 More on reddit.com