Skip to content

G
gostnops
Commit 17916dfe authored by aliiohs's avatar aliiohs
Browse files
Options

change name from BigDecimal to Decimal

parent 73462bb7
Show whitespace changes
Inline Side-by-side
Showing with 98 additions and 91 deletions
math/big/decimal.go
View file @ 17916dfe
......@@ -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
View file @ 17916dfe
......@@ -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
View file @ 17916dfe
......@@ -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)
}
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment