Namespace: go.std.math.big
v1.0Contents
Summary
Provides a lowlevel interface to the math/big package.
Package big implements arbitraryprecision arithmetic (big numbers).
The following numeric types are supported:
Int signed integers
Rat rational numbers
Float floatingpoint numbers
The zero value for an Int, Rat, or Float correspond to 0. Thus, new
values can be declared in the usual ways and denote 0 without further
initialization:
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
Alternatively, new values can be allocated and initialized with factory
functions of the form:
func NewT(v V) *T
For instance, NewInt(x) returns an *Int set to the value of the int64
argument x, NewRat(a, b) returns a *Rat set to the fraction a/b where
a and b are int64 values, and NewFloat(f) returns a *Float initialized
to the float64 argument f. More flexibility is provided with explicit
setters, for instance:
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
Setters, numeric operations and predicates are represented as methods of
the form:
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)
with T one of Int, Rat, or Float. For unary and binary operations, the
result is the receiver (usually named z in that case; see below); if it
is one of the operands x or y it may be safely overwritten (and its memory
reused).
Arithmetic expressions are typically written as a sequence of individual
method calls, with each call corresponding to an operation. The receiver
denotes the result and the method arguments are the operation's operands.
For instance, given three *Int values a, b and c, the invocation
c.Add(a, b)
computes the sum a + b and stores the result in c, overwriting whatever
value was held in c before. Unless specified otherwise, operations permit
aliasing of parameters, so it is perfectly ok to write
sum.Add(sum, x)
to accumulate values x in a sum.
(By always passing in a result value via the receiver, memory use can be
much better controlled. Instead of having to allocate new memory for each
result, an operation can reuse the space allocated for the result value,
and overwrite that value with the new result in the process.)
Notational convention: Incoming method parameters (including the receiver)
are named consistently in the API to clarify their use. Incoming operands
are usually named x, y, a, b, and so on, but never z. A parameter specifying
the result is named z (typically the receiver).
For instance, the arguments for (*Int).Add are named x and y, and because
the receiver specifies the result destination, it is called z:
func (z *Int) Add(x, y *Int) *Int
Methods of this form typically return the incoming receiver as well, to
enable simple call chaining.
Methods which don't require a result value to be passed in (for instance,
Int.Sign), simply return the result. In this case, the receiver is typically
the first operand, named x:
func (x *Int) Sign() int
Various methods support conversions between strings and corresponding
numeric values, and vice versa: *Int, *Rat, and *Float values implement
the Stringer interface for a (default) string representation of the value,
but also provide SetString methods to initialize a value from a string in
a variety of supported formats (see the respective SetString documentation).
Finally, *Int, *Rat, and *Float satisfy the fmt package's Scanner interface
for scanning and (except for *Rat) the Formatter interface for formatted
printing.
Index
 *Accuracy
 *ErrNaN
 *Float
 *Int
 *Rat
 *RoundingMode
 *Word
 Above
 Accuracy
 AwayFromZero
 Below
 ErrNaN
 Exact
 Float
 Int
 Jacobi
 MaxBase
 MaxExp
 MaxPrec
 MinExp
 NewFloat
 NewInt
 NewRat
 ParseFloat
 Rat
 RoundingMode
 ToNearestAway
 ToNearestEven
 ToNegativeInf
 ToPositiveInf
 ToZero
 Word
 arrayOfAccuracy
 arrayOfErrNaN
 arrayOfFloat
 arrayOfInt
 arrayOfRat
 arrayOfRoundingMode
 arrayOfWord
Legend

Constant
Variable
Function
Macro
Special form
Type
GoVar
Receiver/Method
Constants
Constants are variables with :const true in their metadata. Joker currently does not recognize them as special; as such, it allows redefining them or their values.
MaxBase
Char v1.0MaxBase is the largest number base accepted for string conversions.

MaxExp
Int v1.0largest supported exponent

MaxPrec
Int v1.0largest (theoretically) supported precision; likely memorylimited

MinExp
Int v1.0smallest supported exponent
Variables

Above
GoObject v1.0Constants describing the Accuracy of a Float.

AwayFromZero
GoObject v1.0no IEEE 7542008 equivalent

Below
GoObject v1.0Constants describing the Accuracy of a Float.

