tatami
C++ API for different matrix representations
Loading...
Searching...
No Matches
Public Member Functions | List of all members
tatami::DelayedSubsetSortedUnique< Value_, Index_, SubsetStorage_ > Class Template Reference

Delayed subsetting of a matrix with sorted, unique indices. More...

#include <DelayedSubsetSortedUnique.hpp>

Inheritance diagram for tatami::DelayedSubsetSortedUnique< Value_, Index_, SubsetStorage_ >:
Inheritance graph
[legend]
Collaboration diagram for tatami::DelayedSubsetSortedUnique< Value_, Index_, SubsetStorage_ >:
Collaboration graph
[legend]

Public Member Functions

 DelayedSubsetSortedUnique (std::shared_ptr< const Matrix< Value_, Index_ > > matrix, SubsetStorage_ subset, bool by_row, bool check=true)
 
Index_ nrow () const
 
Index_ ncol () const
 
bool is_sparse () const
 
double is_sparse_proportion () const
 
bool prefer_rows () const
 
double prefer_rows_proportion () const
 
bool uses_oracle (bool row) const
 
std::unique_ptr< MyopicDenseExtractor< Value_, Index_ > > dense (bool row, const Options &opt) const
 
std::unique_ptr< MyopicDenseExtractor< Value_, Index_ > > dense (bool row, Index_ block_start, Index_ block_length, const Options &opt) const
 
std::unique_ptr< MyopicDenseExtractor< Value_, Index_ > > dense (bool row, VectorPtr< Index_ > indices_ptr, const Options &opt) const
 
std::unique_ptr< MyopicSparseExtractor< Value_, Index_ > > sparse (bool row, const Options &opt) const
 
std::unique_ptr< MyopicSparseExtractor< Value_, Index_ > > sparse (bool row, Index_ block_start, Index_ block_length, const Options &opt) const
 
std::unique_ptr< MyopicSparseExtractor< Value_, Index_ > > sparse (bool row, VectorPtr< Index_ > indices_ptr, const Options &opt) const
 
std::unique_ptr< OracularDenseExtractor< Value_, Index_ > > dense (bool row, std::shared_ptr< const Oracle< Index_ > > oracle, const Options &opt) const
 
std::unique_ptr< OracularDenseExtractor< Value_, Index_ > > dense (bool row, std::shared_ptr< const Oracle< Index_ > > oracle, Index_ block_start, Index_ block_length, const Options &opt) const
 
std::unique_ptr< OracularDenseExtractor< Value_, Index_ > > dense (bool row, std::shared_ptr< const Oracle< Index_ > > oracle, VectorPtr< Index_ > indices_ptr, const Options &opt) const
 
std::unique_ptr< OracularSparseExtractor< Value_, Index_ > > sparse (bool row, std::shared_ptr< const Oracle< Index_ > > oracle, const Options &opt) const
 
std::unique_ptr< OracularSparseExtractor< Value_, Index_ > > sparse (bool row, std::shared_ptr< const Oracle< Index_ > > oracle, Index_ block_start, Index_ block_length, const Options &opt) const
 
std::unique_ptr< OracularSparseExtractor< Value_, Index_ > > sparse (bool row, std::shared_ptr< const Oracle< Index_ > > oracle, VectorPtr< Index_ > indices_ptr, const Options &opt) const
 
- Public Member Functions inherited from tatami::Matrix< Value_, Index_ >
std::unique_ptr< MyopicDenseExtractor< Value_, Index_ > > dense_row (const Options &opt) const
 
std::unique_ptr< MyopicDenseExtractor< Value_, Index_ > > dense_row (Index_ block_start, Index_ block_length, const Options &opt) const
 
std::unique_ptr< MyopicDenseExtractor< Value_, Index_ > > dense_row (VectorPtr< Index_ > indices_ptr, const Options &opt) const
 
std::unique_ptr< MyopicDenseExtractor< Value_, Index_ > > dense_row (std::vector< Index_ > indices, const Options &opt) const
 
std::unique_ptr< MyopicDenseExtractor< Value_, Index_ > > dense_row () const
 
