reform 0.1.0

A symbolic manipulation toolkit which aims to handle expressions with billions of terms, taking up terabytes of diskspace.
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

//! Routines for modulo operation.

use fastdivide;

/// Abstraction of modulo operation.
pub trait Modulus<N, M>: Copy {
    /// Returns the modulo.
    fn value(&self) -> M;

    /// Modulo operation giving `x % modulo`.
    fn modulus(&self, x: N) -> N;
}

// Implementation for primitives.

impl Modulus<u64, u32> for u32 {
    #[inline]
    fn value(&self) -> u32 {
        *self
    }

    #[inline]
    fn modulus(&self, x: u64) -> u64 {
        x % u64::from(*self)
    }
}

/// Fast modulo operation for `u64 % u32`.
pub struct FastModulus6432 {
    n: u32,
    magic: fastdivide::DividerU64,
}

impl FastModulus6432 {
    /// Construct a fast modulo operation.
    #[inline]
    pub fn from(n: u32) -> FastModulus6432 {
        FastModulus6432 {
            n,
            magic: fastdivide::DividerU64::divide_by(u64::from(n)),
        }
    }
}

impl<'a> Modulus<u64, u32> for &'a FastModulus6432 {
    #[inline]
    fn value(&self) -> u32 {
        self.n
    }

    #[inline]
    fn modulus(&self, x: u64) -> u64 {
        // TODO: for now DividerU64 is used, but is it possible to make use of the fact that
        // the modulo fits in u32?
        let division = self.magic.divide(x);
        x - division * u64::from(self.n)
    }
}