Struct ExprDagBuilder 

pub struct ExprDagBuilder { /* private fields */ }

Builder that makes forward references and cycles unrepresentable.

Implementations

§

impl ExprDagBuilder

Signature links:ExprDagBuilder

pub fn finite_unary( &mut self, operation: FiniteUnaryOperation, value: ExprId, ) -> Result<ExprId, Diagnostic>

Signature links:finite_unaryFiniteUnaryOperationExprIdResultExprIdDiagnostic

Add a finite unary operation such as a transpose or adjoint; types are checked during semantic admission.

pub fn finite_binary( &mut self, operation: FiniteBinaryOperation, left: ExprId, right: ExprId, ) -> Result<ExprId, Diagnostic>

Signature links:finite_binaryFiniteBinaryOperationExprIdExprIdResultExprIdDiagnostic

Add a finite binary operation; endpoint types are checked during inference.

§

impl ExprDagBuilder

Signature links:ExprDagBuilder

pub fn property( &mut self, release: PropertyRelease, arguments: impl IntoIterator<Item = ExprId>, ) -> Result<ExprId, Diagnostic>

Signature links:propertyPropertyReleaseIntoIteratorExprIdResultExprIdDiagnostic

Add a property value together with its scientific identity. Equal values from different releases get distinct arena IDs.

Errors

Rejects arguments to a constant or an invalid typed application.

pub fn bind_property( &mut self, id: ExprId, release: PropertyRelease, ) -> Result<(), Diagnostic>

Signature links:bind_propertyExprIdPropertyReleaseResult()Diagnostic

Reattach a scientific identity to an existing node during replay.

Errors

Rejects a foreign root, a duplicate annotation, a changed constant, or a substituted analytic definition: each annotation must match the value it is attached to.

§

impl ExprDagBuilder

Signature links:ExprDagBuilder

pub fn project_operator_component<I>( &mut self, instance: &PureOperatorInstantiation<'_, I>, arguments: &[impl AsRef<[ExprId]>], component: &[u32], max_nodes: usize, ) -> Result<ExprId, Diagnostic>

Signature links:project_operator_componentPureOperatorInstantiationAsRefExprIdu32usizeResultExprIdDiagnostic

Append one ordered scalar component of a checked pure instantiation. Each argument supplies its complete row-major scalar coordinates. The Model itself keeps the original application and definition. max_nodes bounds the whole destination arena before expansion allocates.

§

impl ExprDagBuilder

Signature links:ExprDagBuilder

pub fn gradient(&mut self, value: ExprId) -> Result<ExprId, Diagnostic>

Signature links:gradientExprIdResultExprIdDiagnostic

Take the physical-space gradient.

pub fn divergence(&mut self, value: ExprId) -> Result<ExprId, Diagnostic>

Signature links:divergenceExprIdResultExprIdDiagnostic

Take the physical-space divergence.

pub fn symmetric_part(&mut self, value: ExprId) -> Result<ExprId, Diagnostic>

Signature links:symmetric_partExprIdResultExprIdDiagnostic

Take the symmetric part of a square Cartesian rank-two tensor.

pub fn isotropic_lift(&mut self, value: ExprId) -> Result<ExprId, Diagnostic>

Signature links:isotropic_liftExprIdResultExprIdDiagnostic

Lift a supported invariant scalar to an isotropic Cartesian tensor.

pub fn trace( &mut self, value: ExprId, on: Id<Domain>, ) -> Result<ExprId, Diagnostic>

Signature links:traceExprIdIdDomainResultExprIdDiagnostic

Take a full trace on a boundary or physical-interface Domain. The operand’s support selects the adjacent parent.

pub fn normal_component( &mut self, value: ExprId, on: Id<Domain>, ) -> Result<ExprId, Diagnostic>

Signature links:normal_componentExprIdIdDomainResultExprIdDiagnostic

Contract with the normal of a boundary or physical-interface Domain. Exterior boundaries use the parent-outward normal; physical interfaces use the common normal of their first declared boundary.

pub fn pullback( &mut self, value: ExprId, source: Vec<ExprId>, at: Vec<(ExprId, ExprId)>, ) -> Result<ExprId, Diagnostic>

Signature links:pullbackExprIdVecExprIdVecExprIdExprIdResultExprIdDiagnostic

Pull a value back along a map between coordinate supports, before any numerical sampling. Type admission requires every coordinate to be bound, each with its own unit.

pub fn coordinate_map_factor( &mut self, factor: CoordinateMapFactor, source: Vec<ExprId>, at: Vec<(ExprId, ExprId)>, ) -> Result<ExprId, Diagnostic>

Signature links:coordinate_map_factorCoordinateMapFactorVecExprIdVecExprIdExprIdResultExprIdDiagnostic

Derive a local Jacobian factor from a complete coordinate map.

Errors

Rejects empty inventories and operands outside this expression arena.

pub fn coordinate_map_factor_action( &mut self, value: ExprId, parameter: ExprId, directions: Vec<ExprId>, ) -> Result<ExprId, Diagnostic>

Signature links:coordinate_map_factor_actionExprIdExprIdVecExprIdResultExprIdDiagnostic

Apply a dimensioned direction, one per mapped row, to a Jacobian factor. The directions are not assumed to be time derivatives; a conservation correspondence has to establish that separately.

Errors

Rejects a non-factor value, a wrong row count, or unavailable operands.

§

impl ExprDagBuilder

Signature links:ExprDagBuilder

pub fn new() -> ExprDagBuilder

Signature links:newExprDagBuilder

Empty expression arena.

pub fn from_dag(expression: &ExprDag) -> ExprDagBuilder

Signature links:from_dagExprDagExprDagBuilder

Start from an existing DAG, keeping its node indices, definitions, and releases.

pub fn push(&mut self, node: ExprNode) -> Result<ExprId, Diagnostic>

Signature links:pushExprNodeResultExprIdDiagnostic

Append one node and return its stable local ID.

pub fn validate_prior_operand(&self, operand: ExprId) -> Result<(), Diagnostic>

Signature links:validate_prior_operandExprIdResult()Diagnostic

Check that an operand references an existing arena node without appending nodes.

Errors

Rejects an ID outside the current arena using the ordinary operand diagnostic.

pub fn array( &mut self, elements: impl IntoIterator<Item = ExprId>, ) -> Result<ExprId, Diagnostic>

Signature links:arrayIntoIteratorExprIdResultExprIdDiagnostic

Construct an ordered outer channel array from existing DAG nodes.

pub fn index(&mut self, value: ExprId, index: u32) -> Result<ExprId, Diagnostic>

Signature links:indexExprIdu32ResultExprIdDiagnostic

Select one outer channel-array element; type checking verifies the bound.

pub fn complex( &mut self, real: ExprId, imag: ExprId, ) -> Result<ExprId, Diagnostic>

Signature links:complexExprIdExprIdResultExprIdDiagnostic

Construct a complex scalar; typing checks both real scalar operands.

pub fn sample( &mut self, value: ExprId, clock: Id<ClockDomain>, ) -> Result<ExprId, Diagnostic>

Signature links:sampleExprIdIdClockDomainResultExprIdDiagnostic

Sample a continuous expression on a nominal clock. Semantic admission checks the clock and the owning activation.

pub fn hold(&mut self, value: ExprId) -> Result<ExprId, Diagnostic>

Signature links:holdExprIdResultExprIdDiagnostic

Read a clocked State continuously. The operand must be a State symbol with explicit initialization and updates; no memory or initial value is created.

pub fn constant<V>(&mut self, value: V) -> Result<ExprId, Diagnostic>

where V: TryInto<ValueLiteral>, <V as TryInto<ValueLiteral>>::Error: Display,

Signature links:constantResultExprIdDiagnosticTryIntoValueLiteralTryIntoValueLiteralErrorDisplay

Add a checked constant; a numerical quantity supplies an explicit real scalar type.

pub fn symbol(&mut self, symbol: SymbolRef) -> Result<ExprId, Diagnostic>

Signature links:symbolSymbolRefResultExprIdDiagnostic

Add a typed symbol reference.

pub fn require( &mut self, condition: ExprId, value: ExprId, ) -> Result<ExprId, Diagnostic>

Signature links:requireExprIdExprIdResultExprIdDiagnostic

Require a true domain condition before demanding the complete value.

pub fn select( &mut self, condition: ExprId, then_value: ExprId, else_value: ExprId, ) -> Result<ExprId, Diagnostic>

Signature links:selectExprIdExprIdExprIdResultExprIdDiagnostic

Select one complete value lazily from a Boolean condition.

pub fn min(&mut self, left: ExprId, right: ExprId) -> Result<ExprId, Diagnostic>

Signature links:minExprIdExprIdResultExprIdDiagnostic

Select the smaller scalar, retaining the first operand on ties. Both operands are demanded; typing requires identical ordered scalar types.

pub fn max(&mut self, left: ExprId, right: ExprId) -> Result<ExprId, Diagnostic>

Signature links:maxExprIdExprIdResultExprIdDiagnostic

Select the larger scalar, retaining the first operand on ties. Both operands are demanded; typing requires identical ordered scalar types.

pub fn compare( &mut self, op: ComparisonOp, left: ExprId, right: ExprId, ) -> Result<ExprId, Diagnostic>

Signature links:compareComparisonOpExprIdExprIdResultExprIdDiagnostic

Compare two scalar expressions.

pub fn not(&mut self, value: ExprId) -> Result<ExprId, Diagnostic>

Signature links:notExprIdResultExprIdDiagnostic

Negate a Boolean expression.

pub fn and(&mut self, left: ExprId, right: ExprId) -> Result<ExprId, Diagnostic>

Signature links:andExprIdExprIdResultExprIdDiagnostic

Short-circuit Boolean conjunction.

pub fn or(&mut self, left: ExprId, right: ExprId) -> Result<ExprId, Diagnostic>

Signature links:orExprIdExprIdResultExprIdDiagnostic

Short-circuit Boolean disjunction.

pub fn neg(&mut self, value: ExprId) -> Result<ExprId, Diagnostic>

Signature links:negExprIdResultExprIdDiagnostic

Add unary negation.

pub fn add(&mut self, left: ExprId, right: ExprId) -> Result<ExprId, Diagnostic>

Signature links:addExprIdExprIdResultExprIdDiagnostic

Add two expressions.

pub fn sub(&mut self, left: ExprId, right: ExprId) -> Result<ExprId, Diagnostic>

Signature links:subExprIdExprIdResultExprIdDiagnostic

Subtract two expressions.

pub fn mul(&mut self, left: ExprId, right: ExprId) -> Result<ExprId, Diagnostic>

Signature links:mulExprIdExprIdResultExprIdDiagnostic

Multiply two expressions.

pub fn div(&mut self, left: ExprId, right: ExprId) -> Result<ExprId, Diagnostic>

Signature links:divExprIdExprIdResultExprIdDiagnostic

Divide two expressions.

pub fn quotient( &mut self, left: ExprId, right: ExprId, ) -> Result<ExprId, Diagnostic>

Signature links:quotientExprIdExprIdResultExprIdDiagnostic

Checked integer quotient.

pub fn remainder( &mut self, left: ExprId, right: ExprId, ) -> Result<ExprId, Diagnostic>

Signature links:remainderExprIdExprIdResultExprIdDiagnostic

Checked integer remainder.

pub fn ordinal(&mut self, value: ExprId) -> Result<ExprId, Diagnostic>

Signature links:ordinalExprIdResultExprIdDiagnostic

Explicit nominal index ordinal projection.

pub fn to_real(&mut self, value: ExprId) -> Result<ExprId, Diagnostic>

Signature links:to_realExprIdResultExprIdDiagnostic

Explicit integer-to-real conversion.

pub fn to_integer(&mut self, value: ExprId) -> Result<ExprId, Diagnostic>

Signature links:to_integerExprIdResultExprIdDiagnostic

Checked integral real-to-integer conversion.

pub fn powi( &mut self, base: ExprId, exponent: i32, ) -> Result<ExprId, Diagnostic>

Signature links:powiExprIdi32ResultExprIdDiagnostic

Raise an expression to an integer power.

pub fn coordinate( &mut self, support: Id<Domain>, factor: Id<Domain>, axis: usize, ) -> Result<ExprId, Diagnostic>

Signature links:coordinateIdDomainIdDomainusizeResultExprIdDiagnostic

Read one coordinate-factor axis on a declared support. Whole-Model admission checks factor membership, axis bounds, and units.

pub fn unary_math( &mut self, function: UnaryMathFunction, value: ExprId, ) -> Result<ExprId, Diagnostic>

Signature links:unary_mathUnaryMathFunctionExprIdResultExprIdDiagnostic

Apply a dimension-aware unary mathematical function.

pub fn coordinate_partial( &mut self, value: ExprId, wrt: ExprId, ) -> Result<ExprId, Diagnostic>

Signature links:coordinate_partialExprIdExprIdResultExprIdDiagnostic

Add a coordinate partial derivative; the numerical representation decides whether it is supported.

Errors

Rejects operands outside this builder or beyond the expression arena limits.

pub fn evaluate_at( &mut self, value: ExprId, at: Vec<(ExprId, ExprId)>, side: Option<BoundarySide>, ) -> Result<ExprId, Diagnostic>

Signature links:evaluate_atExprIdVecExprIdExprIdOptionBoundarySideResultExprIdDiagnostic

Evaluate an expression at a point that gives every coordinate, without choosing a numerical representation.

Errors

Rejects an empty or oversized point and operands outside the expression arena.

pub fn pure_operator( &mut self, definition: &PureOperatorDefinition, arguments: impl IntoIterator<Item = ExprId>, ) -> Result<ExprId, Diagnostic>

Signature links:pure_operatorPureOperatorDefinitionIntoIteratorExprIdResultExprIdDiagnostic

Apply a closed pure-operator definition to earlier expressions.

The definition is deduplicated by content digest and stored in the finished expression. Arguments are matched to formal slots by position; there is no lookup by name and no implicit commutativity.

Errors

Returns EQ0301 for an empty or wrongly sized argument list, a forward reference, or a digest collision between different canonical definitions.

pub fn finish( self, roots: impl IntoIterator<Item = ExprId>, ) -> Result<ExprDag, Diagnostic>

Signature links:finishIntoIteratorExprIdResultExprDagDiagnostic

Finish a DAG with one or more output roots.

Errors

Returns EQ0301 when the arena or root set is empty, or a root is not present in this arena.

Trait Implementations

§

impl Debug for ExprDagBuilder

Signature links:DebugExprDagBuilder

§

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

Signature links:fmtFormatterResult()Error

Formats the value using the given formatter.

§

impl Default for ExprDagBuilder

Signature links:DefaultExprDagBuilder

§

fn default() -> ExprDagBuilder

Signature links:defaultExprDagBuilder

Returns the “default value” for a type.