Floor function returning unexpected value [duplicate]

Question

Something very strange is happening as I evaluate the Floor function:

(9.2 - 8)/1.2
Floor[(9.2 - 8)/1.2]

returns:

1.

0

so I did the following:

Floor[1]
Floor[1.0]
Floor[1.2/1.2]

returning

1

1

1

Does anybody know what is happening? Am I doing something wrong here? I also tried the following and got the same confusing result:

x = (9.2 - 8)/1.2
Floor[x]

1.

0

and

In[57]:= Floor[(10.2 - 9.0)/1.2]

Out[57]= 0

but

In[59]:= Floor[(10.4 - 9.0)/1.4]

Out[59]= 1

I'm getting so confused that sometimes I doubt myself when doing this simple operations in my head... Any information about this will be highly appreciated.

Answer 1

As it was suggested by @CarlWoll and @thorimur in the comments, I evaluated:

(9.2 - 8)/1.2 // FullForm

which returns:

0.9999999999999994`

I'm not really sure why, but I suspect that this is related to the order in which Mathematica evaluates each operation. Since 9.2/1.2 and 8/1.2 have no finite decimal expansion, apparently Mathematica truncates this expressions and rounds them when showing the final answer. So I decided to round them myself before plugging them in the Floor function as follows:

Floor[Round[(9.2 - 8)/1.2, 0.1]]

resulting in:

1

I still have no clue why Mathematica would distribute the 1/1.2 into the subtraction apparently ignoring the parenthesis, but I suppose it's usually better when working with large numbers...

Answer 2

Machine-precision numbers are stored internally by a 64-bit pattern encoding the IEEE 754 format. Each bit pattern describes a rational number of the form $\pm m\times 2^{e}$ where $m$ is the mantissa or significand and $e$ is the binary exponent. To see which rational number is encoded in a given machine-precision number, we can set the precision to infinity:

SetPrecision[9.2 - 8, Infinity]
(*    337769972052787/281474976710656    *)

SetPrecision[(9.2 - 8)/1.2, Infinity]
(*    9007199254740987/9007199254740992    *)

The latter number is clearly less than 1.

Digging a bit deeper, things clarify when we look at the involved numbers in their hexadecimal representations:

SetPrecision[9.2, Infinity] ==
  2^-48*FromDigits["9333333333333", 16]
(*    True    *)

SetPrecision[9.2 - 8, Infinity] ==
  2^-48*FromDigits["1333333333333", 16]
(*    True    *)

SetPrecision[1.2, Infinity] ==
  2^-52*FromDigits["13333333333333", 16]
(*    True    *)

Note that the representation of 9.2 - 8 has one fewer digits in the periodic expansion than the representation of 1.2. This comes from the cancellation and error amplification when subtracting two large numbers (here, 9.2 and 8) to form a smaller number (here, 1.2).

Another way of seeing IEEE 754 floating-point numbers is as intervals: for example, the machine-precision number 9.2 is actually the interval of size $2^{-48}$ centered at $2589569785738035\times2^{-48}$: it is $9.2=(2589569785738035\times2^{-48})\pm2^{-49}$. The interval's size is given by the number of binary digits that we can store in the mantissa. Subtracting 8 (an exact number) from this number gives $9.2-8=(337769972052787\times2^{-48})\pm2^{-49}$; notice that the interval's size has not changed. This contrasts with the number $1.2$, which can be expressed as the interval $1.2=(5404319552844595\times2^{-52})\pm2^{-53}$ and has a 16-fold smaller interval size.

Answer 3

One can finesse this for machine numbers by allowing some relative error to handle the fact that (i) decimals do not always have exact finite binary expansions and (ii) finite precision arithmetic can have roundoff and/or cancellation error. I use an order of magnitude above machine precision in the code below, but easy to reconfigure e.g. as a Tolerance option.

floorWithFuzz[n_] := Floor[n*(1 + 10*10^(-MachinePrecision))]

Here are two examples that have appeared in this thread and comments.

floorWithFuzz[(9.2 - 8)/1.2]

(* Out[15]= 1 *)

floorWithFuzz[N[ArcSinh[Sqrt[5] 3/2]/Log[GoldenRatio]]]

(* Out[16]= 4 *)