mock_dense_chunk.hpp

Go to the documentation of this file.

#ifndef TATAMI_CHUNKED_MOCK_DENSE_CHUNK_HPP
#define TATAMI_CHUNKED_MOCK_DENSE_CHUNK_HPP
 
#include <vector>
 
namespace tatami_chunked {
 
namespace MockDenseChunk_internal {
 
template<typename InflatedValue_>
using Workspace =  std::vector<InflatedValue_>; 
 
template<class Blob_>
class Core {
public:
    Core() = default;
 
    Core(Blob_ chunk) : my_chunk(std::move(chunk)) {}
 
private:
    Blob_ my_chunk;
 
    typedef typename Blob_::value_type value_type;
 
public:
    auto get_target_chunkdim(bool row) const {
        if (row) {
            return my_chunk.nrow();
        } else {
            return my_chunk.ncol();
        }
    }
 
    auto get_non_target_chunkdim(bool row) const {
        if (row) {
            return my_chunk.ncol();
        } else {
            return my_chunk.nrow();
        }
    }
 
public:
    template<typename Index_>
    void extract(bool row, Index_ target_start, Index_ target_length, Index_ non_target_start, Index_ non_target_length, Workspace<value_type>& work, value_type* output, size_t stride) const {
        my_chunk.inflate(work);
        output += static_cast<size_t>(target_start) * stride; // cast to size_t to avoid overflow.
 
        if (my_chunk.is_row_major() == row) {
            size_t non_target_chunkdim = get_non_target_chunkdim(row); // use size_t to avoid integer overflow with Index_.
            auto srcptr = work.data() + static_cast<size_t>(target_start) * non_target_chunkdim + static_cast<size_t>(non_target_start);
            for (Index_ p = 0; p < target_length; ++p) {
                std::copy_n(srcptr, non_target_length, output);
                srcptr += non_target_chunkdim;
                output += stride;
            }
 
        } else {
            size_t target_chunkdim = get_target_chunkdim(row); // use size_t to avoid integer overflow with Index_.
            auto srcptr = work.data() + static_cast<size_t>(non_target_start) * target_chunkdim + static_cast<size_t>(target_start);
            for (Index_ p = 0; p < target_length; ++p) {
                auto copy_srcptr = srcptr;
                auto copy_output = output;
                for (Index_ s = 0; s < non_target_length; ++s) {
                    *copy_output = *copy_srcptr;
                    ++copy_output;
                    copy_srcptr += target_chunkdim;
                }
                ++srcptr;
                output += stride;
            }
        }
    }
 
    template<typename Index_>
    void extract(bool row, Index_ target_start, Index_ target_length, const std::vector<Index_>& non_target_indices, Workspace<value_type>& work, value_type* output, size_t stride) const {
        my_chunk.inflate(work);
        output += static_cast<size_t>(target_start) * stride; // cast to size_t to avoid overflow.
 
        if (my_chunk.is_row_major() == row) {
            size_t non_target_chunkdim = get_non_target_chunkdim(row); // use size_t to avoid integer overflow with Index_.
            auto srcptr = work.data() + static_cast<size_t>(target_start) * non_target_chunkdim;
            for (Index_ p = 0; p < target_length; ++p) {
                auto copy_output = output;
                for (auto x : non_target_indices) {
                    *copy_output = srcptr[x];
                    ++copy_output;
                }
                srcptr += non_target_chunkdim;
                output += stride;
            }
 
        } else {
            size_t target_chunkdim = get_target_chunkdim(row); // use size_t to avoid integer overflow with Index_.
            auto srcptr = work.data() + static_cast<size_t>(target_start);
            for (Index_ p = 0; p < target_length; ++p) {
                auto copy_output = output;
                for (size_t x : non_target_indices) {
                    *copy_output = srcptr[x * target_chunkdim];
                    ++copy_output;
                }
                ++srcptr;
                output += stride;
            }
        }
    }
 
public:
    template<typename Index_>
    void extract(bool row, const std::vector<Index_>& target_indices, Index_ non_target_start, Index_ non_target_length, Workspace<value_type>& work, value_type* output, size_t stride) const {
        my_chunk.inflate(work);
 
        if (my_chunk.is_row_major() == row) {
            size_t non_target_chunkdim = get_non_target_chunkdim(row); // use size_t to avoid integer overflow with Index_.
            size_t offset = non_target_start;
            for (size_t p : target_indices) {
                auto srcptr = work.data() + p * non_target_chunkdim + offset;
                std::copy_n(srcptr, non_target_length, output + p * stride);
            }
 
        } else {
            size_t target_chunkdim = get_target_chunkdim(row); // use size_t to avoid integer overflow with Index_.
            auto srcptr = work.data() + static_cast<size_t>(non_target_start) * target_chunkdim;
            for (size_t p : target_indices) {
                auto copy_srcptr = srcptr + p;
                auto copy_output = output + p * stride;
                for (Index_ s = 0; s < non_target_length; ++s) {
                    *copy_output = *copy_srcptr;
                    ++copy_output;
                    copy_srcptr += target_chunkdim;
                }
            }
        }
    }
 
