Add HasResidueRepr and ResidueRepr traits to connect integers and residue representations

Author: fjarri

src/modular/boxed_monty_form.rs

@@ -12,7 +12,7 @@ use super::{
     reduction::{montgomery_reduction_boxed, montgomery_reduction_boxed_mut},
     Retrieve,
 };
-use crate::{BoxedUint, ConstantTimeSelect, Integer, Limb, NonZero, Word};
+use crate::{BoxedUint, ConstantTimeSelect, Integer, Limb, MontyFormLike, NonZero, Word};
 use subtle::CtOption;
 
 #[cfg(feature = "std")]
@@ -251,6 +251,27 @@ impl Retrieve for BoxedMontyForm {
     }
 }
 
+impl MontyFormLike for BoxedMontyForm {
+    type Raw = BoxedUint;
+    type Params = BoxedMontyParams;
+
+    fn new_params(modulus: Self::Raw) -> CtOption<Self::Params> {
+        BoxedMontyParams::new(modulus)
+    }
+
+    fn new(value: Self::Raw, params: Self::Params) -> Self {
+        BoxedMontyForm::new(value, params)
+    }
+
+    fn zero(params: Self::Params) -> Self {
+        BoxedMontyForm::zero(params)
+    }
+
+    fn one(params: Self::Params) -> Self {
+        BoxedMontyForm::one(params)
+    }
+}
+
 /// Convert the given integer into the Montgomery domain.
 #[inline]
 fn convert_to_montgomery(integer: &mut BoxedUint, params: &BoxedMontyParams) {

src/modular/monty_form.rs

@@ -13,7 +13,7 @@ use super::{
     reduction::montgomery_reduction,
     Retrieve,
 };
-use crate::{Limb, NonZero, Uint, Word, Zero};
+use crate::{Limb, MontyFormLike, NonZero, Uint, Word, Zero};
 use subtle::{Choice, ConditionallySelectable, ConstantTimeEq, CtOption};
 
 /// Parameters to efficiently go to/from the Montgomery form for an odd modulus provided at runtime.
@@ -208,6 +208,27 @@ impl<const LIMBS: usize> Retrieve for MontyForm<LIMBS> {
     }
 }
 
+impl<const LIMBS: usize> MontyFormLike for MontyForm<LIMBS> {
+    type Raw = Uint<LIMBS>;
+    type Params = MontyParams<LIMBS>;
+
+    fn new_params(modulus: Self::Raw) -> CtOption<Self::Params> {
+        MontyParams::new(&modulus)
+    }
+
+    fn new(value: Self::Raw, params: Self::Params) -> Self {
+        MontyForm::new(&value, params)
+    }
+
+    fn zero(params: Self::Params) -> Self {
+        MontyForm::zero(params)
+    }
+
+    fn one(params: Self::Params) -> Self {
+        MontyForm::one(params)
+    }
+}
+
 impl<const LIMBS: usize, P: ConstMontyParams<LIMBS>> From<&ConstMontyForm<P, LIMBS>>
     for MontyForm<LIMBS>
 {

src/traits.rs

@@ -513,3 +513,33 @@ pub trait WideningMul<Rhs = Self>: Sized {
     /// Perform widening multiplication.
     fn widening_mul(&self, rhs: Rhs) -> Self::Output;
 }
+
+/// This integer has a representation optimized for the performance of modular operations.
+pub trait HasMontyForm {
+    /// The representation type.
+    type MontyForm: MontyFormLike<Raw = Self>;
+}
+
+/// A representation of an integer optimized for the performance of modular operations.
+pub trait MontyFormLike {
+    /// The original integer type.
+    type Raw: HasMontyForm<MontyForm = Self>;
+
+    /// The precomputed data needed for this representation.
+    type Params: Clone;
+
+    /// Create the precomputed data.
+    ///
+    /// Can return `None` if `modulus` is not valid for the representation;
+    /// see the documentation of the specific type for the requirements.
+    fn new_params(modulus: Self::Raw) -> CtOption<Self::Params>;
+
+    /// Convert the value into the representation using precomputed data.
+    fn new(value: Self::Raw, params: Self::Params) -> Self;
+
+    /// Returns zero in this representation.
+    fn zero(params: Self::Params) -> Self;
+
+    /// Returns one in this representation.
+    fn one(params: Self::Params) -> Self;
+}

src/uint.rs

@@ -40,8 +40,9 @@ pub(crate) mod boxed;
 mod rand;
 
 use crate::{
-    modular::BernsteinYangInverter, Bounded, ConstCtOption, Constants, Encoding, FixedInteger,
-    Integer, Limb, NonZero, PrecomputeInverter, PrecomputeInverterWithAdjuster, Word, ZeroConstant,
+    modular::{BernsteinYangInverter, MontyForm},
+    Bounded, ConstCtOption, Constants, Encoding, FixedInteger, HasMontyForm, Integer, Limb,
+    NonZero, PrecomputeInverter, PrecomputeInverterWithAdjuster, Word, ZeroConstant,
 };
 use core::fmt;
 use subtle::{Choice, ConditionallySelectable, ConstantTimeEq};
@@ -260,6 +261,10 @@ impl<const LIMBS: usize> Integer for Uint<LIMBS> {
     }
 }
 
+impl<const LIMBS: usize> HasMontyForm for Uint<LIMBS> {
+    type MontyForm = MontyForm<LIMBS>;
+}
+
 impl<const LIMBS: usize> ZeroConstant for Uint<LIMBS> {
     const ZERO: Self = Self::ZERO;
 }

src/uint/boxed.rs

@@ -25,7 +25,7 @@ mod sub_mod;
 #[cfg(feature = "rand_core")]
 mod rand;
 
-use crate::{Integer, Limb, NonZero, Word, Zero};
+use crate::{modular::BoxedMontyForm, HasMontyForm, Integer, Limb, NonZero, Word, Zero};
 use alloc::{boxed::Box, vec, vec::Vec};
 use core::fmt;
 use subtle::{Choice, ConditionallySelectable, ConstantTimeEq};
@@ -343,6 +343,10 @@ impl num_traits::One for BoxedUint {
     }
 }
 
+impl HasMontyForm for BoxedUint {
+    type MontyForm = BoxedMontyForm;
+}
+
 #[cfg(feature = "zeroize")]
 impl Zeroize for BoxedUint {
     fn zeroize(&mut self) {