php mutile 手册,math/big - [ Go 中文开发手册 ] - 在线原生手册 - php中文网

import "math/big"

概述

索引

示例

概述

Big 包实现了任意精度算术(大数)。支持以下数字类型:

Int    signed integers

Rat    rational numbers

Float  floating-point numbers

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

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

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

func NewT(v V) *T

例如,NewInt(x)返回* Int,设置为int64参数x的值,NewRat(a, b)返回设置为a/b的小数部分a/b,其中a和b是int64值,NewFloat(f)返回一个初始化为float64参数f的Float。显式设置器提供了更多的灵活性,例如:

var z1 Int

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

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

func (z *T) SetV(v V) *T          // z = vfunc (z *T) Unary(x *T) *T        // z = unary xfunc (z *T) Binary(x, y *T) *T    // z = x binary yfunc (x *T) Pred() P              // p = pred(x)

用 T,Int,Rat 或 Float 中的一个。对于一元和二元运算,结果是接收器(在这种情况下通常命名为z;见下文); 如果它是操作数x或y中的一个,它可能会被安全覆盖(以及它的内存重用)。

算术表达式通常写成一系列单独的方法调用,每个调用都对应一个操作。接收方表示结果,方法参数是操作的操作数。例如,给定三个* Int值a,b和c,调用

c.Add(a, b)

计算总和 a + b 并将结果存储在 c 中,覆盖之前在 c 中保存的任何值。除非另有说明,否则操作允许混叠参数,因此写入完全可以

sum.Add(sum, x)

在一个和中累加值 x 。

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

符号约定:传入方法参数(包括接收者)在API中被一致命名以阐明其用法。传入的操作数通常命名为 x,y,a,b 等等,但从不 z 。指定结果的参数被命名为 z (通常是接收者)。

例如, (*Int).Add 的参数被命名为 x 和 y,并且因为接收者指定了结果目的地,所以它被称为z:

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

这种形式的方法通常也会返回传入的接收者,以启用简单的呼叫链接。

不需要传入结果值的方法(例如Int.Sign),只需返回结果。在这种情况下,接收器通常是第一个操作数,名为x:

func (x *Int) Sign() int

各种方法支持字符串和相应数值之间的转换,反之亦然:* Int,* Rat 和 * Float 值为值的(默认)字符串表示形式实现Stringer接口,但也提供SetString方法以初始化来自一个支持多种格式的字符串(请参阅相应的SetString文档)。

最后,* Int,* Rat和* Float满足 fmt 软件包的 Scanner 界面进行扫描和格式化界面格式化打印(* Rat除外)。

示例(EConvergents)

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

package mainimport ("fmt""math/big")// Use the classic continued fraction for e//     e = [1; 0, 1, 1, 2, 1, 1, ... 2n, 1, 1, ...]// i.e., for the nth term, use//     1          if   n mod 3 != 1//  (n-1)/3 * 2   if   n mod 3 == 1func recur(n, lim int64) *big.Rat {

term := new(big.Rat)if n%3 != 1 {

term.SetInt64(1)} else {

term.SetInt64((n - 1) / 3 * 2)}if n > lim {return term}// Directly initialize frac as the fractional// inverse of the result of recur.

frac := new(big.Rat).Inv(recur(n+1, lim))return term.Add(term, frac)}// This example demonstrates how to use big.Rat to compute the// first 15 terms in the sequence of rational convergents for// the constant e (base of natural logarithm).func main() {for i := 1; i <= 15; i++ {

r := recur(0, int64(i))// Print r both as a fraction and as a floating-point number.// Since big.Rat implements fmt.Formatter, we can use %-13s to// get a left-aligned string representation of the fraction.

fmt.Printf("%-13s = %s\n", r, r.FloatString(8))}}

示例(Fibonacci)

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

