操作矩阵的类 cmatrix.txt

一个操作矩阵的类CMatrix的算法

////////////////////////////////////////////////////////////////////// 
// Matrix.cpp 
// 
// 操作矩阵的类 CMatrix 的实现文件 
// 
// 周长发编制, 2002/8 
////////////////////////////////////////////////////////////////////// 

#include "stdafx.h" 
#include "Matrix.h" 

#ifdef _DEBUG 
#undef THIS_FILE 
static char THIS_FILE[]=__FILE__; 
#define new DEBUG_NEW 
#endif 

////////////////////////////////////////////////////////////////////// 
// Construction/Destruction 
////////////////////////////////////////////////////////////////////// 

////////////////////////////////////////////////////////////////////// 
// 基本构造函数 
////////////////////////////////////////////////////////////////////// 
CMatrix::CMatrix() 
{ 
m_nNumColumns = 1; 
m_nNumRows = 1; 
m_pData = NULL; 
BOOL bSuccess = Init(m_nNumRows, m_nNumColumns); 
ASSERT(bSuccess); 
} 

////////////////////////////////////////////////////////////////////// 
// 指定行列构造函数 
// 
// 参数： 
// 1. int nRows - 指定的矩阵行数 
// 2. int nCols - 指定的矩阵列数 
////////////////////////////////////////////////////////////////////// 
CMatrix::CMatrix(int nRows, int nCols) 
{ 
m_nNumRows = nRows; 
m_nNumColumns = nCols; 
m_pData = NULL; 
BOOL bSuccess = Init(m_nNumRows, m_nNumColumns); 
ASSERT(bSuccess); 
} 

////////////////////////////////////////////////////////////////////// 
// 指定值构造函数 
// 
// 参数： 
// 1. int nRows - 指定的矩阵行数 
// 2. int nCols - 指定的矩阵列数 
// 3. double value[] - 一维数组，长度为nRows*nCols，存储矩阵各元素的值 
////////////////////////////////////////////////////////////////////// 
CMatrix::CMatrix(int nRows, int nCols, double value[]) 
{ 
m_nNumRows = nRows; 
m_nNumColumns = nCols; 
m_pData = NULL; 
BOOL bSuccess = Init(m_nNumRows, m_nNumColumns); 
ASSERT(bSuccess); 

SetData(value); 
} 

////////////////////////////////////////////////////////////////////// 
// 方阵构造函数 
// 
// 参数： 
// 1. int nSize - 方阵行列数 
////////////////////////////////////////////////////////////////////// 
CMatrix::CMatrix(int nSize) 
{ 
m_nNumRows = nSize; 
m_nNumColumns = nSize; 
m_pData = NULL; 
BOOL bSuccess = Init(nSize, nSize); 
ASSERT (bSuccess); 
} 

////////////////////////////////////////////////////////////////////// 
// 方阵构造函数 
// 
// 参数： 
// 1. int nSize - 方阵行列数 
// 2. double value[] - 一维数组，长度为nRows*nRows，存储方阵各元素的值 
////////////////////////////////////////////////////////////////////// 
CMatrix::CMatrix(int nSize, double value[]) 
{ 
m_nNumRows = nSize; 
m_nNumColumns = nSize; 
m_pData = NULL; 
BOOL bSuccess = Init(nSize, nSize); 
ASSERT (bSuccess); 

SetData(value); 
} 

////////////////////////////////////////////////////////////////////// 
// 拷贝构造函数 
// 
// 参数： 
// 1. const CMatrix& other - 源矩阵 
////////////////////////////////////////////////////////////////////// 
CMatrix::CMatrix(const CMatrix& other) 
{ 
m_nNumColumns = other.GetNumColumns(); 
m_nNumRows = other.GetNumRows(); 
m_pData = NULL; 
BOOL bSuccess = Init(m_nNumRows, m_nNumColumns); 
ASSERT(bSuccess); 

// copy the pointer 
memcpy(m_pData, other.m_pData, 
sizeof(double)*m_nNumColumns*m_nNumRows); 
} 

////////////////////////////////////////////////////////////////////// 
// 析构函数 
////////////////////////////////////////////////////////////////////// 
CMatrix::~CMatrix() 
{ 
if (m_pData) 
{ 
delete[] m_pData; 
m_pData = NULL; 
} 
} 

////////////////////////////////////////////////////////////////////// 
// 初始化函数 
// 
// 参数： 
// 1. int nRows - 指定的矩阵行数 
// 2. int nCols - 指定的矩阵列数 
// 
// 返回值：BOOL 型，初始化是否成功 
////////////////////////////////////////////////////////////////////// 
BOOL CMatrix::Init(int nRows, int nCols) 
{ 
if (m_pData) 
{ 
delete[] m_pData; 
m_pData = NULL; 
} 

m_nNumRows = nRows; 
m_nNumColumns = nCols; 
int nSize = nCols*nRows; 
if (nSize < 0) 
return FALSE; 

// 分配内存 
m_pData = new double[nSize]; 

if (m_pData == NULL) 
return FALSE; // 内存分配失败 

if (IsBadReadPtr(m_pData, sizeof(double) * nSize)) 
return FALSE; 

// 将各元素值置0 
memset(m_pData, 0, sizeof(double) * nSize); 

return TRUE; 
} 

