Why Does Go Print 9.12 for `912 * 0.01` but 9.120000000000001 for `float64(912) * 0.01`?

Why the Discrepancy Between Two float64s?

Consider the following Go snippets:

fmt.Println(912 * 0.01)
fmt.Println(float64(912) * 0.01)

While you correctly understand that the second line prints 9.120000000000001, you may wonder why the first line prints 9.12 without the trailing ...01.

The answer lies in Go's handling of constant expressions, as defined in the specification:

Constant expressions are always evaluated exactly; intermediate values and the constants themselves may require precision significantly larger than supported by any predeclared type in the language.

Because 912 * 0.01 is a constant expression, it's evaluated with extreme precision. This same precision is maintained when passing the result of this expression as an argument to fmt.Println(). In essence, fmt.Println(912 * 0.01) behaves as if it were fmt.Println(9.12), where 9.12 is an exact representation of the evaluated expression.

In contrast, when you explicitly cast 912 to float64 in the second line, both operands of the floating-point multiplication are implicitly cast to float64. Since 0.01 cannot be precisely represented in float64, precision loss occurs, leading to the presence of ...01 in the output.

Thus, the difference in outcomes stems from the precision retained during constant expression evaluation and the implicit casting involved in float64(912) * 0.01.

The above is the detailed content of Why Does Go Print 9.12 for `912 * 0.01` but 9.120000000000001 for `float64(912) * 0.01`?. For more information, please follow other related articles on the PHP Chinese website!