Exact
GoObject v1.0Constants describing the Accuracy of a Float.

ToNearestAway
GoObject v1.0== IEEE 7542008 roundTiesToAway

ToNearestEven
GoObject v1.0== IEEE 7542008 roundTiesToEven

ToNegativeInf
GoObject v1.0== IEEE 7542008 roundTowardNegative

ToPositiveInf
GoObject v1.0== IEEE 7542008 roundTowardPositive

ToZero
GoObject v1.0== IEEE 7542008 roundTowardZero
Functions, Macros, and Special Forms

Jacobi
Function v1.0(Jacobi x y)
Jacobi returns the Jacobi symbol (x/y), either +1, 1, or 0.
The y argument must be an odd integer.
Go input arguments: (x *Int, y *Int)
Go returns: int
Joker input arguments: [^*Int x, ^*Int y]
Joker returns: ^Int 
NewFloat
Function v1.0(NewFloat x)
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.
Go input arguments: (x float64)
Go returns: *Float
Joker input arguments: [^Double x]
Joker returns: ^*Float 
NewInt
Function v1.0(NewInt x)
NewInt allocates and returns a new Int set to x.
Go input arguments: (x int64)
Go returns: *Int
Joker input arguments: [^BigInt x]
Joker returns: ^*Int 
NewRat
Function v1.0(NewRat a b)
NewRat creates a new Rat with numerator a and denominator b.
Go input arguments: (a int64, b int64)
Go returns: *Rat
Joker input arguments: [^BigInt a, ^BigInt b]
Joker returns: ^*Rat 
ParseFloat
Function v1.0(ParseFloat s base prec mode)
ParseFloat is like f.Parse(s, base) with f set to the given precision
and rounding mode.
Go input arguments: (s string, base int, prec uint, mode RoundingMode)
Go returns: (f *Float, b int, err error)
Joker input arguments: [^String s, ^Int base, ^Number prec, ^RoundingMode mode]
Joker returns: [^*Float f, ^Int b, ^Error err]
Types

*Accuracy
Concrete Type v1.0Accuracy describes the rounding error produced by the most recent
operation that generated a Float value, relative to the exact value.

*ErrNaN
Concrete Type v1.0An ErrNaN panic is raised by a Float operation that would lead to
a NaN under IEEE754 rules. An ErrNaN implements the error interface.

*Float
Concrete Type v1.0A nonzero finite Float represents a multiprecision 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 IEEE754 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 IEEE754 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.

Abs
Receiver for *Float v1.0([x])
Abs sets z to the (possibly rounded) value x (the absolute value of x)
and returns z.

Acc
Receiver for *Float v1.0([])
Acc returns the accuracy of x produced by the most recent
operation, unless explicitly documented otherwise by that
operation.

Add
Receiver for *Float v1.0([x y])
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.

Append
Receiver for *Float v1.0([buf fmt prec])
Append appends to buf the string form of the floatingpoint number x,
as generated by x.Text, and returns the extended buffer.

Cmp
Receiver for *Float v1.0([y])
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

Copy
Receiver for *Float v1.0([x])
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.

Float32
Receiver for *Float v1.0([])
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.

Float64
Receiver for *Float v1.0([])
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.

Format
Receiver for *Float v1.0([s format])
Format implements fmt.Formatter. It accepts all the regular
formats for floatingpoint 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.

GobDecode
Receiver for *Float v1.0([buf])
GobDecode implements the gob.GobDecoder interface.
The result is rounded per the precision and rounding mode of
z unless z's precision is 0, in which case z is set exactly
to the decoded value.

GobEncode
Receiver for *Float v1.0([])
GobEncode implements the gob.GobEncoder interface.
The Float value and all its attributes (precision,
rounding mode, accuracy) are marshaled.

Int
Receiver for *Float v1.0([z])
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 nonnil *Int argument z is provided, Int stores
the result in z instead of allocating a new Int.

Int64
Receiver for *Float v1.0([])
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.

IsInf
Receiver for *Float v1.0([])
IsInf reports whether x is +Inf or Inf.

IsInt
Receiver for *Float v1.0([])
IsInt reports whether x is an integer.
±Inf values are not integers.

MantExp
Receiver for *Float v1.0([mant])
MantExp breaks x into its mantissa and exponent components
and returns the exponent. If a nonnil 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.