std::unique_ptr< MyopicDenseExtractor< Value_, Index_ > > dense_row (Index_ block_start, Index_ block_length) const
 
std::unique_ptr< MyopicDenseExtractor< Value_, Index_ > > dense_row (VectorPtr< Index_ > indices_ptr) const
 
std::unique_ptr< MyopicDenseExtractor< Value_, Index_ > > dense_row (std::vector< Index_ > indices) const
 
std::unique_ptr< OracularDenseExtractor< Value_, Index_ > > dense_row (std::shared_ptr< const Oracle< Index_ > > oracle, const Options &opt) const
 
std::unique_ptr< OracularDenseExtractor< Value_, Index_ > > dense_row (std::shared_ptr< const Oracle< Index_ > > oracle, Index_ block_start, Index_ block_length, const Options &opt) const
 
std::unique_ptr< OracularDenseExtractor< Value_, Index_ > > dense_row (std::shared_ptr< const Oracle< Index_ > > oracle, VectorPtr< Index_ > indices_ptr, const Options &opt) const
 
std::unique_ptr< OracularDenseExtractor< Value_, Index_ > > dense_row (std::shared_ptr< const Oracle< Index_ > > oracle, std::vector< Index_ > indices, const Options &opt) const
 
std::unique_ptr< OracularDenseExtractor< Value_, Index_ > > dense_row (std::shared_ptr< const Oracle< Index_ > > oracle) const
 
std::unique_ptr< OracularDenseExtractor< Value_, Index_ > > dense_row (std::shared_ptr< const Oracle< Index_ > > oracle, Index_ block_start, Index_ block_length) const
 
std::unique_ptr< OracularDenseExtractor< Value_, Index_ > > dense_row (std::shared_ptr< const Oracle< Index_ > > oracle, VectorPtr< Index_ > indices_ptr) const
 
std::unique_ptr< OracularDenseExtractor< Value_, Index_ > > dense_row (std::shared_ptr< const Oracle< Index_ > > oracle, std::vector< Index_ > indices) const
 
std::unique_ptr< MyopicDenseExtractor< Value_, Index_ > > dense_column (const Options &opt) const
 
std::unique_ptr< MyopicDenseExtractor< Value_, Index_ > > dense_column (Index_ block_start, Index_ block_length, const Options &opt) const
 
std::unique_ptr< MyopicDenseExtractor< Value_, Index_ > > dense_column (VectorPtr< Index_ > indices_ptr, const Options &opt) const
 
std::unique_ptr< MyopicDenseExtractor< Value_, Index_ > > dense_column (std::vector< Index_ > indices, const Options &opt) const
 
std::unique_ptr< MyopicDenseExtractor< Value_, Index_ > > dense_column () const
 
std::unique_ptr< MyopicDenseExtractor< Value_, Index_ > > dense_column (Index_ block_start, Index_ block_length) const
 
std::unique_ptr< MyopicDenseExtractor< Value_, Index_ > > dense_column (VectorPtr< Index_ > indices_ptr) const
 
std::unique_ptr< MyopicDenseExtractor< Value_, Index_ > > dense_column (std::vector< Index_ > indices) const
 
std::unique_ptr< OracularDenseExtractor< Value_, Index_ > > dense_column (std::shared_ptr< const Oracle< Index_ > > oracle, const Options &opt) const
 
std::unique_ptr< OracularDenseExtractor< Value_, Index_ > > dense_column (std::shared_ptr< const Oracle< Index_ > > oracle, Index_ block_start, Index_ block_length, const Options &opt) const
 
std::unique_ptr< OracularDenseExtractor< Value_, Index_ > > dense_column (std::shared_ptr< const Oracle< Index_ > > oracle, VectorPtr< Index_ > indices_ptr, const Options &opt) const
 
std::unique_ptr< OracularDenseExtractor< Value_, Index_ > > dense_column (std::shared_ptr< const Oracle< Index_ > > oracle, std::vector< Index_ > indices, const Options &opt) const
 
std::unique_ptr< OracularDenseExtractor< Value_, Index_ > > dense_column (std::shared_ptr< const Oracle< Index_ > > oracle) const
 
