Package big

import "math/big"
Overview
Index
Examples

Overview ▾

包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 0
var r = &Rat{}   // r is a *Rat of value 0
y := new(Float)  // y is a *Float of value 0

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

func NewT(v V) *T

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

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

设置器,数字运算和谓词表示为以下形式的方法:

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除外)满足Formatter界面进行格式化打印.

实施例(EConvergents)

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

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

例子(斐波那契)

本示例演示如何使用big.Int计算具有100个十进制数字的最小斐波那契数并测试其是否为质数.

1344719667586153181419716641724567886890850696275767987106294472017884974410332069524504824747437757
false

范例(Sqrt2)

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

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

Index ▾

Constants
func Jacobi(x, y *Int) int
type Accuracy
    func (i Accuracy) String() string
type ErrNaN
    func (err ErrNaN) Error() string
type Float
    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 (z *Float) Sqrt(x *Float) *Float
    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 (x *Int) CmpAbs(y *Int) 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) TrailingZeroBits() uint
    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 (z *Rat) SetUint64(x uint64) *Rat
    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

Package files

accuracy_string.go arith.go arith_amd64.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 sqrt.go

Constants

指数和精度极限.

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 = 10 + ('z' - 'a' + 1) + ('Z' - 'A' + 1)

func Jacobi 1.5

func Jacobi(x, y *Int) int

Jacobi返回+ 1,-1或0的Jacobi符号(x / y).y参数必须为奇数整数.

type Accuracy 1.5

精度描述了最近的操作产生的舍入误差,该操作产生一个相对于精确值的浮点值.

type Accuracy int8

描述浮点精度的常数.

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

func (Accuracy) String 1.5

func (i Accuracy) String() string

type ErrNaN 1.5

浮动操作引起ErrNaN恐慌,这将导致IEEE-754规则下的NaN. ErrNaN实现错误接口.

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

func (ErrNaN) Error 1.5

func (err ErrNaN) Error() string

type Float 1.5

非零的有限浮点数表示多精度浮点数

sign × mantissa × 2**exponent

0.5 <=尾数<1.0,且MinExp <=指数<= MaxExp. 浮点数也可以是零(+0,-0)或无限(+ Inf,-Inf). 所有浮点数都是有序的,两个浮点数x和y的顺序由x.Cmp(y)定义.

每个浮点值还具有精度,舍入模式和精度. 精度是可用于表示该值的最大尾数位数. 舍入模式指定如何将结果舍入以适合尾数位,而精度描述相对于精确结果的舍入误差.

除非另有说明,否则为结果指定* Float变量的所有操作(包括设置器)(通常通过MantExp之外的接收器)都将根据结果变量的精度和舍入模式对数字结果进行舍入.

如果提供的结果精度为0(请参见下文),则将其设置为在进行任何舍入之前具有最大精度值的参数的精度,并且舍入模式保持不变. 因此,作为结果参数提供的未初始化的Float会将其精度设置为由操作数确定的合理值,并且其模式为RoundingMode(ToNearestEven)的零值.

通过将期望的精度设置为24或53,并使用匹配的舍入模式(通常为ToNearestEven),对于与普通(即,非非正规)操作数相对应的操作数,Float操作产生的结果与相应的float32或float64 IEEE-754算法相同.数字. 指数下溢和溢出导致值不同于IEEE-754的0或无穷大,因为浮点指数的范围更大.

浮点数的零(未初始化)值可以立即使用,并表示精确地为+0.0的数字,精度为0,舍入模式为ToNearestEven.

Operations always take pointer arguments (*Float) rather than Float values, and each unique Float value requires its own unique *Float pointer. To "copy" a Float value, an existing (or newly allocated) Float must be set to a new value using the Float.Set method; shallow copies of Floats are not supported and may lead to errors.

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

示例(班次)

0.015625
0.03125
0.0625
0.125
0.25
0.5
1
2
4
8
16

