Golang标准库——math

math

math包提供了基本的数学常数和数学函数。

Constants

const (
    E   = 2.71828182845904523536028747135266249775724709369995957496696763 // A001113
    Pi  = 3.14159265358979323846264338327950288419716939937510582097494459 // A000796
    Phi = 1.61803398874989484820458683436563811772030917980576286213544862 // A001622
    Sqrt2   = 1.41421356237309504880168872420969807856967187537694807317667974 // A002193
    SqrtE   = 1.64872127070012814684865078781416357165377610071014801157507931 // A019774
    SqrtPi  = 1.77245385090551602729816748334114518279754945612238712821380779 // A002161
    SqrtPhi = 1.27201964951406896425242246173749149171560804184009624861664038 // A139339
    Ln2    = 0.693147180559945309417232121458176568075500134360255254120680009 // A002162
    Log2E  = 1 / Ln2
    Ln10   = 2.30258509299404568401799145468436420760110148862877297603332790 // A002392
    Log10E = 1 / Ln10
)

数学常数，参见：http://oeis.org/Axxxxxx

const (
    MaxFloat32             = 3.40282346638528859811704183484516925440e+38  // 2**127 * (2**24 - 1) / 2**23
    SmallestNonzeroFloat32 = 1.401298464324817070923729583289916131280e-45 // 1 / 2**(127 - 1 + 23)
    MaxFloat64             = 1.797693134862315708145274237317043567981e+308 // 2**1023 * (2**53 - 1) / 2**52
    SmallestNonzeroFloat64 = 4.940656458412465441765687928682213723651e-324 // 1 / 2**(1023 - 1 + 52)
)

浮点数的取值极限。Max是该类型所能表示的最大有限值；SmallestNonzero是该类型所能表示的最小非零正数值。

const (
    MaxInt8   = 1<<7 - 1
    MinInt8   = -1 << 7
    MaxInt16  = 1<<15 - 1
    MinInt16  = -1 << 15
    MaxInt32  = 1<<31 - 1
    MinInt32  = -1 << 31
    MaxInt64  = 1<<63 - 1
    MinInt64  = -1 << 63
    MaxUint8  = 1<<8 - 1
    MaxUint16 = 1<<16 - 1
    MaxUint32 = 1<<32 - 1
    MaxUint64 = 1<<64 - 1
)

整数的取值极限。

func NaN

func NaN() float64

函数返回一个IEEE 754“这不是一个数字”值。

func IsNaN

func IsNaN(f float64) (is bool)

报告f是否表示一个NaN（Not A Number）值。

func Inf

func Inf(sign int) float64

如果sign>=0函数返回正无穷大，否则返回负无穷大。

func IsInf

func IsInf(f float64, sign int) bool

如果sign > 0，f是正无穷大时返回真；如果sign<0，f是负无穷大时返回真；sign==0则f是两种无穷大时都返回真。

func Float32bits

func Float32bits(f float32) uint32

函数返回浮点数f的IEEE 754格式二进制表示对应的4字节无符号整数。

func Float32frombits

func Float32frombits(b uint32) float32

函数返回无符号整数b对应的IEEE 754格式二进制表示的4字节浮点数。

func Float64bits

func Float64bits(f float64) uint64

函数返回浮点数f的IEEE 754格式二进制表示对应的8字节无符号整数。

func Float64frombits

func Float64frombits(b uint64) float64

函数返回无符号整数b对应的IEEE 754格式二进制表示的8字节浮点数。

func Signbit

func Signbit(x float64) bool

如果x是一个负数或者负零，返回真。

func Copysign

func Copysign(x, y float64) float64

返回拥有x的量值（绝对值）和y的标志位（正负号）的浮点数。

func Ceil

func Ceil(x float64) float64

返回不小于x的最小整数（的浮点值），特例如下：

Ceil(±0) = ±0
Ceil(±Inf) = ±Inf
Ceil(NaN) = NaN

func Floor

func Floor(x float64) float64

返回不大于x的最大整数（的浮点值），特例如下：

Floor(±0) = ±0
Floor(±Inf) = ±Inf
Floor(NaN) = NaN

func Trunc

func Trunc(x float64) float64

返回x的整数部分（的浮点值）。特例如下：

Trunc(±0) = ±0
Trunc(±Inf) = ±Inf
Trunc(NaN) = NaN

func Modf

func Modf(f float64) (int float64, frac float64)

返回f的整数部分和小数部分，结果的正负号和都x相同；特例如下：

Modf(±Inf) = ±Inf, NaN
Modf(NaN) = NaN, NaN

func Nextafter

func Nextafter(x, y float64) (r float64)

参数x到参数y的方向上，下一个可表示的数值；如果x==y将返回x。特例如下：

Nextafter(NaN, y) = NaN
Nextafter(x, NaN) = NaN

func Abs

func Abs(x float64) float64

