Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

Go math/big 包详解

概述

math/big 包实现了任意精度算术（大数运算）。该包提供了三种数值类型：有符号整数（Int）、有理数（Rat）和浮点数（Float），支持超出标准整数和浮点数范围的大数运算。

重要说明：

  • ✓ 支持任意精度算术
  • ✓ 所有操作都使用指针参数（*Int、*Rat、*Float）
  • ✓ 结果通常作为接收者返回，支持链式调用
  • ✓ 零值表示 0，无需显式初始化

包导入

import "math/big"

基本使用

1. 大整数运算

package main

import (
    "fmt"
    "math/big"
)

func main() {
    a := new(big.Int).SetInt64(123456789)
    b := new(big.Int).SetInt64(987654321)
    
    // 加法
    sum := new(big.Int).Add(a, b)
    fmt.Printf("和：%s\n", sum)
    
    // 乘法
    product := new(big.Int).Mul(a, b)
    fmt.Printf("积：%s\n", product)
}

2. 有理数运算

package main

import (
    "fmt"
    "math/big"
)

func main() {
    // 创建 1/2
    r1 := new(big.Rat).SetFrac64(1, 2)
    
    // 创建 1/3
    r2 := new(big.Rat).SetFrac64(1, 3)
    
    // 加法：1/2 + 1/3 = 5/6
    sum := new(big.Rat).Add(r1, r2)
    fmt.Printf("和：%s\n", sum.RatString())
    
    // 转换为浮点数
    f, _ := sum.Float64()
    fmt.Printf("浮点数：%f\n", f)
}

3. 高精度浮点数

package main

import (
    "fmt"
    "math/big"
)

func main() {
    // 创建高精度浮点数
    x := new(big.Float).SetPrec(256)
    x.SetString("3.14159265358979323846264338327950288419716939")
    
    // 平方根
    sqrt := new(big.Float).Sqrt(x)
    fmt.Printf("√π = %.50f\n", sqrt)
}

一、常量

MaxBase

定义：

const MaxBase = 10 + ('z' - 'a' + 1) + ('Z' - 'A' + 1)

说明：

  • 功能：字符串转换接受的最大进制
  • 值：62（10 个数字 + 26 个小写字母 + 26 个大写字母）
  • 用途：限制 SetString 和 Text 方法的进制范围

示例：

package main

import (
    "fmt"
    "math/big"
)

func main() {
    // 最大支持 62 进制
    fmt.Println("最大进制:", big.MaxBase) // 62
    
    // 36 进制示例
    n := new(big.Int)
    n.SetString("zz", 36)
    fmt.Printf("36 进制的 'zz' = %s (十进制)\n", n)
}

二、Int 类型（有符号大整数）

Int 结构体

定义：

type Int struct {
    // 内部字段
}

说明：

  • 功能：表示有符号多精度整数
  • 零值：表示 0
  • 特点：
    • 所有操作使用指针参数
    • 每个 Int 值需要唯一的 *Int 指针
    • 不支持浅拷贝

示例：

package main

import (
    "fmt"
    "math/big"
)

func main() {
    // 创建方式 1：new + 初始化
    a := new(big.Int)
    a.SetInt64(123)
    
    // 创建方式 2：使用工厂函数
    b := big.NewInt(456)
    
    // 创建方式 3：从字符串
    c := new(big.Int)
    c.SetString("789", 10)
    
    fmt.Printf("a = %s\n", a)
    fmt.Printf("b = %s\n", b)
    fmt.Printf("c = %s\n", c)
}

NewInt

定义：

func NewInt(x int64) *Int

说明：

  • 功能：分配并返回一个新的 Int
  • 参数：x - int64 值
  • 返回值：*Int - 新分配的 Int 指针

示例：

package main

import (
    "fmt"
    "math/big"
)

func main() {
    a := big.NewInt(123)
    b := big.NewInt(-456)
    c := big.NewInt(0)
    
    fmt.Println(a) // 123
    fmt.Println(b) // -456
    fmt.Println(c) // 0
}

Int 方法

Abs

定义：

func (z *Int) Abs(x *Int) *Int

说明：

  • 功能：设置 z 为 x 的绝对值
  • 参数：x - 源整数
  • 返回值：*Int - 接收者 z

示例：

n := big.NewInt(-123)
abs := new(big.Int).Abs(n)
fmt.Println(abs) // 123

Add

定义：

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

说明：

  • 功能：设置 z = x + y
  • 参数：x, y - 操作数
  • 返回值：*Int - 接收者 z

示例：

a := big.NewInt(100)
b := big.NewInt(200)
sum := new(big.Int).Add(a, b)
fmt.Println(sum) // 300

And

定义：

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

说明：

  • 功能：设置 z = x & y（按位与）
  • 参数：x, y - 操作数
  • 返回值：*Int - 接收者 z

示例：

a := big.NewInt(0b1100)
b := big.NewInt(0b1010)
result := new(big.Int).And(a, b)
fmt.Printf("%b\n", result) // 1000

AndNot

定义：

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

说明：

  • 功能：设置 z = x &^ y（按位与非）
  • 参数：x, y - 操作数
  • 返回值：*Int - 接收者 z

示例：

a := big.NewInt(0b1100)
b := big.NewInt(0b1010)
result := new(big.Int).AndNot(a, b)
fmt.Printf("%b\n", result) // 10

Append

定义：

func (x *Int) Append(buf []byte, base int) []byte

说明：

  • 功能：将 x 的字符串表示追加到 buf
  • 参数：
    • buf - 缓冲区
    • base - 进制（2-62）
  • 返回值：[]byte - 扩展后的缓冲区

示例：

n := big.NewInt(255)
buf := []byte("结果：")
buf = n.Append(buf, 16)
fmt.Println(string(buf)) // 结果：ff

Binomial

定义：