func NewFloat 1.5

func NewFloat(x float64) *Float

NewFloat分配并返回设置为x的新Float,精度为53,舍入模式为ToNearestEven. 如果x是NaN,NewFloat会对ErrNaN感到恐慌.

func ParseFloat 1.5

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 1.5

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

Abs将z设置为(可能是四舍五入的)值| x | (x的绝对值)并返回z.

func (*Float) Acc 1.5

func (x *Float) Acc() Accuracy

Acc返回最近一次操作产生的x的精度.

func (*Float) Add 1.5

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

将集合z加到四舍五入后的x + y并返回z. 如果z的精度为0,则在操作之前将其更改为x或y的较大精度. 舍入是根据z的精度和舍入模式进行的; z的精度报告相对于精确(非四舍五入)结果的结果误差. 如果x和y是具有相反符号的无穷大,请使用ErrNaN添加恐慌. 在这种情况下,z的值是不确定的.

Example

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

func (*Float) Append 1.5

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

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

func (*Float) Cmp 1.5

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

Example

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

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

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

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

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

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

func (*Float) Copy 1.5

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

复制将z设置为x,并具有与x相同的精度,舍入模式和精度,并返回z. 即使z和x相同,x也不会改变.

func (*Float) Float32 1.5

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

Float32返回最接近x的float32值. 如果x太小而无法用float32(| x | <math.SmallestNonzeroFloat32)表示,则结果取决于x的符号分别为(0,低于)或(-0,高于). 如果x太大而不能用float32(| x |> math.MaxFloat32)表示,则结果是(+ Inf,Above)或(-Inf,below),具体取决于x的符号.

func (*Float) Float64 1.5

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

Float64返回最接近x的float64值. 如果x太小而无法用float64(| x | <math.SmallestNonzeroFloat64)表示,则结果取决于x的符号分别为(0,低于)或(-0,高于). 如果x太大而不能用float64(| x |> math.MaxFloat64)表示,则结果是(+ Inf,Above)或(-Inf,below),具体取决于x的符号.

func (*Float) Format 1.5

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

Format实现fmt.Formatter. 它接受浮点数的所有常规格式(" b"," e"," E"," f"," F"," g"," G"," x")以及" p"和" v". 参见(* Float).Text有关'p'的解释. 'v'格式的处理方式类似于'g'. 格式还支持指定最低精度(以数字为单位),输出字段宽度以及格式标志" +"和"'(用于符号控制)," 0"(用于空格或零填充)以及"-"(用于左对齐或右对齐) . 有关详细信息,请参见fmt软件包.

func (*Float) GobDecode 1.7

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

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

func (*Float) GobEncode 1.7

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

GobEncode实现gob.GobEncoder接口. 浮点值及其所有属性(精度,舍入模式,准确性)均已封送.

func (*Float) Int 1.5

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

Int返回将x截断为零的结果. 如果x是无穷大,则为nil. 如果x.IsInt();结果为Exact. 否则,对于x> 0,它是"低于";对于x <0,它是高于.如果提供了非nil * Int参数z,则Int会将结果存储在z中,而不是分配新的Int.

func (*Float) Int64 1.5

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

Int64返回将x截断为零所得的整数. 如果math.MinInt64 <= x <= math.MaxInt64,则如果x为整数,则结果为Exact,否则为Above(x <0)或Under(x> 0). 对于x <math.MinInt64,结果为(math.MinInt64,上方);对于x> math.MaxInt64,结果为(math.MaxInt64,下方).

func (*Float) IsInf 1.5

func (x *Float) IsInf() bool

IsInf报告x是+ Inf还是-Inf.

func (*Float) IsInt 1.5

func (x *Float) IsInt() bool

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

func (*Float) MantExp 1.5

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

