tam.h

将C语言的常用程序集移植到VC开发环境的源代码

/************************************************
 Simple&Easy!
 This header file are coded for the convenience of
 TArray&TMatrix operations.
 It contains two classes,namely TArray & TMatrix.
 Expect bugs!
 Please use and enjoy, and let me know of any bugs/mods/improvements 
 that you have found/implemented and I will fix/incorporate them into 
 this file.
 Written by hujinshan@2002.12.23 Airforce Engineering University.				

************************************************/
/*** AM.h ***/
#ifndef AM_H_
#define AM_H_
#include <stdlib.h>
#include <time.h>
#include <string.h>

template <class T=double>
class TArray
{
protected:
	T* pdata;
	unsigned int length;
public:
	TArray();
	TArray(unsigned int);
	TArray(TArray const&);

	virtual ~TArray();

	void operator = (TArray&);
	TArray<T>& operator + (TArray&);
	TArray<T>& operator - (TArray&);
	
	T const& operator [] (unsigned int)const;
	T& operator [](unsigned int);

	T const* GetData() const;
	unsigned int GetLenght();
	void SetLength(unsigned int,bool=true);

};
////////////////////////////////////////////////////////////
//缺省构造函数
template <class T>
TArray<T>::TArray():pdata(new T[1]),length(1)
{
}
//数组构造函数
template <class T>
TArray<T>::TArray(unsigned int n):pdata(new T[n]),length(n)
{
}
//拷贝构造函数
template <class T>
TArray<T>::TArray(TArray<T> const& array):pdata(new T[array.length]),length(array.length)
{
	for(unsigned int i=0;i<length;i++)
		pdata[i]=array.pdata[i];
}
//析构函数
template <class T> TArray<T>::~TArray()
{
	delete []pdata;
}
//得到指向数组的指针变量
template <class T>T const* TArray<T>::GetData()const
{
	return pdata;
}
//得到数组长度
template <class T> unsigned int TArray<T>::GetLenght()
{
	return length;
}
//重载操作符
template <class T>TArray<T>& TArray<T>::operator + (TArray& array)
{
	if(array.length!=length)
		throw("Error: TArray do not match !");
	for(unsigned int i=0;i<length;i++)
		pdata[i]+=array[i];
	return *this;
}
template <class T>TArray<T>& TArray<T>::operator - (TArray& array)
{
	if(array.length!=length)
		throw("Error: TArray do not match !");
	for(unsigned int i=0;i<length;i++)
		pdata[i]-=array[i];
	return *this;
}
template <class T> void TArray<T>::operator = (TArray& array)
{
	if(array.length!=length)
		throw;
	for(unsigned int i=0;i<length;i++)
		pdata[i]=array[i];
	return;
}
//下标操作
template <class T> T const& TArray<T>::operator[](unsigned int position)const
{
	if(position>=length)
		throw("Error: TArray--Out_of_range!");
	return pdata[position];
}
template <class T> T& TArray<T>::operator[](unsigned int position)
{
	if(position>=length)
		throw("Error: TArray--Out_of_range!");
	return pdata[position];
}
//数组大小重新调整
template <class T> void TArray<T>::SetLength(unsigned int newLength,bool bCopyData)
{
	T* const pnewData=new T[newLength];
	unsigned int const min=length<newLength?length:newLength;
	if(bCopyData)
		for(unsigned int i=0;i<min;i++)
			pnewData[i]=pdata[i];
	delete []pdata;
	pdata=pnewData;
	length=newLength;
}
//*//*//*//*//*//*//*//*//*//*//*//*//*//*//*//*//*//*//*//*//*//*//*//
template <class T=double>
class TMatrix
{
protected:
	unsigned int numberOfRows;
	unsigned int numberOfColumns;
	TArray<T> array;
public:
	class Row
	{
		TMatrix<T>& matrix;
		unsigned int const row;
	public:
		Row (TMatrix<T>& _matrix,unsigned int _row):matrix(_matrix),row(_row){}
		T& operator [](unsigned int column)const
		{return matrix.Select(row,column);}
	};

	TMatrix();
	TMatrix(unsigned int, unsigned int);
	TMatrix(TMatrix<T>& mat);
	
	virtual ~TMatrix();

	T& Select(unsigned int, unsigned int);
	Row operator[](unsigned int);

	TMatrix<T>& operator + (TMatrix<T>& mat);
	TMatrix<T>& operator - (TMatrix<T>& mat);
	TMatrix<T>& operator * (TMatrix<T>& mat);
	bool operator == (TMatrix<T>& mat);

