arcium-primitives 0.4.2

Arcium primitives
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

pub mod random;
pub mod sharing;
pub mod types;

pub use types::*;

#[cfg(test)]
mod tests {
    use itertools::Itertools;
    use typenum::{Unsigned, U5};

    use crate::{
        algebra::elliptic_curve::{Curve25519Ristretto, ScalarField},
        correlated_randomness::singlets::Singlets,
        random::{Random, RandomWith},
        sharing::Verifiable,
    };

    pub type Fq = ScalarField<Curve25519Ristretto>;

    #[test]
    fn test_random_singlets() {
        let n_parties = 3;
        type NSamples = U5;
        let mut rng = crate::random::test_rng();

        // Generate singlets
        let random_singlets: Vec<_> = Singlets::<Fq, NSamples>::random_n(&mut rng, n_parties);

        // Verify the singlets
        Singlets::verify_all(random_singlets).unwrap();
    }

    #[test]
    fn test_collect_singlets() {
        let n_parties = 3;
        type NSamples = U5;
        let mut rng = crate::random::test_rng();

        // Generate singlets
        let random_singlet = Singlets::<Fq, NSamples>::random_with(&mut rng, n_parties);

        // Collect them into a vector of vectors
        let collected_singlets = random_singlet.clone().into_iter().collect_vec();

        // Check that the singlets were collected correctly
        assert_eq!(collected_singlets.len(), NSamples::USIZE);
        for (i, singlet) in collected_singlets.iter().enumerate().take(NSamples::USIZE) {
            assert_eq!(
                singlet.0.get_value().to_owned(),
                random_singlet.0.get_value()[i]
            );
        }
    }

    #[test]
    fn test_iter_singlets() {
        let n_parties = 3;
        type NSamples = U5;
        let mut rng = crate::random::test_rng();

        // Generate singlets
        let singlets = Singlets::<Fq, NSamples>::random_n::<Vec<_>>(&mut rng, n_parties)[0].clone();

        // Iterate over them and collect back
        let collected_singlets = singlets
            .clone()
            .into_iter()
            .collect::<Singlets<Fq, NSamples>>();

        // Check that the singlets were collected correctly
        assert_eq!(collected_singlets.0, singlets.0);
    }

    #[test]
    fn test_ref_iter_singlets() {
        let n_parties = 3;
        type NSamples = U5;
        let mut rng = crate::random::test_rng();

        // Generate singlets
        let singlets = Singlets::<Fq, NSamples>::random_n::<Vec<_>>(&mut rng, n_parties)[0].clone();

        // Iterate over them and collect back
        let collected_singlets = (&singlets).into_iter().collect::<Singlets<Fq, NSamples>>();

        // Check that the singlets were collected correctly
        assert_eq!(collected_singlets.0, singlets.0);
    }

    #[test]
    fn test_into_parallel_iter() {
        use rayon::prelude::*;

        let n_parties = 3;
        type NSamples = U5;
        let mut rng = crate::random::test_rng();

        // Generate singlets
        let singlets = Singlets::<Fq, NSamples>::random_n::<Vec<_>>(&mut rng, n_parties)[0].clone();

        // Iterate over them and collect back
        let collected_singlets = singlets.clone().into_par_iter().collect::<Vec<_>>();
        let collected_singlets = Singlets::<Fq, NSamples>::from_iter(collected_singlets);

        // Check that the singlets were collected correctly
        assert_eq!(collected_singlets.0, singlets.0);
    }
}