ForcedDense.hpp

Go to the documentation of this file.

#ifndef TATAMI_FORCED_DENSE_HPP
#define TATAMI_FORCED_DENSE_HPP
 
#include "../base/Matrix.hpp"
 
namespace tatami {
 
template<typename Value_, typename Index_>
class ForcedDense final : public Matrix<Value_, Index_> {
public: 
    ForcedDense(std::shared_ptr<const Matrix<Value_, Index_> > matrix) : my_matrix(std::move(matrix)) {}
 
private: 
    std::shared_ptr<const Matrix<Value_, Index_> > my_matrix;
 
public:
    Index_ nrow() const { return my_matrix->nrow(); }
 
    Index_ ncol() const { return my_matrix->ncol(); }
 
    bool prefer_rows() const { return my_matrix->prefer_rows(); }
 
    bool uses_oracle(const bool row) const { return my_matrix->uses_oracle(row); }
 
    bool is_sparse() const { return false; }
 
    double is_sparse_proportion() const { return 0; }
 
    double prefer_rows_proportion() const { return my_matrix->prefer_rows_proportion(); }
 
    using Matrix<Value_, Index_>::dense;
 
    using Matrix<Value_, Index_>::sparse;
 
    /*****************************
     ******* Dense myopic ********
     *****************************/
public:
    std::unique_ptr<MyopicDenseExtractor<Value_, Index_> > dense(const bool row, const Options& opt) const {
        return my_matrix->dense(row, opt);
    }
 
    std::unique_ptr<MyopicDenseExtractor<Value_, Index_> > dense(const bool row, const Index_ block_start, const Index_ block_length, const Options& opt) const {
        return my_matrix->dense(row, block_start, block_length, opt);
    }
 
    std::unique_ptr<MyopicDenseExtractor<Value_, Index_> > dense(const bool row, VectorPtr<Index_> indices_ptr, const Options& opt) const {
        return my_matrix->dense(row, std::move(indices_ptr), opt); 
    }
 
    /******************************
     ******* Sparse myopic ********
     ******************************/
public:
    std::unique_ptr<MyopicSparseExtractor<Value_, Index_> > sparse(const bool row, const Options& opt) const {
        return my_matrix->sparse(row, opt);
    }
 
    std::unique_ptr<MyopicSparseExtractor<Value_, Index_> > sparse(const bool row, const Index_ block_start, const Index_ block_length, const Options& opt) const {
        return my_matrix->sparse(row, block_start, block_length, opt);
    }
 
    std::unique_ptr<MyopicSparseExtractor<Value_, Index_> > sparse(const bool row, VectorPtr<Index_> indices_ptr, const Options& opt) const {
        return my_matrix->sparse(row, indices_ptr, opt);
    }
 
    /*******************************
     ******* Dense oracular ********
     *******************************/
public:
    std::unique_ptr<OracularDenseExtractor<Value_, Index_> > dense(
        const bool row,
        std::shared_ptr<const Oracle<Index_> > oracle,
        const Options& opt
    ) const {
        return my_matrix->dense(row, std::move(oracle), opt);
    }
 
    std::unique_ptr<OracularDenseExtractor<Value_, Index_> > dense(
        const bool row,
        std::shared_ptr<const Oracle<Index_> > oracle,
        const Index_ block_start,
        const Index_ block_length,
        const Options& opt)
    const {
        return my_matrix->dense(row, std::move(oracle), block_start, block_length, opt);
    }
 
    std::unique_ptr<OracularDenseExtractor<Value_, Index_> > dense(
        const bool row,
        std::shared_ptr<const Oracle<Index_> > oracle,
        VectorPtr<Index_> indices_ptr,
        const Options& opt
    ) const {
        return my_matrix->dense(row, std::move(oracle), std::move(indices_ptr), opt);
    }
 
    /********************************
     ******* Sparse oracular ********
     ********************************/
public:
    std::unique_ptr<OracularSparseExtractor<Value_, Index_> > sparse(
        const bool row,
        std::shared_ptr<const Oracle<Index_> > oracle,
        const Options& opt
    ) const {
        return my_matrix->sparse(row, std::move(oracle), opt);
    }
 
    std::unique_ptr<OracularSparseExtractor<Value_, Index_> > sparse(
        const bool row,
        std::shared_ptr<const Oracle<Index_> > oracle,
        const Index_ block_start,
        const Index_ block_length,
        const Options& opt)
    const {
        return my_matrix->sparse(row, std::move(oracle), block_start, block_length, opt);
    }
 
    std::unique_ptr<OracularSparseExtractor<Value_, Index_> > sparse(
        const bool row,
        std::shared_ptr<const Oracle<Index_> > oracle,
        VectorPtr<Index_> indices_ptr,
        const Options& opt
    ) const {
        return my_matrix->sparse(row, std::move(oracle), std::move(indices_ptr), opt);
    }
};
 
}
 
#endif