返回x的绝对值；特例如下：

Abs(±Inf) = +Inf
Abs(NaN) = NaN

func Max

func Max(x, y float64) float64

返回x和y中最大值，特例如下：

Max(x, +Inf) = Max(+Inf, x) = +Inf
Max(x, NaN) = Max(NaN, x) = NaN
Max(+0, ±0) = Max(±0, +0) = +0
Max(-0, -0) = -0

func Min

func Min(x, y float64) float64

返回x和y中最小值，特例如下：

Min(x, -Inf) = Min(-Inf, x) = -Inf
Min(x, NaN) = Min(NaN, x) = NaN
Min(-0, ±0) = Min(±0, -0) = -0

func Dim

func Dim(x, y float64) float64

函数返回x-y和0中的最大值，特殊情况：

Dim(+Inf, +Inf) = NaN
Dim(-Inf, -Inf) = NaN
Dim(x, NaN) = Dim(NaN, x) = NaN

func Mod

func Mod(x, y float64) float64

取余运算，可以理解为 x-Trunc(x/y)*y，结果的正负号和x相同；特例如下：

Mod(±Inf, y) = NaN
Mod(NaN, y) = NaN
Mod(x, 0) = NaN
Mod(x, ±Inf) = x
Mod(x, NaN) = NaN

func Remainder

func Remainder(x, y float64) float64

IEEE 754差数求值，即x减去最接近x/y的整数值（如果有两个整数与x/y距离相同，则取其中的偶数）与y的乘积。特例如下：

Remainder(±Inf, y) = NaN
Remainder(NaN, y) = NaN
Remainder(x, 0) = NaN
Remainder(x, ±Inf) = x
Remainder(x, NaN) = NaN

func Sqrt

func Sqrt(x float64) float64

返回x的二次方根，特例如下：

Sqrt(+Inf) = +Inf
Sqrt(±0) = ±0
Sqrt(x < 0) = NaN
Sqrt(NaN) = NaN

func Cbrt

func Cbrt(x float64) float64

返回x的三次方根，特例如下：

Cbrt(±0) = ±0
Cbrt(±Inf) = ±Inf
Cbrt(NaN) = NaN

func Hypot

func Hypot(p, q float64) float64

返回Sqrt(pp + qq)，注意要避免不必要的溢出或下溢。特例如下：

Hypot(±Inf, q) = +Inf
Hypot(p, ±Inf) = +Inf
Hypot(NaN, q) = NaN
Hypot(p, NaN) = NaN

func Sin

func Sin(x float64) float64

求正弦。特例如下：

Sin(±0) = ±0
Sin(±Inf) = NaN
Sin(NaN) = NaN

func Cos

func Cos(x float64) float64

求余弦。特例如下：

Cos(±Inf) = NaN
Cos(NaN) = NaN

func Tan

func Tan(x float64) float64

求正切。特例如下：

Tan(±0) = ±0
Tan(±Inf) = NaN
Tan(NaN) = NaN

func Sincos

func Sincos(x float64) (sin, cos float64)

函数返回Sin(x), Cos(x)。特例如下：

Sincos(±0) = ±0, 1
Sincos(±Inf) = NaN, NaN
Sincos(NaN) = NaN, NaN

func Asin

func Asin(x float64) float64

求反正弦（x是弧度）。特例如下：

Asin(±0) = ±0
Asin(x) = NaN if x < -1 or x > 1

func Acos

func Acos(x float64) float64

求反余弦（x是弧度）。特例如下：

Acos(x) = NaN if x < -1 or x > 1

func Atan

func Atan(x float64) float64

求反正切（x是弧度）。特例如下：

Atan(±0) = ±0
Atan(±Inf) = ±Pi/2

func Atan2

func Atan2(y, x float64) float64

类似Atan(y/x)，但会根据x，y的正负号确定象限。特例如下（前面的优先）：

Atan2(y, NaN) = NaN
Atan2(NaN, x) = NaN
Atan2(+0, x>=0) = +0
Atan2(-0, x>=0) = -0
Atan2(+0, x<=-0) = +Pi
Atan2(-0, x<=-0) = -Pi
Atan2(y>0, 0) = +Pi/2
Atan2(y<0, 0) = -Pi/2
Atan2(+Inf, +Inf) = +Pi/4
Atan2(-Inf, +Inf) = -Pi/4
Atan2(+Inf, -Inf) = 3Pi/4
Atan2(-Inf, -Inf) = -3Pi/4
Atan2(y, +Inf) = 0
Atan2(y>0, -Inf) = +Pi
Atan2(y<0, -Inf) = -Pi
Atan2(+Inf, x) = +Pi/2
Atan2(-Inf, x) = -Pi/2

func Sinh

func Sinh(x float64) float64

求双曲正弦，特例如下：

Sinh(±0) = ±0
Sinh(±Inf) = ±Inf
Sinh(NaN) = NaN

