字节序问题与浮点数

在开发 Tormenta 中，我遇到一个字节序问题，涉及按顺序存储浮点数。虽然正浮点数的字节序符合预期，但负浮点数的顺序却出现混乱。为了解决这个问题，需要同时翻转符号位和反转负浮点数的顺序。一种解决方案是使用 math.float64bits() 将浮点数转换为 uint64 值，然后对该值进行按位运算。如果浮点数为正，则将最高位与 0x8000000000000000 异或；如果为负，则将所有位与 0xffffffffffffffff 异或。另一种方法是直接对序列化后的浮点数字节进行异或操作，对正浮点数仅异或第一个字节，对负浮点数异或所有字节。

我正在开发 Tormenta (https://github.com/jpincas/tormenta)，它由 BadgerDB (https://github.com/dgraph-io/badger) 支持。 BadgerDB 按字节顺序存储键（字节片）。我正在创建包含需要按顺序存储的浮点数的键，以便我可以正确使用 Badger 的键迭代。我没有扎实的计算机科学背景，所以有点力不从心。

我对浮点数进行编码，如下所示：binary.Write(buf, binary.BigEndian, myFloat)。这对于正浮点数来说效果很好 - 关键顺序是您所期望的，但是对于负浮点数，字节顺序会崩溃。

顺便说一句，整数也存在同样的问题，但我可以通过使用 b[0] ^= 1 << 7 翻转 int 上的符号位来相对轻松地解决这个问题（其中 b 是 []byte 持有对 int 进行编码的结果），然后在检索密钥时翻转回来。

虽然 b[0] ^= 1 << 7 也会翻转浮点数上的符号位，从而将所有负浮点数放在正浮点数之前，但负浮点数的顺序不正确（向后）。需要翻转符号位并反转负浮点数的顺序。

这里在 StackOverflow 上提出了类似的问题：Sorting float-point value using their byte-representation，并且一致同意的解决方案是：

将所有正数与 0x8000... 进行异或，将负数与 0xffff... 进行异或。 这应该翻转两者的符号位（因此负数先行），然后反转负数的顺序。

但是，这远远超出了我的位翻转技能水平，因此我希望 Go 位忍者可以帮助我将其转换为一些 Go 代码。

解决方案

使用 math.float64bits()

您可以使用 math.Float64bits()，它返回一个 uint64 值，该值与传递给它的 float64 值具有相同的字节/位。

一旦有了 uint64，对其执行按位运算就很简单：

f := 1.0 // some float64 value

bits := math.float64bits(f)
if f >= 0 {
    bits ^= 0x8000000000000000
} else {
    bits ^= 0xffffffffffffffff
}

然后序列化 bits 值而不是 f float64 值，就完成了。

让我们看看它的实际效果。让我们创建一个包含 float64 数字及其字节的包装类型：

type num struct {
    f    float64
    data [8]byte
}

让我们创建这些 num 的切片：

nums := []*num{
    {f: 1.0},
    {f: 2.0},
    {f: 0.0},
    {f: -1.0},
    {f: -2.0},
    {f: math.pi},
}

序列化它们：

for _, n := range nums {
    bits := math.float64bits(n.f)
    if n.f >= 0 {
        bits ^= 0x8000000000000000
    } else {
        bits ^= 0xffffffffffffffff
    }
    if err := binary.write(bytes.newbuffer(n.data[:0]), binary.bigendian, bits); err != nil {
        panic(err)
    }
}

这就是我们如何按字节对它们进行排序：

sort.slice(nums, func(i int, j int) bool {
    ni, nj := nums[i], nums[j]
    for k := range ni.data {
        if bi, bj := ni.data[k], nj.data[k]; bi < bj {
            return true // we're certain it's less
        } else if bi > bj {
            return false // we're certain it's not less
        } // we have to check the next byte
    }
    return false // if we got this far, they are equal (=> not less)
})

现在让我们看看按字节排序后的顺序：

fmt.println("final order byte-wise:")
for _, n := range nums {
    fmt.printf("% .7f %3v\n", n.f, n.data)
}

输出将为（在 Go Playground 上尝试）：

final order byte-wise:
-2.0000000 [ 63 255 255 255 255 255 255 255]
-1.0000000 [ 64  15 255 255 255 255 255 255]
 0.0000000 [128   0   0   0   0   0   0   0]
 1.0000000 [191 240   0   0   0   0   0   0]
 2.0000000 [192   0   0   0   0   0   0   0]
 3.1415927 [192   9  33 251  84  68  45  24]

没有 math.float64bits()

另一种选择是首先序列化 float64 值，然后对字节执行 xor 操作。

如果数字为正（或零），则将第一个字节与 0x80 进行异或，其余字节与 0x00 进行异或，这基本上对它们不执行任何操作。

如果数字为负数，则将所有字节与 0xff 进行异或，这基本上是按位求反。

实际操作：唯一不同的部分是序列化和 xor 操作：

for _, n := range nums {
    if err := binary.Write(bytes.NewBuffer(n.data[:0]), binary.BigEndian, n.f); err != nil {
        panic(err)
    }
    if n.f >= 0 {
        n.data[0] ^= 0x80
    } else {
        for i, b := range n.data {
            n.data[i] = ^b
        }
    }
}

其余的都是一样的。输出也将是相同的。在 Go Playground 上试试这个。

本篇关于《字节序问题与浮点数》的介绍就到此结束啦，但是学无止境，想要了解学习更多关于Golang的相关知识，请关注golang学习网公众号！