MantExp将x分解为其尾数和指数成分,并返回指数. 如果提供了非nil mant参数,则将其值设置为x的尾数,其精度和舍入模式与x相同. 分量满足x == mant×2 ** exp,其中0.5 <= | mant | <1.0. 使用nil参数调用MantExp是获得接收方指数的有效方法.

特殊情况是:

(  ±0).MantExp(mant) = 0, with mant set to   ±0
(±Inf).MantExp(mant) = 0, with mant set to ±Inf

在这种情况下,将x和mant设置为尾数即可.

func (*Float) MarshalText 1.6

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

MarshalText实现encoding.TextMarshaler接口. 仅将浮点值编组(以全精度),而忽略诸如精度或精度之类的其他属性.

func (*Float) MinPrec 1.5

func (x *Float) MinPrec() uint

MinPrec返回精确表示x所需的最小精度(即,x.SetPrec(prec)开始对x取整之前的最小prec). | x |的结果为0 == 0和| x | == Inf.

func (*Float) Mode 1.5

func (x *Float) Mode() RoundingMode

Mode返回x的舍入模式.

func (*Float) Mul 1.5

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

Mul将z设置为四舍五入的乘积x * y并返回z. 精度,舍入和精度报告与"添加"相同. 如果一个操作数为零,而另一个操作数为无穷大,则Mul会用ErrNaN惊慌. 在这种情况下,z的值是不确定的.

func (*Float) Neg 1.5

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

Neg将z设置为x的(可能是四舍五入的)值,且其符号取反,然后返回z.

func (*Float) Parse 1.5

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

解析解析s,该s必须包含浮点数的文本表示形式,该浮点数在给定的转换基础中带有尾数(指数始终是十进制数),或者是表示无穷大值的字符串.

对于基数0,下划线字符" _"可能出现在基数前缀和相邻数字之间以及连续数字之间; 这样的下划线不会更改数字的值或返回的数字计数. 如果没有其他错误,则将下划线的错误放置报告为错误. 如果base!= 0,则下划线将不被识别,因此像其他不是有效小数点或数字的字符一样终止扫描.

It sets z to the (possibly rounded) value of the corresponding floating- point value, and returns z, the actual base b, and an error err, if any. The entire string (not just a prefix) must be consumed for success. If z's precision is 0, it is changed to 64 before rounding takes effect. The number must be of the form:

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

基本参数必须为0、2、8、10或16.提供无效的基本参数将导致运行时恐慌.

对于以0为底的数字,数字前缀确定实际的底数:前缀" 0b"或" 0B"选择以2为底," 0o"或" 0O"选择以8为底," 0x"或" 0X"选择以16为底. ,实际基数为10,不接受前缀. 不支持八进制前缀" 0"(前导" 0"被简单地视为" 0").

" p"或" P"指数表示以2为底(而不是以10为底)的指数; 例如," 0x1.fffffffffffffpp1023"(使用基数0)表示最大float64值. 对于十六进制尾数,指数字符必须为" p"或" P"之一(如果存在)(不能将" e"或" E"指数指示符与尾数位区分开).

返回的* Float f为nil,z的值有效,但如果报告错误,则未定义.

func (*Float) Prec 1.5

func (x *Float) Prec() uint

Prec返回x的尾数精度(以位为单位). | x |的结果可能为0 == 0和| x | == Inf.

func (*Float) Quo 1.5

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

Quo将z设置为四舍五入的商x / y并返回z. 精度,舍入和精度报告与"添加"相同. 如果两个操作数均为零或无穷大,则使用ErrNaN进行恐慌. 在这种情况下,z的值是不确定的.

func (*Float) Rat 1.5

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

Rat返回与x对应的有理数; 如果x是无穷大,则为nil. 如果x不是Inf,则结果为Exact. 如果提供了非n * Rat参数z,则Rat将结果存储在z中,而不是分配新的Rat.

func (*Float) Scan 1.8

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

