{- |
Copyright   :  (c) Henning Thielemann 2007-2009

Maintainer  :  haskell@henning-thielemann.de
Stability   :  stable
Portability :  Haskell 98

Event list with absolute times starting with a time and ending with a body
-}
module Data.EventList.Absolute.TimeTime
   (T,
    pause, isPause,
    viewL, switchL, cons, snoc,
    mapBody, mapTime,
    concatMapMonoid,
    traverse, traverse_, traverseBody, traverseTime,
    mapM, mapM_, mapBodyM, mapTimeM,
    getTimes, getBodies, duration,
    merge, mergeBy, insert, insertBy,
    moveForward,
    decreaseStart, delay, filter, partition, slice, foldr,
    mapMaybe, catMaybes,
    normalize, isNormalized,
    collectCoincident, flatten, mapCoincident,
    append, concat, cycle,
    discretize, resample,
   ) where

import Data.EventList.Absolute.TimeTimePrivate
import Data.EventList.Absolute.TimeBodyPrivate (($~))
import qualified Data.EventList.Absolute.TimeBodyPrivate as TimeBodyPriv
import qualified Data.EventList.Absolute.TimeBody as TimeBodyList

import qualified Data.AlternatingList.List.Disparate as Disp
import qualified Data.AlternatingList.List.Uniform as Uniform
import qualified Data.AlternatingList.List.Mixed as Mixed

import qualified Data.List as List
import qualified Data.List.HT as ListHT
import qualified Data.EventList.Utility as Utility

import Data.Tuple.HT (mapSnd, mapPair, )
import Data.Maybe.HT (toMaybe, )
import Data.List.HT (isAscending, )

import qualified Control.Monad as Monad
import Control.Applicative (Applicative, WrappedMonad(WrapMonad, unwrapMonad), )

import Control.Monad.Trans.State (state, evalState)
import Control.Monad (Monad, (>>), )

import Data.Monoid (Monoid, )

import Data.Function (flip, (.), ($), )
import Data.Functor (fmap, )
import Data.Maybe (Maybe(Just), fromMaybe, )
import Data.Tuple (uncurry, fst, snd, )
import Data.Ord (Ord, max, (<), (>=), )
import Data.Eq (Eq, (/=), )
import Prelude
   (Num, Integral, RealFrac, round, subtract, (*), (+), (-),
    Bool, error, )



pause :: time -> T time body
pause :: forall time body. time -> T time body
pause = forall time body. T body time -> T time body
Cons forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall b a. b -> T a b
Uniform.singleton

isPause :: T time body -> Bool
isPause :: forall time body. T time body -> Bool
isPause = forall a b. T a b -> Bool
Uniform.isSingleton forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall time body. T time body -> T body time
decons



getBodies :: T time body -> [body]
getBodies :: forall time body. T time body -> [body]
getBodies = forall a b. T a b -> [a]
Uniform.getFirsts forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall time body. T time body -> T body time
decons

getTimes :: T time body -> [time]
getTimes :: forall time body. T time body -> [time]
getTimes = forall a b. T a b -> [b]
Uniform.getSeconds forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall time body. T time body -> T body time
decons

duration :: Num time => T time body -> time
duration :: forall time body. Num time => T time body -> time
duration = forall a b. (a, b) -> b
snd forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall time body. T time body -> (T time body, time)
viewTimeR
-- duration = last . getTimes



cons :: time -> body -> T time body -> T time body
cons :: forall time body. time -> body -> T time body -> T time body
cons time
time body
body = forall body0 time0 body1 time1.
(T body0 time0 -> T body1 time1) -> T time0 body0 -> T time1 body1
lift (forall b a. b -> a -> T a b -> T a b
Uniform.cons time
time body
body)

snoc :: T time body -> body -> time -> T time body
snoc :: forall time body. T time body -> body -> time -> T time body
snoc T time body
xs body
body time
time =
   forall time body. T body time -> T time body
Cons forall a b. (a -> b) -> a -> b
$ (forall a b. T a b -> a -> b -> T a b
Uniform.snoc forall body time a. (T body time -> a) -> T time body -> a
$* T time body
xs) body
body time
time


