util/Matrix.h

Go to the documentation of this file.

#ifndef MATRIX_H
#define MATRIX_H

#include <stdexcept>
#include <string>
#include <typeinfo>
#include "utils.h"

// TODO: Matrix-operations (arithmetics)?

template<typename T>
class Matrix
{
    public:
        class Row {
            public:
                Row(Matrix *parent, size_t i) : _par(parent), _i(i) {}
                T& operator[](int j) { return _par->at(_i, j); }
            private:
                Matrix<T>* _par;
                size_t _i;
        };

        Matrix(size_t n, size_t m, T v = static_cast<T>(0));

        Matrix(Matrix<T> const& other);

        ~Matrix();

        const size_t getN() const { return m_width; }

        const size_t getM() const { return m_height; }

        T& at(size_t i, size_t j);

        T& operator()(size_t i, size_t j) { return at(i, j); }

        T get(size_t i, size_t j) const;

        void set(size_t i, size_t j, T v);

        Matrix<T> &operator=(Matrix<T> const& other);

        Row operator[](size_t i) { return Row(this, i); }

        Matrix<T> transposed();
        Matrix<T> &transposeSelf();

        Matrix<T> &operator+=(Matrix<T>& right);

        Matrix<T> &operator-=(Matrix<T>& right);

        Matrix<T> &operator*=(Matrix<T>& right);

        Matrix<T> &operator*=(T scalar);

    private:
        size_t m_width;
        size_t m_height;
        T *m_matrix;
};

template<typename T>
Matrix<T>::Matrix(size_t n, size_t m, T v) :
    m_width(n), m_height(m)
{   
    m_matrix = new T[n*m];
    for (size_t i = 0; i < n*m; ++i) {
        m_matrix[i] = v;
    }
}

template<typename T>
Matrix<T>::Matrix(Matrix const& other) :
    m_width(other.getN()), m_height(other.getM())
{
    m_matrix = new T[getN()*getM()];
    for (size_t i = 0; i < other.getN(); ++i) {
        for (size_t j = 0; j < other.getM(); ++j) {
            m_matrix[i + j * getN()] = other.get(i, j);
        }
    }
}

template<typename T>
Matrix<T>::~Matrix()
{
    delete[] m_matrix;
    m_matrix = NULL;
}

template<typename T>
T& Matrix<T>::at(size_t i, size_t j)
{
    if (i < 0 || i >= getN() || j < 0 || j >= getM()) {
        std::string err = "Matrix<";
        err += typeid(T).name();
        err += ">::at(" + convertTo<size_t, std::string>(i) + ", " + convertTo<size_t, std::string>(j);
        err += "): index out of range. Dimensions are: ";
        err += convertTo<size_t, std::string>(getN()) + ", " + convertTo<size_t, std::string>(getM());
        throw std::out_of_range(err.c_str());
    }

    return m_matrix[i + j * getN()];
}

template<typename T>
T Matrix<T>::get(size_t i, size_t j) const
{ 
    // cannot use at here because of constness
    if (i < 0 || i >= getN() || j < 0 || j >= getM()) {
        std::string err = "Matrix<";
        err += typeid(T).name();
        err += ">::get(" + convertTo<size_t, std::string>(i) + ", " + convertTo<size_t, std::string>(j);
        err += "): index out of range. Dimensions";
        err += convertTo<size_t, std::string>(getN()) + ", " + convertTo<size_t, std::string>(getM());
        throw std::out_of_range(err.c_str());
    }

    return m_matrix[i + j * getN()];
}

template<typename T>
void Matrix<T>::set(size_t i, size_t j, T v)
{
    at(i, j) = v;
}

template<typename T>
Matrix<T>& Matrix<T>::operator=(Matrix<T> const &other)
{
    if (&other == this)
        return *this;

    if (other.getN() != getN() || other.getM() != getM()) {
        T *temp = m_matrix;
        m_width = other.getN();
        m_height = other.getM();
        m_matrix = new T[getN()*getM()];
        delete[] temp;
    }

    for (size_t i = 0; i < other.getN(); ++i) {
        for (size_t j = 0; j < other.getM(); ++j) {
            m_matrix[i + j * getN()] = other.get(i, j);
        }
    }
    return *this;
}

template<typename T>
Matrix<T> &Matrix<T>::transposeSelf()
{
    Matrix<T> temp(transposed());
    *this = temp;
    return *this;
}

template<typename T>
Matrix<T> Matrix<T>::transposed() 
{
    Matrix<T> temp(getM(), getN());
    for (size_t i = 0; i < getN(); ++i) {
        for (size_t j = 0; j < getM; ++j) {
            temp.at(j, i) = get(i, j);
        }
    }
    return temp;
}

template<typename T>
Matrix<T> &Matrix<T>::operator+=(Matrix<T>& right)
{
    if (getN() != right.getN() || getM() != right.getM()) {
        std::string err = "Matrix<";
        err += typeid(T).name();
        err += ">::operator+=(Matrix<T>& right): Matrix sizes do not match: ";
        err += convertTo<size_t, std::string>(getN()) + ", " + convertTo<size_t, std::string>(getM());
        err += " vs " +  convertTo<size_t, std::string>(right.getN()) + ", " + convertTo<size_t, std::string>(right.getM());
        throw std::out_of_range(err.c_str());
    }

    Matrix temp(*this);
    for (size_t i = 0; i < getN(); ++i) {
        for (size_t j = 0; j < getM(); ++j) {
            temp.at(i, j) += right.at(i, j);
        }
    }

    *this = temp;
    return *this;
}

template<typename T>
Matrix<T> &Matrix<T>::operator-=(Matrix<T>& right)
{
    if (getN() != right.getN() || getM() != right.getM()) {
        std::string err = "Matrix<";
        err += typeid(T).name();
        err += ">::operator+=(Matrix<T>& right): Matrix sizes do not match: ";
        err += convertTo<size_t, std::string>(getN()) + ", " + convertTo<size_t, std::string>(getM());
        err += " vs " +  convertTo<size_t, std::string>(right.getN()) + ", " + convertTo<size_t, std::string>(right.getM());
        throw std::out_of_range(err.c_str());
    }

    Matrix temp(*this);
    for (size_t i = 0; i < getN(); ++i) {
        for (size_t j = 0; j < getM(); ++j) {
            temp.at(i, j) -= right.at(i, j);
        }
    }

    *this = temp;
    return *this;
}

template<typename T>
Matrix<T> &Matrix<T>::operator*=(Matrix<T>& right)
{
    if (getM() != right.getN()) {
        std::string err = "Matrix<";
        err += typeid(T).name();
        err += ">::operator+=(Matrix<T>& right): Matrix sizes do not match: ";
        err += convertTo<size_t, std::string>(getN()) + ", " + convertTo<size_t, std::string>(getM());
        err += " vs " +  convertTo<size_t, std::string>(right.getN()) + ", " + convertTo<size_t, std::string>(right.getM());
        throw std::out_of_range(err.c_str());
    }

    Matrix temp(getN(), right.getM());
    for (size_t i = 0; i < getN(); ++i) {
        for (size_t j = 0; j < right.getM(); ++j) {
            for (size_t k = 0; k < getM(); ++k) {
                temp.at(i, j) += get(i, k) + get(k, j);
            }
        }
    }

    *this = temp;
    return *this;
}

template<typename T>
Matrix<T> &Matrix<T>::operator*=(T scalar)
{
    for (size_t i = 0; i < getN() * getM(); ++i) {
        m_matrix[i] *= scalar;
    }
}

#endif

---