module Data.EventList.Relative.TimeBody
(T,
empty, singleton, null,
viewL, viewR, switchL, switchR, cons, snoc,
fromPairList, toPairList,
getTimes, getBodies, duration,
mapBody, mapTime,
zipWithBody, zipWithTime, unzip,
concatMapMonoid,
traverse, traverse_, traverseBody, traverseTime,
mapM, mapM_, mapBodyM, mapTimeM,
foldr, foldrPair,
merge, mergeBy, insert, insertBy,
moveForward,
decreaseStart, delay, filter, partition, partitionMaybe, slice, span,
mapMaybe, catMaybes,
normalize, isNormalized,
collectCoincident, flatten, mapCoincident,
append, concat, cycle,
discretize, resample,
toAbsoluteEventList, fromAbsoluteEventList,
toAbsoluteEventListGen, fromAbsoluteEventListGen,
) where
import Data.EventList.Relative.TimeBodyPrivate
import qualified Data.EventList.Relative.BodyBodyPrivate as BodyBodyPriv
import qualified Data.EventList.Absolute.TimeBodyPrivate as AbsoluteEventPriv
import qualified Data.EventList.Absolute.TimeBody as AbsoluteEventList
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.EventList.Utility as Utility
import Control.Applicative (Applicative, WrappedMonad(WrapMonad, unwrapMonad), )
import Data.Monoid (Monoid, )
import qualified Numeric.NonNegative.Class as NonNeg
import Numeric.NonNegative.Class ((-|), zero, add, )
import Data.Tuple.HT (mapFst, mapSnd, mapPair, )
import Data.Maybe.HT (toMaybe, )
import Data.List.HT (isAscending, )
import Control.Monad.Trans.State (evalState, modify, get, put, )
import Control.Monad (Monad, return, (>>), )
import Data.Function (flip, const, (.), ($), )
import Data.Functor (fmap, )
import Data.Maybe (Maybe(Just, Nothing), maybe, )
import Data.Bool (Bool, not, (||), (&&), )
import Data.Tuple (uncurry, fst, snd, )
import Data.Ord (Ord, (<), )
import Data.Eq (Eq, (/=), )
import Prelude (Num, Integral, RealFrac, (*), (+), (-), error, )
empty :: T time body
empty :: forall time body. T time body
empty = forall time body. T time body -> T time body
Cons forall a b. T a b
Disp.empty
null :: T time body -> Bool
null :: forall time body. T time body -> Bool
null = forall a b. T a b -> Bool
Disp.null forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall time body. T time body -> T time body
decons
singleton :: time -> body -> T time body
singleton :: forall time body. time -> body -> T time body
singleton time
time body
body = forall time body. T time body -> T time body
Cons forall a b. (a -> b) -> a -> b
$ forall a b. a -> b -> T a b
Disp.singleton time
time body
body
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 time0 body0 time1 body1.
(T time0 body0 -> T time1 body1) -> T time0 body0 -> T time1 body1
lift (forall a b. a -> b -> T a b -> T a b
Disp.cons time
time body
body)
snoc :: T time body -> time -> body -> T time body
snoc :: forall time body. T time body -> time -> body -> T time body
snoc T time body
xs time
time body
body = forall time body. T time body -> T time body
Cons forall a b. (a -> b) -> a -> b
$ (forall a b. T a b -> a -> b -> T a b
Disp.snoc forall time body a. (T time body -> a) -> T time body -> a
$~* T time body
xs) time
time body
body
viewL :: T time body -> Maybe ((time, body), T time body)
viewL :: forall time body. T time body -> Maybe ((time, body), T time body)
viewL = 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 time body -> T time body
Cons) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. T a b -> Maybe ((a, b), T a b)
Disp.viewL forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall time body. T time body -> T time body
decons
viewR :: T time body -> Maybe (T time body, (time, body))
viewR :: forall time body. T time body -> Maybe (T time body, (time, body))
viewR = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (forall a c b. (a -> c) -> (a, b) -> (c, b)
mapFst forall time body. T time body -> T time body
Cons) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. T a b -> Maybe (T a b, (a, b))
Disp.viewR forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall time body. T time body -> T time body
decons
{-# INLINE switchL #-}
switchL :: c -> ((time, body) -> T time body -> c) -> T time body -> c
switchL :: forall c time body.
c -> ((time, body) -> T time body -> c) -> T time body -> c
switchL c
f (time, body) -> T time body -> c
g = forall c a b. c -> (a -> b -> T a b -> c) -> T a b -> c
Disp.switchL c
f (\ time
t body
b -> (time, body) -> T time body -> c
g (time
t,body
b) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall time body. T time body -> T time body
Cons) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall time body. T time body -> T time body
decons
{-# INLINE switchR #-}
switchR :: c -> (T time body -> (time, body) -> c) -> T time body -> c
switchR :: forall c time body.
c -> (T time body -> (time, body) -> c) -> T time body -> c
switchR c
f T time body -> (time, body) -> c
g = forall c a b. c -> (T a b -> a -> b -> c) -> T a b -> c
Disp.switchR c
f (\T time body
xs time
t body
b -> T time body -> (time, body) -> c
g (forall time body. T time body -> T time body
Cons T time body
xs) (time
t,body
b)) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall time body. T time body -> T time body
decons
fromPairList :: [(a,b)] -> T a b
fromPairList :: forall a b. [(a, b)] -> T a b
fromPairList = forall time body. T time body -> T time body
Cons forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. [(a, b)] -> T a b
Disp.fromPairList
toPairList :: T a b -> [(a,b)]
toPairList :: forall a b. T a b -> [(a, b)]
toPairList = forall a b. T a b -> [(a, b)]
Disp.toPairList forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall time body. T time body -> T time body
decons
getBodies :: T time body -> [body]
getBodies :: forall time body. T time body -> [body]
getBodies = forall a b. T a b -> [b]
Disp.getSeconds forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall time body. T time body -> T time body
decons
getTimes :: T time body -> [time]
getTimes :: forall time body. T time body -> [time]
getTimes = forall a b. T a b -> [a]
Disp.getFirsts forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall time body. T time body -> T time body
decons
duration :: NonNeg.C time => T time body -> time
duration :: forall time body. C time => T time body -> time
duration = forall a. C a => [a] -> a
NonNeg.sum forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall time body. T time body -> [time]
getTimes
mapBody :: (body0 -> body1) -> T time body0 -> T time body1
mapBody :: forall body0 body1 time.
(body0 -> body1) -> T time body0 -> T time body1
mapBody body0 -> body1
f = forall time0 body0 time1 body1.
(T time0 body0 -> T time1 body1) -> T time0 body0 -> T time1 body1
lift (forall b0 b1 a. (b0 -> b1) -> T a b0 -> T a b1
Disp.mapSecond body0 -> body1
f)
mapTime :: (time0 -> time1) -> T time0 body -> T time1 body
mapTime :: forall time0 time1 body.
(time0 -> time1) -> T time0 body -> T time1 body
mapTime time0 -> time1
f = forall time0 body0 time1 body1.
(T time0 body0 -> T time1 body1) -> T time0 body0 -> T time1 body1
lift (forall a0 a1 b. (a0 -> a1) -> T a0 b -> T a1 b
Disp.mapFirst time0 -> time1
f)
zipWithBody ::
(body0 -> body1 -> body2) ->
[body0] -> T time body1 -> T time body2
zipWithBody :: forall body0 body1 body2 time.
(body0 -> body1 -> body2)
-> [body0] -> T time body1 -> T time body2
zipWithBody body0 -> body1 -> body2
f = forall time0 body0 time1 body1.
(T time0 body0 -> T time1 body1) -> T time0 body0 -> T time1 body1
lift forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall b0 b1 b2 a. (b0 -> b1 -> b2) -> [b0] -> T a b1 -> T a b2
Disp.zipWithSecond body0 -> body1 -> body2
f
zipWithTime ::
(time0 -> time1 -> time2) ->
[time0] -> T time1 body -> T time2 body
zipWithTime :: forall time0 time1 time2 body.
(time0 -> time1 -> time2)
-> [time0] -> T time1 body -> T time2 body
zipWithTime time0 -> time1 -> time2
f = forall time0 body0 time1 body1.
(T time0 body0 -> T time1 body1) -> T time0 body0 -> T time1 body1
lift forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a0 a1 a2 b. (a0 -> a1 -> a2) -> [a0] -> T a1 b -> T a2 b
Disp.zipWithFirst time0 -> time1 -> time2
f
unzip :: T time (body0, body1) -> (T time body0, T time body1)
unzip :: forall time body0 body1.
T time (body0, body1) -> (T time body0, T time body1)
unzip =
forall time body a.
(time -> body -> a -> a) -> a -> T time body -> a
foldrPair
(\time
time (body0
body0, body1
body1) ->
forall a c b d. (a -> c, b -> d) -> (a, b) -> (c, d)
mapPair (forall time body. time -> body -> T time body -> T time body
cons time
time body0
body0, forall time body. time -> body -> T time body -> T time body
cons time
time body1
body1))
(forall time body. T time body
empty, forall time body. T time body
empty)
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
Disp.concatMapMonoid time -> m
f body -> m
g forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall time body. T time body -> T time body
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 :: * -> *) time0 body0 time1 body1.
Applicative m =>
(T time0 body0 -> m (T time1 body1))
-> 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)
Disp.traverse time0 -> m time1
f body0 -> m body1
g)
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
Disp.traverse_ time -> m ()
f body -> m ()
g forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall time body. T time body -> T time body
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 :: * -> *) time0 body0 time1 body1.
Applicative m =>
(T time0 body0 -> m (T time1 body1))
-> 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)
Disp.traverseSecond 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 :: * -> *) time0 body0 time1 body1.
Applicative m =>
(T time0 body0 -> m (T time1 body1))
-> 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)
Disp.traverseFirst 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) -> b -> T time body -> b
foldr :: forall time a b body.
(time -> a -> b) -> (body -> b -> a) -> b -> T time body -> b
foldr time -> a -> b
f body -> b -> a
g b
x = forall a c d b. (a -> c -> d) -> (b -> d -> c) -> d -> T a b -> d
Disp.foldr time -> a -> b
f body -> b -> a
g b
x forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall time body. T time body -> T time body
decons
foldrPair :: (time -> body -> a -> a) -> a -> T time body -> a
foldrPair :: forall time body a.
(time -> body -> a -> a) -> a -> T time body -> a
foldrPair time -> body -> a -> a
f a
x = forall a b c. (a -> b -> c -> c) -> c -> T a b -> c
Disp.foldrPair time -> body -> a -> a
f a
x forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall time body. T time body -> T time body
decons
filter :: (NonNeg.C time) =>
(body -> Bool) -> T time body -> T time body
filter :: forall time body.
C time =>
(body -> Bool) -> T time body -> T time body
filter body -> Bool
p = forall time body0 body1.
C 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 :: (NonNeg.C time) =>
(body0 -> Maybe body1) ->
T time body0 -> T time body1
mapMaybe :: forall time body0 body1.
C time =>
(body0 -> Maybe body1) -> T time body0 -> T time body1
mapMaybe body0 -> Maybe body1
f = forall time body. C 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 :: (NonNeg.C time) =>
T time (Maybe body) -> T time body
catMaybes :: forall time body. C time => T time (Maybe body) -> T time body
catMaybes =
forall time body. T time body -> T time body
Cons forall b c a. (b -> c) -> (a -> b) -> a -> c
.
forall a b. (a, b) -> a
fst forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. T a b -> (T b a, b)
Mixed.viewSecondR forall b c a. (b -> c) -> (a -> b) -> a -> c
.
forall b0 b1 a. (b0 -> b1) -> T a b0 -> T a b1
Uniform.mapSecond forall a. C a => [a] -> a
NonNeg.sum forall b c a. (b -> c) -> (a -> b) -> a -> c
.
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 b a. T b a -> b -> T a b
Mixed.snocSecond (forall a. HasCallStack => [Char] -> a
error [Char]
"catMaybes: no trailing time") forall b c a. (b -> c) -> (a -> b) -> a -> c
.
forall time body. T time body -> T time body
decons
partition :: (NonNeg.C time) =>
(body -> Bool) -> T time body -> (T time body, T time body)
partition :: forall time body.
C time =>
(body -> Bool) -> T time body -> (T time body, T time body)
partition body -> Bool
p = forall time body.
C time =>
(body -> Bool)
-> time -> time -> T time body -> (T time body, T time body)
partitionRec body -> Bool
p forall a. C a => a
zero forall a. C a => a
zero
partitionRec :: (NonNeg.C time) =>
(body -> Bool) -> time -> time ->
T time body -> (T time body, T time body)
partitionRec :: forall time body.
C time =>
(body -> Bool)
-> time -> time -> T time body -> (T time body, T time body)
partitionRec body -> Bool
p =
let recourse :: t -> t -> T t body -> (T t body, T t body)
recourse t
t0 t
t1 =
forall c time body.
c -> ((time, body) -> T time body -> c) -> T time body -> c
switchL
(forall time body. T time body
empty, forall time body. T time body
empty)
(\ (t
t, body
b) T t body
es ->
let t0' :: t
t0' = forall a. C a => a -> a -> a
add t
t0 t
t
t1' :: t
t1' = forall a. C a => a -> a -> a
add t
t1 t
t
in if body -> Bool
p body
b
then forall a c b. (a -> c) -> (a, b) -> (c, b)
mapFst (forall time body. time -> body -> T time body -> T time body
cons t
t0' body
b) (t -> t -> T t body -> (T t body, T t body)
recourse forall a. C a => a
zero t
t1' T t body
es)
else forall b c a. (b -> c) -> (a, b) -> (a, c)
mapSnd (forall time body. time -> body -> T time body -> T time body
cons t
t1' body
b) (t -> t -> T t body -> (T t body, T t body)
recourse t
t0' forall a. C a => a
zero T t body
es))
in forall {t}. C t => t -> t -> T t body -> (T t body, T t body)
recourse
partitionMaybe :: (NonNeg.C time) =>
(body0 -> Maybe body1) -> T time body0 ->
(T time body1, T time body0)
partitionMaybe :: forall time body0 body1.
C time =>
(body0 -> Maybe body1)
-> T time body0 -> (T time body1, T time body0)
partitionMaybe body0 -> Maybe body1
f =
forall a c b d. (a -> c, b -> d) -> (a, b) -> (c, d)
mapPair (forall time body. C time => T time (Maybe body) -> T time body
catMaybes, forall time body. C time => T time (Maybe body) -> T time body
catMaybes) forall b c a. (b -> c) -> (a -> b) -> a -> c
.
forall time body a.
(time -> body -> a -> a) -> a -> T time body -> a
foldrPair (\time
t body0
a ->
let mb :: Maybe body1
mb = body0 -> Maybe body1
f body0
a
a1 :: Maybe body0
a1 = forall b a. b -> (a -> b) -> Maybe a -> b
maybe (forall a. a -> Maybe a
Just body0
a) (forall a b. a -> b -> a
const forall a. Maybe a
Nothing) Maybe body1
mb
in forall a c b d. (a -> c, b -> d) -> (a, b) -> (c, d)
mapPair (forall time body. time -> body -> T time body -> T time body
cons time
t Maybe body1
mb, forall time body. time -> body -> T time body -> T time body
cons time
t Maybe body0
a1))
(forall time body. T time body
empty, forall time body. T time body
empty)
slice :: (Eq a, NonNeg.C time) =>
(body -> a) -> T time body -> [(a, T time body)]
slice :: forall a time body.
(Eq a, C 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) -> b
snd forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a, b) -> a
fst) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall time body. T time body -> Maybe ((time, body), T time body)
viewL) forall time body.
C time =>
(body -> Bool) -> T time body -> (T time body, T time body)
partition
span :: (body -> Bool) -> T time body -> (T time body, T time body)
span :: forall body time.
(body -> Bool) -> T time body -> (T time body, T time body)
span body -> Bool
p = forall a c b d. (a -> c, b -> d) -> (a, b) -> (c, d)
mapPair (forall time body. T time body -> T time body
Cons, forall time body. T time body -> T time body
Cons) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall b a. (b -> Bool) -> T a b -> (T a b, T a b)
Disp.spanSecond body -> Bool
p forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall time body. T time body -> T time body
decons
collectCoincident :: (NonNeg.C time) => T time body -> T time [body]
collectCoincident :: forall time body. C time => T time body -> T time [body]
collectCoincident =
forall time body0 body1.
(T time body0 -> T time body1) -> T time body0 -> T time body1
mapTimeTail forall a b. (a -> b) -> a -> b
$ forall time0 body0 time1 body1.
(T time0 body0 -> T time1 body1) -> T time0 body0 -> T time1 body1
BodyBodyPriv.lift forall a b. (a -> b) -> a -> b
$ forall a b. (a -> Bool) -> T a b -> T a [b]
Uniform.filterFirst (forall a. C a => a
zero forall a. Ord a => a -> a -> Bool
<)
flatten :: (NonNeg.C time) => T time [body] -> T time body
flatten :: forall time body. C time => T time [body] -> T time body
flatten =
forall time body. T time body -> T time body
Cons forall b c a. (b -> c) -> (a -> b) -> a -> c
.
forall c a b. c -> (a -> T a b -> c) -> T a b -> c
Mixed.switchFirstL
forall a b. T a b
Disp.empty
(\time
time ->
forall time0 body0 time1 body1.
(T time0 body0 -> T time1 body1) -> T time0 body0 -> T time1 body1
unlift (forall time body. C time => time -> T time body -> T time body
delay time
time) forall b c a. (b -> c) -> (a -> b) -> a -> c
.
forall a b. (a, b) -> a
fst forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. T a b -> (T b a, b)
Mixed.viewSecondR forall b c a. (b -> c) -> (a -> b) -> a -> c
.
forall a c d b. (a -> c -> d) -> (b -> d -> c) -> d -> T a b -> c
Uniform.foldr
(forall a b. T a b -> T b a -> T b a
Mixed.appendUniformUniform forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. a -> [b] -> T a b
Uniform.fromSecondList forall a. C a => a
zero)
forall b a. b -> T a b -> T a b
Mixed.consSecond forall a b. T a b
Disp.empty forall b c a. (b -> c) -> (a -> b) -> a -> c
.
forall b0 b1 a. (b0 -> b1) -> T a b0 -> T a b1
Uniform.mapSecond forall a. C a => [a] -> a
NonNeg.sum forall b c a. (b -> c) -> (a -> b) -> a -> c
.
forall b a. (b -> Bool) -> T a b -> T b [a]
Uniform.filterSecond (Bool -> Bool
not forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (t :: * -> *) a. Foldable t => t a -> Bool
List.null)) forall b c a. (b -> c) -> (a -> b) -> a -> c
.
forall time body. T time body -> T time body
decons
mapCoincident :: (NonNeg.C time) =>
([a] -> [b]) -> T time a -> T time b
mapCoincident :: forall time a b. C time => ([a] -> [b]) -> T time a -> T time b
mapCoincident [a] -> [b]
f = forall time body. C 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. C time => T time body -> T time [body]
collectCoincident
normalize :: (NonNeg.C time, Ord body) => T time body -> T time body
normalize :: forall time body. (C time, Ord body) => T time body -> T time body
normalize = forall time a b. C time => ([a] -> [b]) -> T time a -> T time b
mapCoincident forall a. Ord a => [a] -> [a]
List.sort
isNormalized :: (NonNeg.C time, Ord body) =>
T time body -> Bool
isNormalized :: forall time body. (C 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. C time => T time body -> T time [body]
collectCoincident
merge :: (NonNeg.C time, Ord body) =>
T time body -> T time body -> T time body
merge :: forall time body.
(C time, Ord body) =>
T time body -> T time body -> T time body
merge = forall time body.
C time =>
(body -> body -> Bool) -> T time body -> T time body -> T time body
mergeBy forall a. Ord a => a -> a -> Bool
(<)
mergeBy :: (NonNeg.C time) =>
(body -> body -> Bool) ->
T time body -> T time body -> T time body
mergeBy :: forall time body.
C time =>
(body -> body -> Bool) -> T time body -> T time body -> T time body
mergeBy body -> body -> Bool
before =
let recourse :: T time body -> T time body -> T time body
recourse T time body
xs0 T time body
ys0 =
case (forall time body. T time body -> Maybe ((time, body), T time body)
viewL T time body
xs0, forall time body. T time body -> Maybe ((time, body), T time body)
viewL T time body
ys0) of
(Maybe ((time, body), T time body)
Nothing, Maybe ((time, body), T time body)
_) -> T time body
ys0
(Maybe ((time, body), T time body)
_, Maybe ((time, body), T time body)
Nothing) -> T time body
xs0
(Just ((time
xt,body
xb),T time body
xs), Just ((time
yt,body
yb),T time body
ys)) ->
let (time
mt,~(Bool
b,time
dt)) = forall a. C a => a -> a -> (a, (Bool, a))
NonNeg.split time
xt time
yt
in forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry (forall time body. time -> body -> T time body -> T time body
cons time
mt) forall a b. (a -> b) -> a -> b
$
if Bool
b Bool -> Bool -> Bool
&& (time
dtforall a. Eq a => a -> a -> Bool
/=forall a. C a => a
zero Bool -> Bool -> Bool
|| body -> body -> Bool
before body
xb body
yb)
then (body
xb, T time body -> T time body -> T time body
recourse T time body
xs forall a b. (a -> b) -> a -> b
$ forall time body. time -> body -> T time body -> T time body
cons time
dt body
yb T time body
ys)
else (body
yb, T time body -> T time body -> T time body
recourse T time body
ys forall a b. (a -> b) -> a -> b
$ forall time body. time -> body -> T time body -> T time body
cons time
dt body
xb T time body
xs)
in forall {time}. C time => T time body -> T time body -> T time body
recourse
insert :: (NonNeg.C time, Ord body) =>
time -> body -> T time body -> T time body
insert :: forall time body.
(C time, Ord body) =>
time -> body -> T time body -> T time body
insert = forall time body.
C time =>
(body -> body -> Bool)
-> time -> body -> T time body -> T time body
insertBy forall a. Ord a => a -> a -> Bool
(<)
insertBy :: (NonNeg.C time) =>
(body -> body -> Bool) ->
time -> body -> T time body -> T time body
insertBy :: forall time body.
C time =>
(body -> body -> Bool)
-> time -> body -> T time body -> T time body
insertBy body -> body -> Bool
before =
let recourse :: t -> body -> T t body -> T t body
recourse t
t0 body
me0 =
(\ ~((t
t,body
me), T t body
rest) -> forall time body. time -> body -> T time body -> T time body
cons t
t body
me T t body
rest) forall b c a. (b -> c) -> (a -> b) -> a -> c
.
forall c time body.
c -> ((time, body) -> T time body -> c) -> T time body -> c
switchL
((t
t0,body
me0), forall time body. T time body
empty)
(\(t
t1, body
me1) T t body
mevs ->
let (t
mt,~(Bool
b,t
dt)) = forall a. C a => a -> a -> (a, (Bool, a))
NonNeg.split t
t0 t
t1
in forall a c b. (a -> c) -> (a, b) -> (c, b)
mapFst ((,) t
mt) forall a b. (a -> b) -> a -> b
$
if Bool
b Bool -> Bool -> Bool
&& (t
dtforall a. Eq a => a -> a -> Bool
/=forall a. C a => a
zero Bool -> Bool -> Bool
|| body -> body -> Bool
before body
me0 body
me1)
then (body
me0, forall time body. time -> body -> T time body -> T time body
cons t
dt body
me1 T t body
mevs)
else (body
me1, t -> body -> T t body -> T t body
recourse t
dt body
me0 T t body
mevs))
in forall {t}. C t => t -> body -> T t body -> T t body
recourse
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 body. Num time => T time body -> T time body
fromAbsoluteEventList forall b c a. (b -> c) -> (a -> b) -> a -> c
.
forall time body.
(Ord time, Num time) =>
T time (time, body) -> T time body
AbsoluteEventList.moveForward forall b c a. (b -> c) -> (a -> b) -> a -> c
.
forall time body. Num time => time -> T time body -> T time body
toAbsoluteEventList time
0
append :: T time body -> T time body -> T time body
append :: forall time body. T time body -> T time body -> T time body
append T time body
xs = forall time0 body0 time1 body1.
(T time0 body0 -> T time1 body1) -> T time0 body0 -> T time1 body1
lift (forall a b. T a b -> T a b -> T a b
Disp.append forall time body a. (T time body -> a) -> T time body -> a
$~* T time body
xs)
concat :: [T time body] -> T time body
concat :: forall time body. [T time body] -> T time body
concat = forall time body. T time body -> T time body
Cons forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. [T a b] -> T a b
Disp.concat forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> b) -> [a] -> [b]
List.map forall time body. T time body -> T time body
decons
cycle :: T time body -> T time body
cycle :: forall time body. T time body -> T time body
cycle = forall time0 body0 time1 body1.
(T time0 body0 -> T time1 body1) -> T time0 body0 -> T time1 body1
lift forall a b. T a b -> T a b
Disp.cycle
decreaseStart :: (NonNeg.C time) =>
time -> T time body -> T time body
decreaseStart :: forall time body. C time => time -> T time body -> T time body
decreaseStart time
dif =
forall time body. (time -> time) -> T time body -> T time body
mapTimeHead (forall a. C a => a -> a -> a
-| time
dif)
delay :: (NonNeg.C time) =>
time -> T time body -> T time body
delay :: forall time body. C time => time -> T time body -> T time body
delay time
dif =
forall time body. (time -> time) -> T time body -> T time body
mapTimeHead (forall a. C a => a -> a -> a
add time
dif)
discretize :: (NonNeg.C time, RealFrac time, NonNeg.C i, Integral i) =>
T time body -> T i body
discretize :: forall time i body.
(C time, RealFrac time, C i, Integral i) =>
T time body -> T i body
discretize =
forall a b c. (a -> b -> c) -> b -> a -> c
flip forall s a. State s a -> s -> a
evalState time
0.5 forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) time0 time1 body.
Monad m =>
(time0 -> m time1) -> T time0 body -> m (T time1 body)
mapTimeM forall t i. (RealFrac t, Integral i) => t -> State t i
Utility.floorDiff
resample :: (NonNeg.C time, RealFrac time, NonNeg.C i, Integral i) =>
time -> T time body -> T i body
resample :: forall time i body.
(C time, RealFrac time, C i, Integral i) =>
time -> T time body -> T i body
resample time
rate =
forall time i body.
(C time, RealFrac time, C i, 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
*)
toAbsoluteEventList :: (Num time) =>
time -> T time body -> AbsoluteEventList.T time body
toAbsoluteEventList :: forall time body. Num time => time -> T time body -> T time body
toAbsoluteEventList = forall absTime relTime body.
(absTime -> relTime -> absTime)
-> absTime -> T relTime body -> T absTime body
toAbsoluteEventListGen forall a. Num a => a -> a -> a
(+)
fromAbsoluteEventList :: (Num time) =>
AbsoluteEventList.T time body -> T time body
fromAbsoluteEventList :: forall time body. Num time => T time body -> T time body
fromAbsoluteEventList = forall absTime relTime body.
(absTime -> absTime -> relTime)
-> absTime -> T absTime body -> T relTime body
fromAbsoluteEventListGen (-) time
0
toAbsoluteEventListGen ::
(absTime -> relTime -> absTime) ->
absTime -> T relTime body -> AbsoluteEventList.T absTime body
toAbsoluteEventListGen :: forall absTime relTime body.
(absTime -> relTime -> absTime)
-> absTime -> T relTime body -> T absTime body
toAbsoluteEventListGen absTime -> relTime -> absTime
accum absTime
start =
forall time body. T time body -> T time body
AbsoluteEventPriv.Cons forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall time body. T time body -> T time body
decons 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 absTime
start forall b c a. (b -> c) -> (a -> b) -> a -> c
.
forall (m :: * -> *) time0 time1 body.
Monad m =>
(time0 -> m time1) -> T time0 body -> m (T time1 body)
mapTimeM (\relTime
dur -> forall (m :: * -> *) s. Monad m => (s -> s) -> StateT s m ()
modify (forall a b c. (a -> b -> c) -> b -> a -> c
flip absTime -> relTime -> absTime
accum relTime
dur) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) s. Monad m => StateT s m s
get)
fromAbsoluteEventListGen ::
(absTime -> absTime -> relTime) ->
absTime ->
AbsoluteEventList.T absTime body -> T relTime body
fromAbsoluteEventListGen :: forall absTime relTime body.
(absTime -> absTime -> relTime)
-> absTime -> T absTime body -> T relTime body
fromAbsoluteEventListGen absTime -> absTime -> relTime
diff absTime
start =
forall a b c. (a -> b -> c) -> b -> a -> c
flip forall s a. State s a -> s -> a
evalState absTime
start forall b c a. (b -> c) -> (a -> b) -> a -> c
.
forall (m :: * -> *) time0 time1 body.
Monad m =>
(time0 -> m time1) -> T time0 body -> m (T time1 body)
mapTimeM
(\absTime
time -> do absTime
lastTime <- forall (m :: * -> *) s. Monad m => StateT s m s
get; forall (m :: * -> *) s. Monad m => s -> StateT s m ()
put absTime
time; forall (m :: * -> *) a. Monad m => a -> m a
return (absTime -> absTime -> relTime
diff absTime
time absTime
lastTime)) forall b c a. (b -> c) -> (a -> b) -> a -> c
.
forall time body. T time body -> T time body
Cons forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall time body. T time body -> T time body
AbsoluteEventPriv.decons