std::unique_ptr< OracularDenseExtractor< Value_, Index_ > > dense_column (std::shared_ptr< const Oracle< Index_ > > oracle, Index_ block_start, Index_ block_length) const
 
std::unique_ptr< OracularDenseExtractor< Value_, Index_ > > dense_column (std::shared_ptr< const Oracle< Index_ > > oracle, VectorPtr< Index_ > indices_ptr) const
 
std::unique_ptr< OracularDenseExtractor< Value_, Index_ > > dense_column (std::shared_ptr< const Oracle< Index_ > > oracle, std::vector< Index_ > indices) const
 
std::unique_ptr< MyopicSparseExtractor< Value_, Index_ > > sparse_row (const Options &opt) const
 
std::unique_ptr< MyopicSparseExtractor< Value_, Index_ > > sparse_row (Index_ block_start, Index_ block_length, const Options &opt) const
 
std::unique_ptr< MyopicSparseExtractor< Value_, Index_ > > sparse_row (VectorPtr< Index_ > indices_ptr, const Options &opt) const
 
std::unique_ptr< MyopicSparseExtractor< Value_, Index_ > > sparse_row (std::vector< Index_ > indices, const Options &opt) const
 
std::unique_ptr< MyopicSparseExtractor< Value_, Index_ > > sparse_row () const
 
std::unique_ptr< MyopicSparseExtractor< Value_, Index_ > > sparse_row (Index_ block_start, Index_ block_length) const
 
std::unique_ptr< MyopicSparseExtractor< Value_, Index_ > > sparse_row (VectorPtr< Index_ > indices_ptr) const
 
std::unique_ptr< MyopicSparseExtractor< Value_, Index_ > > sparse_row (std::vector< Index_ > indices) const
 
std::unique_ptr< OracularSparseExtractor< Value_, Index_ > > sparse_row (std::shared_ptr< const Oracle< Index_ > > oracle, const Options &opt) const
 
std::unique_ptr< OracularSparseExtractor< Value_, Index_ > > sparse_row (std::shared_ptr< const Oracle< Index_ > > oracle, Index_ block_start, Index_ block_length, const Options &opt) const
 
std::unique_ptr< OracularSparseExtractor< Value_, Index_ > > sparse_row (std::shared_ptr< const Oracle< Index_ > > oracle, VectorPtr< Index_ > indices_ptr, const Options &opt) const
 
std::unique_ptr< OracularSparseExtractor< Value_, Index_ > > sparse_row (std::shared_ptr< const Oracle< Index_ > > oracle, std::vector< Index_ > indices, const Options &opt) const
 
std::unique_ptr< OracularSparseExtractor< Value_, Index_ > > sparse_row (std::shared_ptr< const Oracle< Index_ > > oracle) const
 
std::unique_ptr< OracularSparseExtractor< Value_, Index_ > > sparse_row (std::shared_ptr< const Oracle< Index_ > > oracle, Index_ block_start, Index_ block_length) const
 
std::unique_ptr< OracularSparseExtractor< Value_, Index_ > > sparse_row (std::shared_ptr< const Oracle< Index_ > > oracle, VectorPtr< Index_ > indices_ptr) const
 
std::unique_ptr< OracularSparseExtractor< Value_, Index_ > > sparse_row (std::shared_ptr< const Oracle< Index_ > > oracle, std::vector< Index_ > indices) const
 
std::unique_ptr< MyopicSparseExtractor< Value_, Index_ > > sparse_column (const Options &opt) const
 
std::unique_ptr< MyopicSparseExtractor< Value_, Index_ > > sparse_column (Index_ block_start, Index_ block_length, const Options &opt) const
 
std::unique_ptr< MyopicSparseExtractor< Value_, Index_ > > sparse_column (VectorPtr< Index_ > indices_ptr, const Options &opt) const
 
std::unique_ptr< MyopicSparseExtractor< Value_, Index_ > > sparse_column (std::vector< Index_ > indices, const Options &opt) const
 
std::unique_ptr< MyopicSparseExtractor< Value_, Index_ > > sparse_column () const
 
