Skip to content

Graph Algebra

Combinators for composing graphs: series(), parallel(), split(), merge().

algebra

FAUST-style block diagram algebra for composing DSP graphs.

Provides four binary combinators -- series, parallel, split, merge -- that compose :class:Graph objects into new :class:Graph objects using :class:Subgraph wiring and expansion.

Importing this module monkey-patches Graph.__rshift__ (>>) and Graph.__floordiv__ (//) for operator-based composition::

from gen_dsp.graph.algebra import series, parallel, split, merge

chain = lpf >> hpf          # series
stack = lpf // hpf          # parallel

series 

series(a: Graph, b: Graph) -> Graph

Pipe a's outputs into b's inputs positionally.

Requires len(a.outputs) == len(b.inputs). Result: inputs = a.inputs, outputs = b.outputs, params = merged(a+b).

parallel 

parallel(a: Graph, b: Graph) -> Graph

Stack a and b side by side with independent I/O.

No constraints on I/O counts. Result: inputs = a_prefixed + b_prefixed, outputs = a_prefixed + b_prefixed.

split 

split(a: Graph, b: Graph) -> Graph

Fan-out: a's outputs cyclically distributed to fill b's inputs.

Requires len(b.inputs) % len(a.outputs) == 0. Result: inputs = a.inputs, outputs = b.outputs, params = merged(a+b).

merge 

merge(a: Graph, b: Graph) -> Graph

Fan-in: a's outputs summed in groups to feed b's inputs.

Requires len(a.outputs) % len(b.inputs) == 0. When k=1 (equal counts), degenerates to direct wiring (like series). For k>1, BinOp(op="add") chain nodes sum each group.