MarshalText
Receiver for *Float v1.0([])
MarshalText implements the encoding.TextMarshaler interface.
Only the Float value is marshaled (in full precision), other
attributes such as precision or accuracy are ignored.

MinPrec
Receiver for *Float v1.0([])
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.

Mode
Receiver for *Float v1.0([])
Mode returns the rounding mode of x.

Mul
Receiver for *Float v1.0([x y])
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.

Neg
Receiver for *Float v1.0([x])
Neg sets z to the (possibly rounded) value of x with its sign negated,
and returns z.

Parse
Receiver for *Float v1.0([s base])
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 runtime 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.

Prec
Receiver for *Float v1.0([])
Prec returns the mantissa precision of x in bits.
The result may be 0 for x == 0 and x == Inf.

Quo
Receiver for *Float v1.0([x y])
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.

Rat
Receiver for *Float v1.0([z])
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 nonnil *Rat argument z is provided, Rat stores
the result in z instead of allocating a new Rat.

Scan
Receiver for *Float v1.0([s ch])
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.

Set
Receiver for *Float v1.0([x])
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.

SetFloat64
Receiver for *Float v1.0([x])
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.

SetInf
Receiver for *Float v1.0([signbit])
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.

SetInt
Receiver for *Float v1.0([x])
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).

SetInt64
Receiver for *Float v1.0([x])
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).

SetMantExp
Receiver for *Float v1.0([mant exp])
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.

SetMode
Receiver for *Float v1.0([mode])
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.

SetPrec
Receiver for *Float v1.0([prec])
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.

SetRat
Receiver for *Float v1.0([x])
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.

SetString
Receiver for *Float v1.0([s])
SetString sets z to the value of s and returns z and a boolean indicating
success. s must be a floatingpoint 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.

SetUint64
Receiver for *Float v1.0([x])
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).

Sign
Receiver for *Float v1.0([])
Sign returns:
1 if x < 0
0 if x is ±0
+1 if x > 0

Signbit
Receiver for *Float v1.0([])
Signbit reports whether x is negative or negative zero.

Sqrt
Receiver for *Float v1.0([x])
Sqrt sets z to the rounded square root of x, and returns it.
If z's precision is 0, it is changed to x's precision before the
operation. Rounding is performed according to z's precision and
rounding mode, but z's accuracy is not computed. Specifically, the
result of z.Acc() is undefined.
The function panics if z < 0. The value of z is undefined in that
case.

String
Receiver for *Float v1.0([])
String formats x like x.Text('g', 10).
(String must be called explicitly, Float.Format does not support %s verb.)

Sub
Receiver for *Float v1.0([x y])
Sub sets z to the rounded difference xy 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.

Text
Receiver for *Float v1.0([format prec])
Text converts the floatingpoint 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 (nonstandard)
'b' ddddddp±dd, decimal mantissa, decimal power of two exponent (nonstandard)
For the poweroftwo 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.

Uint64
Receiver for *Float v1.0([])
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.

UnmarshalText
Receiver for *Float v1.0([text])
UnmarshalText implements the encoding.TextUnmarshaler interface.
The result is rounded per the precision and rounding mode of z.
If z's precision is 0, it is changed to 64 before rounding takes
effect.

*Int
Concrete Type v1.0An Int represents a signed multiprecision 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.

Abs
Receiver for *Int v1.0([x])
Abs sets z to x (the absolute value of x) and returns z.

Add
Receiver for *Int v1.0([x y])
Add sets z to the sum x+y and returns z.

And
Receiver for *Int v1.0([x y])
And sets z = x & y and returns z.

AndNot
Receiver for *Int v1.0([x y])
AndNot sets z = x &^ y and returns z.

Append
Receiver for *Int v1.0([buf base])
Append appends the string representation of x, as generated by
x.Text(base), to buf and returns the extended buffer.

Binomial
Receiver for *Int v1.0([n k])
Binomial sets z to the binomial coefficient of (n, k) and returns z.

Bit
Receiver for *Int v1.0([i])
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.

BitLen
Receiver for *Int v1.0([])
BitLen returns the length of the absolute value of x in bits.
The bit length of 0 is 0.

