Trait tc_tensor::TensorMathConst

pub trait TensorMathConst {
    type Combine: TensorInstance;
    type DenseCombine: TensorInstance;

    fn add_const(self, other: Number) -> TCResult<Self::DenseCombine>;
    fn div_const(self, other: Number) -> TCResult<Self::Combine>;
    fn log_const(self, base: Number) -> TCResult<Self::Combine>;
    fn mul_const(self, other: Number) -> TCResult<Self::Combine>;
    fn pow_const(self, other: Number) -> TCResult<Self::Combine>;
    fn sub_const(self, other: Number) -> TCResult<Self::DenseCombine>;
}

Tensor constant math operations

Required Associated Types

type Combine: TensorInstance

The return type of a math operation

type DenseCombine: TensorInstance

The return type of a math operation with a result expected to be dense

Required Methods

fn add_const(self, other: Number) -> TCResult<Self::DenseCombine>

Add a constant to this tensor

fn div_const(self, other: Number) -> TCResult<Self::Combine>

Divide self by other.

fn log_const(self, base: Number) -> TCResult<Self::Combine>

Element-wise logarithm

fn mul_const(self, other: Number) -> TCResult<Self::Combine>

Multiply self by other.

fn pow_const(self, other: Number) -> TCResult<Self::Combine>

Raise self to the power other.

fn sub_const(self, other: Number) -> TCResult<Self::DenseCombine>

Subtract other from self.

Implementors

impl<FD, FS, D, T> TensorMathConst 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 Combine = Tensor<FD, FS, D, T>

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

impl<FD, FS, D, T, A> TensorMathConst 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>,
    Self: TensorInstance,
    <Self as TensorInstance>::Dense: TensorMathConst,

type Combine = SparseTensor<FD, FS, D, T, SparseConstCombinator<FD, FS, D, T, A>>

type DenseCombine = <<SparseTensor<FD, FS, D, T, A> as TensorInstance>::Dense as TensorMathConst>::DenseCombine

impl<FD, FS, D, T, B> TensorMathConst 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 Combine = DenseTensor<FD, FS, D, T, BlockListConst<FD, FS, D, T, B>>

type DenseCombine = DenseTensor<FD, FS, D, T, BlockListConst<FD, FS, D, T, B>>