Go言語プログラミング：big.Int.CmpAbs() の代替方法と使い分け

2025-06-01

big.Int.CmpAbs() は、Go の math/big パッケージで提供されている、任意精度の整数型である big.Int のメソッドの一つです。このメソッドは、二つの big.Int 型の絶対値の大きさを比較するために使用されます。

具体的には、レシーバー（メソッドを呼び出す側の big.Int）の絶対値と、引数として渡された big.Int の絶対値を比較し、その結果を整数値で返します。

返される値は以下のいずれかになります。

1
レシーバーの絶対値が引数の絶対値よりも大きい場合
0
レシーバーの絶対値と引数の絶対値が等しい場合
-1
レシーバーの絶対値が引数の絶対値よりも小さい場合

重要な点は、CmpAbs() は元の big.Int の符号（正の数か負の数か）を無視し、絶対値のみを比較するという点です。

例

package main

import (
	"fmt"
	"math/big"
)

func main() {
	a := big.NewInt(-10)
	b := big.NewInt(5)
	c := big.NewInt(10)

	fmt.Println(a.CmpAbs(b)) // 出力: 1 (|-10| > |5|)
	fmt.Println(a.CmpAbs(c)) // 出力: 0 (|-10| == |10|)
	fmt.Println(b.CmpAbs(c)) // 出力: -1 (|5| < |10|)
}

この例では、a は -10、b は 5、c は 10 という値を持っています。

b.CmpAbs(c) は、|5| と |10| を比較し、5 < 10 なので -1 を返します。
a.CmpAbs(c) は、|-10| と |10| を比較し、10 == 10 なので 0 を返します。
a.CmpAbs(b) は、|-10| と |5| を比較し、10 > 5 なので 1 を返します。

nil レシーバーまたは引数

エラー
big.Int 型の変数が初期化されずに nil の状態で CmpAbs() を呼び出したり、引数として nil を渡したりすると、ランタイムパニックが発生します。
トラブルシューティング
- big.NewInt() などを使って big.Int 型の変数を適切に初期化してから CmpAbs() を呼び出すようにしてください。
- 関数に big.Int 型の引数を取る場合は、関数内で nil チェックを行うなど、引数が有効であることを確認してください。

package main

import (
    "fmt"
    "math/big"
)

func main() {
    var a *big.Int // 初期化されていない (nil)
    b := big.NewInt(5)

    // エラー: nil レシーバーに対してメソッド呼び出しが発生
    // fmt.Println(a.CmpAbs(b))

    if a != nil && b != nil {
        fmt.Println(a.CmpAbs(b))
    } else {
        fmt.Println("a または b が nil です")
    }

    c := big.NewInt(10)
    var d *big.Int // 初期化されていない (nil)

    // エラー: nil の引数を渡している
    // fmt.Println(c.CmpAbs(d))

    if d != nil {
        fmt.Println(c.CmpAbs(d))
    } else {
        fmt.Println("d が nil です")
    }
}

比較ロジックの誤り

エラー
CmpAbs() の戻り値 (-1, 0, 1) の意味を正しく理解していないために、比較結果に基づいた処理が意図通りに動作しないことがあります。
トラブルシューティング
- CmpAbs() の戻り値の意味を再確認し、比較したい条件に合わせて正しく処理を記述してください。例えば、「絶対値が等しい」ことを判定したい場合は戻り値が 0 であることを確認します。

package main

import (
    "fmt"
    "math/big"
)

func main() {
    a := big.NewInt(-10)
    b := big.NewInt(10)

    // 間違った比較: 絶対値が等しい場合に "greater" と表示してしまう
    if a.CmpAbs(b) > 0 {
        fmt.Println("絶対値で a は b より大きい")
    } else if a.CmpAbs(b) < 0 {
        fmt.Println("絶対値で a は b より小さい")
    } else {
        fmt.Println("絶対値で a と b は等しい") // 正しい出力
    }

    // 正しい比較
    if a.CmpAbs(b) == 1 {
        fmt.Println("絶対値で a は b より大きい")
    } else if a.CmpAbs(b) == -1 {
        fmt.Println("絶対値で a は b より小さい")
    } else if a.CmpAbs(b) == 0 {
        fmt.Println("絶対値で a と b は等しい")
    }
}

