Struct ForwardModeEngine 

pub struct ForwardModeEngine<T: Float + Debug + Default + Clone + Send + Sync + Sum + 'static> { /* private fields */ }

Forward-mode AD engine

Implementations

impl<T: Float + Debug + Default + Clone + Send + Sync + Sum + 'static> ForwardModeEngine<T>

pub fn new() -> Self

Create a new forward-mode AD engine

pub fn enable_higher_order(&mut self, enabled: bool)

Enable higher-order derivatives

pub fn higher_order_enabled(&self) -> bool

Whether higher-order derivative tracking is enabled

pub fn set_seed_vectors(&mut self, seeds: Vec<Array1<T>>)

Set seed vectors for computing directional derivatives

pub fn seed_vectors(&self) -> &[Array1<T>]

Seed vectors previously registered with Self::set_seed_vectors

pub fn variable_order(&self) -> &[String]

Variable names in creation order (the seed-space layout)

pub fn declared_shape(&self, node_id: usize) -> Result<Option<&[usize]>>

Declared logical shape of a tape node, when the builder recorded one.

Leaves and matrix products carry an explicit shape; element-wise operations infer theirs from their operands during the forward pass and therefore report None.

pub fn create_variable(&mut self, name: &str, value: Array1<T>) -> usize

Create a variable.

Re-creating a variable under an existing name rebinds the name to the new tape node but keeps its original seed ordinal.

pub fn create_constant(&mut self, value: Array1<T>) -> usize

Create a constant

pub fn input_dimension( &self, inputs: &HashMap<String, Array1<T>>, ) -> Result<usize>

Total dimension of the seed / tangent space for the given inputs.

This is the sum of the input lengths taken in variable-creation order.

pub fn add(&mut self, lhs: usize, rhs: usize) -> Result<usize>

Add two variables

pub fn subtract(&mut self, lhs: usize, rhs: usize) -> Result<usize>

Subtract two variables

pub fn multiply(&mut self, lhs: usize, rhs: usize) -> Result<usize>

Multiply two variables

pub fn divide(&mut self, lhs: usize, rhs: usize) -> Result<usize>

Divide two variables

pub fn power(&mut self, base: usize, exponent: T) -> Result<usize>

Raise to power

pub fn exp(&mut self, input: usize) -> Result<usize>

Exponential function

pub fn log(&mut self, input: usize) -> Result<usize>

Natural logarithm

pub fn sin(&mut self, input: usize) -> Result<usize>

Sine function

pub fn cos(&mut self, input: usize) -> Result<usize>

Cosine function

pub fn tanh(&mut self, input: usize) -> Result<usize>

Hyperbolic tangent

pub fn sigmoid(&mut self, input: usize) -> Result<usize>

Sigmoid function

pub fn relu(&mut self, input: usize) -> Result<usize>

ReLU function

pub fn matmul( &mut self, lhs: usize, rhs: usize, dims: (usize, usize, usize), ) -> Result<usize>

Matrix multiplication.

dims is (m, k, n): the left operand is the row-major flattening of an m x k matrix, the right operand of a k x n matrix, and the output is m x n.

pub fn dot(&mut self, lhs: usize, rhs: usize) -> Result<usize>

Dot product

pub fn sum(&mut self, input: usize, _axis: Option<usize>) -> Result<usize>

Sum reduction over all elements

pub fn mean(&mut self, input: usize, _axis: Option<usize>) -> Result<usize>

Mean reduction over all elements

pub fn norm(&mut self, input: usize) -> Result<usize>

L2 norm

pub fn forward_pass( &self, inputs: &HashMap<String, Array1<T>>, seed_direction: &Array1<T>, ) -> Result<Vec<VectorDual<T>>>

Compute the forward pass with dual numbers.

seed_direction is a vector in the concatenated input space: its length must equal Self::input_dimension, and the slice belonging to a variable seeds that variable’s tangent component-wise.

pub fn jacobian_vector_product( &self, inputs: &HashMap<String, Array1<T>>, output_id: usize, direction: &Array1<T>, ) -> Result<Array1<T>>

Compute Jacobian-vector product

pub fn jacobian_matrix( &self, inputs: &HashMap<String, Array1<T>>, output_id: usize, input_size: usize, ) -> Result<Array2<T>>

Compute the full Jacobian of output_id with respect to the inputs.

The result has shape (output_dim, input_dim) where output_dim is the number of elements of the selected output node and input_dim is Self::input_dimension. input_size must agree with input_dim.

pub fn get_graph_stats(&self) -> ForwardModeStats

Get computation graph statistics

Trait Implementations

impl<T: Float + Debug + Default + Clone + Send + Sync + Sum + 'static> Default for ForwardModeEngine<T>

fn default() -> Self

Returns the “default value” for a type.