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
    FD: File<Key = u64, Block = Array, Inner = D::Inner>,
    FS: File<Key = NodeId, Block = Node>,
    D: Dir,
    T: Transaction<D>,
    D::Write: DirCreateFile<FD>,

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<Key = u64, Block = Array, Inner = D::Inner>,
    FS: File<Key = NodeId, Block = 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
    FD: File<Key = u64, Block = Array, Inner = D::Inner>,
    FS: File<Key = NodeId, Block = Node>,
    D: Dir,
    T: Transaction<D>,
    B: DenseAccess<FD, FS, D, T>,
    D::Write: DirCreateFile<FD>,

type Txn = T

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