func (z *Int) Binomial(n, k int64) *Int

说明：

  • 功能：设置 z 为二项式系数 C(n, k)
  • 参数：n, k - 整数
  • 返回值：*Int - 接收者 z

示例：

// C(5, 2) = 10
result := new(big.Int).Binomial(5, 2)
fmt.Println(result) // 10

// C(10, 3) = 120
result.Binomial(10, 3)
fmt.Println(result) // 120

Bit

定义：

func (x *Int) Bit(i int) uint

说明：

  • 功能：返回 x 的第 i 位值
  • 参数：i - 位索引（>= 0）
  • 返回值：uint - 0 或 1

示例：

n := big.NewInt(0b1010)
fmt.Println(n.Bit(0)) // 0
fmt.Println(n.Bit(1)) // 1
fmt.Println(n.Bit(2)) // 0
fmt.Println(n.Bit(3)) // 1

BitLen

定义：

func (x *Int) BitLen() int

说明：

  • 功能：返回 x 绝对值的位长度
  • 返回值：int - 位长度
  • 特殊情况：0 的位长度为 0

示例：

fmt.Println(big.NewInt(0).BitLen())    // 0
fmt.Println(big.NewInt(1).BitLen())    // 1
fmt.Println(big.NewInt(7).BitLen())    // 3 (111)
fmt.Println(big.NewInt(8).BitLen())    // 4 (1000)
fmt.Println(big.NewInt(-1).BitLen())   // 1

Bits

定义：

func (x *Int) Bits() []Word

说明：

  • 功能：返回 x 绝对值的底层 Word 切片
  • 返回值：[]Word - 小端序 Word 切片
  • 注意：用于底层实现，应避免使用

示例：

n := big.NewInt(123456)
words := n.Bits()
fmt.Printf("Words: %v\n", words)

Bytes

定义：

func (x *Int) Bytes() []byte

说明：

  • 功能：返回 x 绝对值的大端序字节切片
  • 返回值：[]byte - 字节切片

示例：

n := big.NewInt(0x12345678)
bytes := n.Bytes()
fmt.Printf("%x\n", bytes) // 12345678

Cmp

定义：

func (x *Int) Cmp(y *Int) int

说明：

  • 功能：比较 x 和 y
  • 参数：y - 比较对象
  • 返回值：
    • -1 - x < y
    • 0 - x == y
    • +1 - x > y

示例：

a := big.NewInt(100)
b := big.NewInt(200)
c := big.NewInt(100)

fmt.Println(a.Cmp(b)) // -1
fmt.Println(a.Cmp(c)) // 0
fmt.Println(b.Cmp(a)) // 1

CmpAbs

定义：

func (x *Int) CmpAbs(y *Int) int

说明：

  • 功能：比较 x 和 y 的绝对值
  • 参数：y - 比较对象
  • 返回值：
    • -1 - |x| < |y|
    • 0 - |x| == |y|
    • +1 - |x| > |y|

示例：

a := big.NewInt(-100)
b := big.NewInt(50)

fmt.Println(a.Cmp(b))      // -1 (比较带符号值)
fmt.Println(a.CmpAbs(b))   // 1 (比较绝对值)

Div

定义：

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

说明：

  • 功能：设置 z = x / y（欧几里得除法）
  • 参数：x, y - 操作数
  • 返回值：*Int - 接收者 z
  • 注意：y == 0 会导致 panic

示例：

a := big.NewInt(10)
b := big.NewInt(3)
result := new(big.Int).Div(a, b)
fmt.Println(result) // 3

DivMod

定义：

func (z *Int) DivMod(x, y, m *Int) (*Int, *Int)

说明：

  • 功能：设置 z = x div y, m = x mod y（欧几里得除法）
  • 参数：x, y - 操作数，m - 余数接收者
  • 返回值：(*Int, *Int) - (商，余数)
  • 特点：余数始终 >= 0

示例：

a := big.NewInt(10)
b := big.NewInt(3)
q := new(big.Int)
r := new(big.Int)
q.DivMod(a, b, r)
fmt.Printf("商：%s, 余数：%s\n", q, r) // 商：3, 余数：1

Exp

定义：

func (z *Int) Exp(x, y, m *Int) *Int

说明：

  • 功能：设置 z = x^y mod |m|
  • 参数：
    • x - 底数
    • y - 指数
    • m - 模数（可为 nil）
  • 返回值：*Int - 接收者 z

示例：

// 2^10 = 1024
base := big.NewInt(2)
exp := big.NewInt(10)
result := new(big.Int).Exp(base, exp, nil)
fmt.Println(result) // 1024

// 2^10 mod 1000 = 24
mod := big.NewInt(1000)
result.Exp(base, exp, mod)
fmt.Println(result) // 24

FillBytes

定义：

func (x *Int) FillBytes(buf []byte) []byte

说明：

  • 功能：将 x 绝对值填充到 buf（大端序）
  • 参数：buf - 缓冲区
  • 返回值：[]byte - 填充后的 buf
  • 注意：如果 x 太大，会 panic

示例：

n := big.NewInt(0x1234)
buf := make([]byte, 4)
n.FillBytes(buf)
fmt.Printf("%x\n", buf) // 00001234

Float64

定义：

func (x *Int) Float64() (float64, Accuracy)

说明：

  • 功能：转换为 float64
  • 返回值：(float64, Accuracy) - 值和精度

示例：

n := big.NewInt(123)
f, acc := n.Float64()
fmt.Printf("值：%f, 精度：%v\n", f, acc)

Format

定义：

func (x *Int) Format(s fmt.State, ch rune)

说明：

  • 功能：实现 fmt.Formatter 接口
  • 支持的格式：b（二进制）、o（八进制）、d（十进制）、x（十六进制）、X（大写十六进制）

示例：

