//////////////////////////////////////////////////////////////////////
// Matrix.cpp
//
// 操作矩陣的類 CMatrix 的實(shí)現(xiàn)文件
//
// 周長(zhǎng)發(fā)編制, 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
//////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////
// 基本構(gòu)造函數(shù)
//////////////////////////////////////////////////////////////////////
CMatrix::CMatrix()
{
	m_nNumColumns = 1;
	m_nNumRows = 1;
	m_pData = NULL;
	BOOL bSuccess = Init(m_nNumRows, m_nNumColumns);
	ASSERT(bSuccess);
}

//////////////////////////////////////////////////////////////////////
// 指定行列構(gòu)造函數(shù)
//
// 參數(shù)：
// 1. int nRows - 指定的矩陣行數(shù)
// 2. int nCols - 指定的矩陣列數(shù)
//////////////////////////////////////////////////////////////////////
CMatrix::CMatrix(int nRows, int nCols)
{
	m_nNumRows = nRows;
	m_nNumColumns = nCols;
	m_pData = NULL;
	BOOL bSuccess = Init(m_nNumRows, m_nNumColumns);
	ASSERT(bSuccess);
}

//////////////////////////////////////////////////////////////////////
// 指定值構(gòu)造函數(shù)
//
// 參數(shù)：
// 1. int nRows - 指定的矩陣行數(shù)
// 2. int nCols - 指定的矩陣列數(shù)
// 3. double value[] - 一維數(shù)組，長(zhǎng)度為nRows*nCols，存儲(chǔ)矩陣各元素的值
//////////////////////////////////////////////////////////////////////
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);
}

//////////////////////////////////////////////////////////////////////
// 方陣構(gòu)造函數(shù)
//
// 參數(shù)：
// 1. int nSize - 方陣行列數(shù)
//////////////////////////////////////////////////////////////////////
CMatrix::CMatrix(int nSize)
{
	m_nNumRows = nSize;
	m_nNumColumns = nSize;
	m_pData = NULL;
	BOOL bSuccess = Init(nSize, nSize);
	ASSERT (bSuccess);
}

//////////////////////////////////////////////////////////////////////
// 方陣構(gòu)造函數(shù)
//
// 參數(shù)：
// 1. int nSize - 方陣行列數(shù)
// 2. double value[] - 一維數(shù)組，長(zhǎng)度為nRows*nRows，存儲(chǔ)方陣各元素的值
//////////////////////////////////////////////////////////////////////
CMatrix::CMatrix(int nSize, double value[])
{
	m_nNumRows = nSize;
	m_nNumColumns = nSize;
	m_pData = NULL;
	BOOL bSuccess = Init(nSize, nSize);
	ASSERT (bSuccess);

	SetData(value);
}

//////////////////////////////////////////////////////////////////////
// 拷貝構(gòu)造函數(shù)
//
// 參數(shù)：
// 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);
}

//////////////////////////////////////////////////////////////////////
// 析構(gòu)函數(shù)
//////////////////////////////////////////////////////////////////////
CMatrix::~CMatrix()
{
	if (m_pData)
	{
		delete[] m_pData;
		m_pData = NULL;
	}
}

//////////////////////////////////////////////////////////////////////
// 初始化函數(shù)
//
// 參數(shù)：
// 1. int nRows - 指定的矩陣行數(shù)
// 2. int nCols - 指定的矩陣列數(shù)
//
// 返回值：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;

	// 分配內(nèi)存
	m_pData = new double[nSize];
	
	if (m_pData == NULL)
		return FALSE;					// 內(nèi)存分配失敗
	if (IsBadReadPtr(m_pData, sizeof(double) * nSize))
		return FALSE;

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

	return TRUE;
}

//////////////////////////////////////////////////////////////////////
// 將方陣初始化為單位矩陣
//
// 參數(shù)：
// 1. int nSize - 方陣行列數(shù)
//
// 返回值：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;
}

//////////////////////////////////////////////////////////////////////
// 將字符串轉(zhuǎn)化為矩陣的值
//
// 參數(shù)：
// 1. CString s - 數(shù)字和分隔符構(gòu)成的字符串
// 2. const CString& sDelim - 數(shù)字之間的分隔符，默認(rèn)為空格
// 3. BOOL bLineBreak - 行與行之間是否有回車換行符，默認(rèn)為真(有換行符)
//         當(dāng)該參數(shù)為FALSE時(shí)，所有元素值都在一行中輸入，字符串的第一個(gè)
//         數(shù)值應(yīng)為矩陣的行數(shù)，第二個(gè)數(shù)值應(yīng)為矩陣的列數(shù)
//
// 返回值：BOOL 型，轉(zhuǎn)換是否成功
//////////////////////////////////////////////////////////////////////
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);
		}

		// 行數(shù)
		m_nNumRows = ListRow.GetCount();

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

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

		// 設(shè)置值
		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;
	
	// 行數(shù)
	tk.Next(sElement);
	sElement.TrimLeft();
	sElement.TrimRight();
	m_nNumRows = atoi(sElement);

	// 列數(shù)
	tk.Next(sElement);
	sElement.TrimLeft();
	sElement.TrimRight();
	m_nNumColumns = atoi(sElement);

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

	// 設(shè)置值
	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;
}

