www.pudn.com > DLT.rar > Matrix.cpp, change:2008-03-21,size:41066b


// Matrix.cpp: implementation of the CMatrix class. 
// 
////////////////////////////////////////////////////////////////////// 
 
#include "stdafx.h" 
#include "Matrix.h" 
#include <math.h> 
 
#ifdef _DEBUG 
#undef THIS_FILE 
static char THIS_FILE[]=__FILE__; 
#define new DEBUG_NEW 
#endif 
 
////////////////////////////////////////////////////////////////////// 
// Construction/Destruction 
////////////////////////////////////////////////////////////////////// 
 
//功能:构造函数,初始化矩阵 
//参数:无 
//返回值:无 
CMatrix::CMatrix() 
{ 
	Initate(); 
} 
 
//功能:构造函数 
// 参数: 
//     OriginalMatrix:原始矩阵 
//返回值:无 
CMatrix::CMatrix(const CMatrix& OriginalMatrix) 
{ 
	//构造函数不能嵌套!! 
	Initate();//作为构造函数,它完全可以被第一步执行,所以总必须对自身的成员变量做初始化,此句必不可少!! 
	InitMatrix(OriginalMatrix.GetDataAddress(), OriginalMatrix.GetRowNumber(), OriginalMatrix.GetColumnNumber()); 
} 
 
//功能:构造函数,初始化矩阵 
//参数:pData: 矩阵数据首地址 
//      nRowNumber: 矩阵行数 
//      nColumnNumber: 矩阵列数 
//返回值:无 
CMatrix::CMatrix(const f8* pData, int4 i4RowNumber, int4 i4ColumnNumber) 
{ 
	Initate();//作为构造函数,它完全可以被第一步执行,所以总必须对自身的成员变量做初始化,此句必不可少!! 
	InitMatrix(pData, i4RowNumber, i4ColumnNumber); 
} 
 
//功能:构造函数,初始化元素为零的矩阵 
//参数:i4RowNumber: 矩阵行数 
//      i4ColumnNumber: 矩阵列数 
//返回值:无 
CMatrix::CMatrix(int4 i4RowNumber, int4 i4ColumnNumber) 
{ 
	m_pData = new f8[ i4RowNumber * i4ColumnNumber ]; 
	memset(m_pData, 0, sizeof(f8) * i4RowNumber * i4ColumnNumber); 
	//其他成员变量 
	m_i4RowNumber = i4RowNumber; 
	m_i4ColumnNumber = i4ColumnNumber; 
} 
 
CMatrix::~CMatrix() 
{ 
	delete [] m_pData; 
	m_pData = NULL; 
} 
 
 
//功能:初始化矩阵,所有为0 
//参数:无 
//返回值:无 
void CMatrix::Initate() 
{ 
	m_pData			 = NULL; 
	m_i4RowNumber	 = 0; 
	m_i4ColumnNumber = 0; 
} 
 
 
//功能:初始化矩阵 
//参数: 
//      pData:原始数据首地址 
//		i4RowNumber:矩阵行数 
//		i4ColumnNumber:矩阵列数 
//返回值:成功返回1,失败返回0,参数错误返回-100 
//注意:所有初始化函数或重载操作的根本函数!! 
////////////////////////////////////////////////////////////////////// 
int4 CMatrix::InitMatrix(const f8* pData,int4 i4RowNumber, int4 i4ColumnNumber) 
{ 
	if(!pData || i4RowNumber<=0 || i4ColumnNumber<=0) return 0; 
 
	//指针赋值 
	//1 如果原有空间和现在空间同大,即可直接赋值 
	//2 如果不同,即有两种情况:1、刚定义之矩阵,数据为空;2、有数据量不同的数据 
	if(m_i4RowNumber * m_i4ColumnNumber != i4RowNumber * i4ColumnNumber) 
	{ 
		delete []m_pData;//和原有数据断绝关系 
		m_pData = new f8[ i4RowNumber * i4ColumnNumber ]; 
		if(!m_pData) return 0; 
	} 
	memcpy( m_pData, pData, sizeof(f8) * i4RowNumber * i4ColumnNumber ); 
 
	//其他成员变量 
	m_i4RowNumber = i4RowNumber; 
	m_i4ColumnNumber = i4ColumnNumber; 
	return 1; 
} 
 
 
//功能:初始化空矩阵,开辟存储空间 
//参数: 
//		nRowNumber:矩阵行数 
//		nColumnNumber:矩阵列数 
//返回值:成功返回1,失败返回0,参数错误返回-100 
int4 CMatrix::InitEmptyMatrix(int4 i4RowNumber, int4 i4ColumnNumber) 
{ 
	if(i4RowNumber<=0 || i4ColumnNumber<=0) return 0; 
	 
	if(m_i4RowNumber * m_i4ColumnNumber != i4RowNumber * i4ColumnNumber)//是否需要增减空间 
	{ 
		delete []m_pData;//和原有数据断绝关系 
		m_pData = new f8[ i4RowNumber * i4ColumnNumber ]; 
		if(!m_pData) return 0; 
	} 
	m_i4RowNumber	= i4RowNumber; 
	m_i4ColumnNumber = i4ColumnNumber; 
	return 1; 
} 
 
 
//功能:初始化零矩阵 
//参数: 
//		nRowNumber:矩阵行数 
//		nColumnNumber:矩阵列数 
//返回值:成功返回1,失败返回0,参数错误返回-100 
int4 CMatrix::InitZeroMatrix(int4 i4RowNumber,int4 i4ColumnNumber) 
{ 
	if(i4RowNumber<=0 || i4ColumnNumber<=0) return 0; 
 
	InitEmptyMatrix(i4RowNumber, i4ColumnNumber); 
	memset(m_pData, 0, sizeof(f8) * i4RowNumber * i4ColumnNumber); 
 
	return 1; 
} 
 
//功能: 将矩阵清零 
//参数:无 
//返回值:成功返回1 
int4 CMatrix::Dump() 
{ 
	if(!m_pData)  
	{ 
		delete [] m_pData;//和原有数据断绝关系 
		m_pData = NULL; 
	} 
	m_i4RowNumber    = 0; 
	m_i4ColumnNumber = 0; 
	return 1; 
} 
 
//功能:获取矩阵首地址 
//参数: 
//        pDestiData :目标地址 
//返回值:1 
//注意:pDestiData必须为有效空间的首地址!! 
int4 CMatrix::GetData(f8* pDestiData) const 
{ 
	memcpy(pDestiData, m_pData, sizeof(f8) * m_i4RowNumber * m_i4ColumnNumber); 
 
	return 1; 
} 
 
//功能:返回矩阵的首地址 
//参数:无 
//返回值:矩阵的首地址 
//注意:这是一个非常危险的函数,它返回矩阵的首地址,这样用户就可能损坏此矩阵数据!! 
f8* CMatrix::GetDataAddress() const 
{  
	return m_pData;  
} 
 
//功能:得到原有矩阵的逆矩阵,原矩阵不变,效率高 
/*参数: 
		maInverse :结果矩阵 
返回值:成功 1 失败 0*/ 
int4 CMatrix::GetInverseMatrix(CMatrix& maInverse)const 
{ 
	if( m_i4RowNumber != m_i4ColumnNumber) return 0; 
 
	maInverse = *this; 
	this->InversMatrix(maInverse.GetDataAddress(),m_i4RowNumber); 
 
	return 1; 
} 
 
//功能:得到原有矩阵的逆矩阵,原矩阵不变,效率低,但是使用方便 
/*参数:无 
返回值:成功返回一个有效CMatrix对象,失败返回空矩阵*/ 
CMatrix CMatrix::GetInverseMatrix()const 
{ 
	CMatrix TmpMatrix; 
	if( m_i4RowNumber != m_i4ColumnNumber) return TmpMatrix;//如果不为方阵,则返回空阵 
 
	TmpMatrix = *this; 
	this->InversMatrix(TmpMatrix.GetDataAddress(),m_i4RowNumber); 
 
	return TmpMatrix; 
} 
 
//功能:原有矩阵求逆 
/*参数:无 
返回值:成功 1 失败 0*/ 
int4 CMatrix::Inverse() 
{ 
	if(m_i4RowNumber != m_i4ColumnNumber) return 0; 
	this->InversMatrix(m_pData, m_i4RowNumber); 
 
	return 1; 
} 
 
