big

package big

import "math/big"

Package big 实现任意精度算术（大数）。支持以下数值类型：

Int    有符号整数
Rat    有理数
Float  浮点数

Int、Rat 或 Float 的零值对应于 0。因此，可以按通常方式声明新值，它们无需进一步初始化即可表示 0：

var x Int        // &x is an *Int of value 0
var r = &Rat{}   // r is a *Rat of value 0
y := new(Float)  // y is a *Float of value 0

此外，也可以使用如下形式的工厂函数来分配并初始化新值：

func NewT(v V) *T

例如，NewInt(x) 返回一个 *Int，其被设为 int64 参数 x 的值；NewRat(a, b) 返回一个 *Rat，其被设为分数 a/b，其中 a 和 b 是 int64 值；NewFloat(f) 返回一个 *Float，其被初始化为 float64 参数 f。通过显式的 setter 可以提供更大的灵活性，例如：

var z1 Int
z1.SetUint64(123)                 // z1 := 123
z2 := new(Rat).SetFloat64(1.25)   // z2 := 5/4
z3 := new(Float).SetInt(z1)       // z3 := 123.0

Setter、数值运算和谓词表示为如下形式的方法：

func (z *T) SetV(v V) *T          // z = v
func (z *T) Unary(x *T) *T        // z = unary x
func (z *T) Binary(x, y *T) *T    // z = x binary y
func (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 累加到 sum 中。

（通过始终经由接收者传入结果值，可以更好地控制内存使用。运算无需为每个结果分配新内存，而是可以重用为结果值分配的空间，并在过程中用新结果覆盖该值。）

命名约定：传入的方法参数（包括接收者）在 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 外）满足 Formatter 接口以进行格式化打印。

Example (EConvergents)

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).

package main

import (
	"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 == 1
func 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))
	}

}

Output:

2/1           = 2.00000000
3/1           = 3.00000000
8/3           = 2.66666667
11/4          = 2.75000000
19/7          = 2.71428571
87/32         = 2.71875000
106/39        = 2.71794872
193/71        = 2.71830986
1264/465      = 2.71827957
1457/536      = 2.71828358
2721/1001     = 2.71828172
23225/8544    = 2.71828184
25946/9545    = 2.71828182
49171/18089   = 2.71828183
517656/190435 = 2.71828183

Example (Fibonacci)

This example demonstrates how to use big.Int to compute the smallest Fibonacci number with 100 decimal digits and to test whether it is prime.

package main

import (
	"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))

}

Output:

1344719667586153181419716641724567886890850696275767987106294472017884974410332069524504824747437757
false

Example (Sqrt2)

This example shows how to use big.Float to compute the square root of 2 with a precision of 200 bits, and how to print the result as a decimal number.

package main

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

func main() {
	// We'll do computations with 200 bits of precision in the mantissa.
	const prec = 200

	// Compute the square root of 2 using Newton's Method. We start with
	// an initial estimate for sqrt(2), and then iterate:
	//     x_{n+1} = 1/2 * ( x_n + (2.0 / x_n) )

	// Since Newton's Method doubles the number of correct digits at each
	// iteration, we need at least log_2(prec) steps.
	steps := int(math.Log2(prec))

	// Initialize values we need for the computation.
	two := new(big.Float).SetPrec(prec).SetInt64(2)
	half := new(big.Float).SetPrec(prec).SetFloat64(0.5)

	// Use 1 as the initial estimate.
	x := new(big.Float).SetPrec(prec).SetInt64(1)

	// We use t as a temporary variable. There's no need to set its precision
	// since big.Float values with unset (== 0) precision automatically assume
	// the largest precision of the arguments when used as the result (receiver)
	// of a big.Float operation.
	t := new(big.Float)

	// Iterate.
	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
	}

	// We can use the usual fmt.Printf verbs since big.Float implements fmt.Formatter
	fmt.Printf("sqrt(2) = %.50f\n", x)

	// Print the error between 2 and x*x.
	t.Mul(x, x) // t = x*x
	fmt.Printf("error = %e\n", t.Sub(two, t))

}

Output:

sqrt(2) = 1.41421356237309504880168872420969807856967187537695
error = 0.000000e+00

Index

Constants
func Jacobi(x, y *Int) int
type Accuracy
- func (i Accuracy) String() string
type ErrNaN
- func (err ErrNaN) Error() string
type Float
type Int
type Rat
type RoundingMode
- func (i RoundingMode) String() string
type Word

Constants

const (
	MaxExp  = math.MaxInt32  // 支持的最大指数
	MinExp  = math.MinInt32  // 支持的最小指数
	MaxPrec = math.MaxUint32 // （理论上）支持的最大精度；可能受内存限制
)

指数和精度限制。

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

MaxBase 是字符串转换所接受的最大数字基数。

Functions

func Jacobi

func Jacobi(x, y *Int) int

Jacobi 返回 Jacobi 符号 (x/y)，其值为 +1、-1 或 0。 y 参数必须是奇整数。

Types

type Accuracy

type Accuracy int8

Accuracy 描述生成 Float 值的最近一次操作所产生的、相对于精确值的舍入误差。

const (
	Below Accuracy = -1
	Exact Accuracy = 0
	Above Accuracy = +1
)

描述 Float 的 Accuracy 的常量。

func (Accuracy) String

func (i Accuracy) String() string

type ErrNaN

type ErrNaN struct {
	// contains filtered or unexported fields
}

Float 操作若在 IEEE 754 规则下会产生 NaN，则会引发 ErrNaN panic。ErrNaN 实现了 error 接口。

func (ErrNaN) Error

func (err ErrNaN) Error() string

type Float

type Float struct {
	// contains filtered or unexported fields
}

非零有限 Float 表示一个多精度浮点数

sign × mantissa × 2**exponent

满足 0.5 <= mantissa < 1.0，且 MinExp <= exponent <= MaxExp。 Float 也可以为零 (+0, -0) 或无穷 (+Inf, -Inf)。所有 Float 都是有序的，两个 Float x 和 y 的顺序由 x.Cmp(y) 定义。

每个 Float 值还带有一个精度、舍入模式和准确性。精度是可用于表示该值的尾数位的最大数量。舍入模式规定了结果应如何舍入以适配尾数位，准确性则描述相对于精确结果的舍入误差。

