Read the environment variable, i.e. the TimeInfo.

Utility to apply functions to the current TimeInfo, such as record selectors: printAbsoluteTime :: ClSF IO cl () () printAbsoluteTime = timeInfoOf absolute >>> arrMCl print

Continuously return the time difference since the last tick.

Continuously return the time difference since clock initialisation.

Continuously return the absolute time.

Continuously return the tag of the current tick.

Calculate the time passed since this ClSF was instantiated, i.e. since the first tick on which this ClSF was run.

This is _not_ the same as sinceInitS, which measures the time since clock initialisation.

For example, the following gives a sawtooth signal:

sawtooth = safely $ do
  try $ sinceStart >>> proc time -> do
    throwOn () -time 1
    returnA    -< time
  safe sawtooth

If you replace sinceStart by sinceInitS, it will usually hang after one second, since it doesn't reset after restarting the sawtooth.

Even in the absence of conditional activation of ClSFs, there is a difference: For a clock that doesn't tick at its initialisation time, sinceStart and sinceInitS will have a constant offset of the duration between initialisation time and first tick.

Alias for >>> (sequential composition) with higher operator precedence, designed to work with the other operators, e.g.:

clsf1 >-> clsf2 @@ clA |@| clsf3 >-> clsf4 @@ clB

The type signature specialises e.g. to

(>->) :: Monad m => ClSF m cl a b -> ClSF m cl b c -> ClSF m cl a c

Alias for <<<.

Output a constant value. Specialises e.g. to this type signature:

arr_ :: Monad m => b -> ClSF m cl a b

The identity synchronous stream function.

The output of integralFrom v0 is the numerical Euler integral of the input, with initial offset v0.

Euler integration, with zero initial offset.

The output of derivativeFrom v0 is the numerical derivative of the input, with a Newton difference quotient. The input is initialised with v0.

Numerical derivative with input initialised to zero.

Like derivativeFrom, but uses three samples to compute the derivative. Consequently, it is delayed by one sample.

Like threePointDerivativeFrom, but with the initial position initialised to zeroVector.

A weighted moving average signal function. The output is the average of the first input, weighted by the second input (which is assumed to be always between 0 and 1). The weight is applied to the average of the last tick, so a weight of 1 simply repeats the past value unchanged, whereas a weight of 0 outputs the current value.

An exponential moving average, or low pass. It will average out, or filter, all features below a given time constant t. (Equivalently, it filters out frequencies above 1 / (2 * pi * t).)

An average, or low pass, initialised to zero.

A linearised version of averageFrom. It is more efficient, but only accurate if the supplied time scale is much bigger than the average time difference between two ticks.

Linearised version of average.

Alias for average.

Filters out frequencies below 1 / (2 * pi * t).

Filters out frequencies other than 1 / (2 * pi * t).

Filters out the frequency 1 / (2 * pi * t).

Remembers and indefinitely outputs ("holds") the first input value.

Remembers all input values that arrived within a given time window. New values are appended left.

Delay a signal by certain time span, initialising with the first input.

Throws an exception after the specified time difference, outputting the time passed since the timer was instantiated.

Like timer_, but doesn't output the remaining time at all.

Like timer, but divides the remaining time by the total time.