扫描是fmt.Scanner的支持例程; 它将z设置为扫描编号的值. 它接受动词受fmt支持的格式.扫描浮点值,即:``b''(二进制),``e'',``E'',``f'',``F'',``g''和``G''. 扫描不处理±Inf.

Example

1.19282e+99

func (*Float) Set 1.5

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

将z设置为x的(可能是四舍五入的)值,并返回z. 如果z的精度为0,则在设置z之前将其更改为x的精度(并且舍入无效). 舍入是根据z的精度和舍入模式进行的; z的精度报告相对于精确(非四舍五入)结果的结果误差.

func (*Float) SetFloat64 1.5

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

SetFloat64将z设置为x的(可能是四舍五入的)值并返回z. 如果z的精度为0,则将其更改为53(并且舍入将不起作用). 如果x为NaN,则SetFloat64会因ErrNaN出现混乱.

func (*Float) SetInf 1.5

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

如果已设置符号位,则SetInf将z设置为无限Float -Inf;如果未设置符号位,则SetInf将+设置为Inf,然后返回z. z的精度不变,并且结果始终是精确的.

func (*Float) SetInt 1.5

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

SetInt将z设置为x的(可能是四舍五入的)值并返回z. 如果z的精度为0,则将其更改为x.BitLen()或64中的较大者(舍入将不起作用).

func (*Float) SetInt64 1.5

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

SetInt64将z设置为x的(可能是四舍五入的)值并返回z. 如果z的精度为0,则将其更改为64(并且舍入将不起作用).

func (*Float) SetMantExp 1.5

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的指数设置为exp的情况下,z和mant可以相同.

func (*Float) SetMode 1.5

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

SetMode将z的舍入模式设置为mode并返回精确的z. z否则保持不变. z.SetMode(z.Mode())是将z的精度设置为"精确"的廉价方法.

func (*Float) SetPrec 1.5

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

SetPrec将z的精度设置为prec并返回z的(可能)舍入值. 如果在不损失精度的情况下不能以精确位表示尾数,则根据z的舍入模式进行舍入. SetPrec(0)将所有有限值映射为±0; 无限值保持不变. 如果prec> MaxPrec,则将其设置为MaxPrec.

func (*Float) SetRat 1.5

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

SetRat sets z to the (possibly rounded) value of x and returns z. If z's precision is 0, it is changed to the largest of a.BitLen(), b.BitLen(), or 64; with x = a/b.

func (*Float) SetString 1.5

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

SetString将z设置为s的值,并返回z和一个指示成功的布尔值. s必须是与Parse接受的格式相同的浮点数,并且基本参数为0.整个字符串(不仅仅是前缀)必须有效才能成功. 如果操作失败,则z的值不确定,但返回的值为nil.

func (*Float) SetUint64 1.5

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

SetUint64将z设置为x的(可能是四舍五入的)值并返回z. 如果z的精度为0,则将其更改为64(并且舍入将不起作用).

func (*Float) Sign 1.5

func (x *Float) Sign() int

标志返回:

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

func (*Float) Signbit 1.5

func (x *Float) Signbit() bool

Signbit报告x是负数还是负零.

func (*Float) Sqrt 1.10

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

Sqrt将z设置为x的圆角平方根,并将其返回.

如果z的精度为0,则在操作之前将其更改为x的精度. 根据z的精度和舍入模式执行舍入.

如果z <0,函数将出现紧急情况.在这种情况下,z的值不确定.

func (*Float) String 1.5

func (x *Float) String() string

字符串格式x类似于x.Text('g',10). (必须显式调用字符串,Float.Format不支持%s动词.)

func (*Float) Sub 1.5

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

Sub将z设置为四舍五入的差xy并返回z. 精度,舍入和精度报告与"添加"相同. 如果x和y是等号的无穷大,则用ErrNaN进行子恐慌. 在这种情况下,z的值是不确定的.

