【Go言語】big.Float.Cmp()で知っておくべき注意点とエラー対策

2025-06-01

`Float.Cmp()`とは何か？

Float.Cmp(y *Float)メソッドは、レシーバーであるFloat型（xとします）と引数yを比較し、その結果を整数で返します。

戻り値の意味は以下の通りです。

x > y の場合: +1
x == y の場合: 0
x < y の場合: -1

この比較は、一般的な数値の大小関係に基づいています。

なぜ`Float.Cmp()`が必要なのか？

Go言語の組み込み型（float64など）では、通常の比較演算子（<, ==, >）を使って数値を比較できます。しかし、math/big.FloatはGoの組み込み型ではなく、任意精度を扱うためのカスタム型です。そのため、直接比較演算子を使うことはできません。

big.Floatは、浮動小数点計算で発生する可能性のある丸め誤差を最小限に抑えたい場合や、非常に大きな（または非常に小さな）数値を正確に扱いたい場合に使用されます。金融計算や科学技術計算など、高い精度が求められる場面で特に役立ちます。

`Float.Cmp()`の使用例

package main

import (
	"fmt"
	"math/big"
)

func main() {
	// 2つの多倍長浮動小数点数を作成
	f1 := new(big.Float).SetFloat64(0.1)
	f2 := new(big.Float).SetFloat64(0.2)
	f3 := new(big.Float).SetFloat64(0.1)

	// f1 と f2 を比較
	cmp1 := f1.Cmp(f2)
	fmt.Printf("f1 (%v) と f2 (%v) の比較結果: %d\n", f1, f2, cmp1) // 出力: -1 (f1 < f2)

	// f1 と f3 を比較
	cmp2 := f1.Cmp(f3)
	fmt.Printf("f1 (%v) と f3 (%v) の比較結果: %d\n", f1, f3, cmp2) // 出力: 0 (f1 == f3)

	// f2 と f1 を比較
	cmp3 := f2.Cmp(f1)
	fmt.Printf("f2 (%v) と f1 (%v) の比較結果: %d\n", f2, f1, cmp3) // 出力: 1 (f2 > f1)

	// より複雑な数値の比較
	f4 := new(big.Float).SetString("12345678901234567890.12345")
	f5 := new(big.Float).SetString("12345678901234567890.12346")

	cmp4 := f4.Cmp(f5)
	fmt.Printf("f4 (%v) と f5 (%v) の比較結果: %d\n", f4, f5, cmp4) // 出力: -1 (f4 < f5)
}

big.FloatはNaN（Not a Number）や無限大（Inf）も表現できます。Cmp()メソッドはこれらの特殊な値についても適切な比較結果を返します。

無限大の比較
- 正の無限大は、有限の数値や負の無限大よりも大きいと判断されます。
- 負の無限大は、有限の数値や正の無限大よりも小さいと判断されます。
NaNの比較
- NaNは他の数値と比較すると、常に「順序なし」とみなされます。Goのmath/bigパッケージのドキュメントによると、x.Cmp(y)において、xがNaNでyがNaNでない場合、-1を返します。xがNaNでyもNaNの場合は0を返します。yがNaNでxがNaNでない場合は+1を返します。
- これはIEEE 754浮動小数点標準の動作とは若干異なる場合があります。IEEE 754では、NaN同士の比較は常にfalseを返します。しかし、big.Float.Cmp()はNaNの順序を定義しており、一貫した比較結果を提供します。

浮動小数点数の精度の問題（特にfloat64からの変換時）

これはbig.Float.Cmp()に限らず、浮動小数点数全般に言える最も重要な注意点です。

よくある誤り
float64で表現された小数をbig.Floatに変換し、文字列から変換したbig.Floatと比較すると、等しくならないことがあります。これは、多くの小数がfloat64では正確に表現できないためです。

例

package main

import (
	"fmt"
	"math/big"
)

func main() {
	// 0.1 を float64 から big.Float に変換
	f64_val := 0.1
	bf_from_f64 := new(big.Float).SetFloat64(f64_val)

	// 0.1 を文字列から big.Float に変換
	bf_from_str, _, err := new(big.Float).Parse("0.1", 10)
	if err != nil {
		fmt.Println("Parse error:", err)
		return
	}

	fmt.Printf("float64から: %v (精度: %d)\n", bf_from_f64, bf_from_f64.Prec())
	fmt.Printf("文字列から: %v (精度: %d)\n", bf_from_str, bf_from_str.Prec())

	// 比較
	cmp_result := bf_from_f64.Cmp(bf_from_str)
	fmt.Printf("比較結果 (bf_from_f64 vs bf_from_str): %d\n", cmp_result)

	if cmp_result == 0 {
		fmt.Println("2つの値は等しいです。")
	} else {
		fmt.Println("2つの値は異なります。") // このケースでは「異なります」と出力される可能性が高い
	}
}

