The DE event. It identifies a discrete event signal. The type of the tag system needs to satisfy all of the three properties, as suggested by the type constraints imposed on it:

• it needs to be a numerical type, to express value 0 (global start) and every representable number needs to have an additive inverse.
• it needs to be unambiguously comparable (defines a total order).
• it needs to unambiguously define an equality operation.

Due to these properties not all numerical types can represent DE tags. A typical example of inappropriate representation is Float.

Type synonym for a base DE signal as a stream of DE events, where the type of tags has not been determined yet. In designs, it is advised to define a type alias for signals, using an appropriate numerical type for tags, e.g.

import ForSyDe.Atom.MoC.DE hiding (Signal) -- hide provided alias, to use your own

type Signal a = SignalBase Int a

Convenience alias for a DE signal, where tags are represented using our exported TimeStamp type.

Alias for the type representing discrete time. It is inherently quantizable, the quantum being a picosecond ( \(10^{-12}\) seconds), thus it can be considered order-isomorphic with a set of integers, i.e. between any two timestamps there is a finite number of timestamps. Moreover, a timestamp can be easily translated into a rational number representing fractions of a second, so the conversion between timestamps (discrete time) and rationals (analog/continuous time) is straightforward.

This type is used in the explicit tags of the DE MoC (and subsequently the discrete event evaluation engine for simulating the CT MoC).

Wraps a (tuple of) pair(s) (tag, value) into the equivalent unit signal(s). A unit signal is a signal with one event with the period tag carrying value.

Helpers: unit|unit[2-4].

Creates an infinite signal.

Takes the first part of the signal util a given timestamp. The last event of the resulting signal is at the given timestamp and carries the previous value. This utility is useful when plotting a signal, to specify the interval of plotting.

Transforms a list of tuples (tag, value) into a DE signal. Checks if it is well-formed.

Checks if a signal is well-formed or not, according to the DE MoC interpretation in ForSyDe-Atom.

Reads a signal from a string and checks if it is well-formed. Like with the read function from Prelude, you must specify the type of the signal.

>>> readSignal "{ 1@0, 2@2, 3@5, 4@7, 5@10 }" :: Signal Int
{1@0s,2@2s,3@5s,4@7s,5@10s}

Incorrect usage (not covered by doctest):

