Enum ComputationNode 

pub enum ComputationNode<T> {
    Leaf {
        id: Uuid,
        sample: Arc<dyn Fn() -> T + Send + Sync>,
    },
    BinaryOp {
        left: Box<ComputationNode<T>>,
        right: Box<ComputationNode<T>>,
        operation: BinaryOperation,
    },
    UnaryOp {
        operand: Box<ComputationNode<T>>,
        operation: UnaryOperation<T>,
    },
    Conditional {
        condition: Box<ComputationNode<bool>>,
        if_true: Box<ComputationNode<T>>,
        if_false: Box<ComputationNode<T>>,
    },
}

Computation graph node for lazy evaluation using indirect enum

This enables building complex expressions like (x + y) * 2.0 - z as a computation graph that’s only evaluated when samples are needed, with proper memoization to ensure shared variables use the same sample within a single evaluation.

Variants

Leaf

Leaf node representing a direct sampling function with unique ID

Fields

id: Uuid

sample: Arc<dyn Fn() -> T + Send + Sync>

BinaryOp

Binary operation node for combining two uncertain values

Fields

left: Box<ComputationNode<T>>

right: Box<ComputationNode<T>>

operation: BinaryOperation

UnaryOp

Unary operation node for transforming a single uncertain value

Fields

operand: Box<ComputationNode<T>>

operation: UnaryOperation<T>

Conditional

Conditional node for if-then-else logic

Fields

condition: Box<ComputationNode<bool>>

if_true: Box<ComputationNode<T>>

if_false: Box<ComputationNode<T>>

Implementations

impl<T> ComputationNode<T>

where T: Shareable,

pub fn evaluate(&self, context: &mut SampleContext) -> T

Evaluates the computation graph node with memoization context

This is the core evaluation method that respects memoization to ensure shared variables produce consistent samples within a single evaluation.

Panics

• Panics if called on a BinaryOp variant. Use evaluate_arithmetic instead for binary operations.
• Panics if called on a Conditional variant. Use evaluate_conditional instead for conditional operations.

pub fn evaluate_arithmetic(&self, context: &mut SampleContext) -> T

where T: Arithmetic,

Evaluates arithmetic operations with proper trait bounds

Panics

Panics if called on a Conditional variant with a boolean condition, as this is not supported in arithmetic context.

pub fn evaluate_fresh(&self) -> T

where T: Arithmetic,

Evaluates the computation graph node in a new context

This creates a fresh context for evaluation, useful when you want independent samples without memoization effects.

pub fn leaf<F>(sample: F) -> Self

where F: Fn() -> T + Send + Sync + 'static,

Creates a new leaf node

pub fn binary_op( left: ComputationNode<T>, right: ComputationNode<T>, operation: BinaryOperation, ) -> Self

Creates a new binary operation node

pub fn map<F>(operand: ComputationNode<T>, func: F) -> Self

where F: Fn(T) -> T + Send + Sync + 'static,

Creates a new unary map operation node

pub fn conditional( condition: ComputationNode<bool>, if_true: ComputationNode<T>, if_false: ComputationNode<T>, ) -> Self

Creates a conditional node

pub fn node_count(&self) -> usize

Counts the number of nodes in the computation graph

pub fn depth(&self) -> usize

Gets the depth of the computation graph

pub fn has_conditionals(&self) -> bool

Checks if the computation graph contains any conditional nodes

pub fn compute_complexity(&self) -> usize

Estimate computational complexity of the node for caching decisions

pub fn structural_hash(&self) -> u64

Generate a structural hash for computation graph caching

impl ComputationNode<bool>

pub fn evaluate_bool(&self, context: &mut SampleContext) -> bool

Evaluates boolean computation nodes

Panics

Panics if called on a BinaryOp variant as boolean binary operations are not implemented.

impl<T> ComputationNode<T>

where T: Shareable,

pub fn evaluate_conditional_with_arithmetic( &self, context: &mut SampleContext, ) -> T

where T: Arithmetic,

Evaluates conditional nodes where condition is bool and branches return T

Trait Implementations

impl<T: Clone> Clone for ComputationNode<T>

fn clone(&self) -> ComputationNode<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.