Merge 6e8c4f56de into d00399e161

Mote: Marshal max digits is 30. it decimal.IntPart large than 30,it will be lose extra digits.

decimal.go

@@ -124,6 +124,26 @@ func NewFromBigInt(value *big.Int, exp int32) Decimal {
 	}
 }
 
+// NewFromBigRat returns a new Decimal from a big.Rat. The numerator and
+// denominator are divided and rounded to the given precision.
+//
+// Example:
+//
+//     d1 := NewFromBigRat(big.NewRat(0, 1), 0)    // output: "0"
+//     d2 := NewFromBigRat(big.NewRat(4, 5), 1)    // output: "0.8"
+//     d3 := NewFromBigRat(big.NewRat(1000, 3), 3) // output: "333.333"
+//     d4 := NewFromBigRat(big.NewRat(2, 7), 4)    // output: "0.2857"
+//
+func NewFromBigRat(value *big.Rat, precision int32) Decimal {
+	return Decimal{
+		value: new(big.Int).Set(value.Num()),
+		exp:   0,
+	}.DivRound(Decimal{
+		value: new(big.Int).Set(value.Denom()),
+		exp:   0,
+	}, precision)
+}
+
 // NewFromString returns a new Decimal from a string representation.
 // Trailing zeroes are not trimmed.
 //

decimal_magpack_test.go

@@ -0,0 +1,55 @@
+package decimal
+
+import (
+	"testing"
+)
+
+func TestMsgPack(t *testing.T) {
+	for _, x := range testTable {
+		s := x.short
+		// limit to 31 digits
+		if len(s) > 31 {
+			s = s[:31]
+			if s[30] == '.' {
+				s = s[:30]
+			}
+		}
+
+		// Prepare Test Decimal Data
+		amount, err := NewFromString(s)
+		if err != nil {
+			t.Error(err)
+		}
+		s = amount.String()
+
+		// MarshalMsg
+		var b []byte
+		out, err := amount.MarshalMsg(b)
+		if err != nil {
+			t.Errorf("error marshalMsg %s: %v", s, err)
+		}
+
+		// check msg type
+		typ := out[0] & 0xe0
+		if typ != 0xa0 {
+			t.Errorf("error marshalMsg, expected type = %b, got %b", 0xa0, typ)
+		}
+
+		// check msg len
+		sz := int(out[0] & 0x1f)
+		if sz != len(s) {
+			t.Errorf("error marshalMsg, expected size = %d, got %d", len(s), sz)
+		}
+
+		// UnmarshalMsg
+		var unmarshalAmount Decimal
+		_, err = unmarshalAmount.UnmarshalMsg(out)
+		if err != nil {
+			t.Errorf("error unmarshalMsg %s: %v", s, err)
+		} else if !unmarshalAmount.Equal(amount) {
+			t.Errorf("expected %s, got %s (%s, %d)",
+				amount.String(), unmarshalAmount.String(),
+				unmarshalAmount.value.String(), unmarshalAmount.exp)
+		}
+	}
+}

decimal_msgpack.go

