Struct tune::key::PianoKey

pub struct PianoKey { /* fields omitted */ }

A physical or logical key on a real or virtual instrument without any notion of a pitch.

This struct does not represent a musical key, like in “F minor”, which is why its name is PianoKey.

Implementations

impl PianoKey

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

Creates a PianoKey instance from the given MIDI number.

pub fn midi_number(self) -> i32

Returns the MIDI number of this PianoKey.

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

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

Examples

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

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

Iterates over all PianoKeys in the range [self, upper_bound).

Examples

let midi_key_62 = PianoKey::from_midi_number(62);
let midi_key_67 = PianoKey::from_midi_number(67);

assert_eq!(
    midi_key_62.keys_before(midi_key_67).collect::<Vec<_>>(),
    (62..67).map(PianoKey::from_midi_number).collect::<Vec<_>>()
);
assert!(midi_key_67.keys_before(midi_key_62).collect::<Vec<_>>().is_empty());

pub fn num_keys_before(self, other: PianoKey) -> i32

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

Examples

let midi_key_62 = PianoKey::from_midi_number(62);
let midi_key_67 = PianoKey::from_midi_number(67);

assert_eq!(midi_key_62.num_keys_before(midi_key_67), 5);
assert_eq!(midi_key_67.num_keys_before(midi_key_62), -5);

pub fn plus_steps(self, num_steps: i32) -> PianoKey

Returns the key num_steps steps after self.

Examples

let midi_key_62 = PianoKey::from_midi_number(62);
let midi_key_67 = PianoKey::from_midi_number(67);

assert_eq!(midi_key_62.plus_steps(5), midi_key_67);
assert_eq!(midi_key_67.plus_steps(-5), midi_key_62);

Trait Implementations

impl Clone for PianoKey

fn clone(&self) -> PianoKey

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Copy for PianoKey

impl Debug for PianoKey

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

Formats the value using the given formatter.

impl Eq for PianoKey

impl Hash for PianoKey

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

pub fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl<S: Borrow<Scl>, K: Borrow<Kbm>> KeyboardMapping<PianoKey> for (S, K)

An (Scl, Kbm) pair has the complete information to define a KeyboardMapping.

Examples

use tune::tuning::KeyboardMapping;

let scl = Scl::builder()
   .push_cents(100.0)
   .build()
   .unwrap();

let kbm = Kbm::builder(Note::from_midi_number(62))
   .push_mapped_key(0)
   .push_mapped_key(4)
   .push_unmapped_key()
   .push_mapped_key(4)
   .formal_octave(12)
   .build()
   .unwrap();

let f = |midi_number| (&scl, &kbm).maybe_pitch_of(PianoKey::from_midi_number(midi_number));
assert_approx_eq!(f(62).unwrap().as_hz(), 293.664768);
assert_approx_eq!(f(63).unwrap().as_hz(), 369.994423);
assert!(f(64).is_none());
assert_approx_eq!(f(65).unwrap().as_hz(), 369.994423);
assert_approx_eq!(f(66).unwrap().as_hz(), 587.329536);

fn maybe_pitch_of(&self, key: PianoKey) -> Option<Pitch>

Returns the Pitch of the provided key or note.

impl Ord for PianoKey

fn cmp(&self, other: &PianoKey) -> Ordering

This method returns an Ordering between self and other.

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

Compares and returns the maximum of two values.

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

Compares and returns the minimum of two values.

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

Restrict a value to a certain interval.

impl PartialEq<PianoKey> for PianoKey

fn eq(&self, other: &PianoKey) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &PianoKey) -> bool

This method tests for !=.

impl PartialOrd<PianoKey> for PianoKey

fn partial_cmp(&self, other: &PianoKey) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

#[must_use]pub fn lt(&self, other: &Rhs) -> bool

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

#[must_use]pub 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]pub fn gt(&self, other: &Rhs) -> bool

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

#[must_use]pub 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 StructuralEq for PianoKey

impl StructuralPartialEq for PianoKey

impl<S: Borrow<Scl>, K: Borrow<KbmRoot>> Tuning<PianoKey> for (S, K)

fn pitch_of(&self, key: PianoKey) -> Pitch

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

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

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