xxmatrix

矩阵计算的c++代码

//////////////////////////////////////////////////////////////////////////////////////////////
//	friends functions: operators
//////////////////////////////////////////////////////////////////////////////////////////////
#pragma once
#ifndef _XXMATRIX_
#define _XXMATRIX_

//对应元素相除
const CMatrix operator / (const CMatrix& left, const CMatrix& right)
{
	int i, j, _M, _N, _O, _P;
	
	_M = left.Rows();	_N = left.Cols();
	_O = right.Rows();	_P = right.Cols();

	assert((_M==_O) && (_N==_P));

	if(left.IsEmpty())
	{// if the source matrix is null, return a null matrix
		return CMatrix();
	}

	CMatrix _result(_M, _N);

	for(i=0; i<_M; ++i)
	{
		for(j=0; j<_N; ++j)
		{	
			assert( right(i,j)!=0.0 );
			_result(i,j) = left(i,j) / right(i,j);
		}
	}

	return _result;
}
//对应元素相乘
// 这个函数注意要用小括号 // the parentheses must be used in this function
const CMatrix operator && (const CMatrix& left, const CMatrix& right)
{
	int i, j, _M, _N, _O, _P;
	
	_M = left.Rows();	_N = left.Cols();
	_O = right.Rows();	_P = right.Cols();

	assert((_M==_O) && (_N==_P));

	if(left.IsEmpty())
	{// if the source matrix is null, return a null matrix
		return CMatrix();
	}

	CMatrix _result(_M, _N);

	for(i=0; i<_M; ++i)
	{
		for(j=0; j<_N; ++j)
		{	_result(i,j) = left(i,j) * right(i,j);	}
	}

	return _result;
}

//	check whether the both matrices equal
bool operator == (const CMatrix& left, const CMatrix& right)
{
	int i, j, _M, _N, _O, _P;
	
	_M = left.Rows();	_N = left.Cols();
	_O = right.Rows();	_P = right.Cols();

	if((_M!=_O)||(_N!=_P))	return false;
	if(left.IsEmpty())		return true;
	if(&left == &right)		return true;	// 检查是否是自己

	for(i=0; i<_M; ++i)
	{
		for(j=0; j<_N; ++j)
		{
			if(left(i,j) != right(i,j))
			{	return false;	}
		}
	}
	return true;
}
bool operator != (const CMatrix& left, const CMatrix& right)
{	return !(left == right);	}

// operator +
const CMatrix operator+(const CMatrix& left, __MatrixType__ right)
{	
	CMatrix _result(left);
	_result += right;
	return _result;
}
const CMatrix operator+(__MatrixType__ left, const CMatrix& right)
{	return right + left;	}

const CMatrix operator+(const CMatrix& left, const CMatrix& right)
{
	CMatrix _result(left);
	_result += right;
	return _result;
}

// operator -
const CMatrix operator-(const CMatrix& left, __MatrixType__ right)
{
	CMatrix _result(left);
	_result -= right;
	return _result;
}
const CMatrix operator-(__MatrixType__ left, const CMatrix& right)
{	return left + (-right);	}
const CMatrix operator-(const CMatrix& left, const CMatrix& right)
{
	CMatrix _result(left);
	_result -= right;
	return _result;
}

// operator *
const CMatrix operator*(const CMatrix& left, __MatrixType__ right)
{
	CMatrix _result(left);
	_result *= right;
	return _result;
}

const CMatrix operator*(__MatrixType__ left, const CMatrix& right)
{	return right * left;	}

const CMatrix operator*(const CMatrix& left, const CMatrix& right)
{	// left[_M*_N], right[_O*_P]
	int i, j, k, _M, _N, _O, _P;
	__MatrixType__ tSum;
	
	_M = left.Rows();	_N = left.Cols();
	_O = right.Rows();	_P = right.Cols();
	
	if(_M==0 && _N==0 && _O==0 && _P==0)
	{	return CMatrix();	}

	assert(_N == _O);

	CMatrix _result(_M, _P);
	for(i=0; i<_M; ++i)
	{		
		for(j=0; j<_P; ++j)
		{
			tSum = 0;
			for(k=0; k<_N; ++k)
			{	tSum += left(i,k) * right(k,j);	}
			_result(i,j) = tSum;
		}
	}
	return _result;
}

const CVector operator * (const CMatrix& left, const CVector& right)
{	// left[_M*_N], right[_P]
	int i, k, _M, _N;
	__MatrixType__ tSum;
	
	_M = left.Rows();	_N = left.Cols();
	int _P = right.size();
	
	if(_M==0 && _N==0 && _P==0)
	{	return CVector();	}

	assert(_N == _P);

	CVector _result(_M);
	for(i=0; i<_M; ++i)
	{		
		tSum = 0;
		for(k=0; k<_N; ++k)
		{	tSum += left(i,k) * right[k];	}
		_result[i] = tSum;
	}
	return _result;
}
const vector<__MatrixType__> operator * (const CMatrix& left, const vector<__MatrixType__>& right)
{	// left[_M*_N], right[_P]
	CVector _right(right), _xx(left.Rows());
	vector<__MatrixType__> _result(left.Rows());
	
	_xx = left * _right;
	
	for(int i=0; i<_xx.size(); ++i)
	{	_result[i] = _xx[i];	}

	return _result;
}
//////////////////////////////
// operator /
// 除以一个非零的数
// divided by a non-zero number
const CMatrix operator / (const CMatrix& left, __MatrixType__ right)
{	
	assert( right!=0.0 );
	return left*(1.0/right);
}

///////////////////////////////////////////////
//	friends functions: implementions
///////////////////////////////////////////////
void mul(const CMatrix& left, const CMatrix& right, CMatrix& result)
{	result = left * right;	}

const CMatrix sqrt(const CMatrix& src)
{
	if(src.IsEmpty())
	{// if the source matrix is null, return a null matrix
		return CMatrix();
	}

	int i, j, _M, _N;
	_M = src.Rows();	_N = src.Cols();

	CMatrix _result(_M,_N);

	for(i=0; i<_M; ++i)
	{
		for(j=0; j<_N; ++j)
		{
			assert(!(src(i,j) < 0.0));
			_result(i,j) = std::sqrt(src(i,j));
		}
	}
	return _result;
}
const CMatrix abs(const CMatrix& src)
{
	if(src.IsEmpty())
	{// if the source matrix is null, return a null matrix
		return CMatrix();
	}

	int i, j, _M, _N;
	_M = src.Rows();	_N = src.Cols();

	CMatrix _result(_M,_N);

	for(i=0; i<_M; ++i)
	{
		for(j=0; j<_N; ++j)
		{	_result(i,j) = std::fabs(src(i,j));	}
	}
	return _result;
}

#endif // _XXMATRIX_