resonata 0.3.0

A music theory library for Rust.
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

#[cfg(test)]
mod tests {
    use super::super::*;
    use crate::{*, notes::NoteName::*};

    #[test]
    fn test_from_steps() {
        let scale = Scale::major();
        let intervals = scale.intervals();
        let expected_intervals = vec![
            Interval::from(2),
            Interval::from(2),
            Interval::from(1),
            Interval::from(2),
            Interval::from(2),
            Interval::from(2),
            Interval::from(1),
        ];
        assert_eq!(*intervals, expected_intervals);
    }

    #[test]
    fn test_to_steps() {
        let steps = Scale::major().to_steps();
        let expected_steps = vec![2, 2, 1, 2, 2, 2, 1];
        assert_eq!(steps, expected_steps);
    }

    #[test]
    fn test_from_str() {
        let scale = Scale::from_str("2, 2, 1, 2, 2, 2, 1").unwrap();
        let expected_scale = Scale::major();
        assert_eq!(scale, expected_scale);

        let scale = Scale::from_str("M2, M2, m2, M2, M2, M2, m2").unwrap();
        let expected_scale = Scale::major();
        assert_eq!(scale, expected_scale);

        let scale = Scale::from_str("C, D, E, F, G, A, B").unwrap();
        let expected_scale = Scale::major();
        assert_eq!(scale, expected_scale);
    }

    #[test]
    fn test_from_notes() {
        let notes = vec![
            Note::from(60),
            Note::from(62),
            Note::from(64),
            Note::from(65),
            Note::from(67),
            Note::from(69),
            Note::from(71),
        ];
        let expected_notes = Scale::major().to_notes(note!(C));
        assert_eq!(notes, expected_notes);
    }

    #[test]
    fn test_to_notes() {
        let scale = Scale::major();
        let expected_notes = vec![
            Note::from(60),
            Note::from(62),
            Note::from(64),
            Note::from(65),
            Note::from(67),
            Note::from(69),
            Note::from(71),
        ];
        assert_eq!(scale.to_notes(note!(C)), expected_notes);
        println!("{}", scale);
    }

    #[test]
    fn test_scale_types() {
        assert_eq!(vec![
            note!(C), 
            note!(D), 
            note!(E), 
            note!(F), 
            note!(G), 
            note!(A), 
            note!(B)], 
            Scale::major().to_notes(note!(C)));
        assert_eq!(Scale::from_steps(vec![2, 1, 2, 2, 1, 2, 2]), Scale::minor());
        assert_eq!(Scale::from_steps(vec![1; 12]), Scale::chromatic());
    }

    #[test]
    fn test_rotation() {
        let scale = Scale::major().rotated(1);
        let expected_scale = Scale::from_steps(vec![2, 1, 2, 2, 2, 1, 2]);
        assert_eq!(scale, expected_scale);
    }

    #[test]
    fn test_macros() {
        assert_eq!(Scale::major(), scale!(Major, 0));
        assert_eq!(Scale::minor(), scale!(Minor, 0));
        
    }
}