除非另有说明，所有为结果指定了 *Float 变量（通常通过接收者，Float.MantExp 除外）的操作（包括 setter），都会根据结果变量的精度和舍入模式对数值结果进行舍入。

如果提供的结果精度为 0（见下文），则在进行任何舍入之前，它会被设为精度值最大的那个参数的精度，且舍入模式保持不变。因此，作为结果参数提供的未初始化 Float 会将其精度设为由操作数决定的合理值，其模式为 RoundingMode 的零值 (ToNearestEven)。

通过将所需精度设为 24 或 53 并使用匹配的舍入模式（通常是 ToNearestEven），对于对应普通（即非非规格化） float32 或 float64 数的操作数，Float 运算会产生与相应的 float32 或 float64 IEEE 754 算术相同的结果。指数下溢和上溢会导致与 IEEE 754 不同的值（0 或无穷），因为 Float 的指数范围要大得多。

Float 的零（未初始化）值可直接使用，它精确表示数 +0.0，精度为 0 且舍入模式为 ToNearestEven。

操作始终接受指针参数 (*Float) 而非 Float 值，每个唯一的 Float 值都需要其自己唯一的 *Float 指针。要“复制”一个 Float 值，必须使用 Float.Set 方法将现有的（或新分配的）Float 设为新值；不支持 Float 的浅拷贝，且浅拷贝可能导致错误。

Example (Shift)

package main

import (
	"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)
	}
}

Output:

func NewFloat

func NewFloat(x float64) *Float

NewFloat 分配并返回一个设为 x 的新 Float，其精度为 53，舍入模式为 ToNearestEven。若 x 为 NaN，NewFloat 会 panic 并给出 ErrNaN。

func ParseFloat

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

ParseFloat 类似于 f.Parse(s, base)，其中 f 被设置为给定的精度和舍入模式。

func (*Float) Abs

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

Abs 将 z 设为 |x| 的（可能已舍入的）值（x 的绝对值）并返回 z。

func (*Float) Acc

func (x *Float) Acc() Accuracy

Acc 返回最近一次操作所产生的 x 的准确性，除非该操作另有明确说明。

func (*Float) Add

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

Add 将 z 设为舍入后的和 x+y 并返回 z。若 z 的精度为 0，则在操作前将其改为 x 与 y 中较大的精度。舍入根据 z 的精度和舍入模式执行；z 的准确性报告结果相对于精确（未舍入）结果的误差。若 x 和 y 是符号相反的无穷，Add 会 panic 并给出 ErrNaN。此时 z 的值未定义。

Example

package main

import (
	"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())
}

Output:

x = 1000 (0x.fap+10, prec = 64, acc = Exact)
y = 2.718281828 (0x.adf85458248cd8p+2, prec = 53, acc = Exact)
z = 1002.718282 (0x.faadf854p+10, prec = 32, acc = Below)

func (*Float) Append

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

Append 将由 x.Text 生成的浮点数 x 的字符串形式追加到 buf，并返回扩展后的缓冲区。

func (*Float) AppendText

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

AppendText 实现 encoding.TextAppender 接口。仅编组 Float 值（全精度），精度或准确性等其他属性会被忽略。

func (*Float) Cmp

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

Cmp 比较 x 和 y 并返回：

若 x < y，返回 -1；
若 x == y（包括 -0 == 0、-Inf == -Inf 和 +Inf == +Inf），返回 0；
若 x > y，返回 +1。

Example

package main

import (
	"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()
	}

}

Output:

   x     y  cmp
---------------
-Inf  -Inf    0
-Inf  -1.2   -1
-Inf    -0   -1
-Inf     0   -1
-Inf   1.2   -1
-Inf  +Inf   -1

-1.2  -Inf    1
-1.2  -1.2    0
-1.2    -0   -1
-1.2     0   -1
-1.2   1.2   -1
-1.2  +Inf   -1

  -0  -Inf    1
  -0  -1.2    1
  -0    -0    0
  -0     0    0
  -0   1.2   -1
  -0  +Inf   -1

   0  -Inf    1
   0  -1.2    1
   0    -0    0
   0     0    0
   0   1.2   -1
   0  +Inf   -1

 1.2  -Inf    1
 1.2  -1.2    1
 1.2    -0    1
 1.2     0    1
 1.2   1.2    0
 1.2  +Inf   -1

+Inf  -Inf    1
+Inf  -1.2    1
+Inf    -0    1
+Inf     0    1
+Inf   1.2    1
+Inf  +Inf    0

func (*Float) Copy

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

Copy 将 z 设为 x，其精度、舍入模式和准确性与 x 相同。 Copy 返回 z。若 x 和 z 相同，Copy 是空操作。

Example

package main

import (
	"fmt"
	"math/big"
)

func main() {
	var x, z big.Float

	x.SetFloat64(1.23)
	r := z.Copy(&x)
	fmt.Printf("a) r = %g, z = %g, x = %g, r == z = %v\n", r, &z, &x, r == &z)

	// changing z changes r since they are identical
	z.SetInt64(42)
	fmt.Printf("b) r = %g, z = %g, r == z = %v\n", r, &z, r == &z)

	x.SetPrec(1)
	z.Copy(&x)
	fmt.Printf("c) z = %g, x = %g, z == x = %v\n", &z, &x, &z == &x)

}

Output:

a) r = 1.23, z = 1.23, x = 1.23, r == z = true
b) r = 42, z = 42, r == z = true
c) z = 1, x = 1, z == x = false

func (*Float) Float32

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

Float32 返回最接近 x 的 float32 值。若 x 太小以致无法用 float32 表示（|x| < math.SmallestNonzeroFloat32），则结果根据 x 的符号分别为 (0, Below) 或 (-0, Above)。若 x 太大以致无法用 float32 表示（|x| > math.MaxFloat32），则结果根据 x 的符号为 (+Inf, Above) 或 (-Inf, Below)。

func (*Float) Float64

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

Float64 返回最接近 x 的 float64 值。若 x 太小以致无法用 float64 表示（|x| < math.SmallestNonzeroFloat64），则结果根据 x 的符号分别为 (0, Below) 或 (-0, Above)。若 x 太大以致无法用 float64 表示（|x| > math.MaxFloat64），则结果根据 x 的符号为 (+Inf, Above) 或 (-Inf, Below)。

