golang在将float32转换为float64时失去精度？

Question

In Golang, it seems that when a float64 var first convert to float32 then convert float64, it's value will change.

a := -8888.95
fmt.Println(a)                    // -8888.95
fmt.Println(float32(a))           // -8888.95
fmt.Println(float64(float32(a)))  // -8888.9501953125

How can I make it unchanging

Answer 1

The way you have described the problem is perhaps misleading.

The precision is not lost "when converting float32 to float64"; rather, it is lost when converting from float64 to float32.

So how can you avoid losing precision when converting from float64 to float32? You can't. This task is impossible, and it's quite easy to see the reason why:

• float64 has twice as many bits as float32
• multiple different float64 values will map to the same float32 value due to the pigeonhole principle
• the conversion is therefore not reversible.

package main

import (
    "fmt"
)

func main() {
    a := -8888.95
    fmt.Printf("%.20f\n", a)
    fmt.Printf("%.20f\n", float32(a))
    fmt.Printf("%.20f\n", float64(float32(a)))
}

Adjusting your program to show a more precise output of each value, you'll see exactly where the precision is lost:

-8888.95000000000072759576
-8888.95019531250000000000
-8888.95019531250000000000

That is, after the float32 conversion (as is expected).

It's also worth noting that neither float64 nor float32 can represent your value -8888.95 exactly. If you convert this number to a fraction, you will get -177779/20 . Notice the denominator, 20. The prime factorization of 20 is 2 * 2 * 5.

If you apply this process to a number and the prime factorization of the denominator contains any factors which are NOT 2, then you can rest assured that this number is definitely not representable exactly in binary floating point form. You may discover that the probability of any number passing this test is quite low.