extend macro to Uint64/256

Author: grod220

packages/std/src/math/fraction.rs

@@ -29,38 +29,38 @@ impl<T: Clone> Fraction<T> for (T, T) {
 
 #[macro_export]
 macro_rules! impl_mul_fraction {
-    ($UintBase:ident, $UintLarger:ident) => {
-        impl $UintBase {
-            pub fn checked_mul_floored<F: Fraction<T>, T: Into<$UintBase>>(
+    ($Uint:ident) => {
+        impl $Uint {
+            pub fn checked_mul_floored<F: Fraction<T>, T: Into<$Uint>>(
                 self,
                 rhs: F,
             ) -> Result<Self, CheckedMultiplyFractionError> {
+                let divisor = rhs.denominator().into();
                 let res = self
                     .full_mul(rhs.numerator().into())
-                    .checked_div($UintLarger::from(rhs.denominator().into()))?;
+                    .checked_div(divisor.into())?;
                 Ok(res.try_into()?)
             }
 
-            pub fn mul_floored<F: Fraction<T>, T: Into<$UintBase>>(self, rhs: F) -> Self {
+            pub fn mul_floored<F: Fraction<T>, T: Into<$Uint>>(self, rhs: F) -> Self {
                 self.checked_mul_floored(rhs).unwrap()
             }
 
-            pub fn checked_mul_ceil<F: Fraction<T> + Clone, T: Into<$UintBase>>(
+            pub fn checked_mul_ceil<F: Fraction<T> + Clone, T: Into<$Uint>>(
                 self,
                 rhs: F,
             ) -> Result<Self, CheckedMultiplyFractionError> {
                 let floor_result = self.checked_mul_floored(rhs.clone())?;
                 let numerator = rhs.numerator().into();
                 let denominator = rhs.denominator().into();
                 if !numerator.checked_rem(denominator)?.is_zero() {
-                    let ceil_result = $UintLarger::one().checked_add(floor_result.into())?;
-                    Ok(ceil_result.try_into()?)
+                    Ok($Uint::one().checked_add(floor_result)?)
                 } else {
                     Ok(floor_result)
                 }
             }
 
-            pub fn mul_ceil<F: Fraction<T> + Clone, T: Into<$UintBase>>(self, rhs: F) -> Self {
+            pub fn mul_ceil<F: Fraction<T> + Clone, T: Into<$Uint>>(self, rhs: F) -> Self {
                 self.checked_mul_ceil(rhs).unwrap()
             }
         }

packages/std/src/math/uint128.rs

@@ -232,7 +232,7 @@ impl Uint128 {
     }
 }
 
-impl_mul_fraction!(Uint128, Uint256);
+impl_mul_fraction!(Uint128);
 
 // `From<u{128,64,32,16,8}>` is implemented manually instead of
 // using `impl<T: Into<u128>> From<T> for Uint128` because
@@ -1175,7 +1175,7 @@ mod tests {
             Err(ConversionOverflow(ConversionOverflowError {
                 source_type: "Uint256",
                 target_type: "Uint128",
-                value: "893241213167463466591358344508391555069".to_string()
+                value: "893241213167463466591358344508391555069".to_string() // raises prior to rounding up
             })),
         );
     }

packages/std/src/math/uint256.rs

@@ -9,10 +9,10 @@ use std::ops::{
 use std::str::FromStr;
 
 use crate::errors::{
-    CheckedMultiplyRatioError, ConversionOverflowError, DivideByZeroError, OverflowError,
-    OverflowOperation, StdError,
+    CheckedMultiplyFractionError, CheckedMultiplyRatioError, ConversionOverflowError,
+    DivideByZeroError, OverflowError, OverflowOperation, StdError,
 };
-use crate::{Uint128, Uint512, Uint64};
+use crate::{impl_mul_fraction, Fraction, Uint128, Uint512, Uint64};
 
 /// This module is purely a workaround that lets us ignore lints for all the code
 /// the `construct_uint!` macro generates.
@@ -336,6 +336,8 @@ impl Uint256 {
     }
 }
 
+impl_mul_fraction!(Uint256);
+
 impl From<Uint128> for Uint256 {
     fn from(val: Uint128) -> Self {
         val.u128().into()
@@ -666,7 +668,8 @@ impl PartialEq<Uint256> for &Uint256 {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::{from_slice, to_vec};
+    use crate::errors::CheckedMultiplyFractionError::{ConversionOverflow, DivideByZero};
+    use crate::{from_slice, to_vec, Decimal, Decimal256};
 
     #[test]
     fn size_of_works() {
@@ -1664,4 +1667,180 @@ mod tests {
             assert_eq!(&lhs == &rhs, expected);
         }
     }
+
+    #[test]
+    fn mul_floored_works_with_zero() {
+        let fraction = (Uint256::zero(), Uint256::from(21u32));
+        let res = Uint256::from(123456u32).mul_floored(fraction);
+        assert_eq!(Uint256::zero(), res)
+    }
+
+    #[test]
+    fn mul_floored_does_nothing_with_one() {
+        let fraction = (Uint256::one(), Uint256::one());
+        let res = Uint256::from(123456u32).mul_floored(fraction);
+        assert_eq!(Uint256::from(123456u32), res)
+    }
+
+    #[test]
+    fn mul_floored_rounds_down_with_normal_case() {
+        let fraction = (Uint256::from(8u128), Uint256::from(21u128));
+        let res = Uint256::from(123456u32).mul_floored(fraction); // 47030.8571
+        assert_eq!(Uint256::from(47030u32), res)
+    }
+
+    #[test]
+    fn mul_floored_works_when_operation_temporarily_takes_above_max() {
+        let fraction = (8u128, 21u128);
+        let res = Uint256::MAX.mul_floored(fraction); // 44_111_272_090_406_169_685_169_899_050_928_726_801_245_708_444_053_548_205_507_651_050_633_573_196_165.71428571
+        assert_eq!(
+            Uint256::from_str(
+                "44111272090406169685169899050928726801245708444053548205507651050633573196165"
+            )
+            .unwrap(),
+            res
+        )
+    }
+
+    #[test]
+    fn mul_floored_works_with_decimal() {
+        let decimal = Decimal::from_ratio(8u128, 21u128);
+        let res = Uint256::from(123456u32).mul_floored(decimal); // 47030.8571
+        assert_eq!(Uint256::from(47030u32), res)
+    }
+
+    #[test]
+    fn mul_floored_works_with_decimal256() {
+        let decimal = Decimal256::from_ratio(8u128, 21u128);
+        let res = Uint256::from(123456u32).mul_floored(decimal); // 47030.8571
+        assert_eq!(Uint256::from(47030u32), res)
+    }
+
+    #[test]
+    #[should_panic(expected = "ConversionOverflowError")]
+    fn mul_floored_panics_on_overflow() {
+        let fraction = (21u128, 8u128);
+        Uint256::MAX.mul_floored(fraction);
+    }
+
+    #[test]
+    fn checked_mul_floored_does_not_panic_on_overflow() {
+        let fraction = (21u128, 8u128);
+        assert_eq!(
+            Uint256::MAX.checked_mul_floored(fraction),
+            Err(ConversionOverflow(ConversionOverflowError {
+                source_type: "Uint512",
+                target_type: "Uint256",
+                value:
+                    "303954234247955012986873835647805758114833709747306480603576158020771965304829"
+                        .to_string()
+            })),
+        );
+    }
+
+    #[test]
+    #[should_panic(expected = "DivideByZeroError")]
+    fn mul_floored_panics_on_zero_div() {
+        let fraction = (21u128, 0u128);
+        Uint256::from(123456u32).mul_floored(fraction);
+    }
+
+    #[test]
+    fn checked_mul_floored_does_not_panic_on_zero_div() {
+        let fraction = (21u128, 0u128);
+        assert_eq!(
+            Uint256::from(123456u32).checked_mul_floored(fraction),
+            Err(DivideByZero(DivideByZeroError {
+                operand: "2592576".to_string()
+            })),
+        );
+    }
+
+    #[test]
+    fn mul_ceil_works_with_zero() {
+        let fraction = (Uint256::zero(), Uint256::from(21u32));
+        let res = Uint256::from(123456u32).mul_ceil(fraction);
+        assert_eq!(Uint256::zero(), res)
+    }
+
+    #[test]
+    fn mul_ceil_does_nothing_with_one() {
+        let fraction = (Uint256::one(), Uint256::one());
+        let res = Uint256::from(123456u32).mul_ceil(fraction);
+        assert_eq!(Uint256::from(123456u32), res)
+    }
+
+    #[test]
+    fn mul_ceil_rounds_up_with_normal_case() {
+        let fraction = (8u128, 21u128);
+        let res = Uint256::from(123456u32).mul_ceil(fraction); // 47030.8571
+        assert_eq!(Uint256::from(47031u32), res)
+    }
+
+    #[test]
+    fn mul_ceil_works_when_operation_temporarily_takes_above_max() {
+        let fraction = (8u128, 21u128);
+        let res = Uint256::MAX.mul_ceil(fraction); // 44_111_272_090_406_169_685_169_899_050_928_726_801_245_708_444_053_548_205_507_651_050_633_573_196_165.71428571
+        assert_eq!(
+            Uint256::from_str(
+                "44111272090406169685169899050928726801245708444053548205507651050633573196166"
+            )
+            .unwrap(),
+            res
+        )
+    }
+
+    #[test]
+    fn mul_ceil_works_with_decimal() {
+        let decimal = Decimal::from_ratio(8u128, 21u128);
+        let res = Uint256::from(123456u32).mul_ceil(decimal); // 47030.8571
+        assert_eq!(Uint256::from(47031u32), res)
+    }
+
+    #[test]
+    fn mul_ceil_works_with_decimal256() {
+        let decimal = Decimal256::from_ratio(8u128, 21u128);
+        let res = Uint256::from(123456u32).mul_ceil(decimal); // 47030.8571
+        assert_eq!(Uint256::from(47031u32), res)
+    }
+
+    #[test]
+    #[should_panic(expected = "ConversionOverflowError")]
+    fn mul_ceil_panics_on_overflow() {
+        let fraction = (21u128, 8u128);
+        Uint256::MAX.mul_ceil(fraction);
+    }
+
+    #[test]
+    fn checked_mul_ceil_does_not_panic_on_overflow() {
+        let fraction = (21u128, 8u128);
+        assert_eq!(
+            Uint256::MAX.checked_mul_ceil(fraction),
+            Err(ConversionOverflow(ConversionOverflowError {
+                source_type: "Uint512",
+                target_type: "Uint256",
+                value:
+                    "303954234247955012986873835647805758114833709747306480603576158020771965304829" // raises prior to rounding up
+                        .to_string()
+            })),
+        );
+    }
+
+    #[test]
+    #[should_panic(expected = "DivideByZeroError")]
+    fn mul_ceil_panics_on_zero_div() {
+        let fraction = (21u128, 0u128);
+        Uint256::from(123456u32).mul_ceil(fraction);
+    }
+
+    #[test]
+    fn checked_mul_ceil_does_not_panic_on_zero_div() {
+        let fraction = (21u128, 0u128);
+        assert_eq!(
+            Uint256::from(123456u32).checked_mul_ceil(fraction),
+            Err(DivideByZero(DivideByZeroError {
+                operand: "2592576".to_string()
+            })),
+        );
+    }
 }