©
This document uses PHP Chinese website manual Release
import "math/big"
概述
索引
示例
Big 包实现了任意精度算术（大数）。支持以下数字类型：
Int signed integers Rat rational numbers Float floating-point numbers
Int，Rat 或 Float 的零值对应于0。因此，可以用通常的方式声明新值，并且在没有进一步初始化的情况下表示0：
var x Int // &x is an *Int of value 0var r = &Rat{} // r is a *Rat of value 0y := new(Float) // y is a *Float of value 0或者，可以使用表单的工厂函数分配和初始化新值：
func NewT(v V) *T
例如，NewInt(x)返回* Int，设置为int64参数x的值，NewRat(a, b)返回设置为a/b的小数部分a/b，其中a和b是int64值，NewFloat(f)返回一个初始化为float64参数f的Float。显式设置器提供了更多的灵活性，例如：
var z1 Int z1.SetUint64(123) // z1 := 123z2 := new(Rat).SetFloat64(1.25) // z2 := 5/4z3 := new(Float).SetInt(z1) // z3 := 123.0
Setters，数字操作和谓词被表示为以下形式的方法：
func (z *T) SetV(v V) *T // z = vfunc (z *T) Unary(x *T) *T // z = unary xfunc (z *T) Binary(x, y *T) *T // z = x binary yfunc (x *T) Pred() P // p = pred(x)
用 T，Int，Rat 或 Float 中的一个。对于一元和二元运算，结果是接收器（在这种情况下通常命名为z；见下文）; 如果它是操作数x或y中的一个，它可能会被安全覆盖（以及它的内存重用）。
算术表达式通常写成一系列单独的方法调用，每个调用都对应一个操作。接收方表示结果，方法参数是操作的操作数。例如，给定三个* Int值a，b和c，调用
c.Add(a, b)
计算总和 a + b 并将结果存储在 c 中，覆盖之前在 c 中保存的任何值。除非另有说明，否则操作允许混叠参数，因此写入完全可以
sum.Add(sum, x)
在一个和中累加值 x 。
（通过总是通过接收器传递结果值，可以更好地控制内存使用，而不必为每个结果分配新的内存，操作可以重新使用分配给结果值的空间，并用新的值覆盖该值导致该过程。）
符号约定：传入方法参数（包括接收者）在API中被一致命名以阐明其用法。传入的操作数通常命名为 x，y，a，b 等等，但从不 z 。指定结果的参数被命名为 z （通常是接收者）。
例如， (*Int).Add 的参数被命名为 x 和 y，并且因为接收者指定了结果目的地，所以它被称为z：
func (z *Int) Add(x, y *Int) *Int
这种形式的方法通常也会返回传入的接收者，以启用简单的呼叫链接。
不需要传入结果值的方法（例如Int.Sign），只需返回结果。在这种情况下，接收器通常是第一个操作数，名为x：
func (x *Int) Sign() int
各种方法支持字符串和相应数值之间的转换，反之亦然：* Int，* Rat 和 * Float 值为值的（默认）字符串表示形式实现Stringer接口，但也提供SetString方法以初始化来自一个支持多种格式的字符串（请参阅相应的SetString文档）。
最后，* Int，* Rat和* Float满足 fmt 软件包的 Scanner 界面进行扫描和格式化界面格式化打印（* Rat除外）。
这个例子演示了如何使用big.Rat来计算常数 e（自然对数的底数）的有理收敛序列中的前15个项。
package mainimport ("fmt""math/big")// Use the classic continued fraction for e// e = [1; 0, 1, 1, 2, 1, 1, ... 2n, 1, 1, ...]// i.e., for the nth term, use// 1 if n mod 3 != 1// (n-1)/3 * 2 if n mod 3 == 1func recur(n, lim int64) *big.Rat {
term := new(big.Rat)if n%3 != 1 {
term.SetInt64(1)} else {
term.SetInt64((n - 1) / 3 * 2)}if n > lim {return term}// Directly initialize frac as the fractional// inverse of the result of recur.
frac := new(big.Rat).Inv(recur(n+1, lim))return term.Add(term, frac)}// This example demonstrates how to use big.Rat to compute the// first 15 terms in the sequence of rational convergents for// the constant e (base of natural logarithm).func main() {for i := 1; i <= 15; i++ {
r := recur(0, int64(i))// Print r both as a fraction and as a floating-point number.// Since big.Rat implements fmt.Formatter, we can use %-13s to// get a left-aligned string representation of the fraction.
fmt.Printf("%-13s = %s\n", r, r.FloatString(8))}}这个例子演示了如何使用big.Int来计算100位十进制数字的最小斐波那契数，并测试它是否为素数。
package mainimport ("fmt""math/big")func main() {// Initialize two big ints with the first two numbers in the sequence.
a := big.NewInt(0)
b := big.NewInt(1)// Initialize limit as 10^99, the smallest integer with 100 digits.var limit big.Int
limit.Exp(big.NewInt(10), big.NewInt(99), nil)// Loop while a is smaller than 1e100.for a.Cmp(&limit) < 0 {// Compute the next Fibonacci number, storing it in a.
a.Add(a, b)// Swap a and b so that b is the next number in the sequence.
a, b = b, a}
fmt.Println(a) // 100-digit Fibonacci number// Test a for primality.// (ProbablyPrimes' argument sets the number of Miller-Rabin// rounds to be performed. 20 is a good value.)
fmt.Println(a.ProbablyPrime(20))}此示例说明如何使用 big.Float 以200位的精度计算2的平方根，以及如何将结果打印为十进制数。
package mainimport ("fmt""math""math/big")func main() {// 我们将做计算与200位精度在尾数。const prec = 200// 用牛顿法计算2的平方根。我们从// sqrt (2) 的初始估计值, 然后循环访问:// x_{n+1} = 1/2 * ( x_n + (2.0 / x_n) )// 因为牛顿的方法加倍的正确数字在每个// 迭代, 我们至少需要 log_2 (prec) 步骤。
steps := int(math.Log2(prec))// 初始化计算所需的值。
two := new(big.Float).SetPrec(prec).SetInt64(2)
half := new(big.Float).SetPrec(prec).SetFloat64(0.5)// 使用1作为初始估计值。
x := new(big.Float).SetPrec(prec).SetInt64(1)// 我们使用 t 作为一个临时变量。没有必要设定它的精确度// 从大。浮动值 (== 0) 精度自动承担// 作为结果使用时参数的最大精度 (接收者)// 大。浮动操作。
t := new(big.Float)// 迭代。for i := 0; i <= steps; i++ {
t.Quo(two, x) // t = 2.0 / x_n
t.Add(x, t) // t = x_n + (2.0 / x_n)
x.Mul(half, t) // x_{n+1} = 0.5 * t}// 我们可以使用常规的裂变材料。自大以来的 Printf 动词。浮动实现了裂变材料。格式
fmt.Printf("sqrt(2) = %.50f\n", x)// 打印2和之间的x*x错误。
t.Mul(x, x) // t = x*x
fmt.Printf("error = %e\n", t.Sub(two, t))}常量
func Jacobi(x, y *Int) int
type Accuracy
func (i Accuracy) String() string
type ErrNaN
func (err ErrNaN) Error() string
type Float
func NewFloat(x float64) *Float
func ParseFloat(s string, base int, prec uint, mode RoundingMode) (f *Float, b int, err error)
func (z *Float) Abs(x *Float) *Float
func (x *Float) Acc() Accuracy
func (z *Float) Add(x, y *Float) *Float
func (x *Float) Append(buf []byte, fmt byte, prec int) []byte
func (x *Float) Cmp(y *Float) int
func (z *Float) Copy(x *Float) *Float
func (x *Float) Float32() (float32, Accuracy)
func (x *Float) Float64() (float64, Accuracy)
func (x *Float) Format(s fmt.State, format rune)
func (z *Float) GobDecode(buf []byte) error
func (x *Float) GobEncode() ([]byte, error)
func (x *Float) Int(z *Int) (*Int, Accuracy)
func (x *Float) Int64() (int64, Accuracy)
func (x *Float) IsInf() bool
func (x *Float) IsInt() bool
func (x *Float) MantExp(mant *Float) (exp int)
func (x *Float) MarshalText() (text []byte, err error)
func (x *Float) MinPrec() uint
func (x *Float) Mode() RoundingMode
func (z *Float) Mul(x, y *Float) *Float
func (z *Float) Neg(x *Float) *Float
func (z *Float) Parse(s string, base int) (f *Float, b int, err error)
func (x *Float) Prec() uint
func (z *Float) Quo(x, y *Float) *Float
func (x *Float) Rat(z *Rat) (*Rat, Accuracy)
func (z *Float) Scan(s fmt.ScanState, ch rune) error
func (z *Float) Set(x *Float) *Float
func (z *Float) SetFloat64(x float64) *Float
func (z *Float) SetInf(signbit bool) *Float
func (z *Float) SetInt(x *Int) *Float
func (z *Float) SetInt64(x int64) *Float
func (z *Float) SetMantExp(mant *Float, exp int) *Float
func (z *Float) SetMode(mode RoundingMode) *Float
func (z *Float) SetPrec(prec uint) *Float
func (z *Float) SetRat(x *Rat) *Float
func (z *Float) SetString(s string) (*Float, bool)
func (z *Float) SetUint64(x uint64) *Float
func (x *Float) Sign() int
func (x *Float) Signbit() bool
func (x *Float) String() string
func (z *Float) Sub(x, y *Float) *Float
func (x *Float) Text(format byte, prec int) string
func (x *Float) Uint64() (uint64, Accuracy)
func (z *Float) UnmarshalText(text []byte) error
type Int
func NewInt(x int64) *Int
func (z *Int) Abs(x *Int) *Int
func (z *Int) Add(x, y *Int) *Int
func (z *Int) And(x, y *Int) *Int
func (z *Int) AndNot(x, y *Int) *Int
func (x *Int) Append(buf []byte, base int) []byte
func (z *Int) Binomial(n, k int64) *Int
func (x *Int) Bit(i int) uint
func (x *Int) BitLen() int
func (x *Int) Bits() []Word
func (x *Int) Bytes() []byte
func (x *Int) Cmp(y *Int) (r int)
func (z *Int) Div(x, y *Int) *Int
func (z *Int) DivMod(x, y, m *Int) (*Int, *Int)
func (z *Int) Exp(x, y, m *Int) *Int
func (x *Int) Format(s fmt.State, ch rune)
func (z *Int) GCD(x, y, a, b *Int) *Int
func (z *Int) GobDecode(buf []byte) error
func (x *Int) GobEncode() ([]byte, error)
func (x *Int) Int64() int64
func (x *Int) IsInt64() bool
func (x *Int) IsUint64() bool
func (z *Int) Lsh(x *Int, n uint) *Int
func (x *Int) MarshalJSON() ([]byte, error)
func (x *Int) MarshalText() (text []byte, err error)
func (z *Int) Mod(x, y *Int) *Int
func (z *Int) ModInverse(g, n *Int) *Int
func (z *Int) ModSqrt(x, p *Int) *Int
func (z *Int) Mul(x, y *Int) *Int
func (z *Int) MulRange(a, b int64) *Int
func (z *Int) Neg(x *Int) *Int
func (z *Int) Not(x *Int) *Int
func (z *Int) Or(x, y *Int) *Int
func (x *Int) ProbablyPrime(n int) bool
func (z *Int) Quo(x, y *Int) *Int
func (z *Int) QuoRem(x, y, r *Int) (*Int, *Int)
func (z *Int) Rand(rnd *rand.Rand, n *Int) *Int
func (z *Int) Rem(x, y *Int) *Int
func (z *Int) Rsh(x *Int, n uint) *Int
func (z *Int) Scan(s fmt.ScanState, ch rune) error
func (z *Int) Set(x *Int) *Int
func (z *Int) SetBit(x *Int, i int, b uint) *Int
func (z *Int) SetBits(abs []Word) *Int
func (z *Int) SetBytes(buf []byte) *Int
func (z *Int) SetInt64(x int64) *Int
func (z *Int) SetString(s string, base int) (*Int, bool)
func (z *Int) SetUint64(x uint64) *Int
func (x *Int) Sign() int
func (z *Int) Sqrt(x *Int) *Int
func (x *Int) String() string
func (z *Int) Sub(x, y *Int) *Int
func (x *Int) Text(base int) string
func (x *Int) Uint64() uint64
func (z *Int) UnmarshalJSON(text []byte) error
func (z *Int) UnmarshalText(text []byte) error
func (z *Int) Xor(x, y *Int) *Int
type Rat
func NewRat(a, b int64) *Rat
func (z *Rat) Abs(x *Rat) *Rat
func (z *Rat) Add(x, y *Rat) *Rat
func (x *Rat) Cmp(y *Rat) int
func (x *Rat) Denom() *Int
func (x *Rat) Float32() (f float32, exact bool)
func (x *Rat) Float64() (f float64, exact bool)
func (x *Rat) FloatString(prec int) string
func (z *Rat) GobDecode(buf []byte) error
func (x *Rat) GobEncode() ([]byte, error)
func (z *Rat) Inv(x *Rat) *Rat
func (x *Rat) IsInt() bool
func (x *Rat) MarshalText() (text []byte, err error)
func (z *Rat) Mul(x, y *Rat) *Rat
func (z *Rat) Neg(x *Rat) *Rat
func (x *Rat) Num() *Int
func (z *Rat) Quo(x, y *Rat) *Rat
func (x *Rat) RatString() string
func (z *Rat) Scan(s fmt.ScanState, ch rune) error
func (z *Rat) Set(x *Rat) *Rat
func (z *Rat) SetFloat64(f float64) *Rat
func (z *Rat) SetFrac(a, b *Int) *Rat
func (z *Rat) SetFrac64(a, b int64) *Rat
func (z *Rat) SetInt(x *Int) *Rat
func (z *Rat) SetInt64(x int64) *Rat
func (z *Rat) SetString(s string) (*Rat, bool)
func (x *Rat) Sign() int
func (x *Rat) String() string
func (z *Rat) Sub(x, y *Rat) *Rat
func (z *Rat) UnmarshalText(text []byte) error
type RoundingMode
func (i RoundingMode) String() string
type Word
Bugs
Float.Add Float.Cmp Float.Scan Float (Shift) Int.Scan Int.SetString Rat.Scan Rat.SetString RoundingMode Package (EConvergents) Package (Fibonacci) Package (Sqrt2)
文件包
accuracy_string.go arith.go arith_decl.go decimal.go doc.go float.go floatconv.go floatmarsh.go ftoa.go int.go intconv.go intmarsh.go nat.go natconv.go prime.go rat.go ratconv.go ratmarsh.go roundingmode_string.go
指数和精度限制。
const ( MaxExp = math.MaxInt32 // largest supported exponent MinExp = math.MinInt32 // smallest supported exponent MaxPrec = math.MaxUint32 // largest (theoretically) supported precision; likely memory-limited)
MaxBase是字符串转换所接受的最大数字基数。
const MaxBase = 'z' - 'a' + 10 + 1
func Jacobi(x, y *Int) int
Jacobi返回Jacobi符号(x/y)，即+1，-1或0. y参数必须是奇数。
准确度描述了最近一次生成Float值的操作产生的舍入误差，相对于精确值。
type Accuracy int8
描述浮点精度的常量。
const ( Below Accuracy = -1 Exact Accuracy = 0 Above Accuracy = +1)
func (i Accuracy) String() string
Float 操作引发了一个 ErrNaN 恐慌，该操作将导致遵循 IEEE-754 规则的 NaN 。ErrNaN 实现错误接口。
type ErrNaN struct { // contains filtered or unexported fields}func (err ErrNaN) Error() string
非零有限Float表示一个多精度浮点数
sign × mantissa × 2**exponent
其中0.5 <=尾数<1.0，且MinExp <=指数<= MaxExp。浮点数也可以是零 (+0, -0) 或无限(+Inf, -Inf)。所有浮点都是有序的，并且两个浮点x和y的排序由x.Cmp(y)定义。
每个浮点值还具有精度，舍入模式和准确度。精度是可用于表示值的尾数位的最大数量。舍入模式指定应如何舍入结果以适合尾数位，准确性描述相对于精确结果的舍入误差。
除非另有规定，否则指定结果的* Float变量（通常通过接收方除MantExp外）的所有操作（包括setter）根据结果变量的精度和舍入模式对数值结果进行舍入。
如果提供的结果精度为0（见下文），则在进行舍入之前将其设置为具有最大精度值的参数的精度，舍入模式保持不变。因此，作为结果参数提供的未初始化的 Floats 将其精度设置为由操作数确定的合理值，并且它们的模式是RoundingMode(ToNearestEven)的零值。
通过将所需精度设置为24或53并使用匹配舍入模式（通常为ToNearestEven），Float 操作产生与对应于正常（即非denormal）float32 或 float64 的操作数的相应 float32 或 float64 IEEE-754 算法相同的结果数字。对于与 IEEE-754 不同的值，指数下溢和溢出会导致0或无穷大，因为 Float 指数具有更大的范围。
Float 的零（未初始化）值已准备好使用，并精确地表示数字+0.0，精度为0，舍入模式为 ToNearestEven 。
type Float struct { // 包含筛选或 unexported 字段}package mainimport ("fmt""math/big")func main() {// Implement Float "shift" by modifying the (binary) exponents directly.for s := -5; s <= 5; s++ {
x := big.NewFloat(0.5)
x.SetMantExp(x, x.MantExp(nil)+s) // shift x by s
fmt.Println(x)}}func NewFloat(x float64) *Float
NewFloat 分配并返回一个新的 Float 设置为 x ，精度为53，舍入模式为 ToNearestEven 。如果 x 是 NaN ， NewFloat 会与 ErrNaN 混淆。
func ParseFloat(s string, base int, prec uint, mode RoundingMode) (f *Float, b int, err error)
ParseFloat 就像f.Parse（s，base），f 设置为给定的精度和舍入模式。
func (z *Float) Abs(x *Float) *Float
Abs 将 z 设置为（可能为四舍五入）值 |x|（x的绝对值）并返回 z 。
func (x *Float) Acc() Accuracy
Acc返回最近操作产生的x的精确度。
func (z *Float) Add(x, y *Float) *Float
将 z 设置为舍入和 x + y 并返回 z 。如果 z 的精度为0，则在操作之前将其更改为x或y的精度中的较大者。舍入是根据z的精度和舍入模式执行的；并且z的准确性报告相对于确切（不是四舍五入）结果的结果错误。如果x和y是符号相反的无穷大，则用 ErrNaN 添加恐慌。在这种情况下 z 的值是未定义的。
BUG(gri)四舍五入 ToNegativeInf 时，Float 值的符号舍入为0是不正确的。
package mainimport ("fmt""math/big")func main() {// Operate on numbers of different precision.var x, y, z big.Float
x.SetInt64(1000) // x is automatically set to 64bit precision
y.SetFloat64(2.718281828) // y is automatically set to 53bit precision
z.SetPrec(32)
z.Add(&x, &y)
fmt.Printf("x = %.10g (%s, prec = %d, acc = %s)\n", &x, x.Text('p', 0), x.Prec(), x.Acc())
fmt.Printf("y = %.10g (%s, prec = %d, acc = %s)\n", &y, y.Text('p', 0), y.Prec(), y.Acc())
fmt.Printf("z = %.10g (%s, prec = %d, acc = %s)\n", &z, z.Text('p', 0), z.Prec(), z.Acc())}func (x *Float) Append(buf []byte, fmt byte, prec int) []byte
追加附加到 buf 浮点数 x 的字符串形式，由x.Text生成，并返回扩展缓冲区。
func (x *Float) Cmp(y *Float) int
Cmp 比较 x 和 y 并返回：
-1 if x < y 0 if x == y (incl. -0 == 0, -Inf == -Inf, and +Inf == +Inf)+1 if x > y
package mainimport ("fmt""math""math/big")func main() {
inf := math.Inf(1)
zero := 0.0
operands := []float64{-inf, -1.2, -zero, 0, +1.2, +inf}
fmt.Println(" x y cmp")
fmt.Println("---------------")for _, x64 := range operands {
x := big.NewFloat(x64)for _, y64 := range operands {
y := big.NewFloat(y64)
fmt.Printf("%4g %4g %3d\n", x, y, x.Cmp(y))}
fmt.Println()}}func (z *Float) Copy(x *Float) *Float
将 z 设置为 x ，具有相同的精度，舍入模式，精度等于 x ，并返回 z 。即使 z 和 x 相同，x 也不会改变。
func (x *Float) Float32() (float32, Accuracy)
Float32返回最接近x的float32值。如果x太小而不能用float32（| x | <math.SmallestNonzeroFloat32）表示，则结果分别为（0，Below）或（-0，Above），具体取决于x的符号。如果x太大而无法用float32（| x |> math.MaxFloat32）表示，则结果为（+ Inf，Above）或（-Inf，Below），具体取决于x的符号。
func (x *Float) Float64() (float64, Accuracy)
Float64返回最接近x的float64值。如果x太小而无法用float64（|x| < math.SmallestNonzeroFloat64）表示，则结果分别为 (0, Below) 或 (-0, Above)，具体取决于x的符号。如果x太大而无法用float64（|x| > math.MaxFloat64）表示，则结果为（+Inf, Above）或（-Inf, Below），具体取决于x的符号。
func (x *Float) Format(s fmt.State, format rune)
格式实现了fmt.Formatter。它接受浮点数的所有常规格式（'b'，'e'，'E'，'f'，'F'，'g'，'G'）以及'p'和'v' 。请参阅（* Float）.Text以解释'p'。'v'格式被处理为'g'。格式还支持以数字表示的最小精度，输出字段宽度以及用于符号控制的格式标志'+'和''，空格或零填充为'0'，左或右对齐为' - ' 。有关详细信息，请参阅 fmt 包。
func (z *Float) GobDecode(buf []byte) error
GobDecode实现了gob.GobDecoder接口。除非z的精度为0，否则结果会按z的精度和舍入模式进行舍入，在这种情况下，z将精确设置为解码值。
func (x *Float) GobEncode() ([]byte, error)
GobEncode实现gob.GobEncoder接口。Float值及其所有属性（精度，舍入模式，准确度）将被封送。
func (x *Float) Int(z *Int) (*Int, Accuracy)
Int返回将 x 截断为零的结果；如果 x 是无穷大，则为零。结果是Exact if x.IsInt（）; 否则它是下面的x> 0和上面的x <0。如果提供了非零* Int参数 z，则 Int 将结果存储在z中，而不是分配新的 Int 。
func (x *Float) Int64() (int64, Accuracy)
Int64返回将x截断为零的整数。如果math.MinInt64 <= x <= math.MaxInt64，则结果为Exact（如果x是整数），否则结果为Above（x <0）或Below（x> 0）。结果是（math.MinInt64，Above）for x <math.MinInt64，和（math.MaxInt64，Below）for x> math.MaxInt64。
func (x *Float) IsInf() bool
IsInf报告x是否是+ Inf或-Inf。
func (x *Float) IsInt() bool
IsInt报告 x 是否是整数。±Inf值不是整数。
func (x *Float) MantExp(mant *Float) (exp int)
MantExp将x分成尾数和指数分量并返回指数。如果提供非零mant参数，则其值被设置为x的尾数，具有与x相同的精度和舍入模式。组件满足x == mant×2 ** exp，其中 0.5 <= |mant| < 1.0。用nil参数调用MantExp是获得接收者指数的有效方法。
特殊情况是：
( ±0).MantExp(mant) = 0, with mant set to ±0(±Inf).MantExp(mant) = 0, with mant set to ±Inf
x和mant可以是相同的，在这种情况下x被设置为其尾数值。
func (x *Float) MarshalText() (text []byte, err error)
MarshalText 实现了encoding.TextMarshaler接口。只有浮点值被编组（全精度），其他属性（如精度或精度）被忽略。
func (x *Float) MinPrec() uint
MinPrec 返回精确表示x所需的最小精度（即x.SetPrec（prec）将开始舍入x）之前的最小精度。对于 |x| == 0和|x| == Inf。结果为0
func (x *Float) Mode() RoundingMode
模式返回 x 的舍入模式。
func (z *Float) Mul(x, y *Float) *Float
Mul 将 z 设置为舍入乘积 x * y 并返回 z 。精确度，舍入和准确性报告与 Add 相同。如果一个操作数为零而另一个操作数为无穷大，则 Mul 会与 ErrNaN 发生混乱。在这种情况下 z 的值是未定义的。
func (z *Float) Neg(x *Float) *Float
Neg将z设置为x的（可能为四舍五入的）值，其符号取反，并返回z。
func (z *Float) Parse(s string, base int) (f *Float, b int, err error)
Parse解析 s ，其中必须包含浮点数的文本表示，其中尾数在给定的转换基数（指数始终为十进制数）或表示无限值的字符串中。
它将 z 设置为相应浮点值的（可能为四舍五入的）值，并返回 z，实际的基数 b 和错误错误（如果有的话）。整个字符串（不只是一个前缀）必须被成功消耗。如果z的精度为0，则在舍入生效之前将其更改为64。该号码必须是以下格式：
number = [ sign ] [ prefix ] mantissa [ exponent ] | infinity .sign = "+" | "-" .prefix = "0" ( "x" | "X" | "b" | "B" ) .mantissa = digits | digits "." [ digits ] | "." digits .exponent = ( "E" | "e" | "p" ) [ sign ] digits .digits = digit { digit } .digit = "0" ... "9" | "a" ... "z" | "A" ... "Z" .infinity = [ sign ] ( "inf" | "Inf" ) .基本参数必须是0，2，10或16。提供无效的基本参数将导致运行时恐慌。
对于基数0，数字前缀确定实际基数：“0x”或“0X”的前缀选择基数16，而“0b”或“0B”前缀选择基数2; 否则，实际基数为10，并且不接受前缀。不支持八进制前缀“0”（前导“0”简单地被认为是“0”）。
“p”指数表示二进制（而不是十进制）指数; 例如“0x1.fffffffffffffp1023”（使用基数0）表示float64的最大值。对于十六进制mantissae，指数必须是二进制的（如果存在的话）（“e”或“E”指数指示不能与尾数数字区分开来）。
返回的* Float f是零，并且 z 的值有效，但是如果报告错误则不定义。
func (x *Float) Prec() uint
Prec 以位为单位返回 x 的尾数精度。对于|x| == 0和|x| == Inf，结果可能为0。
func (z *Float) Quo(x, y *Float) *Float
现在将 z 设置为四舍五入的商x/y并返回 z 。精确度，舍入和准确性报告与 Add 相同。如果两个操作数都是零或无穷大，那么现在恐慌与 ErrNaN 。在这种情况下 z 的值是未定义的。
func (x *Float) Rat(z *Rat) (*Rat, Accuracy)
Rat 返回对应于 x 的有理数; 如果 x 是无穷大，则为零。如果 x 不是 Inf，结果是 Exact。如果提供非零* Rat参数 z，则 Rat 将结果存储在 z 中，而不是分配新的 Rat 。
func (z *Float) Scan(s fmt.ScanState, ch rune) error
扫描是fmt.Scanner的支持例程；它将 z 设置为扫描号码的值。它接受fmt.Scan为浮点值支持的动词格式，它们是：'b'（二进制），'e'，'E'，'f'，'F'，'g'和'G'。扫描不处理±Inf。
package mainimport ("fmt""log""math/big")func main() {// 扫描功能很少直接使用;// 禁产条约包承认它是裂变材料条约的一个实施。扫描仪。
f := new(big.Float)
_, err := fmt.Sscan("1.19282e99", f)if err != nil {
log.Println("error scanning value:", err)} else {
fmt.Println(f)}}func (z *Float) Set(x *Float) *Float
将z设置为x的（可能为四舍五入的）值并返回z。如果z的精度为0，则在设置z之前将其更改为x的精度（并且舍入将不起作用）。舍入是根据z的精度和舍入模式执行的; 并且z的准确性报告相对于确切（不是四舍五入）结果的结果错误。
func (z *Float) SetFloat64(x float64) *Float
SetFloat64 将 z 设置为 x 的（可能为四舍五入的）值并返回 z 。如果 z 的精度为0，则其更改为53（并且舍入将不起作用）。如果 x 是 NaN，则 SetFloat64 与 ErrNaN 发生混乱。
func (z *Float) SetInf(signbit bool) *Float
SetInf 将 z 设置为无限Float -Inf（如果设置了符号位）或者+Inf（如果未设置符号位）并返回 z 。z 的精度不变，结果总是精确的。
func (z *Float) SetInt(x *Int) *Float
SetInt将 z 设置为 x 的（可能为四舍五入的）值并返回 z。如果 z 的精度为0，则将其更改为x.BitLen()或64中较大的一个（并且舍入将不起作用）。
func (z *Float) SetInt64(x int64) *Float
SetInt64将 z 设置为 x 的（可能为四舍五入的）值并返回 z。如果z的精度为0，则它变为64（并且舍入将不起作用）。
func (z *Float) SetMantExp(mant *Float, exp int) *Float
SetMantExp 将 z 设置为mant×2 ** exp并返回 z 。结果 z 与 mant 具有相同的精度和舍入模式。SetMantExp 与 MantExp 相反，但不要求 0.5 <= |mant| < 1.0。特别：
mant := new(Float)new(Float).SetMantExp(mant, x.MantExp(mant)).Cmp(x) == 0
特殊情况是：
z.SetMantExp( ±0, exp) = ±0z.SetMantExp(±Inf, exp) = ±Inf
z 和 mant 可以相同，在这种情况下 z 的指数设置为 exp 。
func (z *Float) SetMode(mode RoundingMode) *Float
SetMode 将 z 的舍入模式设置为模式并返回确切的 z 。z 保持不变。z.SetMode(z.Mode())是将 z 的准确性设置为 Exact 的廉价方法。
func (z *Float) SetPrec(prec uint) *Float
SetPrec 将 z 的精度设置为 prec 并返回（可能）z的四舍五入值。如果尾数不能用精确比特表示，并且没有精度损失，则根据z的舍入模式舍入。SetPrec(0) 将所有有限值映射为±0；无限的价值保持不变。如果prec> MaxPrec，则将其设置为 MaxPrec 。
func (z *Float) SetRat(x *Rat) *Float
SetRat 将 z 设置为 x 的（可能是舍入的）值并返回z。如果 z 的精度为0，则将其更改为a.BitLen()，b.BitLen()或64中的最大值；与x = a/ b。
func (z *Float) SetString(s string) (*Float, bool)
SetString 将 z 设置为 s 的值，并返回z和一个表示成功的布尔值。s 必须是一个与 Parse 接受的格式相同的浮点数，其基数为0。整个字符串（不只是前缀）必须对成功有效。如果操作失败，则z的值未定义，但返回值为零。
func (z *Float) SetUint64(x uint64) *Float
SetUint64 将 z 设置为 x 的（可能为四舍五入的）值并返回z。如果 z 的精度为0，则它变为64（并且舍入将不起作用）。
func (x *Float) Sign() int
符号返回：
-1 if x < 0 0 if x is ±0+1 if x > 0
func (x *Float) Signbit() bool
如果 x 是负值或负值，则 Signbit 返回 true 。
func (x *Float) String() string
字符串格式 x，如x.Text（'g'，10）。（字符串必须显式调用，Float.Format不支持％s动词。）
func (z *Float) Sub(x, y *Float) *Float
Sub 将 z 设置为舍入差异 xy 并返回 z 。精确度，舍入和准确性报告与 Add 相同。如果 x 和 y 是等号的无穷大，则会与 ErrNaN 发生混淆。在这种情况下 z 的值是未定义的。
func (x *Float) Text(format byte, prec int) string
文本根据给定的格式和精度 prec 将浮点数 x 转换为一个字符串。格式是以下之一：
'e'-d.dddde±dd, decimal exponent, at least two (possibly 0) exponent digits'E'-d.ddddE±dd, decimal exponent, at least two (possibly 0) exponent digits'f'-ddddd.dddd, no exponent'g' like 'e' for large exponents, like 'f' otherwise'G' like 'E' for large exponents, like 'f' otherwise'b'-ddddddp±dd, binary exponent'p'-0x.dddp±dd, binary exponent, hexadecimal mantissa
对于二进制指数格式，尾数以标准化形式打印：
'b' decimal integer mantissa using x.Prec() bits, or -0'p' hexadecimal fraction with 0.5 <= 0.mantissa < 1.0, or -0
如果格式是不同的字符，则文本将返回“％”，后跟无法识别的格式字符。
precision prec控制由'e'，'E'，'f'，'g'和'G'格式打印的位数（不包括指数）。对于'e'，'E'和'f'，它是小数点后的位数。对于'g'和'G'这是总位数。负精度选择使用x.Pre()尾数位唯一标识值x所需的最小小数位数。“b”或“p”格式的 prec 值将被忽略。
func (x *Float) Uint64() (uint64, Accuracy)
Uint64 返回将 x 截断为零的无符号整数。如果0 <= x <= math.MaxUint64，则结果为 Exact，如果x是一个整数，否则返回 Below。对于x <0，结果为(0，Above)；对于x> math.MaxUint64，结果为（math.MaxUint64，Below）。
func (z *Float) UnmarshalText(text []byte) error
UnmarshalText实现了encoding.TextUnmarshaler接口。结果按z的精度和舍入模式四舍五入。如果z的精度为0，则在舍入生效之前将其更改为64。
Int 表示一个带符号的多精度整数。Int 的零值表示值0。
type Int struct { // 包含筛选或 unexported 字段}func NewInt(x int64) *Int
NewInt 分配并返回一个新的 Int 集到 x 。
func (z *Int) Abs(x *Int) *Int
Abs 将 z 设置为 |x|（x 的绝对值）并返回 z 。
func (z *Int) Add(x, y *Int) *Int
将 z 设置为总和 x + y 并返回 z 。
func (z *Int) And(x, y *Int) *Int
并设置 z = x＆y 并返回 z 。
func (z *Int) AndNot(x, y *Int) *Int
并且不设置 z = x＆^ y 并返回 z 。
func (x *Int) Append(buf []byte, base int) []byte
Append 将由 x.Text（base）生成的 x 的字符串表示形式附加到 buf 并返回扩展缓冲区。
func (z *Int) Binomial(n, k int64) *Int
二项式将 z 设置为 (n, k) 的二项式系数并返回 z 。
func (x *Int) Bit(i int) uint
位返回 x 的第 i 位的值。也就是说，它返回 (x>>i)&1。位索引 i 必须> = 0。
func (x *Int) BitLen() int
BitLen 以位为单位返回 x 的绝对值的长度。0的位长度是0。
func (x *Int) Bits() []Word
位通过返回它的绝对值作为一个小尾端的 Word 片来提供对 x 的原始（未经检查但快速）访问。结果和x共享相同的底层数组。位旨在支持在此包外部实现缺少的低级别 Int 功能；否则应该避免。
func (x *Int) Bytes() []byte
字节返回 x 的绝对值作为大端字节片。
func (x *Int) Cmp(y *Int) (r int)
Cmp 比较 x 和 y 并返回：
-1 if x < y 0 if x == y+1 if x > y
func (z *Int) Div(x, y *Int) *Int
Div 将 z 设置为 y!= 0 的商x / y并返回 z 。如果y == 0，则会发生除零运行时恐慌。Div 实现欧几里德分割（与Go不同）; 请参阅 DivMod 了解更多详情。
func (z *Int) DivMod(x, y, m *Int) (*Int, *Int)
DivMod 将 z 设置为商x div y和m至模x mod y并返回y(y，y)对(z，m)。如果y == 0，则发生除零运行时恐慌。
DivMod 实现欧几里德分割和模数（与Go不同）：
q = x div y such that m = x - y*q with 0 <= m < |y|
（参见Raymond T.Boute，“功能div和mod的欧几里得定义”，ACM Transactions on Programming Languages and Systems（TOPLAS), 14(2):127-144, New York, NY, USA, 4/1992. ACM press）。请参阅QuoRem了解T-分割和模量（如Go）。
func (z *Int) Exp(x, y, m *Int) *Int
Exp 设置 z = x**y mod |m|（即 m 的符号被忽略），并返回z。如果y <= 0，则结果为1 mod |m；如果m == nil或m == 0，则z = x ** y。
特定大小输入的模块化指数不是一个密码恒定时间操作。
func (x *Int) Format(s fmt.State, ch rune)
格式实现了fmt.Formatter。它接受格式'b'（二进制），'o'（八进制），'d'（十进制），'x'（小写十六进制）和'X'（大写十六进制）。还支持整套fmt格式的整型标志，包括用于符号控制的'+'和''，用于八进制和十六进制的前导零，'％'的前导“0”或“0X” #x“和”％＃X“分别指定最小位数精度，输出字段宽度，空格或零填充以及用于左对齐或右对齐的' - '。
func (z *Int) GCD(x, y, a, b *Int) *Int
GCD将z设置为a和b的最大公约数，它们都必须> 0，并返回z。如果x和y不为零，则GCD将x和y设置为z = a * x + b * y。如果a或b <= 0，则GCD设置z = x = y = 0。
func (z *Int) GobDecode(buf []byte) error
GobDecode实现了gob.GobDecoder接口。
func (x *Int) GobEncode() ([]byte, error)
GobEncode 实现 gob.GobEncoder 接口。
func (x *Int) Int64() int64
Int64 返回 x 的 int64 表示形式。如果 x 不能在 int64 中表示，结果是未定义的。
func (x *Int) IsInt64() bool
IsInt64报告x是否可以表示为int64。
func (x *Int) IsUint64() bool
IsUint64 报告 x 是否可以表示为 uint64 。
func (z *Int) Lsh(x *Int, n uint) *Int
Lsh 设置z = x << n并返回 z 。
func (x *Int) MarshalJSON() ([]byte, error)
MarshalJSON实现了json.Marshaler接口。
func (x *Int) MarshalText() (text []byte, err error)
MarshalText 实现了encoding.TextMarshaler接口。
func (z *Int) Mod(x, y *Int) *Int
Mod 将 z 设置为y！= 0的模量x％y并返回 z 。如果y == 0，则会发生除零运行时恐慌。Mod 实现欧几里德模量（与Go不同）; 请参阅 DivMod 了解更多详情。
func (z *Int) ModInverse(g, n *Int) *Int
ModInverse 将 z 设置为环中的 g 的乘法倒数 ℤ/nℤ 并返回 z 。如果 g 和 n 不是相对的素数，结果是不确定的。
func (z *Int) ModSqrt(x, p *Int) *Int
如果这样的平方根存在并且返回 z，则 ModSqrt 将 z 设置为x mod p的平方根。模数 p 必须是一个奇素数。如果 x 不是平方 mod p，则 ModSqrt 保持 z 不变并返回 nil 。如果 p 不是奇数，此函数会发生混乱。
func (z *Int) Mul(x, y *Int) *Int
Mul 将 z 设置为产品 x * y 并返回 z。
func (z *Int) MulRange(a, b int64) *Int
MulRange 将 z 设置为范围a，b中所有整数的乘积，并且返回 z。如果a> b（空范围），结果为1。
func (z *Int) Neg(x *Int) *Int
Neg 将 z 设置为 -x 并返回 z 。
func (z *Int) Not(x *Int) *Int
未设置z = ^ x并返回 z 。
func (z *Int) Or(x, y *Int) *Int
或者设置z = x | y并返回 z 。
func (x *Int) ProbablyPrime(n int) bool
ProbablyPrime 报告 x 是否可能是素数，用 n 个伪随机选择的碱基以及 Baillie-PSW 测试应用 Miller-Rabin 测试。
如果 x 是素数，则 ProbablyPrime 返回 true 。如果 x 随机选择而不是素数，则 ProbablyPrime 可能返回 false 。对于随机选择的非素数返回真的概率至多为1/4。
对于小于2⁶4的输入，ProbablyPrime 100％准确。关于误差概率的进一步讨论参见 Menezes 等人，应用密码学手册，1997年，第145-149页和 FIPS 186-4 附录 F.
ProbablyPrime 不适用于判断对手可能制造出来欺骗测试的素数。
从 Go 1.8 开始，ProbablyPrime(0)是允许的，仅适用于 Baillie-PSW 测试。在Go 1.8之前，ProbablyPrime 只应用 Miller-Rabin 测试，而 ProbablyPrime(0) 恐慌。
func (z *Int) Quo(x, y *Int) *Int
现在将 z 设置为y！= 0的商 x / y 并返回 z 。如果y == 0，则会发生除零运行时恐慌。现在实现截断分裂（像Go）; 请参阅 QuoRem 了解更多详情。
func (z *Int) QuoRem(x, y, r *Int) (*Int, *Int)
QuoRem 将 z 设置为商 x/y，将 r 设置为余数 x％y，并返回 y(y)= 0 时的对 (z, r) 。如果 y == 0，则会发生除零运行时恐慌。
QuoRem implements T-division and modulus (like Go):
q = x/y with the result truncated to zero r = x - y*q
（请参阅Daan Leijen，“计算机科学家的分部和模数”。）请参见DivMod的欧几里德除法和模数（与 Go 不同）。
func (z *Int) Rand(rnd *rand.Rand, n *Int) *Int
Rand 将 z 设置为[0，n）中的伪随机数并返回 z 。
func (z *Int) Rem(x, y *Int) *Int
Rem 将 z 设置为y！= 0的余数 x％y 并返回 z 。如果 y == 0，则会发生除零运行时恐慌。Rem 实现截断模数（如Go）; 请参阅 QuoRem 了解更多详情。
func (z *Int) Rsh(x *Int, n uint) *Int
Rsh 设置z = x >> n并返回 z 。
func (z *Int) Scan(s fmt.ScanState, ch rune) error
扫描是fmt.Scanner的支持例程; 它将z设置为扫描号码的值。它接受格式'b'（二进制），'o'（八进制），'d'（十进制），'x'（小写十六进制）和'X'（大写十六进制）。
package mainimport ("fmt""log""math/big")func main() {// The Scan function is rarely used directly;// the fmt package recognizes it as an implementation of fmt.Scanner.
i := new(big.Int)
_, err := fmt.Sscan("18446744073709551617", i)if err != nil {
log.Println("error scanning value:", err)} else {
fmt.Println(i)}}func (z *Int) Set(x *Int) *Int
将 z 设置为 x 并返回 z 。
func (z *Int) SetBit(x *Int, i int, b uint) *Int
SetBit 将 z 设置为 x，并将 x 的第 i 位设置为 b（0或1）。也就是说，如果 b 是1，SetBit 设置z = x | (1 << i)； 如果 b为0，SetBit 设置 z = x &^ (1 << i) 。如果 b不是0或1，SetBit 将会发生混乱。
func (z *Int) SetBits(abs []Word) *Int
SetBits 通过将其值设置为 abs，解释为 little-endian Word 切片并返回 z ，提供对 z 的原始（未检查但快速）访问。结果和 abs 共享相同的底层数组。SetBits 旨在支持在此包外部实现缺少的低级别 Int 功能；否则应该避免。
func (z *Int) SetBytes(buf []byte) *Int
SetBytes 将 buf 解释为大端无符号整数的字节，将z设置为该值并返回 z 。
func (z *Int) SetInt64(x int64) *Int
SetInt64 将 z 设置为 x 并返回 z 。
func (z *Int) SetString(s string, base int) (*Int, bool)
SetString 将 z 设置为 s 的值，在给定的基础中进行解释，并返回 z 和一个表示成功的布尔值。整个字符串（不只是一个前缀）必须对成功有效。如果 SetString 失败，则z的值未定义，但返回值为零。
基本参数必须为0或介于2和 MaxBase 之间的值。如果基数为0，则字符串前缀将确定实际的转换基数。前缀“0x”或“0X”选择基址16；“0”前缀选择基数8，而“0b”或“0B”前缀选择基数2，否则选择的基数为10。
package mainimport ("fmt""math/big")func main() {
i := new(big.Int)
i.SetString("644", 8) // octal
fmt.Println(i)}func (z *Int) SetUint64(x uint64) *Int
SetUint64 将 z 设置为 x 并返回 z 。
func (x *Int) Sign() int
符号返回：
-1 if x < 0 0 if x == 0+1 if x > 0
func (z *Int) Sqrt(x *Int) *Int
Sqrt 将 z 设置为⌊√x⌋，即 z²≤x 的最大整数，并返回 z 。如果 x 是负数，它会发生恐慌。
func (x *Int) String() string
func (z *Int) Sub(x, y *Int) *Int
Sub 将 z 设置为差值 xy 并返回 z 。
func (x *Int) Text(base int) string
文本返回给定基础中 x 的字符串表示形式。基数必须介于2和36之间，包括2和36。结果对数字值> = 10使用小写字母'a'到'z'。没有基本前缀（例如“0x”）被添加到字符串中。
func (x *Int) Uint64() uint64
Uint64 返回 x 的 uint64 表示。如果 x 不能在 uint64 中表示，结果是未定义的。
func (z *Int) UnmarshalJSON(text []byte) error
UnmarshalJSON 实现了 json.Unmarshaler 接口。
func (z *Int) UnmarshalText(text []byte) error
UnmarshalText实现了encoding.TextUnmarshaler接口。
func (z *Int) Xor(x, y *Int) *Int
Xor 设置z = x ^ y并返回 z 。
Rat 表示任意精度的商 a/b 。Rat 的零值表示值0。
type Rat struct { // 包含筛选或 unexported 字段}func NewRat(a, b int64) *Rat
NewRat 用分子 a 和分母 b 创建一个新的 Rat 。
func (z *Rat) Abs(x *Rat) *Rat
Abs 将 z 设置为|x|（x的绝对值）并返回 z 。
func (z *Rat) Add(x, y *Rat) *Rat
将 z 设置为总和 x + y 并返回 z 。
func (x *Rat) Cmp(y *Rat) int
Cmp 比较 x 和 y 并返回：
-1 if x < y 0 if x == y+1 if x > y
func (x *Rat) Denom() *Int
Denom 返回 x 的分母；它始终> 0。结果是对x的分母的引用；如果新的值被分配给 x ，它可能会改变，反之亦然。
func (x *Rat) Float32() (f float32, exact bool)
Float32 返回 x 的最接近的 float32 值和一个 bool，指示 f 是否准确地表示 x 。如果 x 的大小太大而不能用 float32 表示，则 f 是无穷大，精确是错误的。f 的符号总是匹配 x 的符号，即使 f == 0 。
func (x *Rat) Float64() (f float64, exact bool)
Float64 返回 x 的最接近的 float64 值和一个 bool 指示 f 是否完全代表 x 。如果 x 的大小太大而不能用 float64 表示，则 f 是无穷大，精确是错误的。f 的符号总是匹配 x 的符号，即使 f == 0 。
func (x *Rat) FloatString(prec int) string
FloatString 以十进制形式返回 x 的字符串表示形式，小数点后的精度为精度数字。最后一位数字四舍五入到最接近的位置，其中一半从零圆整。
func (z *Rat) GobDecode(buf []byte) error
GobDecode 实现了 gob.GobDecoder 接口。
func (x *Rat) GobEncode() ([]byte, error)
GobEncode 实现 gob.GobEncoder 接口。
func (z *Rat) Inv(x *Rat) *Rat
Inv 将 z 设置为 1/x 并返回 z 。
func (x *Rat) IsInt() bool
IsInt 报告 x 的分母是否为1。
func (x *Rat) MarshalText() (text []byte, err error)
MarshalText 实现了encoding.TextMarshaler接口。
func (z *Rat) Mul(x, y *Rat) *Rat
Mul 将 z 设置为产品 x * y 并返回 z 。
func (z *Rat) Neg(x *Rat) *Rat
Neg 将 z 设置为 -x 并返回 z 。
func (x *Rat) Num() *Int
Num 返回 x 的分子；它可能<= 0。结果是对 x 的分子的引用；如果新的值被分配给 x，它可能会改变，反之亦然。分子的符号对应于 x 的符号。
func (z *Rat) Quo(x, y *Rat) *Rat
现在将 z 设为商 x/y 并返回 z 。如果 y == 0，则会发生除零运行时恐慌。
func (x *Rat) RatString() string
如果b！= 1，RatString 返回 x 形式的字符串表示形式“a/b”，如果b == 1则形式为“a”形式。
func (z *Rat) Scan(s fmt.ScanState, ch rune) error
扫描是fmt.Scanner的支持例程。它接受格式'e'，'E'，'f'，'F'，'g'，'G'和'v'。所有格式都是相同的。
package mainimport ("fmt""log""math/big")func main() {// 扫描功能很少直接使用;// 禁产条约包承认它是裂变材料条约的一个实施。扫描仪。
r := new(big.Rat)
_, err := fmt.Sscan("1.5000", r)if err != nil {
log.Println("error scanning value:", err)} else {
fmt.Println(r)}}func (z *Rat) Set(x *Rat) *Rat
将 z 设置为 x（通过制作 x 的副本）并返回 z 。
func (z *Rat) SetFloat64(f float64) *Rat
SetFloat64 将 z 设置为完全 f 并返回 z 。如果 f 不是有限的，SetFloat 返回 nil 。
func (z *Rat) SetFrac(a, b *Int) *Rat
SetFrac 将 z 设置为 a/b 并返回 z 。
func (z *Rat) SetFrac64(a, b int64) *Rat
SetFrac64 将 z 设置为 a/b 并返回 z 。
func (z *Rat) SetInt(x *Int) *Rat
SetInt 将 z 设置为 x（通过制作x的副本）并返回 z 。
func (z *Rat) SetInt64(x int64) *Rat
SetInt64 将 z 设置为 x 并返回 z 。
func (z *Rat) SetString(s string) (*Rat, bool)
SetString 将 z 设置为 s 的值，并返回 z 和一个表示成功的布尔值。s 可以作为分数 “a/b” 给出，也可以作为浮点数可选地跟随一个指数。整个字符串（不只是一个前缀）必须对成功有效。如果操作失败，则z的值未定义，但返回值为零。
package mainimport ("fmt""math/big")func main() {
r := new(big.Rat)
r.SetString("355/113")
fmt.Println(r.FloatString(3))}func (x *Rat) Sign() int
符号返回：
-1 if x < 0 0 if x == 0+1 if x > 0
func (x *Rat) String() string
字符串以“a/b”的形式返回x的字符串表示形式（即使b == 1）。
func (z *Rat) Sub(x, y *Rat) *Rat
Sub 将 z 设置为差值 xy 并返回 z 。
func (z *Rat) UnmarshalText(text []byte) error
UnmarshalText实现了encoding.TextUnmarshaler接口。
RoundingMode 确定浮点值如何四舍五入到所需的精度。舍入可能会改变浮点值；舍入误差由Float's Accuracy 描述。
type RoundingMode byte
这些常量定义了支持的舍入模式。
const ( ToNearestEven RoundingMode = iota // == IEEE 754-2008 roundTiesToEven ToNearestAway // == IEEE 754-2008 roundTiesToAway ToZero // == IEEE 754-2008 roundTowardZero AwayFromZero // no IEEE 754-2008 equivalent ToNegativeInf // == IEEE 754-2008 roundTowardNegative ToPositiveInf // == IEEE 754-2008 roundTowardPositive)
package mainimport ("fmt""math/big")func main() {
operands := []float64{2.6, 2.5, 2.1, -2.1, -2.5, -2.6}
fmt.Print(" x")for mode := big.ToNearestEven; mode <= big.ToPositiveInf; mode++ {
fmt.Printf(" %s", mode)}
fmt.Println()for _, f64 := range operands {
fmt.Printf("%4g", f64)for mode := big.ToNearestEven; mode <= big.ToPositiveInf; mode++ {// sample operands above require 2 bits to represent mantissa// set binary precision to 2 to round them to integer values
f := new(big.Float).SetPrec(2).SetMode(mode).SetFloat64(f64)
fmt.Printf(" %*g", len(mode.String()), f)}
fmt.Println()}}func (i RoundingMode) String() string
Word 表示多精度无符号整数的单个数字。
type Word uint
☞ 舍入 ToNegativeInf 时，Float 值的符号舍入为0是不正确的。