Trait tc_tensor::TensorUnary

pub trait TensorUnary<D: Dir> {
    type Txn: Transaction<D>;
    type Unary: TensorInstance;

    fn abs(&self) -> TCResult<Self::Unary>;
    fn exp(&self) -> TCResult<Self::Unary>;
    fn ln(&self) -> TCResult<Self::Unary>;
    fn round(&self) -> TCResult<Self::Unary>;
    fn all<'async_trait>(
        self, 
        txn: Self::Txn
    ) -> Pin<Box<dyn Future<Output = TCResult<bool>> + Send + 'async_trait>>
    where
        Self: 'async_trait;
    fn any<'async_trait>(
        self, 
        txn: Self::Txn
    ) -> Pin<Box<dyn Future<Output = TCResult<bool>> + Send + 'async_trait>>
    where
        Self: 'async_trait;
    fn not(&self) -> TCResult<Self::Unary>;
}

Unary Tensor operations

Required Associated Types

type Txn: Transaction<D>

The type of Transaction to expect

type Unary: TensorInstance

The return type of a unary operation

Required Methods

fn abs(&self) -> TCResult<Self::Unary>

Element-wise absolute value

fn exp(&self) -> TCResult<Self::Unary>

Element-wise exponentiation

fn ln(&self) -> TCResult<Self::Unary>

Element-wise natural logarithm

fn round(&self) -> TCResult<Self::Unary>

Element-wise round to the nearest integer

fn all<'async_trait>(
    self,
    txn: Self::Txn
) -> Pin<Box<dyn Future<Output = TCResult<bool>> + Send + 'async_trait>> where
    Self: 'async_trait, 

Return true if all elements in this Tensor are nonzero.

fn any<'async_trait>(
    self,
    txn: Self::Txn
) -> Pin<Box<dyn Future<Output = TCResult<bool>> + Send + 'async_trait>> where
    Self: 'async_trait, 

Return true if any element in this Tensor is nonzero.

fn not(&self) -> TCResult<Self::Unary>

Element-wise logical not

Implementors

impl<FD, FS, D, T> TensorUnary<D> for Tensor<FD, FS, D, T> where
    D: Dir,
    T: Transaction<D>,
    FD: File<Array>,
    FS: File<Node>,
    D::File: AsType<FD> + AsType<FS>,
    D::FileClass: From<TensorType>, 

type Txn = T

type Unary = Tensor<FD, FS, D, T>

impl<FD, FS, D, T, A> TensorUnary<D> for SparseTensor<FD, FS, D, T, A> where
    FD: File<Array>,
    FS: File<Node>,
    D: Dir,
    T: Transaction<D>,
    A: SparseAccess<FD, FS, D, T>, 

type Txn = T

type Unary = SparseTensor<FD, FS, D, T, SparseUnary<FD, FS, D, T>>

impl<FD, FS, D, T, B> TensorUnary<D> for DenseTensor<FD, FS, D, T, B> where
    D: Dir,
    T: Transaction<D>,
    FD: File<Array>,
    FS: File<Node>,
    D::File: AsType<FD> + AsType<FS>,
    B: DenseAccess<FD, FS, D, T>,
    D::FileClass: From<TensorType>, 

type Txn = T

type Unary = DenseTensor<FD, FS, D, T, BlockListUnary<FD, FS, D, T, B>>