Weird errors.

Hello !

I'm getting many errors I have no idea how to correct them. The code seems fine to me but it does look like it isn't.

Code:

---

#ifndef MATRIX_H_INCLUDED
#define MATRIX_H_INCLUDED

#include <list>

template < class T >
class Matrix
{
public:
        bool SquareMatrix( );
        static MATRIX_PTR Minor(const Matrix< T >&);
private:
        typedef std::auto_ptr< Matrix< T > > MATRIX_PTR;
        unsigned int Rows, Cols;
        std::list< std::list< T > > Data;
        MATRIX_PTR Temp;
};

template < class T >
bool Matrix< T >::SquareMatrix( )
{
        return (Rows == Cols);
}

template < class T >
MATRIX_PTR Matrix< T >::Minor(const Matrix< T >& m)
{
       
}

#endif // MATRIX_H_INCLUDED

---

Quote:

---

error C2236: '<Unknown>' '<Unknown>' inattendu
error C2143: syntax error : missing '>' before'{'
error C2079: 'Matrix' uses class 'Matrix' undefined
error C2988: cannot recognize template declaration / definition
error C2059: syntax error : '<end Parse>'
error C2143: syntax error : missing ';' before'<'
error C2988: cannot recognize template declaration / definition
error C2059: syntax error : '<'
error C2039: 'Minor' : is not a member of 'operator``global namespace'''
error C2039: 'SquareMatrix' : is not a member of 'operator``global namespace'''
error C2447: '{' : function header missing (old format formal list ?)
syntax error : missing ';' before'{'

---

Any info would be more than welcome. I have tried moving around the typedef, using a #define instead, not defining a new type at all.. etc.

You should place the typedef before the code that uses it (Minor returns a MATRIX_PTR). I'm not sure if that will solve the problem, but if you haven't tried it already I'd do that. Just add a private block above the public one.

Of course, can you return a private typedef from a public function? You might have to make the typedef public.

I put that typedef up there in the public section, before the two functions and I get the same errors. I also tried adding an empty constructor, just in case, but it didn't change anything either.

You should #include <memory> to use auto_ptr.

Ahah, thanks. I still get the same errors though.

There is an issue I see though. I have an auto_ptr to a Matrix, however it is impossible to have a class object of type Foo inside class Foo itself. I don't know how to get around of this..

A pointer to an object is not the same as an object directly.

How do the errors change if you replace the auto_ptr with a raw pointer, though? (Just out of interest.)

It doesn't change anything. I have tried right after posting. I knew that trick already but I think an auto_ptr<> is much more suited to my needs.

Basically what I want to do is have a temp object for when I don't want to modify a matrix but rather return a matrix derived from it. For example return a minor, its transposed matrix, upper triangle, lower triangle.. I also removed the static keyword which I don't even know why I put it there in the first place but still no changes... I can't even see what's wrong.. =/ Especially when I check what MSDN has to say about the first error:

http://msdn2.microsoft.com/en-us/library/wx7x0ezw.aspx

It's the typedef that's the source of your pain. This compiles with g++:

Code:

---

#ifndef MATRIX_H_INCLUDED
#define MATRIX_H_INCLUDED

#include <list>
#include <memory>

template <class T>
class Matrix
{
public:
        bool SquareMatrix( );
        static std::auto_ptr< Matrix<T> > Minor(const Matrix< T >&);
private:
        unsigned int Rows, Cols;
        std::list< std::list< T > > Data;
        std::auto_ptr< Matrix<T> > Temp;
};

template <class T>
bool Matrix< T >::SquareMatrix( )
{
        return (Rows == Cols);
}

template <class T>
std::auto_ptr< Matrix<T> > Matrix<T>::Minor(const Matrix<T>& m)
{
       
}

---

AFAIK, templates and typedefs don't play well together. You may just have to bite the bullet there...

Quote:

---

AFAIK, templates and typedefs don't play well together. You may just have to bite the bullet there...

---

Maybe not. I'm guessing that a typename might work some magic here:

Code:

