File content as of revision 3:589fb80932b5:

/**
 * @file Matrix.cpp
 * @author Ernesto Palacios
 * @brief Source Code for the Operator of Matrix Class.
 *
 * Created on September 2011.
 *
 */
#include "mbed.h"
#include "Matrix.h"

/// Overloaded Asign Operator. Resizes Matrix
Matrix& Matrix::operator = ( const Matrix& rightM )
{
    if (this != &rightM )
    {

         _nRows = rightM._nRows;
         _nCols = rightM._nCols;

         _matrix.resize( rightM._nRows );
         for( int i = 0; i < rightM._nRows; i++ )
             _matrix [i].resize(rightM._nCols);

         for( int i = 0; i < _nRows; i++ )
             for( int j = 0; j < _nCols; j++ )
                 _matrix[i][j] = rightM._matrix[i][j];
    }
     return *this;

}

/// Comapre element by element
bool Matrix::operator == ( const Matrix& rightM )
{
    if( _nRows == rightM._nRows  &&  _nCols == rightM._nCols )
    {
        bool equal = false;

        for( int i = 0; i < _nRows; i++ )
            for( int j = 0; j < _nCols; j++ )
                if( _matrix[i][j] != rightM._matrix[i][j] )
                    equal = equal || true;

        return !equal;

    }else{  return false;  }
}


/// Calls for '==' operator
bool Matrix::operator != ( const Matrix& rightM )
{
    return !( *this == rightM );
}


/// Matrices must be same size.
/// Element by element adition.
Matrix& Matrix::operator +=(const Matrix& rightM)
{
    if( _nRows == rightM._nRows  &&  _nCols == rightM._nCols )
    {
        for( int i = 0; i < _nRows; i++ )
            for( int j = 0; j < _nCols; j++ )
                _matrix[i][j] += rightM._matrix[i][j];

        return *this;

    }else{
        printf( "\n\nERROR\nDiferent Dimensions @ += operator\n" );
        //Matrix error(4);
        //error.Clear();
        //return error;
    }
}


/// Matrices must be same size.
/// Element by element Substraction
Matrix& Matrix::operator -=(const Matrix& rightM)
{
    if( _nRows == rightM._nRows  &&  _nCols == rightM._nCols )
    {
        for( int i = 0; i < _nRows; i++ )
            for( int j = 0; j < _nCols; j++ )
                _matrix[i][j] -= rightM._matrix[i][j];

        return *this;

    }else{
        printf( "\n\nERROR\nDiferent Dimensions @ -= operator \n" );
    }
}


Matrix& Matrix::operator *=( const Matrix& rightM )
{
    if( this->_nCols == rightM._nRows )
    {
        Matrix resultM ( this->_nRows, rightM._nCols );

        for( int i = 0; i < resultM._nRows; i++ )
            for( int j = 0; j < resultM._nCols; j++ )
                for( int m = 0; m < rightM._nRows; m++ )
                    resultM._matrix[i][j] += this->_matrix[i][m] * rightM._matrix[m][j];

        *this = resultM;
    }

    return *this;
}


Matrix& Matrix::operator *=(float number)
{
    for( int i = 0; i < _nRows; i++ )
            for( int j = 0; j < _nCols; j++ )
                _matrix[i][j] *= number;

    return *this;
}


const Matrix Matrix::operator -()
{
    Matrix result( _nRows, _nCols );

     for( int i = 0; i < _nRows; i++ )
           for( int j = 0; j < _nCols; j++ )
              result._matrix[i][j] = _matrix[i][j] * -1;

    return result;
}

/*****************************************************************************/

// Overload operators


const Matrix operator +=( Matrix& leftM, float number )
{
    for( int i = 0; i < leftM._nRows; i++ )
           for( int j = 0; j < leftM._nCols; j++ )
              leftM._matrix[i][j] += number;
    return leftM;
}