func (*Float) Format

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

Format 实现 fmt.Formatter。它接受浮点数的所有常规格式（'b'、'e'、'E'、'f'、'F'、'g'、'G'、'x'）以及 'p' 和 'v'。 'p' 的含义参见 (*Float).Text。'v' 格式的处理方式与 'g' 相同。 Format 还支持指定以数字表示的最小精度、输出字段宽度，以及用于符号控制的格式标志 '+' 和 ' '、用于空格或零填充的 '0'，以及用于左对齐或右对齐的 '-'。详情参见 fmt 包。

func (*Float) GobDecode

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

GobDecode 实现 encoding/gob.GobDecoder 接口。结果按照 z 的精度和舍入模式进行舍入，除非 z 的精度为 0，此时 z 会被精确地设置为解码后的值。

func (*Float) GobEncode

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

GobEncode 实现 encoding/gob.GobEncoder 接口。 Float 值及其所有属性（精度、舍入模式、准确性）都会被编组。

func (*Float) Int

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

Int 返回将 x 向零截断的结果；若 x 为无穷则返回 nil。若 x.IsInt() 则结果为 Exact；否则对于 x > 0 为 Below，对于 x < 0 为 Above。若提供了非 nil 的 *Int 参数 z，Int 会将结果存储在 z 中，而不是分配新的 Int。

func (*Float) Int64

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

Int64 返回将 x 向零截断得到的整数。若 math.MinInt64 <= x <= math.MaxInt64，则当 x 为整数时结果为 Exact，否则为 Above（x < 0）或 Below（x > 0）。对于 x < math.MinInt64，结果为 (math.MinInt64, Above)；对于 x > math.MaxInt64，结果为 (math.MaxInt64, Below)。

func (*Float) IsInf

func (x *Float) IsInf() bool

IsInf 报告 x 是否为 +Inf 或 -Inf。

func (*Float) IsInt

func (x *Float) IsInt() bool

IsInt 报告 x 是否为整数。 ±Inf 值不是整数。

func (*Float) MantExp

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

MantExp 将 x 分解为尾数和指数两部分，并返回指数。若提供了非 nil 的 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 (*Float) MarshalText

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

MarshalText 实现 encoding.TextMarshaler 接口。仅编组 Float 值（全精度），精度或准确性等其他属性会被忽略。

func (*Float) MinPrec

func (x *Float) MinPrec() uint

MinPrec 返回精确表示 x 所需的最小精度（即 x.SetPrec(prec) 开始对 x 舍入之前的最小 prec）。对于 |x| == 0 和 |x| == Inf，结果为 0。

func (*Float) Mode

func (x *Float) Mode() RoundingMode

Mode 返回 x 的舍入模式。

func (*Float) Mul

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

Mul 将 z 设为舍入后的积 x*y 并返回 z。精度、舍入和准确性报告与 Float.Add 相同。若一个操作数为零而另一个操作数为无穷，Mul 会 panic 并给出 ErrNaN。此时 z 的值未定义。

func (*Float) Neg

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

Neg 将 z 设为 x 的（可能已舍入的）值并取反其符号，并返回 z。

func (*Float) Parse

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

Parse 解析 s，s 必须包含给定转换进制下带尾数的浮点数文本表示（指数始终是十进制数），或者是表示无穷值的字符串。

对于进制 0，下划线字符 “_” 可以出现在进制前缀与相邻数字之间，以及连续数字之间；这样的下划线不会改变数字的值，也不会改变返回的数字个数。如果没有其他错误，下划线位置不正确会报告为错误。如果 base != 0，则不识别下划线，因此会像任何其他不是有效小数点或数字的字符一样终止扫描。

它将 z 设置为对应浮点值的（可能经过舍入的）值，并返回 z、实际使用的进制 b，以及错误 err（如果有）。成功时必须消费整个字符串（不只是前缀）。如果 z 的精度为 0，则在舍入生效之前会被改为 64。数字必须具有以下形式：

number    = [ sign ] ( float | "inf" | "Inf" ) .
sign      = "+" | "-" .
float     = ( mantissa | prefix pmantissa ) [ exponent ] .
prefix    = "0" [ "b" | "B" | "o" | "O" | "x" | "X" ] .
mantissa  = digits "." [ digits ] | digits | "." digits .
pmantissa = [ "_" ] digits "." [ digits ] | [ "_" ] digits | "." digits .
exponent  = ( "e" | "E" | "p" | "P" ) [ sign ] digits .
digits    = digit { [ "_" ] digit } .
digit     = "0" ... "9" | "a" ... "z" | "A" ... "Z" .

base 参数必须是 0、2、8、10 或 16。提供无效的 base 参数会导致运行时 panic。

对于进制 0，数字前缀决定实际使用的进制：“0b” 或 “0B” 选择进制 2， “0o” 或 “0O” 选择进制 8，“0x” 或 “0X” 选择进制 16。否则，实际进制为 10，且不接受前缀。不支持八进制前缀 "0"（前导的 "0" 会被直接视为 "0"）。

"p" 或 "P" 指数表示以 2 为底（而非以 10 为底）的指数；例如， "0x1.fffffffffffffp1023"（使用进制 0）表示最大的 float64 值。对于十六进制尾数，如果存在指数字符，则必须是 'p' 或 'P' 之一（"e" 或 "E" 指数指示符无法与尾数数字区分开）。

如果报告了错误，返回的 *Float f 为 nil，z 的值有效但未定义。

func (*Float) Prec

func (x *Float) Prec() uint

Prec 返回 x 的尾数精度（以位为单位）。对于 |x| == 0 和 |x| == Inf，结果可能为 0。

func (*Float) Quo

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

Quo 将 z 设为舍入后的商 x/y 并返回 z。精度、舍入和准确性报告与 Float.Add 相同。若两个操作数都为零或都为无穷，Quo 会 panic 并给出 ErrNaN。此时 z 的值未定义。

func (*Float) Rat

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

Rat 返回与 x 对应的有理数；若 x 为无穷则返回 nil。若 x 不是 Inf，则结果为 Exact。若提供了非 nil 的 *Rat 参数 z，Rat 会将结果存储在 z 中，而不是分配新的 Rat。

