Struct DiffOp 

pub struct DiffOp<F> { /* private fields */ }

Available on crate feature diffop only.

A linear differential operator L = Σ C_α D^α.

Each term is a (coefficient, multi-index) pair. The operator can be evaluated exactly via DiffOp::eval using JetPlan, or used to build a SparseSamplingDistribution for stochastic estimation.

Examples

use echidna::diffop::DiffOp;

// Laplacian in 3 variables: ∂²/∂x₀² + ∂²/∂x₁² + ∂²/∂x₂²
let lap = DiffOp::laplacian(3);

// Biharmonic: ∂⁴/∂x₀⁴ + ∂⁴/∂x₁⁴ + ∂⁴/∂x₂⁴
let bih = DiffOp::biharmonic(3);

Implementations

impl<F: Float> DiffOp<F>

pub fn new(num_vars: usize, terms: Vec<(F, MultiIndex)>) -> Self

Create a differential operator from explicit (coefficient, multi-index) pairs.

Panics

Panics if terms is empty or any multi-index has wrong num_vars.

pub fn from_orders(num_vars: usize, terms: &[(F, &[u8])]) -> Self

Create a differential operator from raw order slices.

Each entry is (coefficient, orders_slice).

pub fn laplacian(n: usize) -> Self

Laplacian: Σ_j ∂²/∂x_j².

pub fn biharmonic(n: usize) -> Self

Biharmonic operator: Δ² = (Σ_j ∂²/∂x_j²)².

Expands to Σ_j ∂⁴/∂x_j⁴ + 2 Σ_{j<k} ∂⁴/(∂x_j² ∂x_k²).

For n=1, equivalent to diagonal(1, 4). For n≥2, includes cross terms. Evaluation via [eval] uses exact jet arithmetic. Stochastic estimation via stde_sparse requires importance sampling (full deterministic sampling is biased when coefficients are non-uniform).

pub fn diagonal(n: usize, k: u8) -> Self

k-th order diagonal: Σ_j ∂^k/∂x_j^k.

pub fn terms(&self) -> &[(F, MultiIndex)]

The terms of the operator.

pub fn num_vars(&self) -> usize

Number of variables.

pub fn order(&self) -> usize

Maximum total order across all terms.

pub fn is_diagonal(&self) -> bool

True if every term has exactly one active variable (no mixed partials).

pub fn split_by_order(&self) -> Vec<DiffOp<F>>

Split an inhomogeneous operator into groups of the same total order.

Returns a vector of DiffOp, each containing terms with the same total order, sorted by increasing order.

impl<F: Float + TaylorArenaLocal> DiffOp<F>

pub fn eval(&self, tape: &BytecodeTape<F>, x: &[F]) -> (F, F)

Exact evaluation: compute Lu(x) via JetPlan.

Returns (value, operator_value).

pub fn sparse_distribution(&self) -> SparseSamplingDistribution<F>

Build a SparseSamplingDistribution for stochastic estimation.

Requires all terms to have the same total order k (homogeneous operator). Use split_by_order to decompose inhomogeneous operators first.

Panics

Panics if the operator is not homogeneous (mixed total orders).

Trait Implementations

impl<F: Clone> Clone for DiffOp<F>

fn clone(&self) -> DiffOp<F>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<F: Debug> Debug for DiffOp<F>

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

Formats the value using the given formatter.