Matrix.h

#ifndef gridripper_math_Matrix_h
#define gridripper_math_Matrix_h
// 1991-92, 2001, 2008, Csizmadia Peter

#include <iostream>

namespace gridripper { namespace math {

template <class T>
class MVector
{
protected:
    T *x;

    int n;

public:
    MVector();

    MVector(int d);

    MVector(const MVector<T>& v);

    virtual ~MVector();

    virtual void setSize(int n);

    int size() const { return n; }

    T&  operator [](int i) const {
        return x[i];
    }

    MVector<T>& operator =(const MVector<T>& b);

    MVector<T>& operator =(T s);

    bool operator ==(const MVector<T>& b) const;

    bool operator !=(const MVector<T>& b) const {
        return !(*this == b);
    }

    MVector<T> operator +() const {return *this;}

    MVector<T> operator -() const;

    MVector<T> operator +(const MVector<T>& b) const;

    MVector<T> operator -(const MVector<T>& b) const;

    MVector<T> operator *(T s) const;

    MVector<T> operator /(T s) const;

    MVector<T>& operator +=(const MVector<T>& b);

    MVector<T>& operator -=(const MVector<T>& b);

    template <class T2>
    friend MVector<T2> operator *(T2 s, const MVector<T2>& v) {
        return v*s;
    }

    T operator *(const MVector<T>& v) const;

    MVector<T>& operator *=(T s);

    MVector<T>& operator /=(T s);

    T square();

    template <class T2>
    friend std::istream& operator >>(std::istream& is, MVector<T2>& v);

    template <class T2>
    friend std::ostream& operator <<(std::ostream& os, const MVector<T2>& v);

private:
    void init(int n);
};

template <class T>
class Matrix
{
protected:
    T *x;

    int numRows;

    int numColumns;

public:
    Matrix() {
        x = NULL;
        numRows = numColumns = 0;
    }

    Matrix(int rows, int columns);

    Matrix(const Matrix<T>&);

    virtual ~Matrix();

    void setZero();

    void setIdentity();

    virtual void setSize(int rows, int columns);

    int getNumRows() const { return numRows; }

    int getNumColumns() const { return numColumns; }

    T& operator ()(int i, int j) {
        return x[i*numColumns + j];
    }

    T operator ()(int i, int j) const {
        return x[i*numColumns + j];
    }

    T& operator [](int i) {
        return x[i];
    }

    T operator [](int i) const {
        return x[i];
    }

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

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

    int operator !=(const Matrix<T>& B) const {return !(*this==B);}

    Matrix<T> operator +() const {return *this;}

    Matrix<T> operator -() const;

    Matrix<T> operator +(const Matrix<T>&) const;

    Matrix<T> operator -(const Matrix<T>&) const;

    MVector<T> operator *(const MVector<T>&) const;

    Matrix<T> operator *(T) const;

    Matrix<T> operator /(T) const;

    Matrix<T> operator ^(int) const;

    Matrix<T> operator *(const Matrix<T>&) const;

    template <class T2>
    friend Matrix<T2> operator *(T2 s, const Matrix<T2>& A) {return A*s;}

    template <class T2>
    friend MVector<T2> operator *(const MVector<T2>&, const Matrix<T2>&);

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

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

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

    Matrix<T>& operator /=(T);

    Matrix<T>& operator *=(const Matrix<T>& B) {
        return *this = *this * B;
    }

    Matrix<T>& operator ^=(int);

    Matrix<T> operator ~() const;

    Matrix<T> minorMatrix(int row, int column) const;

    template <class T2>
    friend MVector<T2> operator /(const MVector<T2>&, const Matrix<T2>&);

    T trace() const;

    T det() const;

    void invert() { invert(*this); }

    void invert(const Matrix<T>&);

    void swapRows(int i, int j);

    template <class T2>
    friend std::istream& operator >>(std::istream&, Matrix<T2>&);

    template <class T2>
    friend std::ostream& operator <<(std::ostream&, const Matrix<T2>&);

private:
    void init(int rows, int columns);
};

#include "Matrix.tcc"

} } // namespace gridripper

#endif /* gridripper_math_Matrix_h */