Dion de Greef
Niet af
Fork of
Matrix
by 
Ernesto Palacios
Diff: Matrix.cpp
- Revision:
- 1:48f417da268e
- Parent:
- 0:3abd8c2d7c34
- Child:
- 2:493402568a5e
--- a/Matrix.cpp Fri Sep 23 21:12:17 2011 +0000
+++ b/Matrix.cpp Mon Sep 26 03:23:35 2011 +0000
@@ -1,76 +1,75 @@
#include "mbed.h"
#include "Matrix.h"
-// Rows by Cols Matrix Constructor
-Matrix::Matrix(int Cols, int Rows): _Cols(Cols), _Rows(Rows)
+
+/// Rows by Cols Matrix Constructor
+Matrix::Matrix(int Rows, int Cols): _nCols(Cols), _nRows(Rows)
{
- _matrix.resize(_Rows);
- for( int i = 0; i < _Rows; i++ )
- _matrix[i].resize(_Cols);
+ _matrix.resize(_nRows);
+ for( int i = 0; i < _nRows; i++ )
+ _matrix[i].resize(_nCols);
}
-
-// Defines the same parameters as 'base' Matrix
-Matrix::Matrix(const Matrix &base): _Cols(base._Cols), _Rows(base._Rows)
+/// Defines the same parameters as 'base' Matrix
+Matrix::Matrix(const Matrix &base): _nCols(base._nCols), _nRows(base._nRows)
{
- _matrix.resize(_Rows);
- for( int i = 0; i < _Rows; i++ )
- _matrix[i].resize(_Cols);
+ _matrix.resize(_nRows);
+ for( int i = 0; i < _nRows; i++ )
+ _matrix[i].resize(_nCols);
}
-
-// Square Matrix Constructor
-Matrix::Matrix(int square): _Cols(square), _Rows(square)
+/// Square Matrix Constructor
+Matrix::Matrix(int square): _nCols(square), _nRows(square)
{
- _matrix.resize(_Rows);
- for( int i = 0; i < _Rows; i++ )
- _matrix[i].resize(_Cols);
+ _matrix.resize(_nRows);
+ for( int i = 0; i < _nRows; i++ )
+ _matrix[i].resize(_nCols);
}
-
-// Default Constructor
+/// Default Constructor
Matrix::Matrix(){/*Intentionally left Blank*/}
-//***** OPERATORS ****//
+/************************************************************************/
-// Overloaded Asign Operator
+
+/// Overloaded Asign Operator. Resizes Matrix
Matrix& Matrix::operator = ( const Matrix &rightM )
{
if( *this != rightM )
{
- this->_Rows = rightM._Rows;
- this->_Cols = rightM._Cols;
+ this->_nRows = rightM._nRows;
+ this->_nCols = rightM._nCols;
- this->_matrix.resize( rightM._Rows );
- for( int i = 0; i < rightM._Rows; i++ )
- this->_matrix [i].resize(rightM._Cols);
+ this->_matrix.resize( rightM._nRows );
+ for( int i = 0; i < rightM._nRows; i++ )
+ this->_matrix [i].resize(rightM._nCols);
- for( int i = 0; i < _Rows; i++ )
- for( int j = 0; j < _Cols; j++ )
+ 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
- {
+
+ }else{
+
Matrix ret (*this);
return ret;
}
}
-
+/// Comapre element by element
bool Matrix::operator == ( const Matrix& rightM )
{
- if( _Rows == rightM._Rows && _Cols == rightM._Cols )
+ if( _nRows == rightM._nRows && _nCols == rightM._nCols )
{
bool equal = false;
- for( int i = 0; i < _Rows; i++ )
- for( int j = 0; j < _Cols; j++ )
+ 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;
@@ -80,54 +79,56 @@
}
+/// 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( _Rows == rightM._Rows && _Cols == rightM._Cols )
+ if( _nRows == rightM._nRows && _nCols == rightM._nCols )
{
- for( int i = 0; i < _Rows; i++ )
- for( int j = 0; j < _Cols; j++ )
+ 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( "\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;
-
+ 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( _Rows == rightM._Rows && _Cols == rightM._Cols )
+ if( _nRows == rightM._nRows && _nCols == rightM._nCols )
{
- for( int i = 0; i < _Rows; i++ )
- for( int j = 0; j < _Cols; j++ )
+ 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( "\nERROR\nDiferent Dimensions @ -= Assignment\n" );
-
- // return rightM;
+ 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;
@@ -135,6 +136,8 @@
return result;
}
+
+/// Element by element Substraction. Must be same sizes
const Matrix Matrix::operator -(const Matrix& rightM)
{
Matrix result = *this;
@@ -142,60 +145,41 @@
return result;
}
-//------------------------------------------
-
-//*** Method that return MATRIX objects ***//
-
+/************************************************************************/
-Matrix Matrix::GetRow(Matrix mat, int Row)
+/// Returns true if matrix is full of zeros
+bool Matrix::isZero()
{
- 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;
- }
+ 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 )
+ zero = zero || true;
+ return !zero;
}
-
-Matrix Matrix::GetCol(Matrix mat, int Col)
+/// Returns true if Matrix is Single Row ot Single Column.
+bool Matrix::isVector()
{
- 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;
- }
+ if( this->_nRows == 1 || this->_nCols == 1 )
+ return true;
+ else
+ return false;
}
+/*************************************************************************/
-
+/// Returns all elements in Matrix as a single Row vector.
Matrix Matrix::ToPackedVector()
{
- Matrix Shattered( ( this->_Rows * this->_Cols ) , 1 );
+ Matrix Shattered( ( this->_nRows * this->_nCols ) , 1 );
int cont = 0;
- for( int i = 0; i < this->_Rows; i++ )
+ for( int i = 0; i < this->_nRows; i++ )
{
- for( int j = 0; j < this->_Cols; j++ )
+ for( int j = 0; j < this->_nCols; j++ )
{
Shattered._matrix[0][cont] = this->_matrix[i][j];
cont++;
@@ -204,60 +188,33 @@
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()
+/// Test elment-by-element. Prints detailed error.
+bool Matrix::Equals( const Matrix mat1, const Matrix mat2 )
{
- 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 )
+ if( mat1._nCols == mat2._nCols && mat1._nRows == mat2._nRows )
{
bool equal = false;
- for( int i = 0; i < mat1._Rows; i++ )
- for( int j = 0; j < mat1._Cols; j++ )
+ for( int i = 0; i < mat1._nRows; i++ )
+ for( int j = 0; j < mat1._nCols; 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 );;
+ printf( "\n\nERROR:\nDiferent Size Matrices!\n" );
+ printf( "mat1._nRows = %u\nmat1._nCols = %u\n",mat1._nRows, mat1._nCols );
+ printf( "mat2._nRows = %u\nmat2._nCols = %u\n",mat2._nRows, mat2._nCols );
return false;
}
}
-
+/// To Implicitly create a Single Column Matrix.
Matrix Matrix::CreateColumnMatrix(int Cols)
{
Matrix ColMatrix(1,Cols);
@@ -265,7 +222,7 @@
}
-
+/// To Implicitly create a Single Row Matrix.
Matrix Matrix::CreateRowMatrix(int Rows)
{
Matrix RowMatrix( Rows, 1);
@@ -273,106 +230,187 @@
}
-
-void Matrix::Clone( const Matrix &Source, Matrix Receip )
+/// To implicitly Clone a Matrix. Although '=' works the same.
+void Matrix::Clone( const Matrix &Source, Matrix &Receip )
{
- Receip._Cols = Source._Cols;
- Receip._Rows = Source._Rows;
+ Receip._nCols = Source._nCols;
+ Receip._nRows = Source._nRows;
- Receip._matrix.resize(Receip._Rows);
- for( int i = 0; i < Receip._Rows; i++ )
- Receip._matrix[i].resize(Receip._Cols);
+ 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._Rows; i++ )
- for( int j = 0; j < Receip._Cols; j++ )
+ for( int i = 0; i < Receip._nRows; i++ )
+ for( int j = 0; j < Receip._nCols; j++ )
Receip._matrix[i][j] = Source._matrix[i][j];
}
-void Matrix::DeleteRow(Matrix& Mat, int Row)
+/// To add (Insert) a Single Row to a Matrix.
+void Matrix::AddRow(Matrix& Mat, int Row)
{
--Row;
- if( Row > Mat._Rows )
+ if( Row > Mat._nRows + 1)
{
- printf("\nERROR:\nColumn out of Limits on DeleteCol()\n");
-
+ printf("\n\nERROR:\nRow out of Limits @ AddRow()\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);
+ Mat._nRows++;
+ Mat._matrix.resize( Mat._nRows );
+
+ Mat._matrix[ Mat._nRows - 1 ].resize( Mat._nCols );
+
+ for( int i = Mat._nRows - 1; i > Row; i-- )
+ for( int j = 0; j < Mat._nCols; j++ )
+ Mat._matrix[i][j] = Mat._matrix[i - 1][j];
+
+ for( int j = 0; j < Mat._nCols; j++ )
+ Mat._matrix[Row][j] = 0.0;
}
}
+/// To add (Insert) a single Column to a Matrix
+void Matrix::AddColumn( Matrix &Mat, int Col )
+{
+ --Col;
+ if( Col > Mat._nCols + 1 )
+ {
+ printf("\n\nERROR:\nRow out of Limits on AddCol()\n");
+
+ }else{
+
+
+ Mat._nCols++;
+ for( int i = 0; i < Mat._nRows; i++ )
+ Mat._matrix[i].resize( Mat._nCols );
+
+ for( int i = 0; i < Mat._nRows; i++ )
+ for( int j = Mat._nCols; j > Col; j-- )
+ Mat._matrix[i][j] = Mat._matrix[i][j - 1];
+
+ for( int i = 0; i < Mat._nRows; i++ )
+ Mat._matrix[i][Col] = 0.0;
+
+ }
+}
+
+
+/// Delete a Single Column From Matrix.
void Matrix::DeleteCol( Matrix &Mat, int Col)
{
--Col; // Because of Column zero.
- if( Col > Mat._Cols )
+ if( Col > Mat._nCols )
{
- printf("\nERROR:\nColumn out of Limits on DeleteCol()\n");
-
+ printf("\n\nERROR:\nColumn out of Limits @ DeleteCol()\n");
+
}else{
- for( int i = 0; i < Mat._Rows; i++ )
- for( int j = Col; j < Mat._Cols; j++ )
+ 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];
// Decrease one column
- Mat._Cols--;
+ Mat._nCols--;
//Erase last Column
- for( int i = 0; i < Mat._Rows; i++ )
- Mat._matrix[i].reserve(Mat._Cols);
+ for( int i = 0; i < Mat._nRows; i++ )
+ Mat._matrix[i].reserve(Mat._nCols);
}
}
-//---------------------------------------------------------------
+
+/// Delete a Single Row form Matrix
+void Matrix::DeleteRow(Matrix& Mat, int Row)
+{
+ --Row;
-//*** Methods returning nothing VOID ***//
+ if( Row > Mat._nRows )
+ {
+ printf("\n\nERROR:\nColumn out of Limits @ DeleteCol()\n");
+
+ }else{
-void Matrix::Add(int Row, int Col, float number)
+ 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--;
+ Mat._matrix.resize(Mat._nRows);
+ }
+}
+
+/*****************************************************************************************/
+
+/// Extracts a single row form calling matrix and saves it to another matrix.
+void Matrix::ExportRow( int Row, Matrix &Mat )
{
- if( Row > _Rows || Col > _Cols )
+ --Row;
+
+ if( Row > this->_nRows )
{
- printf("\nERROR:\n@ Matrix::Add, Out of limits of Matrix\n");
+ printf( "\n\nWARNING: Row out of dimmensions @ GetRow\n"
+ "Nothing Done.\n\n" );
}else{
- _matrix[Row][Col] = number;
+
+ Matrix SingleRow( 1 , this->_nCols );
+ SingleRow.Clear();
+
+ for( int j = 0; j < this->_nCols; j++ )
+ SingleRow._matrix[0][j] = this->_matrix[Row][j];
+
+ Mat = SingleRow;
}
-
-
-}
-
-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);
}
+/// Extracts a single column form calling matrix and saves it to another matrix.
+void Matrix::ExportCol( int Col, Matrix &Mat )
+{
+ if( Col > this->_nCols )
+ {
+ printf( "\n\nWARNING:\nCol 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;
+ }
+}
+
+
+/// Makes matrix Bigger!
+void Matrix::Resize( int Rows, int Cols )
+{
+ this->_nRows = Rows;
+ this->_nCols = Cols;
+ this->_matrix.resize( _nRows );
+
+ for( int i = 0; i< _nRows ; i++ )
+ _matrix[i].resize(_nCols);
+}
+
+
+/// Ask user for elemnts in Matrix
void Matrix::FillMatrix()
{
- for(int i = 0; i < _Rows; i++)
+ for(int i = 0; i < _nRows; i++)
{
- for(int j = 0; j < _Cols; j++)
+ for(int j = 0; j < _nCols; j++)
{
printf( "Position [%u][%u]: ", i, j );
float numero;
scanf( "%f", &numero );
printf("%.3f ", numero);
- this->Add( i, j, numero);
+ this->_matrix[i][j] = numero;
}
printf("\n");
}
@@ -380,48 +418,65 @@
}
-void Matrix::Clear()
-{
- for( int i = 0; i < _Rows; i++ )
- for( int j = 0; j < _Cols; j++ )
- _matrix[i][j] = 0;
- }
-
+/// Prints out Matrix.
void Matrix::print()
{
- for( int i = 0; i < _Rows; i++ )
+ for( int i = 0; i < _nRows; i++ )
{
- for( int j = 0; j < _Cols; j++ )
+ for( int j = 0; j < _nCols; j++ )
{
printf( "%.3f, ",_matrix[i][j] );
+
}
- printf( "\n" );
+ printf( "\n" );
}
}
+/// Fills matrix with zeros.
+void Matrix::Clear()
+{
+ for( int i = 0; i < _nRows; i++ )
+ for( int j = 0; j < _nCols; j++ )
+ _matrix[i][j] = 0;
+}
-float Matrix::Sum()
+/********************************************************************************/
+
+/// 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;
+ }
+}
+
+
+/// Adds all elements in matrix and returns the answer.
+float Matrix::sum()
{
float total;
- for( int i = 0; i < this->_Rows; i++ )
- for( int j = 0; j < this->_Cols; j++ )
+ for( int i = 0; i < this->_nRows; i++ )
+ for( int j = 0; j < this->_nCols; j++ )
total += this->_matrix[i][j];
return total;
}
+/// Returns the specified element. Index Starts at [1][1].
+float Matrix::getNumber( int Row, int Col )
+{ return this->_matrix[Row -1][Col - 1]; }
-float Matrix::GetNumber( int Row, int Col )
-{
- return this->_matrix[Row][Col];
-}
+/// Returns the number of Rows in Matrix.
+int Matrix::getRows(){ return this->_nRows; }
-int Matrix::getRows(){ return this->_Rows; }
-
-int Matrix::getCols(){ return this->_Cols; }
-
-
-
+/// Returns the number of Columns in Matrix.
+int Matrix::getCols(){ return this->_nCols; }