Why Do Untyped and Typed Floating-Point Multiplications in Go Produce Different Results?

Why do These Two float64s Have Different Values?

Introduction

When working with floating-point numbers, it's essential to understand precision limitations. Consider the following Go code:

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

(Go Playground link)

The second line produces an expected result of "9.120000000000001" due to floating-point precision limitations.

Question

However, the first line prints "9.12" without any trailing precision. This raises the question: why doesn't Go perform floating-point multiplication for the two untyped constants and then convert them to a 9.12 literal?

Answer

According to the Go language specification, constant expressions are evaluated exactly. Therefore, "912 * 0.01" is evaluated precisely, which is the same as "9.12".

When you type cast the first operand to float64 (float64(912)), the other operand (0.01) is also implicitly type cast to float64. 0.01 cannot be represented exactly in a float64, so precision is lost in a different location than in the first example. This explains the different results observed when using fmt.Println() with different input expressions.

The above is the detailed content of Why Do Untyped and Typed Floating-Point Multiplications in Go Produce Different Results?. For more information, please follow other related articles on the PHP Chinese website!