なぜGoのbig.Int.GCD() が最強？代替実装との比較でわかるその真価

2025-06-01

メソッドのシグネチャ

func (z *Int) GCD(x, y, a, b *Int) *Int

引数と戻り値

a *Int, b *Int: 拡張ユークリッドの互除法におけるベズーの等式（Bézout's identity）の係数 a と b が格納されます。つまり、ax+by=GCD(x,y) となるような a と b です。これらの引数は nil であっても構いません。nil の場合、対応する係数は計算されません。
x *Int, y *Int: 最大公約数を計算する対象となる2つの非負の整数です。
z *Int: 計算結果（最大公約数）が格納される big.Int 型のポインタです。このメソッドは z 自身を返します（レシーバを返します）。

動作

big.Int.GCD() メソッドは、入力された2つの非負の整数 x と y の最大公約数を計算し、その結果を z に格納します。同時に、オプションでベズーの等式を満たす係数 a と b を計算し、それぞれ a と b に格納します。

このメソッドは、ユークリッドの互除法の拡張版（拡張ユークリッドの互除法）に基づいて実装されています。これにより、最大公約数だけでなく、その線形結合を形成する係数も効率的に計算できます。

package main

import (
	"fmt"
	"math/big"
)

func main() {
	// 2つの大きな整数を定義
	x := new(big.Int)
	x.SetString("12345678901234567890", 10) // 例として大きな数を設定

	y := new(big.Int)
	y.SetString("98765432109876543210", 10) // 例として大きな数を設定

	// GCDを格納するbig.Intを作成
	gcd := new(big.Int)

	// ベズーの等式の係数を格納するbig.Intを作成（必要ない場合はnilでも良い）
	a := new(big.Int)
	b := new(big.Int)

	// GCDを計算し、同時に係数aとbも計算
	gcd.GCD(nil, nil, x, y) // 第一引数と第二引数は結果のzと係数a,bが格納されるため、ここではx,yとして計算したい数値を第三引数、第四引数として渡す
	fmt.Printf("GCD(%s, %s) = %s\n", x.String(), y.String(), gcd.String())

	// ベズーの等式の検証 (ax + by = GCD(x,y))
	// 係数a, bも計算する場合の正しい呼び出し方
	gcd.GCD(a, b, x, y) // GCD(a, b, x, y) は a*x + b*y = GCD(x,y) となるa, bを計算する
	
	term1 := new(big.Int).Mul(a, x)
	term2 := new(big.Int).Mul(b, y)
	sum := new(big.Int).Add(term1, term2)

	fmt.Printf("Bézout's coefficients: a = %s, b = %s\n", a.String(), b.String())
	fmt.Printf("Verification: (%s * %s) + (%s * %s) = %s\n", a.String(), x.String(), b.String(), y.String(), sum.String())
	fmt.Printf("Expected GCD: %s, Calculated sum: %s (Match: %t)\n", gcd.String(), sum.String(), gcd.Cmp(sum) == 0)

	// 引数 a と b が nil の場合
	gcdNilCoeffs := new(big.Int)
	gcdNilCoeffs.GCD(nil, nil, x, y) // 係数を計算しない
	fmt.Printf("\nGCD without coefficients: GCD(%s, %s) = %s\n", x.String(), y.String(), gcdNilCoeffs.String())
}

x と y は非負の整数である必要があります。
ベズーの係数 a と b は、GCD() の呼び出し時に a と b の引数にポインタを渡すことで得られます。これらの引数に nil を渡すと、係数は計算されません。
GCD() メソッドのレシーバ z には、計算された最大公約数が格納されます。

big.Int.GCD() は比較的シンプルなメソッドですが、math/big パッケージの他の操作と同様に、big.Int 型の扱い方やポインタの概念を理解していないと、予期せぬ挙動やエラーに遭遇することがあります。

レシーバや引数の初期化不足 (nil ポインタ参照)

エラーの症状
panic: runtime error: invalid memory address or nil pointer dereference

