File content as of revision 0:3abd8c2d7c34:

#include "mbed.h"
#include "Matrix.h"

// Rows by Cols Matrix Constructor
Matrix::Matrix(int Cols, int Rows): _Cols(Cols), _Rows(Rows)
{
    _matrix.resize(_Rows);
    for( int i = 0; i < _Rows; i++ )
        _matrix[i].resize(_Cols);
}



// Defines the same parameters as 'base' Matrix
Matrix::Matrix(const Matrix &base): _Cols(base._Cols), _Rows(base._Rows)
{
    _matrix.resize(_Rows);
    for( int i = 0; i < _Rows; i++ )
        _matrix[i].resize(_Cols);
}



// Square Matrix Constructor
Matrix::Matrix(int square): _Cols(square), _Rows(square)
{
    _matrix.resize(_Rows);
    for( int i = 0; i < _Rows; i++ )
        _matrix[i].resize(_Cols);
}



// Default Constructor
Matrix::Matrix(){/*Intentionally left Blank*/}


//*****  OPERATORS ****//

// Overloaded Asign Operator
Matrix& Matrix::operator = ( const Matrix &rightM )
{
    if( *this != rightM )
    {
        this->_Rows = rightM._Rows;
        this->_Cols = rightM._Cols;

        this->_matrix.resize( rightM._Rows );
        for( int i = 0; i < rightM._Rows; i++ )
            this->_matrix [i].resize(rightM._Cols);

        for( int i = 0; i < _Rows; i++ )
            for( int j = 0; j < _Cols; j++ )
                this->_matrix[i][j] = rightM._matrix[i][j];

        return *this;
    }
    else
    {
        Matrix ret (*this);
        return ret;
    }
}


bool Matrix::operator == ( const Matrix& rightM )
{
    if( _Rows == rightM._Rows  &&  _Cols == rightM._Cols )
    {
        bool equal = false;

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

        return !equal;

    }else{  return false;  }
}


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


Matrix& Matrix::operator +=(const Matrix& rightM)
{
    if( _Rows == rightM._Rows  &&  _Cols == rightM._Cols )
    {
        for( int i = 0; i < _Rows; i++ )
            for( int j = 0; j < _Cols; j++ )
                _matrix[i][j] += rightM._matrix[i][j];

        return *this;

    }else{
        
        printf( "\nERROR\nDiferent Dimensions @ += Assignment\n" );
        
        //  Code below doesn't work!  I dunno why. But anyway at this point
        //  the program should break anyway.
        //
        //Matrix::Matrix error( 4 );
        //error.Clear();
        //return error;
     
    }
}


Matrix& Matrix::operator -=(const Matrix& rightM)
{
    if( _Rows == rightM._Rows  &&  _Cols == rightM._Cols )
    {
        for( int i = 0; i < _Rows; i++ )
            for( int j = 0; j < _Cols; j++ )
                _matrix[i][j] -= rightM._matrix[i][j];

        return *this;

    }else{
        printf( "\nERROR\nDiferent Dimensions @ -= Assignment\n" );
        
       // return rightM;
    }
}

const Matrix Matrix::operator +(const Matrix& rightM)
{
    Matrix result = *this;
    result += rightM;
    return result;
}

const Matrix Matrix::operator -(const Matrix& rightM)
{
    Matrix result = *this;
    result -= rightM;
    return result;
}

//------------------------------------------

//*** Method that return MATRIX objects ***//



Matrix Matrix::GetRow(Matrix mat, int Row)
{
    if( Row > mat._Rows )
    {
        printf( "WARNING: Row out of dimmensions @ GetRow().\nEmpty Matrix Returned\n" );
        Matrix err( 1 , mat._Cols );
        err.Clear();
        return err;
    }else{

        Matrix SingleRow( 1 , mat._Cols );

        for( int i = 0; i < mat._Cols; i++ )
            SingleRow._matrix[0][i] = mat._matrix[Row][i];

        return SingleRow;
    }
}



Matrix Matrix::GetCol(Matrix mat, int Col)
{
    if( Col > mat._Cols )
    {
        printf( "WARNING: Column out of dimmensions @ GetCol.\nEmpty matrix returned\n" );
        Matrix err( mat._Rows , 1 );
        err.Clear();
        return err;
    }else{

        Matrix SingleCol( mat._Rows, 1 );
        for(int i = 0; i < mat._Rows; i++ )
            SingleCol._matrix[i][0] = mat._matrix[i][Col];
        return SingleCol;
    }
}



Matrix Matrix::ToPackedVector()
{
    Matrix Shattered( ( this->_Rows * this->_Cols ) , 1 );

    int cont = 0;
    for( int i = 0; i < this->_Rows; i++ )
    {
        for( int j = 0; j < this->_Cols; j++ )
        {
            Shattered._matrix[0][cont] = this->_matrix[i][j];
            cont++;
        }
    }

    return Shattered;
}
//----------------------------------------------------

//*** Method returning BOOLEAN ***//