//功能:得到原有矩阵的转置矩阵,原矩阵不变,效率高 
/*参数: 
		maTransposed :结果矩阵 
返回值:成功 1 失败 0*/ 
int4 CMatrix::GetTransposedMatrix(CMatrix& maTransposed)const 
{ 
	maTransposed.InitEmptyMatrix(m_i4ColumnNumber,m_i4RowNumber); 
	Transpose(m_pData,maTransposed.GetDataAddress(),m_i4RowNumber,m_i4ColumnNumber); 
	 
	return 1; 
} 
 
//功能:得到原有矩阵的转置矩阵,原矩阵不变,效率低,但是使用方便 
/*参数:无 
返回值:成功返回一个有效CMatrix对象,失败返回空矩阵*/ 
CMatrix CMatrix::GetTransposedMatrix()const 
{ 
	CMatrix TmpMatrix;	TmpMatrix.InitEmptyMatrix(m_i4ColumnNumber,m_i4RowNumber); 
	Transpose(m_pData,TmpMatrix.GetDataAddress(),m_i4RowNumber,m_i4ColumnNumber); 
	 
	return TmpMatrix; 
} 
 
 
 
//功能:原有矩阵转置 
//返回:成功 1 失败 0 
int4 CMatrix::Transpose() 
{ 
	f8* pf8Tmp = new f8[m_i4RowNumber * m_i4ColumnNumber]; 
	Transpose(m_pData, pf8Tmp, m_i4RowNumber, m_i4ColumnNumber); 
	delete []m_pData; 
	m_pData = pf8Tmp; 
 
	//行列交换 
	int4 i4Tmp = m_i4RowNumber; 
	m_i4RowNumber = m_i4ColumnNumber; 
	m_i4ColumnNumber = i4Tmp; 
 
	return 1; 
} 
 
//功能:得到原有矩阵的四舍五入整数矩阵,原矩阵不变 
//返回:成功 1 失败 0 
int4 CMatrix::GetRoundMatrix(CMatrix& maTransposed)const 
{ 
	maTransposed.InitEmptyMatrix(m_i4RowNumber, m_i4ColumnNumber); 
	f8* pf8Tmp = maTransposed.GetDataAddress(); 
	for(int4 i=0; i<m_i4RowNumber*m_i4ColumnNumber; i++) 
	{ 
		pf8Tmp[i] = round(m_pData[i]); 
	} 
	return 1; 
} 
 
//功能:得到原有矩阵的四舍五入整数矩阵,原矩阵不变 
//返回:成功返回一个有效CMatrix对象,失败返回空矩阵 
CMatrix CMatrix::GetRoundMatrix()const 
{ 
	CMatrix maTransposed(m_i4RowNumber, m_i4ColumnNumber); 
	f8* pf8Tmp = maTransposed.GetDataAddress(); 
	for(int4 i=0; i<m_i4RowNumber*m_i4ColumnNumber; i++) 
	{ 
		pf8Tmp[i] = round(m_pData[i]); 
	} 
	return maTransposed; 
} 
 
//功能:原有矩阵四舍五入,变成整数矩阵 
//返回:成功 1 失败 0 
int4 CMatrix::Round() 
{ 
	for(int4 i=0; i<m_i4RowNumber*m_i4ColumnNumber; i++) 
	{ 
		m_pData[i] = round(m_pData[i]); 
	} 
	return 1; 
} 
 
 
//功能:得到原有矩阵的左上角子矩阵,原矩阵不变,效率高 
/*参数: 
i4SubRowNumber:	新矩阵的行数 
i4SubColumnNumber:	新矩阵的列数 
maSubMatrix:		结果矩阵 
返回值:成功返回一个有效CMatrix对象,失败返回空矩阵*/ 
int4 CMatrix::GetLeftTopSubMatrix(int4 i4SubRowNumber, int4 i4SubColumnNumber, CMatrix& maSubMatrix)const 
{ 
	if(i4SubRowNumber>m_i4RowNumber || i4SubColumnNumber>m_i4ColumnNumber) return 0; 
	 
	maSubMatrix.InitEmptyMatrix(i4SubRowNumber, i4SubColumnNumber); 
	for(int4 i=0; i<i4SubRowNumber; i++) 
	{ 
		memcpy(maSubMatrix.GetDataAddress() + i * i4SubColumnNumber, m_pData + i * m_i4ColumnNumber, i4SubColumnNumber * sizeof(f8)); 
	} 
	 
	return 1; 
} 
 
//功能:得到原有矩阵的左上角子矩阵,原矩阵不变,效率低,但是使用方便 
/*参数: 
i4SubRowNumber:	新矩阵的行数 
i4SubColumnNumber:	新矩阵的列数 
返回值:成功返回一个有效CMatrix对象,失败返回空矩阵*/ 
CMatrix CMatrix::GetLeftTopSubMatrix(int4 i4SubRowNumber,int4 i4SubColumnNumber)const 
{ 
	CMatrix maResult; 
	if(i4SubRowNumber>m_i4RowNumber || i4SubColumnNumber>m_i4ColumnNumber) return maResult; 
	 
	maResult.InitEmptyMatrix(i4SubRowNumber, i4SubColumnNumber); 
	for(int4 i=0; i<i4SubRowNumber; i++) 
	{ 
		memcpy(maResult.GetDataAddress() + i * i4SubColumnNumber, m_pData + i * m_i4ColumnNumber, i4SubColumnNumber * sizeof(f8)); 
	} 
	 
	return maResult; 
} 
 
//功能:得到原有矩阵的任意位置子阵,原矩阵不变,效率低,但是使用方便 
/*参数: 
i4BeginRowNo:		子阵在原有矩阵中的起始行号,从0起算 
nSubRowNumber:		新矩阵的行数 
nBeginColumnNo:		子阵在原有矩阵中的起始列号,从0起算 
nSubColumnNumber:	新矩阵的列数 
maSubMatrix			结果矩阵 
返回值:1 成功;0 失败*/ 
int4 CMatrix::GetSubMatrix(int4 i4BeginRowNo, int4 i4SubRowNumber, int4 i4BeginColumnNo, int4 i4SubColumnNumber, CMatrix& maSubMatrix)const 
{ 
	if(i4BeginRowNo + i4SubRowNumber > m_i4RowNumber 
		|| i4BeginColumnNo + i4SubColumnNumber > m_i4ColumnNumber) return 0; 
	 
	maSubMatrix.InitEmptyMatrix(i4SubRowNumber, i4SubColumnNumber);	 
	for(int4 i=0; i<i4SubRowNumber; i++) 
	{ 
		memcpy(maSubMatrix.GetDataAddress() + i * i4SubColumnNumber, m_pData + (i4BeginRowNo+i) * m_i4ColumnNumber + i4BeginColumnNo, i4SubColumnNumber * sizeof(f8)); 
	} 
	 
	return 1;	 
} 
 
//功能:得到原有矩阵的任意位置子阵,原矩阵不变,效率低,但是使用方便 
/*参数: 
nBeginRowNo:		子阵在原有矩阵中的起始行号,从0起算 
nSubRowNumber:		新矩阵的行数 
nBeginColumnNo:		子阵在原有矩阵中的起始列号,从0起算 
nSubColumnNumber:	新矩阵的列数 
返回值:成功返回一个有效CMatrix对象,失败返回空矩阵*/ 
CMatrix CMatrix::GetSubMatrix(int4 i4BeginRowNo, int4 i4SubRowNumber, int4 i4BeginColumnNo, int4 i4SubColumnNumber)const 
{ 
	CMatrix maResult; 
	if(i4BeginRowNo + i4SubRowNumber > m_i4RowNumber 
		|| i4BeginColumnNo + i4SubColumnNumber > m_i4ColumnNumber) return maResult; 
	 
	maResult.InitEmptyMatrix(i4SubRowNumber, i4SubColumnNumber);	 
	for(int4 i=0; i<i4SubRowNumber; i++) 
	{ 
		memcpy(maResult.GetDataAddress() + i * i4SubColumnNumber, m_pData + (i4BeginRowNo+i) * m_i4ColumnNumber + i4BeginColumnNo, i4SubColumnNumber * sizeof(f8)); 
	} 
	 
	return maResult; 
} 
 
 
//功能:矩阵相加运算 
//参数:maRight		被加数 
//		maResult	相加后的结果矩阵 
//返回值:1 成功;0 失败 
//使用示例:A.AddMatrix(B,C) 意为: C中的元素为A、B中元素之和 
int4 CMatrix::AddMatrix(CMatrix& maRight, CMatrix& maResult)const 
{ 
	//行、列不相等的矩阵不能相加 
	if((m_i4RowNumber != maRight.m_i4RowNumber) || (m_i4ColumnNumber != maRight.m_i4ColumnNumber)) return 0; 
 
	int4 i4ElementNumber = m_i4RowNumber * m_i4ColumnNumber; 
	maResult.InitMatrix(m_pData, m_i4RowNumber, m_i4ColumnNumber); 
 
	for(int4 i=0; i<i4ElementNumber; i++) 
	{ 
		maResult.m_pData[i] += maRight.m_pData[i]; 
	} 
	 
	return 1; 
} 
 