原因
big.Int の操作では、通常、結果を格納するための big.Int オブジェクトを new(big.Int) や big.NewInt() などで明示的に初期化する必要があります。GCD() のレシーバ (z) や、結果を格納したい係数 (a, b) の引数に nil のままのポインタを渡すと、実行時にパニックが発生します。

悪い例

package main

import (
	"fmt"
	"math/big"
)

func main() {
	x := big.NewInt(12)
	y := big.NewInt(18)

	var gcd *big.Int // 初期化されていない (nil)
	var a *big.Int   // 初期化されていない (nil)
	var b *big.Int   // 初期化されていない (nil)

	// panic: runtime error: invalid memory address or nil pointer dereference
	gcd.GCD(a, b, x, y) 
	fmt.Printf("GCD: %s\n", gcd.String())
}

トラブルシューティング/解決策
new(big.Int) を使って、必要な big.Int ポインタを初期化してください。

良い例

package main

import (
	"fmt"
	"math/big"
)

func main() {
	x := big.NewInt(12)
	y := big.NewInt(18)

	gcd := new(big.Int) // 初期化
	a := new(big.Int)   // 初期化
	b := new(big.Int)   // 初期化

	gcd.GCD(a, b, x, y)
	fmt.Printf("GCD(%s, %s) = %s\n", x.String(), y.String(), gcd.String())
	fmt.Printf("Coefficients: a = %s, b = %s\n", a.String(), b.String())
}

例外
GCD() メソッドの a と b の引数については、係数を計算する必要がない場合は nil を渡すことが許可されています。この場合はパニックにはなりません。

// 係数を計算しない場合
gcd := new(big.Int)
gcd.GCD(nil, nil, x, y) // a と b は nil でOK

結果の格納先の間違い

エラーの症状
論理的な誤り。計算結果が期待通りにならない。

原因
GCD() メソッドは、レシーバ (z) に最大公約数を格納し、さらに第一引数 (a) と第二引数 (b) にベズーの係数を格納します。これらの引数の順序を誤解したり、同じ big.Int オブジェクトを複数の役割で使おうとしたりすると、意図しない結果になります。

悪い例 (よくある誤解)

package main

import (
	"fmt"
	"math/big"
)

func main() {
	x := big.NewInt(12)
	y := big.NewInt(18)

	// 以下のように呼び出すと、gcd には係数 a が格納され、
	// gcd2 には係数 b が格納されてしまう（実際はレシーバgcdがGCDとなる）
	// この呼び出し方自体はpanicにはならないが、意図した結果とは異なる
	// func (z *Int) GCD(x, y, a, b *Int) *Int ではなく
	// func (z *Int) GCD(a, b, x, y *Int) *Int が正しい
	// (z, a, b, x, y という引数順ではなく、z, x, y, a, b という引数順)
	//
	// 正しいシグネチャは `func (z *Int) GCD(a, b, x, y *Int) *Int`
	// つまり、z は結果のGCD、a は係数a、b は係数b、x は最初の入力、y は2番目の入力

	gcd := new(big.Int)
	a := new(big.Int)
	b := new(big.Int)

	// xとyのGCDを計算するつもりで、a,bの代わりにx,yを渡していると誤解している例
	// これは `gcd` に `a` の値が、`a` に `b` の値が、`b` に `x` の値が格納されるという混乱を招く
	// このメソッドは第一引数に係数a、第二引数に係数b、第三引数に被演算子x、第四引数に被演算子yを取る
	// そのため、GCD(a, b, x, y) のように書くのが正しい
	// 誤った引数順序での呼び出しは、コンパイル時にエラーになる可能性もあるが、
	// 型が合う場合はコンパイルが通ってしまい、論理エラーとなる。
	// ここでの混乱は、ドキュメントの読み間違いによるもの。
	// func (z *Int) GCD(a, b, x, y *Int) *Int
	//  この `a` と `b` は「係数」で、`x` と `y` は「被演算子」です。
	// なので、GCD(係数a, 係数b, 被演算子x, 被演算子y) と呼び出します。
	
	// 以下は、レシーバ (gcd) にGCDの結果が、第一引数 (a) に係数a、第二引数 (b) に係数b、
	// 第三引数 (x) に被演算子x、第四引数 (y) に被演算子yが渡されるという正しい使い方
	gcd.GCD(a, b, x, y) // x, y のGCDを計算し、結果を gcd に、係数を a, b に格納

	fmt.Printf("GCD(%s, %s) = %s\n", x.String(), y.String(), gcd.String())
	fmt.Printf("Coefficients: a = %s, b = %s\n", a.String(), b.String())
	// 検証: ax + by = GCD(x,y)
	term1 := new(big.Int).Mul(a, x)
	term2 := new(big.Int).Mul(b, y)
	sum := new(big.Int).Add(term1, term2)
	fmt.Printf("Verification: (%s * %s) + (%s * %s) = %s (Expected: %s)\n",
		a.String(), x.String(), b.String(), y.String(), sum.String(), gcd.String())
}

