Support fraction multiply

Author: grod220

packages/std/src/errors/mod.rs

@@ -5,8 +5,9 @@ mod verification_error;
 
 pub use recover_pubkey_error::RecoverPubkeyError;
 pub use std_error::{
-    CheckedFromRatioError, CheckedMultiplyRatioError, ConversionOverflowError, DivideByZeroError,
-    OverflowError, OverflowOperation, RoundUpOverflowError, StdError, StdResult,
+    CheckedFromRatioError, CheckedMultiplyFractionalError, CheckedMultiplyRatioError,
+    ConversionOverflowError, DivideByZeroError, OverflowError, OverflowOperation,
+    RoundUpOverflowError, StdError, StdResult,
 };
 pub use system_error::SystemError;
 pub use verification_error::VerificationError;

packages/std/src/errors/std_error.rs

@@ -543,7 +543,7 @@ impl ConversionOverflowError {
 }
 
 #[derive(Error, Debug, PartialEq, Eq)]
-#[error("Cannot devide {operand} by zero")]
+#[error("Cannot divide {operand} by zero")]
 pub struct DivideByZeroError {
     pub operand: String,
 }
@@ -556,6 +556,15 @@ impl DivideByZeroError {
     }
 }
 
+#[derive(Error, Debug, PartialEq, Eq)]
+pub enum CheckedMultiplyFractionalError {
+    #[error("{0}")]
+    DivideByZero(#[from] DivideByZeroError),
+
+    #[error("{0}")]
+    ConversionOverflow(#[from] ConversionOverflowError),
+}
+
 #[derive(Error, Debug, PartialEq, Eq)]
 pub enum CheckedMultiplyRatioError {
     #[error("Denominator must not be zero")]

packages/std/src/lib.rs

@@ -46,7 +46,7 @@ pub use crate::ibc::{
 #[cfg(feature = "iterator")]
 pub use crate::iterator::{Order, Record};
 pub use crate::math::{
-    Decimal, Decimal256, Decimal256RangeExceeded, DecimalRangeExceeded, Fraction, Isqrt, Uint128,
+    Decimal, Decimal256, Decimal256RangeExceeded, DecimalRangeExceeded, Fractional, Isqrt, Uint128,
     Uint256, Uint512, Uint64,
 };
 pub use crate::never::Never;

packages/std/src/math/decimal.rs

@@ -12,7 +12,7 @@ use crate::errors::{
     OverflowOperation, RoundUpOverflowError, StdError,
 };
 
-use super::Fraction;
+use super::Fractional;
 use super::Isqrt;
 use super::{Uint128, Uint256};
 
@@ -359,7 +359,7 @@ impl Decimal {
     }
 }
 
-impl Fraction<Uint128> for Decimal {
+impl Fractional<Uint128> for Decimal {
     #[inline]
     fn numerator(&self) -> Uint128 {
         self.0

packages/std/src/math/decimal256.rs

@@ -13,7 +13,7 @@ use crate::errors::{
 };
 use crate::{Decimal, Uint512};
 
-use super::Fraction;
+use super::Fractional;
 use super::Isqrt;
 use super::Uint256;
 
@@ -376,7 +376,7 @@ impl Decimal256 {
     }
 }
 
-impl Fraction<Uint256> for Decimal256 {
+impl Fractional<Uint256> for Decimal256 {
     #[inline]
     fn numerator(&self) -> Uint256 {
         self.0

packages/std/src/math/fraction.rs

@@ -1,7 +1,9 @@
+use serde::{Deserialize, Serialize};
+
 /// A fraction `p`/`q` with integers `p` and `q`.
 ///
 /// `p` is called the numerator and `q` is called the denominator.
-pub trait Fraction<T>: Sized {
+pub trait Fractional<T>: Sized {
     /// Returns the numerator `p`
     fn numerator(&self) -> T;
     /// Returns the denominator `q`
@@ -12,3 +14,26 @@ pub trait Fraction<T>: Sized {
     /// If `p` is zero, None is returned.
     fn inv(&self) -> Option<Self>;
 }
+
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]
+pub struct Fraction<T>(T, T);
+
+impl<T> Fraction<T> {
+    pub fn new(numerator: T, denominator: T) -> Self {
+        Self(numerator, denominator)
+    }
+}
+
+impl<T: Clone> Fractional<T> for Fraction<T> {
+    fn numerator(&self) -> T {
+        self.0.clone()
+    }
+
+    fn denominator(&self) -> T {
+        self.1.clone()
+    }
+
+    fn inv(&self) -> Option<Self> {
+        unimplemented!()
+    }
+}

packages/std/src/math/mod.rs

@@ -9,7 +9,7 @@ mod uint64;
 
 pub use decimal::{Decimal, DecimalRangeExceeded};
 pub use decimal256::{Decimal256, Decimal256RangeExceeded};
-pub use fraction::Fraction;
+pub use fraction::Fractional;
 pub use isqrt::Isqrt;
 pub use uint128::Uint128;
 pub use uint256::Uint256;

packages/std/src/math/uint128.rs

@@ -8,9 +8,10 @@ use std::ops::{
 use std::str::FromStr;
 
 use crate::errors::{
-    CheckedMultiplyRatioError, DivideByZeroError, OverflowError, OverflowOperation, StdError,
+    CheckedMultiplyFractionalError, CheckedMultiplyRatioError, DivideByZeroError, OverflowError,
+    OverflowOperation, StdError,
 };
-use crate::{ConversionOverflowError, Uint256, Uint64};
+use crate::{ConversionOverflowError, Fractional, Uint256, Uint64};
 
 /// A thin wrapper around u128 that is using strings for JSON encoding/decoding,
 /// such that the full u128 range can be used for clients that convert JSON numbers to floats,
@@ -136,6 +137,37 @@ impl Uint128 {
             .unwrap()
     }
 
+    pub fn mul_floored<F: Fractional<T>, T: Into<u128>>(self, rhs: F) -> Self {
+        self.checked_mul_floored(rhs).unwrap()
+    }
+
+    pub fn checked_mul_floored<F: Fractional<T>, T: Into<u128>>(
+        self,
+        rhs: F,
+    ) -> Result<Self, CheckedMultiplyFractionalError> {
+        let res = self
+            .full_mul(rhs.numerator())
+            .checked_div(Uint256::from(rhs.denominator().into()))?;
+        Ok(res.try_into()?)
+    }
+
+    pub fn mul_ceil<F: Fractional<T> + Clone, T: Into<u128>>(self, rhs: F) -> Self {
+        self.checked_mul_ceil(rhs).unwrap()
+    }
+
+    pub fn checked_mul_ceil<F: Fractional<T> + Clone, T: Into<u128>>(
+        self,
+        rhs: F,
+    ) -> Result<Self, CheckedMultiplyFractionalError> {
+        let mut result = self.checked_mul_floored(rhs.clone())?;
+        let numerator = Uint256::from(rhs.numerator().into());
+        let denominator = Uint256::from(rhs.denominator().into());
+        if !numerator.checked_rem(denominator)?.is_zero() {
+            result += Uint128::one();
+        };
+        Ok(result)
+    }
+
     pub fn checked_add(self, other: Self) -> Result<Self, OverflowError> {
         self.0
             .checked_add(other.0)
@@ -538,7 +570,9 @@ impl PartialEq<Uint128> for &Uint128 {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::{from_slice, to_vec};
+    use crate::errors::CheckedMultiplyFractionalError::{ConversionOverflow, DivideByZero};
+    use crate::math::fraction::Fraction;
+    use crate::{from_slice, to_vec, Decimal};
 
     #[test]
     fn size_of_works() {
@@ -1039,4 +1073,136 @@ mod tests {
             assert_eq!(&lhs == &rhs, expected);
         }
     }
+
+    #[test]
+    fn mul_floored_works_with_zero() {
+        let fraction = Fraction::new(Uint128::zero(), Uint128::new(21));
+        let res = Uint128::new(123456).mul_floored(fraction);
+        assert_eq!(Uint128::zero(), res)
+    }
+
+    #[test]
+    fn mul_floored_does_nothing_with_one() {
+        let fraction = Fraction::new(Uint128::one(), Uint128::one());
+        let res = Uint128::new(123456).mul_floored(fraction);
+        assert_eq!(Uint128::new(123456), res)
+    }
+
+    #[test]
+    fn mul_floored_rounds_down_with_normal_case() {
+        let fraction = Fraction::new(8u128, 21u128);
+        let res = Uint128::new(123456).mul_floored(fraction); // 47030.8571
+        assert_eq!(Uint128::new(47030), res)
+    }
+
+    #[test]
+    fn mul_floored_works_with_decimal() {
+        let decimal = Decimal::from_ratio(8u128, 21u128);
+        let res = Uint128::new(123456).mul_floored(decimal); // 47030.8571
+        assert_eq!(Uint128::new(47030), res)
+    }
+
+    #[test]
+    #[should_panic(expected = "ConversionOverflowError")]
+    fn mul_floored_panics_on_overflow() {
+        let fraction = Fraction::new(21u128, 8u128);
+        Uint128::MAX.mul_floored(fraction);
+    }
+
+    #[test]
+    fn checked_mul_floored_does_not_panic_on_overflow() {
+        let fraction = Fraction::new(21u128, 8u128);
+        assert_eq!(
+            Uint128::MAX.checked_mul_floored(fraction),
+            Err(ConversionOverflow(ConversionOverflowError {
+                source_type: "Uint256",
+                target_type: "Uint128",
+                value: "893241213167463466591358344508391555069".to_string()
+            })),
+        );
+    }
+
+    #[test]
+    #[should_panic(expected = "DivideByZeroError")]
+    fn mul_floored_panics_on_zero_div() {
+        let fraction = Fraction::new(21u128, 0u128);
+        Uint128::new(123456).mul_floored(fraction);
+    }
+
+    #[test]
+    fn checked_mul_floored_does_not_panic_on_zero_div() {
+        let fraction = Fraction::new(21u128, 0u128);
+        assert_eq!(
+            Uint128::new(123456).checked_mul_floored(fraction),
+            Err(DivideByZero(DivideByZeroError {
+                operand: "2592576".to_string()
+            })),
+        );
+    }
+
+    #[test]
+    fn mul_ceil_works_with_zero() {
+        let fraction = Fraction::new(Uint128::zero(), Uint128::new(21));
+        let res = Uint128::new(123456).mul_ceil(fraction);
+        assert_eq!(Uint128::zero(), res)
+    }
+
+    #[test]
+    fn mul_ceil_does_nothing_with_one() {
+        let fraction = Fraction::new(Uint128::one(), Uint128::one());
+        let res = Uint128::new(123456).mul_ceil(fraction);
+        assert_eq!(Uint128::new(123456), res)
+    }
+
+    #[test]
+    fn mul_ceil_rounds_up_with_normal_case() {
+        let fraction = Fraction::new(8u128, 21u128);
+        let res = Uint128::new(123456).mul_ceil(fraction); // 47030.8571
+        assert_eq!(Uint128::new(47031), res)
+    }
+
+    #[test]
+    fn mul_ceil_works_with_decimal() {
+        let decimal = Decimal::from_ratio(8u128, 21u128);
+        let res = Uint128::new(123456).mul_ceil(decimal); // 47030.8571
+        assert_eq!(Uint128::new(47031), res)
+    }
+
+    #[test]
+    #[should_panic(expected = "ConversionOverflowError")]
+    fn mul_ceil_panics_on_overflow() {
+        let fraction = Fraction::new(21u128, 8u128);
+        Uint128::MAX.mul_ceil(fraction);
+    }
+
+    #[test]
+    fn checked_mul_ceil_does_not_panic_on_overflow() {
+        let fraction = Fraction::new(21u128, 8u128);
+        assert_eq!(
+            Uint128::MAX.checked_mul_ceil(fraction),
+            Err(ConversionOverflow(ConversionOverflowError {
+                source_type: "Uint256",
+                target_type: "Uint128",
+                value: "893241213167463466591358344508391555069".to_string()
+            })),
+        );
+    }
+
+    #[test]
+    #[should_panic(expected = "DivideByZeroError")]
+    fn mul_ceil_panics_on_zero_div() {
+        let fraction = Fraction::new(21u128, 0u128);
+        Uint128::new(123456).mul_ceil(fraction);
+    }
+
+    #[test]
+    fn checked_mul_ceil_does_not_panic_on_zero_div() {
+        let fraction = Fraction::new(21u128, 0u128);
+        assert_eq!(
+            Uint128::new(123456).checked_mul_ceil(fraction),
+            Err(DivideByZero(DivideByZeroError {
+                operand: "2592576".to_string()
+            })),
+        );
+    }
 }