Struct TriadBase 

pub struct TriadBase<S = TriChord, K = Major, T = <S as RawSpace>::Elem>
where
    K: TriadType,
    S: TriadRepr<Elem = T>,
{ /* private fields */ }

The TriadBase is an implementation of a triad generic over the chord, or storage, its classification, and the element type used to represent a note within the triadic chord.

Implementations

impl<S, T, K> TriadBase<S, K, T>

where K: TriadType, S: TriadRepr<Elem = T>,

pub fn new(chord: S, class: K) -> Self

where T: Zero,

Returns a new instance of the TriadBase with the given chord and kind.

pub fn from_root_with_class(root: T, class: K) -> Self

where T: Copy + FromPrimitive + Zero + PitchMod<Output = T> + Add<Output = T>,

Create a new triad from a root pitch and class

pub fn dynamic(self) -> TriadBase<S, Triads, T>

consumes the instance to use a dynamic classification enum

pub const fn chord(&self) -> &S

returns an immutable reference to the chord.

pub const fn chord_mut(&mut self) -> &mut S

returns a mutable reference to the chord.

pub const fn class(&self) -> &K

returns a reference of the class of the triad.

pub const fn class_mut(&mut self) -> &mut K

returns a mutable reference to the class of the triad.

pub const fn octave(&self) -> &Octave<T>

returns a reference to the octave of the triad.

pub const fn octave_mut(&mut self) -> &mut Octave<T>

pub fn root(&self) -> &T

where S: TriadRepr,

returns a reference to the root note of the triad.

pub fn root_mut(&mut self) -> &mut T

where S: TriadReprMut,

returns a mutable reference to the root note of the triad.

pub fn third(&self) -> &T

where S: TriadRepr,

returns a reference to the third note of the triad.

pub fn third_mut(&mut self) -> &mut T

where S: TriadReprMut,

returns a mutable reference to the third note of the triad.

pub fn fifth(&self) -> &T

where S: TriadRepr,

returns a reference to the fifth note of the triad.

pub fn fifth_mut(&mut self) -> &mut T

where S: TriadReprMut,

returns a mutable reference to the fifth note of the triad.

pub fn set_chord(&mut self, chord: S) -> &mut Self

update the chord and returns a mutable reference to the triad

pub fn set_class(&mut self, class: K) -> &mut Self

update the class and returns a mutable reference to the triad

pub fn with_chord<S2>(self, chord: S2) -> TriadBase<S2, K>

where S2: TriadRepr<Elem = T>, T: Sized,

consumes the current instance to create another with the given chord

pub fn with_class<K2>(self, class: K2) -> TriadBase<S, K2>

where K2: TriadType,

consumes the current instance to create another with the given class

pub fn with_octave(self, octave: Octave<T>) -> Self

pub fn into_parts(self) -> (S, K)

consumes the triad and returns the chord and class

pub fn is_augmented(&self) -> bool

returns true if the triad is classified as an augmented triad.

pub fn is_diminished(&self) -> bool

returns true if the triad is classified as a diminished triad.

pub fn is_major(&self) -> bool

returns true if the triad is classified as a major triad.

pub fn is_minor(&self) -> bool

returns true if the triad is classified as a minor triad.

pub fn centroid<U>(&self) -> Option<[U; 2]>

where T: Copy + ToPrimitive, U: Float + FromPrimitive + ToPrimitive + Sum<T>, S: Clone + IntoIterator<Item = T>,

computes the centroid of the triad

pub fn contains<Q>(&self, note: &Q) -> bool

where for<'a> &'a S: IntoIterator<Item = &'a T>, T: PartialEq, Q: Borrow<T>,

returns true if the triad contains the given note

pub fn common_tones(&self, other: &Self) -> Vec<T>

where T: Clone + PartialEq, for<'a> &'a S: IntoIterator<Item = &'a T>,

returns a collection containing any tones common to both triads

pub fn transform<X, Y>(self, step: X) -> Y

where Self: Transform<X, Output = Y>,

apply the given LPR transformation onto the triad, returning a new triad classified under Q where Q and K are related via the Rel associated type. For example, if transforming a major triad, then the resulting triad will be minor (and vice versa).

pub fn leading<Y>(self) -> Y

where Self: Transform<LPR, Output = Y>,

apply the Leading transformation to the triad

pub fn parallel<Y>(self) -> Y

where Self: Transform<LPR, Output = Y>,

apply the Parallel transformation to the triad

pub fn relative<Y>(self) -> Y

where Self: Transform<LPR, Output = Y>,

apply the Relative transformation to the triad

pub fn path_finder(&self) -> PathFinder<'_, S, K, T>

returns a path finder for the current triad

impl<S, T> TriadBase<S, Augmented, T>

where S: TriadRepr<Elem = T>,

pub fn augmented(root: T) -> Self

where T: Copy + FromPrimitive + Zero + PitchMod<Output = T> + Add<Output = T>,

returns a new instance of the TriadBase with the given chord and kind as an augmented triad.

impl<S, T> TriadBase<S, Diminished, T>

