Struct Key

Source

pub struct Key { /* private fields */ }

Expand description

Musical key signature represented as a root PitchClass, Scale (e.g. Major/Minor), and Mode.

use redact_composer_musical::{Key, Mode, NoteName::*, Scale::Major, Note, PitchClassCollection};
let c_major = Key::from((C, Major));
assert_eq!(c_major.pitch_classes(), vec![C, D, E, F, G, A, B]);

Implementations§

Source §

impl Key

Source

pub fn root_name(&self) -> NoteName

Returns the NoteName of the key’s tonic pitch class.

Source

pub fn note_names(&self) -> Vec<NoteName>

Returns the ordered list of NoteName’s associated with the key’s pitch classes.

use redact_composer_musical::{Key, NoteName::*, Scale::Major};
let key = Key::from((D, Major));
assert_eq!(key.note_names(), [D, E, Fs, G, A, B, Cs])

Source §

impl Key

Source

pub fn new(root: PitchClass, scale: Scale, mode: Mode) -> Key

Creates a Key from a PitchClass, Scale, and Mode. Alternatively, several From implementations are supported:

use redact_composer_musical::{Key, Mode::Ionian, NoteName::C, PitchClass, Scale::Major};

// All the ways to define C Major (Ionian)
let first = Key::new(PitchClass(0), Major, Ionian);
let second = Key::from((PitchClass(0), Major));
let third = Key::from((PitchClass(0), Major, Ionian));
let fourth = Key::from((C, Major));
let fifth = Key::from((C, Major, Ionian));

assert!([second, third, fourth, fifth].into_iter().all(|k| k == first));

Source

pub fn root(&self) -> PitchClass

Returns the key’s root PitchClass.

Source

pub fn scale(&self) -> Scale

Returns the key’s Scale.

Source

pub fn mode(&self) -> Mode

Returns the key’s Mode.

Source

pub fn chords(&self) -> Vec<Chord>

Returns the chords that use notes exclusively from this key.

Source

pub fn chords_with_shape(&self, shape: Vec<ChordShape>) -> Vec<Chord>

Returns chords of the given shapes which use notes exclusively from this key.

use redact_composer_musical::{Key, NoteName::*, Chord, ChordShape, ChordShape::{dim, maj, min}, Scale, Mode};
use redact_composer_musical::Scale::Major;

let key = Key::from((C, Major));
assert_eq!(
    key.chords_with_shape(ChordShape::triad()),
    vec![
        Chord::from((C, maj)),
        Chord::from((D, min)),
        Chord::from((E, min)),
        Chord::from((F, maj)),
        Chord::from((G, maj)),
        Chord::from((A, min)),
        Chord::from((B, dim)),
    ]
)

Source

pub fn contains(&self, pitches: &P) -> bool
where P: PitchClassCollection,

Checks if all PitchClasss from a collection (for example, Chord) belong to this key.

use redact_composer_musical::{Chord, ChordShape::{maj, min}, Key, Mode::Ionian, NoteName::*, Scale::Major};

assert!(Key::from((C, Major)).contains(&Chord::from((C, maj))));
assert!(!Key::from((C, Major)).contains(&Chord::from((C, min))));

Source

pub fn relative_pitch<D>(&self, degree: D) -> PitchClass
where D: Into<Degree>,

Returns the pitch class for a given degree of this scale.

use redact_composer_musical::{Degree, Key, Scale::Major, Mode::Locrian, NoteName::{B, D}};

let key = Key::from((B, Major, Locrian));
assert_eq!(key.relative_pitch(Degree::III), D);