viewL :: T time body -> (time, Maybe (body, T time body))
viewL :: forall time body. T time body -> (time, Maybe (body, T time body))
viewL =
   forall b c a. (b -> c) -> (a, b) -> (a, c)
mapSnd (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (forall b c a. (b -> c) -> (a, b) -> (a, c)
mapSnd forall time body. T body time -> T time body
Cons) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. T a b -> Maybe (a, T a b)
Mixed.viewFirstL) forall b c a. (b -> c) -> (a -> b) -> a -> c
.
   forall a b. T a b -> (b, T a b)
Mixed.viewSecondL forall b c a. (b -> c) -> (a -> b) -> a -> c
.
   forall time body. T time body -> T body time
decons

{-# INLINE switchL #-}
switchL :: (time -> a) -> ((time, body) -> T time body -> a) -> T time body -> a
switchL :: forall time a body.
(time -> a)
-> ((time, body) -> T time body -> a) -> T time body -> a
switchL time -> a
f (time, body) -> T time body -> a
g =
   forall b c a. (b -> c) -> (b -> a -> T a b -> c) -> T a b -> c
Mixed.switchL time -> a
f (\time
t body
b -> (time, body) -> T time body -> a
g (time
t,body
b) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall time body. T body time -> T time body
Cons) forall b c a. (b -> c) -> (a -> b) -> a -> c
.
   forall time body. T time body -> T body time
decons


mapBody :: (body0 -> body1) -> T time body0 -> T time body1
mapBody :: forall body0 body1 time.
(body0 -> body1) -> T time body0 -> T time body1
mapBody = forall body0 time0 body1 time1.
(T body0 time0 -> T body1 time1) -> T time0 body0 -> T time1 body1
lift forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a0 a1 b. (a0 -> a1) -> T a0 b -> T a1 b
Uniform.mapFirst

mapTime :: (time0 -> time1) -> T time0 body -> T time1 body
mapTime :: forall time0 time1 body.
(time0 -> time1) -> T time0 body -> T time1 body
mapTime = forall body0 time0 body1 time1.
(T body0 time0 -> T body1 time1) -> T time0 body0 -> T time1 body1
lift forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall b0 b1 a. (b0 -> b1) -> T a b0 -> T a b1
Uniform.mapSecond



concatMapMonoid :: Monoid m =>
   (time -> m) -> (body -> m) ->
   T time body -> m
concatMapMonoid :: forall m time body.
Monoid m =>
(time -> m) -> (body -> m) -> T time body -> m
concatMapMonoid time -> m
f body -> m
g =
   forall m time body.
Monoid m =>
(time -> m) -> (body -> m) -> T time body -> m
Uniform.concatMapMonoid body -> m
g time -> m
f forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall time body. T time body -> T body time
decons


traverse :: Applicative m =>
   (time0 -> m time1) -> (body0 -> m body1) ->
   T time0 body0 -> m (T time1 body1)
traverse :: forall (m :: * -> *) time0 time1 body0 body1.
Applicative m =>
(time0 -> m time1)
-> (body0 -> m body1) -> T time0 body0 -> m (T time1 body1)
traverse time0 -> m time1
f body0 -> m body1
g = forall (m :: * -> *) body0 time0 body1 time1.
Applicative m =>
(T body0 time0 -> m (T body1 time1))
-> T time0 body0 -> m (T time1 body1)
liftA (forall (m :: * -> *) a0 a1 b0 b1.
Applicative m =>
(a0 -> m a1) -> (b0 -> m b1) -> T a0 b0 -> m (T a1 b1)
Uniform.traverse body0 -> m body1
g time0 -> m time1
f)

traverse_ :: Applicative m =>
   (time -> m ()) -> (body -> m ()) ->
   T time body -> m ()
traverse_ :: forall (m :: * -> *) time body.
Applicative m =>
(time -> m ()) -> (body -> m ()) -> T time body -> m ()
traverse_ time -> m ()
f body -> m ()
g = forall (m :: * -> *) d a b.
(Applicative m, Monoid d) =>
(a -> m d) -> (b -> m d) -> T a b -> m d
Uniform.traverse_ body -> m ()
g time -> m ()
f forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall time body. T time body -> T body time
decons


traverseBody :: Applicative m =>
   (body0 -> m body1) -> T time body0 -> m (T time body1)
traverseBody :: forall (m :: * -> *) body0 body1 time.
Applicative m =>
(body0 -> m body1) -> T time body0 -> m (T time body1)
traverseBody body0 -> m body1
f = forall (m :: * -> *) body0 time0 body1 time1.
Applicative m =>
(T body0 time0 -> m (T body1 time1))
-> T time0 body0 -> m (T time1 body1)
liftA (forall (m :: * -> *) a0 a1 b.
Applicative m =>
(a0 -> m a1) -> T a0 b -> m (T a1 b)
Uniform.traverseFirst body0 -> m body1
f)

traverseTime :: Applicative m =>
   (time0 -> m time1) -> T time0 body -> m (T time1 body)
traverseTime :: forall (m :: * -> *) time0 time1 body.
Applicative m =>
(time0 -> m time1) -> T time0 body -> m (T time1 body)
traverseTime time0 -> m time1
f = forall (m :: * -> *) body0 time0 body1 time1.
Applicative m =>
(T body0 time0 -> m (T body1 time1))
-> T time0 body0 -> m (T time1 body1)
liftA (forall (m :: * -> *) b0 b1 a.
Applicative m =>
(b0 -> m b1) -> T a b0 -> m (T a b1)
Uniform.traverseSecond time0 -> m time1
f)


mapM :: Monad m =>
   (time0 -> m time1) -> (body0 -> m body1) ->
   T time0 body0 -> m (T time1 body1)
mapM :: forall (m :: * -> *) time0 time1 body0 body1.
Monad m =>
(time0 -> m time1)
-> (body0 -> m body1) -> T time0 body0 -> m (T time1 body1)
mapM time0 -> m time1
f body0 -> m body1
g =
   forall (m :: * -> *) a. WrappedMonad m a -> m a
unwrapMonad forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) time0 time1 body0 body1.
Applicative m =>
(time0 -> m time1)
-> (body0 -> m body1) -> T time0 body0 -> m (T time1 body1)
traverse (forall (m :: * -> *) a. m a -> WrappedMonad m a
WrapMonad forall b c a. (b -> c) -> (a -> b) -> a -> c
. time0 -> m time1
f) (forall (m :: * -> *) a. m a -> WrappedMonad m a
WrapMonad forall b c a. (b -> c) -> (a -> b) -> a -> c
. body0 -> m body1
g)