func (*Float) Scan

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

Scan 是 fmt.Scanner 的辅助例程；它将 z 设置为所扫描数字的值。它接受 fmt.Scan 对浮点值所支持的动词格式，即： 'b'（二进制）、'e'、'E'、'f'、'F'、'g' 和 'G'。 Scan 不处理 ±Inf。

Example

package main

import (
	"fmt"
	"log"
	"math/big"
)

func main() {
	// The Scan function is rarely used directly;
	// the fmt package recognizes it as an implementation of fmt.Scanner.
	f := new(big.Float)
	_, err := fmt.Sscan("1.19282e99", f)
	if err != nil {
		log.Println("error scanning value:", err)
	} else {
		fmt.Println(f)
	}
}

Output:

1.19282e+99

func (*Float) Set

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

Set 将 z 设为 x 的（可能已舍入的）值并返回 z。若 z 的精度为 0，则在设置 z 之前将其改为 x 的精度（此时舍入没有任何效果）。舍入根据 z 的精度和舍入模式执行；z 的准确性报告结果相对于精确（未舍入）结果的误差。

func (*Float) SetFloat64

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

SetFloat64 将 z 设为 x 的（可能已舍入的）值并返回 z。若 z 的精度为 0，则将其改为 53（此时舍入没有任何效果）。若 x 为 NaN，SetFloat64 会 panic 并给出 ErrNaN。

func (*Float) SetInf

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

若 signbit 被置位，SetInf 将 z 设为无穷 Float -Inf，否则设为 +Inf，并返回 z。z 的精度保持不变，且结果始终为 Exact。

func (*Float) SetInt

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

SetInt 将 z 设为 x 的（可能已舍入的）值并返回 z。若 z 的精度为 0，则将其改为 x.BitLen() 与 64 中的较大者（此时舍入没有任何效果）。

func (*Float) SetInt64

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

SetInt64 将 z 设为 x 的（可能已舍入的）值并返回 z。若 z 的精度为 0，则将其改为 64（此时舍入没有任何效果）。

func (*Float) SetMantExp

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

SetMantExp 将 z 设为 mant × 2**exp 并返回 z。结果 z 的精度和舍入模式与 mant 相同。 SetMantExp 是 Float.MantExp 的逆操作，但不要求 0.5 <= |mant| < 1.0。具体而言，对于给定的 *Float 类型的 x，SetMantExp 与 Float.MantExp 的关系如下：

mant := new(Float)
new(Float).SetMantExp(mant, x.MantExp(mant)).Cmp(x) == 0

特殊情况有：

z.SetMantExp(  ±0, exp) =   ±0
z.SetMantExp(±Inf, exp) = ±Inf

z 和 mant 可以相同，此时 z 的指数被设为 exp。

func (*Float) SetMode

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

SetMode 将 z 的舍入模式设为 mode，并返回精确的 z。除此之外 z 保持不变。 z.SetMode(z.Mode()) 是将 z 的准确性设为 Exact 的廉价方式。

func (*Float) SetPrec

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

SetPrec 将 z 的精度设为 prec，并返回 z 的（可能已舍入的）值。若尾数无法在不损失精度的情况下用 prec 位表示，则根据 z 的舍入模式进行舍入。 SetPrec(0) 将所有有限值映射为 ±0；无穷值保持不变。若 prec > MaxPrec，则将其设为 MaxPrec。

func (*Float) SetRat

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

SetRat 将 z 设为 x 的（可能已舍入的）值并返回 z。若 z 的精度为 0，则将其改为 a.BitLen()、b.BitLen() 与 64 中的最大者；其中 x = a/b。

func (*Float) SetString

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

SetString 将 z 设置为 s 的值，并返回 z 和一个表示成功与否的布尔值。 s 必须是格式与 Float.Parse 所接受格式相同的浮点数，且 base 参数为 0。成功时整个字符串（不只是前缀）都必须有效。如果操作失败， z 的值未定义，但返回的值为 nil。

Example

package main

import (
	"fmt"
	"math/big"
)

func main() {
	f := new(big.Float)
	f.SetString("3.14159")
	fmt.Println(f)
}

Output:

3.14159

func (*Float) SetUint64

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

SetUint64 将 z 设为 x 的（可能已舍入的）值并返回 z。若 z 的精度为 0，则将其改为 64（此时舍入没有任何效果）。

func (*Float) Sign

func (x *Float) Sign() int

Sign 返回：

若 x < 0，返回 -1；
若 x 为 ±0，返回 0；
若 x > 0，返回 +1。

func (*Float) Signbit

func (x *Float) Signbit() bool

Signbit 报告 x 是否为负数或负零。

func (*Float) Sqrt

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

Sqrt 将 z 设为 x 的舍入后的平方根，并返回它。

如果 z 的精度为 0，则在操作前将其改为 x 的精度。舍入根据 z 的精度和舍入模式进行，但不会计算 z 的准确度。具体来说，z.Acc() 的结果是未定义的。

如果 z < 0，该函数会 panic。在这种情况下 z 的值未定义。

func (*Float) String

func (x *Float) String() string

String 像 x.Text('g', 10) 一样格式化 x。（必须显式调用 String，Float.Format 不支持 %s 动词。）

func (*Float) Sub

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

Sub 将 z 设为舍入后的差 x-y 并返回 z。精度、舍入和准确性报告与 Float.Add 相同。若 x 和 y 是符号相同的无穷，Sub 会 panic 并给出 ErrNaN。此时 z 的值未定义。

func (*Float) Text

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

Text 按照给定的格式和精度 prec 将浮点数 x 转换为字符串。格式为以下之一：

'e'	-d.dddde±dd，十进制指数，至少两位（可能为 0）指数数字
'E'	-d.ddddE±dd，十进制指数，至少两位（可能为 0）指数数字
'f'	-ddddd.dddd，无指数
'g'	对大指数像 'e'，否则像 'f'
'G'	对大指数像 'E'，否则像 'f'
'x'	-0xd.dddddp±dd，十六进制尾数，十进制表示的 2 的幂指数
'p'	-0x.dddp±dd，十六进制尾数，十进制表示的 2 的幂指数（非标准）
'b'	-ddddddp±dd，十进制尾数，十进制表示的 2 的幂指数（非标准）

