change name from BigDecimal to Decimal

math/big/decimal.go

@@ -113,7 +113,7 @@ var (
 		999999900,
 		999999990,
 	}
-	zeroBigDecimal = BigDecimal{}
+	zeroBigDecimal = Decimal{}
 )
 
 // add adds a and b and carry, returns the sum and new carry.
@@ -223,11 +223,11 @@ func digitsToWords(digits int) int {
 	return (digits + digitsPerWord - 1) / digitsPerWord
 }
 
-// BigDecimalStructSize is the struct size of BigDecimal.
+// BigDecimalStructSize is the struct size of Decimal.
 const BigDecimalStructSize = 40
 
-// BigDecimal represents a decimal value.
-type BigDecimal struct {
+// Decimal represents a decimal value.
+type Decimal struct {
 	digitsInt int8 // the number of *decimal* digits before the point.
 
 	digitsFrac int8 // the number of decimal digits after the point.
@@ -239,32 +239,39 @@ type BigDecimal struct {
 	//  wordBuf is an array of int32 words.
 	// A word is an int32 value can hold 9 digits.(0 <= word < wordBase)
 	wordBuf [maxWordBufLen]int32
+
+	// for hessian
+	Value string
+}
+
+func (Decimal) JavaClassName() string {
+	return "java.math.BigDecimal"
 }
 
 // IsNegative returns whether a decimal is negative.
-func (d *BigDecimal) IsNegative() bool {
+func (d *Decimal) IsNegative() bool {
 	return d.negative
 }
 
 // GetDigitsFrac returns the digitsFrac.
-func (d *BigDecimal) GetDigitsFrac() int8 {
+func (d *Decimal) GetDigitsFrac() int8 {
 	return d.digitsFrac
 }
 
 // String returns the decimal string representation rounded to resultFrac.
-func (d *BigDecimal) String() string {
+func (d *Decimal) String() string {
 	tmp := *d
 	_ = tmp.Round(&tmp, int(tmp.resultFrac), ModeHalfEven)
 	//todo terror.Log(errors.Trace(err))
 	return string(tmp.ToString())
 }
 
-func (d *BigDecimal) stringSize() int {
+func (d *Decimal) stringSize() int {
 	// sign, zero integer and dot.
 	return int(d.digitsInt + d.digitsFrac + 3)
 }
 
-func (d *BigDecimal) removeLeadingZeros() (wordIdx int, digitsInt int) {
+func (d *Decimal) removeLeadingZeros() (wordIdx int, digitsInt int) {
 	digitsInt = int(d.digitsInt)
 	i := ((digitsInt - 1) % digitsPerWord) + 1
 	for digitsInt > 0 && d.wordBuf[wordIdx] == 0 {
@@ -280,7 +287,7 @@ func (d *BigDecimal) removeLeadingZeros() (wordIdx int, digitsInt int) {
 	return
 }
 
-func (d *BigDecimal) removeTrailingZeros() (lastWordIdx int, digitsFrac int) {
+func (d *Decimal) removeTrailingZeros() (lastWordIdx int, digitsFrac int) {
 	digitsFrac = int(d.digitsFrac)
 	i := ((digitsFrac - 1) % digitsPerWord) + 1
 	lastWordIdx = digitsToWords(int(d.digitsInt)) + digitsToWords(int(d.digitsFrac))
@@ -304,7 +311,7 @@ func (d *BigDecimal) removeTrailingZeros() (lastWordIdx int, digitsFrac int) {
 //      str       - result string
 //      errCode   - eDecOK/eDecTruncate/eDecOverflow
 //
-func (d *BigDecimal) ToString() (str []byte) {
+func (d *Decimal) ToString() (str []byte) {
 	str = make([]byte, d.stringSize())
 	digitsFrac := int(d.digitsFrac)
 	wordStartIdx, digitsInt := d.removeLeadingZeros()
@@ -382,7 +389,7 @@ func (d *BigDecimal) ToString() (str []byte) {
 }
 
 // FromString parses decimal from string.
-func (d *BigDecimal) FromString(str []byte) error {
+func (d *Decimal) FromString(str []byte) error {
 	for i := 0; i < len(str); i++ {
 		if !isSpace(str[i]) {
 			str = str[i:]
@@ -524,7 +531,7 @@ func (d *BigDecimal) FromString(str []byte) error {
 //   eDecOverflow    operation lead to overflow, number is untoched
 //   eDecTruncated   number was rounded to fit into buffer
 //
-func (d *BigDecimal) Shift(shift int) error {
+func (d *Decimal) Shift(shift int) error {
 	var err error
 	if shift == 0 {
 		return nil
@@ -688,7 +695,7 @@ func (d *BigDecimal) Shift(shift int) error {
       start - index (from 0 ) of first decimal digits.
       end   - index of position just after last decimal digit.
 */
-func (d *BigDecimal) digitBounds() (start, end int) {
+func (d *Decimal) digitBounds() (start, end int) {
 	var i int
 	bufBeg := 0
 	bufLen := digitsToWords(int(d.digitsInt)) + digitsToWords(int(d.digitsFrac))
@@ -741,7 +748,7 @@ func (d *BigDecimal) digitBounds() (start, end int) {
     Result fitting in the buffer should be garanted.
     'shift' have to be from 1 to digitsPerWord-1 (inclusive)
 */
-func (d *BigDecimal) doMiniLeftShift(shift, beg, end int) {
+func (d *Decimal) doMiniLeftShift(shift, beg, end int) {
 	bufFrom := beg / digitsPerWord
 	bufEnd := (end - 1) / digitsPerWord
 	cShift := digitsPerWord - shift
@@ -765,7 +772,7 @@ func (d *BigDecimal) doMiniLeftShift(shift, beg, end int) {
     Result fitting in the buffer should be garanted.
     'shift' have to be from 1 to digitsPerWord-1 (inclusive)
 */
-func (d *BigDecimal) doMiniRightShift(shift, beg, end int) {
+func (d *Decimal) doMiniRightShift(shift, beg, end int) {
 	bufFrom := (end - 1) / digitsPerWord
 	bufEnd := beg / digitsPerWord
 	cShift := digitsPerWord - shift
@@ -793,7 +800,7 @@ func (d *BigDecimal) doMiniRightShift(shift, beg, end int) {
 //
 // RETURN VALUE
 //  eDecOK/eDecTruncated
-func (d *BigDecimal) Round(to *BigDecimal, frac int, roundMode RoundMode) (err error) {
+func (d *Decimal) Round(to *Decimal, frac int, roundMode RoundMode) (err error) {
 	// wordsFracTo is the number of fraction words in buffer.
 	wordsFracTo := (frac + 1) / digitsPerWord
 	if frac > 0 {
@@ -968,7 +975,7 @@ func (d *BigDecimal) Round(to *BigDecimal, frac int, roundMode RoundMode) (err e
 }
 
 // FromInt sets the decimal value from int64.
-func (d *BigDecimal) FromInt(val int64) *BigDecimal {
+func (d *Decimal) FromInt(val int64) *Decimal {
 	var uVal uint64
 	if val < 0 {
 		d.negative = true
@@ -980,7 +987,7 @@ func (d *BigDecimal) FromInt(val int64) *BigDecimal {
 }
 
 // FromUint sets the decimal value from uint64.
-func (d *BigDecimal) FromUint(val uint64) *BigDecimal {
+func (d *Decimal) FromUint(val uint64) *Decimal {
 	x := val
 	wordIdx := 1
 	for x >= wordBase {
@@ -1000,7 +1007,7 @@ func (d *BigDecimal) FromUint(val uint64) *BigDecimal {
 }
 
 // ToInt returns int part of the decimal, returns the result and errcode.
-func (d *BigDecimal) ToInt() (int64, error) {
+func (d *Decimal) ToInt() (int64, error) {
 	var x int64
 	wordIdx := 0
 	for i := d.digitsInt; i > 0; i -= digitsPerWord {
@@ -1041,7 +1048,7 @@ func (d *BigDecimal) ToInt() (int64, error) {
 }
 
 // ToUint returns int part of the decimal, returns the result and errcode.
-func (d *BigDecimal) ToUint() (uint64, error) {
+func (d *Decimal) ToUint() (uint64, error) {
 	if d.negative {
 		return 0, ErrOverflow
 	}
@@ -1065,13 +1072,13 @@ func (d *BigDecimal) ToUint() (uint64, error) {
 }
 
 // FromFloat64 creates a decimal from float64 value.
-func (d *BigDecimal) FromFloat64(f float64) error {
+func (d *Decimal) FromFloat64(f float64) error {
 	s := strconv.FormatFloat(f, 'g', -1, 64)
 	return d.FromString([]byte(s))
 }
 
 // ToFloat64 converts decimal to float64 value.
-func (d *BigDecimal) ToFloat64() (float64, error) {
+func (d *Decimal) ToFloat64() (float64, error) {
 	f, err := strconv.ParseFloat(d.String(), 64)
 	if err != nil {
 		err = ErrOverflow
@@ -1157,7 +1164,7 @@ with the correct -1/0/+1 result
 
                 7E F2 04 C7 2D FB 2D
 */
-func (d *BigDecimal) ToBin(precision, frac int) ([]byte, error) {
+func (d *Decimal) ToBin(precision, frac int) ([]byte, error) {
 	if precision > digitsPerWord*maxWordBufLen || precision < 0 || frac > maxDecimalScale || frac < 0 {
 		return nil, ErrBadNumber
 	}
@@ -1269,7 +1276,7 @@ func (d *BigDecimal) ToBin(precision, frac int) ([]byte, error) {
 
 // ToHashKey removes the leading and trailing zeros and generates a hash key.
 // Two Decimals dec0 and dec1 with different fraction will generate the same hash keys if dec0.Compare(dec1) == 0.
-func (d *BigDecimal) ToHashKey() ([]byte, error) {
+func (d *Decimal) ToHashKey() ([]byte, error) {
 	_, digitsInt := d.removeLeadingZeros()
 	_, digitsFrac := d.removeTrailingZeros()
 	prec := digitsInt + digitsFrac
@@ -1288,7 +1295,7 @@ func (d *BigDecimal) ToHashKey() ([]byte, error) {
 }
 
 // PrecisionAndFrac returns the internal precision and frac number.
-func (d *BigDecimal) PrecisionAndFrac() (precision, frac int) {
+func (d *Decimal) PrecisionAndFrac() (precision, frac int) {
 	frac = int(d.digitsFrac)
 	_, digitsInt := d.removeLeadingZeros()
 	precision = digitsInt + frac
@@ -1299,7 +1306,7 @@ func (d *BigDecimal) PrecisionAndFrac() (precision, frac int) {
 }
 
 // IsZero checks whether it's a zero decimal.
-func (d *BigDecimal) IsZero() bool {
+func (d *Decimal) IsZero() bool {
 	isZero := true
 	for _, val := range d.wordBuf {
 		if val != 0 {
@@ -1311,7 +1318,7 @@ func (d *BigDecimal) IsZero() bool {
 }
 
 // FromBin Restores decimal from its binary fixed-length representation.
-func (d *BigDecimal) FromBin(bin []byte, precision, frac int) (binSize int, err error) {
+func (d *Decimal) FromBin(bin []byte, precision, frac int) (binSize int, err error) {
 	if len(bin) == 0 {
 		*d = zeroBigDecimal
 		return 0, ErrBadNumber
@@ -1460,7 +1467,7 @@ func writeWord(b []byte, word int32, size int) {
 }
 
 // Compare compares one decimal to another, returns -1/0/1.
-func (d *BigDecimal) Compare(to *BigDecimal) int {
+func (d *Decimal) Compare(to *Decimal) int {
 	if d.negative == to.negative {
 		cmp, _ := doSub(d, to, nil)
 		//todo terror.Log(errors.Trace(err))
@@ -1473,7 +1480,7 @@ func (d *BigDecimal) Compare(to *BigDecimal) int {
 }
 
 // DecimalNeg reverses decimal's sign.
-func DecimalNeg(from *BigDecimal) *BigDecimal {
+func DecimalNeg(from *Decimal) *Decimal {
 	to := *from
 	if from.IsZero() {
 		return &to
@@ -1485,7 +1492,7 @@ func DecimalNeg(from *BigDecimal) *BigDecimal {
 // DecimalAdd adds two decimals, sets the result to 'to'.
 // Note: DO NOT use `from1` or `from2` as `to` since the metadata
 // of `to` may be changed during evaluating.
-func DecimalAdd(from1, from2, to *BigDecimal) error {
+func DecimalAdd(from1, from2, to *Decimal) error {
 	to.resultFrac = myMaxInt8(from1.resultFrac, from2.resultFrac)
 	if from1.negative == from2.negative {
 		return doAdd(from1, from2, to)
@@ -1495,7 +1502,7 @@ func DecimalAdd(from1, from2, to *BigDecimal) error {
 }
 
 // DecimalSub subs one decimal from another, sets the result to 'to'.
-func DecimalSub(from1, from2, to *BigDecimal) error {
+func DecimalSub(from1, from2, to *Decimal) error {
 	to.resultFrac = myMaxInt8(from1.resultFrac, from2.resultFrac)
 	if from1.negative == from2.negative {
 		_, err := doSub(from1, from2, to)
@@ -1504,7 +1511,7 @@ func DecimalSub(from1, from2, to *BigDecimal) error {
 	return doAdd(from1, from2, to)
 }
 
-func doSub(from1, from2, to *BigDecimal) (cmp int, err error) {
+func doSub(from1, from2, to *Decimal) (cmp int, err error) {
 	var (
 		wordsInt1   = digitsToWords(int(from1.digitsInt))
 		wordsFrac1  = digitsToWords(int(from1.digitsFrac))
@@ -1669,7 +1676,7 @@ func doSub(from1, from2, to *BigDecimal) (cmp int, err error) {
 	return 0, err
 }
 
-func doAdd(from1, from2, to *BigDecimal) error {
+func doAdd(from1, from2, to *Decimal) error {
 	var (
 		err         error
 		wordsInt1   = digitsToWords(int(from1.digitsInt))
@@ -1775,7 +1782,7 @@ func doAdd(from1, from2, to *BigDecimal) error {
 	return err
 }
 
-func maxDecimal(precision, frac int, to *BigDecimal) {
+func maxDecimal(precision, frac int, to *Decimal) {
 	digitsInt := precision - frac
 	to.negative = false
 	to.digitsInt = int8(digitsInt)
@@ -1823,7 +1830,7 @@ DecimalMul multiplies two decimals.
     XXX if this library is to be used with huge numbers of thousands of
     digits, fast multiplication must be implemented.
 */
-func DecimalMul(from1, from2, to *BigDecimal) error {
+func DecimalMul(from1, from2, to *Decimal) error {
 	var (
 		err         error
 		wordsInt1   = digitsToWords(int(from1.digitsInt))
@@ -1951,7 +1958,7 @@ func DecimalMul(from1, from2, to *BigDecimal) error {
 // from2    - divisor
 // to       - quotient
 // fracIncr - increment of fraction
-func DecimalDiv(from1, from2, to *BigDecimal, fracIncr int) error {
+func DecimalDiv(from1, from2, to *Decimal, fracIncr int) error {
 	to.resultFrac = myMinInt8(from1.resultFrac+int8(fracIncr), maxDecimalScale)
 	return doDivMod(from1, from2, to, nil, fracIncr)
 }
@@ -1980,12 +1987,12 @@ DecimalMod does modulus of two decimals.
 
    thus, there's no requirement for M or N to be integers
 */
-func DecimalMod(from1, from2, to *BigDecimal) error {
+func DecimalMod(from1, from2, to *Decimal) error {
 	to.resultFrac = myMaxInt8(from1.resultFrac, from2.resultFrac)
 	return doDivMod(from1, from2, nil, to, 0)
 }
 
-func doDivMod(from1, from2, to, mod *BigDecimal, fracIncr int) error {
+func doDivMod(from1, from2, to, mod *Decimal, fracIncr int) error {
 	var (
 		frac1 = digitsToWords(int(from1.digitsFrac)) * digitsPerWord
 		prec1 = int(from1.digitsInt) + frac1
@@ -2246,34 +2253,34 @@ func DecimalPeak(b []byte) (int, error) {
 	return decimalBinSize(precision, frac) + 2, nil
 }
 
-// NewDecFromInt creates a BigDecimal from int.
-func NewDecFromInt(i int64) *BigDecimal {
-	return new(BigDecimal).FromInt(i)
+// NewDecFromInt creates a Decimal from int.
+func NewDecFromInt(i int64) *Decimal {
+	return new(Decimal).FromInt(i)
 }
 
-// NewDecFromUint creates a BigDecimal from uint.
-func NewDecFromUint(i uint64) *BigDecimal {
-	return new(BigDecimal).FromUint(i)
+// NewDecFromUint creates a Decimal from uint.
+func NewDecFromUint(i uint64) *Decimal {
+	return new(Decimal).FromUint(i)
 }
 
-// NewDecFromFloatForTest creates a BigDecimal from float, as it returns no error, it should only be used in test.
-func NewDecFromFloatForTest(f float64) *BigDecimal {
-	dec := new(BigDecimal)
+// NewDecFromFloatForTest creates a Decimal from float, as it returns no error, it should only be used in test.
+func NewDecFromFloatForTest(f float64) *Decimal {
+	dec := new(Decimal)
 	_ = dec.FromFloat64(f)
 	//todo terror.Log(errors.Trace(err))
 	return dec
 }
 
-// NewDecFromStringForTest creates a BigDecimal from string, as it returns no error, it should only be used in test.
-func NewDecFromStringForTest(s string) *BigDecimal {
-	dec := new(BigDecimal)
+// NewDecFromStringForTest creates a Decimal from string, as it returns no error, it should only be used in test.
+func NewDecFromStringForTest(s string) *Decimal {
+	dec := new(Decimal)
 	_ = dec.FromString([]byte(s))
 	//todo terror.Log(errors.Trace(err))
 	return dec
 }
 
 // NewMaxOrMinDec returns the max or min value decimal for given precision and fraction.
-func NewMaxOrMinDec(negative bool, prec, frac int) *BigDecimal {
+func NewMaxOrMinDec(negative bool, prec, frac int) *Decimal {
 	str := make([]byte, prec+2)
 	for i := 0; i < len(str); i++ {
 		str[i] = '9'
@@ -2284,7 +2291,7 @@ func NewMaxOrMinDec(negative bool, prec, frac int) *BigDecimal {
 		str[0] = '+'
 	}
 	str[1+prec-frac] = '.'
-	dec := new(BigDecimal)
+	dec := new(Decimal)
 	_ = dec.FromString(str)
 	//todo terror.Log(errors.Trace(err))
 	return dec

math/big/decimal_benchmark_test.go

@@ -17,11 +17,11 @@ import "testing"
 
 func BenchmarkRound(b *testing.B) {
 	b.StopTimer()
-	var roundTo BigDecimal
+	var roundTo Decimal
 	tests := []struct {
 		input    string
 		scale    int
-		inputDec BigDecimal
+		inputDec Decimal
 	}{
 		{input: "123456789.987654321", scale: 1},
 		{input: "15.1", scale: 0},

math/big/decimal_test.go

@@ -50,7 +50,7 @@ func TestFromUint(t *testing.T) {
 		{18446744073709551615, "18446744073709551615"},
 	}
 	for _, tt := range tests {
-		var dec BigDecimal
+		var dec Decimal
 		dec.FromUint(tt.input)
 		str := dec.ToString()
 		assert.Equal(t, string(str), tt.output)
@@ -73,7 +73,7 @@ func TestToInt(t *testing.T) {
 		{"-9223372036854775809", -9223372036854775808, ErrOverflow},
 	}
 	for _, tt := range tests {
-		var dec BigDecimal
+		var dec Decimal
 		dec.FromString([]byte(tt.input))
 		result, ec := dec.ToInt()
 		assert.Equal(t, ec, tt.err)
@@ -97,7 +97,7 @@ func TestToUint(t *testing.T) {
 		{"9999999999999999999999999.000", 18446744073709551615, ErrOverflow},
 	}
 	for _, tt := range tests {
-		var dec BigDecimal
+		var dec Decimal
 		_ = dec.FromString([]byte(tt.input))
 		result, ec := dec.ToUint()
 		assert.Equal(t, ec, tt.err)
@@ -135,7 +135,7 @@ func TestToFloat(t *testing.T) {
 		{"1234500009876.5", 1234500009876.5},
 	}
 	for _, ca := range tests {
-		var dec BigDecimal
+		var dec Decimal
 		_ = dec.FromString([]byte(ca.s))
 		f, _ := dec.ToFloat64()
 		assert.Equal(t, f, ca.f)
@@ -159,7 +159,7 @@ func TestToHashKey(t *testing.T) {
 	for _, ca := range tests {
 		keys := make([]string, 0, len(ca.numbers))
 		for _, num := range ca.numbers {
-			var dec BigDecimal
+			var dec Decimal
 			assert.Equal(t, dec.FromString([]byte(num)), nil)
 			key, err := dec.ToHashKey()
 			assert.Equal(t, err, nil)
@@ -195,14 +195,14 @@ func TestToHashKey(t *testing.T) {
 	for _, ca := range binTests {
 		keys := make([]string, 0, len(ca.hashNumbers)+len(ca.binNumbers))
 		for _, num := range ca.hashNumbers {
-			var dec BigDecimal
+			var dec Decimal
 			assert.Equal(t, dec.FromString([]byte(num)), nil)
 			key, err := dec.ToHashKey()
 			assert.Equal(t, err, nil)
 			keys = append(keys, string(key))
 		}
 		for _, num := range ca.binNumbers {
-			var dec BigDecimal
+			var dec Decimal
 			assert.Equal(t, dec.FromString([]byte(num)), nil)
 			prec, frac := dec.PrecisionAndFrac() // remove leading zeros but trailing zeros remain
 			key, err := dec.ToBin(prec, frac)
@@ -226,7 +226,7 @@ func TestRemoveTrailingZeros(t *testing.T) {
 		"123987654321.123456789000", "000000000123", "123456789.987654321", "999.999000",
 	}
 	for _, ca := range tests {
-		var dec BigDecimal
+		var dec Decimal
 		assert.Equal(t, dec.FromString([]byte(ca)), nil)
 
 		// calculate the number of digits after point but trailing zero
@@ -258,7 +258,7 @@ func TestShift(t *testing.T) {
 	}
 	var dotest = func(t *testing.T, tests []tcase) {
 		for _, ca := range tests {
-			var dec BigDecimal
+			var dec Decimal
 			err := dec.FromString([]byte(ca.input))
 			//assert.Equal(t, err, IsNil)
 			//origin := dec
@@ -389,9 +389,9 @@ func TestRoundWithHalfEven(t *testing.T) {
 	}
 
 	for _, ca := range tests {
-		var dec BigDecimal
+		var dec Decimal
 		dec.FromString([]byte(ca.input))
-		var rounded BigDecimal
+		var rounded Decimal
 		err := dec.Round(&rounded, ca.scale, ModeHalfEven)
 		assert.Equal(t, err, ca.err)
 		result := rounded.ToString()
@@ -423,9 +423,9 @@ func TestRoundWithTruncate(t *testing.T) {
 		{"999999999", -9, "0", nil},
 	}
 	for _, ca := range tests {
-		var dec BigDecimal
+		var dec Decimal
 		dec.FromString([]byte(ca.input))
-		var rounded BigDecimal
+		var rounded Decimal
 		err := dec.Round(&rounded, ca.scale, ModeTruncate)
 		assert.Equal(t, err, ca.err)
 		result := rounded.ToString()
@@ -458,9 +458,9 @@ func TestRoundWithCeil(t *testing.T) {
 		{"999999999", -9, "1000000000", nil},
 	}
 	for _, ca := range tests {
-		var dec BigDecimal
+		var dec Decimal
 		dec.FromString([]byte(ca.input))
-		var rounded BigDecimal
+		var rounded Decimal
 		err := dec.Round(&rounded, ca.scale, modeCeiling)
 		assert.Equal(t, err, ca.err)
 		result := rounded.ToString()
@@ -485,7 +485,7 @@ func TestFromString(t *testing.T) {
 		{"1e -1", "0.1", nil},
 	}
 	for _, ca := range tests {
-		var dec BigDecimal
+		var dec Decimal
 		err := dec.FromString([]byte(ca.input))
 		if err != nil {
 			assert.Equal(t, err, ca.err)
@@ -499,7 +499,7 @@ func TestFromString(t *testing.T) {
 		{"123450.000098765", "123450", ErrTruncated},
 	}
 	for _, ca := range tests {
-		var dec BigDecimal
+		var dec Decimal
 		err := dec.FromString([]byte(ca.input))
 		assert.Equal(t, err, ca.err)
 		result := string(dec.ToString())
@@ -519,7 +519,7 @@ func TestToString(t *testing.T) {
 		{"00123.123", "123.123"},
 	}
 	for _, ca := range tests {
-		var dec BigDecimal
+		var dec Decimal
 		_ = dec.FromString([]byte(ca.input))
 		result := dec.ToString()
 		assert.Equal(t, string(result), ca.output)
@@ -552,18 +552,18 @@ func TestToBinFromBin(t *testing.T) {
 		{"1000", 3, 0, "0", ErrOverflow},
 	}
 	for _, ca := range tests {
-		var dec BigDecimal
+		var dec Decimal
 		err := dec.FromString([]byte(ca.input))
 		assert.Equal(t, err, nil)
 		buf, err := dec.ToBin(ca.precision, ca.frac)
 		assert.Equal(t, err, ca.err)
-		var dec2 BigDecimal
+		var dec2 Decimal
 		_, err = dec2.FromBin(buf, ca.precision, ca.frac)
 		assert.Equal(t, err, nil)
 		str := dec2.ToString()
 		assert.Equal(t, string(str), ca.output)
 	}
-	var dec BigDecimal
+	var dec Decimal
 	dec.FromInt(1)
 	errTests := []struct {
 		prec int
@@ -600,7 +600,7 @@ func TestCompare(t *testing.T) {
 		{"1.1", "1.2", -1},
 	}
 	for _, tt := range tests {
-		var a, b BigDecimal
+		var a, b Decimal
 		_ = a.FromString([]byte(tt.a))
 		_ = b.FromString([]byte(tt.b))
 		assert.Equal(t, a.Compare(&b), tt.cmp)
@@ -631,7 +631,7 @@ func TestMaxDecimal(t *testing.T) {
 		{40, 20, "99999999999999999999.99999999999999999999"},
 	}
 	for _, tt := range tests {
-		var dec BigDecimal
+		var dec Decimal
 		maxDecimal(tt.prec, tt.frac, &dec)
 		str := dec.ToString()
 		assert.Equal(t, string(str), tt.result)
@@ -684,7 +684,7 @@ func TestAdd(t *testing.T) {
 	for _, tt := range tests {
 		a := NewDecFromStringForTest(tt.a)
 		b := NewDecFromStringForTest(tt.b)
-		var sum BigDecimal
+		var sum Decimal
 		err := DecimalAdd(a, b, &sum)
 		assert.Equal(t, err, tt.err)
 		result := sum.ToString()
@@ -716,7 +716,7 @@ func TestSub(t *testing.T) {
 		{"12345", "-123.45", "12468.45", nil},
 	}
 	for _, tt := range tests {
-		var a, b, sum BigDecimal
+		var a, b, sum Decimal
 		a.FromString([]byte(tt.a))
 		b.FromString([]byte(tt.b))
 		err := DecimalSub(&a, &b, &sum)
@@ -747,7 +747,7 @@ func TestMul(t *testing.T) {
 		{"0.5999991229317", "0.918755041726042", "0.5512522192247026369112773314", nil},
 	}
 	for _, tt := range tests {
-		var a, b, product BigDecimal
+		var a, b, product Decimal
 		a.FromString([]byte(tt.a))
 		b.FromString([]byte(tt.b))
 		err := DecimalMul(&a, &b, &product)
@@ -782,7 +782,7 @@ func TestDivMod(t *testing.T) {
 		{"51", "0.003430", "14868.804664723032069970", nil},
 	}
 	for _, tt := range tests {
-		var a, b, to BigDecimal
+		var a, b, to Decimal
 		a.FromString([]byte(tt.a))
 		b.FromString([]byte(tt.b))
 		err := doDivMod(&a, &b, &to, nil, 5)
@@ -804,7 +804,7 @@ func TestDivMod(t *testing.T) {
 		{"0.0000000001", "1.0", "0.0000000001", nil},
 	}
 	for _, tt := range tests {
-		var a, b, to BigDecimal
+		var a, b, to Decimal
 		a.FromString([]byte(tt.a))
 		b.FromString([]byte(tt.b))
 		ec := doDivMod(&a, &b, nil, &to, 0)
@@ -824,7 +824,7 @@ func TestDivMod(t *testing.T) {
 		{"51", "0.003430", "14868.8047", nil},
 	}
 	for _, tt := range tests {
-		var a, b, to BigDecimal
+		var a, b, to Decimal
 		a.FromString([]byte(tt.a))
 		b.FromString([]byte(tt.b))
 		ec := DecimalDiv(&a, &b, &to, DivFracIncr)
@@ -842,10 +842,10 @@ func TestDivMod(t *testing.T) {
 		{"51", "0.003430", "0.002760", nil},
 	}
 	for _, tt := range tests {
-		var a, b, to BigDecimal
-		a.FromString([]byte(tt.a))
-		b.FromString([]byte(tt.b))
+		var a, b, to Decimal
 		ec := DecimalMod(&a, &b, &to)
+		_ = a.FromString([]byte(tt.a))
+		_ = b.FromString([]byte(tt.b))
 		assert.Equal(t, ec, tt.err)
 		if tt.err == ErrDivByZero {
 			continue
@@ -885,9 +885,9 @@ func benchmarkBigDecimalToBinOrHashCases() []string {
 
 func BenchmarkBigDecimalToBin(b *testing.B) {
 	cases := benchmarkBigDecimalToBinOrHashCases()
-	decs := make([]*BigDecimal, 0, len(cases))
+	decs := make([]*Decimal, 0, len(cases))
 	for _, ca := range cases {
-		var dec BigDecimal
+		var dec Decimal
 		if err := dec.FromString([]byte(ca)); err != nil {
 			b.Fatal(err)
 		}
@@ -908,9 +908,9 @@ func BenchmarkBigDecimalToBin(b *testing.B) {
 
 func BenchmarkBigDecimalToHashKey(b *testing.B) {
 	cases := benchmarkBigDecimalToBinOrHashCases()
-	decs := make([]*BigDecimal, 0, len(cases))
+	decs := make([]*Decimal, 0, len(cases))
 	for _, ca := range cases {
-		var dec BigDecimal
+		var dec Decimal
 		if err := dec.FromString([]byte(ca)); err != nil {
 			b.Fatal(err)
 		}