Enum tonality::tpc::Tpc

#[must_use]pub enum Tpc {
    Fbb,
    Cbb,
    Gbb,
    Dbb,
    Abb,
    Ebb,
    Bbb,
    Fb,
    Cb,
    Gb,
    Db,
    Ab,
    Eb,
    Bb,
    F,
    C,
    G,
    D,
    A,
    E,
    B,
    Fs,
    Cs,
    Gs,
    Ds,
    As,
    Es,
    Bs,
    Fss,
    Css,
    Gss,
    Dss,
    Ass,
    Ess,
    Bss,
}

Tonal pitch class

Has variants for all pitch classes with double or single flats, natural, double or single sharps. The numeric value of the enum corresponds to steps away from C on the "line of fifths". For instance, F is one fifth below C and has the value -1.

Note that the "s" and "ss" suffixes mean sharp and double sharp. Should not be confused with the names of flat notes, which in some languages use the -s suffix.

Variants

Fbb

Cbb

Gbb

Dbb

Abb

Ebb

Bbb

Fb

Cb

Gb

Db

Ab

Eb

Bb

F

C

G

D

A

E

B

Fs

Cs

Gs

Ds

As

Es

Bs

Fss

Css

Gss

Dss

Ass

Ess

Bss

Implementations

impl Tpc

pub const MAX: Tpc

The sharpest valid Tpc: B double sharp

pub const MIN: Tpc

The flattest valid Tpc: F double flat

pub fn step(self) -> Step

The basic step of the Tpc, or where it is placed on the staff

assert_eq!(Step::C, Tpc::C.step());
assert_eq!(Step::C, Tpc::Cs.step());
assert_eq!(Tpc::Gb.step(), Tpc::Gs.step());

#[must_use]pub fn alteration(self, key: Key) -> Alteration

The number of semitones by which the tpc is altered with respect to the key

Example

// C natural is not altered in the key of A flat
assert_eq!(0, Tpc::C.alteration(Key::Ab));
// A major has C sharp, so a C natural is one semitone flat
assert_eq!(-1, Tpc::C.alteration(Key::A));
// Db major has A flat, so an A sharp is two semitones sharp
assert_eq!(2, Tpc::As.alteration(Key::Db));

pub fn altered_step(self, key: Option<Key>) -> (Step, Option<Accidental>)

Find the appropriate accidental for the Tpc in a key.

If no key is given, default to C major with no fixed accidentals

Example

let tpc = Tpc::C;
let key: Option<Key> = None;
assert_eq!((Step::C, None), tpc.altered_step(key));

let key: Option<Key> = Some(Key::A);
assert_eq!((Step::C, Some(Accidental::Natural)), tpc.altered_step(key));

let tpc = Tpc::Fss;
let key: Option<Key> = None;
assert_eq!((Step::F, Some(Accidental::DblSharp)), tpc.altered_step(key));

#[must_use]pub fn alter(self, by: Alteration) -> Option<Tpc>

Adjust alteration while maintaining the step value

Returns None if the alteration would be sharper than double sharp or flatter than double flat

assert_eq!(Some(Tpc::Gs), Tpc::G.alter(1));
assert_eq!(None, Tpc::Bbb.alter(-1));
assert_eq!(Some(Tpc::Abb), Tpc::As.alter(-3));

#[must_use]pub fn enharmonic(self, other: Tpc) -> bool

Whether the two tpcs are enharmonic, i.e. represent the same pitch class in twelve tone equal temperament.

This relation applies even to tpcs which doesn't have a valid interval between them, such as Abb and Fss.

assert!(Tpc::Gs.enharmonic(Tpc::Ab));
assert!(Tpc::Fs.enharmonic(Tpc::Ess));
assert!(Tpc::Abb.enharmonic(Tpc::Fss));
assert!(!Tpc::Fs.enharmonic(Tpc::F));

Trait Implementations

impl Add<Interval> for Tpc

type Output = Option<Tpc>

The resulting type after applying the + operator.

fn add(self, rhs: Interval) -> Self::Output

Performs the + operation.

impl Clone for Tpc

fn clone(&self) -> Tpc

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Copy for Tpc

impl Debug for Tpc

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

Formats the value using the given formatter.

impl Eq for Tpc

impl From<Tpc> for Step

fn from(tpc: Tpc) -> Self

Performs the conversion.

impl FromPrimitive for Tpc

fn from_i64(n: i64) -> Option<Self>

Converts an i64 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_u64(n: u64) -> Option<Self>

Converts an u64 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_isize(n: isize) -> Option<Self>

Converts an isize to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_i8(n: i8) -> Option<Self>

Converts an i8 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_i16(n: i16) -> Option<Self>

Converts an i16 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_i32(n: i32) -> Option<Self>

Converts an i32 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_i128(n: i128) -> Option<Self>

Converts an i128 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_usize(n: usize) -> Option<Self>

Converts a usize to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_u8(n: u8) -> Option<Self>

Converts an u8 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_u16(n: u16) -> Option<Self>

Converts an u16 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_u32(n: u32) -> Option<Self>

Converts an u32 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_u128(n: u128) -> Option<Self>

Converts an u128 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_f32(n: f32) -> Option<Self>

Converts a f32 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_f64(n: f64) -> Option<Self>

Converts a f64 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

impl Ord for Tpc

fn cmp(&self, other: &Tpc) -> 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<Tpc> for Tpc

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

fn partial_cmp(&self, other: &Tpc) -> 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 StructuralEq for Tpc

impl StructuralPartialEq for Tpc

impl Sub<Interval> for Tpc

type Output = Option<Tpc>

The resulting type after applying the - operator.

fn sub(self, rhs: Interval) -> Self::Output

Performs the - operation.

impl Sub<Tpc> for Tpc

type Output = Option<Interval>

The resulting type after applying the - operator.

fn sub(self, rhs: Tpc) -> Self::Output

Performs the - operation.