std::unique_ptr< MyopicSparseExtractor< Value_, Index_ > > sparse_column (Index_ block_start, Index_ block_length) const
 
std::unique_ptr< MyopicSparseExtractor< Value_, Index_ > > sparse_column (VectorPtr< Index_ > indices_ptr) const
 
std::unique_ptr< MyopicSparseExtractor< Value_, Index_ > > sparse_column (std::vector< Index_ > indices) const
 
std::unique_ptr< OracularSparseExtractor< Value_, Index_ > > sparse_column (std::shared_ptr< const Oracle< Index_ > > oracle, const Options &opt) const
 
std::unique_ptr< OracularSparseExtractor< Value_, Index_ > > sparse_column (std::shared_ptr< const Oracle< Index_ > > oracle, Index_ block_start, Index_ block_length, const Options &opt) const
 
std::unique_ptr< OracularSparseExtractor< Value_, Index_ > > sparse_column (std::shared_ptr< const Oracle< Index_ > > oracle, VectorPtr< Index_ > indices_ptr, const Options &opt) const
 
std::unique_ptr< OracularSparseExtractor< Value_, Index_ > > sparse_column (std::shared_ptr< const Oracle< Index_ > > oracle, std::vector< Index_ > indices, const Options &opt) const
 
std::unique_ptr< OracularSparseExtractor< Value_, Index_ > > sparse_column (std::shared_ptr< const Oracle< Index_ > > oracle) const
 
std::unique_ptr< OracularSparseExtractor< Value_, Index_ > > sparse_column (std::shared_ptr< const Oracle< Index_ > > oracle, Index_ block_start, Index_ block_length) const
 
std::unique_ptr< OracularSparseExtractor< Value_, Index_ > > sparse_column (std::shared_ptr< const Oracle< Index_ > > oracle, VectorPtr< Index_ > indices_ptr) const
 
std::unique_ptr< OracularSparseExtractor< Value_, Index_ > > sparse_column (std::shared_ptr< const Oracle< Index_ > > oracle, std::vector< Index_ > indices) const
 

Additional Inherited Members

- Public Types inherited from tatami::Matrix< Value_, Index_ >
typedef Value_ value_type
 
typedef Index_ index_type
 

Detailed Description

template<typename Value_, typename Index_, class SubsetStorage_>
class tatami::DelayedSubsetSortedUnique< Value_, Index_, SubsetStorage_ >

Delayed subsetting of a matrix with sorted, unique indices.

Implements delayed subsetting (i.e., slicing) on the rows or columns of a matrix, given a vector of sorted and unique indices. This operation is "delayed" in that it is only evaluated when data is requested from the matrix.

Template Parameters
Value_Type of matrix value.
Index_Type of index value.
SubsetStorage_Vector containing the subset indices.

Constructor & Destructor Documentation

◆ DelayedSubsetSortedUnique()

tatami::DelayedSubsetSortedUnique< Value_, Index_, SubsetStorage_ >::DelayedSubsetSortedUnique ( std::shared_ptr< const Matrix< Value_, Index_ > >  matrix,
SubsetStorage_  subset,
bool  by_row,
bool  check = true 
)
inline
Parameters
matrixPointer to the underlying (pre-subset) matrix.
subsetVector of 0-based indices to use for subsetting on the rows (if by_row = true) or columns (otherwise). This should be sorted and unique.
by_rowWhether to apply the subset to the rows. If false, the subset is applied to the columns.
checkWhether to check subset for sorted and unique values.

Member Function Documentation

◆ nrow()

Returns
Number of rows.

Implements tatami::Matrix< Value_, Index_ >.

◆ ncol()

Returns
Number of columns.

Implements tatami::Matrix< Value_, Index_ >.

◆ is_sparse()

Returns
Boolean indicating whether this matrix is sparse.

This can be used to choose between dense and sparse outputs.

Implements tatami::Matrix< Value_, Index_ >.

◆ is_sparse_proportion()

double tatami::DelayedSubsetSortedUnique< Value_, Index_, SubsetStorage_ >::is_sparse_proportion ( ) const
inlinevirtual
Returns
Approximate proportion of the matrix that is sparse.

