tc_modular 0.1.0

Modular arithmetic and Montgomery forms for cryptography over the integers of tc_bigint, constant time over the fixed-width and padded ones.
Documentation
//! Negation of [`FixedMontyForm`].

use core::ops::Neg;

use tc_bigint::{FixedBigUint, Limb, LimbArray};

use super::FixedMontyForm;
use crate::monty::sub_mod_assign;
use crate::wipe::replace_wiped;

/// `-self mod m`, never negative: zero stays zero, and any other value `x`
/// becomes `m - x`. Constant time.
impl<const N: usize> Neg for FixedMontyForm<N> {
    type Output = FixedMontyForm<N>;

    fn neg(mut self) -> FixedMontyForm<N> {
        let mut negated = [Limb::new(0); N];
        sub_mod_assign(
            &mut negated,
            self.value.as_limbs(),
            self.params.modulus.as_limbs(),
        );
        // The negation takes the place of the value, which is wiped.
        replace_wiped(&mut self.value, FixedBigUint::new(LimbArray::new(negated)));
        self
    }
}

/// Negates a copy of `self`, on the stack. Constant time.
impl<const N: usize> Neg for &FixedMontyForm<N> {
    type Output = FixedMontyForm<N>;

    fn neg(self) -> FixedMontyForm<N> {
        -self.clone()
    }
}

#[cfg(test)]
mod tests {
    use super::super::testing::{MODULI, VALUES, form, int};

    #[test]
    fn the_negation_is_the_modulus_less_the_residue() {
        for m in MODULI {
            for a in VALUES {
                assert_eq!((-form(a, m)).retrieve(), int((m - a % m) % m), "{a} {m}");
            }
        }
    }
}