	TArray<T>& GetData();
	unsigned int GetNumberOfRows();
	unsigned int GetNumberOfColumns();
	bool LoadFromArray(double [],unsigned int,unsigned int);
	bool LoadFromString(char*,char,char);
	bool ResetMatrix(unsigned int, unsigned int);
	bool ReverseMatrix();
	void ZeroMatrix();
	void RandomMatrix(int max);
};
//-----------------------------------------
//缺省构造函数
template <class T>
TMatrix<T>::TMatrix():
	numberOfRows(1),numberOfColumns(1),
		array(1)
{//array[0]=0.0;
}

//构造函数
template <class T>
TMatrix<T>::TMatrix(unsigned int rows,unsigned int cols):
numberOfRows(rows),numberOfColumns(cols),array(rows*cols)
{//ZeroMatrix();
}
//拷贝构造函数
template <class T>
TMatrix<T>::TMatrix(TMatrix<T>& mat):
	numberOfRows(mat.numberOfRows),numberOfColumns(mat.numberOfColumns),
		array(mat.numberOfRows*mat.numberOfColumns)
{*this=mat;
}

template <class T>
TMatrix<T>::~TMatrix()
{
}

//重新调整矩阵大小
template <class T> bool TMatrix<T>::ResetMatrix(unsigned int rows, unsigned int cols)
{
	try{	
		TMatrix mat(*this);
		array.SetLength(rows*cols,false);
		if(numberOfRows<=rows&&numberOfColumns<=cols)
			for(unsigned int i=0;i<numberOfRows;i++)
			for(unsigned int j=0;j<numberOfColumns;j++)
				array[i*cols+j]=mat.Select(i,j);
		numberOfRows=rows;
		numberOfColumns=cols;//ZeroMatrix();
	}
	catch(...){return false;}
	return true;
}
//从数组导入数据
template <class T> bool TMatrix<T>::LoadFromArray(double a[],unsigned int rows, unsigned int cols)
{
	if(!ResetMatrix(rows,cols))
		return false;
	for(unsigned int i=0;i<rows;i++)
			for(unsigned int j=0;j<cols;j++)
				Select(i,j)=a[i*numberOfColumns+j];
	return true;
}
//从字符串导入数据
template <class T> bool TMatrix<T>::LoadFromString(char* str,char chSepOne=',',char chSepRow=';')
{
try{
	char buf[50];
	buf[0]='\0';
	if(chSepRow==chSepOne)
		throw("Sorry, the dividing symbols cannot be the same!");
	unsigned int i,j,nRows=0,nCols=0,nIndex=0;
	int pos,nTmp=-1;//pos为字符在字符串中的位置
	for(i=0;i<strlen(str);i++)
	{
		if((str[i]==chSepRow) || (i==strlen(str)-1))
		{
			nRows++;nCols++;
			if(nTmp==-1)
				nTmp=nCols;
			else if(nTmp!=nCols)
					throw("Sorry, the string is invalid!");
			if(i!=strlen(str)-1)
				nCols=0;
		}
		else if(str[i]==chSepOne)
				nCols++;
	}
	if(nTmp!=nCols)
		throw("Sorry, the string is invalid!");

	TArray<double> arrayTmp(nRows*nCols);
	unsigned int iA=0;
	ResetMatrix(nRows,nCols);
	char ch[2];
	for(i=0;i<strlen(str);i++)
		if(str[i]==chSepRow)
		{
			for(j=nIndex;j<i;j++)
				ch[0]=str[j],ch[1]='\0',strcat(buf,ch);
			pos=strcspn(buf,&chSepOne);
			if(pos<strlen(buf))
				strncpy(buf+pos," ",1);
			pos=strcspn(buf,&chSepRow);
			if(pos<strlen(buf))
				strncpy(buf+pos," ",1);
			arrayTmp[iA]=atof(buf);
			iA++;
			nIndex=i;buf[0]='\0';
		}
		else
		{	
			if(i==strlen(str)-1)//last char is not chSepRow
			{
				
				for(j=nIndex;j<i+1;j++)
					ch[0]=str[j],ch[1]='\0',strcat(buf,ch);
				pos=strcspn(buf,&chSepOne);
				if(pos<strlen(buf))
					strncpy(buf+pos, " ",1);
				pos=strcspn(buf,&chSepRow);
				if(pos<strlen(buf))
					strncpy(buf+pos," ",1);
				arrayTmp[iA]=atof(buf);
				iA++;
				buf[0]='\0';
				nRows++;nIndex=i;
			}
			else if(str[i]==chSepOne)
			{
				for(j=nIndex;j<i;j++)
				ch[0]=str[j],ch[1]='\0',strcat(buf,ch);
				pos=strcspn(buf,&chSepOne);
				if(pos<strlen(buf))
					strncpy(buf+pos, " ",1);
				pos=strcspn(buf,&chSepRow);
				if(pos<strlen(buf))
					strncpy(buf+pos," ",1);
				arrayTmp[iA]=atof(buf);
				iA++;
				nIndex=i;buf[0]='\0';
			}
		}
	for(i=0;i<numberOfRows;i++)
		for(j=0;j<numberOfColumns;j++)
			Select(i,j)=arrayTmp[i*numberOfColumns+j];
}
catch(...)
	{throw("Sorry, cannot load matrix from string! ");}
	return true;
}
//选取元素
template <class T> T& TMatrix<T>::Select(unsigned int i, unsigned int j)
{
	char ch[50];
	if(i>=numberOfRows)
	{	
		sprintf(ch,"Invalid row: %d",i);
		throw (ch);
	}
	if(j>=numberOfColumns)
	{
		sprintf(ch,"Invalid colum: %d",j);
		throw (ch);
	}
	return array[i*numberOfColumns+j];
}
template <class T> TArray<T>& TMatrix<T>::GetData()
{
	return array;
}
//得到行数
template <class T> unsigned int TMatrix<T>::GetNumberOfRows()
{
	return numberOfRows;
}
//得到列数
template <class T> unsigned int TMatrix<T>::GetNumberOfColumns()
{
	return numberOfColumns;
}
//下标操作
template <class T> TMatrix<T>::Row TMatrix<T>::operator [] (unsigned int row)//返回Row对象
{
	return Row(*this,row);
}
//重载操作符
template <class T> TMatrix<T>& TMatrix<T>::operator + (TMatrix<T>& mat)
{
	TMatrix mt=*this;
	if( (numberOfRows!=mat.numberOfRows)||
		(mat.numberOfColumns!=numberOfColumns) )
		throw("The matrices are not match!");
	for(unsigned int i=0;i<numberOfRows;i++)
		for(unsigned int j=0;j<numberOfColumns;j++)
			mt[i][j]+=mat[i][j];
	return mt;
}
template <class T> TMatrix<T>& TMatrix<T>::operator - (TMatrix<T>& mat)
{
	TMatrix mt=*this;
	if( (numberOfRows!=mat.numberOfRows)||
		(mat.numberOfColumns!=numberOfColumns) )
		throw("The matrices do not match!");
	for(unsigned int i=0;i<numberOfRows;i++)
		for(unsigned int j=0;j<numberOfColumns;j++)
			mt[i][j]-=mat[i][j];
	return 	mt;
}
template <class T> TMatrix<T>& TMatrix<T>::operator * (TMatrix<T>& mat)
{
	if(mat.numberOfRows!=numberOfColumns)
		throw("The matrices do not match!");
	TMatrix matRet(numberOfRows,mat.numberOfColumns);
	unsigned int i,j,l;
	double tmp;
	for (i=0; i<numberOfRows; i++)
		for (j=0; j<mat.numberOfColumns; j++)
		{
			tmp=0.0;
			for (l=0; l<numberOfColumns; l++)
				tmp=tmp+array[i*numberOfColumns+l]*(mat.Select(l,j));
			matRet[i][j]=tmp;
		}
	return matRet;
}
template <class T> bool TMatrix<T>::operator == (TMatrix<T>& mat)
{
	if( (numberOfRows!=mat.numberOfRows)||
		(mat.numberOfColumns!=numberOfColumns) )
		return false;
	for(unsigned int i=0;i<numberOfRows;i++)
		for(unsigned int j=0;j<numberOfColumns;j++)
			if(Select(i,j)!=mat[i][j])
				return false;
	return true;
}
//矩阵元素清零
template <class T> void TMatrix<T>::ZeroMatrix()
{
	for(unsigned int i=0;i<numberOfRows;i++)
			for(unsigned int j=0;j<numberOfColumns;j++)
				Select(i,j)=0;
}
template <class T> void TMatrix<T>::RandomMatrix(int max)
{
	srand( (unsigned)time( NULL ) );
	for(unsigned int i=0;i<numberOfRows;i++)
			for(unsigned int j=0;j<numberOfColumns;j++)
				Select(i,j)=rand()%max+1;
}
//实矩阵转置
template <class T> bool TMatrix<T>::ReverseMatrix()
{
	double tmp;
	try{
		if(numberOfRows!=numberOfColumns)
		{
			TArray<double> tmpArray(array);
			ResetMatrix(numberOfColumns,numberOfRows);
			for(unsigned int i=0;i<numberOfRows;i++)
				for(unsigned int j=0;j<numberOfColumns;j++)
					array[i*numberOfColumns+j]=tmpArray[j*numberOfRows+i];
		}
		else
		{
			for(unsigned int i=0;i<numberOfRows;i++)
				for(unsigned int j=0;j<numberOfColumns;j++)
					if(i>j)
					{
						tmp=array[i*numberOfColumns+j];
						array[i*numberOfColumns+j]=array[j*numberOfColumns+i];
						array[j*numberOfColumns+i]=tmp;
					}
		}return true;
	}
	catch(...)
	{return false;}
}
//------------------------------------------------------
#endif
//end of file