Virtual class for a matrix. More...

#include <Matrix.hpp>

Public Types
typedef Value_	value_type

typedef Index_	index_type

Public Member Functions
virtual Index_	nrow () const =0

virtual Index_	ncol () const =0

virtual bool	is_sparse () const =0

virtual double	is_sparse_proportion () const =0

virtual bool	prefer_rows () const =0

virtual double	prefer_rows_proportion () const =0

virtual bool	uses_oracle (bool row) const =0

virtual std::unique_ptr< MyopicDenseExtractor< Value_, Index_ > >	dense (bool row, const Options &opt) const =0

virtual std::unique_ptr< MyopicDenseExtractor< Value_, Index_ > >	dense (bool row, Index_ block_start, Index_ block_length, const Options &opt) const =0

virtual std::unique_ptr< MyopicDenseExtractor< Value_, Index_ > >	dense (bool row, VectorPtr< Index_ > indices_ptr, const Options &opt) const =0

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

virtual std::unique_ptr< MyopicSparseExtractor< Value_, Index_ > >	sparse (bool row, const Options &opt) const =0

virtual std::unique_ptr< MyopicSparseExtractor< Value_, Index_ > >	sparse (bool row, Index_ block_start, Index_ block_length, const Options &opt) const =0

virtual std::unique_ptr< MyopicSparseExtractor< Value_, Index_ > >	sparse (bool row, VectorPtr< Index_ > indices_ptr, const Options &opt) const =0

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

virtual std::unique_ptr< OracularDenseExtractor< Value_, Index_ > >	dense (bool row, std::shared_ptr< const Oracle< Index_ > > oracle, const Options &opt) const =0

virtual 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 =0

virtual std::unique_ptr< OracularDenseExtractor< Value_, Index_ > >	dense (bool row, std::shared_ptr< const Oracle< Index_ > > oracle, VectorPtr< Index_ > indices_ptr, const Options &opt) const =0

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

virtual std::unique_ptr< OracularSparseExtractor< Value_, Index_ > >	sparse (bool row, std::shared_ptr< const Oracle< Index_ > > oracle, const Options &opt) const =0

virtual 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 =0

virtual std::unique_ptr< OracularSparseExtractor< Value_, Index_ > >	sparse (bool row, std::shared_ptr< const Oracle< Index_ > > oracle, VectorPtr< Index_ > indices_ptr, const Options &opt) const =0

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

Detailed Description

template<typename Value_, typename Index_ = int>
class tatami::Matrix< Value_, Index_ >

Virtual class for a matrix.

Template Parameters

Value	Data value type, should be numeric.
Index	Row/column index type, should be integer.

Interface for a matrix in the tatami library. This declares methods to iterate through the matrix by row or column, extracting data in either dense or sparse form. Check out DenseMatrix and CompressedSparseMatrix for examples of concrete subclasses.

To access the matrix data, the Matrix methods first return an instance of an extractor class like MyopicDenseExtractor, which can then be used to retrieve the matrix contents. Creation of the extractor depends on a few parameters:

Choice of the "target" dimension. The "target" dimension is defined as the one that is iterated over/indexed into, while the "non-target" dimension is the other dimension. For example, if we were iterating row-wise through a matrix, the rows would constitute the target dimension, while the columns would be the non-target dimension. An element of the target dimension is obtained by indexing into that dimension, e.g., if the rows are the target dimension, then any particular row is an element of the target dimension.
Whether to restrict the non-target dimension (see tatami::DimensionSelectionType). We can choose to extract the full extent of the non-target dimension, a contiguous block, or an indexed subset. For example, if we were iterating row-wise through a matrix, we might only be interested in a subset of columns.
Whether the order of accesses on the target dimension are known. If so, we can potentially improve efficiency by supplying an Oracle during extractor construction. For example, if we know we will iterate through the matrix by consecutive rows, we could supply a ConsecutiveOracle to allow Matrix implementations to optimize for this access pattern.
Whether to obtain the contents for a target dimension element in dense or sparse form. The dense form is simply a contiguous 1-dimensional array of matrix Value_s. The sparse form is a SparseRange describing the structural non-zeros for that dimension element.

Matrix subclasses should describe whether they are dense/sparse and if they prefer row or column access. This allows users to choose the best method of extracting data from the matrix.

Member Typedef Documentation

◆ value_type

template<typename Value_ , typename Index_ = int>

typedef Value_ tatami::Matrix< Value_, Index_ >::value_type

Type of data to be returned by getters.

◆ index_type

template<typename Value_ , typename Index_ = int>

typedef Index_ tatami::Matrix< Value_, Index_ >::index_type

Type of index to be returned by the sparse getters.

Member Function Documentation

◆ nrow()

template<typename Value_ , typename Index_ = int>

virtual Index_ tatami::Matrix< Value_, Index_ >::nrow ( ) const

pure virtual

Returns: Number of rows.

Implemented in tatami::DenseMatrix< Value_, Index_, Storage_ >, tatami::DenseMatrix< Value_, Index_, std::vector< Value_ > >, tatami::DelayedBinaryIsometricOperation< OutputValue_, InputValue_, Index_, Operation_ >, tatami::DelayedUnaryIsometricOperation< OutputValue_, InputValue_, Index_, Operation_ >, tatami::ConstantMatrix< Value_, Index_ >, tatami::DelayedBind< Value_, Index_ >, tatami::DelayedCast< ValueOut_, IndexOut_, ValueIn_, IndexIn_ >, tatami::DelayedTranspose< Value_, Index_ >, tatami::CompressedSparseMatrix< Value_, Index_, ValueStorage_, IndexStorage_, PointerStorage_ >, tatami::CompressedSparseMatrix< Value_, Index_, std::vector< Value_ >, std::vector< Index_ >, std::vector< size_t > >, tatami::FragmentedSparseMatrix< Value_, Index_, ValueVectorStorage_, IndexVectorStorage_ >, tatami::FragmentedSparseMatrix< Value_, Index_, std::vector< std::vector< Value_ > >, std::vector< std::vector< Index_ > > >, tatami::DelayedSubset< Value_, Index_, SubsetStorage_ >, tatami::DelayedSubsetBlock< Value_, Index_ >, tatami::DelayedSubsetSorted< Value_, Index_, SubsetStorage_ >, tatami::DelayedSubsetSortedUnique< Value_, Index_, SubsetStorage_ >, and tatami::DelayedSubsetUnique< Value_, Index_, SubsetStorage_ >.

◆ ncol()

template<typename Value_ , typename Index_ = int>

virtual Index_ tatami::Matrix< Value_, Index_ >::ncol ( ) const

pure virtual

Returns: Number of columns.

Implemented in tatami::DenseMatrix< Value_, Index_, Storage_ >, tatami::DenseMatrix< Value_, Index_, std::vector< Value_ > >, tatami::DelayedBinaryIsometricOperation< OutputValue_, InputValue_, Index_, Operation_ >, tatami::DelayedUnaryIsometricOperation< OutputValue_, InputValue_, Index_, Operation_ >, tatami::ConstantMatrix< Value_, Index_ >, tatami::DelayedBind< Value_, Index_ >, tatami::DelayedCast< ValueOut_, IndexOut_, ValueIn_, IndexIn_ >, tatami::DelayedTranspose< Value_, Index_ >, tatami::CompressedSparseMatrix< Value_, Index_, ValueStorage_, IndexStorage_, PointerStorage_ >, tatami::CompressedSparseMatrix< Value_, Index_, std::vector< Value_ >, std::vector< Index_ >, std::vector< size_t > >, tatami::FragmentedSparseMatrix< Value_, Index_, ValueVectorStorage_, IndexVectorStorage_ >, tatami::FragmentedSparseMatrix< Value_, Index_, std::vector< std::vector< Value_ > >, std::vector< std::vector< Index_ > > >, tatami::DelayedSubset< Value_, Index_, SubsetStorage_ >, tatami::DelayedSubsetBlock< Value_, Index_ >, tatami::DelayedSubsetSorted< Value_, Index_, SubsetStorage_ >, tatami::DelayedSubsetSortedUnique< Value_, Index_, SubsetStorage_ >, and tatami::DelayedSubsetUnique< Value_, Index_, SubsetStorage_ >.

◆ is_sparse()

template<typename Value_ , typename Index_ = int>

virtual bool tatami::Matrix< Value_, Index_ >::is_sparse ( ) const

pure virtual

Returns: Boolean indicating whether this matrix is sparse.

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

Implemented in tatami::DenseMatrix< Value_, Index_, Storage_ >, tatami::DenseMatrix< Value_, Index_, std::vector< Value_ > >, tatami::DelayedBinaryIsometricOperation< OutputValue_, InputValue_, Index_, Operation_ >, tatami::DelayedUnaryIsometricOperation< OutputValue_, InputValue_, Index_, Operation_ >, tatami::ConstantMatrix< Value_, Index_ >, tatami::DelayedBind< Value_, Index_ >, tatami::DelayedCast< ValueOut_, IndexOut_, ValueIn_, IndexIn_ >, tatami::DelayedTranspose< Value_, Index_ >, tatami::CompressedSparseMatrix< Value_, Index_, ValueStorage_, IndexStorage_, PointerStorage_ >, tatami::CompressedSparseMatrix< Value_, Index_, std::vector< Value_ >, std::vector< Index_ >, std::vector< size_t > >, tatami::FragmentedSparseMatrix< Value_, Index_, ValueVectorStorage_, IndexVectorStorage_ >, tatami::FragmentedSparseMatrix< Value_, Index_, std::vector< std::vector< Value_ > >, std::vector< std::vector< Index_ > > >, tatami::DelayedSubset< Value_, Index_, SubsetStorage_ >, tatami::DelayedSubsetBlock< Value_, Index_ >, tatami::DelayedSubsetSorted< Value_, Index_, SubsetStorage_ >, tatami::DelayedSubsetSortedUnique< Value_, Index_, SubsetStorage_ >, and tatami::DelayedSubsetUnique< Value_, Index_, SubsetStorage_ >.