func (*Float) Text 1.5

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
'x'	-0xd.dddddp±dd, hexadecimal mantissa, decimal power of two exponent
'p'	-0x.dddp±dd, hexadecimal mantissa, decimal power of two exponent (non-standard)
'b'	-ddddddp±dd, decimal mantissa, decimal power of two exponent (non-standard)

对于2的幂次幂格式,尾数以规范化形式打印:

'x'	hexadecimal mantissa in [1, 2), or 0
'p'	hexadecimal mantissa in [½, 1), or 0
'b'	decimal integer mantissa using x.Prec() bits, or 0

Note that the 'x' form is the one used by most other languages and libraries.

如果format是其他字符,则Text返回"%",后跟无法识别的格式字符.

精度精度控制以" e"," E"," f"," g"," G"和" x"格式打印的位数(不包括指数). 对于" e"," E"," f"和" x",它是小数点后的位数. 对于" g"和" G",它是数字的总数. 负精度选择使用x.Prec()尾数位来唯一标识值x所需的最少十进制数字. 对于'b'和'p'格式,prec值将被忽略.

func (*Float) Uint64 1.5

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

Uint64 returns the unsigned integer resulting from truncating x towards zero. If 0 <= x <= math.MaxUint64, the result is Exact if x is an integer and Below otherwise. The result is (0, Above) for x < 0, and (math.MaxUint64, Below) for x > math.MaxUint64.

func (*Float) UnmarshalText 1.6

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

UnmarshalText实现encoding.TextUnmarshaler接口. 根据z的精度和舍入模式对结果进行舍入. 如果z的精度为0,则在四舍五入生效之前将其更改为64.

type Int

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

操作始终使用指针参数(* Int)而不是Int值,并且每个唯一的Int值都需要其自己的唯一的* Int指针. 若要"复制"一个Int值,必须使用Int.Set方法将一个现有(或新分配的)Int设置为一个新值; 不支持Ints的浅表副本,可能会导致错误.

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

func NewInt

func NewInt(x int64) *Int

NewInt分配并返回设置为x的新Int.

func (*Int) Abs

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

Abs将z设置为| x | (x的绝对值)并返回z.

func (*Int) Add

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

将集合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

AndNot设置z = x&^ y并返回z.

func (*Int) Append 1.6

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

追加将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

通过将x的绝对值作为小端单词切片返回,Bits提供了对x的原始(未经检查但快速的)访问. 结果和x共享相同的基础数组. Bits旨在支持该程序包外部缺少的底层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) CmpAbs 1.10

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

