Module Pitch.Class

Pitch classes.

In the naming scheme, f stands for flat (♭) and s is for sharp (♯).

Pitch classes

type t = [
| `Cff(*

C♭♭

*)
| `Cf(*

C♭

*)
| `C(*

C

*)
| `Cs(*

C♯

*)
| `Css(*

C♯♯

*)
| `Dff(*

D♭♭

*)
| `Df(*

D♭

*)
| `D(*

D

*)
| `Ds(*

D♯

*)
| `Dss(*

D♯♯

*)
| `Eff(*

E♭♭

*)
| `Ef(*

E♭

*)
| `E(*

E

*)
| `Es(*

E♯

*)
| `Ess(*

E♯♯

*)
| `Fff(*

F♭♭

*)
| `Ff(*

F♭

*)
| `F(*

F

*)
| `Fs(*

F♯

*)
| `Fss(*

F♯♯

*)
| `Gff(*

G♭♭

*)
| `Gf(*

G♭

*)
| `G(*

G

*)
| `Gs(*

G♯

*)
| `Gss(*

G♯♯

*)
| `Aff(*

F♭♭

*)
| `Af(*

A♭

*)
| `A(*

A

*)
| `As(*

A♯

*)
| `Ass(*

A♯♯

*)
| `Bff(*

B♭♭

*)
| `Bf(*

B♭

*)
| `B(*

B

*)
| `Bs(*

B♯

*)
| `Bss(*

B♯♯

*)
]

The type for pitch classes. The representation is not unique, for example Css (C♯♯) and D are the same pitch class.

val to_int : t -> int

to_int c is c as an integer on a non-modular semitone scale. `C is 0, `Cff is -2 and `Bss is 13. See also to_mod_int.

val to_mod_int : t -> int

to_mod_int c is like to_int but the result is non-negative and modulo 12, `C is 0. Enharmonics like `C and `Bs are mapped to the same integer. See also to_int.

Predicates and comparisons

XXX. Should the default equal and compare be the modular one ?

val equal : t -> t -> bool

equal c0 c1 is true iff to_int c0 = to_int c1. Note that this does not equate enharmonics like `C and `Bs, use mod_equal for that.

val compare : t -> t -> int

compare c0 c1 orders c0 and c1 according to to_int. Note that this does not equate enharmonics like `C and `Bs, use mod_compare for that.

val mod_equal : t -> t -> bool

mod_equal c0 c1 is true iff c0 and c1 represent the same pitch class. Equates enharmonics like `C and `Bs.

val mod_compare : t -> t -> int

mod_compare c0 c1 is a total order on pitches compatible with mod_equal.

Formatters

val pp : Stdlib.Format.formatter -> t -> unit

pp formats pitch classes. Uses the Unicode ♭ and ♯ characters.