【Go言語】`big.Int.QuoRem()` エラー解消ガイド：ゼロ除算・初期化の落とし穴

2025-06-01

`big.Int.QuoRem()` とは何か

big.Int.QuoRem() は、Go言語の math/big パッケージに含まれるメソッドで、非常に大きな整数（big.Int 型）の除算と剰余を同時に計算するために使用されます。Go言語の組み込み整数型（int, int64 など）では扱えないような、任意精度（arbitrary-precision）の整数演算を可能にするのが math/big パッケージの目的です。

メソッドのシグネチャ

big.Int.QuoRem() のシグネチャ（定義）は以下のようになっています。

func (z *Int) QuoRem(x, y *Int) (quo, rem *Int)

それぞれの引数と戻り値の意味は以下の通りです。

rem *Int: 戻り値として、剰余（remainder）が格納されます。
quo *Int: 戻り値として、商（quotient）が格納されます。
y *Int: 除数（divisor）です。y で x を割ります。
x *Int: 被除数（dividend）です。x を y で割ります。
z *Int: このメソッドを呼び出すレシーバー（オブジェクト）です。通常、演算結果の商（quo）を格納するために使用されますが、Goの慣例として、結果を返すための変数として使われます。

注意点

戻り値の quo と rem は、レシーバーである z とは異なる新しい big.Int オブジェクトへのポインタとして返されるか、あるいは z 自身が quo の結果を保持する場合があります。しかし、一般的には QuoRem の結果を格納するために新しい big.Int インスタンスを渡すことが推奨されます。
y（除数）がゼロの場合、QuoRem はパニック（panic）を起こします。

演算の定義

QuoRem(x, y) は、以下の方程式が成り立つように商 quo と剰余 rem を計算します。

x=quo⋅y+rem

また、剰余 rem の符号については以下のルールがあります。

∣rem∣<∣y∣ が成り立ちます。
rem の符号は、x の符号と同じになります。

例えば、x = -10、y = 3 の場合、

rem = -1 となります。これは、(−3)⋅3+(−1)=−9−1=−10 となり、x=quo⋅y+rem を満たし、rem の符号が x の符号と同じで、∣−1∣<∣3∣ を満たします。
quo = -3

使用例

以下に簡単な使用例を示します。

package main

import (
	"fmt"
	"math/big"
)

func main() {
	// 非常に大きな整数を作成
	x := new(big.Int)
	y := new(big.Int)

	x.SetString("123456789012345678901234567890", 10) // 10進数で設定
	y.SetString("7890", 10)

	fmt.Printf("x = %s\n", x.String())
	fmt.Printf("y = %s\n", y.String())

	// QuoRem を使用して商と剰余を計算
	quo := new(big.Int)
	rem := new(big.Int)

	quo, rem = quo.QuoRem(x, y) // xをyで割る

	fmt.Printf("商 (quotient) = %s\n", quo.String())
	fmt.Printf("剰余 (remainder) = %s\n", rem.String())

	// 負の数の例
	xNeg := new(big.Int)
	yPos := new(big.Int)

	xNeg.SetInt64(-10)
	yPos.SetInt64(3)

	fmt.Printf("\n負の数の例:\n")
	fmt.Printf("x = %s\n", xNeg.String())
	fmt.Printf("y = %s\n", yPos.String())

	quoNeg := new(big.Int)
	remNeg := new(big.Int)

	quoNeg, remNeg = quoNeg.QuoRem(xNeg, yPos)

	fmt.Printf("商 (quotient) = %s\n", quoNeg.String())
	fmt.Printf("剰余 (remainder) = %s\n", remNeg.String()) // xと同じ符号になる
}

出力例

x = 123456789012345678901234567890
y = 7890
商 (quotient) = 15647248290538108860000000000
剰余 (remainder) = 3690

負の数の例:
x = -10
y = 3
商 (quotient) = -3
剰余 (remainder) = -1

通常の組み込み型であれば、x / y で商、x % y で剰余を計算できます。しかし、math/big パッケージでは、単に商や剰余を計算するだけでなく、それらを同時に効率的に計算できる QuoRem メソッドが提供されています。これは、除算アルゴリズムによっては商と剰余が同時に計算されることが多く、別々にメソッドを呼び出すよりも効率的であるためです。

