Go言語 big.Int.SetBytes()徹底解説：バイト列から巨大整数を扱う

Function Signature

func (z *Int) SetBytes(buf []byte) *Int

Go言語におけるbig.Int.SetBytes()は、math/bigパッケージが提供するbig.Int型（任意精度整数）のメソッドです。このメソッドは、バイトスライス（[]byte）を受け取り、そのバイト列をbig.Intの値として設定するために使用されます。

主な機能と動作

1. バイト列の解釈
   SetBytes()は、入力されたバイトスライスbufを、符号なし（非負）のビッグエンディアン形式の整数として解釈します。

   • ビッグエンディアン
     これは、バイト列の最初のバイトが最上位バイト（最も桁の大きい部分）であることを意味します。例えば、[]byte{0x01, 0x02}は10進数で258（1×256+2×1）と解釈されます。
   • 符号なし
     SetBytes()は、常に符号なしの整数として解釈します。負の数を設定したい場合は、別途SetBytes()で設定した後にNeg()メソッドなどを使用する必要があります。

2. big.Intへの設定
   解釈されたバイト列の数値が、レシーバである*Int（つまり、SetBytes()を呼び出したbig.Intのインスタンス）に設定されます。

3. レシーバの返却
   便宜のため、SetBytes()は、設定されたbig.Intのポインタ（レシーバと同じ）を返します。これにより、メソッドチェーンが可能になります。

使用例（Go言語）

package main

import (
	"fmt"
	"math/big"
)

func main() {
	// 例1: 10進数の258を設定
	// 0x01 = 1, 0x02 = 2
	// ビッグエンディアンなので、1*256 + 2 = 258
	bytes1 := []byte{0x01, 0x02}
	n1 := new(big.Int)
	n1.SetBytes(bytes1)
	fmt.Printf("Bytes: %x -> big.Int: %s\n", bytes1, n1.String()) // 出力: Bytes: 0102 -> big.Int: 258

	// 例2: 大きな数を設定
	// 0x1234567890ABCDEFは、16進数で大きな値
	bytes2 := []byte{0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF}
	n2 := new(big.Int)
	n2.SetBytes(bytes2)
	fmt.Printf("Bytes: %x -> big.Int: %s\n", bytes2, n2.String()) // 出力: Bytes: 1234567890abcdef -> big.Int: 13117684674637903215

	// 例3: 先頭にゼロがある場合（先頭のゼロは無視されない）
	// 0x0001は1と解釈される
	bytes3 := []byte{0x00, 0x01}
	n3 := new(big.Int)
	n3.SetBytes(bytes3)
	fmt.Printf("Bytes: %x -> big.Int: %s\n", bytes3, n3.String()) // 出力: Bytes: 0001 -> big.Int: 1
}

注意点

• エンディアン
  必ずビッグエンディアンで解釈されることを理解しておくことが重要です。リトルエンディアンのバイト列を扱う場合は、事前にバイト列の順序を反転させるなどの処理が必要になります。
• ゼロバイトの扱い
  先頭のゼロバイトも数値の一部として扱われます。例えば、[]byte{0x00, 0x01}は1として解釈されます。
• 符号の扱い
  SetBytes()は常に符号なしとして解釈します。負の値を表すバイト列を直接与えても、それは符号なしの大きな数として扱われます。負の数を表現したい場合は、SetBytes()で値を設定した後、Neg()メソッドなどを使って符号を反転させる必要があります。

---

big.Int.SetBytes() はバイトスライスを符号なしビッグエンディアン形式の整数として解釈します。この解釈方法が原因で、多くの問題が発生します。

想定外の数値になる (符号の誤解)

問題
バイトスライスが負の数を表すことを意図しているのに、SetBytes() で設定すると非常に大きな正の数になってしまう。これは、big.Int が二進補数表現で負の数を扱うことを期待してバイト列を渡した場合によく発生します。

例
[]byte{0xFF} を -1 として扱いたいのに、255 と解釈されてしまう。

