Struct redact_composer_musical::Interval

pub struct Interval(pub u8);

A pitch difference, measured in half-steps/semitones.

Tuple Fields

0: u8

Implementations

impl Interval

pub const P1: Interval = _

Perfect Unison (0 semitones)

pub const m2: Interval = _

Minor 2nd (1 semitone)

pub const M2: Interval = _

Major 2nd (2 semitones)

pub const m3: Interval = _

Minor 3rd (3 semitones)

pub const M3: Interval = _

Major 3rd (4 semitones)

pub const P4: Interval = _

Perfect 4th (5 semitones)

pub const TT: Interval = _

Tritone (6 semitones)

pub const A4: Interval = _

Augmented 4th (6 semitones)

pub const d5: Interval = _

Diminished 5th (6 semitones)

pub const P5: Interval = _

Perfect 5th (7 semitones)

pub const m6: Interval = _

Minor 6th (8 semitones)

pub const A5: Interval = _

Augmented 5th (8 semitones)

pub const M6: Interval = _

Major 6th (9 semitones)

pub const d7: Interval = _

Diminished 7th (9 semitones)

pub const m7: Interval = _

Minor 7th (10 semitones)

pub const M7: Interval = _

Major 7th (11 semitones)

pub const P8: Interval = _

Perfect 8th (12 semitones)

pub const Octave: Interval = Self::P8

Octave (12 semitones)

pub const m9: Interval = _

Minor 9th (13 semitones)

pub const M9: Interval = _

Major 9th (13 semitones)

pub const m10: Interval = _

Minor 10th (15 semitones)

pub const M10: Interval = _

Major 10th (16 semitones)

pub const P11: Interval = _

Perfect 11th (17 semitones)

pub const P12: Interval = _

Perfect 12th (19 semitones)

pub const m13: Interval = _

Minor 13th (20 semitones)

pub const M13: Interval = _

Major 13th (21 semitones)

pub fn is_simple(&self) -> bool

Returns true if this is a simple interval (up to one octave).

assert!(Interval::P5.is_simple());

pub fn to_simple(self) -> Interval

Return the simple interval counterpart. Note: This function will reduce Interval::Octave to Interval::P1.

assert_eq!(Interval::m9.to_simple(), Interval::m2);

pub fn is_compound(&self) -> bool

Returns true if this is a compound interval (larger than one octave).

assert!(Interval::m9.is_compound());

pub fn to_compound(self) -> Interval

Return the compound interval counterpart (added octave). Does nothing if the interval is already compound.

assert_eq!(Interval::m2.to_compound(), Interval::m9);

pub fn inversion(&self) -> Interval

Returns the interval’s inversion.

assert_eq!(Interval::P5.inversion(), Interval::P4);

Trait Implementations

impl Add<Interval> for Note

fn add(self, rhs: Interval) -> Self::Output

Adds an interval to this note, resulting in another note.

use redact_composer_musical::{Interval as I, Note, NoteName::{C, G}};

let c3 = Note::from((C, 4));
assert_eq!(c3, Note(60));
assert_eq!(c3 + I::P5, Note::from((G, 4)));

type Output = Note

The resulting type after applying the + operator.

impl Add<Interval> for PitchClass

fn add(self, rhs: Interval) -> Self::Output

Returns the pitch class a given interval above this.

use redact_composer_musical::{Interval as I, NoteName::{C, G}, PitchClass};

assert_eq!(PitchClass::from(C) + I::P5, PitchClass::from(G));
assert_eq!(PitchClass::from(C) + I::Octave, PitchClass::from(C));

type Output = PitchClass

The resulting type after applying the + operator.

impl Add for Interval

type Output = Interval

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self::Output

Performs the + operation.

impl AddAssign<Interval> for Note

fn add_assign(&mut self, rhs: Interval)

Performs the += operation.

impl AddAssign<Interval> for PitchClass

fn add_assign(&mut self, rhs: Interval)

Performs the += operation.

impl AddAssign for Interval

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl Clone for Interval

fn clone(&self) -> Interval

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Interval

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

Formats the value using the given formatter.

impl Default for Interval

fn default() -> Interval

Returns the “default value” for a type.

impl Hash for Interval

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 Interval

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

This method returns an Ordering between self and other.

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

where Self: Sized,

Compares and returns the maximum of two values.

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

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl PartialEq for Interval

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

fn partial_cmp(&self, other: &Interval) -> 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 Sub<Interval> for Note

fn sub(self, rhs: Interval) -> Self::Output

Subtracts an interval from this note, resulting in another note.

use redact_composer_musical::{Interval as I, Note, NoteName::{C, G}};

let c3 = Note::from((C, 3));
assert_eq!(c3 - I::P4, Note::from((G, 2)));

type Output = Note

The resulting type after applying the - operator.

impl Sub<Interval> for PitchClass

fn sub(self, rhs: Interval) -> Self::Output

Returns the pitch class a given interval below this.

use redact_composer_musical::{Interval as I, NoteName::{C, F}, PitchClass};

assert_eq!(PitchClass::from(C) - I::P5, PitchClass::from(F));
assert_eq!(PitchClass::from(C) - I::Octave, PitchClass::from(C));

type Output = PitchClass

The resulting type after applying the - operator.

impl SubAssign<Interval> for Note

fn sub_assign(&mut self, rhs: Interval)

Performs the -= operation.

impl SubAssign<Interval> for PitchClass

fn sub_assign(&mut self, rhs: Interval)

Performs the -= operation.

impl Sum for Interval

fn sum<I: Iterator<Item = Self>>(iter: I) -> Self

Method which takes an iterator and generates Self from the elements by “summing up” the items.

impl Copy for Interval

impl Eq for Interval

impl StructuralPartialEq for Interval