◆ is_sparse_proportion()

template<typename Value_ , typename Index_ = int>

virtual double tatami::Matrix< Value_, Index_ >::is_sparse_proportion ( ) const

pure virtual

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

Implemented in tatami::DenseMatrix< Value_, Index_, Storage_ >, tatami::DenseMatrix< Value_, Index_, std::vector< Value_ > >, tatami::DelayedBinaryIsometricOperation< OutputValue_, InputValue_, Index_, Operation_ >, tatami::DelayedUnaryIsometricOperation< OutputValue_, InputValue_, Index_, Operation_ >, tatami::ConstantMatrix< Value_, Index_ >, tatami::DelayedBind< Value_, Index_ >, tatami::DelayedCast< ValueOut_, IndexOut_, ValueIn_, IndexIn_ >, tatami::DelayedTranspose< Value_, Index_ >, tatami::CompressedSparseMatrix< Value_, Index_, ValueStorage_, IndexStorage_, PointerStorage_ >, tatami::CompressedSparseMatrix< Value_, Index_, std::vector< Value_ >, std::vector< Index_ >, std::vector< size_t > >, tatami::FragmentedSparseMatrix< Value_, Index_, ValueVectorStorage_, IndexVectorStorage_ >, tatami::FragmentedSparseMatrix< Value_, Index_, std::vector< std::vector< Value_ > >, std::vector< std::vector< Index_ > > >, tatami::DelayedSubset< Value_, Index_, SubsetStorage_ >, tatami::DelayedSubsetBlock< Value_, Index_ >, tatami::DelayedSubsetSorted< Value_, Index_, SubsetStorage_ >, tatami::DelayedSubsetSortedUnique< Value_, Index_, SubsetStorage_ >, and tatami::DelayedSubsetUnique< Value_, Index_, SubsetStorage_ >.

◆ prefer_rows()

template<typename Value_ , typename Index_ = int>

virtual bool tatami::Matrix< Value_, Index_ >::prefer_rows ( ) const

pure virtual

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

Implemented in tatami::DenseMatrix< Value_, Index_, Storage_ >, tatami::DenseMatrix< Value_, Index_, std::vector< Value_ > >, tatami::DelayedBinaryIsometricOperation< OutputValue_, InputValue_, Index_, Operation_ >, tatami::DelayedUnaryIsometricOperation< OutputValue_, InputValue_, Index_, Operation_ >, tatami::ConstantMatrix< Value_, Index_ >, tatami::DelayedBind< Value_, Index_ >, tatami::DelayedCast< ValueOut_, IndexOut_, ValueIn_, IndexIn_ >, tatami::DelayedTranspose< Value_, Index_ >, tatami::CompressedSparseMatrix< Value_, Index_, ValueStorage_, IndexStorage_, PointerStorage_ >, tatami::CompressedSparseMatrix< Value_, Index_, std::vector< Value_ >, std::vector< Index_ >, std::vector< size_t > >, tatami::FragmentedSparseMatrix< Value_, Index_, ValueVectorStorage_, IndexVectorStorage_ >, tatami::FragmentedSparseMatrix< Value_, Index_, std::vector< std::vector< Value_ > >, std::vector< std::vector< Index_ > > >, tatami::DelayedSubset< Value_, Index_, SubsetStorage_ >, tatami::DelayedSubsetBlock< Value_, Index_ >, tatami::DelayedSubsetSorted< Value_, Index_, SubsetStorage_ >, tatami::DelayedSubsetSortedUnique< Value_, Index_, SubsetStorage_ >, and tatami::DelayedSubsetUnique< Value_, Index_, SubsetStorage_ >.

◆ prefer_rows_proportion()

template<typename Value_ , typename Index_ = int>

virtual double tatami::Matrix< Value_, Index_ >::prefer_rows_proportion ( ) const

pure virtual

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

Implemented in tatami::DenseMatrix< Value_, Index_, Storage_ >, tatami::DenseMatrix< Value_, Index_, std::vector< Value_ > >, tatami::DelayedBinaryIsometricOperation< OutputValue_, InputValue_, Index_, Operation_ >, tatami::DelayedUnaryIsometricOperation< OutputValue_, InputValue_, Index_, Operation_ >, tatami::ConstantMatrix< Value_, Index_ >, tatami::DelayedBind< Value_, Index_ >, tatami::DelayedCast< ValueOut_, IndexOut_, ValueIn_, IndexIn_ >, tatami::DelayedTranspose< Value_, Index_ >, tatami::CompressedSparseMatrix< Value_, Index_, ValueStorage_, IndexStorage_, PointerStorage_ >, tatami::CompressedSparseMatrix< Value_, Index_, std::vector< Value_ >, std::vector< Index_ >, std::vector< size_t > >, tatami::FragmentedSparseMatrix< Value_, Index_, ValueVectorStorage_, IndexVectorStorage_ >, tatami::FragmentedSparseMatrix< Value_, Index_, std::vector< std::vector< Value_ > >, std::vector< std::vector< Index_ > > >, tatami::DelayedSubset< Value_, Index_, SubsetStorage_ >, tatami::DelayedSubsetBlock< Value_, Index_ >, tatami::DelayedSubsetSorted< Value_, Index_, SubsetStorage_ >, tatami::DelayedSubsetSortedUnique< Value_, Index_, SubsetStorage_ >, and tatami::DelayedSubsetUnique< Value_, Index_, SubsetStorage_ >.

◆ uses_oracle()

template<typename Value_ , typename Index_ = int>

virtual bool tatami::Matrix< Value_, Index_ >::uses_oracle ( bool row ) const

pure virtual

Parameters

row	Row 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.

Implemented in tatami::DelayedBinaryIsometricOperation< OutputValue_, InputValue_, Index_, Operation_ >, tatami::DelayedUnaryIsometricOperation< OutputValue_, InputValue_, Index_, Operation_ >, tatami::DelayedBind< Value_, Index_ >, tatami::DelayedCast< ValueOut_, IndexOut_, ValueIn_, IndexIn_ >, tatami::DelayedTranspose< Value_, Index_ >, tatami::DelayedSubset< Value_, Index_, SubsetStorage_ >, tatami::DelayedSubsetBlock< Value_, Index_ >, tatami::DelayedSubsetSorted< Value_, Index_, SubsetStorage_ >, tatami::DelayedSubsetSortedUnique< Value_, Index_, SubsetStorage_ >, tatami::DelayedSubsetUnique< Value_, Index_, SubsetStorage_ >, tatami::DenseMatrix< Value_, Index_, Storage_ >, tatami::DenseMatrix< Value_, Index_, std::vector< Value_ > >, tatami::ConstantMatrix< Value_, Index_ >, tatami::CompressedSparseMatrix< Value_, Index_, ValueStorage_, IndexStorage_, PointerStorage_ >, tatami::CompressedSparseMatrix< Value_, Index_, std::vector< Value_ >, std::vector< Index_ >, std::vector< size_t > >, tatami::FragmentedSparseMatrix< Value_, Index_, ValueVectorStorage_, IndexVectorStorage_ >, and tatami::FragmentedSparseMatrix< Value_, Index_, std::vector< std::vector< Value_ > >, std::vector< std::vector< Index_ > > >.

◆ dense() [1/6]

template<typename Value_ , typename Index_ = int>

virtual std::unique_ptr< MyopicDenseExtractor< Value_, Index_ > > tatami::Matrix< Value_, Index_ >::dense	(	bool	row,
		const Options &	opt
	)		const

pure virtual

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

Parameters

row	Whether to create a row-wise extractor, i.e., the rows are the target dimension.
opt	Options 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.

Implemented in tatami::DenseMatrix< Value_, Index_, Storage_ >, tatami::DenseMatrix< Value_, Index_, std::vector< Value_ > >, tatami::CompressedSparseMatrix< Value_, Index_, ValueStorage_, IndexStorage_, PointerStorage_ >, tatami::CompressedSparseMatrix< Value_, Index_, std::vector< Value_ >, std::vector< Index_ >, std::vector< size_t > >, tatami::DelayedBinaryIsometricOperation< OutputValue_, InputValue_, Index_, Operation_ >, tatami::DelayedUnaryIsometricOperation< OutputValue_, InputValue_, Index_, Operation_ >, tatami::ConstantMatrix< Value_, Index_ >, tatami::DelayedBind< Value_, Index_ >, tatami::DelayedCast< ValueOut_, IndexOut_, ValueIn_, IndexIn_ >, tatami::DelayedTranspose< Value_, Index_ >, tatami::DelayedSubset< Value_, Index_, SubsetStorage_ >, tatami::DelayedSubsetBlock< Value_, Index_ >, tatami::DelayedSubsetSorted< Value_, Index_, SubsetStorage_ >, tatami::DelayedSubsetSortedUnique< Value_, Index_, SubsetStorage_ >, and tatami::DelayedSubsetUnique< Value_, Index_, SubsetStorage_ >.

◆ dense() [2/6]

template<typename Value_ , typename Index_ = int>

virtual std::unique_ptr< MyopicDenseExtractor< Value_, Index_ > > tatami::Matrix< Value_, Index_ >::dense	(	bool	row,
		Index_	block_start,
		Index_	block_length,
		const Options &	opt
	)		const

pure virtual

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

Parameters

row	Whether to create a row-wise extractor, i.e., the rows are the target dimension.
block_start	Index of the column (if `row = true`) or row (otherwise) at the start of the block.
block_length	Number of columns (if `row = true`) or rows (otherwise) in the block.
opt	Options 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.

