openpql-range-parser 0.1.0

Poker Range Notation Parser
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
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

use super::{Itertools, LazyLock};

type IdxPermutations = Vec<Vec<u8>>;

pub static PERM11: LazyLock<IdxPermutations> =
    LazyLock::new(|| (0..1).permutations(1).collect_vec());
pub static PERM21: LazyLock<IdxPermutations> =
    LazyLock::new(|| (0..2).permutations(1).collect_vec());
pub static PERM22: LazyLock<IdxPermutations> =
    LazyLock::new(|| (0..2).permutations(2).collect_vec());
pub static PERM31: LazyLock<IdxPermutations> =
    LazyLock::new(|| (0..3).permutations(1).collect_vec());
pub static PERM32: LazyLock<IdxPermutations> =
    LazyLock::new(|| (0..3).permutations(2).collect_vec());
pub static PERM33: LazyLock<IdxPermutations> =
    LazyLock::new(|| (0..3).permutations(3).collect_vec());
pub static PERM41: LazyLock<IdxPermutations> =
    LazyLock::new(|| (0..4).permutations(1).collect_vec());
pub static PERM42: LazyLock<IdxPermutations> =
    LazyLock::new(|| (0..4).permutations(2).collect_vec());
pub static PERM43: LazyLock<IdxPermutations> =
    LazyLock::new(|| (0..4).permutations(3).collect_vec());
pub static PERM44: LazyLock<IdxPermutations> =
    LazyLock::new(|| (0..4).permutations(4).collect_vec());

pub static PERM_BOARD_4: LazyLock<IdxPermutations> = LazyLock::new(|| {
    vec![
        vec![0, 1, 2, 3],
        vec![0, 2, 1, 3],
        vec![1, 0, 2, 3],
        vec![1, 2, 0, 3],
        vec![2, 0, 1, 3],
        vec![2, 1, 0, 3],
    ]
});

pub static PERM_BOARD_5: LazyLock<IdxPermutations> = LazyLock::new(|| {
    vec![
        vec![0, 1, 2, 3, 4],
        vec![0, 2, 1, 3, 4],
        vec![1, 0, 2, 3, 4],
        vec![1, 2, 0, 3, 4],
        vec![2, 0, 1, 3, 4],
        vec![2, 1, 0, 3, 4],
    ]
});

#[inline]
pub fn range_cond_indices(
    n: usize,
    r: usize,
    board: bool,
) -> &'static IdxPermutations {
    match (n, r, board) {
        (1, 1, false) => PERM11.as_ref(),

        (2, 1, false) => PERM21.as_ref(),
        (2, 2, false) => PERM22.as_ref(),

        (3, 1, false) | (5, 1, true) => PERM31.as_ref(),
        (3, 2, false) | (5, 2, true) => PERM32.as_ref(),
        (3, 3, false) | (5, 3, true) => PERM33.as_ref(),

        (4, 1, false) => PERM41.as_ref(),
        (4, 2, false) => PERM42.as_ref(),
        (4, 3, false) => PERM43.as_ref(),
        (4, 4, false) => PERM44.as_ref(),

        (5, 4, true) => PERM_BOARD_4.as_ref(),
        (5, 5, true) => PERM_BOARD_5.as_ref(),

        _ => unimplemented!("n={n}; r={r}; board: {board}"),
    }
}

#[cfg(test)]
mod tests {
    use self::range_cond_indices as indices;
    use super::*;

    #[test]
    fn test_indices() {
        assert_eq!(*indices(1, 1, false), [[0]]);
        assert_eq!(*indices(2, 1, false), [[0], [1]]);
        assert_eq!(*indices(2, 2, false), [[0, 1], [1, 0]]);
        assert_eq!(*indices(3, 1, false), [[0], [1], [2]]);
        assert_eq!(indices(3, 2, false).len(), 6);
        assert_eq!(indices(3, 3, false).len(), 6);
        assert_eq!(*indices(4, 1, false), [[0], [1], [2], [3]]);
        assert_eq!(indices(4, 2, false).len(), 12);
        assert_eq!(indices(4, 3, false).len(), 24);
        assert_eq!(indices(4, 4, false).len(), 24);
    }

    #[test]
    fn test_indices_board() {
        assert_eq!(*indices(5, 1, true), *indices(3, 1, false));
        assert_eq!(*indices(5, 2, true), *indices(3, 2, false));
        assert_eq!(*indices(5, 3, true), *indices(3, 3, false));
        assert_eq!(
            *indices(5, 4, true),
            [
                [0, 1, 2, 3],
                [0, 2, 1, 3],
                [1, 0, 2, 3],
                [1, 2, 0, 3],
                [2, 0, 1, 3],
                [2, 1, 0, 3],
            ]
        );

        assert_eq!(
            *indices(5, 5, true),
            [
                [0, 1, 2, 3, 4],
                [0, 2, 1, 3, 4],
                [1, 0, 2, 3, 4],
                [1, 2, 0, 3, 4],
                [2, 0, 1, 3, 4],
                [2, 1, 0, 3, 4],
            ]
        );
    }

    #[test]
    #[should_panic(expected = "not implemented: n=5; r=1; board: false")]
    fn test_unimpl() {
        let _ = indices(5, 1, false);
    }
}