トラブルシューティング/解決策
GCD() メソッドのシグネチャを正確に理解し、それぞれの引数が何を表すのかを把握することです。

func (z *Int) GCD(a, b, x, y *Int) *Int

y: GCD を計算する対象となる二番目の被演算子 *big.Int。
x: GCD を計算する対象となる最初の被演算子 *big.Int。
b: ベズーの等式における係数 b が格納される *big.Int。nil 可。
a: ベズーの等式における係数 a が格納される *big.Int。nil 可。
z: 計算された最大公約数 (GCD) が格納されるレシーバ。

負の数やゼロの扱いに関する誤解

エラーの症状
予期せぬ結果、または特定のケースでパニック。

原因
big.Int.GCD() のドキュメントには、「x と y は非負である必要があります」と明記されています。負の数を入力すると、正しくない結果が返される可能性があります。また、ゼロが入力された場合の動作についても理解が必要です。

ドキュメントからの引用

GCD sets z to the greatest common divisor of x and y. If x or y are not non-negative, the result is undefined. (GCD は z を x と y の最大公約数に設定します。x または y が非負でない場合、結果は未定義です。)

悪い例 (負の数を渡す)

package main

import (
	"fmt"
	"math/big"
)

func main() {
	x := big.NewInt(-12) // 負の数
	y := big.NewInt(18)

	gcd := new(big.Int)
	gcd.GCD(nil, nil, x, y)
	fmt.Printf("GCD(%s, %s) = %s\n", x.String(), y.String(), gcd.String()) // 結果は未定義
}

トラブルシューティング/解決策
GCD() を呼び出す前に、入力 x と y が非負であることを確認します。必要に応じて Abs() メソッドを使用して絶対値を取ることを検討してください。

良い例 (負の数への対処)

package main

import (
	"fmt"
	"math/big"
)

func main() {
	xVal := big.NewInt(-12)
	yVal := big.NewInt(18)

	// 入力が負の場合に備えて絶対値を取る
	x := new(big.Int).Abs(xVal)
	y := new(big.Int).Abs(yVal)

	gcd := new(big.Int)
	gcd.GCD(nil, nil, x, y)
	fmt.Printf("GCD(|%s|, |%s|) = %s\n", xVal.String(), yVal.String(), gcd.String())

	// ゼロの場合
	xZero := big.NewInt(0)
	yNonZero := big.NewInt(25)
	gcdZero := new(big.Int)
	gcdZero.GCD(nil, nil, xZero, yNonZero)
	fmt.Printf("GCD(%s, %s) = %s\n", xZero.String(), yNonZero.String(), gcdZero.String()) // GCD(0, n) = |n|

	xBothZero := big.NewInt(0)
	yBothZero := big.NewInt(0)
	gcdBothZero := new(big.Int)
	gcdBothZero.GCD(nil, nil, xBothZero, yBothZero)
	fmt.Printf("GCD(%s, %s) = %s\n", xBothZero.String(), yBothZero.String(), gcdBothZero.String()) // GCD(0, 0) = 0
}

ゼロの場合の注意点

