SparsifiedWrapper.hpp

Go to the documentation of this file.

#ifndef TATAMI_SPARSIFIED_WRAPPER_HPP
#define TATAMI_SPARSIFIED_WRAPPER_HPP
 
#include "../base/SparseRange.hpp"
#include "../base/Options.hpp"
#include "../base/Extractor.hpp"
 
#include <algorithm>
 
namespace tatami {
 
template<bool oracle_, typename Value_, typename Index_>
class FullSparsifiedWrapper : public SparseExtractor<oracle_, Value_, Index_> {
public:
    FullSparsifiedWrapper(std::unique_ptr<DenseExtractor<oracle_, Value_, Index_> > dense, Index_ extent, const Options& opt) :
        my_dense(std::move(dense)), 
        my_extent(extent), 
        my_needs_value(opt.sparse_extract_value), 
        my_needs_index(opt.sparse_extract_index) 
    {}
 
    SparseRange<Value_, Index_> fetch(Index_ i, Value_* value_buffer, Index_* index_buffer) {
        SparseRange<Value_, Index_> output(my_extent);
        if (my_needs_value) {
            output.value = my_dense->fetch(i, value_buffer);
        }
        if (my_needs_index) {
            std::iota(index_buffer, index_buffer + my_extent, static_cast<Index_>(0));
            output.index = index_buffer;
        }
        return output;
    }
 
private:
    std::unique_ptr<DenseExtractor<oracle_, Value_, Index_> > my_dense;
    Index_ my_extent;
    bool my_needs_value;
    bool my_needs_index;
};
 
template<bool oracle_, typename Value_, typename Index_>
class BlockSparsifiedWrapper : public SparseExtractor<oracle_, Value_, Index_> {
public:
    BlockSparsifiedWrapper(std::unique_ptr<DenseExtractor<oracle_, Value_, Index_> > dense, Index_ block_start, Index_ block_length, const Options& opt) :
        my_dense(std::move(dense)), 
        my_block_start(block_start), 
        my_block_length(block_length), 
        my_needs_value(opt.sparse_extract_value), 
        my_needs_index(opt.sparse_extract_index) 
    {}
 
    SparseRange<Value_, Index_> fetch(Index_ i, Value_* value_buffer, Index_* index_buffer) {
        SparseRange<Value_, Index_> output(my_block_length, NULL, NULL);
        if (my_needs_value) {
            output.value = my_dense->fetch(i, value_buffer);
        }
        if (my_needs_index) {
            std::iota(index_buffer, index_buffer + my_block_length, my_block_start);
            output.index = index_buffer;
        }
        return output;
    }
 
private:
    std::unique_ptr<DenseExtractor<oracle_, Value_, Index_> > my_dense;
    Index_ my_block_start, my_block_length;
    bool my_needs_value;
    bool my_needs_index;
};
 
template<bool oracle_, typename Value_, typename Index_>
class IndexSparsifiedWrapper : public SparseExtractor<oracle_, Value_, Index_> {
public:
    IndexSparsifiedWrapper(std::unique_ptr<DenseExtractor<oracle_, Value_, Index_> > dense, VectorPtr<Index_> indices_ptr, const Options& opt) :
        my_dense(std::move(dense)), 
        my_indices_ptr(std::move(indices_ptr)), 
        my_needs_value(opt.sparse_extract_value), 
        my_needs_index(opt.sparse_extract_index) 
    {}
 
    SparseRange<Value_, Index_> fetch(Index_ i, Value_* value_buffer, Index_* index_buffer) {
        const auto& ix = *my_indices_ptr;
        SparseRange<Value_, Index_> output(ix.size());
        if (my_needs_value) {
            output.value = my_dense->fetch(i, value_buffer);
        }
        if (my_needs_index) {
            std::copy(ix.begin(), ix.end(), index_buffer);
            output.index = index_buffer;
        }
        return output;
    }
 
private:
    std::unique_ptr<DenseExtractor<oracle_, Value_, Index_> > my_dense;
    VectorPtr<Index_> my_indices_ptr;
    bool my_needs_value;
    bool my_needs_index;
};
 
}
 
#endif