mapM_ :: Monad m =>
   (time -> m ()) -> (body -> m ()) ->
   T time body -> m ()
mapM_ :: forall (m :: * -> *) time body.
Monad m =>
(time -> m ()) -> (body -> m ()) -> T time body -> m ()
mapM_ time -> m ()
f body -> m ()
g =
   forall (m :: * -> *) a. WrappedMonad m a -> m a
unwrapMonad forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) time body.
Applicative m =>
(time -> m ()) -> (body -> m ()) -> T time body -> m ()
traverse_ (forall (m :: * -> *) a. m a -> WrappedMonad m a
WrapMonad forall b c a. (b -> c) -> (a -> b) -> a -> c
. time -> m ()
f) (forall (m :: * -> *) a. m a -> WrappedMonad m a
WrapMonad forall b c a. (b -> c) -> (a -> b) -> a -> c
. body -> m ()
g)


mapBodyM :: Monad m =>
   (body0 -> m body1) -> T time body0 -> m (T time body1)
mapBodyM :: forall (m :: * -> *) body0 body1 time.
Monad m =>
(body0 -> m body1) -> T time body0 -> m (T time body1)
mapBodyM body0 -> m body1
f = forall (m :: * -> *) a. WrappedMonad m a -> m a
unwrapMonad forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) body0 body1 time.
Applicative m =>
(body0 -> m body1) -> T time body0 -> m (T time body1)
traverseBody (forall (m :: * -> *) a. m a -> WrappedMonad m a
WrapMonad forall b c a. (b -> c) -> (a -> b) -> a -> c
. body0 -> m body1
f)

mapTimeM :: Monad m =>
   (time0 -> m time1) -> T time0 body -> m (T time1 body)
