big.Int.Not() 徹底ガイド：Go言語での多倍長整数ビット操作
2025-06-01
big.Int.Not(x *Int)は、Go言語のmath/bigパッケージで提供されるメソッドで、**巨大な整数（多倍長整数）に対するビットごとの論理否定（ビット反転、NOT演算）**を実行します。
簡単に言うと、与えられた巨大な整数 x の各ビットを反転させ、その結果を新しいbig.Intのインスタンスに格納して返します。
メソッドのシグネチャ
func (z *Int) Not(x *Int) *Int
- 戻り値: 結果が格納された
zへのポインタを返します。通常、メソッドチェーンを可能にするためにz自身が返されます。 x *Int: ビット反転の対象となるbig.Intへのポインタです。z *Int: 演算結果が格納されるbig.Intへのポインタです。zはレシーバーと呼ばれ、メソッドが実行された後にこのオブジェクトが結果を持ちます。
動作の具体例
例えば、xがバイナリで...00101100という値だとします（先頭の...は無限に続くゼロを表します）。
x.Not()を呼び出すと、各ビットが反転されます。
1は0に0は1に
したがって、xが...00101100の場合、x.Not()の結果は...11010011となります。
ただし、big.Intは符号付き整数を扱うため、ビット反転の挙動は少し注意が必要です。
例えば、Goの組み込み型である符号付き整数（int, int64など）で負数を表現する際には、2の補数表現が用いられます。big.Intも同様に2の補数表現で負数を内部的に扱います。
Not(x)は、数学的な意味でのビットごとのNOT演算を行います。これは、-(x + 1) と等価です。
例:
x = 5 (バイナリ: ...00000101)
x.Not() は -(5 + 1) = -6 となります。
-6 を2の補数表現で表すと ...11111010 となり、これは ...00000101 のビットを反転させたものと一致します。
使用例
package main
import (
"fmt"
"math/big"
)
func main() {
// big.Int のインスタンスを作成
x := new(big.Int)
y := new(big.Int)
// x に値をセット (例: 10進数の5)
x.SetString("5", 10) // バイナリ: ...00000101
// x のビットを反転させて y に格納
y.Not(x) // y は -6 となる (バイナリ: ...11111010)
fmt.Printf("x: %s (バイナリ: %s)\n", x.String(), x.Text(2))
fmt.Printf("y (x.Not()): %s (バイナリ: %s)\n", y.String(), y.Text(2))
// 別の例 (負の数)
a := new(big.Int)
b := new(big.Int)
a.SetString("-10", 10) // バイナリ: ...11110110
b.Not(a) // b は -(-10 + 1) = -(-9) = 9 となる (バイナリ: ...00001001)
fmt.Printf("a: %s (バイナリ: %s)\n", a.String(), a.Text(2))
fmt.Printf("b (a.Not()): %s (バイナリ: %s)\n", b.String(), b.Text(2))
}
出力例
x: 5 (バイナリ: 101)
y (x.Not()): -6 (バイナリ: -110)
a: -10 (バイナリ: -1010)
b (a.Not()): 9 (バイナリ: 1001)
注意点
big.Int.Text(2)でバイナリ表現を出力する場合、負の数に対しては2の補数表現そのものではなく、先頭に-が付いた形で出力されます。内部的には2の補数で表現されていますが、表示は人間が理解しやすいように整形されます。
ポインタの扱いの誤り
一般的なエラー
big.Intのメソッドはほとんどがポインタレシーバー (*Int) を持ち、引数もポインタで受け取ります。Not()も例外ではありません。big.Intのインスタンスを適切に初期化せず、ゼロ値のbig.Int構造体に対して直接メソッドを呼び出したり、ポインタではない値を渡そうとしたりすると、コンパイルエラーやランタイムエラーが発生する可能性があります。
// エラーの例: 初期化されていないbig.Int
var x big.Int
// y.Not(x) // コンパイルエラー: cannot use x (type big.Int) as type *big.Int in argument to y.Not
トラブルシューティング
big.Intは常にnew(big.Int)またはbig.NewInt(value)で初期化し、ポインタとして扱う必要があります。
package main
import (
"fmt"
"math/big"
)
func main() {
// 正しい初期化
x := new(big.Int) // または big.NewInt(0) など
x.SetString("5", 10)
y := new(big.Int)
y.Not(x) // x は *big.Int 型なので問題ない
fmt.Println(y)
}
結果の格納先（レシーバー）の誤解
一般的なエラー
Not(x *Int)は、レシーバーであるzに結果を格納し、そのzを返します。たまに、結果が新しいインスタンスとして返されると誤解し、レシーバーの値を無視してしまうことがあります。
// エラーの例: 結果が新しいインスタンスになると誤解
x := big.NewInt(5)
result := new(big.Int)
result.Not(x) // result に結果が格納される
// もし `result := x.Not()` のように書こうとすると、Goではこれはできません。
// `big.Int.Not` は `(z *Int) Not(x *Int) *Int` なので、`x.Not(x)` は `x` 自身をビット反転します。
// あるいは `new(big.Int).Not(x)` とすれば、新しいインスタンスに結果を格納できます。
トラブルシューティング
メソッドのシグネチャ func (z *Int) Not(x *Int) *Int を理解し、zが結果を保持するオブジェクトであることを意識してください。通常、zには結果を格納したいbig.Intのポインタを渡します。
package main
import (
"fmt"
"math/big"
)
func main() {
x := big.NewInt(5)
z := new(big.Int) // 結果を格納するインスタンスを準備
z.Not(x) // x の Not 演算結果を z に格納
fmt.Printf("x: %s, Not(x): %s\n", x.String(), z.String())
// または、元の値を上書きしても良い場合
val := big.NewInt(10)
val.Not(val) // val 自身をビット反転し、結果を val に格納
fmt.Printf("val: %s\n", val.String())
}
ビット反転の特性（2の補数表現）への誤解
一般的なエラー
big.Int.Not()は、単にビットを反転させるだけでなく、符号付き整数（2の補数表現）の文脈でビット反転を行います。これは、数学的に -(x + 1) と等価です。この特性を理解していないと、特に負の数を扱った場合に「期待と異なる結果」になることがあります。
例:
Not(-5)(...11111011) は-(-5 + 1) = -(-4) = 4(...00000100)Not(5)(...00000101) は-(5 + 1) = -6(...11111010)
もし、「最上位ビットを符号ビットと見なさず、純粋なビット列として反転させたい」と考える場合、big.Int.Not()は期待通りの動作をしない可能性があります。
トラブルシューティング
- 純粋なビット列の反転が必要な場合は、
big.Intのビット操作メソッド（SetBit,BitLen,Bytesなど）を組み合わせて自分で実装するか、特定のビット長に切り詰める必要があります。例えば、ある固定ビット長（例: 256ビット）でのビット反転を行いたい場合は、そのビット長に合わせたマスク値とXor演算を使用することが考えられます。 big.Int.Not()が-(x + 1)の演算であることを理解し、その挙動が意図通りか確認します。
package main
import (
"fmt"
"math/big"
)
func main() {
x := big.NewInt(5) // ...00000101
z := new(big.Int)
z.Not(x)
fmt.Printf("Not(%s) = %s\n", x.String(), z.String()) // Not(5) = -6
// 固定ビット長（例: 8ビット）でのビット反転をシミュレートしたい場合
// 実際にはもっと複雑なロジックが必要なことが多いですが、概念として
mask8bit := big.NewInt(0xFF) // 11111111
fixedBitsX := new(big.Int).And(x, mask8bit) // 5 (00000101)
pureNot := new(big.Int).Xor(fixedBitsX, mask8bit) // 11111010 (250)
fmt.Printf("Fixed 8-bit Not(%s) = %s\n", x.String(), pureNot.String()) // Fixed 8-bit Not(5) = 250
}
nilポインタの扱い
一般的なエラー
Go言語ではnilポインタを扱う際にパニック（panic）が発生することがあります。big.Intのメソッドも例外ではありません。引数にnilを渡したり、初期化されていないbig.Intのポインタにメソッドを呼び出したりすると、実行時エラーが発生する可能性があります。
// エラーの例: nil ポインタへのメソッド呼び出し
var x *big.Int // x は nil
// x.Not(big.NewInt(10)) // panic: value method Not called using nil *Int pointer
トラブルシューティング
big.Intのポインタがnilでないことを確認するか、メソッドを呼び出す前に適切に初期化してください。
package main
import (
"fmt"
"math/big"
)
func main() {
var x *big.Int = nil // わざとnilにする
// 安全な使い方: メソッドを呼び出す前に初期化をチェック
if x == nil {
x = new(big.Int) // または big.NewInt(0)
}
y := big.NewInt(10)
x.Not(y)
fmt.Println(x)
}
パフォーマンスに関する考慮事項
一般的なエラー
big.Intは任意の精度を持つ整数を扱うため、非常に大きな数値を扱うと、通常の組み込み型（int, int64など）よりも演算に時間がかかることがあります。Not()自体は比較的軽量な操作ですが、連続して大量のbig.Intオブジェクトを生成・操作する場合、メモリ使用量やCPU使用率が増加する可能性があります。
トラブルシューティング
big.Intが必要な精度でない場合は、組み込み型を使用することを検討します。- プロファイリングツール（
go tool pprofなど）を使用して、パフォーマンスのボトルネックを特定します。 - 可能な限り、同じ
big.Intインスタンスを再利用して、新しいオブジェクトの生成を避けます。Not()メソッドはレシーバーzに結果を格納するため、再利用しやすいです。
package main
import (
"fmt"
"math/big"
"time"
)
func main() {
start := time.Now()
// 効率的な例: レシーバーを再利用
result := new(big.Int)
for i := 0; i < 100000; i++ {
x := big.NewInt(int64(i))
result.Not(x) // 同じ result インスタンスを使い回す
}
fmt.Printf("Reusing result took: %v\n", time.Since(start))
start = time.Now()
// 非効率な例: ループごとに新しいインスタンスを生成
for i := 0; i < 100000; i++ {
x := big.NewInt(int64(i))
new(big.Int).Not(x) // 結果はすぐにGCされるが、インスタンス生成のオーバーヘッドがある
}
fmt.Printf("Creating new result each time took: %v\n", time.Since(start))
}
（上記の例では、Not()の計算自体が軽いため大きな差は出にくいですが、より複雑な演算やオブジェクトの生存期間が長い場合は顕著になります。）
big.Int.Not()は、math/bigパッケージが提供する多倍長整数（任意の精度を持つ整数）に対するビットごとの論理否定（NOT演算）を行うメソッドです。数学的には -(x + 1) と等価な操作です。
基本的な使用例
この例では、big.Int.Not()の最も基本的な使い方を示します。
package main
import (
"fmt"
"math/big"
)
func main() {
fmt.Println("--- 基本的な使用例 ---")
// 1. big.Int のインスタンスを作成
// new(big.Int) でポインタを生成し、デフォルト値（0）で初期化
x := new(big.Int)
result := new(big.Int) // 演算結果を格納するためのインスタンス
// 2. x に値をセット
// SetString("数値", 基数) で文字列から数値をセットします。
x.SetString("5", 10) // 10進数の5 (バイナリ: ...00000101)
fmt.Printf("元の値 x: %s (バイナリ: %s)\n", x.String(), x.Text(2))
// 3. Not() メソッドを呼び出す
// result.Not(x) は、x のビットを反転させた結果を result に格納します。
result.Not(x)
// 4. 結果の表示
// 5 のビット反転は -6 になります。
// 5 (00000101) -> -6 (11111010) ※2の補数表現
fmt.Printf("Not(x) の結果: %s (バイナリ: %s)\n", result.String(), result.Text(2))
fmt.Println("\n--- 負の数に対する Not() ---")
// 負の数に対する Not() の例
y := new(big.Int)
y.SetString("-10", 10) // 10進数の-10 (バイナリ: ...11110110)
fmt.Printf("元の値 y: %s (バイナリ: %s)\n", y.String(), y.Text(2))
result.Not(y) // y のビットを反転させた結果を result に格納
// -10 のビット反転は 9 になります。
// -10 (11110110) -> 9 (00001001) ※2の補数表現
fmt.Printf("Not(y) の結果: %s (バイナリ: %s)\n", result.String(), result.Text(2))
}
解説
x.Text(2):big.Intの値を指定された基数（この場合は2進数）の文字列として返します。負の数の場合、2の補数表現そのものではなく、先頭に-が付いた形で出力されます。x.String():big.Intの値を文字列として返します。result.Not(x):xのビットごとの論理否定を実行し、その結果をresultに格納します。メソッドはレシーバー（この場合はresult）に結果を書き込みます。x.SetString("5", 10):xというbig.Intインスタンスに、文字列"5"を10進数として設定します。new(big.Int):big.Int型の新しいインスタンスへのポインタを生成します。big.Intは構造体なので、ポインタとして扱うのがGo言語での慣習です。
メソッドチェーンと自己上書き
big.Intのメソッドは、通常レシーバー自身（z）を返すため、メソッドチェーンが可能です。また、引数とレシーバーが同じインスタンスでも問題なく動作します（自己上書き）。
package main
import (
"fmt"
"math/big"
)
func main() {
fmt.Println("\n--- メソッドチェーンと自己上書き ---")
// 1. 自己上書きの例
a := big.NewInt(100) // 100 を持つ big.Int を作成
fmt.Printf("元の値 a: %s\n", a.String())
a.Not(a) // a 自身のビットを反転させ、その結果を a に格納する
fmt.Printf("a.Not(a) の結果: %s\n", a.String()) // Not(100) = -101
// 2. メソッドチェーンの例 (Not() だけでチェーンすることはあまりないが、他の演算と組み合わせる場合)
b := big.NewInt(10)
c := big.NewInt(20)
d := big.NewInt(0)
// 例えば、d = Not(b) + c のようにしたい場合
// Not() の結果を一時変数に格納してから Add するのが一般的ですが、
// 概念としては d.Not(b).Add(d, c) のようには書けません。（Addは引数dも必要なので）
// 正しいチェーンの例としては、例えば複数のビット演算を組み合わせる場合などです。
// d.Not(b)の結果はdに格納され、そのdを使って別の演算を続けることができます。
fmt.Printf("元の値 b: %s, c: %s\n", b.String(), c.String())
d.Not(b) // d は -11 になる
d.Add(d, c) // d = d + c = -11 + 20 = 9
fmt.Printf("Not(b) の結果を d に格納し、その d に c を足した結果: %s\n", d.String())
}
解説
- メソッドチェーン:
d.Not(b).Add(d, c)のような直接的なチェーンは、Addがdを再度引数として必要とするため、この場合はできません。しかし、Not()を実行した結果がdに格納されているため、そのdを使って次の演算を続けることができます。 a.Not(a):aのビットを反転させ、その結果を再びaに格納します。これは非常に一般的なパターンで、一時変数を使わずに値を更新したい場合に便利です。big.NewInt(100):new(big.Int)で初期化する代わりに、指定されたint64の値を持つbig.Intの新しいインスタンスを生成して返します。これは便利です。
固定ビット長でのビット反転（応用）
big.Int.Not()は2の補数表現でビット反転を行うため、数学的には-(x+1)と等価になります。しかし、特定のビット長（例: 8ビット、32ビット）で純粋なビット反転を行いたい場合、つまり最上位ビットを符号ビットと見なさずにすべてのビットを反転させたい場合は、Not()だけでは不十分です。この場合は、XOR演算（Xor()）と適切なマスク値を使用します。
package main
import (
"fmt"
"math/big"
)
func main() {
fmt.Println("\n--- 固定ビット長でのビット反転 ---")
val := big.NewInt(5) // 10進数の5 (バイナリ: ...00000101)
fmt.Printf("元の値 val: %s (バイナリ: %s)\n", val.String(), val.Text(2))
// big.Int.Not() を使う場合
notResult := new(big.Int)
notResult.Not(val)
fmt.Printf("big.Int.Not() の結果: %s (バイナリ: %s)\n", notResult.String(), notResult.Text(2)) // -6
// 例: 8ビットでのビット反転を行いたい場合
// 8ビットのマスク (0xFF = 255)
mask8bit := big.NewInt(0xFF) // バイナリ: 11111111
// まず、元の値を8ビットにクリップ（マスク）する
clippedVal := new(big.Int).And(val, mask8bit) // 5 & 255 = 5 (00000101)
fmt.Printf("8ビットにクリップした値: %s (バイナリ: %s)\n", clippedVal.String(), clippedVal.Text(2))
// クリップした値とマスク値で XOR 演算を行う
// これにより、指定したビット長内での純粋なビット反転が実現されます
pureNot8bit := new(big.Int).Xor(clippedVal, mask8bit) // 5 ^ 255 = 250
// 00000101 (5)
// XOR
// 11111111 (255)
// = 11111010 (250)
fmt.Printf("8ビットでの純粋なビット反転の結果: %s (バイナリ: %s)\n", pureNot8bit.String(), pureNot8bit.Text(2))
// 例: 32ビットでのビット反転を行いたい場合
mask32bit := big.NewInt(0xFFFFFFFF) // 2^32 - 1
clippedVal32 := new(big.Int).And(val, mask32bit)
pureNot32bit := new(big.Int).Xor(clippedVal32, mask32bit)
fmt.Printf("32ビットでの純粋なビット反転の結果: %s (バイナリ: %s)\n", pureNot32bit.String(), pureNot32bit.Text(2))
}
pureNot8bit := new(big.Int).Xor(clippedVal, mask8bit):Xor()メソッドはビットごとの排他的論理和（XOR演算）を実行します。あるビットと1をXORするとそのビットは反転し、0をXORするとそのビットは変化しないため、これによって指定したビット長内での純粋なビット反転が実現されます。clippedVal := new(big.Int).And(val, mask8bit):And()メソッドはビットごとの論理積（AND演算）を実行します。これにより、valの上位ビットをゼロにし、下位8ビットだけを残します。mask8bit := big.NewInt(0xFF): 8ビットのすべてのビットが1であるマスクを作成します。0xFFは16進数で、10進数では255です。
-(x + 1) による直接的な計算
最も直接的な代替方法は、Not(x)の定義である-(x + 1)をそのまま計算することです。これはNot()メソッドの内部実装に近い動作をします。
package main
import (
"fmt"
"math/big"
)
func main() {
fmt.Println("--- 代替方法 1: -(x + 1) による計算 ---")
x := big.NewInt(5) // 10進数の5
fmt.Printf("元の値 x: %s\n", x.String())
// big.Int.Not() を使った場合
resultNot := new(big.Int)
resultNot.Not(x)
fmt.Printf("big.Int.Not(%s) の結果: %s\n", x.String(), resultNot.String()) // -6
// 代替方法: -(x + 1) を計算
one := big.NewInt(1)
temp := new(big.Int)
alternativeResult := new(big.Int)
temp.Add(x, one) // x + 1 を計算
alternativeResult.Neg(temp) // -(x + 1) を計算 (Neg は負数を取るメソッド)
fmt.Printf("-(%s + 1) の結果: %s\n", x.String(), alternativeResult.String()) // -6
// 負の数で確認
y := big.NewInt(-10)
fmt.Printf("\n元の値 y: %s\n", y.String())
resultNot.Not(y)
fmt.Printf("big.Int.Not(%s) の結果: %s\n", y.String(), resultNot.String()) // 9
temp.Add(y, one)
alternativeResult.Neg(temp)
fmt.Printf("-(%s + 1) の結果: %s\n", y.String(), alternativeResult.String()) // 9
}
解説
alternativeResult.Neg(temp):tempの符号を反転させます。Negメソッドは、レシーバー（alternativeResult）に結果を格納します。 この方法は、Not()メソッドが提供する正確なビット反転ロジックを理解するための良い演習にもなります。temp.Add(x, one):xに1を足します。big.IntのAddメソッドは、レシーバー（temp）に結果を格納します。
固定ビット長でのビット反転（XOR 演算とマスク）
前回の説明でも触れましたが、これは「純粋なビット反転」を目的とした場合の重要な代替方法です。big.Int.Not()が2の補数表現に基づいているのに対し、特定のビット幅で上位ビットを考慮せずにビットを反転させたい場合に用います。
package main
import (
"fmt"
"math/big"
)
func main() {
fmt.Println("\n--- 代替方法 2: 固定ビット長でのビット反転 (XORとマスク) ---")
val := big.NewInt(5) // 10進数の5 (バイナリ: ...00000101)
fmt.Printf("元の値 val: %s (バイナリ: %s)\n", val.String(), val.Text(2))
// 例: 8ビットでの純粋なビット反転
mask8bit := big.NewInt(0xFF) // 8ビットすべてが1 (11111111)
// 1. まず値を指定ビット長にクリップ（マスク）する
clippedVal := new(big.Int).And(val, mask8bit) // 5 (00000101)
fmt.Printf("8ビットにクリップした値: %s (バイナリ: %s)\n", clippedVal.String(), clippedVal.Text(2))
// 2. クリップした値とマスク値でXOR演算を行う
pureNot8bit := new(big.Int).Xor(clippedVal, mask8bit)
// 00000101 XOR 11111111 = 11111010 (250)
fmt.Printf("8ビットでの純粋なビット反転の結果: %s (バイナリ: %s)\n", pureNot8bit.String(), pureNot8bit.Text(2))
// 例: 32ビットでの純粋なビット反転
mask32bit := big.NewInt(0xFFFFFFFF) // 32ビットすべてが1
clippedVal32 := new(big.Int).And(val, mask32bit)
pureNot32bit := new(big.Int).Xor(clippedVal32, mask32bit)
fmt.Printf("32ビットでの純粋なビット反転の結果: %s (バイナリ: %s)\n", pureNot32bit.String(), pureNot32bit.Text(2))
// 負の数に適用する場合 (内部的には2の補数表現だが、特定ビット幅でビット反転)
negVal := big.NewInt(-5) // バイナリ: ...11111011
fmt.Printf("\n元の値 negVal: %s (バイナリ: %s)\n", negVal.String(), negVal.Text(2))
// 8ビットにクリップ (下位8ビットは 11111011)
clippedNegVal8 := new(big.Int).And(negVal, mask8bit)
// clippedNegVal8 は 251 となる（2の補数から正の数と解釈されるため）
// (0xFFFFFFFB AND 0xFF) = 0xFB = 251
fmt.Printf("8ビットにクリップした負の値: %s (バイナリ: %s)\n", clippedNegVal8.String(), clippedNegVal8.Text(2))
pureNotNeg8bit := new(big.Int).Xor(clippedNegVal8, mask8bit)
// 11111011 XOR 11111111 = 00000100 (4)
fmt.Printf("8ビットでの純粋なビット反転 (負の値) の結果: %s (バイナリ: %s)\n", pureNotNeg8bit.String(), pureNotNeg8bit.Text(2))
}
解説
- XOR演算 (Xor())
val.Xor(clippedVal, mask)は、クリップされた数値とマスクのビットごとの排他的論理和を取ります。XOR演算の特性として、「1」とXORするとビットが反転し、「0」とXORするとビットは変化しないため、マスクの「1」の場所のビットが反転します。 - AND演算 (And())
val.And(val, mask)は、valとmaskのビットごとの論理積を取ります。これにより、maskで指定されたビット以外のビットはすべてゼロになります。これは、指定したビット幅に数値を「切り詰める」効果があります。 - マスクの作成
0xFF(8ビット),0xFFFFFFFF(32ビット) のように、特定のビット長に対応するすべてのビットが1であるbig.Intマスクを作成します。
この方法は、暗号化、データフォーマット、ビットマップ操作など、特定のビット長での厳密なビット操作が必要な場合に特に有用です。
SetBit() を用いた手動でのビット反転（特定のケース）
big.Intの各ビットを個別に操作したい場合、SetBit()メソッドを使用できます。これはNot()の直接的な代替というよりは、より低レベルでのビット操作が必要な場合の手段です。
package main
import (
"fmt"
"math/big"
)
func main() {
fmt.Println("\n--- 代替方法 3: SetBit() を用いた手動でのビット反転 (特定のケース) ---")
x := big.NewInt(5) // 10進数の5 (バイナリ: ...00000101)
fmt.Printf("元の値 x: %s (バイナリ: %s)\n", x.String(), x.Text(2))
// 各ビットを反転させる (あくまで例であり、Not()の完全な代替ではない)
// 例えば、下位3ビットだけを反転させたい場合
manualNot := new(big.Int).Set(x) // x のコピーを作成
// 0ビット目を反転 (1 -> 0)
// manualNot.Bit(0) は 1 なので、0 に設定
manualNot.SetBit(manualNot, 0, 0)
// 1ビット目を反転 (0 -> 1)
// manualNot.Bit(1) は 0 なので、1 に設定
manualNot.SetBit(manualNot, 1, 1)
// 2ビット目を反転 (1 -> 0)
// manualNot.Bit(2) は 1 なので、0 に設定
manualNot.SetBit(manualNot, 2, 0)
fmt.Printf("手動ビット反転 (下位3ビット) の結果: %s (バイナリ: %s)\n", manualNot.String(), manualNot.Text(2))
// 5 (00000101) の下位3ビット反転 -> 00000010 (2)
}
解説
manualNot.Bit(i int):i番目のビットの値（0または1）を返します。manualNot.SetBit(i *big.Int, i int, val uint):i番目のビットをval（0または1）に設定します。manualNot := new(big.Int).Set(x): 元の値を変更しないために、xのコピーを作成します。
この方法は、Not()のようにすべてのビットを反転させるのには適していませんが、特定のビットのみを操作したい場合や、複雑なビットパターンを構築する際に役立ちます。
big.Int.Not()の代替方法は、その目的によって異なります。
- Not()と全く同じ数学的結果 (-(x + 1)) を求める場合
Add()とNeg()を組み合わせるのが直接的な代替です。 - 特定のビット長で純粋なビット反転を行いたい場合
And()とXor()をマスク値と組み合わせて使用するのが標準的な方法です。 - 個々のビットを細かく制御したい場合
SetBit()やBit()メソッドを使用します。