Enum wmidi::Note

#[repr(u8)]
pub enum Note {
    CMinus1,
    DbMinus1,
    DMinus1,
    EbMinus1,
    EMinus1,
    FMinus1,
    GbMinus1,
    GMinus1,
    AbMinus1,
    AMinus1,
    BbMinus1,
    BMinus1,
    C0,
    Db0,
    D0,
    Eb0,
    E0,
    F0,
    Gb0,
    G0,
    Ab0,
    A0,
    Bb0,
    B0,
    C1,
    Db1,
    D1,
    Eb1,
    E1,
    F1,
    Gb1,
    G1,
    Ab1,
    A1,
    Bb1,
    B1,
    C2,
    Db2,
    D2,
    Eb2,
    E2,
    F2,
    Gb2,
    G2,
    Ab2,
    A2,
    Bb2,
    B2,
    C3,
    Db3,
    D3,
    Eb3,
    E3,
    F3,
    Gb3,
    G3,
    Ab3,
    A3,
    Bb3,
    B3,
    C4,
    Db4,
    D4,
    Eb4,
    E4,
    F4,
    Gb4,
    G4,
    Ab4,
    A4,
    Bb4,
    B4,
    C5,
    Db5,
    D5,
    Eb5,
    E5,
    F5,
    Gb5,
    G5,
    Ab5,
    A5,
    Bb5,
    B5,
    C6,
    Db6,
    D6,
    Eb6,
    E6,
    F6,
    Gb6,
    G6,
    Ab6,
    A6,
    Bb6,
    B6,
    C7,
    Db7,
    D7,
    Eb7,
    E7,
    F7,
    Gb7,
    G7,
    Ab7,
    A7,
    Bb7,
    B7,
    C8,
    Db8,
    D8,
    Eb8,
    E8,
    F8,
    Gb8,
    G8,
    Ab8,
    A8,
    Bb8,
    B8,
    C9,
    Db9,
    D9,
    Eb9,
    E9,
    F9,
    Gb9,
    G9,
}

A midi note.

The format for the enum is $NOTE $MODIFIER? $OCTAVE. Note can be a note from A to G. Modifier can be b for flat or Sharp for sharp. Octave is the number. The octave -1 is represented as Minus1.

Example

use wmidi::Note;
let ab7_chord = [Note::AbMinus1, Note::C4, Note::Gb4]; // We omit the 5th for a jazzier sound
let dmaj_chord = [Note::D2, Note::FSharp3, Note::A3];
assert_eq!(u8::from(Note::C3), 48u8);
assert_eq!(Note::from_u8_lossy(48), Note::C3);

Variants

CMinus1

DbMinus1

DMinus1

EbMinus1

EMinus1

FMinus1

GbMinus1

GMinus1

AbMinus1

AMinus1

BbMinus1

BMinus1

C0

Db0

D0

Eb0

E0

F0

Gb0

G0

Ab0

A0

Bb0

B0

C1

Db1

D1

Eb1

E1

F1

Gb1

G1

Ab1

A1

Bb1

B1

C2

Db2

D2

Eb2

E2

F2

Gb2

G2

Ab2

A2

Bb2

B2

C3

Db3

D3

Eb3

E3

F3

Gb3

G3

Ab3

A3

Bb3

B3

C4

Middle C.

Db4

D4

Eb4

E4

F4

Gb4

G4

Ab4

A4

A440.

Bb4

B4

C5

Db5

D5

Eb5

E5

F5

Gb5

G5

Ab5

A5

Bb5

B5

C6

Db6

D6

Eb6

E6

F6

Gb6

G6

Ab6

A6

Bb6

B6

C7

Db7

D7

Eb7

E7

F7

Gb7

G7

Ab7

A7

Bb7

B7

C8

Db8

D8

Eb8

E8

F8

Gb8

G8

Ab8

A8

Bb8

B8

C9

Db9

D9

Eb9

E9

F9

Gb9

G9

Implementations

impl Note

pub const CSharpMinus1: Note

pub const DSharpMinus1: Note