除数がゼロ (y がゼロ) の場合

エラー
panic: big: division by zero

説明
QuoRem メソッドは、除数 y がゼロの場合にパニックを引き起こします。これは、数学的にゼロによる除算が未定義であるためです。Go言語の組み込み整数型では実行時エラーになるのと同じ挙動です。

トラブルシューティング
QuoRem を呼び出す前に、除数となる big.Int がゼロでないことを必ず確認してください。Cmp() メソッドを使用してゼロと比較することができます。

package main

import (
	"fmt"
	"math/big"
)

func main() {
	x := big.NewInt(100)
	y := big.NewInt(0) // 除数をゼロにする

	if y.Cmp(big.NewInt(0)) == 0 {
		fmt.Println("エラー: 除数がゼロです。")
		// エラーハンドリング: 例えば、エラーを返すか、別の処理を行う
		return
	}

	quo := new(big.Int)
	rem := new(big.Int)
	quo, rem = quo.QuoRem(x, y) // ここでパニックが発生する
	fmt.Printf("商: %s, 剰余: %s\n", quo.String(), rem.String())
}

big.Int の初期化忘れまたは誤った初期化

エラー
nil ポインタのデリファレンス（ランタイムパニック）

説明
big.Int はポインタ型 (*big.Int) であり、new(big.Int) または big.NewInt() で適切に初期化する必要があります。初期化せずにメソッドを呼び出すと、nil ポインタデリファレンスのエラーが発生します。

package main

import (
	"fmt"
	"math/big"
)

func main() {
	var x *big.Int // 初期化されていない (nil)
	y := big.NewInt(3)

	// x.SetInt64(100) // これがないと次の行でパニック
	quo := new(big.Int)
	rem := new(big.Int)
	quo, rem = quo.QuoRem(x, y) // xがnilなのでパニック
	fmt.Printf("商: %s, 剰余: %s\n", quo.String(), rem.String())
}

トラブルシューティング
すべての big.Int 変数が new(big.Int) または big.NewInt() で初期化されていることを確認してください。

package main

import (
	"fmt"
	"math/big"
)

func main() {
	x := new(big.Int).SetInt64(100) // 適切に初期化
	y := big.NewInt(3)

	quo := new(big.Int)
	rem := new(big.Int)
	quo, rem = quo.QuoRem(x, y)
	fmt.Printf("商: %s, 剰余: %s\n", quo.String(), rem.String())
}

戻り値の取り扱いの誤解 (特にレシーバーとの関係)

説明
QuoRem のシグネチャは func (z *Int) QuoRem(x, y *Int) (quo, rem *Int) です。これは、レシーバー z に商が格納され、別の quo と rem のポインタが返されることを意味します。この挙動を理解していないと、意図しない結果になることがあります。

Goの math/big パッケージのメソッドの多くは、演算結果をレシーバー（メソッドを呼び出すオブジェクト）に格納し、そのレシーバー自身を返します（あるいは、QuoRem のように複数の値を返す場合はその一部）。

package main

import (
	"fmt"
	"math/big"
)

func main() {
	x := big.NewInt(100)
	y := big.NewInt(3)

	// 誤解しやすい例:
	// quo も rem も新しい big.Int を作成しているが、
	// quo.QuoRem(x,y) の呼び出しでは、quo (レシーバー) に商が格納され、
	// 戻り値の quo と rem がその結果を指す
	quo := new(big.Int)
	rem := new(big.Int)
	
	// この行の実行後、quo は商を表す big.Int を指し、rem は剰余を表す big.Int を指す。
	// ここで代入されている quo, rem は、
	// レシーバーの quo とは異なる可能性があることに注意。
	// 実際には、QuoRemはレシーバーz(ここではquo)を商として返し、
	// もう一つの結果である剰余を新たなポインタとして返す。
	quo, rem = quo.QuoRem(x, y) 

	// より一般的な書き方:
	// 商と剰余を格納するための新しい big.Int を作成し、それをレシーバーとして使う
	resultQuo := new(big.Int)
	resultRem := new(big.Int)
	
	// QuoRemは結果を格納するためのレシーバー (resultQuo) と、
	// 剰余の新たなポインタ (resultRem) を返す。
	resultQuo, resultRem = resultQuo.QuoRem(x, y) 

	fmt.Printf("商: %s, 剰余: %s\n", resultQuo.String(), resultRem.String())
}