原因
SetBytes() は、常に**符号なし（非負）**の整数としてバイト列を解釈します。これは、入力バイト列の最上位ビットが符号ビットとして扱われることはない、という意味です。

トラブルシューティング
負の数を設定したい場合は、以下のいずれかの方法を取ります。

• 符号付き整数をバイト列に変換する際の注意
  もし、Go以外の言語やシステムから受け取った二進補数表現のバイト列を Go で big.Int として扱いたい場合は、事前にそのバイト列が正の数なのか負の数なのかを判断し、負の数であれば適切な変換（例えば、二進補数から絶対値への変換）を行ってから SetBytes() に渡し、その後 Neg() を適用する必要があります。これは、big.Int が内部的に符号と値のペアで数を保持しているためです。

• 正の値を設定してから Neg() メソッドを使用する
  まず、負の数の絶対値を表すバイト列（例えば、-1 の場合は 1 を表す []byte{0x01}）を SetBytes() で設定し、その後 Neg() メソッドで符号を反転させます。

  package main
  
  import (
  	"fmt"
  	"math/big"
  )
  
  func main() {
  	// -1 を設定したい場合
  	bytesAbs1 := []byte{0x01} // 1を表す
  	n := new(big.Int)
  	n.SetBytes(bytesAbs1) // nは1になる
  	n.Neg(n)              // nは-1になる
  	fmt.Printf("Bytes: %x -> big.Int: %s\n", bytesAbs1, n.String()) // 出力: Bytes: 01 -> big.Int: -1
  
  	// 負の大きな数を設定したい場合
  	// 例えば、-1000000 を設定したい場合、1000000 (0xF4240) のバイト列を用意する
  	bytesAbsMillion := []byte{0x0F, 0x42, 0x40} // 1000000を表す
  	m := new(big.Int)
  	m.SetBytes(bytesAbsMillion) // mは1000000になる
  	m.Neg(m)                    // mは-1000000になる
  	fmt.Printf("Bytes: %x -> big.Int: %s\n", bytesAbsMillion, m.String()) // 出力: Bytes: 0f4240 -> big.Int: -1000000
  }
  

想定外の数値になる (エンディアンの誤解)

問題
リトルエンディアン形式のバイト列を SetBytes() に渡すと、期待とは全く異なる大きな数値になってしまう。

例
[]byte{0x02, 0x01} を 258 (0x0102) として扱いたいのに、513 (0x0201) と解釈されてしまう。

原因
SetBytes() は、バイト列を常にビッグエンディアンとして解釈します。つまり、バイト列の先頭のバイトが最も高い位の値を持つとみなされます。

トラブルシューティング
リトルエンディアン形式のバイト列を big.Int に設定したい場合は、SetBytes() を呼び出す前にバイト列の順序を反転させる必要があります。

package main

import (
	"fmt"
	"math/big"
)

func reverseBytes(b []byte) []byte {
	// スライスをコピーして元のスライスを変更しないようにする
	reversed := make([]byte, len(b))
	for i, j := 0, len(b)-1; i < len(b); i, j = i+1, j-1 {
		reversed[i] = b[j]
	}
	return reversed
}

func main() {
	// リトルエンディアンのバイト列 (0x0102 = 258)
	littleEndianBytes := []byte{0x02, 0x01}
	fmt.Printf("Original Little Endian Bytes: %x\n", littleEndianBytes)

	// バイト列を反転させる
	bigEndianBytes := reverseBytes(littleEndianBytes)
	fmt.Printf("Converted Big Endian Bytes: %x\n", bigEndianBytes)

	n := new(big.Int)
	n.SetBytes(bigEndianBytes)
	fmt.Printf("big.Int from Little Endian: %s\n", n.String()) // 出力: big.Int from Little Endian: 258
}

バイト列の長さが不適切

問題
特定のビット幅（例: 64ビット整数）のバイト列を扱う際に、バイト列の長さが期待と異なる。

例
uint64 をバイト列に変換して SetBytes() に渡す際に、バイト列の長さが8バイトではない場合（Goの binary パッケージなどでエンディアンを意識しない変換を行った場合など）。