where S: TriadRepr<Elem = T>,

pub fn diminished(root: T) -> Self

where T: Copy + FromPrimitive + Zero + PitchMod<Output = T> + Add<Output = T>,

returns a new instance of the TriadBase with the given chord and kind as a diminished triad.

impl<S, T> TriadBase<S, Major, T>

where S: TriadRepr<Elem = T>,

pub fn major(root: T) -> Self

where T: Copy + FromPrimitive + Zero + PitchMod<Output = T> + Add<Output = T>,

returns a new instance of the TriadBase with the given chord and kind as a major triad.

impl<S, T> TriadBase<S, Minor, T>

where S: TriadRepr<Elem = T>,

pub fn minor(root: T) -> Self

where T: Copy + FromPrimitive + Zero + PitchMod<Output = T> + Add<Output = T>,

returns a new instance of the TriadBase with the given chord and kind as a minor triad.

impl<T> TriadBase<[T; 3], Triads, T>

where T: Copy + ToPrimitive + FromPrimitive + PitchMod<Output = T> + Add<Output = T>,

pub fn barycentric<N, U>(&self, p: N) -> [U; 3]

where T: Copy + ToPrimitive, N: IntoAspn, U: Float + FromPrimitive,

return the barycentric coordinates of the given note w.r.t the current triad

pub fn is_valid(&self) -> bool

where T: Copy + PartialEq + FromPrimitive + ToPrimitive + PitchMod<Output = T> + Sub<Output = T>,

returns true if the pitches within the triad match its classification

pub fn is_neighbor(&self, other: &Self) -> Option<LPR>

where Self: Transform<LPR, Output = Self>, T: PartialEq,

returns some LPR transformation, iff they are within a single step of one another otherwise, returns None.

impl<T> TriadBase<[T; 3], Triads, T>

where T: Copy + ToPrimitive + FromPrimitive + Num + PitchMod<Output = T>,

pub fn walk<I>(&self, path: I) -> Self

where I: IntoIterator<Item = LPR>,

apply a series of transformations to a triad

pub fn walk_inplace<I>(&mut self, path: I)

where I: IntoIterator<Item = LPR>,

apply a chain of transformations to a triad in-place

impl TriadBase<[usize; 3], Triads>

pub fn transform_inplace(&mut self, transform: LPR)

apply a single transformation to a triad in-place, mutating the current instance

Trait Implementations

impl<T, S, K> AsMut<S> for TriadBase<S, K, T>

where S: TriadRepr<Elem = T>, K: TriadType,

fn as_mut(&mut self) -> &mut S

Converts this type into a mutable reference of the (usually inferred) input type.

impl<T, S, K> AsRef<S> for TriadBase<S, K, T>

where S: TriadRepr<Elem = T>, K: TriadType,

fn as_ref(&self) -> &S

Converts this type into a shared reference of the (usually inferred) input type.

impl<T, S, K> Borrow<S> for TriadBase<S, K, T>

where S: TriadRepr<Elem = T>, K: TriadType,

fn borrow(&self) -> &S

Immutably borrows from an owned value.

impl<T, S, K> BorrowMut<S> for TriadBase<S, K, T>

where S: TriadRepr<Elem = T>, K: TriadType,

fn borrow_mut(&mut self) -> &mut S

Mutably borrows from an owned value.

impl<S, K, T: Clone> Clone for TriadBase<S, K, T>

where K: TriadType + Clone, S: TriadRepr<Elem = T> + Clone,

fn clone(&self) -> TriadBase<S, K, T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T, S, K> Debug for TriadBase<S, K, T>

where S: TriadRepr<Elem = T> + Debug, K: TriadType, T: Debug,

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

Formats the value using the given formatter.

impl<S, K, T: Default> Default for TriadBase<S, K, T>

where K: TriadType + Default, S: TriadRepr<Elem = T> + Default,

fn default() -> TriadBase<S, K, T>

Returns the “default value” for a type.

impl<T, S, K> Deref for TriadBase<S, K, T>

where S: TriadRepr<Elem = T>, K: TriadType,

type Target = S

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T, S, K> DerefMut for TriadBase<S, K, T>

where S: TriadRepr<Elem = T>, K: TriadType,

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<S, T, K> Dirac<&TriadBase<S, K, T>> for &LPR

where K: TriadType, K::Rel: TriadType, S: TriadRepr<Elem = T>, T: Copy + FromPrimitive + One + PitchMod<Output = T> + Add<Output = T> + Sub<Output = T>,

type Output = TriadBase<S, <K as Relative>::Rel, T>

fn apply(self, rhs: &TriadBase<S, K, T>) -> Self::Output

impl<S, T, K> Dirac<&TriadBase<S, K, T>> for LPR

where K: TriadType, K::Rel: TriadType, S: TriadRepr<Elem = T>, T: Copy + FromPrimitive + One + PitchMod<Output = T> + Add<Output = T> + Sub<Output = T>,

type Output = TriadBase<S, <K as Relative>::Rel, T>

fn apply(self, rhs: &TriadBase<S, K, T>) -> Self::Output