n := big.NewInt(255)
fmt.Printf("%d\n", n)  // 255
fmt.Printf("%x\n", n)  // ff
fmt.Printf("%b\n", n)  // 11111111

GCD

定义：

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

说明：

  • 功能：设置 z = gcd(a, b)
  • 参数：
    • x, y - 可选，用于存储贝祖等式的系数
    • a, b - 操作数
  • 返回值：*Int - 接收者 z

示例：

a := big.NewInt(48)
b := big.NewInt(18)
x := new(big.Int)
y := new(big.Int)
z := new(big.Int)
z.GCD(x, y, a, b)
fmt.Printf("GCD: %s\n", z) // 6
fmt.Printf("48*%s + 18*%s = 6\n", x, y)

GobEncode / GobDecode

定义：

func (x *Int) GobEncode() ([]byte, error)
func (z *Int) GobDecode(buf []byte) error

说明：

  • 功能：实现 encoding/gob 接口
  • 用途：序列化和反序列化

Int64

定义：

func (x *Int) Int64() int64

说明：

  • 功能：转换为 int64
  • 返回值：int64
  • 注意：无法表示时结果未定义

示例：

n := big.NewInt(123)
v := n.Int64()
fmt.Println(v) // 123

IsInt64

定义：

func (x *Int) IsInt64() bool

说明：

  • 功能：检查是否可表示为 int64
  • 返回值：bool

示例：

a := big.NewInt(123)
b := new(big.Int).Exp(big.NewInt(2), big.NewInt(100), nil)

fmt.Println(a.IsInt64()) // true
fmt.Println(b.IsInt64()) // false

IsUint64

定义：

func (x *Int) IsUint64() bool

说明：

  • 功能：检查是否可表示为 uint64
  • 返回值：bool

示例：

a := big.NewInt(123)
b := big.NewInt(-1)

fmt.Println(a.IsUint64()) // true
fmt.Println(b.IsUint64()) // false

Lsh

定义：

func (z *Int) Lsh(x *Int, n uint) *Int

说明：

  • 功能：设置 z = x << n（左移）
  • 参数：
    • x - 操作数
    • n - 移位数量
  • 返回值：*Int - 接收者 z

示例：

n := big.NewInt(1)
result := new(big.Int).Lsh(n, 10)
fmt.Println(result) // 1024

MarshalJSON / UnmarshalJSON

定义：

func (x *Int) MarshalJSON() ([]byte, error)
func (z *Int) UnmarshalJSON(text []byte) error

说明：

  • 功能：实现 encoding/json 接口

MarshalText / UnmarshalText

定义：

func (x *Int) MarshalText() (text []byte, error)
func (z *Int) UnmarshalText(text []byte) error

说明：

  • 功能：实现 encoding.TextMarshaler 接口

Mod

定义：

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

说明：

  • 功能：设置 z = x % y（欧几里得模）
  • 参数：x, y - 操作数
  • 返回值：*Int - 接收者 z
  • 注意：y == 0 会导致 panic

示例：

a := big.NewInt(10)
b := big.NewInt(3)
result := new(big.Int).Mod(a, b)
fmt.Println(result) // 1

ModInverse

定义：

func (z *Int) ModInverse(g, n *Int) *Int

说明：

  • 功能：设置 z 为 g 在 ℤ/nℤ 中的乘法逆元
  • 参数：g, n - 操作数
  • 返回值：*Int - 接收者 z，失败返回 nil

示例：

g := big.NewInt(3)
n := big.NewInt(11)
result := new(big.Int).ModInverse(g, n)
fmt.Println(result) // 4 (因为 3*4 mod 11 = 1)

ModSqrt

定义：

func (z *Int) ModSqrt(x, p *Int) *Int

说明：

  • 功能：设置 z 为 x mod p 的平方根
  • 参数：
    • x - 被开方数
    • p - 奇素数模数
  • 返回值：*Int - 接收者 z，失败返回 nil

示例：

// 求 4 mod 7 的平方根
x := big.NewInt(4)
p := big.NewInt(7)
result := new(big.Int).ModSqrt(x, p)
fmt.Println(result) // 2 或 5

Mul

定义：

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

说明：

  • 功能：设置 z = x * y
  • 参数：x, y - 操作数
  • 返回值：*Int - 接收者 z

示例：

a := big.NewInt(100)
b := big.NewInt(200)
result := new(big.Int).Mul(a, b)
fmt.Println(result) // 20000

MulRange

定义：

func (z *Int) MulRange(a, b int64) *Int

说明：

  • 功能：设置 z 为 [a, b] 范围内所有整数的乘积
  • 参数：a, b - 范围边界
  • 返回值：*Int - 接收者 z

示例：

// 5! = 120
result := new(big.Int).MulRange(1, 5)
fmt.Println(result) // 120

// 空范围 = 1
result.MulRange(5, 1)
fmt.Println(result) // 1

Neg

定义：

func (z *Int) Neg(x *Int) *Int

说明：

  • 功能：设置 z = -x
  • 参数：x - 操作数
  • 返回值：*Int - 接收者 z

示例：

n := big.NewInt(123)
result := new(big.Int).Neg(n)
fmt.Println(result) // -123

Not

定义：

func (z *Int) Not(x *Int) *Int

说明：

  • 功能：设置 z = ^x（按位取反）
  • 参数：x - 操作数
  • 返回值：*Int - 接收者 z

示例：

n := big.NewInt(0)
result := new(big.Int).Not(n)
fmt.Println(result) // -1

Or

定义：

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

说明：

  • 功能：设置 z = x | y（按位或）
  • 参数：x, y - 操作数
  • 返回值：*Int - 接收者 z

示例：

a := big.NewInt(0b1100)
b := big.NewInt(0b1010)
result := new(big.Int).Or(a, b)
fmt.Printf("%b\n", result) // 1110

ProbablyPrime

定义：

func (x *Int) ProbablyPrime(n int) bool