@@ -0,0 +1,94 @@
+package decimal
+
+import (
+	"errors"
+)
+
+var (
+	errShortBytes = errors.New("msgp: too few bytes left to read object")
+)
+
+// MarshalMsg implements msgp.Marshaler
+//  Note: limit to 31 digits, if d.IntPart size large than 31, will be lose.
+func (d Decimal) MarshalMsg(b []byte) ([]byte, error) {
+	o := require(b, d.Msgsize())
+	str := d.String()
+	sz := len(str)
+	// limit to 31 digits
+	// note, if d.IntPart size large than 3, will be lose.
+	if sz > 31 {
+		sz = 31
+		// if last char is '.' then limit to 30 digits
+		if str[30] == '.' {
+			sz = 30
+		}
+
+		str = str[:sz]
+	}
+
+	o, n := ensure(o, 1+sz)
+	o[n] = byte(0xa0 | sz)
+	n++
+
+	return o[:n+copy(o[n:], str)], nil
+}
+
+// UnmarshalMsg implements msgp.Unmarshaler
+func (d *Decimal) UnmarshalMsg(b []byte) ([]byte, error) {
+	o, err := b, errShortBytes
+
+	l := len(b)
+	if l < 1 {
+		return o, err
+	}
+
+	sz := int(b[0] & 0x1f)
+	if len(b[1:]) < sz {
+		return o, err
+	}
+	if *d, err = NewFromString(string(b[1 : sz+1])); err == nil {
+		o = b[sz:]
+	}
+	return o, err
+}
+
+// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
+func (d Decimal) Msgsize() int {
+	return 32
+}
+
+// Require ensures that cap(old)-len(old) >= extra.
+func require(old []byte, extra int) []byte {
+	l := len(old)
+	c := cap(old)
+	r := l + extra
+	if c >= r {
+		return old
+	} else if l == 0 {
+		return make([]byte, 0, extra)
+	}
+	// the new size is the greater
+	// of double the old capacity
+	// and the sum of the old length
+	// and the number of new bytes
+	// necessary.
+	c <<= 1
+	if c < r {
+		c = r
+	}
+	n := make([]byte, l, c)
+	copy(n, old)
+	return n
+}
+
+// ensure 'sz' extra bytes in 'b' btw len(b) and cap(b)
+func ensure(b []byte, sz int) ([]byte, int) {
+	l := len(b)
+	c := cap(b)
+	if c-l < sz {
+		o := make([]byte, (2*c)+sz) // exponential growth
+		n := copy(o, b)
+		return o[:n+sz], n
+	}
+	return b[:l+sz], l
+}

decimal_test.go

@@ -556,6 +556,51 @@ func TestNewFromBigIntWithExponent(t *testing.T) {
 	}
 }
 
+func TestNewFromBigRat(t *testing.T) {
+	mustParseRat := func(val string) *big.Rat {
+		num, _ := new(big.Rat).SetString(val)
+		return num
+	}
+
+	type Inp struct {
+		val  *big.Rat
+		prec int32
+	}
+
+	tests := map[Inp]string{
+		Inp{big.NewRat(0, 1), 16}:                                                     "0",
+		Inp{big.NewRat(4, 5), 16}:                                                     "0.8",
+		Inp{big.NewRat(10, 2), 16}:                                                    "5",
+		Inp{big.NewRat(1023427554493, 43432632), 16}:                                  "23563.5628642767953828", // rounded
+		Inp{big.NewRat(1, 434324545566634), 16}:                                       "0.0000000000000023",
+		Inp{big.NewRat(1, 3), 16}:                                                     "0.3333333333333333",
+		Inp{big.NewRat(2, 3), 2}:                                                      "0.67",               // rounded
+		Inp{big.NewRat(2, 3), 16}:                                                     "0.6666666666666667", // rounded
+		Inp{big.NewRat(10000, 3), 16}:                                                 "3333.3333333333333333",
+		Inp{mustParseRat("30702832066636633479"), 16}:                                 "30702832066636633479",
+		Inp{mustParseRat("487028320159896636679.1827512895753"), 16}:                  "487028320159896636679.1827512895753",
+		Inp{mustParseRat("127028320612589896636633479.173582751289575278357832"), -2}: "127028320612589896636633500",                  // rounded
+		Inp{mustParseRat("127028320612589896636633479.173582751289575278357832"), 16}: "127028320612589896636633479.1735827512895753", // rounded
+		Inp{mustParseRat("127028320612589896636633479.173582751289575278357832"), 32}: "127028320612589896636633479.173582751289575278357832",
+	}
+
+	// add negatives
+	for p, s := range tests {
+		if p.val.Cmp(new(big.Rat)) > 0 {
+			tests[Inp{p.val.Neg(p.val), p.prec}] = "-" + s
+		}
+	}
+
+	for input, s := range tests {
+		d := NewFromBigRat(input.val, input.prec)
+		if d.String() != s {
+			t.Errorf("expected %s, got %s (%s, %d)",
+				s, d.String(),
+				d.value.String(), d.exp)
+		}
+	}
+}
+
 func TestCopy(t *testing.T) {
 	origin := New(1, 0)
 	cpy := origin.Copy()