---

#ifndef MATRIX_H_INCLUDED
#define MATRIX_H_INCLUDED

#include <list>
#include <memory>

template < class T >
class Matrix
{
public:
    typedef std::auto_ptr< Matrix< T > > MATRIX_PTR;
    bool SquareMatrix( );
    static MATRIX_PTR Minor(const Matrix< T >&);
private:
    unsigned int Rows, Cols;
    std::list< std::list< T > > Data;
    MATRIX_PTR Temp;
};

template < class T >
bool Matrix< T >::SquareMatrix( )
{
    return (Rows == Cols);
}

template < class T >
typename Matrix<T>::MATRIX_PTR Matrix< T >::Minor(const Matrix< T >& m)
{

}

#endif // MATRIX_H_INCLUDED

---

The typedef should be public since it is used in the public interface.

I already tried without typedef'ing and got the same errors. I also tried the typename trick and got the very same errors. I left the typedef public but it didn't change anything either. I tried cleaning and rebuilding the solution as well but the result is the same.

I have tried creating a completely new empty command line project and got the very same errors with the following code:

Code:

---

#ifndef MATRIX_H_INCLUDED
#define MATRIX_H_INCLUDED

#include <list>
#include <memory>

template < class T >
class Matrix
{
public:
        Matrix( ) { }

        bool SquareMatrix( );
        std::auto_ptr< Matrix< T > >& Minor(const Matrix< T >&);
private:
        unsigned int Rows, Cols;
        std::list< std::list< T > > Data;
        std::auto_ptr< Matrix< T > > Temp;
};

template < class T >
bool Matrix< T >::SquareMatrix( )
{
        return (Rows == Cols);
}

template < class T >
std::auto_ptr< Matrix< T > >& Matrix< T >::Minor(const Matrix< T >& m)
{
       
}

#endif // MATRIX_H_INCLUDED

---

I'm using MSVC++ 2003 under Windows XP Pro SP2, by the way.

Edit: I posted the question on another forum. If they have an answer, I'll let you guys know.

Works for me on VC++ 2003. Can you post your entire piece of code?

Code:

---

#include <iostream>
#include <list>
#include <memory>

static bool made_one = false;

template < class T >
class Matrix
{
public:
    Matrix( ) : Rows(2), Cols(2), Temp(0)
    {
        if (!made_one)
        {
            made_one = true;
            Temp.reset(new Matrix<T>());
        }
    }

    bool SquareMatrix( ) const;
    std::auto_ptr< Matrix< T > >& Minor(const Matrix< T >&);
private:
    unsigned int Rows, Cols;
    std::list< std::list< T > > Data;
    std::auto_ptr< Matrix< T > > Temp;
};

template < class T >
bool Matrix< T >::SquareMatrix( ) const
{
    return (Rows == Cols);
}

template < class T >
std::auto_ptr< Matrix< T > >& Matrix< T >::Minor(const Matrix< T >& m)
{
    if (m.Temp.get())
        return Temp;
    else if (Temp.get())
        return Temp->Temp;
    return Temp;
}

int main()
{
    Matrix<int> m1;
    Matrix<int> m2;
    if (m1.SquareMatrix() && m2.SquareMatrix())
    {
        std::auto_ptr< Matrix< int > >& ap = m1.Minor(m2);
        if (ap.get() == 0)
            std::cout << "Success!\n";
        else
            std::cout << "Failure!\n";
    }
}

---

With a typedef it works too:

Code:

---

#include <iostream>
#include <list>
#include <memory>

static bool made_one = false;

template < class T >
class Matrix
{
public:
    typedef std::auto_ptr< Matrix< T > > MATRIX_PTR;
    Matrix( ) : Rows(2), Cols(2), Temp(0)
    {
        if (!made_one)
        {
            made_one = true;
            Temp.reset(new Matrix<T>());
        }
    }

    bool SquareMatrix( ) const;
    MATRIX_PTR& Minor(const Matrix< T >&);
private:
    unsigned int Rows, Cols;
    std::list< std::list< T > > Data;
    MATRIX_PTR Temp;
};

