performance fixes (#81)

- Much faster `Quo`
- `Int64x` same as `Int64` but reports whether the conversion was exact.
- `ScaleB`/`ScaleBInt` return a * 10^b
- Precook small integers [-10, 10].
- `make profile` convenience rule

Author: anzdaddy

Makefile

@@ -33,3 +33,7 @@ lint: build-linux
 		-v `go env GOMODCACHE`:/go/pkg/mod \
 		golangci/golangci-lint:v1.60.1-alpine \
 		golangci-lint run
+
+.PHONY: profile
+profile:
+	go test -cpuprofile cpu.prof -count=10 && go tool pprof -http=:8080 cpu.prof

decimal64.go

@@ -109,16 +109,39 @@ func signalNaN64() {
 	panic("sNaN64")
 }
 
-func checkSignificandIsNormal(significand uint64) {
-	logicCheck(decimal64Base <= significand, "%d <= %d", decimal64Base, significand)
-	logicCheck(significand < 10*decimal64Base, "%d < %d", significand, 10*decimal64Base)
+var small64s = [...]Decimal64{
+	new64FromInt64(-10),
+	new64FromInt64(-9),
+	new64FromInt64(-8),
+	new64FromInt64(-7),
+	new64FromInt64(-6),
+	new64FromInt64(-5),
+	new64FromInt64(-4),
+	new64FromInt64(-3),
+	new64FromInt64(-2),
+	NegOne64,
+	Zero64,
+	One64,
+	new64FromInt64(2),
+	new64FromInt64(3),
+	new64FromInt64(4),
+	new64FromInt64(5),
+	new64FromInt64(6),
+	new64FromInt64(7),
+	new64FromInt64(8),
+	new64FromInt64(9),
+	new64FromInt64(10),
 }
 
 // New64FromInt64 returns a new Decimal64 with the given value.
-func New64FromInt64(value int64) Decimal64 {
-	if value == 0 {
-		return Zero64
+func New64FromInt64(i int64) Decimal64 {
+	if i >= -10 && i <= 10 {
+		return small64s[10+i]
 	}
+	return new64FromInt64(i)
+}
+
+func new64FromInt64(value int64) Decimal64 {
 	sign := 0
 	if value < 0 {
 		sign = 1
@@ -182,21 +205,25 @@ func roundStatus(significand uint64, exp int, targetExp int) discardedDigit {
 // TODO: make this more efficent
 func countTrailingZeros(n uint64) int {
 	zeros := 0
-	if n%10000000000000000 == 0 {
+	q := n / 1_0000_0000_0000_0000
+	if n == q*1_0000_0000_0000_0000 {
 		zeros += 16
-		n /= 10000000000000000
+		n = q
 	}
-	if n%100000000 == 0 {
+	q = n / 1_0000_0000
+	if n == q*1_0000_0000 {
 		zeros += 8
-		n /= 100000000
+		n = q
 	}
-	if n%10000 == 0 {
+	q = n / 10000
+	if n == q*10000 {
 		zeros += 4
-		n /= 10000
+		n = q
 	}
-	if n%100 == 0 {
+	q = n / 100
+	if n == q*100 {
 		zeros += 2
-		n /= 100
+		n = q
 	}
 	if n%10 == 0 {
 		zeros++
@@ -315,28 +342,36 @@ func (d Decimal64) Float64() float64 {
 
 // Int64 returns an int64 representation of d, clamped to [[math.MinInt64], [math.MaxInt64]].
 func (d Decimal64) Int64() int64 {
+	i, _ := d.Int64x()
+	return i
+}
+
+// Int64 returns an int64 representation of d, clamped to [[math.MinInt64],
+// [math.MaxInt64]].
+// The second return value, exact indicates whether New64FromInt64(i) == d.
+func (d Decimal64) Int64x() (i int64, exact bool) {
 	fl, sign, exp, significand := d.parts()
 	switch fl {
 	case flInf:
 		if sign == 0 {
-			return math.MaxInt64
+			return math.MaxInt64, false
 		}
-		return math.MinInt64
+		return math.MinInt64, false
 	case flQNaN:
-		return 0
+		return 0, false
 	case flSNaN:
 		signalNaN64()
-		return 0
+		return 0, false
 	}
-	exp, whole, _ := expWholeFrac(exp, significand)
+	exp, whole, frac := expWholeFrac(exp, significand)
 	for exp > 0 && whole < math.MaxInt64/10 {
 		exp--
 		whole *= 10
 	}
 	if exp > 0 {
-		return math.MaxInt64
+		return math.MaxInt64, false
 	}
-	return int64(1-2*sign) * int64(whole)
+	return int64(1-2*sign) * int64(whole), frac == 0
 }
 
 // IsZero returns true if the Decimal encodes a zero value.
@@ -405,6 +440,62 @@ func (d Decimal64) Signbit() bool {
 	return d.bits>>63 == 1
 }
 
+func (d Decimal64) ScaleB(e Decimal64) Decimal64 {
+	var dp decParts
+	dp.unpack(d)
+	var ep decParts
+	ep.unpack(e)
+	if r, nan := checkNan(&dp, &ep); nan {
+		return r
+	}
+
+	if dp.fl != flNormal || dp.isZero() {
+		return d
+	}
+	if ep.fl != flNormal {
+		return QNaN64
+	}
+
+	i, exact := e.Int64x()
+	if !exact {
+		return QNaN64
+	}
+	return scaleBInt(&dp, int(i))
+}
+
+func (d Decimal64) ScaleBInt(i int) Decimal64 {
+	var dp decParts
+	dp.unpack(d)
+	if dp.fl != flNormal || dp.isZero() {
+		return d
+	}
+	return scaleBInt(&dp, i)
+}
+
+func scaleBInt(dp *decParts, i int) Decimal64 {
+	dp.exp += i
+
+	for dp.significand.lo < decimal64Base && dp.exp > -expOffset {
+		dp.exp--
+		dp.significand.lo *= 10
+	}
+
+	switch {
+	case dp.exp > expMax:
+		return Infinity64.CopySign(dp.original)
+	case dp.exp < -expOffset:
+		for dp.exp < -expOffset {
+			dp.exp++
+			dp.significand.lo /= 10
+		}
+		if dp.significand.lo == 0 {
+			return Zero64.CopySign(dp.original)
+		}
+	}
+
+	return dp.decimal64()
+}
+
 // Class returns a string representing the number's 'type' that the decimal is.
 // It can be one of the following:
 //

decimal64_debug.go

@@ -3,6 +3,8 @@
 
 package decimal
 
+import "fmt"
+
 // 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.
@@ -32,3 +34,13 @@ func new64(bits uint64) Decimal64 {
 
 	return d
 }
+
+func checkSignificandIsNormal(significand uint64) {
+	if decimal64Base > significand {
+		panic(fmt.Errorf("Failed logic check: %d <= %d", decimal64Base, significand))
+	}
+
+	if significand >= 10*decimal64Base {
+		panic(fmt.Errorf("Failed logic check: %d < %d", significand, 10*decimal64Base))
+	}
+}

decimal64_ndebug.go

@@ -16,3 +16,5 @@ type Decimal64 struct {
 func new64(bits uint64) Decimal64 {
 	return new64Raw(bits)
 }
+
+func checkSignificandIsNormal(significand uint64) {}

decimal64decParts.go

@@ -15,6 +15,10 @@ func unpack(d Decimal64) decParts {
 	return dp
 }
 
+func (dp *decParts) decimal64() Decimal64 {
+	return newFromParts(dp.sign, dp.exp, dp.significand.lo)
+}
+
 // add128 adds two decParts with full precision in 128 bits of significand
 func (dp *decParts) add128(ep *decParts) decParts {
 	dp.matchScales128(ep)
@@ -24,7 +28,7 @@ func (dp *decParts) add128(ep *decParts) decParts {
 		ans.sign = dp.sign
 		ans.significand = dp.significand.add(ep.significand)
 	} else {
-		if ep.significand.gt(dp.significand) {
+		if dp.significand.lt(ep.significand) {
 			ans.sign = ep.sign
 			ans.significand = ep.significand.sub(dp.significand)
 		} else if ep.significand.lt(dp.significand) {
@@ -50,24 +54,14 @@ func (dp *decParts) matchScales128(ep *decParts) {
 	}
 }
 
-func (dp *decParts) matchSignificandDigits(ep *decParts) {
-	expDiff := ep.significand.numDecimalDigits() - dp.significand.numDecimalDigits()
-	if expDiff < 0 {
-		ep.significand = ep.significand.mul(tenToThe128[-expDiff-1])
-		ep.exp -= -expDiff - 1
-		return
-	}
-	dp.significand = dp.significand.mul(tenToThe128[expDiff+1])
-	dp.exp -= expDiff + 1
-}
-
 func (dp *decParts) roundToLo() discardedDigit {
 	var rndStatus discardedDigit
-	if dp.significand.numDecimalDigits() > 16 {
+
+	if dsig := dp.significand; dsig.hi > 0 || dsig.lo >= 10*decimal64Base {
 		var remainder uint64
-		expDiff := dp.significand.numDecimalDigits() - 16
+		expDiff := dsig.numDecimalDigits() - 16
 		dp.exp += expDiff
-		dp.significand, remainder = dp.significand.divrem64(tenToThe[expDiff])
+		dp.significand, remainder = dsig.divrem64(tenToThe[expDiff])
 		rndStatus = roundStatus(remainder, 0, expDiff)
 	}
 	return rndStatus

decimal64math.go

@@ -1,5 +1,7 @@
 package decimal
 
+import "math/bits"
+
 // Equal indicates whether two numbers are equal.
 // It is equivalent to d.Cmp(e) == 0.
 func (d Decimal64) Equal(e Decimal64) bool {
@@ -240,43 +242,43 @@ func (ctx Context64) Quo(d, e Decimal64) Decimal64 {
 	if ep.isZero() {
 		return infinities64[ans.sign]
 	}
-	dp.matchSignificandDigits(&ep)
-	ans.exp = dp.exp - ep.exp
-	for {
-		for dp.significand.gt(ep.significand) {
-			dp.significand = dp.significand.sub(ep.significand)
-			ans.significand = ans.significand.add(uint128T{1, 0})
-		}
-		if dp.significand == (uint128T{}) || ans.significand.numDecimalDigits() == 16 {
-			break
-		}
-		ans.significand = ans.significand.mulBy10()
-		dp.significand = dp.significand.mulBy10()
-		ans.exp--
-	}
-	var rndStatus discardedDigit
-	dp.significand = dp.significand.mul64(2)
-	if dp.significand == (uint128T{}) {
-		rndStatus = eq0
-	} else if dp.significand.gt(ep.significand) {
-		rndStatus = gt5
-	} else if dp.significand.lt(ep.significand) {
-		rndStatus = lt5
-	} else {
-		rndStatus = eq5
+
+	const ampl = 1000
+	hi, lo := bits.Mul64(dp.significand.lo, ampl*decimal64Base)
+	q, _ := bits.Div64(hi, lo, ep.significand.lo)
+	exp := dp.exp - ep.exp - 15
+
+	for q < ampl*decimal64Base && exp > -expOffset {
+		q *= 10
+		exp--
 	}
-	ans.significand.lo = ctx.Rounding.round(ans.significand.lo, rndStatus)
-	if ans.exp < -expOffset {
-		rndStatus = ans.rescale(-expOffset)
-		ans.significand.lo = ctx.Rounding.round(ans.significand.lo, rndStatus)
+	for q >= 10*ampl*decimal64Base {
+		q /= 10
+		exp++
 	}
-	if ans.exp >= -expOffset && ans.significand.lo != 0 {
-		ans.exp, ans.significand.lo = renormalize(ans.exp, ans.significand.lo)
+	for exp < -expOffset {
+		q /= 10
+		exp++
 	}
-	if ans.significand.lo > maxSig || ans.exp > expMax {
+	if exp > expMax {
 		return infinities64[ans.sign]
 	}
-	return newFromParts(ans.sign, ans.exp, ans.significand.lo)
+
+	switch ctx.Rounding {
+	case HalfUp:
+		q = (q + ampl/2) / ampl
+	case HalfEven:
+		d := q / ampl
+		rem := q - d*ampl
+		q = d
+		if rem > ampl/2 || rem == ampl/2 && d%2 == 1 {
+			q++
+		}
+	case Down:
+		q /= ampl
+	}
+
+	return newFromParts(ans.sign, exp, q)
 }
 
 // Sqrt computes √d.
@@ -357,7 +359,7 @@ func (ctx Context64) Add(d, e Decimal64) Decimal64 {
 	if ans.exp > expMax || ans.significand.lo > maxSig {
 		return infinities64[ans.sign]
 	}
-	return newFromParts(ans.sign, ans.exp, ans.significand.lo)
+	return ans.decimal64()
 }
 
 // Add computes d + e
@@ -418,7 +420,7 @@ func (ctx Context64) FMA(d, e, f Decimal64) Decimal64 {
 	if ans.exp > expMax || ans.significand.lo > maxSig {
 		return infinities64[ans.sign]
 	}
-	return newFromParts(ans.sign, ans.exp, ans.significand.lo)
+	return ans.decimal64()
 }
 
 // Mul computes d * e
@@ -454,7 +456,7 @@ func (ctx Context64) Mul(d, e Decimal64) Decimal64 {
 	if ans.significand.lo > maxSig || ans.exp > expMax {
 		return infinities64[ans.sign]
 	}
-	return newFromParts(ans.sign, ans.exp, ans.significand.lo)
+	return ans.decimal64()
 }
 
 // NextPlus returns the next value above d.