This is defined as the proportion of matrix elements that lie within sparse submatrices. It is intended for use in Matrix representations that consist of combinations of multiple submatrices (e.g., DelayedBind), allowing them to derive a suitable value for is_sparse() based on whether most of its submatrices are sparse. (A more granular approach would be to report the density of structural non-zero elements, but this may not be known by all representations at construction time.)

Implements tatami::Matrix< Value_, Index_ >.

◆ prefer_rows()

Returns
The preferred dimension for extracting values. If true, row-wise extraction is preferred; if false, column-wise extraction is preferred.

Implements tatami::Matrix< Value_, Index_ >.

◆ prefer_rows_proportion()

double tatami::DelayedSubsetSortedUnique< Value_, Index_, SubsetStorage_ >::prefer_rows_proportion ( ) const
inlinevirtual
Returns
Approximate proportion of the matrix that prefers row-level access.

This is defined as the proportion of matrix elements that lie within submatrices that prefer row-level access. It is useful for determining the return value of prefer_rows() in combined matrices consisting of both row- and column-preferred submatrices. In such cases, the net preference can be determined based on the combined size of the submatrices for each preference. (A more granular approach would be to report the iteration cost on each dimension, but this is difficult to estimate.)

Implements tatami::Matrix< Value_, Index_ >.

◆ uses_oracle()

Parameters
rowRow access if true, column access otherwise.
Returns
Whether this matrix's tatami::Extractor classes make use of oracle predictions for row (if row = true) or column access (otherwise).

The output of this method indicates whether callers should construct an oracle for use in ExtractorBase::set_oracle(). If false, callers should not bother to pass an oracle as it will be ignored.

Implements tatami::Matrix< Value_, Index_ >.

◆ dense() [1/6]

std::unique_ptr< MyopicDenseExtractor< Value_, Index_ > > tatami::DelayedSubsetSortedUnique< Value_, Index_, SubsetStorage_ >::dense ( bool  row,
const Options opt 
) const
inlinevirtual

Create an extractor that retrieves the full extent of the non-target dimension in dense form.

Parameters
rowWhether to create a row-wise extractor, i.e., the rows are the target dimension.
optOptions for extraction.
Returns
Object for extracting each row (if row = true) or column (otherwise) in dense form. This should not outlive the parent Matrix from which it was created.

Implements tatami::Matrix< Value_, Index_ >.

◆ dense() [2/6]

std::unique_ptr< MyopicDenseExtractor< Value_, Index_ > > tatami::DelayedSubsetSortedUnique< Value_, Index_, SubsetStorage_ >::dense ( bool  row,
Index_  block_start,
Index_  block_length,
const Options opt 
) const
inlinevirtual

Create an extractor that retrieves a contiguous block of the non-target dimension in dense form.

Parameters
rowWhether to create a row-wise extractor, i.e., the rows are the target dimension.
block_startIndex of the column (if row = true) or row (otherwise) at the start of the block.
block_lengthNumber of columns (if row = true) or rows (otherwise) in the block.
optOptions for extraction.
Returns
Object for extracting a contiguous block from each row (if row = true) or column (otherwise) in dense form. This should not outlive the parent Matrix from which it was created.

Implements tatami::Matrix< Value_, Index_ >.

◆ dense() [3/6]

std::unique_ptr< MyopicDenseExtractor< Value_, Index_ > > tatami::DelayedSubsetSortedUnique< Value_, Index_, SubsetStorage_ >::dense ( bool  row,
VectorPtr< Index_ indices_ptr,
const Options opt 
) const
inlinevirtual

Create an extractor that retrieves an indexed subset of the non-target dimension in dense form.

Parameters
rowWhether to create a row-wise extractor, i.e., the rows are the target dimension.
indices_ptrPointer to a vector of sorted and unique column indices (if row = true) or row indices (otherwise). This should be non-NULL.
optOptions for extraction.
Returns
Object for extracting an indexed subset from each row (if row = true) or column (otherwise) in dense form. This should not outlive the parent Matrix from which it was created.

Implements tatami::Matrix< Value_, Index_ >.

