\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) -- as slow as reasonably possible %adagiettoRange = ( 70, 80) -- slightly faster than adagio %allegrettoRange = (110,150) -- not quite allegro \begin{haskelllisting}

    > largoRange, larghettoRange, adagioRange, andanteRange,
    >   moderatoRange, allegroRange, prestoRange, prestissimoRange
    >     :: Fractional a => (a,a)
    >
    > largoRange       = ( 40, 60) -- slowly and broadly
    > larghettoRange   = ( 60, 68) -- a little less slow than largo
    > adagioRange      = ( 66, 76) -- slowly
    > andanteRange     = ( 76,108) -- at a walking pace
    > moderatoRange    = (108,120) -- at a moderate tempo
    > allegroRange     = (120,168) -- quickly
    > prestoRange      = (168,200) -- fast
    > prestissimoRange = (200,208) -- very fast
    >
    >
    > 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=UTF-8&selm=25919-385E77EA-28%40storefull-615.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.