template < class T >
bool Matrix< T >::SquareMatrix( ) const
{
    return (Rows == Cols);
}

template < class T >
typename Matrix< T >::MATRIX_PTR& Matrix< T >::Minor(const Matrix< T >& m)
{
    if (m.Temp.get())
        return Temp;
    else if (Temp.get())
        return Temp->Temp;
    return Temp;
}

int main()
{
    Matrix<int> m1;
    Matrix<int> m2;
    if (m1.SquareMatrix() && m2.SquareMatrix())
    {
        Matrix<int>::MATRIX_PTR& ap = m1.Minor(m2);
        if (ap.get() == 0)
            std::cout << "Success!\n";
        else
            std::cout << "Failure!\n";
    }
}

---

Your code works for me too. What did you change ?

Thanks a lot, by the way. =)

PS: I didn't have anything else. I just had a blank .cpp file which only included matrix.h so that it would compile the code.

I copied my old code into a new project and added an empty main() function and it compiled. Does anyone know why it does so ?

I put the code you posted just above mine into a project with an empty main, so it wasn't that code that was the problem. I just added stuff to make sure it compiles (if you don't use a template it won't always get run through the compiler).

I don't understand the errors you posted, so perhaps there is something wrong somewhere else in your original project that is causing strange parse errors. I dunno.

You tested it with an empty main, but when I tested it at first, I had no main() at all.

Alright, I'm done for today, I'll post it here for you guys so you can comment, criticize and suggest ideas. I haven't finished the Determinant() function. Right now it can only calculate determinants for matrice from 1x1 to 3x3 but no more since I haven't fully understood the LU decomposition method for faster calculation of determinants on large matrices.

Anyway, here's the code. I haven't fully tested it but most of it works (tested) :

Code:

---

#ifndef MATRIX_H_INCLUDED
#define MATRIX_H_INCLUDED

#include <iostream>
#include <vector>
#include <memory>

template < class T >
class Matrix
{
public:
    typedef std::auto_ptr< Matrix< T > > MATRIX_PTR;

    Matrix(int Cols = 0, int Rows = 0);

        void Output( )
        {
                for(int j = 0; j < Rows; j++)
                {
                        for(int i = 0; i < Cols; i++)
                        {
                                std::cout << Data[j][i];
                        }
                        std::cout << std::endl;
                }
        }

        void SetElement(int col, int row, T val);
        void InterchangeRows(int row_1, int row_2);
        void InterchangeCols(int col_1, int col_2);

        bool LowerTriangle( ) const;
        bool UpperTriangle( ) const;
    bool SquareMatrix( ) const;

        T Determinant( );

    MATRIX_PTR& Minor(int col, int row);
private:
        unsigned int Rows, Cols;
    std::vector< std::vector< T > > Data;
    MATRIX_PTR Temp;
};

template < class T >
Matrix< T >::Matrix< T >(int n_cols, int n_rows)
        : Cols(n_cols), Rows(n_rows)
{
        if(n_cols > 0 && n_rows > 0)
        {
                for(int i = 0; i < Rows; i++)
                {
                        Data.push_back(std::vector< T >( ));
                        Data[i].insert(Data[i].begin(), Cols, 0);
                }
        }
        else
        {
                Cols = Rows = 0;
        }
}

template < class T >
void Matrix< T >::SetElement(int col, int row, T val)
{
        if(col >= 0 && row >= 0)
        {
                Data[row][col] = val;
        }
}

template < class T >
void Matrix< T >::InterchangeRows(int row_1, int row_2)
{
        if(row_1 != row_2 && (row_1 >= 0 && row_2 >= 0))
        {
                Data[row_1].swap(Data[row_2]);
        }
}

