osmomath: AddMut and QuoMut

548207900.mdttt

@@ -0,0 +1,16 @@
+- mut add
+- test add mut
+- quo  mut
+- test quo mut/ remove want from test struct
+
+<!-- < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < ☺
+v                               ✰  Thanks for creating a PR! ✰    
+v    Before smashing the submit button please review the checkboxes.
+v    If a checkbox is n/a - please still include it but + a little note why
+v    If your PR doesn't close an issue, that's OK!  Just remove the Closes: #XXX line!
+☺ > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > >  -->
+
+Closes: #3773
+
+## What is the purpose of the change
+mutative add and quo + tests

osmomath/decimal.go

@@ -248,6 +248,17 @@ func (d BigDec) Add(d2 BigDec) BigDec {
 	return BigDec{res}
 }
 
+// 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 d
+}
+
 // subtraction
 func (d BigDec) Sub(d2 BigDec) BigDec {
 	res := new(big.Int).Sub(d.i, d2.i)
@@ -332,6 +343,20 @@ func (d BigDec) Quo(d2 BigDec) BigDec {
 	return BigDec{chopped}
 }
 
+// mutative quotient
+func (d BigDec) QuoMut(d2 BigDec) BigDec {
+	// multiply precision twice
+	d.i.Mul(d.i, precisionReuse)
+	d.i.Mul(d.i, precisionReuse)
+
+	d.i.Quo(d.i, d2.i)
+	chopPrecisionAndRound(d.i)
+
+	if d.i.BitLen() > maxDecBitLen {
+		panic("Int overflow")
+	}
+	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

@@ -38,6 +38,59 @@ func (s *decimalTestSuite) assertMutResult(expectedResult, startValue, mutativeR
 	s.Require().Equal(nonMutativeStartValue, startValue)
 }
 
+func TestAddMut(t *testing.T) {
+	tests := []struct {
+		testing osmomath.BigDec
+		adding  osmomath.BigDec
+	}{
+		{osmomath.NewBigDec(0), osmomath.NewBigDec(0)},
+		{osmomath.NewBigDec(1), osmomath.NewBigDec(1)},
+		{osmomath.NewBigDec(10), osmomath.NewBigDec(1)},
+		{osmomath.NewBigDec(12340), osmomath.NewBigDec(10)},
+		{osmomath.NewDecWithPrec(12340, 4), osmomath.NewDecWithPrec(12340, 4)},
+		{osmomath.NewDecWithPrec(12340, 5), osmomath.NewDecWithPrec(12, 5)},
+		{osmomath.NewDecWithPrec(12340, 8), osmomath.NewDecWithPrec(1009009009009009009, 8)},
+		{osmomath.NewDecWithPrec(1009009009009009009, 17), osmomath.NewDecWithPrec(100, 17)},
+	}
+	for _, tc := range tests {
+		want := tc.testing.Add(tc.adding)
+		tc.testing.AddMut(tc.adding)
+
+		require.Equal(t, want, tc.testing)
+	}
+}
+
+func TestQuoMut(t *testing.T) {
+	tests := []struct {
+		testing osmomath.BigDec
+		quo     osmomath.BigDec
+
+		expectingErr bool
+	}{
+		{osmomath.NewBigDec(0), osmomath.NewBigDec(0), true},
+		{osmomath.NewBigDec(1), osmomath.NewBigDec(1), false},
+		{osmomath.NewBigDec(10), osmomath.NewBigDec(1), false},
+		{osmomath.NewBigDec(12340), osmomath.NewBigDec(10), false},
+		{osmomath.NewDecWithPrec(12340, 4), osmomath.NewDecWithPrec(12340, 4), false},
+		{osmomath.NewDecWithPrec(12340, 5), osmomath.NewDecWithPrec(12, 5), false},
+		{osmomath.NewDecWithPrec(1009009009009009009, 8), osmomath.NewDecWithPrec(1000, 8), false},
+		{osmomath.NewDecWithPrec(500, 17), osmomath.NewDecWithPrec(100, 17), false},
+	}
+	for _, tc := range tests {
+		if !tc.expectingErr {
+			want := tc.testing.Quo(tc.quo)
+			tc.testing.QuoMut(tc.quo)
+
+			require.Equal(t, want, tc.testing)
+		} else {
+			save := tc.testing
+
+			require.Panics(t, func() { tc.testing.QuoMut(tc.quo) })
+			require.Equal(t, save, tc.testing)
+		}
+
+	}
+}
 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)
 }