Bits
Receiver for *Int v1.0([])
Bits provides raw (unchecked but fast) access to x by returning its
absolute value as a littleendian Word slice. The result and x share
the same underlying array.
Bits is intended to support implementation of missing lowlevel Int
functionality outside this package; it should be avoided otherwise.

Bytes
Receiver for *Int v1.0([])
Bytes returns the absolute value of x as a bigendian byte slice.
To use a fixed length slice, or a preallocated one, use FillBytes.

Cmp
Receiver for *Int v1.0([y])
Cmp compares x and y and returns:
1 if x < y
0 if x == y
+1 if x > y

CmpAbs
Receiver for *Int v1.0([y])
CmpAbs compares the absolute values of x and y and returns:
1 if x < y
0 if x == y
+1 if x > y

Div
Receiver for *Int v1.0([x y])
Div sets z to the quotient x/y for y != 0 and returns z.
If y == 0, a divisionbyzero runtime panic occurs.
Div implements Euclidean division (unlike Go); see DivMod for more details.

DivMod
Receiver for *Int v1.0([x y m])
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 divisionbyzero runtime 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):127144, New York, NY, USA, 4/1992.
ACM press.)
See QuoRem for Tdivision and modulus (like Go).

Exp
Receiver for *Int v1.0([x y m])
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 constanttime operation.

FillBytes
Receiver for *Int v1.0([buf])
FillBytes sets buf to the absolute value of x, storing it as a zeroextended
bigendian byte slice, and returns buf.
If the absolute value of x doesn't fit in buf, FillBytes will panic.

Format
Receiver for *Int v1.0([s ch])
Format implements fmt.Formatter. It accepts the formats
'b' (binary), 'o' (octal with 0 prefix), 'O' (octal with 0o prefix),
'd' (decimal), 'x' (lowercase hexadecimal), and
'X' (uppercase hexadecimal).
Also supported are the full suite of package fmt's format
flags for integral types, including '+' and ' ' for sign
control, '#' for leading zero in octal and for hexadecimal,
a leading "0x" or "0X" for "%#x" and "%#X" respectively,
specification of minimum digits precision, output field
width, space or zero padding, and '' for left or right
justification.

GCD
Receiver for *Int v1.0([x y a b])
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.

GobDecode
Receiver for *Int v1.0([buf])
GobDecode implements the gob.GobDecoder interface.

GobEncode
Receiver for *Int v1.0([])
GobEncode implements the gob.GobEncoder interface.

Int64
Receiver for *Int v1.0([])
Int64 returns the int64 representation of x.
If x cannot be represented in an int64, the result is undefined.

IsInt64
Receiver for *Int v1.0([])
IsInt64 reports whether x can be represented as an int64.

IsUint64
Receiver for *Int v1.0([])
IsUint64 reports whether x can be represented as a uint64.

Lsh
Receiver for *Int v1.0([x n])
Lsh sets z = x << n and returns z.

MarshalJSON
Receiver for *Int v1.0([])
MarshalJSON implements the json.Marshaler interface.

MarshalText
Receiver for *Int v1.0([])
MarshalText implements the encoding.TextMarshaler interface.

Mod
Receiver for *Int v1.0([x y])
Mod sets z to the modulus x%y for y != 0 and returns z.
If y == 0, a divisionbyzero runtime panic occurs.
Mod implements Euclidean modulus (unlike Go); see DivMod for more details.

ModInverse
Receiver for *Int v1.0([g n])
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.

ModSqrt
Receiver for *Int v1.0([x p])
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.

Mul
Receiver for *Int v1.0([x y])
Mul sets z to the product x*y and returns z.

MulRange
Receiver for *Int v1.0([a b])
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.

Neg
Receiver for *Int v1.0([x])
Neg sets z to x and returns z.

Not
Receiver for *Int v1.0([x])
Not sets z = ^x and returns z.

Or
Receiver for *Int v1.0([x y])
Or sets z = x  y and returns z.