GCD(0,0)=0 これらは数学的な定義に則しており、big.Int.GCD() もこの挙動を示します。
GCD(n,0)=∣n∣ (nが0でない場合)
GCD(0,n)=∣n∣ (nが0でない場合)

非常に大きな数によるパフォーマンスの問題

エラーの症状
プログラムの実行が非常に遅い、または応答しない。

原因
big.Int は任意精度の整数を扱いますが、計算にかかる時間は数字の大きさに比例します。非常に桁数の多い数（数百万桁など）のGCDを計算しようとすると、計算資源（CPU時間）が大量に消費され、処理が遅くなることがあります。

リソースの確認
CPU使用率やメモリ使用量を確認し、ボトルネックがどこにあるのかを特定します。
並行処理 (Goルーチン)
複数のGCD計算を同時に行う必要がある場合、Goルーチンを使って並行処理を行うことで、全体のスループットを向上させることができます（ただし、単一のGCD計算自体が速くなるわけではありません）。
アルゴリズムの見直し
GCDの計算自体は非常に効率的なアルゴリズムですが、GCD計算を複数回繰り返すような、より上位のアルゴリズムがある場合、その全体の効率を見直す必要があるかもしれません。
計算負荷の評価
実際にどれくらいの大きさの数を扱う必要があるのかを再評価します。必要以上に大きな数を使っていませんか？

big.Int.GCD() は、非常に大きな整数の最大公約数（GCD）を計算するために使われます。このメソッドは、最大公約数だけでなく、拡張ユークリッドの互除法におけるベズーの等式 (ax+by=GCD(x,y)) の係数 a と b も計算できるのが特徴です。

ここでは、いくつかの異なるシナリオでの使用例を提示し、それぞれのコードの目的と動作を解説します。

例1: 最も基本的なGCDの計算

この例では、2つの大きな整数 x と y の最大公約数を計算し、その結果を表示します。係数 a と b は計算しません。

package main

import (
	"fmt"
	"math/big"
)

func main() {
	fmt.Println("--- 例1: 最も基本的なGCDの計算 ---")

	// 1. big.Int オブジェクトの作成と初期化
	// big.NewInt() は int64 から big.Int を作成する便利な関数です。
	// SetString() を使えば、文字列から任意精度の数値を設定できます。
	x := big.NewInt(1234567890123456789)
	y := big.NewInt(987654321098765432)

	// GCDの結果を格納するための big.Int オブジェクトを初期化
	gcdResult := new(big.Int)

	// 2. big.Int.GCD() の呼び出し
	// 第一引数と第二引数 (a, b) には nil を渡すことで、係数の計算をスキップできます。
	// x と y は GCD を計算したい元の数値です。
	gcdResult.GCD(nil, nil, x, y)

	// 3. 結果の表示
	fmt.Printf("x = %s\n", x.String())
	fmt.Printf("y = %s\n", y.String())
	fmt.Printf("GCD(x, y) = %s\n", gcdResult.String())
	// 期待される出力例: GCD(1234567890123456789, 987654321098765432) = 1
}

解説

String() メソッドは big.Int の値を文字列形式で表示するために使われます。
gcdResult.GCD(nil, nil, x, y) の呼び出しでは、nil を渡すことでベズーの係数 a と b の計算を明示的にスキップしています。これにより、計算リソースをわずかに節約できます。
new(big.Int) は、新しい big.Int オブジェクトへのポインタを作成し、ゼロ値（0）で初期化します。これがGCDの結果を格納する場所になります。
big.NewInt() は、int64 型の値を big.Int 型に変換して初期化するのに便利です。

例2: 拡張ユークリッドの互除法とベズーの係数の計算

この例では、GCDと同時にベズーの等式 ax+by=GCD(x,y) を満たす整数係数 a と b を計算し、結果を検証します。

package main

import (
	"fmt"
	"math/big"
)