原因
SetBytes() はバイト列の長さに制限を設けません。与えられたバイト列をそのまま解釈します。問題は、バイト列を生成する側にあることが多いです。

トラブルシューティング

• パディング
  もしバイト列が特定の長さよりも短い場合で、先頭にゼロを追加して長さを揃えたい場合は、手動でパディングする必要があります。

• バイト列の生成方法を確認する
  binary パッケージなどを使用して数値をバイト列に変換する場合は、エンディアンとバイト数を明示的に指定することが重要です。例えば、binary.BigEndian.PutUint64() を使用すると、常に8バイトのビッグエンディアン形式のバイト列が生成されます。

  package main
  
  import (
  	"encoding/binary"
  	"fmt"
  	"math/big"
  )
  
  func main() {
  	var val uint64 = 1234567890123456789 // 大きなuint64の値
  	buf := make([]byte, 8)
  	binary.BigEndian.PutUint64(buf, val) // 8バイトのビッグエンディアンバイト列を生成
  
  	n := new(big.Int)
  	n.SetBytes(buf)
  	fmt.Printf("uint64: %d -> Bytes: %x -> big.Int: %s\n", val, buf, n.String())
  }
  

先頭のゼロバイトの解釈

問題
[]byte{0x00, 0x01} のようなバイト列を SetBytes() に渡すと、1 と解釈される。しかし、一部のシステムでは 0x00 を単なるパディングとして無視することを期待する場合がある。

原因
SetBytes() は、先頭のゼロバイトも含めてバイト列全体を数値の一部として扱います。これは正しい動作であり、ゼロは有効な数値の桁の一部です。

トラブルシューティング
これはエラーというよりも、解釈の期待値の違いです。もし先頭のゼロバイトを無視したい場合は、SetBytes() に渡す前に、先頭の連続するゼロバイトをトリムする必要があります。

package main

import (
	"fmt"
	"math/big"
)

func trimLeadingZeros(b []byte) []byte {
	i := 0
	for i < len(b)-1 && b[i] == 0x00 { // 最後のバイトが0x00でもトリムしないように len(b)-1 を使う
		i++
	}
	return b[i:]
}

func main() {
	bytesWithZeros := []byte{0x00, 0x00, 0x01, 0x02} // 0x0102 = 258
	fmt.Printf("Original Bytes: %x -> big.Int (direct): %s\n", bytesWithZeros, new(big.Int).SetBytes(bytesWithZeros).String())

	trimmedBytes := trimLeadingZeros(bytesWithZeros)
	fmt.Printf("Trimmed Bytes: %x -> big.Int: %s\n", trimmedBytes, new(big.Int).SetBytes(trimmedBytes).String()) // 258
}

ただし、通常 big.Int.SetBytes は先頭のゼロバイトを数値として扱うことが期待されるため、このトリムは特定のユースケースでのみ必要となります。

big.Int.SetBytes() を使用する際の主な注意点は、以下の2点に集約されます。

1. 符号の扱い
   常に符号なしとして解釈される。負の数を扱いたい場合は Neg() を使う。
2. エンディアン
   常にビッグエンディアンとして解釈される。リトルエンディアンの場合はバイト列を反転させる。

---

big.Int.SetBytes() は、バイトスライスから big.Int の値を設定するためのメソッドです。主に、ネットワークプロトコルから受信したバイナリデータ、ハッシュ値、データベースから取得した大きな数値などを扱う際に利用されます。

基本的な使い方：正の整数をバイトスライスから設定する

この例では、一般的な正の整数をバイトスライスで表現し、SetBytes() を使って big.Int に設定する方法を示します。

package main

import (
	"fmt"
	"math/big" // big.Int を使用するために必要
)