CmpAbs比较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将y!= 0的z设置为商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!= 0的对(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的欧几里得定义".ACMTransactions on Programming Languages and Systems(TOPLAS),14(2):127-144,纽约,NY,美国,4/1992. ACM印刷机.)有关T划分和模量(如Go),请参见QuoRem.

func (*Int) Exp

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

exp集合z = x ** y mod | m | (即忽略m的符号),并返回z. 如果m == nil或m == 0,则z = x ** y,除非y <= 0则z =1.如果m> 0,y <0,并且x和n不是相对质数,则z不变且nil返回.

特定大小的输入的模幂不是密码恒定时间操作.

func (*Int) Format

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

Format实现fmt.Formatter. 它接受以下格式:" b"(二进制)," o"(前缀为0的八进制)," O"(前缀为0o的八进制)," d"(十进制)," x"(小写十六进制)和" X" (大写十六进制). 还支持完整的软件包fmt格式标记集,用于整数类型,包括用于符号控制的'+'和'',用于八进制和十六进制的'#',用于"%"的前缀" 0x"或" 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将其值设置为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 implements the gob.GobEncoder interface.

func (*Int) Int64

func (x *Int) Int64() int64

Int64返回x的int64表示形式. 如果x不能在int64中表示,则结果不确定.

func (*Int) IsInt64 1.9

func (x *Int) IsInt64() bool

IsInt64 reports whether x can be represented as an int64.

func (*Int) IsUint64 1.9

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 1.1

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

MarshalJSON实现json.Marshaler接口.

func (*Int) MarshalText 1.3

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

MarshalText实现encoding.TextMarshaler接口.

func (*Int) Mod

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

Mod将y!= 0的z设置为模数x%y并返回z. 如果y == 0,则会发生零除运行时崩溃. Mod实现欧几里德模量(不同于Go); 有关更多详细信息,请参见DivMod.

func (*Int) ModInverse

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

ModInverse将z设置为环ℤ/nℤ中g的乘法逆,然后返回z. 如果g和n不是相对质数,则g在环ℤ/nℤ中没有乘法逆. 在这种情况下,z不变,返回值为nil.

func (*Int) ModSqrt 1.5

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

如果存在这样的平方根,则ModSqrt会将z设置为x mod p的平方根,然后返回z. 模数p必须是奇数素数. 如果x不是平方模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个伪随机选择的碱基的Miller-Rabin检验以及Baillie-PSW检验.

如果x为质数,则ProbablyPrime返回true. 如果x是随机选择而不是素数,则ProbablyPrime可能返回false. 对于随机选择的非素数返回true的概率最多为1 /4ⁿ.

输入少于2⁶⁴时,Prime可能是100%准确的. 有关错误概率的进一步讨论,请参见Menezes等人,《应用密码学手册》,1997年,第145-149页和FIPS 186-4附录F.

可能Prime不适合判断对手为欺骗测试而可能制作的素数.

从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

Quo将y!= 0的z设为商x / y并返回z. 如果y == 0,则会发生零除运行时崩溃. Quo实现了截断的除法(如Go); 有关更多详细信息,请参见QuoRem.

func (*Int) QuoRem

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

QuoRem将z设置为商x / y,将r设置为余数x%y,并返回y!= 0的对(z,r).如果y == 0,则会发生零除运行时恐慌.

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在[0,n)中将z设置为伪随机数,然后返回z.

由于它使用math / rand软件包,因此不得用于对安全性敏感的工作. 使用crypto / rand.Int代替.

func (*Int) Rem

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

Rem将y!= 0的z设置为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"(大写十六进制).

Example

18446744073709551617

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 <<我); 如果b为0 SetBit设置z = x&^(1 << i). 如果b不为0或1,则SetBit将发生恐慌.

func (*Int) SetBits

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

SetBits通过将z的值设置为abs(解释为小端单词切片)并返回z,从而提供对z的原始(未经检查但快速的)访问. 结果和ab共享相同的基础数组. 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的值不确定,但返回的值为nil.

基本参数必须为0或2到MaxBase之间的值. 对于以0为底的数字,数字前缀确定实际的底数:以" 0b"或" 0B"为前缀选择2,以" 0"," 0o"或" 0O"为前缀选择8,以" 0x"或" 0X"为前缀选择base16.否则,所选的base为10,并且不接受前缀.

对于基数<= 36,小写和大写字母被认为是相同的:字母'a'到'z'和'A'到'Z'代表数字值10到35.对于基数> 36,大写字母' A'至'Z'代表数字值36至61.

对于基数0,下划线字符" _"可能出现在基数前缀和相邻数字之间以及连续数字之间; 这样的下划线不会更改数字的值. 如果没有其他错误,则将下划线的错误放置报告为错误. 如果基数!= 0,则下划线将不被识别,其作用类似于无效数字的任何其他字符.

Example

420

func (*Int) SetUint64 1.1

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 1.8

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

Sqrt将z设置为⌊√x⌋,即使得z²≤x的最大整数,并返回z. 如果x为负,则表示恐慌.

func (*Int) String

func (x *Int) String() string

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

func (*Int) Sub

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

Sub将z设置为差xy并返回z.

func (*Int) Text 1.6

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

