Struct ScalarOperatorIr 

pub struct ScalarOperatorIr { /* private fields */ }

Compact scalar SSA Operator IR lowered from one residual DAG.

Implementations

§

impl ScalarOperatorIr

Signature links:ScalarOperatorIr

pub fn additive_terms( &self, inputs: &[ValueLiteral], selected: SymbolRef, ) -> Result<Vec<(ScalarOperatorIr, Vec<Ratio<BigInt>>)>, Diagnostic>

Signature links:additive_termsValueLiteralSymbolRefResultVecScalarOperatorIrVecRatioBigIntDiagnostic

Express the selected-symbol dependence as an additive sum of opaque scalar terms, each with a coefficient for every original root. Other inputs are frozen at the typed point. Only addition, subtraction, negation, and factors independent of the selected symbol are expanded. Structurally equal terms have equal canonical IR, including across owners. Active guards remain inside terms; this performs no differentiation. Original demanded primal/domain validation occurs before cancellation.

Errors

Rejects an invalid point, unsupported scalar projection, or exceeded exact-coefficient budget. Coefficients are exact binary rationals, including their sums and products. This does not evaluate derivatives.

§

impl ScalarOperatorIr

Signature links:ScalarOperatorIr

pub fn lower_affine_map_density<I>( typed: &TypedResidual<I>, resolve: &mut impl FnMut(SymbolRef) -> Option<ValueLiteral>, ) -> Result<ScalarOperatorIr, Diagnostic>

where I: Clone + Eq,

Signature links:lower_affine_map_densityTypedResidualFnMutSymbolRefOptionValueLiteralResultScalarOperatorIrDiagnosticCloneEq

Project a density for regularity admission at fixed nonspatial inputs. Coordinate-map factors must have structurally affine mapped coordinates. Their spatially constant Jacobians use the shared LU/conditioning owner. This projection is not a parameter derivative: retained expressions remain authoritative for value evaluation and differentiation.

Errors

Rejects non-affine maps, spatial coefficients, unavailable fixed inputs, invalid numerical factors and the ordinary scalar projection limits.

pub fn bind_affine_coordinate_map<I>( typed: &TypedResidual<I>, id: ExprId, resolve: &mut impl FnMut(SymbolRef) -> Option<ValueLiteral>, ) -> Result<Vec<BoundAffineScalarIr<ScalarSymbolCoordinate>>, Diagnostic>

where I: Clone + Eq,

Signature links:bind_affine_coordinate_mapTypedResidualExprIdFnMutSymbolRefOptionValueLiteralResultVecBoundAffineScalarIrScalarSymbolCoordinateDiagnosticCloneEq

Prove and bind the rows of one exact retained coordinate map. Rows follow its target-binding order; columns retain the ordered source coordinate identities. Fixed nonspatial inputs include physical Time. The same scalar SSA affine proof supplies values and Jacobian entries; no point sampling or numerical differentiation is used. Invertibility, orientation and a consecutive motion path remain with their consumers.

Errors

Rejects a foreign or non-map node, non-affine mapped rows, spatial coefficients, unavailable or mistyped fixed inputs, and resource excess.

§

impl ScalarOperatorIr

Signature links:ScalarOperatorIr

pub fn lower(expression: &ExprDag) -> Result<ScalarOperatorIr, Diagnostic>

Signature links:lowerExprDagResultScalarOperatorIrDiagnostic

Lower a canonical expression DAG into dense symbol slots and scalar instructions without changing operation order. Sample/Hold reuse their operand value; activation and memory admission remain with the validated KernelProgram retained by the executor, not this scalar value projection.

Errors

Returns EQ0701 if an operand/root index is inconsistent with the DAG contract.

§

impl ScalarOperatorIr

Signature links:ScalarOperatorIr

pub fn require_regular_density( &self, varying: impl FnMut(SymbolRef) -> bool, ) -> Result<(), Diagnostic>

Signature links:require_regular_densityFnMutSymbolRefboolResult()Diagnostic

Require polynomial, sine, cosine and exponential composition with no varying poles or radicals.

varying must identify every input that depends on a coordinate in the density’s support. Other inputs are held fixed; their numerical values must still pass normal evaluation (including nonzero divisors and finite intermediates). This structural check establishes no quadrature error bound and does not admit improper integrals.