////////////////////////////////////////////////////////////////////// 
// 将方阵初始化为单位矩阵 
// 
// 参数： 
// 1. int nSize - 方阵行列数 
// 
// 返回值：BOOL 型，初始化是否成功 
////////////////////////////////////////////////////////////////////// 
BOOL CMatrix::MakeUnitMatrix(int nSize) 
{ 
if (! Init(nSize, nSize)) 
return FALSE; 

for (int i=0; i<nSize; ++i) 
for (int j=0; j<nSize; ++j) 
if (i == j) 
SetElement(i, j, 1); 

return TRUE; 
} 

////////////////////////////////////////////////////////////////////// 
// 将字符串转化为矩阵的值 
// 
// 参数： 
// 1. CString s - 数字和分隔符构成的字符串 
// 2. const CString& sDelim - 数字之间的分隔符，默认为空格 
// 3. BOOL bLineBreak - 行与行之间是否有回车换行符，默认为真(有换行符) 
// 当该参数为FALSE时，所有元素值都在一行中输入，字符串的第一个 
// 数值应为矩阵的行数，第二个数值应为矩阵的列数 
// 
// 返回值：BOOL 型，转换是否成功 
////////////////////////////////////////////////////////////////////// 
BOOL CMatrix::FromString(CString s, const CString& sDelim /*= " "*/, BOOL 
bLineBreak /*= TRUE*/) 
{ 
if (s.IsEmpty()) 
return FALSE; 

// 分行处理 
if (bLineBreak) 
{ 
CTokenizer tk(s, "\r\n"); 

CStringList ListRow; 
CString sRow; 
while (tk.Next(sRow)) 
{ 
sRow.TrimLeft(); 
sRow.TrimRight(); 
if (sRow.IsEmpty()) 
break; 

ListRow.AddTail(sRow); 
} 

// 行数 
m_nNumRows = ListRow.GetCount(); 

sRow = ListRow.GetHead(); 
CTokenizer tkRow(sRow, sDelim); 
CString sElement; 
// 列数 
m_nNumColumns = 0; 
while (tkRow.Next(sElement)) 
{ 
m_nNumColumns++; 
} 

// 初始化矩阵 
if (! Init(m_nNumRows, m_nNumColumns)) 
return FALSE; 

// 设置值 
POSITION pos = ListRow.GetHeadPosition(); 
for (int i=0; i<m_nNumRows; i++) 
{ 
sRow = ListRow.GetNext(pos); 
int j = 0; 
CTokenizer tkRow(sRow, sDelim); 
while (tkRow.Next(sElement)) 
{ 
sElement.TrimLeft(); 
sElement.TrimRight(); 
double v = atof(sElement); 
SetElement(i, j++, v); 
} 
} 

return TRUE; 
} 

// 不分行（单行）处理 

CTokenizer tk(s, sDelim); 

CString sElement; 

// 行数 
tk.Next(sElement); 
sElement.TrimLeft(); 
sElement.TrimRight(); 
m_nNumRows = atoi(sElement); 

// 列数 
tk.Next(sElement); 
sElement.TrimLeft(); 
sElement.TrimRight(); 
m_nNumColumns = atoi(sElement); 

// 初始化矩阵 
if (! Init(m_nNumRows, m_nNumColumns)) 
return FALSE; 

// 设置值 
int i = 0, j = 0; 
while (tk.Next(sElement)) 
{ 
sElement.TrimLeft(); 
sElement.TrimRight(); 
double v = atof(sElement); 
SetElement(i, j++, v); 

if (j == m_nNumColumns) 
{ 
j = 0; 
i++; 
if (i == m_nNumRows) 
break; 
} 
} 

return TRUE; 
} 

////////////////////////////////////////////////////////////////////// 
// 将矩阵各元素的值转化为字符串 
// 
// 参数： 
// 1. const CString& sDelim - 数字之间的分隔符，默认为空格 
// 2 BOOL bLineBreak - 行与行之间是否有回车换行符，默认为真(有换行符) 
// 
// 返回值：CString 型，转换得到的字符串 
////////////////////////////////////////////////////////////////////// 
CString CMatrix::ToString(const CString& sDelim /*= " "*/, BOOL bLineBreak 
/*= TRUE*/) const 
{ 
CString s=""; 

for (int i=0; i<m_nNumRows; ++i) 
{ 
for (int j=0; j<m_nNumColumns; ++j) 
{ 
CString ss; 
ss.Format("%f", GetElement(i, j)); 
s += ss; 

if (bLineBreak) 
{ 
if (j != m_nNumColumns-1) 
s += sDelim; 
} 
else 
{ 
if (i != m_nNumRows-1 || j != m_nNumColumns-1) 
s += sDelim; 
} 
} 
if (bLineBreak) 
if (i != m_nNumRows-1) 
s += "\r\n"; 
} 

return s; 
} 

