Matrix.hpp

Go to the documentation of this file.

#ifndef KNNCOLLE_MATRIX_HPP
#define KNNCOLLE_MATRIX_HPP
 
#include <memory>
#include <cstddef>
 
#include "sanisizer/sanisizer.hpp"
 
namespace knncolle {
 
template<typename Data_>
class MatrixExtractor {
public:
    MatrixExtractor() = default;
    MatrixExtractor(const MatrixExtractor&) = default;
    MatrixExtractor(MatrixExtractor&&) = default;
    MatrixExtractor& operator=(const MatrixExtractor&) = default;
    MatrixExtractor& operator=(MatrixExtractor&&) = default;
    virtual ~MatrixExtractor() = default;
public:
    virtual const Data_* next() = 0;
};
 
 
template<typename Index_, typename Data_>
class Matrix {
public:
    Matrix() = default;
    Matrix(const Matrix&) = default;
    Matrix(Matrix&&) = default;
    Matrix& operator=(const Matrix&) = default;
    Matrix& operator=(Matrix&&) = default;
    virtual ~Matrix() = default;
public:
    virtual Index_ num_observations() const = 0;
 
    virtual std::size_t num_dimensions() const = 0;
 
public:
    virtual std::unique_ptr<MatrixExtractor<Data_> > new_extractor() const = 0;
 
    auto new_known_extractor() const {
        return new_extractor();
    }
};
 
template<typename Data_>
class SimpleMatrixExtractor final : public MatrixExtractor<Data_> {
public:
    SimpleMatrixExtractor(const Data_* data, std::size_t dim) : my_data(data), my_dim(dim) {}
 
private:
    const Data_* my_data;
    std::size_t my_dim;
    std::size_t at = 0;
 
public:
    const Data_* next() {
        return my_data + sanisizer::product_unsafe<std::size_t>(at++, my_dim);
    } 
};
template<typename Index_, typename Data_>
class SimpleMatrix final : public Matrix<Index_, Data_> {
public:
    SimpleMatrix(std::size_t num_dimensions, Index_ num_observations, const Data_* 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;
 
public:
    Index_ num_observations() const {
        return my_num_obs;
    }
 
    std::size_t num_dimensions() const {
        return my_num_dim;
    }
 
    std::unique_ptr<MatrixExtractor<Data_> > new_extractor() const {
        return new_known_extractor();
    }
 
    auto new_known_extractor() const {
        return std::make_unique<SimpleMatrixExtractor<Data_> >(my_data, my_num_dim);
    }
};
 
}
 
#endif