func main() {
	fmt.Println("--- 例1: 基本的な使い方（正の整数） ---")

	// 10進数で 258 を表すバイトスライス (ビッグエンディアン)
	// 0x01 = 1, 0x02 = 2
	// 1 * 256^1 + 2 * 256^0 = 256 + 2 = 258
	bytes1 := []byte{0x01, 0x02}
	n1 := new(big.Int) // 新しい big.Int を初期化
	n1.SetBytes(bytes1) // バイトスライスから値を設定
	fmt.Printf("バイトスライス: %x -> big.Int: %s\n", bytes1, n1.String())
	// 出力: バイトスライス: 0102 -> big.Int: 258

	// より大きな数値を設定
	// 16進数で "1234567890ABCDEF" を表すバイトスライス
	bytes2 := []byte{0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF}
	n2 := new(big.Int)
	n2.SetBytes(bytes2)
	fmt.Printf("バイトスライス: %x -> big.Int: %s\n", bytes2, n2.String())
	// 出力: バイトスライス: 1234567890abcdef -> big.Int: 13117684674637903215 (これは 0x1234567890ABCDEF の10進数表現)
}

解説

• n.String() は big.Int の値を10進数文字列として返します。
• SetBytes() メソッドは、与えられたバイトスライスを符号なしのビッグエンディアン形式の整数として解釈し、その値をレシーバ（この場合は n1 や n2）に設定します。
• new(big.Int) で big.Int の新しいインスタンスへのポインタを作成します。

負の数を設定する（SetBytes() の直接的な使用ではない）

SetBytes() は常に符号なしとしてバイト列を解釈するため、直接負の数を設定することはできません。負の数を表現したい場合は、正の値を設定してから Neg() メソッドで符号を反転させる必要があります。

package main

import (
	"fmt"
	"math/big"
)

func main() {
	fmt.Println("\n--- 例2: 負の数を設定する ---")

	// -1 を設定したい場合
	// まずは 1 を表すバイトスライスを用意する
	bytesAbs1 := []byte{0x01}
	nNeg1 := new(big.Int)
	nNeg1.SetBytes(bytesAbs1) // nNeg1 は 1 になる
	nNeg1.Neg(nNeg1)          // nNeg1 を -nNeg1 に設定する (つまり -1)
	fmt.Printf("バイトスライス(絶対値): %x -> big.Int: %s\n", bytesAbs1, nNeg1.String())
	// 出力: バイトスライス(絶対値): 01 -> big.Int: -1

	// 10進数で -12345 を設定したい場合
	// まずは 12345 を表すバイトスライスを用意する (12345 の16進数は 0x3039)
	bytesAbs12345 := []byte{0x30, 0x39}
	nNeg12345 := new(big.Int)
	nNeg12345.SetBytes(bytesAbs12345) // nNeg12345 は 12345 になる
	nNeg12345.Neg(nNeg12345)          // nNeg12345 を -12345 に設定する
	fmt.Printf("バイトスライス(絶対値): %x -> big.Int: %s\n", bytesAbs12345, nNeg12345.String())
	// 出力: バイトスライス(絶対値): 3039 -> big.Int: -12345
}

解説

• big.Int.Neg(x *Int) メソッドは、レシーバの値を x の負の値に設定します。この例では n.Neg(n) のように同じインスタンスを引数に渡して、そのインスタンス自身の符号を反転させています。
• SetBytes() は常に正の数としてバイト列を解釈します。

リトルエンディアン形式のバイト列を扱う

SetBytes() はビッグエンディアンを期待するため、リトルエンディアンのバイト列を直接渡すと誤った値になります。この場合は、バイト列を反転させる必要があります。

package main

import (
	"fmt"
	"math/big"
	"encoding/binary" // バイト順序変換の補助に使えるが、ここでは手動で反転
)

// バイトスライスを反転させるヘルパー関数
func reverseBytes(b []byte) []byte {
	// 元のスライスを変更しないようにコピーを作成
	reversed := make([]byte, len(b))
	for i, j := 0, len(b)-1; i < len(b); i, j = i+1, j-1 {
		reversed[i] = b[j]
	}
	return reversed
}

