matrix.cpp

adaboost code in matlab

#include "matrix.h"
#include <iostream.h>
#include <stdlib.h>
#include <math.h>
#include <fstream.h>

#define AS_ZERO		0.0001

Matrix::Matrix(int r, int c)
{
	rows = r;
	cols = c;
	alloc();

	// initialize all elements to zero
	toZero();
}

// copy constructor //
Matrix::Matrix(const Matrix& m)
{
	rows = m.rows;
	cols = m.cols;
	alloc();

	for (int i = 0; i < rows; i++)
		for (int j = 0; j < cols; j++)
			element[i][j] = m.element[i][j];
}

// destructor //
Matrix::~Matrix(void)
{
	release();
//	cout << "Matrix is: " << this << endl;
//	cout << "destructor called" << endl;
}

// allocate memory on heap //
void Matrix::alloc(void)
{
	element = new T* [rows];
	for (int i = 0; i < rows; i++)
		element[i] = new T [cols]; 
}

// free heap memory //
void Matrix::release(void)
{
	for (int i = 0; i < rows; i++)
	{
		delete [] element[i];
		element[i]=0; 
	}
	delete [] element;
	element=0;
}

void Matrix::toZero(void)
{
	for (int i = 0; i < rows; i++)
		for (int j = 0; j < cols; j++)
			element[i][j] = 0;
}

void Matrix::zeros(int i, int j)
{
	for (int ii = 0; ii < rows; ii++)
		for (int jj = 0; jj < cols; jj++)
			element[ii][jj] = 0;
}

void Matrix::toOne(void)
{	
	for (int i = 0; i < rows; i++)
	for (int j = 0; j < cols; j++)
	element[i][j] = 1;
}

void Matrix::ones(int i, int j, T val, int scaler)
{
    for (int ii = 0; ii < i; ii++)
		for (int jj = 0; jj < j; jj++)
			element[ii][jj] = val / scaler;
}

void Matrix::print(void) const
{
	cout << *this;									// w/ << overloaded //
//	for (int i = 0; i < rows; i++)
//	{
//		for (int j = 0; j < cols; j++)
//			cout << element[i][j] << '\t';
//		cout << endl;
//	}
}

void Matrix::set(int i, int j, T val)
{
	//if(i>rows-1 || j>cols-1)
	//	reptError("Matrix subscript out of bound, set(i,j) failed!");
	    i=i-1;
    	element[i][j]=val;
}

void Matrix::setValue (int tt, T val)
{
	tt=tt-1;
	element[tt][0] = val;
}

// Get Value from matrix
int Matrix::getValue(int j,double *val, Matrix& m) const
{
	j=j-1;
	(*val) = m.element[0][j];
	return (0);
}

// Get Value from matrix
int Matrix::getValueSpecific(int i, int j,double *val, Matrix& m) const
{ 
	(*val) = m.element[i][j];
	return (0);
}

// overload subscript operator to access element[i][j] //
T Matrix::operator () (int i, int j) const
{
	if(i>rows-1 || j>cols-1)
		reptError("Matrix subscript out of bound, () failed!");
	return element[i][j];
}

// Take only part from the matrix
void Matrix::partOfMatrix(int r, int c, Matrix& m) const
{
   for (int i = 0; i < row(); i++)
		for (int j = 0; j < col(); j++)
			element[i][j] = m.element[i][j];
}

void Matrix::partOfMatrixNext(int r, int c, int step, Matrix& m) const
{
   int k=0;
   int i = step - r;
   for (i; i < step; i++){
	   for (int j = 0; j < col()-1; j++){
			element[k][j] = m.element[i][j];
	   }
	   k++;
   }
}

// Take only part from the matrix from end
void Matrix::partOfMatrixFromEnd(int r_train,int step,int c,Matrix& m) const
{
   int k=0;
   int i=r_train - step;
   for (i; i < r_train; i++){
	   for (int j = 0; j < col()-1; j++){
			element[k][j] = m.element[i][j];
	   }
	   k++;
   }
}

