Struct NegExpr 

pub struct NegExpr<E> { /* private fields */ }

Unary negation expression

Implementations

impl<E> NegExpr<E>

pub fn new(expr: E) -> Self

Create a new negation expression

Trait Implementations

impl<E: Clone> Clone for NegExpr<E>

fn clone(&self) -> NegExpr<E>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<E: Debug> Debug for NegExpr<E>

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

Formats the value using the given formatter.

impl<E> TensorExpr for NegExpr<E>

where E: TensorExpr, E::Scalar: Neg<Output = E::Scalar>,

type Scalar = <E as TensorExpr>::Scalar

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<E: Copy> Copy for NegExpr<E>