Merge 584bc5502b into 57a340d853

decimal.go

@@ -124,26 +124,6 @@ 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_test.go

@@ -556,51 +556,6 @@ 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()