トラブルシューティング

許容誤差を考慮した比較
厳密な等価性ではなく、ある程度の許容誤差（ε）範囲内での比較が必要な場合は、x.Sub(y).Abs().Cmp(epsilon) < 0のようなロジックを使用します。
同じ精度で比較する
big.Floatは任意の精度を持つため、異なる精度で生成された2つのbig.Floatを比較する場合、見かけ上同じ値でも内部表現が異なるためにCmp()が異なる結果を返すことがあります。比較する前に、両方のbig.FloatにSetPrec()で同じ精度を設定することを検討してください。ただし、SetPrec()は既存の値を丸める可能性があるため注意が必要です。
文字列からの初期化を優先する
可能な限り、数値をstringとして渡し、big.Float.Parse()またはbig.Float.SetString()でbig.Floatを初期化します。これにより、丸め誤差なしに正確な値を表現できます。

ポインタの比較と値の比較の混同

これはbig.Float.Cmp()自体が原因というよりは、Goのポインタと値の比較に関する一般的な誤りです。

よくある誤り
big.Floatは構造体ですが、通常はポインタ（*big.Float）として扱われます。初心者が誤ってポインタの比較演算子==を使ってしまうことがあります。

package main

import (
	"fmt"
	"math/big"
)

func main() {
	f1 := new(big.Float).SetFloat64(1.0)
	f2 := new(big.Float).SetFloat64(1.0)

	// これはポインタのアドレスを比較します。
	if f1 == f2 {
		fmt.Println("f1 と f2 は同じポインタです。")
	} else {
		fmt.Println("f1 と f2 は異なるポインタです。") // 通常はこちらが出力される
	}

	// これが正しい値の比較です。
	if f1.Cmp(f2) == 0 {
		fmt.Println("f1 と f2 の値は等しいです。") // こちらが出力される
	} else {
		fmt.Println("f1 と f2 の値は異なります。")
	}
}

トラブルシューティング

常にFloat.Cmp()を使用する
*big.Float型の変数を比較する際は、常にf1.Cmp(f2)メソッドを使用してください。ポインタの等価性（メモリ上のアドレスが同じか）をチェックしたい場合を除き、==は使用しないでください。

NaN（非数）と無限大の比較挙動の理解不足

big.FloatはNaNや無限大も表現できますが、これらの特殊な値の比較挙動は直感的でない場合があります。

よくある誤り
big.FloatのNaN同士の比較や、NaNと他の数値の比較が、期待通りの結果を返さないと誤解すること。

例

package main

import (
	"fmt"
	"math/big"
)

func main() {
	nan1 := new(big.Float).SetNaN()
	nan2 := new(big.Float).SetNaN()
	f := new(big.Float).SetFloat64(1.0)
	infPos := new(big.Float).SetInf(false) // +Inf
	infNeg := new(big.Float).SetInf(true)  // -Inf

	fmt.Printf("nan1.Cmp(nan2): %d\n", nan1.Cmp(nan2)) // 0 (big.FloatではNaN同士は等しいとみなされる)
	fmt.Printf("nan1.Cmp(f): %d\n", nan1.Cmp(f))     // -1 (nan1はfより小さいとみなされる)
	fmt.Printf("f.Cmp(nan1): %d\n", f.Cmp(nan1))     // 1 (fはnan1より大きいとみなされる)

	fmt.Printf("infPos.Cmp(f): %d\n", infPos.Cmp(f)) // 1
	fmt.Printf("infNeg.Cmp(f): %d\n", infNeg.Cmp(f)) // -1
	fmt.Printf("infPos.Cmp(infNeg): %d\n", infPos.Cmp(infNeg)) // 1
}

トラブルシューティング

IsNaN()やIsInf()の利用
比較を行う前に、IsNaN()やIsInf()メソッドを使って、値が特殊な値であるかをチェックし、それに応じた処理を行うことを検討してください。
ドキュメントの確認
math/bigパッケージのドキュメントを読み、NaNと無限大の比較挙動を正確に理解しておくことが重要です。

big.Floatは任意精度を扱いますが、演算によってその精度が変わることがあります。これが比較に影響を与える可能性があります。

よくある誤り
計算結果のbig.Floatの精度が、比較対象のbig.Floatの精度と異なり、予期せぬ比較結果になること。