符号付き比較との混同
- エラー
  絶対値比較 (CmpAbs()) を行いたいのに、誤って符号付きの比較メソッド (Cmp()) を使用してしまうことがあります。
- トラブルシューティング
  - 絶対値のみを比較したい場合は、必ず CmpAbs() を使用してください。符号を含めた比較を行いたい場合は Cmp() を使用します。
```
package main

import (
    "fmt"
    "math/big"
)

func main() {
    a := big.NewInt(-10)
    b := big.NewInt(5)

    // 符号付き比較: -10 は 5 より小さい
    fmt.Println(a.Cmp(b)) // 出力: -1

    // 絶対値比較: |-10| は |5| より大きい
    fmt.Println(a.CmpAbs(b)) // 出力: 1
}
```

型の間違い

エラー
CmpAbs() は big.Int 型のメソッドなので、他の数値型（int, float64 など）に対して直接呼び出すことはできません。
トラブルシューティング
- 比較したい数値が big.Int 型でない場合は、big.NewInt() などを使って big.Int 型に変換してから CmpAbs() を使用してください。

package main

import (
    "fmt"
    "math/big"
)

func main() {
    a := -10 // int 型
    b := big.NewInt(5)

    // エラー: int 型には CmpAbs() メソッドはありません
    // fmt.Println(a.CmpAbs(b))

    bigA := big.NewInt(int64(a)) // int を big.Int に変換
    fmt.Println(bigA.CmpAbs(b))   // 正しい使用方法
}

基本的な比較

package main

import (
	"fmt"
	"math/big"
)

func main() {
	a := big.NewInt(-100)
	b := big.NewInt(50)
	c := big.NewInt(100)

	fmt.Printf("a (%s) の絶対値と b (%s) の絶対値を比較: %d\n", a.String(), b.String(), a.CmpAbs(b)) // 出力: 1 (|-100| > |50|)
	fmt.Printf("a (%s) の絶対値と c (%s) の絶対値を比較: %d\n", a.String(), c.String(), a.CmpAbs(c)) // 出力: 0 (|-100| == |100|)
	fmt.Printf("b (%s) の絶対値と c (%s) の絶対値を比較: %d\n", b.String(), c.String(), b.CmpAbs(c)) // 出力: -1 (|50| < |100|)
}

この例では、異なる符号と大きさを持つ三つの big.Int を作成し、CmpAbs() を使ってそれぞれの絶対値を比較しています。出力結果から、符号は無視され、絶対値の大小関係に基づいて -1、0、1 が返されていることがわかります。

条件分岐での利用

package main

import (
	"fmt"
	"math/big"
)

func main() {
	x := big.NewInt(-500)
	y := big.NewInt(500)
	z := big.NewInt(1000)

	if x.CmpAbs(y) == 0 {
		fmt.Printf("%s の絶対値と %s の絶対値は等しい\n", x.String(), y.String())
	} else {
		fmt.Printf("%s の絶対値と %s の絶対値は異なる\n", x.String(), y.String())
	}

	if z.CmpAbs(x) > 0 {
		fmt.Printf("%s の絶対値は %s の絶対値より大きい\n", z.String(), x.String())
	} else {
		fmt.Printf("%s の絶対値は %s の絶対値以下である\n", z.String(), x.String())
	}
}

この例では、CmpAbs() の結果を if 文の条件として使用しています。絶対値が等しいかどうか、どちらの絶対値が大きいかによって異なる処理を実行することができます。

関数の引数としての利用

package main

import (
	"fmt"
	"math/big"
)