トラブルシューティング
結果を格納するための新しい big.Int インスタンスを明示的に作成し、それをレシーバーとして使用することを推奨します。

package main

import (
	"fmt"
	"math/big"
)

func main() {
	x := big.NewInt(100)
	y := big.NewInt(3)

	// 商を格納する変数を定義し、それをレシーバーとしてQuoRemを呼び出す
	quotient := new(big.Int)
	remainder := new(big.Int)

	// quotient が商の計算結果を格納する
	// QuoRem はその quotient を返すが、さらに剰余も返すため、多値代入で受け取る
	quotient, remainder = quotient.QuoRem(x, y)

	fmt.Printf("商: %s, 剰余: %s\n", quotient.String(), remainder.String())
}

このように書くことで、quotient に商、remainder に剰余が格納されることが明確になります。

組み込み型への変換時のオーバーフロー

エラー
Int64() や Uint64() でのデータ損失

説明
big.Int は任意精度の整数を扱いますが、それを int64 や uint64 などの組み込み型に変換する際には、元の big.Int の値が組み込み型の最大値を超えているとオーバーフローが発生し、データが切り捨てられたり、予期しない値になったりします。QuoRem 自体はオーバーフローを起こしませんが、その結果を組み込み型で利用しようとすると問題になることがあります。

package main

import (
	"fmt"
	"math/big"
)

func main() {
	x := new(big.Int).SetString("9223372036854775807000", 10) // int64の最大値よりも大きい
	y := big.NewInt(10)

	quo := new(big.Int)
	rem := new(big.Int)
	quo, rem = quo.QuoRem(x, y)

	fmt.Printf("商: %s\n", quo.String())

	// 商をint64に変換しようとする
	if quo.IsInt64() { // IsInt64() で int64 に収まるか確認できる
		quoInt64 := quo.Int64()
		fmt.Printf("商 (int64): %d\n", quoInt64)
	} else {
		fmt.Printf("警告: 商はint64に収まりません。\n")
	}

	fmt.Printf("剰余: %s\n", rem.String())
	if rem.IsInt64() {
		remInt64 := rem.Int64()
		fmt.Printf("剰余 (int64): %d\n", remInt64)
	} else {
		fmt.Printf("警告: 剰余はint64に収まりません。\n")
	}
}

トラブルシューティング

収まらない場合は、引き続き big.Int 型として扱うか、文字列として出力するなど、適切な方法で処理します。
変換前に IsInt64() や IsUint64() メソッドを使って、値が組み込み型に収まるかを確認します。

パフォーマンスに関する考慮事項

説明
math/big パッケージは任意精度の計算を可能にするため、通常の組み込み整数演算に比べてパフォーマンスのオーバーヘッドがあります。非常に多くの QuoRem 操作をループ内で実行する場合、パフォーマンスが問題になることがあります。

（非常に高度なケースですが）Goの math/big はGMP (GNU Multiple Precision Arithmetic Library) のようなC言語で実装された非常に最適化されたライブラリと比較すると、速度が劣る場合があります。パフォーマンスが極めて重視される場合は、Cgoなどを介してGMPを直接利用することも検討できますが、これはGoの哲学から外れることが多く、複雑性が増します。
計算アルゴリズムを見直し、big.Int の演算回数を減らせないかを検討します。
可能な限り、big.Int が必要ない場面では組み込みの整数型を使用します。
プロファイリングツール (go tool pprof) を使用して、アプリケーションのボトルネックを特定します。QuoRem や math/big 関連の関数がかなりのCPU時間を消費している場合、それがボトルネックの可能性があります。

big.Int.QuoRem() は、math/big パッケージで提供される多倍長整数（big.Int）の除算と剰余を同時に計算するメソッドです。ここでは、いくつかの異なるシナリオでの使用例と、関連するポイントを説明します。

例 1: 基本的な除算と剰余の計算

最も基本的な使用例です。正の整数同士の除算を行います。