例

package main

import (
	"fmt"
	"math/big"
)

func main() {
	f1 := new(big.Float).SetPrec(64).SetFloat64(1.0 / 3.0) // 精度64ビット
	f2 := new(big.Float).SetPrec(128).SetFloat64(1.0 / 3.0) // 精度128ビット

	fmt.Printf("f1: %v (精度: %d)\n", f1, f1.Prec())
	fmt.Printf("f2: %v (精度: %d)\n", f2, f2.Prec())

	// この場合、float64の限界で両方とも同じ値に丸められるため、Cmpは0を返す可能性が高いですが、
	// より複雑な演算や異なる初期化方法では、精度の違いが結果に影響を与えることがあります。
	cmp_result := f1.Cmp(f2)
	fmt.Printf("比較結果 (f1 vs f2): %d\n", cmp_result) // 環境によっては0以外を返す可能性もある
}

トラブルシューティング

比較前に精度を統一する
厳密な比較が必要な場合は、比較対象のすべてのbig.FloatにSetPrec()を適用して、同じ精度に揃えてからCmp()を使用することを検討してください。ただし、上述の通りSetPrec()による丸めには注意が必要です。
演算結果の精度を明示的に設定する
演算を行う際にSetPrec()や、Add()などの演算メソッドのレシーバーに希望の精度を設定したbig.Floatを使用することで、結果の精度を制御できます。

big.Float.Cmp()を使う際の主な問題は、通常のfloat64とは異なるbig.Floatの「任意精度」という特性と、浮動小数点数特有の丸め誤差や特殊値の扱いに起因することがほとんどです。

精度の管理を意識する
NaNや無限大の挙動を理解する
比較はCmp()メソッドを常に使用
初期化は文字列を推奨

例1: 基本的な数値の比較

最も基本的な使い方です。2つのbig.Floatの大小関係を調べます。

package main

import (
	"fmt"
	"math/big"
)

func main() {
	// big.Float の作成
	// new(big.Float) で新しい big.Float ポインタを作成し、
	// SetFloat64() や SetString() で値を設定します。
	f1 := new(big.Float).SetFloat64(123.45)
	f2 := new(big.Float).SetFloat64(123.45)
	f3 := new(big.Float).SetFloat64(100.0)
	f4 := new(big.Float).SetFloat64(200.0)

	fmt.Println("--- 基本的な数値の比較 ---")

	// f1 と f2 の比較 (f1 == f2)
	// Cmpが0を返すので等しい
	cmp1 := f1.Cmp(f2)
	fmt.Printf("f1 (%v) と f2 (%v) の比較: %d\n", f1, f2, cmp1)
	if cmp1 == 0 {
		fmt.Println(" -> f1 と f2 は等しい")
	}

	// f1 と f3 の比較 (f1 > f3)
	// Cmpが1を返すのでf1が大きい
	cmp2 := f1.Cmp(f3)
	fmt.Printf("f1 (%v) と f3 (%v) の比較: %d\n", f1, f3, cmp2)
	if cmp2 > 0 {
		fmt.Println(" -> f1 は f3 より大きい")
	}

	// f1 と f4 の比較 (f1 < f4)
	// Cmpが-1を返すのでf1が小さい
	cmp3 := f1.Cmp(f4)
	fmt.Printf("f1 (%v) と f4 (%v) の比較: %d\n", f1, f4, cmp3)
	if cmp3 < 0 {
		fmt.Println(" -> f1 は f4 より小さい")
	}
}

例2: 文字列からの初期化と精度の問題

float64からの変換では誤差が生じることがあるため、文字列からの初期化が推奨されます。

package main

import (
	"fmt"
	"math/big"
)

func main() {
	fmt.Println("\n--- 文字列からの初期化と精度の問題 ---")

	// float64 から 0.1 を設定 (丸め誤差を含む可能性がある)
	f_from_float64 := new(big.Float).SetFloat64(0.1)

	// 文字列から 0.1 を設定 (正確な表現)
	// Parse() は (数値, 基数, エラー) を返すため、_, _, err で不要な値を捨てる
	f_from_string, _, err := new(big.Float).Parse("0.1", 10)
	if err != nil {
		fmt.Println("Parse error:", err)
		return
	}

	fmt.Printf("float64から生成: %v\n", f_from_float64)
	fmt.Printf("文字列から生成: %v\n", f_from_string)

	// 比較
	cmp_result := f_from_float64.Cmp(f_from_string)
	fmt.Printf("比較結果 (float64 vs string): %d\n", cmp_result)

	if cmp_result == 0 {
		fmt.Println(" -> 2つの値は等しい (Goの環境によっては等しくなる場合もある)")
	} else {
		fmt.Println(" -> 2つの値は異なる (多くの場合、こちらが出力される)")
		fmt.Println("    理由: float64(0.1) は正確に 0.1 を表現できないため")
	}

	// 別の例: 0.25 の場合
	f_from_float64_exact := new(big.Float).SetFloat64(0.25)
	f_from_string_exact, _, _ := new(big.Float).Parse("0.25", 10)
	cmp_exact := f_from_float64_exact.Cmp(f_from_string_exact)
	fmt.Printf("0.25の比較結果: %d\n", cmp_exact)
	if cmp_exact == 0 {
		fmt.Println(" -> 0.25 は float64 でも正確に表現できるため等しい")
	}
}

