Music.Theory.Pitch.Note

Common music notation note and alteration values.

Note_T

data Note_T

Enumeration of common music notation note names (C to B).

Constructors

C

D

E

F

G

A

B

Instances

Bounded Note_T

Methods

minBound :: Note_T

maxBound :: Note_T

Enum Note_T

Methods

succ :: Note_T -> Note_T

pred :: Note_T -> Note_T

toEnum :: Int -> Note_T

fromEnum :: Note_T -> Int

enumFrom :: Note_T -> [Note_T]

enumFromThen :: Note_T -> Note_T -> [Note_T]

enumFromTo :: Note_T -> Note_T -> [Note_T]

enumFromThenTo :: Note_T -> Note_T -> Note_T -> [Note_T]

Eq Note_T

Methods

(==) :: Note_T -> Note_T -> Bool

(/=) :: Note_T -> Note_T -> Bool

Ord Note_T

Methods

compare :: Note_T -> Note_T -> Ordering

(<) :: Note_T -> Note_T -> Bool

(<=) :: Note_T -> Note_T -> Bool

(>) :: Note_T -> Note_T -> Bool

(>=) :: Note_T -> Note_T -> Bool

max :: Note_T -> Note_T -> Note_T

min :: Note_T -> Note_T -> Note_T

Read Note_T

Methods

readsPrec :: Int -> ReadS Note_T

readList :: ReadS [Note_T]

readPrec :: ReadPrec Note_T

readListPrec :: ReadPrec [Note_T]

Show Note_T

Methods

showsPrec :: Int -> Note_T -> ShowS

show :: Note_T -> String

showList :: [Note_T] -> ShowS

note_seq :: [Note_T]

Note sequence as usually understood, ie. C - B.

note_pp :: Note_T -> Char

Char variant of show.

note_pc_tbl :: Num i => [(Note_T, i)]

Table of Note_T and corresponding pitch-classes.

note_to_pc :: Num i => Note_T -> i

Transform Note_T to pitch-class number.

map note_to_pc [C,E,G] == [0,4,7]

pc_to_note :: (Eq i, Num i) => i -> Maybe Note_T

Inverse of note_to_pc.

mapMaybe pc_to_note [0,4,7] == [C,E,G]

note_t_transpose :: Note_T -> Int -> Note_T

Modal transposition of Note_T value.

note_t_transpose C 2 == E

parse_note_t :: Bool -> Char -> Maybe Note_T

Parser from Char, case insensitive flag.

mapMaybe (parse_note True) "CDEFGab" == [C,D,E,F,G,A,B]

note_span :: Note_T -> Note_T -> [Note_T]

Inclusive set of Note_T within indicated interval. This is not equal to enumFromTo which is not circular.

note_span E B == [E,F,G,A,B]
note_span B D == [B,C,D]
enumFromTo B D == []

Alteration

data Alteration_T

Enumeration of common music notation note alterations.

Constructors

DoubleFlat

ThreeQuarterToneFlat

Flat

QuarterToneFlat

Natural

QuarterToneSharp

Sharp

ThreeQuarterToneSharp

DoubleSharp

Instances

Bounded Alteration_T

Methods

minBound :: Alteration_T

maxBound :: Alteration_T

Enum Alteration_T

Methods

succ :: Alteration_T -> Alteration_T

pred :: Alteration_T -> Alteration_T

toEnum :: Int -> Alteration_T

fromEnum :: Alteration_T -> Int

enumFrom :: Alteration_T -> [Alteration_T]

enumFromThen :: Alteration_T -> Alteration_T -> [Alteration_T]

enumFromTo :: Alteration_T -> Alteration_T -> [Alteration_T]

enumFromThenTo :: Alteration_T -> Alteration_T -> Alteration_T -> [Alteration_T]

Eq Alteration_T

Methods

(==) :: Alteration_T -> Alteration_T -> Bool

(/=) :: Alteration_T -> Alteration_T -> Bool

Ord Alteration_T

Methods

compare :: Alteration_T -> Alteration_T -> Ordering

(<) :: Alteration_T -> Alteration_T -> Bool

(<=) :: Alteration_T -> Alteration_T -> Bool

(>) :: Alteration_T -> Alteration_T -> Bool

(>=) :: Alteration_T -> Alteration_T -> Bool

max :: Alteration_T -> Alteration_T -> Alteration_T

min :: Alteration_T -> Alteration_T -> Alteration_T

Show Alteration_T

Methods

showsPrec :: Int -> Alteration_T -> ShowS

show :: Alteration_T -> String

showList :: [Alteration_T] -> ShowS

generic_alteration_to_diff :: Integral i => Alteration_T -> Maybe i

Generic form.

alteration_to_diff :: Alteration_T -> Maybe Int