package mainimport ("fmt""math/big")func main() {// Initialize two big ints with the first two numbers in the sequence.

a := big.NewInt(0)

b := big.NewInt(1)// Initialize limit as 10^99, the smallest integer with 100 digits.var limit big.Int

limit.Exp(big.NewInt(10), big.NewInt(99), nil)// Loop while a is smaller than 1e100.for a.Cmp(&limit) 

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的平方根,以及如何将结果打印为十进制数。

package mainimport ("fmt""math""math/big")func main() {// 我们将做计算与200位精度在尾数。const prec = 200// 用牛顿法计算2的平方根。我们从// sqrt (2) 的初始估计值, 然后循环访问://     x_{n+1} = 1/2 * ( x_n + (2.0 / x_n) )// 因为牛顿的方法加倍的正确数字在每个// 迭代, 我们至少需要 log_2 (prec) 步骤。

steps := int(math.Log2(prec))// 初始化计算所需的值。

two := new(big.Float).SetPrec(prec).SetInt64(2)

half := new(big.Float).SetPrec(prec).SetFloat64(0.5)// 使用1作为初始估计值。

x := new(big.Float).SetPrec(prec).SetInt64(1)// 我们使用 t 作为一个临时变量。没有必要设定它的精确度// 从大。浮动值 (== 0) 精度自动承担// 作为结果使用时参数的最大精度 (接收者)// 大。浮动操作。

t := new(big.Float)// 迭代。for i := 0; i <= steps; i++ {

t.Quo(two, x)  // t = 2.0 / x_n

t.Add(x, t)    // t = x_n + (2.0 / x_n)

x.Mul(half, t) // x_{n+1} = 0.5 * t}// 我们可以使用常规的裂变材料。自大以来的 Printf 动词。浮动实现了裂变材料。格式

fmt.Printf("sqrt(2) = %.50f\n", x)// 打印2和之间的x*x错误。

t.Mul(x, x) // t = x*x

fmt.Printf("error = %e\n", t.Sub(two, t))}

索引

常量

func Jacobi(x, y *Int) int

type Accuracy

func (i Accuracy) String() string

type ErrNaN

func (err ErrNaN) Error() string

type Float

func NewFloat(x float64) *Float

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

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

func (x *Float) Acc() Accuracy

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

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

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

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

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

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

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

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

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

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

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

func (x *Float) IsInf() bool

func (x *Float) IsInt() bool

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

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

func (x *Float) MinPrec() uint

func (x *Float) Mode() RoundingMode

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

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

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

func (x *Float) Prec() uint

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func (x *Float) Sign() int

func (x *Float) Signbit() bool

func (x *Float) String() string

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

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

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

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

type Int

func NewInt(x int64) *Int

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

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

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

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

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

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

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

func (x *Int) BitLen() int

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

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

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

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

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

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

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

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

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

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

func (x *Int) Int64() int64

func (x *Int) IsInt64() bool

func (x *Int) IsUint64() bool

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func (x *Int) Sign() int

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

func (x *Int) String() string

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

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

func (x *Int) Uint64() uint64

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

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

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

type Rat

func NewRat(a, b int64) *Rat

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

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

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

func (x *Rat) Denom() *Int

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

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

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

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

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

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

func (x *Rat) IsInt() bool

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

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

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

func (x *Rat) Num() *Int

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

func (x *Rat) RatString() string

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

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

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

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

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

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

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

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

func (x *Rat) Sign() int

func (x *Rat) String() string

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

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

type RoundingMode

func (i RoundingMode) String() string

type Word

Bugs

示例

Float.Add Float.Cmp Float.Scan Float (Shift) Int.Scan Int.SetString Rat.Scan Rat.SetString RoundingMode Package (EConvergents) Package (Fibonacci) Package (Sqrt2)

文件包

accuracy_string.go arith.go arith_decl.go decimal.go doc.go float.go floatconv.go floatmarsh.go ftoa.go int.go intconv.go intmarsh.go nat.go natconv.go prime.go rat.go ratconv.go ratmarsh.go roundingmode_string.go

常量

指数和精度限制。

const (

MaxExp  = math.MaxInt32  // largest supported exponent

MinExp  = math.MinInt32  // smallest supported exponent

MaxPrec = math.MaxUint32 // largest (theoretically) supported precision; likely memory-limited)

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

const MaxBase = 'z' - 'a' + 10 + 1

func Jacobi

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 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 设置为 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 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 浮点数 x 的字符串形式,由x.Text生成,并返回扩展缓冲区。

func (*Float) Cmp

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

Cmp 比较 x 和 y 并返回:

-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 设置为 x ,具有相同的精度,舍入模式,精度等于 x ,并返回 z 。即使 z 和 x 相同,x 也不会改变。

func (*Float) Float32

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

Float32返回最接近x的float32值。如果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.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 mainimport ("fmt""log""math/big")func main() {// 扫描功能很少直接使用;// 禁产条约包承认它是裂变材料条约的一个实施。扫描仪。

f := new(big.Float)

_, err := fmt.Sscan("1.19282e99", f)if err != nil {

log.Println("error scanning value:", err)} else {

fmt.Println(f)}}

func (*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) =   ±0z.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

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 

如果格式是不同的字符,则文本将返回“%”,后跟无法识别的格式字符。

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

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 

(参见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 implements T-division and modulus (like Go):

q = x/y      with the result truncated to zero

r = x - y*q

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

func (*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 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 设置为 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 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 设置为 x 并返回 z 。

func (*Int) Sign

func (x *Int) Sign() int

符号返回:

-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

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 mainimport ("fmt""log""math/big")func main() {// 扫描功能很少直接使用;// 禁产条约包承认它是裂变材料条约的一个实施。扫描仪。

r := new(big.Rat)

_, err := fmt.Sscan("1.5000", r)if err != nil {

log.Println("error scanning value:", err)} else {

fmt.Println(r)}}

func (*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 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

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 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 表示多精度无符号整数的单个数字。

type Word uint

Bugs

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

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值