make floor/ceil tenses consistent

grod220 · grod220 · commit 8b63fcd4faef · 2023-01-18T22:58:49.000+01:00
diff --git a/packages/std/src/math/fraction.rs b/packages/std/src/math/fraction.rs
@@ -35,7 +35,7 @@ impl<T: Copy + From<u8> + PartialEq> Fraction<T> for (T, T) {
 macro_rules! impl_mul_fraction {
     ($Uint:ident) => {
         impl $Uint {
-            pub fn checked_mul_floored<F: Fraction<T>, T: Into<$Uint>>(
+            pub fn checked_mul_floor<F: Fraction<T>, T: Into<$Uint>>(
                 self,
                 rhs: F,
             ) -> Result<Self, CheckedMultiplyFractionError> {
@@ -46,8 +46,8 @@ macro_rules! impl_mul_fraction {
                 Ok(res.try_into()?)
             }
 
-            pub fn mul_floored<F: Fraction<T>, T: Into<$Uint>>(self, rhs: F) -> Self {
-                self.checked_mul_floored(rhs).unwrap()
+            pub fn mul_floor<F: Fraction<T>, T: Into<$Uint>>(self, rhs: F) -> Self {
+                self.checked_mul_floor(rhs).unwrap()
             }
 
             pub fn checked_mul_ceil<F: Fraction<T>, T: Into<$Uint>>(
@@ -58,7 +58,7 @@ macro_rules! impl_mul_fraction {
                 let remainder = self
                     .full_mul(rhs.numerator().into())
                     .checked_rem(divisor.into())?;
-                let floor_result = self.checked_mul_floored(rhs)?;
+                let floor_result = self.checked_mul_floor(rhs)?;
                 if !remainder.is_zero() {
                     Ok($Uint::one().checked_add(floor_result)?)
                 } else {
diff --git a/packages/std/src/math/uint128.rs b/packages/std/src/math/uint128.rs
@@ -1047,62 +1047,62 @@ mod tests {
     }
 
     #[test]
-    fn mul_floored_works_with_zero() {
+    fn mul_floor_works_with_zero() {
         let fraction = (Uint128::zero(), Uint128::new(21));
-        let res = Uint128::new(123456).mul_floored(fraction);
+        let res = Uint128::new(123456).mul_floor(fraction);
         assert_eq!(Uint128::zero(), res)
     }
 
     #[test]
-    fn mul_floored_does_nothing_with_one() {
+    fn mul_floor_does_nothing_with_one() {
         let fraction = (Uint128::one(), Uint128::one());
-        let res = Uint128::new(123456).mul_floored(fraction);
+        let res = Uint128::new(123456).mul_floor(fraction);
         assert_eq!(Uint128::new(123456), res)
     }
 
     #[test]
-    fn mul_floored_rounds_down_with_normal_case() {
+    fn mul_floor_rounds_down_with_normal_case() {
         let fraction = (8u128, 21u128);
-        let res = Uint128::new(123456).mul_floored(fraction); // 47030.8571
+        let res = Uint128::new(123456).mul_floor(fraction); // 47030.8571
         assert_eq!(Uint128::new(47030), res)
     }
 
     #[test]
-    fn mul_floored_does_not_round_on_even_divide() {
+    fn mul_floor_does_not_round_on_even_divide() {
         let fraction = (2u128, 5u128);
-        let res = Uint128::new(25).mul_floored(fraction);
+        let res = Uint128::new(25).mul_floor(fraction);
         assert_eq!(Uint128::new(10), res)
     }
 
     #[test]
-    fn mul_floored_works_when_operation_temporarily_takes_above_max() {
+    fn mul_floor_works_when_operation_temporarily_takes_above_max() {
         let fraction = (8u128, 21u128);
-        let res = Uint128::MAX.mul_floored(fraction); // 129_631_377_874_643_224_176_523_659_974_006_937_697.14285
+        let res = Uint128::MAX.mul_floor(fraction); // 129_631_377_874_643_224_176_523_659_974_006_937_697.14285
         assert_eq!(
             Uint128::new(129_631_377_874_643_224_176_523_659_974_006_937_697),
             res
         )
     }
 
     #[test]
-    fn mul_floored_works_with_decimal() {
+    fn mul_floor_works_with_decimal() {
         let decimal = Decimal::from_ratio(8u128, 21u128);
-        let res = Uint128::new(123456).mul_floored(decimal); // 47030.8571
+        let res = Uint128::new(123456).mul_floor(decimal); // 47030.8571
         assert_eq!(Uint128::new(47030), res)
     }
 
     #[test]
     #[should_panic(expected = "ConversionOverflowError")]
-    fn mul_floored_panics_on_overflow() {
+    fn mul_floor_panics_on_overflow() {
         let fraction = (21u128, 8u128);
-        Uint128::MAX.mul_floored(fraction);
+        Uint128::MAX.mul_floor(fraction);
     }
 
     #[test]
-    fn checked_mul_floored_does_not_panic_on_overflow() {
+    fn checked_mul_floor_does_not_panic_on_overflow() {
         let fraction = (21u128, 8u128);
         assert_eq!(
-            Uint128::MAX.checked_mul_floored(fraction),
+            Uint128::MAX.checked_mul_floor(fraction),
             Err(ConversionOverflow(ConversionOverflowError {
                 source_type: "Uint256",
                 target_type: "Uint128",
@@ -1113,16 +1113,16 @@ mod tests {
 
     #[test]
     #[should_panic(expected = "DivideByZeroError")]
-    fn mul_floored_panics_on_zero_div() {
+    fn mul_floor_panics_on_zero_div() {
         let fraction = (21u128, 0u128);
-        Uint128::new(123456).mul_floored(fraction);
+        Uint128::new(123456).mul_floor(fraction);
     }
 
     #[test]
-    fn checked_mul_floored_does_not_panic_on_zero_div() {
+    fn checked_mul_floor_does_not_panic_on_zero_div() {
         let fraction = (21u128, 0u128);
         assert_eq!(
-            Uint128::new(123456).checked_mul_floored(fraction),
+            Uint128::new(123456).checked_mul_floor(fraction),
             Err(DivideByZero(DivideByZeroError {
                 operand: "2592576".to_string()
             })),
diff --git a/packages/std/src/math/uint256.rs b/packages/std/src/math/uint256.rs
@@ -1669,37 +1669,37 @@ mod tests {
     }
 
     #[test]
-    fn mul_floored_works_with_zero() {
+    fn mul_floor_works_with_zero() {
         let fraction = (Uint256::zero(), Uint256::from(21u32));
-        let res = Uint256::from(123456u32).mul_floored(fraction);
+        let res = Uint256::from(123456u32).mul_floor(fraction);
         assert_eq!(Uint256::zero(), res)
     }
 
     #[test]
-    fn mul_floored_does_nothing_with_one() {
+    fn mul_floor_does_nothing_with_one() {
         let fraction = (Uint256::one(), Uint256::one());
-        let res = Uint256::from(123456u32).mul_floored(fraction);
+        let res = Uint256::from(123456u32).mul_floor(fraction);
         assert_eq!(Uint256::from(123456u32), res)
     }
 
     #[test]
-    fn mul_floored_rounds_down_with_normal_case() {
+    fn mul_floor_rounds_down_with_normal_case() {
         let fraction = (Uint256::from(8u128), Uint256::from(21u128));
-        let res = Uint256::from(123456u32).mul_floored(fraction); // 47030.8571
+        let res = Uint256::from(123456u32).mul_floor(fraction); // 47030.8571
         assert_eq!(Uint256::from(47030u32), res)
     }
 
     #[test]
-    fn mul_floored_does_not_round_on_even_divide() {
+    fn mul_floor_does_not_round_on_even_divide() {
         let fraction = (2u128, 5u128);
-        let res = Uint256::from(25u32).mul_floored(fraction);
+        let res = Uint256::from(25u32).mul_floor(fraction);
         assert_eq!(Uint256::from(10u32), res)
     }
 
     #[test]
-    fn mul_floored_works_when_operation_temporarily_takes_above_max() {
+    fn mul_floor_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
+        let res = Uint256::MAX.mul_floor(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"
@@ -1710,31 +1710,31 @@ mod tests {
     }
 
     #[test]
-    fn mul_floored_works_with_decimal() {
+    fn mul_floor_works_with_decimal() {
         let decimal = Decimal::from_ratio(8u128, 21u128);
-        let res = Uint256::from(123456u32).mul_floored(decimal); // 47030.8571
+        let res = Uint256::from(123456u32).mul_floor(decimal); // 47030.8571
         assert_eq!(Uint256::from(47030u32), res)
     }
 
     #[test]
-    fn mul_floored_works_with_decimal256() {
+    fn mul_floor_works_with_decimal256() {
         let decimal = Decimal256::from_ratio(8u128, 21u128);
-        let res = Uint256::from(123456u32).mul_floored(decimal); // 47030.8571
+        let res = Uint256::from(123456u32).mul_floor(decimal); // 47030.8571
         assert_eq!(Uint256::from(47030u32), res)
     }
 
     #[test]
     #[should_panic(expected = "ConversionOverflowError")]
-    fn mul_floored_panics_on_overflow() {
+    fn mul_floor_panics_on_overflow() {
         let fraction = (21u128, 8u128);
-        Uint256::MAX.mul_floored(fraction);
+        Uint256::MAX.mul_floor(fraction);
     }
 
     #[test]
-    fn checked_mul_floored_does_not_panic_on_overflow() {
+    fn checked_mul_floor_does_not_panic_on_overflow() {
         let fraction = (21u128, 8u128);
         assert_eq!(
-            Uint256::MAX.checked_mul_floored(fraction),
+            Uint256::MAX.checked_mul_floor(fraction),
             Err(ConversionOverflow(ConversionOverflowError {
                 source_type: "Uint512",
                 target_type: "Uint256",
@@ -1747,16 +1747,16 @@ mod tests {
 
     #[test]
     #[should_panic(expected = "DivideByZeroError")]
-    fn mul_floored_panics_on_zero_div() {
+    fn mul_floor_panics_on_zero_div() {
         let fraction = (21u128, 0u128);
-        Uint256::from(123456u32).mul_floored(fraction);
+        Uint256::from(123456u32).mul_floor(fraction);
     }
 
     #[test]
-    fn checked_mul_floored_does_not_panic_on_zero_div() {
+    fn checked_mul_floor_does_not_panic_on_zero_div() {
         let fraction = (21u128, 0u128);
         assert_eq!(
-            Uint256::from(123456u32).checked_mul_floored(fraction),
+            Uint256::from(123456u32).checked_mul_floor(fraction),
             Err(DivideByZero(DivideByZeroError {
                 operand: "2592576".to_string()
             })),
diff --git a/packages/std/src/math/uint64.rs b/packages/std/src/math/uint64.rs
@@ -961,52 +961,52 @@ mod tests {
     }
 
     #[test]
-    fn mul_floored_works_with_zero() {
+    fn mul_floor_works_with_zero() {
         let fraction = (0u32, 21u32);
-        let res = Uint64::new(123456).mul_floored(fraction);
+        let res = Uint64::new(123456).mul_floor(fraction);
         assert_eq!(Uint64::zero(), res)
     }
 
     #[test]
-    fn mul_floored_does_nothing_with_one() {
+    fn mul_floor_does_nothing_with_one() {
         let fraction = (Uint64::one(), Uint64::one());
-        let res = Uint64::new(123456).mul_floored(fraction);
+        let res = Uint64::new(123456).mul_floor(fraction);
         assert_eq!(Uint64::new(123456), res)
     }
 
     #[test]
-    fn mul_floored_rounds_down_with_normal_case() {
+    fn mul_floor_rounds_down_with_normal_case() {
         let fraction = (8u64, 21u64);
-        let res = Uint64::new(123456).mul_floored(fraction); // 47030.8571
+        let res = Uint64::new(123456).mul_floor(fraction); // 47030.8571
         assert_eq!(Uint64::new(47030), res)
     }
 
     #[test]
-    fn mul_floored_does_not_round_on_even_divide() {
+    fn mul_floor_does_not_round_on_even_divide() {
         let fraction = (2u64, 5u64);
-        let res = Uint64::new(25).mul_floored(fraction);
+        let res = Uint64::new(25).mul_floor(fraction);
         assert_eq!(Uint64::new(10), res)
     }
 
     #[test]
-    fn mul_floored_works_when_operation_temporarily_takes_above_max() {
+    fn mul_floor_works_when_operation_temporarily_takes_above_max() {
         let fraction = (8u64, 21u64);
-        let res = Uint64::MAX.mul_floored(fraction); // 7_027_331_075_698_876_805.71428571
+        let res = Uint64::MAX.mul_floor(fraction); // 7_027_331_075_698_876_805.71428571
         assert_eq!(Uint64::new(7_027_331_075_698_876_805), res)
     }
 
     #[test]
     #[should_panic(expected = "ConversionOverflowError")]
-    fn mul_floored_panics_on_overflow() {
+    fn mul_floor_panics_on_overflow() {
         let fraction = (21u64, 8u64);
-        Uint64::MAX.mul_floored(fraction);
+        Uint64::MAX.mul_floor(fraction);
     }
 
     #[test]
-    fn checked_mul_floored_does_not_panic_on_overflow() {
+    fn checked_mul_floor_does_not_panic_on_overflow() {
         let fraction = (21u64, 8u64);
         assert_eq!(
-            Uint64::MAX.checked_mul_floored(fraction),
+            Uint64::MAX.checked_mul_floor(fraction),
             Err(ConversionOverflow(ConversionOverflowError {
                 source_type: "Uint128",
                 target_type: "Uint64",
@@ -1017,16 +1017,16 @@ mod tests {
 
     #[test]
     #[should_panic(expected = "DivideByZeroError")]
-    fn mul_floored_panics_on_zero_div() {
+    fn mul_floor_panics_on_zero_div() {
         let fraction = (21u64, 0u64);
-        Uint64::new(123456).mul_floored(fraction);
+        Uint64::new(123456).mul_floor(fraction);
     }
 
     #[test]
-    fn checked_mul_floored_does_not_panic_on_zero_div() {
+    fn checked_mul_floor_does_not_panic_on_zero_div() {
         let fraction = (21u64, 0u64);
         assert_eq!(
-            Uint64::new(123456).checked_mul_floored(fraction),
+            Uint64::new(123456).checked_mul_floor(fraction),
             Err(DivideByZero(DivideByZeroError {
                 operand: "2592576".to_string()
             })),
