cmatrix.cpp

GPS坐标转换软件与源程序 支持世界上大多数坐标框架下

// 	return maSuperMatrix;
// }
/******************************************************************************/
/*Function: Append a sub-matrix at bottom of original matrix. the original
			matrix don't change.the new maxtrix is maSuperMatrix.the colum of 
			two matrix is equal.		high efficient.
  Parameters:
		this:				the matrix to be added.
		maSubMatrix:		the matrix to add.
		maSuperMatrix:		the new matrix stored added matrix.
  Return:	
		Success return 1;
		else return 0;
*/
/******************************************************************************/
i4 CMatrix::AppendBSubMatrix(const CMatrix maSubMatrix, CMatrix& maSuperMaxtrix)const
{
	if (m_nColumnNumber != maSubMatrix.GetColumnNumber()) return 0;
	maSuperMaxtrix = *this;
	f8* pData = new f8[m_nColumnNumber];
	memset(pData,0,m_nColumnNumber*sizeof(*pData));
	//append row.
	for (int i=0;i<maSubMatrix.GetRowNumber();i++)
	{
		maSubMatrix.GetOneRow(i,pData);
		maSuperMaxtrix.AppendNewRow(pData,m_nColumnNumber);	
	}

	SAFE_DELETE_ARRAY(pData);
	return 1;
}


//功能：获取矩阵中的某个元素
/*参数：
		nRowNumber：	元素所在矩阵中的行数，从0起算
		nColumnNumber：	元素所在矩阵中的列数，从0起算
		f8Member     : 有效的f8地址
返回值：成功返回1 失败返回0*/
i4	CMatrix::GetMember(i4 nRowNo,i4 nColumnNo, f8& f8Member)const
{
	if(nRowNo >= m_nRowNumber || nColumnNo >= m_nColumnNumber) return 0;
	f8Member = *(m_pData+ nRowNo * m_nColumnNumber + nColumnNo);
	return 1;
}

//功能：获取矩阵中的某个元素
/*参数：
		nRowNumber：	元素所在矩阵中的行数，从0起算
		nColumnNumber：	元素所在矩阵中的列数，从0起算
返回值：成功返回元素的值 失败返回0*/
f8	CMatrix::GetMember(i4 nRowNo,i4 nColumnNo)const
{
	if(nRowNo >= m_nRowNumber || nColumnNo >= m_nColumnNumber) return 0;
	f8 data= *(m_pData+ nRowNo * m_nColumnNumber + nColumnNo);
	return data;
}

//功能：更改矩阵中的某个元素
/*参数：
		nRowNo：	元素所在矩阵中的行数，从0起算
		nColumnNo：	元素所在矩阵中的列数，从0起算
		f8Member :  元素改为的值
返回值：成功返回1 失败返回0*/
i4	CMatrix::ChangeMember(i4 nRowNo,i4 nColumnNo, f8 f8Member)const
{
	if(nRowNo >= m_nRowNumber || nColumnNo >= m_nColumnNumber) return 0;
	 *(m_pData+ nRowNo * m_nColumnNumber + nColumnNo) = f8Member;
	return 1;
}


//功能：在原有矩阵中追加一行
/*参数：pData:		欲追加数据的首地址
		nDataNumber:数据长度,原矩阵的列数
返回值：成功返回1，失败返回0，参数错误返回-100
注意：pData必须为有效地址，且数据长度必须等于矩阵的列数*/
i4 CMatrix::AppendNewRow(f8* pData,i4 nDataNumber)
{
	if(!(pData && nDataNumber)) return -100;

	//追加
	if(nDataNumber != this->m_nColumnNumber) return -100;
	f8* pTmpData = new f8[ (m_nRowNumber +1) * m_nColumnNumber ];
	if(!pTmpData) return 0;
	memcpy(pTmpData, m_pData, sizeof(f8) * m_nRowNumber * m_nColumnNumber );//转移原有数据
	memcpy(pTmpData + m_nRowNumber * m_nColumnNumber, pData, sizeof(f8) * m_nColumnNumber );//追加新一行数据
	delete [] m_pData;//释放原有内存
	m_pData = pTmpData;//转移指针到新数据区

	//后续工作
	m_nRowNumber++;

	return 1;
}




//功能：在原有矩阵中追加一列
/*参数：pData:		欲追加数据的首地址
		nDataNumber:数据长度,原矩阵的行数
返回值：成功返回1，失败返回0，参数错误返回-100
注意：pData必须为有效地址，且数据长度必须等于矩阵的行数*/
i4 CMatrix::AppendNewColumn(f8* pData,i4 nDataNumber)
{
	if(!(pData && nDataNumber)) return -100;

	CMatrix mTmpMatri; this->GetTransposedMatrix(mTmpMatri);
	mTmpMatri.AppendNewRow( pData, nDataNumber);
	mTmpMatri.GetTransposedMatrix(*this);


	return 1;

}






