Struct ExprGraph 

pub struct ExprGraph { /* private fields */ }

Arena-based expression graph with structural interning.

Identical subexpressions always return the same ExprId — this gives automatic common subexpression elimination (CSE) for free.

Implementations

impl ExprGraph

pub fn to_c_f64(&self, outputs: &[ExprId], n_inputs: usize) -> ComputeKernel

Generate a plain-C kernel in f64: void k0(const double* inputs, double* outputs, int count). Literals keep full precision.

pub fn to_kernel( &self, outputs: &[ExprId], n_inputs: usize, dialect: Dialect, ) -> ComputeKernel

Generate a compute kernel for the given dialect.

Each work item reads n_inputs f32 values and writes outputs.len() f32 values. Shared subexpressions are computed once per thread.

impl ExprGraph

pub fn compile(&self, expr: ExprId) -> CompiledExpr

Compile a single expression to a closure &[f64] -> f64.

Shared subexpressions (from interning) are computed once. Dead nodes (not reachable from output) are skipped.

pub fn compile_many(&self, exprs: &[ExprId]) -> CompiledMany

Compile multiple output expressions to a single closure.

Writes results into the output slice.

pub fn live_set(&self, outputs: &[ExprId]) -> HashSet<usize>

Find all node indices reachable from the given outputs.

impl ExprGraph

pub fn diff(&mut self, expr: ExprId, var: u16) -> ExprId

Differentiate expr with respect to Var(var).

Returns a new ExprId in the same graph. Uses memoization to avoid recomputing derivatives of shared subexpressions.

impl ExprGraph

pub fn fmt_expr(&self, expr: ExprId) -> String

Format an expression as a human-readable string.

impl ExprGraph

pub fn eval<S: Scalar>(&self, expr: ExprId, inputs: &[S]) -> S

Evaluate an expression with concrete scalar inputs.

inputs[n] provides the value for Var(n). Walks the graph in topological order (which is just index order, since children are always created before parents).

pub fn eval_many<S: Scalar>(&self, exprs: &[ExprId], inputs: &[S]) -> Vec<S>

Evaluate multiple output expressions, sharing intermediate values.

impl ExprGraph

pub fn new() -> Self

Create a new graph pre-populated with ZERO, ONE, TWO.

pub fn len(&self) -> usize

Total number of nodes in the graph.

pub fn is_empty(&self) -> bool

Whether the graph is empty (it never is after construction).

pub fn node(&self, id: ExprId) -> Node

Look up the node for an ExprId.

pub fn nodes_slice(&self) -> &[Node]

Read-only access to the node arena for serialization.

pub fn var(&mut self, n: u16) -> ExprId

Create a variable node.

pub fn lit(&mut self, v: f64) -> ExprId

Create a literal node.

pub fn add(&mut self, a: ExprId, b: ExprId) -> ExprId

Add two expressions.

pub fn mul(&mut self, a: ExprId, b: ExprId) -> ExprId

Multiply two expressions.

pub fn neg(&mut self, a: ExprId) -> ExprId

Negate an expression.

pub fn recip(&mut self, a: ExprId) -> ExprId

Reciprocal (1/x).

pub fn sqrt(&mut self, a: ExprId) -> ExprId

Square root.

pub fn sin(&mut self, a: ExprId) -> ExprId

Sine.

pub fn atan2(&mut self, y: ExprId, x: ExprId) -> ExprId

atan2(y, x).

pub fn exp2(&mut self, a: ExprId) -> ExprId

Base-2 exponential.

pub fn log2(&mut self, a: ExprId) -> ExprId

Base-2 logarithm.

pub fn select(&mut self, cond: ExprId, a: ExprId, b: ExprId) -> ExprId

Branchless select: returns a if cond > 0, else b.

impl ExprGraph

pub fn vjp( &mut self, outputs: &[ExprId], seeds: &[ExprId], n_vars: usize, ) -> Vec<ExprId>

The vector-Jacobian product seedᵀ ∂outputs/∂vars as new expressions in this graph: entry k is Σ_i seeds[i] ∂outputs[i]/∂Var(k) for k < n_vars. One reverse sweep over the live nodes, so the cost is a small multiple of evaluating outputs whatever n_vars is (forward diff is one sweep per variable). Seeds are expressions too (typically fresh Vars past the inputs), so one compiled graph serves every seed. Select passes gradient to the taken branch only, as diff does.

impl ExprGraph

pub fn simplify(&mut self, expr: ExprId) -> ExprId

Simplify an expression by applying rewrite rules to fixpoint.

Bottom-up: simplify children first, then match parent. Iterates until no more changes occur.

impl ExprGraph

pub fn deps(&self, expr: ExprId) -> u64

Compute a bitmask of which Var(n) indices appear in expr.

Bit n is set if Var(n) is reachable from expr. Supports up to 64 variables.

pub fn jacobian_sparsity(&self, outputs: &[ExprId], n_vars: usize) -> Vec<u64>

Compute the Jacobian sparsity pattern.

Returns one u64 bitmask per output expression. Bit j of result[i] is set if outputs[i] depends on Var(j).

impl ExprGraph

pub fn to_wgsl_split( &self, outputs: &[ExprId], n_inputs: usize, max_nodes: usize, ) -> SplitKernels

to_kernel for WGSL, cut into kernels of at most max_nodes evaluated nodes each (topological order); a value used outside the kernel that computes it goes through scratch.

pub fn to_wgsl_split_f64( &self, outputs: &[ExprId], n_inputs: usize, max_nodes: usize, ) -> SplitKernels

to_wgsl_split in f64 (buffers, scratch and arithmetic), for a device with wgpu’s SHADER_F64. Vulkan has no f64 sin/exp2/log2/atan2, so those come from WGSL helpers accurate to a few ulp. A buffer of n values takes 2n f32 slots.

impl ExprGraph

pub fn to_wgsl(&self, outputs: &[ExprId], n_inputs: usize) -> WgslKernel

Generate a WGSL compute shader that evaluates expressions in parallel.

Each work item reads n_inputs values and writes outputs.len() values. The generated shader uses f32 (GPU native). Shared subexpressions are computed once per thread.

The caller handles device/pipeline/dispatch (no wgpu dependency here).

Trait Implementations

impl Clone for ExprGraph

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Default for ExprGraph

fn default() -> Self

Returns the “default value” for a type.