Implemented in tatami::CompressedSparseMatrix< Value_, Index_, ValueStorage_, IndexStorage_, PointerStorage_ >, tatami::CompressedSparseMatrix< Value_, Index_, std::vector< Value_ >, std::vector< Index_ >, std::vector< size_t > >, tatami::DenseMatrix< Value_, Index_, Storage_ >, tatami::DenseMatrix< Value_, Index_, std::vector< Value_ > >, tatami::DelayedBinaryIsometricOperation< OutputValue_, InputValue_, Index_, Operation_ >, tatami::DelayedUnaryIsometricOperation< OutputValue_, InputValue_, Index_, Operation_ >, tatami::ConstantMatrix< Value_, Index_ >, tatami::DelayedBind< Value_, Index_ >, tatami::DelayedTranspose< Value_, Index_ >, tatami::DelayedSubset< Value_, Index_, SubsetStorage_ >, tatami::DelayedSubsetBlock< Value_, Index_ >, tatami::DelayedSubsetSorted< Value_, Index_, SubsetStorage_ >, tatami::DelayedSubsetSortedUnique< Value_, Index_, SubsetStorage_ >, tatami::DelayedSubsetUnique< Value_, Index_, SubsetStorage_ >, and tatami::DelayedCast< ValueOut_, IndexOut_, ValueIn_, IndexIn_ >.

◆ dense() [3/6]

template<typename Value_ , typename Index_ = int>

virtual std::unique_ptr< MyopicDenseExtractor< Value_, Index_ > > tatami::Matrix< Value_, Index_ >::dense	(	bool	row,
		VectorPtr< Index_ >	indices_ptr,
		const Options &	opt
	)		const

pure virtual

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

Parameters

row	Whether to create a row-wise extractor, i.e., the rows are the target dimension.
indices_ptr	Pointer to a vector of sorted and unique column indices (if `row = true`) or row indices (otherwise). This should be non-NULL.
opt	Options 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.

Implemented in tatami::DenseMatrix< Value_, Index_, Storage_ >, tatami::DenseMatrix< Value_, Index_, std::vector< Value_ > >, tatami::CompressedSparseMatrix< Value_, Index_, ValueStorage_, IndexStorage_, PointerStorage_ >, tatami::CompressedSparseMatrix< Value_, Index_, std::vector< Value_ >, std::vector< Index_ >, std::vector< size_t > >, tatami::DelayedBinaryIsometricOperation< OutputValue_, InputValue_, Index_, Operation_ >, tatami::DelayedUnaryIsometricOperation< OutputValue_, InputValue_, Index_, Operation_ >, tatami::ConstantMatrix< Value_, Index_ >, tatami::DelayedBind< Value_, Index_ >, tatami::DelayedTranspose< Value_, Index_ >, tatami::DelayedSubsetBlock< Value_, Index_ >, tatami::DelayedSubsetSorted< Value_, Index_, SubsetStorage_ >, tatami::DelayedSubsetSortedUnique< Value_, Index_, SubsetStorage_ >, tatami::DelayedSubsetUnique< Value_, Index_, SubsetStorage_ >, tatami::DelayedSubset< Value_, Index_, SubsetStorage_ >, and tatami::DelayedCast< ValueOut_, IndexOut_, ValueIn_, IndexIn_ >.

◆ dense_row() [1/16]

template<typename Value_ , typename Index_ = int>

std::unique_ptr< MyopicDenseExtractor< Value_, Index_ > > tatami::Matrix< Value_, Index_ >::dense_row ( const Options & opt ) const

inline

Create a row-wise extractor that retrieves all columns in dense form.

Parameters

opt	Options for extraction.

Returns: Object for extracting each row in dense form. This should not outlive the parent Matrix from which it was created.

◆ dense_row() [2/16]

template<typename Value_ , typename Index_ = int>

std::unique_ptr< MyopicDenseExtractor< Value_, Index_ > > tatami::Matrix< Value_, Index_ >::dense_row	(	Index_	block_start,
		Index_	block_length,
		const Options &	opt
	)		const

inline

Create a row-wise extractor that retrieves a contiguous block of columns in dense form.

Parameters

block_start	Index of the column at the start of the block.
block_length	Number of columns in the block.
opt	Options for extraction.

Returns: Object for extracting a contiguous block from each row in dense form. This should not outlive the parent Matrix from which it was created.

◆ dense_row() [3/16]

template<typename Value_ , typename Index_ = int>

std::unique_ptr< MyopicDenseExtractor< Value_, Index_ > > tatami::Matrix< Value_, Index_ >::dense_row	(	VectorPtr< Index_ >	indices_ptr,
		const Options &	opt
	)		const

inline

Create a row-wise extractor that retrieves an indexed subset of columns in dense form.

Parameters

indices_ptr	Pointer to a vector of sorted and unique column indices. This should not be NULL.
opt	Options for extraction.

Returns: Object for extracting an indexed subset from each row in dense form. This should not outlive the parent Matrix from which it was created.

◆ dense_row() [4/16]

template<typename Value_ , typename Index_ = int>

std::unique_ptr< MyopicDenseExtractor< Value_, Index_ > > tatami::Matrix< Value_, Index_ >::dense_row	(	std::vector< Index_ >	indices,
		const Options &	opt
	)		const

inline

Create a row-wise extractor that retrieves an indexed subset of columns in dense form.

Parameters

indices	Vector of sorted and unique column indices.
opt	Options for extraction.

Returns: Object for extracting an indexed subset from each row. This should not outlive the parent Matrix from which it was created.

◆ dense_column() [1/16]

template<typename Value_ , typename Index_ = int>

std::unique_ptr< MyopicDenseExtractor< Value_, Index_ > > tatami::Matrix< Value_, Index_ >::dense_column ( const Options & opt ) const

inline

Create a column-wise extractor that retrieves all rows in dense form.

Parameters

opt	Options for extraction.

Returns: Object for extracting each column in dense form. This should not outlive the parent Matrix from which it was created.

◆ dense_column() [2/16]

template<typename Value_ , typename Index_ = int>

std::unique_ptr< MyopicDenseExtractor< Value_, Index_ > > tatami::Matrix< Value_, Index_ >::dense_column	(	Index_	block_start,
		Index_	block_length,
		const Options &	opt
	)		const

inline

Create a column-wise extractor that retrieves a contiguous block of rows in dense form.

Parameters

block_start	Index of the row at the start of the block.
block_length	Number of rows in the block.
opt	Options for extraction.

Returns: Object for extracting a contiguous block from each column in dense form. This should not outlive the parent Matrix from which it was created.

◆ dense_column() [3/16]

template<typename Value_ , typename Index_ = int>

std::unique_ptr< MyopicDenseExtractor< Value_, Index_ > > tatami::Matrix< Value_, Index_ >::dense_column	(	VectorPtr< Index_ >	indices_ptr,
		const Options &	opt
	)		const

inline

Create a column-wise extractor that retrieves an indexed subset of rows in dense form.

Parameters

indices_ptr	Pointer to a vector of sorted and unique row indices. This should not be NULL.
opt	Options for extraction.

Returns: Object for extracting an indexed subset from each column in dense form. This should not outlive the parent Matrix from which it was created.

◆ dense_column() [4/16]

template<typename Value_ , typename Index_ = int>

std::unique_ptr< MyopicDenseExtractor< Value_, Index_ > > tatami::Matrix< Value_, Index_ >::dense_column	(	std::vector< Index_ >	indices,
		const Options &	opt
	)		const

inline

Create a column-wise extractor that retrieves an indexed subset of rows in dense form.

Parameters

indices	Vector of sorted and unique row indices.
opt	Options for extraction.

Returns: Object for extracting an indexed subset from each column in dense form. This should not outlive the parent Matrix from which it was created.

◆ dense_row() [5/16]

template<typename Value_ , typename Index_ = int>

std::unique_ptr< MyopicDenseExtractor< Value_, Index_ > > tatami::Matrix< Value_, Index_ >::dense_row ( ) const

inline

Overload of dense_row() that uses the default options.

Returns: Object for extracting each row in dense form. This should not outlive the parent Matrix from which it was created.

◆ dense_row() [6/16]

template<typename Value_ , typename Index_ = int>

std::unique_ptr< MyopicDenseExtractor< Value_, Index_ > > tatami::Matrix< Value_, Index_ >::dense_row	(	Index_	block_start,
		Index_	block_length
	)		const

inline

Overload of dense_row() that uses the default options.

Parameters

block_start	Index of the column at the start of the block.
block_length	Number of columns in the block.

Returns: Object for extracting a contiguous block from each row in dense form. This should not outlive the parent Matrix from which it was created.

◆ dense_row() [7/16]

template<typename Value_ , typename Index_ = int>

std::unique_ptr< MyopicDenseExtractor< Value_, Index_ > > tatami::Matrix< Value_, Index_ >::dense_row ( VectorPtr< Index_ > indices_ptr ) const

inline

Overload of dense_row() that uses the default options.

Parameters

indices_ptr Pointer to a vector of sorted and unique column indices. This should be non-NULL.

Returns: Object for extracting an indexed subset from each row in dense form. This should not outlive the parent Matrix from which it was created.

◆ dense_row() [8/16]

template<typename Value_ , typename Index_ = int>

std::unique_ptr< MyopicDenseExtractor< Value_, Index_ > > tatami::Matrix< Value_, Index_ >::dense_row ( std::vector< Index_ > indices ) const

inline

Overload of dense_row() that uses the default options.

Parameters

indices Vector of sorted and unique column indices.

Returns: Object for extracting an indexed subset from each row in dense form. This should not outlive the parent Matrix from which it was created.

◆ dense_column() [5/16]

template<typename Value_ , typename Index_ = int>

std::unique_ptr< MyopicDenseExtractor< Value_, Index_ > > tatami::Matrix< Value_, Index_ >::dense_column ( ) const

inline

Overload of dense_column() that uses the default options.

Returns: Object for extracting each column in dense form. This should not outlive the parent Matrix from which it was created.

◆ dense_column() [6/16]

template<typename Value_ , typename Index_ = int>

std::unique_ptr< MyopicDenseExtractor< Value_, Index_ > > tatami::Matrix< Value_, Index_ >::dense_column	(	Index_	block_start,
		Index_	block_length
	)		const

inline

Overload of dense_column() that uses the default options.

Parameters

block_start	Index of the row at the start of the block.
block_length	Number of rows in the block.

Returns: Object for extracting a contiguous block from each column in dense form. This should not outlive the parent Matrix from which it was created.