//功能:矩阵相减运算 
//参数:maRight		被减数 
//		maResult	相减后的结果矩阵 
//返回值:1 成功;0 失败 
//使用示例:A.SubMatrix(B,C) 意为: C中的元素为A、B中元素之差 
int4 CMatrix::SubMatrix(CMatrix& maRight, CMatrix& maResult)const 
{ 
	//行、列不相等的矩阵不能相加 
	if((m_i4RowNumber != maRight.m_i4RowNumber) || (m_i4ColumnNumber != maRight.m_i4ColumnNumber)) return 0; 
	 
	int4 i4ElementNumber = m_i4RowNumber * m_i4ColumnNumber; 
	maResult.InitMatrix(m_pData, m_i4RowNumber, m_i4ColumnNumber); 
	 
	for(int4 i=0; i<i4ElementNumber; i++) 
	{ 
		maResult.m_pData[i] -= maRight.m_pData[i]; 
	} 
	 
	return 1; 
} 
 
//功能:矩阵相乘运算 
//参数:maRight		被乘数 
//		maResult	相乘后的结果矩阵 
//返回值:1 成功;0 失败 
//使用示例:A.MultiplyMatrix(B,C) 意为: C中的元素为A、B中元素之积 
int4 CMatrix::MultiplyMatrix(CMatrix& maRight, CMatrix& maResult)const 
{ 
	if(m_i4ColumnNumber != maRight.m_i4RowNumber) return 0;//A阵列数不等于B阵行数 
	maResult.InitEmptyMatrix(m_i4RowNumber, maRight.m_i4ColumnNumber); 
	Mult(m_pData, maRight.m_pData, maResult.m_pData, m_i4RowNumber, m_i4ColumnNumber, maRight.m_i4ColumnNumber); 
	 
	return 1; 
} 
 
//功能:获取矩阵中的某个元素 
//参数: 
//		i4RowNo:	元素所在矩阵中的行数,从0起算 
//		i4ColumnNo:	元素所在矩阵中的列数,从0起算 
//		f8Member:   有效的f8地址 
//返回:成功返回1, 失败返回0 
int4 CMatrix::GetMember(int4 i4RowNo, int4 i4ColumnNo, f8& f8Member)const 
{ 
	if(i4RowNo >= m_i4RowNumber || i4ColumnNo >= m_i4ColumnNumber) return 0; 
	f8Member = *(m_pData + i4RowNo * m_i4ColumnNumber + i4ColumnNo); 
	 
	return 1; 
} 
 
//功能:更改矩阵中的某个元素 
//参数: 
//		i4RowNo:	元素所在矩阵中的行数,从0起算 
//		i4ColumnNo:	元素所在矩阵中的列数,从0起算 
//		f8Member:   有效的f8地址 
//返回:成功返回1, 失败返回0 
int4 CMatrix::ChangeMember(int4 i4RowNo, int4 i4ColumnNo, f8 f8Member)const 
{ 
	if(i4RowNo >= m_i4RowNumber || i4ColumnNo >= m_i4ColumnNumber) return 0; 
	*(m_pData+ i4RowNo * m_i4ColumnNumber + i4ColumnNo) = f8Member; 
 
	return 1; 
} 
 
//功能:交换矩阵中指定的两行 
//参数: 
//		i4RowNo1	i4RowNo2	将要被交换的行号,从0起算 
//返回:1 成功;0 失败 
int4 CMatrix::ExChangeTwoRows(int4 i4RowNo1, int4 i4RowNo2)const 
{ 
	if(i4RowNo1 >= m_i4RowNumber || i4RowNo2 >= m_i4RowNumber) return 0; 
	if(i4RowNo1 == i4RowNo2) return 1; 
	f8* pTmp = new f8[m_i4ColumnNumber]; 
	//将i4RowNo1行的内容存放到临时变量中 
	memcpy(pTmp, m_pData+i4RowNo1*m_i4ColumnNumber, sizeof(f8)*m_i4ColumnNumber); 
	memcpy(m_pData+i4RowNo1*m_i4ColumnNumber, m_pData+i4RowNo2*m_i4ColumnNumber, sizeof(f8)*m_i4ColumnNumber); 
	memcpy(m_pData+i4RowNo2*m_i4ColumnNumber, pTmp, sizeof(f8)*m_i4ColumnNumber); 
	delete []pTmp; 
	return 1; 
} 
 
//功能:交换矩阵中指定的两列 
//参数: 
//		i4ColumnNo1 i4ColumnNo2	将要被交换的列号,从0起算 
//返回:1 成功;0 失败 
int4 CMatrix::ExChangeTwoColumns(int4 i4ColumnNo1, int4 i4ColumnNo2)const 
{ 
	if(i4ColumnNo1 >= m_i4ColumnNumber || i4ColumnNo2 >= m_i4ColumnNumber) return 0; 
	if(i4ColumnNo1 == i4ColumnNo2) return 1; 
	 
	f8 f8Tmp = 0.0; 
	for(int4 i=0; i<m_i4RowNumber; i++) 
	{ 
		f8Tmp = m_pData[i*m_i4RowNumber+i4ColumnNo1]; 
		m_pData[i*m_i4RowNumber+i4ColumnNo1] = m_pData[i*m_i4RowNumber+i4ColumnNo2]; 
		m_pData[i*m_i4RowNumber+i4ColumnNo2] = f8Tmp; 
	} 
	return 1; 
} 
 
//功能:更改矩阵中的某子块矩阵元素, 基于ChangeMember函数 
//参数: 
//		i4RowNo:		元素所在矩阵中的行数,从0起算 
//		i4ColumnNo:		元素所在矩阵中的列数,从0起算 
//		maSubMatrix:	子块矩阵 
//返回:成功返回1, 失败返回0 
int4 CMatrix::ChangeSubMatrix(int4 i4BeginRowNo, int4 i4BeginColumnNo, const CMatrix& maSecMatrix)// 改变子块 
{ 
	int4 i4SecRow = maSecMatrix.GetRowNumber(); 
	int4 i4SecColumn = maSecMatrix.GetColumnNumber(); 
	if((i4BeginRowNo+i4SecRow) > m_i4RowNumber || (i4BeginColumnNo+i4SecColumn) > m_i4ColumnNumber) return 0; 
	f8 f8Data = 0; 
	for(int i= 0; i<i4SecRow; i++) 
		for(int j=0; j<i4SecColumn; j++) 
		{ 
			ChangeMember(i4BeginRowNo+i, i4BeginColumnNo+j, *(maSecMatrix.GetDataAddress()+ i * i4SecColumn + j));//改变矩阵元素 
		} 
 
	return 1; 
} 
 