mapTimeM :: forall (m :: * -> *) time0 time1 body.
Monad m =>
(time0 -> m time1) -> T time0 body -> m (T time1 body)
mapTimeM time0 -> m time1
f = forall (m :: * -> *) a. WrappedMonad m a -> m a
unwrapMonad forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) time0 time1 body.
Applicative m =>
(time0 -> m time1) -> T time0 body -> m (T time1 body)
traverseTime (forall (m :: * -> *) a. m a -> WrappedMonad m a
WrapMonad forall b c a. (b -> c) -> (a -> b) -> a -> c
. time0 -> m time1
f)



foldr :: (time -> a -> b) -> (body -> b -> a) -> a -> T time body -> b
foldr :: forall time a b body.
(time -> a -> b) -> (body -> b -> a) -> a -> T time body -> b
foldr time -> a -> b
f body -> b -> a
g a
x = forall a c d b. (a -> c -> d) -> (b -> d -> c) -> d -> T a b -> c
Uniform.foldr body -> b -> a
g time -> a -> b
f a
x forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall time body. T time body -> T body time
decons


filter :: (Num time) =>
   (body -> Bool) -> T time body -> T time body
filter :: forall time body.
Num time =>
(body -> Bool) -> T time body -> T time body
filter body -> Bool
p = forall time body0 body1.
Num time =>
(body0 -> Maybe body1) -> T time body0 -> T time body1
mapMaybe (\body
b -> forall a. Bool -> a -> Maybe a
toMaybe (body -> Bool
p body
b) body
b)

mapMaybe :: (Num time) =>
   (body0 -> Maybe body1) ->
   T time body0 -> T time body1
mapMaybe :: forall time body0 body1.
Num time =>
(body0 -> Maybe body1) -> T time body0 -> T time body1
mapMaybe body0 -> Maybe body1
f = forall time body. Num time => T time (Maybe body) -> T time body
catMaybes forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall body0 body1 time.
(body0 -> body1) -> T time body0 -> T time body1
mapBody body0 -> Maybe body1
f

catMaybes :: (Num time) =>
   T time (Maybe body) -> T time body
catMaybes :: forall time body. Num time => T time (Maybe body) -> T time body
catMaybes =
   forall time body0 body1.
(T time body0 -> T time body1) -> T time body0 -> T time body1
mapTimeInit forall time body. Num time => T time (Maybe body) -> T time body
TimeBodyList.catMaybes

{-
Could be implemented more easily in terms of Uniform.partition
-}
partition ::
   (body -> Bool) -> T time body -> (T time body, T time body)
partition :: forall body time.
(body -> Bool) -> T time body -> (T time body, T time body)
partition body -> Bool
p =
   forall time body a. (T time body -> time -> a) -> T time body -> a
switchTimeR
   (\ T time body
xs time
t ->
      forall a c b d. (a -> c, b -> d) -> (a, b) -> (c, d)
mapPair
         (forall a b c. (a -> b -> c) -> b -> a -> c
flip forall time body. T time body -> time -> T time body
snocTime time
t, forall a b c. (a -> b -> c) -> b -> a -> c
flip forall time body. T time body -> time -> T time body
snocTime time
t)
         (forall body time.
(body -> Bool) -> T time body -> (T time body, T time body)
TimeBodyList.partition body -> Bool
p T time body
xs))

slice :: (Eq a, Num time) =>
   (body -> a) -> T time body -> [(a, T time body)]
slice :: forall a time body.
(Eq a, Num time) =>
(body -> a) -> T time body -> [(a, T time body)]
slice =
   forall a eventlist body.
Eq a =>
(eventlist -> Maybe body)
-> ((body -> Bool) -> eventlist -> (eventlist, eventlist))
-> (body -> a)
-> eventlist
-> [(a, eventlist)]
Utility.slice
      (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a b. (a, b) -> a
fst forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a, b) -> b
snd forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall time body. T time body -> (time, Maybe (body, T time body))
viewL)
      forall body time.
(body -> Bool) -> T time body -> (T time body, T time body)
partition


collectCoincident :: Eq time => T time body -> T time [body]
collectCoincident :: forall time body. Eq time => T time body -> T time [body]
collectCoincident =
   forall time body. T body time -> T time body
