Struct Note

pub struct Note(/* private fields */);

The main note type. Does not take into account enharmonic spelling.

Example:

use music_theory::theory::*;
assert_eq!(Note::new(0), Note::A0);

Implementations

impl Note

pub const MAX: Note

Biggest valid Note value.

Example:

use music_theory::theory::*;
assert_eq!(Note::MAX + Note::C3, Note::MAX);

pub const MIN: Note

Smallest valid Note value.

Example:

use music_theory::theory::*;
assert_eq!(Note::MIN.shift_octave(-1), Note::MIN);

pub const ZERO: Note

The zeroth Note, the same as Note::MIN.

Example:

use music_theory::theory::*;
assert_eq!(Note::ZERO, Note::MIN);

pub const A0: Note

pub const AS0: Note

pub const B0: Note

pub const C0: Note

pub const CS0: Note

pub const D0: Note

pub const DS0: Note

pub const E0: Note

pub const F0: Note

pub const FS0: Note

pub const G0: Note

pub const GS0: Note

pub const A1: Note

pub const AS1: Note

pub const B1: Note

pub const C1: Note

pub const CS1: Note

pub const D1: Note

pub const DS1: Note

pub const E1: Note

pub const F1: Note

pub const FS1: Note

pub const G1: Note

pub const GS1: Note

pub const A2: Note

pub const AS2: Note

pub const B2: Note

pub const C2: Note

pub const CS2: Note

pub const D2: Note

pub const DS2: Note

pub const E2: Note

pub const F2: Note

pub const FS2: Note

pub const G2: Note

pub const GS2: Note

pub const A3: Note

pub const AS3: Note

pub const B3: Note

pub const C3: Note

pub const CS3: Note

pub const D3: Note

pub const DS3: Note

pub const E3: Note

pub const F3: Note

pub const FS3: Note

pub const G3: Note

pub const GS3: Note

pub const A4: Note

pub const AS4: Note

pub const B4: Note

pub const C4: Note

pub const CS4: Note

pub const D4: Note

pub const DS4: Note

pub const E4: Note

pub const F4: Note

pub const FS4: Note

pub const G4: Note

pub const GS4: Note

pub const A5: Note

pub const AS5: Note

pub const B5: Note

pub const C5: Note

pub const CS5: Note

pub const D5: Note

pub const DS5: Note

pub const E5: Note

pub const F5: Note

pub const FS5: Note

pub const G5: Note

pub const GS5: Note

pub const A6: Note

pub const AS6: Note

pub const B6: Note

pub const C6: Note

pub const CS6: Note

pub const D6: Note

pub const DS6: Note

pub const E6: Note

pub const F6: Note

pub const FS6: Note

pub const G6: Note

pub const GS6: Note

pub const A7: Note

pub const AS7: Note

pub const B7: Note

pub const C7: Note

pub const CS7: Note

pub const D7: Note

pub const DS7: Note

pub const E7: Note

pub const F7: Note

pub const FS7: Note

pub const G7: Note

pub const GS7: Note

pub const A8: Note

pub const AS8: Note

pub const B8: Note

pub const C8: Note

pub const CS8: Note

pub const D8: Note

pub const DS8: Note

pub const E8: Note

pub const F8: Note

pub const FS8: Note

pub const G8: Note

pub const GS8: Note

pub const A9: Note

pub const AS9: Note

pub const B9: Note

pub const C9: Note

pub const CS9: Note

pub const D9: Note

pub const DS9: Note

pub const E9: Note

pub const F9: Note

pub const FS9: Note

pub const G9: Note

pub const GS9: Note

pub fn new(note: u32) -> Self

Create a new valid note. Will be clamped if nessesary.

Example:

use music_theory::theory::*;
assert_eq!(Note::new(12), Note::A1);

pub fn inside(&self) -> u32

Returns the inner value. You can not set the inner value directly to prevent invalid notes.

Example:

use music_theory::theory::*;
assert_eq!(Note::A2.inside(), 24);

pub fn to_pitch(&self) -> f32

Return the pitch in hertz. Note::A4 has an inner value of 48 and a pitch of 440 hz.

Example:

use music_theory::theory::*;
assert_eq!(Note::A4.to_pitch(), 440.0);

pub fn to_midi_note(&self) -> u8

Return the equivalent MIDI note. Note::A4 has an inner value of 48 and a MIDI note number of 69.

Example:

use music_theory::theory::*;
assert_eq!(Note::A4.to_midi_note(), 69);

Trait Implementations

impl Add for Note

type Output = Note

The resulting type after applying the + operator.

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

Performs the + operation.

impl AddAssign for Note

fn add_assign(&mut self, other: Self)

Performs the += operation.

impl AddInterval for Note

fn add_interval(self, interval: Interval) -> Option<Self>

Add an Interval.

impl Clone for Note

fn clone(&self) -> Note

Returns a duplicate 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 Default for Note

fn default() -> Note

Returns the “default value” for a type.

impl Display for Note

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

Formats the value using the given formatter.

impl GeneratablePartialOrder for Note

fn next(self) -> Option<Note>

Generate the next item.

fn prev(self) -> Option<Note>

Generate the previous item.

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

type Output = Note

The resulting type after applying the * operator.

fn mul(self, other: Self) -> Self::Output

Performs the * operation.

impl MulAssign for Note

fn mul_assign(&mut self, other: Self)

Performs the *= operation.

impl OctaveShiftable for Note

fn with_octave(self, octave: Octave) -> Note

Have the value with everything the same except change the octave to the given one.

fn shift_octave(self, shift: OctaveShift) -> Note

Have the value with everything the same except shift the octave from the current one with the given shift.

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,

Restrict a value to a certain interval.

impl PartialEq for Note

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

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

fn start_bound(&self) -> Bound<&Self>

Start index bound.

fn end_bound(&self) -> Bound<&Self>

End index bound.

fn contains<U>(&self, item: &U) -> bool

where T: PartialOrd<U>, U: PartialOrd<T> + ?Sized,

Returns true if item is contained in the range.

fn is_empty(&self) -> bool

where T: PartialOrd,

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

Returns true if the range contains no items. One-sided ranges (RangeFrom, etc) always return false.

impl Rem for Note

type Output = Note

The resulting type after applying the % operator.

fn rem(self, other: Self) -> Self::Output

Performs the % operation.

impl RemAssign for Note

fn rem_assign(&mut self, other: Self)

Performs the %= operation.

impl Sub for Note

type Output = Interval

The resulting type after applying the - operator.

fn sub(self, other: Self) -> Interval

Performs the - operation.

impl ToEnharmonicNote for Note

fn to_enharmonic_note(self) -> EnharmonicNote

Take self and return EnharmonicNote.

impl ToLetterTry for Note

fn to_letter_try(&self) -> Option<Letter>

Take self and try to return Letter.

impl ToPC for Note

fn to_pc(self) -> PC

Take self and return PC.

impl Wrapper for Note

type Inner = u32

The type the new type wraps.

fn wrap(note: Self::Inner) -> Option<Self>

Try to wrap a Self::Inner type into the Self type.

fn unwrap(self) -> Self::Inner

Unwrap a Self type into a Self::Inner type.

impl Copy for Note

impl Eq for Note

impl StructuralPartialEq for Note