说明：

  • 功能：检查 x 是否可能是素数
  • 参数：n - Miller-Rabin 测试的轮数
  • 返回值：bool - 可能是素数返回 true
  • 准确性：非素数误判概率 ≤ 4^(-n)

示例：

// 检查大素数
p := new(big.Int)
p.SetString("600851475143", 10)
fmt.Println(p.ProbablyPrime(20)) // true

// 检查合数
c := big.NewInt(100)
fmt.Println(c.ProbablyPrime(20)) // false

Quo

定义：

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

说明：

  • 功能：设置 z = x / y（截断除法，如 Go）
  • 参数：x, y - 操作数
  • 返回值：*Int - 接收者 z

示例：

a := big.NewInt(-10)
b := big.NewInt(3)
result := new(big.Int).Quo(a, b)
fmt.Println(result) // -3 (向 0 截断)

QuoRem

定义：

func (z *Int) QuoRem(x, y, r *Int) (*Int, *Int)

说明：

  • 功能：设置 z = x / y, r = x % y（截断除法）
  • 参数：x, y - 操作数，r - 余数接收者
  • 返回值：(*Int, *Int) - (商，余数)

示例：

a := big.NewInt(-10)
b := big.NewInt(3)
q := new(big.Int)
r := new(big.Int)
q.QuoRem(a, b, r)
fmt.Printf("商：%s, 余数：%s\n", q, r) // 商：-3, 余数：-1

Rand

定义：

func (z *Int) Rand(rnd *rand.Rand, n *Int) *Int

说明：

  • 功能：设置 z 为 [0, n) 内的伪随机数
  • 参数：
    • rnd - 随机源
    • n - 上界
  • 返回值：*Int - 接收者 z
  • 注意：不用于安全敏感场景

示例：

import "math/rand"

n := big.NewInt(100)
r := new(big.Int).Rand(rand.New(rand.NewSource(time.Now().UnixNano())), n)
fmt.Println(r) // 0-99 之间的随机数

Rem

定义：

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

说明：

  • 功能：设置 z = x % y（截断模）
  • 参数：x, y - 操作数
  • 返回值：*Int - 接收者 z

示例：

a := big.NewInt(-10)
b := big.NewInt(3)
result := new(big.Int).Rem(a, b)
fmt.Println(result) // -1

Rsh

定义：

func (z *Int) Rsh(x *Int, n uint) *Int

说明：

  • 功能：设置 z = x >> n（右移）
  • 参数：
    • x - 操作数
    • n - 移位数量
  • 返回值：*Int - 接收者 z

示例：

n := big.NewInt(1024)
result := new(big.Int).Rsh(n, 10)
fmt.Println(result) // 1

Scan

定义：

func (z *Int) Scan(s fmt.ScanState, ch rune) error

说明：

  • 功能：实现 fmt.Scanner 接口
  • 支持的格式：b、o、d、x、X

Set

定义：

func (z *Int) Set(x *Int) *Int

说明：

  • 功能：设置 z = x（复制）
  • 参数：x - 源整数
  • 返回值：*Int - 接收者 z

示例：

a := big.NewInt(123)
b := new(big.Int).Set(a)
fmt.Println(b) // 123

SetBit

定义：

func (z *Int) SetBit(x *Int, i int, b uint) *Int

说明：

  • 功能：设置 x 的第 i 位为 b
  • 参数：
    • x - 源整数
    • i - 位索引
    • b - 值（0 或 1）
  • 返回值：*Int - 接收者 z

示例：

n := big.NewInt(0) // 0000
n.SetBit(n, 2, 1)  // 0100
fmt.Println(n)     // 4

SetBits

定义：

func (z *Int) SetBits(abs []Word) *Int

说明：

  • 功能：设置 z 为 Word 切片表示的值
  • 参数：abs - 小端序 Word 切片
  • 返回值：*Int - 接收者 z
  • 注意：用于底层实现

SetBytes

定义：

func (z *Int) SetBytes(buf []byte) *Int

说明：

  • 功能：将大端序字节切片解释为整数
  • 参数：buf - 字节切片
  • 返回值：*Int - 接收者 z

示例：

buf := []byte{0x12, 0x34, 0x56, 0x78}
n := new(big.Int).SetBytes(buf)
fmt.Printf("%x\n", n) // 12345678

SetInt64

定义：

func (z *Int) SetInt64(x int64) *Int

说明：

  • 功能：设置 z = x
  • 参数：x - int64 值
  • 返回值：*Int - 接收者 z

示例：

n := new(big.Int).SetInt64(123)
fmt.Println(n) // 123

SetString

定义：

func (z *Int) SetString(s string, base int) (*Int, bool)

说明：

  • 功能：将字符串 s 解析为整数
  • 参数：
    • s - 字符串
    • base - 进制（0 或 2-62）
  • 返回值：(*Int, bool) - (整数，成功标志)

示例：

n := new(big.Int)
if ok := n.SetString("FF", 16); ok {
    fmt.Println(n) // 255
}

SetUint64

定义：

func (z *Int) SetUint64(x uint64) *Int

说明：

  • 功能：设置 z = x
  • 参数：x - uint64 值
  • 返回值：*Int - 接收者 z

Sign

定义：

func (x *Int) Sign() int

说明：

  • 功能：返回 x 的符号
  • 返回值：
    • -1 - x < 0
    • 0 - x == 0
    • +1 - x > 0

示例：

fmt.Println(big.NewInt(-123).Sign()) // -1
fmt.Println(big.NewInt(0).Sign())    // 0
fmt.Println(big.NewInt(123).Sign())  // 1

Sqrt

定义：

func (z *Int) Sqrt(x *Int) *Int

说明：

  • 功能：设置 z = ⌊√x⌋
  • 参数：x - 被开方数（必须 >= 0）
  • 返回值：*Int - 接收者 z

