GenericMatrix.h

Go to the documentation of this file.

#ifndef GENERIC_MATRIX_H
#define GENERIC_MATRIX_H
#include <exception>
#include <iostream>
#include <sstream>
#include <string>
#include <valarray>
#include <vector>
 
#include "CoreEnums.h"
 
template <typename T>
class GenericMatrix
{
    protected:
        int m_rows{0};
        int m_cols{0};
 
        std::valarray<T> m_matrix{};
        std::vector<std::pair<int, int>> m_non_zero_elements;
 
    public:
        GenericMatrix();
        GenericMatrix(int rows, int cols);
        GenericMatrix(int rows, int cols, const std::valarray<T>& values,
                      bool allow_mismatched_size);
 
        GenericMatrix(const GenericMatrix&) = default;
        GenericMatrix& operator=(const GenericMatrix&) = default;
 
        GenericMatrix(GenericMatrix&&) = default;
        GenericMatrix& operator=(GenericMatrix&&) = default;
 
        std::pair<int, int> size() const;
 
        virtual T& operator()(int rows, int cols) = 0;
        virtual T operator()(int rows, int cols) const = 0;
 
        virtual std::valarray<T> scalarAdd(T value) const = 0;
        virtual std::valarray<T> scalarSubtract(T value) const = 0;
        virtual std::valarray<T> scalarMultiply(T value) const = 0;
        virtual std::valarray<T> scalarDivide(T value) const = 0;
 
        virtual std::valarray<T> vectorElemAdd(const std::valarray<T>& value) const = 0;
        virtual std::valarray<T> vectorElemSubtract(const std::valarray<T>& value) const = 0;
        virtual std::valarray<T> vectorElemMultiply(const std::valarray<T>& value) const = 0;
        virtual std::valarray<T> vectorElemDivide(const std::valarray<T>& value) const = 0;
 
        virtual std::valarray<T> matrixVectorMultiplication(
            const std::valarray<T>& value) const = 0;
 
        virtual void buildAtRuntime(int rows, int cols) = 0;
        virtual void registerElement(T value, int rows, int cols) {};
 
        virtual void updateNonZeroElements() = 0;
        virtual const std::vector<std::pair<int, int>>& getNonZeroElements() = 0;
 
        virtual const MatrixType getMatrixType() = 0;
 
        void zeroMatrix();
 
        void overwriteMatrixValues(const std::valarray<T>& value);
 
        virtual ~GenericMatrix() = default;
};
 
template <typename T>
GenericMatrix<T>::GenericMatrix()
{
}
 
template <typename T>
GenericMatrix<T>::GenericMatrix(int rows, int cols) : m_rows{rows}, m_cols{cols}
{
    m_matrix.resize(rows * cols);
}
 
template <typename T>
GenericMatrix<T>::GenericMatrix(int rows, int cols, const std::valarray<T>& values,
                                bool allow_mismatched_size)
    : m_rows{rows}, m_cols{cols}, m_matrix{values}
{
    std::cout << "\n";
    if (values.size() != rows * cols && !allow_mismatched_size)
    {
        std::cerr << "Size mismatch between dimensions and provided values.\n";
        throw std::invalid_argument(
            static_cast<std::string>("Size mismatch between dimensions and provided values."));
    }
}
 
template <typename T>
std::pair<int, int> GenericMatrix<T>::size() const
{
    return std::pair<int, int>{m_rows, m_cols};
}
 
template <typename T>
void GenericMatrix<T>::zeroMatrix()
{
    m_matrix *= 0;
}
 
template <typename T>
void GenericMatrix<T>::overwriteMatrixValues(const std::valarray<T>& value)
{
    m_matrix = value;
}
 
class MatrixOutOfBoundsError : public std::exception
{
    private:
        std::string m_error_string;
 
    public:
        MatrixOutOfBoundsError(int access_row, int access_col, int rows, int cols,
                               const std::string& tag)
        {
            std::ostringstream oss;
            oss << tag << " Tried accessing matrix at index (" << access_row << ", " << access_col
                << ").\n"
                << "Nominal bounds of this matrix are: (" << rows << ", " << cols << ").\n";
            m_error_string = oss.str();
        }
 
        [[nodiscard]] const char* what() const noexcept override { return m_error_string.c_str(); }
 
        ~MatrixOutOfBoundsError() override = default;
};
 
#endif