revise NewDec*, SetUnscaled*: favor common case rather than general case

benchmark_test.go

@@ -23,9 +23,9 @@ var initBench = func() {
 	max := new(big.Int).Lsh(big.NewInt(1), bits)
 	r := rand.New(rand.NewSource(0))
 	for i := 0; i < cap(decInput); i++ {
-		decInput[i][0].SetUnscaled(new(big.Int).Rand(r, max)).
+		decInput[i][0].SetUnscaledBig(new(big.Int).Rand(r, max)).
 			SetScale(Scale(r.Int31n(int32(2*maxscale-1)) - int32(maxscale)))
-		decInput[i][1].SetUnscaled(new(big.Int).Rand(r, max)).
+		decInput[i][1].SetUnscaledBig(new(big.Int).Rand(r, max)).
 			SetScale(Scale(r.Int31n(int32(2*maxscale-1)) - int32(maxscale)))
 	}
 	for i := 0; i < cap(intInput); i++ {

dec.go

@@ -15,7 +15,7 @@
 //  - conversions to and from float32/64 types
 //
 // Features considered for possible addition:
-//  + simplify API for New*()
+//  + revise/add Unscaled(Big) to match SetUnscaled(Big) and NewDec(Big)
 //  + formatting options
 //  + Exp method
 //  + combined operations such as AddRound/MulAdd etc
@@ -25,6 +25,7 @@ package inf
 
 // TODO:
 //  - avoid excessive deep copying (quo and rounders)
+//  - use Round (not Quo) in rounding examples
 
 import (
 	"fmt"
@@ -114,14 +115,14 @@ var exp10cache [64]big.Int = func() [64]big.Int {
 
 // NewDec allocates and returns a new Dec set to the given unscaled value and
 // scale.
-func NewDec(unscaled *big.Int, scale Scale) *Dec {
+func NewDec(unscaled int64, scale Scale) *Dec {
 	return new(Dec).SetUnscaled(unscaled).SetScale(scale)
 }
 
 // NewDecInt64 allocates and returns a new Dec set to the given int64 value with
 // scale 0.
-func NewDecInt64(x int64) *Dec {
-	return new(Dec).SetUnscaled(big.NewInt(x))
+func NewDecBig(unscaled *big.Int, scale Scale) *Dec {
+	return new(Dec).SetUnscaledBig(unscaled).SetScale(scale)
 }
 
 // Scale returns the scale of x.
@@ -134,25 +135,34 @@ func (x *Dec) Unscaled() *big.Int {
 	return &x.unscaled
 }
 
-// SetScale sets the scale of x, with the unscaled value unchanged.
+// SetScale sets the scale of z, with the unscaled value unchanged, and returns
+// z.
 // The mathematical value of the Dec changes as if it was multiplied by
 // 10**(oldscale-scale).
-func (x *Dec) SetScale(scale Scale) *Dec {
-	x.scale = scale
-	return x
+func (z *Dec) SetScale(scale Scale) *Dec {
+	z.scale = scale
+	return z
 }
 
-// SetScale sets the unscaled value of x, with the scale unchanged.
-func (x *Dec) SetUnscaled(unscaled *big.Int) *Dec {
-	x.unscaled.Set(unscaled)
-	return x
+// SetUnscaled sets the unscaled value of z, with the scale unchanged, and
+// returns z.
+func (z *Dec) SetUnscaled(unscaled int64) *Dec {
+	z.unscaled.SetInt64(unscaled)
+	return z
+}
+
+// SetUnscaledBig sets the unscaled value of z, with the scale unchanged, and
+// returns z.
+func (z *Dec) SetUnscaledBig(unscaled *big.Int) *Dec {
+	z.unscaled.Set(unscaled)
+	return z
 }
 
 // Set sets z to the value of x and returns z.
 // It does nothing if z == x.
 func (z *Dec) Set(x *Dec) *Dec {
 	if z != x {
-		z.SetUnscaled(x.Unscaled())
+		z.SetUnscaledBig(x.Unscaled())
 		z.SetScale(x.Scale())
 	}
 	return z
@@ -222,7 +232,7 @@ func (z *Dec) Mul(x, y *Dec) *Dec {
 // Round sets z to the value of x rounded to Scale s using Rounder r, and
 // returns z.
 func (z *Dec) Round(x *Dec, s Scale, r Rounder) *Dec {
-	return z.QuoRound(x, NewDecInt64(1), s, r)
+	return z.QuoRound(x, NewDec(1, 0), s, r)
 }
 
 // QuoRound sets z to the quotient x/y, rounded using the given Rounder to the
@@ -381,10 +391,10 @@ func (x *Dec) rescale(newScale Scale) *Dec {
 	switch {
 	case shift < 0:
 		e := exp10(-shift)
-		return NewDec(new(big.Int).Quo(x.Unscaled(), e), newScale)
+		return NewDecBig(new(big.Int).Quo(x.Unscaled(), e), newScale)
 	case shift > 0:
 		e := exp10(shift)
-		return NewDec(new(big.Int).Mul(x.Unscaled(), e), newScale)
+		return NewDecBig(new(big.Int).Mul(x.Unscaled(), e), newScale)
 	}
 	return x
 }

dec_test.go

@@ -15,23 +15,23 @@ type decArgZZ struct {
 }
 
 var decSumZZ = []decArgZZ{
-	{NewDecInt64(0), NewDecInt64(0), NewDecInt64(0)},
-	{NewDecInt64(1), NewDecInt64(1), NewDecInt64(0)},
-	{NewDecInt64(1111111110), NewDecInt64(123456789), NewDecInt64(987654321)},
-	{NewDecInt64(-1), NewDecInt64(-1), NewDecInt64(0)},
-	{NewDecInt64(864197532), NewDecInt64(-123456789), NewDecInt64(987654321)},
-	{NewDecInt64(-1111111110), NewDecInt64(-123456789), NewDecInt64(-987654321)},
-	{NewDec(big.NewInt(12), 2), NewDec(big.NewInt(1), 1), NewDec(big.NewInt(2), 2)},
+	{NewDec(0, 0), NewDec(0, 0), NewDec(0, 0)},
+	{NewDec(1, 0), NewDec(1, 0), NewDec(0, 0)},
+	{NewDec(1111111110, 0), NewDec(123456789, 0), NewDec(987654321, 0)},
+	{NewDec(-1, 0), NewDec(-1, 0), NewDec(0, 0)},
+	{NewDec(864197532, 0), NewDec(-123456789, 0), NewDec(987654321, 0)},
+	{NewDec(-1111111110, 0), NewDec(-123456789, 0), NewDec(-987654321, 0)},
+	{NewDec(12, 2), NewDec(1, 1), NewDec(2, 2)},
 }
 
 var decProdZZ = []decArgZZ{
-	{NewDecInt64(0), NewDecInt64(0), NewDecInt64(0)},
-	{NewDecInt64(0), NewDecInt64(1), NewDecInt64(0)},
-	{NewDecInt64(1), NewDecInt64(1), NewDecInt64(1)},
-	{NewDecInt64(-991 * 991), NewDecInt64(991), NewDecInt64(-991)},
-	{NewDec(big.NewInt(2), 3), NewDec(big.NewInt(1), 1), NewDec(big.NewInt(2), 2)},
-	{NewDec(big.NewInt(2), -3), NewDec(big.NewInt(1), -1), NewDec(big.NewInt(2), -2)},
-	{NewDec(big.NewInt(2), 3), NewDec(big.NewInt(1), 1), NewDec(big.NewInt(2), 2)},
+	{NewDec(0, 0), NewDec(0, 0), NewDec(0, 0)},
+	{NewDec(0, 0), NewDec(1, 0), NewDec(0, 0)},
+	{NewDec(1, 0), NewDec(1, 0), NewDec(1, 0)},
+	{NewDec(-991*991, 0), NewDec(991, 0), NewDec(-991, 0)},
+	{NewDec(2, 3), NewDec(1, 1), NewDec(2, 2)},
+	{NewDec(2, -3), NewDec(1, -1), NewDec(2, -2)},
+	{NewDec(2, 3), NewDec(1, 1), NewDec(2, 2)},
 }
 
 func TestDecSignZ(t *testing.T) {
@@ -104,18 +104,18 @@ var decQuoRemZZZ = []struct {
 	srA, srB int
 }{
 	// basic examples
-	{NewDec(big.NewInt(1), 0), NewDecInt64(2), NewDecInt64(2), big.NewRat(0, 1), 0, 1},
-	{NewDec(big.NewInt(15), 1), NewDecInt64(3), NewDecInt64(2), big.NewRat(0, 1), 0, 1},
-	{NewDec(big.NewInt(1), 1), NewDecInt64(1), NewDecInt64(10), big.NewRat(0, 1), 0, 1},
-	{NewDec(big.NewInt(0), 0), NewDecInt64(2), NewDecInt64(3), big.NewRat(2, 3), 1, 1},
-	{NewDec(big.NewInt(0), 0), NewDecInt64(2), NewDecInt64(6), big.NewRat(1, 3), 1, 1},
-	{NewDec(big.NewInt(1), 1), NewDecInt64(2), NewDecInt64(12), big.NewRat(2, 3), 1, 1},
+	{NewDec(1, 0), NewDec(2, 0), NewDec(2, 0), big.NewRat(0, 1), 0, 1},
+	{NewDec(15, 1), NewDec(3, 0), NewDec(2, 0), big.NewRat(0, 1), 0, 1},
+	{NewDec(1, 1), NewDec(1, 0), NewDec(10, 0), big.NewRat(0, 1), 0, 1},
+	{NewDec(0, 0), NewDec(2, 0), NewDec(3, 0), big.NewRat(2, 3), 1, 1},
+	{NewDec(0, 0), NewDec(2, 0), NewDec(6, 0), big.NewRat(1, 3), 1, 1},
+	{NewDec(1, 1), NewDec(2, 0), NewDec(12, 0), big.NewRat(2, 3), 1, 1},
 
 	// examples from the Go Language Specification
-	{NewDec(big.NewInt(1), 0), NewDecInt64(5), NewDecInt64(3), big.NewRat(2, 3), 1, 1},
-	{NewDec(big.NewInt(-1), 0), NewDecInt64(-5), NewDecInt64(3), big.NewRat(-2, 3), -1, 1},
-	{NewDec(big.NewInt(-1), 0), NewDecInt64(5), NewDecInt64(-3), big.NewRat(-2, 3), 1, -1},
-	{NewDec(big.NewInt(1), 0), NewDecInt64(-5), NewDecInt64(-3), big.NewRat(2, 3), -1, -1},
+	{NewDec(1, 0), NewDec(5, 0), NewDec(3, 0), big.NewRat(2, 3), 1, 1},
+	{NewDec(-1, 0), NewDec(-5, 0), NewDec(3, 0), big.NewRat(-2, 3), -1, 1},
+	{NewDec(-1, 0), NewDec(5, 0), NewDec(-3, 0), big.NewRat(-2, 3), 1, -1},
+	{NewDec(1, 0), NewDec(-5, 0), NewDec(-3, 0), big.NewRat(2, 3), -1, -1},
 }
 
 func TestDecQuoRem(t *testing.T) {
@@ -138,16 +138,16 @@ var decRoundTests = [...]struct {
 	r   Rounder
 	exp *Dec
 }{
-	{NewDec(big.NewInt(123424999999999993), 15), 2, RoundHalfUp, NewDec(big.NewInt(12342), 2)},
-	{NewDec(big.NewInt(123425000000000001), 15), 2, RoundHalfUp, NewDec(big.NewInt(12343), 2)},
-	{NewDec(big.NewInt(123424999999999993), 15), 15, RoundHalfUp, NewDec(big.NewInt(123424999999999993), 15)},
-	{NewDec(big.NewInt(123424999999999993), 15), 16, RoundHalfUp, NewDec(big.NewInt(1234249999999999930), 16)},
-	{NewDec(new(big.Int).Lsh(big.NewInt(1), 64), 0), -1, RoundHalfUp, NewDec(big.NewInt(1844674407370955162), -1)},
-	{NewDec(new(big.Int).Lsh(big.NewInt(1), 64), 0), -2, RoundHalfUp, NewDec(big.NewInt(184467440737095516), -2)},
-	{NewDec(new(big.Int).Lsh(big.NewInt(1), 64), 0), -3, RoundHalfUp, NewDec(big.NewInt(18446744073709552), -3)},
-	{NewDec(new(big.Int).Lsh(big.NewInt(1), 64), 0), -4, RoundHalfUp, NewDec(big.NewInt(1844674407370955), -4)},
-	{NewDec(new(big.Int).Lsh(big.NewInt(1), 64), 0), -5, RoundHalfUp, NewDec(big.NewInt(184467440737096), -5)},
-	{NewDec(new(big.Int).Lsh(big.NewInt(1), 64), 0), -6, RoundHalfUp, NewDec(big.NewInt(18446744073710), -6)},
+	{NewDec(123424999999999993, 15), 2, RoundHalfUp, NewDec(12342, 2)},
+	{NewDec(123425000000000001, 15), 2, RoundHalfUp, NewDec(12343, 2)},
+	{NewDec(123424999999999993, 15), 15, RoundHalfUp, NewDec(123424999999999993, 15)},
+	{NewDec(123424999999999993, 15), 16, RoundHalfUp, NewDec(1234249999999999930, 16)},
+	{NewDecBig(new(big.Int).Lsh(big.NewInt(1), 64), 0), -1, RoundHalfUp, NewDec(1844674407370955162, -1)},
+	{NewDecBig(new(big.Int).Lsh(big.NewInt(1), 64), 0), -2, RoundHalfUp, NewDec(184467440737095516, -2)},
+	{NewDecBig(new(big.Int).Lsh(big.NewInt(1), 64), 0), -3, RoundHalfUp, NewDec(18446744073709552, -3)},
+	{NewDecBig(new(big.Int).Lsh(big.NewInt(1), 64), 0), -4, RoundHalfUp, NewDec(1844674407370955, -4)},
+	{NewDecBig(new(big.Int).Lsh(big.NewInt(1), 64), 0), -5, RoundHalfUp, NewDec(184467440737096, -5)},
+	{NewDecBig(new(big.Int).Lsh(big.NewInt(1), 64), 0), -6, RoundHalfUp, NewDec(18446744073710, -6)},
 }
 
 func TestDecRound(t *testing.T) {
@@ -221,7 +221,7 @@ func TestDecGetString(t *testing.T) {
 		if !test.ok {
 			continue
 		}
-		z.SetUnscaled(big.NewInt(test.val))
+		z.SetUnscaled(test.val)
 		z.SetScale(test.scale)
 
 		s := z.String()
@@ -245,10 +245,10 @@ func TestDecSetString(t *testing.T) {
 		}
 		// initialize to a non-zero value so that issues with parsing
 		// 0 are detected
-		tmp.Set(NewDecInt64(1234567890).SetScale(123))
+		tmp.Set(NewDec(1234567890, 123))
 		n1, ok1 := new(Dec).SetString(test.in)
 		n2, ok2 := tmp.SetString(test.in)
-		expected := NewDecInt64(test.val).SetScale(test.scale)
+		expected := NewDec(test.val, test.scale)
 		if ok1 != test.ok || ok2 != test.ok {
 			t.Errorf("#%d (input '%s') ok incorrect (should be %t)", i, test.in, test.ok)
 			continue
@@ -284,7 +284,7 @@ func TestDecScan(t *testing.T) {
 		}
 		// initialize to a non-zero value so that issues with parsing
 		// 0 are detected
-		tmp.Set(NewDecInt64(1234567890).SetScale(123))
+		tmp.Set(NewDec(1234567890, 123))
 		n1, n2 := new(Dec), tmp
 		nn1, err1 := fmt.Sscan(test.in, n1)
 		nn2, err2 := fmt.Sscan(test.in, n2)
@@ -294,7 +294,7 @@ func TestDecScan(t *testing.T) {
 			}
 			continue
 		}
-		expected := NewDecInt64(test.val).SetScale(test.scale)
+		expected := NewDec(test.val, test.scale)
 		if nn1 != 1 || err1 != nil || nn2 != 1 || err2 != nil {
 			t.Errorf("#%d (input '%s') error %d %v, %d %v", i, test.in, nn1, err1, nn2, err2)
 			continue

example_test.go

@@ -29,7 +29,7 @@ func ExampleDec_Scan() {
 
 func ExampleDec_QuoRound_scale2RoundDown() {
 	// 10 / 3 is an infinite decimal; it has no exact Dec representation
-	x, y := inf.NewDecInt64(10), inf.NewDecInt64(3)
+	x, y := inf.NewDec(10, 0), inf.NewDec(3, 0)
 	// use 2 digits beyond the decimal point, round towards 0
 	z := new(inf.Dec).QuoRound(x, y, 2, inf.RoundDown)
 	fmt.Println(z)
@@ -38,7 +38,7 @@ func ExampleDec_QuoRound_scale2RoundDown() {
 
 func ExampleDec_QuoRound_scale2RoundCeil() {
 	// -42 / 400 is an finite decimal with 3 digits beyond the decimal point
-	x, y := inf.NewDecInt64(-42), inf.NewDecInt64(400)
+	x, y := inf.NewDec(-42, 0), inf.NewDec(400, 0)
 	// use 2 digits beyond decimal point, round towards positive infinity
 	z := new(inf.Dec).QuoRound(x, y, 2, inf.RoundCeil)
 	fmt.Println(z)
@@ -47,7 +47,7 @@ func ExampleDec_QuoRound_scale2RoundCeil() {
 
 func ExampleDec_QuoExact_ok() {
 	// 1 / 25 is a finite decimal; it has exact Dec representation
-	x, y := inf.NewDecInt64(1), inf.NewDecInt64(25)
+	x, y := inf.NewDec(1, 0), inf.NewDec(25, 0)
 	z := new(inf.Dec).QuoExact(x, y)
 	fmt.Println(z)
 	// Output: 0.04
@@ -55,7 +55,7 @@ func ExampleDec_QuoExact_ok() {
 
 func ExampleDec_QuoExact_fail() {
 	// 1 / 3 is an infinite decimal; it has no exact Dec representation
-	x, y := inf.NewDecInt64(1), inf.NewDecInt64(3)
+	x, y := inf.NewDec(1, 0), inf.NewDec(3, 0)
 	z := new(inf.Dec).QuoExact(x, y)
 	fmt.Println(z)
 	// Output: <nil>

rounder_test.go

@@ -10,24 +10,24 @@ var decRounderInputs = [...]struct {
 	rA, rB *big.Int
 }{
 	// examples from go language spec
-	{NewDec(big.NewInt(1), 0), big.NewInt(2), big.NewInt(3)},   //  5 /  3
-	{NewDec(big.NewInt(-1), 0), big.NewInt(-2), big.NewInt(3)}, // -5 /  3
-	{NewDec(big.NewInt(-1), 0), big.NewInt(2), big.NewInt(-3)}, //  5 / -3
-	{NewDec(big.NewInt(1), 0), big.NewInt(-2), big.NewInt(-3)}, // -5 / -3
+	{NewDec(1, 0), big.NewInt(2), big.NewInt(3)},   //  5 /  3
+	{NewDec(-1, 0), big.NewInt(-2), big.NewInt(3)}, // -5 /  3
+	{NewDec(-1, 0), big.NewInt(2), big.NewInt(-3)}, //  5 / -3
+	{NewDec(1, 0), big.NewInt(-2), big.NewInt(-3)}, // -5 / -3
 	// examples from godoc
-	{NewDec(big.NewInt(-1), 1), big.NewInt(-8), big.NewInt(10)},
-	{NewDec(big.NewInt(-1), 1), big.NewInt(-5), big.NewInt(10)},
-	{NewDec(big.NewInt(-1), 1), big.NewInt(-2), big.NewInt(10)},
-	{NewDec(big.NewInt(0), 1), big.NewInt(-8), big.NewInt(10)},
-	{NewDec(big.NewInt(0), 1), big.NewInt(-5), big.NewInt(10)},
-	{NewDec(big.NewInt(0), 1), big.NewInt(-2), big.NewInt(10)},
-	{NewDec(big.NewInt(0), 1), big.NewInt(0), big.NewInt(1)},
-	{NewDec(big.NewInt(0), 1), big.NewInt(2), big.NewInt(10)},
-	{NewDec(big.NewInt(0), 1), big.NewInt(5), big.NewInt(10)},
-	{NewDec(big.NewInt(0), 1), big.NewInt(8), big.NewInt(10)},
-	{NewDec(big.NewInt(1), 1), big.NewInt(2), big.NewInt(10)},
-	{NewDec(big.NewInt(1), 1), big.NewInt(5), big.NewInt(10)},
-	{NewDec(big.NewInt(1), 1), big.NewInt(8), big.NewInt(10)},
+	{NewDec(-1, 1), big.NewInt(-8), big.NewInt(10)},
+	{NewDec(-1, 1), big.NewInt(-5), big.NewInt(10)},
+	{NewDec(-1, 1), big.NewInt(-2), big.NewInt(10)},
+	{NewDec(0, 1), big.NewInt(-8), big.NewInt(10)},
+	{NewDec(0, 1), big.NewInt(-5), big.NewInt(10)},
+	{NewDec(0, 1), big.NewInt(-2), big.NewInt(10)},
+	{NewDec(0, 1), big.NewInt(0), big.NewInt(1)},
+	{NewDec(0, 1), big.NewInt(2), big.NewInt(10)},
+	{NewDec(0, 1), big.NewInt(5), big.NewInt(10)},
+	{NewDec(0, 1), big.NewInt(8), big.NewInt(10)},
+	{NewDec(1, 1), big.NewInt(2), big.NewInt(10)},
+	{NewDec(1, 1), big.NewInt(5), big.NewInt(10)},
+	{NewDec(1, 1), big.NewInt(8), big.NewInt(10)},
 }
 
 var decRounderResults = [...]struct {
@@ -36,56 +36,56 @@ var decRounderResults = [...]struct {
 }{
 	{RoundExact, [...]*Dec{nil, nil, nil, nil,
 		nil, nil, nil, nil, nil, nil,
-		NewDec(big.NewInt(0), 1), nil, nil, nil, nil, nil, nil}},
+		NewDec(0, 1), nil, nil, nil, nil, nil, nil}},
 	{RoundDown, [...]*Dec{
-		NewDecInt64(1), NewDecInt64(-1), NewDecInt64(-1), NewDecInt64(1),
-		NewDec(big.NewInt(-1), 1), NewDec(big.NewInt(-1), 1), NewDec(big.NewInt(-1), 1),
-		NewDec(big.NewInt(0), 1), NewDec(big.NewInt(0), 1), NewDec(big.NewInt(0), 1),
-		NewDec(big.NewInt(0), 1),
-		NewDec(big.NewInt(0), 1), NewDec(big.NewInt(0), 1), NewDec(big.NewInt(0), 1),
-		NewDec(big.NewInt(1), 1), NewDec(big.NewInt(1), 1), NewDec(big.NewInt(1), 1)}},
+		NewDec(1, 0), NewDec(-1, 0), NewDec(-1, 0), NewDec(1, 0),
+		NewDec(-1, 1), NewDec(-1, 1), NewDec(-1, 1),
+		NewDec(0, 1), NewDec(0, 1), NewDec(0, 1),
+		NewDec(0, 1),
+		NewDec(0, 1), NewDec(0, 1), NewDec(0, 1),
+		NewDec(1, 1), NewDec(1, 1), NewDec(1, 1)}},
 	{RoundUp, [...]*Dec{
-		NewDecInt64(2), NewDecInt64(-2), NewDecInt64(-2), NewDecInt64(2),
-		NewDec(big.NewInt(-2), 1), NewDec(big.NewInt(-2), 1), NewDec(big.NewInt(-2), 1),
-		NewDec(big.NewInt(-1), 1), NewDec(big.NewInt(-1), 1), NewDec(big.NewInt(-1), 1),
-		NewDec(big.NewInt(0), 1),
-		NewDec(big.NewInt(1), 1), NewDec(big.NewInt(1), 1), NewDec(big.NewInt(1), 1),
-		NewDec(big.NewInt(2), 1), NewDec(big.NewInt(2), 1), NewDec(big.NewInt(2), 1)}},
+		NewDec(2, 0), NewDec(-2, 0), NewDec(-2, 0), NewDec(2, 0),
+		NewDec(-2, 1), NewDec(-2, 1), NewDec(-2, 1),
+		NewDec(-1, 1), NewDec(-1, 1), NewDec(-1, 1),
+		NewDec(0, 1),
+		NewDec(1, 1), NewDec(1, 1), NewDec(1, 1),
+		NewDec(2, 1), NewDec(2, 1), NewDec(2, 1)}},
 	{RoundHalfDown, [...]*Dec{
-		NewDecInt64(2), NewDecInt64(-2), NewDecInt64(-2), NewDecInt64(2),
-		NewDec(big.NewInt(-2), 1), NewDec(big.NewInt(-1), 1), NewDec(big.NewInt(-1), 1),
-		NewDec(big.NewInt(-1), 1), NewDec(big.NewInt(0), 1), NewDec(big.NewInt(0), 1),
-		NewDec(big.NewInt(0), 1),
-		NewDec(big.NewInt(0), 1), NewDec(big.NewInt(0), 1), NewDec(big.NewInt(1), 1),
-		NewDec(big.NewInt(1), 1), NewDec(big.NewInt(1), 1), NewDec(big.NewInt(2), 1)}},
+		NewDec(2, 0), NewDec(-2, 0), NewDec(-2, 0), NewDec(2, 0),
+		NewDec(-2, 1), NewDec(-1, 1), NewDec(-1, 1),
+		NewDec(-1, 1), NewDec(0, 1), NewDec(0, 1),
+		NewDec(0, 1),
+		NewDec(0, 1), NewDec(0, 1), NewDec(1, 1),
+		NewDec(1, 1), NewDec(1, 1), NewDec(2, 1)}},
 	{RoundHalfUp, [...]*Dec{
-		NewDecInt64(2), NewDecInt64(-2), NewDecInt64(-2), NewDecInt64(2),
-		NewDec(big.NewInt(-2), 1), NewDec(big.NewInt(-2), 1), NewDec(big.NewInt(-1), 1),
-		NewDec(big.NewInt(-1), 1), NewDec(big.NewInt(-1), 1), NewDec(big.NewInt(0), 1),
-		NewDec(big.NewInt(0), 1),
-		NewDec(big.NewInt(0), 1), NewDec(big.NewInt(1), 1), NewDec(big.NewInt(1), 1),
-		NewDec(big.NewInt(1), 1), NewDec(big.NewInt(2), 1), NewDec(big.NewInt(2), 1)}},
+		NewDec(2, 0), NewDec(-2, 0), NewDec(-2, 0), NewDec(2, 0),
+		NewDec(-2, 1), NewDec(-2, 1), NewDec(-1, 1),
+		NewDec(-1, 1), NewDec(-1, 1), NewDec(0, 1),
+		NewDec(0, 1),
+		NewDec(0, 1), NewDec(1, 1), NewDec(1, 1),
+		NewDec(1, 1), NewDec(2, 1), NewDec(2, 1)}},
 	{RoundHalfEven, [...]*Dec{
-		NewDecInt64(2), NewDecInt64(-2), NewDecInt64(-2), NewDecInt64(2),
-		NewDec(big.NewInt(-2), 1), NewDec(big.NewInt(-2), 1), NewDec(big.NewInt(-1), 1),
-		NewDec(big.NewInt(-1), 1), NewDec(big.NewInt(0), 1), NewDec(big.NewInt(0), 1),
-		NewDec(big.NewInt(0), 1),
-		NewDec(big.NewInt(0), 1), NewDec(big.NewInt(0), 1), NewDec(big.NewInt(1), 1),
-		NewDec(big.NewInt(1), 1), NewDec(big.NewInt(2), 1), NewDec(big.NewInt(2), 1)}},
+		NewDec(2, 0), NewDec(-2, 0), NewDec(-2, 0), NewDec(2, 0),
+		NewDec(-2, 1), NewDec(-2, 1), NewDec(-1, 1),
+		NewDec(-1, 1), NewDec(0, 1), NewDec(0, 1),
+		NewDec(0, 1),
+		NewDec(0, 1), NewDec(0, 1), NewDec(1, 1),
+		NewDec(1, 1), NewDec(2, 1), NewDec(2, 1)}},
 	{RoundFloor, [...]*Dec{
-		NewDecInt64(1), NewDecInt64(-2), NewDecInt64(-2), NewDecInt64(1),
-		NewDec(big.NewInt(-2), 1), NewDec(big.NewInt(-2), 1), NewDec(big.NewInt(-2), 1),
-		NewDec(big.NewInt(-1), 1), NewDec(big.NewInt(-1), 1), NewDec(big.NewInt(-1), 1),
-		NewDec(big.NewInt(0), 1),
-		NewDec(big.NewInt(0), 1), NewDec(big.NewInt(0), 1), NewDec(big.NewInt(0), 1),
-		NewDec(big.NewInt(1), 1), NewDec(big.NewInt(1), 1), NewDec(big.NewInt(1), 1)}},
+		NewDec(1, 0), NewDec(-2, 0), NewDec(-2, 0), NewDec(1, 0),
+		NewDec(-2, 1), NewDec(-2, 1), NewDec(-2, 1),
+		NewDec(-1, 1), NewDec(-1, 1), NewDec(-1, 1),
+		NewDec(0, 1),
+		NewDec(0, 1), NewDec(0, 1), NewDec(0, 1),
+		NewDec(1, 1), NewDec(1, 1), NewDec(1, 1)}},
 	{RoundCeil, [...]*Dec{
-		NewDecInt64(2), NewDecInt64(-1), NewDecInt64(-1), NewDecInt64(2),
-		NewDec(big.NewInt(-1), 1), NewDec(big.NewInt(-1), 1), NewDec(big.NewInt(-1), 1),
-		NewDec(big.NewInt(0), 1), NewDec(big.NewInt(0), 1), NewDec(big.NewInt(0), 1),
-		NewDec(big.NewInt(0), 1),
-		NewDec(big.NewInt(1), 1), NewDec(big.NewInt(1), 1), NewDec(big.NewInt(1), 1),
-		NewDec(big.NewInt(2), 1), NewDec(big.NewInt(2), 1), NewDec(big.NewInt(2), 1)}},
+		NewDec(2, 0), NewDec(-1, 0), NewDec(-1, 0), NewDec(2, 0),
+		NewDec(-1, 1), NewDec(-1, 1), NewDec(-1, 1),
+		NewDec(0, 1), NewDec(0, 1), NewDec(0, 1),
+		NewDec(0, 1),
+		NewDec(1, 1), NewDec(1, 1), NewDec(1, 1),
+		NewDec(2, 1), NewDec(2, 1), NewDec(2, 1)}},
 }
 
 func TestDecRounders(t *testing.T) {