func Cosh

func Cosh(x float64) float64

求双曲余弦，特例如下：

Cosh(±0) = 1
Cosh(±Inf) = +Inf
Cosh(NaN) = NaN

func Tanh

func Tanh(x float64) float64

求双曲正切，特例如下：

Tanh(±0) = ±0
Tanh(±Inf) = ±1
Tanh(NaN) = NaN

func Asinh

func Asinh(x float64) float64

求反双曲正弦，特例如下：

Asinh(±0) = ±0
Asinh(±Inf) = ±Inf
Asinh(NaN) = NaN

func Acosh

func Acosh(x float64) float64

求反双曲余弦，特例如下：

Acosh(+Inf) = +Inf
Acosh(x) = NaN if x < 1
Acosh(NaN) = NaN

func Atanh

func Atanh(x float64) float64

求反双曲正切，特例如下：

Atanh(1) = +Inf
Atanh(±0) = ±0
Atanh(-1) = -Inf
Atanh(x) = NaN if x < -1 or x > 1
Atanh(NaN) = NaN

func Log

func Log(x float64) float64

求自然对数，特例如下：

Log(+Inf) = +Inf
Log(0) = -Inf
Log(x < 0) = NaN
Log(NaN) = NaN

func Log1p

func Log1p(x float64) float64

等价于Log(1+x)。但是在x接近0时，本函数更加精确；特例如下：

Log1p(+Inf) = +Inf
Log1p(±0) = ±0
Log1p(-1) = -Inf
Log1p(x < -1) = NaN
Log1p(NaN) = NaN

func Log2

func Log2(x float64) float64

求2为底的对数；特例和Log相同。

func Log10

func Log10(x float64) float64

求10为底的对数；特例和Log相同。

func Logb

func Logb(x float64) float64

返回x的二进制指数值，可以理解为Trunc(Log2(x))；特例如下：

Logb(±Inf) = +Inf
Logb(0) = -Inf
Logb(NaN) = NaN

func Ilogb

func Ilogb(x float64) int

类似Logb，但返回值是整型；特例如下：

Ilogb(±Inf) = MaxInt32
Ilogb(0) = MinInt32
Ilogb(NaN) = MaxInt32

func Frexp

func Frexp(f float64) (frac float64, exp int)

返回一个标准化小数frac和2的整型指数exp，满足f == frac * 2**exp，且0.5 <= Abs(frac) < 1；特例如下：

Frexp(±0) = ±0, 0
Frexp(±Inf) = ±Inf, 0
Frexp(NaN) = NaN, 0

func Ldexp

func Ldexp(frac float64, exp int) float64

Frexp的反函数，返回 frac * 2**exp。特例如下：

Ldexp(±0, exp) = ±0
Ldexp(±Inf, exp) = ±Inf
Ldexp(NaN, exp) = NaN

func Exp

func Exp(x float64) float64

返回E**x；x绝对值很大时可能会溢出为0或者+Inf，x绝对值很小时可能会下溢为1。特例如下：

Exp(+Inf) = +Inf
Exp(NaN) = NaN

func Expm1

func Expm1(x float64) float64

等价于Exp(x)-1，但是在x接近零时更精确；x绝对值很大时可能会溢出为-1或+Inf。特例如下：

Expm1(+Inf) = +Inf
Expm1(-Inf) = -1
Expm1(NaN) = NaN

func Exp2

func Exp2(x float64) float64

返回2**x；特例和Exp相同。

func Pow

func Pow(x, y float64) float64

返回x**y；特例如下（前面的优先）：

Pow(x, ±0) = 1 for any x
Pow(1, y) = 1 for any y
Pow(x, 1) = x for any x
Pow(NaN, y) = NaN
Pow(x, NaN) = NaN
Pow(±0, y) = ±Inf for y an odd integer < 0
Pow(±0, -Inf) = +Inf
Pow(±0, +Inf) = +0
Pow(±0, y) = +Inf for finite y < 0 and not an odd integer
Pow(±0, y) = ±0 for y an odd integer > 0
Pow(±0, y) = +0 for finite y > 0 and not an odd integer
Pow(-1, ±Inf) = 1
Pow(x, +Inf) = +Inf for |x| > 1
Pow(x, -Inf) = +0 for |x| > 1
Pow(x, +Inf) = +0 for |x| < 1
Pow(x, -Inf) = +Inf for |x| < 1
Pow(+Inf, y) = +Inf for y > 0
Pow(+Inf, y) = +0 for y < 0
Pow(-Inf, y) = Pow(-0, -y)
Pow(x, y) = NaN for finite x < 0 and finite non-integer y

func Pow10

func Pow10(e int) float64

返回10**e；特例如下：

Pow10(e) = +Inf for e > 309
Pow10(e) = 0 for e < -324

func Gamma

func Gamma(x float64) float64