//////////////////////////////////////////////////////////////////////
// 將矩陣各元素的值轉(zhuǎn)化為字符串
//
// 參數(shù)：
// 1. const CString& sDelim - 數(shù)字之間的分隔符，默認(rèn)為空格
// 2 BOOL bLineBreak - 行與行之間是否有回車換行符，默認(rèn)為真(有換行符)
//
// 返回值：CString 型，轉(zhuǎn)換得到的字符串
//////////////////////////////////////////////////////////////////////
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;
}

//////////////////////////////////////////////////////////////////////
// 將矩陣指定行中各元素的值轉(zhuǎn)化為字符串
//
// 參數(shù)：
// 1. int nRow - 指定的矩陣行，nRow = 0表示第一行
// 2. const CString& sDelim - 數(shù)字之間的分隔符，默認(rèn)為空格
//
// 返回值：CString 型，轉(zhuǎn)換得到的字符串
//////////////////////////////////////////////////////////////////////
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;
}

//////////////////////////////////////////////////////////////////////
// 將矩陣指定列中各元素的值轉(zhuǎn)化為字符串
//
// 參數(shù)：
// 1. int nCol - 指定的矩陣行，nCol = 0表示第一列
// 2. const CString& sDelim - 數(shù)字之間的分隔符，默認(rèn)為空格
//
// 返回值：CString 型，轉(zhuǎn)換得到的字符串
//////////////////////////////////////////////////////////////////////
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;
}

//////////////////////////////////////////////////////////////////////
// 設(shè)置矩陣各元素的值
//
// 參數(shù)：
// 1. double value[] - 一維數(shù)組，長(zhǎng)度為m_nNumColumns*m_nNumRows，存儲(chǔ)
//                     矩陣各元素的值
//
// 返回值：無(wú)
//////////////////////////////////////////////////////////////////////
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);
}

//////////////////////////////////////////////////////////////////////
// 設(shè)置指定元素的值
//
// 參數(shù)：
// 1. int nRows - 指定的矩陣行數(shù)
// 2. int nCols - 指定的矩陣列數(shù)
// 3. double value - 指定元素的值
//
// 返回值：BOOL 型，說(shuō)明設(shè)置是否成功
//////////////////////////////////////////////////////////////////////
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;
}

//////////////////////////////////////////////////////////////////////
// 設(shè)置指定元素的值
//
// 參數(shù)：
// 1. int nRows - 指定的矩陣行數(shù)
// 2. int nCols - 指定的矩陣列數(shù)
//
// 返回值：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] ;
}

//////////////////////////////////////////////////////////////////////
// 獲取矩陣的列數(shù)
//
// 參數(shù)：無(wú)
//
// 返回值：int 型，矩陣的列數(shù)
//////////////////////////////////////////////////////////////////////
int	CMatrix::GetNumColumns() const
{
	return m_nNumColumns;
}

//////////////////////////////////////////////////////////////////////
// 獲取矩陣的行數(shù)
//
// 參數(shù)：無(wú)
//
// 返回值：int 型，矩陣的行數(shù)
//////////////////////////////////////////////////////////////////////
int	CMatrix::GetNumRows() const
{
	return m_nNumRows;
}

//////////////////////////////////////////////////////////////////////
// 獲取矩陣的數(shù)據(jù)
//
// 參數(shù)：無(wú)
//
// 返回值：double型指針，指向矩陣各元素的數(shù)據(jù)緩沖區(qū)
//////////////////////////////////////////////////////////////////////
double* CMatrix::GetData() const
{
	return m_pData;
}

//////////////////////////////////////////////////////////////////////
// 獲取指定行的向量
//
// 參數(shù)：
// 1. int nRows - 指定的矩陣行數(shù)
// 2.  double* pVector - 指向向量中各元素的緩沖區(qū)
//
// 返回值：int 型，向量中元素的個(gè)數(shù)，即矩陣的列數(shù)
//////////////////////////////////////////////////////////////////////
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;
}

//////////////////////////////////////////////////////////////////////
// 獲取指定列的向量
//
// 參數(shù)：
// 1. int nCols - 指定的矩陣列數(shù)
// 2.  double* pVector - 指向向量中各元素的緩沖區(qū)
//
// 返回值：int 型，向量中元素的個(gè)數(shù)，即矩陣的行數(shù)
//////////////////////////////////////////////////////////////////////
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;
}

//////////////////////////////////////////////////////////////////////
// 重載運(yùn)算符=，給矩陣賦值
//
// 參數(shù)：
// 1. const CMatrix& other - 用于給矩陣賦值的源矩陣