//增加矩阵中的某子块矩阵元素 
//参数: 
//		i4RowNo:		元素所在矩阵中的行数,从0起算 
//		i4ColumnNo:		元素所在矩阵中的列数,从0起算 
//		maSubMatrix:	子块矩阵 
//返回:成功返回1, 失败返回0 
int4 CMatrix::AddSubMatrixMember(int4 i4BeginRowNo, int4 i4BeginColumnNo, const CMatrix& maSecMatrix)// 子块元素相加,改变原有矩阵元素 
{ 
	int4 i4SecRow = maSecMatrix.GetRowNumber(); 
	int4 i4SecColumn = maSecMatrix.GetColumnNumber(); 
	if((i4BeginRowNo + i4SecRow) > m_i4RowNumber || (i4BeginColumnNo + i4SecColumn) > m_i4ColumnNumber) return 0; 
	for(int i= 0; i<i4SecRow; i++) 
		for(int j=0; j<i4SecColumn; j++) 
		{ 
			*(m_pData + (i4BeginRowNo+i) * m_i4ColumnNumber + i4BeginColumnNo+j) += *(maSecMatrix.GetDataAddress()+ i * i4SecColumn + j); 
		} 
	return 1; 
} 
 
 
//功能:以某一个数值,更改矩阵中的某行元素 
//参数: 
//		i4RowNo		要修改的行数,从0起算 
//		f8Member	行元素改为的值 
//返回:1 成功;0 失败 
int4 CMatrix::ChangeOneRowWithMember(int4 i4RowNo, f8 f8Member) 
{ 
	if(i4RowNo >= m_i4RowNumber) return 0; 
	for(int4 i=0; i<m_i4ColumnNumber; i++) 
	{ 
		m_pData[i4RowNo * m_i4ColumnNumber + i] = f8Member; 
	} 
	return 1; 
} 
 
//功能:以某一个数值,更改矩阵中的某列元素 
//参数: 
//		i4ColumnNo	要修改的列数,从0起算 
//		f8Member	列元素改为的值 
//返回:1 成功;0 失败 
int4 CMatrix::ChangeOneColumnWithMember(int4 i4ColumnNo, f8 f8Member) 
{ 
	if(i4ColumnNo >= m_i4ColumnNumber) return 0; 
	for(int4 i=0; i<m_i4RowNumber; i++) 
	{ 
		m_pData[i * m_i4ColumnNumber + i4ColumnNo] = f8Member; 
	} 
	return 1; 
} 
 
//功能:在原有矩阵中追加一行 
/*参数:pData:		欲追加数据的首地址 
		i4DataNumber:数据长度,原矩阵的列数 
返回值:成功返回1,失败返回0,参数错误返回-100 
注意:	1. pData必须为有效地址,且数据长度必须等于矩阵的列数 
		2. 若是空矩阵,则可以添加一行*/ 
int4 CMatrix::AppendNewRow(f8* pData, int4 i4DataNumber) 
{ 
	if(!(pData && i4DataNumber)) return -100; 
 
	//追加 
	if(i4DataNumber != m_i4ColumnNumber && m_i4ColumnNumber != 0) return -100; 
	f8* pTmpData = new f8[ (m_i4RowNumber + 1) * m_i4ColumnNumber ]; 
	if(!pTmpData) return 0; 
	if(m_i4RowNumber * m_i4ColumnNumber != 0)//若矩阵不是空矩阵 
	{ 
		memcpy(pTmpData, m_pData, sizeof(f8) * m_i4RowNumber * m_i4ColumnNumber );//转移原有数据 
	} 
	memcpy(pTmpData + m_i4RowNumber * m_i4ColumnNumber, pData, sizeof(f8) * m_i4ColumnNumber );//追加新一行数据 
	delete [] m_pData;//释放原有内存 
	m_pData = NULL; 
	m_pData = pTmpData;//转移指针到新数据区 
 
	//后续工作 
	m_i4RowNumber++; 
 
	return 1; 
} 
 
//功能:在原有矩阵中追加一列 
/*参数:pData:		 欲追加数据的首地址 
		i4DataNumber:数据长度,原矩阵的行数 
返回值:成功返回1,失败返回0,参数错误返回-100 
注意:pData必须为有效地址,且数据长度必须等于矩阵的行数*/ 
int4 CMatrix::AppendNewColumn(f8* pData, int4 i4DataNumber) 
{ 
	if(!(pData && i4DataNumber)) return -100; 
 
	CMatrix mTmpMatri; this->GetTransposedMatrix(mTmpMatri); 
	mTmpMatri.AppendNewRow( pData, i4DataNumber); 
	mTmpMatri.GetTransposedMatrix(*this); 
 
	return 1; 
} 
 
//功能:在原有矩阵中以行的形式追加矩阵,以追加行的形式实现 
//参数: 
//		SecMatrix 	欲追加数据的矩阵 
//返回值:成功返回1,失败返回0,参数错误返回-100 
int4 CMatrix::AppendMatrixInRow(const CMatrix& SecMatrix) 
{ 
	//追加 
	int4 i4SecColumn = SecMatrix.GetColumnNumber(); 
	if(i4SecColumn != m_i4ColumnNumber) return -100; 
	int4 i4SecRow = SecMatrix.GetRowNumber(); 
	f8* pTmpData = new f8[ (m_i4RowNumber + i4SecRow) * m_i4ColumnNumber ]; 
	if(!pTmpData) return 0; 
	memcpy(pTmpData, m_pData, sizeof(f8) * m_i4RowNumber * m_i4ColumnNumber );//转移原有数据 
	memcpy(pTmpData + m_i4RowNumber * m_i4ColumnNumber, SecMatrix.GetDataAddress(), sizeof(f8) * i4SecRow * i4SecColumn );//追加新一行数据 
	delete [] m_pData;//释放原有内存 
	m_pData = pTmpData;//转移指针到新数据区 
 
	//后续工作 
	m_i4RowNumber += i4SecRow; 
 
	return 1; 
} 
 
//功能:在原有矩阵中以列的形式追加矩阵,在追加行中实现 
//参数: 
//		SecMatrix 	欲追加数据的矩阵 
//返回值:成功返回1,失败返回0,参数错误返回-100 
int4 CMatrix::AppendMatrixInColumn(const CMatrix& SecMatrix) 
{ 
	CMatrix mTmpMatri; this->GetTransposedMatrix(mTmpMatri); 
	CMatrix mTmpMatri2; SecMatrix.GetTransposedMatrix(mTmpMatri2); 
	mTmpMatri.AppendMatrixInRow(mTmpMatri2); 
	if(!mTmpMatri.GetTransposedMatrix(*this)) return 0; 
 
	return 1; 
} 
 
//功能:在原有矩阵中以矩阵形式追加矩阵 
//参数: 
//		SecMatrix 	欲追加数据的矩阵 
//返回值:成功返回1,失败返回0,参数错误返回-100 
/*			 
		| A 0| 
	A =	| 0 B| 
 */ 
int4 CMatrix::AppendMatrixInDiagonal(const CMatrix& SecMatrix)  
{ 
 
	int4 i4SecRow = SecMatrix.GetRowNumber(); 
	int4 i4SecColumn = SecMatrix.GetColumnNumber(); 
	CMatrix maRightMatrix, maZeroMatri1; 
 
	maZeroMatri1.InitZeroMatrix(i4SecRow, m_i4ColumnNumber); 
 
	maRightMatrix.InitZeroMatrix(m_i4RowNumber, i4SecColumn); 
	maRightMatrix.AppendMatrixInRow(SecMatrix); 
 
	this->AppendMatrixInRow(maZeroMatri1); 
	this->AppendMatrixInColumn(maRightMatrix); 
 
	return 1; 
} 
 
 
 
