Enum wmidi::Note

#[repr(u8)]
pub enum Note {
    CMinus1 = 0,
    DbMinus1 = 1,
    DMinus1 = 2,
    EbMinus1 = 3,
    EMinus1 = 4,
    FMinus1 = 5,
    GbMinus1 = 6,
    GMinus1 = 7,
    AbMinus1 = 8,
    AMinus1 = 9,
    BbMinus1 = 10,
    BMinus1 = 11,
    C0 = 12,
    Db0 = 13,
    D0 = 14,
    Eb0 = 15,
    E0 = 16,
    F0 = 17,
    Gb0 = 18,
    G0 = 19,
    Ab0 = 20,
    A0 = 21,
    Bb0 = 22,
    B0 = 23,
    C1 = 24,
    Db1 = 25,
    D1 = 26,
    Eb1 = 27,
    E1 = 28,
    F1 = 29,
    Gb1 = 30,
    G1 = 31,
    Ab1 = 32,
    A1 = 33,
    Bb1 = 34,
    B1 = 35,
    C2 = 36,
    Db2 = 37,
    D2 = 38,
    Eb2 = 39,
    E2 = 40,
    F2 = 41,
    Gb2 = 42,
    G2 = 43,
    Ab2 = 44,
    A2 = 45,
    Bb2 = 46,
    B2 = 47,
    C3 = 48,
    Db3 = 49,
    D3 = 50,
    Eb3 = 51,
    E3 = 52,
    F3 = 53,
    Gb3 = 54,
    G3 = 55,
    Ab3 = 56,
    A3 = 57,
    Bb3 = 58,
    B3 = 59,
    C4 = 60,
    Db4 = 61,
    D4 = 62,
    Eb4 = 63,
    E4 = 64,
    F4 = 65,
    Gb4 = 66,
    G4 = 67,
    Ab4 = 68,
    A4 = 69,
    Bb4 = 70,
    B4 = 71,
    C5 = 72,
    Db5 = 73,
    D5 = 74,
    Eb5 = 75,
    E5 = 76,
    F5 = 77,
    Gb5 = 78,
    G5 = 79,
    Ab5 = 80,
    A5 = 81,
    Bb5 = 82,
    B5 = 83,
    C6 = 84,
    Db6 = 85,
    D6 = 86,
    Eb6 = 87,
    E6 = 88,
    F6 = 89,
    Gb6 = 90,
    G6 = 91,
    Ab6 = 92,
    A6 = 93,
    Bb6 = 94,
    B6 = 95,
    C7 = 96,
    Db7 = 97,
    D7 = 98,
    Eb7 = 99,
    E7 = 100,
    F7 = 101,
    Gb7 = 102,
    G7 = 103,
    Ab7 = 104,
    A7 = 105,
    Bb7 = 106,
    B7 = 107,
    C8 = 108,
    Db8 = 109,
    D8 = 110,
    Eb8 = 111,
    E8 = 112,
    F8 = 113,
    Gb8 = 114,
    G8 = 115,
    Ab8 = 116,
    A8 = 117,
    Bb8 = 118,
    B8 = 119,
    C9 = 120,
    Db9 = 121,
    D9 = 122,
    Eb9 = 123,
    E9 = 124,
    F9 = 125,
    Gb9 = 126,
    G9 = 127,
}

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

DbMinus1 = 1

DMinus1 = 2

EbMinus1 = 3

EMinus1 = 4

FMinus1 = 5

GbMinus1 = 6

GMinus1 = 7

AbMinus1 = 8

AMinus1 = 9

BbMinus1 = 10

BMinus1 = 11

C0 = 12

Db0 = 13

D0 = 14

Eb0 = 15

E0 = 16

F0 = 17

Gb0 = 18

G0 = 19

Ab0 = 20

A0 = 21

Bb0 = 22

B0 = 23

C1 = 24

Db1 = 25

D1 = 26

Eb1 = 27

E1 = 28

F1 = 29

Gb1 = 30

G1 = 31

Ab1 = 32

A1 = 33

Bb1 = 34

B1 = 35

C2 = 36

Db2 = 37

D2 = 38

Eb2 = 39

E2 = 40

F2 = 41

Gb2 = 42

G2 = 43

Ab2 = 44

A2 = 45

Bb2 = 46

B2 = 47

C3 = 48

Db3 = 49

D3 = 50

Eb3 = 51

E3 = 52

F3 = 53

Gb3 = 54

G3 = 55

Ab3 = 56

A3 = 57

Bb3 = 58

B3 = 59

