Struct tune::note::Note

pub struct Note { /* private fields */ }

A musical note encapsulating a clearly defined pitch.

The pitch can be derived using the Pitched impl on the Note type itself, assuming standard 440 Hz tuning, or on NoteAtConcertPitch, given a specific concert pitch.

Implementations

impl Note

pub fn from_midi_number(midi_number: impl Into<i32>) -> Self

Creates a Note instance from the given MIDI number.

pub fn from_letter_and_octave( note_letter: NoteLetter, octave: impl Into<Octave> ) -> Self

Creates a Note instance given a NoteLetter and an octave.

Examples

let a4 = Note::from_midi_number(69);
assert_eq!(Note::from_letter_and_octave(NoteLetter::A, 4), a4);
assert_eq!(Note::from_letter_and_octave(NoteLetter::A, Octave::from_octave_number(4)), a4);
assert_eq!(Note::from_letter_and_octave(NoteLetter::A, HelmholtzOctave::OneLined), a4);

pub fn from_piano_key(piano_key: PianoKey) -> Self

Creates a Note instance from a PianoKey assuming standard 12-EDO tuning.

pub fn midi_number(self) -> i32

Returns the MIDI number of this Note.

pub fn checked_midi_number(self) -> Option<u8>

Returns the MIDI number of this Note if it is in the valid MIDI range [0..128).

Examples

assert_eq!(Note::from_midi_number(-1).checked_midi_number(), None);
assert_eq!(Note::from_midi_number(0).checked_midi_number(), Some(0));
assert_eq!(Note::from_midi_number(64).checked_midi_number(), Some(64));
assert_eq!(Note::from_midi_number(127).checked_midi_number(), Some(127));
assert_eq!(Note::from_midi_number(128).checked_midi_number(), None);

pub fn letter_and_octave(self) -> (NoteLetter, Octave)

Splits the current note into a NoteLetter and an Octave part.

Examples

let a4 = Note::from_midi_number(69);
assert_eq!(a4.letter_and_octave(), (NoteLetter::A, Octave::from_octave_number(4)));

let midi_root = Note::from_midi_number(0);
assert_eq!(midi_root.letter_and_octave(), (NoteLetter::C, Octave::from_octave_number(-1)));

pub fn as_piano_key(self) -> PianoKey

Retrieves the associated PianoKey assuming standard 12-EDO tuning.

pub fn at_pitch(self, pitched: impl Pitched) -> NoteAtConcertPitch

Creates a NoteAtConcertPitch instance with self sounding at a different pitch.

Examples

use tune::pitch::Pitched;

let c4_at_260_hz = NoteLetter::C.in_octave(4).at_pitch(Pitch::from_hz(260.0));
assert_approx_eq!(c4_at_260_hz.pitch().as_hz(), 260.0);

let (_note, concert_pitch) = c4_at_260_hz;
assert_approx_eq!(concert_pitch.a4_pitch().as_hz(), 437.266136);

pub fn at_concert_pitch(self, concert_pitch: ConcertPitch) -> NoteAtConcertPitch

Convenience function creating a NoteAtConcertPitch instance.

Examples

let a4 = NoteLetter::A.in_octave(4);
let concert_pitch = ConcertPitch::from_a4_pitch(Pitch::from_hz(435.0));
assert_eq!(a4.at_concert_pitch(concert_pitch), (a4, concert_pitch));

pub fn notes_before( self, upper_bound: Note ) -> impl DoubleEndedIterator<Item = Note> + ExactSizeIterator<Item = Note> + 'static

Iterates over all Notes in the range [self..upper_bound).

Examples

let midi_note_62 = Note::from_midi_number(62);
let midi_note_67 = Note::from_midi_number(67);

assert_eq!(
    midi_note_62.notes_before(midi_note_67).collect::<Vec<_>>(),
    (62..67).map(Note::from_midi_number).collect::<Vec<_>>()
);
assert!(midi_note_67.notes_before(midi_note_62).collect::<Vec<_>>().is_empty());

pub fn num_semitones_before(self, other: Note) -> i32

Counts the number of semitones [left inclusive, right exclusive) between self and other.

Examples

let midi_note_62 = Note::from_midi_number(62);
let midi_note_67 = Note::from_midi_number(67);

assert_eq!(midi_note_62.num_semitones_before(midi_note_67), 5);
assert_eq!(midi_note_67.num_semitones_before(midi_note_62), -5);

