Struct music_theory::theory::chord::Chord

pub struct Chord(pub Vec<Note>);

A Chord only encodes the quality of the the chord. No root from which it is build is defined.

Example:

use music_theory::theory::*;
let chord = Chord::new(&MAJOR);
assert!(chord.contains_all(&POWER));

Tuple Fields

0: Vec<Note>

Implementations

impl Chord

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

Create a chord from an array of unsigned note intervals.

Example:

use music_theory::theory::*;
let chord = Chord::new(&MAJOR);
assert!(chord.contains_all(&POWER));

pub fn same_intervals(&self, blueprint: &[Note]) -> bool

Returns true if the blueprint is the same as the inner wrapper value.

Example:

use music_theory::theory::*;
let chord = Chord::new(&MAJOR);
assert!(chord.same_intervals(&MAJOR));

pub fn normalized(self) -> Self

Returns a normalised version of the chord. Intervals will be mapped into one octave (from Z to Z_12). The intervals will also be sorted duplicates will be removed. This means any form of voicing will be lost and the core quality will remain.

Example:

use music_theory::theory::*;
use interval::note_interval as ni;
assert_eq!(
    Chord::new(&[ni::MAJ2, ni::MAJ3, ni::PER5, ni::MAJ7, ni::MAJ9, ni::PER5])
        .normalized().unwrap(),
    vec![ni::MAJ2, ni::MAJ3, ni::PER5, ni::MAJ7]
);

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

Returns the quality of a chord as a string. Takes a ChordStyle to determine the formatting style. The base string is a prefix to the stringified quality. The algorithm works with normalised chords and does not take into account voicing, it aims to determine the core quality of the chord. It is not an exhaustive search style or optimalisation style algorithm and may not produce the very best quality you could assign to the input.

Example:

use music_theory::theory::*;
let std = ChordStyle::Std(MStyle::Symbol, EStyle::Symbol);
let base = String::from("BASESTRING");
assert_eq!(&Chord::new(&MINOR_MAJOR_SEVENTH).quality(base, std), "BASESTRING-Δ");

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

Stringify the chord

Example:

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

Trait Implementations

impl AsScale for Chord

fn as_scale(&self, root: Note) -> Scale

Borrow self and return Scale. Note is either the root of the scale or the octave.

impl AsSubs for Chord

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 Chord

fn clone(&self) -> Chord

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Chord

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

Formats the value using the given formatter.

impl Default for Chord

fn default() -> Chord

Returns the “default value” for a type.

impl Hash for Chord

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 Index<usize> for Chord

type Output = Note

The returned type after indexing.

fn index(&self, index: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl IndexMut<usize> for Chord

fn index_mut(&mut self, index: usize) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl Ord for Chord

fn cmp(&self, other: &Chord) -> 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<Chord> for Chord

fn eq(&self, other: &Chord) -> 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<Chord> for Chord

fn partial_cmp(&self, other: &Chord) -> 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 VecWrapper for Chord

type Item = Note

The type the new type wraps.

fn len(&self) -> usize

Return the length of the inner vector.

fn is_empty(&self) -> bool

Return whether the inner vector is empty or not.

fn iter(&self) -> Iter<'_, Self::Item>

Iterate over the inner vector.

fn contains(&self, item: &Self::Item) -> bool

Returns whether the inner vector contains an item.

fn contains_all(&self, items: &[Self::Item]) -> bool

Returns whether the inner vector contains all of the given items.

fn contains_any(&self, items: &[Self::Item]) -> bool

Returns whether the inner vector contains any of the given items.

impl Wrapper for Chord

type Inner = Vec<Note, Global>

The type the new type wraps.

fn wrap(scale: Self::Inner) -> Option<Self>

Try to wrap a Self::Inner type into the Self type.

fn unwrap(self) -> Self::Inner

Unwrap a Self type into a Self::Inner type.

impl Eq for Chord

impl StructuralEq for Chord

impl StructuralPartialEq for Chord