//功能:在原有矩阵中以行形式插入矩阵 
//参数:i4RowNo		元素所在矩阵中的行数,从0起算 
//		SecMatrix 	欲追加数据的矩阵 
//返回:成功返回1,失败返回0,参数错误返回-100	 
int4 CMatrix::InsertMatrixInRow(int4 i4RowNo, const CMatrix& SecMatrix) 
{ 
	if(i4RowNo == m_i4RowNumber) return AppendMatrixInRow(SecMatrix); 
	if (SecMatrix.GetColumnNumber() != m_i4ColumnNumber || i4RowNo<0 || i4RowNo > m_i4RowNumber) return 0; 
 
	//创建新空间,并拷贝数据 
	f8* pTmp = new f8[m_i4ColumnNumber * (m_i4RowNumber + SecMatrix.GetRowNumber())]; 
	memcpy(pTmp, m_pData, i4RowNo*m_i4ColumnNumber*sizeof(f8)); 
	memcpy(pTmp + (i4RowNo)*m_i4ColumnNumber, SecMatrix.GetDataAddress(), SecMatrix.GetRowNumber()*m_i4ColumnNumber*sizeof(f8)); 
	memcpy(pTmp + (i4RowNo)*m_i4ColumnNumber + SecMatrix.GetRowNumber()*m_i4ColumnNumber, m_pData+i4RowNo*m_i4ColumnNumber,  
			(m_i4RowNumber - i4RowNo)*m_i4ColumnNumber*sizeof(f8)); 
	//转移数据地址 
	delete []m_pData; 
	m_pData = pTmp; 
	m_i4RowNumber += SecMatrix.GetRowNumber(); 
 
	return 1; 
} 
 
 
//功能:在原有矩阵中以行形式插入矩阵 
//参数:i4ColumnNo	元素所在矩阵中的列数,从0起算 
//		SecMatrix 	欲追加数据的矩阵 
//返回:成功返回1,失败返回0,参数错误返回-100	 
int4 CMatrix::InsertMatrixInColomn(int4 i4ColumnNo, const CMatrix& SecMatrix) 
{ 
	if(i4ColumnNo == m_i4ColumnNumber) return 	AppendMatrixInColumn(SecMatrix); 
	if (SecMatrix.GetRowNumber() != m_i4RowNumber || i4ColumnNo<0 || i4ColumnNo > m_i4ColumnNumber) return 0; 
 
	//创建新空间,并循环拷贝数据 
	f8* pTmp = new f8[m_i4RowNumber * (m_i4ColumnNumber + SecMatrix.GetColumnNumber())]; 
	f8* pSecMatrix = SecMatrix.GetDataAddress(); 
	int4 i4SecColNum = SecMatrix.GetColumnNumber(); 
	for(int4 i=0; i<m_i4RowNumber; i++) 
	{ 
		memcpy(pTmp+i*(m_i4ColumnNumber+i4SecColNum), m_pData+i*m_i4ColumnNumber, i4ColumnNo*sizeof(f8)); 
		memcpy(pTmp+i*(m_i4ColumnNumber+i4SecColNum) + i4ColumnNo, pSecMatrix+i*i4SecColNum, i4SecColNum*sizeof(f8)); 
		memcpy(pTmp+i*(m_i4ColumnNumber+i4SecColNum) + i4ColumnNo + i4SecColNum,  
				m_pData+i*m_i4ColumnNumber+i4ColumnNo, (m_i4ColumnNumber-i4ColumnNo)*sizeof(f8)); 
	} 
	//转移数据地址 
	delete []m_pData; 
	m_pData = pTmp; 
	m_i4ColumnNumber = m_i4ColumnNumber+i4SecColNum; 
	return 1; 
} 
 
 
//功能:在指定行后面添加一行,所添加行的元素全为f8Member 
//参数:i4RowNo		指定行号,从0起算 
//		f8Member 	元素 
//返回:成功返回1,失败返回0 
int4 CMatrix::InsertOneRowWithMember(int4 i4RowNo, f8 f8Member) 
{ 
	if(i4RowNo > m_i4RowNumber) return 0;//参数不对就退出 
	CMatrix SecMatrix; 
	SecMatrix.InitEmptyMatrix(1, m_i4ColumnNumber); 
	f8* pData = SecMatrix.GetDataAddress(); 
	for(int4 i=0; i<m_i4ColumnNumber; i++) pData[i] = f8Member; 
	return InsertMatrixInRow(i4RowNo,  SecMatrix); 
} 
 
//功能:在指定行后面添加一列,所添加列的元素全为f8Member 
//参数:i4ColumnNo		指定列号,从0起算 
//		f8Member 	元素 
//返回:成功返回1,失败返回0	 
int4 CMatrix::InsertOneColomnWithMember(int4 i4ColumnNo, f8 f8Member) 
{ 
	if(i4ColumnNo > m_i4ColumnNumber) return 0;//参数不对就退出 
	CMatrix SecMatrix; 
	SecMatrix.InitEmptyMatrix(m_i4RowNumber, 1); 
	f8* pData = SecMatrix.GetDataAddress(); 
	for(int4 i=0; i<m_i4RowNumber; i++) pData[i] = f8Member;	 
	return InsertMatrixInColomn(i4ColumnNo, SecMatrix); 
} 
 
//功能:获取原矩阵中的一行 
/*参数: 
		i4RowNo:	欲取数据在矩阵中的行号,从0起算 
		pData:		返回数据的首地址,必须已经实化,并有足够的空间 
返回值:成功返回1,失败返回0,参数错误返回-100 
注意:pData必须为有效地址,且空间长度必须大于等于矩阵的列数*/ 
int4 CMatrix::GetOneRow(int4 i4RowNo, f8* pData) const 
{ 
	if(i4RowNo >= m_i4RowNumber) return -100; 
	memcpy(pData, m_pData + i4RowNo * m_i4ColumnNumber, sizeof(f8) * m_i4ColumnNumber );//拷贝数据 
 
	return 1; 
} 
 
//功能:获取原矩阵中的一行 
/*参数:i4RowNo:		欲取数据在矩阵中的行号,从0起算 
		maRowMAtrix:	行矩阵结果 
返回值:成功返回1,失败返回0,参数错误返回-100*/ 
int4 CMatrix::GetOneRow(int4 i4RowNo, CMatrix& maRowMAtrix) const 
{ 
	if(i4RowNo >= m_i4RowNumber) return -100; 
	maRowMAtrix.InitEmptyMatrix(1, m_i4ColumnNumber); 
	GetOneRow(i4RowNo, maRowMAtrix.GetDataAddress()); 
 
	return 1; 
} 
 
//功能:获取原矩阵中的一列。通过获取行函数实现 
/*参数: 
		i4ColumnNo:	欲取数据在矩阵中的列号,从0起算 
		pData:		返回数据的首地址,必须已经实化,并有足够的空间 
返回值:成功返回1,失败返回0,参数错误返回-100 
注意:pData必须为有效地址,且空间长度必须大于等于矩阵的行数*/ 
int4 CMatrix::GetOneColumn(int4 i4ColumnNo, f8* pData)const 
{ 
	if(i4ColumnNo >= m_i4ColumnNumber) return -100; 
	CMatrix maTmp = GetTransposedMatrix(); 
	maTmp.GetOneRow(i4ColumnNo, pData); 
 
	return 1; 
} 
 
//功能:获取原矩阵中的一列 
/*参数: 
		i4ColumnNo:	欲取数据在矩阵中的列号,从0起算 
		maColumnMAtrix:	列矩阵结果 
返回值:成功返回1,失败返回0,参数错误返回-100*/ 
int4 CMatrix::GetOneColumn(int4 i4ColumnNo, CMatrix& maColumnMAtrix)const 
{ 
	if(i4ColumnNo >= m_i4ColumnNumber) return -100; 
	maColumnMAtrix.InitEmptyMatrix(m_i4RowNumber, 1); 
	GetOneColumn(i4ColumnNo, maColumnMAtrix.GetDataAddress()); 
	 
	return 1; 
} 
 
//功能:在原有矩阵中删除一行 
/*参数:i4RowNo:欲删除行的行号,注意:行列号从0起算 
返回值:成功返回1,失败返回0,参数错误返回-100*/ 
int4 CMatrix::DeleteOneRow(int4 i4RowNo) 
{ 
	if(i4RowNo > m_i4RowNumber-1) return -100; 
 
	if(i4RowNo != m_i4RowNumber-1)//如果删除最后一行,就直接将行数减1即可 
	{ 
		memmove(m_pData+ i4RowNo * m_i4ColumnNumber,  
				m_pData+ (i4RowNo+1) * m_i4ColumnNumber,  
				(m_i4RowNumber - (i4RowNo +1)) * m_i4ColumnNumber * sizeof(f8)); 
	} 
 
	//后续工作 
	m_i4RowNumber--; 
 
	return 1; 
 
} 
 
//功能:在原有矩阵中删除一行,并将此行数据以行矩阵形式返回 
/*参数:i4RowNo:欲删除行的行号,注意:行列号从0起算 
		maRowMAtrix:	行矩阵结果 
返回值:成功返回1,失败返回0,参数错误返回-100*/ 
int4 CMatrix::DeleteOneRow(int4 i4RowNo, CMatrix& maRowMAtrix) 
{ 
	if(i4RowNo > m_i4RowNumber-1) return -100; 
	if(!GetOneRow(i4RowNo, maRowMAtrix)) return 0; 
	return DeleteOneRow(i4RowNo); 
} 
 
