Struct music_theory::theory::chord::RootedChord

pub struct RootedChord {
    pub root: Note,
    pub chord: Chord,
}

Wrapper around Chord. Also has a root note and extra functionality around that.

Example:

use music_theory::theory::*;
let chord = RootedChord::new(Note::C2, &MAJOR);
assert_eq!(chord.to_scale().unwrap(), vec![Note::C2, Note::E2, Note::G2]);

Fields

root: Note

The root note from which the chord is build.

chord: Chord

The quality of the chord.

Implementations

impl RootedChord

pub fn new(root: Note, intervals: &[Note]) -> Self

Create an new RootedChord from a root note and some unsigned intervals.

Example:

use music_theory::theory::*;
let chord = RootedChord::new(Note::C2, &MAJOR);
assert_eq!(chord.to_scale().unwrap(), vec![Note::C2, Note::E2, Note::G2]);

pub fn from_chord(root: Note, chord: Chord) -> Self

Create an RootedChord from a root note and a chord.

Example:

use music_theory::theory::*;
let chord = RootedChord::from_chord(Note::C2, Chord::new(&MAJOR));
assert_eq!(chord.to_scale().unwrap(), vec![Note::C2, Note::E2, Note::G2]);

pub fn as_scale(&self) -> Scale

Convert the RootedChord to a Scale.

Example:

use music_theory::theory::*;
let chord = RootedChord::new(Note::C2, &MAJOR);
assert_eq!(chord.as_scale().unwrap(), vec![Note::C2, Note::E2, Note::G2]);

pub fn to_scale(self) -> Scale

Ownership taking version of as_scale.

Example:

use music_theory::theory::*;
let chord = RootedChord::new(Note::C2, &MAJOR);
assert_eq!(chord.to_scale().unwrap(), vec![Note::C2, Note::E2, Note::G2]);

pub fn normalized(self) -> Self

Returns a normalised version of the RootedChord.

Example:

use music_theory::theory::*;
use interval::note_interval as ni;
assert_eq!(
    RootedChord::new(Note::C1, &[ni::MAJ2, ni::MAJ3, ni::PER5, ni::MAJ7, ni::MAJ9, ni::PER5])
        .normalized(),
    RootedChord{
        root: Note::C0,
        chord: Chord::new(&[ni::MAJ2, ni::MAJ3, ni::PER5, ni::MAJ7])
    }
);

pub fn as_chordtone_wholetone_scale(&self) -> Option<Scale>

Attempts to find a chordtone wholetone scale for the RootedChord.

Example:

use music_theory::theory::*;
assert_eq!(
    RootedChord::new(Note::F1, MAJOR_SEVENTH_CHORD).as_chordtone_wholetone_scale(),
    Some(Scale::wrap(
        vec![Note::F1, Note::G1, Note::A2, Note::B2, Note::C2, Note::D2, Note::E2]
    )).unwrap()
);

pub fn as_inversion(&self) -> Self

Returns a RootedChord that is the next inversion of the current one.

Example:

use music_theory::theory::*;
assert_eq!(
    Scale::wrap(vec![Note::A1, Note::C1, Note::E1, Note::G1])
        .unwrap().as_rooted_chord().to_inversion(),
    Scale::wrap(vec![Note::C1, Note::E1, Note::G1, Note::A2])
        .unwrap().as_rooted_chord(),
);

pub fn to_inversion(self) -> Self

Ownership taking version of as_inversion.

Example:

use music_theory::theory::*;
assert_eq!(
    Scale::wrap(vec![Note::A1, Note::C1, Note::E1, Note::G1])
        .unwrap().to_rooted_chord().to_inversion(),
    Scale::wrap(vec![Note::C1, Note::E1, Note::G1, Note::A2])
        .unwrap().to_rooted_chord(),
);

pub fn as_all_inversions(&self) -> Vec<Self>

Returns a vector of all inversions of the RootedChord.

Example:

use music_theory::theory::*;
assert_eq!(
    Scale::wrap(vec![Note::A1, Note::C1, Note::E1, Note::G1])
        .unwrap().to_rooted_chord().as_all_inversions(),
    vec![
        Scale::wrap(vec![Note::C1, Note::E1, Note::G1, Note::A2]).unwrap().to_rooted_chord(),
        Scale::wrap(vec![Note::E1, Note::G1, Note::A1, Note::C2]).unwrap().to_rooted_chord(),
        Scale::wrap(vec![Note::G1, Note::A2, Note::C2, Note::E2]).unwrap().to_rooted_chord(),
        Scale::wrap(vec![Note::A2, Note::C2, Note::E2, Note::G2]).unwrap().to_rooted_chord(),
    ]
);

pub fn to_all_inversions(self) -> Vec<Self>

Ownership taking version of as_all_inversions.

Example:

use music_theory::theory::*;
assert_eq!(
    Scale::wrap(vec![Note::A1, Note::C1, Note::E1, Note::G1])
        .unwrap().to_rooted_chord().to_all_inversions(),
    vec![
        Scale::wrap(vec![Note::C1, Note::E1, Note::G1, Note::A2]).unwrap().to_rooted_chord(),
        Scale::wrap(vec![Note::E1, Note::G1, Note::A1, Note::C2]).unwrap().to_rooted_chord(),
        Scale::wrap(vec![Note::G1, Note::A2, Note::C2, Note::E2]).unwrap().to_rooted_chord(),
        Scale::wrap(vec![Note::A2, Note::C2, Note::E2, Note::G2]).unwrap().to_rooted_chord(),
    ]
);

pub fn as_string(&self, style: ChordStyle) -> String

Stringify the RootedChord.

Example:

use music_theory::theory::*;
let std = ChordStyle::Std(MStyle::Symbol, EStyle::Symbol);
assert_eq!(&RootedChord::new(Note::C2, &MINOR_MAJOR_SEVENTH).as_string(std), "C-Δ");

Trait Implementations

impl AsSubs for RootedChord

fn as_subs(&self, max_len: Option<usize>) -> Vec<Self>

Generate all subs sets with optional maximal subset length. The output size of this grows really fast with the input size so be aware: 2, 5, 16, 65, 326, 1957, 13700, 109601, 986410, 9864101, 108505112.

impl Clone for RootedChord

fn clone(&self) -> RootedChord

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for RootedChord

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for RootedChord

fn default() -> RootedChord

Returns the “default value” for a type.

impl Hash for RootedChord

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for RootedChord

fn cmp(&self, other: &RootedChord) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Selfwhere Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Selfwhere Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere Self: Sized + PartialOrd<Self>,

Restrict a value to a certain interval.

impl PartialEq<RootedChord> for RootedChord

fn eq(&self, other: &RootedChord) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd<RootedChord> for RootedChord

fn partial_cmp(&self, other: &RootedChord) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Eq for RootedChord

impl StructuralEq for RootedChord

impl StructuralPartialEq for RootedChord