synthesizer-dimensional 0.8.1.1 → 0.9

raw patch · 21 files changed

+348/−251 lines, 21 filesdep ~randomdep ~semigroupsdep ~storablevectorPVP ok

version bump matches the API change (PVP)

Dependency ranges changed: random, semigroups, storablevector, synthesizer-core, utility-ht

API changes (from Hackage documentation)

Files

• src/Synthesizer/Dimensional/Amplitude/Control.hs +1/−1
• src/Synthesizer/Dimensional/Amplitude/Cut.hs +5/−5
• src/Synthesizer/Dimensional/Causal/Process.hs +5/−5
• src/Synthesizer/Dimensional/ChunkySize/Signal.hs +2/−2
• src/Synthesizer/Dimensional/Cyclic/Analysis.hs +1/−1
• src/Synthesizer/Dimensional/Cyclic/Signal.hs +2/−2
• src/Synthesizer/Dimensional/Duration.hs +38/−0
• src/Synthesizer/Dimensional/Process.hs +0/−27
• src/Synthesizer/Dimensional/Rate/Cut.hs +12/−17
• src/Synthesizer/Dimensional/Rate/Dirac.hs +1/−1
• src/Synthesizer/Dimensional/Rate/Filter.hs +29/−17
• src/Synthesizer/Dimensional/RateAmplitude/Cut.hs +86/−44
• src/Synthesizer/Dimensional/RateAmplitude/Demonstration.hs +41/−34
• src/Synthesizer/Dimensional/RateAmplitude/Filter.hs +15/−14
• src/Synthesizer/Dimensional/RateAmplitude/Instrument.hs +13/−9
• src/Synthesizer/Dimensional/RateAmplitude/Piece.hs +25/−29
• src/Synthesizer/Dimensional/RateAmplitude/Rain.hs +19/−17
• src/Synthesizer/Dimensional/RateAmplitude/Traumzauberbaum.hs +13/−8
• src/Synthesizer/Dimensional/Signal.hs +1/−1
• src/Synthesizer/Dimensional/Signal/Private.hs +28/−8
• synthesizer-dimensional.cabal +11/−9

@@ -68,7 +68,7 @@  {-# INLINE piecewiseConstantGeneric #-} piecewiseConstantGeneric ::-   (SigG.Write sig y) =>+   (SigG.Produce sig y) =>    SigA.T rate amp (PC.T y) ->    SigA.T rate amp (sig y) piecewiseConstantGeneric =

@@ -301,7 +301,7 @@ zip ::    (Ord y, Field.C y, Dim.C u,     Module.C y yv0, Module.C y yv1,-    SigG.Read sig yv0, SigG.Transform sig yv1, SigG.Transform sig (yv0,yv1)) =>+    SigG.Consume sig yv0, SigG.Transform sig yv1, SigG.Transform sig (yv0,yv1)) =>    Signal s u y sig yv0 -> Signal s u y sig yv1 -> Signal s u y sig (yv0,yv1) zip =    merge (SigG.zipWithState (,)) . SigA.restore@@ -310,7 +310,7 @@ zipVolume ::    (Field.C y, Dim.C u,     Module.C y yv0, Module.C y yv1,-    SigG.Read sig yv0, SigG.Transform sig yv1, SigG.Transform sig (yv0,yv1)) =>+    SigG.Consume sig yv0, SigG.Transform sig yv1, SigG.Transform sig (yv0,yv1)) =>    DN.T u y ->    Signal s u y sig yv0 -> Signal s u y sig yv1 -> Signal s u y sig (yv0,yv1) zipVolume vol =@@ -350,7 +350,7 @@ zip3 ::    (Ord y, Field.C y, Dim.C u,     Module.C y yv0, Module.C y yv1, Module.C y yv2,-    SigG.Read sig yv0, SigG.Read sig yv1,+    SigG.Consume sig yv0, SigG.Consume sig yv1,     SigG.Transform sig yv2, SigG.Transform sig (yv0, yv1, yv2)) =>    Signal s u y sig yv0 -> Signal s u y sig yv1 -> Signal s u y sig yv2 ->    Signal s u y sig (yv0,yv1,yv2)@@ -363,7 +363,7 @@ zip3Volume ::    (Field.C y, Dim.C u,     Module.C y yv0, Module.C y yv1, Module.C y yv2,-    SigG.Read sig yv0, SigG.Read sig yv1,+    SigG.Consume sig yv0, SigG.Consume sig yv1,     SigG.Transform sig yv2, SigG.Transform sig (yv0, yv1, yv2)) =>    DN.T u y ->    Signal s u y sig yv0 -> Signal s u y sig yv1 -> Signal s u y sig yv2 ->@@ -382,7 +382,7 @@ selectBool ::    (Ord y, Field.C y, Dim.C u,     Module.C y yv,-    SigG.Read sig yv,+    SigG.Consume sig yv,     SigG.Transform sig Bool, SigG.Transform sig yv) =>    Signal s u y sig yv {- ^ False -} ->    Signal s u y sig yv {- ^ True -} ->

