Ensure no rounds on even divides

Author: grod220

packages/std/src/math/fraction.rs

@@ -56,10 +56,12 @@ macro_rules! impl_mul_fraction {
                 self,
                 rhs: F,
             ) -> Result<Self, CheckedMultiplyFractionError> {
-                let numerator = rhs.numerator().into();
-                let denominator = rhs.denominator().into();
+                let divisor = rhs.denominator().into();
+                let remainder = self
+                    .full_mul(rhs.numerator().into())
+                    .checked_rem(divisor.into())?;
                 let floor_result = self.checked_mul_floored(rhs)?;
-                if !numerator.checked_rem(denominator)?.is_zero() {
+                if !remainder.is_zero() {
                     Ok($Uint::one().checked_add(floor_result)?)
                 } else {
                     Ok(floor_result)

packages/std/src/math/uint128.rs

@@ -1067,6 +1067,13 @@ mod tests {
         assert_eq!(Uint128::new(47030), res)
     }
 
+    #[test]
+    fn mul_floored_does_not_round_on_even_divide() {
+        let fraction = (2u128, 5u128);
+        let res = Uint128::new(25).mul_floored(fraction);
+        assert_eq!(Uint128::new(10), res)
+    }
+
     #[test]
     fn mul_floored_works_when_operation_temporarily_takes_above_max() {
         let fraction = (8u128, 21u128);
@@ -1143,6 +1150,13 @@ mod tests {
         assert_eq!(Uint128::new(47031), res)
     }
 
+    #[test]
+    fn mul_ceil_does_not_round_on_even_divide() {
+        let fraction = (2u128, 5u128);
+        let res = Uint128::new(25).mul_ceil(fraction);
+        assert_eq!(Uint128::new(10), res)
+    }
+
     #[test]
     fn mul_ceil_works_when_operation_temporarily_takes_above_max() {
         let fraction = (8u128, 21u128);

packages/std/src/math/uint256.rs

@@ -1689,6 +1689,13 @@ mod tests {
         assert_eq!(Uint256::from(47030u32), res)
     }
 
+    #[test]
+    fn mul_floored_does_not_round_on_even_divide() {
+        let fraction = (2u128, 5u128);
+        let res = Uint256::from(25u32).mul_floored(fraction);
+        assert_eq!(Uint256::from(10u32), res)
+    }
+
     #[test]
     fn mul_floored_works_when_operation_temporarily_takes_above_max() {
         let fraction = (8u128, 21u128);
@@ -1777,6 +1784,13 @@ mod tests {
         assert_eq!(Uint256::from(47031u32), res)
     }
 
+    #[test]
+    fn mul_ceil_does_not_round_on_even_divide() {
+        let fraction = (2u128, 5u128);
+        let res = Uint256::from(25u32).mul_ceil(fraction);
+        assert_eq!(Uint256::from(10u32), res)
+    }
+
     #[test]
     fn mul_ceil_works_when_operation_temporarily_takes_above_max() {
         let fraction = (8u128, 21u128);

packages/std/src/math/uint64.rs

@@ -981,6 +981,13 @@ mod tests {
         assert_eq!(Uint64::new(47030), res)
     }
 
+    #[test]
+    fn mul_floored_does_not_round_on_even_divide() {
+        let fraction = (2u64, 5u64);
+        let res = Uint64::new(25).mul_floored(fraction);
+        assert_eq!(Uint64::new(10), res)
+    }
+
     #[test]
     fn mul_floored_works_when_operation_temporarily_takes_above_max() {
         let fraction = (8u64, 21u64);
@@ -1047,6 +1054,13 @@ mod tests {
         assert_eq!(Uint64::new(47031), res)
     }
 
+    #[test]
+    fn mul_ceil_does_not_round_on_even_divide() {
+        let fraction = (2u64, 5u64);
+        let res = Uint64::new(25).mul_ceil(fraction);
+        assert_eq!(Uint64::new(10), res)
+    }
+
     #[test]
     fn mul_ceil_works_when_operation_temporarily_takes_above_max() {
         let fraction = (8u64, 21u64);