伽玛函数（当x为正整数时，值为(x-1)!）。特例如下：

Gamma(+Inf) = +Inf
Gamma(+0) = +Inf
Gamma(-0) = -Inf
Gamma(x) = NaN for integer x < 0
Gamma(-Inf) = NaN
Gamma(NaN) = NaN

func Lgamma

func Lgamma(x float64) (lgamma float64, sign int)

返回Gamma(x)的自然对数和正负号。特例如下：

Lgamma(+Inf) = +Inf
Lgamma(0) = +Inf
Lgamma(-integer) = +Inf
Lgamma(-Inf) = -Inf
Lgamma(NaN) = NaN

func Erf

func Erf(x float64) float64

误差函数，特例如下：

Erf(+Inf) = 1
Erf(-Inf) = -1
Erf(NaN) = NaN

func Erfc

func Erfc(x float64) float64

余补误差函数，特例如下：

Erfc(+Inf) = 0
Erfc(-Inf) = 2
Erfc(NaN) = NaN

func J0

func J0(x float64) float64

第一类贝塞尔函数，0阶。特例如下：

J0(±Inf) = 0
J0(0) = 1
J0(NaN) = NaN

func J1

func J1(x float64) float64

第一类贝塞尔函数，1阶。特例如下：

J1(±Inf) = 0
J1(NaN) = NaN

func Jn

func Jn(n int, x float64) float64

第一类贝塞尔函数，n阶。特例如下：

Jn(n, ±Inf) = 0
Jn(n, NaN) = NaN

func Y0

func Y0(x float64) float64

第二类贝塞尔函数，0阶。特例如下：

Y0(+Inf) = 0
Y0(0) = -Inf
Y0(x < 0) = NaN
Y0(NaN) = NaN

func Y1

func Y1(x float64) float64

第二类贝塞尔函数，1阶。特例如下：

Y1(+Inf) = 0
Y1(0) = -Inf
Y1(x < 0) = NaN
Y1(NaN) = NaN

func Yn

func Yn(n int, x float64) float64

第二类贝塞尔函数，n阶。特例如下：

Yn(n, +Inf) = 0
Yn(n > 0, 0) = -Inf
Yn(n < 0, 0) = +Inf if n is odd, -Inf if n is even
Y1(n, x < 0) = NaN
Y1(n, NaN) = NaN

• big
• cmplx
• rand

big

big包实现了大数字的多精度计算。 支持如下数字类型：

- Int   有符号整数
- Rat   有理数

方法一般为如下格式：

func (z *Int) Op(x, y *Int) *Int    (similar for *Rat)

该方法实现了操作z = x Op y：计算并将结果写入z。如果结果是操作数之一，可能会重写该参数（重用其内存）；为了实现链式的计算，计算结果同时会作为返回值。方法返回一个结果而不是让Int/Rat调用方法获取另一个操作数。

Constants

const MaxBase = 'z' - 'a' + 10 + 1 // = hexValue('z') + 1

MaxBase是字符串转换函数接受的最大进制。

type Word

type Word uintptr

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

type Int

type Int struct {
    neg bool // sign
    abs nat  // absolute value of the integer
}

Int类型代表多精度的整数，零值代表数字0。

func NewInt

func NewInt(x int64) *Int

创建一个值为x的*Int。

func (*Int) Int64

func (x *Int) Int64() int64

返回x的int64表示，如果不能用int64表示，结果是未定义的。

func (*Int) Uint64

func (x *Int) Uint64() uint64

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

func (*Int) Bytes

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

返回x的绝对值的大端在前的字节切片表示。

func (*Int) String

func (x *Int) String() string

func (*Int) BitLen

func (x *Int) BitLen() int

返回x的绝对值的字位数，0的字位数为0。

func (*Int) Bits

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

提供了对x的数据不检查而快速的访问，返回构成x的绝对值的小端在前的word切片。该切片与x的底层是同一个数组，本函数用于支持在包外实现缺少的低水平功能，否则不应被使用。

func (*Int) Bit

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

返回第i个字位的值，即返回(x>>i)&1。i必须不小于0。

func (*Int) SetInt64

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

将z设为x并返回z。

func (*Int) SetUint64

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

将z设为x并返回z。

func (*Int) SetBytes

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

将buf视为一个大端在前的无符号整数，将z设为该值，并返回z。

func (*Int) SetString

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

将z设为s代表的值（base为基数）。返回z并用一个bool来表明成功与否。如果失败，z的值是不确定的，但返回值为nil。基数必须是0或者2到MaxBase之间的整数。如果基数为0，字符串的前缀决定实际的转换基数："0x"、"0X"表示十六进制；"0b"、"0B"表示二进制；"0"表示八进制；否则为十进制。

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

func (*Int) SetBits

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