对于 2 的幂指数格式，尾数会以规范化形式打印：

'x'	[1, 2) 范围内的十六进制尾数，或 0
'p'	[½, 1) 范围内的十六进制尾数，或 0
'b'	使用 x.Prec() 位的十进制整数尾数，或 0

注意 'x' 形式是大多数其他语言和库所采用的形式。

如果 format 是其他字符，Text 会返回 "%" 后跟无法识别的格式字符。

精度 prec 控制由 'e'、'E'、'f'、'g'、'G' 和 'x' 格式打印的数字个数（不包括指数）。对于 'e'、'E'、'f' 和 'x'，它表示小数点后的数字个数。对于 'g' 和 'G'，它表示数字总个数。负的精度会选择能够使用 x.Prec() 尾数位唯一标识值 x 所需的最小十进制数字个数。对于 'b' 和 'p' 格式，prec 值会被忽略。

func (*Float) Uint64

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

Uint64 返回将 x 向零截断得到的无符号整数。若 0 <= x <= math.MaxUint64，则当 x 为整数时结果为 Exact，否则为 Below。对于 x < 0，结果为 (0, Above)；对于 x > math.MaxUint64，结果为 (math.MaxUint64, Below)。

func (*Float) UnmarshalText

func (z *Float) UnmarshalText(text []byte) error

UnmarshalText 实现 encoding.TextUnmarshaler 接口。结果按照 z 的精度和舍入模式进行舍入。如果 z 的精度为 0，则在舍入生效之前会被改为 64。

type Int

type Int struct {
	// contains filtered or unexported fields
}

An Int 表示一个有符号多精度整数。 Int 的零值表示值 0。

运算总是接受指针参数（*Int）而非 Int 值，并且每个唯一的 Int 值都需要其自己唯一的 *Int 指针。要“复制”一个 Int 值，必须使用 Int.Set 方法将现有（或新分配的）Int 设置为新值；不支持 Int 的浅拷贝，且可能导致错误。

注意，方法可能会通过时序侧信道泄露 Int 的值。由于这一点，以及实现的规模和复杂性，Int 并不适合实现密码学运算。标准库避免将非平凡的 Int 方法暴露给攻击者可控的输入，并且判定 math/big 中的某个 bug 是否被视为安全漏洞可能取决于其对标准库的影响。

func NewInt

func NewInt(x int64) *Int

NewInt 分配并返回一个设为 x 的新 Int。

func (*Int) Abs

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

Abs 将 z 设为 |x|（x 的绝对值）并返回 z。

func (*Int) Add

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

Add 将 z 设为和 x+y 并返回 z。

func (*Int) And

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

And 将 z 设为 x & y 并返回 z。

func (*Int) AndNot

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

AndNot 将 z 设为 x &^ y 并返回 z。

func (*Int) Append

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

Append 将由 x.Text(base) 生成的 x 的字符串表示追加到 buf，并返回扩展后的缓冲区。

func (*Int) AppendText

func (x *Int) AppendText(b []byte) (text []byte, err error)

AppendText 实现 encoding.TextAppender 接口。

func (*Int) Binomial

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

Binomial 将 z 设为二项式系数 C(n, k) 并返回 z。

func (*Int) Bit

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

Bit 返回 x 的第 i 位的值。也就是说，它返回 (x>>i)&1。位索引 i 必须 >= 0。

func (*Int) BitLen

func (x *Int) BitLen() int

BitLen 返回 x 绝对值的位长度。 0 的位长度为 0。

func (*Int) Bits

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

Bits 以 little-endian Word 切片的形式返回 x 的绝对值，从而提供对 x 的原始（未检查但快速）访问。结果与 x 共享同一底层数组。 Bits 旨在支持在本包之外实现缺失的底层 Int 功能；除此之外应避免使用它。

func (*Int) Bytes

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

Bytes 以大端字节切片的形式返回 x 的绝对值。

要使用固定长度的切片或预分配的切片，请使用 Int.FillBytes。

func (*Int) Cmp

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

Cmp 比较 x 和 y 并返回：

-1 若 x < y；
0 若 x == y；
+1 若 x > y。

func (*Int) CmpAbs

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

CmpAbs 比较 x 和 y 的绝对值并返回：

-1 若 |x| < |y|；
0 若 |x| == |y|；
+1 若 |x| > |y|。

func (*Int) Div

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

Div 将 z 设为商 x/y（y != 0）并返回 z。如果 y == 0，会引发除零运行期 panic。 Div 实现欧几里得除法（与 Go 不同）；更多细节参见 Int.DivMod。

func (*Int) DivMod

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

DivMod 将 z 设为商 x div y，将 m 设为模 x mod y，并对 y != 0 返回对 (z, m)。如果 y == 0，会引发除零运行期 panic。

DivMod 实现欧几里得除法和取模（与 Go 不同）：

q = x div y  使得
m = x - y*q  且 0 <= m < |y|

（参见 Raymond T. Boute，“The Euclidean definition of the functions div and mod”。ACM Transactions on Programming Languages and Systems (TOPLAS), 14(2):127-144, New York, NY, USA, 4/1992. ACM press.） T-除法和取模（与 Go 相同）参见 Int.QuoRem。

func (*Int) Exp

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

Exp 将 z 设为 x**y mod |m|（即忽略 m 的符号），并返回 z。如果 m == nil 或 m == 0，则 z = x**y，除非 y <= 0，此时 z = 1。如果 m != 0、 y < 0，且 x 与 m 不互质，则 z 保持不变并返回 nil。

特定大小输入的模幂运算不是密码学常数时间的操作。

func (*Int) FillBytes

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

FillBytes 将 buf 设为 x 的绝对值，以零扩展的大端字节切片形式存储，并返回 buf。

如果 x 的绝对值无法放入 buf，FillBytes 会 panic。

func (*Int) Float64

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

Float64 返回最接近 x 的 float64 值，以及发生了何种舍入的指示。

func (*Int) Format

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