package main

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

func main() {
	fmt.Println("--- 例 1: 基本的な除算と剰余 ---")

	// 被除数 (x) を設定
	x := new(big.Int)
	x.SetString("12345678901234567890", 10) // 非常に大きな数を10進数文字列で設定

	// 除数 (y) を設定
	y := new(big.Int)
	y.SetInt64(789) // 小さな整数も big.Int に変換して使用可能

	fmt.Printf("被除数 (x): %s\n", x.String())
	fmt.Printf("除数 (y): %s\n", y.String())

	// 商と剰余を格納するための big.Int 変数を初期化
	quo := new(big.Int) // 商 (quotient)
	rem := new(big.Int) // 剰余 (remainder)

	// QuoRem メソッドを呼び出す
	// quo.QuoRem(x, y) は、x を y で割り、商を quo に、剰余を rem に格納する。
	// 戻り値の (quo, rem) は、計算結果が格納された big.Int へのポインタ。
	quo, rem = quo.QuoRem(x, y)

	fmt.Printf("商 (quotient): %s\n", quo.String())
	fmt.Printf("剰余 (remainder): %s\n", rem.String())

	// 検算: x = quo * y + rem が成り立つか確認
	check := new(big.Int).Mul(quo, y) // 商 * 除数
	check.Add(check, rem)            // (商 * 除数) + 剰余
	fmt.Printf("検算 (quo * y + rem): %s (一致: %t)\n", check.String(), check.Cmp(x) == 0)
}

解説

Cmp() メソッドで big.Int 同士の比較を行い、0 であれば値が等しいことを示します。
String() メソッドで big.Int の値を文字列として取得し、表示します。
quo.QuoRem(x, y) で計算を実行します。quo が商のレシーバーとなり、rem が剰余のレシーバーとなります。メソッドは計算結果が格納されたこれらのポインタを返します。
SetString("...", 10) で文字列から10進数として値を設定します。SetInt64() で int64 から設定することもできます。
new(big.Int) で big.Int 型の変数を初期化します。これらはポインタです。

例 2: 負の数を含む除算

QuoRem() は、剰余の符号が被除数と同じになるように定義されています。

package main

import (
	"fmt"
	"math/big"
)

func main() {
	fmt.Println("\n--- 例 2: 負の数を含む除算 ---")

	testCases := []struct {
		xStr string
		yStr string
	}{
		{"10", "3"},   // x:正, y:正 -> 商:3, 剰余:1
		{"-10", "3"},  // x:負, y:正 -> 商:-3, 剰余:-1 (剰余の符号はxと同じ)
		{"10", "-3"},  // x:正, y:負 -> 商:-3, 剰余:1
		{"-10", "-3"}, // x:負, y:負 -> 商:3, 剰余:-1 (剰余の符号はxと同じ)
		{"5", "5"},    // 割り切れる場合
		{"-5", "5"},   // 割り切れる場合（負）
	}

	for _, tc := range testCases {
		x := new(big.Int)
		y := new(big.Int)
		x.SetString(tc.xStr, 10)
		y.SetString(tc.yStr, 10)

		quo := new(big.Int)
		rem := new(big.Int)
		quo, rem = quo.QuoRem(x, y)

		fmt.Printf("x: %s, y: %s => 商: %s, 剰余: %s\n",
			x.String(), y.String(), quo.String(), rem.String())

		// 検算
		check := new(big.Int).Mul(quo, y)
		check.Add(check, rem)
		fmt.Printf("  検算: %s (一致: %t)\n", check.String(), check.Cmp(x) == 0)
	}
}

解説

剰余の符号が被除数と同じになるという重要なルールがここで確認できます。例えば -10 / 3 の場合、商は -3 で、(-3) * 3 = -9 なので、(-10) - (-9) = -1 となり、剰余は -1 となります。
複数のテストケースを用いて、負の数を考慮したQuoRemの挙動を確認しています。

例 3: ゼロ除算のハンドリング

big.Int.QuoRem() は除数がゼロの場合にパニックを引き起こすため、事前にチェックする必要があります。

package main

import (
	"fmt"
	"math/big"
)

