DenseMatrix.h

Go to the documentation of this file.

#ifndef DENSE_MATRIX_H
#define DENSE_MATRIX_H
 
#include <iostream>
#include <string>
#include <valarray>
#include <vector>
 
#include "CoreEnums.h"
#include "GenericMatrix.h"
 
template <typename T>
class DenseMatrix : public GenericMatrix<T>
{
    public:
        DenseMatrix();
        DenseMatrix(int rows, int cols);
        DenseMatrix(int rows, int cols, const std::valarray<T>& values);
 
        T& operator()(int rows, int cols) override;
        T operator()(int rows, int cols) const override;
 
        DenseMatrix(const DenseMatrix&) = default;
        DenseMatrix& operator=(const DenseMatrix&) = default;
 
        DenseMatrix(DenseMatrix&&) = default;
        DenseMatrix& operator=(DenseMatrix&&) = default;
 
        std::valarray<T> scalarAdd(T value) const override;
        std::valarray<T> matrixAddElementWise(const DenseMatrix& dense_matrix) const;
        std::valarray<T> scalarSubtract(T value) const override;
        std::valarray<T> matrixSubtractElementWise(const DenseMatrix& dense_matrix) const;
        std::valarray<T> scalarMultiply(T value) const override;
        std::valarray<T> matrixMultiplyElementWise(const DenseMatrix& dense_matrix) const;
        DenseMatrix<T> matrixMultiply(const DenseMatrix& dense_matrix) const;
        std::valarray<T> scalarDivide(T value) const override;
        std::valarray<T> matrixDivideElementWise(const DenseMatrix& dense_matrix) const;
 
        std::valarray<T> vectorElemAdd(const std::valarray<T>& value) const override;
        std::valarray<T> vectorElemSubtract(const std::valarray<T>& value) const override;
        std::valarray<T> vectorElemMultiply(const std::valarray<T>& value) const override;
        std::valarray<T> vectorElemDivide(const std::valarray<T>& value) const override;
 
        std::valarray<T> matrixVectorMultiplication(const std::valarray<T>& value) const override;
 
        void buildAtRuntime(int rows, int cols) override;
        void updateNonZeroElements() override;
        const std::vector<std::pair<int, int>>& getNonZeroElements() override
        {
            return this->m_non_zero_elements;
        }
 
        const MatrixType getMatrixType() override { return MatrixType::Dense; }
 
        ~DenseMatrix() override = default;
};
 
template <typename T>
DenseMatrix<T>::DenseMatrix()
{
}
 
template <typename T>
DenseMatrix<T>::DenseMatrix(int rows, int cols) : GenericMatrix<T>{rows, cols}
{
}
 
template <typename T>
DenseMatrix<T>::DenseMatrix(int rows, int cols, const std::valarray<T>& values)
    : GenericMatrix<T>{rows, cols, values, false}
{
    if (values.size() != rows * cols)
    {
        throw std::invalid_argument("Size mismatch between dimensions and provided values.");
    }
}
 
template <typename T>
T& DenseMatrix<T>::operator()(const int rows, const int cols)
{
    if (rows >= this->m_rows || cols >= this->m_cols)
    {
        throw MatrixOutOfBoundsError(rows, cols, this->m_rows, this->m_cols);
    }
    return this->m_matrix[rows * this->m_cols + cols];
}
 
template <typename T>
T DenseMatrix<T>::operator()(const int rows, const int cols) const
{
    if (rows >= this->m_rows || cols >= this->m_cols)
    {
        throw MatrixOutOfBoundsError(rows, cols, this->m_rows, this->m_cols);
    }
    return this->m_matrix[rows * this->m_cols + cols];
}
 
template <typename T>
std::valarray<T> DenseMatrix<T>::scalarAdd(const T value) const
{
    return this->m_matrix + value;
}
 
template <typename T>
std::valarray<T> DenseMatrix<T>::matrixAddElementWise(const DenseMatrix& dense_matrix) const
{
    return this->m_matrix + dense_matrix.m_matrix;
}
 
template <typename T>
std::valarray<T> DenseMatrix<T>::scalarSubtract(const T value) const
{
    return this->m_matrix - value;
}
 
template <typename T>
std::valarray<T> DenseMatrix<T>::matrixSubtractElementWise(const DenseMatrix& dense_matrix) const
{
    return this->m_matrix - dense_matrix.m_matrix;
}
 
template <typename T>
std::valarray<T> DenseMatrix<T>::scalarMultiply(const T value) const
{
    return this->m_matrix * value;
}
 
template <typename T>
DenseMatrix<T> DenseMatrix<T>::matrixMultiply(const DenseMatrix& dense_matrix) const
{
    // Multiply matrices A^(n x m) * B^(m x k) = C^(n x k)
    // Not very efficient algorithm, please revise if used more intensily in the future!
    std::valarray<T> result(this->m_rows * dense_matrix.m_cols);
    for (int i = 0; i < this->m_rows; i++)
    {
        for (int j = 0; j < dense_matrix.m_cols; j++)
        {
            T sum = {0};
            for (int k = 0; k < this->m_cols; k++)
            {
                sum += this->m_matrix[i * this->m_cols + k]
                       * dense_matrix.m_matrix[k * dense_matrix.m_cols + j];
            }
            result[i * this->m_cols + j] = sum;
        }
    }
    return {this->m_rows, dense_matrix.m_cols, result};
}
 
template <typename T>
std::valarray<T> DenseMatrix<T>::matrixMultiplyElementWise(const DenseMatrix& dense_matrix) const
{
    return this->m_matrix * dense_matrix.m_matrix;
}
 
