Node Reference

Emit fixed value as source node

Synthetic 2-D matrix source: gaussian, product, ripple, checkerboard

Stochastic waveform source: white, pink, brown, Gaussian

Periodic waveform source: sine, square, triangle, sawtooth, pulse, DC

Forwards workspace signal from memory registry by handle ID

Time-ramp source: value at each sample equals its timestamp

Element-wise |x| on a signal (stateless)

Element-wise comparison → boolean signal (1.0/0.0)

Build a complex array from magnitude and phase: z = mag·(cos φ + i·sin φ)

Fuse two real arrays into one complex array: z = re + i·im (rectangular form)

Complex conjugate z* = re − i·im (negates the imaginary part)

Element-wise expression evaluation with optional operands y, z

Extract the imaginary part Im(z) of a complex array (zeros for real input)

Element-wise boolean logic: AND, OR, NOT, NAND, NOR, XOR, XNOR

Element-wise modulus |z| = √(re² + im²) of a complex (or real) array

Element-wise binary operations: add, subtract, multiply, divide, power, modulo, min, max

Element-wise argument arg(z) = atan2(im, re) in radians

Extract the real part Re(z) of a complex array as a real array

Linear transform y = a·x + b with configurable order

Split a complex array into its real and imaginary parts (inverse of complex_pack)

Element-wise trig/inverse/hyperbolic with degree/radian conversion

numpy arange: a half-open [start, stop) sequence spaced by step

Join 2–4 Signals or Vectors end-to-end along axis 0, rebuilding a monotonic time axis

numpy diag: 1-D input → diagonal matrix, 2-D input → extract the k-th diagonal

Insert a size-1 axis into an array at a chosen position (numpy expand_dims)

numpy eye(n, m, k): an n×m matrix with ones on the k-th diagonal (identity when square)

Ravel a Matrix / Tensor / Vector into a 1-D Vector in C- or Fortran-order (numpy ravel)

Parse a pasted list of numbers into an array; optional shape folds it into a grid

numpy-style array filled with one constant value; shape rank picks the variant

numpy geomspace: num samples geometrically (log-) spaced between actual start and stop

numpy fancy indexing arr[i] / arr[[i,j,k]] over a Signal or Vector; single→Scalar, list→series

numpy linspace: num evenly-spaced samples from start to stop with a pinned endpoint

numpy logspace: base raised to a linspace of exponents (spans base^start … base^stop)

numpy-style one-filled array source; shape rank picks Vector / Matrix / Tensor

Extend a Signal or Vector at its ends with constant / edge / reflect / wrap fill (numpy np.pad)

i.i.d. Gaussian samples N(mean, std) with a portable, reproducible RNG and seed output

i.i.d. uniform samples on [low, high) with a portable, reproducible RNG and seed output

Re-lay a flat row-major array under a new shape (numpy reshape); rank picks Vector/Matrix/Tensor

Crop a Signal to a time window [t0, t1] by timestamp (not index), configurable endpoint inclusivity

numpy basic slicing arr[start:stop:step] over Signal / Vector / Matrix, with n-D multi-axis spec

Drop size-1 axes from an array — all of them, or a single specified axis (numpy squeeze)

Concatenate up to four arrays along an existing axis (numpy concatenate); no new dimension

Element-wise binary op on N-D arrays with numpy broadcasting; IEEE-pure, units propagate

Reduce an N-D array along chosen axes: sum, mean, min, max, product, variance, std

Stack up to four equal-shaped arrays along a NEW axis (numpy stack); result rank is ndim+1

Permute or reverse array axes (numpy transpose / .T); a pure reindex that preserves the unit

Replicate a Signal or Vector reps times, whole-array (tile) or per-element (repeat)

numpy-style zero-filled array source; shape rank picks Vector / Matrix / Tensor

Cholesky factor L of a symmetric positive-definite matrix (A = L·Lᵀ)

Condition number κ(A) = σ_max / σ_min — sensitivity of the linear system

Scalar determinant det(A) via MKL LAPACK; dimensionless

General (non-symmetric) eigen-decomposition with real+imag facade ports and unified complex arrays

Eigen-decomposition of a symmetric/Hermitian matrix: real eigenvalues and orthonormal vectors

Einstein summation over up to 3 operands via a subscripts string (matmul, trace, transpose, batched)

Dense matrix inverse A⁻¹ via MKL LAPACK; dimensionless result

Least-squares solution of A·x ≈ b with residual, rank, and singular values

numpy @ matmul: 1-D/2-D/N-D with batch broadcasting; result unit = product of operand units

Selectable vector/matrix norm (Euclidean, L1, L∞, Lᵖ, L0, spectral, nuclear, operator)

Moore-Penrose pseudo-inverse A⁺ for rectangular / rank-deficient matrices

QR decomposition A = Q·R with orthonormal Q and upper-triangular R