func main() {
	fmt.Println("\n--- 例 3: ゼロ除算のハンドリング ---")

	x := big.NewInt(123)
	y := big.NewInt(0) // 除数をゼロに設定

	fmt.Printf("被除数 (x): %s\n", x.String())
	fmt.Printf("除数 (y): %s\n", y.String())

	// y がゼロかどうかをチェック
	// big.NewInt(0) との比較は、y.Cmp(big.NewInt(0)) == 0 で行います。
	if y.Cmp(big.NewInt(0)) == 0 {
		fmt.Println("エラー: 除数がゼロです。除算を実行できません。")
		// ここでエラーをログに記録したり、ユーザーに通知したり、
		// エラー値を返したりするなどの適切なエラーハンドリングを行う。
		return // プログラムの実行を停止
	}

	quo := new(big.Int)
	rem := new(big.Int)
	quo, rem = quo.QuoRem(x, y) // この行は実行されない（上記で return されるため）

	fmt.Printf("商 (quotient): %s\n", quo.String())
	fmt.Printf("剰余 (remainder): %s\n", rem.String())
}

解説

ゼロ除算の場合には、QuoRem を呼び出す前に処理を中断し、適切なエラーメッセージを表示するようにします。
y.Cmp(big.NewInt(0)) == 0 を使用して、y がゼロと等しいかを安全にチェックします。

例 4: `big.Int` の値が `int64` に収まるかのチェック

QuoRem の結果が非常に大きい場合、それをGoの組み込み型（int64 など）に変換しようとするとオーバーフローが発生する可能性があります。

package main

import (
	"fmt"
	"math/big"
)

func main() {
	fmt.Println("\n--- 例 4: 結果の int64 への変換とチェック ---")

	x := new(big.Int)
	// int64 の最大値 (9223372036854775807) よりもずっと大きな値
	x.SetString("922337203685477580712345", 10)
	y := big.NewInt(100)

	quo := new(big.Int)
	rem := new(big.Int)
	quo, rem = quo.QuoRem(x, y)

	fmt.Printf("商 (big.Int): %s\n", quo.String())
	fmt.Printf("剰余 (big.Int): %s\n", rem.String())

	// 商が int64 に収まるかチェック
	if quo.IsInt64() {
		quoInt64 := quo.Int64()
		fmt.Printf("商 (int64): %d\n", quoInt64)
	} else {
		fmt.Printf("警告: 商 (%s) は int64 に収まりません。\n", quo.String())
	}

	// 剰余が int64 に収まるかチェック
	if rem.IsInt64() {
		remInt64 := rem.Int64()
		fmt.Printf("剰余 (int64): %d\n", remInt64)
	} else {
		fmt.Printf("警告: 剰余 (%s) は int64 に収まりません。\n", rem.String())
	}

	// 小さな数の例（int64 に収まる場合）
	xSmall := big.NewInt(100)
	ySmall := big.NewInt(7)
	quoSmall := new(big.Int)
	remSmall := new(big.Int)
	quoSmall, remSmall = quoSmall.QuoRem(xSmall, ySmall)

	fmt.Printf("\n小さな数の例:\n")
	fmt.Printf("商 (big.Int): %s\n", quoSmall.String())
	if quoSmall.IsInt64() {
		fmt.Printf("商 (int64): %d\n", quoSmall.Int64())
	}
}

小さな数であれば、IsInt64() が true を返し、安全に int64 に変換できることがわかります。
Int64() メソッドで big.Int を int64 に変換できますが、IsInt64() でのチェックなしに変換すると、値が大きすぎる場合に期待しない結果になる可能性があります。
IsInt64() メソッドを使って、big.Int の値が int64 の範囲内に収まるかを確認できます。

big.Int.QuoRem() は、多倍長整数（big.Int）の除算と剰余を同時に計算する最も効率的な方法です。これは、多くの除算アルゴリズムが商と剰余を同時に生成するため、このメソッドが最適な選択肢となるからです。

しかし、特定の状況やニーズに応じて、以下の代替方法を検討することも可能です。

big.Int.Div() と big.Int.Mod() を個別に呼び出す
独自の除算ロジックの実装 (非現実的だが理論上は可能)
big.Int.Quo() または big.Int.Rem() のみを使用する
他の言語のライブラリ（Cgo経由など）

