Go: How to check precision loss when converting float64 to float32

php editor Baicao today introduces to you a solution to a common problem: how to check the precision loss that may occur when converting float64 to float32. When converting floating point numbers, precision loss may occur due to the difference in the number of bits between the two data types. This article will detail how to determine whether there is a loss by comparing the values ​​before and after conversion, and provide a feasible solution to help developers better deal with this problem.

Question content

I have a scenario where I receive a float64 value but have to send it over the wire to another service as a float32 value. We know that the received value should always fit into a float32. However, just to be on the safe side I'd like to log that we lose data by converting to float32.

This code block will not compile because you cannot compare float32 to float64 directly.

func convert(input float64) (output float32, err error) {
    const tolerance = 0.001
    output = float32(input)
    if output > input+tolerance || output < input-tolerance {
        return 0, errors.New("lost too much precision")
    }
    return output, nil
}

Is there an easy way to check if I'm encountering this? This check happens frequently, so I want to avoid string conversion.

Workaround

You can convert the float32 value back to float64, for validation only.

To check if the converted value represents the same value, just compare it with the original value (input). It is also sufficient/idiomatic to just return the ok bool message (instead of error):

func convert(input float64) (output float32, ok bool) {
    output = float32(input)
    ok = float64(output) == input
    return
}

(Note: Edge cases like nan will not be checked.)

Test it:

fmt.println(convert(1))
fmt.println(convert(1.5))
fmt.println(convert(0.123456789))
fmt.println(convert(math.maxfloat32))

Output (try it on go playground):

1 true
1.5 true
0.12345679 false
3.4028235e+38 true

Note that this will usually give ok = false results, since float32 has less precision than float64, even though the converted value may be very close to the input .

So it would be more useful in practice to check the difference in converted values. Your proposed solution checks for absolute differences, which is not very useful: e.g. 1000000.1 and 1000000 are very close numbers, even if the difference is 0.1. The difference between 0.0001 and 0.00011 is much smaller: 0.00001, but the difference is much larger compared to the numbers.

So you should check the relative difference, for example:

func convert(input float64) (output float32, ok bool) {
    const maxreldiff = 1e-8

    output = float32(input)
    diff := math.abs(float64(output) - input)
    ok = diff <= math.abs(input)*maxreldiff

    return
}

Test it:

fmt.println(convert(1))
fmt.println(convert(1.5))
fmt.println(convert(1e20))
fmt.println(convert(math.pi))
fmt.println(convert(0.123456789))
fmt.println(convert(math.maxfloat32))

Output (try it on go playground):

1 true
1.5 true
1e+20 false
3.1415927 false
0.12345679 false
3.4028235e+38 true

The above is the detailed content of Go: How to check precision loss when converting float64 to float32. For more information, please follow other related articles on the PHP Chinese website!