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).

Type alias for the type to represent metric (continuous) time. Underneath we use Rational that is able to represent any \(t\) between \(t_1 < t_2 \in T\).

The CT event. It identifies a continuous time signal. It is composed of three parts: a tag, a phase displacement and a continuous sub-signal as a function of time. The types passed to this constructor need to satisfy all of the three properties, as suggested by the type constraints:

• time needs to be an arbitrary numerical type, member of the Fractional class (see MoC instance). If possible, Time, which is an alias for Rational is preferred, as it is the closest numerical representation for continuums.
• timestamp needs to be a numerical type, to express value 0 (global start) and every representable number needs to have an additive inverse.
• timestamp needs to be unambiguously comparable (defines a total order).
• timestamp needs to unambiguously define an equality operation.

Due to these properties not all numerical types can represent CT timestamps, see DE.

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.CT

type MyCtSignal a = SignalBase Int Float a

Convenience alias for a CT signal, where tags are represented using our TimeStamp alias and time is represented usign our Time alias.

Wraps a (tuple of) pair(s) (time, function) into the equivalent unit signal(s), i.e. signal(s) with one event with the period time carrying function.

Helpers: unit and unit[2-4].

Creates an infinite signal.

Transforms a list of tuples such as the ones taken by event into a CT signal

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

The delay process "delays" a signal with one event. Instantiates the delay pattern. In the CT MoC, this process can be interpreted as an ideal "delay line".