提供了对z的数据不检查而快速的操作，将abs视为小端在前的word切片并直接赋给z，返回z。会将z的底层设置为abs的同一底层数组，本函数用于支持在包外实现缺少的低水平功能，否则不应被使用。

func (*Int) SetBit

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

将z设为x并设置z的第i位为b，返回z。如b为1，z = x | (1 << i)；如b为0，z = x & ^(1 << i)；否则会panic。

func (*Int) MulRange

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

将z设置为区间[a, b]内所有整数的乘积A(a, b)，并返回z。如果a>b会将z设为1并返回。

func (*Int) Binomial

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

将z设为k次二项式展开第n项的系数C(n, k)，并返回z。

func (*Int) Rand

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

将z设为一个范围在[0, n)的伪随机值，并返回z。

func (*Int) ProbablyPrime

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

对x进行n次Miller-Rabin质数检测。如果方法返回真则x是质数的几率为1-(1/4)**n；否则x不是质数。

func (*Int) Sign

func (x *Int) Sign() int

返回x的正负号。x<0时返回-1；x>0时返回+1；否则返回0。

func (*Int) Cmp

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

比较x和y的大小。x<y时返回-1；x>y时返回+1；否则返回0。

func (*Int) Not

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

将z设为^x并返回z（按位取反）。

func (*Int) And

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

将z设为x & y并返回z（按位且）。

func (*Int) Or

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

将z设为x | y并返回z（按位或）。

func (*Int) Xor

func (z *Int) Xor(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) Lsh

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

将z设为x << n并返回z（左位移运算）。

func (*Int) Rsh

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

将z设为x >> n并返回z（右位移运算）。

func (*Int) Abs

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

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

func (*Int) Neg

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

将z设为-x并返回z。

func (*Int) Set

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

将z设为x（生成一个拷贝）并返回z

func (*Int) Add

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

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

func (*Int) Sub

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

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

func (*Int) Mul

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

将z设为x * y并返回z。

func (*Int) Div

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

如果y != 0会将z设为x/y并返回z；如果y==0会panic。函数采用欧几里德除法（和Go不同），参见DivMod。

func (*Int) Mod

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

如果y != 0会将z设为x%y并返回z；如果y==0会panic。函数采用欧几里德除法（和Go不同），参见DivMod。

func (*Int) DivMod

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

如果y != 0将z设为x/y，将m设为x%y并返回(z, m)；如果y == 0会panic。采用欧几里德除法（和Go不同）

DivMod方法实现了欧几里德带余除法：

q = x div y  满足
m = x - y*q  且 0 <= m < |q|

func (*Int) Quo

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

如果y != 0会将z设为x/y并返回z；如果y==0会panic。函数采用截断除法（和Go相同），参见QuoRem。

func (*Int) Rem

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

如果y != 0会将z设为x%y并返回z；如果y==0会panic。函数采用截断除法（和Go相同），参见QuoRem。

func (*Int) QuoRem

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

如果y != 0将z设为x/y，将r设为x%y并返回(z, r)；如果y == 0会panic。函数采用截断除法（和Go相同）

QuoRem方法实现了截断带余除法：

q = x/y      返回值向零的方向截断
r = x - y*q

func (*Int) ModInverse

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

将z设为g相对p的模逆（即z、g满足(z * g) % p == 1）。返回值z大于0小于p。

func (*Int) Exp

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

将z设为xy mod |m|并返回z；如果y <= 0，返回1；如果m == nil 或 m == 0，z设为xy。

func (*Int) GCD

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

将z设为a和b的最大公约数并返回z。a或b为nil时会panic；a和b都>0时设置z为最大公约数；如果任一个<=0方法就会设置z = x = y = 0。如果x和y都不是nil，会将x和y设置为满足ax + by==z。

func (*Int) Format

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

Format方法实现了fmt.Formatter接口。本方法接受格式'b'（二进制）、'o'（八进制）、'd'（十进制）、'x'（小写十六进制）、'X'（大写十六进制）。

方法支持全套fmt包对整数类型的动作：包括用于符号控制的'+'、'-'、' '；用于十六进制和八进制前导0的'#'；"%#x"和"%#X"会设置前导的"0x"或"0X"；指定最小数字精度；输出字段宽度；空格或'0'的补位；左右对齐。

func (*Int) Scan

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

Scan实现了fmt.Scanner接口，将z设为读取的数字。方法可以接受接受格式'b'（二进制）、'o'（八进制）、'd'（十进制）、'x'（小写十六进制）、'X'（大写十六进制）。

func main() {
    i := new(big.Int)
    _, err := fmt.Sscan("18446744073709551617", i)
    if err != nil {
        log.Println("error scanning value:", err)
    } else {
        fmt.Println(i)
    }
}

func (*Int) GobEncode

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

本方法实现了gob.GobEncoder接口。

func (*Int) GobDecode

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

本方法实现了gob.GobDecoder接口。

func (*Int) MarshalJSON

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