//功能:在原有矩阵中删除一列 
/*参数:i4ColumnNo:	欲删除列的列号,注意:行列号从0起算 
返回值:成功返回1,失败返回0,参数错误返回-100 
实现方法:先定义一转置矩阵,并将之删除一行,然后再转置回来*/ 
int4 CMatrix::DeleteOneColumn(int4 i4ColumnNo) 
{ 
	if(i4ColumnNo > m_i4ColumnNumber-1) return -100; 
 
	CMatrix mTmpMatri; this->GetTransposedMatrix(mTmpMatri); 
	mTmpMatri.DeleteOneRow(i4ColumnNo); 
	mTmpMatri.GetTransposedMatrix(*this); 
 
	return 1; 
} 
 
 
/* 
//功能:在原有矩阵中删除一列 
/ *参数:i4ColumnNo:	欲删除列的列号,注意:行列号从0起算 
返回值:成功返回1,失败返回0,参数错误返回-100 
实现方法:先定义一转置矩阵,并将之删除一行,然后再转置回来* / 
int4 CMatrix::DeleteOneColumn(int4 i4ColumnNo) 
{ 
	if((i4ColumnNo > m_i4ColumnNumber-1) || (i4ColumnNo < 0)) return -100;  
     
	int4 i4Size = m_i4ColumnNumber - 1; 
	for(int4 i=0; i<m_i4RowNumber; i++) 
	{ 
		memcpy(m_pData+m_i4ColumnNumber*i+i4ColumnNo-i, 
			   m_pData+m_i4ColumnNumber*i+i4ColumnNo+1, 
			   i4Size*sizeof(f8)); 
	} 
	//将移位后的空位清零 
	memset(m_pData + (m_i4ColumnNumber*m_i4RowNumber) - m_i4RowNumber, 0, m_i4RowNumber*sizeof(f8)); 
	m_i4ColumnNumber--; 
	 
	return 1; 
} 
*/ 
 
//功能:在原有矩阵中删除一列,并将此列数据以列矩阵形式返回 
/*参数:i4ColumnNo:		欲删除列的列号,注意:行列号从0起算 
		maColumnMatrix:	列矩阵结果 
返回值:成功返回1,失败返回0,参数错误返回-100*/ 
int4 CMatrix::DeleteOneColumn(int4 i4ColumnNo, CMatrix& maColumnMatrix) 
{ 
	if(i4ColumnNo > m_i4ColumnNumber-1) return -100; 
 
	if(!GetOneColumn(i4ColumnNo, maColumnMatrix)) return 0; 
	return DeleteOneColumn(i4ColumnNo); 
} 
 
//功能:将前面行的数据合并到目标行 
//参数:1	i4RowNo:欲合并的行号,从0起算 
//		2	i4ComMode:合并模式:1:相加;-1:相减 
//返回值:成功返回1,失败返回0,参数错误返回-100 
int4 CMatrix::CombineRow(int4 i4RowNo, int4 i4ComMode) 
{ 
	if(i4RowNo >= m_i4RowNumber) return -100; 
	 
	//将数据合并,越过目标行 
	for(int4 i=0; i<m_i4RowNumber; i++) 
	{ 
		if(i != i4RowNo) 
		{ 
			for(int4 j=0; j<m_i4ColumnNumber; j++) 
			{ 
				*(m_pData+ i * m_i4ColumnNumber + j ) += *(m_pData + i4RowNo * m_i4ColumnNumber + j ) * i4ComMode;//nRowNo从0起算 
			} 
		} 
	} 
	//删去nRowNo行 
	this->DeleteOneRow(i4RowNo); 
	 
	return 1; 
} 
 
//功能:将前面行的数据合并到目标列 
//参数:1	i4ColumnNo :欲合并的列号,从0起算 
//		2	i4ComMode:合并模式:1:相加;-1:相减 
//返回值:成功返回1,失败返回0,参数错误返回-100 
int4 CMatrix::CombineColumn(int4 i4ColumnNo, int4 i4ComMode) 
{ 
	if(i4ColumnNo >= m_i4ColumnNumber) return -100; 
	 
	//将数据合并,越过目标列 
	for(int4 i=0; i<m_i4RowNumber; i++) 
	{ 
		for(int4 j=0; j<m_i4ColumnNumber; j++) 
		{ 
			if(j != i4ColumnNo) 
			{ 
				*(m_pData+ i * m_i4ColumnNumber + j ) += *(m_pData + i * m_i4ColumnNumber + i4ColumnNo ) * i4ComMode;//nRowNo从0起算 
			} 
		} 
	} 
	//删去i4ColumnNo列 
	this->DeleteOneColumn(i4ColumnNo); 
	 
	return 1; 
} 
 
//功能:输出矩阵的迹 
//参数: 无 
//返回值: 矩阵的迹 
f8 CMatrix::GetTrace()const 
{ 
	f8 f8Trace = 0.0; 
	if(m_i4RowNumber != m_i4ColumnNumber) 
	{	//如果不为方阵,则无迹 
		f8Trace = 0.0; 
	} 
	else 
	{ 
		for(int4 i=0;i<m_i4RowNumber;i++) 
		{ 
			f8Trace += *(m_pData + i*(m_i4ColumnNumber+1)); 
		} 
	} 
	return f8Trace;	 
} 
 
 
//功能:输出矩阵范数 
//参数:无 
//返回值:矩阵范数 
f8 CMatrix::GetNorm()const 
{ 
	int4 i4ElementNum = m_i4RowNumber * m_i4ColumnNumber; 
	f8 f8Norm = 0.0; 
	for(int4 i=0; i<i4ElementNum; i++) 
	{ 
		f8Norm += m_pData[i] * m_pData[i]; 
	} 
	 
	return f8Norm; 
} 
 
//功能:转换地址中的数值,矩阵转置核心函数 
/*参数:pm1:原数据首地址 
		pm2:转置后数据的首地址 
		i4m:原数组行数 
		i4n:原数组列数*/ 
void CMatrix::Transpose(const f8* pm1, f8* pm2, int4 i4m, int4 i4n)const 
{ 
	int4 i,j; 
	for(i=0; i<i4m; i++) 
		for(j=0; j<i4n; j++) 
			pm2[j*i4m+i] = pm1[i*i4n+j]; 
	return; 
} 
 
//功能:两个矩阵相乘核心函数 
/*参数:pm1:		第一矩阵数据首地址 
		pm2:		第二矩阵数据首地址 
		presult:	结果矩阵数据首地址 
		i_1:		第一矩阵行数,即结果矩阵行数 
		j_12:		第一矩阵列数,即第二矩阵的行数 
		j_2:		第二矩阵的列数,即结果矩阵列数*/ 
void CMatrix::Mult(const f8* pm1, const f8* pm2, f8* pResult, int4 i_1, int4 j_12, int4 j_2)const 
{ 
	int4 i,j,k; 
	for(i=0; i<i_1; i++) 
		for(j=0;j<j_2;j++) 
		{ 
			pResult[i*j_2+j]= 0.0; 
			for(k=0; k<j_12; k++) 
				pResult[i*j_2+j] += pm1[i*j_12+k] * pm2[j+k*j_2]; 
		} 
	return; 
} 
 