Transform Alteration_T to semitone alteration. Returns Nothing for non-semitone alterations.

map alteration_to_diff [Flat,QuarterToneSharp] == [Just (-1),Nothing]

alteration_is_12et :: Alteration_T -> Bool

Is Alteration_T 12-ET.

alteration_to_diff_err :: Integral i => Alteration_T -> i

Transform Alteration_T to semitone alteration.

map alteration_to_diff_err [Flat,Sharp] == [-1,1]

alteration_to_fdiff :: Fractional n => Alteration_T -> n

Transform Alteration_T to fractional semitone alteration, ie. allow quarter tones.

alteration_to_fdiff QuarterToneSharp == 0.5

fdiff_to_alteration :: (Fractional n, Eq n) => n -> Maybe Alteration_T

Transform fractional semitone alteration to Alteration_T, ie. allow quarter tones.

map fdiff_to_alteration [-0.5,0.5] == [Just QuarterToneFlat
                                      ,Just QuarterToneSharp]

alteration_raise_quarter_tone :: Alteration_T -> Maybe Alteration_T

Raise Alteration_T by a quarter tone where possible.

alteration_raise_quarter_tone Flat == Just QuarterToneFlat
alteration_raise_quarter_tone DoubleSharp == Nothing

alteration_lower_quarter_tone :: Alteration_T -> Maybe Alteration_T

Lower Alteration_T by a quarter tone where possible.

alteration_lower_quarter_tone Sharp == Just QuarterToneSharp
alteration_lower_quarter_tone DoubleFlat == Nothing

alteration_edit_quarter_tone :: (Fractional n, Eq n) => n -> Alteration_T -> Maybe Alteration_T

Edit Alteration_T by a quarter tone where possible, -0.5 lowers, 0 retains, 0.5 raises.

import Data.Ratio
alteration_edit_quarter_tone (-1 % 2) Flat == Just ThreeQuarterToneFlat

alteration_clear_quarter_tone :: Alteration_T -> Alteration_T

Simplify Alteration_T to standard 12ET by deleting quarter tones.

Data.List.nub (map alteration_clear_quarter_tone [minBound..maxBound])

alteration_symbol_tbl :: [(Alteration_T, Char)]

alteration_symbol :: Alteration_T -> Char

Unicode has entries for Musical Symbols in the range U+1D100 through U+1D1FF. The 3/4 symbols are non-standard, here they correspond to MUSICAL SYMBOL FLAT DOWN and MUSICAL SYMBOL SHARP UP.

map alteration_symbol [minBound .. maxBound] == "𝄫𝄭♭𝄳♮𝄲♯𝄰𝄪"

symbol_to_alteration :: Char -> Maybe Alteration_T

Inverse of alteration_symbol.

mapMaybe symbol_to_alteration "♭♮♯" == [Flat,Natural,Sharp]

symbol_to_alteration_iso :: Char -> Maybe Alteration_T

Variant of symbol_to_alteration that also recognises b for Flat and # for Sharp and x for double sharp.

alteration_iso_tbl :: [(Alteration_T, String)]

alteration_iso_m :: Alteration_T -> Maybe String

The ISO ASCII spellings for alterations. Naturals are written as the empty string.

mapMaybe alteration_iso_m [Flat .. Sharp] == ["b","","#"]
mapMaybe alteration_iso_m [DoubleFlat,DoubleSharp] == ["bb","x"]

alteration_iso :: Alteration_T -> String

The ISO ASCII spellings for alterations.

alteration_tonh :: Alteration_T -> String

The Tonhöhe ASCII spellings for alterations.

See http://www.musiccog.ohio-state.edu/Humdrum/guide04.html and http://lilypond.org/doc/v2.16/Documentation/notation/writing-pitches

map alteration_tonh [Flat .. Sharp] == ["es","eh","","ih","is"]

12-ET

note_alteration_to_pc :: (Note_T, Alteration_T) -> Maybe Int

note_alteration_to_pc_err :: (Note_T, Alteration_T) -> Int

note_alteration_ks :: [(Note_T, Alteration_T)]

Note & alteration sequence in key-signature spelling.

pc_note_alteration_ks_tbl :: Integral i => [((Note_T, Alteration_T), i)]

Table connecting pitch class number with note_alteration_ks.

pc_to_note_alteration_ks :: Integral i => i -> Maybe (Note_T, Alteration_T)

reverse_lookup of pc_note_alteration_ks_tbl.

Rational Alteration

type Alteration_R = (Rational, String)

Alteration given as a rational semitone difference and a string representation of the alteration.

alteration_r :: Alteration_T -> Alteration_R

Transform Alteration_T to Alteration_R.

let r = [(-1,"♭"),(0,"♮"),(1,"♯")]
in map alteration_t' [Flat,Natural,Sharp] == r