四舍五入在 Go 语言中为何如此困难?

// source: https://github.com/icza/gox/blob/master/mathx/mathx.go
package mathx

import "math"

// AbsInt returns the absolute value of i.
func AbsInt(i int) int {
 if i < 0 {
  return -i
 }
 return i
}

// Round returns x rounded to the given unit.
// Tip: x is "arbitrary", maybe greater than 1.
// For example:
//     Round(0.363636, 0.001) // 0.364
//     Round(0.363636, 0.01)  // 0.36
//     Round(0.363636, 0.1)   // 0.4
//     Round(0.363636, 0.05)  // 0.35
//     Round(3.2, 1)          // 3
//     Round(32, 5)           // 30
//     Round(33, 5)           // 35
//     Round(32, 10)          // 30
//
// For details, see https://stackoverflow.com/a/39544897/1705598
func Round(x, unit float64) float64 {
 return math.Round(x/unit) * unit
}

// Near reports if 2 float64 numbers are "near" to each other.
// The caller is responsible to provide a sensible epsilon.
//
// "near" is defined as the following:
//     near := math.Abs(a - b) < eps
//
// Corner cases:
//  1. if a==b, result is true (eps will not be checked, may be NaN)
//  2. Inf is near to Inf (even if eps=NaN; consequence of 1.)
//  3. -Inf is near to -Inf (even if eps=NaN; consequence of 1.)
//  4. NaN is not near to anything (not even to NaN)
//  5. eps=Inf results in true (unless any of a or b is NaN)
func Near(a, b, eps float64) bool {
 // Quick check, also handles infinities:
 if a == b {
  return true
 }

 return math.Abs(a-b) < eps
}

//source: https://play.golang.org/p/0uN1kEG30kI
package main

import (
 "fmt"
 "math"
)

func main() {
 f := 12.15807659924030304
 fmt.Println(Round(f, 0.0001)) // 12.158100000000001

 f = 0.15807659924030304
 fmt.Println(Round(f, 0.0001)) // 0.15810000000000002
}

func Round(x, unit float64) float64 {
 return math.Round(x/unit) * unit
}

source: https://play.golang.org/p/jxILFBYBEF
package main

import (
 "fmt"
 "strconv"
)

func main() {
 fmt.Println(Round(0.363636, 0.05)) // 0.35
 fmt.Println(Round(3.232, 0.05))    // 3.25
 fmt.Println(Round(0.4888, 0.05))   // 0.5
}

func Round(x, unit float64) float64 {
 var rounded float64
 if x > 0 {
  rounded = float64(int64(x/unit+0.5)) * unit
 } else {
  rounded = float64(int64(x/unit-0.5)) * unit
 }
 formatted, err := strconv.ParseFloat(fmt.Sprintf("%.2f", rounded), 64)
 if err != nil {
  return rounded
 }
 return formatted
}

package main

import (
 "fmt"
 "strconv"
)

func main() {
 f := 12.15807659924030304
 fmt.Println(Round(f, 0.0001)) // 12.1581

 f = 0.15807659924030304
 fmt.Println(Round(f, 0.0001)) // 0.1581

 fmt.Println(Round(0.363636, 0.0001)) // 0.3636
 fmt.Println(Round(3.232, 0.0001))    // 3.232
 fmt.Println(Round(0.4888, 0.0001))   // 0.4888
}

func Round(x, unit float64) float64 {
 var rounded float64
 if x > 0 {
  rounded = float64(int64(x/unit+0.5)) * unit
 } else {
  rounded = float64(int64(x/unit-0.5)) * unit
 }

 var precision int
 for unit < 1 {
  precision++
  unit *= 10
 }

 formatted, err := strconv.ParseFloat(fmt.Sprintf("%."+strconv.Itoa(precision)+"f", rounded), 64)
 if err != nil {
  return rounded
 }
 return formatted
}

package main

import (
 "fmt"
 "github.com/thinkeridea/go-extend/exmath"
)

func main() {
 f := 0.15807659924030304
 fmt.Println(float64(int64(f*10000+0.5)) / 10000) // 0.1581
}

func Round(x, unit float64) float64 {
 return float64(int64(x*unit+0.5)) / unit
}

//source: https://github.com/thinkeridea/go-extend/blob/main/exmath/round.go

// MIT License
// Copyright (c) 2020 Qi Yin <qiyin@thinkeridea.com>

package exmath

import (
 "math"
)

// Round 四舍五入，ROUND_HALF_UP 模式实现
// 返回将 val 根据指定精度 precision（十进制小数点后数字的数目）进行四舍五入的结果。precision 也可以是负数或零。
func Round(val float64, precision int) float64 {
 if precision == 0 {
  return math.Round(val)
 }

 p := math.Pow10(precision)
 if precision < 0 {
  return math.Floor(val*p+0.5) * math.Pow10(-precision)
 }

 return math.Floor(val*p+0.5) / p
}