本方法实现了json.Marshaler接口。

func (*Int) UnmarshalJSON

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

本方法实现了json.Unmarshaler接口。

func (*Int) MarshalText

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

本方法实现了encoding.TextMarshaler接口。

func (*Int) UnmarshalText

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

本方法实现了encoding.TextUnmarshaler接口。

type Rat

type Rat struct {
    // To make zero values for Rat work w/o initialization,
    // a zero value of b (len(b) == 0) acts like b == 1. At
    // the earliest opportunity (when an assignment to the Rat
    // is made), such uninitialized denominators are set to 1.
    // a.neg determines the sign of the Rat, b.neg is ignored.
    a, b Int
}

Rat类型代表一个任意精度的有理数（底层采用分数表示），Rat的零值代表数字0。

func NewRat

func NewRat(a, b int64) *Rat

NewRat函数使用分子a和分母b创建一个Rat。

func (*Rat) Num

func (x *Rat) Num() *Int

返回x的分子，分子可能<=0。返回的是x分子的指针，因此对返回值的操作可能改变x，反之亦然。x的符号与分子的符号是绑定的。

func (*Rat) Denom

func (x *Rat) Denom() *Int

返回x的分母，分母总是>0。返回的是x分母的指针，因此对返回值的操作可能改变x，反之亦然。

func (*Rat) Float64

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

返回最接近x的值的float64值，exact用于说明f是否精确的表示了x。 如果x的量级太大或太小不能被float64类型表示，返回无穷和false；f的符号始终与x的符号一致，即使f==0。

func (*Rat) RatString

func (x *Rat) RatString() string

返回z的字符串表示，如果分母不等于1，格式为"a/b"；否则格式为"a"。

func (*Rat) FloatString

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

返回z的字符串表示为精度为prec的十进制浮点数，最后一位会进行四舍五入。

func (*Rat) String

func (x *Rat) String() string

返回z的字符串表示，格式为"a/b"（即使分母等于1）。

func (*Rat) IsInt

func (x *Rat) IsInt() bool

返回x的分母是否为1（即x为整数）。

func (*Rat) SetInt64

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

将z设为x，并返回z。

func (*Rat) SetFrac64

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

将z设为a/b，并返回z。

func (*Rat) SetFloat64

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

将z设为f的精确值并返回z。如果f不是有穷数（即f为+Inf、+Inf或NaN）时会返回nil。。

func (*Rat) SetInt

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

将z设为x（生成一个拷贝）并返回z。

func (*Rat) SetFrac

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

将z设为a/b，并返回z。

func (*Rat) SetString

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

将z设为字符串代表的值，返回z并用一个bool表明是否成功。字符串s的格式可以是形如"a/b"的分数格式，也可以是浮点数后跟可选的指数的科学计数法格式。如果操作失败，z的值是不确定的，但返回值为nil。

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

func (*Rat) Sign

func (x *Rat) Sign() int

返回x的正负号。如x < 0返回-1；如x > 0返回+1；否则返回0。

func (*Rat) Cmp

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

比较x和y的大小。如x < y返回-1；如x > y返回+1；否则返回0。

func (*Rat) Abs

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

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

func (*Rat) Neg

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

将z设为-x并返回z。

func (*Rat) Inv

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

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

func (*Rat) Set

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

将z设为x（生成一个拷贝）并返回z。

func (*Rat) Add

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

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

func (*Rat) Sub

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

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

func (*Rat) Mul

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

将z设为x * y并返回z。

func (*Rat) Quo

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

如果y != 0会将z设为x/y并返回z；如果y==0会panic。

func (*Rat) Scan

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

本方法实现了fmt.Scanner接口，将z设为读取到的数字。接受格式'e'、'E'、'f'、'F'、'g'、'G'、'v'；它们都是等价的。

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

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

本方法实现了gob.GobEncoder接口。

func (*Rat) GobDecode

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

本方法实现了gob.GobDecoder接口。

func (*Rat) MarshalText

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

本方法实现了encoding.TextMarshaler接口。

func (*Rat) UnmarshalText

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

本方法实现了encoding.TextUnmarshaler接口。

cmplx

cmplx包提供了复数的常用常数和常用函数。

func NaN

func NaN() complex128

返回一个复数的“Not A Number”值。

func IsNaN

func IsNaN(x complex128) bool

如果x的实部或者虚部是“Not A Number”值，则返回真。

func Inf

func Inf() complex128

返回一个复数的无穷大，complex(+Inf, +Inf)。

func IsInf

func IsInf(x complex128) bool

如果x的实部或者虚部是无穷（不管正负），则返回真。

func Abs

func Abs(x complex128) float64

返回x的绝对值（也被称为模）。

func Phase

func Phase(x complex128) float64

返回x的相位（也被称为幅角），返回值范围[-Pi, Pi]。

func Polar

func Polar(x complex128) (r, θ float64)