////////////////////////////////////////////////////////////////////// 
// 将矩阵指定行中各元素的值转化为字符串 
// 
// 参数： 
// 1. int nRow - 指定的矩阵行，nRow = 0表示第一行 
// 2. const CString& sDelim - 数字之间的分隔符，默认为空格 
// 
// 返回值：CString 型，转换得到的字符串 
////////////////////////////////////////////////////////////////////// 
CString CMatrix::RowToString(int nRow, const CString& sDelim /*= " "*/) const 
{ 
CString s = ""; 

if (nRow >= m_nNumRows) 
return s; 

for (int j=0; j<m_nNumColumns; ++j) 
{ 
CString ss; 
ss.Format("%f", GetElement(nRow, j)); 
s += ss; 
if (j != m_nNumColumns-1) 
s += sDelim; 
} 

return s; 
} 

////////////////////////////////////////////////////////////////////// 
// 将矩阵指定列中各元素的值转化为字符串 
// 
// 参数： 
// 1. int nCol - 指定的矩阵行，nCol = 0表示第一列 
// 2. const CString& sDelim - 数字之间的分隔符，默认为空格 
// 
// 返回值：CString 型，转换得到的字符串 
////////////////////////////////////////////////////////////////////// 
CString CMatrix::ColToString(int nCol, const CString& sDelim /*= " "*/) const 
{ 
CString s = ""; 

if (nCol >= m_nNumColumns) 
return s; 

for (int i=0; i<m_nNumRows; ++i) 
{ 
CString ss; 
ss.Format("%f", GetElement(i, nCol)); 
s += ss; 
if (i != m_nNumRows-1) 
s += sDelim; 
} 

return s; 
} 

////////////////////////////////////////////////////////////////////// 
// 设置矩阵各元素的值 
// 
// 参数： 
// 1. double value[] - 一维数组，长度为m_nNumColumns*m_nNumRows，存储 
// 矩阵各元素的值 
// 
// 返回值：无 
////////////////////////////////////////////////////////////////////// 
void CMatrix::SetData(double value[]) 
{ 
// empty the memory 
memset(m_pData, 0, sizeof(double) * m_nNumColumns*m_nNumRows); 
// copy data 
memcpy(m_pData, value, sizeof(double)*m_nNumColumns*m_nNumRows); 
} 

////////////////////////////////////////////////////////////////////// 
// 设置指定元素的值 
// 
// 参数： 
// 1. int nRows - 指定的矩阵行数 
// 2. int nCols - 指定的矩阵列数 
// 3. double value - 指定元素的值 
// 
// 返回值：BOOL 型，说明设置是否成功 
////////////////////////////////////////////////////////////////////// 
BOOL CMatrix::SetElement(int nRow, int nCol, double value) 
{ 
if (nCol < 0 || nCol >= m_nNumColumns || nRow < 0 || nRow >= 
m_nNumRows) 
return FALSE; // 
array bounds error 
if (m_pData == NULL) 
return 
FALSE; // bad pointer error 

m_pData[nCol + nRow * m_nNumColumns] = value; 

return TRUE; 
} 

////////////////////////////////////////////////////////////////////// 
// 设置指定元素的值 
// 
// 参数： 
// 1. int nRows - 指定的矩阵行数 
// 2. int nCols - 指定的矩阵列数 
// 
// 返回值：double 型，指定元素的值 
////////////////////////////////////////////////////////////////////// 
double CMatrix::GetElement(int nRow, int nCol) const 
{ 
ASSERT(nCol >= 0 && nCol < m_nNumColumns && nRow >= 0 && nRow < 
m_nNumRows); // array bounds error 

ASSERT(m_pData); // 
bad pointer error 
return m_pData[nCol + nRow * m_nNumColumns] ; 
} 

////////////////////////////////////////////////////////////////////// 
// 获取矩阵的列数 
// 
// 参数：无 
// 
// 返回值：int 型，矩阵的列数 
////////////////////////////////////////////////////////////////////// 
int CMatrix::GetNumColumns() const 
{ 
return m_nNumColumns; 
} 

////////////////////////////////////////////////////////////////////// 
// 获取矩阵的行数 
// 
// 参数：无 
// 
// 返回值：int 型，矩阵的行数 
////////////////////////////////////////////////////////////////////// 
int CMatrix::GetNumRows() const 
{ 
return m_nNumRows; 
} 