pub const FSharpMinus1: Note

pub const GSharpMinus1: Note

pub const ASharpMinus1: Note

pub const CSharp0: Note

pub const DSharp0: Note

pub const FSharp0: Note

pub const GSharp0: Note

pub const ASharp0: Note

pub const CSharp1: Note

pub const DSharp1: Note

pub const FSharp1: Note

pub const GSharp1: Note

pub const ASharp1: Note

pub const CSharp2: Note

pub const DSharp2: Note

pub const FSharp2: Note

pub const GSharp2: Note

pub const ASharp2: Note

pub const CSharp3: Note

pub const DSharp3: Note

pub const FSharp3: Note

pub const GSharp3: Note

pub const ASharp3: Note

pub const CSharp4: Note

pub const DSharp4: Note

pub const FSharp4: Note

pub const GSharp4: Note

pub const ASharp4: Note

pub const CSharp5: Note

pub const DSharp5: Note

pub const FSharp5: Note

pub const GSharp5: Note

pub const ASharp5: Note

pub const CSharp6: Note

pub const DSharp6: Note

pub const FSharp6: Note

pub const GSharp6: Note

pub const ASharp6: Note

pub const CSharp7: Note

pub const DSharp7: Note

pub const FSharp7: Note

pub const GSharp7: Note

pub const ASharp7: Note

pub const CSharp8: Note

pub const DSharp8: Note

pub const FSharp8: Note

pub const GSharp8: Note

pub const ASharp8: Note

pub const CSharp9: Note

pub const DSharp9: Note

pub const FSharp9: Note

pub const LOWEST_NOTE: Note

The lowest representable note.

pub const HIGHEST_NOTE: Note

The highest representable note.

pub unsafe fn from_u8_unchecked(note: u8) -> Note

Creates a note from a u8. note must be between [0, 127] inclusive to create a valid note.

Example

 let parsed_note = 60;
 let note = unsafe { wmidi::Note::from_u8_unchecked(parsed_note) };

Safety

note must be less than or equal to 127.

pub fn from_u8_lossy(note: u8) -> Note

Create a note from a u8. Only the 7 least significant bits of note are used.

pub fn to_freq_f32(self) -> f32

The frequency using the standard 440Hz tuning.

Example

let note = wmidi::Note::A3;
sing(note.to_freq_f32());

pub fn to_freq_f64(self) -> f64

The frequency using the standard 440Hz tuning.

Example

let note = wmidi::Note::A3;
sing(note.to_freq_f64());

pub fn step(self, half_steps: i8) -> Result<Note, Error>

Get the note relative to self.

Example

use wmidi::Note;
fn minor_chord(root: Note) -> Result<[Note; 3], wmidi::Error> {
    Ok([root, root.step(3)?, root.step(7)?])
}
assert_eq!(minor_chord(Note::C2), Ok([Note::C2, Note::Eb2, Note::G2]));

pub fn to_str(self) -> &'static str

Get a str representation of the note. For example: "C3" or "A#/Bb2".

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

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

Formats the value using the given formatter.

impl From<U7> for Note

fn from(note: U7) -> Note

Performs the conversion.

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

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 ==.

#[must_use]

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

#[must_use]

fn lt(&self, other: &Rhs) -> bool

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

#[must_use]

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

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

#[must_use]

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

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

#[must_use]

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 TryFrom<u8> for Note

Convert from a u8 to a Note. The u8 must be in the range [0, 127] inclusive.

fn try_from(note: u8) -> Result<Note, Error>

Creates a note from a u8. note must be between [0, 127] inclusive to create a valid note.

Example

 use std::convert::TryFrom;
 fn decode_note(number: u8) -> Result<wmidi::Note, wmidi::Error> {
     let parsed_note = 60;
     let note = wmidi::Note::try_from(parsed_note)?;
     Ok(note)
 }

type Error = Error

The type returned in the event of a conversion error.

impl Copy for Note

impl Eq for Note

impl StructuralEq for Note

impl StructuralPartialEq for Note