Merge afac94241f into d00399e161

FIX Add functionality to compare if a decimal value is between two decimals #319

decimal.go

@@ -9,7 +9,7 @@
 //
 // To use Decimal as part of a struct:
 //
-//	type StructName struct {
+//	type Struct struct {
 //	    Number Decimal
 //	}
 //
@@ -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.
 //
@@ -1022,6 +1042,13 @@ func (d Decimal) LessThanOrEqual(d2 Decimal) bool {
 	return cmp == -1 || cmp == 0
 }
 
+// Betwee (LTE) return true when d is between d1 and d2 inclusive
+func (d Decimal) IsBetween(d1 Decimal, d2 Decimal) bool {
+	cmp1 := d.Cmp(d1)
+	cmp2 := d.Cmp(d2)
+	return (cmp1 == 1 || cmp1 == 0) && (cmp2 == -1 || cmp2 == 0)
+}
+
 // Sign returns:
 //
 //	-1 if d <  0
@@ -1224,7 +1251,7 @@ func (d Decimal) Round(places int32) Decimal {
 //	NewFromFloat(545).RoundCeil(-2).String()   // output: "600"
 //	NewFromFloat(500).RoundCeil(-2).String()   // output: "500"
 //	NewFromFloat(1.1001).RoundCeil(2).String() // output: "1.11"
-//	NewFromFloat(-1.454).RoundCeil(1).String() // output: "-1.4"
+//	NewFromFloat(-1.454).RoundCeil(1).String() // output: "-1.5"
 func (d Decimal) RoundCeil(places int32) Decimal {
 	if d.exp >= -places {
 		return d
@@ -1249,7 +1276,7 @@ func (d Decimal) RoundCeil(places int32) Decimal {
 //	NewFromFloat(545).RoundFloor(-2).String()   // output: "500"
 //	NewFromFloat(-500).RoundFloor(-2).String()   // output: "-500"
 //	NewFromFloat(1.1001).RoundFloor(2).String() // output: "1.1"
-//	NewFromFloat(-1.454).RoundFloor(1).String() // output: "-1.5"
+//	NewFromFloat(-1.454).RoundFloor(1).String() // output: "-1.4"
 func (d Decimal) RoundFloor(places int32) Decimal {
 	if d.exp >= -places {
 		return d
@@ -1274,7 +1301,7 @@ func (d Decimal) RoundFloor(places int32) Decimal {
 //	NewFromFloat(545).RoundUp(-2).String()   // output: "600"
 //	NewFromFloat(500).RoundUp(-2).String()   // output: "500"
 //	NewFromFloat(1.1001).RoundUp(2).String() // output: "1.11"
-//	NewFromFloat(-1.454).RoundUp(1).String() // output: "-1.5"
+//	NewFromFloat(-1.454).RoundUp(1).String() // output: "-1.4"
 func (d Decimal) RoundUp(places int32) Decimal {
 	if d.exp >= -places {
 		return d
@@ -1301,7 +1328,7 @@ func (d Decimal) RoundUp(places int32) Decimal {
 //	NewFromFloat(545).RoundDown(-2).String()   // output: "500"
 //	NewFromFloat(-500).RoundDown(-2).String()   // output: "-500"
 //	NewFromFloat(1.1001).RoundDown(2).String() // output: "1.1"
-//	NewFromFloat(-1.454).RoundDown(1).String() // output: "-1.4"
+//	NewFromFloat(-1.454).RoundDown(1).String() // output: "-1.5"
 func (d Decimal) RoundDown(places int32) Decimal {
 	if d.exp >= -places {
 		return d

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()
@@ -2548,6 +2593,13 @@ func TestDecimal_Equalities(t *testing.T) {
 	if c.LessThanOrEqual(b) {
 		t.Errorf("%q should not be less than or equal %q", a, b)
 	}
+
+	if !b.IsBetween(c, a) {
+		t.Errorf("%q should be less than or equal  %q", a, b)
+	}
+	if b.IsBetween(a, c) {
+		t.Errorf("%q should not be less than or equal %q", a, b)
+	}
 }
 
 func TestDecimal_ScalesNotEqual(t *testing.T) {