To round a floating-point number in Go, you can use the math.Round() function from the built-in math package. However, this function rounds to the nearest integer, so it cannot be used directly to round a float to a particular precision. But you can use it to create your own function that rounds to any decimal places. All you need to do is:
- multiply the number to be rounded times 10 to the power of
X, whereXis the precision you want to achieve - round this raised number to the nearest integer value using the
math.Round()function - divide the rounded number by 10 to the power of
X, whereXis the rounding decimal precision
In this way, by rounding the raised number to the nearest integer and then dividing, we get a number rounded to the specified decimal places.
Examples
The roundFloat() is a floating-point rounding function, working as described above. The way it works is shown in the example:
package main
import (
"fmt"
"math"
)
func roundFloat(val float64, precision uint) float64 {
ratio := math.Pow(10, float64(precision))
return math.Round(val*ratio) / ratio
}
func main() {
number := 12.3456789
fmt.Println(roundFloat(number, 2))
fmt.Println(roundFloat(number, 3))
fmt.Println(roundFloat(number, 4))
fmt.Println(roundFloat(number, 5))
number = -12.3456789
fmt.Println(roundFloat(number, 0))
fmt.Println(roundFloat(number, 1))
fmt.Println(roundFloat(number, 10))
}
Output:
12.35
12.346
12.3457
12.34568
-12
-12.3
-12.3456789
Round float to 2 decimal places
Full example of rounding a float to 2 decimal places:
package main
import (
"fmt"
"math"
)
func roundFloat(val float64, precision uint) float64 {
ratio := math.Pow(10, float64(precision))
return math.Round(val*ratio) / ratio
}
func main() {
number := 12.3456789
fmt.Println(roundFloat(number, 2))
}
Output:
12.35
Round float to 3 decimal places
Full example of rounding a float to 3 decimal places:
package main
import (
"fmt"
"math"
)
func roundFloat(val float64, precision uint) float64 {
ratio := math.Pow(10, float64(precision))
return math.Round(val*ratio) / ratio
}
func main() {
number := 12.3456789
fmt.Println(roundFloat(number, 3))
}
Output:
12.346
Round the float to a string
In Go, there is another way of rounding numbers often called float truncation. The difference from classical rounding is that you get the result in the form of a string, as truncating is carried out by the formatting function fmt.Sprintf() or fmt.Printf(). To round a float in this way, you must set the formatting verb %f as an argument to these functions with a precision value of %.nf where n specifies the precision, that is, the number of decimal places.
The example below is equivalent to the first example on rounding, except it uses the fmt.Printf() function.
package main
import (
"fmt"
)
func main() {
number := 12.3456789
fmt.Printf("%.2f\n", number)
fmt.Printf("%.3f\n", number)
fmt.Printf("%.4f\n", number)
fmt.Printf("%.5f\n", number)
number = -12.3456789
fmt.Printf("%.0f\n", number)
fmt.Printf("%.1f\n", number)
fmt.Printf("%.10f\n", number)
}
Output:
12.35
12.346
12.3457
12.34568
-12
-12.3
-12.3456789000
As you can see, the results are similar to using our roundFloat() function. The difference is when we set a higher precision in the fmt.Printf() than the number itself has - then the trailing zeros are displayed in the resulting string:
For:
fmt.Printf("%.10f\n", number)
you get:
-12.3456789000
Below is the same example, but it formats the results into a string type variable:
package main
import (
"fmt"
)
func main() {
number := 12.3456789
numberString := fmt.Sprintf("%.2f", number)
fmt.Println(numberString)
numberString = fmt.Sprintf("%.3f", number)
fmt.Println(numberString)
numberString = fmt.Sprintf("%.4f", number)
fmt.Println(numberString)
numberString = fmt.Sprintf("%.5f", number)
fmt.Println(numberString)
number = -12.3456789
numberString = fmt.Sprintf("%.0f", number)
fmt.Println(numberString)
numberString = fmt.Sprintf("%.1f", number)
fmt.Println(numberString)
numberString = fmt.Sprintf("%.10f", number)
fmt.Println(numberString)
}