それぞれについて詳しく見ていきましょう。

big.Int.Div() と big.Int.Mod() を個別に呼び出す

これは QuoRem() の最も直接的な代替方法であり、多くの場合、実用的な選択肢となります。big.Int パッケージには、商のみを計算する Div() メソッドと、剰余のみを計算する Mod() メソッドがそれぞれ用意されています。

Div() メソッドのシグネチャ

func (z *Int) Div(x, y *Int) *Int

x を y で割った商を z に格納し、z を返します。

Mod() メソッドのシグネチャ

func (z *Int) Mod(x, y *Int) *Int

注意点

除数 y がゼロの場合、両メソッドともパニックを引き起こします。
Div() と Mod() の符号ルールは QuoRem() と同じです。すなわち、剰余の符号は被除数 x の符号と同じになります。

使用例

package main

import (
	"fmt"
	"math/big"
)

func main() {
	fmt.Println("--- Div() と Mod() を個別に呼び出す例 ---")

	x := big.NewInt(12345)
	y := big.NewInt(789)

	fmt.Printf("被除数 (x): %s\n", x.String())
	fmt.Printf("除数 (y): %s\n", y.String())

	// 商を計算
	quo := new(big.Int)
	quo.Div(x, y) // quo = x / y

	// 剰余を計算
	rem := new(big.Int)
	rem.Mod(x, y) // rem = x % y

	fmt.Printf("商 (quo): %s\n", quo.String())
	fmt.Printf("剰余 (rem): %s\n", rem.String())

	// 検算
	check := new(big.Int).Mul(quo, y)
	check.Add(check, rem)
	fmt.Printf("検算 (quo * y + rem): %s (一致: %t)\n", check.String(), check.Cmp(x) == 0)

	// 負の数の例
	xNeg := big.NewInt(-10)
	yPos := big.NewInt(3)

	quoNeg := new(big.Int)
	remNeg := new(big.Int)

	quoNeg.Div(xNeg, yPos)
	remNeg.Mod(xNeg, yPos)

	fmt.Printf("\n負の数の例: x=%s, y=%s => 商:%s, 剰余:%s\n",
		xNeg.String(), yPos.String(), quoNeg.String(), remNeg.String())
}

QuoRem() との比較

欠点
内部的には、Div() と Mod() の両方を呼び出すと、QuoRem() を1回呼び出すよりも若干のパフォーマンスオーバーヘッドが発生する可能性があります。これは、QuoRem() が単一の操作で両方の結果を効率的に取得できるためです。ただし、ほとんどのアプリケーションでは、このパフォーマンスの差は無視できるレベルです。
利点
コードの可読性がわずかに向上する可能性があります。商と剰余の片方のみが必要な場合に、不必要な計算を避けることができると誤解されがちですが、実際には内部で同時に計算されることが多いです。

独自の除算ロジックの実装 (非現実的だが理論上は可能)

これは非常に非現実的で、ほとんどの場合、推奨されません。多倍長整数の除算アルゴリズムは非常に複雑で、効率的かつ正確に実装するには専門知識が必要です。

考えられるシナリオ

既存のbig.Int の振る舞い（特に剰余の符号ルールなど）が、特定の数学的定義に合致しない場合（ただし、これはまれです）。
特定の研究目的や、Goの math/big パッケージの内部実装に依存したくない場合など、非常に特殊な状況。

なぜ非現実的か

パフォーマンス
自分で実装した場合、Goの math/big パッケージの最適化された実装に比べて、はるかに遅くなる可能性が高いです。
バグの温床
ゼロ除算、負の数、オーバーフローなど、様々なエッジケースを正確に処理するのは困難です。
複雑性
筆算の原理に基づいた除算アルゴリズム（例: ニュートン法、Schönhage-Strassen法など）は、桁数が増えるほど複雑になります。

トラブルシューティング
この方法を選択した場合、問題が発生した際に外部のサポートを得ることは非常に困難になります。

big.Int.Quo() または big.Int.Rem() のみを使用する

これは、商または剰余のどちらか片方のみが必要な場合に検討できます。

Quo() メソッドのシグネチャ