////////////////////////////////////////////////////////////////////// 
// 获取矩阵的数据 
// 
// 参数：无 
// 
// 返回值：double型指针，指向矩阵各元素的数据缓冲区 
////////////////////////////////////////////////////////////////////// 
double* CMatrix::GetData() const 
{ 
return m_pData; 
} 

////////////////////////////////////////////////////////////////////// 
// 获取指定行的向量 
// 
// 参数： 
// 1. int nRows - 指定的矩阵行数 
// 2. double* pVector - 指向向量中各元素的缓冲区 
// 
// 返回值：int 型，向量中元素的个数，即矩阵的列数 
////////////////////////////////////////////////////////////////////// 
int CMatrix::GetRowVector(int nRow, double* pVector) const 
{ 
if (pVector == NULL) 
delete pVector; 

pVector = new double[m_nNumColumns]; 
ASSERT(pVector != NULL); 

for (int j=0; j<m_nNumColumns; ++j) 
pVector[j] = GetElement(nRow, j); 

return m_nNumColumns; 
} 

////////////////////////////////////////////////////////////////////// 
// 获取指定列的向量 
// 
// 参数： 
// 1. int nCols - 指定的矩阵列数 
// 2. double* pVector - 指向向量中各元素的缓冲区 
// 
// 返回值：int 型，向量中元素的个数，即矩阵的行数 
////////////////////////////////////////////////////////////////////// 
int CMatrix::GetColVector(int nCol, double* pVector) const 
{ 
if (pVector == NULL) 
delete pVector; 

pVector = new double[m_nNumRows]; 
ASSERT(pVector != NULL); 

for (int i=0; i<m_nNumRows; ++i) 
pVector[i] = GetElement(i, nCol); 

return m_nNumRows; 
} 

////////////////////////////////////////////////////////////////////// 
// 重载运算符=，给矩阵赋值 
// 
// 参数： 
// 1. const CMatrix& other - 用于给矩阵赋值的源矩阵 
// 
// 返回值：CMatrix型的引用，所引用的矩阵与other相等 
////////////////////////////////////////////////////////////////////// 
CMatrix& CMatrix::operator=(const CMatrix& other) 
{ 
if (&other != this) 
{ 
BOOL bSuccess = Init(other.GetNumRows(), 
other.GetNumColumns()); 
ASSERT(bSuccess); 

// copy the pointer 
memcpy(m_pData, other.m_pData, 
sizeof(double)*m_nNumColumns*m_nNumRows); 
} 

// finally return a reference to ourselves 
return *this ; 
} 

////////////////////////////////////////////////////////////////////// 
// 重载运算符==，判断矩阵是否相等 
// 
// 参数： 
// 1. const CMatrix& other - 用于比较的矩阵 
// 
// 返回值：BOOL 型，两个矩阵相等则为TRUE，否则为FALSE 
////////////////////////////////////////////////////////////////////// 
BOOL CMatrix::operator==(const CMatrix& other) const 
{ 
// 首先检查行列数是否相等 
if (m_nNumColumns != other.GetNumColumns() || m_nNumRows != 
other.GetNumRows()) 
return FALSE; 

for (int i=0; i<m_nNumRows; ++i) 
{ 
for (int j=0; j<m_nNumColumns; ++j) 
{ 
if (GetElement(i, j) != other.GetElement(i, j)) 
return FALSE; 
} 
} 

return TRUE; 
} 

////////////////////////////////////////////////////////////////////// 
// 重载运算符!=，判断矩阵是否不相等 
// 
// 参数： 
// 1. const CMatrix& other - 用于比较的矩阵 
// 
// 返回值：BOOL 型，两个不矩阵相等则为TRUE，否则为FALSE 
////////////////////////////////////////////////////////////////////// 
BOOL CMatrix::operator!=(const CMatrix& other) const 
{ 
return !(*this == other); 
} 

////////////////////////////////////////////////////////////////////// 
// 重载运算符+，实现矩阵的加法 
// 
// 参数： 
// 1. const CMatrix& other - 与指定矩阵相加的矩阵 
// 
// 返回值：CMatrix型，指定矩阵与other相加之和 
////////////////////////////////////////////////////////////////////// 
CMatrix CMatrix::operator+(const CMatrix& other) const 
{ 
// 首先检查行列数是否相等 
ASSERT (m_nNumColumns == other.GetNumColumns() && m_nNumRows == 
other.GetNumRows()); 

// 构造结果矩阵 
CMatrix result(*this) ; // 拷贝构造 
// 矩阵加法 
for (int i = 0 ; i < m_nNumRows ; ++i) 
{ 
for (int j = 0 ; j < m_nNumColumns; ++j) 
result.SetElement(i, j, result.GetElement(i, j) + 
other.GetElement(i, j)) ; 
} 

return result ;