"errors"
"fmt"
"io"
"math"
"math/bits"
"sync"
"fmt"
"math"
"math"
"sync"
"internal/cpu"
"fmt"
"io"
"math/rand"
"strings"
"math/bits"
"errors"
"fmt"
"io"
"strconv"
"strings"
"strconv"
_ "unsafe"
"internal/byteorder"
"math/bits"
"math/rand"
"sync"
"math/rand"
"errors"
"fmt"
"internal/byteorder"
"math"
"strconv"
"fmt"
"io"
"strings"
"bytes"
"fmt"
"strconv"
"errors"
"fmt"
"io"
"bytes"
"fmt"
"math/bits"
"internal/cpu"
"fmt"
"math"
"math/bits"
"errors"
"fmt"
"internal/byteorder"
Constants describing the [Accuracy] of a [Float].
const Above Accuracy = *ast.UnaryExprThese constants define supported rounding modes.
const AwayFromZeroConstants describing the [Accuracy] of a [Float].
const Below Accuracy = *ast.UnaryExprConstants describing the [Accuracy] of a [Float].
const Exact Accuracy = 0MaxBase is the largest number base accepted for string conversions.
const MaxBase = *ast.BinaryExprExponent and precision limits.
const MaxExp = math.MaxInt32Exponent and precision limits.
const MaxPrec = math.MaxUint32Exponent and precision limits.
const MinExp = math.MinInt32These constants define supported rounding modes.
const ToNearestAwayThese constants define supported rounding modes.
const ToNearestEven RoundingMode = iotaThese constants define supported rounding modes.
const ToNegativeInfThese constants define supported rounding modes.
const ToPositiveInfThese constants define supported rounding modes.
const ToZerovar _ fmt.Formatter = intOnevar _ fmt.Scanner = *ast.UnaryExprvar _ fmt.Scanner = intOnevar _ fmt.Formatter = *ast.UnaryExprvar _ fmt.Scanner = *ast.CallExprvar _Accuracy_index = [...]uint8{...}const _Accuracy_name = "BelowExactAbove"const _B = *ast.BinaryExprconst _M = *ast.BinaryExprvar _RoundingMode_index = [...]uint8{...}const _RoundingMode_name = "ToNearestEvenToNearestAwayToZeroAwayFromZeroToNegativeInfToPositiveInf"const _S = *ast.BinaryExprconst _W = bits.UintSizeOperands that are shorter than basicSqrThreshold are squared using "grade school" multiplication; for operands longer than karatsubaSqrThreshold we use the Karatsuba algorithm optimized for x == y.
var basicSqrThreshold = 20var cacheBase10 struct{...}const debugFloat = falseconst digits = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"divRecursiveThreshold is the number of divisor digits at which point divRecursive is faster than divBasic.
const divRecursiveThreshold = 100scan errors
var errInvalSep = *ast.CallExprscan errors
var errNoDigits = *ast.CallExprThe form value order is relevant - do not change!
const finiteGob codec version. Permits backward-compatible changes to the encoding.
const floatGobVersion byte = 1var floatZero Floatvar hasVX = cpu.S390X.HasVXThe form value order is relevant - do not change!
const infGob codec version. Permits backward-compatible changes to the encoding.
const intGobVersion byte = 1var intOne = *ast.UnaryExprvar karatsubaSqrThreshold = 260Operands that are shorter than karatsubaThreshold are multiplied using "grade school" multiplication; for longer operands the Karatsuba algorithm is used.
var karatsubaThreshold = 40Split blocks greater than leafSize Words (or set to 0 to disable recursive conversion) Benchmark and configure leafSize using: go test -bench="Leaf" 8 and 16 effective on 3.0 GHz Xeon "Clovertown" CPU (128 byte cache lines) 8 and 16 effective on 2.66 GHz Core 2 Duo "Penryn" CPU
var leafSize int = 8const maxBaseSmall = *ast.BinaryExprMaximum shift amount that can be done in one pass without overflow.
A Word has _W bits and (1<const maxShift = *ast.BinaryExpr
var natFive = nat{...}var natOne = nat{...}var natPool sync.Poolvar natTen = nat{...}var natTwo = nat{...}These powers of 5 fit into a uint64. for p, q := uint64(0), uint64(1); p < q; p, q = q, q*5 { fmt.Println(q) }
var pow5tab = [...]uint64{...}Gob codec version. Permits backward-compatible changes to the encoding.
const ratGobVersion byte = 1var ratZero Ratvar support_adx = *ast.BinaryExprvar threeOnce struct{...}The form value order is relevant - do not change!
const zero form = iotaAccuracy describes the rounding error produced by the most recent operation that generated a [Float] value, relative to the exact value.
type Accuracy int8RoundingMode 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].
type RoundingMode byteA Word represents a single digit of a multi-precision unsigned integer.
type Word uintA form value describes the internal representation.
type form byteAn unsigned integer x of the form x = x[n-1]*_B^(n-1) + x[n-2]*_B^(n-2) + ... + x[1]*_B + x[0] with 0 <= x[i] < _B and 0 <= i < n is stored in a slice of length n, with the digits x[i] as the slice elements. A number is normalized if the slice contains no leading 0 digits. During arithmetic operations, denormalized values may occur but are always normalized before returning the final result. The normalized representation of 0 is the empty or nil slice (length = 0).
type nat []WordAn 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 ErrNaN struct {
msg string
}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 [Float.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.
type Float struct {
prec uint32
mode RoundingMode
acc Accuracy
form form
neg bool
mant nat
exp int32
}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. Note that methods may leak the Int's value through timing side-channels. Because of this and because of the scope and complexity of the implementation, Int is not well-suited to implement cryptographic operations. The standard library avoids exposing non-trivial Int methods to attacker-controlled inputs and the determination of whether a bug in math/big is considered a security vulnerability might depend on the impact on the standard library.
type Int struct {
neg bool
abs nat
}A 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.
type Rat struct {
a Int
b Int
}byteReader is a local wrapper around fmt.ScanState; it implements the ByteReader interface.
type byteReader struct {
fmt.ScanState
}A decimal represents an unsigned floating-point number in decimal representation. The value of a non-zero decimal d is d.mant * 10**d.exp with 0.1 <= d.mant < 1, with the most-significant mantissa digit at index 0. For the zero decimal, the mantissa length and exponent are 0. The zero value for decimal represents a ready-to-use 0.0.
type decimal struct {
mant []byte
exp int
}type divisor struct {
bbb nat
nbits int
ndigits int
}Abs sets z to |x| (the absolute value of x) and returns z.
func (z *Int) Abs(x *Int) *IntAbs sets z to |x| (the absolute value of x) and returns z.
func (z *Rat) Abs(x *Rat) *RatAbs sets z to the (possibly rounded) value |x| (the absolute value of x) and returns z.
func (z *Float) Abs(x *Float) *FloatAcc returns the accuracy of x produced by the most recent operation, unless explicitly documented otherwise by that operation.
func (x *Float) Acc() AccuracyAdd 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 (z *Float) Add(x *Float, y *Float) *FloatAdd sets z to the sum x+y and returns z.
func (z *Rat) Add(x *Rat, y *Rat) *RatAdd sets z to the sum x+y and returns z.
func (z *Int) Add(x *Int, y *Int) *IntAnd sets z = x & y and returns z.
func (z *Int) And(x *Int, y *Int) *IntAndNot sets z = x &^ y and returns z.
func (z *Int) AndNot(x *Int, y *Int) *IntAppend appends to buf the string form of the floating-point number x, as generated by x.Text, and returns the extended buffer.
func (x *Float) Append(buf []byte, fmt byte, prec int) []byteAppend appends the string representation of x, as generated by x.Text(base), to buf and returns the extended buffer.
func (x *Int) Append(buf []byte, base int) []byteAppendText implements the [encoding.TextAppender] interface.
func (x *Rat) AppendText(b []byte) ([]byte, error)AppendText implements the [encoding.TextAppender] interface. Only the [Float] value is marshaled (in full precision), other attributes such as precision or accuracy are ignored.
func (x *Float) AppendText(b []byte) ([]byte, error)AppendText implements the [encoding.TextAppender] interface.
func (x *Int) AppendText(b []byte) (text []byte, err error)Binomial sets z to the binomial coefficient C(n, k) and returns z.
func (z *Int) Binomial(n int64, k int64) *IntBit 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 (x *Int) Bit(i int) uintBitLen returns the length of the absolute value of x in bits. The bit length of 0 is 0.
func (x *Int) BitLen() intBits 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 (x *Int) Bits() []WordBytes returns the absolute value of x as a big-endian byte slice. To use a fixed length slice, or a preallocated one, use [Int.FillBytes].
func (x *Int) Bytes() []byteCmp compares x and y and returns: - -1 if x < y; - 0 if x == y; - +1 if x > y.
func (x *Rat) Cmp(y *Rat) intCmp compares x and y and returns: - -1 if x < y; - 0 if x == y; - +1 if x > y.
func (x *Int) Cmp(y *Int) (r int)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 (x *Float) Cmp(y *Float) intCmpAbs compares the absolute values of x and y and returns: - -1 if |x| < |y|; - 0 if |x| == |y|; - +1 if |x| > |y|.
func (x *Int) CmpAbs(y *Int) intCopy sets z to x, with the same precision, rounding mode, and accuracy as x. Copy returns z. If x and z are identical, Copy is a no-op.
func (z *Float) Copy(x *Float) *FloatDenom 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.
func (x *Rat) Denom() *IntDiv 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 [Int.DivMod] for more details.
func (z *Int) Div(x *Int, y *Int) *IntDivMod 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 [Int.QuoRem] for T-division and modulus (like Go).
func (z *Int) DivMod(x *Int, y *Int, m *Int) (*Int, *Int)func (err ErrNaN) Error() stringExp 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 (z *Int) Exp(x *Int, y *Int, m *Int) *IntFillBytes 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 (x *Int) FillBytes(buf []byte) []byteFloat32 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 (x *Float) Float32() (float32, Accuracy)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.
func (x *Rat) Float32() (f float32, exact bool)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 (x *Float) Float64() (float64, Accuracy)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.
func (x *Rat) Float64() (f float64, exact bool)Float64 returns the float64 value nearest x, and an indication of any rounding that occurred.
func (x *Int) Float64() (float64, Accuracy)FloatPrec returns the number n of non-repeating digits immediately following the decimal point of the decimal representation of x. The boolean result indicates whether a decimal representation of x with that many fractional digits is exact or rounded. Examples: x n exact decimal representation n fractional digits 0 0 true 0 1 0 true 1 1/2 1 true 0.5 1/3 0 false 0 (0.333... rounded) 1/4 2 true 0.25 1/6 1 false 0.2 (0.166... rounded)
func (x *Rat) FloatPrec() (n int, exact bool)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.
func (x *Rat) FloatString(prec int) stringFormat 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.
func (x *Int) Format(s fmt.State, ch rune)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 (x *Float) Format(s fmt.State, format rune)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 (z *Int) GCD(x *Int, y *Int, a *Int, b *Int) *IntGobDecode implements the [encoding/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.
func (z *Float) GobDecode(buf []byte) errorGobDecode implements the [encoding/gob.GobDecoder] interface.
func (z *Rat) GobDecode(buf []byte) errorGobDecode implements the [encoding/gob.GobDecoder] interface.
func (z *Int) GobDecode(buf []byte) errorGobEncode implements the [encoding/gob.GobEncoder] interface.
func (x *Rat) GobEncode() ([]byte, error)GobEncode implements the [encoding/gob.GobEncoder] interface.
func (x *Int) GobEncode() ([]byte, error)GobEncode implements the [encoding/gob.GobEncoder] interface. The [Float] value and all its attributes (precision, rounding mode, accuracy) are marshaled.
func (x *Float) GobEncode() ([]byte, error)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 (x *Float) Int(z *Int) (*Int, Accuracy)Int64 returns the int64 representation of x. If x cannot be represented in an int64, the result is undefined.
func (x *Int) Int64() int64Int64 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 (x *Float) Int64() (int64, Accuracy)Inv sets z to 1/x and returns z. If x == 0, Inv panics.
func (z *Rat) Inv(x *Rat) *RatIsInf reports whether x is +Inf or -Inf.
func (x *Float) IsInf() boolIsInt reports whether the denominator of x is 1.
func (x *Rat) IsInt() boolIsInt reports whether x is an integer. ±Inf values are not integers.
func (x *Float) IsInt() boolIsInt64 reports whether x can be represented as an int64.
func (x *Int) IsInt64() boolIsUint64 reports whether x can be represented as a uint64.
func (x *Int) IsUint64() boolJacobi returns the Jacobi symbol (x/y), either +1, -1, or 0. The y argument must be an odd integer.
func Jacobi(x *Int, y *Int) intLsh sets z = x << n and returns z.
func (z *Int) Lsh(x *Int, n uint) *IntMantExp 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 (x *Float) MantExp(mant *Float) (exp int)MarshalJSON implements the [encoding/json.Marshaler] interface.
func (x *Int) MarshalJSON() ([]byte, error)MarshalText implements the [encoding.TextMarshaler] interface.
func (x *Rat) MarshalText() (text []byte, err error)MarshalText implements the [encoding.TextMarshaler] interface. Only the [Float] value is marshaled (in full precision), other attributes such as precision or accuracy are ignored.
func (x *Float) MarshalText() (text []byte, err error)MarshalText implements the [encoding.TextMarshaler] interface.
func (x *Int) MarshalText() (text []byte, err error)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 (x *Float) MinPrec() uintMod 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 [Int.DivMod] for more details.
func (z *Int) Mod(x *Int, y *Int) *IntModInverse 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. If n == 0, a division-by-zero run-time panic occurs.
func (z *Int) ModInverse(g *Int, n *Int) *IntModSqrt 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, its behavior is undefined if p is odd but not prime.
func (z *Int) ModSqrt(x *Int, p *Int) *IntMode returns the rounding mode of x.
func (x *Float) Mode() RoundingModeMul sets z to the rounded product x*y and returns z. Precision, rounding, and accuracy reporting are as for [Float.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 (z *Float) Mul(x *Float, y *Float) *FloatMul sets z to the product x*y and returns z.
func (z *Int) Mul(x *Int, y *Int) *IntMul sets z to the product x*y and returns z.
func (z *Rat) Mul(x *Rat, y *Rat) *RatMulRange 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 (z *Int) MulRange(a int64, b int64) *IntNeg sets z to the (possibly rounded) value of x with its sign negated, and returns z.
func (z *Float) Neg(x *Float) *FloatNeg sets z to -x and returns z.
func (z *Rat) Neg(x *Rat) *RatNeg sets z to -x and returns z.
func (z *Int) Neg(x *Int) *IntNewFloat 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 NewFloat(x float64) *FloatNewInt allocates and returns a new [Int] set to x.
func NewInt(x int64) *IntNewRat creates a new [Rat] with numerator a and denominator b.
func NewRat(a int64, b int64) *RatNot sets z = ^x and returns z.
func (z *Int) Not(x *Int) *IntNum 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.
func (x *Rat) Num() *IntOr sets z = x | y and returns z.
func (z *Int) Or(x *Int, y *Int) *IntParse 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 than 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 (z *Float) Parse(s string, base int) (f *Float, b int, err error)ParseFloat is like f.Parse(s, base) with f set to the given precision and rounding mode.
func ParseFloat(s string, base int, prec uint, mode RoundingMode) (f *Float, b int, err error)Prec returns the mantissa precision of x in bits. The result may be 0 for |x| == 0 and |x| == Inf.
func (x *Float) Prec() uintProbablyPrime reports whether x is probably prime, applying the Miller-Rabin test with n pseudorandomly chosen bases as well as a Baillie-PSW 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 non-prime is at most ¼ⁿ. ProbablyPrime is 100% accurate for inputs less than 2⁶⁴. See Menezes et al., Handbook of Applied Cryptography, 1997, pp. 145-149, and FIPS 186-4 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 Baillie-PSW test. Before Go 1.8, ProbablyPrime applied only the Miller-Rabin tests, and ProbablyPrime(0) panicked.
func (x *Int) ProbablyPrime(n int) boolQuo 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 [Int.QuoRem] for more details.
func (z *Int) Quo(x *Int, y *Int) *IntQuo sets z to the rounded quotient x/y and returns z. Precision, rounding, and accuracy reporting are as for [Float.Add]. Quo panics with [ErrNaN] if both operands are zero or infinities. The value of z is undefined in that case.
func (z *Float) Quo(x *Float, y *Float) *FloatQuo sets z to the quotient x/y and returns z. If y == 0, Quo panics.
func (z *Rat) Quo(x *Rat, y *Rat) *RatQuoRem 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 [Int.DivMod] for Euclidean division and modulus (unlike Go).
func (z *Int) QuoRem(x *Int, y *Int, r *Int) (*Int, *Int)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 (z *Int) Rand(rnd *rand.Rand, n *Int) *IntRat 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 (x *Float) Rat(z *Rat) (*Rat, Accuracy)RatString returns a string representation of x in the form "a/b" if b != 1, and in the form "a" if b == 1.
func (x *Rat) RatString() stringfunc (r byteReader) ReadByte() (byte, error)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 [Int.QuoRem] for more details.
func (z *Int) Rem(x *Int, y *Int) *IntRsh sets z = x >> n and returns z.
func (z *Int) Rsh(x *Int, n uint) *IntScan 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 (z *Float) Scan(s fmt.ScanState, ch rune) errorScan is a support routine for fmt.Scanner. It accepts the formats 'e', 'E', 'f', 'F', 'g', 'G', and 'v'. All formats are equivalent.
func (z *Rat) Scan(s fmt.ScanState, ch rune) errorScan 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).
func (z *Int) Scan(s fmt.ScanState, ch rune) errorSet sets z to x and returns z.
func (z *Int) Set(x *Int) *IntSet sets z to x (by making a copy of x) and returns z.
func (z *Rat) Set(x *Rat) *RatSet 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 (z *Float) Set(x *Float) *FloatSetBit 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 (z *Int) SetBit(x *Int, i int, b uint) *IntSetBits 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 (z *Int) SetBits(abs []Word) *IntSetBytes interprets buf as the bytes of a big-endian unsigned integer, sets z to that value, and returns z.
func (z *Int) SetBytes(buf []byte) *IntSetFloat64 sets z to exactly f and returns z. If f is not finite, SetFloat returns nil.
func (z *Rat) SetFloat64(f float64) *RatSetFloat64 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 (z *Float) SetFloat64(x float64) *FloatSetFrac sets z to a/b and returns z. If b == 0, SetFrac panics.
func (z *Rat) SetFrac(a *Int, b *Int) *RatSetFrac64 sets z to a/b and returns z. If b == 0, SetFrac64 panics.
func (z *Rat) SetFrac64(a int64, b int64) *RatSetInf 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 (z *Float) SetInf(signbit bool) *FloatSetInt sets z to x (by making a copy of x) and returns z.
func (z *Rat) SetInt(x *Int) *RatSetInt 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 (z *Float) SetInt(x *Int) *FloatSetInt64 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 (z *Float) SetInt64(x int64) *FloatSetInt64 sets z to x and returns z.
func (z *Int) SetInt64(x int64) *IntSetInt64 sets z to x and returns z.
func (z *Rat) SetInt64(x int64) *RatSetMantExp 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 [Float.MantExp] but does not require 0.5 <= |mant| < 1.0. Specifically, for a given x of type *[Float], SetMantExp relates to [Float.MantExp] as follows: 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 (z *Float) SetMantExp(mant *Float, exp int) *FloatSetMode 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 (z *Float) SetMode(mode RoundingMode) *FloatSetPrec 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 (z *Float) SetPrec(prec uint) *FloatSetRat 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 (z *Float) SetRat(x *Rat) *FloatSetString 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 floating-point 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 upper-case variants) to denote a binary, octal, or hexadecimal integer, respectively. The divisor may not be signed. If a floating-point number is provided, it may be in decimal form or use any of the same prefixes as above but for “0” to denote a non-decimal mantissa. A leading “0” is considered a decimal leading 0; it does not indicate octal representation in this case. An optional base-10 “e” or base-2 “p” (or their upper-case 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.
func (z *Rat) SetString(s string) (*Rat, bool)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 (z *Int) SetString(s string, base int) (*Int, bool)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 [Float.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 (z *Float) SetString(s string) (*Float, bool)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 (z *Float) SetUint64(x uint64) *FloatSetUint64 sets z to x and returns z.
func (z *Rat) SetUint64(x uint64) *RatSetUint64 sets z to x and returns z.
func (z *Int) SetUint64(x uint64) *IntSign returns: - -1 if x < 0; - 0 if x == 0; - +1 if x > 0.
func (x *Int) Sign() intSign returns: - -1 if x < 0; - 0 if x == 0; - +1 if x > 0.
func (x *Rat) Sign() intSign returns: - -1 if x < 0; - 0 if x is ±0; - +1 if x > 0.
func (x *Float) Sign() intSignbit reports whether x is negative or negative zero.
func (x *Float) Signbit() boolSqrt sets z to ⌊√x⌋, the largest integer such that z² ≤ x, and returns z. It panics if x is negative.
func (z *Int) Sqrt(x *Int) *IntSqrt 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.
func (z *Float) Sqrt(x *Float) *Floatfunc (x *decimal) String() stringfunc (z nat) String() stringString formats x like x.Text('g', 10). (String must be called explicitly, [Float.Format] does not support %s verb.)
func (x *Float) String() stringfunc (i RoundingMode) String() stringfunc (i Accuracy) String() stringString returns the decimal representation of x as generated by x.Text(10).
func (x *Int) String() stringString returns a string representation of x in the form "a/b" (even if b == 1).
func (x *Rat) String() stringSub sets z to the difference x-y and returns z.
func (z *Rat) Sub(x *Rat, y *Rat) *RatSub sets z to the rounded difference x-y and returns z. Precision, rounding, and accuracy reporting are as for [Float.Add]. Sub panics with [ErrNaN] if x and y are infinities with equal signs. The value of z is undefined in that case.
func (z *Float) Sub(x *Float, y *Float) *FloatSub sets z to the difference x-y and returns z.
func (z *Int) Sub(x *Int, y *Int) *IntText 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.
func (x *Float) Text(format byte, prec int) stringText returns the string representation of x in the given base.
Base must be between 2 and 62, inclusive. The result uses the
lower-case letters 'a' to 'z' for digit values 10 to 35, and
the upper-case 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 "
func (x *Int) Text(base int) stringTrailingZeroBits returns the number of consecutive least significant zero bits of |x|.
func (x *Int) TrailingZeroBits() uintUint64 returns the uint64 representation of x. If x cannot be represented in a uint64, the result is undefined.
func (x *Int) Uint64() uint64Uint64 returns the unsigned integer resulting from truncating x towards zero. If 0 <= x <= [math.MaxUint64], the result is [Exact] if x is an integer and [Below] otherwise. The result is (0, [Above]) for x < 0, and ([math.MaxUint64], [Below]) for x > [math.MaxUint64].
func (x *Float) Uint64() (uint64, Accuracy)UnmarshalJSON implements the [encoding/json.Unmarshaler] interface.
func (z *Int) UnmarshalJSON(text []byte) errorUnmarshalText 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.
func (z *Float) UnmarshalText(text []byte) errorUnmarshalText implements the [encoding.TextUnmarshaler] interface.
func (z *Int) UnmarshalText(text []byte) errorUnmarshalText implements the [encoding.TextUnmarshaler] interface.
func (z *Rat) UnmarshalText(text []byte) errorfunc (r byteReader) UnreadByte() errorXor sets z = x ^ y and returns z.
func (z *Int) Xor(x *Int, y *Int) *Intfunc _()func _()func (z nat) add(x nat, y nat) nataddAt implements z += x<<(_W*i); z must be long enough. (we don't use nat.add because we need z to stay the same slice, and we don't need to normalize z after each addition)
func addAt(z nat, x nat, i int)func addMulVVW(z []Word, x []Word, y Word) (c Word)addMulVVW should be an internal detail, but widely used packages access it using linkname. Notable members of the hall of shame include: - github.com/remyoudompheng/bigfft Do not remove or change the type signature. See go.dev/issue/67401. go:linkname addMulVVW go:noescape
func addMulVVW(z []Word, x []Word, y Word) (c Word)func addMulVVW_g(z []Word, x []Word, y Word) (c Word)func addVV(z []Word, x []Word, y []Word) (c Word)addVV should be an internal detail, but widely used packages access it using linkname. Notable members of the hall of shame include: - github.com/remyoudompheng/bigfft Do not remove or change the type signature. See go.dev/issue/67401. go:linkname addVV go:noescape
func addVV(z []Word, x []Word, y []Word) (c Word)func addVV_check(z []Word, x []Word, y []Word) (c Word)The resulting carry c is either 0 or 1.
func addVV_g(z []Word, x []Word, y []Word) (c Word)func addVV_novec(z []Word, x []Word, y []Word) (c Word)func addVV_vec(z []Word, x []Word, y []Word) (c Word)addVW should be an internal detail, but widely used packages access it using linkname. Notable members of the hall of shame include: - github.com/remyoudompheng/bigfft Do not remove or change the type signature. See go.dev/issue/67401. go:linkname addVW go:noescape
func addVW(z []Word, x []Word, y Word) (c Word)func addVW(z []Word, x []Word, y Word) (c Word)The resulting carry c is either 0 or 1.
func addVW_g(z []Word, x []Word, y Word) (c Word)addVWlarge is addVW, but intended for large z. The only difference is that we check on every iteration whether we are done with carries, and if so, switch to a much faster copy instead. This is only a good idea for large z, because the overhead of the check and the function call outweigh the benefits when z is small.
func addVWlarge(z []Word, x []Word, y Word) (c Word)alias reports whether x and y share the same base array. Note: alias assumes that the capacity of underlying arrays is never changed for nat values; i.e. that there are no 3-operand slice expressions in this code (or worse, reflect-based operations to the same effect).
func alias(x nat, y nat) boolfunc (z nat) and(x nat, y nat) natfunc (z nat) andNot(x nat, y nat) natappendZeros appends n 0 digits to buf and returns buf.
func appendZeros(buf []byte, n int) []byteat returns the i'th mantissa digit, starting with the most significant digit at 0.
func (d *decimal) at(i int) bytebasicMul multiplies x and y and leaves the result in z. The (non-normalized) result is placed in z[0 : len(x) + len(y)].
func basicMul(z nat, x nat, y nat)basicSqr sets z = x*x and is asymptotically faster than basicMul by about a factor of 2, but slower for small arguments due to overhead. Requirements: len(x) > 0, len(z) == 2*len(x) The (non-normalized) result is placed in z.
func basicSqr(z nat, x nat)bigEndianWord returns the contents of buf interpreted as a big-endian encoded Word value.
func bigEndianWord(buf []byte) Wordbit returns the value of the i'th bit, with lsb == bit 0.
func (x nat) bit(i uint) uintbitLen returns the length of x in bits. Unlike most methods, it works even if x is not normalized.
func (x nat) bitLen() intbytes writes the value of z into buf using big-endian encoding. The value of z is encoded in the slice buf[i:]. If the value of z cannot be represented in buf, bytes panics. The number i of unused bytes at the beginning of buf is returned as result.
func (z nat) bytes(buf []byte) (i int)func (x nat) cmp(y nat) (r int)Convert words of q to base b digits in s. If q is large, it is recursively "split in half" by nat/nat division using tabulated divisors. Otherwise, it is converted iteratively using repeated nat/Word division. The iterative method processes n Words by n divW() calls, each of which visits every Word in the incrementally shortened q for a total of n + (n-1) + (n-2) ... + 2 + 1, or n(n+1)/2 divW()'s. Recursive conversion divides q by its approximate square root, yielding two parts, each half the size of q. Using the iterative method on both halves means 2 * (n/2)(n/2 + 1)/2 divW()'s plus the expensive long div(). Asymptotically, the ratio is favorable at 1/2 the divW()'s, and is made better by splitting the subblocks recursively. Best is to split blocks until one more split would take longer (because of the nat/nat div()) than the twice as many divW()'s of the iterative approach. This threshold is represented by leafSize. Benchmarking of leafSize in the range 2..64 shows that values of 8 and 16 work well, with a 4x speedup at medium lengths and ~30x for 20000 digits. Use nat_test.go's BenchmarkLeafSize tests to optimize leafSize for specific hardware.
func (q nat) convertWords(s []byte, b Word, ndigits int, bb Word, table []divisor)div returns q, r such that q = ⌊u/v⌋ and r = u%v = u - q·v. It uses z and z2 as the storage for q and r.
func (z nat) div(z2 nat, u nat, v nat) (q nat, r nat)divBasic implements long division as described above. It overwrites q with ⌊u/v⌋ and overwrites u with the remainder r. q must be large enough to hold ⌊u/v⌋.
func (q nat) divBasic(u nat, v nat)div returns q, r such that q = ⌊uIn/vIn⌋ and r = uIn%vIn = uIn - q·vIn. It uses z and u as the storage for q and r. The caller must ensure that len(vIn) ≥ 2 (use divW otherwise) and that len(uIn) ≥ len(vIn) (the answer is 0, uIn otherwise).
func (z nat) divLarge(u nat, uIn nat, vIn nat) (q nat, r nat)divRecursive implements recursive division as described above. It overwrites z with ⌊u/v⌋ and overwrites u with the remainder r. z must be large enough to hold ⌊u/v⌋. This function is just for allocating and freeing temporaries around divRecursiveStep, the real implementation.
func (z nat) divRecursive(u nat, v nat)divRecursiveStep is the actual implementation of recursive division. It adds ⌊u/v⌋ to z and overwrites u with the remainder r. z must be large enough to hold ⌊u/v⌋. It uses temps[depth] (allocating if needed) as a temporary live across the recursive call. It also uses tmp, but not live across the recursion.
func (z nat) divRecursiveStep(u nat, v nat, depth int, tmp *nat, temps []*nat)divW returns q, r such that q = ⌊x/y⌋ and r = x%y = x - q·y. It uses z as the storage for q. Note that y is a single digit (Word), not a big number.
func (z nat) divW(x nat, y Word) (q nat, r Word)divWVW overwrites z with ⌊x/y⌋, returning the remainder r. The caller must ensure that len(z) = len(x).
func divWVW(z []Word, xn Word, x []Word, y Word) (r Word)q = ( x1 << _W + x0 - r)/y. m = floor(( _B^2 - 1 ) / d - _B). Requiring x1func divWW(x1 Word, x0 Word, y Word, m Word) (q Word, r Word)
construct table of powers of bb*leafSize to use in subdivisions.
func divisors(m int, b Word, ndigits int, bb Word) []divisoreuclidUpdate performs a single step of the Euclidean GCD algorithm if extended is true, it also updates the cosequence Ua, Ub.
func euclidUpdate(A *Int, B *Int, Ua *Int, Ub *Int, q *Int, r *Int, s *Int, t *Int, extended bool)func (z *Int) exp(x *Int, y *Int, m *Int, slow bool) *IntIf m != 0 (i.e., len(m) != 0), expNN sets z to x**y mod m; otherwise it sets z to x**y. The result is the value of z.
func (z nat) expNN(x nat, y nat, m nat, slow bool) natexpNNMontgomery calculates x**y mod m using a fixed, 4-bit window. Uses Montgomery representation.
func (z nat) expNNMontgomery(x nat, y nat, m nat) natexpNNMontgomeryEven calculates x**y mod m where m = m1 × m2 for m1 = 2ⁿ and m2 odd. It uses two recursive calls to expNN for x**y mod m1 and x**y mod m2 and then uses the Chinese Remainder Theorem to combine the results. The recursive call using m1 will use expNNWindowed, while the recursive call using m2 will use expNNMontgomery. For more details, see Ç. K. Koç, “Montgomery Reduction with Even Modulus”, IEE Proceedings: Computers and Digital Techniques, 141(5) 314-316, September 1994. http://www.people.vcu.edu/~jwang3/CMSC691/j34monex.pdf
func (z nat) expNNMontgomeryEven(x nat, y nat, m nat) natexpNNWindowed calculates x**y mod m using a fixed, 4-bit window, where m = 2**logM.
func (z nat) expNNWindowed(x nat, y nat, logM uint) natfunc (z *Int) expSlow(x *Int, y *Int, m *Int) *IntexpWW computes x**y
func (z nat) expWW(x Word, y Word) natfmtB appends the string of x in the format mantissa "p" exponent with a decimal mantissa and a binary exponent, or "0" if x is zero, and returns the extended buffer. The mantissa is normalized such that is uses x.Prec() bits in binary representation. The sign of x is ignored, and x must not be an Inf. (The caller handles Inf before invoking fmtB.)
func (x *Float) fmtB(buf []byte) []byte%e: d.ddddde±dd
func fmtE(buf []byte, fmt byte, prec int, d decimal) []byte%f: ddddddd.ddddd
func fmtF(buf []byte, prec int, d decimal) []bytefmtP appends the string of x in the format "0x." mantissa "p" exponent with a hexadecimal mantissa and a binary exponent, or "0" if x is zero, and returns the extended buffer. The mantissa is normalized such that 0.5 <= 0.mantissa < 1.0. The sign of x is ignored, and x must not be an Inf. (The caller handles Inf before invoking fmtP.)
func (x *Float) fmtP(buf []byte) []bytefmtX appends the string of x in the format "0x1." mantissa "p" exponent with a hexadecimal mantissa and a binary exponent, or "0x0p0" if x is zero, and returns the extended buffer. A non-zero mantissa is normalized such that 1.0 <= mantissa < 2.0. The sign of x is ignored, and x must not be an Inf. (The caller handles Inf before invoking fmtX.)
func (x *Float) fmtX(buf []byte, prec int) []bytefnorm normalizes mantissa m by shifting it to the left such that the msb of the most-significant word (msw) is 1. It returns the shift amount. It assumes that len(m) != 0.
func fnorm(m nat) int64getNat returns a *nat of len n. The contents may not be zero. The pool holds *nat to avoid allocation when converting to interface{}.
func getNat(n int) *natgreaterThan reports whether the two digit numbers x1 x2 > y1 y2. TODO(rsc): In contradiction to most of this file, x1 is the high digit and x2 is the low digit. This should be fixed.
func greaterThan(x1 Word, x2 Word, y1 Word, y2 Word) boolInit initializes x to the decimal representation of m << shift (for shift >= 0), or m >> -shift (for shift < 0).
func (x *decimal) init(m nat, shift int)isPow2 returns i, true when x == 2**i and 0, false otherwise.
func (x nat) isPow2() (uint, bool)itoa is like utoa but it prepends a '-' if neg && x != 0.
func (x nat) itoa(neg bool, base int) []bytekaratsuba multiplies x and y and leaves the result in z. Both x and y must have the same length n and n must be a power of 2. The result vector z must have len(z) >= 6*n. The (non-normalized) result is placed in z[0 : 2*n].
func karatsuba(z nat, x nat, y nat)Fast version of z[0:n+n>>1].add(z[0:n+n>>1], x[0:n]) w/o bounds checks. Factored out for readability - do not use outside karatsuba.
func karatsubaAdd(z nat, x nat, n int)karatsubaLen computes an approximation to the maximum k <= n such that k = p<= 0. Thus, the result is the largest number that can be divided repeatedly by 2 before becoming about the value of threshold.
func karatsubaLen(n int, threshold int) intkaratsubaSqr squares x and leaves the result in z. len(x) must be a power of 2 and len(z) >= 6*len(x). The (non-normalized) result is placed in z[0 : 2*len(x)]. The algorithm and the layout of z are the same as for karatsuba.
func karatsubaSqr(z nat, x nat)Like karatsubaAdd, but does subtract.
func karatsubaSub(z nat, x nat, n int)lehmerGCD sets z to the greatest common divisor of a and b, which both must be != 0, and returns z. If x or y are not nil, their values are set such that z = a*x + b*y. See Knuth, The Art of Computer Programming, Vol. 2, Section 4.5.2, Algorithm L. This implementation uses the improved condition by Collins requiring only one quotient and avoiding the possibility of single Word overflow. See Jebelean, "Improving the multiprecision Euclidean algorithm", Design and Implementation of Symbolic Computation Systems, pp 45-58. The cosequences are updated according to Algorithm 10.45 from Cohen et al. "Handbook of Elliptic and Hyperelliptic Curve Cryptography" pp 192.
func (z *Int) lehmerGCD(x *Int, y *Int, a *Int, b *Int) *IntlehmerSimulate attempts to simulate several Euclidean update steps using the leading digits of A and B. It returns u0, u1, v0, v1 such that A and B can be updated as: A = u0*A + v0*B B = u1*A + v1*B Requirements: A >= B and len(B.abs) >= 2 Since we are calculating with full words to avoid overflow, we use 'even' to track the sign of the cosequences. For even iterations: u0, v1 >= 0 && u1, v0 <= 0 For odd iterations: u0, v1 <= 0 && u1, v0 >= 0
func lehmerSimulate(A *Int, B *Int) (u0 Word, u1 Word, v0 Word, v1 Word, even bool)lehmerUpdate updates the inputs A and B such that: A = u0*A + v0*B B = u1*A + v1*B where the signs of u0, u1, v0, v1 are given by even For even == true: u0, v1 >= 0 && u1, v0 <= 0 For even == false: u0, v1 <= 0 && u1, v0 >= 0 q, r, s, t are temporary variables to avoid allocations in the multiplication.
func lehmerUpdate(A *Int, B *Int, q *Int, r *Int, s *Int, t *Int, u0 Word, u1 Word, v0 Word, v1 Word, even bool)low32 returns the least significant 32 bits of x.
func low32(x nat) uint32low64 returns the least significant 64 bits of x.
func low64(x nat) uint64func (z nat) make(n int) natfunc makeAcc(above bool) Accuracymarshal implements [Rat.String] returning a slice of bytes. It appends the string representation of x in the form "a/b" (even if b == 1) to buf, and returns the extended buffer.
func (x *Rat) marshal(buf []byte) []bytemaxPow returns (b**n, n) such that b**n is the largest power b**n <= _M. For instance maxPow(10) == (1e19, 19) for 19 decimal digits in a 64bit Word. In other words, at most n digits in base b fit into a Word. TODO(gri) replace this with a table, generated at build time.
func maxPow(b Word) (p Word, n int)func (z nat) modInverse(g nat, n nat) natmodSqrt3Mod4 uses the identity (a^((p+1)/4))^2 mod p == u^(p+1) mod p == u^2 mod p to calculate the square root of any quadratic residue mod p quickly for 3 mod 4 primes.
func (z *Int) modSqrt3Mod4Prime(x *Int, p *Int) *IntmodSqrt5Mod8Prime uses Atkin's observation that 2 is not a square mod p alpha == (2*a)^((p-5)/8) mod p beta == 2*a*alpha^2 mod p is a square root of -1 b == a*alpha*(beta-1) mod p is a square root of a to calculate the square root of any quadratic residue mod p quickly for 5 mod 8 primes.
func (z *Int) modSqrt5Mod8Prime(x *Int, p *Int) *IntmodSqrtTonelliShanks uses the Tonelli-Shanks algorithm to find the square root of a quadratic residue modulo any prime.
func (z *Int) modSqrtTonelliShanks(x *Int, p *Int) *IntmodW returns x % d.
func (x nat) modW(d Word) (r Word)montgomery computes z mod m = x*y*2**(-n*_W) mod m, assuming k = -1/m mod 2**_W. z is used for storing the result which is returned; z must not alias x, y or m. See Gueron, "Efficient Software Implementations of Modular Exponentiation". https://eprint.iacr.org/2011/239.pdf In the terminology of that paper, this is an "Almost Montgomery Multiplication": x and y are required to satisfy 0 <= z < 2**(n*_W) and then the result z is guaranteed to satisfy 0 <= z < 2**(n*_W), but it may not be < m.
func (z nat) montgomery(x nat, y nat, m nat, k Word, n int) natmsb32 returns the 32 most significant bits of x.
func msb32(x nat) uint32msb64 returns the 64 most significant bits of x.
func msb64(x nat) uint64func (z nat) mul(x nat, y nat) natmulAddVWW should be an internal detail, but widely used packages access it using linkname. Notable members of the hall of shame include: - github.com/remyoudompheng/bigfft Do not remove or change the type signature. See go.dev/issue/67401. go:linkname mulAddVWW go:noescape
func mulAddVWW(z []Word, x []Word, y Word, r Word) (c Word)func mulAddVWW(z []Word, x []Word, y Word, r Word) (c Word)func mulAddVWW_g(z []Word, x []Word, y Word, r Word) (c Word)func (z nat) mulAddWW(x nat, y Word, r Word) natz1<<_W + z0 = x*y + c
func mulAddWWW_g(x Word, y Word, c Word) (z1 Word, z0 Word)mulDenom sets z to the denominator product x*y (by taking into account that 0 values for x or y must be interpreted as 1) and returns z.
func mulDenom(z nat, x nat, y nat) natmulRange computes the product of all the unsigned integers in the range [a, b] inclusively. If a > b (empty range), the result is 1.
func (z nat) mulRange(a uint64, b uint64) natz1<<_W + z0 = x*y
func mulWW(x Word, y Word) (z1 Word, z0 Word)newFloat returns a new *Float with space for twice the given precision.
func newFloat(prec2 uint32) *Floatnlz returns the number of leading zeros in x. Wraps bits.LeadingZeros call for convenience.
func nlz(x Word) uintfunc (z nat) norm() natfunc (z *Rat) norm() *Ratfunc (z nat) or(x nat, y nat) natord classifies x and returns: -2 if -Inf == x -1 if -Inf < x < 0 0 if x == 0 (signed or unsigned) +1 if 0 < x < +Inf +2 if x == +Inf
func (x *Float) ord() intpow returns x**n for n > 0, and 1 otherwise.
func pow(x Word, n int) (p Word)pow5 sets z to 5**n and returns z. n must not be negative.
func (z *Float) pow5(n uint64) *FloatprobablyPrimeLucas reports whether n passes the "almost extra strong" Lucas probable prime test, using Baillie-OEIS parameter selection. This corresponds to "AESLPSP" on Jacobsen's tables (link below). The combination of this test and a Miller-Rabin/Fermat test with base 2 gives a Baillie-PSW test. References: Baillie and Wagstaff, "Lucas Pseudoprimes", Mathematics of Computation 35(152), October 1980, pp. 1391-1417, especially page 1401. https://www.ams.org/journals/mcom/1980-35-152/S0025-5718-1980-0583518-6/S0025-5718-1980-0583518-6.pdf Grantham, "Frobenius Pseudoprimes", Mathematics of Computation 70(234), March 2000, pp. 873-891. https://www.ams.org/journals/mcom/2001-70-234/S0025-5718-00-01197-2/S0025-5718-00-01197-2.pdf Baillie, "Extra strong Lucas pseudoprimes", OEIS A217719, https://oeis.org/A217719. Jacobsen, "Pseudoprime Statistics, Tables, and Data", http://ntheory.org/pseudoprimes.html. Nicely, "The Baillie-PSW Primality Test", https://web.archive.org/web/20191121062007/http://www.trnicely.net/misc/bpsw.html. (Note that Nicely's definition of the "extra strong" test gives the wrong Jacobi condition, as pointed out by Jacobsen.) Crandall and Pomerance, Prime Numbers: A Computational Perspective, 2nd ed. Springer, 2005.
func (n nat) probablyPrimeLucas() boolprobablyPrimeMillerRabin reports whether n passes reps rounds of the Miller-Rabin primality test, using pseudo-randomly chosen bases. If force2 is true, one of the rounds is forced to use base 2. See Handbook of Applied Cryptography, p. 139, Algorithm 4.24. The number n is known to be non-zero.
func (n nat) probablyPrimeMillerRabin(reps int, force2 bool) boolfunc putNat(x *nat)quotToFloat32 returns the non-negative float32 value nearest to the quotient a/b, using round-to-even in halfway cases. It does not mutate its arguments. Preconditions: b is non-zero; a and b have no common factors.
func quotToFloat32(a nat, b nat) (f float32, exact bool)quotToFloat64 returns the non-negative float64 value nearest to the quotient a/b, using round-to-even in halfway cases. It does not mutate its arguments. Preconditions: b is non-zero; a and b have no common factors.
func quotToFloat64(a nat, b nat) (f float64, exact bool)random creates a random integer in [0..limit), using the space in z if possible. n is the bit length of limit.
func (z nat) random(rand *rand.Rand, limit nat, n int) natfunc ratTok(ch rune) boolreciprocalWord return the reciprocal of the divisor. rec = floor(( _B^2 - 1 ) / u - _B). u = d1 << nlz(d1).
func reciprocalWord(d1 Word) Wordrem returns r such that r = u%v. It uses z as the storage for r.
func (z nat) rem(u nat, v nat) (r nat)round rounds z according to z.mode to z.prec bits and sets z.acc accordingly. sbit must be 0 or 1 and summarizes any "sticky bit" information one might have before calling round. z's mantissa must be normalized (with the msb set) or empty. CAUTION: The rounding modes [ToNegativeInf], [ToPositiveInf] are affected by the sign of z. For correct rounding, the sign of z must be set correctly before calling round.
func (z *Float) round(sbit uint)round sets x to (at most) n mantissa digits by rounding it to the nearest even value with n (or fever) mantissa digits. If n < 0, x remains unchanged.
func (x *decimal) round(n int)func (x *decimal) roundDown(n int)func roundShortest(d *decimal, x *Float)func (x *decimal) roundUp(n int)func same(x nat, y nat) boolscaleDenom sets z to the product x*f. If f == 0 (zero value of denominator), z is set to (a copy of) x.
func (z *Int) scaleDenom(x *Int, f nat)scan sets z to the integer value corresponding to the longest possible prefix read from r representing a signed integer number in a given conversion base. It returns z, the actual conversion base used, and an error, if any. In the error case, the value of z is undefined but the returned value is nil. The syntax follows the syntax of integer literals in Go. The base argument must be 0 or a value from 2 through MaxBase. If the base is 0, the string prefix determines the actual conversion base. A prefix of “0b” or “0B” selects base 2; a “0”, “0o”, or “0O” prefix selects base 8, and a “0x” or “0X” prefix selects base 16. Otherwise the selected base is 10.
func (z *Int) scan(r io.ByteScanner, base int) (*Int, int, error)scan is like Parse but reads the longest possible prefix representing a valid floating point number from an io.ByteScanner rather than a string. It serves as the implementation of Parse. It does not recognize ±Inf and does not expect EOF at the end.
func (z *Float) scan(r io.ByteScanner, base int) (f *Float, b int, err error)scan scans the number corresponding to the longest possible prefix from r representing an unsigned number in a given conversion base. scan returns the corresponding natural number res, the actual base b, a digit count, and a read or syntax error err, if any. 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. number = mantissa | prefix pmantissa . prefix = "0" [ "b" | "B" | "o" | "O" | "x" | "X" ] . mantissa = digits "." [ digits ] | digits | "." digits . pmantissa = [ "_" ] digits "." [ digits ] | [ "_" ] digits | "." digits . digits = digit { [ "_" ] digit } . digit = "0" ... "9" | "a" ... "z" | "A" ... "Z" . Unless fracOk is set, the base argument must be 0 or a value between 2 and MaxBase. If fracOk is set, the base argument must be one of 0, 2, 8, 10, or 16. Providing an invalid base argument leads 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. If fracOk is false, a “0” prefix (immediately followed by digits) selects base 8 as well. Otherwise, the selected base is 10 and no prefix is accepted. If fracOk is set, a period followed by a fractional part is permitted. The result value is computed as if there were no period present; and the count value is used to determine the fractional part. 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. A result digit count > 0 corresponds to the number of (non-prefix) digits parsed. A digit count <= 0 indicates the presence of a period (if fracOk is set, only), and -count is the number of fractional digits found. In this case, the actual value of the scanned number is res * b**count.
func (z nat) scan(r io.ByteScanner, base int, fracOk bool) (res nat, b int, count int, err error)scanExponent scans the longest possible prefix of r representing a base 10 (“e”, “E”) or a base 2 (“p”, “P”) exponent, if any. It returns the exponent, the exponent base (10 or 2), or a read or syntax error, if any. If sepOk is set, an underscore character “_” may appear between successive exponent digits; such underscores do not change the value of the exponent. Incorrect placement of underscores is reported as an error if there are no other errors. If sepOk is not set, underscores are not recognized and thus terminate scanning like any other character that is not a valid digit. exponent = ( "e" | "E" | "p" | "P" ) [ sign ] digits . sign = "+" | "-" . digits = digit { [ '_' ] digit } . digit = "0" ... "9" . A base 2 exponent is only permitted if base2ok is set.
func scanExponent(r io.ByteScanner, base2ok bool, sepOk bool) (exp int64, base int, err error)func scanSign(r io.ByteScanner) (neg bool, err error)func (z nat) set(x nat) natfunc (z nat) setBit(x nat, i uint, b uint) natfunc (z *Float) setBits64(neg bool, x uint64) *FloatsetBytes interprets buf as the bytes of a big-endian unsigned integer, sets z to that value, and returns z.
func (z nat) setBytes(buf []byte) natfunc (z *Float) setExpAndRound(exp int64, sbit uint)setFromScanner implements SetString given an io.ByteScanner. For documentation see comments of SetString.
func (z *Int) setFromScanner(r io.ByteScanner, base int) (*Int, bool)func (z nat) setUint64(x uint64) natfunc (z nat) setWord(x Word) natz = x << s
func (z nat) shl(x nat, s uint) natfunc shlVU(z []Word, x []Word, s uint) (c Word)shlVU should be an internal detail, but widely used packages access it using linkname. Notable members of the hall of shame include: - github.com/remyoudompheng/bigfft Do not remove or change the type signature. See go.dev/issue/67401. go:linkname shlVU go:noescape
func shlVU(z []Word, x []Word, s uint) (c Word)func shlVU_g(z []Word, x []Word, s uint) (c Word)shouldRoundUp reports if x should be rounded up if shortened to n digits. n must be a valid index for x.mant.
func shouldRoundUp(x *decimal, n int) boolshr implements x >> s, for s <= maxShift.
func shr(x *decimal, s uint)z = x >> s
func (z nat) shr(x nat, s uint) natfunc shrVU(z []Word, x []Word, s uint) (c Word)go:noescape
func shrVU(z []Word, x []Word, s uint) (c Word)func shrVU_g(z []Word, x []Word, s uint) (c Word)z = x*x
func (z nat) sqr(x nat) natsqrt sets z = ⌊√x⌋
func (z nat) sqrt(x nat) natCompute √x (to z.prec precision) by solving 1/t² - x = 0 for t (using Newton's method), and then inverting.
func (z *Float) sqrtInverse(x *Float)sticky returns 1 if there's a 1 bit within the i least significant bits, otherwise it returns 0.
func (x nat) sticky(i uint) uintfunc (z nat) sub(x nat, y nat) natsubMod2N returns z = (x - y) mod 2ⁿ.
func (z nat) subMod2N(x nat, y nat, n uint) natsubVV should be an internal detail, but widely used packages access it using linkname. Notable members of the hall of shame include: - github.com/remyoudompheng/bigfft Do not remove or change the type signature. See go.dev/issue/67401. go:linkname subVV go:noescape
func subVV(z []Word, x []Word, y []Word) (c Word)func subVV(z []Word, x []Word, y []Word) (c Word)func subVV_check(z []Word, x []Word, y []Word) (c Word)The resulting carry c is either 0 or 1.
func subVV_g(z []Word, x []Word, y []Word) (c Word)func subVV_novec(z []Word, x []Word, y []Word) (c Word)func subVV_vec(z []Word, x []Word, y []Word) (c Word)func subVW(z []Word, x []Word, y Word) (c Word)subVW should be an internal detail, but widely used packages access it using linkname. Notable members of the hall of shame include: - github.com/remyoudompheng/bigfft Do not remove or change the type signature. See go.dev/issue/67401. go:linkname subVW go:noescape
func subVW(z []Word, x []Word, y Word) (c Word)func subVW_g(z []Word, x []Word, y Word) (c Word)subVWlarge is to subVW as addVWlarge is to addVW.
func subVWlarge(z []Word, x []Word, y Word) (c Word)func three() *FloattrailingZeroBits returns the number of consecutive least significant zero bits of x.
func (x nat) trailingZeroBits() uinttrim cuts off any trailing zeros from x's mantissa; they are meaningless for the value of x.
func trim(x *decimal)trunc returns z = x mod 2ⁿ.
func (z nat) trunc(x nat, n uint) natz = x + y, ignoring signs of x and y for the addition but using the sign of z for rounding the result. x and y must have a non-empty mantissa and valid exponent.
func (z *Float) uadd(x *Float, y *Float)ucmp returns -1, 0, or +1, depending on whether |x| < |y|, |x| == |y|, or |x| > |y|. x and y must have a non-empty mantissa and valid exponent.
func (x *Float) ucmp(y *Float) intfunc umax32(x uint32, y uint32) uint32z = x * y, ignoring signs of x and y for the multiplication but using the sign of z for rounding the result. x and y must have a non-empty mantissa and valid exponent.
func (z *Float) umul(x *Float, y *Float)z = x / y, ignoring signs of x and y for the division but using the sign of z for rounding the result. x and y must have a non-empty mantissa and valid exponent.
func (z *Float) uquo(x *Float, y *Float)z = x - y for |x| > |y|, ignoring signs of x and y for the subtraction but using the sign of z for rounding the result. x and y must have a non-empty mantissa and valid exponent.
func (z *Float) usub(x *Float, y *Float)utoa converts x to an ASCII representation in the given base; base must be between 2 and MaxBase, inclusive.
func (x nat) utoa(base int) []bytedebugging support
func (x *Float) validate()func (x *Float) validate0() stringfunc validateBinaryOperands(x *Float, y *Float)write count copies of text to s.
func writeMultiple(s fmt.State, text string, count int)func (z nat) xor(x nat, y nat) natGenerated with Arrow