musicbox 0.2.0

General Musical Framework for working with tonality
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
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163

use crate::core::semitone;
use crate::TONIC;




pub struct Notary {
    pub tonic: f64,
    pub octave: i64,
    pub chord: Vec<f64>,
}



// struct Chord {
//      //hash map of various length, we will store the rounded value as the key, and  
// }
//TODO: impl chord match     fn chord_match(&mut self) -> Result<Chord ,E>{}
impl Notary {
    pub fn new() -> Self {
        Self {
            tonic: TONIC,
            octave: 0,
            chord: vec![],
        }
    }
    ///[0]Tonic
    pub fn _0 (&mut self) {
        self.chord.push(semitone(self.tonic, 0));
    }
    ///[1]Semitone
    pub fn _1 (&mut self) {
        self.chord.push(semitone(self.tonic, 1));

    }
    ///[2]Wholetone
    pub fn _2(&mut self) {
        self.chord.push(semitone(self.tonic, 2));
    }
    ///[3]Minor3
    pub fn _3(&mut self) {
        self.chord.push(semitone(self.tonic, 3));

    }
    ///[4]Major3
    pub fn _4(&mut self) {
        self.chord.push(semitone(self.tonic, 4));

    }
    ///[5]Fourth(prime)inv[7]
    pub fn _5(&mut self) {
        self.chord.push(semitone(self.tonic, 5));

    }
    ///[6]Tritone***
    pub fn _6(&mut self) {
        self.chord.push(semitone(self.tonic, 6));

    }
    ///[7] Fifth(prime)inv[5],
    pub fn _7(&mut self) {
        self.chord.push(semitone(self.tonic, 7));

    }
    ///[8]Inverse[4]&&AugFifth
    pub fn _8(&mut self) {
        self.chord.push(semitone(self.tonic, 8));

    }
    ///[9]Inverse[3]Major6
    pub fn _9(&mut self) {
        self.chord.push(semitone(self.tonic, 9));

    }
    ///[x]Inverse[2]Dominant7
    pub fn _x(&mut self) {
        self.chord.push(semitone(self.tonic, 10));

    }
    ///[y]Inverse[1]Major7&&LeadTone
    pub fn _y(&mut self) {
        self.chord.push(semitone(self.tonic, 11));

    }
    ///[a] Octave(prime)
    pub fn _a(&mut self) {
        self.chord.push(semitone(self.tonic, 12));

    }
    ///[b] Minor9(invert[9])
    pub fn _b(&mut self) {
        self.chord.push(semitone(self.tonic, 13));

    }
    ///[c] Major9(invert[x])
    pub fn _c(&mut self) {
        self.chord.push(semitone(self.tonic, 14));

    }
    ///[d] Sharp9(invert[9])
    pub fn _d(&mut self) {
        self.chord.push(semitone(self.tonic, 15));

    }
    ///[e] Tenth(invert[8])
    pub fn _e(&mut self) {
        self.chord.push(semitone(self.tonic, 16));

    }
    ///[f] Eleventh(invert[7])
    pub fn _f(&mut self) {
        self.chord.push(semitone(self.tonic, 17));

    }
    ///[g] Sharp11(invert[6])
    pub fn _g(&mut self) {
        self.chord.push(semitone(self.tonic, 18));

    }
    ///[h] Twelfth(inv[5])
    pub fn _h(&mut self) {
        self.chord.push(semitone(self.tonic, 19));

    }
    ///[i] Flat13(invert[4])
    pub fn _i(&mut self) {
        self.chord.push(semitone(self.tonic, 20));

    }
    ///[j] Thirteen(inv[3])
    pub fn _j(&mut self) {
        self.chord.push(semitone(self.tonic, 21));

    }
    ///[k] Sharp13(inv[2])
    pub fn _k(&mut self) {
        self.chord.push(semitone(self.tonic, 22));

    }
    ///[l] Flat15 (invert[1])
    pub fn _l(&mut self) {
        self.chord.push(semitone(self.tonic, 23));

    }
    ///[m] Fifteen && DoubleOctave
    pub fn _m(&mut self) {
        self.chord.push(semitone(self.tonic, 24));

    }
    
}



#[test]
fn get_amaj0 () {

    // Create chords using a generic trait method that is implemented on different tonics.



}