@@ -142,7 +142,7 @@  {-# INLINE applyFst #-} applyFst ::-   (SigG.Read sig yv) =>+   (SigG.Consume sig yv) =>    T s (Sample.T amp yv, restSampleIn) restSampleOut ->    SigA.T (Rate.Phantom s) amp (sig yv) ->    T s restSampleIn restSampleOut@@ -150,7 +150,7 @@  {-# INLINE applyFlatFst #-} applyFlatFst ::-   (Flat.C yv amp, SigG.Read sig yv) =>+   (Flat.C yv amp, SigG.Consume sig yv) =>    T s (Sample.T (Amp.Flat yv) yv, restSampleIn) restSampleOut ->    SigA.T (Rate.Phantom s) amp (sig yv) ->    T s restSampleIn restSampleOut@@ -160,7 +160,7 @@  {-# INLINE feedFst #-} feedFst ::-   (SigG.Read sig yv) =>+   (SigG.Consume sig yv) =>    SigA.T (Rate.Phantom s) amp (sig yv) ->    T s restSample (Sample.T amp yv, restSample) feedFst x =@@ -170,7 +170,7 @@  {-# INLINE applySnd #-} applySnd ::-   (SigG.Read sig yv) =>+   (SigG.Consume sig yv) =>    T s (restSampleIn, Sample.T amp yv) restSampleOut ->    SigA.T (Rate.Phantom s) amp (sig yv) ->    T s restSampleIn restSampleOut@@ -178,7 +178,7 @@  {-# INLINE feedSnd #-} feedSnd ::-   (SigG.Read sig yv) =>+   (SigG.Consume sig yv) =>    SigA.T (Rate.Phantom s) amp (sig yv) ->    T s restSample (restSample, Sample.T amp yv) feedSnd x =

@@ -32,7 +32,7 @@  {-# INLINE store #-} store ::-   (SigC.Write sig yv) =>+   (SigC.Produce sig yv) =>    Size s ->    Signal s amp (Sig.T yv) ->    Signal s amp (sig yv)@@ -44,7 +44,7 @@ Move to a new module Analysis in order to be consistent with other Analysis modules? -} {-# INLINE length #-}-length :: (CutC.Read sig) =>+length :: (CutC.Consume sig) =>    Signal s amp sig ->    Size s length =

@@ -39,7 +39,7 @@ {- * Positions -}  {-# INLINE period #-}-period :: (Field.C t, Dim.C u, CutG.Read body) =>+period :: (Field.C t, Dim.C u, CutG.Consume body) =>    SigA.T (Rate.Dimensional u t) amp (SigC.T body) ->    DN.T u t period = makePhysicalPeriod (fromIntegral . CutG.length)

@@ -77,10 +77,10 @@ -} {-# INLINE fromSignal #-} fromSignal ::-   (Additive.C yv, SigG.Write sig yv) =>+   (Additive.C yv, SigG.Produce sig yv) =>    Int -> sig yv -> T (sig yv) fromSignal n  =-   fromPeriod . Cyclic.fromSignal SigG.defaultLazySize n+   fromPeriod . Cyclic.fromSignal n  {- | Convert a cyclic signal to a straight signal containing a loop.

@@ -0,0 +1,38 @@+module Synthesizer.Dimensional.Duration where++import qualified Synthesizer.Dimensional.Process as Proc++import Control.Applicative ((<$>))++import qualified Algebra.ToInteger     as ToInteger+import qualified Algebra.Field         as Field+import qualified Algebra.RealRing      as RealRing++import qualified Number.DimensionTerm        as DN+import qualified Algebra.DimensionTerm       as Dim+import Number.DimensionTerm ((*&))++import qualified NumericPrelude.Numeric as NP+++{- |+This type is intended to hold a duration+which is an integer with respect to the sampling rate.+It allows to do exact duration computations, i.e. without rounding errors.+The trade-off is that it is bound to a certain sampling rate+and you must convert to different sampling rates explicitly.+-}+newtype T s i = Cons i++fromTime ::+   (Dim.C u, ToInteger.C i, RealRing.C t) =>+   DN.T u t -> Proc.T s u t (T s i)+fromTime t = Cons . RealRing.round <$> Proc.toTimeScalar t++toTime ::+   (Dim.C u, ToInteger.C i, Field.C t) =>+   Proc.T s u t (T s i -> DN.T u t)+toTime =+   (\sampleRate (Cons dur) -> NP.fromIntegral dur *& DN.unrecip sampleRate)+   <$>+   Proc.getSampleRate

@@ -27,7 +27,6 @@       run, {-share,-} withParam, getSampleRate,       toTimeScalar,    toFrequencyScalar,       toTimeDimension, toFrequencyDimension,-      intFromTime, intFromTime98,       DimensionGradient, toGradientScalar,       loop, pure,       ($:), ($::), ($^), ($#),@@ -40,7 +39,6 @@  import Number.DimensionTerm ((*&), (&/&), ) -- ((&*&), ) -import qualified Algebra.RealRing      as RealRing import qualified Algebra.Field          as Field import qualified Algebra.Ring           as Ring @@ -50,7 +48,6 @@ import qualified Control.Applicative as App import Control.Applicative (Applicative) -import NumericPrelude.Numeric import NumericPrelude.Base  import qualified Prelude as P@@ -172,27 +169,3 @@ (~*&) = toTimeScalar (~/&) = toFrequencyScalar -}---checkedChunkSize ::-   String -> Int -> Int-checkedChunkSize funcName cs =-   if cs>0-     then cs-     else error $ funcName ++ ": negative chunkSize"--intFromTime ::-   (RealRing.C t, Dim.C u) =>-   String ->-   DN.T u t ->-   T s u t Int-intFromTime funcName t =-   fmap (checkedChunkSize funcName . RealRing.ceiling) $ toTimeScalar t--intFromTime98 ::-   (Ring.C t, RealFrac t, Dim.C u) =>-   String ->-   DN.T u t ->-   T s u t Int-intFromTime98 funcName t =-   fmap (checkedChunkSize funcName . P.ceiling) $ toTimeScalar t

@@ -12,13 +12,13 @@    concat, append, ) where  import qualified Synthesizer.Dimensional.Process as Proc+import qualified Synthesizer.Dimensional.Duration as Dur import qualified Synthesizer.Dimensional.Rate as Rate import qualified Synthesizer.Dimensional.Amplitude as Amp  import qualified Synthesizer.Dimensional.Signal.Private as SigA import qualified Synthesizer.Generic.Cut as CutG -import qualified Number.DimensionTerm        as DN import qualified Algebra.DimensionTerm       as Dim  -- import qualified Number.NonNegative     as NonNeg@@ -44,36 +44,31 @@ -} {-# INLINE splitAt #-} splitAt :: (CutG.Transform sig, RealRing.C t, Dim.C u) =>-   DN.T u t ->    Proc.T s u t-      (Signal s amp sig ->+      (Dur.T s Int ->+       Signal s amp sig ->        (Signal s amp sig, Signal s amp sig))-splitAt t' =-   flip fmap (Proc.toTimeScalar t') $-   \t x ->-      let (y,z) = CutG.splitAt (RealRing.round t) $ SigA.body x+splitAt =+   Proc.pure $ \(Dur.Cons t) x ->+      let (y,z) = CutG.splitAt t $ SigA.body x       in  (SigA.replaceBody y x,            SigA.replaceBody z x)  {-# INLINE take #-} take :: (CutG.Transform sig, RealRing.C t, Dim.C u) =>-   DN.T u t ->    Proc.T s u t-      (Signal s amp sig ->+      (Dur.T s Int ->+       Signal s amp sig ->        Signal s amp sig)-take t' =-   flip fmap (Proc.toTimeScalar t') $-   \t -> SigA.processBody (CutG.take (RealRing.round t))+take = Proc.pure $ \(Dur.Cons t) -> SigA.processBody (CutG.take t)  {-# INLINE drop #-} drop :: (CutG.Transform sig, RealRing.C t, Dim.C u) =>-   DN.T u t ->    Proc.T s u t-      (Signal s amp sig ->+      (Dur.T s Int ->+       Signal s amp sig ->        Signal s amp sig)-drop t' =-   flip fmap (Proc.toTimeScalar t') $-   \t -> SigA.processBody (CutG.drop (RealRing.round t))+drop = Proc.pure $ \(Dur.Cons t) -> SigA.processBody (CutG.drop t)   {-# INLINE concat #-}

@@ -48,7 +48,7 @@    mempty = Cons Mn.mempty    mappend (Cons x) (Cons y) = Cons (Mn.mappend x y) -instance Cut.Read (sig Bool) => Cut.Read (T s sig) where+instance Cut.Consume (sig Bool) => Cut.Consume (T s sig) where    {-# INLINE null #-}    null = Cut.null . decons    {-# INLINE length #-}

@@ -22,6 +22,7 @@     {- ** Delay -}    delay,+   delayStorable,    phaseModulation,    phaser,    phaserStereo,@@ -64,6 +65,7 @@ import qualified Synthesizer.Dimensional.Amplitude.Filter       as FiltV import qualified Synthesizer.Dimensional.Process as Proc import qualified Synthesizer.Dimensional.Amplitude as Amp+import qualified Synthesizer.Dimensional.Duration as Dur import qualified Synthesizer.Dimensional.Rate as Rate  import Synthesizer.Dimensional.Process@@ -90,6 +92,7 @@ import qualified Synthesizer.Plain.Filter.Recursive.Chebyshev   as Cheby import qualified Synthesizer.Plain.Filter.Recursive             as FiltRec +import qualified Synthesizer.Storable.Filter.NonRecursive as FiltNRSt import qualified Synthesizer.Storable.Signal as SigSt import qualified Synthesizer.Generic.Filter.Recursive.Comb as Comb @@ -115,6 +118,8 @@ -- import qualified Algebra.VectorSpace    as VectorSpace import qualified Algebra.Module         as Module +import qualified Data.StorableVector.Lazy.Typed as SVT+ import Foreign.Storable (Storable, )  -- import qualified Data.List as List@@ -210,23 +215,31 @@                  toStorable)  {-# INLINE delay #-}-delay :: (Additive.C yv, RealRing.C t, Dim.C u, SigG.Write sig yv) =>-      DN.T u t-   -> Proc.T s u t (-        SigA.T (Rate.Phantom s) amp (sig yv)+delay :: (Additive.C yv, RealRing.C t, Dim.C u, SigG.Produce sig yv) =>+   Proc.T s u t (+        Dur.T s Int+     -> SigA.T (Rate.Phantom s) amp (sig yv)      -> SigA.T (Rate.Phantom s) amp (sig yv))-delay time =-   flip fmap (toTimeScalar time) $-   \t -> SigA.processBody (DelayG.static (round t))+delay =+   Proc.pure $ \(Dur.Cons t) -> SigA.processBody (DelayG.static t) +{-# INLINE delayStorable #-}+delayStorable :: (Additive.C yv, RealRing.C t, Dim.C u, Storable yv) =>+   Proc.T s u t (+        Dur.T s Int+     -> SigA.T (Rate.Phantom s) amp (SigSt.T yv)+     -> SigA.T (Rate.Phantom s) amp (SigSt.T yv))+delayStorable =+   Proc.pure $ \(Dur.Cons t) -> SigA.processBody (FiltNRSt.delay t) + {-# INLINE toStorable #-}-toStorable :: (Storable a) => Sig.T a -> SigSt.T a-toStorable = Sig.toStorableSignal SigSt.defaultChunkSize+toStorable :: (Storable a) => Sig.T a -> SVT.DefaultVector a+toStorable = SigG.fromState  {-# INLINE fromStorable #-}-fromStorable :: (Storable a) => SigSt.T a -> Sig.T a-fromStorable = Sig.fromStorableSignal+fromStorable :: (Storable a) => SVT.DefaultVector a -> Sig.T a+fromStorable = SigG.toState  {-# INLINE phaseModulation #-} phaseModulation ::@@ -258,7 +271,7 @@ {-# INLINE phaseModulationGeneric #-} phaseModulationGeneric ::    (Additive.C yv, RealField.C q, Dim.C u,-    SigG.Transform sig q, SigG.Transform sig yv, SigG.Write sig yv) =>+    SigG.Transform sig q, SigG.Transform sig yv, SigG.Produce sig yv) =>       Interpolation.T q yv    -> DN.T u q           {- ^ minimal deviation from current time, usually negative -}@@ -590,11 +603,10 @@ {- | Infinitely many equi-delayed exponentially decaying echos. -} {-# INLINE comb #-} comb :: (RealRing.C t, Module.C y yv, Dim.C u, Storable yv) =>-   DN.T u t -> y -> Proc.T s u t (Signal s amp yv -> Signal s amp yv)-comb time gain =-   do t <- toTimeScalar time-      return $ SigA.processBody-         (fromStorable . Comb.run (round t) gain . toStorable)+   y -> Proc.T s u t (Dur.T s Int -> Signal s amp yv -> Signal s amp yv)+comb gain =+   return $ \(Dur.Cons t) ->+      SigA.processBody (fromStorable . Comb.run t gain . toStorable)   -- * auxiliary functions

@@ -23,7 +23,7 @@    zip3,        zip3Volume,    mergeStereo, mergeStereoVolume,    arrange,     arrangeVolume,-   arrangeStorableVolume,+   arrangeStorableVolume, arrangeStorableTypedVolume,   ) where  import qualified Synthesizer.Dimensional.Amplitude.Cut as CutV@@ -31,18 +31,19 @@ import qualified Synthesizer.Storable.Cut as CutSt import qualified Synthesizer.Storable.Signal as SigSt import qualified Synthesizer.State.Cut as CutS-import qualified Synthesizer.State.Signal as Sig+import qualified Synthesizer.State.Signal as SigS import qualified Synthesizer.Generic.Signal as SigG  import qualified Synthesizer.Frame.Stereo as Stereo import Foreign.Storable (Storable, )  import qualified Synthesizer.Dimensional.Amplitude as Amp+import qualified Synthesizer.Dimensional.Duration as Dur import qualified Synthesizer.Dimensional.Rate as Rate  import qualified Synthesizer.Dimensional.Signal.Private as SigA import qualified Synthesizer.Dimensional.Process as Proc-import Synthesizer.Dimensional.Process (($#), toTimeScalar, intFromTime98, )+import Synthesizer.Dimensional.Process (($#), toTimeScalar, ) import Synthesizer.Dimensional.Signal.Private (toAmplitudeScalar, )  import qualified Number.DimensionTerm        as DN@@ -58,39 +59,37 @@ import qualified Algebra.RealRing           as RealRing import qualified Algebra.Field               as Field import qualified Algebra.Ring                as Ring+import qualified Algebra.Additive            as Additive +import qualified Data.StorableVector.Lazy.Typed as SVT import qualified Data.List as List -import NumericPrelude.Base ((.), ($), Ord, (<=), map, return, )+import NumericPrelude.Base ((.), ($), Ord, (<=), map, fmap, return, ) -- import NumericPrelude.Numeric-import Prelude (RealFrac, )+import Prelude (Int, RealFrac, )   {- * dissection -}  {-# INLINE splitAt #-} splitAt :: (RealRing.C t, Dim.C u, Dim.C v, Storable yv) =>-   DN.T u t -> Proc.T s u t (SigA.R s v y yv -> (SigA.R s v y yv, SigA.R s v y yv))-splitAt t' =-   do t <- toTimeScalar t'-      return $ \x ->-         let (ss0,ss1) = Sig.splitAt (RealRing.round t) (SigA.body x)-         in  (SigA.replaceBody ss0 x,-              SigA.replaceBody ss1 x)+   Proc.T s u t (Dur.T s Int -> SigA.R s v y yv -> (SigA.R s v y yv, SigA.R s v y yv))+splitAt =+   CutR.splitAt  {-# INLINE take #-} take :: (RealRing.C t, Dim.C u, Dim.C v) =>-   DN.T u t -> Proc.T s u t (SigA.R s v y yv -> SigA.R s v y yv)-take t' =-   CutR.take t'-   -- fmap (fst.) $ splitAt t+   Proc.T s u t (Dur.T s Int -> SigA.R s v y yv -> SigA.R s v y yv)+take =+   CutR.take+   -- fmap (fst.) $ splitAt  {-# INLINE drop #-} drop :: (RealRing.C t, Dim.C u, Dim.C v) =>-   DN.T u t -> Proc.T s u t (SigA.R s v y yv -> SigA.R s v y yv)-drop t' =-   CutR.drop t'-   -- fmap (snd.) $ splitAt t+   Proc.T s u t (Dur.T s Int -> SigA.R s v y yv -> SigA.R s v y yv)+drop =+   CutR.drop+   -- fmap (snd.) $ splitAt  {-# INLINE takeUntilPause #-} takeUntilPause ::@@ -242,19 +241,21 @@     RealFrac t,     Ord y, Field.C y, Dim.C v,     Module.C y yv, Storable yv) =>-      DN.T u t  {- ^ Maximum chunk size -}-   -> DN.T u t  {- ^ Unit of the time values in the time ordered list. -}+      DN.T u t  {- ^ Unit of the time values in the time ordered list. -}    -> Proc.T s u t (-         EventList.T (NonNeg.T t) (SigA.R s v y yv)+         Dur.T s Int+               {- v Maximum chunk size -}+      -> EventList.T (NonNeg.T t) (SigA.R s v y yv)                {- v A list of pairs: (relative start time, signal part),                     The start time is relative                     to the start time of the previous event. -}       -> SigA.R s v y yv)                {- ^ The mixed signal. -}-arrange chunkSize unit' =+arrange unit' =+   Proc.withParam $ \chunkSize ->    Proc.withParam $ \sched ->       let amp = List.maximum (map SigA.actualAmplitude (EventList.getBodies sched))-      in  arrangeVolume chunkSize amp unit' $# sched+      in  (arrangeVolume amp unit' $# chunkSize) $# sched   {- |@@ -268,30 +269,31 @@     RealFrac t,     Field.C y, Dim.C v,     Module.C y yv, Storable yv) =>-      DN.T u t  {- ^ Maximum chunk size -}-   -> DN.T v y  {- ^ Output volume -}+      DN.T v y  {- ^ Output volume -}    -> DN.T u t  {- ^ Unit of the time values in the time ordered list. -}    -> Proc.T s u t (-         EventList.T (NonNeg.T t) (SigA.R s v y yv)+         Dur.T s Int+            {- v Maximum chunk size -}+      -> EventList.T (NonNeg.T t) (SigA.R s v y yv)             {- v A list of pairs: (relative start time, signal part),                  The start time is relative                  to the start time of the previous event. -}       -> SigA.R s v y yv)             {- ^ The mixed signal. -}-arrangeVolume chunkSize' amp unit' =+arrangeVolume amp unit' =    do unit <- toTimeScalar unit'-      chunkSize <--         intFromTime98 "Dimensional.Cut.arrangeStorableVolume" chunkSize'-      return $ \sched ->-         let z =+      return $ \(Dur.Cons chunkSize) sched' ->+         let sched =+                EventList.mapBody+                   (SigS.toStorableSignal (SigSt.chunkSize chunkSize) .+                    SigA.vectorSamples (toAmplitudeScalar z))+                sched'+             z =                 SigA.fromBody amp $                 SigG.toState $                 CutSt.arrange (SigSt.chunkSize chunkSize) $                  EventList.resample-                   (NonNeg.fromNumberMsg "Dimensional.Cut.arrangeVolume" unit) $-                EventList.mapBody-                   (SigG.fromState (SigG.LazySize chunkSize) .-                    SigA.vectorSamples (toAmplitudeScalar z))+                   (NonNeg.fromNumberMsg "Dimensional.Cut.arrangeVolume" unit)                 sched          in  z @@ -301,22 +303,21 @@     RealFrac t,     Field.C y, Dim.C v,     Module.C y yv, Storable yv) =>-      DN.T u t  {- ^ Maximum chunk size -}-   -> DN.T v y  {- ^ Output volume -}+      DN.T v y  {- ^ Output volume -}    -> DN.T u t  {- ^ Unit of the time values in the time ordered list. -}    -> Proc.T s u t (-         EventList.T (NonNeg.T t)+         Dur.T s Int+            {- v Maximum chunk size -}+      -> EventList.T (NonNeg.T t)             (SigA.T (Rate.Phantom s) (Amp.Dimensional v y) (SigSt.T yv))             {- v A list of pairs: (relative start time, signal part),                  The start time is relative                  to the start time of the previous event. -}       -> (SigA.T (Rate.Phantom s) (Amp.Dimensional v y) (SigSt.T yv)))             {- ^ The mixed signal. -}-arrangeStorableVolume chunkSize' amp unit' =+arrangeStorableVolume amp unit' =    do unit <- toTimeScalar unit'-      chunkSize <--         intFromTime98 "Dimensional.Cut.arrangeStorableVolume" chunkSize'-      return $ \sched ->+      return $ \(Dur.Cons chunkSize) sched ->          let z =                 SigA.fromBody amp $                 CutSt.arrange (SigSt.chunkSize chunkSize) $@@ -324,5 +325,46 @@                    (NonNeg.fromNumberMsg "Dimensional.Cut.arrangeStorableVolume" unit) $                 EventList.mapBody                    (SigA.vectorSamples (toAmplitudeScalar z))+                sched+         in  z++++-- ToDo: move to synthesizer-core?+arrangeTyped ::+   (SVT.Size size, Additive.C a, Storable a) =>+   SVT.ChunkSize size ->+   EventList.T NonNeg.Int (SVT.Vector size a) -> SVT.Vector size a+arrangeTyped chunkSize =+   SVT.fromVectorLazy .+   CutSt.arrange (SVT.lazyChunkSize chunkSize) .+   fmap SVT.toVectorLazy++{-# INLINE arrangeStorableTypedVolume #-}+arrangeStorableTypedVolume ::+   (Ring.C t, Dim.C u,+    RealFrac t,+    Field.C y, Dim.C v,+    Module.C y yv, Storable yv,+    SVT.Size size) =>+      DN.T v y  {- ^ Output volume -}+   -> DN.T u t  {- ^ Unit of the time values in the time ordered list. -}+   -> Proc.T s u t (+         EventList.T (NonNeg.T t)+            (SigA.T (Rate.Phantom s) (Amp.Dimensional v y) (SVT.Vector size yv))+            {- v A list of pairs: (relative start time, signal part),+                 The start time is relative+                 to the start time of the previous event. -}+      -> (SigA.T (Rate.Phantom s) (Amp.Dimensional v y) (SVT.Vector size yv)))+            {- ^ The mixed signal. -}+arrangeStorableTypedVolume amp unit' =+   do unit <- toTimeScalar unit'+      return $ \sched ->+         let z =+                SigA.fromBody amp $+                arrangeTyped SVT.chunkSize $+                EventList.resample+                   (NonNeg.fromNumberMsg "Dimensional.Cut.arrangeStorableTypedVolume" unit) $+                EventList.mapBody (SigA.vectorSamples (toAmplitudeScalar z))                 sched          in  z

@@ -37,6 +37,7 @@  import qualified Synthesizer.Dimensional.Wave as WaveD import qualified Synthesizer.Dimensional.Amplitude as Amp+import qualified Synthesizer.Dimensional.Duration as Dur import qualified Synthesizer.Dimensional.Rate as Rate import Synthesizer.Dimensional.Wave ((&*~), ) @@ -180,6 +181,9 @@                    (DN.frequency 1, DN.frequency 1000)))  +second :: (RealField.C q) => q -> Proc.T s Dim.Time q (Dur.T s Int)+second t = Dur.fromTime $ DN.time t+ {-# INLINE airplane #-} airplane ::    (RealField.C q, Trans.C q, Module.C q q, Random q, Storable q) =>@@ -188,7 +192,7 @@    SigA.share       (Noise.white (DN.frequency 20000) (DN.voltage 0.2))       (\noise ->-          Cut.take (DN.time 5) $: (Disp.mix+          Cut.take $: second 5 $: (Disp.mix              $: noise              $: (Filt.frequencyModulation IpMod.linear                     $- DN.scalar 1.001@@ -229,7 +233,7 @@ windStereo =    SigA.share       wind-      (\w -> Cut.mergeStereo $: w $: (Cut.drop (DN.time 0.2) $: w))+      (\w -> Cut.mergeStereo $: w $: (Cut.drop $: second 0.2 $: w))   @@ -370,7 +374,7 @@       $- DN.frequency 4       $: (Cut.concatVolume (DN.scalar 1) $:           mapM (\p ->-             Cut.take (DN.time (1/6))+             Cut.take $: second (1/6)               $: Ctrl.constant (DN.scalar (fromInteger p / 12)))               (randomRs (0,24) (mkStdGen 3141))) @@ -434,7 +438,9 @@    Proc.T s Dim.Time q (SigA.R s Dim.Voltage q q) bubbles =    let delay = 0.24-   in  Filt.comb (DN.time delay) (0.5 `asTypeOf` delay) $:+   in  Filt.comb (0.5 `asTypeOf` delay)+       $: Dur.fromTime (DN.time delay)+       $:        (Osci.freqMod (DN.voltage 0.5 &*~ Wave.sine) zero $:          (DispA.mapExponential 0.5 (DN.frequency 440) $^             (Disp.mix@@ -455,8 +461,9 @@                (Disp.mix                   $: Osci.static (DN.scalar 1.5 &*~ Wave.saw) zero (DN.frequency 0.5)                   $: Osci.static (DN.scalar 0.5 &*~ Wave.saw) zero f))-   in  Filt.comb (DN.time delay) (0.5 `asTypeOf` delay) $:-          (Cut.mergeStereo+   in  Filt.comb (0.5 `asTypeOf` delay)+       $: Dur.fromTime (DN.time delay)+       $: (Cut.mergeStereo               $: channel (DN.frequency 10)               $: channel (DN.frequency 9.23)) @@ -466,8 +473,8 @@    (RealField.C q, Trans.C q, Module.C q q, Random q, Storable q) =>    Proc.T s Dim.Time q (SigA.R s Dim.Voltage q q) dampedEcho =-   FiltA.combProc (DN.time 0.2)-            (Filt.firstOrderLowpass $- DN.frequency 1000)+   FiltA.combProc (Filt.firstOrderLowpass $- DN.frequency 1000)+      $: Dur.fromTime (DN.time 0.2)       $: (Filt.envelope             $: CtrlR.exponential2 (DN.time 0.1)             $: Osci.static (DN.voltage 1 &*~ Wave.saw) zero (DN.frequency 440))@@ -495,7 +502,7 @@    (RealField.C q, Trans.C q) =>    Proc.T s Dim.Time q (SigA.T (Rate.Phantom s) (Amp.Flat q) (Sig.T q)) staticSine =-   CutR.take (DN.time 10)+   CutR.take $: second 10       $: (Osci.static (WaveD.flat Wave.sine) zero (DN.frequency 440))  @@ -637,7 +644,7 @@    in  renderToAIFF        File.renderTimeVoltageMonoDoubleToInt16        subName-       (Cut.take (DN.time 10) $: fmap filterSelect sound)+       (Cut.take $: second 10 $: fmap filterSelect sound)  renderFilter ::    (Interpol.C Double param,@@ -708,9 +715,9 @@              File.renderTimeVoltageStereoDoubleToInt16              name (fromSound sound)) $ -         ("bass-filter", Sound (Cut.take (DN.time 15) $: bassFilter)) :-         ("wind",        Sound (Cut.take (DN.time 10) $: windStereo)) :-         ("bubbles",     Sound (Cut.take (DN.time 10) $: bubblesStereo)) :+         ("bass-filter", Sound (Cut.take $: second 15 $: bassFilter)) :+         ("wind",        Sound (Cut.take $: second 10 $: windStereo)) :+         ("bubbles",     Sound (Cut.take $: second 10 $: bubblesStereo)) :          []        mapM_@@ -775,38 +782,38 @@          but we leave them for demonstration purposes.          -}          ("moog-saw-direct",-                         Sound (Cut.take (DN.time 10) $: moogSawDirect)) :+                         Sound (Cut.take $: second 10 $: moogSawDirect)) :          ("moog-saw-causal",-                         Sound (Cut.take (DN.time 10) $: moogSawCausal)) :+                         Sound (Cut.take $: second 10 $: moogSawCausal)) :           ("allpass-phaser-direct",-                         Sound (Cut.take (DN.time 10) $: allpassPhaserDirect)) :+                         Sound (Cut.take $: second 10 $: allpassPhaserDirect)) :          ("allpass-phaser-causal",-                         Sound (Cut.take (DN.time 10) $: allpassPhaserCausal)) :+                         Sound (Cut.take $: second 10 $: allpassPhaserCausal)) :           ("universal-lowpass",-                         Sound (Cut.take (DN.time 10) $: universalLowpassDirect)) :+                         Sound (Cut.take $: second 10 $: universalLowpassDirect)) :          ("universal-lowpass-sync",-                         Sound (Cut.take (DN.time 10) $: universalLowpassSync)) :+                         Sound (Cut.take $: second 10 $: universalLowpassSync)) :          ("universal-lowpass-async-linear",-                         Sound (Cut.take (DN.time 10) $: universalLowpassAsyncLinear)) :+                         Sound (Cut.take $: second 10 $: universalLowpassAsyncLinear)) :          ("universal-lowpass-async-constant",-                         Sound (Cut.take (DN.time 10) $: universalLowpassAsyncConstant)) :+                         Sound (Cut.take $: second 10 $: universalLowpassAsyncConstant)) : -         ("sine-low",    Sound (Cut.take (DN.time 1) $: sineLow)) :-         ("sine-high",   Sound (Cut.take (DN.time 1) $: sineHigh)) :-         ("sine-mix",    Sound (Cut.take (DN.time 1) $: sineMix)) :-         ("exponential", Sound (Cut.take (DN.time 1) $: DN.voltage 1 &*^ exponential)) :-         ("ping",        Sound (Cut.take (DN.time 1) $: ping)) :-         ("ping-saw",    Sound (Cut.take (DN.time 1) $: pingSaw)) :+         ("sine-low",    Sound (Cut.take $: second 1 $: sineLow)) :+         ("sine-high",   Sound (Cut.take $: second 1 $: sineHigh)) :+         ("sine-mix",    Sound (Cut.take $: second 1 $: sineMix)) :+         ("exponential", Sound (Cut.take $: second 1 $: DN.voltage 1 &*^ exponential)) :+         ("ping",        Sound (Cut.take $: second 1 $: ping)) :+         ("ping-saw",    Sound (Cut.take $: second 1 $: pingSaw)) : ---         ("saw",         Sound (Cut.take (DN.time 2) $: saw)) :-         ("saw-vibrato", Sound (Cut.take (DN.time 2) $: sawVibrato)) :-         ("saw-chorus",  Sound (Cut.take (DN.time 2) $: sawChorus)) :+--         ("saw",         Sound (Cut.take $: second 2 $: saw)) :+         ("saw-vibrato", Sound (Cut.take $: second 2 $: sawVibrato)) :+         ("saw-chorus",  Sound (Cut.take $: second 2 $: sawChorus)) : -         ("wasp",        Sound (Cut.take (DN.time  5) $: wasp (DN.frequency 110))) :-         ("trapezoid",   Sound (Cut.take (DN.time  5) $: trapezoid)) :-         ("damped-echo", Sound (Cut.take (DN.time  4) $: dampedEcho)) :+         ("wasp",        Sound (Cut.take $: second 5 $: wasp (DN.frequency 110))) :+         ("trapezoid",   Sound (Cut.take $: second 5 $: trapezoid)) :+         ("damped-echo", Sound (Cut.take $: second 4 $: dampedEcho)) :          ("chirp",       Sound (amplitudeModulationChirp)) :          ("airplane",        Sound airplane) :          {- This becomes considerably faster, if other effects are not rendered.@@ -829,7 +836,7 @@             renderToAIFF             File.renderTimeVoltageMonoDoubleToInt16             fileName-            (Cut.take (DN.time 1) $: fromSound tone)+            (Cut.take $: second 1 $: fromSound tone)   {-

@@ -70,6 +70,7 @@ import qualified Synthesizer.Dimensional.Amplitude.Filter as FiltV -- import qualified Synthesizer.Dimensional.ControlledProcess as CProc import qualified Synthesizer.Dimensional.Process as Proc+import qualified Synthesizer.Dimensional.Duration as Dur import qualified Synthesizer.Dimensional.Rate as Rate  -- import Synthesizer.Dimensional.Process ((.:), (.^), )@@ -81,12 +82,12 @@ import qualified Synthesizer.State.Signal as Sig -- import Synthesizer.Plain.Signal (Modifier) -import Synthesizer.Dimensional.Process-   (DimensionGradient, toTimeScalar, {- toFrequencyScalar, -} )+import Synthesizer.Dimensional.Process (DimensionGradient, )  {- import qualified Synthesizer.Frame.Stereo as Stereo -}+import qualified Data.StorableVector.Lazy.Typed as SVT import Foreign.Storable (Storable, )  {-@@ -105,8 +106,8 @@ -} import qualified Synthesizer.State.Filter.NonRecursive as FiltNR -import qualified Synthesizer.Storable.Signal as SigSt import qualified Synthesizer.Generic.Filter.Recursive.Comb as Comb+import qualified Synthesizer.Generic.Signal as SigG  import qualified Number.DimensionTerm        as DN import qualified Algebra.DimensionTerm       as Dim@@ -126,6 +127,8 @@  -- import Control.Monad(liftM2) +import Data.Function.HT (Id)+ import NumericPrelude.Numeric hiding (negate) import NumericPrelude.Base as P import Prelude ()@@ -543,7 +546,7 @@ {- | Infinitely many equi-delayed exponentially decaying echos. -} {-# INLINE comb #-} comb :: (RealRing.C t, Module.C y yv, Dim.C u, Dim.C v, Storable yv) =>-   DN.T u t -> y -> Proc.T s u t (SigA.R s v y yv -> SigA.R s v y yv)+   y -> Proc.T s u t (Dur.T s Int -> SigA.R s v y yv -> SigA.R s v y yv) comb = FiltR.comb  @@ -552,23 +555,21 @@ combProc ::    (RealRing.C t, Absolute.C y, Field.C y, Module.C y yv,     Dim.C u, Dim.C v, Storable yv) =>-   DN.T u t ->    Proc.T s u t (SigA.R s v y yv -> SigA.R s v y yv) ->-   Proc.T s u t (SigA.R s v y yv -> SigA.R s v y yv)-combProc time proc =+   Proc.T s u t (Dur.T s Int -> SigA.R s v y yv -> SigA.R s v y yv)+combProc proc =    do f <- proc-      t <- fmap round $ toTimeScalar time-      let chunkSize = SigSt.chunkSize t-      return $ \x ->+      return $ \(Dur.Cons t) x ->          SigA.processBody-            (Sig.fromStorableSignal .+            (SigG.toState .              Comb.runProc t-                (Sig.toStorableSignal chunkSize .+                (SigG.fromState .                  SigA.vectorSamples (SigA.toAmplitudeScalar x) .                  f .                  SigA.fromBody (SigA.actualAmplitude x) .-                 Sig.fromStorableSignal) .-             Sig.toStorableSignal chunkSize) x+                 SigG.toState) .+             (id :: Id (SVT.DefaultVector a)) .+             SigG.fromState) x  {- combProc time proc sr x =

@@ -31,7 +31,7 @@  import qualified Synthesizer.Dimensional.Amplitude.Flat as Flat import qualified Synthesizer.Dimensional.Sample as Sample--- import qualified Synthesizer.Dimensional.Rate as Rate+import qualified Synthesizer.Dimensional.Duration as Dur  -- import qualified Synthesizer.Storable.Signal as SigSt import Foreign.Storable (Storable, )@@ -244,7 +244,9 @@ fatPad freq =    let env =           Cut.append-             $: (Cut.take (DN.time 0.7) $:+             $: (Cut.take+                  $: (Dur.fromTime $ DN.time 0.7)+                  $:                   Ctrl.cubicHermite                    (DN.time 0,   (DN.fromNumber 0,   DN.frequency 1 &*& DN.fromNumber 5))                    (DN.time 0.7, (DN.fromNumber 0.5, DN.frequency 1 &*& DN.fromNumber 0)))@@ -265,11 +267,11 @@    (RealField.C a, Trans.C a, Module.C a a, Random a) =>    DN.T Dim.Frequency a -> Proc.T s Dim.Time a (SigA.R s Dim.Voltage a a) brass freq =-   let blobEnv = Piece.runState+   let blobEnv = Piece.run           (DN.fromNumber 0  |# (DN.time 0.05, Piece.cosine) #|-            DN.fromNumber 1 -|# (DN.time 0.05, Piece.cosine) #|            DN.fromNumber 0)-       adsr = Piece.runState+       adsr = Piece.run           (DN.fromNumber 0 |# (DN.time 0.1, Piece.cubic (DN.frequency 1 &*& DN.fromNumber 10) (DN.frequency 1 &*& DN.fromNumber 0)) #|-            DN.fromNumber 0.5 -|# (DN.time 1, Piece.step) #|-            DN.fromNumber 0.5 -|# (DN.time 0.3, Piece.exponential (DN.fromNumber 0)) #|@@ -506,8 +508,8 @@    DN.T Dim.Frequency a ->    Proc.T s Dim.Time a (SigA.R s Dim.Voltage a a) noiseBass freq =-   FiltA.combProc (DN.unrecip freq)-      (Filt.firstOrderLowpass $- DN.frequency 2000)+   FiltA.combProc (Filt.firstOrderLowpass $- DN.frequency 2000)+      $: Dur.fromTime (DN.unrecip freq)       $: noisePerc  {-|@@ -524,8 +526,8 @@    Proc.T s Dim.Time a (SigA.R s Dim.Voltage a a) electroTom =    let ks =-         FiltA.combProc (DN.time (1/30))-            (Filt.firstOrderLowpass $- (DN.frequency 1000))+         FiltA.combProc (Filt.firstOrderLowpass $- (DN.frequency 1000))+            $: Dur.fromTime (DN.time (1/30))             $: noisePerc    in  Filt.frequencyModulation Interpolation.linear           $: CtrlR.exponential2 (DN.time 0.3)@@ -536,7 +538,9 @@    (RealField.C q, Trans.C q, Module.C q q, Random q) =>    Proc.T s Dim.Time q (SigA.R s Dim.Voltage q q) bassDrum =-   Cut.take (DN.time 0.15) $:+   Cut.take+   $: (Dur.fromTime $ DN.time 0.15)+   $:    (Disp.mix     $: (Filt.firstOrderLowpass           $- (DN.frequency 5000)

@@ -16,7 +16,6 @@ import qualified Synthesizer.Dimensional.Process as Proc import Synthesizer.Dimensional.Process           (toTimeScalar, toGradientScalar, DimensionGradient, )--- import Synthesizer.Dimensional.Process (($:), ($#), )  import qualified Synthesizer.Dimensional.Amplitude as Amp import qualified Synthesizer.Dimensional.Rate as Rate@@ -39,7 +38,6 @@ -- import Control.Monad.Fix (mfix, ) import Control.Monad (liftM3, ) -import NumericPrelude.Numeric (zero, ) import NumericPrelude.Base import Prelude () @@ -48,13 +46,13 @@ type T s u v sig q =    Piecewise.Piece       (DN.T u q) (DN.T v q)-      (DN.T v q -> SigG.LazySize -> q ->+      (DN.T v q -> q ->        Proc.T s u q (SigA.T (Rate.Phantom s) (Amp.Flat q) (sig q)))  type Sequence s u v sig q =    Piecewise.T       (DN.T u q) (DN.T v q)-      (DN.T v q -> SigG.LazySize -> q ->+      (DN.T v q -> q ->        Proc.T s u q (SigA.T (Rate.Phantom s) (Amp.Flat q) (sig q)))  @@ -64,12 +62,11 @@ infinite descriptions cannot be used here. -} {-# INLINE run #-}-run :: (Trans.C q, RealRing.C q, Dim.C u, Dim.C v, SigG.Write sig q) =>-   DN.T u q ->+run :: (Trans.C q, RealRing.C q, Dim.C u, Dim.C v, SigG.Produce sig q) =>    Sequence s u v sig q ->    Proc.T s u q (SigA.T (Rate.Phantom s) (Amp.Dimensional v q) (sig q))-run lazySize cs =-   runVolume lazySize cs $+run cs =+   runVolume cs $    maximum $    map (\c -> max (DN.abs (Piecewise.pieceY0 c))                   (DN.abs (Piecewise.pieceY1 c))) cs@@ -77,39 +74,38 @@  {-# INLINE runVolume #-} runVolume ::-   (Trans.C q, RealRing.C q, Dim.C u, Dim.C v, SigG.Write sig q) =>-   DN.T u q ->+   (Trans.C q, RealRing.C q, Dim.C u, Dim.C v, SigG.Produce sig q) =>    Sequence s u v sig q ->    DN.T v q ->    Proc.T s u q (SigA.T (Rate.Phantom s) (Amp.Dimensional v q) (sig q))-runVolume lazySize' cs amplitude =+runVolume cs amplitude =    -- it would be nice if we could re-use Piece.run    do ts0 <- mapM (toTimeScalar . Piecewise.pieceDur) cs-      lazySize <--         Proc.intFromTime "Dimensional.Piece.runVolume" lazySize'       fmap (SigA.fromBody amplitude . SigG.concat) $          sequence $ zipWith             (\(n,t) (Piecewise.PieceData c yi0 yi1 d) ->                  fmap (SigG.take n . SigA.body) $-                 Piecewise.computePiece c yi0 yi1 d amplitude (SigG.LazySize lazySize) t)+                 Piecewise.computePiece c yi0 yi1 d amplitude t)             (Piecewise.splitDurations ts0)             cs  +{-# DEPRECATED runState "Use 'run' instead." #-} {-# INLINE runState #-} runState :: (Trans.C q, RealRing.C q, Dim.C u, Dim.C v) =>    Sequence s u v Sig.T q ->    Proc.T s u q (SigA.R s v q q)-runState = run zero+runState = run  +{-# DEPRECATED runStateVolume "Use 'runVolume' instead." #-} {-# INLINE runStateVolume #-} runStateVolume ::    (Trans.C q, RealRing.C q, Dim.C u, Dim.C v) =>    Sequence s u v Sig.T q ->    DN.T v q ->    Proc.T s u q (SigA.R s v q q)-runStateVolume = runVolume zero+runStateVolume = runVolume   {-# INLINE toAmpScalar #-}@@ -120,65 +116,65 @@    DN.divToScalar y amp  {-# INLINE make #-}-make :: (Field.C q, Dim.C u, Dim.C v, SigG.Write sig q) =>+make :: (Field.C q, Dim.C u, Dim.C v, SigG.Produce sig q) =>    Piece.T sig q -> T s u v sig q make piece =-   Piecewise.pieceFromFunction $ \ y0 y1 d amplitude lazySize t0 ->+   Piecewise.pieceFromFunction $ \ y0 y1 d amplitude t0 ->       flip fmap (toTimeScalar d) (\d' ->          SigA.flatFromBody $          Piecewise.computePiece piece             (toAmpScalar amplitude y0)             (toAmpScalar amplitude y1)-            d' lazySize t0)+            d' t0)  {-# INLINE step #-}-step :: (Field.C q, Dim.C u, Dim.C v, SigG.Write sig q) => T s u v sig q+step :: (Field.C q, Dim.C u, Dim.C v, SigG.Produce sig q) => T s u v sig q step =    make Piece.step  {-# INLINE linear #-}-linear :: (Field.C q, Dim.C u, Dim.C v, SigG.Write sig q) => T s u v sig q+linear :: (Field.C q, Dim.C u, Dim.C v, SigG.Produce sig q) => T s u v sig q linear =    make Piece.linear  {-# INLINE exponential #-}-exponential :: (Trans.C q, Dim.C u, Dim.C v, SigG.Write sig q) =>+exponential :: (Trans.C q, Dim.C u, Dim.C v, SigG.Produce sig q) =>    DN.T v q -> T s u v sig q exponential saturation =-   Piecewise.pieceFromFunction $ \ y0 y1 d amplitude lazySize t0 ->+   Piecewise.pieceFromFunction $ \ y0 y1 d amplitude t0 ->       flip fmap (toTimeScalar d) (\d' ->          SigA.flatFromBody $          Piecewise.computePiece             (Piece.exponential (toAmpScalar amplitude saturation))             (toAmpScalar amplitude y0)             (toAmpScalar amplitude y1)-            d' lazySize t0)+            d' t0)  {-# INLINE cosine #-}-cosine :: (Trans.C q, Dim.C u, Dim.C v, SigG.Write sig q) => T s u v sig q+cosine :: (Trans.C q, Dim.C u, Dim.C v, SigG.Produce sig q) => T s u v sig q cosine =    make Piece.cosine  {-# INLINE halfSine #-}-halfSine :: (Trans.C q, Dim.C u, Dim.C v, SigG.Write sig q) =>+halfSine :: (Trans.C q, Dim.C u, Dim.C v, SigG.Produce sig q) =>    Piece.FlatPosition -> T s u v sig q halfSine pos =    make (Piece.halfSine pos)  {-# INLINE cubic #-}-cubic :: (Field.C q, Dim.C u, Dim.C v, SigG.Write sig q) =>+cubic :: (Field.C q, Dim.C u, Dim.C v, SigG.Produce sig q) =>    DN.T (DimensionGradient u v) q ->    DN.T (DimensionGradient u v) q ->    T s u v sig q cubic yd0 yd1 =-   Piecewise.pieceFromFunction $ \ y0 y1 d amplitude lazySize t0 ->+   Piecewise.pieceFromFunction $ \ y0 y1 d amplitude t0 ->       liftM3 (\d' yd0' yd1' ->          SigA.flatFromBody $             Piecewise.computePiece                (Piece.cubic yd0' yd1')                (toAmpScalar amplitude y0)                (toAmpScalar amplitude y1)-               d' lazySize t0)+               d' t0)          (toTimeScalar d)          (toGradientScalar amplitude yd0)          (toGradientScalar amplitude yd1)

@@ -40,6 +40,7 @@ import qualified Synthesizer.Dimensional.Amplitude.Flat as Flat import qualified Synthesizer.Dimensional.Amplitude as Amp import qualified Synthesizer.Dimensional.Sample as Sample+import qualified Synthesizer.Dimensional.Duration as Dur import qualified Synthesizer.Dimensional.Rate as Rate  import qualified Synthesizer.Frame.Stereo as Stereo@@ -55,7 +56,7 @@  import Synthesizer.Utility (balanceLevel, ) -import qualified Synthesizer.Storable.Signal as SigSt+import qualified Data.StorableVector.Lazy.Typed as SVT  import qualified Algebra.DimensionTerm as Dim import qualified Number.DimensionTerm  as DN@@ -130,13 +131,13 @@    fromIntegral pc / 12 + fromIntegral oct  -type Signal s amp a = SigA.T (Rate.Phantom s) amp (SigSt.T a)+type Signal s amp a = SigA.T (Rate.Phantom s) amp (SVT.DefaultVector a) type Flat = Amp.Flat Double type Volt = Amp.Dimensional Dim.Voltage Double  {- delay ::-   (SigG2.Transform sig y (Stereo.T y), SigG.Write sig y,+   (SigG2.Transform sig y (Stereo.T y), SigG.Produce sig y,     Additive.C y, Amp.Primitive amp,     RealField.C t, Dim.C u) =>    DN.T u t ->@@ -149,12 +150,13 @@    Proc.T s Dim.Time Double       (Signal s Flat Double -> Signal s Flat (Stereo.T Double)) delay time =-   let (appDelay, merge) =+   let (delTime, merge) =           if time>=zero-            then (Filt.delay time, flip CutA.mergeStereoPrimitive)-            else (Filt.delay (negate time), CutA.mergeStereoPrimitive)-   in  flip fmap appDelay-          (\del x -> merge x (del x))+            then (time, flip CutA.mergeStereoPrimitive)+            else (negate time, CutA.mergeStereoPrimitive)+   in  fmap+         (\del x -> merge x (del x))+         (Filt.delay $: Dur.fromTime delTime)  {-# INLINE bell #-} bell ::@@ -163,8 +165,8 @@    Proc.T s Dim.Time Double (Signal s Flat (Stereo.T Double)) bell del freq =    delay del .:-   SigA.store timeUnit .:-   CutR.take (DN.time 1) .:+   SigA.storeTyped .:+   (CutR.take $: Dur.fromTime (DN.time 1)) .:    (Filt.envelope $: CtrlR.exponential2 (DN.time 0.2)) $:    Osci.static (WaveD.flat Wave.sine) zero freq @@ -188,7 +190,7 @@    DN.Time Double ->    Proc.T s Dim.Time Double (SigA.R s Dim.Scalar Double Double) stringEnvelope duration =-   Piece.runState $+   Piece.run $       DN.scalar 0.01 |#          (stringAttack,           Piece.halfSine Piece.FlatRight) #|-@@ -318,8 +320,7 @@ chordSnds =    EventList.traverseBody       (\(tones,dur) ->-          (SigA.store timeUnit .:-           Disp.mixMulti) $:+          (SigA.storeTyped .: Disp.mixMulti) $:           mapM              (strings (fromIntegral (dur*chordTicks) *& timeUnit) .               (*& DN.frequency 440) . (2**) .@@ -415,7 +416,7 @@ simpleStorable :: Proc.T s Dim.Time Double (Signal s Volt (Stereo.T Double)) simpleStorable =    FiltA.amplify 0.5 $^-   (Cut.arrangeStorableVolume timeUnit (DN.voltage 1) timeUnit+   (Cut.arrangeStorableTypedVolume (DN.voltage 1) timeUnit --      $: chordSnds --      $: evolvingDropSnds       $: -- fmap (EventList.fromPairList . drop 1100 . EventList.toPairList)@@ -469,8 +470,9 @@ --      "rain-long.aiff"       "rain-short.aiff"       ((CutA.dropWhile (DN.voltage 1) (zero==) .^-        Cut.take-           ((2 * NonNeg.toNumber partTicks +-             fromIntegral stringAttackTicks) *& timeUnit))+        (Cut.take+          $: (Dur.fromTime $+               (2 * NonNeg.toNumber partTicks ++                fromIntegral stringAttackTicks) *& timeUnit)))          $: simple)      >> return ()

@@ -33,6 +33,7 @@ import Synthesizer.Dimensional.Amplitude.Displacement (mapExponential, )  import qualified Synthesizer.Dimensional.Sample as Sample+import qualified Synthesizer.Dimensional.Duration as Dur  import qualified Synthesizer.Frame.Stereo as Stereo @@ -178,9 +179,9 @@    DN.voltage 1 &*~ Wave.trapezoid p  -{-# INLINE timeUnit #-}-timeUnit :: DN.T Dim.Time Double-timeUnit = DN.time 0.2+{-# INLINE intDur #-}+intDur :: Int -> Proc.T s Dim.Time Double (Dur.T s Int)+intDur dur = Dur.fromTime (fromIntegral dur *& DN.time 0.2)  {-# INLINE pitchControl #-} pitchControl ::@@ -189,7 +190,8 @@ pitchControl =    Cut.concatVolume (DN.scalar 1) $:    (mapM (\(p,dur) ->-      Cut.take (fromIntegral dur *& timeUnit)+      Cut.take+       $: intDur dur        $: Ctrl.constant (DN.scalar (assemblePitch p))) melody)  @@ -307,7 +309,7 @@    Proc.T s Dim.Time Double (SigA.R s Dim.Voltage Double (Stereo.T Double)) chordAccompaniment =    Cut.concat $::-   (map (\(chd,dur) -> Cut.take (fromIntegral dur *& timeUnit) $: makeChord chd) chords)+   (map (\(chd,dur) -> Cut.take $: intDur dur $: makeChord chd) chords)   @@ -318,12 +320,14 @@ bassControl =    Cut.concatVolume (DN.scalar 1) $::    (map (\(p,dur) ->-      Cut.take (fromIntegral dur *& timeUnit)+      Cut.take+       $: intDur dur        $: Ctrl.constant (DN.scalar (assemblePitch p))) bass) {-    Cut.concatVolume (DN.scalar 1) $:    (mapM (\(p,dur) ->-      Cut.take (fromIntegral dur *& timeUnit)+      Cut.take+       $: intDur dur        $: Ctrl.constant (DN.scalar (assemblePitch p))) bass) -} @@ -411,7 +415,8 @@          $: (mapExponential 2 (DN.frequency 440) $^                (Cut.concatVolume (DN.scalar 1) $:                    (mapM (\p ->-                      Cut.take (2 *& timeUnit)+                      Cut.take+                         $: intDur 2                          $: Ctrl.constant (DN.scalar (assemblePitch p))) harmony)))          $: accompaniment) 

@@ -7,7 +7,7 @@    asTypeOfAmplitude,    render, apply,    cache, bindCached, share,-   store, restore,+   store, storeTyped, restore,    ($-),  ($&),    (&*^), (&*>^),    ) where

@@ -7,6 +7,7 @@ module Synthesizer.Dimensional.Signal.Private where  import qualified Synthesizer.Dimensional.Amplitude as Amp+import qualified Synthesizer.Dimensional.Duration as Dur import qualified Synthesizer.Dimensional.Rate as Rate  import qualified Synthesizer.Dimensional.Process as Proc@@ -19,7 +20,8 @@ import qualified Synthesizer.Storable.Signal as SigSt import qualified Synthesizer.Frame.Stereo as Stereo import qualified Synthesizer.Basic.Binary as BinSmp-import Data.Int (Int16, )+import qualified Data.StorableVector.Lazy.Typed as SVT+import Data.Int (Int, Int16, ) import Foreign.Storable (Storable, )  import qualified Synthesizer.State.Signal as Sig@@ -150,7 +152,7 @@ Of course, for stereo signals @Stereo.T@ should be prefered. -} zip ::-   (SigG.Transform sig y1, SigG.Transform sig (y0,y1), SigG.Read sig y0) =>+   (SigG.Transform sig y1, SigG.Transform sig (y0,y1), SigG.Consume sig y0) =>    T (Rate.Phantom s) amp0 (sig y0) ->    T (Rate.Phantom s) amp1 (sig y1) ->    T (Rate.Phantom s) (amp0,amp1) (sig (y0,y1))@@ -233,22 +235,40 @@   +{-# INLINE lazyFromDefaultTypedVector #-}+lazyFromDefaultTypedVector ::+   (Storable yv) =>+   T rate amp (SVT.DefaultVector yv) -> T rate amp (SigSt.T yv)+lazyFromDefaultTypedVector =+   processBody SVT.toVectorLazy+ {-# INLINE store #-} store ::    (RealRing.C t, Dim.C u, Storable yv) =>-   DN.T u t ->    Proc.T s u t (+      Dur.T s Int ->       {-       Rate.Phantom required,       because chunk size is dicretized with respect to the process' sample rate       -}       T (Rate.Phantom s) amp (Sig.T yv) ->       T (Rate.Phantom s) amp (SigSt.T yv))-store chunkSize =-   fmap-      (\cs -> processBody (Sig.toStorableSignal (SigSt.chunkSize cs)))-      (Proc.intFromTime "Dimensional.Signal.store" chunkSize)+store =+   Proc.pure $ \(Dur.Cons cs) ->+      processBody (Sig.toStorableSignal (SigSt.chunkSize cs)) +{-# INLINE storeTyped #-}+storeTyped ::+   (SVT.Size size, RealRing.C t, Dim.C u, Storable yv) =>+   Proc.T s u t (+      {-+      Rate.Phantom required,+      because chunk size is dicretized with respect to the process' sample rate+      -}+      T (Rate.Phantom s) amp (Sig.T yv) ->+      T (Rate.Phantom s) amp (SVT.Vector size yv))+storeTyped = Proc.pure $ processBody SigG.fromState+ {- better use ChunkySize.Signal.store we do not need Proc context@@ -266,7 +286,7 @@  {-# INLINE restore #-} restore ::-   (SigG.Read sig yv) =>+   (SigG.Consume sig yv) =>    T rate amp (sig yv) ->    T rate amp (Sig.T yv) restore =

@@ -1,5 +1,5 @@ Name:           synthesizer-dimensional-Version:        0.8.1.1+Version:        0.9 License:        GPL License-File:   LICENSE Author:         Henning Thielemann <haskell@henning-thielemann.de>@@ -33,24 +33,24 @@   Location:    http://code.haskell.org/synthesizer/dimensional/  Source-Repository this-  Tag:         0.8.1.1+  Tag:         0.9   Type:        darcs   Location:    http://code.haskell.org/synthesizer/dimensional/  Library   Build-Depends:-    synthesizer-core >=0.8.1 && <0.9,+    synthesizer-core >=0.9 && <0.10,     transformers >=0.2 && <0.7,-    semigroups >=0.1 && <1.0,+    semigroups >=0.1 && <1,     event-list >=0.1 && <0.2,     non-negative >=0.1 && <0.2,     numeric-prelude >=0.3 && <0.5,     storable-record >=0.0.1 && <0.1,     sox >=0.2 && <0.3,-    storablevector >=0.2.3 && <0.3,-    bytestring >= 0.9 && <0.12,-    random >=1.0 && <2.0,-    utility-ht >=0.0.5 && <0.1,+    storablevector >=0.2.12 && <0.3,+    bytestring >= 0.9 && <0.13,+    random >=1.0 && <1.4,+    utility-ht >=0.0.13 && <0.1,     base >= 4 && <5    If impl(ghc>=7.0)@@ -66,6 +66,7 @@     Synthesizer.Dimensional.Amplitude     Synthesizer.Dimensional.Sample     Synthesizer.Dimensional.Rate+    Synthesizer.Dimensional.Duration     Synthesizer.Dimensional.Arrow     Synthesizer.Dimensional.Map     Synthesizer.Dimensional.Map.Displacement@@ -120,6 +121,7 @@     Build-Depends:       synthesizer-dimensional,       synthesizer-core,+      storablevector,       numeric-prelude,       event-list,       utility-ht,@@ -141,7 +143,7 @@ Executable demonstration   If flag(buildExamples)     Build-Depends:-      explicit-exception >=0.1.6 && <0.2,+      explicit-exception >=0.1.6 && <0.3,       old-time >=1.0 && <2,        synthesizer-dimensional,