poly-ring-xnp1 0.2.0

Polynomial ring Z[x]/(x^n+1) for lattice-based cryptography
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
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

use num::{FromPrimitive, ToPrimitive};

use super::{ZqI32, ZqI64, ZqU32, ZqU64};

macro_rules! impl_to_primitive {
    ($T:ty, $Z:tt) => {
        impl<const Q: $T> ToPrimitive for $Z<Q> {
            fn to_i64(&self) -> Option<i64> {
                <$T as ToPrimitive>::to_i64(&self.value)
            }

            fn to_u64(&self) -> Option<u64> {
                <$T as ToPrimitive>::to_u64(&self.value)
            }
        }
    };
}

impl_to_primitive!(i32, ZqI32);
impl_to_primitive!(i64, ZqI64);
impl_to_primitive!(u32, ZqU32);
impl_to_primitive!(u64, ZqU64);

macro_rules! impl_from_primitive {
    ($T:ty, $Z:tt) => {
        impl<const Q: $T> FromPrimitive for $Z<Q> {
            fn from_i64(n: i64) -> Option<Self> {
                <$T as FromPrimitive>::from_i64(n).map(Self::new)
            }

            fn from_u64(n: u64) -> Option<Self> {
                <$T as FromPrimitive>::from_u64(n).map(Self::new)
            }
        }
    };
}

impl_from_primitive!(i32, ZqI32);
impl_from_primitive!(i64, ZqI64);
impl_from_primitive!(u32, ZqU32);
impl_from_primitive!(u64, ZqU64);

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_i32_from_to_primitive() {
        let zq = ZqI32::<7>::new(3);
        assert_eq!(zq.to_i64(), Some(3));
        assert_eq!(zq.to_u64(), Some(3));

        let zq = ZqI32::<7>::new(-3);
        assert_eq!(zq.to_i64(), Some(-3));
        assert_eq!(zq.to_u64(), None);

        assert_eq!(ZqI32::<7>::from_i64(3), Some(ZqI32::<7>::new(3)));
        assert_eq!(ZqI32::<7>::from_i64(10), Some(ZqI32::<7>::new(3)));
        assert_eq!(ZqI32::<7>::from_i64(-3), Some(ZqI32::<7>::new(-3)));
        assert_eq!(ZqI32::<7>::from_i64(-10), Some(ZqI32::<7>::new(-3)));

        assert_eq!(ZqI32::<7>::from_u64(3), Some(ZqI32::<7>::new(3)));
        assert_eq!(ZqI32::<7>::from_u64(10), Some(ZqI32::<7>::new(3)));
    }

    #[test]
    fn test_u32_from_to_primitive() {
        let zq = ZqU32::<7>::new(3);
        assert_eq!(zq.to_i64(), Some(3));
        assert_eq!(zq.to_u64(), Some(3));

        let zq = ZqU32::<7>::new(10);
        assert_eq!(zq.to_i64(), Some(3));
        assert_eq!(zq.to_u64(), Some(3));

        assert_eq!(ZqU32::<7>::from_i64(3), Some(ZqU32::<7>::new(3)));
        assert_eq!(ZqU32::<7>::from_i64(10), Some(ZqU32::<7>::new(3)));
        assert_eq!(ZqU32::<7>::from_i64(-3), None);
        assert_eq!(ZqU32::<7>::from_i64(-10), None);

        assert_eq!(ZqU32::<7>::from_u64(3), Some(ZqU32::<7>::new(3)));
        assert_eq!(ZqU32::<7>::from_u64(10), Some(ZqU32::<7>::new(3)));
    }

    #[test]
    fn test_i64_from_to_primitive() {
        let zq = ZqI64::<7>::new(3);
        assert_eq!(zq.to_i64(), Some(3));
        assert_eq!(zq.to_u64(), Some(3));

        let zq = ZqI64::<7>::new(-3);
        assert_eq!(zq.to_i64(), Some(-3));
        assert_eq!(zq.to_u64(), None);

        assert_eq!(ZqI64::<7>::from_i64(3), Some(ZqI64::<7>::new(3)));
        assert_eq!(ZqI64::<7>::from_i64(10), Some(ZqI64::<7>::new(3)));
        assert_eq!(ZqI64::<7>::from_i64(-3), Some(ZqI64::<7>::new(-3)));
        assert_eq!(ZqI64::<7>::from_i64(-10), Some(ZqI64::<7>::new(-3)));

        assert_eq!(ZqI64::<7>::from_u64(3), Some(ZqI64::<7>::new(3)));
        assert_eq!(ZqI64::<7>::from_u64(10), Some(ZqI64::<7>::new(3)));
    }

    #[test]
    fn test_u64_from_to_primitive() {
        let zq = ZqU64::<7>::new(3);
        assert_eq!(zq.to_i64(), Some(3));
        assert_eq!(zq.to_u64(), Some(3));

        let zq = ZqU64::<7>::new(10);
        assert_eq!(zq.to_i64(), Some(3));
        assert_eq!(zq.to_u64(), Some(3));

        assert_eq!(ZqU64::<7>::from_i64(3), Some(ZqU64::<7>::new(3)));
        assert_eq!(ZqU64::<7>::from_i64(10), Some(ZqU64::<7>::new(3)));
        assert_eq!(ZqU64::<7>::from_i64(-3), None);
        assert_eq!(ZqU64::<7>::from_i64(-10), None);

        assert_eq!(ZqU64::<7>::from_u64(3), Some(ZqU64::<7>::new(3)));
        assert_eq!(ZqU64::<7>::from_u64(10), Some(ZqU64::<7>::new(3)));
    }
}