Format 实现 fmt.Formatter。它接受格式 'b'（二进制）、'o'（带 0 前缀的八进制）、'O'（带 0o 前缀的八进制）、 'd'（十进制）、'x'（小写十六进制）和 'X'（大写十六进制）。还支持 fmt 包针对整数类型的全套格式标志，包括用于符号控制的 '+' 和 ' '，用于八进制前导零和十六进制的 '#'，分别用于 "%#x" 和 "%#X" 的前导 "0x" 或 "0X"，最小数字精度、输出字段宽度、空格或零填充，以及用于左对齐或右对齐的 '-'。

func (*Int) GCD

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

GCD 将 z 设为 a 和 b 的最大公约数并返回 z。如果 x 或 y 不为 nil，GCD 会设置它们的值，使得 z = a*x + b*y。

a 和 b 可以为正、零或负。（在 Go 1.14 之前，二者都必须 > 0。）无论 a 和 b 的符号如何，z 始终 >= 0。

如果 a == b == 0，GCD 设置 z = x = y = 0。

如果 a == 0 且 b != 0，GCD 设置 z = |b|，x = 0，y = sign(b) * 1。

如果 a != 0 且 b == 0，GCD 设置 z = |a|，x = sign(a) * 1，y = 0。

func (*Int) GobDecode

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

GobDecode 实现 encoding/gob.GobDecoder 接口。

func (*Int) GobEncode

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

GobEncode 实现 encoding/gob.GobEncoder 接口。

func (*Int) Int64

func (x *Int) Int64() int64

Int64 返回 x 的 int64 表示。如果 x 无法用 int64 表示，结果未定义。

func (*Int) IsInt64

func (x *Int) IsInt64() bool

IsInt64 报告 x 能否用 int64 表示。

func (*Int) IsUint64

func (x *Int) IsUint64() bool

IsUint64 报告 x 能否用 uint64 表示。

func (*Int) Lsh

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

Lsh 将 z 设为 x << n 并返回 z。

func (*Int) MarshalJSON

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

MarshalJSON 实现 encoding/json.Marshaler 接口。

func (*Int) MarshalText

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

MarshalText 实现 encoding.TextMarshaler 接口。

func (*Int) Mod

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

Mod 将 z 设为模 x%y（y != 0）并返回 z。如果 y == 0，会引发除零运行期 panic。 Mod 实现欧几里得取模（与 Go 不同）；更多细节参见 Int.DivMod。

func (*Int) ModInverse

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

ModInverse 将 z 设为 g 在环 ℤ/nℤ 中的乘法逆元并返回 z。如果 g 和 n 不互质，则 g 在环 ℤ/nℤ 中没有乘法逆元。在这种情况下，z 保持不变，返回值为 nil。如果 n == 0，会引发除零运行期 panic。

func (*Int) ModSqrt

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

ModSqrt 如果 x mod p 的平方根存在，则将 z 设为它，并返回 z。模数 p 必须是奇素数。如果 x 不是模 p 的平方数， ModSqrt 保持 z 不变并返回 nil。如果 p 不是奇整数，此函数会 panic；如果 p 是奇数但不是素数，其行为未定义。

func (*Int) Mul

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

Mul 将 z 设为乘积 x*y 并返回 z。

func (*Int) MulRange

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

MulRange 将 z 设为区间 [a, b]（含端点）内所有整数的乘积并返回 z。如果 a > b（空区间），结果为 1。

func (*Int) Neg

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

Neg 将 z 设为 -x 并返回 z。

func (*Int) Not

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

Not 将 z 设为 ^x 并返回 z。

func (*Int) Or

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

Or 将 z 设为 x | y 并返回 z。

func (*Int) ProbablyPrime

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

ProbablyPrime 报告 x 是否可能为素数，使用 n 个伪随机选择的基进行 Miller-Rabin 检验，以及一次 Baillie-PSW 检验。

如果 x 是素数，ProbablyPrime 返回 true。如果 x 是随机选取的且不是素数，ProbablyPrime 很可能返回 false。对于随机选取的非素数，返回 true 的概率至多为 ¼ⁿ。

对于小于 2⁶⁴ 的输入，ProbablyPrime 是 100% 准确的。关于错误概率的进一步讨论，参见 Menezes 等人，Handbook of Applied Cryptography, 1997, pp. 145-149，以及 FIPS 186-4 Appendix F。

ProbablyPrime 不适合用于判断对手可能精心构造以欺骗该检验的素数。

从 Go 1.8 起，允许 ProbablyPrime(0)，且它只应用一次 Baillie-PSW 检验。在 Go 1.8 之前，ProbablyPrime 只应用 Miller-Rabin 检验，并且 ProbablyPrime(0) 会 panic。

func (*Int) Quo

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

Quo 将 z 设为商 x/y（y != 0）并返回 z。如果 y == 0，会引发除零运行期 panic。 Quo 实现截断除法（与 Go 相同）；更多细节参见 Int.QuoRem。

func (*Int) QuoRem

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

QuoRem 将 z 设为商 x/y，将 r 设为余数 x%y，并对 y != 0 返回对 (z, r)。如果 y == 0，会引发除零运行期 panic。

QuoRem 实现 T-除法和取模（与 Go 相同）：

q = x/y      结果向零截断
r = x - y*q

（参见 Daan Leijen，“Division and Modulus for Computer Scientists”。）欧几里得除法和取模（与 Go 不同）参见 Int.DivMod。

func (*Int) Rand

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

Rand 将 z 设为 [0, n) 中的伪随机数并返回 z。

由于它使用 math/rand 包，不得用于安全敏感的工作。请改用 crypto/rand.Int。

func (*Int) Rem

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

Rem 将 z 设为余数 x%y（y != 0）并返回 z。如果 y == 0，会引发除零运行期 panic。 Rem 实现截断取模（与 Go 相同）；更多细节参见 Int.QuoRem。

func (*Int) Rsh

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

Rsh 将 z 设为 x >> n 并返回 z。

func (*Int) Scan

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

Scan 是 fmt.Scanner 的辅助例程；它将 z 设为所扫描数字的值。它接受格式 'b'（二进制）、'o'（八进制）、'd'（十进制）、 'x'（小写十六进制）和 'X'（大写十六进制）。

Example

package main

import (
	"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)
	}
}

Output:

18446744073709551617

func (*Int) Set

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

Set 将 z 设为 x 并返回 z。

func (*Int) SetBit

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 会 panic。

func (*Int) SetBits

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

SetBits 将 z 的值设为 abs（解释为 little-endian Word 切片）并返回 z，从而提供对 z 的原始（未检查但快速）访问。结果与 abs 共享同一底层数组。 SetBits 旨在支持在本包之外实现缺失的底层 Int 功能；除此之外应避免使用它。

func (*Int) SetBytes

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

SetBytes 将 buf 解释为大端无符号整数的字节，将 z 设为该值并返回 z。

func (*Int) SetInt64

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

SetInt64 将 z 设为 x 并返回 z。

func (*Int) SetString

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

SetString 将 z 设为按给定 base 解释的 s 的值，并返回 z 以及一个表示是否成功的布尔值。整个字符串（而不只是前缀）必须有效才算成功。如果 SetString 失败，z 的值未定义，但返回值为 nil。

base 参数必须是 0 或 2 到 MaxBase 之间的值。对于 base 0，数字前缀决定实际的 base：“0b”或“0B”前缀选择 base 2， “0”、“0o”或“0O”选择 base 8，“0x”或“0X”选择 base 16。否则，所选 base 为 10，且不接受前缀。

对于 base <= 36，小写和大写字母被视为相同：字母 'a' 到 'z' 和 'A' 到 'Z' 表示数字值 10 到 35。对于 base > 36，大写字母 'A' 到 'Z' 表示数字值 36 到 61。

对于 base 0，下划线字符“_”可以出现在 base 前缀与相邻数字之间，以及相邻数字之间；此类下划线不改变数字的值。如果没有其他错误，下划线位置不正确会被报告为错误。如果 base != 0，则不识别下划线，其行为与任何其他不是有效数字的字符相同。

Example

package main

import (
	"fmt"
	"math/big"
)

func main() {
	i := new(big.Int)
	i.SetString("644", 8) // octal
	fmt.Println(i)
}

Output:

func (*Int) SetUint64

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

SetUint64 将 z 设为 x 并返回 z。

func (*Int) Sign

func (x *Int) Sign() int

Sign 返回：

-1 若 x < 0；
0 若 x == 0；
+1 若 x > 0。

func (*Int) Sqrt

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

Sqrt 将 z 设为 ⌊√x⌋，即使得 z² ≤ x 的最大整数，并返回 z。如果 x 为负，它会 panic。

func (*Int) String

func (x *Int) String() string

String 返回由 x.Text(10) 生成的 x 的十进制表示。

func (*Int) Sub

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

Sub 将 z 设为差 x-y 并返回 z。

func (*Int) Text

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

Text 返回 x 在给定 base 下的字符串表示。 Base 必须在 2 到 62 之间（含）。结果使用小写字母 'a' 到 'z' 表示数字值 10 到 35，使用大写字母 'A' 到 'Z' 表示数字值 36 到 61。字符串中不添加前缀（如 "0x"）。如果 x 是 nil 指针，返回 "<nil>"。

func (*Int) TrailingZeroBits

func (x *Int) TrailingZeroBits() uint

TrailingZeroBits 返回 |x| 中连续的最低有效零位的数量。

func (*Int) Uint64

func (x *Int) Uint64() uint64

Uint64 返回 x 的 uint64 表示。如果 x 无法用 uint64 表示，结果未定义。

func (*Int) UnmarshalJSON

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

UnmarshalJSON 实现 encoding/json.Unmarshaler 接口。

func (*Int) UnmarshalText

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

UnmarshalText 实现 encoding.TextUnmarshaler 接口。

func (*Int) Xor

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

Xor 将 z 设为 x ^ y 并返回 z。

type Rat

type Rat struct {
	// contains filtered or unexported fields
}

Rat 表示任意精度的商 a/b。 Rat 的零值表示数值 0。

所有操作都接受指针参数 (*Rat) 而不是 Rat 值，并且每个唯一的 Rat 值都需要其自身唯一的 *Rat 指针。要“复制”一个 Rat 值，必须使用 Rat.Set 方法将某个已存在（或新分配）的 Rat 设置为新值；不支持对 Rat 进行浅拷贝，否则可能导致错误。

func NewRat

func NewRat(a, b int64) *Rat

NewRat 创建一个新的 Rat，其分子为 a、分母为 b。

func (*Rat) Abs

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

Abs 将 z 设置为 |x|（x 的绝对值）并返回 z。

func (*Rat) Add

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

Add 将 z 设置为和 x+y 并返回 z。

func (*Rat) AppendText

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

AppendText 实现 encoding.TextAppender 接口。

func (*Rat) Cmp

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

Cmp 比较 x 和 y 并返回：

如果 x < y 则为 -1；
如果 x == y 则为 0；
如果 x > y 则为 +1。

func (*Rat) Denom

func (x *Rat) Denom() *Int

Denom 返回 x 的分母；它总是 > 0。结果是对 x 分母的引用，除非 x 是未初始化（零值）的 Rat，此时结果是一个值为 1 的新 Int。（要初始化 x，任何会设置 x 的操作都可以，包括 x.Set(x)。）如果结果是对 x 分母的引用，那么当给 x 赋了新值时它可能会改变，反之亦然。

func (*Rat) Float32

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

Float32 返回 x 最接近的 float32 值，以及一个布尔值，表示 f 是否精确地表示 x。如果 x 的绝对值太大而无法用 float32 表示，则 f 为无穷，exact 为 false。即使 f == 0，f 的符号也始终与 x 的符号一致。

func (*Rat) Float64

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

Float64 返回 x 最接近的 float64 值，以及一个布尔值，表示 f 是否精确地表示 x。如果 x 的绝对值太大而无法用 float64 表示，则 f 为无穷，exact 为 false。即使 f == 0，f 的符号也始终与 x 的符号一致。

func (*Rat) FloatPrec

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

FloatPrec 返回 x 的十进制表示中小数点后紧接的、非循环数字的个数 n。布尔结果表示 x 的具有这么多位小数的十进制表示是精确的还是舍入的。

示例：

x      n    exact    十进制表示（n 位小数）
0      0    true     0
1      0    true     1
1/2    1    true     0.5
1/3    0    false    0       （0.333... 舍入）
1/4    2    true     0.25
1/6    1    false    0.2     （0.166... 舍入）

