Trait tc_tensor::SparseAccess

pub trait SparseAccess<FD, FS, D, T>: ReadValueAt<D, Txn = T> + TensorAccess + Clone + Display + Send + Sync + 'staticwhere
    D: Dir,
    T: Transaction<D>,{
    type Slice: SparseAccess<FD, FS, D, T>;

    fn accessor(self) -> SparseAccessor<FD, FS, D, T>;
    fn filled<'a, 'async_trait>(
        self,
        txn: T
    ) -> Pin<Box<dyn Future<Output = TCResult<Pin<Box<dyn Stream<Item = TCResult<(Coord, Number)>> + Send + Unpin + 'a>>>> + Send + 'async_trait>>
    where
        Self: 'async_trait,
        'a: 'async_trait;
    fn filled_at<'a, 'async_trait>(
        self,
        txn: T,
        axes: Vec<usize>
    ) -> Pin<Box<dyn Future<Output = TCResult<TCBoxTryStream<'a, Coords>>> + Send + 'async_trait>>
    where
        Self: 'async_trait,
        'a: 'async_trait;
    fn filled_count<'async_trait>(
        self,
        txn: T
    ) -> Pin<Box<dyn Future<Output = TCResult<u64>> + Send + 'async_trait>>
    where
        Self: 'async_trait;
    fn is_empty<'async_trait>(
        self,
        txn: T
    ) -> Pin<Box<dyn Future<Output = TCResult<bool>> + Send + 'async_trait>>
    where
        Self: 'async_trait;
    fn slice(self, bounds: Bounds) -> TCResult<Self::Slice>;
    fn transpose(
        self,
        permutation: Option<Vec<usize>>
    ) -> TCResult<SparseAccessor<FD, FS, D, T>>;
}

Access methods for SparseTensor data

Required Associated Types

type Slice: SparseAccess<FD, FS, D, T>

The type of a slice of this accessor

Required Methods

fn accessor(self) -> SparseAccessor<FD, FS, D, T>

Return this accessor as a SparseAccessor.

fn filled<'a, 'async_trait>(
    self,
    txn: T
) -> Pin<Box<dyn Future<Output = TCResult<Pin<Box<dyn Stream<Item = TCResult<(Coord, Number)>> + Send + Unpin + 'a>>>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'a: 'async_trait,

Return this SparseTensor’s contents as an ordered stream of (Coord, [Number]) pairs.

fn filled_at<'a, 'async_trait>(
    self,
    txn: T,
    axes: Vec<usize>
) -> Pin<Box<dyn Future<Output = TCResult<TCBoxTryStream<'a, Coords>>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'a: 'async_trait,

Return an ordered stream of unique Coords on the given axes with nonzero values.

Note: is it not safe to assume that all returned coordinates are filled, but it is safe to assume that all coordinates not returned are not filled.

TODO: add sort parameter to make sorting results optional.

fn filled_count<'async_trait>(
    self,
    txn: T
) -> Pin<Box<dyn Future<Output = TCResult<u64>> + Send + 'async_trait>>where
    Self: 'async_trait,

Return the number of nonzero values in this SparseTensor.

fn is_empty<'async_trait>(
    self,
    txn: T
) -> Pin<Box<dyn Future<Output = TCResult<bool>> + Send + 'async_trait>>where
    Self: 'async_trait,

Return true if this SparseTensor contains no elements.

fn slice(self, bounds: Bounds) -> TCResult<Self::Slice>

Return a slice of this accessor with the given Bounds.

fn transpose(
    self,
    permutation: Option<Vec<usize>>
) -> TCResult<SparseAccessor<FD, FS, D, T>>

Return this accessor as transposed according to the given permutation.

If no permutation is given, this accessor’s axes will be reversed.

Implementors

impl<FD, FS, D, T> SparseAccess<FD, FS, D, T> for SparseAccessor<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 Slice = SparseAccessor<FD, FS, D, T>

impl<FD, FS, D, T> SparseAccess<FD, FS, D, T> for SparseTable<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 Slice = SparseAccessor<FD, FS, D, T>