Struct redact_composer_musical::PitchClass

pub struct PitchClass(pub u8);

An octave-independent note.

Tuple Fields

0: u8

Implementations

impl PitchClass

pub fn values() -> Vec<PitchClass>

Returns all valid PitchClass values (0..=11).

pub fn all_in_range<R: RangeBounds<Note>>(range: R) -> Vec<PitchClass>

Returns all pitch classes contained in the given note range.

use redact_composer_musical::{Note, NoteName::{C, F}, PitchClass as PC};

assert_eq!(
    PC::all_in_range(Note::from((C, 3))..=Note::from((F, 3))),
    vec![PC(0), PC(1), PC(2), PC(3), PC(4), PC(5)]
);

assert_eq!(
    PC::all_in_range(Note::from((C, 3))..=Note::from((C, 5))),
    PC::values()
);

pub fn in_octave(&self, octave: i8) -> Note

Returns the Note with this pitch class in a given octave.

use redact_composer_musical::{Note, NoteName::C, PitchClass};

assert_eq!(PitchClass::from(C).in_octave(4), Note(60));

pub fn above(&self, note: &Note) -> Note

Returns the next Note of this pitch class above the given note. If the given note is already of this pitch class, the note an octave above is returned.

use redact_composer_musical::{Note, NoteName::{C, G}, PitchClass};

assert_eq!(PitchClass::from(G).above(&Note::from((C, 3))), Note::from((G, 3)));
assert_eq!(PitchClass::from(G).above(&Note::from((G, 3))), Note::from((G, 4)));

pub fn at_or_above(&self, note: &Note) -> Note

Returns the next Note of this pitch class at or above the given note.

use redact_composer_musical::{Note, NoteName::{C, G}, PitchClass};

assert_eq!(PitchClass::from(G).at_or_above(&Note::from((C, 3))), Note::from((G, 3)));
assert_eq!(PitchClass::from(G).at_or_above(&Note::from((G, 3))), Note::from((G, 3)));

pub fn below(&self, note: &Note) -> Note

Returns the next Note of this pitch class below the given note. If the given note is already of this pitch class, the note an octave below is returned.

use redact_composer_musical::{Note, NoteName::{C, G}, PitchClass};

assert_eq!(PitchClass::from(G).below(&Note::from((C, 3))), Note::from((G, 2)));
assert_eq!(PitchClass::from(G).below(&Note::from((G, 3))), Note::from((G, 2)));

pub fn at_or_below(&self, note: &Note) -> Note

Returns the next Note of this pitch class at or below the given note.

use redact_composer_musical::{Note, NoteName::{C, G}, PitchClass};

assert_eq!(PitchClass::from(G).at_or_below(&Note::from((C, 3))), Note::from((G, 2)));
assert_eq!(PitchClass::from(G).at_or_below(&Note::from((G, 3))), Note::from((G, 3)));

pub fn interval_to(&self, other: &PitchClass) -> Interval

Returns the simple interval (ascending) from this pitch class to the nearest other pitch class.

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

assert_eq!(PitchClass::from(C).interval_to(&G.into()), Interval::P5);

pub fn interval_from(&self, other: &PitchClass) -> Interval

Returns the simple interval (ascending) from some other pitch class to this one.

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

assert_eq!(PitchClass::from(C).interval_from(&G.into()), Interval::P4);

impl PitchClass

pub fn names(&self) -> Vec<NoteName>

Provides the note names matching this pitch class.

pub fn name_in_key(&self, key: &Key) -> NoteName

Returns this pitch class’s name within the context of a Key. Pitch classes not in the given key will return some variation of a name equating to the pitch class, but exactly which is subject to change.

Trait Implementations

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 AddAssign<Interval> for PitchClass

fn add_assign(&mut self, rhs: Interval)

Performs the += operation.

impl Clone for PitchClass

fn clone(&self) -> PitchClass

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for PitchClass

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

Formats the value using the given formatter.

impl From<Note> for PitchClass

fn from(value: Note) -> Self

Converts to this type from the input type.

impl From<NoteName> for PitchClass

fn from(value: NoteName) -> Self

Converts to this type from the input type.

impl From<u8> for PitchClass

fn from(value: u8) -> Self

Converts to this type from the input type.

impl Hash for PitchClass

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 NoteIterator for PitchClass

fn iter_notes_in_range<R: RangeBounds<Note>>( &self, note_range: R ) -> NoteIter<R>

Returns a note iterator (NoteIter) for notes of an interval pattern within the given note range.

fn notes_in_range<R: RangeBounds<Note>>(&self, note_range: R) -> Vec<Note>

Returns all notes matching an interval pattern within the given note range.

impl PartialEq<NoteName> for PitchClass

fn eq(&self, note_name: &NoteName) -> bool

use redact_composer_musical::{NoteName::C, PitchClass};
assert!(PitchClass(0).eq(&C));

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 PartialEq<PitchClass> for Note

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

use redact_composer_musical::{Note, NoteName::C, PitchClass};

assert!(Note::from((C, 3)) == PitchClass::from(C));

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 PartialEq<PitchClass> for NoteName

fn eq(&self, pitch_class: &PitchClass) -> bool

use redact_composer_musical::{NoteName, PitchClass};
assert!(NoteName::C.eq(&PitchClass(0)));

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 PartialEq for PitchClass

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

fn pitch_classes(&self) -> Vec<PitchClass>

Returns this type’s pitches.

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 PitchClass

fn sub_assign(&mut self, rhs: Interval)

Performs the -= operation.

impl Copy for PitchClass

impl Eq for PitchClass

impl StructuralPartialEq for PitchClass