◆ sparse() [1/6]

std::unique_ptr< MyopicSparseExtractor< Value_, Index_ > > tatami::DelayedSubsetSortedUnique< Value_, Index_, SubsetStorage_ >::sparse ( bool  row,
const Options opt 
) const
inlinevirtual

Create an extractor that retrieves the full extent of the non-target dimension in sparse form.

Parameters
rowWhether to create a row-wise extractor, i.e., the rows are the target dimension.
optOptions for extraction.
Returns
Object for extracting each row (if row = true) or columns (otherwise) in sparse form. This should not outlive the parent Matrix from which it was created.

Implements tatami::Matrix< Value_, Index_ >.

◆ sparse() [2/6]

std::unique_ptr< MyopicSparseExtractor< Value_, Index_ > > tatami::DelayedSubsetSortedUnique< Value_, Index_, SubsetStorage_ >::sparse ( bool  row,
Index_  block_start,
Index_  block_length,
const Options opt 
) const
inlinevirtual

Create an extractor that retrieves a contiguous block of the non-target dimension in sparse form.

Parameters
rowWhether to create a row-wise extractor, i.e., the rows are the target dimension.
block_startIndex of the column (if row = true) or row (otherwise) at the start of the block.
block_lengthNumber of columns (if row = true) or rows (otherwise) in the block.
optOptions for extraction.
Returns
Object for extracting a contiguous block from each row (if row = true) or column (otherwise) in sparse form. This should not outlive the parent Matrix from which it was created.

Implements tatami::Matrix< Value_, Index_ >.

◆ sparse() [3/6]

std::unique_ptr< MyopicSparseExtractor< Value_, Index_ > > tatami::DelayedSubsetSortedUnique< Value_, Index_, SubsetStorage_ >::sparse ( bool  row,
VectorPtr< Index_ indices_ptr,
const Options opt 
) const
inlinevirtual

Create an extractor that retrieves an indexed subset of the non-target dimension in sparse form.

Parameters
rowWhether to create a row-wise extractor, i.e., the rows are the target dimension.
indices_ptrPointer to a vector of sorted and unique column indices (if row = true) or row indices (otherwise). This should be non-NULL.
optOptions for extraction.
Returns
Object for extracting an indexed subset from each row (if row = true) or column (otherwise) in sparse form. This should not outlive the parent Matrix from which it was created.

Implements tatami::Matrix< Value_, Index_ >.

◆ dense() [4/6]

std::unique_ptr< OracularDenseExtractor< Value_, Index_ > > tatami::DelayedSubsetSortedUnique< Value_, Index_, SubsetStorage_ >::dense ( bool  row,
std::shared_ptr< const Oracle< Index_ > >  oracle,
const Options opt 
) const
inlinevirtual

Create an oracle-aware extractor that retrieves the full extent of the non-target dimension in dense form.

Parameters
rowWhether to create a row-wise extractor, i.e., the rows are the target dimension.
oracleAn oracle supplying predictions of the next requested row (if row = true) or column (otherwise).
optOptions for extraction.
Returns
Object for extracting each row (if row = true) or columns (otherwise) in dense form. This should not outlive the parent Matrix from which it was created.

Implements tatami::Matrix< Value_, Index_ >.

◆ dense() [5/6]

std::unique_ptr< OracularDenseExtractor< Value_, Index_ > > tatami::DelayedSubsetSortedUnique< Value_, Index_, SubsetStorage_ >::dense ( bool  row,
std::shared_ptr< const Oracle< Index_ > >  oracle,
Index_  block_start,
Index_  block_length,
const Options opt 
) const
inlinevirtual

Create an oracle-aware extractor that retrieves a contiguous block of the non-target dimension in dense form.

Parameters
rowWhether to create a row-wise extractor, i.e., the rows are the target dimension.
oracleAn oracle supplying predictions of the next requested row (if row = true) or column (otherwise).
block_startIndex of the column (if row = true) or row (otherwise) at the start of the block.
block_lengthNumber of columns (if row = true) or rows (otherwise) in the block.
optOptions for extraction.
Returns
Object for extracting a contiguous block from each row (if row = true) or column (otherwise) in dense form. This should not outlive the parent Matrix from which it was created.

