| // Copyright 2017 The Go Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style |
| // license that can be found in the LICENSE file. |
| |
| //go:generate stringer -type RoundingMode |
| |
| package number |
| |
| import ( |
| "math" |
| "strconv" |
| ) |
| |
| // RoundingMode determines how a number is rounded to the desired precision. |
| type RoundingMode byte |
| |
| const ( |
| ToNearestEven RoundingMode = iota // towards the nearest integer, or towards an even number if equidistant. |
| ToNearestZero // towards the nearest integer, or towards zero if equidistant. |
| ToNearestAway // towards the nearest integer, or away from zero if equidistant. |
| ToPositiveInf // towards infinity |
| ToNegativeInf // towards negative infinity |
| ToZero // towards zero |
| AwayFromZero // away from zero |
| numModes |
| ) |
| |
| const maxIntDigits = 20 |
| |
| // A Decimal represents a floating point number in decimal format. |
| // Digits represents a number [0, 1.0), and the absolute value represented by |
| // Decimal is Digits * 10^Exp. Leading and trailing zeros may be omitted and Exp |
| // may point outside a valid position in Digits. |
| // |
| // Examples: |
| // |
| // Number Decimal |
| // 12345 Digits: [1, 2, 3, 4, 5], Exp: 5 |
| // 12.345 Digits: [1, 2, 3, 4, 5], Exp: 2 |
| // 12000 Digits: [1, 2], Exp: 5 |
| // 12000.00 Digits: [1, 2], Exp: 5 |
| // 0.00123 Digits: [1, 2, 3], Exp: -2 |
| // 0 Digits: [], Exp: 0 |
| type Decimal struct { |
| digits |
| |
| buf [maxIntDigits]byte |
| } |
| |
| type digits struct { |
| Digits []byte // mantissa digits, big-endian |
| Exp int32 // exponent |
| Neg bool |
| Inf bool // Takes precedence over Digits and Exp. |
| NaN bool // Takes precedence over Inf. |
| } |
| |
| // Digits represents a floating point number represented in digits of the |
| // base in which a number is to be displayed. It is similar to Decimal, but |
| // keeps track of trailing fraction zeros and the comma placement for |
| // engineering notation. Digits must have at least one digit. |
| // |
| // Examples: |
| // |
| // Number Decimal |
| // decimal |
| // 12345 Digits: [1, 2, 3, 4, 5], Exp: 5 End: 5 |
| // 12.345 Digits: [1, 2, 3, 4, 5], Exp: 2 End: 5 |
| // 12000 Digits: [1, 2], Exp: 5 End: 5 |
| // 12000.00 Digits: [1, 2], Exp: 5 End: 7 |
| // 0.00123 Digits: [1, 2, 3], Exp: -2 End: 3 |
| // 0 Digits: [], Exp: 0 End: 1 |
| // scientific (actual exp is Exp - Comma) |
| // 0e0 Digits: [0], Exp: 1, End: 1, Comma: 1 |
| // .0e0 Digits: [0], Exp: 0, End: 1, Comma: 0 |
| // 0.0e0 Digits: [0], Exp: 1, End: 2, Comma: 1 |
| // 1.23e4 Digits: [1, 2, 3], Exp: 5, End: 3, Comma: 1 |
| // .123e5 Digits: [1, 2, 3], Exp: 5, End: 3, Comma: 0 |
| // engineering |
| // 12.3e3 Digits: [1, 2, 3], Exp: 5, End: 3, Comma: 2 |
| type Digits struct { |
| digits |
| // End indicates the end position of the number. |
| End int32 // For decimals Exp <= End. For scientific len(Digits) <= End. |
| // Comma is used for the comma position for scientific (always 0 or 1) and |
| // engineering notation (always 0, 1, 2, or 3). |
| Comma uint8 |
| // IsScientific indicates whether this number is to be rendered as a |
| // scientific number. |
| IsScientific bool |
| } |
| |
| func (d *Digits) NumFracDigits() int { |
| if d.Exp >= d.End { |
| return 0 |
| } |
| return int(d.End - d.Exp) |
| } |
| |
| // normalize returns a new Decimal with leading and trailing zeros removed. |
| func (d *Decimal) normalize() (n Decimal) { |
| n = *d |
| b := n.Digits |
| // Strip leading zeros. Resulting number of digits is significant digits. |
| for len(b) > 0 && b[0] == 0 { |
| b = b[1:] |
| n.Exp-- |
| } |
| // Strip trailing zeros |
| for len(b) > 0 && b[len(b)-1] == 0 { |
| b = b[:len(b)-1] |
| } |
| if len(b) == 0 { |
| n.Exp = 0 |
| } |
| n.Digits = b |
| return n |
| } |
| |
| func (d *Decimal) clear() { |
| b := d.Digits |
| if b == nil { |
| b = d.buf[:0] |
| } |
| *d = Decimal{} |
| d.Digits = b[:0] |
| } |
| |
| func (x *Decimal) String() string { |
| if x.NaN { |
| return "NaN" |
| } |
| var buf []byte |
| if x.Neg { |
| buf = append(buf, '-') |
| } |
| if x.Inf { |
| buf = append(buf, "Inf"...) |
| return string(buf) |
| } |
| switch { |
| case len(x.Digits) == 0: |
| buf = append(buf, '0') |
| case x.Exp <= 0: |
| // 0.00ddd |
| buf = append(buf, "0."...) |
| buf = appendZeros(buf, -int(x.Exp)) |
| buf = appendDigits(buf, x.Digits) |
| |
| case /* 0 < */ int(x.Exp) < len(x.Digits): |
| // dd.ddd |
| buf = appendDigits(buf, x.Digits[:x.Exp]) |
| buf = append(buf, '.') |
| buf = appendDigits(buf, x.Digits[x.Exp:]) |
| |
| default: // len(x.Digits) <= x.Exp |
| // ddd00 |
| buf = appendDigits(buf, x.Digits) |
| buf = appendZeros(buf, int(x.Exp)-len(x.Digits)) |
| } |
| return string(buf) |
| } |
| |
| func appendDigits(buf []byte, digits []byte) []byte { |
| for _, c := range digits { |
| buf = append(buf, c+'0') |
| } |
| return buf |
| } |
| |
| // appendZeros appends n 0 digits to buf and returns buf. |
| func appendZeros(buf []byte, n int) []byte { |
| for ; n > 0; n-- { |
| buf = append(buf, '0') |
| } |
| return buf |
| } |
| |
| func (d *digits) round(mode RoundingMode, n int) { |
| if n >= len(d.Digits) { |
| return |
| } |
| // Make rounding decision: The result mantissa is truncated ("rounded down") |
| // by default. Decide if we need to increment, or "round up", the (unsigned) |
| // mantissa. |
| inc := false |
| switch mode { |
| case ToNegativeInf: |
| inc = d.Neg |
| case ToPositiveInf: |
| inc = !d.Neg |
| case ToZero: |
| // nothing to do |
| case AwayFromZero: |
| inc = true |
| case ToNearestEven: |
| inc = d.Digits[n] > 5 || d.Digits[n] == 5 && |
| (len(d.Digits) > n+1 || n == 0 || d.Digits[n-1]&1 != 0) |
| case ToNearestAway: |
| inc = d.Digits[n] >= 5 |
| case ToNearestZero: |
| inc = d.Digits[n] > 5 || d.Digits[n] == 5 && len(d.Digits) > n+1 |
| default: |
| panic("unreachable") |
| } |
| if inc { |
| d.roundUp(n) |
| } else { |
| d.roundDown(n) |
| } |
| } |
| |
| // roundFloat rounds a floating point number. |
| func (r RoundingMode) roundFloat(x float64) float64 { |
| // Make rounding decision: The result mantissa is truncated ("rounded down") |
| // by default. Decide if we need to increment, or "round up", the (unsigned) |
| // mantissa. |
| abs := x |
| if x < 0 { |
| abs = -x |
| } |
| i, f := math.Modf(abs) |
| if f == 0.0 { |
| return x |
| } |
| inc := false |
| switch r { |
| case ToNegativeInf: |
| inc = x < 0 |
| case ToPositiveInf: |
| inc = x >= 0 |
| case ToZero: |
| // nothing to do |
| case AwayFromZero: |
| inc = true |
| case ToNearestEven: |
| // TODO: check overflow |
| inc = f > 0.5 || f == 0.5 && int64(i)&1 != 0 |
| case ToNearestAway: |
| inc = f >= 0.5 |
| case ToNearestZero: |
| inc = f > 0.5 |
| default: |
| panic("unreachable") |
| } |
| if inc { |
| i += 1 |
| } |
| if abs != x { |
| i = -i |
| } |
| return i |
| } |
| |
| func (x *digits) roundUp(n int) { |
| if n < 0 || n >= len(x.Digits) { |
| return // nothing to do |
| } |
| // find first digit < 9 |
| for n > 0 && x.Digits[n-1] >= 9 { |
| n-- |
| } |
| |
| if n == 0 { |
| // all digits are 9s => round up to 1 and update exponent |
| x.Digits[0] = 1 // ok since len(x.Digits) > n |
| x.Digits = x.Digits[:1] |
| x.Exp++ |
| return |
| } |
| x.Digits[n-1]++ |
| x.Digits = x.Digits[:n] |
| // x already trimmed |
| } |
| |
| func (x *digits) roundDown(n int) { |
| if n < 0 || n >= len(x.Digits) { |
| return // nothing to do |
| } |
| x.Digits = x.Digits[:n] |
| trim(x) |
| } |
| |
| // trim cuts off any trailing zeros from x's mantissa; |
| // they are meaningless for the value of x. |
| func trim(x *digits) { |
| i := len(x.Digits) |
| for i > 0 && x.Digits[i-1] == 0 { |
| i-- |
| } |
| x.Digits = x.Digits[:i] |
| if i == 0 { |
| x.Exp = 0 |
| } |
| } |
| |
| // A Converter converts a number into decimals according to the given rounding |
| // criteria. |
| type Converter interface { |
| Convert(d *Decimal, r RoundingContext) |
| } |
| |
| const ( |
| signed = true |
| unsigned = false |
| ) |
| |
| // Convert converts the given number to the decimal representation using the |
| // supplied RoundingContext. |
| func (d *Decimal) Convert(r RoundingContext, number interface{}) { |
| switch f := number.(type) { |
| case Converter: |
| d.clear() |
| f.Convert(d, r) |
| case float32: |
| d.ConvertFloat(r, float64(f), 32) |
| case float64: |
| d.ConvertFloat(r, f, 64) |
| case int: |
| d.ConvertInt(r, signed, uint64(f)) |
| case int8: |
| d.ConvertInt(r, signed, uint64(f)) |
| case int16: |
| d.ConvertInt(r, signed, uint64(f)) |
| case int32: |
| d.ConvertInt(r, signed, uint64(f)) |
| case int64: |
| d.ConvertInt(r, signed, uint64(f)) |
| case uint: |
| d.ConvertInt(r, unsigned, uint64(f)) |
| case uint8: |
| d.ConvertInt(r, unsigned, uint64(f)) |
| case uint16: |
| d.ConvertInt(r, unsigned, uint64(f)) |
| case uint32: |
| d.ConvertInt(r, unsigned, uint64(f)) |
| case uint64: |
| d.ConvertInt(r, unsigned, f) |
| |
| default: |
| d.NaN = true |
| // TODO: |
| // case string: if produced by strconv, allows for easy arbitrary pos. |
| // case reflect.Value: |
| // case big.Float |
| // case big.Int |
| // case big.Rat? |
| // catch underlyings using reflect or will this already be done by the |
| // message package? |
| } |
| } |
| |
| // ConvertInt converts an integer to decimals. |
| func (d *Decimal) ConvertInt(r RoundingContext, signed bool, x uint64) { |
| if r.Increment > 0 { |
| // TODO: if uint64 is too large, fall back to float64 |
| if signed { |
| d.ConvertFloat(r, float64(int64(x)), 64) |
| } else { |
| d.ConvertFloat(r, float64(x), 64) |
| } |
| return |
| } |
| d.clear() |
| if signed && int64(x) < 0 { |
| x = uint64(-int64(x)) |
| d.Neg = true |
| } |
| d.fillIntDigits(x) |
| d.Exp = int32(len(d.Digits)) |
| } |
| |
| // ConvertFloat converts a floating point number to decimals. |
| func (d *Decimal) ConvertFloat(r RoundingContext, x float64, size int) { |
| d.clear() |
| if math.IsNaN(x) { |
| d.NaN = true |
| return |
| } |
| // Simple case: decimal notation |
| if r.Increment > 0 { |
| scale := int(r.IncrementScale) |
| mult := 1.0 |
| if scale >= len(scales) { |
| mult = math.Pow(10, float64(scale)) |
| } else { |
| mult = scales[scale] |
| } |
| // We multiply x instead of dividing inc as it gives less rounding |
| // issues. |
| x *= mult |
| x /= float64(r.Increment) |
| x = r.Mode.roundFloat(x) |
| x *= float64(r.Increment) |
| x /= mult |
| } |
| |
| abs := x |
| if x < 0 { |
| d.Neg = true |
| abs = -x |
| } |
| if math.IsInf(abs, 1) { |
| d.Inf = true |
| return |
| } |
| |
| // By default we get the exact decimal representation. |
| verb := byte('g') |
| prec := -1 |
| // As the strconv API does not return the rounding accuracy, we can only |
| // round using ToNearestEven. |
| if r.Mode == ToNearestEven { |
| if n := r.RoundSignificantDigits(); n >= 0 { |
| prec = n |
| } else if n = r.RoundFractionDigits(); n >= 0 { |
| prec = n |
| verb = 'f' |
| } |
| } else { |
| // TODO: At this point strconv's rounding is imprecise to the point that |
| // it is not usable for this purpose. |
| // See https://github.com/golang/go/issues/21714 |
| // If rounding is requested, we ask for a large number of digits and |
| // round from there to simulate rounding only once. |
| // Ideally we would have strconv export an AppendDigits that would take |
| // a rounding mode and/or return an accuracy. Something like this would |
| // work: |
| // AppendDigits(dst []byte, x float64, base, size, prec int) (digits []byte, exp, accuracy int) |
| hasPrec := r.RoundSignificantDigits() >= 0 |
| hasScale := r.RoundFractionDigits() >= 0 |
| if hasPrec || hasScale { |
| // prec is the number of mantissa bits plus some extra for safety. |
| // We need at least the number of mantissa bits as decimals to |
| // accurately represent the floating point without rounding, as each |
| // bit requires one more decimal to represent: 0.5, 0.25, 0.125, ... |
| prec = 60 |
| } |
| } |
| |
| b := strconv.AppendFloat(d.Digits[:0], abs, verb, prec, size) |
| i := 0 |
| k := 0 |
| beforeDot := 1 |
| for i < len(b) { |
| if c := b[i]; '0' <= c && c <= '9' { |
| b[k] = c - '0' |
| k++ |
| d.Exp += int32(beforeDot) |
| } else if c == '.' { |
| beforeDot = 0 |
| d.Exp = int32(k) |
| } else { |
| break |
| } |
| i++ |
| } |
| d.Digits = b[:k] |
| if i != len(b) { |
| i += len("e") |
| pSign := i |
| exp := 0 |
| for i++; i < len(b); i++ { |
| exp *= 10 |
| exp += int(b[i] - '0') |
| } |
| if b[pSign] == '-' { |
| exp = -exp |
| } |
| d.Exp = int32(exp) + 1 |
| } |
| } |
| |
| func (d *Decimal) fillIntDigits(x uint64) { |
| if cap(d.Digits) < maxIntDigits { |
| d.Digits = d.buf[:] |
| } else { |
| d.Digits = d.buf[:maxIntDigits] |
| } |
| i := 0 |
| for ; x > 0; x /= 10 { |
| d.Digits[i] = byte(x % 10) |
| i++ |
| } |
| d.Digits = d.Digits[:i] |
| for p := 0; p < i; p++ { |
| i-- |
| d.Digits[p], d.Digits[i] = d.Digits[i], d.Digits[p] |
| } |
| } |
| |
| var scales [70]float64 |
| |
| func init() { |
| x := 1.0 |
| for i := range scales { |
| scales[i] = x |
| x *= 10 |
| } |
| } |