pub fn plus_semitones(self, num_semitones: i32) -> Note

Returns the note num_semitones semitones above self.

Examples

let midi_note_62 = Note::from_midi_number(62);
let midi_note_67 = Note::from_midi_number(67);

assert_eq!(midi_note_62.plus_semitones(5), midi_note_67);
assert_eq!(midi_note_67.plus_semitones(-5), midi_note_62);

Trait Implementations

impl Clone for Note

fn clone(&self) -> Note

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Note

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

Formats the value using the given formatter.

impl Display for Note

Notes are rendered in scientific pitch notation.

Examples

assert_eq!(Note::from_midi_number(0).to_string(), "C -1");
assert_eq!(Note::from_midi_number(69).to_string(), "A 4");
assert_eq!(Note::from_midi_number(70).to_string(), "A#/Bb 4");
assert_eq!(Note::from_midi_number(71).to_string(), "B 4");
assert_eq!(Note::from_midi_number(72).to_string(), "C 5");
assert_eq!(Note::from_midi_number(127).to_string(), "G 9");

// Format flags
assert_eq!(format!("{:+}", Note::from_midi_number(70)), "A# 4");
assert_eq!(format!("{:-}", Note::from_midi_number(70)), "Bb 4");
assert_eq!(format!("{:10}", Note::from_midi_number(70)), "A#/Bb 4   ");
assert_eq!(format!("{:<10}", Note::from_midi_number(70)), "A#/Bb 4   ");
assert_eq!(format!("{:>10}", Note::from_midi_number(70)), "   A#/Bb 4");

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

Formats the value using the given formatter.

impl Hash for Note

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 Note

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

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

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

fn pitch(&self) -> Pitch

Retrieves the Pitch of the Pitched object.

fn find_in_tuning<K, T: Tuning<K>>(&self, tuning: T) -> Approximation<K>

Finds a key or note for any Pitched object in the given tuning.

impl PitchedNote for Note

fn note(&self) -> Note

Retrieves the Note part of self.

fn alter_pitch_by(&self, delta: Ratio) -> NoteAtConcertPitch

Returns a new PitchedNote with the same Note part but a Pitch altered by delta.

impl Tuning<Note> for ()

Convenience implementation enabling to write () instead of ConcertPitch::default().

Examples

use tune::pitch::Pitched;

assert_eq!(Pitch::from_hz(880.0).find_in_tuning(()).approx_value, Note::from_midi_number(81));

fn pitch_of(&self, note: Note) -> Pitch

Returns the Pitch of the given key or note K in the current Tuning.

fn find_by_pitch(&self, pitch: Pitch) -> Approximation<Note>

Finds a closest key or note Approximation for the given Pitch in the current Tuning.

fn as_linear_mapping(self) -> LinearMapping<Self>

where Self: Sized,

Wraps self in a type adapter s.t. it can be used in functions that are generic over KeyboardMapping<K>.

impl Tuning<Note> for ConcertPitch

A ConcertPitch maps Notes to Pitches and is considered a Tuning.

Examples

use tune::tuning::Tuning;

let c4 = NoteLetter::C.in_octave(4);
let a4 = NoteLetter::A.in_octave(4);

let standard_tuning = ConcertPitch::default();
assert_approx_eq!(standard_tuning.pitch_of(c4).as_hz(), 261.625565);
assert_approx_eq!(standard_tuning.pitch_of(a4).as_hz(), 440.0);

let healing_tuning = ConcertPitch::from_a4_pitch(Pitch::from_hz(432.0));
assert_approx_eq!(healing_tuning.pitch_of(c4).as_hz(), 256.868737);
assert_approx_eq!(healing_tuning.pitch_of(a4).as_hz(), 432.0);

fn pitch_of(&self, note: Note) -> Pitch

Returns the Pitch of the given key or note K in the current Tuning.

fn find_by_pitch(&self, pitch: Pitch) -> Approximation<Note>

Finds a closest key or note Approximation for the given Pitch in the current Tuning.

fn as_linear_mapping(self) -> LinearMapping<Self>

where Self: Sized,

Wraps self in a type adapter s.t. it can be used in functions that are generic over KeyboardMapping<K>.

impl Copy for Note

impl Eq for Note

impl StructuralEq for Note

impl StructuralPartialEq for Note