ProbablyPrime
Receiver for *Int v1.0([n])
ProbablyPrime reports whether x is probably prime,
applying the MillerRabin test with n pseudorandomly chosen bases
as well as a BailliePSW test.
If x is prime, ProbablyPrime returns true.
If x is chosen randomly and not prime, ProbablyPrime probably returns false.
The probability of returning true for a randomly chosen nonprime is at most ¼ⁿ.
ProbablyPrime is 100% accurate for inputs less than 2⁶⁴.
See Menezes et al., Handbook of Applied Cryptography, 1997, pp. 145149,
and FIPS 1864 Appendix F for further discussion of the error probabilities.
ProbablyPrime is not suitable for judging primes that an adversary may
have crafted to fool the test.
As of Go 1.8, ProbablyPrime(0) is allowed and applies only a BailliePSW test.
Before Go 1.8, ProbablyPrime applied only the MillerRabin tests, and ProbablyPrime(0) panicked.

Quo
Receiver for *Int v1.0([x y])
Quo sets z to the quotient x/y for y != 0 and returns z.
If y == 0, a divisionbyzero runtime panic occurs.
Quo implements truncated division (like Go); see QuoRem for more details.

QuoRem
Receiver for *Int v1.0([x y r])
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 divisionbyzero runtime panic occurs.
QuoRem implements Tdivision 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).

Rand
Receiver for *Int v1.0([rnd n])
Rand sets z to a pseudorandom number in [0, n) and returns z.
As this uses the math/rand package, it must not be used for
securitysensitive work. Use crypto/rand.Int instead.

Rem
Receiver for *Int v1.0([x y])
Rem sets z to the remainder x%y for y != 0 and returns z.
If y == 0, a divisionbyzero runtime panic occurs.
Rem implements truncated modulus (like Go); see QuoRem for more details.

Rsh
Receiver for *Int v1.0([x n])
Rsh sets z = x >> n and returns z.

Scan
Receiver for *Int v1.0([s ch])
Scan is a support routine for fmt.Scanner; it sets z to the value of
the scanned number. It accepts the formats 'b' (binary), 'o' (octal),
'd' (decimal), 'x' (lowercase hexadecimal), and 'X' (uppercase hexadecimal).

Set
Receiver for *Int v1.0([x])
Set sets z to x and returns z.

SetBit
Receiver for *Int v1.0([x i b])
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.

SetBits
Receiver for *Int v1.0([abs])
SetBits provides raw (unchecked but fast) access to z by setting its
value to abs, interpreted as a littleendian Word slice, and returning
z. The result and abs share the same underlying array.
SetBits is intended to support implementation of missing lowlevel Int
functionality outside this package; it should be avoided otherwise.

SetBytes
Receiver for *Int v1.0([buf])
SetBytes interprets buf as the bytes of a bigendian unsigned
integer, sets z to that value, and returns z.

SetInt64
Receiver for *Int v1.0([x])
SetInt64 sets z to x and returns z.

SetString
Receiver for *Int v1.0([s base])
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.

SetUint64
Receiver for *Int v1.0([x])
SetUint64 sets z to x and returns z.

Sign
Receiver for *Int v1.0([])
Sign returns:
1 if x < 0
0 if x == 0
+1 if x > 0

Sqrt
Receiver for *Int v1.0([x])
Sqrt sets z to ⌊√x⌋, the largest integer such that z² ≤ x, and returns z.
It panics if x is negative.

String
Receiver for *Int v1.0([])
String returns the decimal representation of x as generated by
x.Text(10).

Sub
Receiver for *Int v1.0([x y])
Sub sets z to the difference xy and returns z.

Text
Receiver for *Int v1.0([base])
Text returns the string representation of x in the given base.
Base must be between 2 and 62, inclusive. The result uses the
lowercase letters 'a' to 'z' for digit values 10 to 35, and
the uppercase letters 'A' to 'Z' for digit values 36 to 61.
No prefix (such as "0x") is added to the string. If x is a nil
pointer it returns "<nil>".

TrailingZeroBits
Receiver for *Int v1.0([])
TrailingZeroBits returns the number of consecutive least significant zero
bits of x.

Uint64
Receiver for *Int v1.0([])
Uint64 returns the uint64 representation of x.
If x cannot be represented in a uint64, the result is undefined.

UnmarshalJSON
Receiver for *Int v1.0([text])
UnmarshalJSON implements the json.Unmarshaler interface.

UnmarshalText
Receiver for *Int v1.0([text])
UnmarshalText implements the encoding.TextUnmarshaler interface.

