{- |
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 = T body time -> T time body
forall time body. T body time -> T time body
Cons (T body time -> T time body)
-> (time -> T body time) -> time -> T time body
forall b c a. (b -> c) -> (a -> b) -> a -> c
. time -> T body time
forall b a. b -> T a b
Uniform.singleton

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



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

getTimes :: T time body -> [time]
getTimes :: forall time body. T time body -> [time]
getTimes = T body time -> [time]
forall a b. T a b -> [b]
Uniform.getSeconds (T body time -> [time])
-> (T time body -> T body time) -> T time body -> [time]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. T time body -> T body time
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 = (T time body, time) -> time
forall a b. (a, b) -> b
snd ((T time body, time) -> time)
-> (T time body -> (T time body, time)) -> T time body -> time
forall b c a. (b -> c) -> (a -> b) -> a -> c
. T time body -> (T time body, time)
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 = (T body time -> T body time) -> T time body -> T time body
forall body0 time0 body1 time1.
(T body0 time0 -> T body1 time1) -> T time0 body0 -> T time1 body1
lift (time -> body -> T body time -> T body time
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 =
   T body time -> T time body
forall time body. T body time -> T time body
Cons (T body time -> T time body) -> T body time -> T time body
forall a b. (a -> b) -> a -> b
$ (T body time -> body -> time -> T body time
forall a b. T a b -> a -> b -> T a b
Uniform.snoc (T body time -> body -> time -> T body time)
-> T time body -> body -> time -> T body time
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 =
   (T body time -> Maybe (body, T time body))
-> (time, T body time) -> (time, Maybe (body, T time body))
forall b c a. (b -> c) -> (a, b) -> (a, c)
mapSnd (((body, T body time) -> (body, T time body))
-> Maybe (body, T body time) -> Maybe (body, T time body)
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((T body time -> T time body)
-> (body, T body time) -> (body, T time body)
forall b c a. (b -> c) -> (a, b) -> (a, c)
mapSnd T body time -> T time body
forall time body. T body time -> T time body
Cons) (Maybe (body, T body time) -> Maybe (body, T time body))
-> (T body time -> Maybe (body, T body time))
-> T body time
-> Maybe (body, T time body)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. T body time -> Maybe (body, T body time)
forall a b. T a b -> Maybe (a, T a b)
Mixed.viewFirstL) ((time, T body time) -> (time, Maybe (body, T time body)))
-> (T time body -> (time, T body time))
-> T time body
-> (time, Maybe (body, T time body))
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
   T body time -> (time, T body time)
forall a b. T a b -> (b, T a b)
Mixed.viewSecondL (T body time -> (time, T body time))
-> (T time body -> T body time)
-> T time body
-> (time, T body time)
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
   T time body -> T body time
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 =
   (time -> a)
-> (time -> body -> T body time -> a) -> T body time -> a
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) (T time body -> a)
-> (T body time -> T time body) -> T body time -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. T body time -> T time body
forall time body. T body time -> T time body
Cons) (T body time -> a)
-> (T time body -> T body time) -> T time body -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
   T time body -> T body time
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 = (T body0 time -> T body1 time) -> T time body0 -> T time body1
forall body0 time0 body1 time1.
(T body0 time0 -> T body1 time1) -> T time0 body0 -> T time1 body1
lift ((T body0 time -> T body1 time) -> T time body0 -> T time body1)
-> ((body0 -> body1) -> T body0 time -> T body1 time)
-> (body0 -> body1)
-> T time body0
-> T time body1
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (body0 -> body1) -> T body0 time -> T body1 time
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 = (T body time0 -> T body time1) -> T time0 body -> T time1 body
forall body0 time0 body1 time1.
(T body0 time0 -> T body1 time1) -> T time0 body0 -> T time1 body1
lift ((T body time0 -> T body time1) -> T time0 body -> T time1 body)
-> ((time0 -> time1) -> T body time0 -> T body time1)
-> (time0 -> time1)
-> T time0 body
-> T time1 body
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (time0 -> time1) -> T body time0 -> T body time1
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 =
   (body -> m) -> (time -> m) -> T body time -> m
forall m time body.
Monoid m =>
(time -> m) -> (body -> m) -> T time body -> m
Uniform.concatMapMonoid body -> m
g time -> m
f (T body time -> m)
-> (T time body -> T body time) -> T time body -> m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. T time body -> T body time
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 = (T body0 time0 -> m (T body1 time1))
-> T time0 body0 -> m (T time1 body1)
forall (m :: * -> *) body0 time0 body1 time1.
Applicative m =>
(T body0 time0 -> m (T body1 time1))
-> T time0 body0 -> m (T time1 body1)
liftA ((body0 -> m body1)
-> (time0 -> m time1) -> T body0 time0 -> m (T body1 time1)
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 = (body -> m ()) -> (time -> m ()) -> T body time -> m ()
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 (T body time -> m ())
-> (T time body -> T body time) -> T time body -> m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. T time body -> T body time
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 = (T body0 time -> m (T body1 time))
-> T time body0 -> m (T time body1)
forall (m :: * -> *) body0 time0 body1 time1.
Applicative m =>
(T body0 time0 -> m (T body1 time1))
-> T time0 body0 -> m (T time1 body1)
liftA ((body0 -> m body1) -> T body0 time -> m (T body1 time)
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 = (T body time0 -> m (T body time1))
-> T time0 body -> m (T time1 body)
forall (m :: * -> *) body0 time0 body1 time1.
Applicative m =>
(T body0 time0 -> m (T body1 time1))
-> T time0 body0 -> m (T time1 body1)
liftA ((time0 -> m time1) -> T body time0 -> m (T body time1)
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 =
   WrappedMonad m (T time1 body1) -> m (T time1 body1)
forall (m :: * -> *) a. WrappedMonad m a -> m a
unwrapMonad (WrappedMonad m (T time1 body1) -> m (T time1 body1))
-> (T time0 body0 -> WrappedMonad m (T time1 body1))
-> T time0 body0
-> m (T time1 body1)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (time0 -> WrappedMonad m time1)
-> (body0 -> WrappedMonad m body1)
-> T time0 body0
-> WrappedMonad m (T time1 body1)
forall (m :: * -> *) time0 time1 body0 body1.
Applicative m =>
(time0 -> m time1)
-> (body0 -> m body1) -> T time0 body0 -> m (T time1 body1)
traverse (m time1 -> WrappedMonad m time1
forall (m :: * -> *) a. m a -> WrappedMonad m a
WrapMonad (m time1 -> WrappedMonad m time1)
-> (time0 -> m time1) -> time0 -> WrappedMonad m time1
forall b c a. (b -> c) -> (a -> b) -> a -> c
. time0 -> m time1
f) (m body1 -> WrappedMonad m body1
forall (m :: * -> *) a. m a -> WrappedMonad m a
WrapMonad (m body1 -> WrappedMonad m body1)
-> (body0 -> m body1) -> body0 -> WrappedMonad m body1
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 =
   WrappedMonad m () -> m ()
forall (m :: * -> *) a. WrappedMonad m a -> m a
unwrapMonad (WrappedMonad m () -> m ())
-> (T time body -> WrappedMonad m ()) -> T time body -> m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (time -> WrappedMonad m ())
-> (body -> WrappedMonad m ()) -> T time body -> WrappedMonad m ()
forall (m :: * -> *) time body.
Applicative m =>
(time -> m ()) -> (body -> m ()) -> T time body -> m ()
traverse_ (m () -> WrappedMonad m ()
forall (m :: * -> *) a. m a -> WrappedMonad m a
WrapMonad (m () -> WrappedMonad m ())
-> (time -> m ()) -> time -> WrappedMonad m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. time -> m ()
f) (m () -> WrappedMonad m ()
forall (m :: * -> *) a. m a -> WrappedMonad m a
WrapMonad (m () -> WrappedMonad m ())
-> (body -> m ()) -> body -> WrappedMonad m ()
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 = WrappedMonad m (T time body1) -> m (T time body1)
forall (m :: * -> *) a. WrappedMonad m a -> m a
unwrapMonad (WrappedMonad m (T time body1) -> m (T time body1))
-> (T time body0 -> WrappedMonad m (T time body1))
-> T time body0
-> m (T time body1)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (body0 -> WrappedMonad m body1)
-> T time body0 -> WrappedMonad m (T time body1)
forall (m :: * -> *) body0 body1 time.
Applicative m =>
(body0 -> m body1) -> T time body0 -> m (T time body1)
traverseBody (m body1 -> WrappedMonad m body1
forall (m :: * -> *) a. m a -> WrappedMonad m a
WrapMonad (m body1 -> WrappedMonad m body1)
-> (body0 -> m body1) -> body0 -> WrappedMonad m body1
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 = WrappedMonad m (T time1 body) -> m (T time1 body)
forall (m :: * -> *) a. WrappedMonad m a -> m a
unwrapMonad (WrappedMonad m (T time1 body) -> m (T time1 body))
-> (T time0 body -> WrappedMonad m (T time1 body))
-> T time0 body
-> m (T time1 body)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (time0 -> WrappedMonad m time1)
-> T time0 body -> WrappedMonad m (T time1 body)
forall (m :: * -> *) time0 time1 body.
Applicative m =>
(time0 -> m time1) -> T time0 body -> m (T time1 body)
traverseTime (m time1 -> WrappedMonad m time1
forall (m :: * -> *) a. m a -> WrappedMonad m a
WrapMonad (m time1 -> WrappedMonad m time1)
-> (time0 -> m time1) -> time0 -> WrappedMonad m time1
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 = (body -> b -> a) -> (time -> a -> b) -> a -> T body time -> b
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 (T body time -> b)
-> (T time body -> T body time) -> T time body -> b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. T time body -> T body time
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 = (body -> Maybe body) -> T time body -> T time body
forall time body0 body1.
Num time =>
(body0 -> Maybe body1) -> T time body0 -> T time body1
mapMaybe (\body
b -> Bool -> body -> Maybe body
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 = T time (Maybe body1) -> T time body1
forall time body. Num time => T time (Maybe body) -> T time body
catMaybes (T time (Maybe body1) -> T time body1)
-> (T time body0 -> T time (Maybe body1))
-> T time body0
-> T time body1
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (body0 -> Maybe body1) -> T time body0 -> T time (Maybe body1)
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 =
   (T time (Maybe body) -> T time body)
-> T time (Maybe body) -> T time body
forall time body0 body1.
(T time body0 -> T time body1) -> T time body0 -> T time body1
mapTimeInit T time (Maybe body) -> T time body
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 =
   (T time body -> time -> (T time body, T time body))
-> T time body -> (T time body, T time body)
forall time body a. (T time body -> time -> a) -> T time body -> a
switchTimeR
   (\ T time body
xs time
t ->
      (T time body -> T time body, T time body -> T time body)
-> (T time body, T time body) -> (T time body, T time body)
forall a c b d. (a -> c, b -> d) -> (a, b) -> (c, d)
mapPair
         ((T time body -> time -> T time body)
-> time -> T time body -> T time body
forall a b c. (a -> b -> c) -> b -> a -> c
flip T time body -> time -> T time body
forall time body. T time body -> time -> T time body
snocTime time
t, (T time body -> time -> T time body)
-> time -> T time body -> T time body
forall a b c. (a -> b -> c) -> b -> a -> c
flip T time body -> time -> T time body
forall time body. T time body -> time -> T time body
snocTime time
t)
         ((body -> Bool) -> T time body -> (T time body, T time body)
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 =
   (T time body -> Maybe body)
-> ((body -> Bool) -> T time body -> (T time body, T time body))
-> (body -> a)
-> T time body
-> [(a, T time body)]
forall a eventlist body.
Eq a =>
(eventlist -> Maybe body)
-> ((body -> Bool) -> eventlist -> (eventlist, eventlist))
-> (body -> a)
-> eventlist
-> [(a, eventlist)]
Utility.slice
      (((body, T time body) -> body)
-> Maybe (body, T time body) -> Maybe body
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (body, T time body) -> body
forall a b. (a, b) -> a
fst (Maybe (body, T time body) -> Maybe body)
-> (T time body -> Maybe (body, T time body))
-> T time body
-> Maybe body
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (time, Maybe (body, T time body)) -> Maybe (body, T time body)
forall a b. (a, b) -> b
snd ((time, Maybe (body, T time body)) -> Maybe (body, T time body))
-> (T time body -> (time, Maybe (body, T time body)))
-> T time body
-> Maybe (body, T time body)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. T time body -> (time, Maybe (body, T time body))
forall time body. T time body -> (time, Maybe (body, T time body))
viewL)
      (body -> Bool) -> T time body -> (T time body, T time body)
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 =
   T [body] time -> T time [body]
forall time body. T body time -> T time body
Cons (T [body] time -> T time [body])
-> (T time body -> T [body] time) -> T time body -> T time [body]
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
   (time -> T body time -> T [body] time)
-> T body time -> T [body] time
forall b a c. (b -> T a b -> c) -> T a b -> c
Mixed.switchSecondL
   (\ time
t0 ->
      time -> T [body] time -> T [body] time
forall b a. b -> T a b -> T a b
Mixed.consSecond time
t0 (T [body] time -> T [body] time)
-> (T body time -> T [body] time) -> T body time -> T [body] time
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
      (T time body -> T time [body]) -> T body time -> T [body] time
forall a b0 b1. (T a b0 -> T a b1) -> T b0 a -> T b1 a
Mixed.mapFirstInit
         (T (Maybe time) body -> T time [body]
forall a b. T (Maybe a) b -> T a [b]
Uniform.catMaybesFirst (T (Maybe time) body -> T time [body])
-> (T time body -> T (Maybe time) body)
-> T time body
-> T time [body]
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
          (State (Maybe time) (T (Maybe time) body)
 -> Maybe time -> T (Maybe time) body)
-> Maybe time
-> State (Maybe time) (T (Maybe time) body)
-> T (Maybe time) body
forall a b c. (a -> b -> c) -> b -> a -> c
flip State (Maybe time) (T (Maybe time) body)
-> Maybe time -> T (Maybe time) body
forall s a. State s a -> s -> a
evalState (time -> Maybe time
forall a. a -> Maybe a
Just time
t0) (State (Maybe time) (T (Maybe time) body) -> T (Maybe time) body)
-> (T time body -> State (Maybe time) (T (Maybe time) body))
-> T time body
-> T (Maybe time) body
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
          (Maybe time -> StateT (Maybe time) Identity (Maybe time))
-> T (Maybe time) body -> State (Maybe time) (T (Maybe time) body)
forall (m :: * -> *) a0 a1 b.
Applicative m =>
(a0 -> m a1) -> T a0 b -> m (T a1 b)
Uniform.traverseFirst (\Maybe time
time -> (Maybe time -> (Maybe time, Maybe time))
-> StateT (Maybe time) Identity (Maybe time)
forall (m :: * -> *) s a. Monad m => (s -> (a, s)) -> StateT s m a
state ((Maybe time -> (Maybe time, Maybe time))
 -> StateT (Maybe time) Identity (Maybe time))
-> (Maybe time -> (Maybe time, Maybe time))
-> StateT (Maybe time) Identity (Maybe time)
forall a b. (a -> b) -> a -> b
$ \ Maybe time
oldTime ->
             (Bool -> Maybe ()
forall (f :: * -> *). Alternative f => Bool -> f ()
Monad.guard (Maybe time
time Maybe time -> Maybe time -> Bool
forall a. Eq a => a -> a -> Bool
/= Maybe time
oldTime) Maybe () -> Maybe time -> Maybe time
forall a b. Maybe a -> Maybe b -> Maybe b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Maybe time
time, Maybe time
time)) (T (Maybe time) body -> State (Maybe time) (T (Maybe time) body))
-> (T time body -> T (Maybe time) body)
-> T time body
-> State (Maybe time) (T (Maybe time) body)
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
          (time -> Maybe time) -> T time body -> T (Maybe time) body
forall a0 a1 b. (a0 -> a1) -> T a0 b -> T a1 b
Uniform.mapFirst time -> Maybe time
forall a. a -> Maybe a
Just)) (T body time -> T [body] time)
-> (T time body -> T body time) -> T time body -> T [body] time
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
   T time body -> T body time
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 = (T time [body] -> T time body) -> T time [body] -> T time body
forall time body0 body1.
(T time body0 -> T time body1) -> T time body0 -> T time body1
mapTimeInit T time [body] -> T time body
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 = T time [b] -> T time b
forall time body. Ord time => T time [body] -> T time body
flatten (T time [b] -> T time b)
-> (T time a -> T time [b]) -> T time a -> T time b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([a] -> [b]) -> T time [a] -> T time [b]
forall body0 body1 time.
(body0 -> body1) -> T time body0 -> T time body1
mapBody [a] -> [b]
f (T time [a] -> T time [b])
-> (T time a -> T time [a]) -> T time a -> T time [b]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. T time a -> T time [a]
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 = ([body] -> [body]) -> T time body -> T time body
forall time a b. Ord time => ([a] -> [b]) -> T time a -> T time b
mapCoincident [body] -> [body]
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 =
   ([body] -> Bool) -> [[body]] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
List.all [body] -> Bool
forall a. Ord a => [a] -> Bool
isAscending ([[body]] -> Bool)
-> (T time body -> [[body]]) -> T time body -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. T time [body] -> [[body]]
forall time body. T time body -> [body]
getBodies (T time [body] -> [[body]])
-> (T time body -> T time [body]) -> T time body -> [[body]]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. T time body -> T time [body]
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 = (body -> body -> Bool) -> T time body -> T time body -> T time body
forall time body.
Ord time =>
(body -> body -> Bool) -> T time body -> T time body -> T time body
mergeBy body -> body -> Bool
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) = T time body -> (T time body, time)
forall time body. T time body -> (T time body, time)
viewTimeR T time body
xs0
       (T time body
ys,time
yt) = T time body -> (T time body, time)
forall time body. T time body -> (T time body, time)
viewTimeR T time body
ys0
   in  T time body -> time -> T time body
forall time body. T time body -> time -> T time body
snocTime
          ((body -> body -> Bool) -> T time body -> T time body -> T time body
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)
          (time -> time -> time
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 = (body -> body -> Bool)
-> time -> body -> T time body -> T time body
forall time body.
Ord time =>
(body -> body -> Bool)
-> time -> body -> T time body -> T time body
insertBy body -> body -> Bool
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  (time -> T time body)
-> ((time, body) -> T time body -> T time body)
-> T time body
-> T time body
forall time a body.
(time -> a)
-> ((time, body) -> T time body -> a) -> T time body -> a
switchL
          (\time
t1 -> (time -> body -> T time body -> T time body)
-> (time, body) -> T time body -> T time body
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry time -> body -> T time body -> T time body
forall time body. time -> body -> T time body -> T time body
cons (time, body)
mev0 (T time body -> T time body) -> T time body -> T time body
forall a b. (a -> b) -> a -> b
$ time -> T time body
forall time body. time -> T time body
pause (time -> time -> time
forall a. Ord a => a -> a -> a
max time
t0 time
t1))
          (\(time, body)
mev1 T time body
mevs ->
              if (body -> body -> Bool) -> (time, body) -> (time, body) -> Bool
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 (time -> body -> T time body -> T time body)
-> (time, body) -> T time body -> T time body
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry time -> body -> T time body -> T time body
forall time body. time -> body -> T time body -> T time body
cons (time, body)
mev0 (T time body -> T time body) -> T time body -> T time body
forall a b. (a -> b) -> a -> b
$ T time body
mevs1
                else (time -> body -> T time body -> T time body)
-> (time, body) -> T time body -> T time body
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry time -> body -> T time body -> T time body
forall time body. time -> body -> T time body -> T time body
cons (time, body)
mev1 (T time body -> T time body) -> T time body -> T time body
forall a b. (a -> b) -> a -> b
$ (time -> body -> T time body -> T time body)
-> (time, body) -> T time body -> T time body
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry ((body -> body -> Bool)
-> time -> body -> T time body -> T time body
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 =
   (T time (time, body) -> T time body)
-> T time (time, body) -> T time body
forall time body0 body1.
(T time body0 -> T time body1) -> T time body0 -> T time body1
mapTimeInit T time (time, body) -> T time body
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 =
   (T time body -> time -> T time body -> T time body)
-> T time body -> T time body -> T time body
forall time body a. (T time body -> time -> a) -> T time body -> a
switchTimeR
   (\T time body
xs time
t -> (T body time -> T body time) -> T time body -> T time body
forall body0 time0 body1 time1.
(T body0 time0 -> T body1 time1) -> T time0 body0 -> T time1 body1
lift (T time body -> T body time -> T body time
forall b a. T b a -> T a b -> T a b
Mixed.appendDisparateUniform (T time body -> T body time -> T body time)
-> T time body -> T body time -> T body time
forall time body a. (T time body -> a) -> T time body -> a
$~ T time body
xs) (T time body -> T time body)
-> (T time body -> T time body) -> T time body -> T time body
forall b c a. (b -> c) -> (a -> b) -> a -> c
. time -> T time body -> T time body
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 = (time -> time -> time) -> time -> [time] -> [time]
forall b a. (b -> a -> b) -> b -> [a] -> [b]
List.scanl time -> time -> time
forall a. Num a => a -> a -> a
(+) time
0 ((T time body -> time) -> [T time body] -> [time]
forall a b. (a -> b) -> [a] -> [b]
List.map T time body -> time
forall time body. Num time => T time body -> time
duration [T time body]
xs)
       ([time]
ts,time
dur) =
          ([time], time) -> Maybe ([time], time) -> ([time], time)
forall a. a -> Maybe a -> a
fromMaybe
             ([Char] -> ([time], time)
forall a. HasCallStack => [Char] -> a
error [Char]
"list of accumulated times is always non-empty")
             ([time] -> Maybe ([time], time)
forall a. [a] -> Maybe ([a], a)
ListHT.viewR [time]
ts0)
   in  T time body -> time -> T time body
forall time body. T time body -> time -> T time body
snocTime
          (T time body -> T time body
forall time body. T time body -> T time body
TimeBodyPriv.Cons (T time body -> T time body) -> T time body -> T time body
forall a b. (a -> b) -> a -> b
$ [T time body] -> T time body
forall a b. [T a b] -> T a b
Disp.concat ([T time body] -> T time body) -> [T time body] -> T time body
forall a b. (a -> b) -> a -> b
$ (T time body -> T time body) -> [T time body] -> [T time body]
forall a b. (a -> b) -> [a] -> [b]
List.map T time body -> T time body
forall time body. T time body -> T time body
TimeBodyPriv.decons ([T time body] -> [T time body]) -> [T time body] -> [T time body]
forall a b. (a -> b) -> a -> b
$
           (time -> T time body -> T time body)
-> [time] -> [T time body] -> [T time body]
forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
List.zipWith time -> T time body -> T time body
forall time body.
(Ord time, Num time) =>
time -> T time body -> T time body
TimeBodyList.delay [time]
ts ((T time body -> T time body) -> [T time body] -> [T time body]
forall a b. (a -> b) -> [a] -> [b]
List.map ((T time body, time) -> T time body
forall a b. (a, b) -> a
fst ((T time body, time) -> T time body)
-> (T time body -> (T time body, time))
-> T time body
-> T time body
forall b c a. (b -> c) -> (a -> b) -> a -> c
. T time body -> (T time body, time)
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 = [T time body] -> T time body
forall time body.
(Ord time, Num time) =>
[T time body] -> T time body
concat ([T time body] -> T time body)
-> (T time body -> [T time body]) -> T time body -> T time body
forall b c a. (b -> c) -> (a -> b) -> a -> c
. T time body -> [T time body]
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 =
   T body time -> T time body
forall time body. T body time -> T time body
Cons (T body time -> T time body)
-> (T time body -> T body time) -> T time body -> T time body
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
   (time -> T body time -> T body time) -> T body time -> T body time
forall b a c. (b -> T a b -> c) -> T a b -> c
Mixed.switchSecondL
   (\ time
t T body time
xs ->
      time -> T body time -> T body time
forall b a. b -> T a b -> T a b
Mixed.consSecond
         (if time
ttime -> time -> Bool
forall a. Ord a => a -> a -> Bool
>=time
dif
            then time
ttime -> time -> time
forall a. Num a => a -> a -> a
-time
dif
            else [Char] -> time
forall a. HasCallStack => [Char] -> a
error [Char]
"decreaseStart: difference too big")
         ((time -> time) -> T body time -> T body time
forall b0 b1 a. (b0 -> b1) -> T a b0 -> T a b1
Disp.mapSecond (time -> time -> time
forall a. Num a => a -> a -> a
subtract time
dif) T body time
xs)) (T body time -> T body time)
-> (T time body -> T body time) -> T time body -> T body time
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
   T time body -> T body time
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
diftime -> time -> Bool
forall a. Ord a => a -> a -> Bool
>=time
0
     then (time -> time) -> T time body -> T time body
forall time0 time1 body.
(time0 -> time1) -> T time0 body -> T time1 body
mapTime (time
diftime -> time -> time
forall a. Num a => a -> a -> a
+)
     else [Char] -> T time body -> T time body
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 = (time -> i) -> T time body -> T i body
forall time0 time1 body.
(time0 -> time1) -> T time0 body -> T time1 body
mapTime time -> i
forall b. Integral b => time -> b
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 =
   T time body -> T i body
forall time i body.
(RealFrac time, Integral i) =>
T time body -> T i body
discretize (T time body -> T i body)
-> (T time body -> T time body) -> T time body -> T i body
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (time -> time) -> T time body -> T time body
forall time0 time1 body.
(time0 -> time1) -> T time0 body -> T time1 body
mapTime (time
ratetime -> time -> time
forall a. Num a => a -> a -> a
*)