template < class T>
void Matrix< T >::InterchangeCols(int col_1, int col_2)
{
        // Parentheses for easier reading only
        // Make sure both columns are different and range in [0, Cols[
        if((col_1 != col_2) && (col_1 >= 0) && (col_2 >= 0) && (col_1 < Cols) && (col_2 < Cols))
        {
                for(int j = 0; j < Rows; j++)
                {
                        T tmp = Data[j][col_1];
                        Data[j][col_1] = Data[j][col_2];
                        Data[j][col_2] = tmp;
                }
        }
}

template < class T >
bool Matrix< T >::LowerTriangle( ) const
{
        // Only square matrixes bigger than 0,0
        if(SquareMatrix() && (Cols != 0 && Rows != 0))
        {
                for(int j = 0; j < Rows; j++)
                {
                        for(int i = 0; i < Cols; i++)
                        {
                                if(i > j && Data[j][i] != 0)
                                {
                                        return false;
                                }
                        }
                }
        }
        else
        {
                return false;
        }
        return true;
}

template < class T >
bool Matrix< T >::UpperTriangle( ) const
{
        // Only square matrixes bigger than 0,0
        if(SquareMatrix() && (Cols != 0 && Rows != 0))
        {
                for(int j = 0; j < Rows; j++)
                {
                        for(int i = 0; i < Cols; i++)
                        {
                                if(i < j && Data[j][i] != 0)
                                {
                                        return false;
                                }
                        }
                }
        }
        else
        {
                return false;
        }
        return true;
}

template < class T >
bool Matrix< T >::SquareMatrix( ) const
{
    return (Rows == Cols);
}

template < class T >
T Matrix< T >::Determinant( )
{
        if(SquareMatrix( ))
        {
                if(Cols == 0 && Rows == 0)
                {
                        return static_cast< T >(0);
                }
                else if(Cols == 1 && Rows == 1)
                {
                        return Data[0][0];
                }
                else if(Cols == 2 && Rows == 2)
                {
                        return (Data[0][0] * Data[1][1] - Data[0][1] * Data[1][0]);
                }
                else if(Cols == 3 && Rows == 3)
                {
                        if(UpperTriangle( ) || LowerTriangle( ))
                        {
                                return (Data[0][0] * Data[1][1] * Data[2][2]);
                        }

                        return (Data[0][0] * Data[1][1] * Data[2][2] +
                                        Data[0][2] * Data[1][0] * Data[2][1] +
                                        Data[0][1] * Data[1][2] * Data[2][0] -
                                        Data[0][2] * Data[1][1] * Data[2][0] -
                                        Data[0][0] * Data[1][2] * Data[2][1] -
                                        Data[0][1] * Data[1][0] * Data[2][2]);
                }
                // Let's use the M = LU decomposition method for faster processing
                else
                {
                       
                }
        }
}

template < class T >
typename Matrix< T >::MATRIX_PTR& Matrix< T >::Minor(int col, int row)
{
        if(SquareMatrix( ) && (Rows != 0 && Cols != 0))
        {
                Temp.reset(new Matrix< T >);

                int y = 0;

                // Move horizontally then down in the matrix
                for(int j = 0; j < Rows; j++)
                {

                        if(j != row)
                        {
                                // We're on a new line...
                                Temp->Data.push_back(std::vector< T >( ));
                                for(int i = 0; i < Cols; i++)
                                {
                                        if(i != col)
                                        {
                                                (Temp->Data[y]).push_back(Data[j][i]);
                                        }
                                }
                                y++;
                        }
                }
        }

        Temp->Cols = Temp->Data[0].size();
        Temp->Rows = Temp->Data.size();
        return Temp;
}

#endif // MATRIX_H_INCLUDED

---

PS: The Output() function is there only for testing purposes, I will take it out when I have finished testing / implementing.

Thanks again !

some comments

Code:

---

template < class T >
class Matrix
{
public:

    Matrix(int Cols = 0, int Rows = 0);
private:
    unsigned int Rows, Cols;
};

template < class T >
Matrix< T >::Matrix< T >(int n_cols, int n_rows)
        : Cols(n_cols), Rows(n_rows)
{
        if(n_cols > 0 && n_rows > 0)
        {
                for(int i = 0; i < Rows; i++)
                {
                        Data.push_back(std::vector< T >( ));
                        Data[i].insert(Data[i].begin(), Cols, 0);
                }
        }
        else
        {
                Cols = Rows = 0;
        }
}