C4 = 60

Middle C.

Db4 = 61

D4 = 62

Eb4 = 63

E4 = 64

F4 = 65

Gb4 = 66

G4 = 67

Ab4 = 68

A4 = 69

A440.

Bb4 = 70

B4 = 71

C5 = 72

Db5 = 73

D5 = 74

Eb5 = 75

E5 = 76

F5 = 77

Gb5 = 78

G5 = 79

Ab5 = 80

A5 = 81

Bb5 = 82

B5 = 83

C6 = 84

Db6 = 85

D6 = 86

Eb6 = 87

E6 = 88

F6 = 89

Gb6 = 90

G6 = 91

Ab6 = 92

A6 = 93

Bb6 = 94

B6 = 95

C7 = 96

Db7 = 97

D7 = 98

Eb7 = 99

E7 = 100

F7 = 101

Gb7 = 102

G7 = 103

Ab7 = 104

A7 = 105

Bb7 = 106

B7 = 107

C8 = 108

Db8 = 109

D8 = 110

Eb8 = 111

E8 = 112

F8 = 113

Gb8 = 114

G8 = 115

Ab8 = 116

A8 = 117

Bb8 = 118

B8 = 119

C9 = 120

Db9 = 121

D9 = 122

Eb9 = 123

E9 = 124

F9 = 125

Gb9 = 126

G9 = 127

Implementations

impl Note

pub const CSharpMinus1: Note = Note::DbMinus1

pub const DSharpMinus1: Note = Note::EbMinus1

pub const FSharpMinus1: Note = Note::GbMinus1

pub const GSharpMinus1: Note = Note::AbMinus1

pub const ASharpMinus1: Note = Note::BbMinus1

pub const CSharp0: Note = Note::Db0

pub const DSharp0: Note = Note::Eb0

pub const FSharp0: Note = Note::Gb0

pub const GSharp0: Note = Note::Ab0

pub const ASharp0: Note = Note::Bb0

pub const CSharp1: Note = Note::Db1

pub const DSharp1: Note = Note::Eb1

pub const FSharp1: Note = Note::Gb1

pub const GSharp1: Note = Note::Ab1

pub const ASharp1: Note = Note::Bb1

pub const CSharp2: Note = Note::Db2

pub const DSharp2: Note = Note::Eb2

pub const FSharp2: Note = Note::Gb2

pub const GSharp2: Note = Note::Ab2

pub const ASharp2: Note = Note::Bb2

pub const CSharp3: Note = Note::Db3

pub const DSharp3: Note = Note::Eb3

pub const FSharp3: Note = Note::Gb3

pub const GSharp3: Note = Note::Ab3

pub const ASharp3: Note = Note::Bb3

pub const CSharp4: Note = Note::Db4

pub const DSharp4: Note = Note::Eb4

pub const FSharp4: Note = Note::Gb4

pub const GSharp4: Note = Note::Ab4

pub const ASharp4: Note = Note::Bb4

pub const CSharp5: Note = Note::Db5

pub const DSharp5: Note = Note::Eb5

pub const FSharp5: Note = Note::Gb5

pub const GSharp5: Note = Note::Ab5

pub const ASharp5: Note = Note::Bb5

pub const CSharp6: Note = Note::Db6

pub const DSharp6: Note = Note::Eb6

pub const FSharp6: Note = Note::Gb6

pub const GSharp6: Note = Note::Ab6

pub const ASharp6: Note = Note::Bb6

pub const CSharp7: Note = Note::Db7

pub const DSharp7: Note = Note::Eb7

pub const FSharp7: Note = Note::Gb7

pub const GSharp7: Note = Note::Ab7

pub const ASharp7: Note = Note::Bb7

pub const CSharp8: Note = Note::Db8

pub const DSharp8: Note = Note::Eb8

pub const FSharp8: Note = Note::Gb8

pub const GSharp8: Note = Note::Ab8

pub const ASharp8: Note = Note::Bb8

pub const CSharp9: Note = Note::Db9

pub const DSharp9: Note = Note::Eb9

pub const FSharp9: Note = Note::Gb9

pub const LOWEST_NOTE: Note = Note::CMinus1

The lowest representable note.

pub const HIGHEST_NOTE: Note = Note::G9

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

Convert from a Note to a u8.

fn from(note: Note) -> u8

Example

 use std::convert::TryFrom;
 fn encode_note(note: wmidi::Note) -> u8 {
     u8::from(note)
 }

impl From<U7> for Note

fn from(note: U7) -> Note

Converts to this type from the input type.

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

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