Spherical float to any precision in Go (Golang)

To spherical a floating-point quantity in Go, you should use the math.Spherical() operate from the built-in math bundle. Nonetheless, this operate rounds to the closest integer, so it can’t be used on to spherical a float to a selected precision. However you should use it to create your individual operate that rounds to any decimal locations. All that you must do is:

1. multiply the quantity to be rounded instances 10 to the facility of X, the place X is the precision you wish to obtain
2. spherical this raised quantity to the closest integer worth utilizing the math.Spherical() operate
3. divide the rounded quantity by 10 to the facility of X, the place X is the rounding decimal precision

On this approach, by rounding the raised quantity to the closest integer after which dividing, we get a quantity rounded to the desired decimal locations.

Examples

The roundFloat() is a floating-point rounding operate, working as described above. The way in which it really works is proven within the instance:

bundle important

import (
    "fmt"
    "math"
)

func roundFloat(val float64, precision uint) float64 {
    ratio := math.Pow(10, float64(precision))
    return math.Spherical(val*ratio) / ratio
}

func important() {
    quantity := 12.3456789

    fmt.Println(roundFloat(quantity, 2))
    fmt.Println(roundFloat(quantity, 3))
    fmt.Println(roundFloat(quantity, 4))
    fmt.Println(roundFloat(quantity, 5))

    quantity = -12.3456789
    fmt.Println(roundFloat(quantity, 0))
    fmt.Println(roundFloat(quantity, 1))
    fmt.Println(roundFloat(quantity, 10))
}

Output:

12.35
12.346
12.3457
12.34568
-12
-12.3
-12.3456789

Spherical float to 2 decimal locations

Full instance of rounding a float to 2 decimal locations:

bundle important

import (
	"fmt"
	"math"
)

func roundFloat(val float64, precision uint) float64 {
	ratio := math.Pow(10, float64(precision))
	return math.Spherical(val*ratio) / ratio
}

func important() {
	quantity := 12.3456789
	fmt.Println(roundFloat(quantity, 2))
}

Output:

Spherical float to three decimal locations

Full instance of rounding a float to three decimal locations:

bundle important

import (
	"fmt"
	"math"
)

func roundFloat(val float64, precision uint) float64 {
	ratio := math.Pow(10, float64(precision))
	return math.Spherical(val*ratio) / ratio
}

func important() {
	quantity := 12.3456789
	fmt.Println(roundFloat(quantity, 3))
}

Output: