math/big

big包

• import "math/big"

• 概述

• 索引

• 示例

概述

Big包实现了任意精度算术（大数）。支持以下数字类型：

Int    signed integers
Rat    rational numbers
Float  floating-point numbers

Int，Rat 或 Float 的零值对应于0。因此，可以用通常的方式声明新值，并且在没有进一步初始化的情况下表示0：

var x Int        //&x是一个值为0的int型
var r = &Rat{}   //r是一个值为0的Rat型
y := new(Float)  //y是一个值为0的float型

或者，可以使用表单的工厂函数分配和初始化新值：

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 := 123
z2 := new(Rat).SetFloat64(1.25)   // z2 := 5/4
z3 := new(Float).SetInt(z1)       // z3 := 123.0

Setters，数字操作和谓词被表示为以下形式的方法：

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 。

（通过总是通过接收器传递结果值，可以更好地控制内存使用，而不必为每个结果分配新的内存，操作可以重新使用分配给结果值的空间，并用新的值覆盖该值导致该过程。）

符号约定：传入方法参数（包括接收者）在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除外）。

示例（EConvergents）

这个例子演示了如何使用big.Rat来计算常数 e（自然对数的底数）的有理收敛序列中的前15个项。

package main

import (
	"fmt"
	"math/big"
)

//使用e的经典连续分数
// e = [1; 0,1,1,2,1,1，... 2n，1,1，......]
//即，对于第n个术语，请使用
// 1如果n mod 3！= 1
//（n-1）/ 3 * 2如果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
	}

//直接将frac初始化为小数
//recur结果的倒数
	frac := new(big.Rat).Inv(recur(n+1, lim))

	return term.Add(term, frac)
}

//这个实例演示了如何使用big.Rat来计算
//在理性收敛序列中的前15个项
//常数e（自然对数的基数
func main() {
	for i := 1; i <= 15; i++ {
		r := recur(0, int64(i))


//将r打印为分数和浮点数。
//由于big.Rat实现了fmt.Formatter，我们可以使用％-13s
//得到分数的左对齐字符串表示。
		fmt.Printf("%-13s = %s\n", r, r.FloatString(8))
	}

}

示例（Fibonacci）

这个例子演示了如何使用big.Int来计算100位十进制数字的最小斐波那契数，并测试它是否为素数。

package main

import (
	"fmt"
	"math/big"
)

func main() {

//使用序列中的前两个数字初始化两个大的整数。
		a := big.NewInt(0)
	b := big.NewInt(1)


//初始化限制为10 ^ 99，最小的100位整数。
		var limit big.Int
	limit.Exp(big.NewInt(10), big.NewInt(99), nil)


//当a小于1e100时循环。
	for a.Cmp(&limit) < 0 {
		//计算下一个Fibonacci数，将其存储在a中。
		a.Add(a, b)
		//交换a和b，使b成为序列中的下一个数字。
		a, b = b, a
	}
	fmt.Println(a)// 100位Fibonacci数

//测试一个素数。
//（ProbablyPrimes的论点设定了米勒 - 拉宾的数量
//要进行的回合。 20是一个很好的值。） 
	fmt.Println(a.ProbablyPrime(20))

}

示例（Sqrt2）

此示例说明如何使用 big.Float 以200位的精度计算2的平方根，以及如何将结果打印为十进制数。

package main

import (
	"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（显示源代码）

func Jacobi(x, y *Int) int

Jacobi返回Jacobi符号(x/y)，即+1，-1或0. y参数必须是奇数。

type Accuracy（显示源代码）

准确度描述了最近一次生成Float值的操作产生的舍入误差，相对于精确值。

type Accuracy int8

描述浮点精度的常量。

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

func (Accuracy) String（显示源代码）

func (i Accuracy) String() string

type ErrNaN（显示源代码）

Float 操作引发了一个 ErrNaN 恐慌，该操作将导致遵循 IEEE-754 规则的 NaN 。ErrNaN 实现错误接口。

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

func (ErrNaN) Error（显示源代码）

func (err ErrNaN) Error() string

type Float（显示源代码）

非零有限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 字段
}

示例（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)
	}
}

func NewFloat（显示源代码）

func NewFloat(x float64) *Float

NewFloat 分配并返回一个新的 Float 设置为 x ，精度为53，舍入模式为 ToNearestEven 。如果 x 是 NaN ， NewFloat 会与 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

将 z 设置为舍入和 x + y 并返回 z 。如果 z 的精度为0，则在操作之前将其更改为x或y的精度中的较大者。舍入是根据z的精度和舍入模式执行的；并且z的准确性报告相对于确切（不是四舍五入）结果的结果错误。如果x和y是符号相反的无穷大，则用 ErrNaN 添加恐慌。在这种情况下 z 的值是未定义的。

