matrix.cpp

设计了矩阵类,该类实现了矩阵的数学运算,包括矩阵乘除/求逆/求特征向量的!

		    if (j != k) 
			{
		        mxTmp[k][j] *= mxTmp[k][k];
			}
		} 

		for (i = 0; i < mxTmp.Row(); i++) 
		{ 
		    if (i != k) 
			{ 
		        for (j = 0; j < mxTmp.Col(); j++) 
				{ 
		            if (j != k) 
					{
		                mxTmp[i][j] = mxTmp[i][j] - mxTmp[i][k] * mxTmp[k][j]; 
					}
				} 
			} 
		} 

		for (i = 0; i < mxTmp.Row(); i++) 
		{ 
		    if (i != k) 
			{
		        mxTmp[i][k] *= -mxTmp[k][k]; 
			}
		} 
	}//for of end

	for (k = mxTmp.Row()-1; k >= 0; k--) 
	{ 
		if ((pJ[k] != -1) && (pJ[k] != k)) 
		{ 
			mxTmp.SwapCol(k, pJ[k]);
		} 

		if ((pI[k] != -1) && (pI[k] != k))
		{ 
			mxTmp.SwapRow(k, pI[k]);
		} 
	} 

	delete [] pI;
	delete [] pJ;

	return fDet*nSign; 
}

int CMatrix::SolveLinearQquations(double ary [])//列主元消元法求线性方程组
{
	ASSERT( (m_nRow+1) == m_nCol );

	int i, j, nIndex;
	double fTmp;
    CMatrix mxTmp(*this);

    for (int k = 0; k < mxTmp.Row()-1; k++)
    {
        nIndex = mxTmp.Pivot(k);
        if (nIndex == -1)// mxTmp[k][k] == 0 ==>> xk有多解
        {
            //AfxMessageBox("Invalid Matrix!");
			continue;
        }

        for (i = k+1; i < mxTmp.Row(); i++)
        {
			fTmp = mxTmp[i][k] / mxTmp[k][k];

            for (j = k+1; j < mxTmp.Col(); j++)
            {
                mxTmp[i][j] -= fTmp * mxTmp[k][j];
            }
        }
    }

	for (i = mxTmp.Row()-1; i >= 0; i--)
	{
		ary[i] = 0;
		fTmp = 0 ;

		for (j = i+1; j < mxTmp.Row(); j++)
		{
		    fTmp += mxTmp[i][j] * ary[j];  
		}

		if (fabs(mxTmp[i][i]) < EPSINON)
			ary[i] = 0;
		else
		    ary[i] = (mxTmp[i][mxTmp.Col()-1] - fTmp) / mxTmp[i][i];
	}

    return ( nIndex );
}

BOOL CMatrix::SaveMatrix()
{ 
	TCHAR BASED_CODE szFilter[] = _T("ASCII Files(*.txt)|*.txt|Binary Files(*.mxb)|*.mxb|");

	CFileDialog dlg(false, _T("MatrixFile.mxa"), NULL, OFN_HIDEREADONLY|OFN_OVERWRITEPROMPT, szFilter);

	if(dlg.DoModal() != IDOK)
	{
        return FALSE;
	}

	CString strExt = dlg.GetFileExt();
	strExt.MakeUpper();
    BOOL bASCII = (strExt == _T("TXT"));
	

	BOOL bFlag = SaveMatrix(dlg.GetPathName(), bASCII);

	return bFlag;
}

BOOL CMatrix::SaveMatrix(CString strPath, BOOL bASCII)
{ 
	CFile file(strPath, CFile::modeCreate | CFile::modeReadWrite);
	CArchive ar(&file, CArchive::store);

	if(bASCII)
	{
		CString strTmp, strRow;
		
		ar.WriteString(_T("-------------------------------"));
		ar.WriteString(_T("\r\n"));//回车换行符号
		strTmp.Format(_T("ROW : %d, COL : %d"), m_nRow, m_nCol);
		ar.WriteString(strTmp);
		ar.WriteString(_T("\r\n"));

		for(int i = 0; i < m_nRow; i++)
		{
		    strRow = _T("");
			for(int j = 0; j < m_nCol; j++)
			{
			    strTmp.Format(_T("%.8lf  "), (*this)[i][j]);
			    strRow += strTmp;
			}

			ar.WriteString(strRow);
			ar.WriteString(_T("\r\n"));
		} 
        
		ar.WriteString(_T("-------------------------------"));
		ar.WriteString(_T("\r\n"));

		return TRUE;
	}
	else
	{
	    Serialize(ar);
	    return TRUE;
	}

	return FALSE;
}