例3: 許容誤差 (Epsilon) を用いた比較

厳密な等価性ではなく、ある程度の許容誤差範囲内での比較が必要な場合に用いられます。

package main

import (
	"fmt"
	"math/big"
)

func main() {
	fmt.Println("\n--- 許容誤差 (Epsilon) を用いた比較 ---")

	valA, _, _ := new(big.Float).Parse("0.3", 10)
	// 0.1 + 0.2 は float64 では 0.3 にならないことがあるが、big.Float なら精度を調整できる
	valB := new(big.Float).SetFloat64(0.1)
	valC := new(big.Float).SetFloat64(0.2)
	valSum := new(big.Float).Add(valB, valC)

	// 比較対象の精度を高くする（計算誤差を減らすため）
	valA.SetPrec(100)
	valSum.SetPrec(100)

	fmt.Printf("valA: %v\n", valA)
	fmt.Printf("valB+valC: %v\n", valSum)

	// 厳密な比較
	if valA.Cmp(valSum) == 0 {
		fmt.Println(" -> 厳密に等しい")
	} else {
		fmt.Println(" -> 厳密には異なる") // この場合、多くは「異なる」と表示される
	}

	// 許容誤差 (epsilon) を定義
	// 例: 1e-9 (0.000000001) を許容誤差とする
	epsilon := new(big.Float).SetPrec(100).SetString("0.000000001")
	if epsilon == nil {
		fmt.Println("Error setting epsilon")
		return
	}

	// |valA - valSum| < epsilon ならば等しいとみなす
	diff := new(big.Float).Sub(valA, valSum) // 差を計算
	absDiff := new(big.Float).Abs(diff)      // 絶対値を取る

	fmt.Printf("差の絶対値: %v\n", absDiff)
	fmt.Printf("許容誤差: %v\n", epsilon)

	if absDiff.Cmp(epsilon) < 0 {
		fmt.Println(" -> 許容誤差の範囲内で等しい")
	} else {
		fmt.Println(" -> 許容誤差を超えて異なる")
	}
}

NaNや無限大のCmp()挙動を理解するための例です。

package main

import (
	"fmt"
	"math/big"
)

func main() {
	fmt.Println("\n--- NaN (非数) と無限大の比較 ---")

	nan1 := new(big.Float).SetNaN()
	nan2 := new(big.Float).SetNaN()
	finiteNum := new(big.Float).SetFloat64(100.0)
	infPos := new(big.Float).SetInf(false) // +Inf
	infNeg := new(big.Float).SetInf(true)  // -Inf

	// NaN同士の比較
	// big.Float では NaN 同士は等しい (0) とみなされる
	fmt.Printf("nan1.Cmp(nan2): %d (nan1 == nan2)\n", nan1.Cmp(nan2))

	// NaNと有限数の比較
	// NaNは他の数値より小さい (-1) とみなされる（レシーバーがNaNの場合）
	fmt.Printf("nan1.Cmp(finiteNum): %d (nan1 < finiteNum)\n", nan1.Cmp(finiteNum))
	// レシーバーが有限数で引数がNaNの場合、レシーバーの方が大きい (+1) とみなされる
	fmt.Printf("finiteNum.Cmp(nan1): %d (finiteNum > nan1)\n", finiteNum.Cmp(nan1))

	// 無限大の比較
	fmt.Printf("infPos.Cmp(finiteNum): %d (+Inf > 有限数)\n", infPos.Cmp(finiteNum))
	fmt.Printf("infNeg.Cmp(finiteNum): %d (-Inf < 有限数)\n", infNeg.Cmp(finiteNum))
	fmt.Printf("infPos.Cmp(infNeg): %d (+Inf > -Inf)\n", infPos.Cmp(infNeg))
	fmt.Printf("infPos.Cmp(infPos): %d (+Inf == +Inf)\n", infPos.Cmp(infPos))

	// IsNaN() や IsInf() で事前にチェックする
	if nan1.IsNaN() {
		fmt.Println("nan1 は NaN です。")
	}
	if infPos.IsInf() {
		fmt.Printf("infPos は無限大です (符号: %t).\n", infPos.IsInf() && infPos.Sign() > 0)
	}
}