//功能:方矩阵求逆核心函数 
/*参数:pm1:	原矩阵数据首地址,也是逆阵的首地址 
		i4n:	矩阵行数或列数 
//返回值:成功返回1,失败返回0*/ 
int4 CMatrix::InversMatrix(f8* pm1, int4 i4n)const 
{  
	int4 *pis,*pjs; 
	int4 i,j,k,l,u,v; 
	f8 temp,max_v; 
	pis = new int4[i4n]; 
	pjs = new int4[i4n]; 
	if(pis==NULL || pjs==NULL)	return(0); 
 
	for(k=0; k<i4n; k++) 
	{ 
		max_v = 0.0; 
		for(i=k; i<i4n; i++) 
			for(j=k; j<i4n; j++) 
			{ 
				temp = fabs(pm1[i*i4n+j]); 
				if( temp>max_v ) 
				{ 
			        max_v = temp;  
					pis[k] = i;  
					pjs[k] = j; 
				} 
			} 
		if(max_v==0.0) 
		{ 
			delete []pis;  
			delete []pjs; 
			return(0); 
		} 
		if(pis[k]!=k) 
			for(j=0; j<i4n; j++) 
			{ 
			   u = k*i4n+j; 
			   v = pis[k]*i4n+j; 
			   temp = pm1[u];  
			   pm1[u] = pm1[v]; 
			   pm1[v] = temp; 
			} 
		if(pjs[k]!=k) 
			for(i=0; i<i4n; i++) 
			{ 
				u = i*i4n+k; v = i*i4n+pjs[k]; 
				temp=pm1[u]; pm1[u]=pm1[v]; pm1[v]=temp; 
			} 
		l=k*i4n+k; 
		pm1[l]=1.0/pm1[l]; 
		for(j=0; j<i4n; j++) 
			if(j!=k) 
			{ 
				u = k*i4n+j; 
				pm1[u] *= pm1[l]; 
			} 
		for(i=0; i<i4n; i++) 
			if(i!=k) 
				for(j=0; j<i4n; j++) 
					if(j!=k) 
					{ 
					  u = i*i4n+j; 
					  pm1[u] -= pm1[i*i4n+k] * pm1[k*i4n+j]; 
					} 
		for(i=0; i<i4n; i++) 
			if(i != k) 
			{ 
				u = i*i4n+k; 
				pm1[u] *= -pm1[l]; 
			} 
	} 
	for(k=i4n-1; k>=0; k--) 
	{ 
		if(pjs[k]!=k) 
			for(j=0; j<i4n; j++) 
			{ 
				u = k*i4n+j; v = pjs[k]*i4n+j; 
				temp=pm1[u]; pm1[u]=pm1[v]; pm1[v]=temp; 
			} 
		if(pis[k] != k) 
			for(i=0; i<i4n; i++) 
			{ 
				u=i*i4n+k; v=i*i4n+pis[k]; 
				temp=pm1[u]; pm1[u]=pm1[v]; pm1[v]=temp; 
			} 
	} 
	delete []pis; delete []pjs; 
 
  return 1; 
 
} 
 
//功能:将矩阵元素设零 
//参数:无 
//返回值:1 
int4 CMatrix::SetZero() 
{ 
	if(m_pData != NULL) 
	{ 
		memset(m_pData, 0, sizeof(f8) * m_i4RowNumber * m_i4ColumnNumber); 
	} 
	return 1; 
} 
 
//功能:将矩阵元素设负 
//参数:无 
//返回值:1 
int4 CMatrix::SetMinus() 
{ 
	int4 nElementNumber = m_i4RowNumber * m_i4ColumnNumber; 
	for(int4 i=0; i<nElementNumber; i++) 
	{ 
		*(m_pData + i) *= -1; 
	} 
	 
	return 1; 
} 
 
//功能:将矩阵元素乘以倍数----注意:此函数和“*”操作符重载不同,这个函数视将自身元素改变,而后者则自身不变  
//参数:f8MulNum	倍数 
//返回值:1 
int4 CMatrix::Multiply(f8 f8MulNum) 
{ 
	int4 i4ElementNumber = m_i4RowNumber * m_i4ColumnNumber; 
	for(int4 i=0;i<i4ElementNumber;i++) 
	{ 
		m_pData[i] *= f8MulNum; 
	} 
	 
	return 1; 
} 
 
//功能:将矩阵设成单位阵 
//参数:i4RowNumber	单位阵的维数 
//返回值:1 
int4 CMatrix::SetIdentity(int4 i4RowNumber) 
{ 
	if(i4RowNumber == 0) return 0; 
 
	this->InitEmptyMatrix(i4RowNumber, i4RowNumber);//开空间 
	memset(m_pData, 0, sizeof(f8) * i4RowNumber * i4RowNumber);//第一步全部置零 
	for(int4 j=0; j<i4RowNumber; j++) 
	{ 
		*(m_pData + j*(i4RowNumber+1) ) = 1.0;//第二步将对角线置1 
	} 
 
	return 1; 
} 
 
//功能:将矩阵设成简单相关阵 
//参数:i4RowNumber	相关阵的维数 
//返回值:1 
int4 CMatrix::SetCorrelativity(int4 i4RowNumber) 
{ 
	if(i4RowNumber==0) return 0; 
 
	if(i4RowNumber * i4RowNumber != m_i4RowNumber * m_i4ColumnNumber)//空间不相同 
	{ 
		this->InitEmptyMatrix(i4RowNumber, i4RowNumber);//重新开空间 
	} 
	 
	for(int4 i=0; i<i4RowNumber*i4RowNumber; i++) 
	{ 
		*(m_pData + i ) = 1.0;//第一步全部置1 
	} 
	for(int4 j=0; j<i4RowNumber; j++) 
	{ 
		*(m_pData + j*(i4RowNumber+1) ) = 2.0;//第二步将对角线置2 
	} 
 
	return 1; 
} 
 
/////////////////////////////////////////////////// 
//公用操作符重载    operator override 
/////////////////////////////////////////////////// 
 
//功能:赋值操作符重载 
/*参数:SecMatrix:		源矩阵 
//返回值:自身矩阵的引用,这样可以使用连等形式,如: A = B = C ,此时 A , B 都等于 C 的值; 
//实现方法:调用InitMatrix()函数实现功能 
使用示例:A=B=C 意为: B=C; A=B; */ 
//CMatrix& CMatrix::operator= (const CMatrix & SecMatrix) 
//{ 
//	if(&SecMatrix == this) return *this; 
//	this->InitMatrix(SecMatrix.GetDataAddress(),SecMatrix.GetRowNumber(),SecMatrix.GetColumnNumber()); 
// 
//	return *this; 
//} 
 
int4 CMatrix::operator= (const CMatrix& SecMatrix) 
{ 
	if(&SecMatrix == this) return 1; 
	return this->InitMatrix(SecMatrix.GetDataAddress(),SecMatrix.GetRowNumber(),SecMatrix.GetColumnNumber()); 
} 
 
//功能:矩阵加法操作符重载 
/*参数:SecMatrix:		源矩阵 
//返回值:相加后的结果矩阵 
使用示例:A=B+C 意为: A中的元素为B、C中元素之和 */ 
CMatrix CMatrix::operator+ (const CMatrix & SecMatrix)const 
{ 
	CMatrix TmpMatrix; 
	//行、列不相等的矩阵不能相加 
	if((m_i4RowNumber != SecMatrix.GetRowNumber()) || (m_i4ColumnNumber != SecMatrix.GetColumnNumber())) return TmpMatrix; 
 
	int4 i4ElementNumber = m_i4RowNumber * m_i4ColumnNumber; 
	f8* pTmpData2 = new f8[i4ElementNumber]; 
	SecMatrix.GetData(pTmpData2); 
	for(int4 i=0; i<i4ElementNumber; i++) 
	{ 
		*(pTmpData2 + i) += *(m_pData + i); 
	} 
	 
	TmpMatrix.InitMatrix(pTmpData2, m_i4RowNumber, m_i4ColumnNumber); 
	delete [] pTmpData2; 
 
	return TmpMatrix; 
} 
 
//功能:矩阵减法操作符重载 
/*参数:SecMatrix:		源矩阵 
//返回值:相加后的结果矩阵 
使用示例:A=B-C 意为: A中的元素为B、C中元素之差*/ 
CMatrix CMatrix::operator- (const CMatrix & SecMatrix)const 
{ 
	CMatrix TmpMatrix(SecMatrix); 
	TmpMatrix.SetMinus(); 
 
	CMatrix SecTmpMatrix(* this + TmpMatrix); 
	return SecTmpMatrix; 
} 
 
//功能:取负操作符重载 
/*参数:无 
//返回值:自身矩阵的负矩阵 
//实现方法:调用SetMinus()函数实现功能 
使用示例:A=-C 意为: A中的元素为B中元素的负值 */ 
CMatrix CMatrix::operator- () 
{ 
	CMatrix TmpMatrix(* this); 
	TmpMatrix.SetMinus(); 
	return TmpMatrix; 
} 
 