Implements tatami::Matrix< Value_, Index_ >.

◆ dense() [6/6]

std::unique_ptr< OracularDenseExtractor< Value_, Index_ > > tatami::DelayedSubsetSortedUnique< Value_, Index_, SubsetStorage_ >::dense ( bool  row,
std::shared_ptr< const Oracle< Index_ > >  oracle,
VectorPtr< Index_ indices_ptr,
const Options opt 
) const
inlinevirtual

Create an oracle-aware extractor that retrieves an indexed subset of the non-target dimension in dense form.

Parameters
rowWhether to create a row-wise extractor, i.e., the rows are the target dimension.
oracleAn oracle supplying predictions of the next requested row (if row = true) or column (otherwise).
indices_ptrPointer to a vector of sorted and unique column indices (if row = true) or row indices (otherwise). This should not be NULL.
optOptions for extraction.
Returns
Object for extracting an indexed subset from each row (if row = true) or column (otherwise) in dense form. This should not outlive the parent Matrix from which it was created.

Implements tatami::Matrix< Value_, Index_ >.

◆ sparse() [4/6]

std::unique_ptr< OracularSparseExtractor< Value_, Index_ > > tatami::DelayedSubsetSortedUnique< Value_, Index_, SubsetStorage_ >::sparse ( bool  row,
std::shared_ptr< const Oracle< Index_ > >  oracle,
const Options opt 
) const
inlinevirtual

Create an oracle-aware extractor that retrieves the full extent of the non-target dimension in sparse form.

Parameters
rowWhether to create a row-wise extractor, i.e., the rows are the target dimension.
oracleAn oracle supplying predictions of the next requested row (if row = true) or column (otherwise).
optOptions for extraction.
Returns
Object for extracting each row (if row = true) or columns (otherwise) in sparse form. This should not outlive the parent Matrix from which it was created.

Implements tatami::Matrix< Value_, Index_ >.

◆ sparse() [5/6]

std::unique_ptr< OracularSparseExtractor< Value_, Index_ > > tatami::DelayedSubsetSortedUnique< Value_, Index_, SubsetStorage_ >::sparse ( bool  row,
std::shared_ptr< const Oracle< Index_ > >  oracle,
Index_  block_start,
Index_  block_length,
const Options opt 
) const
inlinevirtual

Create an oracle-aware extractor that retrieves a contiguous block of the non-target dimension in sparse form.

Parameters
rowWhether to create a row-wise extractor, i.e., the rows are the target dimension.
oracleAn oracle supplying predictions of the next requested row (if row = true) or column (otherwise).
block_startIndex of the column (if row = true) or row (otherwise) at the start of the block.
block_lengthNumber of columns (if row = true) or rows (otherwise) in the block.
optOptions for extraction.
Returns
Object for extracting a contiguous block from each row (if row = true) or column (otherwise) in dense form. This should not outlive the parent Matrix from which it was created.

Implements tatami::Matrix< Value_, Index_ >.

◆ sparse() [6/6]

std::unique_ptr< OracularSparseExtractor< Value_, Index_ > > tatami::DelayedSubsetSortedUnique< Value_, Index_, SubsetStorage_ >::sparse ( bool  row,
std::shared_ptr< const Oracle< Index_ > >  oracle,
VectorPtr< Index_ indices_ptr,
const Options opt 
) const
inlinevirtual

Create an oracle-aware extractor that retrieves an indexed subset of the non-target dimension in sparse form.

Parameters
rowWhether to create a row-wise extractor, i.e., the rows are the target dimension.
oracleAn oracle supplying predictions of the next requested row (if row = true) or column (otherwise).
indices_ptrPointer to a vector of sorted and unique column indices (if row = true) or row indices (otherwise). This should not be NULL.
optOptions for extraction.
Returns
Object for extracting an indexed subset from each row (if row = true) or column (otherwise) in sparse form. This should not outlive the parent Matrix from which it was created.

Implements tatami::Matrix< Value_, Index_ >.


The documentation for this class was generated from the following file: