Documentation ¶
Index ¶
- Constants
- func Jacobi(x, y *Int) int
- type Accuracy
- type ErrNaN
- type Float
- 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 (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) 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)
- type 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 (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) FillBytes(buf []byte) []byte
- func (z *Int) GCD(x, y, a, b *Int) *Int
- 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 (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 (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) 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 (z *Int) Sub(x, y *Int) *Int
- func (x *Int) TrailingZeroBits() uint
- func (x *Int) Uint64() uint64
- func (z *Int) Xor(x, y *Int) *Int
- type RoundingMode
- type Word
Constants ¶
const ( MaxExp = math.MaxInt32 // largest supported exponent MinExp = math.MinInt32 // smallest supported exponent MaxPrec = math.MaxUint32 // largest (theoretically) supported precision; likely memory-limited )
Exponent and precision limits.
Variables ¶
This section is empty.
Functions ¶
Types ¶
type Accuracy ¶
type Accuracy int8
Accuracy describes the rounding error produced by the most recent operation that generated a Float value, relative to the exact value.
type ErrNaN ¶
type ErrNaN struct {
// contains filtered or unexported fields
}
An ErrNaN panic is raised by a Float operation that would lead to a NaN under IEEE-754 rules. An ErrNaN implements the error interface.
type Float ¶
type Float struct {
// contains filtered or unexported fields
}
A nonzero finite Float represents a multi-precision floating point number
sign × mantissa × 2**exponent
with 0.5 <= mantissa < 1.0, and MinExp <= exponent <= MaxExp. A Float may also be zero (+0, -0) or infinite (+Inf, -Inf). All Floats are ordered, and the ordering of two Floats x and y is defined by x.Cmp(y).
Each Float value also has a precision, rounding mode, and accuracy. The precision is the maximum number of mantissa bits available to represent the value. The rounding mode specifies how a result should be rounded to fit into the mantissa bits, and accuracy describes the rounding error with respect to the exact result.
Unless specified otherwise, all operations (including setters) that specify a *Float variable for the result (usually via the receiver with the exception of MantExp), round the numeric result according to the precision and rounding mode of the result variable.
If the provided result precision is 0 (see below), it is set to the precision of the argument with the largest precision value before any rounding takes place, and the rounding mode remains unchanged. Thus, uninitialized Floats provided as result arguments will have their precision set to a reasonable value determined by the operands, and their mode is the zero value for RoundingMode (ToNearestEven).
By setting the desired precision to 24 or 53 and using matching rounding mode (typically ToNearestEven), Float operations produce the same results as the corresponding float32 or float64 IEEE-754 arithmetic for operands that correspond to normal (i.e., not denormal) float32 or float64 numbers. Exponent underflow and overflow lead to a 0 or an Infinity for different values than IEEE-754 because Float exponents have a much larger range.
The zero (uninitialized) value for a Float is ready to use and represents the number +0.0 exactly, with precision 0 and rounding mode 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.
func NewFloat ¶
NewFloat allocates and returns a new Float set to x, with precision 53 and rounding mode ToNearestEven. NewFloat panics with ErrNaN if x is a NaN.
func ParseFloat ¶
ParseFloat is like f.Parse(s, base) with f set to the given precision and rounding mode.
func (*Float) Abs ¶
Abs sets z to the (possibly rounded) value |x| (the absolute value of x) and returns z.
func (*Float) Acc ¶
Acc returns the accuracy of x produced by the most recent operation, unless explicitly documented otherwise by that operation.
func (*Float) Add ¶
Add sets z to the rounded sum x+y and returns z. If z's precision is 0, it is changed to the larger of x's or y's precision before the operation. Rounding is performed according to z's precision and rounding mode; and z's accuracy reports the result error relative to the exact (not rounded) result. Add panics with ErrNaN if x and y are infinities with opposite signs. The value of z is undefined in that case.
func (*Float) Append ¶
Append appends to buf the string form of the floating-point number x, as generated by x.Text, and returns the extended buffer.
func (*Float) Cmp ¶
Cmp compares x and y and returns:
-1 if x < y 0 if x == y (incl. -0 == 0, -Inf == -Inf, and +Inf == +Inf) +1 if x > y
func (*Float) Copy ¶
Copy sets z to x, with the same precision, rounding mode, and accuracy as x, and returns z. x is not changed even if z and x are the same.
func (*Float) Float32 ¶
Float32 returns the float32 value nearest to x. If x is too small to be represented by a float32 (|x| < math.SmallestNonzeroFloat32), the result is (0, Below) or (-0, Above), respectively, depending on the sign of x. If x is too large to be represented by a float32 (|x| > math.MaxFloat32), the result is (+Inf, Above) or (-Inf, Below), depending on the sign of x.
func (*Float) Float64 ¶
Float64 returns the float64 value nearest to x. If x is too small to be represented by a float64 (|x| < math.SmallestNonzeroFloat64), the result is (0, Below) or (-0, Above), respectively, depending on the sign of x. If x is too large to be represented by a float64 (|x| > math.MaxFloat64), the result is (+Inf, Above) or (-Inf, Below), depending on the sign of x.
func (*Float) Format ¶
Format implements fmt.Formatter. It accepts all the regular formats for floating-point numbers ('b', 'e', 'E', 'f', 'F', 'g', 'G', 'x') as well as 'p' and 'v'. See (*Float).Text for the interpretation of 'p'. The 'v' format is handled like 'g'. Format also supports specification of the minimum precision in digits, the output field width, as well as the format flags '+' and ' ' for sign control, '0' for space or zero padding, and '-' for left or right justification. See the fmt package for details.
func (*Float) Int ¶
Int returns the result of truncating x towards zero; or nil if x is an infinity. The result is Exact if x.IsInt(); otherwise it is Below for x > 0, and Above for x < 0. If a non-nil *Int argument z is provided, Int stores the result in z instead of allocating a new Int.
func (*Float) Int64 ¶
Int64 returns the integer resulting from truncating x towards zero. If math.MinInt64 <= x <= math.MaxInt64, the result is Exact if x is an integer, and Above (x < 0) or Below (x > 0) otherwise. The result is (math.MinInt64, Above) for x < math.MinInt64, and (math.MaxInt64, Below) for x > math.MaxInt64.
func (*Float) MantExp ¶
MantExp breaks x into its mantissa and exponent components and returns the exponent. If a non-nil mant argument is provided its value is set to the mantissa of x, with the same precision and rounding mode as x. The components satisfy x == mant × 2**exp, with 0.5 <= |mant| < 1.0. Calling MantExp with a nil argument is an efficient way to get the exponent of the receiver.
Special cases are:
( ±0).MantExp(mant) = 0, with mant set to ±0 (±Inf).MantExp(mant) = 0, with mant set to ±Inf
x and mant may be the same in which case x is set to its mantissa value.
func (*Float) MinPrec ¶
MinPrec returns the minimum precision required to represent x exactly (i.e., the smallest prec before x.SetPrec(prec) would start rounding x). The result is 0 for |x| == 0 and |x| == Inf.
func (*Float) Mul ¶
Mul sets z to the rounded product x*y and returns z. Precision, rounding, and accuracy reporting are as for Add. Mul panics with ErrNaN if one operand is zero and the other operand an infinity. The value of z is undefined in that case.
func (*Float) Neg ¶
Neg sets z to the (possibly rounded) value of x with its sign negated, and returns z.
func (*Float) Parse ¶
Parse parses s which must contain a text representation of a floating- point number with a mantissa in the given conversion base (the exponent is always a decimal number), or a string representing an infinite value.
For base 0, an underscore character “_” may appear between a base prefix and an adjacent digit, and between successive digits; such underscores do not change the value of the number, or the returned digit count. Incorrect placement of underscores is reported as an error if there are no other errors. If base != 0, underscores are not recognized and thus terminate scanning like any other character that is not a valid radix point or digit.
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" .
The base argument must be 0, 2, 8, 10, or 16. Providing an invalid base argument will lead to a run-time panic.
For base 0, the number prefix determines the actual base: A prefix of “0b” or “0B” selects base 2, “0o” or “0O” selects base 8, and “0x” or “0X” selects base 16. Otherwise, the actual base is 10 and no prefix is accepted. The octal prefix "0" is not supported (a leading "0" is simply considered a "0").
A "p" or "P" exponent indicates a base 2 (rather then base 10) exponent; for instance, "0x1.fffffffffffffp1023" (using base 0) represents the maximum float64 value. For hexadecimal mantissae, the exponent character must be one of 'p' or 'P', if present (an "e" or "E" exponent indicator cannot be distinguished from a mantissa digit).
The returned *Float f is nil and the value of z is valid but not defined if an error is reported.
func (*Float) Prec ¶
Prec returns the mantissa precision of x in bits. The result may be 0 for |x| == 0 and |x| == Inf.
func (*Float) Quo ¶
Quo sets z to the rounded quotient x/y and returns z. Precision, rounding, and accuracy reporting are as for Add. Quo panics with ErrNaN if both operands are zero or infinities. The value of z is undefined in that case.
func (*Float) Rat ¶
Rat returns the rational number corresponding to x; or nil if x is an infinity. The result is Exact if x is not an Inf. If a non-nil *Rat argument z is provided, Rat stores the result in z instead of allocating a new Rat.
func (*Float) Scan ¶
Scan is a support routine for fmt.Scanner; it sets z to the value of the scanned number. It accepts formats whose verbs are supported by fmt.Scan for floating point values, which are: 'b' (binary), 'e', 'E', 'f', 'F', 'g' and 'G'. Scan doesn't handle ±Inf.
func (*Float) Set ¶
Set sets z to the (possibly rounded) value of x and returns z. If z's precision is 0, it is changed to the precision of x before setting z (and rounding will have no effect). Rounding is performed according to z's precision and rounding mode; and z's accuracy reports the result error relative to the exact (not rounded) result.
func (*Float) SetFloat64 ¶
SetFloat64 sets z to the (possibly rounded) value of x and returns z. If z's precision is 0, it is changed to 53 (and rounding will have no effect). SetFloat64 panics with ErrNaN if x is a NaN.
func (*Float) SetInf ¶
SetInf sets z to the infinite Float -Inf if signbit is set, or +Inf if signbit is not set, and returns z. The precision of z is unchanged and the result is always Exact.
func (*Float) SetInt ¶
SetInt sets z to the (possibly rounded) value of x and returns z. If z's precision is 0, it is changed to the larger of x.BitLen() or 64 (and rounding will have no effect).
func (*Float) SetInt64 ¶
SetInt64 sets z to the (possibly rounded) value of x and returns z. If z's precision is 0, it is changed to 64 (and rounding will have no effect).
func (*Float) SetMantExp ¶
SetMantExp sets z to mant × 2**exp and returns z. The result z has the same precision and rounding mode as mant. SetMantExp is an inverse of MantExp but does not require 0.5 <= |mant| < 1.0. Specifically:
mant := new(Float) new(Float).SetMantExp(mant, x.MantExp(mant)).Cmp(x) == 0
Special cases are:
z.SetMantExp( ±0, exp) = ±0 z.SetMantExp(±Inf, exp) = ±Inf
z and mant may be the same in which case z's exponent is set to exp.
func (*Float) SetMode ¶
func (z *Float) SetMode(mode RoundingMode) *Float
SetMode sets z's rounding mode to mode and returns an exact z. z remains unchanged otherwise. z.SetMode(z.Mode()) is a cheap way to set z's accuracy to Exact.
func (*Float) SetPrec ¶
SetPrec sets z's precision to prec and returns the (possibly) rounded value of z. Rounding occurs according to z's rounding mode if the mantissa cannot be represented in prec bits without loss of precision. SetPrec(0) maps all finite values to ±0; infinite values remain unchanged. If prec > MaxPrec, it is set to MaxPrec.
func (*Float) SetRat ¶
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 ¶
SetString sets z to the value of s and returns z and a boolean indicating success. s must be a floating-point number of the same format as accepted by Parse, with base argument 0. The entire string (not just a prefix) must be valid for success. If the operation failed, the value of z is undefined but the returned value is nil.
func (*Float) SetUint64 ¶
SetUint64 sets z to the (possibly rounded) value of x and returns z. If z's precision is 0, it is changed to 64 (and rounding will have no effect).
func (*Float) String ¶
String formats x like x.Text('g', 10). (String must be called explicitly, Float.Format does not support %s verb.)
func (*Float) Sub ¶
Sub sets z to the rounded difference x-y and returns z. Precision, rounding, and accuracy reporting are as for Add. Sub panics with ErrNaN if x and y are infinities with equal signs. The value of z is undefined in that case.
func (*Float) Text ¶
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! math/big/ftoa.go Text converts the floating-point number x to a string according to the given format and precision prec. The format is one of:
'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)
For the power-of-two exponent formats, the mantissa is printed in normalized form:
'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.
If format is a different character, Text returns a "%" followed by the unrecognized format character.
The precision prec controls the number of digits (excluding the exponent) printed by the 'e', 'E', 'f', 'g', 'G', and 'x' formats. For 'e', 'E', 'f', and 'x', it is the number of digits after the decimal point. For 'g' and 'G' it is the total number of digits. A negative precision selects the smallest number of decimal digits necessary to identify the value x uniquely using x.Prec() mantissa bits. The prec value is ignored for the 'b' and 'p' formats.
type Int ¶
type Int struct {
// contains filtered or unexported fields
}
An Int represents a signed multi-precision integer. The zero value for an Int represents the value 0.
Operations always take pointer arguments (*Int) rather than Int values, and each unique Int value requires its own unique *Int pointer. To "copy" an Int value, an existing (or newly allocated) Int must be set to a new value using the Int.Set method; shallow copies of Ints are not supported and may lead to errors.
func (*Int) Bit ¶
Bit returns the value of the i'th bit of x. That is, it returns (x>>i)&1. The bit index i must be >= 0.
func (*Int) BitLen ¶
BitLen returns the length of the absolute value of x in bits. The bit length of 0 is 0.
func (*Int) Bits ¶
Bits provides raw (unchecked but fast) access to x by returning its absolute value as a little-endian Word slice. The result and x share the same underlying array. Bits is intended to support implementation of missing low-level Int functionality outside this package; it should be avoided otherwise.
func (*Int) Bytes ¶
Bytes returns the absolute value of x as a big-endian byte slice.
To use a fixed length slice, or a preallocated one, use FillBytes.
func (*Int) CmpAbs ¶
CmpAbs compares the absolute values of x and y and returns:
-1 if |x| < |y| 0 if |x| == |y| +1 if |x| > |y|
func (*Int) Div ¶
Div sets z to the quotient x/y for y != 0 and returns z. If y == 0, a division-by-zero run-time panic occurs. Div implements Euclidean division (unlike Go); see DivMod for more details.
func (*Int) DivMod ¶
DivMod sets z to the quotient x div y and m to the modulus x mod y and returns the pair (z, m) for y != 0. If y == 0, a division-by-zero run-time panic occurs.
DivMod implements Euclidean division and modulus (unlike Go):
q = x div y such that m = x - y*q with 0 <= m < |y|
(See Raymond T. Boute, “The Euclidean definition of the functions div and mod”. ACM Transactions on Programming Languages and Systems (TOPLAS), 14(2):127-144, New York, NY, USA, 4/1992. ACM press.) See QuoRem for T-division and modulus (like Go).
func (*Int) Exp ¶
Exp sets z = x**y mod |m| (i.e. the sign of m is ignored), and returns z. If m == nil or m == 0, z = x**y unless y <= 0 then z = 1. If m != 0, y < 0, and x and m are not relatively prime, z is unchanged and nil is returned.
Modular exponentiation of inputs of a particular size is not a cryptographically constant-time operation.
func (*Int) FillBytes ¶
FillBytes sets buf to the absolute value of x, storing it as a zero-extended big-endian byte slice, and returns buf.
If the absolute value of x doesn't fit in buf, FillBytes will panic.
func (*Int) GCD ¶
GCD sets z to the greatest common divisor of a and b and returns z. If x or y are not nil, GCD sets their value such that z = a*x + b*y.
a and b may be positive, zero or negative. (Before Go 1.14 both had to be > 0.) Regardless of the signs of a and b, z is always >= 0.
If a == b == 0, GCD sets z = x = y = 0.
If a == 0 and b != 0, GCD sets z = |b|, x = 0, y = sign(b) * 1.
If a != 0 and b == 0, GCD sets z = |a|, x = sign(a) * 1, y = 0.
func (*Int) Int64 ¶
Int64 returns the int64 representation of x. If x cannot be represented in an int64, the result is undefined.
func (*Int) Mod ¶
Mod sets z to the modulus x%y for y != 0 and returns z. If y == 0, a division-by-zero run-time panic occurs. Mod implements Euclidean modulus (unlike Go); see DivMod for more details.
func (*Int) ModInverse ¶
ModInverse sets z to the multiplicative inverse of g in the ring ℤ/nℤ and returns z. If g and n are not relatively prime, g has no multiplicative inverse in the ring ℤ/nℤ. In this case, z is unchanged and the return value is nil.
func (*Int) ModSqrt ¶
ModSqrt sets z to a square root of x mod p if such a square root exists, and returns z. The modulus p must be an odd prime. If x is not a square mod p, ModSqrt leaves z unchanged and returns nil. This function panics if p is not an odd integer.
func (*Int) MulRange ¶
MulRange sets z to the product of all integers in the range [a, b] inclusively and returns z. If a > b (empty range), the result is 1.
func (*Int) Quo ¶
Quo sets z to the quotient x/y for y != 0 and returns z. If y == 0, a division-by-zero run-time panic occurs. Quo implements truncated division (like Go); see QuoRem for more details.
func (*Int) QuoRem ¶
QuoRem sets z to the quotient x/y and r to the remainder x%y and returns the pair (z, r) for y != 0. If y == 0, a division-by-zero run-time panic occurs.
QuoRem implements T-division and modulus (like Go):
q = x/y with the result truncated to zero r = x - y*q
(See Daan Leijen, “Division and Modulus for Computer Scientists”.) See DivMod for Euclidean division and modulus (unlike Go).
func (*Int) Rand ¶
Rand sets z to a pseudo-random number in [0, n) and returns z.
As this uses the math/rand package, it must not be used for security-sensitive work. Use crypto/rand.Int instead.
func (*Int) Rem ¶
Rem sets z to the remainder x%y for y != 0 and returns z. If y == 0, a division-by-zero run-time panic occurs. Rem implements truncated modulus (like Go); see QuoRem for more details.
func (*Int) SetBit ¶
SetBit sets z to x, with x's i'th bit set to b (0 or 1). That is, if b is 1 SetBit sets z = x | (1 << i); if b is 0 SetBit sets z = x &^ (1 << i). If b is not 0 or 1, SetBit will panic.
func (*Int) SetBits ¶
SetBits provides raw (unchecked but fast) access to z by setting its value to abs, interpreted as a little-endian Word slice, and returning z. The result and abs share the same underlying array. SetBits is intended to support implementation of missing low-level Int functionality outside this package; it should be avoided otherwise.
func (*Int) SetBytes ¶
SetBytes interprets buf as the bytes of a big-endian unsigned integer, sets z to that value, and returns z.
func (*Int) SetString ¶
SetString sets z to the value of s, interpreted in the given base, and returns z and a boolean indicating success. The entire string (not just a prefix) must be valid for success. If SetString fails, the value of z is undefined but the returned value is nil.
The base argument must be 0 or a value between 2 and MaxBase. For base 0, the number prefix determines the actual base: A prefix of “0b” or “0B” selects base 2, “0”, “0o” or “0O” selects base 8, and “0x” or “0X” selects base 16. Otherwise, the selected base is 10 and no prefix is accepted.
For bases <= 36, lower and upper case letters are considered the same: The letters 'a' to 'z' and 'A' to 'Z' represent digit values 10 to 35. For bases > 36, the upper case letters 'A' to 'Z' represent the digit values 36 to 61.
For base 0, an underscore character “_” may appear between a base prefix and an adjacent digit, and between successive digits; such underscores do not change the value of the number. Incorrect placement of underscores is reported as an error if there are no other errors. If base != 0, underscores are not recognized and act like any other character that is not a valid digit.
func (*Int) Sqrt ¶
Sqrt sets z to ⌊√x⌋, the largest integer such that z² ≤ x, and returns z. It panics if x is negative.
func (*Int) TrailingZeroBits ¶
TrailingZeroBits returns the number of consecutive least significant zero bits of |x|.
type RoundingMode ¶
type RoundingMode byte
RoundingMode determines how a Float value is rounded to the desired precision. Rounding may change the Float value; the rounding error is described by the Float's Accuracy.
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 )
These constants define supported rounding modes.