Merge pull request #1342 from CosmWasm/1186-decimal-pow-saturating

`Decimal`/`Decimal256`: Implement `pow`/`saturating_pow`

CHANGELOG.md

@@ -15,6 +15,7 @@ and this project adheres to
 - cosmwasm-std: Implement `Rem`/`RemAssign` for `Decimal`/`Decimal256`.
 - cosmwasm-std: Implement `checked_add`/`_sub`/`_div`/`_rem` for
   `Decimal`/`Decimal256`.
+- cosmwasm-std: Implement `pow`/`saturating_pow` for `Decimal`/`Decimal256`.
 
 [#1334]: https://github.com/CosmWasm/cosmwasm/pull/1334
 

packages/std/src/math/decimal.rs

@@ -212,6 +212,14 @@ impl Decimal {
             })
     }
 
+    /// Raises a value to the power of `exp`, panics if an overflow occurred.
+    pub fn pow(self, exp: u32) -> Self {
+        match self.checked_pow(exp) {
+            Ok(value) => value,
+            Err(_) => panic!("Multiplication overflow"),
+        }
+    }
+
     /// Raises a value to the power of `exp`, returning an `OverflowError` if an overflow occurred.
     pub fn checked_pow(self, exp: u32) -> Result<Self, OverflowError> {
         // This uses the exponentiation by squaring algorithm:
@@ -245,6 +253,14 @@ impl Decimal {
         })
     }
 
+    /// Raises a value to the power of `exp`, returns MAX on overflow.
+    pub fn saturating_pow(self, exp: u32) -> Self {
+        match self.checked_pow(exp) {
+            Ok(value) => value,
+            Err(_) => Self::MAX,
+        }
+    }
+
     pub fn checked_div(self, other: Self) -> Result<Self, CheckedFromRatioError> {
         Decimal::checked_from_ratio(self.numerator(), other.numerator())
     }
@@ -1835,4 +1851,25 @@ mod tests {
             Err(DivideByZeroError { .. })
         ));
     }
+
+    #[test]
+    fn decimal_pow_works() {
+        assert_eq!(Decimal::percent(200).pow(2), Decimal::percent(400));
+        assert_eq!(Decimal::percent(200).pow(10), Decimal::percent(102400));
+    }
+
+    #[test]
+    #[should_panic]
+    fn decimal_pow_overflow_panics() {
+        Decimal::MAX.pow(2u32);
+    }
+
+    #[test]
+    fn decimal_saturating_pow() {
+        assert_eq!(
+            Decimal::percent(400).saturating_pow(2u32),
+            Decimal::percent(1600)
+        );
+        assert_eq!(Decimal::MAX.saturating_pow(2u32), Decimal::MAX);
+    }
 }

packages/std/src/math/decimal256.rs

@@ -225,6 +225,14 @@ impl Decimal256 {
             })
     }
 
+    /// Raises a value to the power of `exp`, panics if an overflow occurred.
+    pub fn pow(self, exp: u32) -> Self {
+        match self.checked_pow(exp) {
+            Ok(value) => value,
+            Err(_) => panic!("Multiplication overflow"),
+        }
+    }
+
     /// Raises a value to the power of `exp`, returning an `OverflowError` if an overflow occurred.
     pub fn checked_pow(self, exp: u32) -> Result<Self, OverflowError> {
         // This uses the exponentiation by squaring algorithm:
@@ -258,6 +266,14 @@ impl Decimal256 {
         })
     }
 
+    /// Raises a value to the power of `exp`, returns MAX on overflow.
+    pub fn saturating_pow(self, exp: u32) -> Self {
+        match self.checked_pow(exp) {
+            Ok(value) => value,
+            Err(_) => Self::MAX,
+        }
+    }
+
     pub fn checked_div(self, other: Self) -> Result<Self, CheckedFromRatioError> {
         Decimal256::checked_from_ratio(self.numerator(), other.numerator())
     }
@@ -1982,4 +1998,28 @@ mod tests {
             Err(DivideByZeroError { .. })
         ));
     }
+
+    #[test]
+    fn decimal256_pow_works() {
+        assert_eq!(Decimal256::percent(200).pow(2), Decimal256::percent(400));
+        assert_eq!(
+            Decimal256::percent(200).pow(10),
+            Decimal256::percent(102400)
+        );
+    }
+
+    #[test]
+    #[should_panic]
+    fn decimal256_pow_overflow_panics() {
+        Decimal256::MAX.pow(2u32);
+    }
+
+    #[test]
+    fn decimal256_saturating_pow() {
+        assert_eq!(
+            Decimal256::percent(400).saturating_pow(2u32),
+            Decimal256::percent(1600)
+        );
+        assert_eq!(Decimal256::MAX.saturating_pow(2u32), Decimal256::MAX);
+    }
 }