Enum Expr 

pub enum Expr<'a, T: Float> {
    Input(&'a Tensor<T>),
    Scalar(T),
    Add(Box<Expr<'a, T>>, Box<Expr<'a, T>>),
    Sub(Box<Expr<'a, T>>, Box<Expr<'a, T>>),
    Mul(Box<Expr<'a, T>>, Box<Expr<'a, T>>),
    Div(Box<Expr<'a, T>>, Box<Expr<'a, T>>),
    Neg(Box<Expr<'a, T>>),
    Sqrt(Box<Expr<'a, T>>),
    Exp(Box<Expr<'a, T>>),
    Ln(Box<Expr<'a, T>>),
    Abs(Box<Expr<'a, T>>),
    Sin(Box<Expr<'a, T>>),
    Cos(Box<Expr<'a, T>>),
    Pow(Box<Expr<'a, T>>, Box<Expr<'a, T>>),
    Fma(Box<Expr<'a, T>>, Box<Expr<'a, T>>, Box<Expr<'a, T>>),
    Clamp(Box<Expr<'a, T>>, T, T),
}

An expression node in the computation graph.

Each variant represents either a leaf (tensor input or scalar constant) or a fused element-wise operation. The tree is evaluated in one pass via Expr::eval, avoiding intermediate tensor allocations.

Variants

Input(&'a Tensor<T>)

A tensor input (leaf node).

Scalar(T)

A scalar constant, broadcast to match the output shape.

Add(Box<Expr<'a, T>>, Box<Expr<'a, T>>)

Element-wise addition.

Sub(Box<Expr<'a, T>>, Box<Expr<'a, T>>)

Element-wise subtraction.

Mul(Box<Expr<'a, T>>, Box<Expr<'a, T>>)

Element-wise multiplication.

Div(Box<Expr<'a, T>>, Box<Expr<'a, T>>)

Element-wise division.

Neg(Box<Expr<'a, T>>)

Unary negation.

Sqrt(Box<Expr<'a, T>>)

Element-wise square root.

Exp(Box<Expr<'a, T>>)

Element-wise exponential.

Ln(Box<Expr<'a, T>>)

Element-wise natural logarithm.

Abs(Box<Expr<'a, T>>)

Element-wise absolute value.

Sin(Box<Expr<'a, T>>)

Element-wise sine.

Cos(Box<Expr<'a, T>>)

Element-wise cosine.

Pow(Box<Expr<'a, T>>, Box<Expr<'a, T>>)

Element-wise power.

Fma(Box<Expr<'a, T>>, Box<Expr<'a, T>>, Box<Expr<'a, T>>)

Fused multiply-add: a * b + c.

Clamp(Box<Expr<'a, T>>, T, T)

Clamp values to [min, max].

Implementations

impl<'a, T: Float> Expr<'a, T>

pub fn input(tensor: &'a Tensor<T>) -> Self

Create an input expression referencing a tensor.

Examples

use scivex_core::Tensor;
use scivex_core::jit::Expr;

let t = Tensor::from_vec(vec![1.0_f64, 2.0, 3.0], vec![3]).unwrap();
let result = Expr::input(&t).eval().unwrap();
assert_eq!(result.as_slice(), &[1.0, 2.0, 3.0]);

pub fn scalar(val: T) -> Self

Create a scalar constant expression.

pub fn add(self, other: Self) -> Self

Element-wise addition: self + other.

pub fn sub(self, other: Self) -> Self

Element-wise subtraction: self - other.

pub fn mul(self, other: Self) -> Self

Element-wise multiplication: self * other.

pub fn div(self, other: Self) -> Self

Element-wise division: self / other.

pub fn neg(self) -> Self

Unary negation: -self.

pub fn sqrt(self) -> Self

Element-wise square root.

pub fn exp(self) -> Self

Element-wise exponential.

pub fn ln(self) -> Self

Element-wise natural logarithm.

pub fn abs(self) -> Self

Element-wise absolute value.

pub fn sin(self) -> Self

Element-wise sine.

pub fn cos(self) -> Self

Element-wise cosine.

pub fn pow(self, other: Self) -> Self

Element-wise power: self ^ other.

pub fn fma(self, b: Self, c: Self) -> Self

Fused multiply-add: self * b + c.

pub fn clamp(self, min: T, max: T) -> Self

Clamp values to [min, max].

pub fn eval(&self) -> Result<Tensor<T>>

Evaluate the expression tree, producing a result tensor.

All Expr::Input tensors referenced anywhere in the tree must have the same shape. Scalar nodes are broadcast to match. Returns an error if input shapes disagree or if no shape can be determined (i.e., the entire expression is purely scalar with no tensor inputs).