Octave and PitchClass duple.

Normalise Octave_PitchClass value, ie. ensure pitch-class is in (0,11).

Transpose Octave_PitchClass value.

Octave_PitchClass value to integral midi note number.

map octave_pitchclass_to_midi [(-1,9),(8,0)] == map (+ 9) [0,99]

Inverse of octave_pitchclass_to_midi.

map midi_to_octave_pitchclass [0,36,60,84,91] == [(-1,0),(2,0),(4,0),(6,0),(6,7)]

One-indexed piano key number (for standard 88 key piano) to pitch class. This has the mnemonic that 49 maps to (4,9).

map pianokey_to_octave_pitchclass [1,49,88] == [(0,9),(4,9),(8,0)]

Pitch classes are modulo twelve integers (0-11)

Octaves are integers, the octave of middle C is 4.

Octave and PitchClass duple.

Translate from generic octave & pitch-class duple.

Normalise OctPc.

octpc_nrm (4,16) == (5,4)

Transpose OctPc.

octpc_trs 7 (4,9) == (5,4)
octpc_trs (-11) (4,9) == (3,10)

Enumerate range, inclusive.

octpc_range ((3,8),(4,1)) == [(3,8),(3,9),(3,10),(3,11),(4,0),(4,1)]

Midi note number (0 - 127). Midi data values are unsigned 7-bit integers, however using an unsigned type would be problematic. It would make transposition, for instance, awkward. x - 12 would transpose down an octave, but the transposition interval itself could not be negative.

Type conversion

Type-specialise f, ie. round, ceiling, truncate

OctPc value to integral midi note number.

map octpc_to_midi [(0,0),(2,6),(4,9),(6,2),(9,0)] == [12,42,69,86,120]
map octpc_to_midi [(0,9),(8,0)] == [21,108]

Inverse of octpc_to_midi.

map midi_to_octpc [40,69] == [(2,4),(4,9)]

(octave,pitch-class) to fractional octave. This is an odd notation, but can be useful for writing pitch data where a float is required. Note this is not a linear octave, for that see oct_to_cps.

map octpc_to_foct [(4,0),(4,7),(5,11)] == [4.00,4.07,5.11]

Inverse of octpc_to_foct.

map foct_to_octpc [3.11,4.00,4.07,5.11] == [(3,11),(4,0),(4,7),(5,11)]

octpc_to_midi of foct_to_octpc.

Fractional midi note number.

Fractional octave pitch-class (octave is integral, pitch-class is fractional).

fromIntegral of octpc_to_midi.

Fractional midi to fractional octave pitch-class.

fmidi_to_foctpc 69.5 == (4,9.5)

Octave of fractional midi note number.

Move fractional midi note number to indicated octave.

map (fmidi_in_octave 1) [59.5,60.5] == [35.5,24.5]

Print fractional midi note number as ET12 pitch with cents detune in parentheses.

fmidi_et12_cents_pp T.pc_spell_ks 66.5 == "F♯4(+50)"

Common music notation pitch value.

Simplify Pitch to standard 12ET by deleting quarter tones.

let p = Pitch T.A T.QuarterToneSharp 4
alteration (pitch_clear_quarter_tone p) == T.Sharp

Pitch to Octave and PitchClass notation.

pitch_to_octpc (Pitch F Sharp 4) == (4,6)

Is Pitch 12-ET.

Pitch to midi note number notation.

pitch_to_midi (Pitch A Natural 4) == 69

Pitch to fractional midi note number notation.

pitch_to_fmidi (Pitch A QuarterToneSharp 4) == 69.5

Extract PitchClass of Pitch

map pitch_to_pc [Pitch A Natural 4,Pitch F Sharp 4] == [9,6]
map pitch_to_pc [Pitch C Flat 4,Pitch B Sharp 5] == [11,0]

Pitch comparison, implemented via pitch_to_fmidi.

pitch_compare (Pitch A Natural 4) (Pitch A QuarterToneSharp 4) == LT

Function to spell a PitchClass.

Variant of Spelling for incomplete functions.

Given Spelling function translate from OctPc notation to Pitch.

octpc_to_pitch T.pc_spell_sharp (4,6) == Pitch T.F T.Sharp 4

Midi note number to Pitch.

import Music.Theory.Pitch.Spelling.Table as T
let r = ["C4","E♭4","F♯4"]
map (pitch_pp . midi_to_pitch T.pc_spell_ks) [60,63,66] == r

Fractional midi note number to Pitch.

p = Pitch T.B T.ThreeQuarterToneFlat 4
map (fmidi_to_pitch T.pc_spell_ks) [69.25,69.5] == [Nothing,Just p]

Erroring variant.

