rstmt-core 0.0.2

This crate focuses on building a music theory library that can be used to generate music theory data structures and algorithms.
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

/*
    Appellation: ops <test>
    Contrib: FL03 <jo3mccain@icloud.com>
*/
extern crate rstmt_core as rstmt;

const MOD: i8 = 12;

lazy_static::lazy_static! {
    static ref CASES: Vec<res::Pair<i8, i8>> = PAIRS.iter().map(|(i, j)| res::Pair::new(*i, *j)).collect();
}
const PAIRS: [(i8, i8); 6] = [(5, 5), (-17, 7), (0, 0), (12, 0), (-12, 0), (-13, 11)];

#[test]
fn test_absmod() {
    use rstmt::ops::AbsMod;
    let cases = PAIRS;
    for (i, j) in cases.iter() {
        assert_eq!(i.absmod(MOD), *j);
    }
}

#[test]
fn test_pymod() {
    use rstmt::ops::PyMod;
    assert_eq!(5.pymod(MOD), 5);
    assert_eq!((-17).pymod(MOD), 7);
    assert_eq!(17.pymod(-MOD), -7);
}

pub mod res {
    #[derive(Clone, Copy, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
    #[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
    pub struct Pair<A, B = A>(pub A, pub B);

    impl<A, B> Pair<A, B> {
        pub fn new(a: A, b: B) -> Self {
            Self(a, b)
        }

        pub fn as_tuple(&self) -> (&A, &B) {
            (&self.0, &self.1)
        }

        pub fn into_tuple(self) -> (A, B) {
            (self.0, self.1)
        }

        pub const fn a(&self) -> &A {
            &self.0
        }

        pub const fn b(&self) -> &B {
            &self.1
        }

        pub fn is_eq(&self) -> bool
        where
            A: PartialEq<B>,
        {
            self.a() == self.b()
        }

        pub fn is_ne(&self) -> bool
        where
            A: PartialEq<B>,
        {
            self.a() != self.b()
        }

        pub fn is_ge(&self) -> bool
        where
            A: PartialOrd<B>,
        {
            self.a() >= self.b()
        }

        pub fn is_gt(&self) -> bool
        where
            A: PartialOrd<B>,
        {
            self.a() > self.b()
        }

        pub fn is_le(&self) -> bool
        where
            A: PartialOrd<B>,
        {
            self.a() <= self.b()
        }

        pub fn is_lt(&self) -> bool
        where
            A: PartialOrd<B>,
        {
            self.a() < self.b()
        }

        pub fn is_default(&self) -> bool
        where
            A: PartialEq + Default,
        {
            self.a() == &A::default()
        }
    }

    impl<A, B> From<(A, B)> for Pair<A, B> {
        fn from(pair: (A, B)) -> Self {
            Self(pair.0, pair.1)
        }
    }
}