λ> readSignal "{ 1@0, 2@2, 3@5, 4@10, 5@7 }" :: Signal Int
{1@0s,2@2s,3@5s*** Exception: [MoC.DE] malformed signal
λ> readSignal "{ 1@1, 2@2, 3@5, 4@7, 5@10 }" :: Signal Int
*** Exception: [MoC.DE] signal does not start from global 0

The delay process "delays" a signal with one event. Instantiates the delay pattern defined in ForSyDe.Atom.MoC.

>>> let s = readSignal "{1@0, 2@2, 3@6, 4@8, 5@9}" :: Signal Int
>>> delay 3 0 s
{0@0s,1@3s,2@5s,3@9s,4@11s,5@12s}

Similar to the previous, but this is the raw instantiation of the delay pattern from ForSyDe.Atom.MoC. It "borrows" the first event from one signal and appends it at the head of another signal.

>>> let s1 = readSignal "{1@0, 2@2, 3@6, 4@8, 5@9}" :: Signal Int
>>> let s2 = readSignal "{3@0, 4@4, 5@5, 6@8, 7@9}" :: Signal Int
>>> delay' s1 s2
{1@0s,3@2s,4@6s,5@7s,6@10s,7@11s}

comb processes map combinatorial functions on signals and take care of synchronization between input signals. It instantiates the comb pattern (see comb22 defined in ForSyDe.Atom.MoC).

Constructors: comb[1-4][1-4].

>>> let s1 = infinite 1
>>> let s2 = readSignal "{1@0, 2@2, 3@6, 4@8, 5@9}" :: Signal Int
>>> comb11 (+1) s2
{2@0s,3@2s,4@6s,5@8s,6@9s}
>>> comb22 (\a b-> (a+b,a-b)) s1 s2
({2@0s,3@2s,4@6s,5@8s,6@9s},{0@0s,-1@2s,-2@6s,-3@8s,-4@9s})

reconfig creates a DE adaptive process where the first signal carries functions and the other carry the arguments. It instantiates the reconfig atom pattern (see reconfig22 defined in ForSyDe.Atom.MoC).

Constructors: reconfig[1-4][1-4].

>>> let sf = signal [(0,(+1)),(2,(*2)),(5,(+1)),(7,(*2))]
>>> let s1 = signal [(0,1),(3,2),(5,3),(9,4)]
>>> reconfig11 sf s1
{2@0,2@2,4@3,4@5,6@7,8@9}

sync synchronizes multiple signals, so that they have the same set of tags, and consequently, the same number of events. It instantiates the comb atom pattern (see comb22 defined in ForSyDe.Atom.MoC).

Constructors: sync[1-4]

>>> let s1 = readSignal "{1@0, 2@2, 3@6, 4@8,  5@9}"  :: Signal Int
>>> let s2 = readSignal "{1@0, 2@5, 3@6, 4@10, 5@12}" :: Signal Int
>>> sync2 s1 s2
({1@0s,2@2s,2@5s,3@6s,4@8s,5@9s,5@10s,5@12s},{1@0s,1@2s,2@5s,3@6s,3@8s,3@9s,4@10s,5@12s})

A signal generator which keeps a value constant. As compared with the SY, it just constructs an infinite signal with constant value (i.e. a signal with one event starting from time 0).

Constructors: constant[1-4].

>>> constant1 2
{2@0}

A signal generator based on a function and a kernel value. It is actually an instantiation of the stated0X constructor (check stated22 defined in ForSyDe.Atom.MoC).

Constructors: generate[1-4].

>>> let (s1,s2) = generate2 (\a b -> (a+1,b+2)) ((3,1),(1,2))
>>> takeS 5 s1
{1@0,2@3,2@4,2@5,3@6}
>>> takeS 7 s2
{2@0,4@1,6@2,8@3,10@4,12@5,14@6}

stated is a state machine without an output decoder. It is an instantiation of the state MoC constructor (see stated22 defined in ForSyDe.Atom.MoC).

Constructors: stated[1-4][1-4].

>>> let s = readSignal "{1@0, 2@2, 3@6, 4@8, 5@9}" :: Signal Int
>>> takeS 7 $ stated11 (+) (6,1) s
{1@0s,2@6s,3@8s,5@12s,7@14s,8@15s,10@18s}

state is a state machine without an output decoder, and the state non-transparent. It is an instantiation of the state MoC constructor (see state22 defined in ForSyDe.Atom.MoC).

Constructors: state[1-4][1-4].

>>> let s = readSignal "{1@0, 2@2, 3@6, 4@8, 5@9}" :: Signal Int
>>> takeS 7 $ state11 (+) (6,1) s
{2@0s,3@2s,5@6s,7@8s,8@9s,10@12s,12@14s}

moore processes model Moore state machines. It is an instantiation of the moore MoC constructor (see moore22 defined in ForSyDe.Atom.MoC).

Constructors: moore[1-4][1-4]

>>> let s = readSignal "{1@0, 2@2, 3@6, 4@8, 5@9}" :: Signal Int
>>> takeS 7 $ moore11 (+) (+1) (6,1) s
{2@0s,3@6s,4@8s,6@12s,8@14s,9@15s,11@18s}

mealy processes model Mealy state machines. It is an instantiation of the mealy MoC constructor (see mealy22 defined in ForSyDe.Atom.MoC).

Constructors: mealy[1-4][1-4]

>>> let s = readSignal "{1@0, 2@2, 3@6, 4@8, 5@9}" :: Signal Int
>>> takeS 7 $ mealy11 (+) (-) (6,1) s
{0@0s,-1@2s,-1@6s,-1@8s,-2@9s,0@12s,2@14s}

Embeds a SY process inside a DE environment. Internally, it synchronizes the input signals, translates them to SY, feeds them to a SY process and translates the result back to DE using the same input tags. Seen from outside, this process behaves like a DE process with "instantaneous response", even for feedback loops.

Constructors: embedSY[1-4][1-4].

For the following example, see the difference between its output and the one of stated22

>>> let s = readSignal "{1@0, 2@2, 3@6, 4@8, 5@9}" :: DE.Signal Int
>>> embedSY11 (SY.stated11 (+) 1) s
{1@0s,2@2s,4@6s,7@8s,11@9s}

Synchronizes a (set of) DE signal(s) an strips off their explicit tags, outputting the equivalent SY signal(s), tupled with an SY signal carrying the timestamps for the synchronization points.

Constructors: toSY[1-4]

>>> let s1 = DE.infinite 1
>>> let s2 = DE.readSignal "{1@0, 2@2, 3@6, 4@8, 5@9}" :: DE.Signal Int
>>> toSY2 s1 s2
({0s,2s,6s,8s,9s},{1,1,1,1,1},{1,2,3,4,5})

Semantic preserving transformation between a (set of) DE signal(s) and the equivalent CT signals. The DE events must carry a function of Time which will be lifted by providing it with CT implicit time semantics.

Constructors: toCT[1-4].

Synchronizes all the signals contained by a vector and zips them into one signal of vectors. It instantiates the zipx skeleton.

>>> let s1 = DE.readSignal "{1@0, 2@2, 3@6, 4@8, 5@9}" :: DE.Signal Int
>>> let s2 = DE.readSignal "{1@0, 2@2, 3@4, 4@8, 5@9}" :: DE.Signal Int
>>> let v1 = V.vector [s1,s1,s2,s2]
>>> v1
<{1@0s,2@2s,3@6s,4@8s,5@9s},{1@0s,2@2s,3@6s,4@8s,5@9s},{1@0s,2@2s,3@4s,4@8s,5@9s},{1@0s,2@2s,3@4s,4@8s,5@9s}>
>>> zipx v1
{<1,1,1,1>@0s,<2,2,2,2>@2s,<2,2,3,3>@4s,<3,3,3,3>@6s,<4,4,4,4>@8s,<5,5,5,5>@9s}

Unzips the vectors carried by a signal into a vector of signals. It instantiates the unzipx skeleton. To avoid infinite recurrence, the user needs to provide the length of the output vector.

>>> let v1 = V.vector [1,2,3,4]
>>> let s1 = DE.signal [(0,v1),(2,v1),(6,v1),(8,v1),(9,v1)] :: DE.Signal (V.Vector Int)
>>> s1
{<1,2,3,4>@0s,<1,2,3,4>@2s,<1,2,3,4>@6s,<1,2,3,4>@8s,<1,2,3,4>@9s}
>>> unzipx 4 s1
<{1@0s,1@2s,1@6s,1@8s,1@9s},{2@0s,2@2s,2@6s,2@8s,2@9s},{3@0s,3@2s,3@6s,3@8s,3@9s},{4@0s,4@2s,4@6s,4@8s,4@9s}>

Same as unzipx, but "sniffs" the first event to determine the length of the output vector. Might have unsafe behavior!

>>> let v1 = V.vector [1,2,3,4]
>>> let s1 = DE.signal [(0,v1),(2,v1),(6,v1),(8,v1),(9,v1)] :: DE.Signal (V.Vector Int)
>>> s1
{<1,2,3,4>@0s,<1,2,3,4>@2s,<1,2,3,4>@6s,<1,2,3,4>@8s,<1,2,3,4>@9s}
>>> unzipx' s1
<{1@0s,1@2s,1@6s,1@8s,1@9s},{2@0s,2@2s,2@6s,2@8s,2@9s},{3@0s,3@2s,3@6s,3@8s,3@9s},{4@0s,4@2s,4@6s,4@8s,4@9s}>