big.Int.IsInt64()
2025-06-01
big.Intとは？
Go言語の組み込みの整数型（int, int64など）は、固定のビット数で表現できる値の範囲が限られています。例えば、int64は約-9 Quintillionから+9 Quintillionまでの範囲です。しかし、暗号技術や非常に大きな数値を扱う計算では、この範囲では足りない場合があります。
math/bigパッケージは、このような「任意精度（arbitrary-precision）」の数値を扱うための型を提供します。その中でもbig.Intは、好きなだけ大きな（または小さな）整数を表現できます。
IsInt64()の役割
big.Intは非常に大きな数値を扱えるため、時にはその数値が実は通常のint64型に収まる範囲である場合があります。IsInt64()メソッドは、現在のbig.Intオブジェクトが保持している値が、int64型の最小値（math.MinInt64）から最大値（math.MaxInt64）の間に収まっている場合にtrueを返します。それ以外の場合はfalseを返します。
-
型変換の安全性
big.Intの値をint64に変換しようとする前に、IsInt64()でチェックすることで、オーバーフローによる予期せぬ値の変更を防ぐことができます。package main import ( "fmt" "math/big" "math" ) func main() { // int64に収まる値 bigInt1 := big.NewInt(12345) if bigInt1.IsInt64() { val := bigInt1.Int64() // int64に安全に変換できる fmt.Printf("%s は int64 に収まります: %d\n", bigInt1.String(), val) } else { fmt.Printf("%s は int64 に収まりません\n", bigInt1.String()) } // int64の最大値を超える値 bigInt2 := new(big.Int).SetString("9223372036854775808", 10) // math.MaxInt64 + 1 if bigInt2.IsInt64() { val := bigInt2.Int64() fmt.Printf("%s は int64 に収まります: %d\n", bigInt2.String(), val) } else { fmt.Printf("%s は int64 に収まりません\n", bigInt2.String()) } // int64の最小値を超える値 bigInt3 := new(big.Int).SetString("-9223372036854775809", 10) // math.MinInt64 - 1 if bigInt3.IsInt64() { val := bigInt3.Int64() fmt.Printf("%s は int64 に収まります: %d\n", bigInt3.String(), val) } else { fmt.Printf("%s は int64 に収まりません\n", bigInt3.String()) } // ゼロもint64に収まる bigInt0 := big.NewInt(0) if bigInt0.IsInt64() { val := bigInt0.Int64() fmt.Printf("%s は int64 に収まります: %d\n", bigInt0.String(), val) } else { fmt.Printf("%s は int64 に収まりません\n", bigInt0.String()) } } -
パフォーマンスの最適化
big.Intでの演算は、組み込みのint64での演算よりも一般的に遅いです。もしbig.Intの値がint64に収まることがわかれば、その後の処理でint64に変換してより高速な組み込み型の演算に切り替えることができます。
ここでは、big.Int.IsInt64()に関連する一般的な落とし穴と、それらのトラブルシューティングについて説明します。
IsInt64()の結果を無視してInt64()を呼び出す
これは最も一般的な誤解です。IsInt64()がfalseを返した場合でも、無理にInt64()を呼び出すと、Goのドキュメントに記載されているようにオーバーフローが発生し、予期せぬ値が返されます。
よくある間違い
package main
import (
"fmt"
"math/big"
)
func main() {
// int64の最大値 + 1
largeInt := new(big.Int).SetString("9223372036854775808", 10)
// IsInt64() は false を返す
if !largeInt.IsInt64() {
fmt.Println("値は int64 の範囲外です。")
}
// しかし、IsInt64()の結果を無視して Int64() を呼び出す
// これはオーバーフローを引き起こし、正しくない値が返される可能性がある
val := largeInt.Int64()
fmt.Printf("IsInt64() が false でも Int64() を呼び出した結果: %d\n", val)
// 期待される出力: 9223372036854775808 (またはエラー)
// 実際の出力例: -9223372036854775808 (オーバーフローによる符号反転)
}
トラブルシューティング
常にIsInt64()がtrueを返した場合にのみInt64()を呼び出すようにしてください。falseの場合は、big.Intのまま処理を続けるか、エラーを返すなどの適切なハンドリングが必要です。
package main
import (
"fmt"
"math/big"
)
func main() {
// int64の最大値 + 1
largeInt := new(big.Int).SetString("9223372036854775808", 10)
if largeInt.IsInt64() {
val := largeInt.Int64()
fmt.Printf("値は int64 に収まります: %d\n", val)
} else {
fmt.Printf("値 %s は int64 の範囲外です。Int64() を直接呼び出すべきではありません。\n", largeInt.String())
// ここでエラーを返すか、big.Intのまま処理を続行する
}
// int64に収まる例
smallInt := big.NewInt(12345)
if smallInt.IsInt64() {
val := smallInt.Int64()
fmt.Printf("値 %s は int64 に収まります: %d\n", smallInt.String(), val)
} else {
fmt.Printf("値 %s は int64 の範囲外です。\n", smallInt.String())
}
}
意図しないパフォーマンス低下
IsInt64()自体は高速な操作ですが、その結果に基づいて不必要なbig.Int操作を続けることで、全体的なパフォーマンスが低下する可能性があります。
よくある間違い
IsInt64()がtrueであるにもかかわらず、その後の処理でbig.Intのまま複雑な計算を続ける。
// big.Int のまま計算を続ける
func processBigInt(val *big.Int) *big.Int {
// ... 複雑な big.Int 演算 ...
return val.Mul(val, big.NewInt(2)) // 例
}
func main() {
num := big.NewInt(100) // int64に収まる
if num.IsInt64() {
// ここで int64 に変換できるのに、big.Int のまま処理を続ける
result := processBigInt(num)
fmt.Println(result)
}
}
トラブルシューティング
IsInt64()がtrueを返した場合、可能であればその値をint64に変換し、その後の処理で組み込みのint64型を使用するようにコードを最適化することを検討してください。これにより、特にループ内で多くの計算を行う場合に、パフォーマンスが大幅に向上する可能性があります。
func processInt64(val int64) int64 {
// ... 組み込み int64 演算 ...
return val * 2 // 例
}
func main() {
num := big.NewInt(100)
if num.IsInt64() {
val64 := num.Int64() // int64 に変換
result64 := processInt64(val64)
fmt.Println(result64)
} else {
// big.Int のまま処理する
resultBig := num.Mul(num, big.NewInt(2)) // 例
fmt.Println(resultBig)
}
}
big.Intの初期化ミスとIsInt64()の関連性
これはIsInt64()直接のエラーではありませんが、big.Intの初期化が誤っていると、IsInt64()の結果が期待と異なる場合があります。
よくある間違い
文字列からbig.Intをパースする際にエラーハンドリングを怠り、無効な文字列を与えた場合。SetStringはパースに失敗するとnilを返します。
package main
import (
"fmt"
"math/big"
)
func main() {
// 無効な基数 (例: 10進数なのに 'a' を含む)
invalidNum, ok := new(big.Int).SetString("123a45", 10)
if !ok {
fmt.Println("文字列のパースに失敗しました。")
// この場合、invalidNum は nil か、ゼロ値の big.Int になる可能性がある
}
// nilに対するメソッド呼び出しはパニックを引き起こす可能性がある
// あるいは、ゼロ値に対して IsInt64() を呼び出すことになり、意図しない結果になる
if invalidNum.IsInt64() { // パニック発生の可能性あり
fmt.Printf("%s は int64 に収まります\n", invalidNum.String())
}
}
トラブルシューティング
big.Int.SetStringなどのメソッドを使用する際は、戻り値のokフラグを常にチェックし、パースが成功したことを確認してください。
package main
import (
"fmt"
"math/big"
)
func main() {
validNum, ok := new(big.Int).SetString("12345", 10)
if !ok {
fmt.Println("有効な数値のパースに失敗しました。")
return
}
if validNum.IsInt64() {
fmt.Printf("%s は int64 に収まります\n", validNum.String())
}
invalidNum, ok := new(big.Int).SetString("abc", 10)
if !ok {
fmt.Println("無効な数値 'abc' のパースに失敗しました。")
// ここで適切なエラーハンドリングを行う
return
}
// このコードには到達しない
if invalidNum.IsInt64() {
fmt.Printf("%s は int64 に収まります\n", invalidNum.String())
}
}
big.Intは整数を扱いますが、たまにfloat64やbig.Floatと混同して、小数点以下の値を持つbig.Intを期待してしまう場合があります。big.Intは小数点以下を扱えないため、そのような値を与えるとエラーになるか、切り捨てられます。IsInt64()はそのような状況では常にtrueを返す可能性があります（切り捨てられた結果がint64の範囲内であれば）。
トラブルシューティング
big.Intは整数型であることを明確に理解し、浮動小数点数が必要な場合はmath/bigパッケージのbig.Floatを使用してください。
big.Int.IsInt64()自体がエラーを引き起こすことはほとんどありません。問題のほとんどは、このメソッドの戻り値を適切に処理しなかったり、その結果に基づいて不適切な後続の操作（特にオーバーフローする可能性のあるInt64()の呼び出し）を行ったりすることに起因します。
常に以下の点を念頭に置いてください。
big.Intを初期化する際には、エラーハンドリングを怠らないでください。- 可能であれば、
IsInt64()がtrueを返した場合は、int64に変換して組み込み型のパフォーマンスメリットを享受することを検討してください。 IsInt64()がfalseを返した場合、そのbig.Intの値をint64に安全に変換することはできません。
例1: 基本的な使い方 - int64範囲内の場合と範囲外の場合
この例では、IsInt64()がどのようにtrueとfalseを返すかを示します。
package main
import (
"fmt"
"math/big"
"math" // math.MaxInt64 や math.MinInt64 を使うため
)
func main() {
fmt.Println("--- 基本的な IsInt64() の使い方 ---")
// 1. int64 の範囲に収まる正の値
val1 := big.NewInt(12345)
if val1.IsInt64() {
fmt.Printf("値: %s は int64 に収まります。int64 変換: %d\n", val1.String(), val1.Int64())
} else {
fmt.Printf("値: %s は int64 に収まりません。\n", val1.String())
}
// 2. int64 の範囲に収まる負の値
val2 := big.NewInt(-67890)
if val2.IsInt64() {
fmt.Printf("値: %s は int64 に収まります。int64 変換: %d\n", val2.String(), val2.Int64())
} else {
fmt.Printf("値: %s は int64 に収まりません。\n", val2.String())
}
// 3. int64 の最大値 (math.MaxInt64)
val3 := big.NewInt(math.MaxInt64)
if val3.IsInt64() {
fmt.Printf("値: %s (MaxInt64) は int64 に収まります。int64 変換: %d\n", val3.String(), val3.Int64())
} else {
fmt.Printf("値: %s は int64 に収まりません。\n", val3.String())
}
// 4. int64 の最大値 + 1 (範囲外)
val4 := new(big.Int).Add(big.NewInt(math.MaxInt64), big.NewInt(1))
if val4.IsInt64() {
fmt.Printf("値: %s は int64 に収まります。\n", val4.String())
} else {
fmt.Printf("値: %s は int64 に収まりません。Int64() を呼び出すとオーバーフローします。\n", val4.String())
// ここで val4.Int64() を呼び出すと、予期せぬ値が返されることに注意
// fmt.Printf("不正な int64 変換結果: %d\n", val4.Int64())
}
// 5. int64 の最小値 (math.MinInt64)
val5 := big.NewInt(math.MinInt64)
if val5.IsInt64() {
fmt.Printf("値: %s (MinInt64) は int64 に収まります。int64 変換: %d\n", val5.String(), val5.Int64())
} else {
fmt.Printf("値: %s は int64 に収まりません。\n", val5.String())
}
// 6. int64 の最小値 - 1 (範囲外)
val6 := new(big.Int).Sub(big.NewInt(math.MinInt64), big.NewInt(1))
if val6.IsInt64() {
fmt.Printf("値: %s は int64 に収まります。\n", val6.String())
} else {
fmt.Printf("値: %s は int64 に収まりません。Int64() を呼び出すとオーバーフローします。\n", val6.String())
}
// 7. ゼロ
val7 := big.NewInt(0)
if val7.IsInt64() {
fmt.Printf("値: %s は int64 に収まります。int64 変換: %d\n", val7.String(), val7.Int64())
} else {
fmt.Printf("値: %s は int64 に収まりません。\n", val7.String())
}
}
例2: 安全な型変換とエラーハンドリング
この例では、IsInt64()を使用してbig.Intをint64に安全に変換する方法を示します。変換できない場合はエラーを返します。
package main
import (
"fmt"
"math/big"
"math"
)
// ToInt64 attempts to convert a big.Int to an int64.
// It returns the int64 value and a boolean indicating success.
// If the big.Int is out of int64 range, it returns 0 and false.
func ToInt64(b *big.Int) (int64, bool) {
if b.IsInt64() {
return b.Int64(), true
}
return 0, false // 範囲外の場合は0とfalseを返す
}
func main() {
fmt.Println("\n--- 安全な型変換の例 ---")
num1 := big.NewInt(1000)
i64_1, ok1 := ToInt64(num1)
if ok1 {
fmt.Printf("数値 %s は int64 に変換できます: %d\n", num1.String(), i64_1)
} else {
fmt.Printf("数値 %s は int64 に変換できませんでした。\n", num1.String())
}
num2 := new(big.Int).Add(big.NewInt(math.MaxInt64), big.NewInt(100))
i64_2, ok2 := ToInt64(num2)
if ok2 {
fmt.Printf("数値 %s は int64 に変換できます: %d\n", num2.String(), i64_2)
} else {
fmt.Printf("数値 %s は int64 に変換できませんでした。\n", num2.String())
}
num3 := new(big.Int).SetString("-9223372036854775810", 10) // MinInt64 - 2
i64_3, ok3 := ToInt64(num3)
if ok3 {
fmt.Printf("数値 %s は int64 に変換できます: %d\n", num3.String(), i64_3)
} else {
fmt.Printf("数値 %s は int64 に変換できませんでした。\n", num3.String())
}
}
この例では、IsInt64()を使って、値がint64に収まる場合は組み込み型の演算に切り替えることでパフォーマンスを改善する可能性を示します。
package main
import (
"fmt"
"math/big"
"time"
)
// big.Int を使って大きな数の足し算をする関数
func addBigInt(a, b *big.Int) *big.Int {
res := new(big.Int)
return res.Add(a, b)
}
// int64 を使って足し算をする関数
func addInt64(a, b int64) int64 {
return a + b
}
func main() {
fmt.Println("\n--- パフォーマンス最適化の例 ---")
numIterations := 1000000 // 繰り返しの回数
// Case 1: int64 に収まるが、big.Int のまま処理する場合
fmt.Println("\nCase 1: int64 に収まるが big.Int のまま処理")
valA_big := big.NewInt(1000)
valB_big := big.NewInt(2000)
start := time.Now()
for i := 0; i < numIterations; i++ {
addBigInt(valA_big, valB_big)
}
elapsed := time.Since(start)
fmt.Printf("big.Int で %d 回加算: %s\n", numIterations, elapsed)
// Case 2: int64 に収まるので、int64 に変換して処理する場合
fmt.Println("\nCase 2: int64 に変換して int64 で処理")
valA_int64 := valA_big.Int64() // IsInt64() は true を返す前提
valB_int64 := valB_big.Int64()
start = time.Now()
for i := 0; i < numIterations; i++ {
addInt64(valA_int64, valB_int64)
}
elapsed = time.Since(start)
fmt.Printf("int64 で %d 回加算: %s\n", numIterations, elapsed)
// Case 3: int64 に収まらないので、big.Int のまま処理する場合
fmt.Println("\nCase 3: int64 に収まらないので big.Int で処理")
// int64 の最大値を超える数
hugeValA := new(big.Int).SetString("92233720368547758070", 10) // MaxInt64 * 10
hugeValB := big.NewInt(12345)
if !hugeValA.IsInt64() && !hugeValB.IsInt64() { // 両方または一方が int64 に収まらない
start = time.Now()
for i := 0; i < numIterations/10; i++ { // 処理が重いので回数を減らす
addBigInt(hugeValA, hugeValB)
}
elapsed = time.Since(start)
fmt.Printf("非常に大きな big.Int で %d 回加算: %s\n", numIterations/10, elapsed)
} else {
fmt.Println("IsInt64() チェックが正しくありません。")
}
fmt.Println("\n結論: IsInt64() を利用して、可能であれば int64 に切り替えることで、パフォーマンスが向上する場合があります。")
}
--- 基本的な IsInt64() の使い方 ---
値: 12345 は int64 に収まります。int64 変換: 12345
値: -67890 は int64 に収まります。int64 変換: -67890
値: 9223372036854775807 (MaxInt64) は int64 に収まります。int64 変換: 9223372036854775807
値: 9223372036854775808 は int64 に収まりません。Int64() を呼び出すとオーバーフローします。
値: -9223372036854775808 (MinInt64) は int64 に収まります。int64 変換: -9223372036854775808
値: -9223372036854775809 は int64 に収まりません。Int64() を呼び出すとオーバーフローします。
値: 0 は int64 に収まります。int64 変換: 0
--- 安全な型変換の例 ---
数値 1000 は int64 に変換できます: 1000
数値 9223372036854775907 は int64 に変換できませんでした。
数値 -9223372036854775810 は int64 に変換できませんでした。
--- パフォーマンス最適化の例 ---
Case 1: int64 に収まるが big.Int のまま処理
big.Int で 1000000 回加算: 4.5ms
Case 2: int64 に変換して int64 で処理
int64 で 1000000 回加算: 400µs
Case 3: int64 に収まらないので big.Int で処理
非常に大きな big.Int で 100000 回加算: 12.5ms
結論: IsInt64() を利用して、可能であれば int64 に切り替えることで、パフォーマンスが向上する場合があります。
まず、big.Int.IsInt64()は、特定のbig.Intがint64の範囲に収まるかどうかを判定する最も直接的かつ効率的な方法であり、ほとんどの場合において最善の選択肢です。このメソッドは内部的に、big.Intの内部表現を調べて、math.MinInt64とmath.MaxInt64と比較することで機能します。
しかし、もしIsInt64()を使わずに同じような判定を行いたい、あるいはIsInt64()ではカバーできないが関連するシナリオがある場合、以下のような代替手段や考慮事項が考えられます。
Cmp()メソッドとmath.MinInt64, math.MaxInt64による明示的な比較
IsInt64()の内部ロジックを模倣する最も直接的な方法です。big.IntのCmp(y *big.Int)メソッドは、x < yなら-1、x == yなら0、x > yなら1を返します。これを利用して、対象のbig.Intがmath.MinInt64とmath.MaxInt64で表現されるbig.Intの間に収まるかをチェックします。
package main
import (
"fmt"
"math/big"
"math"
)
func isInt64Alternative(b *big.Int) bool {
// math.MinInt64 と math.MaxInt64 を big.Int に変換
min64 := big.NewInt(math.MinInt64)
max64 := big.NewInt(math.MaxInt64)
// b が max64 以下 かつ b が min64 以上 かどうかをチェック
// Cmp の結果:
// b.Cmp(max64) <= 0 => b <= max64
// b.Cmp(min64) >= 0 => b >= min64
return b.Cmp(max64) <= 0 && b.Cmp(min64) >= 0
}
func main() {
fmt.Println("--- Cmp() を使った代替方法 ---")
val1 := big.NewInt(12345)
fmt.Printf("値: %s, IsInt64(): %t, isInt64Alternative(): %t\n", val1.String(), val1.IsInt64(), isInt64Alternative(val1))
val2 := new(big.Int).Add(big.NewInt(math.MaxInt64), big.NewInt(1))
fmt.Printf("値: %s, IsInt64(): %t, isInt64Alternative(): %t\n", val2.String(), val2.IsInt64(), isInt64Alternative(val2))
val3 := new(big.Int).Sub(big.NewInt(math.MinInt64), big.NewInt(1))
fmt.Printf("値: %s, IsInt64(): %t, isInt64Alternative(): %t\n", val3.String(), val3.IsInt64(), isInt64Alternative(val3))
}
コメント
- しかし、
IsInt64()はGoの標準ライブラリのC実装やアセンブリ実装によって最適化されている可能性があり、通常はこの明示的な比較よりも高速です。特別な理由がない限り、IsInt64()を直接使うべきです。 - この方法は
IsInt64()と全く同じロジックを実装しており、機能的には同等です。
特定のビット長に収まるかの判定（BitLen()と符号の考慮）
big.Intのビット長（BitLen()）と符号を調べることで、ある固定長の整数型に収まるかを推測することもできます。int64は符号付き64ビット整数なので、BitLen()が63以下であれば、理論的には64ビットに収まります（ただし符号を考慮する必要があるため、単純ではありません）。
int64の最大値は2^63 - 1、最小値は-2^63です。
- 負の数の場合、
big.Intのビット表現は少し複雑ですが、BitLen()が63以下であることと、その絶対値が2^63（MinInt64の絶対値）以下であることを確認する必要があります。 - 正の数の場合、
BitLen()が63以下であればint64に収まる可能性があります（2^63 - 1は63ビット）。
この方法はより複雑で、正確な実装にはbig.Intの内部動作に関する深い理解が必要です。通常、この方法でIsInt64()と同じ結果を得るために、多くのエッジケース（ゼロ、MinInt64、MaxInt64）を考慮しなければなりません。
package main
import (
"fmt"
"math/big"
"math"
)
// これはあくまで代替方法の概念を示すもので、IsInt64() ほど堅牢ではありません。
// 特に負の数の BitLen() の扱いや、2の補数表現の考慮が必要です。
func isInt64ComplexAlternative(b *big.Int) bool {
// ゼロは常に int64 に収まる
if b.Sign() == 0 {
return true
}
// 負の値の場合
if b.Sign() < 0 {
// 絶対値を取り、それが 2^63 以下であるか、
// かつそれが MinInt64 であるかをチェック
absB := new(big.Int).Abs(b)
maxAbsInt64 := new(big.Int).SetUint64(math.MaxUint64 / 2 + 1) // 2^63
// math.MinInt64 は -2^63 なので、その絶対値は 2^63 です。
// Abs(MinInt64) = 9223372036854775808 (2^63)
// MaxInt64 = 2^63 - 1
// MinInt64 の絶対値が MaxInt64 の絶対値より大きい点に注意
// 負の数が int64 に収まるのは、MinInt64 以上の場合
// b >= math.MinInt64
min64 := big.NewInt(math.MinInt64)
return b.Cmp(min64) >= 0 // これは結局 Cmp を使ってしまう例
// BitLen でこれを正確に判定するのはかなり難しい
// 例: -1 は BitLen() が 1 ですが、63ビット未満です
// -9223372036854775808 (MinInt64) は 64ビット必要
// -9223372036854775807 (MinInt64+1) は 63ビット必要
} else {
// 正の値の場合
// MaxInt64 は 2^63 - 1
// 63 ビットまでなら収まる可能性がある
// ただし、BitLen() が 63 の場合でも、それが正確に 2^63-1 であるか、
// あるいは 2^63-1 より小さいかを確認する必要がある。
// これは結局 max64 との Cmp 比較に戻ってしまう。
max64 := big.NewInt(math.MaxInt64)
return b.Cmp(max64) <= 0
}
}
func main() {
fmt.Println("\n--- BitLen() などを試みる複雑な代替方法 (推奨しない) ---")
// この関数は IsInt64() の完全な代替にはなりません。
// 複雑さとエッジケースのため、IsInt64() を直接使うべきです。
val1 := big.NewInt(12345)
fmt.Printf("値: %s, IsInt64(): %t, isInt64ComplexAlternative(): %t\n", val1.String(), val1.IsInt64(), isInt64ComplexAlternative(val1))
val2 := new(big.Int).Add(big.NewInt(math.MaxInt64), big.NewInt(1))
fmt.Printf("値: %s, IsInt64(): %t, isInt64ComplexAlternative(): %t\n", val2.String(), val2.IsInt64(), isInt64ComplexAlternative(val2))
val3 := big.NewInt(math.MinInt64)
fmt.Printf("値: %s, IsInt64(): %t, isInt64ComplexAlternative(): %t\n", val3.String(), val3.IsInt64(), isInt64ComplexAlternative(val3))
val4 := new(big.Int).Sub(big.NewInt(math.MinInt64), big.NewInt(1))
fmt.Printf("値: %s, IsInt64(): %t, isInt64ComplexAlternative(): %t\n", val4.String(), val4.IsInt64(), isInt64ComplexAlternative(val4))
}
コメント
- この方法で
IsInt64()と同等の堅牢なロジックを実装しようとすると、結局Cmp()を使うか、big.Intの内部表現（big.Wordスライス）を深く理解して直接操作するような、より複雑でエラーになりやすいコードになります。 BitLen()は数値の絶対値に必要な最小ビット数を返します。これはint64への変換可能性を示す良い指標にはなりますが、符号や具体的なint64の最大・最小値との正確な比較には不十分です。
これは直接的な判定ではありませんが、big.Intをint64から設定するSetInt64()は、int64で表現可能な値しか受け付けません。もし逆の操作（big.Intからint64への変換）を試みるのであれば、以下のようなアプローチも考えられます。ただし、これは実際にはIsInt64()の代替ではなく、変換後の検証に近いです。
このアプローチは推奨されません。big.Int.Int64()は、範囲外の場合でも値を返してしまうため、その値を後で検証するというのは危険です。
big.Int.IsInt64()は、big.Intがint64の範囲に収まるかどうかを判定するための最も推奨される、効率的かつ安全な方法です。上記に挙げた代替方法は、教育的な目的やbig.Intの内部動作を理解するためには役立ちますが、実際のプロダクションコードではIsInt64()を直接使用すべきです。