func compareAbs(n1, n2 *big.Int) string {
	result := n1.CmpAbs(n2)
	if result > 0 {
		return fmt.Sprintf("%s の絶対値は %s の絶対値より大きい", n1.String(), n2.String())
	} else if result < 0 {
		return fmt.Sprintf("%s の絶対値は %s の絶対値より小さい", n1.String(), n2.String())
	} else {
		return fmt.Sprintf("%s の絶対値と %s の絶対値は等しい", n1.String(), n2.String())
	}
}

func main() {
	num1 := big.NewInt(-200)
	num2 := big.NewInt(150)
	num3 := big.NewInt(200)

	fmt.Println(compareAbs(num1, num2)) // 出力: -200 の絶対値は 150 の絶対値より大きい
	fmt.Println(compareAbs(num1, num3)) // 出力: -200 の絶対値と 200 の絶対値は等しい
	fmt.Println(compareAbs(num2, num3)) // 出力: 150 の絶対値は 200 の絶対値より小さい
}

ここでは、二つの big.Int 型の引数を受け取り、それらの絶対値を CmpAbs() で比較して結果を文字列で返す compareAbs 関数を定義しています。

ソートへの応用 (絶対値に基づくソート)

package main

import (
	"fmt"
	"math/big"
	"sort"
)

type ByAbs []*big.Int

func (a ByAbs) Len() int           { return len(a) }
func (a ByAbs) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
func (a ByAbs) Less(i, j int) bool { return a[i].CmpAbs(a[j]) < 0 }

func main() {
	numbers := []*big.Int{
		big.NewInt(-30),
		big.NewInt(15),
		big.NewInt(-5),
		big.NewInt(25),
		big.NewInt(0),
	}

	sort.Sort(ByAbs(numbers))
	fmt.Println("絶対値でソート:", numbers) // 出力: 絶対値でソート: [-5 0 15 25 -30]
}

この例では、sort パッケージを使って big.Int のスライスを絶対値の昇順にソートしています。ByAbs というカスタム型を定義し、その Less メソッドの中で CmpAbs() を使用して比較を行っています。

package main

import (
	"fmt"
	"math/big"
)

func main() {
	largeNum1, ok := new(big.Int).SetString("123456789012345678901234567890", 10)
	if !ok {
		fmt.Println("largeNum1 の設定に失敗")
		return
	}

	largeNum2, ok := new(big.Int).SetString("-987654321098765432109876543210", 10)
	if !ok {
		fmt.Println("largeNum2 の設定に失敗")
		return
	}

	result := largeNum1.CmpAbs(largeNum2)
	if result > 0 {
		fmt.Println(largeNum1, "の絶対値は", largeNum2, "の絶対値より大きい")
	} else if result < 0 {
		fmt.Println(largeNum1, "の絶対値は", largeNum2, "の絶対値より小さい")
	} else {
		fmt.Println(largeNum1, "の絶対値と", largeNum2, "の絶対値は等しい")
	}
}

Abs() メソッドと Cmp() メソッドの組み合わせ

big.Int 型には、自身の絶対値を新しい big.Int として返す Abs() メソッドと、二つの big.Int を符号付きで比較する Cmp() メソッドがあります。これらを組み合わせることで、絶対値の比較と同じ結果を得ることができます。

package main

import (
	"fmt"
	"math/big"
)

func compareAbsAlternative(n1, n2 *big.Int) int {
	absN1 := new(big.Int).Abs(n1)
	absN2 := new(big.Int).Abs(n2)
	return absN1.Cmp(absN2)
}

func main() {
	a := big.NewInt(-75)
	b := big.NewInt(50)
	c := big.NewInt(75)

	fmt.Println(compareAbsAlternative(a, b)) // 出力: 1 (|-75| > |50|)
	fmt.Println(compareAbsAlternative(a, c)) // 出力: 0 (|-75| == |75|)
	fmt.Println(compareAbsAlternative(b, c)) // 出力: -1 (|50| < |75|)
}