◆ dense_column() [7/16]

template<typename Value_ , typename Index_ = int>

std::unique_ptr< MyopicDenseExtractor< Value_, Index_ > > tatami::Matrix< Value_, Index_ >::dense_column ( VectorPtr< Index_ > indices_ptr ) const

inline

Overload of dense_column() that uses the default options.

Parameters

indices_ptr Pointer to a vector of sorted and unique row indices. This should be non-NULL.

Returns: Obejct for extracting an indexed subset from each column in dense form. This should not outlive the parent Matrix from which it was created.

◆ dense_column() [8/16]

template<typename Value_ , typename Index_ = int>

std::unique_ptr< MyopicDenseExtractor< Value_, Index_ > > tatami::Matrix< Value_, Index_ >::dense_column ( std::vector< Index_ > indices ) const

inline

Overload of dense_column() that uses the default options.

Parameters

indices Vector of sorted and unique row indices.

Returns: Obejct for extracting an indexed subset from each column in dense form. This should not outlive the parent Matrix from which it was created.

◆ sparse() [1/6]

template<typename Value_ , typename Index_ = int>

virtual std::unique_ptr< MyopicSparseExtractor< Value_, Index_ > > tatami::Matrix< Value_, Index_ >::sparse	(	bool	row,
		const Options &	opt
	)		const

pure virtual

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

Parameters

row	Whether to create a row-wise extractor, i.e., the rows are the target dimension.
opt	Options 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.

Implemented in tatami::DenseMatrix< Value_, Index_, Storage_ >, tatami::DenseMatrix< Value_, Index_, std::vector< Value_ > >, tatami::DelayedBinaryIsometricOperation< OutputValue_, InputValue_, Index_, Operation_ >, tatami::DelayedUnaryIsometricOperation< OutputValue_, InputValue_, Index_, Operation_ >, tatami::ConstantMatrix< Value_, Index_ >, tatami::DelayedCast< ValueOut_, IndexOut_, ValueIn_, IndexIn_ >, tatami::DelayedTranspose< Value_, Index_ >, tatami::CompressedSparseMatrix< Value_, Index_, ValueStorage_, IndexStorage_, PointerStorage_ >, tatami::CompressedSparseMatrix< Value_, Index_, std::vector< Value_ >, std::vector< Index_ >, std::vector< size_t > >, tatami::DelayedSubset< Value_, Index_, SubsetStorage_ >, tatami::DelayedSubsetBlock< Value_, Index_ >, tatami::DelayedSubsetSorted< Value_, Index_, SubsetStorage_ >, tatami::DelayedSubsetSortedUnique< Value_, Index_, SubsetStorage_ >, and tatami::DelayedSubsetUnique< Value_, Index_, SubsetStorage_ >.

◆ sparse() [2/6]

template<typename Value_ , typename Index_ = int>

virtual std::unique_ptr< MyopicSparseExtractor< Value_, Index_ > > tatami::Matrix< Value_, Index_ >::sparse	(	bool	row,
		Index_	block_start,
		Index_	block_length,
		const Options &	opt
	)		const

pure virtual

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

Parameters

row	Whether to create a row-wise extractor, i.e., the rows are the target dimension.
block_start	Index of the column (if `row = true`) or row (otherwise) at the start of the block.
block_length	Number of columns (if `row = true`) or rows (otherwise) in the block.
opt	Options 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.

Implemented in tatami::CompressedSparseMatrix< Value_, Index_, ValueStorage_, IndexStorage_, PointerStorage_ >, tatami::CompressedSparseMatrix< Value_, Index_, std::vector< Value_ >, std::vector< Index_ >, std::vector< size_t > >, tatami::DenseMatrix< Value_, Index_, Storage_ >, tatami::DenseMatrix< Value_, Index_, std::vector< Value_ > >, tatami::DelayedBinaryIsometricOperation< OutputValue_, InputValue_, Index_, Operation_ >, tatami::DelayedUnaryIsometricOperation< OutputValue_, InputValue_, Index_, Operation_ >, tatami::ConstantMatrix< Value_, Index_ >, tatami::DelayedTranspose< Value_, Index_ >, tatami::DelayedSubset< Value_, Index_, SubsetStorage_ >, tatami::DelayedSubsetBlock< Value_, Index_ >, tatami::DelayedSubsetSorted< Value_, Index_, SubsetStorage_ >, tatami::DelayedSubsetSortedUnique< Value_, Index_, SubsetStorage_ >, tatami::DelayedSubsetUnique< Value_, Index_, SubsetStorage_ >, and tatami::DelayedCast< ValueOut_, IndexOut_, ValueIn_, IndexIn_ >.

◆ sparse() [3/6]

template<typename Value_ , typename Index_ = int>

virtual std::unique_ptr< MyopicSparseExtractor< Value_, Index_ > > tatami::Matrix< Value_, Index_ >::sparse	(	bool	row,
		VectorPtr< Index_ >	indices_ptr,
		const Options &	opt
	)		const

pure virtual

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

Parameters

row	Whether to create a row-wise extractor, i.e., the rows are the target dimension.
indices_ptr	Pointer to a vector of sorted and unique column indices (if `row = true`) or row indices (otherwise). This should be non-NULL.
opt	Options 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.

Implemented in tatami::DenseMatrix< Value_, Index_, Storage_ >, tatami::DenseMatrix< Value_, Index_, std::vector< Value_ > >, tatami::DelayedBinaryIsometricOperation< OutputValue_, InputValue_, Index_, Operation_ >, tatami::DelayedUnaryIsometricOperation< OutputValue_, InputValue_, Index_, Operation_ >, tatami::ConstantMatrix< Value_, Index_ >, tatami::DelayedTranspose< Value_, Index_ >, tatami::CompressedSparseMatrix< Value_, Index_, ValueStorage_, IndexStorage_, PointerStorage_ >, tatami::CompressedSparseMatrix< Value_, Index_, std::vector< Value_ >, std::vector< Index_ >, std::vector< size_t > >, tatami::DelayedSubsetBlock< Value_, Index_ >, tatami::DelayedSubsetSorted< Value_, Index_, SubsetStorage_ >, tatami::DelayedSubsetSortedUnique< Value_, Index_, SubsetStorage_ >, tatami::DelayedSubsetUnique< Value_, Index_, SubsetStorage_ >, tatami::DelayedSubset< Value_, Index_, SubsetStorage_ >, and tatami::DelayedCast< ValueOut_, IndexOut_, ValueIn_, IndexIn_ >.

◆ sparse_row() [1/16]

template<typename Value_ , typename Index_ = int>

std::unique_ptr< MyopicSparseExtractor< Value_, Index_ > > tatami::Matrix< Value_, Index_ >::sparse_row ( const Options & opt ) const

inline

Create a row-wise extractor that retrieves all columns in sparse form.

Parameters

opt	Options for extraction.

Returns: Object for extracting each row in sparse form. This should not outlive the parent Matrix from which it was created.

◆ sparse_row() [2/16]

template<typename Value_ , typename Index_ = int>

std::unique_ptr< MyopicSparseExtractor< Value_, Index_ > > tatami::Matrix< Value_, Index_ >::sparse_row	(	Index_	block_start,
		Index_	block_length,
		const Options &	opt
	)		const

inline

Create a row-wise extractor that retrieves a contiguous block of columns in sparse form.

Parameters

block_start	Index of the column at the start of the block.
block_length	Number of columns in the block.
opt	Options for extraction.

Returns: Object for extracting a contiguous block from each row in sparse form. This should not outlive the parent Matrix from which it was created.

◆ sparse_row() [3/16]

template<typename Value_ , typename Index_ = int>

std::unique_ptr< MyopicSparseExtractor< Value_, Index_ > > tatami::Matrix< Value_, Index_ >::sparse_row	(	VectorPtr< Index_ >	indices_ptr,
		const Options &	opt
	)		const

inline

Create a row-wise extractor that retrieves an indexed subset of columns in sparse form.

Parameters

indices_ptr	Pointer to a vector of sorted and unique column indices. This should not be NULL.
opt	Options for extraction.

Returns: Object for extracting an indexed subset from each row in sparse form. This should not outlive the parent Matrix from which it was created.

◆ sparse_row() [4/16]

template<typename Value_ , typename Index_ = int>

std::unique_ptr< MyopicSparseExtractor< Value_, Index_ > > tatami::Matrix< Value_, Index_ >::sparse_row	(	std::vector< Index_ >	indices,
		const Options &	opt
	)		const

inline

Create a row-wise extractor that retrieves an indexed subset of columns in sparse form.

Parameters

indices	Vector of sorted and unique column indices.
opt	Options for extraction.

Returns: Object for extracting an indexed subset from each row in sparse form. This should not outlive the parent Matrix from which it was created.

◆ sparse_column() [1/16]

template<typename Value_ , typename Index_ = int>

std::unique_ptr< MyopicSparseExtractor< Value_, Index_ > > tatami::Matrix< Value_, Index_ >::sparse_column ( const Options & opt ) const

inline

Create a column-wise extractor that retrieves all rows in sparse form.

Parameters

opt	Options for extraction.

Returns: Object for extracting each column in sparse form. This should not outlive the parent Matrix from which it was created.

◆ sparse_column() [2/16]

template<typename Value_ , typename Index_ = int>

std::unique_ptr< MyopicSparseExtractor< Value_, Index_ > > tatami::Matrix< Value_, Index_ >::sparse_column	(	Index_	block_start,
		Index_	block_length,
		const Options &	opt
	)		const

inline

Create a column-wise extractor that retrieves a contiguous block of rows in sparse form.

Parameters

block_start	Index of the row at the start of the block.
block_length	Number of rows in the block.
opt	Options for extraction.

Returns: Object for extracting a contiguous block from each column in sparse form. This should not outlive the parent Matrix from which it was created.

◆ sparse_column() [3/16]

template<typename Value_ , typename Index_ = int>

std::unique_ptr< MyopicSparseExtractor< Value_, Index_ > > tatami::Matrix< Value_, Index_ >::sparse_column	(	VectorPtr< Index_ >	indices_ptr,
		const Options &	opt
	)		const