func main() {
	fmt.Println("\n--- 例2: 拡張ユークリッドの互除法とベズーの係数の計算 ---")

	x := big.NewInt(24) // 任意の整数
	y := big.NewInt(15) // 任意の整数

	// GCDの結果と係数を格納するための big.Int オブジェクトを初期化
	gcdResult := new(big.Int)
	coeffA := new(big.Int) // 係数 a
	coeffB := new(big.Int) // 係数 b

	// big.Int.GCD() の呼び出し（係数 a と b も計算）
	// gcdResult.GCD(coeffA, coeffB, x, y) は、以下の処理を行う
	// 1. x と y のGCDを計算し、gcdResult に格納する。
	// 2. ベズーの等式を満たす係数 a と b を計算し、coeffA と coeffB に格納する。
	//    すなわち、(coeffA * x) + (coeffB * y) = gcdResult が成り立つ。
	gcdResult.GCD(coeffA, coeffB, x, y)

	fmt.Printf("x = %s\n", x.String())
	fmt.Printf("y = %s\n", y.String())
	fmt.Printf("GCD(x, y) = %s\n", gcdResult.String())
	fmt.Printf("Bézout's coefficients: a = %s, b = %s\n", coeffA.String(), coeffB.String())

	// ベズーの等式の検証: ax + by = GCD(x, y)
	// term1 = a * x
	term1 := new(big.Int).Mul(coeffA, x)
	// term2 = b * y
	term2 := new(big.Int).Mul(coeffB, y)
	// sum = term1 + term2
	sum := new(big.Int).Add(term1, term2)

	fmt.Printf("Verification: (%s * %s) + (%s * %s) = %s\n",
		coeffA.String(), x.String(), coeffB.String(), y.String(), sum.String())

	// 計算結果がGCDと一致するか確認
	if sum.Cmp(gcdResult) == 0 {
		fmt.Println("Verification successful: ax + by = GCD(x, y) holds true.")
	} else {
		fmt.Println("Verification failed: Calculation mismatch.")
	}
	// 期待される出力例:
	// x = 24
	// y = 15
	// GCD(x, y) = 3
	// Bézout's coefficients: a = 2, b = -3
	// Verification: (2 * 24) + (-3 * 15) = 48 + (-45) = 3
	// Verification successful: ax + by = GCD(x, y) holds true.
}

解説

検証部分では、Mul() (乗算) と Add() (加算) メソッドを使って ax+by を計算し、それが実際にGCDと一致するかどうかを Cmp() (比較) メソッドで確認しています。Cmp(other *Int) int は、レシーバが other より小さい場合は -1、等しい場合は 0、大きい場合は 1 を返します。
gcdResult.GCD(coeffA, coeffB, x, y) の呼び出しでは、coeffA と coeffB にポインタを渡すことで、計算された係数 a と b がこれらの変数に格納されます。

例3: 負の数やゼロの入力に対する挙動

big.Int.GCD() は入力 x と y が非負であると仮定します。この例では、負の数やゼロを扱う際の推奨される方法を示します。

package main

import (
	"fmt"
	"math/big"
)

func main() {
	fmt.Println("\n--- 例3: 負の数やゼロの入力に対する挙動 ---")

	// ケース1: 負の数を含む場合
	// GCDの数学的定義では、GCD(a, b) = GCD(|a|, |b|) です。
	// big.Int.GCD() は非負入力を想定しているため、Abs() で絶対値を取ることが推奨されます。
	xNeg := big.NewInt(-24)
	yPos := big.NewInt(15)

	// Abs() で絶対値を取る
	absX := new(big.Int).Abs(xNeg)
	absY := new(big.Int).Abs(yPos)

	gcdNegative := new(big.Int)
	gcdNegative.GCD(nil, nil, absX, absY)
	fmt.Printf("GCD(|%s|, |%s|) = %s\n", xNeg.String(), yPos.String(), gcdNegative.String())
	// 期待される出力例: GCD(|-24|, |15|) = 3

	// ケース2: 一方がゼロの場合
	// GCD(0, n) = |n|
	xZero := big.NewInt(0)
	yNonZero := big.NewInt(42)

	gcdZeroOne := new(big.Int)
	gcdZeroOne.GCD(nil, nil, xZero, yNonZero)
	fmt.Printf("GCD(%s, %s) = %s\n", xZero.String(), yNonZero.String(), gcdZeroOne.String())
	// 期待される出力例: GCD(0, 42) = 42

	// ケース3: 両方がゼロの場合
	// GCD(0, 0) = 0
	xBothZero := big.NewInt(0)
	yBothZero := big.NewInt(0)

	gcdBothZero := new(big.Int)
	gcdBothZero.GCD(nil, nil, xBothZero, yBothZero)
	fmt.Printf("GCD(%s, %s) = %s\n", xBothZero.String(), yBothZero.String(), gcdBothZero.String())
	// 期待される出力例: GCD(0, 0) = 0
}

