Convert big.Int to int64 and vice versa as well as two's complement

php editor Youzi will introduce to you how to convert big.Int to int64 in PHP, and how to convert int64 to big.Int. In computer programming, big.Int and int64 are two different data types. big.Int is used to handle large integers, while int64 is a 64-bit signed integer type. When doing type conversion, we need to pay attention to the concept of two's complement, which is a way of representing signed integers in computers. Next, we will detail the conversion process between these two types.

Question content

I'm trying to convert a go big.int representing a 128-bit integer to [2]int64. The idea is to be able to match rust's i128::to_le_bytes(), which encodes 128-bit signed integers into little-endian byte order. This example matches rust's i128::to_le_bytes(). Whenever I try to convert it back to big.int I don't get the same value. Are any bits lost when doing the initial right shift? Thanks.

package main
 
import (
    "encoding/binary"
    "fmt"
    "math/big"
)
 
func main() {
    initial := new(big.Int)
    initial.SetString("-42", 10)
 
    value, _ := new(big.Int).SetString("-42", 10)
 
    var result [2]int64
 
    result[0] = value.Int64()
    result[1] = value.Rsh(value, 64).Int64()
 
    leRepresentation := make([]byte, 16)
 
    binary.LittleEndian.PutUint64(leRepresentation[:8], uint64(result[0]))
    binary.LittleEndian.PutUint64(leRepresentation[8:], uint64(result[1]))
 
    fmt.Println(leRepresentation)
 
    fmt.Println(result)
 
    reverse := big.NewInt(result[1])
    reverse.Lsh(reverse, 64)
    reverse.Add(reverse, big.NewInt(result[0]))
 
    fmt.Println(reverse.String())
 
    fmt.Println(initial.String() == reverse.String())
}

Solution

There are many problems here:

value cannot be represented in terms of int64, so the result of value.int64() is undefined.

Your lower bits are not taking into account the signed result of int64, so you may be adding negative numbers to the result. You need to use uint64 (or at least convert it before adding it to big.int).

You are changing the value within the rsh method, so even if the value is recreated correctly, the final comparison will fail. If you want to compare, create a new big.int to store the original value.

If you want the raw data representation of big.int to be exactly 128 bits, you can use the fillbytes method. We can take the big-endian data and construct 2 64-bit values ​​like this:

b := make([]byte, 16)
value.fillbytes(b)  

var result [2]uint64
result[0] = binary.bigendian.uint64(b[:8])
result[1] = binary.bigendian.uint64(b[8:])

Now that the byte order is fixed, add the sign bit to the result. However, in order to make it work like int128 we need to set the symbol

const sign = uint64(1 << 63)
if value.sign() < 0 {
    // convert the unsigned value to two's compliment
    result[0] = ^result[0]
    result[1] = ^result[1]

    result[1]++
    // check for carry
    if result[1] == 0 {
        result[0]++
    }
}

To create a new big.int, reverse the entire process:

neg := uint128[0]&sign != 0
if neg {
    // reverse the two's compliment
    if uint128[1] == 0 {
        uint128[0]--
    }
    uint128[1]--

    uint128[0] = ^uint128[0]
    uint128[1] = ^uint128[1]
}

b := make([]byte, 16)
binary.BigEndian.PutUint64(b[:8], uint128[0])
binary.BigEndian.PutUint64(b[8:], uint128[1])

result := new(big.Int).SetBytes(b)
if neg {
    result.Neg(result)
}

Example of testing multiple key values: https://go.dev/play/ p/e1e-5cilflr

Since the output is written as an unsigned value, if you can start with a value > maxint128 you should also add a check to ensure that signed values ​​are not overflowed. Storing them as [2]int64 would be more confusing because we need uint64 values ​​for bitwise operations, and we need to make sure that the int64 values ​​don't roll over by their own complement . In this case it would be easier to convert [2]int64 to and from [2]uint64 around a given function.

The above is the detailed content of Convert big.Int to int64 and vice versa as well as two's complement. For more information, please follow other related articles on the PHP Chinese website!