これらの例からわかるように、big.Float.Cmp()を使用する際は以下の点を意識することが重要です。

初期化の注意点
float64からの直接変換は丸め誤差を生む可能性があるため、高精度を求める場合は**文字列からの初期化（SetStringやParse）**を優先すべきです。
常にCmp()を使用
*big.Float型の値の比較には、==演算子ではなく必ずCmp()メソッドを使用します。==はポインタのアドレスを比較してしまいます。
許容誤差の考慮
厳密な等価性が不要な（または不可能な）浮動小数点数計算では、Cmp()とSub()、Abs()を組み合わせて許容誤差の範囲内での比較を行うことが一般的です。
特殊値の挙動
NaNや無限大の比較挙動は通常の数値と異なるため、IsNaN()やIsInf()で事前にチェックし、適切なロジックを組むことが賢明です。

許容誤差 (Epsilon) を用いた比較

これはCmp()の直接的な代替というよりは、Cmp()を補完してより実用的な比較を行う方法です。浮動小数点数の性質上、計算結果には微小な誤差が含まれることがよくあります。そのため、「完全に等しい」ことを比較するのではなく、「ある程度の許容誤差の範囲内で等しい」ことを判定する方が適切な場合があります。

方法
2つのbig.Floatである x と y があるとき、その差の絶対値が非常に小さな値（イプシロン: ϵ）よりも小さいかどうかをチェックします。

∣x−y∣<ϵ

これをGoのコードで書くと以下のようになります。

package main

import (
	"fmt"
	"math/big"
)

func main() {
	a, _, _ := new(big.Float).Parse("0.1", 10)
	b, _, _ := new(big.Float).Parse("0.2", 10)
	c, _, _ := new(big.Float).Parse("0.3", 10)

	// a + b を計算
	sum := new(big.Float).Add(a, b)

	fmt.Printf("a: %v, b: %v, c: %v\n", a, b, c)
	fmt.Printf("a + b の結果: %v\n", sum)

	// 厳密な比較 (多くの場合は異なる)
	if sum.Cmp(c) == 0 {
		fmt.Println("厳密に等しいです。")
	} else {
		fmt.Println("厳密には異なります。")
	}

	// 許容誤差を定義
	epsilon := new(big.Float).SetPrec(100).SetString("0.0000000000000000001") // 10^-19 の精度

	// 差の絶対値を計算: |sum - c|
	diff := new(big.Float).Sub(sum, c)
	absDiff := new(big.Float).Abs(diff)

	fmt.Printf("差の絶対値: %v\n", absDiff)
	fmt.Printf("許容誤差: %v\n", epsilon)

	// 許容誤差内での比較
	if absDiff.Cmp(epsilon) < 0 {
		fmt.Println("許容誤差の範囲内で等しいです。")
	} else {
		fmt.Println("許容誤差を超えて異なります。")
	}
}

コメント
多くの科学技術計算や金融計算では、この「許容誤差を用いた比較」が標準的なアプローチとなります。ϵ の値は、アプリケーションの要件と期待される精度に基づいて慎重に選択する必要があります。

big.FloatにはSign()メソッドがあり、数値の符号を返します。これは、値が0より大きいか、小さいか、または0であるかを知るためにCmp()の簡略版として使うことができます。

方法
x.Sign()は以下の値を返します。

x == 0 の場合: 0
x < 0 の場合: -1
x > 0 の場合: +1

【Go言語】big.Float.Cmp()で知っておくべき注意点とエラー対策

Float.Cmp()とは何か？

なぜFloat.Cmp()が必要なのか？

Float.Cmp()の使用例

浮動小数点数の精度の問題（特にfloat64からの変換時）

ポインタの比較と値の比較の混同

NaN（非数）と無限大の比較挙動の理解不足

例1: 基本的な数値の比較

例2: 文字列からの初期化と精度の問題

例3: 許容誤差 (Epsilon) を用いた比較

許容誤差 (Epsilon) を用いた比較

`Float.Cmp()`とは何か？

なぜ`Float.Cmp()`が必要なのか？

`Float.Cmp()`の使用例