inline

Create a column-wise extractor that retrieves an indexed subset of rows in sparse form.

Parameters

indices_ptr	Pointer to a vector of sorted and unique row indices. This should not be NULL.
opt	Options for extraction.

Returns: Object for extracting an indexed subset from each column in sparse form. This should not outlive the parent Matrix from which it was created.

◆ sparse_column() [4/16]

template<typename Value_ , typename Index_ = int>

std::unique_ptr< MyopicSparseExtractor< Value_, Index_ > > tatami::Matrix< Value_, Index_ >::sparse_column	(	std::vector< Index_ >	indices,
		const Options &	opt
	)		const

inline

Create a column-wise extractor that retrieves an indexed subset of rows in sparse form.

Parameters

indices	Vector of sorted and unique row indices.
opt	Options for extraction.

Returns: Object for extracting an indexed subset from each column in sparse form. This should not outlive the parent Matrix from which it was created.

◆ sparse_row() [5/16]

template<typename Value_ , typename Index_ = int>

std::unique_ptr< MyopicSparseExtractor< Value_, Index_ > > tatami::Matrix< Value_, Index_ >::sparse_row ( ) const

inline

Overload of sparse_row() that uses the default options.

Returns: Object for extracting each row in sparse form. This should not outlive the parent Matrix from which it was created.

◆ sparse_row() [6/16]

template<typename Value_ , typename Index_ = int>

std::unique_ptr< MyopicSparseExtractor< Value_, Index_ > > tatami::Matrix< Value_, Index_ >::sparse_row	(	Index_	block_start,
		Index_	block_length
	)		const

inline

Overload of sparse_row() that uses the default options.

Parameters

block_start	Index of the column at the start of the block.
block_length	Number of columns in the block.

Returns: Object for extracting a contiguous block from each row in sparse form. This should not outlive the parent Matrix from which it was created.

◆ sparse_row() [7/16]

template<typename Value_ , typename Index_ = int>

std::unique_ptr< MyopicSparseExtractor< Value_, Index_ > > tatami::Matrix< Value_, Index_ >::sparse_row ( VectorPtr< Index_ > indices_ptr ) const

inline

Overload of sparse_row() that uses the default options.

Parameters

indices_ptr Pointer to a vector of sorted and unique column indices. This should not be NULL.

Returns: Object for extracting an indexed subset from each row in sparse form. This should not outlive the parent Matrix from which it was created.

◆ sparse_row() [8/16]

template<typename Value_ , typename Index_ = int>

std::unique_ptr< MyopicSparseExtractor< Value_, Index_ > > tatami::Matrix< Value_, Index_ >::sparse_row ( std::vector< Index_ > indices ) const

inline

Overload of sparse_row() that uses the default options.

Parameters

indices Vector of sorted and unique column indices.

Returns: Object for extracting an indexed subset from each row in sparse form. This should not outlive the parent Matrix from which it was created.

◆ sparse_column() [5/16]

template<typename Value_ , typename Index_ = int>

std::unique_ptr< MyopicSparseExtractor< Value_, Index_ > > tatami::Matrix< Value_, Index_ >::sparse_column ( ) const

inline

Overload of sparse_column() that uses the default options.

Returns: Object for extracting each column in sparse form. This should not outlive the parent Matrix from which it was created.

◆ sparse_column() [6/16]

template<typename Value_ , typename Index_ = int>

std::unique_ptr< MyopicSparseExtractor< Value_, Index_ > > tatami::Matrix< Value_, Index_ >::sparse_column	(	Index_	block_start,
		Index_	block_length
	)		const

inline

Overload of sparse_column() that uses the default options.

Parameters

block_start	Index of the row at the start of the block.
block_length	Number of rows in the block.

Returns: Object for extracting a contiguous block from each column in sparse form. This should not outlive the parent Matrix from which it was created.

◆ sparse_column() [7/16]

template<typename Value_ , typename Index_ = int>

std::unique_ptr< MyopicSparseExtractor< Value_, Index_ > > tatami::Matrix< Value_, Index_ >::sparse_column ( VectorPtr< Index_ > indices_ptr ) const

inline

Overload of sparse_column() that uses the default options.

Parameters

indices_ptr Pointer to a vector of sorted and unique row indices. This should not be NULL.

Returns: Object for extracting an indexed subset from each column in sparse form. This should not outlive the parent Matrix from which it was created.

◆ sparse_column() [8/16]

template<typename Value_ , typename Index_ = int>

std::unique_ptr< MyopicSparseExtractor< Value_, Index_ > > tatami::Matrix< Value_, Index_ >::sparse_column ( std::vector< Index_ > indices ) const

inline

Overload of sparse_column() that uses the default options.

Parameters

indices Vector of sorted and unique row indices.

Returns: Object for extracting an indexed subset from each column in sparse form. This should not outlive the parent Matrix from which it was created.

◆ dense() [4/6]

template<typename Value_ , typename Index_ = int>

virtual std::unique_ptr< OracularDenseExtractor< Value_, Index_ > > tatami::Matrix< Value_, Index_ >::dense	(	bool	row,
		std::shared_ptr< const Oracle< Index_ > >	oracle,
		const Options &	opt
	)		const

pure virtual

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

Parameters

row	Whether to create a row-wise extractor, i.e., the rows are the target dimension.
oracle	An oracle supplying predictions of the next requested row (if `row = true`) or column (otherwise).
opt	Options 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.

Implemented in tatami::DenseMatrix< Value_, Index_, Storage_ >, tatami::DenseMatrix< Value_, Index_, std::vector< Value_ > >, tatami::DelayedBinaryIsometricOperation< OutputValue_, InputValue_, Index_, Operation_ >, tatami::DelayedUnaryIsometricOperation< OutputValue_, InputValue_, Index_, Operation_ >, tatami::ConstantMatrix< Value_, Index_ >, tatami::DelayedBind< Value_, Index_ >, tatami::DelayedTranspose< Value_, Index_ >, tatami::CompressedSparseMatrix< Value_, Index_, ValueStorage_, IndexStorage_, PointerStorage_ >, tatami::CompressedSparseMatrix< Value_, Index_, std::vector< Value_ >, std::vector< Index_ >, std::vector< size_t > >, tatami::FragmentedSparseMatrix< Value_, Index_, ValueVectorStorage_, IndexVectorStorage_ >, tatami::FragmentedSparseMatrix< Value_, Index_, std::vector< std::vector< Value_ > >, std::vector< std::vector< Index_ > > >, tatami::DelayedSubset< Value_, Index_, SubsetStorage_ >, tatami::DelayedSubsetBlock< Value_, Index_ >, tatami::DelayedSubsetSorted< Value_, Index_, SubsetStorage_ >, tatami::DelayedSubsetSortedUnique< Value_, Index_, SubsetStorage_ >, tatami::DelayedSubsetUnique< Value_, Index_, SubsetStorage_ >, and tatami::DelayedCast< ValueOut_, IndexOut_, ValueIn_, IndexIn_ >.

◆ dense() [5/6]

template<typename Value_ , typename Index_ = int>

virtual std::unique_ptr< OracularDenseExtractor< Value_, Index_ > > tatami::Matrix< Value_, Index_ >::dense	(	bool	row,
		std::shared_ptr< const Oracle< Index_ > >	oracle,
		Index_	block_start,
		Index_	block_length,
		const Options &	opt
	)		const

pure virtual

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

Parameters

row	Whether to create a row-wise extractor, i.e., the rows are the target dimension.
oracle	An oracle supplying predictions of the next requested row (if `row = true`) or column (otherwise).
block_start	Index of the column (if `row = true`) or row (otherwise) at the start of the block.
block_length	Number of columns (if `row = true`) or rows (otherwise) in the block.
opt	Options 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.

◆ dense() [6/6]

template<typename Value_ , typename Index_ = int>

virtual std::unique_ptr< OracularDenseExtractor< Value_, Index_ > > tatami::Matrix< Value_, Index_ >::dense	(	bool	row,
		std::shared_ptr< const Oracle< Index_ > >	oracle,
		VectorPtr< Index_ >	indices_ptr,
		const Options &	opt
	)		const

pure virtual

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

Parameters

row	Whether to create a row-wise extractor, i.e., the rows are the target dimension.
oracle	An oracle supplying predictions of the next requested row (if `row = true`) or column (otherwise).
indices_ptr	Pointer to a vector of sorted and unique column indices (if `row = true`) or row indices (otherwise). This should not be NULL.
opt	Options 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.

Implemented in tatami::DenseMatrix< Value_, Index_, Storage_ >, tatami::DenseMatrix< Value_, Index_, std::vector< Value_ > >, tatami::DelayedBinaryIsometricOperation< OutputValue_, InputValue_, Index_, Operation_ >, tatami::DelayedUnaryIsometricOperation< OutputValue_, InputValue_, Index_, Operation_ >, tatami::ConstantMatrix< Value_, Index_ >, tatami::DelayedBind< Value_, Index_ >, tatami::DelayedTranspose< Value_, Index_ >, tatami::DelayedSubsetBlock< Value_, Index_ >, tatami::DelayedSubsetSorted< Value_, Index_, SubsetStorage_ >, tatami::DelayedSubsetSortedUnique< Value_, Index_, SubsetStorage_ >, tatami::DelayedSubsetUnique< Value_, Index_, SubsetStorage_ >, tatami::CompressedSparseMatrix< Value_, Index_, ValueStorage_, IndexStorage_, PointerStorage_ >, tatami::CompressedSparseMatrix< Value_, Index_, std::vector< Value_ >, std::vector< Index_ >, std::vector< size_t > >, tatami::DelayedSubset< Value_, Index_, SubsetStorage_ >, tatami::FragmentedSparseMatrix< Value_, Index_, ValueVectorStorage_, IndexVectorStorage_ >, tatami::FragmentedSparseMatrix< Value_, Index_, std::vector< std::vector< Value_ > >, std::vector< std::vector< Index_ > > >, and tatami::DelayedCast< ValueOut_, IndexOut_, ValueIn_, IndexIn_ >.