func main() {
	fmt.Println("\n--- 例3: リトルエンディアン形式のバイト列を扱う ---")

	// 10進数で 258 (0x0102) をリトルエンディアンで表現したバイトスライス
	// つまり、下位バイトから並んでいる: 0x02, 0x01
	littleEndianBytes := []byte{0x02, 0x01}
	fmt.Printf("リトルエンディアンバイト: %x\n", littleEndianBytes)

	// 直接 SetBytes() に渡すと、0x0201 = 513 と解釈されてしまう
	nDirect := new(big.Int)
	nDirect.SetBytes(littleEndianBytes)
	fmt.Printf("直接 SetBytes() に渡した場合: %s (不正な値)\n", nDirect.String()) // 513

	// バイトスライスを反転させてビッグエンディアンにする
	bigEndianBytes := reverseBytes(littleEndianBytes)
	fmt.Printf("反転後のビッグエンディアンバイト: %x\n", bigEndianBytes) // 0102

	nCorrect := new(big.Int)
	nCorrect.SetBytes(bigEndianBytes)
	fmt.Printf("反転後に SetBytes() に渡した場合: %s (正しい値)\n", nCorrect.String()) // 258

	// binaryパッケージと組み合わせる例 (uint64の場合)
	fmt.Println("\n--- 例3b: binaryパッケージと組み合わせる例 ---")
	var val uint64 = 0x1122334455667788
	buf8 := make([]byte, 8)

	// リトルエンディアンでバイト列に書き込む
	binary.LittleEndian.PutUint64(buf8, val)
	fmt.Printf("元のuint64値: %x\n", val)
	fmt.Printf("Little Endianバイト列: %x\n", buf8) // 8877665544332211

	// SetBytes() はビッグエンディアンを期待するので、リトルエンディアンバイトを反転させる
	reversedBuf8 := reverseBytes(buf8)
	fmt.Printf("反転後のBig Endianバイト列: %x\n", reversedBuf8) // 1122334455667788

	nFromLE := new(big.Int)
	nFromLE.SetBytes(reversedBuf8)
	fmt.Printf("big.Int値: %s\n", nFromLE.String()) // 12297829382473034632 (元のuint64の10進数)
}

解説

• SetBytes() に渡す前に、このリトルエンディアンのバイトスライスを reverseBytes でビッグエンディアンに変換する必要があります。
• binary.LittleEndian.PutUint64() は、uint64 の値をリトルエンディアン形式のバイトスライスに書き込みます。
• reverseBytes ヘルパー関数は、バイトスライスの要素の順序を逆転させます。

先頭のゼロバイトの扱い

SetBytes() は、先頭のゼロバイトも数値の一部として扱います。これは正しい動作ですが、もしこれをトリムしたい場合は別途処理が必要です。

package main

import (
	"fmt"
	"math/big"
)

// 先頭の連続するゼロバイトをトリムするヘルパー関数
func trimLeadingZeros(b []byte) []byte {
	i := 0
	// バイトスライスが空でない、かつ、最後のバイトではない限り
	// 先頭の0x00をスキップする。
	// len(b)-1 を使うのは、例えば []byte{0x00} のような場合でも
	// その0x00が唯一の桁（0）を表す可能性があり、それをトリムしないようにするため。
	for i < len(b)-1 && b[i] == 0x00 {
		i++
	}
	return b[i:]
}

func main() {
	fmt.Println("\n--- 例4: 先頭のゼロバイトの扱い ---")

	// 0x0001 は 1 と解釈される
	bytesWithLeadingZero := []byte{0x00, 0x01}
	nWithZero := new(big.Int)
	nWithZero.SetBytes(bytesWithLeadingZero)
	fmt.Printf("先頭にゼロがあるバイト: %x -> big.Int: %s\n", bytesWithLeadingZero, nWithZero.String())
	// 出力: 先頭にゼロがあるバイト: 0001 -> big.Int: 1

	// 0x00000102 は 258 と解釈される
	bytesMultipleLeadingZeros := []byte{0x00, 0x00, 0x01, 0x02}
	nMultipleZeros := new(big.Int)
	nMultipleZeros.SetBytes(bytesMultipleLeadingZeros)
	fmt.Printf("複数の先頭ゼロがあるバイト: %x -> big.Int: %s\n", bytesMultipleLeadingZeros, nMultipleZeros.String())
	// 出力: 複数の先頭ゼロがあるバイト: 00000102 -> big.Int: 258

	// 先頭のゼロをトリムする例
	trimmedBytes := trimLeadingZeros(bytesMultipleLeadingZeros)
	nTrimmed := new(big.Int)
	nTrimmed.SetBytes(trimmedBytes)
	fmt.Printf("トリム後のバイト: %x -> big.Int: %s\n", trimmedBytes, nTrimmed.String())
	// 出力: トリム後のバイト: 0102 -> big.Int: 258
}