func (*Rat) FloatString

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

FloatString 返回 x 的十进制字符串表示，小数点后具有 prec 位精度。最后一位按最接近舍入，恰好一半时向远离零的方向舍入。

func (*Rat) GobDecode

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

GobDecode 实现 encoding/gob.GobDecoder 接口。

func (*Rat) GobEncode

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

GobEncode 实现 encoding/gob.GobEncoder 接口。

func (*Rat) Inv

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

Inv 将 z 设置为 1/x 并返回 z。如果 x == 0，Inv 会 panic。

func (*Rat) IsInt

func (x *Rat) IsInt() bool

IsInt 报告 x 的分母是否为 1。

func (*Rat) MarshalText

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

MarshalText 实现 encoding.TextMarshaler 接口。

func (*Rat) Mul

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

Mul 将 z 设置为乘积 x*y 并返回 z。

func (*Rat) Neg

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

Neg 将 z 设置为 -x 并返回 z。

func (*Rat) Num

func (x *Rat) Num() *Int

Num 返回 x 的分子；它可能 <= 0。结果是对 x 分子的引用；如果给 x 赋了新值，它可能会改变，反之亦然。分子的符号与 x 的符号一致。

func (*Rat) Quo

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

Quo 将 z 设置为商 x/y 并返回 z。如果 y == 0，Quo 会 panic。

func (*Rat) RatString

func (x *Rat) RatString() string

RatString 返回 x 的字符串表示：如果 b != 1 则为 "a/b" 形式，如果 b == 1 则为 "a" 形式。

func (*Rat) Scan

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

Scan 是 fmt.Scanner 的辅助例程。它接受格式 'e'、'E'、'f'、'F'、'g'、'G' 和 'v'。所有格式都是等价的。

Example

package main

import (
	"fmt"
	"log"
	"math/big"
)

func main() {
	// The Scan function is rarely used directly;
	// the fmt package recognizes it as an implementation of fmt.Scanner.
	r := new(big.Rat)
	_, err := fmt.Sscan("1.5000", r)
	if err != nil {
		log.Println("error scanning value:", err)
	} else {
		fmt.Println(r)
	}
}

Output:

3/2

func (*Rat) Set

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

Set 将 z 设置为 x（通过复制 x）并返回 z。

func (*Rat) SetFloat64

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

SetFloat64 将 z 精确设置为 f 并返回 z。如果 f 不是有限值，SetFloat 返回 nil。

func (*Rat) SetFrac

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

SetFrac 将 z 设置为 a/b 并返回 z。如果 b == 0，SetFrac 会 panic。

func (*Rat) SetFrac64

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

SetFrac64 将 z 设置为 a/b 并返回 z。如果 b == 0，SetFrac64 会 panic。

func (*Rat) SetInt

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

SetInt 将 z 设置为 x（通过复制 x）并返回 z。

func (*Rat) SetInt64

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

SetInt64 将 z 设置为 x 并返回 z。

func (*Rat) SetString

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

SetString 将 z 设置为 s 的值，并返回 z 和一个表示成功与否的布尔值。 s 可以表示为（可能带符号的）分数 "a/b"，也可以表示为一个浮点数，其后可选地跟一个指数。如果提供的是分数，则被除数和除数都可以是十进制整数，也可以分别独立使用前缀 “0b”、“0” 或 “0o”，或 “0x”（及其大写变体）来分别表示二进制、八进制或十六进制整数。除数不能带符号。如果提供的是浮点数，则它可以是十进制形式，也可以使用上述任一前缀（但 “0” 除外）来表示非十进制尾数。前导 “0” 被视为十进制的前导 0；在这种情况下它不表示八进制表示。还可以提供可选的以 10 为底的 “e” 或以 2 为底的 “p”（及其大写变体）指数，但十六进制浮点数除外，它们只接受（可选的）“p” 指数（因为 “e” 或 “E” 无法与尾数数字区分开）。如果指数的绝对值过大，操作可能会失败。成功时整个字符串（不只是前缀）都必须有效。如果操作失败， z 的值未定义，但返回的值为 nil。

Example

package main

import (
	"fmt"
	"math/big"
)

func main() {
	r := new(big.Rat)
	r.SetString("355/113")
	fmt.Println(r.FloatString(3))
}

Output:

3.142

func (*Rat) SetUint64

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

SetUint64 将 z 设置为 x 并返回 z。

func (*Rat) Sign

func (x *Rat) Sign() int

Sign 返回：

如果 x < 0 则为 -1；
如果 x == 0 则为 0；
如果 x > 0 则为 +1。

func (*Rat) String

func (x *Rat) String() string

String 返回 x 的字符串表示，形式为 "a/b"（即使 b == 1）。

func (*Rat) Sub

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

Sub 将 z 设置为差 x-y 并返回 z。

func (*Rat) UnmarshalText

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

UnmarshalText 实现 encoding.TextUnmarshaler 接口。

type RoundingMode

type RoundingMode byte

RoundingMode 决定 Float 值如何舍入到所需精度。舍入可能会改变 Float 值；舍入误差由 Float 的 Accuracy 描述。

Example

package main

import (
	"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()
	}

}

Output:

   x  ToNearestEven  ToNearestAway  ToZero  AwayFromZero  ToNegativeInf  ToPositiveInf
 2.6              3              3       2             3              2              3
 2.5              2              3       2             3              2              3
 2.1              2              2       2             3              2              3
-2.1             -2             -2      -2            -3             -3             -2
-2.5             -2             -3      -2            -3             -3             -2
-2.6             -3             -3      -2            -3             -3             -2

const (
	ToNearestEven RoundingMode = iota // == IEEE 754-2008 roundTiesToEven
	ToNearestAway                     // == IEEE 754-2008 roundTiesToAway
	ToZero                            // == IEEE 754-2008 roundTowardZero
	AwayFromZero                      // 无 IEEE 754-2008 等价项
	ToNegativeInf                     // == IEEE 754-2008 roundTowardNegative
	ToPositiveInf                     // == IEEE 754-2008 roundTowardPositive
)

这些常量定义支持的舍入模式。

func (RoundingMode) String

func (i RoundingMode) String() string

type Word

type Word uint

A Word 表示多精度无符号整数的一个数位。