bool Matrix::isZero()
{
    bool zero = false;
    for( int i = 0; i < this->_Rows; i++ )
        for( int j = 0; j < this->_Cols; j++ )
            if( this->_matrix[i][j] != 0 )
                zero = zero || true;
    return !zero;
}



bool Matrix::isVector()
{
    if( this->_Rows == 1 || this->_Cols == 1 )
        return true;
    else
        return false;
}

//-------------------------------------

//*** Static Methods ***//

const bool Matrix::Equals( Matrix mat1, Matrix mat2 )
{
    if( mat1._Cols == mat2._Cols  &&  mat1._Rows == mat2._Rows )
    {
        bool equal = false;

        for( int i = 0; i < mat1._Rows; i++ )
            for( int j = 0; j < mat1._Cols; j++ )
                if( mat1._matrix[i][j] != mat2._matrix[i][j] )
                    equal = equal || true;

        return !equal;

    }else{
        printf( "ERROR: Diferent Size Matrices!\n" );
        printf( "mat1._Rows = %u\nmat1._Cols = %u\n",mat1._Rows, mat1._Cols );
        printf( "mat2._Rows = %u\nmat2._Cols = %u\n",mat2._Rows, mat2._Cols );;
        return false;
    }
}



Matrix Matrix::CreateColumnMatrix(int Cols)
{
    Matrix ColMatrix(1,Cols);
    return ColMatrix;
}



Matrix Matrix::CreateRowMatrix(int Rows)
{
    Matrix RowMatrix( Rows, 1);
    return RowMatrix;
}



void Matrix::Clone( const Matrix &Source, Matrix Receip )
{
    Receip._Cols = Source._Cols;
    Receip._Rows = Source._Rows;

    Receip._matrix.resize(Receip._Rows);
    for( int i = 0; i < Receip._Rows; i++ )
        Receip._matrix[i].resize(Receip._Cols);

    for( int i = 0; i < Receip._Rows; i++ )
       for( int j = 0; j < Receip._Cols; j++ )
           Receip._matrix[i][j] = Source._matrix[i][j];
}


void Matrix::DeleteRow(Matrix& Mat, int Row)
{
    --Row;

    if( Row > Mat._Rows )
    {
        printf("\nERROR:\nColumn out of Limits on DeleteCol()\n");
        
    }else{

        for( int i = Row; i < Mat._Rows - 1; i++ )
        
            for( int j = 0; j < Mat._Cols; j++ )
                Mat._matrix[i][j] = Mat._matrix[i+1][j];
        Mat._Rows--;
        Mat._matrix.resize(Mat._Rows);
    }
}



void Matrix::DeleteCol( Matrix &Mat, int Col)
{
    --Col; // Because of Column zero.

    if( Col > Mat._Cols )
    {
        printf("\nERROR:\nColumn out of Limits on DeleteCol()\n");
        
    }else{

        for( int i = 0; i < Mat._Rows; i++ )
            for( int j = Col; j < Mat._Cols; j++ )
                Mat._matrix[i][j] = Mat._matrix[i][j+1];

        // Decrease one column
        Mat._Cols--;

        //Erase last Column
        for( int i = 0; i < Mat._Rows; i++ )
            Mat._matrix[i].reserve(Mat._Cols);

    }
}

//---------------------------------------------------------------

//***  Methods returning nothing VOID ***//

void Matrix::Add(int Row, int Col, float number)
{
    if( Row > _Rows || Col > _Cols )
    {
        printf("\nERROR:\n@ Matrix::Add, Out of limits of Matrix\n");

    }else{
        _matrix[Row][Col] = number;
    }


}

void Matrix::Resize( int Rows, int Cols )
{
    this->_Rows = Rows;
    this->_Cols = Cols;
    this->_matrix.resize( _Rows );
    
    for( int i = 0; i< _Rows ; i++ )
        _matrix[i].resize(_Cols);
}


void Matrix::FillMatrix()
{
    for(int i = 0; i < _Rows; i++)
    {
        for(int j = 0; j < _Cols; j++)
        {
            printf( "Position [%u][%u]: ", i, j );
            float numero;
            scanf( "%f", &numero );
            printf("%.3f ", numero);
            this->Add( i, j, numero);
        }
        printf("\n");
    }
    printf("\n");
}


void Matrix::Clear()
{
    for( int i = 0; i < _Rows; i++ )
       for( int j = 0; j < _Cols; j++ )
           _matrix[i][j] = 0;
 }

void Matrix::print()
{
    for( int i = 0; i < _Rows; i++ )
    {
        for( int j = 0; j < _Cols; j++ )
        {
            printf( "%.3f, ",_matrix[i][j] );
        }
        printf( "\n" ); 
    }
}



float Matrix::Sum()
{
    float total;

    for( int i = 0; i < this->_Rows; i++ )
        for( int j = 0; j < this->_Cols; j++ )
            total += this->_matrix[i][j];
    return total;
}



float Matrix::GetNumber( int Row, int Col )
{
    return this->_matrix[Row][Col];
}


int Matrix::getRows(){ return this->_Rows; }

int Matrix::getCols(){ return this->_Cols; }