impl<S, T, K> Dirac<&mut TriadBase<S, K, T>> for LPR

where K: TriadType, K::Rel: TriadType, S: TriadRepr<Elem = T>, T: Copy + FromPrimitive + One + PitchMod<Output = T> + Add<Output = T> + Sub<Output = T>,

type Output = TriadBase<S, <K as Relative>::Rel, T>

fn apply(self, rhs: &mut TriadBase<S, K, T>) -> Self::Output

impl<S, T, K> Dirac<TriadBase<S, K, T>> for &LPR

where K: TriadType, K::Rel: TriadType, S: TriadRepr<Elem = T>, T: Copy + FromPrimitive + One + PitchMod<Output = T> + Add<Output = T> + Sub<Output = T>,

type Output = TriadBase<S, <K as Relative>::Rel, T>

fn apply(self, rhs: TriadBase<S, K, T>) -> Self::Output

impl<S, T, K> Dirac<TriadBase<S, K, T>> for &mut LPR

where K: TriadType, K::Rel: TriadType, S: TriadRepr<Elem = T>, T: Copy + FromPrimitive + One + PitchMod<Output = T> + Add<Output = T> + Sub<Output = T>,

type Output = TriadBase<S, <K as Relative>::Rel, T>

fn apply(self, rhs: TriadBase<S, K, T>) -> Self::Output

impl<S, T, K> Dirac<TriadBase<S, K, T>> for LPR

where K: TriadType, K::Rel: TriadType, S: TriadRepr<Elem = T>, T: Copy + FromPrimitive + One + PitchMod<Output = T> + Add<Output = T> + Sub<Output = T>,

type Output = TriadBase<S, <K as Relative>::Rel, T>

fn apply(self, rhs: TriadBase<S, K, T>) -> Self::Output

impl<T, S, K> Display for TriadBase<S, K, T>

where S: TriadRepr<Elem = T> + Debug, K: TriadType + Display, T: Display,

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

Formats the value using the given formatter.

impl<T, S, K> From<(S, K)> for TriadBase<S, K, T>

where S: TriadRepr<Elem = T>, T: Zero, K: TriadType,

fn from((chord, class): (S, K)) -> Self

Converts to this type from the input type.

impl<S, K, T: Hash> Hash for TriadBase<S, K, T>

where K: TriadType + Hash, S: TriadRepr<Elem = T> + Hash,

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<T, S, K> Index<Factors> for TriadBase<S, K, T>

where S: TriadRepr<Elem = T>, K: TriadType,

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T, S, K> IndexMut<Factors> for TriadBase<S, K, T>

where S: TriadReprMut<Elem = T>, K: TriadType,

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

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

impl<'a, S, T, K, I> IntoIterator for &'a TriadBase<S, K, T>

where S: TriadRepr<Elem = T>, K: TriadType, I: Iterator<Item = &'a T>, &'a S: IntoIterator<Item = I::Item, IntoIter = I>,

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = I

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, S, T, K, I> IntoIterator for &'a mut TriadBase<S, K, T>

where S: TriadRepr<Elem = T>, K: TriadType, I: Iterator<Item = &'a T>, &'a mut S: IntoIterator<Item = I::Item, IntoIter = I>,

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = I

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<S, T, K, I> IntoIterator for TriadBase<S, K, T>

where S: TriadRepr<Elem = T> + IntoIterator<Item = I::Item, IntoIter = I>, K: TriadType, I: Iterator<Item = T>,

type Item = T

The type of the elements being iterated over.

type IntoIter = I

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<S, T, K> PartialEq<S> for TriadBase<S, K, T>

where S: TriadRepr<Elem = T> + PartialEq, K: TriadType,

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl<S1, T1, K1, S2, T2, K2> PartialEq<TriadBase<S2, K2, T2>> for TriadBase<S1, K1, T1>

where S1: TriadRepr<Elem = T1> + PartialEq<S2>, K1: TriadType, S2: TriadRepr<Elem = T2>, K2: TriadType,

fn eq(&self, other: &TriadBase<S2, K2, T2>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl<S, K, T: PartialOrd> PartialOrd for TriadBase<S, K, T>

where K: TriadType + PartialOrd, S: TriadRepr<Elem = T> + PartialOrd,

fn partial_cmp(&self, other: &TriadBase<S, K, T>) -> Option<Ordering>

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

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

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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

impl<S, T, K> Transform<LPR> for TriadBase<S, K, T>

where K: TriadType, K::Rel: TriadType, S: TriadRepr<Elem = T>, T: Copy + FromPrimitive + One + PitchMod<Output = T> + Add<Output = T> + Sub<Output = T>,

type Output = TriadBase<S, <K as Relative>::Rel, T>

fn transform(self, transformation: LPR) -> Self::Output

impl<S, K, T: Copy> Copy for TriadBase<S, K, T>

where K: TriadType + Copy, S: TriadRepr<Elem = T> + Copy,

impl<S, K, T: Eq> Eq for TriadBase<S, K, T>

where K: TriadType + Eq, S: TriadRepr<Elem = T> + Eq,