ゼロを含むケースについても、big.Int.GCD() は数学的なGCDの定義（GCD(0,n)=∣n∣、GCD(0,0)=0）に従って正しく動作します。
負の数を扱う場合、new(big.Int).Abs(originalInt) を使って絶対値を取ることがGoの big.Int.GCD() の正しい利用方法です。これにより、数学的な定義に沿った結果が得られます。

Go言語の math/big パッケージに含まれる big.Int.GCD() メソッドは、任意精度の整数の最大公約数（GCD）を計算するための標準的かつ最も推奨される方法です。これは非常に効率的で、拡張ユークリッドの互除法を内部で実装しており、ベズーの係数も計算できます。

しかし、特定の状況や学習目的のために、他の代替手段や、big.Int.GCD() を使わずにGCDを実装する方法を検討することもあります。

Go標準ライブラリの他のパッケージ (int/int64の場合)

もし扱う整数が int64 の範囲に収まるのであれば、math/big パッケージを使う必要はありません。この場合、Goの標準の数値型を使った独自のGCD関数を実装することができます。

ユークリッドの互除法の実装例 (int64版)

package main

import (
	"fmt"
)

// GcdInt64 は2つの int64 の最大公約数をユークリッドの互除法で計算します。
func GcdInt64(a, b int64) int64 {
	// 絶対値を取ることで、負の数も正しく扱えるようにします。
	if a < 0 {
		a = -a
	}
	if b < 0 {
		b = -b
	}

	for b != 0 {
		a, b = b, a%b
	}
	return a
}

func main() {
	fmt.Println("--- int64 を使用したGCD ---")
	fmt.Printf("GCD(48, 18) = %d\n", GcdInt64(48, 18))       // 出力: 6
	fmt.Printf("GCD(101, 103) = %d\n", GcdInt64(101, 103)) // 出力: 1 (互いに素)
	fmt.Printf("GCD(-48, 18) = %d\n", GcdInt64(-48, 18))     // 出力: 6 (絶対値で計算)
	fmt.Printf("GCD(0, 15) = %d\n", GcdInt64(0, 15))         // 出力: 15
	fmt.Printf("GCD(0, 0) = %d\n", GcdInt64(0, 0))           // 出力: 0
}

利点

コードがシンプルです。
big.Int のオーバーヘッドがないため、非常に高速です。

欠点

扱える数値の範囲が int64 に限定されます。big.Int が必要な数には使えません。

自前でユークリッドの互除法を実装する (big.Int版)

big.Int.GCD() を使わずに、big.Int 型の引数を受け取る形でユークリッドの互除法を実装することも可能です。これは主に、アルゴリズムの学習や、big.Int.GCD() にはない特定の振る舞いを実装したい場合（非常に稀ですが）に行われます。

ユークリッドの互除法の実装例 (big.Int版)

package main

import (
	"fmt"
	"math/big"
)

// GcdBigInt は2つの big.Int の最大公約数をユークリッドの互除法で計算します。
// big.Int のメソッドは通常、レシーバを変更し、そのレシーバを返します。
// ここでは新しい big.Int を作成して結果を格納します。
func GcdBigInt(a, b *big.Int) *big.Int {
	// 入力をコピーして、元の値を変更しないようにします。
	x := new(big.Int).Set(a)
	y := new(big.Int).Set(b)

	// 絶対値を取ることで、負の数も正しく扱えるようにします。
	x.Abs(x)
	y.Abs(y)

	// ユークリッドの互除法
	// y が 0 でない限り繰り返す
	for y.Cmp(big.NewInt(0)) != 0 {
		// tmp := y
		tmp := new(big.Int).Set(y)
		
		// y = x % y
		y.Mod(x, y)
		
		// x = tmp
		x.Set(tmp)
	}
	return x // x が GCD となる
}

