const (
// MaxExponent is the highest exponent supported. Exponents near this range will
// perform very slowly (many seconds per operation).
MaxExponent = 100000
// MinExponent is the lowest exponent supported with the same limitations as
// MaxExponent.
MinExponent = -MaxExponent
)
const (
// DefaultTraps is the default trap set used by BaseContext.
DefaultTraps = SystemOverflow |
SystemUnderflow |
Overflow |
Underflow |
Subnormal |
DivisionUndefined |
DivisionByZero |
DivisionImpossible |
InvalidOperation
)
BaseContext is a useful default Context. Should not be mutated.
var BaseContext = Context{ Precision: 0, MaxExponent: MaxExponent, MinExponent: MinExponent, Traps: DefaultTraps, }
func NewFromString(s string) (*Decimal, Condition, error)
NewFromString creates a new decimal from s. It has no restrictions on exponents or precision.
func NumDigits(b *BigInt) int64
NumDigits returns the number of decimal digits of b.
BigInt is a wrapper around big.Int. It minimizes memory allocation by using an inline array to back the big.Int's variable-length "nat" slice when the integer's value is sufficiently small. The zero value is ready to use.
type BigInt struct {
// contains filtered or unexported fields
}
func NewBigInt(x int64) *BigInt
NewBigInt allocates and returns a new BigInt set to x.
NOTE: BigInt jumps through hoops to avoid escaping to the heap. As such, most users of BigInt should not need this function. They should instead declare a zero-valued BigInt directly on the stack and interact with references to this stack-allocated value. Recall that the zero-valued BigInt is ready to use.
func (z *BigInt) Abs(x *BigInt) *BigInt
Abs calls (big.Int).Abs.
func (z *BigInt) Add(x, y *BigInt) *BigInt
Add calls (big.Int).Add.
func (z *BigInt) And(x, y *BigInt) *BigInt
And calls (big.Int).And.
func (z *BigInt) AndNot(x, y *BigInt) *BigInt
AndNot calls (big.Int).AndNot.
func (z *BigInt) Append(buf []byte, base int) []byte
Append calls (big.Int).Append.
func (z *BigInt) Binomial(n, k int64) *BigInt
Binomial calls (big.Int).Binomial.
func (z *BigInt) Bit(i int) uint
Bit calls (big.Int).Bit.
func (z *BigInt) BitLen() int
BitLen calls (big.Int).BitLen.
func (z *BigInt) Bits() []big.Word
Bits calls (big.Int).Bits.
func (z *BigInt) Bytes() []byte
Bytes calls (big.Int).Bytes.
func (z *BigInt) Cmp(y *BigInt) (r int)
Cmp calls (big.Int).Cmp.
func (z *BigInt) CmpAbs(y *BigInt) (r int)
CmpAbs calls (big.Int).CmpAbs.
func (z *BigInt) Div(x, y *BigInt) *BigInt
Div calls (big.Int).Div.
func (z *BigInt) DivMod(x, y, m *BigInt) (*BigInt, *BigInt)
DivMod calls (big.Int).DivMod.
func (z *BigInt) Exp(x, y, m *BigInt) *BigInt
Exp calls (big.Int).Exp.
func (z *BigInt) FillBytes(buf []byte) []byte
FillBytes calls (big.Int).FillBytes.
func (z *BigInt) Format(s fmt.State, ch rune)
Format calls (big.Int).Format.
func (z *BigInt) GCD(x, y, a, b *BigInt) *BigInt
GCD calls (big.Int).GCD.
func (z *BigInt) GobDecode(buf []byte) error
GobDecode calls (big.Int).GobDecode.
func (z *BigInt) GobEncode() ([]byte, error)
GobEncode calls (big.Int).GobEncode.
func (z *BigInt) Int64() int64
Int64 calls (big.Int).Int64.
func (z *BigInt) IsInt64() bool
IsInt64 calls (big.Int).IsInt64.
func (z *BigInt) IsUint64() bool
IsUint64 calls (big.Int).IsUint64.
func (z *BigInt) Lsh(x *BigInt, n uint) *BigInt
Lsh calls (big.Int).Lsh.
func (z *BigInt) MarshalJSON() ([]byte, error)
MarshalJSON calls (big.Int).MarshalJSON.
func (z *BigInt) MarshalText() (text []byte, err error)
MarshalText calls (big.Int).MarshalText.
func (z *BigInt) MathBigInt() *big.Int
MathBigInt returns the math/big.Int representation of z.
func (z *BigInt) Mod(x, y *BigInt) *BigInt
Mod calls (big.Int).Mod.
func (z *BigInt) ModInverse(g, n *BigInt) *BigInt
ModInverse calls (big.Int).ModInverse.
func (z *BigInt) ModSqrt(x, p *BigInt) *BigInt
ModSqrt calls (big.Int).ModSqrt.
func (z *BigInt) Mul(x, y *BigInt) *BigInt
Mul calls (big.Int).Mul.
func (z *BigInt) MulRange(x, y int64) *BigInt
MulRange calls (big.Int).MulRange.
func (z *BigInt) Neg(x *BigInt) *BigInt
Neg calls (big.Int).Neg.
func (z *BigInt) Not(x *BigInt) *BigInt
Not calls (big.Int).Not.
func (z *BigInt) Or(x, y *BigInt) *BigInt
Or calls (big.Int).Or.
func (z *BigInt) ProbablyPrime(n int) bool
ProbablyPrime calls (big.Int).ProbablyPrime.
func (z *BigInt) Quo(x, y *BigInt) *BigInt
Quo calls (big.Int).Quo.
func (z *BigInt) QuoRem(x, y, r *BigInt) (*BigInt, *BigInt)
QuoRem calls (big.Int).QuoRem.
func (z *BigInt) Rand(rnd *rand.Rand, n *BigInt) *BigInt
Rand calls (big.Int).Rand.
func (z *BigInt) Rem(x, y *BigInt) *BigInt
Rem calls (big.Int).Rem.
func (z *BigInt) Rsh(x *BigInt, n uint) *BigInt
Rsh calls (big.Int).Rsh.
func (z *BigInt) Scan(s fmt.ScanState, ch rune) error
Scan calls (big.Int).Scan.
func (z *BigInt) Set(x *BigInt) *BigInt
Set calls (big.Int).Set.
func (z *BigInt) SetBit(x *BigInt, i int, b uint) *BigInt
SetBit calls (big.Int).SetBit.
func (z *BigInt) SetBits(abs []big.Word) *BigInt
SetBits calls (big.Int).SetBits.
func (z *BigInt) SetBytes(buf []byte) *BigInt
SetBytes calls (big.Int).SetBytes.
func (z *BigInt) SetInt64(x int64) *BigInt
SetInt64 calls (big.Int).SetInt64.
func (z *BigInt) SetMathBigInt(x *big.Int) *BigInt
SetMathBigInt sets z to x and returns z.
func (z *BigInt) SetString(s string, base int) (*BigInt, bool)
SetString calls (big.Int).SetString.
func (z *BigInt) SetUint64(x uint64) *BigInt
SetUint64 calls (big.Int).SetUint64.
func (z *BigInt) Sign() int
Sign calls (big.Int).Sign.
func (z *BigInt) Size() uintptr
Size returns the total memory footprint of z in bytes.
func (z *BigInt) Sqrt(x *BigInt) *BigInt
Sqrt calls (big.Int).Sqrt.
func (z *BigInt) String() string
String calls (big.Int).String.
func (z *BigInt) Sub(x, y *BigInt) *BigInt
Sub calls (big.Int).Sub.
func (z *BigInt) Text(base int) string
Text calls (big.Int).Text.
func (z *BigInt) TrailingZeroBits() uint
TrailingZeroBits calls (big.Int).TrailingZeroBits.
func (z *BigInt) Uint64() uint64
Uint64 calls (big.Int).Uint64.
func (z *BigInt) UnmarshalJSON(text []byte) error
UnmarshalJSON calls (big.Int).UnmarshalJSON.
func (z *BigInt) UnmarshalText(text []byte) error
UnmarshalText calls (big.Int).UnmarshalText.
func (z *BigInt) Xor(x, y *BigInt) *BigInt
Xor calls (big.Int).Xor.
Condition holds condition flags.
type Condition uint32
const (
// SystemOverflow is raised when an exponent is greater than MaxExponent.
SystemOverflow Condition = 1 << iota
// SystemUnderflow is raised when an exponent is less than MinExponent.
SystemUnderflow
// Overflow is raised when the exponent of a result is too large to be
// represented.
Overflow
// Underflow is raised when a result is both subnormal and inexact.
Underflow
// Inexact is raised when a result is not exact (one or more non-zero
// coefficient digits were discarded during rounding).
Inexact
// Subnormal is raised when a result is subnormal (its adjusted exponent is
// less than Emin), before any rounding.
Subnormal
// Rounded is raised when a result has been rounded (that is, some zero or
// non-zero coefficient digits were discarded).
Rounded
// DivisionUndefined is raised when both division operands are 0.
DivisionUndefined
// DivisionByZero is raised when a non-zero dividend is divided by zero.
DivisionByZero
// DivisionImpossible is raised when integer division cannot be exactly
// represented with the given precision.
DivisionImpossible
// InvalidOperation is raised when a result would be undefined or impossible.
InvalidOperation
// Clamped is raised when the exponent of a result has been altered or
// constrained in order to fit the constraints of the Decimal representation.
Clamped
)
func (r Condition) Any() bool
Any returns true if any flag is true.
func (r Condition) Clamped() bool
Clamped returns true if the Clamped flag is set.
func (r Condition) DivisionByZero() bool
DivisionByZero returns true if the DivisionByZero flag is set.
func (r Condition) DivisionImpossible() bool
DivisionImpossible returns true if the DivisionImpossible flag is set.
func (r Condition) DivisionUndefined() bool
DivisionUndefined returns true if the DivisionUndefined flag is set.
func (r Condition) GoError(traps Condition) (Condition, error)
GoError converts r to an error based on the given traps and returns r. Traps are the conditions which will trigger an error result if the corresponding Flag condition occurred.
func (r Condition) Inexact() bool
Inexact returns true if the Inexact flag is set.
func (r Condition) InvalidOperation() bool
InvalidOperation returns true if the InvalidOperation flag is set.
func (r Condition) Overflow() bool
Overflow returns true if the Overflow flag is set.
func (r Condition) Rounded() bool
Rounded returns true if the Rounded flag is set.
func (r Condition) String() string
func (r Condition) Subnormal() bool
Subnormal returns true if the Subnormal flag is set.
func (r Condition) SystemOverflow() bool
SystemOverflow returns true if the SystemOverflow flag is set.
func (r Condition) SystemUnderflow() bool
SystemUnderflow returns true if the SystemUnderflow flag is set.
func (r Condition) Underflow() bool
Underflow returns true if the Underflow flag is set.
Context maintains options for Decimal operations. It can safely be used concurrently, but not modified concurrently. Arguments for any method can safely be used as both result and operand.
type Context struct {
// Precision is the number of places to round during rounding; this is
// effectively the total number of digits (before and after the decimal
// point).
Precision uint32
// MaxExponent specifies the largest effective exponent. The
// effective exponent is the value of the Decimal in scientific notation. That
// is, for 10e2, the effective exponent is 3 (1.0e3). Zero (0) is not a special
// value; it does not disable this check.
MaxExponent int32
// MinExponent is similar to MaxExponent, but for the smallest effective
// exponent.
MinExponent int32
// Traps are the conditions which will trigger an error result if the
// corresponding Flag condition occurred.
Traps Condition
// Rounding specifies the Rounder to use during rounding. RoundHalfUp is used if
// empty or not present in Roundings.
Rounding Rounder
}
▹ Example (Inexact)
▹ Example (Overflow)
func (c *Context) Abs(d, x *Decimal) (Condition, error)
Abs sets d to |x| (the absolute value of x).
func (c *Context) Add(d, x, y *Decimal) (Condition, error)
Add sets d to the sum x+y.
func (c *Context) Cbrt(d, x *Decimal) (Condition, error)
Cbrt sets d to the cube root of x.
func (c *Context) Ceil(d, x *Decimal) (Condition, error)
Ceil sets d to the smallest integer >= x.
func (c *Context) Cmp(d, x, y *Decimal) (Condition, error)
Cmp compares x and y and sets d to:
-1 if x < y 0 if x == y +1 if x > y
This comparison respects the normal rules of special values (like NaN), and does not compare them.
func (c *Context) Exp(d, x *Decimal) (Condition, error)
Exp sets d = e**x.
func (c *Context) Floor(d, x *Decimal) (Condition, error)
Floor sets d to the largest integer <= x.
func (c *Context) Ln(d, x *Decimal) (Condition, error)
Ln sets d to the natural log of x.
func (c *Context) Log10(d, x *Decimal) (Condition, error)
Log10 sets d to the base 10 log of x.
func (c *Context) Mul(d, x, y *Decimal) (Condition, error)
Mul sets d to the product x*y.
func (c *Context) Neg(d, x *Decimal) (Condition, error)
Neg sets d to -x.
func (c *Context) NewFromString(s string) (*Decimal, Condition, error)
NewFromString creates a new decimal from s. The returned Decimal has its exponents restricted by the context and its value rounded if it contains more digits than the context's precision.
func (c *Context) Pow(d, x, y *Decimal) (Condition, error)
Pow sets d = x**y.
func (c *Context) Quantize(d, x *Decimal, exp int32) (Condition, error)
Quantize adjusts and rounds x as necessary so it is represented with exponent exp and stores the result in d.
▹ Example
func (c *Context) Quo(d, x, y *Decimal) (Condition, error)
Quo sets d to the quotient x/y for y != 0. c.Precision must be > 0. If an exact division is required, use a context with high precision and verify it was exact by checking the Inexact flag on the return Condition.
func (c *Context) QuoInteger(d, x, y *Decimal) (Condition, error)
QuoInteger sets d to the integer part of the quotient x/y. If the result cannot fit in d.Precision digits, an error is returned.
func (c *Context) Reduce(d, x *Decimal) (int, Condition, error)
Reduce sets d to x with all trailing zeros removed and returns the number of zeros removed.
func (c *Context) Rem(d, x, y *Decimal) (Condition, error)
Rem sets d to the remainder part of the quotient x/y. If the integer part cannot fit in d.Precision digits, an error is returned.
func (c *Context) Round(d, x *Decimal) (Condition, error)
Round sets d to rounded x, rounded to the precision specified by c. If c has zero precision, no rounding will occur. If c has no Rounding specified, RoundHalfUp is used.
func (c *Context) RoundToIntegralExact(d, x *Decimal) (Condition, error)
RoundToIntegralExact sets d to integral value of x.
▹ Example
func (c *Context) RoundToIntegralValue(d, x *Decimal) (Condition, error)
RoundToIntegralValue sets d to integral value of x. Inexact and Rounded flags are ignored and removed.
func (c *Context) SetString(d *Decimal, s string) (*Decimal, Condition, error)
SetString sets d to s and returns d. The returned Decimal has its exponents restricted by the context and its value rounded if it contains more digits than the context's precision.
func (c *Context) Sqrt(d, x *Decimal) (Condition, error)
Sqrt sets d to the square root of x. Sqrt uses the Babylonian method for computing the square root, which uses O(log p) steps for p digits of precision.
func (c *Context) Sub(d, x, y *Decimal) (Condition, error)
Sub sets d to the difference x-y.
func (c *Context) WithPrecision(p uint32) *Context
WithPrecision returns a copy of c but with the specified precision.
Decimal is an arbitrary-precision decimal. Its value is:
Negative × Coeff × 10**Exponent
Coeff must be positive. If it is negative results may be incorrect and apd may panic.
type Decimal struct {
Form Form
Negative bool
Exponent int32
Coeff BigInt
}
func New(coeff int64, exponent int32) *Decimal
New creates a new decimal with the given coefficient and exponent.
func NewWithBigInt(coeff *BigInt, exponent int32) *Decimal
NewWithBigInt creates a new decimal with the given coefficient and exponent.
func (d *Decimal) Abs(x *Decimal) *Decimal
Abs sets d to |x| and returns d.
func (d *Decimal) Append(buf []byte, fmtString byte) []byte
Append appends to buf the string form of the decimal number d, as generated by d.Text, and returns the extended buffer.
func (d *Decimal) Cmp(x *Decimal) int
Cmp compares d and x and returns:
-1 if d < x 0 if d == x +1 if d > x undefined if d or x are NaN
func (d *Decimal) CmpTotal(x *Decimal) int
CmpTotal compares d and x using their abstract representation rather than their numerical value. A total ordering is defined for all possible abstract representations, as described below. If the first operand is lower in the total order than the second operand then the result is -1, if the operands have the same abstract representation then the result is 0, and if the first operand is higher in the total order than the second operand then the result is 1.
Numbers (representations which are not NaNs) are ordered such that a larger numerical value is higher in the ordering. If two representations have the same numerical value then the exponent is taken into account; larger (more positive) exponents are higher in the ordering.
For example, the following values are ordered from lowest to highest. Note the difference in ordering between 1.2300 and 1.23.
-NaN -NaNSignaling -Infinity -127 -1.00 -1 -0.000 -0 0 1.2300 1.23 1E+9 Infinity NaNSignaling NaN
func (d *Decimal) Compose(form byte, negative bool, coefficient []byte, exponent int32) error
Compose sets the internal decimal value from parts. If the value cannot be represented then an error should be returned.
func (d *Decimal) Decompose(buf []byte) (form byte, negative bool, coefficient []byte, exponent int32)
Decompose returns the internal decimal state into parts. If the provided buf has sufficient capacity, buf may be returned as the coefficient with the value set and length set as appropriate.
func (d *Decimal) Float64() (float64, error)
Float64 returns the float64 representation of x. This conversion may lose data (see strconv.ParseFloat for caveats).
func (d *Decimal) Format(s fmt.State, format rune)
Format implements fmt.Formatter. It accepts many of the regular formats for floating-point numbers ('e', 'E', 'f', 'F', 'g', 'G') as well as 's' and 'v', which are handled like 'G'. Format also supports 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. It does not support precision. See the fmt package for details.
func (d *Decimal) Int64() (int64, error)
Int64 returns the int64 representation of x. If x cannot be represented in an int64, an error is returned.
func (d *Decimal) IsZero() bool
IsZero returns true if d == 0 or -0.
func (d *Decimal) MarshalText() ([]byte, error)
MarshalText implements the encoding.TextMarshaler interface.
func (d *Decimal) Modf(integ, frac *Decimal)
Modf sets integ to the integral part of d and frac to the fractional part such that d = integ+frac. If d is negative, both integ or frac will be either 0 or negative. integ.Exponent will be >= 0; frac.Exponent will be <= 0. Either argument can be nil, preventing it from being set.
func (d *Decimal) Neg(x *Decimal) *Decimal
Neg sets d to -x and returns d.
func (d *Decimal) NumDigits() int64
NumDigits returns the number of decimal digits of d.Coeff.
func (d *Decimal) Reduce(x *Decimal) (*Decimal, int)
Reduce sets d to x with all trailing zeros removed and returns d and the number of zeros removed.
func (d *Decimal) Scan(src interface{}) error
Scan implements the database/sql.Scanner interface. It supports string, []byte, int64, float64.
func (d *Decimal) Set(x *Decimal) *Decimal
Set sets d's fields to the values of x and returns d.
func (d *Decimal) SetFinite(x int64, e int32) *Decimal
SetFinite sets d to x with exponent e and returns d.
func (d *Decimal) SetFloat64(f float64) (*Decimal, error)
SetFloat64 sets d's Coefficient and Exponent to x and returns d. d will hold the exact value of f.
func (d *Decimal) SetInt64(x int64) *Decimal
SetInt64 sets d to x and returns d.
func (d *Decimal) SetString(s string) (*Decimal, Condition, error)
SetString sets d to s and returns d. It has no restrictions on exponents or precision.
func (d *Decimal) Sign() int
Sign returns, if d is Finite:
-1 if d < 0 0 if d == 0 or -0 +1 if d > 0
Otherwise (if d is Infinite or NaN):
-1 if d.Negative == true +1 if d.Negative == false
func (d *Decimal) Size() uintptr
Size returns the total memory footprint of d in bytes.
func (d *Decimal) String() string
String formats x like x.Text('G'). It matches the to-scientific-string conversion of the GDA spec.
func (d *Decimal) Text(format byte) string
Text converts the floating-point number x to a string according to the given format. The format is one of:
'e' -d.dddde±dd, decimal exponent, exponent digits 'E' -d.ddddE±dd, decimal exponent, 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
If format is a different character, Text returns a "%" followed by the unrecognized.Format character. The 'f' format has the possibility of displaying precision that is not present in the Decimal when it appends zeros (the 'g' format avoids the use of 'f' in this case). All other formats always show the exact precision of the Decimal.
func (d *Decimal) UnmarshalText(b []byte) error
UnmarshalText implements the encoding.TextUnmarshaler interface.
func (d Decimal) Value() (driver.Value, error)
Value implements the database/sql/driver.Valuer interface. It converts d to a string.
ErrDecimal performs operations on decimals and collects errors during operations. If an error is already set, the operation is skipped. Designed to be used for many operations in a row, with a single error check at the end.
type ErrDecimal struct {
Ctx *Context
// Flags are the accumulated flags from operations.
Flags Condition
// contains filtered or unexported fields
}
▹ Example
func MakeErrDecimal(c *Context) ErrDecimal
MakeErrDecimal creates a ErrDecimal with given context.
func (e *ErrDecimal) Abs(d, x *Decimal) *Decimal
Abs performs e.Ctx.Abs(d, x) and returns d.
func (e *ErrDecimal) Add(d, x, y *Decimal) *Decimal
Add performs e.Ctx.Add(d, x, y) and returns d.
func (e *ErrDecimal) Ceil(d, x *Decimal) *Decimal
Ceil performs e.Ctx.Ceil(d, x) and returns d.
func (e *ErrDecimal) Err() error
Err returns the first error encountered or the context's trap error if present.
func (e *ErrDecimal) Exp(d, x *Decimal) *Decimal
Exp performs e.Ctx.Exp(d, x) and returns d.
func (e *ErrDecimal) Floor(d, x *Decimal) *Decimal
Floor performs e.Ctx.Floor(d, x) and returns d.
func (e *ErrDecimal) Int64(d *Decimal) int64
Int64 returns 0 if err is set. Otherwise returns d.Int64().
func (e *ErrDecimal) Ln(d, x *Decimal) *Decimal
Ln performs e.Ctx.Ln(d, x) and returns d.
func (e *ErrDecimal) Log10(d, x *Decimal) *Decimal
Log10 performs d.Log10(x) and returns d.
func (e *ErrDecimal) Mul(d, x, y *Decimal) *Decimal
Mul performs e.Ctx.Mul(d, x, y) and returns d.
func (e *ErrDecimal) Neg(d, x *Decimal) *Decimal
Neg performs e.Ctx.Neg(d, x) and returns d.
func (e *ErrDecimal) Pow(d, x, y *Decimal) *Decimal
Pow performs e.Ctx.Pow(d, x, y) and returns d.
func (e *ErrDecimal) Quantize(d, v *Decimal, exp int32) *Decimal
Quantize performs e.Ctx.Quantize(d, v, exp) and returns d.
func (e *ErrDecimal) Quo(d, x, y *Decimal) *Decimal
Quo performs e.Ctx.Quo(d, x, y) and returns d.
func (e *ErrDecimal) QuoInteger(d, x, y *Decimal) *Decimal
QuoInteger performs e.Ctx.QuoInteger(d, x, y) and returns d.
func (e *ErrDecimal) Reduce(d, x *Decimal) (int, *Decimal)
Reduce performs e.Ctx.Reduce(d, x) and returns the number of zeros removed and d.
func (e *ErrDecimal) Rem(d, x, y *Decimal) *Decimal
Rem performs e.Ctx.Rem(d, x, y) and returns d.
func (e *ErrDecimal) Round(d, x *Decimal) *Decimal
Round performs e.Ctx.Round(d, x) and returns d.
func (e *ErrDecimal) RoundToIntegralExact(d, x *Decimal) *Decimal
RoundToIntegralExact performs e.Ctx.RoundToIntegralExact(d, x) and returns d.
func (e *ErrDecimal) RoundToIntegralValue(d, x *Decimal) *Decimal
RoundToIntegralValue performs e.Ctx.RoundToIntegralValue(d, x) and returns d.
func (e *ErrDecimal) Sqrt(d, x *Decimal) *Decimal
Sqrt performs e.Ctx.Sqrt(d, x) and returns d.
func (e *ErrDecimal) Sub(d, x, y *Decimal) *Decimal
Sub performs e.Ctx.Sub(d, x, y) and returns d.
Form specifies the form of a Decimal.
type Form int8
const (
// Finite is the finite form.
Finite Form = iota
// Infinite is the infinite form.
Infinite
// NaNSignaling is the signaling NaN form. It will always raise the
// InvalidOperation condition during an operation.
NaNSignaling
// NaN is the NaN form.
NaN
)
func (i Form) String() string
NullDecimal represents a string that may be null. NullDecimal implements the database/sql.Scanner interface so it can be used as a scan destination:
var d NullDecimal
err := db.QueryRow("SELECT num FROM foo WHERE id=?", id).Scan(&d)
...
if d.Valid {
// use d.Decimal
} else {
// NULL value
}
type NullDecimal struct {
Decimal Decimal
Valid bool // Valid is true if Decimal is not NULL
}
func (nd *NullDecimal) Scan(value interface{}) error
Scan implements the database/sql.Scanner interface.
func (nd NullDecimal) Value() (driver.Value, error)
Value implements the database/sql/driver.Valuer interface.
Rounder specifies the behavior of rounding.
type Rounder string
const (
// RoundDown rounds toward 0; truncate.
RoundDown Rounder = "down"
// RoundHalfUp rounds up if the digits are >= 0.5.
RoundHalfUp Rounder = "half_up"
// RoundHalfEven rounds up if the digits are > 0.5. If the digits are equal
// to 0.5, it rounds up if the previous digit is odd, always producing an
// even digit.
RoundHalfEven Rounder = "half_even"
// RoundCeiling towards +Inf: rounds up if digits are > 0 and the number
// is positive.
RoundCeiling Rounder = "ceiling"
// RoundFloor towards -Inf: rounds up if digits are > 0 and the number
// is negative.
RoundFloor Rounder = "floor"
// RoundHalfDown rounds up if the digits are > 0.5.
RoundHalfDown Rounder = "half_down"
// RoundUp rounds away from 0.
RoundUp Rounder = "up"
// Round05Up rounds zero or five away from 0; same as round-up, except that
// rounding up only occurs if the digit to be rounded up is 0 or 5.
Round05Up Rounder = "05up"
)
func (r Rounder) Round(c *Context, d, x *Decimal, disableIfPrecisionZero bool) Condition
Round sets d to rounded x.
func (r Rounder) ShouldAddOne(result *BigInt, neg bool, half int) bool
ShouldAddOne returns true if 1 should be added to the absolute value of a number being rounded. result is the result to which the 1 would be added. neg is true if the number is negative. half is -1 if the discarded digits are < 0.5, 0 if = 0.5, or 1 if > 0.5.