BOOL CMatrix::LoadMatrix(CString strPath)
{ 
	this->Empty();

	CFile file(strPath, CFile::modeRead);
	CArchive ar(&file, CArchive::load);

	Serialize(ar);

	return TRUE;
}

BOOL CMatrix::LoadMatrix()
{
	this->Empty();

	TCHAR BASED_CODE szFilter[] = _T("Binary Files(*.mxb)|*.mxb|");
	CFileDialog dlg(true, _T("Binary Files(*.mxb)"), NULL, OFN_HIDEREADONLY|OFN_OVERWRITEPROMPT, szFilter);

	if(dlg.DoModal() == IDOK)
	{
		CString strPath = dlg.GetPathName();
		CFile file(strPath, CFile::modeRead);
		CArchive ar(&file, CArchive::load);

		Serialize(ar);

		return TRUE;
	}

	return FALSE;
}


/*---------------------------------------
*友元
----------------------------------------*/
CMatrix operator + (CMatrix & mx, double k)//重载 + : 矩阵与数字相加
{
	CMatrix mxTmp(mx.Row(), mx.Col());

	for (int i = 0; i < mx.Row(); i++)
	{
		for (int j = 0; j < mx.Col(); j++)
		{
			mxTmp[i][j] = k + mx[i][j];
		}
	}

    return mxTmp;
}

CMatrix operator + (double k, CMatrix & mx)//重载 + : 矩阵与数字相加
{
	CMatrix mxTmp(mx.Row(), mx.Col());

	for (int i = 0; i < mx.Row(); i++)
	{
		for (int j = 0; j < mx.Col(); j++)
		{
			mxTmp[i][j] = k + mx[i][j];
		}
	}

    return mxTmp;
}

CMatrix operator + (CMatrix & mx1, CMatrix & mx2)//重载 + : 矩阵相加
{
    ASSERT((mx1.Row() == mx2.Row()) && (mx1.Col() == mx2.Col()));

	CMatrix mxTmp(mx1.Row(), mx1.Col());

	for (int i = 0; i < mxTmp.Row(); i++)
	{
		for (int j = 0; j < mxTmp.Col(); j++)
		{
		    mxTmp[i][j] = mx1[i][j] + mx2[i][j];
		}
	}

	return mxTmp;
}

CMatrix operator - (CMatrix & mx, double k)//重载 - : 矩阵与数字相减
{
	CMatrix mxTmp(mx.Row(), mx.Col());

	for (int i = 0; i < mx.Row(); i++)
	{
		for (int j = 0; j < mx.Col(); j++)
		{
			mxTmp[i][j] = mx[i][j] - k;
		}
	}

    return mxTmp;
}

CMatrix operator - (double k, CMatrix & mx)//重载 - : 矩阵与数字相减
{
	CMatrix mxTmp(mx.Row(), mx.Col());

	for (int i = 0; i < mx.Row(); i++)
	{
		for (int j = 0; j < mx.Col(); j++)
		{
			mxTmp[i][j] = k - mx[i][j];
		}
	}

    return mxTmp;
}

CMatrix operator - (CMatrix & mx1, CMatrix & mx2)//重载 - : 矩阵相减
{
    ASSERT((mx1.Row() == mx2.Row()) && (mx1.Col() == mx2.Col()));

	CMatrix mxTmp(mx1.Row(), mx1.Col());

	for (int i = 0; i < mx1.Row(); i++)
	{
		for (int j = 0; j < mx2.Col(); j++)
		{
		    mxTmp[i][j] = mx1[i][j] - mx2[i][j];
		}
	}

	return mxTmp;
}

CMatrix operator * (CMatrix & mx, double k)//重载 * : 矩阵与数字相乘
{
	CMatrix mxTmp(mx.Row(), mx.Col());

	for (int i = 0; i < mx.Row(); i++)
	{
		for (int j = 0; j < mx.Col(); j++)
		{
			mxTmp[i][j] = mx[i][j] * k;
		}
	}

    return mxTmp;
}

CMatrix operator * (double k, CMatrix & mx)//重载 * : 矩阵与数字相乘
{
	CMatrix mxTmp(mx.Row(), mx.Col());

	for (int i = 0; i < mx.Row(); i++)
	{
		for (int j = 0; j < mx.Col(); j++)
		{
			mxTmp[i][j] = k * mx[i][j];
		}
	}

    return mxTmp;
}