const Matrix operator -=( Matrix& leftM, float number )
{
    for( int i = 0; i < leftM._nRows; i++ )
           for( int j = 0; j < leftM._nCols; j++ )
              leftM._matrix[i][j] -= number;
    return leftM;
}


const Matrix operator +( const Matrix& leftM, const Matrix& rightM)
{
    if( leftM._nRows == rightM._nRows  &&  leftM._nCols == rightM._nCols )
    {
        Matrix result( leftM._nRows, leftM._nCols );

        for( int i = 0; i < leftM._nRows; i++ )
           for( int j = 0; j < leftM._nCols; j++ )
              result._matrix[i][j] = leftM._matrix[i][j] + rightM._matrix[i][j];

        return result;

    }else{
        printf( "\n\nERROR\nDiferent Dimensions @ + operator \n" );
        //Matrix error(4);
        //error.Clear();
        //return error;
    }
}


const Matrix operator +( const Matrix& leftM, float number )
{
    Matrix result( leftM._nRows, leftM._nCols );

    for( int i = 0; i < leftM._nRows; i++ )
        for( int j = 0; j < leftM._nCols; j++ )
            result._matrix[i][j] = leftM._matrix[i][j] + number;

    return result;
}


const Matrix operator +( float number, const Matrix& leftM )
{
    return ( leftM + number );
}


const Matrix operator -( const Matrix& leftM, const Matrix& rightM )
{
    if( leftM._nRows == rightM._nRows  &&  leftM._nCols == rightM._nCols )
    {
        Matrix result( leftM._nRows, leftM._nCols );

        for( int i = 0; i < leftM._nRows; i++ )
           for( int j = 0; j < leftM._nCols; j++ )
              result._matrix[i][j] = leftM._matrix[i][j] - rightM._matrix[i][j];

        return result;

    }else{
        printf( "\n\nERROR:\nDiferent Dimensions @ + operator \n" );

    }
}


const Matrix operator -( const Matrix& leftM, float number )
{
    Matrix result( leftM._nRows, leftM._nCols );

    for( int i = 0; i < leftM._nRows; i++ )
       for( int j = 0; j < leftM._nCols; j++ )
          result._matrix[i][j] = leftM._matrix[i][j] - number;

    return result;
}


const Matrix operator -( float number, const Matrix& leftM )
{
    return ( leftM - number );
}


const Matrix operator *( const Matrix& leftM, const Matrix& rightM )
{
    if( leftM._nCols == rightM._nRows )
    {
        Matrix resultM ( leftM._nRows, rightM._nCols );
        resultM.Clear();

        for( int i = 0; i < resultM._nRows; i++ )
            for( int j = 0; j < resultM._nCols; j++ )
                for( int m = 0; m < rightM._nRows; m++ )
                    resultM._matrix[i][j] += leftM._matrix[i][m] * rightM._matrix[m][j];

        return resultM;

    } else {

        printf("\n\nERROR:\nDiferent Dimension matrices @ * operator");
    }

}


const Matrix operator *( const Matrix& leftM, float number )
{
    Matrix result( leftM._nRows, leftM._nCols );

    for( int i = 0; i < leftM._nRows; i++ )
       for( int j = 0; j < leftM._nCols; j++ )
          result._matrix[i][j] = leftM._matrix[i][j] * number;

    return result;
}

const Matrix operator *( float number, const Matrix& leftM )
{
    return ( leftM * number );
}


Matrix& operator <<( Matrix& leftM, float number )
{
    if( leftM._pCol == leftM._nCols ) //end of Row
    {
        leftM._pCol = 0;
        leftM._pRow++;
    }
    if( leftM._pRow > leftM._nRows )
    {
        printf( "\n\nERROR:\nAssignment out of limits @ << operator" );
        return leftM;

    }else{

        leftM._matrix[ leftM._pRow ][ leftM._pCol ] = number;
        leftM._pCol++;

        return leftM;
    }
}