📄 cmatrix.cpp

📁 相对定向的坐标解算
💻 CPP
📖 第 1 页 / 共 3 页
字号:
12 3 下一页
// Matrix.cpp: implementation of the CMatrix class.
//
//////////////////////////////////////////////////////////////////////


#include "stdafx.h"
#include "CMatrix.h"
#include <math.h>

//////////////////////////////////////////////////////////////////////
// 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);
12 3 下一页
💿 文件大小 135 K
👤 上传用户 fengkuangyidao
📂 所属分类其他
🏷️ 相关标签

#定向 #解算
⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -