Fix formatting and add Round/ToIntegral (#75)

Author: anzdaddy

decimal64.go

@@ -31,14 +31,6 @@ const (
 	roundDown
 )
 
-// Decimal64 represents an IEEE 754 64-bit floating point decimal number.
-// It uses the binary representation method.
-// Decimal64 is intentionally a struct to ensure users don't accidentally cast it to uint64
-type Decimal64 struct {
-	bits      uint64
-	debugInfo //nolint:unused
-}
-
 // Context64 stores the rounding type for arithmetic operations.
 type Context64 struct {
 	roundingMode roundingMode
@@ -113,7 +105,6 @@ func New64FromInt64(value int64) Decimal64 {
 }
 
 func renormalize(exp int, significand uint64) (int, uint64) {
-
 	numBits := 64 - bits.LeadingZeros64(significand)
 	numDigits := numBits * 3 / 10
 	normExp := 15 - numDigits
@@ -192,12 +183,12 @@ func newFromParts(sign int, exp int, significand uint64) Decimal64 {
 	if significand < 0x8<<50 {
 		// s EEeeeeeeee   (0)ttt tttttttttt tttttttttt tttttttttt tttttttttt tttttttttt
 		//   EE ∈ {00, 01, 10}
-		return Decimal64{bits: s | uint64(exp+expOffset)<<(63-10) | significand}.debug()
+		return new64(s | uint64(exp+expOffset)<<(63-10) | significand)
 	}
 	// s 11EEeeeeeeee (100)t tttttttttt tttttttttt tttttttttt tttttttttt tttttttttt
 	//     EE ∈ {00, 01, 10}
 	significand &= 0x8<<50 - 1
-	return Decimal64{bits: s | uint64(0xc00|(exp+expOffset))<<(63-12) | significand}.debug()
+	return new64(s | uint64(0xc00|(exp+expOffset))<<(63-12) | significand)
 }
 
 func (d Decimal64) parts() (fl flavor, sign int, exp int, significand uint64) {
@@ -357,7 +348,7 @@ func (d Decimal64) IsInt() bool {
 
 // quiet returns a quiet form of d, which must be a NaN.
 func (d Decimal64) quiet() Decimal64 {
-	return Decimal64{bits: d.bits &^ (2 << 56)}.debug()
+	return new64(d.bits &^ (2 << 56))
 }
 
 // IsSubnormal returns true iff d is a subnormal.

decimal64_debug.go

@@ -5,29 +5,31 @@ package decimal
 
 // Decimal64 represents an IEEE 754 64-bit floating point decimal number.
 // It uses the binary representation method.
-// Decimal64 is intentionally a struct to ensure users don't accidentally cast it to uint64
-type debugInfo struct {
+// Decimal64 is intentionally a struct to ensure users don't accidentally cast it to uint64.
+type Decimal64 struct {
 	s           string
 	fl          flavor
 	sign        int
 	exp         int
 	significand uint64
+	bits        uint64
 }
 
-func (d Decimal64) debug() Decimal64 {
-	s := d.s
-	if s == "" {
-		s = d.String()
-	}
+// This should be the only point at which Decimal64 instances are constructed raw.
+// The verbose construction below makes it easy to audit accidental raw cosntruction.
+// A search for (?<!\[\])Decimal64\{ must come up empty.
+func new64(bits uint64) Decimal64 {
+	var d Decimal64
+	d.bits = bits
+
 	fl, sign, exp, significand := d.parts()
-	return Decimal64{
-		bits: d.bits,
-		debugInfo: debugInfo{
-			s:           s,
-			fl:          fl,
-			sign:        sign,
-			exp:         exp,
-			significand: significand,
-		},
-	}
+
+	d.s = d.String()
+	d.fl = fl
+	d.sign = sign
+	d.exp = exp
+	d.significand = significand
+	d.bits = d.bits
+
+	return d
 }

decimal64_ndebug.go

@@ -5,9 +5,16 @@ package decimal
 
 // Decimal64 represents an IEEE 754 64-bit floating point decimal number.
 // It uses the binary representation method.
-// Decimal64 is intentionally a struct to ensure users don't accidentally cast it to uint64
-type debugInfo struct{} //nolint:unused
+// Decimal64 is intentionally a struct to ensure users don't accidentally cast it to uint64.
+type Decimal64 struct {
+	bits uint64
+}
 
-func (d Decimal64) debug() Decimal64 {
+// This should be the only point at which Decimal64 instances are constructed raw.
+// The verbose construction below makes it easy to audit accidental raw cosntruction.
+// A search for (?<!\[\])Decimal64\{ must come up empty.
+func new64(bits uint64) Decimal64 {
+	var d Decimal64
+	d.bits = bits
 	return d
 }

decimal64_test.go

@@ -151,7 +151,7 @@ func TestDecimal64isZero(t *testing.T) {
 	require := require.New(t)
 
 	require.Equal(true, Zero64.IsZero())
-	require.Equal(true, Decimal64{bits: Zero64.bits | neg64}.IsZero())
+	require.Equal(true, NegZero64.IsZero())
 	require.Equal(false, One64.IsZero())
 }
 

decimal64const.go

@@ -13,25 +13,25 @@ var One64 = newFromParts(0, -15, decimal64Base)
 var NegOne64 = newFromParts(1, -15, decimal64Base)
 
 // Infinity64 represents ∞ as a Decimal64.
-var Infinity64 = Decimal64{bits: inf64}.debug()
+var Infinity64 = new64(inf64)
 
 // NegInfinity64 represents -∞ as a Decimal64.
-var NegInfinity64 = Decimal64{bits: neg64 | inf64}.debug()
+var NegInfinity64 = new64(neg64 | inf64)
 
 // QNaN64 represents a quiet NaN as a Decimal64.
-var QNaN64 = Decimal64{bits: 0x7c << 56}.debug()
+var QNaN64 = new64(0x7c << 56)
 
 // SNaN64 represents a signalling NaN as a Decimal64.
-var SNaN64 = Decimal64{bits: 0x7e << 56}.debug()
+var SNaN64 = new64(0x7e << 56)
 
 // Pi64 represents π.
 var Pi64 = newFromParts(0, -15, 3_141592653589793)
 
 // E64 represents e (lim[n→∞](1+1/n)ⁿ).
 var E64 = newFromParts(0, -15, 2_718281828459045)
 
-var neg64 uint64 = 0x80 << 56
-var inf64 uint64 = 0x78 << 56
+const neg64 uint64 = 0x80 << 56
+const inf64 uint64 = 0x78 << 56
 
 // 1E15
 const decimal64Base uint64 = 1_000_000_000_000_000

decimal64decParts.go

@@ -9,6 +9,12 @@ type decParts struct {
 	original    Decimal64
 }
 
+func unpack(d Decimal64) decParts {
+	var dp decParts
+	dp.unpack(d)
+	return dp
+}
+
 // add128 adds two decParts with full precision in 128 bits of significand
 func (dp *decParts) add128(ep *decParts) decParts {
 	dp.matchScales128(ep)

decimal64fmt.go

@@ -6,9 +6,9 @@ import (
 	"strconv"
 )
 
-var _ fmt.Formatter = Decimal64{}
+var _ fmt.Formatter = Zero64
 var _ fmt.Scanner = (*Decimal64)(nil)
-var _ fmt.Stringer = Decimal64{}
+var _ fmt.Stringer = Zero64
 
 func appendFrac64(buf []byte, n, limit uint64) []byte {
 	for n > 0 {
@@ -102,13 +102,20 @@ func (d Decimal64) append(buf []byte, format byte, width, prec int) []byte {
 formatBlock:
 	switch format {
 	case 'e', 'E':
+		// normalise subnormals
+		exp, significand = unsubnormal(exp, significand)
+
 		whole := significand / decimal64Base
 		buf = append(buf, byte('0'+whole))
 		frac := significand - decimal64Base*whole
 		if frac > 0 {
 			buf = appendFrac64(append(buf, '.'), frac, decimal64Base/10)
 		}
 
+		if significand == 0 {
+			return buf
+		}
+
 		exp += 15
 		if exp != 0 {
 			buf = append(buf, format)
@@ -149,7 +156,9 @@ formatBlock:
 		}
 		return buf
 	case 'g', 'G':
-		if exp < -decimal64Digits-4 || prec >= 0 && exp > prec {
+		if exp < -decimal64Digits-3 ||
+			prec >= 0 && exp > prec ||
+			prec < 0 && exp > -decimal64Digits+6 {
 			format -= 'g' - 'e'
 		} else {
 			format -= 'g' - 'f'

decimal64fmt_test.go

@@ -38,6 +38,23 @@ func TestDecimal64String(t *testing.T) {
 	}
 }
 
+func TestDecimal64StringEdgeCases(t *testing.T) {
+	t.Parallel()
+
+	require.Equal(t, "123456", MustParse64("123456").String())
+	require.Equal(t, "-123456", MustParse64("-123456").String())
+	require.Equal(t, "1.234567e+6", MustParse64("1234567").String())
+	require.Equal(t, "-1.234567e+6", MustParse64("-1234567").String())
+	require.Equal(t, "0.0001", MustParse64("0.0001").String())
+	require.Equal(t, "-0.0001", MustParse64("-0.0001").String())
+	require.Equal(t, "1e-5", MustParse64("0.00001").String())
+	require.Equal(t, "-1e-5", MustParse64("-0.00001").String())
+	require.Equal(t, "9.999999999999999e+384", MustParse64("9.999999999999999e+384").String())
+	require.Equal(t, "-9.999999999999999e+384", MustParse64("-9.999999999999999e+384").String())
+	require.Equal(t, "1e-398", MustParse64("1e-398").String())
+	require.Equal(t, "-1e-398", MustParse64("-1e-398").String())
+}
+
 func BenchmarkDecimal64String(b *testing.B) {
 	d := New64FromInt64(123456789)
 	for i := 0; i <= b.N; i++ {
@@ -116,7 +133,7 @@ func TestDecimal64FormatPrec(t *testing.T) {
 
 	// Add five digits to the significand so we round at a 2.
 	pi = pi.Add(New64FromInt64(10_100_000_000))
-	assert.Equal(t, "10100100103.14159", fmt.Sprintf("%v", pi))
+	assert.Equal(t, "1.010010010314159e+10", fmt.Sprintf("%v", pi))
 	assert.Equal(t, "10100100103.141590", fmt.Sprintf("%f", pi))
 	assert.Equal(t, "10100100103", fmt.Sprintf("%.0f", pi))
 	assert.Equal(t, "10100100103.1", fmt.Sprintf("%.1f", pi))

decimal64gob.go

@@ -5,7 +5,7 @@ import (
 )
 
 var _ gob.GobDecoder = (*Decimal64)(nil)
-var _ gob.GobEncoder = Decimal64{}
+var _ gob.GobEncoder = Zero64
 
 // GobDecode implements encoding.GobDecoder.
 func (d *Decimal64) GobDecode(buf []byte) error {

decimal64json.go

@@ -2,7 +2,7 @@ package decimal
 
 import "encoding/json"
 
-var _ json.Marshaler = Decimal64{}
+var _ json.Marshaler = Zero64
 var _ json.Unmarshaler = (*Decimal64)(nil)
 
 // MarshalText implements the encoding.TextMarshaler interface.

decimal64marshal.go

@@ -6,7 +6,7 @@ import (
 	"fmt"
 )
 
-var _ encoding.TextMarshaler = Decimal64{}
+var _ encoding.TextMarshaler = Zero64
 var _ encoding.TextUnmarshaler = (*Decimal64)(nil)
 
 // MarshalText implements the encoding.TextMarshaler interface.
@@ -26,7 +26,7 @@ func (d *Decimal64) UnmarshalText(text []byte) error {
 	return err
 }
 
-var _ encoding.BinaryMarshaler = Decimal64{}
+var _ encoding.BinaryMarshaler = Zero64
 var _ encoding.BinaryUnmarshaler = (*Decimal64)(nil)
 
 // MarshalBinary implements the encoding.BinaryMarshaler interface.
@@ -38,7 +38,8 @@ func (d Decimal64) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements the encoding.BinaryUnmarshaler interface.
 func (d *Decimal64) UnmarshalBinary(data []byte) error {
-	d.bits = binary.BigEndian.Uint64(data)
+	bits := binary.BigEndian.Uint64(data)
 	// TODO: Check for out of bounds significand.
+	*d = new64(bits)
 	return nil
 }