//功能：在原有矩阵中以行的形式追加矩阵，以追加行的形式实现
//参数：
//		SecMatrix 	欲追加数据的矩阵
//返回值：成功返回1，失败返回0，参数错误返回-100
i4 CMatrix::AppendMatrixInRow(const CMatrix& SecMatrix)
{
	//追加
	i4 nSecRow = SecMatrix.GetRowNumber();
	i4 nSecColumn = SecMatrix.GetColumnNumber();
	if(nSecColumn != this->m_nColumnNumber) return -100;
	f8* pTmpData = new f8[ (m_nRowNumber + nSecRow) * m_nColumnNumber ];
	if(!pTmpData) return 0;
	memcpy(pTmpData, m_pData, sizeof(f8) * m_nRowNumber * m_nColumnNumber );//转移原有数据
	memcpy(pTmpData + m_nRowNumber * m_nColumnNumber, SecMatrix.GetDataAddress(), sizeof(f8) * nSecRow * nSecColumn );//追加新一行数据
	delete [] m_pData;//释放原有内存
	m_pData = pTmpData;//转移指针到新数据区

	//后续工作
	m_nRowNumber += nSecRow;

	return 1;
}





//功能：在原有矩阵中以列的形式追加矩阵，在追加行中实现
//参数：
//		SecMatrix 	欲追加数据的矩阵
//返回值：成功返回1，失败返回0，参数错误返回-100
i4 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;
}




//功能：获取原矩阵中的一行
/*参数：
		nRowNo:	欲取数据在矩阵中的行号，从0起算
		pData:		返回数据的首地址，必须已经实化，并有足够的空间
返回值：成功返回1，失败返回0，参数错误返回-100
注意：pData必须为有效地址，且空间长度必须大于等于矩阵的列数*/

i4 CMatrix::GetOneRow(i4 nRowNo, f8* pData) const
{
	if(nRowNo >= m_nRowNumber) return -100;
	memcpy(pData, m_pData + nRowNo * m_nColumnNumber, sizeof(f8) * m_nColumnNumber );//拷贝数据

	return 1;
}



//功能：获取原矩阵中的一行
/*参数：nRowNo:		欲取数据在矩阵中的行号，从0起算
		maRowMAtrix:	行矩阵结果
返回值：成功返回1，失败返回0，参数错误返回-100*/

i4 CMatrix::GetOneRow(i4 nRowNo, CMatrix& maRowMAtrix) const
{
	if(nRowNo >= m_nRowNumber) return -100;
	maRowMAtrix.InitEmptyMatrix(1, m_nColumnNumber);
	GetOneRow(nRowNo, maRowMAtrix.GetDataAddress());

	return 1;
}


//功能：获取原矩阵中的一列。通过获取行函数实现
/*参数：
		nColumnNo:	欲取数据在矩阵中的列号，从0起算
		pData:		返回数据的首地址，必须已经实化，并有足够的空间
返回值：成功返回1，失败返回0，参数错误返回-100
注意：pData必须为有效地址，且空间长度必须大于等于矩阵的行数*/
/*
i4 CMatrix::GetOneColumn(i4 nColumnNo, f8* pData)const
{
	if(nColumnNo >= m_nColumnNumber) return -100;
	CMatrix maTmp = this->GetTransposedMatrix();
	maTmp.GetOneRow(nColumnNo, pData);

	return 1;
}
*/



//功能：获取原矩阵中的一列
/*参数：
		nColumnNo:	欲取数据在矩阵中的列号，从0起算
		maColumnMAtrix:	列矩阵结果
返回值：成功返回1，失败返回0，参数错误返回-100*/
/*
i4 CMatrix::GetOneColumn(i4 nColumnNo, CMatrix& maColumnMAtrix)const
{
	if(nColumnNo >= m_nColumnNumber) return -100;
	maColumnMAtrix.InitEmptyMatrix(m_nRowNumber, 1);
	GetOneColumn(nColumnNo, maColumnMAtrix.GetDataAddress());
	return 1;
}
*/



//功能：在原有矩阵中删除一行
/*参数：nRowNo:欲删除行的行号,注意：行列号从0起算
返回值：成功返回1，失败返回0，参数错误返回-100*/
i4 CMatrix::DeleteOneRow(i4 nRowNo)
{
	ASSERT(m_pData);

	if(nRowNo > m_nRowNumber-1) return -100;

//	f8 * pTmpData = new f8[m_nColumnNumber * ()];

	if(nRowNo != m_nRowNumber-1)//如果删除最后一行，就直接将行数减1即可
	{
		memmove(m_pData+ nRowNo * m_nColumnNumber, 
			m_pData+ (nRowNo+1) * m_nColumnNumber, 
			(m_nRowNumber - (nRowNo +1)) * m_nColumnNumber * sizeof(f8));
	}

	//后续工作
	m_nRowNumber--;

	return 1;

}




//功能：在原有矩阵中删除一行，并将此行数据以行矩阵形式返回
/*参数：nRowNo:欲删除行的行号,注意：行列号从0起算
		maRowMAtrix:	行矩阵结果
返回值：成功返回1，失败返回0，参数错误返回-100*/
/*
i4 CMatrix::DeleteOneRow(i4 nRowNo, CMatrix& maRowMAtrix)
{
	if(nRowNo > m_nRowNumber-1) return -100;
	if(!GetOneRow(nRowNo,maRowMAtrix)) return 0;
	return DeleteOneRow(nRowNo);
}
*/