示例：

n := big.NewInt(100)
result := new(big.Int).Sqrt(n)
fmt.Println(result) // 10

n.SetInt64(10)
result.Sqrt(n)
fmt.Println(result) // 3 (⌊√10⌋)

String

定义：

func (x *Int) String() string

说明：

  • 功能：返回十进制字符串表示
  • 返回值：string

示例：

n := big.NewInt(123)
fmt.Println(n.String()) // "123"

Sub

定义：

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

说明：

  • 功能：设置 z = x - y
  • 参数：x, y - 操作数
  • 返回值：*Int - 接收者 z

示例：

a := big.NewInt(200)
b := big.NewInt(100)
result := new(big.Int).Sub(a, b)
fmt.Println(result) // 100

Text

定义：

func (x *Int) Text(base int) string

说明：

  • 功能：返回指定进制的字符串表示
  • 参数：base - 进制（2-62）
  • 返回值：string

示例：

n := big.NewInt(255)
fmt.Println(n.Text(2))  // 11111111
fmt.Println(n.Text(8))  // 377
fmt.Println(n.Text(16)) // ff

TrailingZeroBits

定义：

func (x *Int) TrailingZeroBits() uint

说明：

  • 功能：返回 |x| 末尾连续零位的数量
  • 返回值：uint

示例：

n := big.NewInt(0b101000) // 40
fmt.Println(n.TrailingZeroBits()) // 3

Uint64

定义：

func (x *Int) Uint64() uint64

说明：

  • 功能：转换为 uint64
  • 返回值：uint64
  • 注意：无法表示时结果未定义

Xor

定义：

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

说明：

  • 功能：设置 z = x ^ y（按位异或）
  • 参数：x, y - 操作数
  • 返回值：*Int - 接收者 z

示例：

a := big.NewInt(0b1100)
b := big.NewInt(0b1010)
result := new(big.Int).Xor(a, b)
fmt.Printf("%b\n", result) // 110

三、Rat 类型（有理数）

Rat 结构体

定义：

type Rat struct {
    // 内部字段
}

说明：

  • 功能：表示任意精度的有理数 a/b
  • 零值：表示 0
  • 特点：分母始终 > 0

NewRat

定义：

func NewRat(a, b int64) *Rat

说明：

  • 功能：创建新的有理数 a/b
  • 参数：a - 分子，b - 分母
  • 返回值：*Rat

示例：

r := big.NewRat(1, 3)
fmt.Println(r.RatString()) // 1/3

Rat 方法

Abs

定义：

func (z *Rat) Abs(x *Rat) *Rat

说明：

  • 功能：设置 z = |x|
  • 返回值：*Rat

Add

定义：

func (z *Rat) Add(x, y *Rat) *Rat

说明：

  • 功能：设置 z = x + y
  • 返回值：*Rat

示例：

r1 := big.NewRat(1, 2)
r2 := big.NewRat(1, 3)
sum := new(big.Rat).Add(r1, r2)
fmt.Println(sum.RatString()) // 5/6

AppendText

定义：

func (x *Rat) AppendText(b []byte) ([]byte, error)

说明：

  • 功能：实现 encoding.TextAppender 接口

Cmp

定义：

func (x *Rat) Cmp(y *Rat) int

说明：

  • 功能：比较 x 和 y
  • 返回值：-1、0、+1

Denom

定义：

func (x *Rat) Denom() *Int

说明：

  • 功能：返回分母（始终 > 0）
  • 返回值：*Int

示例：

r := big.NewRat(3, 4)
fmt.Println(r.Denom()) // 4

Float32 / Float64

定义：

func (x *Rat) Float32() (f float32, exact bool)
func (x *Rat) Float64() (f float64, exact bool)

说明：

  • 功能：转换为 float32/float64
  • 返回值：(值，是否精确)

FloatPrec

定义：

func (x *Rat) FloatPrec() (n int, exact bool)

说明：

  • 功能：返回小数点后非循环位数

FloatString

定义：

func (x *Rat) FloatString(prec int) string

说明：

  • 功能：返回指定精度的十进制字符串
  • 参数：prec - 小数位数

示例：

r := big.NewRat(1, 3)
fmt.Println(r.FloatString(5)) // 0.33333

GobEncode / GobDecode

定义：

func (x *Rat) GobEncode() ([]byte, error)
func (z *Rat) GobDecode(buf []byte) error

Inv

定义：

func (z *Rat) Inv(x *Rat) *Rat

说明：

  • 功能：设置 z = 1/x
  • 注意：x == 0 会 panic

示例：

r := big.NewRat(2, 3)
inv := new(big.Rat).Inv(r)
fmt.Println(inv.RatString()) // 3/2

IsInt

定义：

func (x *Rat) IsInt() bool

说明：

  • 功能：检查分母是否为 1

示例：

r1 := big.NewRat(5, 1)
r2 := big.NewRat(5, 2)
fmt.Println(r1.IsInt()) // true
fmt.Println(r2.IsInt()) // false

MarshalText / UnmarshalText

定义：

func (x *Rat) MarshalText() (text []byte, error)
func (z *Rat) UnmarshalText(text []byte) error

Mul

定义：

func (z *Rat) Mul(x, y *Rat) *Rat

说明：

  • 功能：设置 z = x * y

示例：

r1 := big.NewRat(1, 2)
r2 := big.NewRat(2, 3)
result := new(big.Rat).Mul(r1, r2)
fmt.Println(result.RatString()) // 1/3

Neg

定义：

func (z *Rat) Neg(x *Rat) *Rat

说明：

  • 功能：设置 z = -x

Num

定义：

func (x *Rat) Num() *Int

说明：

  • 功能：返回分子（可能 <= 0）
  • 返回值：*Int

示例：

r := big.NewRat(-3, 4)
fmt.Println(r.Num()) // -3

