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

I have a scenario where I receive a float64 value, but must send it down the wire to another service as a float32 value. We know the received value should always fit into a float32. However, to be safe I want to log the case where we are losing data by converting to float32.

This code block does not compile, since you can't 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 that I am hitting this condition? This check will happen at high frequency, so I want to avoid doing string conversions.

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

To check if the converted value represents the same value, simply compare it to the original value (the input). It's also enough / idiomatic to just return an ok bool info (instead of an error):

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

(Note: edge cases like NaN are not checked.)

Testing it:

fmt.Println(convert(1))
fmt.Println(convert(1.5))
fmt.Println(convert(0.123456789))
fmt.Println(convert(math.MaxFloat32))

Output (try it on the Go Playground):

1 true
1.5 true
0.12345679 false
3.4028235e+38 true

Note that this will often give ok = false result because the precision of float32 is less than that of float64, even though the converted value may be very close to the input.

So in practice it would be more useful to check the difference of the converted value. Your proposed solution checks for the absolute difference value which is not so useful: for example 1000000.1 and 1000000 are very close numbers, even though the difference is 0.1. 0.0001 and 0.00011 have much less difference: 0.00001, yet the difference compared to the numbers is much bigger.

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
}

Testing 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 the Go Playground):

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

Yes. Check that the value does not exceed the upper or lower value limit. Then ensure the 52 - 23 least significant bits are 0. (in a nutshell)