    template<typename Index_>
    void extract(bool row, const std::vector<Index_>& target_indices, const std::vector<Index_>& non_target_indices, Workspace<value_type>& work, value_type* output, size_t stride) const {
        my_chunk.inflate(work);
 
        if (my_chunk.is_row_major() == row) {
            size_t non_target_chunkdim = get_non_target_chunkdim(row); // use size_t to avoid integer overflow with Index_.
            for (size_t p : target_indices) {
                auto srcptr = work.data() + p * non_target_chunkdim;
                auto copy_output = output + p * stride;
                for (auto x : non_target_indices) {
                    *copy_output = srcptr[x];
                    ++copy_output;
                }
            }
 
        } else {
            size_t target_chunkdim = get_target_chunkdim(row); // use size_t to avoid integer overflow with Index_.
            for (size_t p : target_indices) {
                auto srcptr = work.data() + p;
                auto copy_output = output + p * stride;
                for (size_t x : non_target_indices) {
                    *copy_output = srcptr[x * target_chunkdim];
                    ++copy_output;
                }
            }
        }
    }
};
 
class MockBlob {
public:
    MockBlob(std::vector<double> data, size_t nrow, size_t ncol) : my_data(std::move(data)), my_nrow(nrow), my_ncol(ncol) {}
    MockBlob() = default;
 
    typedef double value_type;
 
    bool is_row_major() const {
        return true;
    }
 
private:
    std::vector<double> my_data;
    size_t my_nrow;
    size_t my_ncol;
 
public:
    size_t nrow() const {
        return my_nrow;
    }
 
    size_t ncol() const {
        return my_ncol;
    }
 
    void inflate(std::vector<double>& buffer) const {
        buffer.resize(my_data.size());
        std::copy(my_data.begin(), my_data.end(), buffer.begin());
    }
};
 
}
class MockSimpleDenseChunk {
public:
    typedef double value_type;
 
    struct Workspace {
        MockDenseChunk_internal::Workspace<value_type> work;
    };
 
    static constexpr bool use_subset = false;
 
public:
    // You can construct this however you like, I don't care.
    MockSimpleDenseChunk() = default;
    MockSimpleDenseChunk(std::vector<double> core, size_t nrow, size_t ncol) : my_core(MockDenseChunk_internal::MockBlob(std::move(core), nrow, ncol)) {}
private:
    MockDenseChunk_internal::Core<MockDenseChunk_internal::MockBlob> my_core;
 
public:
    template<typename Index_>
    void extract(bool row, Index_ non_target_start, Index_ non_target_length, Workspace& work, value_type* output, size_t stride) const {
        my_core.template extract<Index_>(row, 0, my_core.get_target_chunkdim(row), non_target_start, non_target_length, work.work, output, stride);
    }
 
    template<typename Index_>
    void extract(bool row, const std::vector<Index_>& non_target_indices, Workspace& work, value_type* output, size_t stride) const {
        my_core.template extract<Index_>(row, 0, my_core.get_target_chunkdim(row), non_target_indices, work.work, output, stride);
    }
};
 
template<class Blob_>
class SimpleDenseChunkWrapper {
public:
    typedef typename Blob_::value_type value_type;
 
    typedef MockDenseChunk_internal::Workspace<value_type> Workspace;
 
    static constexpr bool use_subset = false;
 
    SimpleDenseChunkWrapper() = default;
 
    SimpleDenseChunkWrapper(Blob_ core) : my_core(std::move(core)) {}
private:
    MockDenseChunk_internal::Core<Blob_> my_core;
 
public:
    template<typename Index_>
    void extract(bool row, Index_ non_target_start, Index_ non_target_length, Workspace& work, value_type* output, size_t stride) const {
        my_core.extract(row, 0, my_core.get_target_chunkdim(row), non_target_start, non_target_length, work, output, stride);
    }
 
    template<typename Index_>
    void extract(bool row, const std::vector<Index_>& non_target_indices, Workspace& work, value_type* output, size_t stride) const {
        my_core.extract(row, 0, my_core.get_target_chunkdim(row), non_target_indices, work, output, stride);
    }
};
 
class MockSubsettedDenseChunk {
public:
    typedef double value_type;
 
    struct Workspace {
        MockDenseChunk_internal::Workspace<value_type> work;
    };
 
    static constexpr bool use_subset = true;
 
    MockSubsettedDenseChunk() = default;
    MockSubsettedDenseChunk(std::vector<double> core, size_t nrow, size_t ncol) : my_core(MockDenseChunk_internal::MockBlob(std::move(core), nrow, ncol)) {}
private:
    MockDenseChunk_internal::Core<MockDenseChunk_internal::MockBlob> my_core;
 
public:
    template<typename Index_>
    void extract(bool row, Index_ target_start, Index_ target_length, Index_ non_target_start, Index_ non_target_length, Workspace& work, value_type* output, size_t stride) const {
        my_core.extract(row, target_start, target_length, non_target_start, non_target_length, work.work, output, stride);
    }
 
    template<typename Index_>
    void extract(bool row, Index_ target_start, Index_ target_length, const std::vector<Index_>& non_target_indices, Workspace& work, value_type* output, size_t stride) const {
        my_core.extract(row, target_start, target_length, non_target_indices, work.work, output, stride);
    }
 
public:
    template<typename Index_>
    void extract(bool row, const std::vector<Index_>& target_indices, Index_ non_target_start, Index_ non_target_length, Workspace& work, value_type* output, size_t stride) const {
        my_core.extract(row, target_indices, non_target_start, non_target_length, work.work, output, stride);
    }
 
    template<typename Index_>
    void extract(bool row, const std::vector<Index_>& target_indices, const std::vector<Index_>& non_target_indices, Workspace& work, value_type* output, size_t stride) const {
        my_core.extract(row, target_indices, non_target_indices, work.work, output, stride);
    }
};
 
}
 
#endif