ecgen/
lib.rs

1pub mod combin;
2pub mod gray_code;
3pub mod perm;
4pub mod set_bipart;
5pub mod set_partition;
6
7pub use crate::combin::{comb, emk_comb_gen};
8pub use crate::gray_code::brgc_gen;
9pub use crate::perm::{ehr_gen, factorial, sjt_gen};
10pub use crate::set_bipart::{set_bipart_gen, stirling2nd2};
11pub use crate::set_partition::{set_partition_gen, stirling2nd};
12
13#[cfg(test)]
14mod tests {
15    use super::*;
16
17    #[test]
18    fn test_brgc() {
19        let mut cnt = 1;
20        for _n in brgc_gen(3) {
21            cnt += 1;
22        }
23        assert_eq!(cnt, 8);
24    }
25
26    #[test]
27    fn test_sjt() {
28        let mut cnt = 0;
29        for _n in sjt_gen(4) {
30            cnt += 1;
31        }
32        assert_eq!(cnt, factorial(4));
33    }
34
35    #[test]
36    fn test_ehr() {
37        let mut cnt = 1;
38        for _n in ehr_gen(4) {
39            cnt += 1;
40        }
41        assert_eq!(cnt, factorial(4));
42    }
43
44    #[test]
45    fn test_emk_even_odd() {
46        let mut cnt = 1;
47        for (_x, _y) in emk_comb_gen(16, 5) {
48            cnt += 1;
49        }
50        assert_eq!(cnt, comb(16, 5));
51    }
52
53    #[test]
54    fn test_emk_odd_odd() {
55        let mut cnt = 1;
56        for (_x, _y) in emk_comb_gen(15, 5) {
57            cnt += 1;
58        }
59        assert_eq!(cnt, comb(15, 5));
60    }
61
62    #[test]
63    fn test_emk_even_even() {
64        let mut cnt = 1;
65        for (_x, _y) in emk_comb_gen(16, 6) {
66            cnt += 1;
67        }
68        assert_eq!(cnt, comb(16, 6));
69    }
70
71    #[test]
72    fn test_emk_odd_even() {
73        let mut cnt = 1;
74        for (_x, _y) in emk_comb_gen(15, 6) {
75            cnt += 1;
76        }
77        assert_eq!(cnt, comb(15, 6));
78    }
79
80    #[test]
81    fn test_set_partition_special() {
82        const N: usize = 2;
83        const K: usize = 2;
84
85        let mut cnt = 1;
86        for (_x, _y) in set_partition_gen(N, K) {
87            cnt += 1;
88        }
89        assert_eq!(cnt, stirling2nd(2, 2));
90    }
91
92    #[test]
93    fn test_set_bipart_even() {
94        const N: usize = 5;
95
96        // 0 0 0 0 0 1
97        let mut b = [0; N + 1];
98        b[N] = 1; // b[0] is unused
99        let mut cnt = 1;
100        for x in set_bipart_gen(N) {
101            let old = b[x];
102            b[x] = 1 - b[x];
103            println!("Move {} from Block {} to Block {}", x, old, b[x]);
104            cnt += 1;
105        }
106        assert_eq!(cnt, stirling2nd2(5));
107    }
108
109    #[test]
110    fn test_set_bipart_special() {
111        const N: usize = 2;
112
113        let mut cnt = 1;
114        for _x in set_bipart_gen(N) {
115            cnt += 1;
116        }
117        assert_eq!(cnt, stirling2nd2(N));
118    }
119
120    #[test]
121    fn test_emk_k_is_1() {
122        let mut cnt = 1;
123        for (_x, _y) in emk_comb_gen(5, 1) {
124            cnt += 1;
125        }
126        assert_eq!(cnt, comb(5, 1));
127    }
128
129    #[test]
130    fn test_emk_k_is_n_minus_1() {
131        let mut cnt = 1;
132        for (_x, _y) in emk_comb_gen(5, 4) {
133            cnt += 1;
134        }
135        assert_eq!(cnt, comb(5, 4));
136    }
137
138    #[test]
139    fn test_sjt_cycle() {
140        let mut p = [0, 1, 2];
141        for i in sjt_gen(3) {
142            p.swap(i, i + 1);
143        }
144        assert_eq!(p, [0, 1, 2]);
145    }
146
147    #[test]
148    fn test_ehr_cycle() {
149        let mut p = [0, 1, 2];
150        for i in ehr_gen(3) {
151            p.swap(0, i);
152        }
153        assert_ne!(p, [0, 1, 2]);
154    }
155
156    #[test]
157    fn test_set_partition_gen_n4_k3() {
158        let mut p = [0, 0, 1, 2];
159        let mut cnt = 1;
160        for (i, j) in set_partition_gen(4, 3) {
161            p[i - 1] = j;
162            cnt += 1;
163        }
164        assert_eq!(cnt, stirling2nd(4, 3));
165    }
166
167    #[test]
168    fn test_set_bipart_gen_n3() {
169        let mut cnt = 1;
170        for _x in set_bipart_gen(3) {
171            cnt += 1;
172        }
173        assert_eq!(cnt, stirling2nd2(3));
174    }
175}