The SDF event. It identifies a synchronous dataflow signal, and wraps only a value.

Type synonym for a SY signal, i.e. "a signal of SY events"

Type synonym for consumption rate

Type synonym for production rate

Transforms a list of values into a SDF signal with only one partition, i.e. all events share the same (initial) tag.

Reads a signal from a string. Like with the read function from Prelude, you must specify the tipe of the signal.

>>> readSignal "{1,2,3,4,5}" :: Signal Int
{1,2,3,4,5}

The delay process "delays" a signal with initial events built from a list. It is an instantiation of the delay constructor.

>>> let s = signal [1,2,3,4,5]
>>> delay [0,0,0] s
{0,0,0,1,2,3,4,5}

actor processes map combnational functions on signals and take care of synchronization between input signals. It instantiates the comb atom pattern (see comb22).

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

>>> let s1 = signal [1..]
>>> let s2 = signal [1,1,1,1,1,1,1]
>>> let f [a,b,c] [d,e] = [a+d, c+e]
>>> actor21 ((3,2),2,f) s1 s2
{2,4,5,7,8,10}

Incorrect usage (not covered by doctest):

λ> actor21 ((3,2),3,f) s1 s2
*** Exception: [MoC.SDF] Wrong production

Similar to the previous, but this is the raw instantiation of the delay pattern. It appends the contents of one signal at the head of another signal.

>>> let s1 = signal [0,0,0]
>>> let s2 = signal [1,2,3,4,5]
>>> delay' s1 s2
{0,0,0,1,2,3,4,5}

reconfig creates an SDF adaptive process where the first signal carries functions and the other carry the arguments. It instantiates the reconfig atom pattern (see reconfig22). According to our SDF definition, the production and consumption rates need to be fixed, so they are passed as parameters to the constructor, whereas the first signal carries adaptive functions only. For the adaptive signal it only makes sense that the consumption rate is always 1.

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

>>> let f1 a = [sum a]
>>> let f2 a = [maximum a]
>>> let sf = signal [f1,f2,f1,f2,f1,f2,f1]
>>> let s1 = signal [1..]
>>> reconfig11 (4,1) sf s1
{10,8,42,16,74,24,106}

A signal generator which repeats the initial tokens indefinitely. It is actually an instantiation of the stated0X constructor (check stated22).

Constructors: constant[1-4].

>>> let (s1, s2) = constant2 ([1,2,3],[2,1])
>>> takeS 7 s1
{1,2,3,1,2,3,1}
>>> takeS 5 s2
{2,1,2,1,2}

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

Constructors: generate[1-4].

>>> let f a b = ([sum a, sum a],[sum b, sum b, sum b])
>>> let (s1,s2) = generate2 ((2,3),(2,3),f) ([1,1],[2,2,2])
>>> takeS 7 s1
{1,1,2,2,4,4,8}
>>> takeS 8 s2
{2,2,2,6,6,6,18,18}

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

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

>>> let f [a] [b,c] = [a+b+c]
>>> let s = signal [1,2,3,4,5,6,7]
>>> stated11 ((1,2),1,f) [1] s
{1,4,11,22}

state is a state machine without an output decoder. It is an instantiation of the stated MoC constructor (see state22).

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

>>> let f [a] [b,c] = [a+b+c]
>>> let s = signal [1,2,3,4,5,6,7]
>>> state11 ((1,2),1,f) [1] s
{4,11,22}

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

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

>>> let ns [a] [b,c] = [a+b+c]
>>> let od [a]       = [a+1,a*2]
>>> let s = signal [1,2,3,4,5,6,7]
>>> moore11 ((1,2),1,ns) (1,2,od) [1] s
{2,2,5,8,12,22,23,44}

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

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

>>> let ns [a] [b,c] = [a+b+c]
>>> let od [a] [b]   = [a+b,a*b]
>>> let s = signal [1,2,3,4,5,6,7]
>>> mealy11 ((1,2),1,ns) ((1,1),2,od) [1] s
{2,1,6,8,14,33,26,88}

Transforms a (set of) SDF signal(s) into the equivalent SY signal(s). The partial ordering is transformed to total ordering with respect to the firings of the interface process(es), and events consumed during one firing are grouped into vectors.

Constructors: toSY[1-4].

>>> let s = SDF.signal [1,2,3,4,5,6,7,8,9]
>>> toSY1 2 s
{<1,2>,<3,4>,<5,6>,<7,8>}

Alternative implementation to toSY2, where the consumption rate of the interface process is 1, meaning that each SDF event has a corresponding SY event.

Constructors: toSY[1-4]'.

>>> let s = SDF.signal [1,2,3,4,5]
>>> toSY1' s
{1,2,3,4,5}

Consumes tokens from a vector of signals and merges them into a signal of vectors, with a production rate of 1. It instantiates the zipx skeleton.

>>> let s1 = SDF.signal [1,2,3,4,5]
>>> let s2 = SDF.signal [11,12,13,14,15]
>>> let v1 = V.vector [s1,s1,s2,s2]
>>> let r  = V.vector [2,1,2,1]
>>> v1
<{1,2,3,4,5},{1,2,3,4,5},{11,12,13,14,15},{11,12,13,14,15}>
>>> zipx r v1
{<1,2,1,11,12,11>,<3,4,2,13,14,12>}

Consumes the vectors carried by a signal with a rate of 1, and unzips them into a vector of signals based on the user provided rates. It instantiates the unzipx skeleton.

OBS: due to the recur pattern contained by unzipx, the vector of production rates needs to be provided in reverse order (see ForSyDe.Atom.Skel.Vector).

>>> let s1 = SDF.signal [1,2,3,4,5]
>>> let s2 = SDF.signal [11,12,13,14,15]
>>> let v1 = V.vector [s1,s1,s2,s2]
>>> let r  = V.vector [2,1,2,1]
>>> let sz = zipx r v1
>>> v1
<{1,2,3,4,5},{1,2,3,4,5},{11,12,13,14,15},{11,12,13,14,15}>
>>> sz
{<1,2,1,11,12,11>,<3,4,2,13,14,12>}
>>> unzipx (V.reverse r) sz
<{1,2,3,4},{1,2},{11,12,13,14},{11,12}>