Trait tc_tensor::TensorDualIO

pub trait TensorDualIO<D: Dir, O> {
    type Txn: Transaction<D>;
    fn mask<'async_trait>(
        self, 
        txn: Self::Txn, 
        value: O
    ) -> Pin<Box<dyn Future<Output = TCResult<()>> + Send + 'async_trait>>
    where
        Self: 'async_trait;
    fn write<'async_trait>(
        self, 
        txn: Self::Txn, 
        bounds: Bounds, 
        value: O
    ) -> Pin<Box<dyn Future<Output = TCResult<()>> + Send + 'async_trait>>
    where
        Self: 'async_trait;
}

Tensor I/O operations which accept another Tensor as an argument

Associated Types

type Txn: Transaction<D>

The type of Transaction to expect

Required methods

fn mask<'async_trait>(
    self,
    txn: Self::Txn,
    value: O
) -> Pin<Box<dyn Future<Output = TCResult<()>> + Send + 'async_trait>> where
    Self: 'async_trait, 

Zero out the elements of this Tensor where the corresponding element of value is nonzero.

fn write<'async_trait>(
    self,
    txn: Self::Txn,
    bounds: Bounds,
    value: O
) -> Pin<Box<dyn Future<Output = TCResult<()>> + Send + 'async_trait>> where
    Self: 'async_trait, 

Overwrite the slice of this Tensor given by Bounds with the given value.

Implementors

impl<FD, FS, D, T> TensorDualIO<D, Tensor<FD, FS, D, T>> for Tensor<FD, FS, D, T> where
    FD: File<Array> + TryFrom<D::File, Error = TCError>,
    FS: File<Node> + TryFrom<D::File, Error = TCError>,
    D: Dir,
    T: Transaction<D>,
    D::FileClass: From<TensorType>, 

impl<FD, FS, D, T, A> TensorDualIO<D, Tensor<FD, FS, D, T>> for SparseTensor<FD, FS, D, T, A> where
    FD: File<Array> + TryFrom<D::File, Error = TCError>,
    FS: File<Node> + TryFrom<D::File, Error = TCError>,
    D: Dir,
    T: Transaction<D>,
    A: SparseWrite<FD, FS, D, T>,
    D::FileClass: From<TensorType>, 

impl<FD, FS, D, T, B> TensorDualIO<D, Tensor<FD, FS, D, T>> for DenseTensor<FD, FS, D, T, B> where
    FD: File<Array> + TryFrom<D::File, Error = TCError>,
    FS: File<Node> + TryFrom<D::File, Error = TCError>,
    D: Dir,
    T: Transaction<D>,
    B: DenseWrite<FD, FS, D, T>,
    D::FileClass: From<TensorType>, 

impl<FD, FS, D, T, B, O> TensorDualIO<D, DenseTensor<FD, FS, D, T, O>> for DenseTensor<FD, FS, D, T, B> where
    FD: File<Array> + TryFrom<D::File, Error = TCError>,
    FS: File<Node> + TryFrom<D::File, Error = TCError>,
    D: Dir,
    T: Transaction<D>,
    B: DenseWrite<FD, FS, D, T>,
    O: DenseAccess<FD, FS, D, T>,
    D::FileClass: From<TensorType>, 

impl<FD, FS, D, T, L, R> TensorDualIO<D, SparseTensor<FD, FS, D, T, R>> for SparseTensor<FD, FS, D, T, L> where
    FD: File<Array> + TryFrom<D::File, Error = TCError>,
    FS: File<Node> + TryFrom<D::File, Error = TCError>,
    D: Dir,
    T: Transaction<D>,
    L: SparseWrite<FD, FS, D, T>,
    R: SparseAccess<FD, FS, D, T>,
    D::FileClass: From<TensorType>,