◆ dense_row() [9/16]

template<typename Value_ , typename Index_ = int>

std::unique_ptr< OracularDenseExtractor< Value_, Index_ > > tatami::Matrix< Value_, Index_ >::dense_row	(	std::shared_ptr< const Oracle< Index_ > >	oracle,
		const Options &	opt
	)		const

inline

Create an oracle-aware row-wise extractor that retrieves all columns in dense form.

Parameters

oracle	An oracle supplying row predictions.
opt	Options for extraction.

Returns: Object for extracting each row in dense form. This should not outlive the parent Matrix from which it was created.

◆ dense_row() [10/16]

template<typename Value_ , typename Index_ = int>

std::unique_ptr< OracularDenseExtractor< Value_, Index_ > > tatami::Matrix< Value_, Index_ >::dense_row	(	std::shared_ptr< const Oracle< Index_ > >	oracle,
		Index_	block_start,
		Index_	block_length,
		const Options &	opt
	)		const

inline

Create an oracle-aware row-wise extractor that retrieves a contiguous block of columns in dense form.

Parameters

oracle	An oracle supplying row predictions.
block_start	Index of the column at the start of the block.
block_length	Number of columns in the block.
opt	Options for extraction.

Returns: Object for extracting a contiguous block from each row. This should not outlive the parent Matrix from which it was created.

◆ dense_row() [11/16]

template<typename Value_ , typename Index_ = int>

std::unique_ptr< OracularDenseExtractor< Value_, Index_ > > tatami::Matrix< Value_, Index_ >::dense_row	(	std::shared_ptr< const Oracle< Index_ > >	oracle,
		VectorPtr< Index_ >	indices_ptr,
		const Options &	opt
	)		const

inline

Create an oracle-aware row-wise extractor that retrieves an indexed subset of columns in dense form.

Parameters

oracle	An oracle supplying row predictions.
indices_ptr	Pointer to a vector of sorted and unique column indices. This should not be NULL.
opt	Options for extraction.

Returns: Object for extracting an indexed subset from each row in dense form. This should not outlive the parent Matrix from which it was created.

◆ dense_row() [12/16]

template<typename Value_ , typename Index_ = int>

std::unique_ptr< OracularDenseExtractor< Value_, Index_ > > tatami::Matrix< Value_, Index_ >::dense_row	(	std::shared_ptr< const Oracle< Index_ > >	oracle,
		std::vector< Index_ >	indices,
		const Options &	opt
	)		const

inline

Create an oracle-aware row-wise extractor that retrieves an indexed subset of columns in dense form.

Parameters

oracle	An oracle supplying row predictions.
indices	Vector of sorted and unique column indices.
opt	Options for extraction.

Returns: Object for extracting an indexed subset from each row in dense form. This should not outlive the parent Matrix from which it was created.

◆ dense_column() [9/16]

template<typename Value_ , typename Index_ = int>

std::unique_ptr< OracularDenseExtractor< Value_, Index_ > > tatami::Matrix< Value_, Index_ >::dense_column	(	std::shared_ptr< const Oracle< Index_ > >	oracle,
		const Options &	opt
	)		const

inline

Create an oracle-aware column-wise extractor that retrieves all rows in dense form.

Parameters

oracle	An oracle supplying column predictions.
opt	Options for extraction.

Returns: Object for extracting each column in dense form. This should not outlive the parent Matrix from which it was created.

◆ dense_column() [10/16]

template<typename Value_ , typename Index_ = int>

std::unique_ptr< OracularDenseExtractor< Value_, Index_ > > tatami::Matrix< Value_, Index_ >::dense_column	(	std::shared_ptr< const Oracle< Index_ > >	oracle,
		Index_	block_start,
		Index_	block_length,
		const Options &	opt
	)		const

inline

Create an oracle-aware column-wise extractor that retrieves a contiguous block of rows in dense form.

Parameters

block_start	Index of the row at the start of the block.
block_length	Number of rows in the block.
oracle	An oracle supplying column predictions.
opt	Options for extraction.

Returns: Object for extracting a contiguous block from each column in dense form. This should not outlive the parent Matrix from which it was created.

◆ dense_column() [11/16]

template<typename Value_ , typename Index_ = int>

std::unique_ptr< OracularDenseExtractor< Value_, Index_ > > tatami::Matrix< Value_, Index_ >::dense_column	(	std::shared_ptr< const Oracle< Index_ > >	oracle,
		VectorPtr< Index_ >	indices_ptr,
		const Options &	opt
	)		const

inline

Create an oracle-aware column-wise extractor that retrieves an indexed subset of rows in dense form.

Parameters

oracle	An oracle supplying column predictions.
indices_ptr	Pointer to a vector of sorted and unique row indices. This should not be NULL.
opt	Options for extraction.

Returns: Object for extracting an indexed subset from each column in dense form. This should not outlive the parent Matrix from which it was created.

◆ dense_column() [12/16]

template<typename Value_ , typename Index_ = int>

std::unique_ptr< OracularDenseExtractor< Value_, Index_ > > tatami::Matrix< Value_, Index_ >::dense_column	(	std::shared_ptr< const Oracle< Index_ > >	oracle,
		std::vector< Index_ >	indices,
		const Options &	opt
	)		const

inline

Create an oracle-aware column-wise extractor that retrieves an indexed subset of rows in dense form.

Parameters

oracle	An oracle supplying column predictions.
indices	Vector of sorted and unique row indices.
opt	Options for extraction.

Returns: Object for extracting an indexed subset from each column in dense form. This should not outlive the parent Matrix from which it was created.

◆ dense_row() [13/16]

template<typename Value_ , typename Index_ = int>

std::unique_ptr< OracularDenseExtractor< Value_, Index_ > > tatami::Matrix< Value_, Index_ >::dense_row ( std::shared_ptr< const Oracle< Index_ > > oracle ) const

inline

Overload of dense_row() that uses the default options.

Parameters

oracle An oracle supplying row predictions.

Returns: Object for extracting each row in dense form. This should not outlive the parent Matrix from which it was created.

◆ dense_row() [14/16]

template<typename Value_ , typename Index_ = int>

std::unique_ptr< OracularDenseExtractor< Value_, Index_ > > tatami::Matrix< Value_, Index_ >::dense_row	(	std::shared_ptr< const Oracle< Index_ > >	oracle,
		Index_	block_start,
		Index_	block_length
	)		const

inline

Overload of dense_row() that uses the default options.

Parameters

oracle	An oracle supplying row predictions.
block_start	Index of the column at the start of the block.
block_length	Number of columns in the block.

Returns: Object for extracting a contiguous block from each row in dense form. This should not outlive the parent Matrix from which it was created.

◆ dense_row() [15/16]

template<typename Value_ , typename Index_ = int>

std::unique_ptr< OracularDenseExtractor< Value_, Index_ > > tatami::Matrix< Value_, Index_ >::dense_row	(	std::shared_ptr< const Oracle< Index_ > >	oracle,
		VectorPtr< Index_ >	indices_ptr
	)		const

inline

Overload of dense_row() that uses the default options.

Parameters

indices_ptr	Pointer to a vector of sorted and unique column indices. This should not be NULL.
oracle	An oracle supplying row predictions.

Returns: Object for extracting an indexed subset from each row in dense form. This should not outlive the parent Matrix from which it was created.

◆ dense_row() [16/16]

template<typename Value_ , typename Index_ = int>

std::unique_ptr< OracularDenseExtractor< Value_, Index_ > > tatami::Matrix< Value_, Index_ >::dense_row	(	std::shared_ptr< const Oracle< Index_ > >	oracle,
		std::vector< Index_ >	indices
	)		const

inline

Overload of dense_row() that uses the default options.

Parameters

indices	Vector of sorted and unique column indices.
oracle	An oracle supplying row predictions.

Returns: Object for extracting an indexed subset from each row in dense form. This should not outlive the parent Matrix from which it was created.

◆ dense_column() [13/16]

template<typename Value_ , typename Index_ = int>

std::unique_ptr< OracularDenseExtractor< Value_, Index_ > > tatami::Matrix< Value_, Index_ >::dense_column ( std::shared_ptr< const Oracle< Index_ > > oracle ) const

inline

Overload of dense_column() that uses the default options.

Parameters

oracle An oracle supplying column predictions.

Returns: Object for extracting each column in dense form. This should not outlive the parent Matrix from which it was created.

◆ dense_column() [14/16]

template<typename Value_ , typename Index_ = int>

std::unique_ptr< OracularDenseExtractor< Value_, Index_ > > tatami::Matrix< Value_, Index_ >::dense_column	(	std::shared_ptr< const Oracle< Index_ > >	oracle,
		Index_	block_start,
		Index_	block_length
	)		const

inline

Overload of dense_column() that uses the default options.

Parameters

block_start	Index of the row at the start of the block.
block_length	Number of rows in the block.
oracle	An oracle supplying column predictions.

Returns: Object for extracting a contiguous block from each column in dense form. This should not outlive the parent Matrix from which it was created.

◆ dense_column() [15/16]

template<typename Value_ , typename Index_ = int>

std::unique_ptr< OracularDenseExtractor< Value_, Index_ > > tatami::Matrix< Value_, Index_ >::dense_column	(	std::shared_ptr< const Oracle< Index_ > >	oracle,
		VectorPtr< Index_ >	indices_ptr
	)		const

inline

Overload of dense_column() that uses the default options.

Parameters

indices_ptr	Pointer to a vector of sorted and unique row indices. This should not be NULL.
oracle	An oracle supplying column predictions.

Returns: Object for extracting an indexed subset from each column in dense form. This should not outlive the parent Matrix from which it was created.

◆ dense_column() [16/16]

template<typename Value_ , typename Index_ = int>

std::unique_ptr< OracularDenseExtractor< Value_, Index_ > > tatami::Matrix< Value_, Index_ >::dense_column	(	std::shared_ptr< const Oracle< Index_ > >	oracle,
		std::vector< Index_ >	indices
	)		const

