cmatrix.cpp

相对定向的坐标解算

	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;
}