Cons forall b c a. (b -> c) -> (a -> b) -> a -> c
.
   forall b a c. (b -> T a b -> c) -> T a b -> c
Mixed.switchSecondL
   (\ time
t0 ->
      forall b a. b -> T a b -> T a b
Mixed.consSecond time
t0 forall b c a. (b -> c) -> (a -> b) -> a -> c
.
      forall a b0 b1. (T a b0 -> T a b1) -> T b0 a -> T b1 a
Mixed.mapFirstInit
         (forall a b. T (Maybe a) b -> T a [b]
Uniform.catMaybesFirst forall b c a. (b -> c) -> (a -> b) -> a -> c
.
          forall a b c. (a -> b -> c) -> b -> a -> c
flip forall s a. State s a -> s -> a
evalState (forall a. a -> Maybe a
Just time
t0) forall b c a. (b -> c) -> (a -> b) -> a -> c
.
          forall (m :: * -> *) a0 a1 b.
Applicative m =>
(a0 -> m a1) -> T a0 b -> m (T a1 b)
Uniform.traverseFirst (\Maybe time
time -> forall (m :: * -> *) s a. Monad m => (s -> (a, s)) -> StateT s m a
state forall a b. (a -> b) -> a -> b
$ \ Maybe time
oldTime ->
             (forall (f :: * -> *). Alternative f => Bool -> f ()
Monad.guard (Maybe time
time forall a. Eq a => a -> a -> Bool
/= Maybe time
oldTime) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Maybe time
time, Maybe time
time)) forall b c a. (b -> c) -> (a -> b) -> a -> c
.
          forall a0 a1 b. (a0 -> a1) -> T a0 b -> T a1 b
Uniform.mapFirst forall a. a -> Maybe a
Just)) forall b c a. (b -> c) -> (a -> b) -> a -> c
.
   forall time body. T time body -> T body time
decons


flatten :: (Ord time) => T time [body] -> T time body
flatten :: forall time body. Ord time => T time [body] -> T time body
flatten = forall time body0 body1.
(T time body0 -> T time body1) -> T time body0 -> T time body1
mapTimeInit forall time body. Ord time => T time [body] -> T time body
TimeBodyList.flatten


{- |
Apply a function to the lists of coincident events.
-}

mapCoincident :: (Ord time) =>
   ([a] -> [b]) -> T time a -> T time b
mapCoincident :: forall time a b. Ord time => ([a] -> [b]) -> T time a -> T time b
mapCoincident [a] -> [b]
f = forall time body. Ord time => T time [body] -> T time body
flatten forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall body0 body1 time.
(body0 -> body1) -> T time body0 -> T time body1
mapBody [a] -> [b]
f forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall time body. Eq time => T time body -> T time [body]
collectCoincident

{- |

'List.sort' sorts a list of coinciding events,
that is all events but the first one have time difference 0.
'normalize' sorts all coinciding events in a list
thus yielding a canonical representation of a time ordered list.
-}

normalize :: (Ord time, Num time, Ord body) => T time body -> T time body
normalize :: forall time body.
(Ord time, Num time, Ord body) =>
T time body -> T time body
normalize = forall time a b. Ord time => ([a] -> [b]) -> T time a -> T time b
mapCoincident forall a. Ord a => [a] -> [a]
List.sort

isNormalized :: (Ord time, Num time, Ord body) =>
   T time body -> Bool
isNormalized :: forall time body.
(Ord time, Num time, Ord body) =>
T time body -> Bool
isNormalized =
   forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
List.all forall a. Ord a => [a] -> Bool
isAscending forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall time body. T time body -> [body]
getBodies forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall time body. Eq time => T time body -> T time [body]
collectCoincident



merge :: (Ord time, Ord body) =>
   T time body -> T time body -> T time body
merge :: forall time body.
(Ord time, Ord body) =>
T time body -> T time body -> T time body
merge = forall time body.
Ord time =>
(body -> body -> Bool) -> T time body -> T time body -> T time body
mergeBy forall a. Ord a => a -> a -> Bool
(<)

mergeBy :: (Ord time) =>
   (body -> body -> Bool) ->
   T time body -> T time body -> T time body
