Music.Theory.Dynamic_Mark

Common music notation dynamic marks.

Documentation

data Dynamic_Mark_T

Enumeration of dynamic mark symbols.

Constructors

Niente

PPPPP

PPPP

PPP

PP

P

MP

MF

F

FF

FFF

FFFF

FFFFF

FP

SF

SFP

SFPP

SFZ

SFFZ

Instances

Bounded Dynamic_Mark_T

Methods

minBound :: Dynamic_Mark_T

maxBound :: Dynamic_Mark_T

Enum Dynamic_Mark_T

Methods

succ :: Dynamic_Mark_T -> Dynamic_Mark_T

pred :: Dynamic_Mark_T -> Dynamic_Mark_T

toEnum :: Int -> Dynamic_Mark_T

fromEnum :: Dynamic_Mark_T -> Int

enumFrom :: Dynamic_Mark_T -> [Dynamic_Mark_T]

enumFromThen :: Dynamic_Mark_T -> Dynamic_Mark_T -> [Dynamic_Mark_T]

enumFromTo :: Dynamic_Mark_T -> Dynamic_Mark_T -> [Dynamic_Mark_T]

enumFromThenTo :: Dynamic_Mark_T -> Dynamic_Mark_T -> Dynamic_Mark_T -> [Dynamic_Mark_T]

Eq Dynamic_Mark_T

Methods

(==) :: Dynamic_Mark_T -> Dynamic_Mark_T -> Bool

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

Ord Dynamic_Mark_T

Methods

compare :: Dynamic_Mark_T -> Dynamic_Mark_T -> Ordering

(<) :: Dynamic_Mark_T -> Dynamic_Mark_T -> Bool

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

(>) :: Dynamic_Mark_T -> Dynamic_Mark_T -> Bool

(>=) :: Dynamic_Mark_T -> Dynamic_Mark_T -> Bool

max :: Dynamic_Mark_T -> Dynamic_Mark_T -> Dynamic_Mark_T

min :: Dynamic_Mark_T -> Dynamic_Mark_T -> Dynamic_Mark_T

Show Dynamic_Mark_T

Methods

showsPrec :: Int -> Dynamic_Mark_T -> ShowS

show :: Dynamic_Mark_T -> String

showList :: [Dynamic_Mark_T] -> ShowS

dynamic_mark_midi :: (Num n, Enum n) => Dynamic_Mark_T -> Maybe n

Lookup MIDI velocity for Dynamic_Mark_T. The range is linear in 0-127.

let r = [0,6,17,28,39,50,61,72,83,94,105,116,127]
in mapMaybe dynamic_mark_midi [Niente .. FFFFF] == r

map dynamic_mark_midi [FP,SF,SFP,SFPP,SFZ,SFFZ] == replicate 6 Nothing

dynamic_mark_midi_err :: Integral n => Dynamic_Mark_T -> n

Error variant.

midi_dynamic_mark :: (Ord n, Num n, Enum n) => n -> Maybe Dynamic_Mark_T

Map midi velocity (0-127) to dynamic mark.

histogram (mapMaybe midi_dynamic_mark [0 .. 127])

dynamic_mark_db :: Fractional n => n -> Dynamic_Mark_T -> Maybe n

Translate fixed Dynamic_Mark_Ts to db amplitude over given range.

mapMaybe (dynamic_mark_db 120) [Niente,P,F,FFFFF] == [-120,-70,-40,0]
mapMaybe (dynamic_mark_db 60) [Niente,P,F,FFFFF] == [-60,-35,-20,0]

ampmidid :: Floating a => a -> a -> a

http://www.csounds.com/manual/html/ampmidid.html

import Sound.SC3.Plot
plotTable [map (ampmidid 20) [0 .. 127],map (ampmidid 60) [0 .. 127]]

amp_db :: Floating a => a -> a

JMcC (SC3) equation.

plotTable1 (map amp_db [0,0.005 .. 1])

db_amp :: Floating a => a -> a

JMcC (SC3) equation.

plotTable1 (map db_amp [-60,-59 .. 0])

data Hairpin_T

Enumeration of hairpin indicators.

Constructors

Crescendo

Diminuendo

End_Hairpin

Instances