文本返回给定基数中x的字符串表示形式. 底数必须在2到62(含)之间. 结果使用小写字母" a"至" z"表示数字值10至35,使用大写字母" A"至" Z"表示数字值36至61.无前缀(例如" 0x" )添加到字符串中. 如果x是nil指针,则返回" <nil>".

func (*Int) TrailingZeroBits 1.13

func (x *Int) TrailingZeroBits() uint

TrailingZeroBits返回| x |的连续最低有效零位的数目.

func (*Int) Uint64 1.1

func (x *Int) Uint64() uint64

Uint64返回x的uint64表示形式. 如果x无法用uint64表示,则结果不确定.

func (*Int) UnmarshalJSON 1.1

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

UnmarshalJSON实现json.Unmarshaler接口.

func (*Int) UnmarshalText 1.3

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.

操作始终使用指针参数(* Rat)而不是Rat值,并且每个唯一的Rat值都需要其自己的唯一* Rat指针. 要"复制" Rat值,必须使用Rat.Set方法将现有(或新分配的)Rat设置为新值. 不支持大鼠的浅表副本,可能会导致错误.

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

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 1.4

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

Float32返回x的最接近float32值和一个布尔值,指示f是否精确表示x. 如果x的大小太大而无法用float32表示,则f为无穷大,而precision为false. 即使f == 0,f的符号也总是与x的符号匹配.

func (*Rat) Float64 1.1

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

Float64返回x的最接近float64值,以及一个布尔值,指示f是否精确表示x. 如果x的大小太大而无法用float64表示,则f为无穷大,而precision为false. 即使f == 0,f的符号也总是与x的符号匹配.

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 1.3

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

MarshalText实现encoding.TextMarshaler接口.

func (*Rat) Mul

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

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

func (*Rat) Neg

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

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

func (*Rat) Num

func (x *Rat) Num() *Int

Num返回x的分子; 结果可能是<=0.结果是对x分子的引用. 如果将新值分配给x,它可能会更改,反之亦然. 分子的符号与x的符号相对应.

func (*Rat) Quo

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

Quo将z设置为商x / y并返回z. 如果y == 0,则会发生零除运行时崩溃.

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". 所有格式都是等效的.

Example

3/2

func (*Rat) Set

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

Set将z设置为x(通过复制x)并返回z.

func (*Rat) SetFloat64 1.1

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"给出,也可以作为浮点数(可选地后面跟一个指数)给出. 如果提供分数,则除数和除数都可以是十进制整数,或分别使用前缀" 0b"," 0"或" 0o"或" 0x"(或其大写变体)来表示a二进制,八进制或十六进制整数. 除数可能未签名. 如果提供了浮点数,则它可以采用十进制形式,也可以使用与上述相同的任何前缀,但" 0"表示非十进制尾数. 前导" 0"被认为是十进制前导0; 在这种情况下,它不表示八进制表示形式. 还可以提供可选的以10为底的" e"或以2为底的" p"(或其大写变体)指数,但十六进制浮点数仅接受(可选)" p"指数(因为" e" "或" E"不能与尾数区分开. 整个字符串(不仅仅是前缀)必须有效才能成功. 如果操作失败,则z的值不确定,但返回的值为nil.

Example

3.142

func (*Rat) SetUint64 1.13

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

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

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

String以" a / b"形式返回x的字符串表示形式(即使b == 1).

func (*Rat) Sub

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

Sub将z设置为差xy并返回z.

func (*Rat) UnmarshalText 1.3

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

UnmarshalText实现encoding.TextUnmarshaler接口.

type RoundingMode 1.5

RoundingMode确定如何将Float值四舍五入到所需的精度. 四舍五入可能会更改Float值; 舍入误差由浮点精度描述.

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
)

Example

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

func (RoundingMode) String 1.5

func (i RoundingMode) String() string

type Word 1.9

单词代表多精度无符号整数的一位数字.

type Word uint

by  ICOPY.SITE