SimpleMatrix.hpp

Go to the documentation of this file.

#ifndef KMEANS_SIMPLE_MATRIX_HPP
#define KMEANS_SIMPLE_MATRIX_HPP
 
#include <cstddef>
#include <limits>
 
#include "sanisizer/sanisizer.hpp"
 
#include "Matrix.hpp"
 
namespace kmeans {
 
template<typename Index_, typename Data_>
class SimpleMatrix;
 
#ifdef KMEANS_DEBUG_POINTER_USAGE
template<typename Data_>
class Buffer {
public:
    Buffer(std::size_t n) : my_buffer(n * MULT), my_n(n), my_eng(n + 1) {}
 
private:
    static constexpr std::size_t MULT = 5;
    std::vector<Data_> my_buffer;
    std::size_t my_n;
    std::mt19937_64 my_eng;
 
public:
    const Data_* update(const Data_* const ptr) {
        std::fill(my_buffer.begin(), my_buffer.end(), std::numeric_limits<Data_>::quiet_NaN());
        auto host = (my_eng() % MULT) * my_n;
        std::copy_n(ptr, my_n, host);
        return host;
    }
};
#endif
 
template<typename Index_, typename Data_>
class SimpleMatrixRandomAccessExtractor final : public RandomAccessExtractor<Index_, Data_> {
public:
    SimpleMatrixRandomAccessExtractor(const SimpleMatrix<Index_, Data_>& parent) : 
        my_parent(parent) 
#ifdef KMEANS_DEBUG_POINTER
        , my_buffer(my_parent.num_dimensions())
#endif
    {}
 
private:
    const SimpleMatrix<Index_, Data_>& my_parent;
#ifdef KMEANS_DEBUG_POINTER
    Buffer<Data_> my_buffer;
#endif
 
public:
    const Data_* get_observation(const Index_ i) {
        const auto output = my_parent.my_data + sanisizer::product_unsafe<std::size_t>(i, my_parent.my_num_dim);
#ifndef KMEANS_DEBUG_POINTER
        return output;
#else
        return my_buffer.update(output);
#endif
    }
};
 
template<typename Index_, typename Data_>
class SimpleMatrixConsecutiveAccessExtractor final : public ConsecutiveAccessExtractor<Index_, Data_> {
public:
    SimpleMatrixConsecutiveAccessExtractor(const SimpleMatrix<Index_, Data_>& parent, const Index_ start) :
        my_parent(parent),
        my_position(start) 
#ifdef KMEANS_DEBUG_POINTER
        , my_buffer(my_parent.num_dimensions())
#endif
    {}
 
private:
    const SimpleMatrix<Index_, Data_>& my_parent;
    Index_ my_position;
#ifdef KMEANS_DEBUG_POINTER
    Buffer<Data_> my_buffer;
#endif
 
public:
    const Data_* get_observation() {
        const auto output = my_parent.my_data + sanisizer::product_unsafe<std::size_t>(my_position++, my_parent.my_num_dim);
#ifndef KMEANS_DEBUG_POINTER
        return output;
#else
        return my_buffer.update(output);
#endif
    }
};
 
template<typename Index_, typename Data_>
class SimpleMatrixIndexedAccessExtractor final : public IndexedAccessExtractor<Index_, Data_> {
public:
    SimpleMatrixIndexedAccessExtractor(const SimpleMatrix<Index_, Data_>& parent, const Index_* const sequence) :
        my_parent(parent),
        my_sequence(sequence)
#ifdef KMEANS_DEBUG_POINTER
        , my_buffer(my_parent.num_dimensions())
#endif
    {}
 
private:
    const SimpleMatrix<Index_, Data_>& my_parent;
    const Index_* my_sequence;
    std::size_t my_position = 0;
#ifdef KMEANS_DEBUG_POINTER
    Buffer<Data_> my_buffer;
#endif
 
public:
    const Data_* get_observation() {
        const auto output = my_parent.my_data + sanisizer::product_unsafe<std::size_t>(my_sequence[my_position++], my_parent.my_num_dim);
#ifndef KMEANS_DEBUG_POINTER
        return output;
#else
        return my_buffer.update(output);
#endif
    }
};
template<typename Index_, typename Data_>
class SimpleMatrix final : public Matrix<Index_, Data_> {
public:
    SimpleMatrix(const std::size_t num_dimensions, const Index_ num_observations, const Data_* const data) :
        my_num_dim(num_dimensions), my_num_obs(num_observations), my_data(data) {}
 
private:
    std::size_t my_num_dim;
    Index_ my_num_obs;
    const Data_* my_data;
    friend class SimpleMatrixRandomAccessExtractor<Index_, Data_>;
    friend class SimpleMatrixConsecutiveAccessExtractor<Index_, Data_>;
    friend class SimpleMatrixIndexedAccessExtractor<Index_, Data_>;
 
public:
    Index_ num_observations() const {
        return my_num_obs;
    }
 
    std::size_t num_dimensions() const {
        return my_num_dim;
    }
 
public:
    std::unique_ptr<RandomAccessExtractor<Index_, Data_> > new_extractor() const {
        return std::make_unique<SimpleMatrixRandomAccessExtractor<Index_, Data_> >(*this);
    }
 
    std::unique_ptr<ConsecutiveAccessExtractor<Index_, Data_> > new_extractor(const Index_ start, const Index_) const {
        return std::make_unique<SimpleMatrixConsecutiveAccessExtractor<Index_, Data_> >(*this, start);
    }
 
    std::unique_ptr<IndexedAccessExtractor<Index_, Data_> > new_extractor(const Index_* sequence, const std::size_t) const {
        return std::make_unique<SimpleMatrixIndexedAccessExtractor<Index_, Data_> >(*this, sequence);
    }
};
 
}
 
#endif