import Music.Theory.Pitch.Spelling as T
pitch_pp (fmidi_to_pitch_err T.pc_spell_ks 65.5) == "F𝄲4"
pitch_pp (fmidi_to_pitch_err T.pc_spell_ks 66.5) == "F𝄰4"
pitch_pp (fmidi_to_pitch_err T.pc_spell_ks 67.5) == "A𝄭4"
pitch_pp (fmidi_to_pitch_err T.pc_spell_ks 69.5) == "B𝄭4"

Composition of pitch_to_fmidi and then fmidi_to_pitch.

import Music.Theory.Pitch.Name as T
import Music.Theory.Pitch.Spelling as T
pitch_transpose_fmidi T.pc_spell_ks 2 T.ees5 == T.f5

Displacement of q into octave of p.

Octave displacement of m2 that is nearest m1.

let p = octpc_to_fmidi (2,1)
let q = map octpc_to_fmidi [(4,11),(4,0),(4,1)]
map (fmidi_in_octave_nearest p) q == [35,36,37]

Displacement of q into octave above p.

fmidi_in_octave_of 69 51 == 63
fmidi_in_octave_nearest 69 51 == 63
fmidi_in_octave_above 69 51 == 75

Displacement of q into octave below p.

fmidi_in_octave_of 69 85 == 61
fmidi_in_octave_nearest 69 85 == 73
fmidi_in_octave_below 69 85 == 61

CPS form of binary fmidi function f.

CPS form of fmidi_in_octave_nearest.

map cps_octave [440,256] == [4,4]
round (cps_in_octave_nearest 440 256) == 512

CPS form of fmidi_in_octave_above.

cps_in_octave_above 55.0 392.0 == 97.99999999999999

CPS form of fmidi_in_octave_above.

Direct implementation of cps_in_octave_above. Raise or lower the frequency q by octaves until it is in the octave starting at p.

cps_in_octave_above_direct 55.0 392.0 == 98.0

Set octave of p2 so that it nearest to p1.

import Music.Theory.Pitch
import Music.Theory.Pitch.Name as T
let r = ["B1","C2","C#2"]
let f = pitch_in_octave_nearest T.cis2
map (pitch_pp_iso . f) [T.b4,T.c4,T.cis4] == r

Raise Note of Pitch, account for octave transposition.

pitch_note_raise (Pitch B Natural 3) == Pitch C Natural 4

Lower Note of Pitch, account for octave transposition.

pitch_note_lower (Pitch C Flat 4) == Pitch B Flat 3

Rewrite Pitch to not use 3/4 tone alterations, ie. re-spell to 1/4 alteration.

let p = Pitch T.A T.ThreeQuarterToneFlat 4
let q = Pitch T.G T.QuarterToneSharp 4
pitch_rewrite_threequarter_alteration p == q

Apply function to octave of PitchClass.

pitch_edit_octave (+ 1) (Pitch T.A T.Natural 4) == Pitch T.A T.Natural 5

fmidi_to_cps of pitch_to_fmidi, given (k0,f0).

fmidi_to_cps of pitch_to_fmidi, given frequency of ISO A4.

pitch_to_cps_k0 (60,440).

Frequency (cps = cycles per second) to fractional midi note number, given frequency of ISO A4 (mnn = 69).

cps_to_fmidi_k0 (69,440).

cps_to_fmidi 440 == 69
cps_to_fmidi (fmidi_to_cps 60.25) == 60.25

Frequency (cycles per second) to midi note number, ie. round of cps_to_fmidi.

map cps_to_midi [261.6,440] == [60,69]

midi_to_cps_f0 of octpc_to_midi, given (k0,f0)

octpc_to_cps_k0 (69,440).

map (round . octpc_to_cps) [(-1,0),(0,0),(4,9),(9,0)] == [8,16,440,8372]

midi_to_octpc of cps_to_midi.

Is cents in (-50,+50].

map cents_is_normal [-250,-75,75,250] == replicate 4 False

cents_is_normal of snd.

In normal form the detune is in the range (-50,+50] instead of [0,100) or wider.

map midi_detune_normalise [(60,-250),(60,-75),(60,75),(60,250)]

In normal-positive form the detune is in the range (0,+100].

map midi_detune_normalise_positive [(60,-250),(60,-75),(60,75),(60,250)]

Inverse of cps_to_midi_detune, given frequency of ISO A4.

Inverse of cps_to_midi_detune.

map midi_detune_to_cps [(69,0),(68,100)] == [440,440]

Midi_Detune to fractional midi note number.

midi_detune_to_fmidi (60,50.0) == 60.50

Midi_Detune to Pitch, detune must be precisely at a notateable Pitch.