// This function return the matrix size
void Matrix::matrixSize(int *i, int *j, Matrix& m) const
{
   (*i) = m.rows;
   (*j) = m.cols;
}
// scalar minus matrix
void Matrix::ScalarMinusMatrix(double k, Matrix& m) const
{
   	int r=rows;
	int c=m.col();
	for (int i=0; i < r; i++)
	    for (int j=0; j < c; j++)
		    element[i][j] = k  - m.element[i][j];
}
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
// Take a specific part (coloum) from the matrix
void Matrix::specificPartOfMatrix(Matrix& m,int r, int c)
{
	//Matrix temp(r,r);
	int j = c;
	int k=0;
	for (int i = 0; i < row(); i++)
		element[i][k] = m.element[i][j];
}
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
// From matrix (Vector) to Array 
void Matrix::matrixToArray(double array[10], Matrix& m) const
{
	int r=rows;
	int c=cols; 
	for (int i = 0; i < r; i++)
	   for (int j=0; j < c; j++)
		    array[i]=m.element[i][j];
//	return array[10];
}
void Matrix::matrixToArray1(double array[10], Matrix& m) const
{
	int r=m.rows;
	int c=m.cols; 
	for (int i = 0; i < r; i++)
	   for (int j=0; j < c; j++)
		    array[i]=m.element[i][j];
//	return array[10];
}
// From matrix (Vector) to Array 
void Matrix::matrixToArrayold(double array[10], Matrix& m) const
{
	int r=rows;
	int c=m.col(); 
	int i = 0;
	for (int j=0; j < c; j++)
		    array[j]=m.element[i][j];
//	return array[10];
}

void Matrix::matrixExp(Matrix& m) const
{
   double dVal;
   int r=rows;
   int c=m.col();
   for (int i = 0; i < r; i++){
	   for (int j = 0; j < c; j++){
			dVal = m.element[i][j];
		    //dValue = fabs(dVal);
			element[i][j] = exp(dVal);
	   }
   }
}

void Matrix::matrixLog(Matrix& m) const
{
   double dVal;
   int r=rows;
   int c=m.col();
   for (int i = 0; i < r; i++){
	   for (int j = 0; j < c; j++){
			dVal = m.element[i][j];
		    //dValue = fabs(dVal);
			element[i][j] = log(dVal);
	   }
   }
}

void Matrix::matrixAbs(Matrix& m) const
{
   double dVal;
   //double dValue;
   for (int i = 0; i < row(); i++){
	   for (int j = 0; j < col(); j++){
			dVal = m.element[i][j];
		    //dValue = fabs(dVal);
			element[i][j] = fabs(dVal);
	   }
   }
}

int Matrix::matrixSumCol(double *sum,  Matrix& m) const
{
	int r=rows;
	int c=cols;
    for (int i = 0; i < r; i++)
		for (int j = 0; j < c-1; j++)
			(*sum) += m.element[i][j];
		
		return (0);		
}

int Matrix::matrixSumRow(double *sum,  Matrix& m) const
{
	int r=rows;
	int c=cols;
	for (int j = 0; j < c; j++){
		for (int i = 0; i < r; i++){
		    	(*sum) += m.element[i][j];
		}
	}
		
	return (0);		
}

// Compare between the current value and the perivues value
int Matrix::matrixCompareAndSet(int *i_index, int c_train, Matrix& m) const
{
	int r=rows;
	int c=m.col();
	Matrix temp(r, c);
	for (int i = 1; i < r; i++){
		for (int j = 0; j < c; j++){
            temp.element[i][j] = (m.element[i][j] - m.element[i-1][j]);
			if ((temp.element[i][j] == 0) && (m.element[i][j] > 0))
			{
				*i_index=*i_index+1;
				if (*i_index > (c_train -2))
				{
					*i_index=1;
				}
			}
			else
			{
			    *i_index=*i_index;			
			}
		}
	}
	return *i_index;
	
}

// Compare between the current value and the perivues value
int Matrix::matrixCompareAndSetfor_t(int k, int *t_index, int c_train, Matrix& m) const
{
	//int r=rows;
	int c=m.col();
	Matrix temp(k, c);
	for (int i = 1; i < k; i++){
		for (int j = 0; j < c; j++){
            temp.element[i][j] = (m.element[i][j] - m.element[i-1][j]);
			if ((temp.element[i][j] == 0) || (temp.element[i][j] == 1) && (m.element[i][j] > 0))
			{
				*t_index=*t_index-5;
				if (*t_index > 130)
				{
					*t_index=73;
				}
				if (*t_index < 70)
				{
					*t_index=127;
				}
			}
			else
			{
			    *t_index=*t_index;			
			}
		}
	}
	return *t_index;
	
}

// Find the max value of the matrix
int Matrix::matrixMax(double *val, int *index, Matrix& m) const
{
	int r=rows;
	int c=m.col();
	Matrix temp(r, c);
    int j,i;
    for (i = 0; i < r; i++){
		for (j = 0; j < c-1; j++){
			if (m.element[i][j] > m.element[i][j+1])
			{
				temp.element[i][j] = m.element[i][j];
				m.element[i][j]=m.element[i][j+1];
				m.element[i][j+1]=temp.element[i][j];
				if (m.element[i][j+1] > (*val))
				{
                  (*val) = m.element[i][j+1];
				  (*index) = j;
				}
				//temp.element[i][j] = m.element[i][j];
			    //(*val) = m.element[i][j];
				//(*index) = j;
			}
		//	else 
		//	{
		//		temp.element[i][j] = m.element[i][j+1];
		//		(*val) = m.element[i][j];
		//		(*index) = j;
		//	}
		}
	}
	return(0);
}