mergeBy :: forall time body.
Ord time =>
(body -> body -> Bool) -> T time body -> T time body -> T time body
mergeBy body -> body -> Bool
before T time body
xs0 T time body
ys0 =
   let (T time body
xs,time
xt) = forall time body. T time body -> (T time body, time)
viewTimeR T time body
xs0
       (T time body
ys,time
yt) = forall time body. T time body -> (T time body, time)
viewTimeR T time body
ys0
   in  forall time body. T time body -> time -> T time body
snocTime
          (forall time body.
Ord time =>
(body -> body -> Bool) -> T time body -> T time body -> T time body
TimeBodyList.mergeBy body -> body -> Bool
before T time body
xs T time body
ys)
          (forall a. Ord a => a -> a -> a
max time
xt time
yt)

insert :: (Ord time, Ord body) =>
   time -> body -> T time body -> T time body
insert :: forall time body.
(Ord time, Ord body) =>
time -> body -> T time body -> T time body
insert = forall time body.
Ord time =>
(body -> body -> Bool)
-> time -> body -> T time body -> T time body
insertBy forall a. Ord a => a -> a -> Bool
(<)

insertBy :: (Ord time) =>
   (body -> body -> Bool) ->
   time -> body -> T time body -> T time body
insertBy :: forall time body.
Ord time =>
(body -> body -> Bool)
-> time -> body -> T time body -> T time body
insertBy body -> body -> Bool
before time
t0 body
me0 T time body
mevs1 =
   let mev0 :: (time, body)
mev0 = (time
t0, body
me0)
   in  forall time a body.
(time -> a)
-> ((time, body) -> T time body -> a) -> T time body -> a
switchL
          (\time
t1 -> forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry forall time body. time -> body -> T time body -> T time body
cons (time, body)
mev0 forall a b. (a -> b) -> a -> b
$ forall time body. time -> T time body
pause (forall a. Ord a => a -> a -> a
max time
t0 time
t1))
          (\(time, body)
mev1 T time body
mevs ->
              if forall time body.
Ord time =>
(body -> body -> Bool) -> (time, body) -> (time, body) -> Bool
Utility.beforeBy body -> body -> Bool
before (time, body)
mev0 (time, body)
mev1
                then forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry forall time body. time -> body -> T time body -> T time body
cons (time, body)
mev0 forall a b. (a -> b) -> a -> b
$ T time body
mevs1
                else forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry forall time body. time -> body -> T time body -> T time body
cons (time, body)
mev1 forall a b. (a -> b) -> a -> b
$ forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry (forall time body.
Ord time =>
(body -> body -> Bool)
-> time -> body -> T time body -> T time body
insertBy body -> body -> Bool
before) (time, body)
mev0 T time body
mevs)
          T time body
mevs1



{- |
Move events towards the front of the event list.
You must make sure, that no event is moved before time zero.
This works only for finite lists.
-}
moveForward :: (Ord time, Num time) =>
   T time (time, body) -> T time body
moveForward :: forall time body.
(Ord time, Num time) =>
T time (time, body) -> T time body
moveForward =
   forall time body0 body1.
(T time body0 -> T time body1) -> T time body0 -> T time body1
mapTimeInit forall time body.
(Ord time, Num time) =>
T time (time, body) -> T time body
TimeBodyList.moveForward



append :: (Ord time, Num time) =>
   T time body -> T time body -> T time body
append :: forall time body.
(Ord time, Num time) =>
T time body -> T time body -> T time body
append =
   forall time body a. (T time body -> time -> a) -> T time body -> a
switchTimeR
   (\T time body
xs time
t -> forall body0 time0 body1 time1.
(T body0 time0 -> T body1 time1) -> T time0 body0 -> T time1 body1
lift (forall b a. T b a -> T a b -> T a b
Mixed.appendDisparateUniform forall time body a. (T time body -> a) -> T time body -> a
$~ T time body
xs) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall time body.
(Ord time, Num time) =>
time -> T time body -> T time body
delay time
t)

concat :: (Ord time, Num time) =>
   [T time body] -> T time body
concat :: forall time body.
(Ord time, Num time) =>
[T time body] -> T time body
concat [T time body]
xs =
   let ts0 :: [time]