inline

Overload of dense_column() that uses the default options.

Parameters

indices	Vector of sorted and unique row indices.
oracle	An oracle supplying column predictions.

Returns: Object for extracting an indexed subset from each column in dense form. This should not outlive the parent Matrix from which it was created.

◆ sparse() [4/6]

template<typename Value_ , typename Index_ = int>

virtual std::unique_ptr< OracularSparseExtractor< Value_, Index_ > > tatami::Matrix< Value_, Index_ >::sparse	(	bool	row,
		std::shared_ptr< const Oracle< Index_ > >	oracle,
		const Options &	opt
	)		const

pure virtual

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

Parameters

row	Whether to create a row-wise extractor, i.e., the rows are the target dimension.
oracle	An oracle supplying predictions of the next requested row (if `row = true`) or column (otherwise).
opt	Options 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.

Implemented in tatami::DenseMatrix< Value_, Index_, Storage_ >, tatami::DenseMatrix< Value_, Index_, std::vector< Value_ > >, tatami::DelayedBinaryIsometricOperation< OutputValue_, InputValue_, Index_, Operation_ >, tatami::DelayedUnaryIsometricOperation< OutputValue_, InputValue_, Index_, Operation_ >, tatami::ConstantMatrix< Value_, Index_ >, tatami::DelayedTranspose< Value_, Index_ >, tatami::CompressedSparseMatrix< Value_, Index_, ValueStorage_, IndexStorage_, PointerStorage_ >, tatami::CompressedSparseMatrix< Value_, Index_, std::vector< Value_ >, std::vector< Index_ >, std::vector< size_t > >, tatami::FragmentedSparseMatrix< Value_, Index_, ValueVectorStorage_, IndexVectorStorage_ >, tatami::FragmentedSparseMatrix< Value_, Index_, std::vector< std::vector< Value_ > >, std::vector< std::vector< Index_ > > >, tatami::DelayedSubset< Value_, Index_, SubsetStorage_ >, tatami::DelayedSubsetBlock< Value_, Index_ >, tatami::DelayedSubsetSorted< Value_, Index_, SubsetStorage_ >, tatami::DelayedSubsetSortedUnique< Value_, Index_, SubsetStorage_ >, tatami::DelayedSubsetUnique< Value_, Index_, SubsetStorage_ >, and tatami::DelayedCast< ValueOut_, IndexOut_, ValueIn_, IndexIn_ >.

◆ sparse() [5/6]

template<typename Value_ , typename Index_ = int>

virtual std::unique_ptr< OracularSparseExtractor< Value_, Index_ > > tatami::Matrix< Value_, Index_ >::sparse	(	bool	row,
		std::shared_ptr< const Oracle< Index_ > >	oracle,
		Index_	block_start,
		Index_	block_length,
		const Options &	opt
	)		const

pure virtual

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

Parameters

row	Whether to create a row-wise extractor, i.e., the rows are the target dimension.
oracle	An oracle supplying predictions of the next requested row (if `row = true`) or column (otherwise).
block_start	Index of the column (if `row = true`) or row (otherwise) at the start of the block.
block_length	Number of columns (if `row = true`) or rows (otherwise) in the block.
opt	Options 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.

Implemented in tatami::DenseMatrix< Value_, Index_, Storage_ >, tatami::DenseMatrix< Value_, Index_, std::vector< Value_ > >, tatami::CompressedSparseMatrix< Value_, Index_, ValueStorage_, IndexStorage_, PointerStorage_ >, tatami::CompressedSparseMatrix< Value_, Index_, std::vector< Value_ >, std::vector< Index_ >, std::vector< size_t > >, tatami::FragmentedSparseMatrix< Value_, Index_, ValueVectorStorage_, IndexVectorStorage_ >, tatami::FragmentedSparseMatrix< Value_, Index_, std::vector< std::vector< Value_ > >, std::vector< std::vector< Index_ > > >, tatami::DelayedBinaryIsometricOperation< OutputValue_, InputValue_, Index_, Operation_ >, tatami::DelayedUnaryIsometricOperation< OutputValue_, InputValue_, Index_, Operation_ >, tatami::ConstantMatrix< Value_, Index_ >, tatami::DelayedTranspose< Value_, Index_ >, tatami::DelayedSubset< Value_, Index_, SubsetStorage_ >, tatami::DelayedSubsetBlock< Value_, Index_ >, tatami::DelayedSubsetSorted< Value_, Index_, SubsetStorage_ >, tatami::DelayedSubsetSortedUnique< Value_, Index_, SubsetStorage_ >, tatami::DelayedSubsetUnique< Value_, Index_, SubsetStorage_ >, and tatami::DelayedCast< ValueOut_, IndexOut_, ValueIn_, IndexIn_ >.

◆ sparse() [6/6]

template<typename Value_ , typename Index_ = int>

virtual std::unique_ptr< OracularSparseExtractor< Value_, Index_ > > tatami::Matrix< Value_, Index_ >::sparse	(	bool	row,
		std::shared_ptr< const Oracle< Index_ > >	oracle,
		VectorPtr< Index_ >	indices_ptr,
		const Options &	opt
	)		const

pure virtual

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

Parameters

row	Whether to create a row-wise extractor, i.e., the rows are the target dimension.
oracle	An oracle supplying predictions of the next requested row (if `row = true`) or column (otherwise).
indices_ptr	Pointer to a vector of sorted and unique column indices (if `row = true`) or row indices (otherwise). This should not be NULL.
opt	Options 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.

Implemented in tatami::DelayedTranspose< Value_, Index_ >, tatami::DenseMatrix< Value_, Index_, Storage_ >, tatami::DenseMatrix< Value_, Index_, std::vector< Value_ > >, tatami::DelayedBinaryIsometricOperation< OutputValue_, InputValue_, Index_, Operation_ >, tatami::DelayedUnaryIsometricOperation< OutputValue_, InputValue_, Index_, Operation_ >, tatami::ConstantMatrix< Value_, Index_ >, tatami::DelayedSubsetBlock< Value_, Index_ >, tatami::DelayedSubsetSorted< Value_, Index_, SubsetStorage_ >, tatami::DelayedSubsetSortedUnique< Value_, Index_, SubsetStorage_ >, tatami::DelayedSubsetUnique< Value_, Index_, SubsetStorage_ >, tatami::CompressedSparseMatrix< Value_, Index_, ValueStorage_, IndexStorage_, PointerStorage_ >, tatami::CompressedSparseMatrix< Value_, Index_, std::vector< Value_ >, std::vector< Index_ >, std::vector< size_t > >, tatami::DelayedSubset< Value_, Index_, SubsetStorage_ >, tatami::FragmentedSparseMatrix< Value_, Index_, ValueVectorStorage_, IndexVectorStorage_ >, tatami::FragmentedSparseMatrix< Value_, Index_, std::vector< std::vector< Value_ > >, std::vector< std::vector< Index_ > > >, and tatami::DelayedCast< ValueOut_, IndexOut_, ValueIn_, IndexIn_ >.

◆ sparse_row() [9/16]

template<typename Value_ , typename Index_ = int>

std::unique_ptr< OracularSparseExtractor< Value_, Index_ > > tatami::Matrix< Value_, Index_ >::sparse_row	(	std::shared_ptr< const Oracle< Index_ > >	oracle,
		const Options &	opt
	)		const

inline

Create an oracle-aware row-wise extractor that retrieves all columns in sparse form.

Parameters

oracle	An oracle supplying row predictions.
opt	Options for extraction.

Returns: Object for extracting each row in sparse form. This should not outlive the parent Matrix from which it was created.

◆ sparse_row() [10/16]

template<typename Value_ , typename Index_ = int>

std::unique_ptr< OracularSparseExtractor< Value_, Index_ > > tatami::Matrix< Value_, Index_ >::sparse_row	(	std::shared_ptr< const Oracle< Index_ > >	oracle,
		Index_	block_start,
		Index_	block_length,
		const Options &	opt
	)		const

inline

Create an oracle-aware row-wise extractor that retrieves a contiguous block of columns in sparse form.

Parameters

oracle	An oracle supplying row predictions.
block_start	Index of the column at the start of the block.
block_length	Number of columns in the block.
opt	Options for extraction.

Returns: Object for extracting a contiguous block from each row in sparse form. This should not outlive the parent Matrix from which it was created.

◆ sparse_row() [11/16]

template<typename Value_ , typename Index_ = int>

std::unique_ptr< OracularSparseExtractor< Value_, Index_ > > tatami::Matrix< Value_, Index_ >::sparse_row	(	std::shared_ptr< const Oracle< Index_ > >	oracle,
		VectorPtr< Index_ >	indices_ptr,
		const Options &	opt
	)		const

inline

Create an oracle-aware row-wise extractor that retrieves an indexed subset of columns in sparse form.

Parameters

oracle	An oracle supplying row predictions.
indices_ptr	Pointer to a vector of sorted and unique column indices.
opt	Options for extraction.

Returns: Object for extracting an indexed subset from each row in sparse form. This should not outlive the parent Matrix from which it was created.

◆ sparse_row() [12/16]

template<typename Value_ , typename Index_ = int>

std::unique_ptr< OracularSparseExtractor< Value_, Index_ > > tatami::Matrix< Value_, Index_ >::sparse_row	(	std::shared_ptr< const Oracle< Index_ > >	oracle,
		std::vector< Index_ >	indices,
		const Options &	opt
	)		const

inline

Create an oracle-aware row-wise extractor that retrieves an indexed subset of columns in sparse form.

Parameters

oracle	An oracle supplying row predictions.
indices	Vector of sorted and unique column indices.
opt	Options for extraction.

Returns: Object for extracting an indexed subset from each row in sparse form. This should not outlive the parent Matrix from which it was created.

◆ sparse_column() [9/16]

template<typename Value_ , typename Index_ = int>

