Go如何精确计算小数-Decimal研究

// case1: 135.90*100 ====
// float32
var f1 float32 = 135.90
fmt.Println(f1 * 100) // output:13589.999
// float64
var f2 float64 = 135.90
fmt.Println(f2 * 100) // output:13590

// case2: 0.1 add 10 times ===
// float32
var f3 float32 = 0
for i := 0; i < 10; i++ {
	f3 += 0.1
}
fmt.Println(f3) //output:1.0000001
// float64
var f4 float64 = 0
for i := 0; i < 10; i++ {
	f4 += 0.1
}
fmt.Println(f4) //output:0.9999999999999999

package main
import (
	"fmt"
)
func main() {
	// case: float32==>float64
	// 从数据库中取出80.45, 历史代码用float32接收
	var a float32 = 80.45
	var b float64
	// 有些函数只能接收float64, 只能强转
	b = float64(a)
	// 打印出值, 强转后出现偏差
	fmt.Println(a) //output:80.45
	fmt.Println(b) //output:80.44999694824219
	// ... 四舍五入保留小数点后1位, 期望80.5, 结果是80.4
	// case: int64==>float64
	var c int64 = 987654321098765432
	fmt.Printf("%.f\n", float64(c)) //output:987654321098765440
	// case: int(float64(xx.xx*100))
	var d float64 = 1129.6
	var e int64 = int64(d * 100)
	fmt.Println(e) //output:112959
}

package main
import (
	"testing"
	"github.com/shopspring/decimal"
	"github.com/pingcap/tidb/util/types"
	"log"
)
var case1String = "135.90"
var case1Bytes = []byte(case1String)
var case2String = "0"
var case2Bytes = []byte("0")
func ShopspringDecimalCase1() decimal.Decimal {
	dec1, err := decimal.NewFromString(case1String)
	if err != nil {
		log.Fatal(err)
	}
	dec2 := decimal.NewFromFloat(100)
	dec3 := dec1.Mul(dec2)
	return dec3
}
func TidbDecimalCase1() *types.MyDecimal {
	dec1 := new(types.MyDecimal)
	err := dec1.FromString(case1Bytes)
	if err != nil {
		log.Fatal(err)
	}
	dec2 := new(types.MyDecimal).FromInt(100)
	dec3 := new(types.MyDecimal)
	err = types.DecimalMul(dec1, dec2, dec3)
	if err != nil {
		log.Fatal(err)
	}
	return dec3
}
func ShopspringDecimalCase2() decimal.Decimal {
	dec1, err := decimal.NewFromString(case2String)
	if err != nil {
		log.Fatal(err)
	}
	dec2 := decimal.NewFromFloat(0.1)
	for i := 0; i < 10; i++ {
		dec1 = dec1.Add(dec2)
	}
	return dec1
}
func TidbDecimalCase2() *types.MyDecimal {
	dec1 := new(types.MyDecimal)
	dec1.FromString(case2Bytes)
	dec2 := new(types.MyDecimal)
	dec2.FromFloat64(0.1)
	for i := 0; i < 10; i++ {
		types.DecimalAdd(dec1, dec2, dec1)
	}
	return dec1
}
// case1: 135.90*100 ====
func BenchmarkShopspringDecimalCase1(b *testing.B) {
	for i := 0; i < b.N; i++ {
		ShopspringDecimalCase1()
	}
	b.Log(ShopspringDecimalCase1()) // output: 13590
}
func BenchmarkTidbDecimalCase1(b *testing.B) {
	for i := 0; i < b.N; i++ {
		TidbDecimalCase1()
	}
	b.Log(TidbDecimalCase1()) //  output: 13590.00
}
// case2: 0.1 add 10 times ===
func BenchmarkShopspringDecimalCase2(b *testing.B) {
	for i := 0; i < b.N; i++ {
		ShopspringDecimalCase2()
	}
	b.Log(ShopspringDecimalCase2()) //  output: 1
}
func BenchmarkTidbDecimalCase2(b *testing.B) {
	for i := 0; i < b.N; i++ {
		TidbDecimalCase2()
	}
	b.Log(TidbDecimalCase2()) //  output: 1.0
}

BenchmarkShopspringDecimalCase1-8        2000000               664 ns/op             340 B/op         10 allocs/op
BenchmarkTidbDecimalCase1-8             20000000                99.2 ns/op            48 B/op          1 allocs/op
BenchmarkShopspringDecimalCase2-8         300000              5210 ns/op            4294 B/op        111 allocs/op
BenchmarkTidbDecimalCase2-8              3000000               517 ns/op              83 B/op          3 allocs/op