cralgebra 0.2.1

A fast crypto algebra library
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

use crate::*;
use noether::*;
use num_traits::*;
use std::ops::*;

#[derive(Clone, Copy, Debug, PartialEq)]
pub struct ModularDyn<T: Sized> {
    /// The underlying raw integer.
    pub inner: T,
    /// The modulo, stored at runtime.
    pub modulo: T,
}

//   ____                              _
//  / ___|___  _ ____   _____ _ __ ___(_) ___  _ __
// | |   / _ \| '_ \ \ / / _ \ '__/ __| |/ _ \| '_ \
// | |__| (_) | | | \ V /  __/ |  \__ \ | (_) | | | |
//  \____\___/|_| |_|\_/ \___|_|  |___/_|\___/|_| |_|
//

impl<T: PartialOrd> ModularDyn<T> {
	pub fn new(inner: T, modulo: T) -> Self {
		debug_assert!(inner < modulo);
		Self {
			inner: inner,
			modulo: modulo,
		}
	}
}

//     _       _     _ _ _   _
//    / \   __| | __| (_) |_(_)_   _____
//   / _ \ / _` |/ _` | | __| \ \ / / _ \
//  / ___ \ (_| | (_| | | |_| |\ V /  __/
// /_/   \_\__,_|\__,_|_|\__|_| \_/ \___|
//

impl<T: Clone + PartialOrd + Zero + WrappingAdd + WrappingSub + One> Add
    for ModularDyn<T>
{
    type Output = Self;

    fn add(self, rhs: Self) -> Self::Output {
    	debug_assert!(self.modulo == rhs.modulo);
        let sum = self.inner.wrapping_add(&rhs.inner);
        let power_of_two = self.modulo.clone() - T::one() == T::zero().wrapping_sub(&T::one()).into();
        let r = if power_of_two {
            sum
        } else {
            let wraparound = self.modulo.clone().wrapping_add(&(self.modulo.clone() - T::one())) > T::zero().wrapping_sub(&T::one()).into();
            if wraparound && sum < rhs.inner
                || !wraparound && sum > self.modulo.clone()
            {
                sum - self.modulo.clone()
            } else {
                sum
            }
        };
        Self { inner: r, modulo: self.modulo }
    }
}

//  __  __       _ _   _       _ _           _   _
// |  \/  |_   _| | |_(_)_ __ | (_) ___ __ _| |_(_)_   _____
// | |\/| | | | | | __| | '_ \| | |/ __/ _` | __| \ \ / / _ \
// | |  | | |_| | | |_| | |_) | | | (_| (_| | |_| |\ V /  __/
// |_|  |_|\__,_|_|\__|_| .__/|_|_|\___\__,_|\__|_| \_/ \___|
//

/*impl<T: Clone + Bounded + PartialEq + PartialOrd + Zero + ClosedAdd + ClosedSub + One + WideningMul> Mul for ModularDyn<T>
{
    type Output = Self;

    fn mul(self, rhs: Self) -> Self::Output {
    	debug_assert!(self.modulo == rhs.modulo);
        let (low, high) = self.inner.wdmul(&rhs.inner);
        let coeff = Self::new(T::max_value(), self.modulo.clone()) + Self::new(T::one(), self.modulo.clone());
        if high.is_zero() {
            Self::new(low % self.modulo.clone(), self.modulo)
        } else {
            let prod = Self::new(high, self.modulo.clone()) * coeff;
            Self::new(low % self.modulo.clone(), self.modulo) + prod
        }
    }
}*/