Trait tc_tensor::TensorMath

pub trait TensorMath<D: Dir, O> {
    type Combine: TensorInstance;
    type LeftCombine: TensorInstance;

    fn add(self, other: O) -> TCResult<Self::Combine>;
    fn div(self, other: O) -> TCResult<Self::LeftCombine>;
    fn log(self, base: O) -> TCResult<Self::LeftCombine>;
    fn mul(self, other: O) -> TCResult<Self::LeftCombine>;
    fn pow(self, other: O) -> TCResult<Self::LeftCombine>;
    fn sub(self, other: O) -> TCResult<Self::Combine>;
}

Tensor math operations

Required Associated Types

type Combine: TensorInstance

The result type of a math operation

type LeftCombine: TensorInstance

The result type of a math operation which may ignore right-hand-side values

Required Methods

fn add(self, other: O) -> TCResult<Self::Combine>

Add two tensors together.

fn div(self, other: O) -> TCResult<Self::LeftCombine>

Divide self by other.

fn log(self, base: O) -> TCResult<Self::LeftCombine>

Element-wise logarithm of self with respect to the given base.

fn mul(self, other: O) -> TCResult<Self::LeftCombine>

Multiply two tensors together.

fn pow(self, other: O) -> TCResult<Self::LeftCombine>

Raise self to the power of other.

fn sub(self, other: O) -> TCResult<Self::Combine>

Subtract other from self.

Implementors

impl<FD, FS, D, T> TensorMath<D, Tensor<FD, FS, D, T>> for Tensor<FD, FS, D, T>where
    D: Dir,
    T: Transaction<D>,
    FD: File<Array>,
    FS: File<Node>,
    <D::Read as DirRead>::FileEntry: AsType<FD> + AsType<FS>,
    <D::Write as DirWrite>::FileClass: From<BTreeType> + From<TensorType>,

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

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

impl<FD, FS, D, T, A> TensorMath<D, Tensor<FD, FS, D, T>> for SparseTensor<FD, FS, D, T, A>where
    D: Dir,
    T: Transaction<D>,
    FD: File<Array>,
    FS: File<Node>,
    <D::Read as DirRead>::FileEntry: AsType<FD> + AsType<FS>,
    <D::Write as DirWrite>::FileClass: From<BTreeType> + From<TensorType>,
    A: SparseAccess<FD, FS, D, T>,

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

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

impl<FD, FS, D, T, B> TensorMath<D, Tensor<FD, FS, D, T>> for DenseTensor<FD, FS, D, T, B>where
    D: Dir,
    T: Transaction<D>,
    FD: File<Array>,
    FS: File<Node>,
    <D::Read as DirRead>::FileEntry: AsType<FD> + AsType<FS>,
    B: DenseAccess<FD, FS, D, T>,
    <D::Write as DirWrite>::FileClass: From<BTreeType> + From<TensorType>,

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

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

impl<FD, FS, D, T, B, O> TensorMath<D, DenseTensor<FD, FS, D, T, O>> for DenseTensor<FD, FS, D, T, B>where
    D: Dir,
    T: Transaction<D>,
    FD: File<Array>,
    FS: File<Node>,
    <D::Read as DirRead>::FileEntry: AsType<FD> + AsType<FS>,
    B: DenseAccess<FD, FS, D, T>,
    O: DenseAccess<FD, FS, D, T>,
    <D::Write as DirWrite>::FileClass: From<BTreeType> + From<TensorType>,

type Combine = DenseTensor<FD, FS, D, T, BlockListCombine<FD, FS, D, T, B, O>>

type LeftCombine = DenseTensor<FD, FS, D, T, BlockListCombine<FD, FS, D, T, B, O>>

impl<FD, FS, D, T, L, R> TensorMath<D, SparseTensor<FD, FS, D, T, R>> for SparseTensor<FD, FS, D, T, L>where
    FD: File<Array>,
    FS: File<Node>,
    D: Dir,
    T: Transaction<D>,
    L: SparseAccess<FD, FS, D, T>,
    R: SparseAccess<FD, FS, D, T>,

type Combine = SparseTensor<FD, FS, D, T, SparseCombinator<FD, FS, D, T, L, R>>

type LeftCombine = SparseTensor<FD, FS, D, T, SparseLeftCombinator<FD, FS, D, T, L, R>>