Struct tune::note::Note

pub struct Note { /* fields omitted */ }

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: i32) -> Self

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

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

Splits the current note into a NoteLetter and an Octave.

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 num_semitones_before(self, other: Note) -> i32

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

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

Retrieves the Note instance num_semitones above self.

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 Copy for Note

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 Eq for Note

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, 

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.

#[must_use]fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]fn clamp(self, min: Self, max: Self) -> Self

🔬 This is a nightly-only experimental API. (clamp)

Restrict a value to a certain interval.

impl PartialEq<Note> 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: &Note) -> bool

This method tests for !=.

impl PartialOrd<Note> 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: &Note) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Note) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Note) -> bool

This method tests greater than (for self and other) and is used by the > operator.

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

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 StructuralEq for Note

impl StructuralPartialEq for Note

impl Tuning<Note> for ConcertPitch

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

Finds the Pitch for the given note or address.

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

Finds the closest note or address for the given Pitch.

impl Tuning<Note> for ()

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

Examples

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

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

Finds the Pitch for the given note or address.

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

Finds the closest note or address for the given Pitch.