Matrix& Matrix::operator= (const Matrix& m)
{
	if(rows != m.row() || cols != m.col())
		reptError("Matrix dimensions differ, assignment failed!");

	for (int i = 0; i < m.row(); i++)
		for (int j = 0; j < m.col(); j++)
			element[i][j] = m.element[i][j];

	return *this;
}

istream& operator>> (istream& is, Matrix& m)
{
	for (int i=0; i < m.row(); i++)
		for (int j=0; j < m.col(); j++)
			is >> m.element[i][j];

	return is;
}

ostream& operator<< (ostream& os, const Matrix& m)
{
	for (int i=0; i<m.row(); i++)
	{
		for (int j=0; j<m.col(); j++)
			os << m.element[i][j] << '\t';
		os << endl;
	}
	os << endl;

	return os;
}

// logic equal to operation //
bool Matrix::operator== (const Matrix& m) const
{
	if (rows != m.row() || cols != m.col())
		return false;

	for (int i=0; i < rows; i++)
		for (int j=0; j < cols; j++)
			if (element[i][j] != m.element[i][j])
				return false;

	return true;
}

// logic not equal to operation //
bool Matrix::operator!= (const Matrix& m)
{
    return (*this == m) ? false : true;
}

// combined addition and assignment operator //
Matrix& Matrix::operator+= (const Matrix& m)
{
	if (rows != m.row() || cols != m.col())
		reptError("Matrix sizes mismatch, += failed!");

	for (int i=0; i < m.row(); i++)
		for (int j=0; j < m.col(); j++)
			element[i][j] += m.element[i][j];

   return *this;
}

// combined subtraction and assignment operator //
Matrix& Matrix::operator-= (const Matrix& m)
{
//	if (rows != m.row() || cols != m.col())
//		reptError("Matrix sizes mismatch, -= failed!");

	for (int i=0; i < m.row(); i++)
		for (int j=0; j < m.col(); j++)
			element[i][j] -= m.element[i][j];

   return *this;
}

// scalar Matrix multiplication
void Matrix::ScalarMultiMatrix (double scalar, Matrix& m)
{
	int r = rows;
	int c = cols;
	int k = 0;
	for (int j=0; j < c; j++)
		for (int i=0; i < r; i++)
			element[i][j] = scalar * m.element[i][k];
}

// Matrix Scalar multiplication
void Matrix::MatrixMultiScalar (double scalar, Matrix& m)
{
	int r = rows;
	//int c=m.col()+1;
	int c = cols + 1;
	//int k = 0;
	for (int i=0; i < r; i++)
		  for (int j=0; j < c; j++)
			element[i][j] = scalar * m.element[i][j];
}
// two matrix multiplication // 
void Matrix::MatrixMultiMatrix (const Matrix& m, const Matrix& n) const
{
	int r=m.rows;
	int c=m.col();
	Matrix temp(r, c);

	for (int i=0; i < r; i++)
	{
		for (int j=0; j < c; j++)
		{
			element[i][j] = n.element[i][j] * m.element[i][j];
			if(fabs(temp.element[i][j])<=AS_ZERO)
				temp.element[i][j]=0;			// round small # to zero
		}
	}
}

void Matrix::MatrixMultiMatrixCOL (const Matrix& m, const Matrix& n) const
{
	int r=n.rows;
	int c=n.col();
	Matrix temp(r, c);

	for (int i=0; i < r; i++)
	{
		for (int j=0; j < c; j++)
		{
			element[i][j] = n.element[i][j] * m.element[1][i];
			if(fabs(temp.element[i][j])<=AS_ZERO)
				temp.element[i][j]=0;			// round small # to zero
		}
	}                     
}

// matrix minux matrix  
void Matrix::matrixMinusMatrix (const Matrix& m, const Matrix& n) const
{
	int r=m.rows;
	//int c=m.cols + 1;
	int c=m.cols;
		  for (int j=0; j < c; j++)
			  for (int i=0; i < r; i++)
				  element[i][j] = n.element[i][j] - m.element[i][j];
}

// matrix minus scalar
void Matrix::matrixMinusSclar (double scalar, Matrix& m)
{
	int r=m.rows;
	int c=m.cols;
		  for (int j=0; j < c; j++)
			  for (int i=0; i < r; i++)
				  element[i][j] = m.element[i][j] - scalar;
}


// combined scalar multiplication and assignment operator //
Matrix& Matrix::operator*= (const T& c)
{
	for (int i = 0; i < rows; i++)
		for (int j = 0; j < cols; j++)
			element[i][j] *= c;

	return *this;
}