将直角坐标的复数表示为极坐标(r, θ)。其中r是x的绝对值，θ是x的相位，范围[-Pi, Pi]。

func Rect

func Rect(r, θ float64) complex128

返回极坐标(r, θ)表示的复数。

func Conj

func Conj(x complex128) complex128

返回x的共轭复数（实部相等，虚部相反）。

func Sqrt

func Sqrt(x complex128) complex128

返回x的平方根。返回值的实部不小于0，而虚部的正负号和x的虚部相同。

func Log

func Log(x complex128) complex128

返回x的自然对数。

func Log10

func Log10(x complex128) complex128

返回x的常用对数。

func Exp

func Exp(x complex128) complex128

返回e**x。

func Pow

func Pow(x, y complex128) complex128

返回x**y；有如下特例：

Pow(0, ±0)  returns 1+0i
Pow(0, c)   如果image(c)==0，则当real(c)<0时返回Inf+0i；否则返回Inf+Inf i

func Sin

func Sin(x complex128) complex128

求正弦。

func Cos

func Cos(x complex128) complex128

求余弦。

func Tan

func Tan(x complex128) complex128

求正切。

func Cot

func Cot(x complex128) complex128

求余切。

func Asin

func Asin(x complex128) complex128

求反正弦。

func Acos

func Acos(x complex128) complex128

求反余弦。

func Atan

func Atan(x complex128) complex128

求反正切。

func Sinh

func Sinh(x complex128) complex128

求双曲正弦。

func Cosh

func Cosh(x complex128) complex128

求双曲余弦。

func Tanh

func Tanh(x complex128) complex128

求双曲正切。

func Asinh

func Asinh(x complex128) complex128

求反双曲正弦。

func Acosh

func Acosh(x complex128) complex128

求反双曲余弦。

func Atanh

func Atanh(x complex128) complex128

求反双曲正切。

rand

随机数从资源生成。包水平的函数都使用的默认的公共资源。该资源会在程序每次运行时都产生确定的序列。如果需要每次运行产生不同的序列，应使用Seed函数进行初始化。默认资源可以安全的用于多go程并发。

type Source

type Source interface {
    Int63() int64
    Seed(seed int64)
}

Source代表一个生成均匀分布在范围[0, 1<<63)的int64值的（伪随机的）资源。

func NewSource

func NewSource(seed int64) Source

使用给定的种子创建一个伪随机资源。

type Rand

type Rand struct {
    src Source
    s64 Source64 // non-nil if src is source64

    // readVal contains remainder of 63-bit integer used for bytes
    // generation during most recent Read call.
    // It is saved so next Read call can start where the previous
    // one finished.
    readVal int64
    // readPos indicates the number of low-order bytes of readVal
    // that are still valid.
    readPos int8
}

Rand生成服从多种分布的随机数。

func New

func New(src Source) *Rand

返回一个使用src生产的随机数来生成其他各种分布的随机数值的*Rand。

func (*Rand) Seed

func (r *Rand) Seed(seed int64)

使用给定的seed来初始化生成器到一个确定的状态。

func main() {
   rand.Seed(42) // Try changing this number!
   answers := []string{
      "It is certain",
      "It is decidedly so",
      "Without a doubt",
      "Yes definitely",
      "You may rely on it",
      "As I see it yes",
      "Most likely",
      "Outlook good",
      "Yes",
      "Signs point to yes",
      "Reply hazy try again",
      "Ask again later",
      "Better not tell you now",
      "Cannot predict now",
      "Concentrate and ask again",
      "Don't count on it",
      "My reply is no",
      "My sources say no",
      "Outlook not so good",
      "Very doubtful",
   }
   fmt.Println("Magic 8-Ball says:", answers[rand.Intn(len(answers))])
}

func (*Rand) Int

func (r *Rand) Int() int

返回一个非负的伪随机int值。

func (*Rand) Int31

func (r *Rand) Int31() int32

返回一个int32类型的非负的31位伪随机数。

func (*Rand) Int63

func (r *Rand) Int63() int64

返回一个int64类型的非负的63位伪随机数。

func (*Rand) Uint32

func (r *Rand) Uint32() uint32

返回一个uint32类型的非负的32位伪随机数。

func (*Rand) Intn

func (r *Rand) Intn(n int) int

返回一个取值范围在[0,n)的伪随机int值，如果n<=0会panic。

func (*Rand) Int31n

func (r *Rand) Int31n(n int32) int32

返回一个取值范围在[0,n)的伪随机int32值，如果n<=0会panic

func (*Rand) Int63n

func (r *Rand) Int63n(n int64) int64

返回一个取值范围在[0,n)的伪随机int64值，如果n<=0会panic。

func (*Rand) Float32

func (r *Rand) Float32() float32

返回一个取值范围在[0.0, 1.0)的伪随机float32值。

func (*Rand) Float64