---

your constructor arguements Cols and Rows have different names in the implementation (n_cols, n_rows). This is legal but bad style. Cols and Rows are both members and arguements in the class def. Personally I like to differentiate members somehow (this->var, m_var, var_, whatever you like). are default arguements of 0 useful?

Also why are the arguements ints, but the members unsigned ints? surely the arguements should also be unsigned?

The else is redundant. Cols and Rows have already been initiated to 0 in your initialiser list.

you should reserve() your vectors since you know the size. It will increase efficiency.

Code:

---

        void SetElement(int col, int row, T val);
        void InterchangeRows(int row_1, int row_2);
        void InterchangeCols(int col_1, int col_2);

---

same comment about unsigned int parameters.


I won't comment on the matrix math since it's been a while since I used it in anger.

Code:

---

template < class T >
typename Matrix< T >::MATRIX_PTR& Matrix< T >::Minor(int col, int row)
{
    // snip...
    Temp.reset(new Matrix< T >);
    // snip...
    return Temp;
}

---

hmmm... this isn't really the best way to use auto_ptr.
consider the following

Code:

---

Matrix<float> agentSmith(666, 666);
MATRIX_PTR &neo = agentSmith.Minor();
// some code

MATRIX_PTR &trinity = agentSmith.Minor(); // arrghhh neo was killed!!

---

You should really return an auto_ptr (not a reference) and forget your Temp member. This will allow the client to take ownership of the minor matrix.

other than that, looks good. keep it up.

Thanks ! I'll fix that up when I get back from College this afternoon. I'll add a copy constructor as well and operators such as multiplication, addition, substraction, equality, assignment... I'd also like to make a function to calculate the order of the matrix (usually noted 'k'). I'll try to find the other thread where someone mentioned points that he/she'd like to have in a matrix library. I might as well make a vector class after.

Here we go, I quite a bit of stuff and I still need to work on determinants and more other stuff (making it possible to add vectors of numbers, adding scalar * matrix, adding matrix transpose...). I'm not completely satisfied with the design yet but it's not that ugly either.

Here it is:

Code:

---

#ifndef MATRIX_H_INCLUDED
#define MATRIX_H_INCLUDED

#include <iostream>
#include <vector>
#include <memory>

template < class T >
class Matrix
{
public:
    typedef std::auto_ptr< Matrix< T > > MATRIX_PTR;

    Matrix(unsigned int n_cols = 0, unsigned int n_rows = 0);
        Matrix(const Matrix& m);

        void Output( )
        {
                for(int j = 0; j < Rows; j++)
                {
                        for(int i = 0; i < Cols; i++)
                        {
                                std::cout << Data[j][i];
                        }
                        std::cout << std::endl;
                }
        }

        void SetElement(unsigned int col, unsigned int row, T val);
        void InterchangeRows(unsigned int row_1, unsigned int row_2);
        void InterchangeCols(unsigned int col_1, unsigned int col_2);

        bool LowerTriangle( ) const;
        bool UpperTriangle( ) const;
    bool SquareMatrix( ) const;

        T Determinant( );

        static MATRIX_PTR IdentityMatrix(unsigned int size);
        static MATRIX_PTR NullMatrix(unsigned int size);

    MATRIX_PTR Minor(unsigned int col, unsigned int row);

        Matrix< T >& operator = (const Matrix< T >&);
        Matrix< T >& operator += (const Matrix< T >&);
        Matrix< T >& operator -= (const Matrix< T >&);
        Matrix< T > operator * (const Matrix< T >&) const;
        Matrix< T > operator - (const Matrix< T >&) const;
        Matrix< T > operator + (const Matrix< T >&) const;
private:
        unsigned int Rows, Cols;
    std::vector< std::vector< T > > Data;
};

