feat: add functions for Money type

1. *Money.IsZero
2. *Money.RoundToNearestEven
3. *Money.RoundToNearestAway
4. *Money.RoundToZero
5. *Money.Round
6. *Money.Truncate

Author: wayn3h0

money.go

@@ -7,70 +7,117 @@ import (
 	"github.com/golang-plus/math/big"
 )
 
-// Money represents an amount of a specific currency.
+// Money represents an amount (with precision 4) of a specific currency.
 type Money struct {
+	amount   *big.Decimal
 	Currency *Currency
 	Amount   float64
-	decimal  *big.Decimal
-}
-
-// NewMoney returns a new money.
-func NewMoney(currency *Currency, amount float64) (*Money, error) {
-	if currency == nil {
-		return nil, errors.New("currency of money cannot be nil")
-	}
-
-	return &Money{
-		Currency: currency,
-		Amount:   amount,
-		decimal:  big.NewDecimal(amount),
-	}, nil
-}
-
-// MustNewMoney is like as NewMoney but panic if error happens.
-func MustNewMoney(currency *Currency, amount float64) *Money {
-	money, err := NewMoney(currency, amount)
-	if err != nil {
-		panic(err)
-	}
-
-	return money
 }
 
 // Format returns the formatted string of money.
 func (m *Money) Format(formatter *CurrencyFormatter) string {
 	return formatter.Format(m.Amount)
 }
 
-// String returns the string of money (format: currency code + amount).
+// String returns the formatted string (format: currency code + amount).
 func (m *Money) String() string {
 	return fmt.Sprintf("%s %f", m.Currency.Code, m.Amount)
 }
 
-// Add sets m.decimal to the sum of m.decimal and another and returns m.
+// IsZero reports whether the amount is euqal to zero.
+func (m *Money) IsZero() bool {
+	return m.amount.IsZero()
+}
+
+// Sign returns:
+// -1: if m <  0
+//  0: if m == 0
+// +1: if m >  0
+func (m *Money) Sign() int {
+	return m.amount.Sign()
+}
+
+// Add sets amount to the sum of amount and x then returns m.
 func (m *Money) Add(x float64) *Money {
-	m.decimal.Add(big.NewDecimal(x))
-	m.Amount = m.decimal.Float64()
+	m.amount.Add(big.NewDecimal(x))
+	m.Amount, _ = m.amount.Float64()
 	return m
 }
 
-// Sub sets m.decimal to the difference m.decimal-another and returns m.
+// Sub sets amount to the difference amount-x then returns m.
 func (m *Money) Sub(x float64) *Money {
-	m.decimal.Sub(big.NewDecimal(x))
-	m.Amount = m.decimal.Float64()
+	m.amount.Sub(big.NewDecimal(x))
+	m.Amount, _ = m.amount.Float64()
 	return m
 }
 
-// Mul sets m.decimal to the product m.decimal*another and returns m.
+// Mul sets amount to the product amount*x and returns m.
 func (m *Money) Mul(x float64) *Money {
-	m.decimal.Mul(big.NewDecimal(x))
-	m.Amount = m.decimal.Float64()
+	m.amount.Mul(big.NewDecimal(x))
+	m.Amount, _ = m.amount.Float64()
 	return m
 }
 
-// Div sets m.decimal to the quotient m/another and return m.
+// Div sets amount to the quotient amount/x and return m.
 func (m *Money) Div(x float64) *Money {
-	m.decimal.Div(big.NewDecimal(x))
-	m.Amount = m.decimal.Float64()
+	m.amount.Div(big.NewDecimal(x))
+	m.Amount, _ = m.amount.Float64()
 	return m
 }
+
+// RoundToNearestEven rounds the amount by "To Nearest Even" mode with 4 precision.
+// precision indicates the number of digits after the decimal point.
+func (m *Money) RoundToNearestEven(precision uint) *Money {
+	m.amount.RoundToNearestEven(precision)
+	m.Amount, _ = m.amount.Float64()
+	return m
+}
+
+// RoundToNearestEven rounds the amount by "To Nearest Away From Zero" mode with 4 precision.
+// precision indicates the number of digits after the decimal point.
+func (m *Money) RoundToNearestAway(precision uint) *Money {
+	m.amount.RoundToNearestAway(precision)
+	m.Amount, _ = m.amount.Float64()
+	return m
+}
+
+// RoundToZero rounds the amount by "To Zero" mode with 4 precision.
+// precision indicates the number of digits after the decimal point.
+func (m *Money) RoundToZero(precision uint) *Money {
+	m.amount.RoundToZero(precision)
+	m.Amount, _ = m.amount.Float64()
+	return m
+}
+
+// Round is same as RoundToNearestEven.
+func (m *Money) Round(precision uint) *Money {
+	return m.RoundToNearestEven(precision)
+}
+
+// Truncate is same as RoundToZero.
+func (m *Money) Truncate(precision uint) *Money {
+	return m.RoundToZero(precision)
+}
+
+// NewMoney returns a new money.
+func NewMoney(currency *Currency, amount float64) (*Money, error) {
+	if currency == nil {
+		return nil, errors.New("currency of money cannot be nil")
+	}
+
+	return &Money{
+		amount:   big.NewDecimal(amount),
+		Currency: currency,
+		Amount:   amount,
+	}, nil
+}
+
+// MustNewMoney is like as NewMoney but panic if error happens.
+func MustNewMoney(currency *Currency, amount float64) *Money {
+	money, err := NewMoney(currency, amount)
+	if err != nil {
+		panic(err)
+	}
+
+	return money
+}

money_test.go

@@ -17,8 +17,41 @@ func TestMoney(t *testing.T) {
 		GroupSeparator:   ",",
 	}
 
-	m := MustNewMoney(GetCurrency("USD"), -1.0)
-	m.Add(100).Sub(55).Div(2.5).Mul(2)
+	// calculation:
+	data := map[string][4]float64{
+		"-$0.8250":    {1.1, 2.2, 3.3, 4.4},
+		"$2.2000":     {4.4, 3.3, 2.2, 1.1},
+		"$22.2200":    {44.44, 33.33, 22.22, 11.11},
+		"$2,222.2222": {4444.4444, 3333.3333, 2222.2222, 1111.1111},
+		"-$833.3333":  {1111.1111, 2222.2222, 3333.3333, 4444.4444},
+	}
+	for k, v := range data {
+		m := MustNewMoney(GetCurrency("usd"), 0)
+		// + - * /
+		m.Add(v[0]).Sub(v[1]).Mul(v[2]).Div(v[3])
+		testing2.AssertEqual(t, m.Format(cf), k)
+	}
+
+	// rounding:
+
+	// to nearest even
+	data2 := map[float64]float64{
+		2.34564:     2.3456,
+		2.34566:     2.3457,
+		2.34605001:  2.3461,
+		2.34635:     2.3464,
+		2.34645:     2.3464,
+		-2.34564:    -2.3456,
+		-2.34566:    -2.3457,
+		-2.34605001: -2.3461,
+		-2.34635:    -2.3464,
+		-2.34645:    -2.3464,
+		2.34555:     2.3456,
+		2.34525:     2.3452,
+	}
+	for k, v := range data2 {
+		m := MustNewMoney(GetCurrency("usd"), k)
+		testing2.AssertEqual(t, m.RoundToNearestEven(4).Amount, v)
+	}
 
-	testing2.AssertEqual(t, m.Format(cf), "$35.2000")
 }