Xor
Receiver for *Int v1.0([x y])
Xor sets z = x ^ y and returns z.

*Rat
Concrete Type v1.0A Rat represents a quotient a/b of arbitrary precision.
The zero value for a Rat represents the value 0.
Operations always take pointer arguments (*Rat) rather
than Rat values, and each unique Rat value requires
its own unique *Rat pointer. To "copy" a Rat value,
an existing (or newly allocated) Rat must be set to
a new value using the Rat.Set method; shallow copies
of Rats are not supported and may lead to errors.

Abs
Receiver for *Rat v1.0([x])
Abs sets z to x (the absolute value of x) and returns z.

Add
Receiver for *Rat v1.0([x y])
Add sets z to the sum x+y and returns z.

Cmp
Receiver for *Rat v1.0([y])
Cmp compares x and y and returns:
1 if x < y
0 if x == y
+1 if x > y

Denom
Receiver for *Rat v1.0([])
Denom returns the denominator of x; it is always > 0.
The result is a reference to x's denominator, unless
x is an uninitialized (zero value) Rat, in which case
the result is a new Int of value 1. (To initialize x,
any operation that sets x will do, including x.Set(x).)
If the result is a reference to x's denominator it
may change if a new value is assigned to x, and vice versa.

Float32
Receiver for *Rat v1.0([])
Float32 returns the nearest float32 value for x and a bool indicating
whether f represents x exactly. If the magnitude of x is too large to
be represented by a float32, f is an infinity and exact is false.
The sign of f always matches the sign of x, even if f == 0.

Float64
Receiver for *Rat v1.0([])
Float64 returns the nearest float64 value for x and a bool indicating
whether f represents x exactly. If the magnitude of x is too large to
be represented by a float64, f is an infinity and exact is false.
The sign of f always matches the sign of x, even if f == 0.

FloatString
Receiver for *Rat v1.0([prec])
FloatString returns a string representation of x in decimal form with prec
digits of precision after the radix point. The last digit is rounded to
nearest, with halves rounded away from zero.

GobDecode
Receiver for *Rat v1.0([buf])
GobDecode implements the gob.GobDecoder interface.

GobEncode
Receiver for *Rat v1.0([])
GobEncode implements the gob.GobEncoder interface.

Inv
Receiver for *Rat v1.0([x])
Inv sets z to 1/x and returns z.
If x == 0, Inv panics.

IsInt
Receiver for *Rat v1.0([])
IsInt reports whether the denominator of x is 1.

MarshalText
Receiver for *Rat v1.0([])
MarshalText implements the encoding.TextMarshaler interface.

Mul
Receiver for *Rat v1.0([x y])
Mul sets z to the product x*y and returns z.

Neg
Receiver for *Rat v1.0([x])
Neg sets z to x and returns z.

Num
Receiver for *Rat v1.0([])
Num returns the numerator of x; it may be <= 0.
The result is a reference to x's numerator; it
may change if a new value is assigned to x, and vice versa.
The sign of the numerator corresponds to the sign of x.

Quo
Receiver for *Rat v1.0([x y])
Quo sets z to the quotient x/y and returns z.
If y == 0, Quo panics.

RatString
Receiver for *Rat v1.0([])
RatString returns a string representation of x in the form "a/b" if b != 1,
and in the form "a" if b == 1.

Scan
Receiver for *Rat v1.0([s ch])
Scan is a support routine for fmt.Scanner. It accepts the formats
'e', 'E', 'f', 'F', 'g', 'G', and 'v'. All formats are equivalent.

Set
Receiver for *Rat v1.0([x])
Set sets z to x (by making a copy of x) and returns z.

SetFloat64
Receiver for *Rat v1.0([f])
SetFloat64 sets z to exactly f and returns z.
If f is not finite, SetFloat returns nil.

SetFrac
Receiver for *Rat v1.0([a b])
SetFrac sets z to a/b and returns z.
If b == 0, SetFrac panics.

SetFrac64
Receiver for *Rat v1.0([a b])
SetFrac64 sets z to a/b and returns z.
If b == 0, SetFrac64 panics.

SetInt
Receiver for *Rat v1.0([x])
SetInt sets z to x (by making a copy of x) and returns z.

SetInt64
Receiver for *Rat v1.0([x])
SetInt64 sets z to x and returns z.

SetString
Receiver for *Rat v1.0([s])
SetString sets z to the value of s and returns z and a boolean indicating
success. s can be given as a (possibly signed) fraction "a/b", or as a
floatingpoint number optionally followed by an exponent.
If a fraction is provided, both the dividend and the divisor may be a
decimal integer or independently use a prefix of ``0b'', ``0'' or ``0o'',
or ``0x'' (or their uppercase variants) to denote a binary, octal, or
hexadecimal integer, respectively. The divisor may not be signed.
If a floatingpoint number is provided, it may be in decimal form or
use any of the same prefixes as above but for ``0'' to denote a nondecimal
mantissa. A leading ``0'' is considered a decimal leading 0; it does not
indicate octal representation in this case.
An optional base10 ``e'' or base2 ``p'' (or their uppercase variants)
exponent may be provided as well, except for hexadecimal floats which
only accept an (optional) ``p'' exponent (because an ``e'' or ``E'' cannot
be distinguished from a mantissa digit). If the exponent's absolute value
is too large, the operation may fail.
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.

SetUint64
Receiver for *Rat v1.0([x])
SetUint64 sets z to x and returns z.

Sign
Receiver for *Rat v1.0([])
Sign returns:
1 if x < 0
0 if x == 0
+1 if x > 0

String
Receiver for *Rat v1.0([])
String returns a string representation of x in the form "a/b" (even if b == 1).

Sub
Receiver for *Rat v1.0([x y])
Sub sets z to the difference xy and returns z.

UnmarshalText
Receiver for *Rat v1.0([text])
UnmarshalText implements the encoding.TextUnmarshaler interface.

*RoundingMode
Concrete Type v1.0RoundingMode 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.

*Word
Concrete Type v1.0A Word represents a single digit of a multiprecision unsigned integer.

Accuracy
Concrete Type v1.0Accuracy describes the rounding error produced by the most recent
operation that generated a Float value, relative to the exact value.

String
Receiver for Accuracy v1.0([])

ErrNaN
Concrete Type v1.0An ErrNaN panic is raised by a Float operation that would lead to
a NaN under IEEE754 rules. An ErrNaN implements the error interface.

Error
Receiver for ErrNaN v1.0([])

Float
Concrete Type v1.0A nonzero finite Float represents a multiprecision 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 IEEE754 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 IEEE754 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.

Int
Concrete Type v1.0An Int represents a signed multiprecision 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.

Rat
Concrete Type v1.0A Rat represents a quotient a/b of arbitrary precision.
The zero value for a Rat represents the value 0.
Operations always take pointer arguments (*Rat) rather
than Rat values, and each unique Rat value requires
its own unique *Rat pointer. To "copy" a Rat value,
an existing (or newly allocated) Rat must be set to
a new value using the Rat.Set method; shallow copies
of Rats are not supported and may lead to errors.

RoundingMode
Concrete Type v1.0RoundingMode 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.

String
Receiver for RoundingMode v1.0([])

Word
Concrete Type v1.0A Word represents a single digit of a multiprecision unsigned integer.

arrayOfAccuracy
Concrete Type v1.0Accuracy describes the rounding error produced by the most recent
operation that generated a Float value, relative to the exact value.

arrayOfErrNaN
Concrete Type v1.0An ErrNaN panic is raised by a Float operation that would lead to
a NaN under IEEE754 rules. An ErrNaN implements the error interface.

arrayOfFloat
Concrete Type v1.0A nonzero finite Float represents a multiprecision 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 IEEE754 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 IEEE754 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.

arrayOfInt
Concrete Type v1.0An Int represents a signed multiprecision 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.

arrayOfRat
Concrete Type v1.0A Rat represents a quotient a/b of arbitrary precision.
The zero value for a Rat represents the value 0.
Operations always take pointer arguments (*Rat) rather
than Rat values, and each unique Rat value requires
its own unique *Rat pointer. To "copy" a Rat value,
an existing (or newly allocated) Rat must be set to
a new value using the Rat.Set method; shallow copies
of Rats are not supported and may lead to errors.

arrayOfRoundingMode
Concrete Type v1.0RoundingMode 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.

arrayOfWord
Concrete Type v1.0A Word represents a single digit of a multiprecision unsigned integer.