Diff: Matrix.cpp

Revision:

2:493402568a5e

Parent:

1:48f417da268e

Child:

3:589fb80932b5

--- a/Matrix.cpp	Mon Sep 26 03:23:35 2011 +0000
+++ b/Matrix.cpp	Thu Oct 20 23:42:13 2011 +0000
@@ -1,152 +1,60 @@
+/**
+ * @file: Matrix.cpp
+ * @author: Ernesto Palacios
+ * @brief: Source Code for the Matrix Class.
+ *
+ * Created on September 2011.
+ *
+ */
+
 #include "mbed.h"
 #include "Matrix.h"
 
-
 /// Rows by Cols Matrix Constructor
-Matrix::Matrix(int Rows, int Cols): _nCols(Cols), _nRows(Rows)
+Matrix::Matrix(int Rows, int Cols): _nRows(Rows), _nCols(Cols)
 {
     _matrix.resize(_nRows);
     for( int i = 0; i < _nRows; i++ )
         _matrix[i].resize(_nCols);
+
+    _pRow = 0;
+    _pCol = 0;
+
+    this->Clear();  //Make all elements zero by default.
 }
 
 
-/// Defines the same parameters as 'base' Matrix
-Matrix::Matrix(const Matrix &base): _nCols(base._nCols), _nRows(base._nRows)
+/// Copies one matrix into a new one
+Matrix::Matrix(const Matrix& base)
 {
+    _nCols = base._nCols;
+    _nRows = base._nRows;
+
+    _pRow  = base._pRow;
+    _pCol  = base._pCol;
+
     _matrix.resize(_nRows);
     for( int i = 0; i < _nRows; i++ )
         _matrix[i].resize(_nCols);
-}
 
-
-/// Square Matrix Constructor
-Matrix::Matrix(int square): _nCols(square), _nRows(square)
-{
-    _matrix.resize(_nRows);
     for( int i = 0; i < _nRows; i++ )
-        _matrix[i].resize(_nCols);
+        for( int j = 0; j < _nCols; j++ )
+            _matrix[i][j] = base._matrix[i][j];
 }
 
 
 /// Default Constructor
-Matrix::Matrix(){/*Intentionally left Blank*/}
-
-
-/************************************************************************/
-
-
-/// Overloaded Asign Operator. Resizes Matrix
-Matrix& Matrix::operator = ( const Matrix &rightM )
+Matrix::Matrix()
 {
-    if( *this != rightM )
-    {
-        this->_nRows = rightM._nRows;
-        this->_nCols = rightM._nCols;
-
-        this->_matrix.resize( rightM._nRows );
-        for( int i = 0; i < rightM._nRows; i++ )
-            this->_matrix [i].resize(rightM._nCols);
-
-        for( int i = 0; i < _nRows; i++ )
-            for( int j = 0; j < _nCols; j++ )
-                this->_matrix[i][j] = rightM._matrix[i][j];
-
-        return *this;
-
-    }else{
+    _nCols = 0;
+    _nRows = 0;
 
-        Matrix ret (*this);
-        return ret;
-    }
-}
-
-/// 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 );
+    _pRow = 0;
+    _pCol = 0;
+    
 }
 
-
-/// 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 @ += \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 @ -= \n" );
-        //Matrix error(4);
-        //error.Clear();
-        //return error;
-    }
-}
-
-
-/// Element by element Adition. Must be same sizes
-const Matrix Matrix::operator +(const Matrix& rightM)
-{
-    Matrix result = *this;
-    result += rightM;
-    return result;
-}
-
-
-/// Element by element Substraction. Must be same sizes
-const Matrix Matrix::operator -(const Matrix& rightM)
-{
-    Matrix result = *this;
-    result -= rightM;
-    return result;
-}
-
-/************************************************************************/
-
+/***********************************************************************/
 
 /// Returns true if matrix is full of zeros
 bool Matrix::isZero()
@@ -154,7 +62,7 @@
     bool zero = false;
     for( int i = 0; i < this->_nRows; i++ )
         for( int j = 0; j < this->_nCols; j++ )
-            if( this->_matrix[i][j] != 0 )
+            if( _matrix[i][j] != 0 )
                 zero = zero || true;
     return !zero;
 }
