Enum ExprNode 

pub enum ExprNode {
    RealConst(f64),
    ComplexConst(Complex<f64>),
    ScalarParam(Parameter),
    EventScalar(Arc<str>),
    EventP4Component {
        name: Arc<str>,
        component: P4Component,
    },
    Unary {
        op: UnaryOp,
        input: ExprId,
    },
    Binary {
        op: BinaryOp,
        lhs: ExprId,
        rhs: ExprId,
    },
    NaryAdd {
        terms: Vec<ExprId>,
    },
    NaryMul {
        factors: Vec<ExprId>,
    },
    Complex {
        re: ExprId,
        im: ExprId,
    },
    Vector {
        elements: Vec<ExprId>,
    },
    Matrix {
        rows: usize,
        cols: usize,
        elements: Vec<ExprId>,
    },
    Component {
        input: ExprId,
        index: usize,
    },
    MatrixElement {
        input: ExprId,
        row: usize,
        col: usize,
    },
    MatMul {
        lhs: ExprId,
        rhs: ExprId,
    },
    MatVec {
        matrix: ExprId,
        vector: ExprId,
    },
    Dot {
        lhs: ExprId,
        rhs: ExprId,
    },
    Solve {
        matrix: ExprId,
        rhs: ExprId,
    },
}

Serialized node in a topologically ordered ExprGraph.

Variants

RealConst(f64)

A real constant.

ComplexConst(Complex<f64>)

A complex constant.

ScalarParam(Parameter)

A scalar fit parameter.

EventScalar(Arc<str>)

A named scalar event column.

EventP4Component

One component of a named event four-momentum.

Fields

name: Arc<str>

Event column base name.

component: P4Component

Requested four-momentum component.

Unary

A unary operation.

Fields

op: UnaryOp

Operation to apply.

input: ExprId

Input node.

Binary

A binary operation.

Fields

op: BinaryOp

Operation to apply.

lhs: ExprId

Left operand.

rhs: ExprId

Right operand.

NaryAdd

A sum of zero or more terms.

Fields

terms: Vec<ExprId>

Term nodes.

NaryMul

A product of zero or more factors.

Fields

factors: Vec<ExprId>

Factor nodes.

Complex

A complex scalar assembled from real and imaginary expressions.

Fields

re: ExprId

Real component.

im: ExprId

Imaginary component.

Vector

A vector assembled from scalar elements.

Fields

elements: Vec<ExprId>

Scalar element nodes.

Matrix

A row-major matrix assembled from scalar elements.

Fields

rows: usize

Number of rows.

cols: usize

Number of columns.

elements: Vec<ExprId>

Row-major scalar elements.

Component

A vector component selection.

Fields

input: ExprId

Vector input.

index: usize

Zero-based component index.

MatrixElement

A matrix element selection.

Fields

input: ExprId

Matrix input.

row: usize

Zero-based row index.

col: usize

Zero-based column index.

MatMul

Matrix-matrix multiplication.

Fields

lhs: ExprId

Left matrix.

rhs: ExprId

Right matrix.

MatVec

Matrix-vector multiplication.

Fields

matrix: ExprId

Matrix operand.

vector: ExprId

Vector operand.

Dot

Vector dot product.

Fields

lhs: ExprId

Left vector.

rhs: ExprId

Right vector.

Solve

Solution of a linear system.

Fields

matrix: ExprId

Coefficient matrix.

rhs: ExprId

Right-hand-side vector or matrix.

Implementations

impl ExprNode

pub fn semantics(&self, children: &[ExprNodeSemantics]) -> ExprNodeSemantics

Infers this node’s context-free value semantics from the already computed semantics of earlier nodes in the expression graph.

pub fn dependency_kind(&self) -> ExprDependencyKind

Returns the intrinsic source of this node’s evaluation dependencies.

pub fn from_folded_const(value: Complex<f64>) -> ExprNode

Creates the most compact constant-node representation for value.

pub fn const_value(&self) -> Option<Complex<f64>>

Returns the node’s scalar constant value, if it is a constant.

pub fn is_zero(node: &ExprNode) -> bool

Returns whether node is the scalar constant zero.

pub fn is_one(node: &ExprNode) -> bool

Returns whether node is the scalar constant one.

pub fn children(&self) -> impl ExactSizeIterator + DoubleEndedIterator

Iterates over this node’s direct dependencies in semantic operand order.

The iterator borrows the node and does not allocate. Binary operands are returned left-to-right, and vector, matrix, sum, and product children retain their stored order.

pub fn child_ids(&self) -> Vec<ExprId>

Returns the identifiers of this node’s direct dependencies.

This compatibility helper collects Self::children. Prefer the borrowed iterator when an owned vector is not required.

pub fn map_children(&self, map: impl FnMut(ExprId) -> ExprId) -> ExprNode

Returns a copy of this node with each direct dependency transformed.

Children are passed to map in the same semantic order as Self::children. Non-child fields are preserved exactly.

Trait Implementations

impl Clone for ExprNode

fn clone(&self) -> ExprNode

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ExprNode

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ExprNode

fn deserialize<__D>( __deserializer: __D, ) -> Result<ExprNode, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<Complex<f64>> for ExprNode

fn from(value: Complex<f64>) -> ExprNode

Converts to this type from the input type.

impl PartialEq for ExprNode

fn eq(&self, other: &ExprNode) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for ExprNode

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for ExprNode