• trimLeadingZeros 関数は、特定のユースケースで先頭のゼロを無視したい場合に役立ちます。ただし、多くの場合、SetBytes() のこの動作は期待通りです。
• SetBytes() は先頭のゼロバイトも有効な桁として扱います。

---

big.Int.SetBytes() は生のバイト列から整数を解釈するのに特化していますが、数値の表現方法やソースに応じて、他の big.Int 初期化メソッドがより適切である場合があります。

文字列から設定する: big.Int.SetString()

数値が文字列として表現されている場合（10進数、16進数など）、SetString() メソッドが非常に便利です。特に、ユーザー入力や設定ファイルから数値を読み込む場合に適しています。

機能
指定された基数（base）で表現された文字列から big.Int の値を設定します。

関数シグネチャ
func (z *Int) SetString(s string, base int) (*Int, bool)

例

package main

import (
	"fmt"
	"math/big"
)

func main() {
	fmt.Println("--- 例1: 文字列から設定する (SetString) ---")

	// 10進数文字列から設定
	s10 := "123456789012345678901234567890" // 非常に大きな10進数
	n10 := new(big.Int)
	_, ok := n10.SetString(s10, 10) // 基数10を指定
	if !ok {
		fmt.Println("10進数文字列の解析に失敗しました:", s10)
	} else {
		fmt.Printf("文字列 (10進数): \"%s\" -> big.Int: %s\n", s10, n10.String())
	}
	// 出力: 文字列 (10進数): "123456789012345678901234567890" -> big.Int: 123456789012345678901234567890

	// 16進数文字列から設定 (プレフィックス '0x' は任意)
	s16 := "0xABCDEF1234567890ABCDEF" // 16進数
	n16 := new(big.Int)
	_, ok = n16.SetString(s16, 0) // 基数0は、文字列のプレフィックスから自動判別 (0xは16進数、0は8進数)
	if !ok {
		fmt.Println("16進数文字列の解析に失敗しました:", s16)
	} else {
		fmt.Printf("文字列 (16進数): \"%s\" -> big.Int: %s\n", s16, n16.String())
	}
	// 出力: 文字列 (16進数): "0xABCDEF1234567890ABCDEF" -> big.Int: 23963473177930856082218087535
	// (0xABCDEF1234567890ABCDEF の10進数表現)

	// 負の数も可能
	sNeg := "-9876543210"
	nNeg := new(big.Int)
	_, ok = nNeg.SetString(sNeg, 10)
	if !ok {
		fmt.Println("負の文字列の解析に失敗しました:", sNeg)
	} else {
		fmt.Printf("文字列 (負の数): \"%s\" -> big.Int: %s\n", sNeg, nNeg.String())
	}
	// 出力: 文字列 (負の数): "-9876543210" -> big.Int: -9876543210
}

SetBytes() との比較

• SetString(): 文字列（テキスト表現）から。基数を指定でき、符号も考慮される。人間が読みやすい形式。
• SetBytes(): 生のバイト列（バイナリデータ）から。符号は考慮されず、常にビッグエンディアン。

標準的な整数型から設定する: big.Int.SetInt64(), big.Int.SetUint64()

Go の組み込み整数型（int, int64, uint, uint64 など）から big.Int を初期化する場合にこれらを使用します。

機能
int64 または uint64 の値を big.Int に設定します。

関数シグネチャ

• func (z *Int) SetUint64(x uint64) *Int
• func (z *Int) SetInt64(x int64) *Int

