IEEE 754 二进制浮点数不精确

Question

当我将math.Floor 与浮点变量一起使用时遇到问题（向下舍入/截断精度部分）。我怎样才能正确地做到这一点？

package main

import (
    "fmt"
    "math"
)

func main() {
    var st float64 = 1980
    var salePrice1 = st * 0.1 / 1.1
    fmt.Printf("%T:%v\n", salePrice1, salePrice1) // 179.9999
    var salePrice2 = math.Floor(st * 0.1 / 1.1)
    fmt.Printf("%T:%v\n", salePrice2, salePrice2) // 179
}

游乐场：https://play.golang.org/p/49TjJwwEdEJ

输出：

float64:179.99999999999997
float64:179

我希望1980 * 0.1 / 1.1 的输出为180，但实际输出为179。

Answer 1

原问题：

---

golang 中的楼层号不正确

使用带有浮点变量的 Math.Floor 时出现问题（圆形 向下/截断精度部分）。我怎样才能正确地做到这一点？

package main

import (
    "fmt"
    "math"
)

func main() {
    var st float64 = 1980
    var salePrice1 = st * 0.1 / 1.1
    fmt.Printf("%T:%v\n", salePrice1, salePrice1)
    var salePrice2 = math.Floor(st * 0.1 / 1.1)
    fmt.Printf("%T:%v\n", salePrice2, salePrice2)
}

我预计 1980 * 0.1 / 1.1 的输出为 180，但实际 输出为 179。”

游乐场：

输出：

float64:179.99999999999997
float64:179

---

XY 问题是询问您尝试的解决方案，而不是您的实际问题：The XY Problem。

---

显然，这是salePrice1 的金钱计算。货币计算使用精确的十进制计算，而不是不精确的二进制浮点计算。

货币计算使用整数。例如，

package main

import "fmt"

func main() {
    var st int64 = 198000 // $1980.00 as cents

    fmt.Printf("%[1]T:%[1]v\n", st)
    fmt.Printf("$%d.%02d\n", st/100, st%100)

    var n, d int64 = 1, 11
    fmt.Printf("%d, %d\n", n, d)

    var salePrice1 int64 = (st * n) / d // round down

    fmt.Printf("%[1]T:%[1]v\n", salePrice1)
    fmt.Printf("$%d.%02d\n", salePrice1/100, salePrice1%100)

    var salePrice2 int64 = ((st*n)*10/d + 5) / 10 // round half up

    fmt.Printf("%[1]T:%[1]v\n", salePrice2)
    fmt.Printf("$%d.%02d\n", salePrice2/100, salePrice2%100)

    var salePrice3 int64 = (st*n + (d - 1)) / d // round up

    fmt.Printf("%[1]T:%[1]v\n", salePrice1)
    fmt.Printf("$%d.%02d\n", salePrice3/100, salePrice3%100)
}

游乐场：https://play.golang.org/p/HbqVJUXXR-N

输出：

int64:198000
$1980.00
1, 11
int64:18000
$180.00
int64:18000
$180.00
int64:18000
$180.00

---

参考资料：

What Every Computer Scientist Should Know About Floating-Point Arithmetic

How should we calc money (decimal, big.Float)

General Decimal Arithmetic

Answer 2

试试this:

    st := 1980.0
    f := 0.1 / 1.1
    salePrice1 := st * f
    salePrice2 := math.Floor(salePrice1)
    fmt.Println(salePrice2) // 180

---

这是一个很大的话题：
对于会计系统：答案是Floating point error mitigation。

（注意：一种缓解技术是使用int64、uint64 或big.Int）

请看：
What Every Computer Scientist Should Know About Floating-Point Arithmetic https://en.wikipedia.org/wiki/Double-precision_floating-point_format https://en.wikipedia.org/wiki/IEEE_floating_point

---

让我们开始吧：

fmt.Println(1.0 / 3.0) // 0.3333333333333333

IEEE 754 二进制表示：

fmt.Printf("%#X\n", math.Float64bits(1.0/3.0)) // 0X3FD5555555555555

IEEE 754 1.1 的二进制表示：

fmt.Printf("%#X\n", math.Float64bits(1.1))        // 0X3FF199999999999A
fmt.Printf("%#X\n", math.Float64bits(st*0.1/1.1)) // 0X40667FFFFFFFFFFF

现在，让：

st := 1980.0
f := 0.1 / 1.1

f 的 IEEE 754 二进制表示是：

fmt.Printf("%#X\n", math.Float64bits(f)) // 0X3FB745D1745D1746

还有：

salePrice1 := st * f
fmt.Println(salePrice1) // 180
fmt.Printf("%#X\n", math.Float64bits(salePrice1)) // 0X4066800000000000
salePrice2 := math.Floor(salePrice1)
fmt.Printf("%#X\n", math.Float64bits(salePrice2)) // 0X4066800000000000

---

在计算机上处​​理浮点数与使用笔和纸不同（浮点计算错误）：

    var st float64 = 1980
    var salePrice1 = st * 0.1 / 1.1
    fmt.Println(salePrice1) // 179.99999999999997

salePrice1 是 179.99999999999997 而不是 180.0 所以小于或等于 179.99999999999997 的整数值是 179：

查看func Floor(x float64) float64的文档：

Floor 返回小于或等于 x 的最大 整数 值。

见：

    fmt.Println(math.Floor(179.999))       // 179
    fmt.Println(math.Floor(179.5 + 0.5))   // 180
    fmt.Println(math.Floor(179.999 + 0.5)) // 180
    fmt.Println(math.Floor(180.0))         // 180

---

一些相关的质量保证：

Golang floating point precision float32 vs float64

How to change a float64 number to uint64 in a right way?

Golang converting float64 to int error

Is floating point math broken?

Go float comparison

What does "%b" do in fmt.Printf for float64 and what is Min subnormal positive double in float64 in binary format?

Is there any standard library to convert float64 to string with fix width with maximum number of significant digits?

fmt.Printf with width and precision fields in %g behaves unexpectedly

Why is there a difference between floating-point multiplication with literals vs. variables in Go?

Golang Round to Nearest 0.05