Struct LazyTensor 

pub struct LazyTensor { /* private fields */ }

A deferred-execution tensor that records operations without running them.

Operations on LazyTensor build up a computation graph (via LazyOp) that is only executed when materialize() is called. Before materialization, the graph can be optimized via optimize() to apply algebraic simplifications such as constant folding, identity elimination, and inverse cancellation.

Implementations

impl LazyTensor

pub fn from_tensor(tensor: Tensor<f32>) -> Self

Wraps a concrete tensor into a lazy tensor.

The tensor is stored internally and referenced by a LazyOp::Tensor node.

pub fn zeros(shape: &[usize]) -> Self

Creates a lazy tensor filled with zeros (materialized on demand).

pub fn ones(shape: &[usize]) -> Self

Creates a lazy tensor filled with ones (materialized on demand).

pub fn neg(&self) -> LazyTensor

Element-wise negation.

pub fn relu(&self) -> LazyTensor

ReLU activation: max(0, x).

pub fn sigmoid(&self) -> LazyTensor

Sigmoid activation: 1 / (1 + exp(-x)).

pub fn exp(&self) -> LazyTensor

Element-wise exponential.

pub fn log(&self) -> LazyTensor

Element-wise natural logarithm.

pub fn sqrt(&self) -> LazyTensor

Element-wise square root.

pub fn abs(&self) -> LazyTensor

Element-wise absolute value.

pub fn add(&self, other: &LazyTensor) -> LazyTensor

Element-wise addition. Shapes must match.

pub fn sub(&self, other: &LazyTensor) -> LazyTensor

Element-wise subtraction. Shapes must match.

pub fn mul(&self, other: &LazyTensor) -> LazyTensor

Element-wise multiplication. Shapes must match.

pub fn div(&self, other: &LazyTensor) -> LazyTensor

Element-wise division. Shapes must match.

pub fn add_scalar(&self, s: f32) -> LazyTensor

Adds a scalar to every element.

pub fn mul_scalar(&self, s: f32) -> LazyTensor

Multiplies every element by a scalar.

pub fn sum(&self) -> LazyTensor

Sum of all elements (reduces to scalar shape).

pub fn mean(&self) -> LazyTensor

Mean of all elements (reduces to scalar shape).

pub fn reshape(&self, shape: &[usize]) -> LazyTensor

Reshapes the lazy tensor to a new shape.

The total number of elements must remain the same.

pub fn shape(&self) -> &[usize]

Returns the inferred output shape.

pub fn op_count(&self) -> usize

Counts the number of operations in the computation graph.

Leaf Tensor nodes count as 0 operations; every other node counts as 1 plus the count of its children.

pub fn materialize(&self) -> Tensor<f32>

Executes the recorded computation graph and returns a concrete Tensor<f32>.

This recursively evaluates every node in the LazyOp tree, starting from leaves and combining results upward.

pub fn optimize(&self) -> LazyTensor

Applies algebraic simplifications to the computation graph.

Currently supported optimizations:

• Identity elimination: x + 0 -> x, x * 1 -> x
• Zero multiplication: x * 0 -> zeros
• Double negation: neg(neg(x)) -> x
• Inverse cancellation: exp(log(x)) -> x, log(exp(x)) -> x
• Scalar folding: x * s1 * s2 -> x * (s1*s2), x + s1 + s2 -> x + (s1+s2)

Trait Implementations

impl Clone for LazyTensor

fn clone(&self) -> LazyTensor

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for LazyTensor

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

Formats the value using the given formatter.