//功能:矩阵相乘 
/*参数:SecMatrix:		被乘矩阵 
//返回值:矩阵相乘的结果矩阵 
使用示例:C=A*B C为结果矩阵 */ 
CMatrix CMatrix::operator* (const CMatrix& SecMatrix)const 
{ 
	CMatrix maTemp; 
	if(m_i4ColumnNumber != SecMatrix.m_i4RowNumber) return maTemp;//A阵列数不等于B阵行数 
	int4 i4ElementNumber = m_i4RowNumber * SecMatrix.GetColumnNumber(); 
	f8* pTmpData = new f8[i4ElementNumber]; 
	Mult(m_pData,SecMatrix.GetDataAddress(), pTmpData, m_i4RowNumber, m_i4ColumnNumber, SecMatrix.GetColumnNumber()); 
 
	CMatrix TmpMatrix(pTmpData, m_i4RowNumber, SecMatrix.GetColumnNumber()); 
	delete [] pTmpData; 
 
	return TmpMatrix; 
} 
 
//功能:矩阵乘以实数 
/*参数: f8MultiNum:	被乘数 
//返回值:矩阵乘以实数的结果矩阵 
使用示例:C= A * dMultiNum C为结果矩阵 */ 
CMatrix CMatrix::operator *(const f8 f8MultiNum) const 
{ 
	int4 i4ElementNumber = m_i4RowNumber * m_i4ColumnNumber; 
	f8* pTmpData = new f8[i4ElementNumber]; 
	GetData(pTmpData); 
	for(int4 i=0; i<i4ElementNumber; i++) 
	{ 
		pTmpData[i] *= f8MultiNum; 
	} 
	 
	CMatrix TmpMatrix(pTmpData, m_i4RowNumber, m_i4ColumnNumber); 
	delete [] pTmpData; 
 
	return TmpMatrix; 
} 
 
//功能:矩阵除以实数 
/*参数: f8MultiNum:	被除数,不能为0 
//返回值:矩阵乘以实数的结果矩阵 
使用示例:C= A * dMultiNum C为结果矩阵 */ 
CMatrix CMatrix::operator /(const f8 f8DevideNum) const 
{ 
	CMatrix TmpMatrix; 
	if(f8DevideNum == 0) return TmpMatrix; 
 
	f8 f8Temp = 1/f8DevideNum; 
	 
	TmpMatrix = this->operator * (f8Temp); 
 
	return TmpMatrix; 
} 
 
//功能:矩阵正向除 
/*参数:SecMatrix:		被除矩阵 
//返回值:矩阵正向除的结果矩阵 */ 
//使用方法:C=A/B C为A乘以B的逆阵的结果阵 
CMatrix CMatrix::operator/ (const CMatrix & SecMatrix)const 
{ 
	//先求B的逆阵 
	CMatrix TmpMatrix1; SecMatrix.GetInverseMatrix(TmpMatrix1); 
	if(!TmpMatrix1.GetRowNumber()) return TmpMatrix1;//如果求逆失败,则返回空阵 
 
	//再矩阵相乘 
	CMatrix TmpMatrix2 = (*this) * TmpMatrix1; 
 
	return TmpMatrix2; 
} 
 
//功能:矩阵逆向除,A%B:表示A的逆阵乘以B 
/*参数:SecMatrix:		被操作矩阵 
//返回值:矩阵逆向除的结果矩阵 */ 
//使用方法:C=A%B C为A的逆阵乘以B的结果阵 
CMatrix CMatrix::operator% (const CMatrix & SecMatrix)const 
{ 
	//先求A的逆阵 
	CMatrix TmpMatrix1; this->GetInverseMatrix(TmpMatrix1); 
	if(!TmpMatrix1.GetRowNumber()) return TmpMatrix1;//如果求逆失败,则返回空阵 
 
	//再矩阵相乘 
	CMatrix TmpMatrix2 = TmpMatrix1 * SecMatrix; 
 
	return TmpMatrix2; 
} 
 
//功能:矩阵加法操作符重载 
/*参数:SecMatrix:		源矩阵 
//返回值:相加后的结果矩阵 
使用示例:A=A+C 意为: A中的元素为原来A、C中元素之和 */ 
int4 CMatrix::operator+= (const CMatrix& SecMatrix) 
{ 
	//行、列不相等的矩阵不能相加 
	if((m_i4RowNumber != SecMatrix.GetRowNumber()) || (m_i4ColumnNumber != SecMatrix.GetColumnNumber())) return 0; 
	 
	int4 i4ElementNumber = m_i4RowNumber * m_i4ColumnNumber; 
	f8* pSecData = SecMatrix.GetDataAddress(); 
	for(int4 i=0; i<i4ElementNumber; i++) 
	{ 
		*(m_pData + i) += *(pSecData + i); 
	} 
	return 1; 
} 
 
//功能:矩阵减法操作符重载 
/*参数:SecMatrix:		源矩阵 
//返回值:相加后的结果矩阵 
使用示例:A=A-C 意为: A中的元素为原来A、C中元素之差 */ 
int4 CMatrix::operator-= (const CMatrix& SecMatrix) 
{ 
	//行、列不相等的矩阵不能相加 
	if((m_i4RowNumber != SecMatrix.GetRowNumber()) || (m_i4ColumnNumber != SecMatrix.GetColumnNumber())) return 0; 
	 
	int4 i4ElementNumber = m_i4RowNumber * m_i4ColumnNumber; 
	f8* pSecData = SecMatrix.GetDataAddress(); 
	for(int4 i=0; i<i4ElementNumber; i++) 
	{ 
		*(m_pData + i) -= *(pSecData + i); 
	} 
	return 1; 
} 
 
//功能:矩阵等于操作符重载 
/*参数:SecMatrix:		源矩阵 
//返回值:相同 1;不同 0 */ 
BOOL CMatrix::operator== (const CMatrix& SecMatrix)const 
{ 
	//行、列不相等的矩阵不相等 
	if((m_i4RowNumber != SecMatrix.GetRowNumber()) || (m_i4ColumnNumber != SecMatrix.GetColumnNumber())) return FALSE; 
 
	int4 i4ElementNumber = m_i4RowNumber * m_i4ColumnNumber; 
	f8* pSecData = SecMatrix.GetDataAddress(); 
	for(int4 i=0; i<i4ElementNumber; i++) 
	{ 
		if(fabs(*(m_pData + i) - *(pSecData + i)) > EPSILON) return FALSE; 
	} 
	return TRUE; 
} 
 
BOOL CMatrix::operator!= (const CMatrix& SecMatrix)const 
{ 
	if(*this == SecMatrix) return 0; 
	else return 1; 
} 
 
 
//功能:四舍五入,计算最靠近的整数 
//例如:1.2 -> 1; 1.8 -> 2; -33.3 -> -33; -6.9 -> -7  
//参数:f8 dNum:要处理的实数 
//返回:返回的整数 
int4 CMatrix::round(f8 dNum)const 
{ 
	int4 nIntNum; 
	if(dNum>=0) nIntNum=(int4)(dNum+0.5); 
	else nIntNum=(int4)(dNum-0.5); 
	return nIntNum; 
} 
double Det(CMatrix A) 
{ 
	CMatrix B(A.m_i4RowNumber,A.m_i4RowNumber),D; 
	int i,j=-1,k; 
	double R=0,r=0; 
	for(i=0;i<B.m_i4RowNumber*B.m_i4ColumnNumber;i++) 
	{ 
		B.m_pData[i]=A.m_pData[i]; 
	} 
	if((B.GetInverseMatrix(D))==0)  
		return 0; 
	else 
	{ 
		D.InitEmptyMatrix(0,0); 
		if(B.m_i4ColumnNumber==1)  
			return B.m_pData[0]; 
		for(i=0;i<B.m_i4ColumnNumber;i++) 
		{ 
			CMatrix C(B.m_i4RowNumber,B.m_i4RowNumber); 
			for(k=0;k<C.m_i4RowNumber*C.m_i4ColumnNumber;k++) 
			{ 
				C.m_pData[k]=B.m_pData[k]; 
			} 
			j*=-1; 
			r=B.m_pData[i]; 
			C.DeleteOneColumn(i); 
			C.DeleteOneRow(0); 
			double t=Det(C); 
			R+=j*r*Det(C); 
		} 
	} 
	return R; 
}