Bounded Hairpin_T

Methods

minBound :: Hairpin_T

maxBound :: Hairpin_T

Enum Hairpin_T

Methods

succ :: Hairpin_T -> Hairpin_T

pred :: Hairpin_T -> Hairpin_T

toEnum :: Int -> Hairpin_T

fromEnum :: Hairpin_T -> Int

enumFrom :: Hairpin_T -> [Hairpin_T]

enumFromThen :: Hairpin_T -> Hairpin_T -> [Hairpin_T]

enumFromTo :: Hairpin_T -> Hairpin_T -> [Hairpin_T]

enumFromThenTo :: Hairpin_T -> Hairpin_T -> Hairpin_T -> [Hairpin_T]

Eq Hairpin_T

Methods

(==) :: Hairpin_T -> Hairpin_T -> Bool

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

Ord Hairpin_T

Methods

compare :: Hairpin_T -> Hairpin_T -> Ordering

(<) :: Hairpin_T -> Hairpin_T -> Bool

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

(>) :: Hairpin_T -> Hairpin_T -> Bool

(>=) :: Hairpin_T -> Hairpin_T -> Bool

max :: Hairpin_T -> Hairpin_T -> Hairpin_T

min :: Hairpin_T -> Hairpin_T -> Hairpin_T

Show Hairpin_T

Methods

showsPrec :: Int -> Hairpin_T -> ShowS

show :: Hairpin_T -> String

showList :: [Hairpin_T] -> ShowS

implied_hairpin :: Dynamic_Mark_T -> Dynamic_Mark_T -> Maybe Hairpin_T

The Hairpin_T implied by a ordered pair of Dynamic_Mark_Ts.

map (implied_hairpin MF) [MP,F] == [Just Diminuendo,Just Crescendo]

type Dynamic_Node = (Maybe Dynamic_Mark_T, Maybe Hairpin_T)

A node in a dynamic sequence.

empty_dynamic_node :: Dynamic_Node

The empty Dynamic_Node.

dynamic_sequence :: [Dynamic_Mark_T] -> [Dynamic_Node]

Calculate a Dynamic_Node sequence from a sequence of Dynamic_Mark_Ts.

dynamic_sequence [PP,MP,MP,PP] == [(Just PP,Just Crescendo)
                                  ,(Just MP,Just End_Hairpin)
                                  ,(Nothing,Just Diminuendo)
                                  ,(Just PP,Just End_Hairpin)]

delete_redundant_marks :: [Maybe Dynamic_Mark_T] -> [Maybe Dynamic_Mark_T]

Delete redundant (unaltered) dynamic marks.

let s = [Just P,Nothing,Just P,Just P,Just F]
in delete_redundant_marks s == [Just P,Nothing,Nothing,Nothing,Just F]

dynamic_sequence_sets :: [Maybe Dynamic_Mark_T] -> [Maybe Dynamic_Node]

Variant of dynamic_sequence for sequences of Dynamic_Mark_T with holes (ie. rests). Runs delete_redundant_marks.

let r = [Just (Just P,Just Crescendo),Just (Just F,Just End_Hairpin)
        ,Nothing,Just (Just P,Nothing)]
in dynamic_sequence_sets [Just P,Just F,Nothing,Just P] == r

let s = [Just P,Nothing,Just P]
in dynamic_sequence_sets s = [Just (Just P,Nothing),Nothing,Nothing]

apply_dynamic_node :: (a -> Dynamic_Mark_T -> a) -> (a -> Hairpin_T -> a) -> Dynamic_Node -> a -> a

Apply Hairpin_T and Dynamic_Mark_T functions in that order as required by Dynamic_Node.

let f _ x = show x
in apply_dynamic_node f f (Nothing,Just Crescendo) undefined

ASCII

dynamic_mark_ascii :: Dynamic_Mark_T -> String

ASCII pretty printer for Dynamic_Mark_T.

hairpin_ascii :: Hairpin_T -> String

ASCII pretty printer for Hairpin_T.

dynamic_node_ascii :: Dynamic_Node -> String

ASCII pretty printer for Dynamic_Node.

dynamic_sequence_ascii :: [Dynamic_Node] -> String

ASCII pretty printer for Dynamic_Node sequence.