例

package main

import (
	"fmt"
	"math/big"
)

func main() {
	fmt.Println("\n--- 例2: 標準整数型から設定する ---")

	// int64 から設定
	var i64 int64 = -9223372036854775808 // int64 の最小値
	nI64 := new(big.Int)
	nI64.SetInt64(i64)
	fmt.Printf("int64: %d -> big.Int: %s\n", i64, nI64.String())
	// 出力: int64: -9223372036854775808 -> big.Int: -9223372036854775808

	// uint64 から設定
	var u64 uint64 = 18446744073709551615 // uint64 の最大値
	nU64 := new(big.Int)
	nU64.SetUint64(u64)
	fmt.Printf("uint64: %d -> big.Int: %s\n", u64, nU64.String())
	// 出力: uint64: 18446744073709551615 -> big.Int: 18446744073709551615
}

SetBytes() との比較

• SetInt64(), SetUint64(): int64 や uint64 が入力。これらのメソッドは内部的に適切なバイト表現を生成して big.Int に設定するため、バイト順序や符号の扱いについて考慮する必要がありません。
• SetBytes(): []byte が入力。

他の big.Int から設定する: big.Int.Set()

すでに存在する別の big.Int インスタンスから値をコピーする場合に Set() メソッドを使用します。

機能
x の値を z にコピーします。

関数シグネチャ
func (z *Int) Set(x *Int) *Int

例

package main

import (
	"fmt"
	"math/big"
)

func main() {
	fmt.Println("\n--- 例3: 他の big.Int から設定する (Set) ---")

	original := new(big.Int)
	original.SetString("98765432109876543210", 10)

	duplicate := new(big.Int)
	duplicate.Set(original) // original の値を duplicate にコピー
	fmt.Printf("オリジナル: %s, コピー: %s\n", original.String(), duplicate.String())

	// コピー後にオリジナルを変更しても、コピーには影響しない
	original.Add(original, big.NewInt(1))
	fmt.Printf("オリジナル変更後: オリジナル: %s, コピー: %s\n", original.String(), duplicate.String())
	// 出力: オリジナル変更後: オリジナル: 98765432109876543211, コピー: 98765432109876543210
}

SetBytes() との比較

• Set(): 既存の big.Int の値をコピーする。
• SetBytes(): ゼロから big.Int を構築する（バイト列から）。

big.NewInt() と組み合わせる

big.NewInt() は、int64 の値から新しい big.Int インスタンスを生成する便利なヘルパー関数です。これは new(big.Int).SetInt64(x) の短縮形と考えることができます。

関数シグネチャ
func NewInt(x int64) *Int

例

package main

import (
	"fmt"
	"math/big"
)

func main() {
	fmt.Println("\n--- 例4: big.NewInt() を使用する ---")

	// 100 という値を持つ新しい big.Int を作成
	n := big.NewInt(100)
	fmt.Printf("big.NewInt(100): %s\n", n.String()) // 出力: big.NewInt(100): 100

	// big.NewInt() は int64 の範囲に限定されるが、後続の操作で任意精度になる
	largeInt := big.NewInt(0).SetString("987654321098765432109876543210", 10) // NewInt(0)で初期化後SetString
	fmt.Printf("大きな数: %s\n", largeInt.String())
}

SetBytes() との比較

• NewInt() は int64 の範囲の初期値から。big.Int が任意精度であるため、NewInt() で初期化した後も、計算によって値が int64 の範囲を超えることができます。
• SetBytes() はバイト列から。

big.Int.SetBytes() は、バイナリデータ形式の数値から big.Int を構築する場合に不可欠ですが、データのソースや形式に応じて、以下の代替手段も考慮することが重要です。

• 簡潔な初期化
  big.NewInt()（int64 範囲の初期値から）
• 既存の big.Int のコピー
  Set()
• Goの標準整数型からの変換
  SetInt64(), SetUint64()（Goプログラム内部での変換）
• 文字列からの解析
  SetString()（ユーザー入力、設定ファイル、JSONなど）