osmomath: AddMut and QuoMut (#3779)

* mut add

* test add mut

* quo  mut

* test quo mut/ remove want from test struct

* refactor exp

* change mutatives code

* change

* not allocaing

* exp change to quomut

* remove file

* refactor quo

* refactor ad

* refactor tests

osmomath/decimal.go

@@ -240,12 +240,20 @@ func (d BigDec) BigInt() *big.Int {
 
 // addition
 func (d BigDec) Add(d2 BigDec) BigDec {
-	res := new(big.Int).Add(d.i, d2.i)
+	copy := d.Clone()
+	copy.AddMut(d2)
+	return copy
+}
 
-	if res.BitLen() > maxDecBitLen {
+// mutative addition
+func (d BigDec) AddMut(d2 BigDec) BigDec {
+	d.i.Add(d.i, d2.i)
+
+	if d.i.BitLen() > maxDecBitLen {
 		panic("Int overflow")
 	}
-	return BigDec{res}
+
+	return d
 }
 
 // subtraction
@@ -319,19 +327,25 @@ func (d BigDec) MulInt64(i int64) BigDec {
 
 // quotient
 func (d BigDec) Quo(d2 BigDec) BigDec {
+	copy := d.Clone()
+	copy.QuoMut(d2)
+	return copy
+}
+
+// mutative quotient
+func (d BigDec) QuoMut(d2 BigDec) BigDec {
 	// multiply precision twice
-	mul := new(big.Int).Mul(d.i, precisionReuse)
-	mul.Mul(mul, precisionReuse)
+	d.i.Mul(d.i, precisionReuse)
+	d.i.Mul(d.i, precisionReuse)
 
-	quo := new(big.Int).Quo(mul, d2.i)
-	chopped := chopPrecisionAndRound(quo)
+	d.i.Quo(d.i, d2.i)
+	chopPrecisionAndRound(d.i)
 
-	if chopped.BitLen() > maxDecBitLen {
+	if d.i.BitLen() > maxDecBitLen {
 		panic("Int overflow")
 	}
-	return BigDec{chopped}
+	return d
 }
-
 func (d BigDec) QuoRaw(d2 int64) BigDec {
 	// multiply precision, so we can chop it later
 	mul := new(big.Int).Mul(d.i, precisionReuse)

osmomath/decimal_test.go

@@ -43,6 +43,53 @@ func (s *decimalTestSuite) assertMutResult(expectedResult, startValue, mutativeR
 	s.Require().Equal(nonMutativeStartValue, startValue)
 }
 
+func (s *decimalTestSuite) TestAddMut() {
+	toAdd := osmomath.MustNewDecFromStr("10")
+	tests := map[string]struct {
+		startValue        osmomath.BigDec
+		expectedMutResult osmomath.BigDec
+	}{
+		"0":  {osmomath.NewBigDec(0), osmomath.NewBigDec(10)},
+		"1":  {osmomath.NewBigDec(1), osmomath.NewBigDec(11)},
+		"10": {osmomath.NewBigDec(10), osmomath.NewBigDec(20)},
+	}
+
+	for name, tc := range tests {
+		s.Run(name, func() {
+			startMut := tc.startValue.Clone()
+			startNonMut := tc.startValue.Clone()
+
+			resultMut := startMut.AddMut(toAdd)
+			resultNonMut := startNonMut.Add(toAdd)
+
+			s.assertMutResult(tc.expectedMutResult, tc.startValue, resultMut, resultNonMut, startMut, startNonMut)
+		})
+	}
+}
+
+func (s *decimalTestSuite) TestQuoMut() {
+	quoBy := osmomath.MustNewDecFromStr("2")
+	tests := map[string]struct {
+		startValue        osmomath.BigDec
+		expectedMutResult osmomath.BigDec
+	}{
+		"0":  {osmomath.NewBigDec(0), osmomath.NewBigDec(0)},
+		"1":  {osmomath.NewBigDec(1), osmomath.MustNewDecFromStr("0.5")},
+		"10": {osmomath.NewBigDec(10), osmomath.NewBigDec(5)},
+	}
+
+	for name, tc := range tests {
+		s.Run(name, func() {
+			startMut := tc.startValue.Clone()
+			startNonMut := tc.startValue.Clone()
+
+			resultMut := startMut.QuoMut(quoBy)
+			resultNonMut := startNonMut.Quo(quoBy)
+
+			s.assertMutResult(tc.expectedMutResult, tc.startValue, resultMut, resultNonMut, startMut, startNonMut)
+		})
+	}
+}
 func TestDecApproxEq(t *testing.T) {
 	// d1 = 0.55, d2 = 0.6, tol = 0.1
 	d1 := osmomath.NewDecWithPrec(55, 2)

osmomath/exp2.go

@@ -93,9 +93,9 @@ func exp2ChebyshevRationalApprox(x BigDec) BigDec {
 	for i := 1; i < len(numeratorCoefficients13Param); i++ {
 		x_exp_i.MulMut(x)
 
-		h_x = h_x.Add(numeratorCoefficients13Param[i].Mul(x_exp_i))
-		p_x = p_x.Add(denominatorCoefficients13Param[i].Mul(x_exp_i))
+		h_x.AddMut(numeratorCoefficients13Param[i].Mul(x_exp_i))
+		p_x.AddMut(denominatorCoefficients13Param[i].Mul(x_exp_i))
 	}
 
-	return h_x.Quo(p_x)
+	return h_x.QuoMut(p_x)
 }