BUG(gri)四舍五入 ToNegativeInf 时，Float 值的符号舍入为0是不正确的。

示例

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

func (*Float) Append（显示源代码）

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

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

func (*Float) Cmp（显示源代码）

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

}

func (*Float) Copy（显示源代码）

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

将 z 设置为 x ，具有相同的精度，舍入模式，精度等于 x ，并返回 z 。即使 z 和 x 相同，x 也不会改变。

func (*Float) Float32（显示源代码）

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 (*Float) Float64（显示源代码）

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 (*Float) Format（显示源代码）

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 (*Float) GobDecode（显示源文件）

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

GobDecode实现了gob.GobDecoder接口。除非z的精度为0，否则结果会按z的精度和舍入模式进行舍入，在这种情况下，z将精确设置为解码值。

func (*Float) GobEncode（显示源文件）

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

GobEncode实现gob.GobEncoder接口。Float值及其所有属性（精度，舍入模式，准确度）将被封送。

func (*Float) Int（显示源文件）

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 (*Float) Int64（显示源文件）

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 (*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分成尾数和指数分量并返回指数。如果提供非零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接口。只有浮点值被编组（全精度），其他属性（如精度或精度）被忽略。

func (*Float) MinPrec（显示源文件）

func (x *Float) MinPrec() uint

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

func (*Float) Mode（显示源文件）

func (x *Float) Mode() RoundingMode

模式返回 x 的舍入模式。

func (*Float) Mul（显示源文件）

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

Mul 将 z 设置为舍入乘积 x * y 并返回 z 。精确度，舍入和准确性报告与 Add 相同。如果一个操作数为零而另一个操作数为无穷大，则 Mul 会与 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 ，其中必须包含浮点数的文本表示，其中尾数在给定的转换基数（指数始终为十进制数）或表示无限值的字符串中。

它将 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 (*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

现在将 z 设置为四舍五入的商x/y并返回 z 。精确度，舍入和准确性报告与 Add 相同。如果两个操作数都是零或无穷大，那么现在恐慌与 ErrNaN 。在这种情况下 z 的值是未定义的。

func (*Float) Rat（显示源文件）

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

Rat 返回对应于 x 的有理数; 如果 x 是无穷大，则为零。如果 x 不是 Inf，结果是 Exact。如果提供非零* Rat参数 z，则 Rat 将结果存储在 z 中，而不是分配新的 Rat 。

func (*Float) Scan（显示源文件）

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

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

示例

package main

import (
	"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 (*Float) Set（显示源文件）

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

将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 与 ErrNaN 发生混乱。

func (*Float) SetInf（显示源文件）

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

SetInf 将 z 设置为无限Float -Inf（如果设置了符号位）或者+Inf（如果未设置符号位）并返回 z 。z 的精度不变，结果总是精确的。

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 与 MantExp 相反，但不要求 0.5 <= |mant| < 1.0。特别：

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 的舍入模式设置为模式并返回确切的 z 。z 保持不变。z.SetMode(z.Mode())是将 z 的准确性设置为 Exact 的廉价方法。

func (*Float) SetPrec（显示源文件）

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

SetPrec 将 z 的精度设置为 prec 并返回（可能）z的四舍五入值。如果尾数不能用精确比特表示，并且没有精度损失，则根据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 必须是一个与 Parse 接受的格式相同的浮点数，其基数为0。整个字符串（不只是前缀）必须对成功有效。如果操作失败，则z的值未定义，但返回值为零。

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

符号返回：

-1 if x <   0
 0 if x is ±0
+1 if x >   0

func (*Float) Signbit（显示源文件）

func (x *Float) Signbit() bool

如果 x 是负值或负值，则 Signbit 返回 true 。

func (*Float) String（显示源文件）

func (x *Float) String() string

字符串格式 x，如x.Text（'g'，10）。（字符串必须显式调用，Float.Format不支持％s动词。）

func (*Float) Sub（显示源文件）

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

Sub 将 z 设置为舍入差异 xy 并返回 z 。精确度，舍入和准确性报告与 Add 相同。如果 x 和 y 是等号的无穷大，则会与 ErrNaN 发生混淆。在这种情况下 z 的值是未定义的。

func (*Float) Text（显示源文件）

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 (*Float) Uint64（显示源文件）

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 (*Float) UnmarshalText（显示源文件）

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

UnmarshalText实现了encoding.TextUnmarshaler接口。结果按z的精度和舍入模式四舍五入。如果z的精度为0，则在舍入生效之前将其更改为64。

type Int（显示源文件）

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

type Int struct {
        // 包含筛选或 unexported 字段
}

func NewInt（显示源文件）

func NewInt(x int64) *Int

NewInt 分配并返回一个新的 Int 集到 x 。

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

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

func (*Int) And（显示源文件）

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

并设置 z = x＆y 并返回 z 。

func (*Int) AndNot（显示源文件）

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

并且不设置 z = x＆^ y 并返回 z 。

func (*Int) Append（显示源文件）

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

Append 将由 x.Text（base）生成的 x 的字符串表示形式附加到 buf 并返回扩展缓冲区。

func (*Int) Binomial（显示源文件）

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

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

func (*Int) Bit（显示源文件）

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

位返回 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

位通过返回它的绝对值作为一个小尾端的 Word 片来提供对 x 的原始（未经检查但快速）访问。结果和x共享相同的底层数组。位旨在支持在此包外部实现缺少的低级别 Int 功能；否则应该避免。

func (*Int) Bytes（显示源文件）

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

字节返回 x 的绝对值作为大端字节片。

func (*Int) Cmp （显示源文件）

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

Cmp 比较 x 和 y 并返回：

-1 if x <  y
 0 if x == y
+1 if x >  y

func (*Int) Div（显示源文件）

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

Div 将 z 设置为 y!= 0 的商x / y并返回 z 。如果y == 0，则会发生除零运行时恐慌。Div 实现欧几里德分割（与Go不同）; 请参阅 DivMod 了解更多详情。

func (*Int) 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 (*Int) Exp（显示源文件）

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 (*Int) Format（显示源文件）

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

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

func (*Int) GCD（显示源文件）

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 (*Int) GobDecode（显示源文件）

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

GobDecode实现了gob.GobDecoder接口。

func (*Int) GobEncode（显示源文件）

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

GobEncode 实现 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实现了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 设置为y！= 0的模量x％y并返回 z 。如果y == 0，则会发生除零运行时恐慌。Mod 实现欧几里德模量（与Go不同）; 请参阅 DivMod 了解更多详情。

func (*Int) ModInverse（显示源文件）

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

ModInverse 将 z 设置为环中的 g 的乘法倒数 ℤ/nℤ 并返回 z 。如果 g 和 n 不是相对的素数，结果是不确定的。

func (*Int) ModSqrt（显示源文件）

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

如果这样的平方根存在并且返回 z，则 ModSqrt 将 z 设置为x mod p的平方根。模数 p 必须是一个奇素数。如果 x 不是平方 mod p，则 ModSqrt 保持 z 不变并返回 nil 。如果 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

未设置z = ^ x并返回 z 。

func (*Int) Or（显示源文件）

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

或者设置z = x | y并返回 z 。

func (*Int) ProbablyPrime（显示源文件）

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 (*Int) Quo（显示源文件）

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

现在将 z 设置为y！= 0的商 x / y 并返回 z 。如果y == 0，则会发生除零运行时恐慌。现在实现截断分裂（像Go）; 请参阅 QuoRem 了解更多详情。

func (*Int) 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实现T分割和模数（如Go）：

q = x/y      with the result truncated to zero
r = x - y*q

（请参阅Daan Leijen，“计算机科学家的分部和模数”。）请参见DivMod的欧几里德除法和模数（与 Go 不同）。

func (*Int) Rand（显示源文件）

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

Rand 将 z 设置为[0，n）中的伪随机数并返回 z 。

func (*Int) Rem（显示源文件）

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

Rem 将 z 设置为y！= 0的余数 x％y 并返回 z 。如果 y == 0，则会发生除零运行时恐慌。Rem 实现截断模数（如Go）; 请参阅 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

扫描是fmt.Scanner的支持例程; 它将z设置为扫描号码的值。它接受格式'b'（二进制），'o'（八进制），'d'（十进制），'x'（小写十六进制）和'X'（大写十六进制）。

示例

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

func (*Int) Set（显示源文件）

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

将 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 将会发生混乱。

func (*Int) SetBits（显示源文件）

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

SetBits 通过将其值设置为 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 设置为 s 的值，在给定的基础中进行解释，并返回 z 和一个表示成功的布尔值。整个字符串（不只是一个前缀）必须对成功有效。如果 SetString 失败，则z的值未定义，但返回值为零。

基本参数必须为0或介于2和 MaxBase 之间的值。如果基数为0，则字符串前缀将确定实际的转换基数。前缀“0x”或“0X”选择基址16；“0”前缀选择基数8，而“0b”或“0B”前缀选择基数2，否则选择的基数为10。

示例

package main

import (
	"fmt"
	"math/big"
)

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

func (*Int) SetUint64（显示源文件）

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

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

func (*Int) Sign（显示源文件）

func (x *Int) Sign() int

符号返回：

-1 if x <  0
 0 if x == 0
+1 if x >  0

func (*Int) Sqrt（显示源文件）

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

Sqrt 将 z 设置为⌊√x⌋，即 z²≤x 的最大整数，并返回 z 。如果 x 是负数，它会发生恐慌。

func (*Int) String（显示源文件）

func (x *Int) String() string

func (*Int) Sub（显示源文件）

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

Sub 将 z 设置为差值 xy 并返回 z 。

func (*Int) Text（显示源文件）

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

文本返回给定基础中 x 的字符串表示形式。基数必须介于2和36之间，包括2和36。结果对数字值> = 10使用小写字母'a'到'z'。没有基本前缀（例如“0x”）被添加到字符串中。

func (*Int) Uint64（显示源文件）

func (x *Int) Uint64() uint64

Uint64 返回 x 的 uint64 表示。如果 x 不能在 uint64 中表示，结果是未定义的。

func (*Int) UnmarshalJSON（显示源文件）

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

UnmarshalJSON 实现了 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（显示源文件）

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

type Rat struct {
        // 包含筛选或 unexported 字段
}

func NewRat（显示源文件）

func NewRat(a, b int64) *Rat

NewRat 用分子 a 和分母 b 创建一个新的 Rat 。

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

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

func (*Rat) Cmp（显示源文件）

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

Cmp 比较 x 和 y 并返回：

-1 if x <  y
 0 if x == y
+1 if x >  y

func (*Rat) Denom（显示源文件）

func (x *Rat) Denom() *Int

Denom 返回 x 的分母；它始终> 0。结果是对x的分母的引用；如果新的值被分配给 x ，它可能会改变，反之亦然。

func (*Rat) Float32（显示源文件）

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

Float32 返回 x 的最接近的 float32 值和一个 bool，指示 f 是否准确地表示 x 。如果 x 的大小太大而不能用 float32 表示，则 f 是无穷大，精确是错误的。f 的符号总是匹配 x 的符号，即使 f == 0 。

func (*Rat) Float64（显示源文件）

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

Float64 返回 x 的最接近的 float64 值和一个 bool 指示 f 是否完全代表 x 。如果 x 的大小太大而不能用 float64 表示，则 f 是无穷大，精确是错误的。f 的符号总是匹配 x 的符号，即使 f == 0 。

func (*Rat) FloatString（显示源文件）

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

FloatString 以十进制形式返回 x 的字符串表示形式，小数点后的精度为精度数字。最后一位数字四舍五入到最接近的位置，其中一半从零圆整。

func (*Rat) GobDecode（显示源文件）

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

GobDecode 实现了 gob.GobDecoder 接口。

func (*Rat) GobEncode（显示源文件）

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

GobEncode 实现 gob.GobEncoder 接口。

func (*Rat) Inv（显示源文件）

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

Inv 将 z 设置为 1/x 并返回 z 。

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

现在将 z 设为商 x/y 并返回 z 。如果 y == 0，则会发生除零运行时恐慌。

func (*Rat) RatString（显示源文件）

func (x *Rat) RatString() string

如果b！= 1，RatString 返回 x 形式的字符串表示形式“a/b”，如果b == 1则形式为“a”形式。

func (*Rat) Scan（显示源文件）

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

扫描是fmt.Scanner的支持例程。它接受格式'e'，'E'，'f'，'F'，'g'，'G'和'v'。所有格式都是相同的。

示例

package main

import (
	"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 (*Rat) Set（显示源文件）

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

将 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 。

func (*Rat) SetFrac64（显示源文件）

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

SetFrac64 将 z 设置为 a/b 并返回 z 。

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” 给出，也可以作为浮点数可选地跟随一个指数。整个字符串（不只是一个前缀）必须对成功有效。如果操作失败，则z的值未定义，但返回值为零。

示例

package main

import (
	"fmt"
	"math/big"
)

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

func (*Rat) Sign（显示源文件）

func (x *Rat) Sign() int

符号返回：

-1 if x <  0
 0 if x == 0
+1 if x >  0

func (*Rat) String（显示源文件）

func (x *Rat) String() string

字符串以“a/b”的形式返回x的字符串表示形式（即使b == 1）。

func (*Rat) Sub（显示源文件）

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

Sub 将 z 设置为差值 xy 并返回 z 。

func (*Rat) UnmarshalText（显示源文件）

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

UnmarshalText实现了encoding.TextUnmarshaler接口。

type RoundingMode（显示源文件）

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

}

func (RoundingMode) String（显示源文件）

func (i RoundingMode) String() string

type Word（显示源文件）

Word 表示多精度无符号整数的单个数字。

type Word uint

Bugs

• ☞ 舍入 ToNegativeInf 时，Float 值的符号舍入为0是不正确的。