Numerical rank of a matrix (count of significant singular values)

Numerically stable log-determinant: returns sign and ln|det A| separately

Solve the linear system A·x = b directly via MKL LAPACK (preferred over forming A⁻¹)

Full singular value decomposition A = U·Σ·Vᵀ via MKL LAPACK

General axis contraction (numpy tensordot) over matched axis lists; unit = product of operand units

Sum of the diagonal, tr(A) = Σ Aᵢᵢ

Definite integral / area under curve

Amplitude limiting: hard clip, soft clip, or wrap

Time-domain signal delay with ring buffer state persistence

Numerical differentiation with state persistence across blocks

Amplitude envelope detection: peak, RMS, or Hilbert analytic

Windowed DFT: magnitude, phase, and frequency outputs

Stateful Butterworth filter with biquad cascade and DirectForm2Transposed

Cumulative integration with running accumulator persistence

Reconstruct time signal from one-sided magnitude + optional phase spectrum

Local maxima/minima with prominence, threshold, and min_distance filtering

Change signal sample rate using sinc anti-aliased resampling

Stateful: classic S&H latch, ring-buffer capture, or decimation

Hysteresis comparator with state persistence across blocks

Low-pass / denoising: moving average, exponential, Gaussian, median, Savitzky-Golay

Sliding-window peak tracker: abs_max, signed_max, signed_min, or running_max

Quantile / percentile of an array with NumPy-style interpolation methods

Twelve descriptive statistics of any array in one pass: mean, spread, shape, extrema, count

Full joint X–Y analysis: correlation, covariance, KDE contours, ellipses, marginals, OLS + PCA axes

The n-th central moment E[(x-μ)ⁿ] of an array (2 = variance, 3 = skew, 4 = kurtosis)

Pearson correlation matrix of a data matrix whose columns are variables

Covariance matrix of a data matrix (columns = variables), with sample/population DOF control

Six error/deviation metrics between two arrays: L1, L2, L∞, MAE, MSE, RMSE

Non-parametric Bayesian fit that produces a calibrated posterior mean and ±σ confidence band

Equal-width histogram of an array: bin counts and bin edges over [min, max]

Kullback-Leibler divergence D(p‖q) between two probability distributions

Fit a model (linear, polynomial, exponential, Gaussian, custom…) to a signal with weighted least squares

Shannon entropy of an array treated as a probability distribution

Reduce signal to six scalar measures: mean, std, min, max, rms, median

Combine 2–4 DataFrames: stack rows (append) or join columns (side by side)

Plot every column against a chosen X column — emits one signal per remaining numeric column

Keep rows where a column matches a condition (=, ≠, <, >, contains, is null…)

Keep or drop a subset of DataFrame columns by name or index; reorder in keep mode

Pack a signal or bundle into a typed table: a time column plus one f64 column per channel

numpy frame[start:stop:step] over rows — head, tail, reverse, decimate

Stable sort the rows by one column, ascending or descending, with nulls last

Decompose a quantity into its magnitude, σ, relative uncertainty, and unit label as separate outputs

Attach, override, or clear a quantity's standard uncertainty (±σ)

Attach or relabel a quantity's unit without rescaling the numbers

Re-express a quantity in another unit, or simplify/reduce its compound unit to canonical SI form

Continuous state block: integrates dx/dt into state x inside a Simulation compound

Zero-crossing event source: fires when a signal crosses a level in the chosen direction

Compound-node input boundary: surfaces one outer input port on a custom subsystem

Compound-node output boundary: surfaces one outer output port from a custom subsystem

Simulation time source: emits the current sim time t for driving f(t) systems

Whole-branch If/Else select: forward the then or else input based on one boolean condition

Human/Hardware-in-the-loop input: keyboard/mouse drives a live scalar into a running simulation

Terminal event: end the sim run early when a watched signal crosses a level in a chosen direction

Element-wise IF/ELSE data router: forward A or B per sample based on a control criteria

Combine N signals into one SignalBundle with lossless per-channel metadata

Split one SignalBundle back into N individual signals

Split a Signal into X (timestamps), Y (values), and σ (std-dev) as three Vectors

Fuse an X array and a Y array into one Signal (X→timestamps, Y→values), σ optional

Write the incoming value (Signal/Bundle/DataFrame/Matrix) to a CSV/TSV/TXT file

Read a CSV/TSV/TXT file into a typed DataFrame, Signal, or Signal Bundle

Reference any workspace resource by handle, optionally narrowed to one column

Speaker-playback sink with live re-trigger guard and monitor mode

Live mic capture as continuous L/R Signals

Exposes live GBF (SA1/SA2) sample tables from memory registry

Bridges live multi-channel DAQ: up to 8 channels (ea0-ea7) + alias

Universal variadic terminal node: accepts any data, returns nothing