template < class T >
Matrix< T >::Matrix< T >(unsigned int n_cols, unsigned int n_rows)
        : Cols(n_cols), Rows(n_rows)
{
        if(Cols > 0 && Rows > 0)
        {
                Data.reserve(Rows);
                for(int i = 0; i < Rows; i++)
                {
                        Data.push_back(std::vector< T >( ));

                        Data[i].reserve(Cols);
                        Data[i].insert(Data[i].begin(), Cols, 0);
                }
        }
        else if(Cols < 0 && Rows < 0)
        {
                Cols = Rows = 0;
        }
}

template < class T >
Matrix< T >::Matrix< T >(const Matrix& m)
{
        *this = m;
}

template < class T >
void Matrix< T >::SetElement(unsigned int col, unsigned int row, T val)
{
        if(col >= 0 && row >= 0 && col < Cols && row < Rows)
        {
                Data[row][col] = val;
        }
}

template < class T >
void Matrix< T >::InterchangeRows(unsigned int row_1, unsigned int row_2)
{
        if(row_1 != row_2 && (row_1 >= 0 && row_2 >= 0))
        {
                Data[row_1].swap(Data[row_2]);
        }
}

template < class T>
void Matrix< T >::InterchangeCols(unsigned int col_1, unsigned int col_2)
{
        // Parentheses for easier reading only
        // Make sure both columns are different and range in [0, Cols[
        if((col_1 != col_2) && (col_1 >= 0) && (col_2 >= 0) && (col_1 < Cols) && (col_2 < Cols))
        {
                for(int j = 0; j < Rows; j++)
                {
                        T tmp = Data[j][col_1];
                        Data[j][col_1] = Data[j][col_2];
                        Data[j][col_2] = tmp;
                }
        }
}

template < class T >
bool Matrix< T >::LowerTriangle( ) const
{
        // Only square matrixes bigger than 0,0
        if(SquareMatrix() && (Cols != 0 && Rows != 0))
        {
                for(int j = 0; j < Rows; j++)
                {
                        for(int i = 0; i < Cols; i++)
                        {
                                if(i > j && Data[j][i] != 0)
                                {
                                        return false;
                                }
                        }
                }
        }
        else
        {
                return false;
        }
        return true;
}

template < class T >
bool Matrix< T >::UpperTriangle( ) const
{
        // Only square matrixes bigger than 0,0
        if(SquareMatrix() && (Cols != 0 && Rows != 0))
        {
                for(int j = 0; j < Rows; j++)
                {
                        for(int i = 0; i < Cols; i++)
                        {
                                if(i < j && Data[j][i] != 0)
                                {
                                        return false;
                                }
                        }
                }
        }
        else
        {
                return false;
        }
        return true;
}

template < class T >
bool Matrix< T >::SquareMatrix( ) const
{
    return (Rows == Cols);
}

template < class T >
T Matrix< T >::Determinant( )
{
        if(SquareMatrix( ))
        {
                if(Cols == 0 && Rows == 0)
                {
                        return static_cast< T >(0);
                }
                if(Cols == 1 && Rows == 1)
                {
                        return Data[0][0];
                }

                if(UpperTriangle( ) || LowerTriangle( ))
                {
                        int total = 1;
                        for(int i = 0; i < Cols; i++)
                        {
                                total *= Data[i][i];
                        }
                        return total;
                }

                if(Cols == 2 && Rows == 2)
                {
                        return (Data[0][0] * Data[1][1] - Data[0][1] * Data[1][0]);
                }
                if(Cols == 3 && Rows == 3)
                {
                        return (Data[0][0] * Data[1][1] * Data[2][2] +
                                        Data[0][2] * Data[1][0] * Data[2][1] +
                                        Data[0][1] * Data[1][2] * Data[2][0] -
                                        Data[0][2] * Data[1][1] * Data[2][0] -
                                        Data[0][0] * Data[1][2] * Data[2][1] -
                                        Data[0][1] * Data[1][0] * Data[2][2]);
                }
                // Let's use the M = LU decomposition method for faster processing
                else
                {
                       
                }
        }
}