func (r *Rand) Float64() float64

返回一个取值范围在[0.0, 1.0)的伪随机float64值。

func (*Rand) NormFloat64

func (r *Rand) NormFloat64() float64

返回一个服从标准正态分布（标准差=1，期望=0）、取值范围在[-math.MaxFloat64, +math.MaxFloat64]的float64值

如果要生成不同的正态分布值，调用者可用如下代码调整输出：

sample = NormFloat64() * 标准差 + 期望

func (*Rand) ExpFloat64

func (r *Rand) ExpFloat64() float64

返回一个服从标准指数分布（率参数=1，率参数是期望的倒数）、取值范围在(0, +math.MaxFloat64]的float64值

如要生成不同的指数分布值，调用者可用如下代码调整输出：

sample = ExpFloat64() / 率参数

func (*Rand) Perm

func (r *Rand) Perm(n int) []int

返回一个有n个元素的，[0,n)范围内整数的伪随机排列的切片。

type Zipf

type Zipf struct {
    r            *Rand
    imax         float64
    v            float64
    q            float64
    s            float64
    oneminusQ    float64
    oneminusQinv float64
    hxm          float64
    hx0minusHxm  float64
}

Zipf生成服从齐普夫分布的随机数。

func NewZipf

func NewZipf(r *Rand, s float64, v float64, imax uint64) *Zipf

NewZipf返回一个[0, imax]范围内的齐普夫随机数生成器。

齐普夫分布：值k出现的几率p(k)正比于(v+k)**(-s)，其中s>1且k>=0且v>=1。

func (*Zipf) Uint64

func (z *Zipf) Uint64() uint64

Uint64返回一个服从Zipf对象描述的齐普夫分布的随机数。

func Seed

func Seed(seed int64)

使用给定的seed将默认资源初始化到一个确定的状态；如未调用Seed，默认资源的行为就好像调用了Seed(1)。

func Int

func Int() int

返回一个非负的伪随机int值。

func Int31

func Int31() int32

返回一个int32类型的非负的31位伪随机数。

func Int63

func Int63() int64

返回一个int64类型的非负的63位伪随机数。

func Uint32

func Uint32() uint32

返回一个uint32类型的非负的32位伪随机数。

func Intn

func Intn(n int) int

返回一个取值范围在[0,n)的伪随机int值，如果n<=0会panic。

func Int31n

func Int31n(n int32) int32

返回一个取值范围在[0,n)的伪随机int32值，如果n<=0会panic。

func Int63n

func Int63n(n int64) int64

返回一个取值范围在[0, n)的伪随机int64值，如果n<=0会panic。

func Float32

func Float32() float32

返回一个取值范围在[0.0, 1.0)的伪随机float32值。

func Float64

func Float64() float64

返回一个取值范围在[0.0, 1.0)的伪随机float64值。

func NormFloat64

func NormFloat64() float64

返回一个服从标准正态分布（标准差=1，期望=0）、取值范围在[-math.MaxFloat64, +math.MaxFloat64]的float64值

如果要生成不同的正态分布值，调用者可用如下代码调整输出：

sample = NormFloat64() * 标准差 + 期望

func ExpFloat64

func ExpFloat64() float64

返回一个服从标准指数分布（率参数=1，率参数是期望的倒数）、取值范围在(0, +math.MaxFloat64]的float64值

如要生成不同的指数分布值，调用者可用如下代码调整输出：

sample = ExpFloat64() / 率参数

func Perm

func Perm(n int) []int

返回一个有n个元素的，[0,n)范围内整数的伪随机排列的切片。

func main() {
   r := rand.New(rand.NewSource(99))
   w := tabwriter.NewWriter(os.Stdout, 1, 1, 1, ' ', 0)
   defer w.Flush()
   show := func(name string, v1, v2, v3 interface{}) {
      fmt.Fprintf(w, "%s\t%v\t%v\t%v\n", name, v1, v2, v3)
   }
   show("Float32", r.Float32(), r.Float32(), r.Float32())
   show("Float64", r.Float64(), r.Float64(), r.Float64())
   show("ExpFloat64", r.ExpFloat64(), r.ExpFloat64(), r.ExpFloat64())
   show("NormFloat64", r.NormFloat64(), r.NormFloat64(), r.NormFloat64())
   show("Int31", r.Int31(), r.Int31(), r.Int31())
   show("Int63", r.Int63(), r.Int63(), r.Int63())
   show("Uint32", r.Int63(), r.Int63(), r.Int63())
   show("Intn(10)", r.Intn(10), r.Intn(10), r.Intn(10))
   show("Int31n(10)", r.Int31n(10), r.Int31n(10), r.Int31n(10))
   show("Int63n(10)", r.Int63n(10), r.Int63n(10), r.Int63n(10))
   show("Perm", r.Perm(5), r.Perm(5), r.Perm(5))
}

---