Trait tc_tensor::TensorCompare

pub trait TensorCompare<O> {
    type Compare: TensorInstance;
    type Dense: TensorInstance;
    fn eq(self, other: O) -> TCResult<Self::Dense>;
    fn gt(self, other: O) -> TCResult<Self::Compare>;
    fn gte(self, other: O) -> TCResult<Self::Dense>;
    fn lt(self, other: O) -> TCResult<Self::Compare>;
    fn lte(self, other: O) -> TCResult<Self::Dense>;
    fn ne(self, other: O) -> TCResult<Self::Compare>;
}

Tensor comparison operations

Associated Types

type Compare: TensorInstance

The result of a comparison operation

type Dense: TensorInstance

The result of a comparison operation which can only return a dense Tensor

Required methods

fn eq(self, other: O) -> TCResult<Self::Dense>

Element-wise equality

fn gt(self, other: O) -> TCResult<Self::Compare>

Element-wise greater-than

fn gte(self, other: O) -> TCResult<Self::Dense>

Element-wise greater-or-equal

fn lt(self, other: O) -> TCResult<Self::Compare>

Element-wise less-than

fn lte(self, other: O) -> TCResult<Self::Dense>

Element-wise less-or-equal

fn ne(self, other: O) -> TCResult<Self::Compare>

Element-wise not-equal

Implementors

impl<FD, FS, D, T> TensorCompare<Tensor<FD, FS, D, T>> 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 Compare = Self

type Dense = Self

impl<FD, FS, D, T, A> TensorCompare<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::File: AsType<FD> + AsType<FS>,
    D::FileClass: From<TensorType>,
    A: SparseAccess<FD, FS, D, T>, 

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

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

impl<FD, FS, D, T, B> TensorCompare<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::File: AsType<FD> + AsType<FS>,
    B: DenseAccess<FD, FS, D, T>,
    D::FileClass: From<TensorType>, 

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

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

impl<FD, FS, D, T, B, O> TensorCompare<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::File: AsType<FD> + AsType<FS>,
    B: DenseAccess<FD, FS, D, T>,
    O: DenseAccess<FD, FS, D, T>,
    D::FileClass: From<TensorType>, 

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

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

impl<FD, FS, D, T, L, R> TensorCompare<SparseTensor<FD, FS, D, T, R>> for SparseTensor<FD, FS, D, T, L> where
    D: Dir,
    T: Transaction<D>,
    FD: File<Array>,
    FS: File<Node>,
    D::File: AsType<FD> + AsType<FS>,
    D::FileClass: From<TensorType>,
    L: SparseAccess<FD, FS, D, T>,
    R: SparseAccess<FD, FS, D, T>, 

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

type Dense = DenseTensor<FD, FS, D, T, BlockListSparse<FD, FS, D, T, SparseCombinator<FD, FS, D, T, L, R>>>