Struct 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) -> <Note as Add<Interval>>::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) -> <PitchClass as Add<Interval>>::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: Interval) -> <Interval as Add>::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: Interval)

Performs the += operation.

impl Clone for Interval

fn clone(&self) -> Interval

Returns a duplicate 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<(), Error>

Formats the value using the given formatter.

impl Default for Interval

fn default() -> Interval

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Interval

fn deserialize<__D>( __deserializer: __D, ) -> Result<Interval, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Element for Interval

fn wrapped_element(&self) -> Option<&(dyn Element + 'static)>

None.

impl Hash for Interval

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

where __H: Hasher,

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,

Restrict a value to a certain interval.

impl PartialEq for Interval

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

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 Serialize for Interval

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Sub<Interval> for Note

fn sub(self, rhs: Interval) -> <Note as Sub<Interval>>::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) -> <PitchClass as Sub<Interval>>::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>(iter: I) -> Interval

where I: Iterator<Item = Interval>,

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