Quo

定义：

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

说明：

  • 功能：设置 z = x / y
  • 注意：y == 0 会 panic

示例：

r1 := big.NewRat(1, 2)
r2 := big.NewRat(1, 3)
result := new(big.Rat).Quo(r1, r2)
fmt.Println(result.RatString()) // 3/2

RatString

定义：

func (x *Rat) RatString() string

说明：

  • 功能：返回 “a/b” 或 “a” 格式

示例：

r1 := big.NewRat(5, 1)
r2 := big.NewRat(5, 2)
fmt.Println(r1.RatString()) // 5
fmt.Println(r2.RatString()) // 5/2

Scan

定义：

func (z *Rat) Scan(s fmt.ScanState, ch rune) error

Set

定义：

func (z *Rat) Set(x *Rat) *Rat

说明：

  • 功能：复制 x 到 z

SetFloat64

定义：

func (z *Rat) SetFloat64(f float64) *Rat

说明：

  • 功能：设置 z = f（精确表示）
  • 注意：f 不是有限值时返回 nil

示例：

r := new(big.Rat).SetFloat64(0.5)
fmt.Println(r.RatString()) // 1/2

SetFrac

定义：

func (z *Rat) SetFrac(a, b *Int) *Rat

说明：

  • 功能：设置 z = a/b
  • 注意：b == 0 会 panic

SetFrac64

定义：

func (z *Rat) SetFrac64(a, b int64) *Rat

说明：

  • 功能：设置 z = a/b
  • 注意：b == 0 会 panic

SetInt

定义：

func (z *Rat) SetInt(x *Int) *Rat

说明：

  • 功能：设置 z = x

SetInt64

定义：

func (z *Rat) SetInt64(x int64) *Rat

说明：

  • 功能：设置 z = x

SetString

定义：

func (z *Rat) SetString(s string) (*Rat, bool)

说明：

  • 功能：解析字符串为有理数
  • 格式："a/b" 或浮点数

示例：

r := new(big.Rat)
r.SetString("3/4")
fmt.Println(r.RatString()) // 3/4

r.SetString("0.75")
fmt.Println(r.RatString()) // 3/4

SetUint64

定义：

func (z *Rat) SetUint64(x uint64) *Rat

Sign

定义：

func (x *Rat) Sign() int

说明：

  • 功能：返回符号（-1、0、+1）

String

定义：

func (x *Rat) String() string

说明：

  • 功能：返回 “a/b” 格式

Sub

定义：

func (z *Rat) Sub(x, y *Rat) *Rat

说明：

  • 功能：设置 z = x - y

四、Float 类型（高精度浮点数）

Float 结构体

定义：

type Float struct {
    // 内部字段
}

说明：

  • 功能：表示多精度浮点数
  • 格式：sign × mantissa × 2^exponent
  • 零值：表示 +0.0

NewFloat

定义：

func NewFloat(x float64) *Float

说明：

  • 功能：创建新的 Float
  • 参数：x - float64 值
  • 返回值：*Float
  • 特点：精度 53，舍入模式 ToNearestEven

示例：

f := big.NewFloat(3.14)
fmt.Println(f) // 3.14

ParseFloat

定义：

func ParseFloat(s string, base int, prec uint, mode RoundingMode) (f *Float, b int, err error)

说明：

  • 功能：解析字符串为 Float
  • 参数：
    • s - 字符串
    • base - 进制（0、2、8、10、16）
    • prec - 精度
    • mode - 舍入模式
  • 返回值：(*Float, int, error)

Float 方法

Abs

定义：

func (z *Float) Abs(x *Float) *Float

说明：

  • 功能：设置 z = |x|

Acc

定义：

func (x *Float) Acc() Accuracy

说明：

  • 功能：返回最近操作的精度误差

Add

定义：

func (z *Float) Add(x, y *Float) *Float

说明：

  • 功能：设置 z = x + y

示例：

a := big.NewFloat(1.5)
b := big.NewFloat(2.5)
sum := new(big.Float).Add(a, b)
fmt.Println(sum) // 4

Append

定义：

func (x *Float) Append(buf []byte, fmt byte, prec int) []byte

说明：

  • 功能：追加字符串表示到 buf

AppendText

定义：

func (x *Float) AppendText(b []byte) ([]byte, error)

Cmp

定义：

func (x *Float) Cmp(y *Float) int

说明：

  • 功能：比较 x 和 y
  • 返回值：-1、0、+1

Copy

定义：

func (z *Float) Copy(x *Float) *Float

说明：

  • 功能：复制 x 到 z（包括精度和舍入模式）

Float32 / Float64

定义：

func (x *Float) Float32() (float32, Accuracy)
func (x *Float) Float64() (float64, Accuracy)

说明：

  • 功能：转换为 float32/float64

Format

定义：

func (x *Float) Format(s fmt.State, format rune)

说明：

  • 功能：实现 fmt.Formatter 接口

GobEncode / GobDecode

定义：

func (x *Float) GobEncode() ([]byte, error)
func (z *Float) GobDecode(buf []byte) error

Int

定义：

func (x *Float) Int(z *Int) (*Int, Accuracy)

说明：

  • 功能：截断为整数

Int64 / Uint64

定义：

func (x *Float) Int64() (int64, Accuracy)
func (x *Float) Uint64() (uint64, Accuracy)

IsInf

定义：

func (x *Float) IsInf() bool

说明：

  • 功能：检查是否为无穷大

IsInt

定义：

func (x *Float) IsInt() bool

说明：

  • 功能：检查是否为整数

MantExp

定义：

func (x *Float) MantExp(mant *Float) (exp int)

说明：

  • 功能：分解为尾数和指数

示例：

f := big.NewFloat(8.0)
mant := new(big.Float)
exp := f.MantExp(mant)
fmt.Printf("尾数：%s, 指数：%d\n", mant, exp) // 0.5, 4

