?
Dokumen ini menggunakan Manual laman web PHP Cina Lepaskan
import "math/big"
概述
索引
示例
概述
Big 包實現(xiàn)了任意精度算術(shù)（大數(shù)）。支持以下數(shù)字類型：
Int signed integers Rat rational numbers Float floating-point numbers
Int，Rat 或 Float 的零值對應(yīng)于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或者，可以使用表單的工廠函數(shù)分配和初始化新值：
func NewT(v V) *T
例如，NewInt(x)返回* Int，設(shè)置為int64參數(shù)x的值，NewRat(a, b)返回設(shè)置為a/b的小數(shù)部分a/b，其中a和b是int64值，NewFloat(f)返回一個初始化為float64參數(shù)f的Float。顯式設(shè)置器提供了更多的靈活性，例如：
var z1 Int z1.SetUint64(123) // z1 := 123z2 := new(Rat).SetFloat64(1.25) // z2 := 5/4z3 := new(Float).SetInt(z1) // z3 := 123.0
Setters，數(shù)字操作和謂詞被表示為以下形式的方法：
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 中的一個。對于一元和二元運算，結(jié)果是接收器（在這種情況下通常命名為z；見下文）; 如果它是操作數(shù)x或y中的一個，它可能會被安全覆蓋（以及它的內(nèi)存重用）。
算術(shù)表達式通常寫成一系列單獨的方法調(diào)用，每個調(diào)用都對應(yīng)一個操作。接收方表示結(jié)果，方法參數(shù)是操作的操作數(shù)。例如，給定三個* Int值a，b和c，調(diào)用
c.Add(a, b)
計算總和 a + b 并將結(jié)果存儲在 c 中，覆蓋之前在 c 中保存的任何值。除非另有說明，否則操作允許混疊參數(shù)，因此寫入完全可以
sum.Add(sum, x)
在一個和中累加值 x 。
（通過總是通過接收器傳遞結(jié)果值，可以更好地控制內(nèi)存使用，而不必為每個結(jié)果分配新的內(nèi)存，操作可以重新使用分配給結(jié)果值的空間，并用新的值覆蓋該值導(dǎo)致該過程。）
符號約定：傳入方法參數(shù)（包括接收者）在API中被一致命名以闡明其用法。傳入的操作數(shù)通常命名為 x，y，a，b 等等，但從不 z 。指定結(jié)果的參數(shù)被命名為 z （通常是接收者）。
例如， (*Int).Add 的參數(shù)被命名為 x 和 y，并且因為接收者指定了結(jié)果目的地，所以它被稱為z：
func (z *Int) Add(x, y *Int) *Int
這種形式的方法通常也會返回傳入的接收者，以啟用簡單的呼叫鏈接。
不需要傳入結(jié)果值的方法（例如Int.Sign），只需返回結(jié)果。在這種情況下，接收器通常是第一個操作數(shù)，名為x：
func (x *Int) Sign() int
各種方法支持字符串和相應(yīng)數(shù)值之間的轉(zhuǎn)換，反之亦然：* Int，* Rat 和 * Float 值為值的（默認）字符串表示形式實現(xiàn)Stringer接口，但也提供SetString方法以初始化來自一個支持多種格式的字符串（請參閱相應(yīng)的SetString文檔）。
最后，* Int，* Rat和* Float滿足 fmt 軟件包的 Scanner 界面進行掃描和格式化界面格式化打?。? Rat除外）。
示例（EConvergents）
這個例子演示了如何使用big.Rat來計算常數(shù) e（自然對數(shù)的底數(shù)）的有理收斂序列中的前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))}}示例（Fibonacci）
這個例子演示了如何使用big.Int來計算100位十進制數(shù)字的最小斐波那契數(shù)，并測試它是否為素數(shù)。
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))}示例（Sqrt2）
此示例說明如何使用 big.Float 以200位的精度計算2的平方根，以及如何將結(jié)果打印為十進制數(shù)。
package mainimport ("fmt""math""math/big")func main() {// 我們將做計算與200位精度在尾數(shù)。const prec = 200// 用牛頓法計算2的平方根。我們從// sqrt (2) 的初始估計值, 然后循環(huán)訪問:// x_{n+1} = 1/2 * ( x_n + (2.0 / x_n) )// 因為牛頓的方法加倍的正確數(shù)字在每個// 迭代, 我們至少需要 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 作為一個臨時變量。沒有必要設(shè)定它的精確度// 從大。浮動值 (== 0) 精度自動承擔// 作為結(jié)果使用時參數(shù)的最大精度 (接收者)// 大。浮動操作。
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}// 我們可以使用常規(guī)的裂變材料。自大以來的 Printf 動詞。浮動實現(xiàn)了裂變材料。格式
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
常量
指數(shù)和精度限制。
const ( MaxExp = math.MaxInt32 // largest supported exponent MinExp = math.MinInt32 // smallest supported exponent MaxPrec = math.MaxUint32 // largest (theoretically) supported precision; likely memory-limited)
MaxBase是字符串轉(zhuǎn)換所接受的最大數(shù)字基數(shù)。
const MaxBase = 'z' - 'a' + 10 + 1
func Jacobi
func Jacobi(x, y *Int) int
Jacobi返回Jacobi符號(x/y)，即+1，-1或0. y參數(shù)必須是奇數(shù)。
type Accuracy
準確度描述了最近一次生成Float值的操作產(chǎn)生的舍入誤差，相對于精確值。
type Accuracy int8
描述浮點精度的常量。
const ( Below Accuracy = -1 Exact Accuracy = 0 Above Accuracy = +1)
func (Accuracy) String
func (i Accuracy) String() string
type ErrNaN
Float 操作引發(fā)了一個 ErrNaN 恐慌，該操作將導(dǎo)致遵循 IEEE-754 規(guī)則的 NaN 。ErrNaN 實現(xiàn)錯誤接口。
type ErrNaN struct { // contains filtered or unexported fields}func (ErrNaN) Error
func (err ErrNaN) Error() string
type Float
非零有限Float表示一個多精度浮點數(shù)
sign × mantissa × 2**exponent
其中0.5 <=尾數(shù)<1.0，且MinExp <=指數(shù)<= MaxExp。浮點數(shù)也可以是零 (+0, -0) 或無限(+Inf, -Inf)。所有浮點都是有序的，并且兩個浮點x和y的排序由x.Cmp(y)定義。
每個浮點值還具有精度，舍入模式和準確度。精度是可用于表示值的尾數(shù)位的最大數(shù)量。舍入模式指定應(yīng)如何舍入結(jié)果以適合尾數(shù)位，準確性描述相對于精確結(jié)果的舍入誤差。
除非另有規(guī)定，否則指定結(jié)果的* Float變量（通常通過接收方除MantExp外）的所有操作（包括setter）根據(jù)結(jié)果變量的精度和舍入模式對數(shù)值結(jié)果進行舍入。
如果提供的結(jié)果精度為0（見下文），則在進行舍入之前將其設(shè)置為具有最大精度值的參數(shù)的精度，舍入模式保持不變。因此，作為結(jié)果參數(shù)提供的未初始化的 Floats 將其精度設(shè)置為由操作數(shù)確定的合理值，并且它們的模式是RoundingMode(ToNearestEven)的零值。
通過將所需精度設(shè)置為24或53并使用匹配舍入模式（通常為ToNearestEven），F(xiàn)loat 操作產(chǎn)生與對應(yīng)于正常（即非denormal）float32 或 float64 的操作數(shù)的相應(yīng) float32 或 float64 IEEE-754 算法相同的結(jié)果數(shù)字。對于與 IEEE-754 不同的值，指數(shù)下溢和溢出會導(dǎo)致0或無窮大，因為 Float 指數(shù)具有更大的范圍。
Float 的零（未初始化）值已準備好使用，并精確地表示數(shù)字+0.0，精度為0，舍入模式為 ToNearestEven 。
type Float struct { // 包含篩選或 unexported 字段}示例（Shift）
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
func NewFloat(x float64) *Float
NewFloat 分配并返回一個新的 Float 設(shè)置為 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 設(shè)置為給定的精度和舍入模式。
func (*Float) Abs
func (z *Float) Abs(x *Float) *Float
Abs 將 z 設(shè)置為（可能為四舍五入）值 |x|（x的絕對值）并返回 z 。
func (*Float) Acc
func (x *Float) Acc() Accuracy
Acc返回最近操作產(chǎn)生的x的精確度。
func (*Float) Add
func (z *Float) Add(x, y *Float) *Float
將 z 設(shè)置為舍入和 x + y 并返回 z 。如果 z 的精度為0，則在操作之前將其更改為x或y的精度中的較大者。舍入是根據(jù)z的精度和舍入模式執(zhí)行的；并且z的準確性報告相對于確切（不是四舍五入）結(jié)果的結(jié)果錯誤。如果x和y是符號相反的無窮大，則用 ErrNaN 添加恐慌。在這種情況下 z 的值是未定義的。
BUG(gri)四舍五入 ToNegativeInf 時，F(xiàn)loat 值的符號舍入為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 (*Float) Append
func (x *Float) Append(buf []byte, fmt byte, prec int) []byte
追加附加到 buf 浮點數(shù) x 的字符串形式，由x.Text生成，并返回擴展緩沖區(qū)。
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 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 (*Float) Copy
func (z *Float) Copy(x *Float) *Float
將 z 設(shè)置為 x ，具有相同的精度，舍入模式，精度等于 x ，并返回 z 。即使 z 和 x 相同，x 也不會改變。
func (*Float) Float32
func (x *Float) Float32() (float32, Accuracy)
Float32返回最接近x的float32值。如果x太小而不能用float32（| x | <math.SmallestNonzeroFloat32）表示，則結(jié)果分別為（0，Below）或（-0，Above），具體取決于x的符號。如果x太大而無法用float32（| x |> math.MaxFloat32）表示，則結(jié)果為（+ Inf，Above）或（-Inf，Below），具體取決于x的符號。
func (*Float) Float64
func (x *Float) Float64() (float64, Accuracy)
Float64返回最接近x的float64值。如果x太小而無法用float64（|x| < math.SmallestNonzeroFloat64）表示，則結(jié)果分別為 (0, Below) 或 (-0, Above)，具體取決于x的符號。如果x太大而無法用float64（|x| > math.MaxFloat64）表示，則結(jié)果為（+Inf, Above）或（-Inf, Below），具體取決于x的符號。
func (*Float) Format
func (x *Float) Format(s fmt.State, format rune)
格式實現(xiàn)了fmt.Formatter。它接受浮點數(shù)的所有常規(guī)格式（'b'，'e'，'E'，'f'，'F'，'g'，'G'）以及'p'和'v' 。請參閱（* Float）.Text以解釋'p'。'v'格式被處理為'g'。格式還支持以數(shù)字表示的最小精度，輸出字段寬度以及用于符號控制的格式標志'+'和''，空格或零填充為'0'，左或右對齊為' - ' 。有關(guān)詳細信息，請參閱 fmt 包。
func (*Float) GobDecode
func (z *Float) GobDecode(buf []byte) error
GobDecode實現(xiàn)了gob.GobDecoder接口。除非z的精度為0，否則結(jié)果會按z的精度和舍入模式進行舍入，在這種情況下，z將精確設(shè)置為解碼值。
func (*Float) GobEncode
func (x *Float) GobEncode() ([]byte, error)
GobEncode實現(xiàn)gob.GobEncoder接口。Float值及其所有屬性（精度，舍入模式，準確度）將被封送。
func (*Float) Int
func (x *Float) Int(z *Int) (*Int, Accuracy)
Int返回將 x 截斷為零的結(jié)果；如果 x 是無窮大，則為零。結(jié)果是Exact if x.IsInt（）; 否則它是下面的x> 0和上面的x <0。如果提供了非零* Int參數(shù) z，則 Int 將結(jié)果存儲在z中，而不是分配新的 Int 。
func (*Float) Int64
func (x *Float) Int64() (int64, Accuracy)
Int64返回將x截斷為零的整數(shù)。如果math.MinInt64 <= x <= math.MaxInt64，則結(jié)果為Exact（如果x是整數(shù)），否則結(jié)果為Above（x <0）或Below（x> 0）。結(jié)果是（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 是否是整數(shù)?！繧nf值不是整數(shù)。
func (*Float) MantExp
func (x *Float) MantExp(mant *Float) (exp int)
MantExp將x分成尾數(shù)和指數(shù)分量并返回指數(shù)。如果提供非零mant參數(shù)，則其值被設(shè)置為x的尾數(shù)，具有與x相同的精度和舍入模式。組件滿足x == mant×2 ** exp，其中 0.5 <= |mant| < 1.0。用nil參數(shù)調(diào)用MantExp是獲得接收者指數(shù)的有效方法。
特殊情況是：
( ±0).MantExp(mant) = 0, with mant set to ±0(±Inf).MantExp(mant) = 0, with mant set to ±Inf
x和mant可以是相同的，在這種情況下x被設(shè)置為其尾數(shù)值。
func (*Float) MarshalText
func (x *Float) MarshalText() (text []byte, err error)
MarshalText 實現(xiàn)了encoding.TextMarshaler接口。只有浮點值被編組（全精度），其他屬性（如精度或精度）被忽略。
func (*Float) MinPrec
func (x *Float) MinPrec() uint
MinPrec 返回精確表示x所需的最小精度（即x.SetPrec（prec）將開始舍入x）之前的最小精度。對于 |x| == 0和|x| == Inf。結(jié)果為0
func (*Float) Mode
func (x *Float) Mode() RoundingMode
模式返回 x 的舍入模式。
func (*Float) Mul
func (z *Float) Mul(x, y *Float) *Float
Mul 將 z 設(shè)置為舍入乘積 x * y 并返回 z 。精確度，舍入和準確性報告與 Add 相同。如果一個操作數(shù)為零而另一個操作數(shù)為無窮大，則 Mul 會與 ErrNaN 發(fā)生混亂。在這種情況下 z 的值是未定義的。
func (*Float) Neg
func (z *Float) Neg(x *Float) *Float
Neg將z設(shè)置為x的（可能為四舍五入的）值，其符號取反，并返回z。
func (*Float) Parse
func (z *Float) Parse(s string, base int) (f *Float, b int, err error)
Parse解析 s ，其中必須包含浮點數(shù)的文本表示，其中尾數(shù)在給定的轉(zhuǎn)換基數(shù)（指數(shù)始終為十進制數(shù)）或表示無限值的字符串中。
它將 z 設(shè)置為相應(yīng)浮點值的（可能為四舍五入的）值，并返回 z，實際的基數(shù) 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" ) .基本參數(shù)必須是0，2，10或16。提供無效的基本參數(shù)將導(dǎo)致運行時恐慌。
對于基數(shù)0，數(shù)字前綴確定實際基數(shù)：“0x”或“0X”的前綴選擇基數(shù)16，而“0b”或“0B”前綴選擇基數(shù)2; 否則，實際基數(shù)為10，并且不接受前綴。不支持八進制前綴“0”（前導(dǎo)“0”簡單地被認為是“0”）。
“p”指數(shù)表示二進制（而不是十進制）指數(shù); 例如“0x1.fffffffffffffp1023”（使用基數(shù)0）表示float64的最大值。對于十六進制mantissae，指數(shù)必須是二進制的（如果存在的話）（“e”或“E”指數(shù)指示不能與尾數(shù)數(shù)字區(qū)分開來）。
返回的* Float f是零，并且 z 的值有效，但是如果報告錯誤則不定義。
func (*Float) Prec
func (x *Float) Prec() uint
Prec 以位為單位返回 x 的尾數(shù)精度。對于|x| == 0和|x| == Inf，結(jié)果可能為0。
func (*Float) Quo
func (z *Float) Quo(x, y *Float) *Float
現(xiàn)在將 z 設(shè)置為四舍五入的商x/y并返回 z 。精確度，舍入和準確性報告與 Add 相同。如果兩個操作數(shù)都是零或無窮大，那么現(xiàn)在恐慌與 ErrNaN 。在這種情況下 z 的值是未定義的。
func (*Float) Rat
func (x *Float) Rat(z *Rat) (*Rat, Accuracy)
Rat 返回對應(yīng)于 x 的有理數(shù); 如果 x 是無窮大，則為零。如果 x 不是 Inf，結(jié)果是 Exact。如果提供非零* Rat參數(shù) z，則 Rat 將結(jié)果存儲在 z 中，而不是分配新的 Rat 。
func (*Float) Scan
func (z *Float) Scan(s fmt.ScanState, ch rune) error
掃描是fmt.Scanner的支持例程；它將 z 設(shè)置為掃描號碼的值。它接受fmt.Scan為浮點值支持的動詞格式，它們是：'b'（二進制），'e'，'E'，'f'，'F'，'g'和'G'。掃描不處理±Inf。
示例
package mainimport ("fmt""log""math/big")func main() {// 掃描功能很少直接使用;// 禁產(chǎn)條約包承認它是裂變材料條約的一個實施。掃描儀。
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設(shè)置為x的（可能為四舍五入的）值并返回z。如果z的精度為0，則在設(shè)置z之前將其更改為x的精度（并且舍入將不起作用）。舍入是根據(jù)z的精度和舍入模式執(zhí)行的; 并且z的準確性報告相對于確切（不是四舍五入）結(jié)果的結(jié)果錯誤。
func (*Float) SetFloat64
func (z *Float) SetFloat64(x float64) *Float
SetFloat64 將 z 設(shè)置為 x 的（可能為四舍五入的）值并返回 z 。如果 z 的精度為0，則其更改為53（并且舍入將不起作用）。如果 x 是 NaN，則 SetFloat64 與 ErrNaN 發(fā)生混亂。
func (*Float) SetInf
func (z *Float) SetInf(signbit bool) *Float
SetInf 將 z 設(shè)置為無限Float -Inf（如果設(shè)置了符號位）或者+Inf（如果未設(shè)置符號位）并返回 z 。z 的精度不變，結(jié)果總是精確的。
func (*Float) SetInt
func (z *Float) SetInt(x *Int) *Float
SetInt將 z 設(shè)置為 x 的（可能為四舍五入的）值并返回 z。如果 z 的精度為0，則將其更改為x.BitLen()或64中較大的一個（并且舍入將不起作用）。
func (*Float) SetInt64
func (z *Float) SetInt64(x int64) *Float
SetInt64將 z 設(shè)置為 x 的（可能為四舍五入的）值并返回 z。如果z的精度為0，則它變?yōu)?4（并且舍入將不起作用）。
func (*Float) SetMantExp
func (z *Float) SetMantExp(mant *Float, exp int) *Float
SetMantExp 將 z 設(shè)置為mant×2 ** exp并返回 z 。結(jié)果 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 的指數(shù)設(shè)置為 exp 。
func (*Float) SetMode
func (z *Float) SetMode(mode RoundingMode) *Float
SetMode 將 z 的舍入模式設(shè)置為模式并返回確切的 z 。z 保持不變。z.SetMode(z.Mode())是將 z 的準確性設(shè)置為 Exact 的廉價方法。
func (*Float) SetPrec
func (z *Float) SetPrec(prec uint) *Float
SetPrec 將 z 的精度設(shè)置為 prec 并返回（可能）z的四舍五入值。如果尾數(shù)不能用精確比特表示，并且沒有精度損失，則根據(jù)z的舍入模式舍入。SetPrec(0) 將所有有限值映射為±0；無限的價值保持不變。如果prec> MaxPrec，則將其設(shè)置為 MaxPrec 。
func (*Float) SetRat
func (z *Float) SetRat(x *Rat) *Float
SetRat 將 z 設(shè)置為 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 設(shè)置為 s 的值，并返回z和一個表示成功的布爾值。s 必須是一個與 Parse 接受的格式相同的浮點數(shù)，其基數(shù)為0。整個字符串（不只是前綴）必須對成功有效。如果操作失敗，則z的值未定義，但返回值為零。
func (*Float) SetUint64
func (z *Float) SetUint64(x uint64) *Float
SetUint64 將 z 設(shè)置為 x 的（可能為四舍五入的）值并返回z。如果 z 的精度為0，則它變?yōu)?4（并且舍入將不起作用）。
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）。（字符串必須顯式調(diào)用，F(xiàn)loat.Format不支持％s動詞。）
func (*Float) Sub
func (z *Float) Sub(x, y *Float) *Float
Sub 將 z 設(shè)置為舍入差異 xy 并返回 z 。精確度，舍入和準確性報告與 Add 相同。如果 x 和 y 是等號的無窮大，則會與 ErrNaN 發(fā)生混淆。在這種情況下 z 的值是未定義的。
func (*Float) Text
func (x *Float) Text(format byte, prec int) string
文本根據(jù)給定的格式和精度 prec 將浮點數(shù) x 轉(zhuǎn)換為一個字符串。格式是以下之一：
'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
對于二進制指數(shù)格式，尾數(shù)以標準化形式打?。?/p>
'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'格式打印的位數(shù)（不包括指數(shù)）。對于'e'，'E'和'f'，它是小數(shù)點后的位數(shù)。對于'g'和'G'這是總位數(shù)。負精度選擇使用x.Pre()尾數(shù)位唯一標識值x所需的最小小數(shù)位數(shù)?！癰”或“p”格式的 prec 值將被忽略。
func (*Float) Uint64
func (x *Float) Uint64() (uint64, Accuracy)
Uint64 返回將 x 截斷為零的無符號整數(shù)。如果0 <= x <= math.MaxUint64，則結(jié)果為 Exact，如果x是一個整數(shù)，否則返回 Below。對于x <0，結(jié)果為(0，Above)；對于x> math.MaxUint64，結(jié)果為（math.MaxUint64，Below）。
func (*Float) UnmarshalText
func (z *Float) UnmarshalText(text []byte) error
UnmarshalText實現(xiàn)了encoding.TextUnmarshaler接口。結(jié)果按z的精度和舍入模式四舍五入。如果z的精度為0，則在舍入生效之前將其更改為64。
type Int
Int 表示一個帶符號的多精度整數(shù)。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 設(shè)置為 |x|（x 的絕對值）并返回 z 。
func (*Int) Add
func (z *Int) Add(x, y *Int) *Int
將 z 設(shè)置為總和 x + y 并返回 z 。
func (*Int) And
func (z *Int) And(x, y *Int) *Int
并設(shè)置 z = x＆y 并返回 z 。
func (*Int) AndNot
func (z *Int) AndNot(x, y *Int) *Int
并且不設(shè)置 z = x＆^ y 并返回 z 。
func (*Int) Append
func (x *Int) Append(buf []byte, base int) []byte
Append 將由 x.Text（base）生成的 x 的字符串表示形式附加到 buf 并返回擴展緩沖區(qū)。
func (*Int) Binomial
func (z *Int) Binomial(n, k int64) *Int
二項式將 z 設(shè)置為 (n, k) 的二項式系數(shù)并返回 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 的原始（未經(jīng)檢查但快速）訪問。結(jié)果和x共享相同的底層數(shù)組。位旨在支持在此包外部實現(xiàn)缺少的低級別 Int 功能；否則應(yīng)該避免。
func (*Int) Bytes
func (x *Int) Bytes() []byte
字節(jié)返回 x 的絕對值作為大端字節(jié)片。
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 設(shè)置為 y!= 0 的商x / y并返回 z 。如果y == 0，則會發(fā)生除零運行時恐慌。Div 實現(xiàn)歐幾里德分割（與Go不同）; 請參閱 DivMod 了解更多詳情。
func (*Int) DivMod
func (z *Int) DivMod(x, y, m *Int) (*Int, *Int)
DivMod 將 z 設(shè)置為商x div y和m至模x mod y并返回y(y，y)對(z，m)。如果y == 0，則發(fā)生除零運行時恐慌。
DivMod 實現(xiàn)歐幾里德分割和模數(shù)（與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 設(shè)置 z = x**y mod |m|（即 m 的符號被忽略），并返回z。如果y <= 0，則結(jié)果為1 mod |m；如果m == nil或m == 0，則z = x ** y。
特定大小輸入的模塊化指數(shù)不是一個密碼恒定時間操作。
func (*Int) Format
func (x *Int) Format(s fmt.State, ch rune)
格式實現(xiàn)了fmt.Formatter。它接受格式'b'（二進制），'o'（八進制），'d'（十進制），'x'（小寫十六進制）和'X'（大寫十六進制）。還支持整套fmt格式的整型標志，包括用于符號控制的'+'和''，用于八進制和十六進制的前導(dǎo)零，'％'的前導(dǎo)“0”或“0X” #x“和”％＃X“分別指定最小位數(shù)精度，輸出字段寬度，空格或零填充以及用于左對齊或右對齊的' - '。
func (*Int) GCD
func (z *Int) GCD(x, y, a, b *Int) *Int
GCD將z設(shè)置為a和b的最大公約數(shù)，它們都必須> 0，并返回z。如果x和y不為零，則GCD將x和y設(shè)置為z = a * x + b * y。如果a或b <= 0，則GCD設(shè)置z = x = y = 0。
func (*Int) GobDecode
func (z *Int) GobDecode(buf []byte) error
GobDecode實現(xiàn)了gob.GobDecoder接口。
func (*Int) GobEncode
func (x *Int) GobEncode() ([]byte, error)
GobEncode 實現(xiàn) gob.GobEncoder 接口。
func (*Int) Int64
func (x *Int) Int64() int64
Int64 返回 x 的 int64 表示形式。如果 x 不能在 int64 中表示，結(jié)果是未定義的。
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 設(shè)置z = x << n并返回 z 。
func (*Int) MarshalJSON
func (x *Int) MarshalJSON() ([]byte, error)
MarshalJSON實現(xiàn)了json.Marshaler接口。
func (*Int) MarshalText
func (x *Int) MarshalText() (text []byte, err error)
MarshalText 實現(xiàn)了encoding.TextMarshaler接口。
func (*Int) Mod
func (z *Int) Mod(x, y *Int) *Int
Mod 將 z 設(shè)置為y！= 0的模量x％y并返回 z 。如果y == 0，則會發(fā)生除零運行時恐慌。Mod 實現(xiàn)歐幾里德模量（與Go不同）; 請參閱 DivMod 了解更多詳情。
func (*Int) ModInverse
func (z *Int) ModInverse(g, n *Int) *Int
ModInverse 將 z 設(shè)置為環(huán)中的 g 的乘法倒數(shù) ?/n? 并返回 z 。如果 g 和 n 不是相對的素數(shù)，結(jié)果是不確定的。
func (*Int) ModSqrt
func (z *Int) ModSqrt(x, p *Int) *Int
如果這樣的平方根存在并且返回 z，則 ModSqrt 將 z 設(shè)置為x mod p的平方根。模數(shù) p 必須是一個奇素數(shù)。如果 x 不是平方 mod p，則 ModSqrt 保持 z 不變并返回 nil 。如果 p 不是奇數(shù)，此函數(shù)會發(fā)生混亂。
func (*Int) Mul
func (z *Int) Mul(x, y *Int) *Int
Mul 將 z 設(shè)置為產(chǎn)品 x * y 并返回 z。
func (*Int) MulRange
func (z *Int) MulRange(a, b int64) *Int
MulRange 將 z 設(shè)置為范圍a，b中所有整數(shù)的乘積，并且返回 z。如果a> b（空范圍），結(jié)果為1。
func (*Int) Neg
func (z *Int) Neg(x *Int) *Int
Neg 將 z 設(shè)置為 -x 并返回 z 。
func (*Int) Not
func (z *Int) Not(x *Int) *Int
未設(shè)置z = ^ x并返回 z 。
func (*Int) Or
func (z *Int) Or(x, y *Int) *Int
或者設(shè)置z = x | y并返回 z 。
func (*Int) ProbablyPrime
func (x *Int) ProbablyPrime(n int) bool
ProbablyPrime 報告 x 是否可能是素數(shù)，用 n 個偽隨機選擇的堿基以及 Baillie-PSW 測試應(yīng)用 Miller-Rabin 測試。
如果 x 是素數(shù)，則 ProbablyPrime 返回 true 。如果 x 隨機選擇而不是素數(shù)，則 ProbablyPrime 可能返回 false 。對于隨機選擇的非素數(shù)返回真的概率至多為1/4。
對于小于2?4的輸入，ProbablyPrime 100％準確。關(guān)于誤差概率的進一步討論參見 Menezes 等人，應(yīng)用密碼學(xué)手冊，1997年，第145-149頁和 FIPS 186-4 附錄 F.
ProbablyPrime 不適用于判斷對手可能制造出來欺騙測試的素數(shù)。
從 Go 1.8 開始，ProbablyPrime(0)是允許的，僅適用于 Baillie-PSW 測試。在Go 1.8之前，ProbablyPrime 只應(yīng)用 Miller-Rabin 測試，而 ProbablyPrime(0) 恐慌。
func (*Int) Quo
func (z *Int) Quo(x, y *Int) *Int
現(xiàn)在將 z 設(shè)置為y！= 0的商 x / y 并返回 z 。如果y == 0，則會發(fā)生除零運行時恐慌?，F(xiàn)在實現(xiàn)截斷分裂（像Go）; 請參閱 QuoRem 了解更多詳情。
func (*Int) QuoRem
func (z *Int) QuoRem(x, y, r *Int) (*Int, *Int)
QuoRem 將 z 設(shè)置為商 x/y，將 r 設(shè)置為余數(shù) x％y，并返回 y(y)= 0 時的對 (z, r) 。如果 y == 0，則會發(fā)生除零運行時恐慌。
QuoRem implements T-division and modulus (like Go):
q = x/y with the result truncated to zero r = x - y*q
（請參閱Daan Leijen，“計算機科學(xué)家的分部和模數(shù)”。）請參見DivMod的歐幾里德除法和模數(shù)（與 Go 不同）。
func (*Int) Rand
func (z *Int) Rand(rnd *rand.Rand, n *Int) *Int
Rand 將 z 設(shè)置為[0，n）中的偽隨機數(shù)并返回 z 。
func (*Int) Rem
func (z *Int) Rem(x, y *Int) *Int
Rem 將 z 設(shè)置為y！= 0的余數(shù) x％y 并返回 z 。如果 y == 0，則會發(fā)生除零運行時恐慌。Rem 實現(xiàn)截斷模數(shù)（如Go）; 請參閱 QuoRem 了解更多詳情。
func (*Int) Rsh
func (z *Int) Rsh(x *Int, n uint) *Int
Rsh 設(shè)置z = x >> n并返回 z 。
func (*Int) Scan
func (z *Int) Scan(s fmt.ScanState, ch rune) error
掃描是fmt.Scanner的支持例程; 它將z設(shè)置為掃描號碼的值。它接受格式'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 (*Int) Set
func (z *Int) Set(x *Int) *Int
將 z 設(shè)置為 x 并返回 z 。
func (*Int) SetBit
func (z *Int) SetBit(x *Int, i int, b uint) *Int
SetBit 將 z 設(shè)置為 x，并將 x 的第 i 位設(shè)置為 b（0或1）。也就是說，如果 b 是1，SetBit 設(shè)置z = x | (1 << i)； 如果 b為0，SetBit 設(shè)置 z = x &^ (1 << i) 。如果 b不是0或1，SetBit 將會發(fā)生混亂。
func (*Int) SetBits
func (z *Int) SetBits(abs []Word) *Int
SetBits 通過將其值設(shè)置為 abs，解釋為 little-endian Word 切片并返回 z ，提供對 z 的原始（未檢查但快速）訪問。結(jié)果和 abs 共享相同的底層數(shù)組。SetBits 旨在支持在此包外部實現(xiàn)缺少的低級別 Int 功能；否則應(yīng)該避免。
func (*Int) SetBytes
func (z *Int) SetBytes(buf []byte) *Int
SetBytes 將 buf 解釋為大端無符號整數(shù)的字節(jié)，將z設(shè)置為該值并返回 z 。
func (*Int) SetInt64
func (z *Int) SetInt64(x int64) *Int
SetInt64 將 z 設(shè)置為 x 并返回 z 。
func (*Int) SetString
func (z *Int) SetString(s string, base int) (*Int, bool)
SetString 將 z 設(shè)置為 s 的值，在給定的基礎(chǔ)中進行解釋，并返回 z 和一個表示成功的布爾值。整個字符串（不只是一個前綴）必須對成功有效。如果 SetString 失敗，則z的值未定義，但返回值為零。
基本參數(shù)必須為0或介于2和 MaxBase 之間的值。如果基數(shù)為0，則字符串前綴將確定實際的轉(zhuǎn)換基數(shù)。前綴“0x”或“0X”選擇基址16；“0”前綴選擇基數(shù)8，而“0b”或“0B”前綴選擇基數(shù)2，否則選擇的基數(shù)為10。
示例
package mainimport ("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 設(shè)置為 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 設(shè)置為?√x?，即 z2≤x 的最大整數(shù)，并返回 z 。如果 x 是負數(shù)，它會發(fā)生恐慌。
func (*Int) String
func (x *Int) String() string
func (*Int) Sub
func (z *Int) Sub(x, y *Int) *Int
Sub 將 z 設(shè)置為差值 xy 并返回 z 。
func (*Int) Text
func (x *Int) Text(base int) string
文本返回給定基礎(chǔ)中 x 的字符串表示形式。基數(shù)必須介于2和36之間，包括2和36。結(jié)果對數(shù)字值> = 10使用小寫字母'a'到'z'。沒有基本前綴（例如“0x”）被添加到字符串中。
func (*Int) Uint64
func (x *Int) Uint64() uint64
Uint64 返回 x 的 uint64 表示。如果 x 不能在 uint64 中表示，結(jié)果是未定義的。
func (*Int) UnmarshalJSON
func (z *Int) UnmarshalJSON(text []byte) error
UnmarshalJSON 實現(xiàn)了 json.Unmarshaler 接口。
func (*Int) UnmarshalText
func (z *Int) UnmarshalText(text []byte) error
UnmarshalText實現(xiàn)了encoding.TextUnmarshaler接口。
func (*Int) Xor
func (z *Int) Xor(x, y *Int) *Int
Xor 設(shè)置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 創(chuàng)建一個新的 Rat 。
func (*Rat) Abs
func (z *Rat) Abs(x *Rat) *Rat
Abs 將 z 設(shè)置為|x|（x的絕對值）并返回 z 。
func (*Rat) Add
func (z *Rat) Add(x, y *Rat) *Rat
將 z 設(shè)置為總和 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。結(jié)果是對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 的字符串表示形式，小數(shù)點后的精度為精度數(shù)字。最后一位數(shù)字四舍五入到最接近的位置，其中一半從零圓整。
func (*Rat) GobDecode
func (z *Rat) GobDecode(buf []byte) error
GobDecode 實現(xiàn)了 gob.GobDecoder 接口。
func (*Rat) GobEncode
func (x *Rat) GobEncode() ([]byte, error)
GobEncode 實現(xiàn) gob.GobEncoder 接口。
func (*Rat) Inv
func (z *Rat) Inv(x *Rat) *Rat
Inv 將 z 設(shè)置為 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 實現(xiàn)了encoding.TextMarshaler接口。
func (*Rat) Mul
func (z *Rat) Mul(x, y *Rat) *Rat
Mul 將 z 設(shè)置為產(chǎn)品 x * y 并返回 z 。
func (*Rat) Neg
func (z *Rat) Neg(x *Rat) *Rat
Neg 將 z 設(shè)置為 -x 并返回 z 。
func (*Rat) Num
func (x *Rat) Num() *Int
Num 返回 x 的分子；它可能<= 0。結(jié)果是對 x 的分子的引用；如果新的值被分配給 x，它可能會改變，反之亦然。分子的符號對應(yīng)于 x 的符號。
func (*Rat) Quo
func (z *Rat) Quo(x, y *Rat) *Rat
現(xiàn)在將 z 設(shè)為商 x/y 并返回 z 。如果 y == 0，則會發(fā)生除零運行時恐慌。
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 mainimport ("fmt""log""math/big")func main() {// 掃描功能很少直接使用;// 禁產(chǎn)條約包承認它是裂變材料條約的一個實施。掃描儀。
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 設(shè)置為 x（通過制作 x 的副本）并返回 z 。
func (*Rat) SetFloat64
func (z *Rat) SetFloat64(f float64) *Rat
SetFloat64 將 z 設(shè)置為完全 f 并返回 z 。如果 f 不是有限的，SetFloat 返回 nil 。
func (*Rat) SetFrac
func (z *Rat) SetFrac(a, b *Int) *Rat
SetFrac 將 z 設(shè)置為 a/b 并返回 z 。
func (*Rat) SetFrac64
func (z *Rat) SetFrac64(a, b int64) *Rat
SetFrac64 將 z 設(shè)置為 a/b 并返回 z 。
func (*Rat) SetInt
func (z *Rat) SetInt(x *Int) *Rat
SetInt 將 z 設(shè)置為 x（通過制作x的副本）并返回 z 。
func (*Rat) SetInt64
func (z *Rat) SetInt64(x int64) *Rat
SetInt64 將 z 設(shè)置為 x 并返回 z 。
func (*Rat) SetString
func (z *Rat) SetString(s string) (*Rat, bool)
SetString 將 z 設(shè)置為 s 的值，并返回 z 和一個表示成功的布爾值。s 可以作為分數(shù) “a/b” 給出，也可以作為浮點數(shù)可選地跟隨一個指數(shù)。整個字符串（不只是一個前綴）必須對成功有效。如果操作失敗，則z的值未定義，但返回值為零。
示例
package mainimport ("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 設(shè)置為差值 xy 并返回 z 。
func (*Rat) UnmarshalText
func (z *Rat) UnmarshalText(text []byte) error
UnmarshalText實現(xiàn)了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 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 (RoundingMode) String
func (i RoundingMode) String() string
type Word
Word 表示多精度無符號整數(shù)的單個數(shù)字。
type Word uint
Bugs
? 舍入 ToNegativeInf 時，F(xiàn)loat 值的符號舍入為0是不正確的。