@@ -163,7 +71,7 @@
 /// Returns true if Matrix is Single Row ot Single Column.
 bool Matrix::isVector()
 {
-    if( this->_nRows == 1 || this->_nCols == 1 )
+    if( _nRows == 1 || _nCols == 1 )
         return true;
     else
         return false;
@@ -172,27 +80,30 @@
 /*************************************************************************/
 
 /// Returns all elements in Matrix as a single Row vector.
-Matrix Matrix::ToPackedVector()
+const Matrix Matrix::ToPackedVector( const Matrix& Mat )
 {
-    Matrix Shattered( ( this->_nRows * this->_nCols ) , 1 );
+    
+    Matrix Crushed( 1, Mat._nRows * Mat._nCols );
 
     int cont = 0;
-    for( int i = 0; i < this->_nRows; i++ )
-    {
-        for( int j = 0; j < this->_nCols; j++ )
+
+    for( int i = 0; i < Mat._nRows; i++ )
+        for( int j = 0; j < Mat._nCols; j++ )
         {
-            Shattered._matrix[0][cont] = this->_matrix[i][j];
+            Crushed._matrix[0][cont] = Mat._matrix[i][j];
             cont++;
         }
-    }
 
-    return Shattered;
+    Crushed._pRow = Crushed._nRows;
+    Crushed._pCol = Crushed._nCols;
+
+    return Crushed;
 }
 
-/***************************************************************************/
+
 
 /// Test elment-by-element. Prints detailed error.
-bool Matrix::Equals( const Matrix mat1, const Matrix mat2 )
+bool Matrix::Equals( const Matrix& mat1, const Matrix& mat2 )
 {
     if( mat1._nCols == mat2._nCols  &&  mat1._nRows == mat2._nRows )
     {
@@ -214,39 +125,7 @@
 }
 
 
-/// To Implicitly create a Single Column Matrix.
-Matrix Matrix::CreateColumnMatrix(int Cols)
-{
-    Matrix ColMatrix(1,Cols);
-    return ColMatrix;
-}
-
-
-/// To Implicitly create a Single Row Matrix.
-Matrix Matrix::CreateRowMatrix(int Rows)
-{
-    Matrix RowMatrix( Rows, 1);
-    return RowMatrix;
-}
-
-
-/// To implicitly Clone a Matrix. Although '=' works the same.
-void Matrix::Clone( const Matrix &Source, Matrix &Receip )
-{
-    Receip._nCols = Source._nCols;
-    Receip._nRows = Source._nRows;
-
-    Receip._matrix.resize(Receip._nRows);
-    for( int i = 0; i < Receip._nRows; i++ )
-        Receip._matrix[i].resize(Receip._nCols);
-
-    for( int i = 0; i < Receip._nRows; i++ )
-       for( int j = 0; j < Receip._nCols; j++ )
-           Receip._matrix[i][j] = Source._matrix[i][j];
-}
-
-
-/// To add (Insert) a Single Row to a Matrix. 
+/// To add (Insert) a Single Row to a Matrix.
 void Matrix::AddRow(Matrix& Mat, int Row)
 {
     --Row;
@@ -254,7 +133,7 @@
     if( Row > Mat._nRows + 1)
     {
         printf("\n\nERROR:\nRow out of Limits @ AddRow()\n");
-       
+
     }else{
 
        Mat._nRows++;
@@ -273,14 +152,14 @@
 
 
 /// To add (Insert) a single Column to a Matrix
-void Matrix::AddColumn( Matrix &Mat, int Col )
+void Matrix::AddColumn( Matrix& Mat, int Col )
 {
     --Col;
 
     if( Col > Mat._nCols + 1 )
     {
         printf("\n\nERROR:\nRow out of Limits on AddCol()\n");
-        
+
     }else{
 
 
@@ -300,20 +179,25 @@
 
 
 /// Delete a Single Column From Matrix.
-void Matrix::DeleteCol( Matrix &Mat, int Col)
+void Matrix::DeleteCol( Matrix& Mat, int Col)
 {
     --Col; // Because of Column zero.
 
     if( Col > Mat._nCols )
     {
         printf("\n\nERROR:\nColumn out of Limits @ DeleteCol()\n");
-            
+
     }else{
 
         for( int i = 0; i < Mat._nRows; i++ )
             for( int j = Col; j < Mat._nCols; j++ )
                 Mat._matrix[i][j] = Mat._matrix[i][j+1];
 
+        // If adressing last element of Column,
+        // wich no longer exists
+        if( Mat._pCol == Mat._nCols )
+            Mat._pCol--;
+
         // Decrease one column
         Mat._nCols--;
 
@@ -333,11 +217,11 @@
     if( Row > Mat._nRows )
     {
         printf("\n\nERROR:\nColumn out of Limits @ DeleteCol()\n");
-        
+
     }else{
 
         for( int i = Row; i < Mat._nRows - 1; i++ )
-        
+
             for( int j = 0; j < Mat._nCols; j++ )
                 Mat._matrix[i][j] = Mat._matrix[i+1][j];
         Mat._nRows--;
@@ -348,41 +232,50 @@
 /*****************************************************************************************/
 
 /// Extracts a single row form calling matrix and saves it to another matrix.
-void Matrix::ExportRow( int Row, Matrix &Mat )
+const Matrix Matrix::ExportRow( const Matrix& Mat, int row )
 {
-    --Row;
+    --row;
 
-    if( Row > this->_nRows )
+    if( row > Mat._nRows )
     {
-        printf( "\n\nWARNING: Row out of dimmensions @ GetRow\n"
+        printf( "\n\nERROR:\nRow out of dimmensions @ GetRow\n"
                 "Nothing Done.\n\n" );
 
     }else{
 
-        Matrix SingleRow( 1 , this->_nCols );
+        Matrix SingleRow( 1 , Mat._nCols );
         SingleRow.Clear();
         
-        for( int j = 0; j < this->_nCols; j++ )
-        SingleRow._matrix[0][j] = this->_matrix[Row][j];
-        
-        Mat = SingleRow;
+        for( int j = 0; j < Mat._nCols; j++ )
+	    SingleRow._matrix[0][j] = Mat._matrix[row][j];
+
+        SingleRow._pCol = SingleRow._nCols;
+        SingleRow._pRow = 0;
+
+        return SingleRow;
     }
 }
 
 
 /// Extracts a single column form calling matrix and saves it to another matrix.
-void Matrix::ExportCol( int Col, Matrix &Mat )
+const Matrix Matrix::ExportCol( const Matrix& Mat, int col )
 {
-    if( Col > this->_nCols )
+    --col;
+    
+    if( col > Mat._nCols )
     {
-        printf( "\n\nWARNING:\nCol out of dimmensions.\n"
+        printf( "\n\nERROR:\nColumn out of dimmensions.\n"
                 "Nothing Done.\n\n" );
     }else{
 
-        Matrix SingleCol( this->_nRows, 1 );
-        for(int i = 0; i < this->_nRows; i++ )
-            SingleCol._matrix[i][0] = this->_matrix[i][Col];
-        Mat = SingleCol;
+        Matrix SingleCol( Mat._nRows, 1 );
+        for(int i = 0; i < Mat._nRows; i++ )
+            SingleCol._matrix[i][0] = Mat._matrix[i][col];
+        
+        SingleCol._pCol = 0;
+        SingleCol._pRow = SingleCol._nRows;
+        
+        return SingleCol;
     }
 }
 
@@ -390,12 +283,16 @@
 /// Makes matrix Bigger!
 void Matrix::Resize( int Rows, int Cols )
 {
-    this->_nRows = Rows;
-    this->_nCols = Cols;
-    this->_matrix.resize( _nRows );
-    
+    _nRows = Rows;  //Decreases one because internally
+    _nCols = Cols; // Index starts at zero.
+
+    _matrix.resize( _nRows );
+
     for( int i = 0; i< _nRows ; i++ )
         _matrix[i].resize(_nCols);
+
+    _pRow = 0; // If matrix is resized the <<
+    _pCol = 0; // operator overwrites everything!
 }
 
 
@@ -415,6 +312,9 @@
         printf("\n");
     }
     printf("\n");
+
+    _pRow = _nRows;
+    _pCol = _nCols;
 }
 
 
@@ -439,19 +339,23 @@
     for( int i = 0; i < _nRows; i++ )
        for( int j = 0; j < _nCols; j++ )
            _matrix[i][j] = 0;
+
+    _pCol = 0;  // New data can be added
+    _pRow = 0;
 }
 
 /********************************************************************************/
 
+
 /// Inserts a Single element in a desired Position( Index starts at [1][1] );
 void Matrix::add(int Row, int Col, float number)
 {
     --Col; --Row;
-    
+
     if( Row > _nRows || Col > _nCols )
     {
         printf("\n\nERROR:\nOut of limits of Matrix @ mat.Add()");
-        
+
     }else{
         _matrix[Row][Col] = number;
     }
@@ -479,4 +383,4 @@
 
 
 /// Returns the number of Columns in Matrix.
-int Matrix::getCols(){ return this->_nCols; }
+int Matrix::getCols(){ return this->_nCols; }
\ No newline at end of file