ts0 = forall b a. (b -> a -> b) -> b -> [a] -> [b]
List.scanl forall a. Num a => a -> a -> a
(+) time
0 (forall a b. (a -> b) -> [a] -> [b]
List.map forall time body. Num time => T time body -> time
duration [T time body]
xs)
       ([time]
ts,time
dur) =
          forall a. a -> Maybe a -> a
fromMaybe
             (forall a. HasCallStack => [Char] -> a
error [Char]
"list of accumulated times is always non-empty")
             (forall a. [a] -> Maybe ([a], a)
ListHT.viewR [time]
ts0)
   in  forall time body. T time body -> time -> T time body
snocTime
          (forall time body. T time body -> T time body
TimeBodyPriv.Cons forall a b. (a -> b) -> a -> b
$ forall a b. [T a b] -> T a b
Disp.concat forall a b. (a -> b) -> a -> b
$ forall a b. (a -> b) -> [a] -> [b]
List.map forall time body. T time body -> T time body
TimeBodyPriv.decons forall a b. (a -> b) -> a -> b
$
           forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
List.zipWith forall time body.
(Ord time, Num time) =>
time -> T time body -> T time body
TimeBodyList.delay [time]
ts (forall a b. (a -> b) -> [a] -> [b]
List.map (forall a b. (a, b) -> a
fst forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall time body. T time body -> (T time body, time)
viewTimeR) [T time body]
xs))
          time
dur

cycle :: (Ord time, Num time) =>
   T time body -> T time body
cycle :: forall time body.
(Ord time, Num time) =>
T time body -> T time body
cycle = forall time body.
(Ord time, Num time) =>
[T time body] -> T time body
concat forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. a -> [a]
List.repeat


decreaseStart :: (Ord time, Num time) =>
   time -> T time body -> T time body
decreaseStart :: forall time body.
(Ord time, Num time) =>
time -> T time body -> T time body
decreaseStart time
dif =
   forall time body. T body time -> T time body
Cons forall b c a. (b -> c) -> (a -> b) -> a -> c
.
   forall b a c. (b -> T a b -> c) -> T a b -> c
Mixed.switchSecondL
   (\ time
t T body time
xs ->
      forall b a. b -> T a b -> T a b
Mixed.consSecond
         (if time
tforall a. Ord a => a -> a -> Bool
>=time
dif
            then time
tforall a. Num a => a -> a -> a
-time
dif
            else forall a. HasCallStack => [Char] -> a
error [Char]
"decreaseStart: difference too big")
         (forall b0 b1 a. (b0 -> b1) -> T a b0 -> T a b1
Disp.mapSecond (forall a. Num a => a -> a -> a
subtract time
dif) T body time
xs)) forall b c a. (b -> c) -> (a -> b) -> a -> c
.
   forall time body. T time body -> T body time
decons

delay :: (Ord time, Num time) =>
   time -> T time body -> T time body
delay :: forall time body.
(Ord time, Num time) =>
time -> T time body -> T time body
delay time
dif =
   if time
difforall a. Ord a => a -> a -> Bool
>=time
0
     then forall time0 time1 body.
(time0 -> time1) -> T time0 body -> T time1 body
mapTime (time
difforall a. Num a => a -> a -> a
+)
     else forall a. HasCallStack => [Char] -> a
error [Char]
"delay: negative delay"


discretize :: (RealFrac time, Integral i) =>
   T time body -> T i body
discretize :: forall time i body.
(RealFrac time, Integral i) =>
T time body -> T i body
discretize = forall time0 time1 body.
(time0 -> time1) -> T time0 body -> T time1 body
mapTime forall a b. (RealFrac a, Integral b) => a -> b
round

resample :: (RealFrac time, Integral i) =>
   time -> T time body -> T i body
resample :: forall time i body.
(RealFrac time, Integral i) =>
time -> T time body -> T i body
resample time
rate =
   forall time i body.
(RealFrac time, Integral i) =>
T time body -> T i body
discretize forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall time0 time1 body.
(time0 -> time1) -> T time0 body -> T time1 body
mapTime (time
rateforall a. Num a => a -> a -> a
*)