ffnt 0.11.0

Finite fields for number theory
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

use crate::{Z32, Z64};

use paste::paste;
use rand::Rng;
use rand::distr::{
    Distribution, StandardUniform,
    uniform::{Error, SampleBorrow, SampleUniform, UniformInt, UniformSampler},
};

macro_rules! impl_rand {
    ( $($z:literal), *) => {
        $(
            paste!{
                impl<const P: [<u $z>]> Distribution<[<Z $z>]<P>> for StandardUniform {
                    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> [<Z $z>]<P> {
                        let num = rng.random_range(0..P);
                        [<Z $z>]::new_unchecked(num)
                    }
                }

                #[allow(missing_docs)]
                #[derive(Clone, Copy, Debug)]
                pub struct [<UniformZ $z>]<const P: [<u $z>]>(UniformInt<[<u $z>]>);

                impl<const P: [<u $z>]> UniformSampler for [<UniformZ $z>]<P> {
                    type X = [<Z $z>]<P>;

                    fn new<B1, B2>(low: B1, high: B2) -> Result<Self, Error>
                    where B1: SampleBorrow<Self::X> + Sized,
                          B2: SampleBorrow<Self::X> + Sized
                    {
                        Ok([<UniformZ $z>](
                            UniformInt::<[<u $z>]>::new(
                                low.borrow().repr(),
                                high.borrow().repr()
                            )?
                        ))
                    }
                    fn new_inclusive<B1, B2>(low: B1, high: B2) -> Result<Self, Error>
                    where B1: SampleBorrow<Self::X> + Sized,
                          B2: SampleBorrow<Self::X> + Sized
                    {
                        Ok([<UniformZ $z>](UniformInt::<[<u $z>]>::new_inclusive(
                            low.borrow().repr(),
                            high.borrow().repr(),
                        )?))
                    }
                    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Self::X {
                        [<Z $z>]::new_unchecked(self.0.sample(rng))
                    }
                }

                impl<const P: [<u $z>]> SampleUniform for [<Z $z>]<P> {
                    type Sampler = [<UniformZ $z>]<P>;
                }
            }
        )*
    }
}

impl_rand! {32, 64}

#[cfg(test)]
mod tests {

    use rand::{Rng, SeedableRng};

    const PRIMES: [u64; 3] = [3, 443619635352171979, 1152921504606846883];

    #[test]
    fn random() {
        use crate::Z64;
        let mut rng = rand_xoshiro::Xoshiro256StarStar::seed_from_u64(0);

        for _ in 0..1000 {
            let _z: Z64<{ PRIMES[0] }> = rng.random();
            let _z: Z64<{ PRIMES[1] }> = rng.random();
            let _z: Z64<{ PRIMES[2] }> = rng.random();
        }
    }

    #[test]
    fn random_range() {
        use crate::Z64;
        let mut rng = rand_xoshiro::Xoshiro256StarStar::seed_from_u64(0);

        const P: u64 = PRIMES[2];
        const MIN: Z64<P> = Z64::new(7);
        const MAX: Z64<P> = Z64::new(153);

        for _ in 0..1000 {
            let z = rng.random_range(MIN..MAX);
            assert!(z >= MIN);
            assert!(z < MAX);
        }
    }
}