>>> let s  = infinite (sin') :: Signal Time
>>> let s' = delay 2 (\_ -> 0) s
>>> dumpDat $ prepare cfg {labels=["delay"]} $ s'
Dumped delay in ./fig
["./fig/delay.dat"]

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

>>> let s  = infinite (sin') :: Signal Time
>>> let s' = signal [(0, \_ -> 0), (2, \_ -> 1)]
>>> dumpDat $ prepare cfg {labels=["delayp"]} $ delay' s' s
Dumped delayp in ./fig
["./fig/delayp.dat"]

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

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

>>> let s1 = infinite (sin') :: Signal Time
>>> let s2 = signal [(0,\_->0),(pi',\_->1),(2*pi',\_->0),(3*pi',\_->1)] :: Signal Time
>>> let o1 = comb11 (+1) s2
>>> let (o2_1, o2_2) = comb22 (\a b-> (a+b,a*b)) s1 s2
>>> dumpDat $ prepare cfg {labels=["comb11"]} o1
Dumped comb11 in ./fig
["./fig/comb11.dat"]
>>> dumpDat $ prepareL cfg {labels=["comb22-1","comb22-2"]} [o2_1, o2_2]
Dumped comb22-1, comb22-2 in ./fig
["./fig/comb22-1.dat","./fig/comb22-2.dat"]

reconfig creates a CT adaptive process where the first signal carries functions and the other carry the arguments. It instantiates the reconfig atom pattern (see reconfig22).

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

>>> let s1 = infinite (sin') :: Signal Time
>>> let sf = signal [(0,\_->(*0)),(pi',\_->(+1)),(2*pi',\_->(*0)),(3*pi',\_->(+1))]
>>> dumpDat $ prepare cfg {labels=["reconfig"]} $ reconfig11 sf s1
Dumped reconfig in ./fig
["./fig/reconfig.dat"]

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

Constructors: constant[1-4].

>>> let ctsig = constant1 2 :: Signal Int
>>> dumpDat $ prepare cfg {labels=["constant"]} ctsig
Dumped constant in ./fig
["./fig/constant.dat"]

A generator for an infinite signal. Similar to constant2.

Constructors: infinite[1-4].

>>> let (inf1, inf2) = infinite2 (sin', cos') :: (Signal Time, Signal Time)
>>> dumpDat $ prepareL cfg {labels=["infinite2-1", "infinite2-2"]} [inf1, inf2]
Dumped infinite2-1, infinite2-2 in ./fig
["./fig/infinite2-1.dat","./fig/infinite2-2.dat"]

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 { osc 0 = 1 ; osc 1 = 0 }
>>> let sg = generate1 osc (pi', \_->0) :: Signal Int
>>> dumpDat $ prepare cfg {labels=["generate"]} sg
Dumped generate in ./fig
["./fig/generate.dat"]

Another example simulating an RC oscillator:

>>> let vs = 2                                -- Vs : supply voltage
>>> let r  = 100                              -- R : resistance
>>> let c  = 0.0005                           -- C : capacitance
>>> let vc t = vs * (1 - exp' (-t / (r * c))) -- Vc(t) : voltage charging through capacitor
>>> let ns v = vs + (-1 * v)                  -- next state : charging / discharging
>>> let rcOsc = generate1 ns (milisec 500, vc)
>>> dumpDat $ prepare cfg {labels=["rcosc"]} $ rcOsc
Dumped rcosc in ./fig
["./fig/rcosc.dat"]

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 { osc 0 a = a; osc _ a = 0 }
>>> let s1 = signal [(0,\_->1), (6,\_->0)] :: Signal Int
>>> dumpDat $ prepare cfg {labels=["stated"]} $ stated11 osc (1,\_->0) s1
Dumped stated in ./fig
["./fig/stated.dat"]

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).

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

>>> let { osc 0 a = a; osc _ a = 0 }
>>> let s1 = signal [(0,\_->1), (6,\_->0)] :: Signal Int
>>> dumpDat $ prepare cfg {labels=["state"]} $ state11 osc (1,\_->0) s1
Dumped state in ./fig
["./fig/state.dat"]

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

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

>>> let { osc 0 a = a; osc _ a = 0 }
>>> let s1 = signal [(0,\_->1), (6,\_->0)] :: Signal Int
>>> dumpDat $ prepare cfg {labels=["moore"]} $ moore11 osc (*3) (1,\_->0) s1
Dumped moore in ./fig
["./fig/moore.dat"]

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

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

>>> let { osc (-1) _ = 1; osc 1 _ = (-1) }
>>> let s1 = infinite sin'
>>> dumpDat $ prepare cfg {labels=["mealy"]} $ mealy11 osc (*) (pi',\_->1) s1
Dumped mealy in ./fig
["./fig/mealy.dat"]

Translates a (set of) CT signal(s) into DE semantics without loss of information. In DE, the abstract function of time inferred by the CT event loses its abstraction and it is "dropped" to explicit form, under a lower layer. In other words the implicit time semantics are lost, the carried value simply becoming an ordinary function.

Constructors: toDE[1-4].

Synchronizes a (set of) CT signal(s) with a DE carrier which holds the timestamps at which the CT signal must be sampled, and outputs the respective (set of) DE signal(s).

Constructors: sampDE[1-4].

>>> let s = CT.infinite (fromRational . sin')
>>> let c = DE.generate1 id (pi'/2, 1)
>>> takeS 6 $ sampDE1 c s
{0.0@0.0,1.0@1.5707963267948966,1.2246489323228883e-16@3.141592653589793,-1.0@4.71238898038469,0.0@6.283185307179586,1.0@7.853981633974483}

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

>>> let s1 = CT.signal [(0,const 1), (2,const 2), (6,const 3)]
>>> let s2 = CT.signal [(0,const 1), (2,const 2), (4,const 3)]
>>> let v1 = V.vector [s1,s1,s2,s2]
>>> zipx v1
{<1,1,1,1>@0,<2,2,2,2>@2,<2,2,3,3>@4,<3,3,3,3>@6}

See zipx from the ForSyDe.Atom.MoC.DE library for a comprehensive visual example.

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 provict the length of the output vector.

>>> let v1 = V.vector [1,2,3,4]
>>> let s1 = CT.signal [(0,const v1),(2,const v1),(6,const v1)]
>>> unzipx 4 s1
<{4@0,4@2,4@6},{3@0,3@2,3@6},{2@0,2@2,2@6},{1@0,1@2,1@6}>

See unzipx from the ForSyDe.Atom.MoC.DE library for a comprehensive visual example.

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

>>> let v1 = V.vector [1,2,3,4]
>>> let s1 = CT.signal [(0,const v1),(2,const v1),(6,const v1)]
>>> unzipx' s1
<{4@0,4@2,4@6},{3@0,3@2,3@6},{2@0,2@2,2@6},{1@0,1@2,1@6}>