func (z *Int) Quo(x, y *Int) *Int

このメソッドは、商のみを計算します。これは Div() と同じ動作をします。

Rem() メソッドのシグネチャ

func (z *Int) Rem(x, y *Int) *Int

このメソッドは、剰余のみを計算します。これは Mod() と同じ動作をします。

注意点

したがって、これらのメソッドを個別に呼び出すことは、前述の「Div() と Mod() を個別に呼び出す」ケースと同じパフォーマンス特性を持ちます。つまり、QuoRem() よりも効率がわずかに劣る可能性がありますが、ほとんどのケースでは問題になりません。
Quo() と Rem() はそれぞれ Div() と Mod() のエイリアス（別名）です。機能的には全く同じです。

使用例（Quo() のみが必要な場合）

package main

import (
	"fmt"
	"math/big"
)

func main() {
	fmt.Println("\n--- Quo() のみを使用する例 ---")

	x := big.NewInt(12345)
	y := big.NewInt(789)

	quo := new(big.Int)
	quo.Quo(x, y) // 商のみを計算

	fmt.Printf("商 (quo): %s\n", quo.String())
	// 剰余は計算されない（または、呼び出し元からは見えない）
}

他の言語のライブラリ（Cgo経由など）

Goの math/big パッケージは非常に優れていますが、特定の超高速計算が要求される場合（例: 科学計算、暗号学の非常にパフォーマンスが重要な部分）には、C言語で書かれたGMP (GNU Multiple Precision Arithmetic Library) のような、さらに最適化されたライブラリを検討することがあります。

方法

Cgo
GoからCの関数を呼び出すためのGoの機能であるCgoを使用します。これにより、GMPなどのCライブラリをGoプログラムに組み込むことができます。

利点

最高のパフォーマンス
特に非常に大きな数（数千ビット以上）の演算において、GMPのようなライブラリは、アセンブリ言語レベルでの最適化により、しばしばGoのネイティブ実装よりも高速です。

欠点

ポータビリティの低下
Cライブラリに依存するため、ターゲット環境にそのライブラリがインストールされている必要があります。
Goのイディオムからの逸脱
Goの安全な型システムやメモリ管理の恩恵を一部失う可能性があります。
複雑性の増加
Cgoはビルドプロセスを複雑にし、クロスコンパイルやデバッグを難しくします。

トラブルシューティング
Cgo関連のトラブルシューティングは、GoとCの両方の知識を必要とし、かなり高度になります。

推奨されるシナリオ

Goのネイティブ機能だけでは満たせない、特定の数学的要件（例: 特殊なモジュラー演算）がある場合。
ベンチマークによって、math/big パッケージがパフォーマンス上のボトルネックであることが明確に示され、その改善がアプリケーションの成功に不可欠である場合。

ほとんどのGoアプリケーションにおいて、big.Int.QuoRem() は多倍長整数の除算と剰余を計算するための最も推奨される方法です。パフォーマンスと利便性のバランスが非常に優れています。

もし商と剰余の片方のみが必要な場合は、big.Int.Div() と big.Int.Mod() を個別に呼び出すことを検討できますが、パフォーマンス上のメリットはほとんどありません。

【Go言語】`big.Int.QuoRem()` エラー解消ガイド：ゼロ除算・初期化の落とし穴

big.Int.QuoRem() とは何か

メソッドのシグネチャ

演算の定義

使用例

除数がゼロ (y がゼロ) の場合

big.Int の初期化忘れまたは誤った初期化

戻り値の取り扱いの誤解 (特にレシーバーとの関係)

組み込み型への変換時のオーバーフロー

パフォーマンスに関する考慮事項

例 1: 基本的な除算と剰余の計算

例 2: 負の数を含む除算

例 3: ゼロ除算のハンドリング

例 4: big.Int の値が int64 に収まるかのチェック

big.Int.Div() と big.Int.Mod() を個別に呼び出す

独自の除算ロジックの実装 (非現実的だが理論上は可能)

big.Int.Quo() または big.Int.Rem() のみを使用する

他の言語のライブラリ（Cgo経由など）

`big.Int.QuoRem()` とは何か

例 4: `big.Int` の値が `int64` に収まるかのチェック