MarshalText / UnmarshalText

定义：

func (x *Float) MarshalText() (text []byte, err error)
func (z *Float) UnmarshalText(text []byte) error

MinPrec

定义：

func (x *Float) MinPrec() uint

说明：

  • 功能：返回精确表示所需的最小精度

Mode

定义：

func (x *Float) Mode() RoundingMode

说明：

  • 功能：返回舍入模式

Mul

定义：

func (z *Float) Mul(x, y *Float) *Float

说明：

  • 功能：设置 z = x * y

Neg

定义：

func (z *Float) Neg(x *Float) *Float

说明：

  • 功能：设置 z = -x

Parse

定义：

func (z *Float) Parse(s string, base int) (f *Float, b int, err error)

说明：

  • 功能：解析字符串

Prec

定义：

func (x *Float) Prec() uint

说明：

  • 功能：返回精度（位数）

Quo

定义：

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

说明：

  • 功能：设置 z = x / y

Rat

定义：

func (x *Float) Rat(z *Rat) (*Rat, Accuracy)

说明：

  • 功能：转换为有理数

Scan

定义：

func (z *Float) Scan(s fmt.ScanState, ch rune) error

Set

定义：

func (z *Float) Set(x *Float) *Float

说明：

  • 功能：设置 z = x

SetFloat64

定义：

func (z *Float) SetFloat64(x float64) *Float

SetInf

定义：

func (z *Float) SetInf(signbit bool) *Float

说明：

  • 功能：设置为无穷大
  • 参数：signbit - true 为 -Inf，false 为 +Inf

SetInt

定义：

func (z *Float) SetInt(x *Int) *Float

SetInt64

定义：

func (z *Float) SetInt64(x int64) *Float

SetMantExp

定义：

func (z *Float) SetMantExp(mant *Float, exp int) *Float

说明：

  • 功能：设置尾数和指数

SetMode

定义：

func (z *Float) SetMode(mode RoundingMode) *Float

SetPrec

定义：

func (z *Float) SetPrec(prec uint) *Float

说明：

  • 功能：设置精度

示例：

f := new(big.Float).SetPrec(256)
f.SetString("3.14159265358979323846264338327950288419716939")
fmt.Printf("%.50f\n", f)

SetRat

定义：

func (z *Float) SetRat(x *Rat) *Float

SetString

定义：

func (z *Float) SetString(s string) (*Float, bool)

说明：

  • 功能：解析字符串

示例：

f := new(big.Float)
f.SetString("3.14159")
fmt.Println(f) // 3.14159

SetUint64

定义：

func (z *Float) SetUint64(x uint64) *Float

Sign

定义：

func (x *Float) Sign() int

说明：

  • 功能：返回符号

Signbit

定义：

func (x *Float) Signbit() bool

说明：

  • 功能：检查是否为负或负零

Sqrt

定义：

func (z *Float) Sqrt(x *Float) *Float

说明：

  • 功能：设置 z = √x
  • 注意：x < 0 会 panic

示例：

x := big.NewFloat(2.0)
sqrt := new(big.Float).Sqrt(x)
fmt.Printf("%.50f\n", sqrt) // 1.41421356237309504880...

String

定义：

func (x *Float) String() string

Sub

定义：

func (z *Float) Sub(x, y *Float) *Float

说明：

  • 功能：设置 z = x - y

Text

定义：

func (x *Float) Text(format byte, prec int) string

说明：

  • 功能：格式化为字符串
  • 格式：e、E、f、g、G、x、p、b

Uint64

定义：

func (x *Float) Uint64() (uint64, Accuracy)

五、Accuracy 类型（精度误差）

Accuracy 类型

定义：

type Accuracy int

常量：

const (
    Below Accuracy = -1  // 结果小于精确值
    Exact Accuracy = 0   // 结果精确
    Above Accuracy = +1  // 结果大于精确值
)

方法：

func (i Accuracy) String() string

六、RoundingMode 类型（舍入模式）

RoundingMode 类型

定义：

type RoundingMode int

常量：

const (
    ToNearestEven RoundingMode = iota  // 舍入到最近偶数
    ToNearestAway                      // 舍入到最近，远离零
    ToZero                             // 向零舍入
    AwayFromZero                       // 远离零舍入
    ToNegativeInf                      // 向负无穷舍入
    ToPositiveInf                      // 向正无穷舍入
)

方法：

func (i RoundingMode) String() string

七、ErrNaN 类型

ErrNaN 结构体

定义：

type ErrNaN struct{}

说明：

  • 功能：当 Float 操作产生 NaN 时抛出
  • 方法：Error() string

八、Word 类型

Word 类型

定义：

type Word uintptr

说明：

  • 功能：表示多精度无符号整数的单个数字

九、包级别函数

Jacobi

定义：

func Jacobi(x, y *Int) int

说明：

  • 功能：返回 Jacobi 符号 (x/y)
  • 参数：
    • x - 分子
    • y - 分母（必须为奇数）
  • 返回值：+1、-1 或 0

示例：

x := big.NewInt(3)
y := big.NewInt(5)
result := big.Jacobi(x, y)
fmt.Println(result) // -1

十、典型示例

示例 1：计算阶乘

package main

import (
    "fmt"
    "math/big"
)

func factorial(n int64) *big.Int {
    result := big.NewInt(1)
    for i := int64(2); i <= n; i++ {
        result.Mul(result, big.NewInt(i))
    }
    return result
}

func main() {
    fmt.Printf("100! = %s\n", factorial(100))
}

示例 2：斐波那契数列

package main

import (
    "fmt"
    "math/big"
)

func fibonacci(n int) *big.Int {
    if n <= 1 {
        return big.NewInt(int64(n))
    }
    
    a, b := big.NewInt(0), big.NewInt(1)
    for i := 2; i <= n; i++ {
        a.Add(a, b)
        a, b = b, a
    }
    return b
}

