taldir

decimal.go (12105B)

---

 // 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
 	}
 }