Expose montgomery form in Residue/DynResidue

src/uint/modular/constant_mod.rs

@@ -59,6 +59,7 @@ pub trait ResidueParams<const LIMBS: usize>:
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 /// A residue mod `MOD`, represented using `LIMBS` limbs. The modulus of this residue is constant, so it cannot be set at runtime.
+/// Internally, the value is stored in Montgomery form (multiplied by MOD::R) until it is retrieved.
 pub struct Residue<MOD, const LIMBS: usize>
 where
     MOD: ResidueParams<LIMBS>,
@@ -107,6 +108,29 @@ impl<MOD: ResidueParams<LIMBS>, const LIMBS: usize> Residue<MOD, LIMBS> {
         )
     }
 
+    /// Access the `Residue` value in Montgomery form.
+    pub const fn as_montgomery(&self) -> &Uint<LIMBS> {
+        &self.montgomery_form
+    }
+
+    /// Mutably access the `Residue` value in Montgomery form.
+    pub fn as_montgomery_mut(&mut self) -> &mut Uint<LIMBS> {
+        &mut self.montgomery_form
+    }
+
+    /// Create a `Residue` from a value in Montgomery form.
+    pub const fn from_montgomery(integer: Uint<LIMBS>) -> Self {
+        Self {
+            montgomery_form: integer,
+            phantom: PhantomData,
+        }
+    }
+
+    /// Extract the value from the `Residue` in Montgomery form.
+    pub const fn to_montgomery(&self) -> Uint<LIMBS> {
+        self.montgomery_form
+    }
+
     /// Performs the modular division by 2, that is for given `x` returns `y`
     /// such that `y * 2 = x mod p`. This means:
     /// - if `x` is even, returns `x / 2`,

src/uint/modular/runtime_mod.rs

@@ -1,6 +1,11 @@
 use crate::{Limb, Uint, Word};
 
-use super::{div_by_2::div_by_2, reduction::montgomery_reduction, Retrieve};
+use super::{
+    constant_mod::{Residue, ResidueParams},
+    div_by_2::div_by_2,
+    reduction::montgomery_reduction,
+    Retrieve,
+};
 
 /// Additions between residues with a modulus set at runtime
 mod runtime_add;
@@ -58,6 +63,20 @@ impl<const LIMBS: usize> DynResidueParams<LIMBS> {
     pub const fn modulus(&self) -> &Uint<LIMBS> {
         &self.modulus
     }
+
+    /// Create `DynResidueParams` corresponding to a `ResidueParams`.
+    pub const fn from_residue_params<P>() -> Self
+    where
+        P: ResidueParams<LIMBS>,
+    {
+        Self {
+            modulus: P::MODULUS,
+            r: P::R,
+            r2: P::R2,
+            r3: P::R3,
+            mod_neg_inv: P::MOD_NEG_INV,
+        }
+    }
 }
 
 /// A residue represented using `LIMBS` limbs. The odd modulus of this residue is set at runtime.
@@ -113,6 +132,32 @@ impl<const LIMBS: usize> DynResidue<LIMBS> {
         &self.residue_params
     }
 
+    /// Access the `DynResidue` value in Montgomery form.
+    pub const fn as_montgomery(&self) -> &Uint<LIMBS> {
+        &self.montgomery_form
+    }
+
+    /// Mutably access the `DynResidue` value in Montgomery form.
+    pub fn as_montgomery_mut(&mut self) -> &mut Uint<LIMBS> {
+        &mut self.montgomery_form
+    }
+
+    /// Create a `DynResidue` from a value in Montgomery form.
+    pub const fn from_montgomery(
+        integer: Uint<LIMBS>,
+        residue_params: DynResidueParams<LIMBS>,
+    ) -> Self {
+        Self {
+            montgomery_form: integer,
+            residue_params,
+        }
+    }
+
+    /// Extract the value from the `DynResidue` in Montgomery form.
+    pub const fn to_montgomery(&self) -> Uint<LIMBS> {
+        self.montgomery_form
+    }
+
     /// Performs the modular division by 2, that is for given `x` returns `y`
     /// such that `y * 2 = x mod p`. This means:
     /// - if `x` is even, returns `x / 2`,
@@ -132,3 +177,12 @@ impl<const LIMBS: usize> Retrieve for DynResidue<LIMBS> {
         self.retrieve()
     }
 }
+
+impl<const LIMBS: usize, P: ResidueParams<LIMBS>> From<&Residue<P, LIMBS>> for DynResidue<LIMBS> {
+    fn from(residue: &Residue<P, LIMBS>) -> Self {
+        Self {
+            montgomery_form: residue.to_montgomery(),
+            residue_params: DynResidueParams::from_residue_params::<P>(),
+        }
+    }
+}