std::unique_ptr< OracularSparseExtractor< Value_, Index_ > > tatami::Matrix< Value_, Index_ >::sparse_column	(	std::shared_ptr< const Oracle< Index_ > >	oracle,
		const Options &	opt
	)		const

inline

Create an oracle-aware column-wise extractor that retrieves all rows in sparse form.

Parameters

oracle	An oracle supplying column predictions.
opt	Options for extraction.

Returns: Object for extracting each column in sparse form. This should not outlive the parent Matrix from which it was created.

◆ sparse_column() [10/16]

template<typename Value_ , typename Index_ = int>

std::unique_ptr< OracularSparseExtractor< Value_, Index_ > > tatami::Matrix< Value_, Index_ >::sparse_column	(	std::shared_ptr< const Oracle< Index_ > >	oracle,
		Index_	block_start,
		Index_	block_length,
		const Options &	opt
	)		const

inline

Create an oracle-aware column-wise extractor that retrieves a contiguous block of rows in sparse form.

Parameters

block_start	Index of the row at the start of the block.
block_length	Number of rows in the block.
oracle	An oracle supplying column predictions.
opt	Options for extraction.

Returns: Object for extracting a contiguous block from each column in sparse form. This should not outlive the parent Matrix from which it was created.

◆ sparse_column() [11/16]

template<typename Value_ , typename Index_ = int>

std::unique_ptr< OracularSparseExtractor< Value_, Index_ > > tatami::Matrix< Value_, Index_ >::sparse_column	(	std::shared_ptr< const Oracle< Index_ > >	oracle,
		VectorPtr< Index_ >	indices_ptr,
		const Options &	opt
	)		const

inline

Create an oracle-aware column-wise extractor that retrieves an indexed subset of rows in sparse form.

Parameters

oracle	An oracle supplying column predictions.
indices_ptr	Pointer to a vector of sorted and unique row indices. This should not be NULL.
opt	Options for extraction.

Returns: Object for extracting an indexed subset from each column in sparse form. This should not outlive the parent Matrix from which it was created.

◆ sparse_column() [12/16]

template<typename Value_ , typename Index_ = int>

std::unique_ptr< OracularSparseExtractor< Value_, Index_ > > tatami::Matrix< Value_, Index_ >::sparse_column	(	std::shared_ptr< const Oracle< Index_ > >	oracle,
		std::vector< Index_ >	indices,
		const Options &	opt
	)		const

inline

Create an oracle-aware column-wise extractor that retrieves an indexed subset of rows in sparse form.

Parameters

oracle	An oracle supplying column predictions.
indices	Vector of sorted and unique row indices.
opt	Options for extraction.

Returns: Object for extracting an indexed subset from each column in sparse form. This should not outlive the parent Matrix from which it was created.

◆ sparse_row() [13/16]

template<typename Value_ , typename Index_ = int>

std::unique_ptr< OracularSparseExtractor< Value_, Index_ > > tatami::Matrix< Value_, Index_ >::sparse_row ( std::shared_ptr< const Oracle< Index_ > > oracle ) const

inline

Overload of sparse_row() that uses the default options.

Parameters

oracle An oracle supplying row predictions.

Returns: Object for extracting each row in sparse form. This should not outlive the parent Matrix from which it was created.

◆ sparse_row() [14/16]

template<typename Value_ , typename Index_ = int>

std::unique_ptr< OracularSparseExtractor< Value_, Index_ > > tatami::Matrix< Value_, Index_ >::sparse_row	(	std::shared_ptr< const Oracle< Index_ > >	oracle,
		Index_	block_start,
		Index_	block_length
	)		const

inline

Overload of sparse_row() that uses the default options.

Parameters

block_start	Index of the column at the start of the block.
block_length	Number of columns in the block.
oracle	An oracle supplying row predictions.

Returns: Object for extracting a contiguous block from each row in sparse form. This should not outlive the parent Matrix from which it was created.

◆ sparse_row() [15/16]

template<typename Value_ , typename Index_ = int>

std::unique_ptr< OracularSparseExtractor< Value_, Index_ > > tatami::Matrix< Value_, Index_ >::sparse_row	(	std::shared_ptr< const Oracle< Index_ > >	oracle,
		VectorPtr< Index_ >	indices_ptr
	)		const

inline

Overload of sparse_row() that uses the default options.

Parameters

oracle	An oracle supplying row predictions.
indices_ptr	Pointer to a vector of sorted and unique column indices.

Returns: Object for extracting an indexed subset from each row in sparse form. This should not outlive the parent Matrix from which it was created.

◆ sparse_row() [16/16]

template<typename Value_ , typename Index_ = int>

std::unique_ptr< OracularSparseExtractor< Value_, Index_ > > tatami::Matrix< Value_, Index_ >::sparse_row	(	std::shared_ptr< const Oracle< Index_ > >	oracle,
		std::vector< Index_ >	indices
	)		const

inline

Overload of sparse_row() that uses the default options.

Parameters

oracle	An oracle supplying row predictions.
indices	Vector of sorted and unique column indices.

Returns: Object for extracting an indexed subset from each row in sparse form. This should not outlive the parent Matrix from which it was created.

◆ sparse_column() [13/16]

template<typename Value_ , typename Index_ = int>

std::unique_ptr< OracularSparseExtractor< Value_, Index_ > > tatami::Matrix< Value_, Index_ >::sparse_column ( std::shared_ptr< const Oracle< Index_ > > oracle ) const

inline

Overload of sparse_column() that uses the default options.

Parameters

oracle An oracle supplying column predictions.

Returns: Object for extracting each column in sparse form. This should not outlive the parent Matrix from which it was created.

◆ sparse_column() [14/16]

template<typename Value_ , typename Index_ = int>

std::unique_ptr< OracularSparseExtractor< Value_, Index_ > > tatami::Matrix< Value_, Index_ >::sparse_column	(	std::shared_ptr< const Oracle< Index_ > >	oracle,
		Index_	block_start,
		Index_	block_length
	)		const

inline

Overload of sparse_column() that uses the default options.

Parameters

block_start	Index of the row at the start of the block.
block_length	Number of rows in the block.
oracle	An oracle supplying column predictions.

Returns: Object for extracting a contiguous block from each column in sparse form. This should not outlive the parent Matrix from which it was created.

◆ sparse_column() [15/16]

template<typename Value_ , typename Index_ = int>

std::unique_ptr< OracularSparseExtractor< Value_, Index_ > > tatami::Matrix< Value_, Index_ >::sparse_column	(	std::shared_ptr< const Oracle< Index_ > >	oracle,
		VectorPtr< Index_ >	indices_ptr
	)		const

inline

Overload of sparse_column() that uses the default options.

Parameters

indices_ptr	Pointer to a vector of sorted and unique row indices.
oracle	An oracle supplying column predictions.

Returns: Object for extracting an indexed subset from each column in sparse form. This should not outlive the parent Matrix from which it was created.

◆ sparse_column() [16/16]

template<typename Value_ , typename Index_ = int>

std::unique_ptr< OracularSparseExtractor< Value_, Index_ > > tatami::Matrix< Value_, Index_ >::sparse_column	(	std::shared_ptr< const Oracle< Index_ > >	oracle,
		std::vector< Index_ >	indices
	)		const

inline

Overload of sparse_column() that uses the default options.

Parameters

indices	Vector of sorted and unique row indices.
oracle	An oracle supplying column predictions.

Returns: Object for extracting an indexed subset from each column in sparse form. This should not outlive the parent Matrix from which it was created.

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

tatami/base/Matrix.hpp

Public Types

Public Member Functions

Detailed Description

Member Typedef Documentation

◆ value_type

◆ index_type

Member Function Documentation

◆ nrow()

◆ ncol()

◆ is_sparse()

◆ is_sparse_proportion()

◆ prefer_rows()

◆ prefer_rows_proportion()

◆ uses_oracle()

◆ dense() [1/6]

◆ dense() [2/6]

◆ dense() [3/6]

◆ dense_row() [1/16]

◆ dense_row() [2/16]

◆ dense_row() [3/16]

◆ dense_row() [4/16]

◆ dense_column() [1/16]

◆ dense_column() [2/16]

◆ dense_column() [3/16]

◆ dense_column() [4/16]

◆ dense_row() [5/16]

◆ dense_row() [6/16]

◆ dense_row() [7/16]

◆ dense_row() [8/16]

◆ dense_column() [5/16]

◆ dense_column() [6/16]

◆ dense_column() [7/16]

◆ dense_column() [8/16]

◆ sparse() [1/6]

◆ sparse() [2/6]

◆ sparse() [3/6]

◆ sparse_row() [1/16]

◆ sparse_row() [2/16]

◆ sparse_row() [3/16]

◆ sparse_row() [4/16]

◆ sparse_column() [1/16]

◆ sparse_column() [2/16]

◆ sparse_column() [3/16]

◆ sparse_column() [4/16]

◆ sparse_row() [5/16]

◆ sparse_row() [6/16]

◆ sparse_row() [7/16]

◆ sparse_row() [8/16]

◆ sparse_column() [5/16]

◆ sparse_column() [6/16]

◆ sparse_column() [7/16]

◆ sparse_column() [8/16]

◆ dense() [4/6]

◆ dense() [5/6]

◆ dense() [6/6]

◆ dense_row() [9/16]

◆ dense_row() [10/16]

◆ dense_row() [11/16]

◆ dense_row() [12/16]

◆ dense_column() [9/16]

◆ dense_column() [10/16]

◆ dense_column() [11/16]

◆ dense_column() [12/16]

◆ dense_row() [13/16]

◆ dense_row() [14/16]

◆ dense_row() [15/16]

◆ dense_row() [16/16]

◆ dense_column() [13/16]

◆ dense_column() [14/16]

◆ dense_column() [15/16]

◆ dense_column() [16/16]

◆ sparse() [4/6]

◆ sparse() [5/6]

◆ sparse() [6/6]

◆ sparse_row() [9/16]

◆ sparse_row() [10/16]

◆ sparse_row() [11/16]

◆ sparse_row() [12/16]

◆ sparse_column() [9/16]

◆ sparse_column() [10/16]