Errors

Rejects varying denominators, negative powers, logarithms or square roots, and operations outside this bounded smooth profile. Callers must separately validate derived input densities.

§

impl ScalarOperatorIr

Signature links:ScalarOperatorIr

pub fn evaluate_typed_batch( &self, roots: &[ExprId], inputs: &[Vec<ValueLiteral>], ) -> Result<Vec<Vec<ValueLiteral>>, Diagnostic>

Signature links:evaluate_typed_batchExprIdVecValueLiteralResultVecVecValueLiteralDiagnostic

Evaluate real scalar property rows in existing symbols() order. Each row has fresh memoization; total scalar work and retained outputs are each limited to one million before per-row projection/allocation.

Errors

Rejects wrong row shapes/types, invalid active domains, and aggregate budgets. No partial batch result is returned on failure.

§

impl ScalarOperatorIr

Signature links:ScalarOperatorIr

pub fn coordinate_map_factor_jvp( entries: &[f64], direction: &[f64], extent: usize, factor: CoordinateMapFactor, ) -> Result<f64, Diagnostic>

Signature links:coordinate_map_factor_jvpf64f64usizeCoordinateMapFactorResultf64Diagnostic

Apply one row-major entry tangent to the existing differential-factor calculus. Entries and tangents use coherent units; the typed map owns their dimensions.

Errors

Rejects wrong tangent cardinality, nonfinite arithmetic, or the factor’s ordinary singularity/conditioning failures.

pub fn coordinate_map_factor( entries: &[f64], extent: usize, factor: CoordinateMapFactor, ) -> Result<f64, Diagnostic>

Signature links:coordinate_map_factorf64usizeCoordinateMapFactorResultf64Diagnostic

Evaluate a differential factor with the same factorization and conditioning profile as finite-map determinants and inverses. Entries use coherent units; the typed coordinate-map owner retains their individual dimensions.

Errors

Rejects invalid shape, resource exhaustion, nonfinite arithmetic, and (for volume/orientation) a singular or numerically unresolved differential.

§

impl ScalarOperatorIr

Signature links:ScalarOperatorIr

pub fn lower_typed_scalar<I>( typed: &TypedResidual<I>, ) -> Result<ScalarOperatorIr, Diagnostic>

Signature links:lower_typed_scalarTypedResidualResultScalarOperatorIrDiagnostic

Project an admitted real scalar residual for numerical derivative products. Retained definition identity stays in the canonical typed residual; this derived graph uses the existing ordered scalar expansion and input slots. Conditional programs retain their input types so ordinary numerical evaluation and linearization use typed demand and active-branch rules.

Errors

Rejects non-real or shaped values, invalid typed applications, and the existing scalar projection resource bounds.

§

impl ScalarOperatorIr

Signature links:ScalarOperatorIr

pub fn linearize_samples( &self, inputs: &[f64], samples: &[ExprId], ) -> Result<ScalarLinearization<'_>, Diagnostic>

Signature links:linearize_samplesf64ExprIdResultScalarLinearizationDiagnostic

Bind selected scalar constant leaves as numerical sample inputs.

A discretization first projects sampled Field values or gradients to scalar constants. Their source expression IDs become dense tangent slots, without fabricating Semantic Parameters or changing Model meaning. Existing semantic symbols remain frozen. Unknown tangents follow samples order and use the ordinary scalar JVP/VJP executor.

Errors

Rejects nonconstant, duplicate or missing samples, invalid symbols, and expression operations outside the ordinary scalar derivative profile.

§

impl ScalarOperatorIr

Signature links:ScalarOperatorIr

pub fn evaluate_typed( &self, roots: &[ExprId], resolve: &mut dyn FnMut(SymbolRef) -> Option<ValueLiteral>, ) -> Result<Vec<ValueLiteral>, Diagnostic>

Signature links:evaluate_typedExprIdFnMutSymbolRefOptionValueLiteralResultVecValueLiteralDiagnostic

Evaluate requested original DAG roots without projecting exact discrete values through floating point. Unreachable symbol slots are never resolved.

Errors

Rejects missing operands, incompatible values, and checked arithmetic failures.

§

impl ScalarOperatorIr

Signature links:ScalarOperatorIr

pub fn linearize_typed( &self, inputs: &[ValueLiteral], roles: &[DifferentiationRole], ) -> Result<ScalarLinearization<'_>, Diagnostic>

Signature links:linearize_typedValueLiteralDifferentiationRoleResultScalarLinearizationDiagnostic

Bind a typed point, rejecting demanded active-input boundaries. Inactive branches are type-checked but never evaluated or differentiated. Active inputs must be real scalars. Frozen inputs retain their exact typed values (including nominal discrete outcomes) and have no tangent space. Active input symbols and roles retain their original order.

Errors

Rejects wrong input types, invalid active domains, comparison ties, square root derivatives at zero, and operations outside the scalar derivative profile.

§

impl ScalarOperatorIr

Signature links:ScalarOperatorIr

pub fn symbols(&self) -> &[SymbolRef]

Signature links:symbolsSymbolRef

Dense symbol order expected by Self::evaluate.

pub fn instruction_count(&self) -> usize

Signature links:instruction_countusize

Number of scalar SSA instructions.

pub fn residual_count(&self) -> usize

Signature links:residual_countusize

Number of residual roots produced by this program.

pub fn constant_symbol_jacobian( &self, variables: &[SymbolRef], ) -> Result<ConstantSymbolJacobian, SymbolicLinearityFailure>

Signature links:constant_symbol_jacobianSymbolRefResultConstantSymbolJacobianSymbolicLinearityFailure

Prove and extract a residual Jacobian that is constant with respect to every other expression symbol.

This is a structural proof over the SSA program, not a numerical probe. Expressions with state-dependent coefficients or nonlinear dependence on any selected variable fail closed. The returned rows follow residual root order and columns follow variables order. A selected-variable-independent predicate may choose between branches with the same coefficients. Required domains remain execution obligations.

Errors

Returns the first structural reason that a constant Jacobian cannot be proven, or reports a repeated selected variable.

pub fn bind_affine( &self, selected_symbols: &[SymbolRef], bindings: &[(SymbolRef, f64)], ) -> Result<BoundAffineScalarIr, BoundAffineFailure>

Signature links:bind_affineSymbolRefSymbolReff64ResultBoundAffineScalarIrBoundAffineFailure

Bind every non-selected symbol and prove an exact affine residual form.

The returned form satisfies R(w) = A w + c: rows retain residual-root order, columns retain selected_symbols order, and coefficient/offset arithmetic follows the original SSA instruction order. This admission is structural; it performs no numerical probing or finite differences. Extra bindings are permitted, but every supplied binding is validated.

Errors

Fails closed for repeated selected symbols, duplicate or non-finite bindings, binding a selected symbol, an unbound symbol read by the IR, nonlinear selected-symbol dependence, non-finite affine arithmetic, or an invalid SSA value reference.

pub fn evaluate(&self, inputs: &[f64]) -> Result<Vec<f64>, Diagnostic>

Signature links:evaluatef64ResultVecf64Diagnostic

Evaluate residual roots with values matching Self::symbols.

Errors

Returns EQ0702 for the wrong input count and EQ0505 for a non-finite intermediate result.

pub fn linearize( &self, inputs: &[f64], roles: &[DifferentiationRole], ) -> Result<ScalarLinearization<'_>, Diagnostic>

Signature links:linearizef64DifferentiationRoleResultScalarLinearizationDiagnostic

Bind one finite point and explicit input roles into an immutable differentiable residual relation.

Errors

Returns EQ0704 when point/role cardinality differs from the dense symbol order or the point contains a non-finite value.

Trait Implementations

§

impl Clone for ScalarOperatorIr

Signature links:CloneScalarOperatorIr

§

fn clone(&self) -> ScalarOperatorIr

Signature links:cloneScalarOperatorIr

Returns a duplicate of the value.

§

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

Signature links:unstableSourceclone_from

Performs copy-assignment from source.

§

impl Debug for ScalarOperatorIr

Signature links:DebugScalarOperatorIr

§

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

Signature links:fmtFormatterResult()Error

Formats the value using the given formatter.

§

impl PartialEq for ScalarOperatorIr

Signature links:PartialEqScalarOperatorIr

§

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

Signature links:eqScalarOperatorIrbool

Tests for self and other values to be equal, and is used by ==.

§

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

Signature links:unstableSourcene&Rhsbool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for ScalarOperatorIr