template < class T >
typename Matrix< T >::MATRIX_PTR Matrix< T >::IdentityMatrix(unsigned int size)
{
        MATRIX_PTR tmp(new Matrix< T >(size, size));

        for(int j = 0; j < tmp->Rows; j++)
        {
                for(int i = 0; i < tmp->Cols; i++)
                {
                        tmp->Data[j][i] = i == j ? 1 : 0;
                }
        }

        return tmp;
}

template < class T >
typename Matrix< T >::MATRIX_PTR Matrix< T >::NullMatrix(unsigned int size)
{
        return MATRIX_PTR(new Matrix< T >(size, size));
}

template < class T >
typename Matrix< T >::MATRIX_PTR Matrix< T >::Minor(unsigned int col, unsigned int row)
{
        static MATRIX_PTR tmp;

        if(SquareMatrix( ) && (Rows != 0 && Cols != 0))
        {
                tmp.reset(new Matrix< T >);

                int y = 0;

                // Move horizontally then down in the matrix
                for(int j = 0; j < Rows; j++)
                {

                        if(j != row)
                        {
                                // We're on a new line...
                                tmp->Data.push_back(std::vector< T >( ));
                                for(int i = 0; i < Cols; i++)
                                {
                                        if(i != col)
                                        {
                                                (tmp->Data[y]).push_back(Data[j][i]);
                                        }
                                }
                                y++;
                        }
                }
                tmp->Cols = tmp->Data[0].size();
                tmp->Rows = tmp->Data.size();
        }

        return tmp;
}

template< class T >
Matrix< T >& Matrix< T >::operator = (const Matrix< T >& m)
{
        Rows = m.Rows;
        Cols = m.Cols;

        Data.assign(m.Data.begin(), m.Data.end());

        return *this;
}

template< class T >
Matrix< T >& Matrix< T >::operator += (const Matrix< T >& m)
{
        *this = *this + m;
        return *this;
}

template< class T >
Matrix< T >& Matrix< T >::operator -= (const Matrix< T >& m)
{
        *this = *this - m;
        return *this;
}

template< class T >
Matrix< T > Matrix< T >::operator * (const Matrix< T >& m) const
{
        // A Matrix A(a, b) and a matrix B(c, d) yield a matric C(b, c) when multiplied
        Matrix< T > tmp(Rows, m.Cols);

        if(Cols == m.Rows && Rows == m.Cols && Rows > 0 && Cols > 0)
        {
                for(int j_result = 0; j_result < Rows; j_result++)
                {
                        for(int i_result = 0; i_result < m.Cols; i_result++)
                        {
                                int sum = 0;
                                for(int j = 0, i = 0; j < m.Rows && i < Cols; j++, i++)
                                {
                                        sum += Data[j_result][i] * m.Data[j][i_result];
                                }
                                tmp.Data[j_result][i_result] = sum;
                        }
                }
        }

        return tmp;
}

template< class T >
Matrix< T > Matrix< T >::operator - (const Matrix< T >& m) const
{
        Matrix< T > tmp(Cols, Rows);

        if(Rows == m.Rows && Cols == m.Cols && Rows > 0 && Cols > 0)
        {
                for(int j = 0; j < Rows; j++)
                {
                        for(int i = 0; i < Cols; i++)
                        {
                                tmp.Data[j][i] = Data[j][i] - m.Data[j][i];
                        }
                }
        }

        return tmp;
}

template< class T >
Matrix< T > Matrix< T >::operator + (const Matrix< T >& m) const
{
        Matrix< T > tmp(Cols, Rows);

        if(Rows == m.Rows && Cols == m.Cols && Rows > 0 && Cols > 0)
        {
                for(int j = 0; j < Rows; j++)
                {
                        for(int i = 0; i < Cols; i++)
                        {
                                tmp.Data[j][i] = Data[j][i] + m.Data[j][i];
                        }
                }
        }

        return tmp;
}

#endif // MATRIX_H_INCLUDED

---