How Can I Safely Convert float64 to uint64 in Go and Preserve Precision?

Float64 to Uint64 Conversion: Ensuring Precision

Floating-point numbers, represented by float64 in Go, store values with variable precision. When converting a float64 to an integer type like uint64, it's important to understand the potential loss of precision.

The IEEE 754 standard defines the precision of float64 as 53 bits, which limits the number of digits that can be represented precisely. Constants, however, can be represented with arbitrary precision.

Consider the following example:

package main

import "fmt"

func main() {
    var n float64 = 6161047830682206209
    fmt.Printf("%f\n", n)
    fmt.Printf("%d\n", uint64(n))
}

The output will be:

6161047830682206208.000000
6161047830682206208

As we can see, the number stored in n is not exactly equal to the constant 6161047830682206209, due to the limited precision of float64. When converting this value to uint64, the fractional part is discarded, resulting in a loss of precision.

To ensure precision in the conversion, we can use a safer method:

func main() {
    const n = 6161047830682206209
    var u uint64 = uint64(n)
    fmt.Printf("%f\n", float64(u))
    fmt.Printf("%d\n", u)
}

In this example, we directly assign the constant to a uint64 variable, ensuring that the exact value is preserved. The subsequent conversion to float64 is precise and will produce the original value.

Understanding the limitations of floating-point precision is crucial when converting between different data types. By carefully considering the precision requirements, we can ensure that the conversion process does not introduce any unintended data loss.

The above is the detailed content of How Can I Safely Convert float64 to uint64 in Go and Preserve Precision?. For more information, please follow other related articles on the PHP Chinese website!