template <typename T>
std::valarray<T> DenseMatrix<T>::scalarDivide(const T value) const
{
    return this->m_matrix / value;
}
 
template <typename T>
std::valarray<T> DenseMatrix<T>::matrixDivideElementWise(const DenseMatrix& dense_matrix) const
{
    return this->m_matrix / dense_matrix.m_matrix;
}
 
template <typename T>
std::valarray<T> DenseMatrix<T>::vectorElemAdd(const std::valarray<T>& value) const
{
    return this->m_matrix + value;
}
 
template <typename T>
std::valarray<T> DenseMatrix<T>::vectorElemSubtract(const std::valarray<T>& value) const
{
    return this->m_matrix - value;
}
 
template <typename T>
std::valarray<T> DenseMatrix<T>::vectorElemMultiply(const std::valarray<T>& value) const
{
    return this->m_matrix * value;
}
 
template <typename T>
std::valarray<T> DenseMatrix<T>::vectorElemDivide(const std::valarray<T>& value) const
{
    return this->m_matrix / value;
}
 
template <typename T>
std::valarray<T> DenseMatrix<T>::matrixVectorMultiplication(const std::valarray<T>& value) const
{
    std::valarray<T> result(value.size());
    for (int i{0}; i < value.size(); i++)
    {
        for (int j = 0; j < this->m_cols; j++)
        {
            result[i] += this->m_matrix[i * this->m_cols + j];
        }
        result[i] *= value[i];
    }
    return result;
}
 
template <typename T>
DenseMatrix<T> operator+(const DenseMatrix<T>& dm_1, const DenseMatrix<T>& dm_2)
{
    std::pair<int, int> size = dm_1.size();
    return {size.first, size.second, dm_1.matrix_add_element_wise(dm_2)};
}
 
template <typename T>
DenseMatrix<T> operator+(const DenseMatrix<T>& dense_matrix, const T value)
{
    std::pair<int, int> size = dense_matrix.size();
    return {size.first, size.second, dense_matrix.scalarAdd(value)};
}
 
template <typename T>
DenseMatrix<T> operator+(const T value, const DenseMatrix<T>& dense_matrix)
{
    std::pair<int, int> size = dense_matrix.size();
    return {size.first, size.second, dense_matrix.scalarAdd(value)};
}
 
template <typename T>
DenseMatrix<T> operator-(const DenseMatrix<T>& dm_1, const DenseMatrix<T>& dm_2)
{
    std::pair<int, int> size = dm_1.size();
    return {size.first, size.second, dm_1.matrix_subtract_element_wise(dm_2)};
}
 
template <typename T>
DenseMatrix<T> operator-(const DenseMatrix<T>& dense_matrix, const T value)
{
    std::pair<int, int> size = dense_matrix.size();
    return {size.first, size.second, dense_matrix.scalarSubtract(value)};
}
 
template <typename T>
DenseMatrix<T> operator-(const T value, const DenseMatrix<T>& dense_matrix)
{
    std::pair<int, int> size = dense_matrix.size();
    return {size.first, size.second, -dense_matrix.scalarSubtract(value)};
}
 
template <typename T>
DenseMatrix<T> operator*(const DenseMatrix<T>& dm_1, const DenseMatrix<T>& dm_2)
{
    std::pair<int, int> size = dm_1.size();
    return {size.first, size.second, dm_1.matrixMultiplyElementWise(dm_2)};
}
 
template <typename T>
DenseMatrix<T> operator*(const DenseMatrix<T>& dense_matrix, const T value)
{
    std::pair<int, int> size = dense_matrix.size();
    return {size.first, size.second, dense_matrix.scalarMultiply(value)};
}
 
template <typename T>
DenseMatrix<T> operator*(const T value, const DenseMatrix<T>& dense_matrix)
{
    std::pair<int, int> size = dense_matrix.size();
    return {size.first, size.second, dense_matrix.scalarMultiply(value)};
}
 
template <typename T>
DenseMatrix<T> operator/(const DenseMatrix<T>& dm_1, const DenseMatrix<T>& dm_2)
{
    std::pair<int, int> size = dm_1.size();
    return {size.first, size.second, dm_1.matrix_divide_element_wise(dm_2)};
}
 
template <typename T>
DenseMatrix<T> operator/(const DenseMatrix<T>& dense_matrix, const T value)
{
    std::pair<int, int> size = dense_matrix.size();
    return {size.first, size.second, dense_matrix.scalarDivide(value)};
}
 
template <typename T>
DenseMatrix<T> operator/(const T value, const DenseMatrix<T>& dense_matrix)
{
    std::pair<int, int> size = dense_matrix.size();
    return {size.first, size.second, 1 / dense_matrix.scalarDivide(value)};
}
 
template <typename T>
std::ostream& operator<<(std::ostream& out, const DenseMatrix<T>& dense_matrix)
{
    std::pair<int, int> size = dense_matrix.size();
    for (int i = 0; i < size.first; i++)
    {
        for (int j = 0; j < size.second; j++)
        {
            std::cout << dense_matrix(i, j) << " ";
        }
        std::cout << "\n";
    }
    return out;
}
 
template <typename T>
void DenseMatrix<T>::buildAtRuntime(const int rows, const int cols)
{
    this->m_rows = rows;
    this->m_cols = cols;
    this->m_matrix.resize(rows * cols);
}
 
template <typename T>
void DenseMatrix<T>::updateNonZeroElements()
{
    for (int i{0}; i < this->m_rows; i++)
    {
        for (int j{0}; j < this->m_cols; j++)
        {
            if (this->m_matrix[i * this->m_cols + j] != 0)
            {
                this->m_non_zero_elements.emplace_back(i, j);
            }
        }
    }
}
#endif