hapsi 0.0.3

A music theory package
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

use std::collections::HashMap;

use once_cell::sync::Lazy;

use crate::{
    core::Chord as CoreChord,
    core::*,
    prelude::{Tone, Twelve},
};

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct Chord<T> {
    root: T,
    quality: Quality,
}

impl<T> Chord<T> {
    pub fn new(root: T, quality: Quality) -> Self {
        Self { root, quality }
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum Quality {
    Major,
    Minor,
    Dim,
    Aug,
    Major7,
    Minor7,
}

static ENUM_QUALITY: Lazy<[Quality; 6]> = Lazy::new(|| {
    [
        Quality::Major,
        Quality::Minor,
        Quality::Dim,
        Quality::Aug,
        Quality::Major7,
        Quality::Minor7,
    ]
});

impl Quality {
    pub fn enumerate() -> std::slice::Iter<'static, Quality> {
        ENUM_QUALITY.iter()
    }
}

static QUALITY_TO_INTERVAL: Lazy<HashMap<Quality, Vec<Interval>>> = Lazy::new(|| {
    let mut hash = HashMap::<Quality, Vec<Interval>>::default();
    hash.insert(Quality::Major, vec![4.into(), 7.into()]);
    hash.insert(Quality::Minor, vec![3.into(), 7.into()]);
    hash.insert(Quality::Dim, vec![3.into(), 6.into()]);
    hash.insert(Quality::Aug, vec![4.into(), 8.into()]);
    hash.insert(Quality::Major7, vec![4.into(), 7.into(), 11.into()]);
    hash.insert(Quality::Minor7, vec![3.into(), 7.into(), 11.into()]);
    hash
});

impl Chord<Tone> {
    pub fn into_class(self) -> CoreChord<Tone> {
        let keyboard = Keyboard::new(Twelve);
        let intervals = QUALITY_TO_INTERVAL.get(&self.quality).unwrap();
        let root_value: usize = self.root.into();
        let others = intervals
            .iter()
            .map(|i| keyboard.get_class(&(root_value + i.value())).clone())
            .collect();
        CoreChord::new(self.root, others)
    }
}

impl Chord<Pitch<Tone>> {
    pub fn into_pitch(self) -> CoreChord<Pitch<Tone>> {
        let keyboard = Keyboard::new(Twelve);
        let intervals = QUALITY_TO_INTERVAL.get(&self.quality).unwrap();
        let root_value: usize = keyboard.as_number(&self.root).unwrap();
        let others = intervals
            .iter()
            .map(|i| keyboard.get_pitch(&(root_value + i.value())).deref())
            .collect();
        CoreChord::new(self.root, others)
    }
}

#[cfg(test)]
mod tests {

    use super::Chord;

    #[test]
    fn into_class() {
        let mut chord = Chord::new("A".parse().unwrap(), super::Quality::Major7)
            .into_class()
            .into_vec()
            .into_iter();
        assert_eq!(chord.next(), Some("A".parse().unwrap()));
        assert_eq!(chord.next(), Some("Cs".parse().unwrap()));
        assert_eq!(chord.next(), Some("E".parse().unwrap()));
        assert_eq!(chord.next(), Some("Gs".parse().unwrap()));
    }
}