lace 0.9.1

A probabilistic cross-categorization engine
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

#![warn(unused_extern_crates)]
#![warn(
    clippy::all,
    clippy::imprecise_flops,
    clippy::suboptimal_flops,
    clippy::unseparated_literal_suffix,
    clippy::unreadable_literal,
    clippy::option_option,
    clippy::implicit_clone
)]

mod matrix;
mod misc;
pub mod numbers;
pub mod quad;
mod random;
mod stats;
mod unique;

pub use matrix::*;
pub use misc::*;
pub use random::*;
pub use stats::*;
pub use unique::*;

/// Iterates over a set of categorical ranges
pub struct CategoricalCartProd {
    ranges: Vec<u32>,
    item: Vec<u32>,
    start: bool,
}

impl CategoricalCartProd {
    pub fn new(ranges: Vec<u32>) -> Self {
        CategoricalCartProd {
            item: vec![0; ranges.len()],
            ranges,
            start: true,
        }
    }
}

impl Iterator for CategoricalCartProd {
    type Item = Vec<u32>;

    fn next(&mut self) -> Option<Self::Item> {
        if self.start {
            self.start = false;
            return Some(self.item.clone());
        }

        let mut k = self.item.len() - 1;

        if self.item[k] == self.ranges[k] - 1 {
            if k == 0 {
                // if there is only one element in ranges, there is nothing more
                // to do because we've provided all the values
                return None;
            }
            loop {
                self.item[k] = 0;
                k -= 1;
                if self.item[k] != (self.ranges[k] - 1) {
                    self.item[k] += 1;
                    return Some(self.item.clone());
                } else if k == 0 {
                    return None;
                }
            }
        } else {
            self.item[k] += 1;
            Some(self.item.clone())
        }
    }
}

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

    #[test]
    fn cartprod_single() {
        let mut cartprod = CategoricalCartProd::new(vec![3]);
        assert_eq!(cartprod.next(), Some(vec![0]));
        assert_eq!(cartprod.next(), Some(vec![1]));
        assert_eq!(cartprod.next(), Some(vec![2]));
        assert_eq!(cartprod.next(), None);
    }

    #[test]
    fn cartprod_dual() {
        let mut cartprod = CategoricalCartProd::new(vec![3, 2]);
        assert_eq!(cartprod.next(), Some(vec![0, 0]));
        assert_eq!(cartprod.next(), Some(vec![0, 1]));
        assert_eq!(cartprod.next(), Some(vec![1, 0]));
        assert_eq!(cartprod.next(), Some(vec![1, 1]));
        assert_eq!(cartprod.next(), Some(vec![2, 0]));
        assert_eq!(cartprod.next(), Some(vec![2, 1]));
        assert_eq!(cartprod.next(), None);
    }

    #[test]
    fn cartprod_triple() {
        let mut cartprod = CategoricalCartProd::new(vec![3, 2, 1]);
        assert_eq!(cartprod.next(), Some(vec![0, 0, 0]));
        assert_eq!(cartprod.next(), Some(vec![0, 1, 0]));
        assert_eq!(cartprod.next(), Some(vec![1, 0, 0]));
        assert_eq!(cartprod.next(), Some(vec![1, 1, 0]));
        assert_eq!(cartprod.next(), Some(vec![2, 0, 0]));
        assert_eq!(cartprod.next(), Some(vec![2, 1, 0]));
        assert_eq!(cartprod.next(), None);
    }
}