Struct ArrayExpr 

pub struct ArrayExpr<'a, T: Copy> { /* private fields */ }

Array reference expression

Wraps a slice for use in expression templates

Implementations

impl<'a, T: Copy> ArrayExpr<'a, T>

pub fn new(data: &'a [T]) -> Self

Create a new array expression from a slice

Trait Implementations

impl<'a, T> Add for ArrayExpr<'a, T>

where T: Copy + Add<Output = T>,

type Output = BinaryExpr<ArrayExpr<'a, T>, ArrayExpr<'a, T>, AddOp>

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self::Output

Performs the + operation.

impl<'a, T: Clone + Copy> Clone for ArrayExpr<'a, T>

fn clone(&self) -> ArrayExpr<'a, T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a, T: Debug + Copy> Debug for ArrayExpr<'a, T>

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

Formats the value using the given formatter.

impl<'a, T> Div for ArrayExpr<'a, T>

where T: Copy + Div<Output = T>,

type Output = BinaryExpr<ArrayExpr<'a, T>, ArrayExpr<'a, T>, DivOp>

The resulting type after applying the / operator.

fn div(self, rhs: Self) -> Self::Output

Performs the / operation.

impl<'a, T> Mul for ArrayExpr<'a, T>

where T: Copy + Mul<Output = T>,

type Output = BinaryExpr<ArrayExpr<'a, T>, ArrayExpr<'a, T>, MulOp>

The resulting type after applying the * operator.

fn mul(self, rhs: Self) -> Self::Output

Performs the * operation.

impl<'a, T> Neg for ArrayExpr<'a, T>

where T: Copy + Neg<Output = T>,

type Output = NegExpr<ArrayExpr<'a, T>>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<'a, T> Sub for ArrayExpr<'a, T>

where T: Copy + Sub<Output = T>,

type Output = BinaryExpr<ArrayExpr<'a, T>, ArrayExpr<'a, T>, SubOp>

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self::Output

Performs the - operation.

impl<'a, T: Copy> TensorExpr for ArrayExpr<'a, T>

type Scalar = T

The scalar type of the expression result

fn eval(&self, index: usize) -> Self::Scalar

Evaluate the expression at the given linear index

fn len(&self) -> usize

Get the total number of elements in the expression

fn is_empty(&self) -> bool

Check if the expression is empty

fn map<F, S>(self, f: F) -> MapExpr<Self, F, S>

where F: Fn(Self::Scalar) -> S, S: Copy,

Map this expression to a new expression by applying a function

fn reduce<F>(&self, init: Self::Scalar, f: F) -> Self::Scalar

where F: Fn(Self::Scalar, Self::Scalar) -> Self::Scalar,

Reduce this expression to a single value

fn sum(&self) -> Self::Scalar

where Self::Scalar: Add<Output = Self::Scalar> + Default,

Sum all elements in the expression

fn max(&self) -> Option<Self::Scalar>

where Self::Scalar: PartialOrd,

Find the maximum element in the expression

fn min(&self) -> Option<Self::Scalar>

where Self::Scalar: PartialOrd,

Find the minimum element in the expression

fn materialize(&self) -> Vec<Self::Scalar>

Materialize the expression into a vector

fn apply_to_slice(&self, output: &mut [Self::Scalar])

Apply the expression to a mutable slice

impl<'a, T: Copy + Copy> Copy for ArrayExpr<'a, T>