func main() {
    fmt.Printf("第 100 个斐波那契数：%s\n", fibonacci(100))
}

示例 3：素数检测

package main

import (
    "fmt"
    "math/big"
)

func main() {
    // 检查大素数
    p := new(big.Int)
    p.SetString("600851475143", 10)
    
    if p.ProbablyPrime(20) {
        fmt.Printf("%s 是素数\n", p)
    } else {
        fmt.Printf("%s 不是素数\n", p)
    }
}

示例 4：模幂运算

package main

import (
    "fmt"
    "math/big"
)

func main() {
    // 计算 2^100 mod 1000
    base := big.NewInt(2)
    exp := big.NewInt(100)
    mod := big.NewInt(1000)
    
    result := new(big.Int).Exp(base, exp, mod)
    fmt.Printf("2^100 mod 1000 = %s\n", result)
}

示例 5：高精度 PI

package main

import (
    "fmt"
    "math/big"
)

func main() {
    // 设置高精度
    pi := new(big.Float).SetPrec(1024)
    pi.SetString("3.141592653589793238462643383279502884197169399375105820974944592307816406286")
    
    // 计算平方根
    sqrt := new(big.Float).Sqrt(pi)
    
    fmt.Printf("π = %.50f\n", pi)
    fmt.Printf("√π = %.50f\n", sqrt)
}

示例 6：有理数运算

package main

import (
    "fmt"
    "math/big"
)

func main() {
    // 1/2 + 1/3 = 5/6
    a := big.NewRat(1, 2)
    b := big.NewRat(1, 3)
    sum := new(big.Rat).Add(a, b)
    
    fmt.Printf("1/2 + 1/3 = %s\n", sum.RatString())
    fmt.Printf("小数：%s\n", sum.FloatString(10))
}

示例 7：最大公约数

package main

import (
    "fmt"
    "math/big"
)

func main() {
    a := big.NewInt(48)
    b := big.NewInt(18)
    
    x := new(big.Int)
    y := new(big.Int)
    z := new(big.Int)
    
    z.GCD(x, y, a, b)
    
    fmt.Printf("GCD(%s, %s) = %s\n", a, b, z)
    fmt.Printf("验证：%s*%s + %s*%s = %s\n", a, x, b, y, a, x, b, y)
}

示例 8：随机大素数

package main

import (
    "crypto/rand"
    "fmt"
    "math/big"
)

func main() {
    // 生成 128 位随机素数
    prime, err := rand.Prime(rand.Reader, 128)
    if err != nil {
        panic(err)
    }
    
    fmt.Printf("随机素数：%s\n", prime)
    fmt.Printf("位数：%d\n", prime.BitLen())
}

十一、最佳实践

1. 使用工厂函数

// ✓ 好的做法
a := big.NewInt(123)
b := big.NewRat(1, 2)
c := big.NewFloat(3.14)

// ✗ 不推荐
var a big.Int
a.SetInt64(123)

2. 避免浅拷贝

// ✓ 好的做法
a := big.NewInt(123)
b := new(big.Int).Set(a)

// ✗ 错误做法
a := big.NewInt(123)
b := *a  // 浅拷贝

3. 链式调用

// ✓ 好的做法
result := new(big.Int).Add(a, b).Mul(result, c)

// ✓ 好的做法
result := new(big.Int)
result.Add(a, b)
result.Mul(result, c)

4. 选择合适类型

// 整数运算用 Int
n := big.NewInt(123)

// 精确分数用 Rat
r := big.NewRat(1, 3)

// 高精度小数用 Float
f := new(big.Float).SetPrec(256)

十二、与其他包配合

1. 与 crypto/rand 配合

import "crypto/rand"

// 生成随机素数
prime, _ := rand.Prime(rand.Reader, 256)

// 生成随机数
n := big.NewInt(100)
random, _ := rand.Int(rand.Reader, n)

2. 与 encoding/json 配合

type Data struct {
    Number *big.Int `json:"number"`
}

data := Data{Number: big.NewInt(123)}
jsonBytes, _ := json.Marshal(data)

十三、快速参考

Int 常用方法

方法功能示例
Add加法z.Add(x, y)
Sub减法z.Sub(x, y)
Mul乘法z.Mul(x, y)
Div除法z.Div(x, y)
Mod取模z.Mod(x, y)
Exp幂运算z.Exp(x, y, m)
Sqrt平方根z.Sqrt(x)
Cmp比较x.Cmp(y)
SetString解析z.SetString(s, base)

Rat 常用方法

方法功能示例
Add加法z.Add(x, y)
Sub减法z.Sub(x, y)
Mul乘法z.Mul(x, y)
Quo除法z.Quo(x, y)
SetFrac64设置分数z.SetFrac64(a, b)
Float64转 float64x.Float64()

Float 常用方法

方法功能示例
Add加法z.Add(x, y)
Sub减法z.Sub(x, y)
Mul乘法z.Mul(x, y)
Quo除法z.Quo(x, y)
Sqrt平方根z.Sqrt(x)
SetPrec设置精度z.SetPrec(256)

十四、注意事项

1. 内存管理

// ✓ 好的做法：复用对象
z := new(big.Int)
for i := 0; i < 1000; i++ {
    z.Add(z, big.NewInt(1))
}

// ✗ 浪费：每次分配新对象
for i := 0; i < 1000; i++ {
    _ = new(big.Int).Add(z, big.NewInt(1))
}

2. 性能考虑

// 大数运算较慢
// 优先使用 int64/uint64
// 只在需要时使用 big.Int

3. 安全性

// Int 不是加密安全的
// 加密用途使用 crypto/rand

最后更新: 2026-04-05
Go 版本: Go 1.21+
包文档: https://pkg.go.dev/math/big