//功能：在原有矩阵中删除一列
/*参数：nColumnNo:	欲删除列的列号,注意：行列号从0起算
返回值：成功返回1，失败返回0，参数错误返回-100
实现方法：先定义一转置矩阵，并将之删除一行，然后再转置回来*/
i4 CMatrix::DeleteOneColumn(i4 nColumnNo)
{
	if(nColumnNo > m_nColumnNumber-1) return -100;

	CMatrix mTmpMatri; this->GetTransposedMatrix(mTmpMatri);
	int bDel = mTmpMatri.DeleteOneRow(nColumnNo);

	ASSERT(bDel == 1);

	mTmpMatri.GetTransposedMatrix(*this);

	return 1;
}




//功能：在原有矩阵中删除一列，并将此列数据以列矩阵形式返回
/*参数：nColumnNo:		欲删除列的列号,注意：行列号从0起算
		maColumnMatrix:	列矩阵结果
返回值：成功返回1，失败返回0，参数错误返回-100*/
/*
i4 CMatrix::DeleteOneColumn(i4 nColumnNo, CMatrix& maColumnMatrix)
{
	if(nColumnNo > m_nColumnNumber-1) return -100;

	if(!GetOneColumn( nColumnNo, maColumnMatrix)) return 0;
	return DeleteOneColumn( nColumnNo);
}
*/


//功能：将前面行的数据合并到目标行
//参数：1	nRowNo：欲合并的行号,从0起算
//		2	nComMode：合并模式：1：相加；-1：相减
//返回值：成功返回1，失败返回0，参数错误返回-100
i4 CMatrix::CombineRow(i4 nRowNo, i4 nComMode)
{
	if(nRowNo > m_nRowNumber) return -100;

	//将欲合并行数据导出
	f8* pTmpRow= new f8[m_nColumnNumber];
	if(!pTmpRow) return 0;
	memcpy(pTmpRow, m_pData + nRowNo * m_nColumnNumber, sizeof(f8) * m_nColumnNumber);

	//将数据合并，包括目标行
	for(i4 i=0;i<m_nRowNumber;i++)
	{
		for(i4 j=0;j<m_nColumnNumber;j++)
		{
			*(m_pData+ i * m_nColumnNumber + j ) += *(pTmpRow + j ) * nComMode;//nRowNo从0起算
		}
	}
	
	//删去nRowNo行
	this->DeleteOneRow(nRowNo);

	//后续
	delete []pTmpRow;

	return 1;
}





//参数：1	nColumnNo ：欲合并的列号,从0起算
//		2	nComMode：合并模式：1：相加；-1：相减
//返回值：成功返回1，失败返回0，参数错误返回-100
/*
i4 CMatrix::CombineColumn(i4 nColumnNo, i4 nComMode)
{
	CMatrix maTmp; this->GetTransposedMatrix(maTmp);//得到转置矩阵
	maTmp.CombineRow(nColumnNo,nComMode);//合并行
	maTmp.GetTransposedMatrix(*this);

	return 1;
}*/


//功能：输出矩阵的迹
//参数： 无
//返回值： 矩阵的迹
f8 CMatrix::GetTrace()
{
	if(!m_bTraceIsGot)
	{
		CalcuTrace();
		m_bTraceIsGot = 1;
	}
	return m_dTrace;
}


//功能：计算矩阵的迹，矩阵的迹为矩阵的特征值之和
//参数：无
//返回值：成功返回1 ，失败返回0
i4 CMatrix::CalcuTrace()
{
	if( m_nRowNumber != m_nColumnNumber)
	{	//如果不为方阵，则无迹
		m_dTrace = 0.0;
		return 0;
	}
	else
	{
		//计算矩阵迹
		m_dTrace = 0;
		for(i4 i=0;i<m_nRowNumber;i++)
		{
			m_dTrace += *(m_pData + i*(m_nColumnNumber+1) );
		}
	}
	return 1;
}


//功能：计算矩阵的行列式
//参数：无
//返回值：矩阵的行列式
f8 CMatrix::GetValue() 
{
	if(!m_bValueIsGot)
	{
		CalcuValue();
		m_bValueIsGot = 1;
	}
	return m_dValue;
}


//功能：计算矩阵的行列式，矩阵的行列式为矩阵的特征值之积
//参数：无
//返回值：成功1，失败0
i4 CMatrix::CalcuValue()
{
	if( m_nRowNumber != m_nColumnNumber)
	{	//如果不为方阵，则无行列式
		m_dValue = 0.0;
		return 0;
	}
	else
	{
		//计算行列式
	}
	return 1;
}


//功能：输出矩阵范数
//参数：无
//返回值：矩阵范数
f8 CMatrix::GetNorm()
{
	if(!m_bNormIsGot)
	{
		CalcuNorm();
		m_bNormIsGot = 1;
	}
	if (m_dNorm >1)
	{
		ASSERT(TRUE);
	}
	return m_dNorm;
}


//功能：计算矩阵Frobenius范数
//参数：无
//返回值：1