func main() {
	fmt.Println("--- big.Int を使用した自前GCD実装 ---")
	x1 := big.NewInt(12345678901234567890)
	y1 := big.NewInt(98765432109876543210)
	fmt.Printf("GCD(%s, %s) = %s\n", x1.String(), y1.String(), GcdBigInt(x1, y1).String())

	x2 := big.NewInt(24)
	y2 := big.NewInt(-15) // 負の数も扱えるように Abs() を使っている
	fmt.Printf("GCD(%s, %s) = %s\n", x2.String(), y2.String(), GcdBigInt(x2, y2).String())

	x3 := big.NewInt(0)
	y3 := big.NewInt(100)
	fmt.Printf("GCD(%s, %s) = %s\n", x3.String(), y3.String(), GcdBigInt(x3, y3).String())

	x4 := big.NewInt(0)
	y4 := big.NewInt(0)
	fmt.Printf("GCD(%s, %s) = %s\n", x4.String(), y4.String(), GcdBigInt(x4, y4).String())
}

利点

アルゴリズムの動作をより深く理解できます。
big.Int の任意精度を扱えます。

欠点

big.Int の操作では、新しいオブジェクトの作成や既存オブジェクトの変更に注意が必要です（特に Set() や Mod() など）。
拡張ユークリッドの互除法による係数 a,b の計算は、この基本的な実装には含まれていません。それらも実装するには、さらに複雑なロジックが必要です。
big.Int.GCD() と比較して、通常はパフォーマンスが劣ります。

拡張ユークリッドの互除法の自前実装 (big.Int版)

前述の基本的なユークリッドの互除法をさらに拡張し、ベズーの係数も計算できるように実装することも理論上は可能です。これはかなり複雑になり、多くの教科書やオンラインリソースでアルゴリズムの詳細を見つけることができます。

実装の複雑さ

big.Int の加算、減算、乗算、代入などの操作を慎重に管理する必要があります。
各ステップで、a,b の係数も同時に更新していく必要があります。
再帰的なアプローチまたは反復的なアプローチで実装できます。

例 (概念のみ、完全なコードは省略)

// func ExtendedGcdBigInt(a, b *big.Int) (*big.Int, *big.Int, *big.Int) {
//     // ... 拡張ユークリッドの互除法のロジックを big.Int を使って実装 ...
//     // 戻り値: GCD, 係数a, 係数b
// }

利点

アルゴリズムの完全な制御が可能です。
big.Int.GCD() と同じ機能（GCDと係数）を独自に実装できます。

欠点

Goの標準ライブラリの堅牢性、テスト済みであることの利点を放棄することになります。
パフォーマンスは、通常、標準ライブラリの big.Int.GCD() に劣ります。
実装が非常に複雑で、バグが入り込みやすいです。

Go言語で big.Int のGCDを計算する場合、math/big パッケージの big.Int.GCD() メソッドを使用することが、ほぼ全ての場合において最適な選択肢です。

メンテナンス性
自分で複雑なコードを書く必要がなく、コードの可読性とメンテナンス性が向上します。
機能性
ベズーの係数も同時に計算できるため、多くの数論的アルゴリズムに直接利用できます。
正確性
徹底的にテストされており、エッジケース（ゼロ、負の数）も正しく扱います。
効率性
標準ライブラリの実装は高度に最適化されています。

代替方法を検討するのは、以下のような非常に特殊な状況に限られます。

big.Int.GCD() では実現できない、極めて特殊な要件がある場合（これは非常に稀でしょう）。
ユークリッドの互除法のアルゴリズム自体を学習・実験したい場合。
int64 で十分な場合（その場合は int64 版のGCDを実装するのが適切）。