Trait tc_tensor::TensorBooleanConst

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

    fn and_const(self, other: Number) -> TCResult<Self::Combine>;
    fn or_const(self, other: Number) -> TCResult<Self::DenseCombine>;
    fn xor_const(self, other: Number) -> TCResult<Self::DenseCombine>;
}

Tensor boolean operations in relation to a constant.

Required Associated Types

type Combine: TensorInstance

The return type of a boolean operation.

type DenseCombine: TensorInstance

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

Required Methods

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

Logical and

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

Logical or

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

Logical xor

Implementors

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

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

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

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 TensorBooleanConst>::DenseCombine

impl<FD, FS, D, T, B> TensorBooleanConst for DenseTensor<FD, FS, D, T, B> where
    D: Dir,
    T: Transaction<D>,
    FD: File<Array>,
    FS: File<Node>,
    B: DenseAccess<FD, FS, D, T>, 

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>>