この方法では、まず Abs() を使って二つの big.Int の絶対値をそれぞれ計算し、その結果を Cmp() で比較しています。Cmp() は符号付きの比較を行いますが、絶対値同士を比較しているため、CmpAbs() と同じ結果が得られます。

利点

絶対値そのものが必要な他の処理と組み合わせやすいことがあります。
Abs() メソッドの結果を再利用できる場合があります。

欠点

一時的に二つの big.Int オブジェクト（絶対値）を生成するため、わずかにメモリと計算コストが増加する可能性があります。

符号を考慮した比較

絶対値の比較は、結局のところ数値の大きさの比較です。符号を考慮しながら、絶対値の大小関係を判定することも可能です。例えば、二つの数 a と b があるとき、 ∣a∣>∣b∣ である条件は、以下のように場合分けできます。

a<0 かつ b<0 の場合: −a>−b (つまり a<b)
a<0 かつ b≥0 の場合: 常に ∣a∣>∣b∣ (−a>b)
a≥0 かつ b<0 の場合: 常に ∣a∣>∣b∣ (a>−b)
a≥0 かつ b≥0 の場合: a>b

これを big.Int のメソッド (Sign(), Cmp()) を使って実装できます。

package main

import (
	"fmt"
	"math/big"
)

func compareAbsBySign(n1, n2 *big.Int) int {
	sign1 := n1.Sign()
	sign2 := n2.Sign()

	if sign1 == 0 && sign2 == 0 {
		return 0
	} else if sign1 == 0 {
		if sign2 < 0 {
			return 1
		} else {
			return -1
		}
	} else if sign2 == 0 {
		if sign1 < 0 {
			return -1
		} else {
			return 1
		}
	} else if sign1 >= 0 && sign2 >= 0 {
		return n1.Cmp(n2)
	} else if sign1 >= 0 && sign2 < 0 {
		return 1
	} else if sign1 < 0 && sign2 >= 0 {
		return -1
	} else { // sign1 < 0 && sign2 < 0
		return n2.Cmp(n1) // 符号が負の場合は絶対値が大きいほど数値は小さい
	}
}

func main() {
	a := big.NewInt(-75)
	b := big.NewInt(50)
	c := big.NewInt(75)
	d := big.NewInt(-100)
	e := big.NewInt(-75)
	zero := big.NewInt(0)

	fmt.Println(compareAbsBySign(a, b))   // 出力: 1
	fmt.Println(compareAbsBySign(a, c))   // 出力: 0
	fmt.Println(compareAbsBySign(b, c))   // 出力: -1
	fmt.Println(compareAbsBySign(a, d))   // 出力: -1
	fmt.Println(compareAbsBySign(a, e))   // 出力: 0
	fmt.Println(compareAbsBySign(a, zero)) // 出力: 1
	fmt.Println(compareAbsBySign(zero, b)) // 出力: -1
}

この方法は、Sign() メソッドで符号を取得し、Cmp() メソッドで数値そのものを比較することで絶対値の大小を判定しています。場合分けが少し複雑になります。

利点

追加の big.Int オブジェクトの生成を避けられるため、わずかに効率が良い可能性があります。

欠点

可読性が CmpAbs() を直接使用する場合に比べて劣る可能性があります。
ロジックが複雑になり、実装や理解が難しくなる可能性があります。

どちらの方法を選ぶべきか

一般的には、big.Int.CmpAbs() を直接使用するのが最も推奨される方法です。その理由は以下の通りです。

安全性
間違いが起こりにくいです。
簡潔性
実装がシンプルで、コードの行数が少なくなります。
明確性
絶対値の比較という意図がコードから直接伝わります。

代替案は、特定の状況下（例えば、パフォーマンスが極めて重要で、一時オブジェクトの生成を避けたい場合など）で検討されるかもしれませんが、通常はその利点よりも可読性や保守性の低下という欠点が大きくなることが多いです。