let p = Pitch {note = T.C, alteration = T.QuarterToneSharp, octave = 4}
midi_detune_to_pitch T.pc_spell_ks (midi_detune_nearest_24et (60,35)) == p

Midi note number with real-valued cents detune.

Fractional midi note number to Midi_Detune.

fmidi_to_midi_detune 60.50 == (60,50.0)

Frequency (in hertz) to Midi_Detune.

map (fmap round . cps_to_midi_detune) [440.00,508.35] == [(69,0),(71,50)]

Round detune value to nearest multiple of 50, normalised.

map midi_detune_nearest_24et [(59,70),(59,80)] == [(59,50),(60,00)]

Midi note number with integral cents detune.

Printed as fmidi value with cents to two places. Must be normal.

map midi_cents_pp [(60,0),(60,25)] == ["60.00","60.25"]

The 24ET pitch-class universe, with sharp spellings, in octave '4'.

length pc24et_univ == 24

let r = "C C𝄲 C♯ C𝄰 D D𝄲 D♯ D𝄰 E E𝄲 F F𝄲 F♯ F𝄰 G G𝄲 G♯ G𝄰 A A𝄲 A♯ A𝄰 B B𝄲"
unwords (map pitch_class_pp pc24et_univ) == r

genericIndex into pc24et_univ.

pitch_class_pp (pc24et_to_pitch 13) == "F𝄰"

Generalised pitch, given by a generalised alteration.

Pretty printer for Pitch_R.

Pitch_R printed without octave.

Parser for single digit ISO octave (C4 = middle-C)

Parser for single digit ISO octave with default value in case of no parse.

Parser for ISO pitch notation.

Parser for extended form of ISO pitch notation.

Parse possible octave from single integer.

map (parse_octave 2) ["","4","x","11"] == [2,4,2,1]x

Generalisation of ISO pitch representation. Allows octave to be elided, pitch names to be lower case, and double sharps written as ##.

See http://www.musiccog.ohio-state.edu/Humdrum/guide04.html

let r = [Pitch T.C T.Natural 4,Pitch T.A T.Flat 5,Pitch T.F T.DoubleSharp 6]
mapMaybe (parse_iso_pitch_oct 4) ["C","Ab5","f##6",""] == r

Variant of parse_iso_pitch_oct requiring octave.

error variant.

Pretty printer for Pitch (unicode, see alteration_symbol). Option selects if Naturals are printed.

pitch_pp_opt (True,True) (Pitch T.E T.Natural 4) == "E♮4"

pitch_pp_opt with default options, ie. (False,True).

pitch_pp (Pitch T.E T.Natural 4) == "E4"
pitch_pp (Pitch T.E T.Flat 4) == "E♭4"
pitch_pp (Pitch T.F T.QuarterToneSharp 3) == "F𝄲3"

pitch_pp_opt with options (False,False).

pitch_class_pp (Pitch T.C T.ThreeQuarterToneSharp 0) == "C𝄰"

Sequential list of n pitch class names starting from k.

import Music.Theory.Pitch.Spelling.Table
unwords (pitch_class_names_12et pc_spell_ks 0 12) == "C C♯ D E♭ E F F♯ G A♭ A B♭ B"
pitch_class_names_12et pc_spell_ks 11 2 == ["B","C"]

Pretty printer for Pitch (ISO, ASCII, see alteration_iso).

pitch_pp_iso (Pitch E Flat 4) == "Eb4"
pitch_pp_iso (Pitch F DoubleSharp 3) == "Fx3"
pitch_pp_iso (Pitch C ThreeQuarterToneSharp 4) -- error

Lilypond octave syntax.

Lookup ly_octave_tbl.

Parse lilypond octave indicator.

Pretty printer for Pitch (ASCII, see alteration_tonh).

pitch_pp_hly (Pitch E Flat 4) == "ees4"
pitch_pp_hly (Pitch F QuarterToneSharp 3) == "fih3"
pitch_pp_hly (Pitch B Natural 6) == "b6"

Pretty printer for Pitch (Tonhöhe, see alteration_tonh).

pitch_pp_tonh (Pitch E Flat 4) == "Es4"
pitch_pp_tonh (Pitch F QuarterToneSharp 3) == "Fih3"
pitch_pp_tonh (Pitch B Natural 6) == "H6"

Run p_pitch_ly.

map (pitch_pp . pitch_parse_ly_err) ["c","d'","ees,","fisis''"] == ["C3","D4","E♭2","F𝄪5"]

Parser for hly notation.

Run p_pitch_hly.

map (pitch_pp . pitch_parse_hly) ["ees4","fih3","b6"] == ["E♭4","F𝄲3","B6"]