CMatrix operator * (CMatrix & mx1, CMatrix & mx2)//重载 * : 矩阵相乘
{
    ASSERT((mx1.Row() == mx2.Row()) && (mx1.Col() == mx2.Col()));

	CMatrix mxTmp(mx1.Row(), mx1.Col());

	for (int i = 0; i < mx1.Row(); i++)
	{
		for (int j = 0; j < mx2.Col(); j++)
		{
		    mxTmp[i][j] = mx1[i][j] * mx2[i][j];
		}
	}

	return mxTmp;
}

BOOL operator == (CMatrix & mx1, CMatrix & mx2)//重载 ==
{
    if ((mx1.Row() != mx2.Row()) || (mx1.Col() != mx2.Col()))
	{
        return FALSE;
	}

    for (int i = 0; i < mx1.Row(); i++)
	{
        for (int j = 0; j < mx1.Col(); j++)
		{
            if (mx1[i][j] != mx2[i][j])
			{
                return FALSE;
			}
		}
	}

    return TRUE;
}

BOOL operator != (CMatrix & mx1, CMatrix & mx2)//重载 !=
{
    return((mx1 == mx2) ? FALSE : TRUE);
}

CMatrix operator ^ (CMatrix & mx, int pow)//矩阵次幂
{    
	ASSERT(pow > 1);

	CMatrix mxTmp(mx);

	for (int i = 2; i <= pow; i++)
    {
        mxTmp *= mx;
    }

    return mxTmp;
}

CMatrix operator ~ (CMatrix & mx)//矩阵转置
{    
	CMatrix mxTmp(mx.Col(), mx.Row());

	for (int i = 0; i < mx.Row(); i++)
	{
		for (int j = 0; j < mx.Col(); j++)
		{
			mxTmp[j][i] = mx[i][j];
		}
	}

	return mxTmp;
}

CMatrix operator ! (CMatrix & mx)//逆矩阵
{
	ASSERT(mx.Row() == mx.Col());

	int *pI, *pJ;

	pI = new int[mx.Row()];
	ASSERT(pI != NULL);
	
	pJ = new int[mx.Col()];
	ASSERT(pJ != NULL);

    CMatrix mxTmp(mx);
	int k, i, j;

	for (k = 0; k < mxTmp.Row(); k++) 
	{
	    pI[k] = -1;
		pJ[k] = -1;
	}

	for (k = 0; k < mxTmp.Row(); k++) 
	{ 
	    //全选主元 
	    double fMax = MINDOUBLE; 
	    for (i = k; i < mxTmp.Row(); i++) 
		{ 
	        for (j = k; j < mxTmp.Col(); j++) 
			{ 
	            double fTmp = fabs(mxTmp[i][j]); 
	            if (fTmp > fMax) 
				{ 
	                fMax = fTmp; 
	                pI[k] = i; 
	                pJ[k] = j; 
				} 
			} 
		} 
	
		if (fabs(fMax) < EPSINON) 
		{
			//AfxMessageBox(_T("Matrix Not Inverse!"));
			return mxTmp;
		}

	    if (pI[k] != k) 
		{ 
			mxTmp.SwapRow(k, pI[k]);
		} 
	
		if (pJ[k] != k) 
		{ 
			mxTmp.SwapCol(k, pJ[k]);
		} 

	    //计算逆矩阵 
		mxTmp[k][k] = 1.0f / mxTmp[k][k]; 
		
		for (j = 0; j < mxTmp.Col(); j++) 
		{ 
		    if (j != k) 
			{
		        mxTmp[k][j] *= mxTmp[k][k];
			}
		} 

		for (i = 0; i < mxTmp.Row(); i++) 
		{ 
		    if (i != k) 
			{ 
		        for (j = 0; j < mxTmp.Col(); j++) 
				{ 
		            if (j != k) 
					{
		                mxTmp[i][j] = mxTmp[i][j] - mxTmp[i][k] * mxTmp[k][j]; 
					}
				} 
			} 
		} 

		for (i = 0; i < mxTmp.Row(); i++) 
		{ 
		    if (i != k) 
			{
		        mxTmp[i][k] *= -mxTmp[k][k]; 
			}
		} 
	}//for of end

	for (k = mxTmp.Row()-1; k >= 0; k--) 
	{ 
		if ((pJ[k] != -1) && (pJ[k] != k)) 
		{ 
			mxTmp.SwapCol(k, pJ[k]);
		} 

		if ((pI[k] != -1) && (pI[k] != k))
		{ 
			mxTmp.SwapRow(k, pI[k]);
		} 
	} 

	delete [] pI;
	delete [] pJ;

	return mxTmp; 
}