开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数值算法/人工智能 > 人工智能/神经网络 > 查看源码
Matrix.cpp
资源名称：神经网络源代码(附说明文档和数据）.rar　[点击查看]
上传用户：guanx8y8
上传日期：2007-07-30
资源大小：326k
文件大小：48k
源码类别：

人工智能/神经网络

开发平台：

Visual C++

Matrix.cpp：源码内容
  1. /////////////////////////////////////////////////////////////////////////////
  2. // Matrix.cpp : Implementation of the class Matrix
  3. //
  4. /////////////////////////////////////////////////////////////////////////////
  6. #include "stdafx.h"
  7. #include "Matrix.h"
  8. #include <math.h>
  9. #include <stdlib.h>
  11. #include <conio.h>
  12. #include <stdio.h>
  14. #ifdef _DEBUG
  15. #define new DEBUG_NEW
  16. #undef THIS_FILE
  17. static char THIS_FILE[] = __FILE__;
  18. #endif
  21. //////////////////////////////////////////////////////////////////////
  22. // Construction/Destruction
  23. //////////////////////////////////////////////////////////////////////
  25. CMatrix::CMatrix()
  26. {
  27. m_nRow = 0;
  28. m_nCol = 0;
  30. m_pTMatrix.resize (m_nRow);
  31. for(unsigned int i=0; i < m_nRow; i++)
  32. {
  33. for(unsigned int j=0; j < m_nCol; j++)
  34. {
  35. m_pTMatrix[i].resize (m_nCol);
  36. m_pTMatrix[i][j] = (double) 0;
  37. }
  38. }
  39. }
  42. CMatrix::~CMatrix()
  43. {
  45. }
  48. CMatrix::CMatrix(unsigned int nRow,unsigned int nCol)
  49. {
  50. // 动态分配二维数组
  51. TMatrix tMatrix;
  52. tMatrix.resize (nRow);
  54. for(unsigned int i=0; i < nRow; i++)
  55. {
  56. for(unsigned int j=0; j < nCol; j++)
  57. {
  58.         tMatrix[i].resize(nCol);
  59. tMatrix[i][j] = (double) 0;
  60. }
  61. }
  63. // 对对象变量赋值
  64. m_nRow = nRow;
  65. m_nCol = nCol;
  66. m_pTMatrix = tMatrix;
  68. }
  71. CMatrix::CMatrix(CMatrix& cMatrixB)
  72. {
  73. // Initialize the variable
  74. m_nRow = cMatrixB.m_nRow ;
  75. m_nCol = cMatrixB.m_nCol ;
  76. m_pTMatrix = cMatrixB.m_pTMatrix ;
  78. // Copy Data
  79. for(unsigned int i=0; i< cMatrixB.m_nRow; i++)
  80. {
  81. for(unsigned int j=0; j < cMatrixB.m_nCol; j++)
  82. {
  83. m_pTMatrix [i][j] = cMatrixB.m_pTMatrix [i][j];
  84. }
  85. }
  87. }
  90. /////////////////////////////////////////////////////////////////////////////
  91. // CMatrix member functions
  92. //
  94. CMatrix CMatrix::operator +(CMatrix& cMatrixB)
  95. {
  96. // 要满足矩阵相加的条件: 行列数目相等!
  97. if(m_nRow != cMatrixB.m_nRow || m_nCol != cMatrixB.m_nCol )
  98. {
  99. ::AfxMessageBox (TEXT("执行相加的两个矩阵维数不相等!"),MB_OK | MB_ICONERROR);
  100. }
  102. CMatrix cMatrix = *this;
  104. for(unsigned int i=0; i < m_nRow; i++)
  105. {
  106. for(unsigned int j=0; j < m_nCol; j++)
  107. {
  108. cMatrix.m_pTMatrix [i][j] = m_pTMatrix [i][j] + cMatrixB.m_pTMatrix [i][j];
  109. }
  110. }
  112. return cMatrix;
  114. }
  117. CMatrix CMatrix::operator -(CMatrix& cMatrixB)
  118. {
  119. // 要满足矩阵相加的条件: 行列数数目相等!
  120. if(m_nRow != cMatrixB.m_nRow || m_nCol != cMatrixB.m_nCol )
  121. {
  122. ::AfxMessageBox (TEXT("执行相减的两个矩阵维数不相等!"),MB_OK | MB_ICONERROR);
  123. }
  125. CMatrix cMatrix = *this;
  127. for(unsigned int i=0; i < m_nRow; i++)
  128. {
  129. for(unsigned int j=0; j < m_nCol; j++)
  130. {
  131. cMatrix.m_pTMatrix [i][j] = m_pTMatrix [i][j] - cMatrixB.m_pTMatrix [i][j];
  132. }
  133. }
  135. return cMatrix;
  137. }
  140. CMatrix CMatrix::operator *(CMatrix& cMatrixB)
  141. {
  142. if( m_nCol != cMatrixB.m_nRow )
  143. {
  144. ::AfxMessageBox (TEXT("执行相乘的两个矩阵维数不满足相乘的条件!"),MB_OK | MB_ICONERROR);
  145. }
  147. CMatrix cResultMatrix(m_nRow,cMatrixB.m_nCol);
  149. for(unsigned int i=0; i < m_nRow; i++)
  150. {
  151. for(unsigned int j=0; j < cMatrixB.m_nCol; j++)
  152. {
  153. for(unsigned int m=0; m < m_nCol; m++)
  154. {
  155. cResultMatrix.m_pTMatrix [i][j] +=  m_pTMatrix [i][m] * cMatrixB.m_pTMatrix [m][j];
  156. }
  157. }
  158. }
  160. return cResultMatrix;
  161. }
  164. CMatrix CMatrix::operator * (double nValue)
  165. {
  166. CMatrix cMatrix = *this;
  168. for(unsigned int i=0; i < m_nRow; i++)
  169. {
  170. for(unsigned int j=0; j < m_nCol; j++)
  171. {
  172. cMatrix.m_pTMatrix [i][j] =m_pTMatrix [i][j] * nValue;
  173. }
  174. }
  176. return cMatrix;
  177. }
  180. CMatrix& CMatrix::operator =(CMatrix& cMatrixB)
  181. {
  182. if( (m_nRow != cMatrixB.m_nRow) || (m_nCol != cMatrixB.m_nCol) )
  183. {
  184. ::AfxMessageBox(TEXT("等号左右两边的矩阵的维数不相等!"),MB_OK | MB_ICONERROR);
  185. return *this; // return invalid value
  186. }
  188. // 给变量赋值
  189. m_nRow = cMatrixB.m_nRow ;
  190. m_nCol = cMatrixB.m_nCol ;
  191. m_pTMatrix = cMatrixB.m_pTMatrix ;
  193. // 赋值操作
  194. for(unsigned int i=0; i < cMatrixB.m_nRow; i++)
  195. {
  196. for(unsigned int j=0; j< cMatrixB.m_nCol; j++)
  197. {
  198. m_pTMatrix [i][j] = cMatrixB.m_pTMatrix [i][j];
  199. }
  200. }
  202. return *this;
  203. }
  206. CMatrix& CMatrix::operator += (CMatrix& cMatrixB)
  207. {
  208. if(m_nRow != cMatrixB.m_nRow || m_nCol != cMatrixB.m_nCol )
  209. {
  210. //printf("错误!执行相加的两个矩阵维数不相等!n");
  211. ::AfxMessageBox (TEXT("运算符的两边矩阵的维数不相等!"),MB_OK | MB_ICONERROR);
  212. return *this; // return invalid value
  213. }
  215. // 赋值操作
  216. for(unsigned int i=0; i < cMatrixB.m_nRow; i++)
  217. {
  218. for(unsigned int j=0; j< cMatrixB.m_nCol; j++)
  219. {
  220. m_pTMatrix [i][j] += cMatrixB.m_pTMatrix [i][j];
  221. }
  222. }
  224. return *this;
  226. }
  229. CMatrix CMatrix::Transpose()
  230. {
  231. CMatrix cMatrix(m_nCol,m_nRow);
  233. for(unsigned int i=0; i < m_nRow; i++)
  234. {
  235. for(unsigned int j=0; j < m_nCol; j++)
  236. {
  237. cMatrix.m_pTMatrix [j][i] = m_pTMatrix [i][j];
  238. }
  239. }
  241. return cMatrix;
  242. }
  244. /////////////////////////////////////////////////////////////////////////////
  245. // 将矩阵的所有的元素按列合成一列
  246. // 例如：
  247. // matrix = [
  248. // 1 2 3
  249. // 4 5 6
  250. // 7 8 9
  251. // ]
  252. // CMatrix cMatrix = matrix.MergeColumnsToColumnVector();
  253. // cMatrix = 
  254. // [ 1
  255. // 4
  256. // 7
  257. // 2
  258. // 5
  259. // 8
  260. // 3
  261. // 6
  262. // 9 ]
  263. /////////////////////////////////////////////////////////////////////////////
  265. CMatrix CMatrix::MergeColumnsToColumnVector()
  266. {
  267. CMatrix cMatrix(m_nRow * m_nCol,(unsigned int)1);
  269. // 对矩阵赋值
  270. for(unsigned int j=0; j < m_nCol; j++)
  271. {
  272. for(unsigned int i=0; i < m_nRow; i++)
  273. {
  274. cMatrix.m_pTMatrix [i + j * m_nRow][(unsigned int)0] = m_pTMatrix [i][j];
  275. }
  276. }
  278. return cMatrix;
  280. }
  282. /////////////////////////////////////////////////////////////////////////////
  283. // Get the total value of the matrix
  284. /////////////////////////////////////////////////////////////////////////////
  286. double CMatrix::GetTotalElementValue()
  287. {
  288. double nTotalValue = 0;
  290. for(unsigned int i=0; i < m_nRow; i++)
  291. {
  292. for( unsigned int j=0; j < m_nCol; j++)
  293. {
  294. nTotalValue += m_pTMatrix [i][j];
  295. }
  296. }
  298. return nTotalValue;
  299. }
  301. /////////////////////////////////////////////////////////////////////////////
  302. // Get System Error
  303. /////////////////////////////////////////////////////////////////////////////
  305. double CMatrix::GetSystemError() const
  306. {
  307. double nSystemError = 0;
  309. for(unsigned int i=0; i < m_nRow; i++)
  310. {
  311. for( unsigned int j=0; j < m_nCol; j++)
  312. {
  313. nSystemError += m_pTMatrix [i][j] * m_pTMatrix [i][j];
  314. }
  315. }
  317. return nSystemError;
  319. }
  321. /////////////////////////////////////////////////////////////////////////////
  322. // Make all the matrix elements to be changed into absolute value
  323. /////////////////////////////////////////////////////////////////////////////
  325. CMatrix CMatrix::AbsoluteValue ()
  326. {
  327. CMatrix cMatrix = *this;
  329. for(unsigned int i=0; i < m_nRow; i++)
  330. {
  331. for(unsigned int j=0; j < m_nCol; j++)
  332. {
  333. cMatrix.m_pTMatrix [i][j] = fabs( m_pTMatrix [i][j]);
  335. }
  337. }
  339. return cMatrix;
  341. }
  344. CMatrix CMatrix::Inverse()
  345. {
  346. /////////////////////////////////////////////////////////////////////////
  347. // Using Gauss - Jordan Method
  348. // 参考书目: 计算机数值方法 --->施吉林 陈桂枝
  349. /////////////////////////////////////////////////////////////////////////
  351. /////////////////////////////////////////////////////////////////////////
  352. // 判断是否是可逆阵:
  353. // 可逆阵一定是方阵!!!
  355. if ( m_nRow != m_nCol)
  356. {
  357. //printf("错误!矩阵的行列数不相等,是非可逆阵!n");
  358. ::AfxMessageBox (TEXT("矩阵的行列数不相等,是非可逆阵!"),MB_OK | MB_ICONERROR);
  359. }
  361. CMatrix cMatrix = *this;
  363. //***********************************************************************
  364. // 思路:(非常规思维!)
  365. // 动态分配整型数组(2*m_nCol)来存储每次交换的行坐标的值
  366. // 不论有没有行交换都记录在数组中,
  367. // 1.没进行行交换的两个数据相等,在SwapMatrixRow()函数中
  368. // 检测到两个值相等立即返回,在SwapMatrixCol()函数中也一样,
  369. // 检测到两个值相等立即返回,不占用系统资源;
  370. // 2.不相等的就交换
  371. //***********************************************************************
  372.     
  373. // 分配内存
  374. int *pIntArray = new int [2*m_nCol];
  376. // nSetp --- 约化步数,按列展开
  377. for(unsigned int k=0; k < cMatrix.m_nCol; k++)
  378. {
  379. /////////////////////////////////////////////////////////////////////
  380. // 进行行交换 ---> 游戏规则:
  381. // 为保证计算过程的数值稳定性,在第k步约化时,先在{a(ik)}|i=k->n中选按
  382. // 模最大者作为约化主元素,并交换矩阵相应的行
  384. // 标记主元素
  385. double nMaxElement = cMatrix.m_pTMatrix [k][k];
  386. // 标记主元素所在的行数
  387. unsigned int nMainRow = k;
  389. for(unsigned int nCount = k+1; nCount < cMatrix.m_nCol; nCount++)
  390. {
  391. if( fabs(nMaxElement) < fabs(cMatrix.m_pTMatrix [nCount][k]) )
  392. {
  393. nMaxElement = cMatrix.m_pTMatrix [nCount][k];
  394. nMainRow = nCount;
  395. }
  396. }
  398. // 将欲交换的行数存在数组中
  399. pIntArray [2*k] = k;
  400. pIntArray [2*k+1] = nMainRow;
  403. // 交换行
  404. cMatrix.SwapMatrixRow(k,nMainRow);
  406. //Display();
  408. // 判断是否是可逆阵
  409. if(cMatrix.m_pTMatrix [k][k] == 0)
  410. {
  411. //printf("错误!此矩阵为非可逆阵!n");
  412. ::AfxMessageBox (TEXT("此矩阵为非可逆阵,没有逆矩阵!"),MB_OK | MB_ICONERROR);
  413. }
  415. cMatrix.m_pTMatrix [k][k] = 1/(cMatrix.m_pTMatrix [k][k]);
  418. // 算主列
  419. for(unsigned int i=0; i < cMatrix.m_nRow; i++)
  420. {
  421. if( i != k)
  422. cMatrix.m_pTMatrix [i][k] = -(cMatrix.m_pTMatrix [k][k]) * (cMatrix.m_pTMatrix [i][k]); 
  424. //int nTempValue = m_pTMatrix [i][k];
  426. }
  428. //printf("n");
  430. // 约化非主行
  431. for(unsigned int m=0; m < cMatrix.m_nRow; m++)
  432. {
  433. if ( m == k)
  434. continue;
  436. for(unsigned int n=0; n < cMatrix.m_nCol; n++)
  437. {
  438. if ( n == k)
  439. continue;
  441. cMatrix.m_pTMatrix [m][n] += cMatrix.m_pTMatrix [m][k] * cMatrix.m_pTMatrix [k][n];
  443. //printf("%10f ",m_pTMatrix [m][n]);
  445. }
  447. //printf("n");
  449. }
  451. // 算主行
  452. for(unsigned int j=0; j < cMatrix.m_nCol; j++)
  453. {
  454. if( j != k)
  455. cMatrix.m_pTMatrix [k][j] = (cMatrix.m_pTMatrix [k][k]) * (cMatrix.m_pTMatrix [k][j]);
  457. }
  459. }
  462. /////////////////////////////////////////////////////////////////////////
  463. // 进行列交换 ---> 对交换行后的矩阵进行列交换 ---> 还原矩阵
  464. // 游戏规则:
  465. // 将开始矩阵中进行的行交换 ---> 现用相对应的列交换进行还原,即可得到所求的
  466. // 逆矩阵
  468. for(int i=2*m_nCol-1; i > 0; i--)
  469. {
  470. cMatrix.SwapMatrixCol(pIntArray[i],pIntArray[i-1]);
  471. i--;
  472. }
  474. delete []pIntArray;
  476. return cMatrix;
  478. }
  481. void CMatrix::SwapMatrixRow(unsigned int nRow1,unsigned int nRow2)
  482. {
  483. if( nRow1 == nRow2)
  484. return;
  486. double *pArray = new double;
  488. for(unsigned int i=0; i < m_nCol; i++)
  489. {
  490. // Swap the datum of the two rows
  491. pArray[0] = m_pTMatrix [nRow1][i];
  492. m_pTMatrix [nRow1][i] = m_pTMatrix [nRow2][i];
  493. m_pTMatrix [nRow2][i] = pArray[0];
  494. }
  496. delete pArray;
  497. }
  500. void CMatrix::SwapMatrixCol(unsigned int nCol1,unsigned int nCol2)
  501. {
  502. if( nCol1 == nCol2)
  503. return;
  505. double *pArray = new double;
  506. for(unsigned int i=0; i < m_nRow; i++)
  507. {
  508. // Swap the datum of the two columns
  509. pArray[0] = m_pTMatrix [i][nCol1];
  510. m_pTMatrix [i][nCol1] = m_pTMatrix [i][nCol2];
  511. m_pTMatrix [i][nCol2] = pArray[0];
  512. }
  514. delete pArray;
  515. }
  518. bool CMatrix::LoadDataFromFile(CString& strFileName)
  519. {
  520. CStdioFile dataFile;
  521. LPCTSTR lpszFileName = "";
  523. // CString convert to LPCTSTR
  524. strFileName.TrimLeft ();
  525. strFileName.TrimRight ();
  526. //strFileName.Format (lpszFileName);
  528. lpszFileName = (LPCTSTR)strFileName;
  530. if(!dataFile.Open (lpszFileName,CFile::modeRead | CFile::typeText))
  531. {
  532. ::AfxMessageBox (TEXT("不能打开要读取数据的文件!"),MB_OK | MB_ICONERROR);
  533. dataFile.Close ();
  534. return FALSE;
  535. }
  537. // 用来存储提取文本文件中一行的数据
  538. CString strData;  
  539. // 用来记录文本文件中一共有多少行数据?
  540. unsigned int nRow = 0;
  542. /////////////////////////////////////////////////////////////////////////
  543. // Step 1: 得到文件的行列数目并根据文本文件的行列数目来设置对象(矩阵)的行
  544. // 列数目
  545. //
  547. while(dataFile.ReadString (strData) != FALSE)
  548. {
  549. ++nRow;
  550. }
  552. // 根据文本文件的数据的行数设置对象(矩阵)的行数
  553. m_nRow = nRow;
  554. SetMatrixRowNumber(m_nRow);
  556. // 重新定位当前文件指针到文件开头
  557. dataFile.SeekToBegin ();
  559. dataFile.ReadString (strData);
  560. strData.TrimLeft ();
  561. strData.TrimRight ();
  563. TCHAR SPACE_CHARACTER = ' ';
  564. // 用来记录文本文件中一行有多少列?
  565. unsigned int nCol = 0;
  567. // 空格符在字符串中的位置索引
  568. int nIndex = 0;
  570. do
  571. {
  572. nIndex = strData.Find (SPACE_CHARACTER);
  574. ++nCol;
  576. // 提取字符串的子字符串,即提取一个double型实数数据
  577. //CString strDoubleNumber = strData.Left (nIndex);
  579. // 将字符串转换为double型实数
  580. //double RealNumber = atof(strDoubleNumber);
  582. //int nTempNumber = strData.GetLength ();
  584. strData = strData.Right (strData.GetLength () - nIndex -1);
  586. // 去掉多余的空格
  587. strData.TrimLeft ();
  589. // Use for debugging
  590. //int nTempNum = strData.GetLength ();
  592. }while(nIndex != -1);
  594. // 根据文本文件的数据的列数设置对象(矩阵)的列数
  595. m_nCol = nCol;
  596. SetMatrixColNumber(m_nCol);
  598. // End of Getting the Rows and Cols of the Text File
  599. /////////////////////////////////////////////////////////////////////////
  602. /////////////////////////////////////////////////////////////////////////
  603. // Step 2: 根据文本文件中的数据对矩阵赋值,并检测每行的列数是否和第一行的
  604. // 列数相等,不相等提示出错信息
  605. //
  607. // 重新定位当前文件指针到文件开头
  608. dataFile.SeekToBegin ();
  610. // 对矩阵中的元素装入文本文件的数据
  611. for(unsigned int i=0; i < m_nRow; i++)
  612. {
  613. dataFile.ReadString (strData);
  614. strData.TrimLeft ();
  615. strData.TrimRight ();
  617. // 验证每行的列数是否与第一行的列数相等
  618. unsigned int nVerifyColNum = 0;
  620. do
  621. {
  622. nIndex = strData.Find (SPACE_CHARACTER);
  624. ++nVerifyColNum;
  626. if(nIndex != -1)
  627. {
  628. // 提取字符串的子字符串,即提取一个double型实数数据
  629. CString strDoubleNumber = strData.Left (nIndex);
  631. // 将字符串转换为double型实数
  632. double RealNumber = atof(strDoubleNumber);
  634. m_pTMatrix [i][nVerifyColNum - 1] = RealNumber;
  635. //int nTempNumber = strData.GetLength ();
  637. strData = strData.Right (strData.GetLength () - nIndex -1);
  639. // 去掉多余的空格
  640. strData.TrimLeft ();
  642. // Using for debugging
  643. //double nReadNumber = m_pTMatrix [i][nVerifyColNum - 1];
  645. // Using for debugging
  646. //int nTempNum = strData.GetLength ();
  647. }
  648. else
  649. {
  650. double RealNumber = atof(strData);
  652. m_pTMatrix [i][nVerifyColNum - 1] = RealNumber;
  653. }
  655. }while(nIndex != -1);
  657. if(nVerifyColNum != m_nCol)
  658. {
  659. CString strRowNumber;
  660. strRowNumber.Format("%d",i + 1);
  662. CString strColNumber;
  663. strColNumber.Format("%d",m_nCol);
  665. CString strVerifyColNumber;
  666. strVerifyColNumber.Format("%d",nVerifyColNum);
  668. CString strMessage =  CString(TEXT("文本文件第")) + strRowNumber + CString(TEXT("行一共有")) + strVerifyColNumber + CString(TEXT("列,与第一行中的列数")) + strColNumber + CString(TEXT("不相等!"));
  670. LPCTSTR lpszText = "";
  671. lpszText = (LPCTSTR)strMessage;
  673. //strMessage.FormatMessage (lpszText);
  674. //::AfxMessageBox (lpszText,MB_OK);
  677. ::AfxMessageBox (lpszText,MB_OK | MB_ICONERROR);
  678. dataFile.Close ();
  679. return false;
  680. }
  683. }
  686. dataFile.Close ();
  688. return TRUE;
  689. }
  693. /////////////////////////////////////////////////////////////////////////////
  694. // Load the data from the file and reset the rows and the colums of 
  695. // the matrixes.
  696. // Parameter:
  697. // [in] strFileName
  698. // [out]cMatrixInputToHideWeightValue
  699. // [out]cMatrixHideLayerValveValue
  700. // [out]cMatrixHideToOutputWeightValue
  701. // [out]cMatrixOutputLayerValveValue
  702. // [out]nInputLayerNumber
  703. // [out]nHideLayerNumber
  704. // [out]nOutputLayerNumber
  705. // [out]nComboArithmetic
  706. // [out]nComboFunc
  707. /////////////////////////////////////////////////////////////////////////////
  709. bool CMatrix::LoadDataFromFileSpecial (CString& strFileName,
  710. CMatrix& cMatrixInputToHideWeightValue,
  711. CMatrix& cMatrixHideLayerValveValue,
  712. CMatrix& cMatrixHideToOutputWeightValue,
  713. CMatrix& cMatrixOutputLayerValveValue,
  714. unsigned int &nInputLayerNumber,
  715. unsigned int &nHideLayerNumber,
  716. unsigned int &nOutputLayerNumber,
  717. int &nComboArithmetic,
  718. int &nComboFunc)
  719. {
  720. CStdioFile dataFile;
  721. LPCTSTR lpszFileName = "";
  723. // CString convert to LPCTSTR
  724. strFileName.TrimLeft ();
  725. strFileName.TrimRight ();
  727. lpszFileName = (LPCTSTR)strFileName;
  729. if(!dataFile.Open (lpszFileName,CFile::modeRead | CFile::typeText))
  730. {
  731. ::AfxMessageBox (TEXT("不能打开要读取的数据文件!!!"),MB_OK | MB_ICONERROR);
  732. dataFile.Close ();
  733. return FALSE;
  734. }
  736. // 提取网络参数
  737. dataFile.SeekToBegin ();
  739. // 用来存储提取文本文件中一行的数据
  740. CString strData;
  741. // 注释标志符号
  742. TCHAR cFirstCharacter = '#';
  743. // 空格符号
  744. TCHAR SPACE_CHARACTER = ' ';
  745. // 空格符在字符串中的位置索引
  746. int nIndex = 0;
  748. // 读取文件中的网络的输入层数目
  749. while(dataFile.ReadString (strData))
  750. {
  751. strData.TrimLeft ();
  752. strData.TrimRight ();
  754. if((strData.Find (cFirstCharacter)) == 0)
  755. {
  756. continue;
  757. }
  758. else
  759. {
  760. LPCSTR strInputLayerNumber = (LPCSTR)strData;
  762. nInputLayerNumber = (unsigned int)atoi(strInputLayerNumber);
  764. break;
  765.  
  766. }
  768. }
  770. // 读取文件中的网络的隐含层数目
  771. while(dataFile.ReadString (strData))
  772. {
  773. strData.TrimLeft ();
  774. strData.TrimRight ();
  776. if((strData.Find (cFirstCharacter)) == 0)
  777. {
  778. continue;
  779. }
  780. else
  781. {
  782. LPCSTR strHideLayerNumber = (LPCSTR)strData;
  784. nHideLayerNumber = (unsigned int)atoi(strHideLayerNumber);
  786. break;
  787. }
  789. }
  791. // 读取文件中的网络的输出层数目
  792. while(dataFile.ReadString (strData))
  793. {
  794. strData.TrimLeft ();
  795. strData.TrimRight ();
  797. if((strData.Find (cFirstCharacter)) == 0)
  798. {
  799. continue;
  800. }
  801. else
  802. {
  803. LPCSTR strOutputLayerNumber = (LPCSTR)strData;
  805. nOutputLayerNumber = (unsigned int)atoi(strOutputLayerNumber);
  807. break;
  808. }
  810. }
  812. // 读取文件中的训练网络所使用的算法的索引值
  813. while(dataFile.ReadString (strData))
  814. {
  815. strData.TrimLeft ();
  816. strData.TrimRight ();
  818. if((strData.Find (cFirstCharacter)) == 0)
  819. {
  820. continue;
  821. }
  822. else
  823. {
  824. LPCSTR strComboArithmetic = (LPCSTR)strData;
  826. nComboArithmetic = atoi(strComboArithmetic);
  828. break;
  829. }
  831. }
  833. // 读取文件中的网络的使用的函数的索引值
  834. while(dataFile.ReadString (strData))
  835. {
  836. strData.TrimLeft ();
  837. strData.TrimRight ();
  839. if((strData.Find (cFirstCharacter)) == 0)
  840. {
  841. continue;
  842. }
  843. else
  844. {
  845. LPCSTR strComboFunc = (LPCSTR)strData;
  847. nComboFunc = atoi(strComboFunc);
  849. break;
  850. }
  852. }
  855. // 根据网络参数设置输入层到隐含层的权值矩阵的行列数
  856. cMatrixInputToHideWeightValue.SetMatrixRowAndCol (nHideLayerNumber,nInputLayerNumber);
  858. // 验证矩阵的行数
  859. unsigned int nVerifyRowNum = 0;
  861. // 读取文件中的输入层到隐含层的权值矩阵到相应的矩阵对象中
  862. while(dataFile.ReadString (strData))
  863. {
  864. strData.TrimLeft ();
  865. strData.TrimRight ();
  867. if((strData.Find (cFirstCharacter)) == 0)
  868. {
  869. continue;
  870. }
  871. else
  872. {
  874. // 装入文本文件的数据到相对应的矩阵中
  876. strData.TrimLeft ();
  877. strData.TrimRight ();
  879. // 验证每行的列数是否与第一行的列数相等
  880. unsigned int nVerifyColNum = 0;
  882. do
  883. {
  884. nIndex = strData.Find (SPACE_CHARACTER);
  886. ++nVerifyColNum;
  888. if(nIndex != -1)
  889. {
  890. // 提取字符串的子字符串,即提取一个double型实数数据
  891. CString strDoubleNumber = strData.Left (nIndex);
  893. // 将字符串转换为double型实数
  894. double RealNumber = atof(strDoubleNumber);
  896. cMatrixInputToHideWeightValue.m_pTMatrix [nVerifyRowNum][nVerifyColNum - 1] = RealNumber;
  898. strData = strData.Right (strData.GetLength () - nIndex -1);
  900. // 去掉多余的空格
  901. strData.TrimLeft ();
  903. }
  904. else
  905. {
  906. double RealNumber = atof(strData);
  908. cMatrixInputToHideWeightValue.m_pTMatrix [nVerifyRowNum][nVerifyColNum - 1] = RealNumber;
  909. }
  911. }while(nIndex != -1);
  913. if(nVerifyColNum != cMatrixInputToHideWeightValue.m_nCol)
  914. {
  915. CString strRowNumber;
  916. strRowNumber.Format("%d",nVerifyRowNum + 1);
  918. CString strColNumber;
  919. strColNumber.Format("%d",m_nCol);
  921. CString strVerifyColNumber;
  922. strVerifyColNumber.Format("%d",nVerifyColNum);
  924. CString strMessage =  CString(TEXT("文本文件第")) + strRowNumber + CString(TEXT("行一共有")) + strVerifyColNumber + CString(TEXT("列,与第一行中的列数")) + strColNumber + CString(TEXT("不相等!"));
  926. LPCTSTR lpszText = "";
  927. lpszText = (LPCTSTR)strMessage;
  929. ::AfxMessageBox (lpszText,MB_OK | MB_ICONERROR);
  930. dataFile.Close ();
  931. return FALSE;
  932. }
  934. ++nVerifyRowNum;
  936. if( nVerifyRowNum == cMatrixInputToHideWeightValue.m_nRow )
  937. {
  938. break;
  939. }
  941. }
  943. }
  945. // Using for debugging
  946. //CString strInputToHideWeightValue = TEXT("TempInputToHideWeightValue.txt");
  947. //cMatrixInputToHideWeightValue.SaveDataToFile (strInputToHideWeightValue);
  951. // 根据网络参数设置隐含层的阀值矩阵的行列数
  952. cMatrixHideLayerValveValue.SetMatrixRowAndCol (nHideLayerNumber,(unsigned int)1);
  954. nIndex = 0;
  955. nVerifyRowNum = 0;
  957. // 读取文件中的隐含层的阀值矩阵到相应的矩阵对象中
  958. while(dataFile.ReadString (strData))
  959. {
  960. strData.TrimLeft ();
  961. strData.TrimRight ();
  963. if((strData.Find (cFirstCharacter)) == 0)
  964. {
  965. continue;
  966. }
  967. else
  968. {
  970. // 装入文本文件的数据到相对应的矩阵中
  972. strData.TrimLeft ();
  973. strData.TrimRight ();
  975. // 验证每行的列数是否与第一行的列数相等
  976. unsigned int nVerifyColNum = 0;
  978. do
  979. {
  980. nIndex = strData.Find (SPACE_CHARACTER);
  982. ++nVerifyColNum;
  984. if(nIndex != -1)
  985. {
  986. // 提取字符串的子字符串,即提取一个double型实数数据
  987. CString strDoubleNumber = strData.Left (nIndex);
  989. // 将字符串转换为double型实数
  990. double RealNumber = atof(strDoubleNumber);
  992. cMatrixHideLayerValveValue.m_pTMatrix [nVerifyRowNum][nVerifyColNum - 1] = RealNumber;
  994. strData = strData.Right (strData.GetLength () - nIndex -1);
  996. // 去掉多余的空格
  997. strData.TrimLeft ();
  999. }
  1000. else
  1001. {
  1002. double RealNumber = atof(strData);
  1004. cMatrixHideLayerValveValue.m_pTMatrix [nVerifyRowNum][nVerifyColNum - 1] = RealNumber;
  1005. }
  1007. }while(nIndex != -1);
  1009. if(nVerifyColNum != cMatrixHideLayerValveValue.m_nCol)
  1010. {
  1011. CString strRowNumber;
  1012. strRowNumber.Format("%d",nVerifyRowNum + 1);
  1014. CString strColNumber;
  1015. strColNumber.Format("%d",m_nCol);
  1017. CString strVerifyColNumber;
  1018. strVerifyColNumber.Format("%d",nVerifyColNum);
  1020. CString strMessage =  CString(TEXT("文本文件第")) + strRowNumber + CString(TEXT("行一共有")) + strVerifyColNumber + CString(TEXT("列,与第一行中的列数")) + strColNumber + CString(TEXT("不相等!"));
  1022. LPCTSTR lpszText = "";
  1023. lpszText = (LPCTSTR)strMessage;
  1025. ::AfxMessageBox (lpszText,MB_OK | MB_ICONERROR);
  1026. dataFile.Close ();
  1027. return FALSE;
  1028. }
  1030. ++nVerifyRowNum;
  1032. if( nVerifyRowNum == cMatrixHideLayerValveValue.m_nRow )
  1033. {
  1034. break;
  1035. }
  1037. }
  1039. }
  1041. // Using for debugging
  1042. //CString strHideLayerValveValue = TEXT("TempHideLayerValveValue.txt");
  1043. //cMatrixHideLayerValveValue.SaveDataToFile (strHideLayerValveValue);
  1045. // 根据网络参数设置隐含层到输出层的权值矩阵的行列数
  1046. cMatrixHideToOutputWeightValue.SetMatrixRowAndCol (nOutputLayerNumber,nHideLayerNumber);
  1048. nIndex = 0;
  1049. nVerifyRowNum = 0;
  1051. // 读取文件中的隐含层到输出层的权值矩阵到相应的矩阵对象中
  1052. while(dataFile.ReadString (strData))
  1053. {
  1054. strData.TrimLeft ();
  1055. strData.TrimRight ();
  1057. if((strData.Find (cFirstCharacter)) == 0)
  1058. {
  1059. continue;
  1060. }
  1061. else
  1062. {
  1064. // 装入文本文件的数据到相对应的矩阵中
  1066. strData.TrimLeft ();
  1067. strData.TrimRight ();
  1069. // 验证每行的列数是否与第一行的列数相等
  1070. unsigned int nVerifyColNum = 0;
  1072. do
  1073. {
  1074. nIndex = strData.Find (SPACE_CHARACTER);
  1076. ++nVerifyColNum;
  1078. if(nIndex != -1)
  1079. {
  1080. // 提取字符串的子字符串,即提取一个double型实数数据
  1081. CString strDoubleNumber = strData.Left (nIndex);
  1083. // 将字符串转换为double型实数
  1084. double RealNumber = atof(strDoubleNumber);
  1086. cMatrixHideToOutputWeightValue.m_pTMatrix [nVerifyRowNum][nVerifyColNum - 1] = RealNumber;
  1088. strData = strData.Right (strData.GetLength () - nIndex -1);
  1090. // 去掉多余的空格
  1091. strData.TrimLeft ();
  1093. }
  1094. else
  1095. {
  1096. double RealNumber = atof(strData);
  1098. cMatrixHideToOutputWeightValue.m_pTMatrix [nVerifyRowNum][nVerifyColNum - 1] = RealNumber;
  1099. }
  1101. }while(nIndex != -1);
  1103. if(nVerifyColNum != cMatrixHideToOutputWeightValue.m_nCol)
  1104. {
  1105. CString strRowNumber;
  1106. strRowNumber.Format("%d",nVerifyRowNum + 1);
  1108. CString strColNumber;
  1109. strColNumber.Format("%d",m_nCol);
  1111. CString strVerifyColNumber;
  1112. strVerifyColNumber.Format("%d",nVerifyColNum);
  1114. CString strMessage =  CString(TEXT("文本文件第")) + strRowNumber + CString(TEXT("行一共有")) + strVerifyColNumber + CString(TEXT("列,与第一行中的列数")) + strColNumber + CString(TEXT("不相等!"));
  1116. LPCTSTR lpszText = "";
  1117. lpszText = (LPCTSTR)strMessage;
  1119. ::AfxMessageBox (lpszText,MB_OK | MB_ICONERROR);
  1120. dataFile.Close ();
  1121. return FALSE;
  1122. }
  1124. ++nVerifyRowNum;
  1126. if( nVerifyRowNum == cMatrixHideToOutputWeightValue.m_nRow )
  1127. {
  1128. break;
  1129. }
  1131. }
  1133. }
  1135. // Using for debugging
  1136. //CString strHideToOutputWeightValue = TEXT("TempHideToOutputWeightValue.txt");
  1137. //cMatrixHideToOutputWeightValue.SaveDataToFile (strHideToOutputWeightValue);
  1139. // 根据网络参数设置输出层的阀值矩阵的行列数
  1140. cMatrixOutputLayerValveValue.SetMatrixRowAndCol (nOutputLayerNumber,(unsigned int)1);
  1142. nIndex = 0;
  1143. nVerifyRowNum = 0;
  1145. // 读取文件中的输出层的阀值矩阵到相应的矩阵对象中
  1146. while(dataFile.ReadString (strData))
  1147. {
  1148. strData.TrimLeft ();
  1149. strData.TrimRight ();
  1151. if((strData.Find (cFirstCharacter)) == 0)
  1152. {
  1153. continue;
  1154. }
  1155. else
  1156. {
  1158. // 装入文本文件的数据到相对应的矩阵中
  1160. strData.TrimLeft ();
  1161. strData.TrimRight ();
  1163. // 验证每行的列数是否与第一行的列数相等
  1164. unsigned int nVerifyColNum = 0;
  1166. do
  1167. {
  1168. nIndex = strData.Find (SPACE_CHARACTER);
  1170. ++nVerifyColNum;
  1172. if(nIndex != -1)
  1173. {
  1174. // 提取字符串的子字符串,即提取一个double型实数数据
  1175. CString strDoubleNumber = strData.Left (nIndex);
  1177. // 将字符串转换为double型实数
  1178. double RealNumber = atof(strDoubleNumber);
  1180. cMatrixOutputLayerValveValue.m_pTMatrix [nVerifyRowNum][nVerifyColNum - 1] = RealNumber;
  1182. strData = strData.Right (strData.GetLength () - nIndex -1);
  1184. // 去掉多余的空格
  1185. strData.TrimLeft ();
  1187. }
  1188. else
  1189. {
  1190. double RealNumber = atof(strData);
  1192. cMatrixOutputLayerValveValue.m_pTMatrix [nVerifyRowNum][nVerifyColNum - 1] = RealNumber;
  1193. }
  1195. }while(nIndex != -1);
  1197. if(nVerifyColNum != cMatrixOutputLayerValveValue.m_nCol)
  1198. {
  1199. CString strRowNumber;
  1200. strRowNumber.Format("%d",nVerifyRowNum + 1);
  1202. CString strColNumber;
  1203. strColNumber.Format("%d",m_nCol);
  1205. CString strVerifyColNumber;
  1206. strVerifyColNumber.Format("%d",nVerifyColNum);
  1208. CString strMessage =  CString(TEXT("文本文件第")) + strRowNumber + CString(TEXT("行一共有")) + strVerifyColNumber + CString(TEXT("列,与第一行中的列数")) + strColNumber + CString(TEXT("不相等!"));
  1210. LPCTSTR lpszText = "";
  1211. lpszText = (LPCTSTR)strMessage;
  1213. ::AfxMessageBox (lpszText,MB_OK | MB_ICONERROR);
  1214. dataFile.Close ();
  1215. return FALSE;
  1216. }
  1218. ++nVerifyRowNum;
  1220. if( nVerifyRowNum == cMatrixOutputLayerValveValue.m_nRow )
  1221. {
  1222. break;
  1223. }
  1225. }
  1227. }
  1229. // Using for debugging
  1230. //CString strOutputLayerValveValue = TEXT("TempOutputLayerValveValue.txt");
  1231. //cMatrixOutputLayerValveValue.SaveDataToFile (strOutputLayerValveValue);
  1235. dataFile.Close ();
  1237. return TRUE;
  1238. }
  1242. bool CMatrix::SaveDataToFile (CString& strFileName)
  1243. {
  1244. CStdioFile dataFile;
  1245. LPCTSTR lpszFileName = "";
  1247. // CString convert to LPCTSTR
  1248. strFileName.TrimLeft ();
  1249. strFileName.TrimRight ();
  1251. lpszFileName = (LPCTSTR)strFileName;
  1253. if(!dataFile.Open (lpszFileName,CFile::modeCreate | CFile::modeNoTruncate | CFile::modeWrite | CFile::typeText))
  1254. {
  1255. ::AfxMessageBox(TEXT("不能创建文件!"),MB_OK | MB_ICONERROR);
  1256. dataFile.Close ();
  1257. return false;
  1258. }
  1260. dataFile.SeekToEnd ();
  1262. // 将对象(矩阵)中的数据写进文件
  1263. for(unsigned int i=0; i < m_nRow; i++)
  1264. {
  1265. for(unsigned int j=0; j < m_nCol; j++)
  1266. {
  1267.  CString strRealNumber;
  1269.  strRealNumber.Format ("%.16f  ", m_pTMatrix [i][j]);
  1271.  // Using for debugging
  1272.  //double nReadNumber = m_pTMatrix [i][j];
  1274.  char *pBuffer = new char[strRealNumber.GetLength()];
  1276.  memcpy(pBuffer,strRealNumber,strRealNumber.GetLength());
  1278.  dataFile.Write (pBuffer,strRealNumber.GetLength ());
  1280. }
  1282. if( i != m_nRow - 1)
  1283. {
  1284. //char ReturnNewline[] = "rn";
  1285. char ReturnNewline[] = "n";
  1287. dataFile.Write (ReturnNewline, (sizeof(ReturnNewline) - 1)/sizeof(char));
  1288. }
  1290. }
  1293. dataFile.Close ();
  1294. return true;
  1295. }
  1297. /////////////////////////////////////////////////////////////////////////////
  1298. // 对矩阵中的元素进行一次操作:
  1299. // 使矩阵变为单位阵
  1300. /////////////////////////////////////////////////////////////////////////////
  1302. void CMatrix::Eye()
  1303. {
  1304. // Verify whether the rows is equal to the columns or not
  1305. if(m_nRow != m_nCol)
  1306. {
  1307. ::AfxMessageBox (TEXT("此矩阵的行列数不相等!不能转变为单位阵!"),MB_OK | MB_ICONERROR);
  1308. return;
  1309. }
  1311. for(unsigned int i=0; i < m_nRow; i++)
  1312. {
  1313. for(unsigned int j=0; j < m_nCol; j++)
  1314. {
  1315. if(i == j)
  1316. {
  1317. m_pTMatrix [i][j] = 1;
  1318. }
  1319. else
  1320. {
  1321. m_pTMatrix [i][j] = 0;
  1322. }
  1323. }
  1325. }
  1328. }
  1331. /////////////////////////////////////////////////////////////////////////////
  1332. // Parameter:
  1333. // CMatrix& cMatrix: 被拷贝的数据源
  1334. // unsigned int nIndex: 被拷贝的数据在对象中的开始索引位置,从0开始
  1335. // Purpose:
  1336. // This function will copy all the data of the cMatrix
  1337. // Notes:
  1338. // 此对象必须是列向量!!!
  1339. /////////////////////////////////////////////////////////////////////////////
  1341. void CMatrix::GetMatrixData(CMatrix& cMatrix, unsigned int nIndex)
  1342. {
  1343. if(m_nCol != 1)
  1344. {
  1345. ::AfxMessageBox (TEXT("拷贝的矩阵不是列向量!"),MB_OK | MB_ICONERROR);
  1346. return;
  1347. }
  1349. if((m_nRow - nIndex) < (cMatrix.m_nRow * cMatrix.m_nCol))
  1350. {
  1351. ::AfxMessageBox (TEXT("拷贝矩阵的空间容量不足!"),MB_OK | MB_ICONERROR);
  1352. return;
  1353. }
  1355. for(unsigned int i=0; i < cMatrix.m_nRow; i++)
  1356. {
  1357. for(unsigned int j=0; j < cMatrix.m_nCol; j++)
  1358. {
  1359. m_pTMatrix [nIndex + i * cMatrix.m_nCol + j][0] = cMatrix.m_pTMatrix [i][j];
  1360. }
  1362. }
  1364. }
  1367. /////////////////////////////////////////////////////////////////////////////
  1368. // Parameter:
  1369. // CMatrix& cMatrix: 被填充的矩阵
  1370. // unsigned int nIndex: 被拷贝的数据在对象中的开始索引位置
  1371. // Purpose:
  1372. // This function will copy part of the object data into cMatrix
  1373. // Notes:
  1374. // The object must be column vector!!!
  1375. /////////////////////////////////////////////////////////////////////////////
  1377. void CMatrix::SetMatrixData(CMatrix& cMatrix, unsigned int nIndex)
  1378. {
  1379. // Verify whether the colunm number is 1
  1380. if(m_nCol != 1)
  1381. {
  1382. ::AfxMessageBox (TEXT("本矩阵对象不是列向量,不满足条件!"),MB_OK | MB_ICONERROR);
  1383. return;
  1384. }
  1386. // Verify whether the number of the object element is enough to be copyed
  1387. if((m_nRow - nIndex) < (cMatrix.m_nRow * cMatrix.m_nCol))
  1388. {
  1389. ::AfxMessageBox (TEXT("对象中的元素数量不足!"),MB_OK | MB_ICONERROR);
  1390. return;
  1391. }
  1394. for(unsigned int i=0; i < cMatrix.m_nRow; i++)
  1395. {
  1396. for(unsigned int j=0; j < cMatrix.m_nCol; j++)
  1397. {
  1398. cMatrix.m_pTMatrix [i][j] = m_pTMatrix [nIndex + i * cMatrix.m_nCol + j][0];
  1400. // Using for debugging
  1401. //unsigned int nIndexNumber = nIndex + i * cMatrix.m_nRow + j;
  1402. //double nData = cMatrix.m_pTMatrix [i][j];
  1404. }
  1405. }
  1407. }
  1410. /////////////////////////////////////////////////////////////////////////////
  1411. // Parameter:
  1412. // CMatrix& cMatrix: 被填充的矩阵
  1413. // unsigned int nIndex: 被拷贝的数据在对象中的开始索引位置
  1414. // unsigned int nRow: 被填充的数据在被填充对象中的行索引
  1415. // Purpose:
  1416. // This function will copy part of the object data to fill the special 
  1417. // row of the cMatrix
  1418. // Notes:
  1419. // The object must be column vector!!!
  1420. /////////////////////////////////////////////////////////////////////////////
  1422. void CMatrix::SetMatrixRowData(CMatrix& cMatrix, unsigned int nIndex, unsigned int nRow)
  1423. {
  1424. // Verify whether the column number is 1
  1425. if(m_nCol != 1)
  1426. {
  1427. ::AfxMessageBox (TEXT("本矩阵对象不是列向量,不满足条件!"),MB_OK | MB_ICONERROR);
  1428. return;
  1429. }
  1431. // Verify whether the number of the object element is enough to be copyed
  1432. if((m_nRow - nIndex) < cMatrix.m_nCol )
  1433. {
  1434. ::AfxMessageBox (TEXT("对象的元素数量不足!"),MB_OK | MB_ICONERROR);
  1435. return;
  1436. }
  1438. for(unsigned int i=0; i < cMatrix.m_nCol; i++)
  1439. {
  1440. cMatrix.m_pTMatrix [nRow][i] = m_pTMatrix [nIndex + i][(unsigned int)0];
  1441. }
  1443. }
  1446. /////////////////////////////////////////////////////////////////////////////
  1447. // Parameter:
  1448. // CMatrix& cMatrix: 被拷贝的数据源
  1449. // unsigned int nIndex: 被拷贝的数据在对象中的开始索引位置
  1450. // unsigned int nRow: 被拷贝的数据在被拷贝对象中的行索引(从0开始)
  1451. // Purpose:
  1452. // This function will copy all the data of the cMatrix
  1453. // Notes:
  1454. // 此对象必须是列向量!!!
  1455. /////////////////////////////////////////////////////////////////////////////
  1457. void CMatrix::GetMatrixRowData(CMatrix& cMatrix, unsigned int nIndex, unsigned int nRow)
  1458. {
  1459. if(m_nCol != 1)
  1460. {
  1461. ::AfxMessageBox (TEXT("拷贝的矩阵不是列向量!"),MB_OK | MB_ICONERROR);
  1462. return;
  1463. }
  1465. if((m_nRow - nIndex) < cMatrix.m_nCol)
  1466. {
  1467. ::AfxMessageBox (TEXT("拷贝矩阵的空间容量不足!"),MB_OK | MB_ICONERROR);
  1468. return;
  1469. }
  1471. for(unsigned int i=0; i < cMatrix.m_nCol; i++)
  1472. {
  1473. m_pTMatrix [nIndex + i][(unsigned int)0] = cMatrix.m_pTMatrix [nRow][i];
  1474. }
  1476. }
  1478. void CMatrix::SetMatrixRowNumber(unsigned int nRow)
  1479. {
  1480. m_nRow = nRow;
  1482. m_pTMatrix.resize (m_nRow);
  1483. for(unsigned int i=0; i < m_nRow; i++)
  1484. {
  1485. for(unsigned int j=0; j < m_nCol; j++)
  1486. {
  1487. m_pTMatrix[i].resize (m_nCol);
  1488. m_pTMatrix[i][j] = (double) 0;
  1489. }
  1490. }
  1492. }
  1495. void CMatrix::SetMatrixColNumber(unsigned int nCol)
  1496. {
  1497. m_nCol = nCol;
  1499. m_pTMatrix.resize (m_nRow);
  1500. for(unsigned int i=0; i < m_nRow; i++)
  1501. {
  1502. for(unsigned int j=0; j < m_nCol; j++)
  1503. {
  1504. m_pTMatrix[i].resize (m_nCol);
  1505. m_pTMatrix[i][j] = (double) 0;
  1506. }
  1507. }
  1509. }
  1511. /////////////////////////////////////////////////////////////////////////
  1512. // 设置矩阵的行列数
  1513. void CMatrix::SetMatrixRowAndCol(unsigned int nRow,unsigned int nCol)
  1514. {
  1515. m_nRow = nRow;
  1516. m_nCol = nCol;
  1518. // 分配内存
  1519. m_pTMatrix.resize (m_nRow);
  1520. for(unsigned int i=0; i < m_nRow; i++)
  1521. {
  1522. for(unsigned int j=0; j < m_nCol; j++)
  1523. {
  1524. m_pTMatrix[i].resize (m_nCol);
  1525. m_pTMatrix[i][j] = (double) 0;
  1526. }
  1527. }
  1529. }
  1532. /////////////////////////////////////////////////////////////////////////////
  1533. // Initialize()
  1534. // 矩阵初始化函数,矩阵的行列数目被初始化为零,矩阵中的元素全部初始化为零
  1535. /////////////////////////////////////////////////////////////////////////////
  1537. void CMatrix::Initialize()
  1538. {
  1539. m_nRow = 0;
  1540. m_nCol = 0;
  1542. m_pTMatrix.resize (m_nRow);
  1543. for(unsigned int i=0; i < m_nRow; i++)
  1544. {
  1545. for(unsigned int j=0; j < m_nCol; j++)
  1546. {
  1547. m_pTMatrix[i].resize (m_nCol);
  1548. m_pTMatrix[i][j] = (double) 0;
  1549. }
  1550. }
  1552. }
  1554. /////////////////////////////////////////////////////////////////////////////
  1555. // InitializeZero()
  1556. // 矩阵初始化函数,矩阵的行列数目被初始化为零,矩阵中的元素全部初始化为零
  1557. /////////////////////////////////////////////////////////////////////////////
  1559. void CMatrix::InitializeZero()
  1560. {
  1561. m_nRow = 0;
  1562. m_nCol = 0;
  1564. m_pTMatrix.resize (m_nRow);
  1565. for(unsigned int i=0; i < m_nRow; i++)
  1566. {
  1567. for(unsigned int j=0; j < m_nCol; j++)
  1568. {
  1569. m_pTMatrix[i].resize (m_nCol);
  1570. m_pTMatrix[i][j] = (double) 0;
  1571. }
  1572. }
  1574. }
  1576. /////////////////////////////////////////////////////////////////////////////
  1577. // RandomInitialize()
  1578. // 将矩阵中的元素随机初始化函数,元素的值在(-1,1)之间的小数
  1579. /////////////////////////////////////////////////////////////////////////////
  1581. void CMatrix::RandomInitialize ()
  1582. {
  1583. for(unsigned int i=0; i < m_nRow; i++)
  1584. {
  1585. for(unsigned int j=0; j < m_nCol; j++)
  1586. {
  1587. m_pTMatrix [i][j] = (double)(rand() - (0.5*RAND_MAX)) / (0.5*RAND_MAX);
  1588. }
  1589. }
  1591. }
  1594. /////////////////////////////////////////////////////////////////////////////
  1595. // 拷贝矩阵的子矩阵元素到另外一个矩阵中
  1596. // Parameter:
  1597. // [out] cMatrix ----> 矩阵的子矩阵返回的结果
  1598. // [in] nStartX ----> 子矩阵在矩阵中的起始坐标,对应行,索引从1开始
  1599. // [in] nStartY ----> 子矩阵在矩阵中的起始坐标,对应列,索引从1开始
  1600. /////////////////////////////////////////////////////////////////////////////
  1602. void CMatrix::CopySubMatrix(CMatrix& cMatrix,unsigned int nStartX,unsigned int nStartY)
  1603. {
  1604. if((m_nRow  < cMatrix.m_nRow + nStartY ) | (m_nCol  < cMatrix.m_nCol + nStartX))
  1605. {
  1606. ::AfxMessageBox (TEXT("被拷贝的矩阵维数小于要拷贝的矩阵所需要的维数!"),MB_OK | MB_ICONERROR);
  1607. return;
  1608. }
  1610. for(unsigned int i=0;  i < cMatrix.m_nRow; i++)
  1611. {
  1612. for(unsigned int j=0; j < cMatrix.m_nCol; j++)
  1613. {
  1614. cMatrix.m_pTMatrix [i][j] = m_pTMatrix [nStartY + i][nStartX + j];
  1615. }
  1616. }
  1618. }
  1620. /////////////////////////////////////////////////////////////////////////////
  1621. // Copy Matrix
  1622. // Parameter:
  1623. // [in] cMatrix ----> 被拷贝的矩阵
  1624. /////////////////////////////////////////////////////////////////////////////
  1626. void CMatrix::CopyMatrix(CMatrix& cMatrix)
  1627. {
  1628. m_nRow = cMatrix.m_nRow ;
  1629. m_nCol = cMatrix.m_nCol ;
  1631. m_pTMatrix = cMatrix.m_pTMatrix ;
  1633. for(unsigned int i=0; i < m_nRow; i++)
  1634. {
  1635. for(unsigned int j=0; j < m_nCol; j++)
  1636. {
  1637. m_pTMatrix [i][j] = cMatrix.m_pTMatrix [i][j];
  1638. }
  1640. }
  1642. }
  1644. /////////////////////////////////////////////////////////////////////////////
  1645. // 从一个列向量中拷贝数据到一个矩阵中
  1646. // Parameter:
  1647. // [out] cMatrix ----> 函数的返回结果
  1648. // [in] nIndex ----> 在列向量中的索引值
  1649. // Notes:
  1650. // 被拷贝的对象必须是列向量!!!
  1651. /////////////////////////////////////////////////////////////////////////////
  1653. void CMatrix::CopySubMatrixFromVector(CMatrix& cMatrix,unsigned int nIndex)
  1654. {
  1655. if(m_nCol != 1)
  1656. {
  1657. ::AfxMessageBox (TEXT("被拷贝的矩阵不是列向量!!!"),MB_OK | MB_ICONERROR);
  1658. return;
  1659. }
  1661. for(unsigned int j=0; j < cMatrix.m_nCol; j++)
  1662. {
  1663. for(unsigned int i=0; i < cMatrix.m_nRow; i++)
  1664. {
  1665. cMatrix.m_pTMatrix [i][j] = m_pTMatrix [nIndex + j * cMatrix.m_nRow + i ][(unsigned int)0];
  1666. }
  1667. }
  1669. }
  1671. /////////////////////////////////////////////////////////////////////////////
  1672. // 对矩阵进列拓展
  1673. // 实现功能:
  1674. // 对矩阵的列数进行拓展,nTimes是每列拓展的次数
  1675. /////////////////////////////////////////////////////////////////////////////
  1677. void CMatrix::nncpyi(CMatrix &cMatrix, unsigned int nTimes)
  1678. {
  1679. m_nRow = cMatrix.m_nRow ;
  1680. m_nCol = cMatrix.m_nCol * nTimes;
  1682. // 根据空间分配内存
  1683. m_pTMatrix.resize (m_nRow);
  1684. for(unsigned int i=0; i < m_nRow; i++)
  1685. {
  1686. for(unsigned int j=0; j < m_nCol; j++)
  1687. {
  1688. m_pTMatrix[i].resize (m_nCol);
  1689. m_pTMatrix[i][j] = (double) 0;
  1690. }
  1691. }
  1693. // 赋值
  1694. for(i=0; i < m_nRow; i++)
  1695. {
  1696. for(unsigned int j=0; j < cMatrix.m_nCol; j++)
  1697. {
  1698. for(unsigned int k=0; k < nTimes; k++)
  1699. {
  1700. m_pTMatrix [i][j * nTimes + k] = cMatrix.m_pTMatrix [i][j];
  1701. }
  1702. }
  1703. }
  1705. }
  1707. /////////////////////////////////////////////////////////////////////////////
  1708. // 对矩阵进行拓展
  1709. // 实现功能:
  1710. // 对矩阵的列数进行拓展
  1711. // matrix = [ 
  1712. // 1 2 3
  1713. // 4 5 6
  1714. // 7 8 9
  1715. // ]
  1716. //
  1717. // nncpyd(matrix) = [
  1718. // 1 0 0 2 0 0 3 0 0
  1719. // 0 4 0 0 5 0 0 6 0
  1720. // 0 0 7 0 0 8 0 0 9
  1721. // ]
  1722. /////////////////////////////////////////////////////////////////////////////
  1724. void CMatrix::nncpyd(CMatrix &cMatrix)
  1725. {
  1726. m_nRow = cMatrix.m_nRow ;
  1727. m_nCol = cMatrix.m_nCol * cMatrix.m_nRow ;
  1729. // 根据空间分配内存
  1730. m_pTMatrix.resize (m_nRow);
  1731. for(unsigned int i=0; i < m_nRow; i++)
  1732. {
  1733. for(unsigned int j=0; j < m_nCol; j++)
  1734. {
  1735. m_pTMatrix[i].resize (m_nCol);
  1736. m_pTMatrix[i][j] = (double) 0;
  1737. }
  1738. }
  1740. // 给矩阵赋值
  1741. for(i=0; i < m_nRow; i++)
  1742. {
  1743. for(unsigned int j=0; j < cMatrix.m_nCol; j++)
  1744. {
  1745. for(unsigned int k=0; k < cMatrix.m_nRow; k++)
  1746. {
  1747. if(i == (j * cMatrix.m_nRow + k) % cMatrix.m_nRow )
  1748. m_pTMatrix [i][j * cMatrix.m_nRow + k] = cMatrix.m_pTMatrix [i][j];
  1749. }
  1750. }
  1751. }
  1753. }
  1755. /////////////////////////////////////////////////////////////////////////////
  1756. // 对矩阵进行拓展
  1757. // 实现功能:
  1758. // 对矩阵的列数进行拓展,nTimes是每列拓展的次数
  1759. // matrix = [ 
  1760. // 1 2 3
  1761. // 4 5 6
  1762. // 7 8 9
  1763. // ]
  1764. // nTimes = 2
  1765. //
  1766. // nncpyd(matrix) = [
  1767. // 1 2 3 1 2 3
  1768. // 4 5 6 4 5 6
  1769. // 7 8 9 7 8 9
  1770. // ]
  1771. /////////////////////////////////////////////////////////////////////////////
  1773. void CMatrix::nncpy(CMatrix& cMatrix,unsigned int nTimes)
  1774. {
  1775. m_nRow = cMatrix.m_nRow ;
  1776. m_nCol = cMatrix.m_nCol * nTimes;
  1778. // 根据空间分配内存
  1779. m_pTMatrix.resize (m_nRow);
  1780. for(unsigned int i=0; i < m_nRow; i++)
  1781. {
  1782. for(unsigned int j=0; j < m_nCol; j++)
  1783. {
  1784. m_pTMatrix[i].resize (m_nCol);
  1785. m_pTMatrix[i][j] = (double) 0;
  1786. }
  1787. }
  1789. // 对矩阵赋值
  1790. for(i=0; i < m_nRow; i++)
  1791. {
  1792. for(unsigned int j=0; j < nTimes; j++)
  1793. {
  1794. for(unsigned int k=0; k < cMatrix.m_nCol; k++)
  1795. {
  1796. m_pTMatrix [i][j * cMatrix.m_nCol + k] = cMatrix.m_pTMatrix [i][k];
  1797. }
  1798. }
  1799. }
  1801. }
  1803. /////////////////////////////////////////////////////////////////////////////
  1804. // 对矩阵中所有的元素进行一次非线性变换:
  1805. // 变换后的值y与变换前的值的关系是:
  1806. // y = f(x) = 1 / (1 + exp(-x)) ( 0 < f(x) < 1)
  1807. //
  1808. /////////////////////////////////////////////////////////////////////////////
  1810. CMatrix CMatrix::Sigmoid()
  1811. {
  1812. CMatrix cMatrix = *this;
  1814. for(unsigned int i=0; i < m_nRow; i++)
  1815. {
  1816. for(unsigned int j=0; j < m_nCol; j++)
  1817. {
  1818. cMatrix.m_pTMatrix [i][j] = 1 / (1 + exp(-m_pTMatrix [i][j]));
  1819. }
  1821. }
  1823. return cMatrix;
  1824. }
  1827. /////////////////////////////////////////////////////////////////////////////
  1828. // 对矩阵中所有的元素进行一次非线性变换:
  1829. // 变换后的值y与变换前的值的关系是:
  1830. // y = tanh(x) = (1 - exp(-x)) / (1 + exp(-x))
  1831. //  =  1 - 2 * exp(-x) / (1 + exp(-x)) ( -1 < f(x) < 1)
  1832. //
  1833. /////////////////////////////////////////////////////////////////////////////
  1835. CMatrix CMatrix::tanh ()
  1836. {
  1837. CMatrix cMatrix = *this;
  1839. for(unsigned int i=0; i < m_nRow; i++)
  1840. {
  1841. for(unsigned int j=0; j < m_nCol; j++)
  1842. {
  1843. cMatrix.m_pTMatrix [i][j] = 1 - (2 * exp(-m_pTMatrix [i][j])) / (1 + exp(-m_pTMatrix [i][j]));
  1844. }
  1846. }
  1848. return cMatrix;
  1849. }
  1851. /////////////////////////////////////////////////////////////////////////////
  1852. // 对矩阵中所有的元素进行一次非线性变换:
  1853. // 变换后的值y与变换前的值的关系是:
  1854. // y = Tansig(x) = 2 / (1 + exp(-2 * x)) -1
  1855. /////////////////////////////////////////////////////////////////////////////
  1857. CMatrix CMatrix::Tansig()
  1858. {
  1859. CMatrix cMatrix = *this;
  1861. for(unsigned int i=0; i < m_nRow; i++)
  1862. {
  1863. for(unsigned int j=0; j < m_nCol; j++)
  1864. {
  1865. cMatrix.m_pTMatrix [i][j] = 2 / (1 + exp(- 2 * m_pTMatrix [i][j])) - 1;
  1866. }
  1867. }
  1869. return cMatrix;
  1871. }
  1873. /////////////////////////////////////////////////////////////////////////////
  1874. // 对矩阵中所有的元素进行一次非线性变换:
  1875. // 变换后的值y与变换前的值的关系是:
  1876. // y = Tansig'(x) = (2 / (1 + exp(-2 * x)) -1)'
  1877. // = (2 / (1 + exp(-2 * x)) -1) * (2 / (1 + exp(-2 * x)) -1) -1
  1878. /////////////////////////////////////////////////////////////////////////////
  1880. CMatrix CMatrix::TansigDerivative()
  1881. {
  1882. CMatrix cMatrix = *this;
  1884. for(unsigned int i=0; i < m_nRow; i++)
  1885. {
  1886. for(unsigned int j=0; j < m_nCol; j++)
  1887. {
  1888. cMatrix.m_pTMatrix [i][j] = (2 / (1 + exp(- 2 * m_pTMatrix [i][j])) - 1) * (2 / (1 + exp(- 2 * m_pTMatrix [i][j])) - 1) - 1;
  1889. }
  1890. }
  1892. return cMatrix;
  1894. }
  1896. /////////////////////////////////////////////////////////////////////////////
  1897. // 对矩阵中的元素进行一次操作:
  1898. // 使所有行中的相对应的列元素相等
  1899. // Parameter:
  1900. // nRowIndex ----> 行索引值(从零开始)
  1901. // 以此行做为标准,使矩阵中其余的行相对应的列的值
  1902. // 与此行相对应的列的值相等
  1903. /////////////////////////////////////////////////////////////////////////////
  1905. void CMatrix::MakeAllColumnElementsSameValue(unsigned int nRowIndex)
  1906. {
  1907. for(unsigned int i=0; i < m_nRow; i++)
  1908. {
  1909. if(i == nRowIndex)
  1910. continue;
  1912. for(unsigned int j=0; j < m_nCol; j++)
  1913. {
  1914. m_pTMatrix [i][j] = m_pTMatrix [nRowIndex][j];
  1915. }
  1916. }
  1918. }
  1921. /////////////////////////////////////////////////////////////////////////////
  1922. // 对矩阵中所有的元素进行一次非线性变换:
  1923. // 变换后的值y与变换前的值的关系是:
  1924. // y = f'(x) = (1 / (1 + exp(-x)))' ( 0 < f(x) < 1)
  1925. //   = exp(-x)/((1 + exp(-x))*(1 + exp(-x)))
  1926. /////////////////////////////////////////////////////////////////////////////
  1928. CMatrix CMatrix::SigmoidDerivative()
  1929. {
  1930. CMatrix cMatrix = *this;
  1932. for(unsigned int i=0; i < m_nRow; i++)
  1933. {
  1934. for(unsigned int j=0; j < m_nCol; j++)
  1935. {
  1936. cMatrix.m_pTMatrix [i][j] = exp(-m_pTMatrix [i][j]) / ((1 + exp(-m_pTMatrix [i][j])) * (1 + exp(-m_pTMatrix [i][j])));
  1937. }
  1939. }
  1941. return cMatrix;
  1942. }
  1945. /////////////////////////////////////////////////////////////////////////////
  1946. // 对矩阵中所有的元素进行一次非线性变换:
  1947. // 变换后的值y与变换前的值的关系是:
  1948. // y = tanh'(x) = ((1 - exp(-x)) / (1 + exp(-x)))' ( -1 < f(x) < 1)
  1949. //  =  2*exp(-x)/((1 + exp(-x))*(1 + exp(-x)))
  1950. /////////////////////////////////////////////////////////////////////////////
  1952. CMatrix CMatrix::tanhDerivative()
  1953. {
  1954. CMatrix cMatrix = *this;
  1956. for(unsigned int i=0; i < m_nRow; i++)
  1957. {
  1958. for(unsigned int j=0; j < m_nCol; j++)
  1959. {
  1960. cMatrix.m_pTMatrix [i][j] = 2 * exp(-m_pTMatrix [i][j]) / ((1 + exp(-m_pTMatrix [i][j])) * (1 + exp(-m_pTMatrix [i][j])));
  1961. }
  1963. }
  1965. return cMatrix;
  1966. }
  1969. /////////////////////////////////////////////////////////////////////////////
  1970. // 实现对点乘操作符的重载
  1971. /////////////////////////////////////////////////////////////////////////////
  1973. CMatrix CMatrix::operator / (CMatrix& cMatrixB)
  1974. {
  1975. CMatrix cMatrix = *this;
  1977. if( (m_nRow != cMatrixB.m_nRow) || (m_nCol != cMatrixB.m_nCol) )
  1978. {
  1979. ::AfxMessageBox (TEXT("两个矩阵的维数不相等,不满足矩阵点乘的条件!"),MB_OK | MB_ICONERROR);
  1980. return cMatrix; // return a invalid value
  1981. }
  1983. for(unsigned int i=0; i < m_nRow; i++)
  1984. {
  1985. for(unsigned int j=0; j < m_nCol; j++)
  1986. {
  1987. cMatrix.m_pTMatrix [i][j] = m_pTMatrix [i][j] * cMatrixB.m_pTMatrix [i][j];
  1988. }
  1990. }
  1992. return cMatrix;
  1994. }
  1998. //***************************************************************************
  1999. // ordinary function
  2000. //
  2002. /////////////////////////////////////////////////////////////////////////////
  2003. // 重载 'double - CMatrix' 运算符
  2004. /////////////////////////////////////////////////////////////////////////////
  2006. CMatrix operator - (double nValue,CMatrix& cMatrixB)
  2007. {
  2008. CMatrix cMatrix = cMatrixB;
  2010. for(unsigned int i=0; i < cMatrix.GetMatrixRowNumber (); i++)
  2011. {
  2012. for(unsigned int j=0; j < cMatrix.GetMatrixColNumber (); j++)
  2013. {
  2014. cMatrix.m_pTMatrix [i][j] = nValue - cMatrixB.m_pTMatrix [i][j];
  2015. }
  2016. }
  2018. return cMatrix;
  2019. }
  2023. /////////////////////////////////////////////////////////////////////////////
  2024. // 矩阵合并运算符
  2025. // 合并规则:
  2026. // 1. 参与合并运算的两个矩阵的行数必须相等;
  2027. // 2. 参与合并的两个矩阵的列数可以不相等;
  2028. // 3. 合并后返回的矩阵的行数与参与合并的矩阵的行数相等,列数是参与合并的
  2029. // 两个矩阵的列数之和;
  2030. /////////////////////////////////////////////////////////////////////////////
  2032. CMatrix MergeMatrix(CMatrix& cMatrixA,CMatrix& cMatrixB)
  2033. {
  2034. // 条件检测
  2035. if( cMatrixA.GetMatrixRowNumber () != cMatrixB.GetMatrixRowNumber () )
  2036. {
  2037. ::AfxMessageBox (TEXT("参与合并的两个矩阵的行数不相等!"),MB_OK | MB_ICONERROR);
  2039. return cMatrixA; // return invalid value
  2040. }
  2042. CMatrix cMatrix(cMatrixA.GetMatrixRowNumber (),cMatrixA.GetMatrixColNumber () + cMatrixB.GetMatrixColNumber ());
  2044. for(unsigned int i=0; i < cMatrixA.GetMatrixRowNumber (); i++)
  2045. {
  2046. for(unsigned int j=0; j < cMatrixA.GetMatrixColNumber (); j++)
  2047. {
  2048. cMatrix.m_pTMatrix [i][j] = cMatrixA.m_pTMatrix [i][j];
  2049. }
  2051. for(unsigned int k=0; k < cMatrixB.GetMatrixColNumber (); k++)
  2052. {
  2053. cMatrix.m_pTMatrix [i][cMatrixA.GetMatrixColNumber () + k] = cMatrixB.m_pTMatrix [i][k];
  2054. }
  2056. }
  2059. return cMatrix;
  2060. }
  2062. // End of ordinary function
  2063. //***************************************************************************