优化 Go 中高精度计算的性能

为在 Go 中优化高精度计算，可以使用 int64 和字符串操作来代替 math/big。int64 方法比 float64 方法快约 25%，同时代码也更易于阅读。int64 版本还提供了比带浮点数的版本快 40% 的速度提升。

注意！ 最初的问题是因为我对 32 位系统上的 64 位类型感到困惑。结果我原来的代码失败了，因为我使用了 float32 作为一个应该是 float64 的值。该错误让我认为我无法在32位系统上使用float64。评论中很快就纠正了这一点。感谢@burakserdar 和@adrian。 为了不使评论无效，我将原来的问题留在了下面。

我已经重构了我的代码，并且有两个可行的替代方案。一种是基于@pakuula 发布的答案，使用 int64 和字符串操作。另一种是使用 float64。 float64 解决方案的执行时间提高了约 25%，但代码似乎更易于阅读。

在 raspberry pi3 上运行基准测试得出两种方法的结果如下：

benchmarkall/int64method-4            286648          3977 ns/op          32 b/op          3 allocs/op
benchmarkall/float64method-4          242878          5000 ns/op          24 b/op          2 allocs/op

float64方法

func float64method(msg []byte) string {
    payload := msg[6:]

    latfloat := float64(int32(binary.littleendian.uint32(payload[8:12])))
    precfloat := float64(int8(payload[24])) / 100

    latsum := (latfloat + precfloat) / 1e7
    return fmt.sprintf("%2.9f", latsum)
}

int64方法

func int64method(msg []byte) string {
    payload := msg[6:]

    rawlatuint32 := binary.littleendian.uint32(payload[8:12])
    rawlatint32 := int32(rawlatuint32)
    rawlatint64 := int64(rawlatint32)
    fixlat8 := int8(payload[24])
    
    highpreclat := rawlatint64*100 + int64(fixlat8)
    negative := (highpreclat < 0)
    sign := ""
    if negative {
        sign = "-"
        highpreclat = -highpreclat
    }

    latint := highpreclat / precision
    latfrac := highpreclat % precision
    return fmt.sprintf("%s%d.%09d", sign, latint, latfrac)
}

go 演示的工作示例：https://go.dev/play/p/cqo67gmdwgs

我正在寻找一种将 4 字节小端值直接转换为 int32 的方法。它似乎不存在于内置包中。

原帖 我正在使用 raspberry pi3（32 位）和 ublox m8 gps 接收器创建地形测量系统。 代码将用 go 编写。 （转到1.19.2）

ublox 接收器在字节消息中生成高精度 gps 位置。纬度和经度值均由 4 字节有符号整数 (i4) 和 1 字节有符号整数 (i1) 组成。字节值是 littleendian。

高精度坐标通过将 i4 和 i1 添加在一起，如下所示： 度 * 1e-7 = i4 + (i1 * 1e-2)

纬度/经度位置将显示为保留 9 位小数的度数，例如：纬度：48.944665243°，经度：-13.117730989°

这就是我因 go（和数学）知识有限而遇到问题的地方。 没有任何内置数据类型可以对这种大小的数字进行算术运算（我的系统是 32 位），因此我使用 math/big 来获得正确的结果。然而，数学/大似乎需要大量的处理能力。我让代码在 64 位系统上运行，我可以使用内置类型和字符串格式来获得正确的结果。使用 math/big 导致处理时间增加四倍。

我正在寻找有关如何改进这段代码的建议。我不知道是否有更好的方法可以在不使用数学/大的情况下做到这一点。另外我真的不知道我对 math/big 的使用是否正确。

latFloat := big.NewFloat(float64(int32(binary.LittleEndian.Uint32(payload[12:16]))))
    precFloat := big.NewFloat(float64(int8(payload[25])) / 100)
    latSum := big.NewFloat(0.0)
    latSum.Add(latSum, latFloat)
    latSum.Add(latSum, precFloat)
    multip := big.NewFloat(0.0000001)
    latSum.Mul(latSum, multip)
    h.Lat = fmt.Sprint(latSum.Text('f', 9))

go 演示中有一个可用的示例：https://go.dev/play/p/ean4ymqeuwo

此外，我想知道关于binary.littleendian解码的问题。有没有办法在不使用binary.littleendian 的uint32 方法的情况下执行此操作。似乎没有必要通过 uint32 到 int32 来获取正确的值。

正确答案

为什么不使用int64？ go 运行时在 32 位平台上非常有效地支持它。

重新设计

这里是一个例子：https://go.dev/play/p/XRVKaGvNMrw

const precisionfactor = 1_000_000_000
// convert fixed-precision int to a string
func intstringwithprecision(val int64) string {
    negative := (val < 0)
    sign := ""
    if negative {
        sign = "-"
        val = -val
    }
    deg := val / precisionfactor
    frac := val % precisionfactor
    return fmt.sprintf("%s%d.%09d", sign, deg, frac)
}
// convert a float to a string with 9 digits after dot
func floatstringwithprecision(val float64) string {
    return fmt.sprintf("%0.9f", val)
}

// parse payload as a fixed-precision int
func getlatasint(payload []byte) int64 {
    rawlatuint32 := binary.littleendian.uint32(payload[12:16])
    rawlatint32 := int32(rawlatuint32)
    rawlatint64 := int64(rawlatint32)

    fixlat8 := int8(payload[25])

    return rawlatint64*100 + int64(fixlat8)
}

// parse payload as a float
func getlatasfloat(payload []byte) float64 {
    latfloat := float64(int32(binary.littleendian.uint32(payload[12:16])))
    precfloat := float64(int8(payload[25])) / 100

    return (latfloat + precfloat) / 1e7
}

诀窍是我们将 9 位精度保留在整数内，并通过 1e9 的整数等效项将 divmod 拆分为整数和小数部分。

输出是：

test(305419896, -112)
using integer: 30.541989488
using float:   30.541989488
test(100, -56)
using integer: 0.000009944
using float:   0.000009944
test(1, 2)
using integer: 0.000000102
using float:   0.000000102
test(-1, 2)
using integer: -0.000000098
using float:   -0.000000098
test(-10, 20)
using integer: -0.000000980
using float:   -0.000000980
test(-305419896, 9)
using integer: -30.541989591
using float:   -30.541989591

如您所见，结果是相同的

基准：https://go.dev/play/p/zdeqTQuDxmS

goos: linux
goarch: amd64
pkg: example.org
cpu: Intel(R) Core(TM) i7-7700 CPU @ 3.60GHz
BenchmarkInt-8                      985913821            1.219 ns/op           0 B/op          0 allocs/op
BenchmarkFloat-8                    616161028            1.990 ns/op           0 B/op          0 allocs/op
BenchmarkToStringInt-8               6727627           175.8 ns/op        24 B/op          2 allocs/op
BenchmarkToStringFloat-8             4459144           269.1 ns/op        24 B/op          2 allocs/op
BenchmarkToStringNegativeInt-8       5851466           204.7 ns/op        40 B/op          3 allocs/op
BenchmarkToStringNegativeFloat-8     4456899           271.2 ns/op        24 B/op          2 allocs/op

int64 版本比带浮点数的版本快 40%，int64 的 tostring 更快

当然，我的 cpu 是 64 位，管道中支持浮点，在 32 位纯整数 cpu 上结果会有所不同。仍然 int 应该优于 float 版本。

今天关于《优化 Go 中高精度计算的性能》的内容就介绍到这里了，是不是学起来一目了然！想要了解更多关于的内容请关注golang学习网公众号！