\subsubsection{Tempo}
\seclabel{tempo}
\begin{haskelllisting}
> module Haskore.Basic.Tempo where
> import qualified Haskore.Basic.Pitch as Pitch
> import Haskore.Basic.Duration (qn, en, sn, (%+), )
> import qualified Haskore.Music as Music
> import Haskore.Music(changeTempo, line, (+:+), (=:=), )
> import qualified Haskore.Melody as Melody
> import qualified Haskore.Basic.Duration as Dur
> import qualified Data.List as List
\end{haskelllisting}
\paragraph*{Set tempo.}
To make it easier to initialize the duration element
of a \code{PerformanceContext.T} (see \secref{performance}),
we can define a ``metronome'' function that,
given a standard metronome marking (in beats per minute)
and the note type associated with one beat (quarter note, eighth note, etc.)
generates the duration of one whole note:
\begin{haskelllisting}
> metro :: Fractional a => a -> Music.Dur -> a
> metro setting dur = 60 / (setting * Dur.toNumber dur)
\end{haskelllisting}
Additionally we define some common tempos and
some range of interpretation as in \figref{tempos}.
This means, the tempo Andante may vary between
\code{fst andanteRange} and \code{snd andanteRange}
beats per minute.
For example, \code{metro andante qn} creates a tempo of 92 quarter
notes per minute.
\begin{figure}
%larghissimoRange = ( 30, 40)
%adagiettoRange = ( 70, 80)
%allegrettoRange = (110,150)
\begin{haskelllisting}
> largoRange, larghettoRange, adagioRange, andanteRange,
> moderatoRange, allegroRange, prestoRange, prestissimoRange
> :: Fractional a => (a,a)
>
> largoRange = ( 40, 60)
> larghettoRange = ( 60, 68)
> adagioRange = ( 66, 76)
> andanteRange = ( 76,108)
> moderatoRange = (108,120)
> allegroRange = (120,168)
> prestoRange = (168,200)
> prestissimoRange = (200,208)
>
>
> largo, larghetto, adagio, andante, moderato, allegro,
> presto, prestissimo :: Fractional a => a
>
> average :: Fractional a => a -> a -> a
> average x y = (x+y)/2
>
> largo = uncurry average largoRange
> larghetto = uncurry average larghettoRange
> adagio = uncurry average adagioRange
> andante = uncurry average andanteRange
> moderato = uncurry average moderatoRange
> allegro = uncurry average allegroRange
> presto = uncurry average prestoRange
> prestissimo = uncurry average prestissimoRange
\end{haskelllisting}
\caption{Common names for tempo.}
\figlabel{tempos}
\end{figure}
% http://en.wikipedia.org/wiki/Tempo
% http://groups.google.de/groups?q=adagio+andante+allegro+bpm&hl=de&lr=&ie=UTF8&selm=25919385E77EA28%40storefull615.iap.bryant.webtv.net&rnum=5
\begin{figure*}
\centerline{
\includegraphics[height=2.0in]{Doc/Pics/poly}
}
\caption{Nested Polyrhythms}
\figlabel{polyrhythms}
\end{figure*}
\paragraph*{Polyrhythms.}
For some rhythmical ideas, consider first a simple \keyword{triplet} of
eighth notes; it can be expressed as ``\code{Tempo (3\%2) m}'', where
\code{m} is a line of three eighth notes. In fact \code{Tempo} can be
used to create quite complex rhythmical patterns. For example,
consider the ``nested polyrhythms'' shown in \figref{polyrhythms}.
They can be expressed quite naturally in Haskore as follows (note the
use of the \code{where} clause in \code{pr2} to capture recurring
phrases):
\begin{haskelllisting}
> pr1, pr2 :: Pitch.T -> Melody.T ()
> pr1 p =
> changeTempo (5%+6)
> (changeTempo (4%+3)
> (line [mkLn 1 p qn,
> changeTempo (3%+2)
> (line [mkLn 3 p en,
> mkLn 2 p sn,
> mkLn 1 p qn] ),
> mkLn 1 p qn]) +:+
> changeTempo (3%+2) (mkLn 6 p en))
>
> pr2 p =
> changeTempo (7%+6)
> (line [m1,
> changeTempo (5%+4) (mkLn 5 p en),
> m1,
> mkLn 2 p en])
> where m1 = changeTempo (5%+4) (changeTempo (3%+2) m2 +:+ m2)
> m2 = mkLn 3 p en
>
> mkLn :: Int -> Pitch.T -> Music.Dur -> Melody.T ()
> mkLn n p d = line (take n (List.repeat (Melody.note p d ())))
\end{haskelllisting}
To play polyrhythms \code{pr1} and \code{pr2} in parallel using middle C
and middle G, respectively, we would do the following (middle C is in
the 5th octave):
\begin{haskelllisting}
> pr12 :: Melody.T ()
> pr12 = pr1 (5, Pitch.C) =:= pr2 (5, Pitch.G)
\end{haskelllisting}
\paragraph*{Symbolic Meter Changes}
We can implement a notion of ``symbolic meter changes'' of the form
``oldnote = newnote'' (quarter note = dotted eighth, for example) by
defining a function:
\begin{haskelllisting}
> (=/=) :: Music.Dur -> Music.Dur -> Music.T note -> Music.T note
> old =/= new = changeTempo (new/old)
\end{haskelllisting}
Of course, using the new function is not much longer than using
\code{changeTempo} directly, but it may have nemonic value.