Struct music_theory::theory::scale::Steps

pub struct Steps(_);

A Steps object is a list of intervals. In this case, the list of notes is represented by the intervals between the notes. The scale formulas build from half steps and whole steps such as [W,W,H,W,W,W,H] for the C Major scale are an example of Steps. Steps can also contain negative intervals, and as big leaps as the Interval type allows.

Example:

use music_theory::theory::*;
let W = Interval::WHOLE;
let S = Interval::SEMI;
let steps = Steps::wrap(vec![W, W, S, W, W, W, S]).unwrap(); /* wraps into Option<Steps> so
when you unwrap again you have Steps. */
assert_eq!(
    steps.to_scale_try(Note::C1),
    Scale::wrap(
        vec![Note::C1, Note::D1, Note::E1, Note::F1, Note::G1, Note::A2, Note::B2]
    )
);

Implementations

impl Steps

pub fn mode_nr_of_this(&self, mode: &Steps) -> Option<(usize, Steps)>

Will try to return an index and a copy of the mode. For example, calling mode_nr_of_this on a Ionian mode with a Dorian mode should return the index of 1. The index is zero based so giving itself as in input return an index of 0.

Example:

use music_theory::theory::*;
let W = Interval::WHOLE;
let H = Interval::SEMI;
let major = Steps::wrap(vec![W, W, H, W, W, W, H]).unwrap();
let minor = major.clone().mode(5);
assert_eq!(
    major.mode_nr_of_this(&minor),
    Some((5, Steps::wrap(vec![ W, H, W, W, H, W, W]).unwrap()))
);

Trait Implementations

impl AsChord for Steps

fn as_chord(&self) -> Chord

Borrow self and return a Chord.

impl AsRelativeIntervals for Steps

fn as_relative_intervals(&self, reference: &Self) -> Option<Intervals>

Borrow self and a reference and compare piecewise. Try to return the differences as Interval’s. Inputs must be of equal length.

impl AsScaleTry for Steps

fn as_scale_try(&self, note: Note) -> Option<Scale>

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

impl AsSubs for Steps

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 Steps

fn clone(&self) -> Steps

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Steps

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

Formats the value using the given formatter.

impl Default for Steps

fn default() -> Steps

Returns the “default value” for a type.

impl Hash for Steps

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 Steps

type Output = Interval

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl IndexMut<usize> for Steps

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

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

impl ModeTrait for Steps

fn next_mode_mut(&mut self)

Modify the value so it turns into it’s next mode.

fn next_mode(self) -> Self

Take the value and give back it’s next mode.

fn mode(self, mode: Mode) -> Self

Take the value and give back it’s Nth mode.

impl Ord for Steps

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

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

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

fn scale_iter(&self, root: Note) -> ScaleIterator<'_>

Spawn the iterator, with the root or starting note.

impl VecWrapper for Steps

type Item = Interval

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 Steps

type Inner = Vec<Interval, Global>

The type the new type wraps.

fn wrap(steps: 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 Steps

impl StructuralEq for Steps

impl StructuralPartialEq for Steps