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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数值算法/人工智能 > 数学计算 > 查看源码
NLequationCalculatorDlg.cpp
资源名称：科学与工程数值计算算法配套源码vc++.zip　[点击查看]
上传用户：weigute
上传日期：2007-03-02
资源大小：1287k
文件大小：14k
源码类别：

数学计算

开发平台：

Visual C++

NLequationCalculatorDlg.cpp：源码内容
  1. // NLequationCalculatorDlg.cpp : implementation file
  2. //
  4. #include "stdafx.h"
  5. #include "NLequationCalculator.h"
  6. #include "NLequationCalculatorDlg.h"
  7. #include "NLequation.h"
  9. #ifdef _DEBUG
  10. #define new DEBUG_NEW
  11. #undef THIS_FILE
  12. static char THIS_FILE[] = __FILE__;
  13. #endif
  15. /////////////////////////////////////////////////////////////////////////////
  16. // CAboutDlg dialog used for App About
  18. class CAboutDlg : public CDialog
  19. {
  20. public:
  21. CAboutDlg();
  23. // Dialog Data
  24. //{{AFX_DATA(CAboutDlg)
  25. enum { IDD = IDD_ABOUTBOX };
  26. //}}AFX_DATA
  28. // ClassWizard generated virtual function overrides
  29. //{{AFX_VIRTUAL(CAboutDlg)
  30. protected:
  31. virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV support
  32. //}}AFX_VIRTUAL
  34. // Implementation
  35. protected:
  36. //{{AFX_MSG(CAboutDlg)
  37. //}}AFX_MSG
  38. DECLARE_MESSAGE_MAP()
  39. };
  41. CAboutDlg::CAboutDlg() : CDialog(CAboutDlg::IDD)
  42. {
  43. //{{AFX_DATA_INIT(CAboutDlg)
  44. //}}AFX_DATA_INIT
  45. }
  47. void CAboutDlg::DoDataExchange(CDataExchange* pDX)
  48. {
  49. CDialog::DoDataExchange(pDX);
  50. //{{AFX_DATA_MAP(CAboutDlg)
  51. //}}AFX_DATA_MAP
  52. }
  54. BEGIN_MESSAGE_MAP(CAboutDlg, CDialog)
  55. //{{AFX_MSG_MAP(CAboutDlg)
  56. // No message handlers
  57. //}}AFX_MSG_MAP
  58. END_MESSAGE_MAP()
  60. /////////////////////////////////////////////////////////////////////////////
  61. // CNLequationCalculatorDlg dialog
  63. CNLequationCalculatorDlg::CNLequationCalculatorDlg(CWnd* pParent /*=NULL*/)
  64. : CDialog(CNLequationCalculatorDlg::IDD, pParent)
  65. {
  66. //{{AFX_DATA_INIT(CNLequationCalculatorDlg)
  67. // NOTE: the ClassWizard will add member initialization here
  68. //}}AFX_DATA_INIT
  69. // Note that LoadIcon does not require a subsequent DestroyIcon in Win32
  70. m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
  71. }
  73. void CNLequationCalculatorDlg::DoDataExchange(CDataExchange* pDX)
  74. {
  75. CDialog::DoDataExchange(pDX);
  76. //{{AFX_DATA_MAP(CNLequationCalculatorDlg)
  77. // NOTE: the ClassWizard will add DDX and DDV calls here
  78. //}}AFX_DATA_MAP
  79. }
  81. BEGIN_MESSAGE_MAP(CNLequationCalculatorDlg, CDialog)
  82. //{{AFX_MSG_MAP(CNLequationCalculatorDlg)
  83. ON_WM_SYSCOMMAND()
  84. ON_WM_PAINT()
  85. ON_WM_QUERYDRAGICON()
  86. ON_BN_CLICKED(IDC_BUTTON1, OnButton1)
  87. ON_BN_CLICKED(IDC_BUTTON2, OnButton2)
  88. ON_BN_CLICKED(IDC_BUTTON3, OnButton3)
  89. ON_BN_CLICKED(IDC_BUTTON4, OnButton4)
  90. ON_BN_CLICKED(IDC_BUTTON5, OnButton5)
  91. ON_BN_CLICKED(IDC_BUTTON6, OnButton6)
  92. ON_BN_CLICKED(IDC_BUTTON7, OnButton7)
  93. ON_BN_CLICKED(IDC_BUTTON8, OnButton8)
  94. ON_BN_CLICKED(IDC_BUTTON9, OnButton9)
  95. ON_BN_CLICKED(IDC_BUTTON10, OnButton10)
  96. ON_BN_CLICKED(IDC_BUTTON11, OnButton11)
  97. ON_BN_CLICKED(IDC_BUTTON12, OnButton12)
  98. ON_BN_CLICKED(IDC_BUTTON13, OnButton13)
  99. //}}AFX_MSG_MAP
  100. END_MESSAGE_MAP()
  102. /////////////////////////////////////////////////////////////////////////////
  103. // CNLequationCalculatorDlg message handlers
  105. BOOL CNLequationCalculatorDlg::OnInitDialog()
  106. {
  107. CDialog::OnInitDialog();
  109. // Add "About..." menu item to system menu.
  111. // IDM_ABOUTBOX must be in the system command range.
  112. ASSERT((IDM_ABOUTBOX & 0xFFF0) == IDM_ABOUTBOX);
  113. ASSERT(IDM_ABOUTBOX < 0xF000);
  115. CMenu* pSysMenu = GetSystemMenu(FALSE);
  116. if (pSysMenu != NULL)
  117. {
  118. CString strAboutMenu;
  119. strAboutMenu.LoadString(IDS_ABOUTBOX);
  120. if (!strAboutMenu.IsEmpty())
  121. {
  122. pSysMenu->AppendMenu(MF_SEPARATOR);
  123. pSysMenu->AppendMenu(MF_STRING, IDM_ABOUTBOX, strAboutMenu);
  124. }
  125. }
  127. // Set the icon for this dialog.  The framework does this automatically
  128. //  when the application's main window is not a dialog
  129. SetIcon(m_hIcon, TRUE); // Set big icon
  130. SetIcon(m_hIcon, FALSE); // Set small icon
  132. // TODO: Add extra initialization here
  134. return TRUE;  // return TRUE  unless you set the focus to a control
  135. }
  137. void CNLequationCalculatorDlg::OnSysCommand(UINT nID, LPARAM lParam)
  138. {
  139. if ((nID & 0xFFF0) == IDM_ABOUTBOX)
  140. {
  141. CAboutDlg dlgAbout;
  142. dlgAbout.DoModal();
  143. }
  144. else
  145. {
  146. CDialog::OnSysCommand(nID, lParam);
  147. }
  148. }
  150. // If you add a minimize button to your dialog, you will need the code below
  151. //  to draw the icon.  For MFC applications using the document/view model,
  152. //  this is automatically done for you by the framework.
  154. void CNLequationCalculatorDlg::OnPaint() 
  155. {
  156. if (IsIconic())
  157. {
  158. CPaintDC dc(this); // device context for painting
  160. SendMessage(WM_ICONERASEBKGND, (WPARAM) dc.GetSafeHdc(), 0);
  162. // Center icon in client rectangle
  163. int cxIcon = GetSystemMetrics(SM_CXICON);
  164. int cyIcon = GetSystemMetrics(SM_CYICON);
  165. CRect rect;
  166. GetClientRect(&rect);
  167. int x = (rect.Width() - cxIcon + 1) / 2;
  168. int y = (rect.Height() - cyIcon + 1) / 2;
  170. // Draw the icon
  171. dc.DrawIcon(x, y, m_hIcon);
  172. }
  173. else
  174. {
  175. CDialog::OnPaint();
  176. }
  177. }
  179. // The system calls this to obtain the cursor to display while the user drags
  180. //  the minimized window.
  181. HCURSOR CNLequationCalculatorDlg::OnQueryDragIcon()
  182. {
  183. return (HCURSOR) m_hIcon;
  184. }
  186. // 求非线性方程实根的对分法
  187. void CNLequationCalculatorDlg::OnButton1() 
  188. {
  189. // 建立CNLequation的子类，在其中重载函数Func
  190. class CNLeq : public CNLequation
  191. {
  192. double Func(double x)
  193. {
  194. double z = (((((x-5.0)*x+3.0)*x+1.0)*x-7.0)*x+7.0)*x-20.0;
  195. return z;
  196. }
  197. };
  199. // 求解
  200. CNLeq nleq;
  201. double x[6];
  202. int n = nleq.GetRootBisect(6, x, -2, 5, 0.2);
  204. // 显示结果
  205. CString sMsg;
  206. sMsg.Format("求得如下 %d 个根：nn", n);
  207. CString ss;
  208.     for (int i=0; i<=n-1; i++)
  209. {
  210. ss.Format("x(%d) = %fn",i,x[i]);
  211. sMsg += ss;
  212. }
  214.     AfxMessageBox(sMsg, MB_OK|MB_ICONINFORMATION);
  215. }
  217. // 求非线性方程一个实根的牛顿法
  218. void CNLequationCalculatorDlg::OnButton2() 
  219. {
  220. // 建立CNLequation的子类，在其中重载函数Func
  221. class CNLeq : public CNLequation
  222. {
  223. void Func(double x, double y[])
  224. {
  225. y[0]=x*x*(x-1.0)-1.0;
  226. y[1]=3.0*x*x-2.0*x;
  227. }
  228. };
  230. // 求解
  231. CNLeq nleq;
  232. double x = 1.5;
  233. int bRet = nleq.GetRootNewton(&x);
  235. // 显示结果
  236. CString sMsg;
  237. if (bRet)
  238. sMsg.Format("求得的一个实根为：nnx = %fn", x);
  239. else
  240. sMsg = "求解失败";
  242. AfxMessageBox(sMsg, MB_OK|MB_ICONINFORMATION);
  243. }
  245. // 求非线性方程一个实根的埃特金迭代法
  246. void CNLequationCalculatorDlg::OnButton3() 
  247. {
  248. // 建立CNLequation的子类，在其中重载函数Func
  249. class CNLeq : public CNLequation
  250. {
  251. double Func(double x)
  252. {
  253.     double y = 6.0-x*x;
  255. return y;
  256. }
  257. };
  259. // 求解
  260. CNLeq nleq;
  261. double x = 0.0;
  262. int bRet = nleq.GetRootAitken(&x);
  264. // 显示结果
  265. CString sMsg;
  266. if (bRet)
  267. sMsg.Format("求得的一个实根为：nnx = %fn", x);
  268. else
  269. sMsg = "求解失败";
  271. AfxMessageBox(sMsg, MB_OK|MB_ICONINFORMATION);
  272. }
  274. // 求非线性方程一个实根的连分式解法
  275. void CNLequationCalculatorDlg::OnButton4() 
  276. {
  277. // 建立CNLequation的子类，在其中重载函数Func
  278. class CNLeq : public CNLequation
  279. {
  280. double Func(double x)
  281. {
  282.     double y = x*x*(x-1.0)-1.0;
  284. return y;
  285. }
  286. };
  288. // 求解
  289. CNLeq nleq;
  290. double x = 1.0;
  291. int bRet = nleq.GetRootPq(&x);
  293. // 显示结果
  294. CString sMsg;
  295. if (bRet)
  296. sMsg.Format("求得的一个实根为：nnx = %fn", x);
  297. else
  298. sMsg = "求解失败";
  300. AfxMessageBox(sMsg, MB_OK|MB_ICONINFORMATION);
  301. }
  303. // 求实系数代数方程全部根的QR方法
  304. void CNLequationCalculatorDlg::OnButton5() 
  305. {
  306. // 求解
  307. CNLequation nleq;
  308. double xr[6], xi[6];
  309. double a[7] = {-30.0,10.5,-10.5,1.5,4.5,-7.5,1.5};
  310. int n = 6;
  311. int bRet = nleq.GetRootQr(n, a, xr, xi);
  313. // 显示结果
  314. CString sMsg;
  315. if (bRet)
  316. {
  317. sMsg.Format("求得的 %d 个根为：nn", n);
  318. for (int i=0; i<n; ++i)
  319. {
  320. CComplex root;
  321. root.SetReal(xr[i]);
  322. root.SetImag(xi[i]);
  324. CString ss;
  325. ss.Format("x(%d) = %sn", i, root.ToString());
  327. sMsg += ss;
  328. }
  329. }
  330. else
  331. sMsg = "求解失败";
  333. AfxMessageBox(sMsg, MB_OK|MB_ICONINFORMATION);
  334. }
  336. // 求实系数代数方程全部根的牛顿下山法
  337. void CNLequationCalculatorDlg::OnButton6() 
  338. {
  339. // 求解
  340. CNLequation nleq;
  341. double xr[6], xi[6];
  342. double a[7] = {-20.0,7.0,-7.0,1.0,3.0,-5.0,1.0};
  343. int n = 6;
  344. int bRet = nleq.GetRootNewtonDownHill(n, a, xr, xi);
  346. // 显示结果
  347. CString sMsg;
  348. if (bRet)
  349. {
  350. sMsg.Format("求得的 %d 个根为：nn", n);
  351. for (int i=0; i<n; ++i)
  352. {
  353. CComplex root;
  354. root.SetReal(xr[i]);
  355. root.SetImag(xi[i]);
  357. CString ss;
  358. ss.Format("x(%d) = %sn", i, root.ToString());
  360. sMsg += ss;
  361. }
  362. }
  363. else
  364. sMsg = "求解失败";
  366. AfxMessageBox(sMsg, MB_OK|MB_ICONINFORMATION);
  367. }
  369. // 求复系数代数方程全部根的牛顿下山法
  370. void CNLequationCalculatorDlg::OnButton7() 
  371. {
  372. // 求解
  373. CNLequation nleq;
  374. double xr[5], xi[5];
  375.     double ar[6]={0.1,21.33,4.9,0.0,3.0,1.0};
  376.     double ai[6]={-100.0,0.0,-19.0,-0.01,2.0,0.0};
  377. int n = 5;
  378. int bRet = nleq.GetRootNewtonDownHill(n, ar, ai, xr, xi);
  380. // 显示结果
  381. CString sMsg;
  382. if (bRet)
  383. {
  384. sMsg.Format("求得的 %d 个根为：nn", n);
  385. for (int i=0; i<n; ++i)
  386. {
  387. CComplex root;
  388. root.SetReal(xr[i]);
  389. root.SetImag(xi[i]);
  391. CString ss;
  392. ss.Format("x(%d) = %sn", i, root.ToString());
  394. sMsg += ss;
  395. }
  396. }
  397. else
  398. sMsg = "求解失败";
  400. AfxMessageBox(sMsg, MB_OK|MB_ICONINFORMATION);
  401. }
  403. // 求非线性方程一个实根的蒙特卡洛法
  404. void CNLequationCalculatorDlg::OnButton8() 
  405. {
  406. // 建立CNLequation的子类，在其中重载函数Func
  407. class CNLeq : public CNLequation
  408. {
  409. double Func(double x)
  410. {
  411. double z = exp(-x*x*x)-sin(x)/cos(x)+800.0;
  412. return z;
  413. }
  414. };
  416. // 求解
  417. CNLeq nleq;
  418.     double x=0.5; 
  419. double b=1.0; 
  420. int m=10;
  421. nleq.GetRootMonteCarlo(&x, b, m);
  423. // 显示结果
  424. CString sMsg;
  425. sMsg.Format("求得的一个根为：nnx = %f", x);
  427.     AfxMessageBox(sMsg, MB_OK|MB_ICONINFORMATION);
  428. }
  430. // 求实函数或复函数方程一个复根的蒙特卡洛法
  431. void CNLequationCalculatorDlg::OnButton9() 
  432. {
  433. // 建立CNLequation的子类，在其中重载函数Func
  434. class CNLeq : public CNLequation
  435. {
  436. double Func(double x, double y)
  437. {
  438. double u=x*x-y*y-6.0*x+13.0;
  439. double v=2.0*x*y-6.0*y;
  440. double z=sqrt(u*u+v*v);
  441. return z;
  442. }
  443. };
  445. // 求解
  446. CNLeq nleq;
  447.     double x=0.5; 
  448. double y=0.5; 
  449. double b=1.0; 
  450. int m=10;
  451. nleq.GetRootMonteCarlo(&x, &y, b, m);
  453. // 构造复数
  454. CComplex root(x, y);
  456. // 显示结果
  457. CString sMsg;
  458. sMsg.Format("求得的一个根为：nnx = %s", root.ToString());
  460.     AfxMessageBox(sMsg, MB_OK|MB_ICONINFORMATION);
  461. }
  463. // 求非线性方程组一组实根的梯度法
  464. void CNLequationCalculatorDlg::OnButton10() 
  465. {
  466. // 建立CNLequation的子类，在其中重载函数Func
  467. class CNLeq : public CNLequation
  468. {
  469. double Func(double x[], double y[])
  470. {
  471. double z,f1,f2,f3,df1,df2,df3;
  473. f1=x[0]-5.0*x[1]*x[1]+7.0*x[2]*x[2]+12.0;
  474. f2=3.0*x[0]*x[1]+x[0]*x[2]-11.0*x[0];
  475. f3=2.0*x[1]*x[2]+40.0*x[0];
  476. z=f1*f1+f2*f2+f3*f3;
  478. df1=1.0; 
  479. df2=3.0*x[1]+x[2]-11.0; 
  480. df3=40.0;
  482. y[0]=2.0*(f1*df1+f2*df2+f3*df3);
  483. df1=10.0*x[1]; 
  484. df2=3.0*x[0]; 
  485. df3=2.0*x[2];
  487. y[1]=2.0*(f1*df1+f2*df2+f3*df3);
  488. df1=14.0*x[2]; 
  489. df2=x[0]; 
  490. df3=2.0*x[1];
  491. y[2]=2.0*(f1*df1+f2*df2+f3*df3);
  493. return(z);
  494. }
  495. };
  497. // 求解
  498. CNLeq nleq;
  499.     double x[3]={1.5,6.5,-5.0};
  500. int n = 3;
  501.     int nMaxIt = 600;
  502. BOOL bRet = nleq.GetRootsetGrad(n, x, nMaxIt);
  504. // 显示结果
  505. CString sMsg;
  506. if (bRet)
  507. {
  508. sMsg.Format("求得的 %d 个根为：nn", n);
  509. for (int i=0; i<n; ++i)
  510. {
  511. CString ss;
  512. ss.Format("x(%d) = %fn", i, x[i]);
  514. sMsg += ss;
  515. }
  516. }
  517. else
  518. sMsg = "求解失败";
  520. AfxMessageBox(sMsg, MB_OK|MB_ICONINFORMATION);
  521. }
  523. // 求非线性方程组一组实根的拟牛顿法
  524. void CNLequationCalculatorDlg::OnButton11() 
  525. {
  526. // 建立CNLequation的子类，在其中重载函数Func
  527. class CNLeq : public CNLequation
  528. {
  529. double Func(double x[], double y[])
  530. {
  531. y[0]=x[0]*x[0]+x[1]*x[1]+x[2]*x[2]-1.0;
  532. y[1]=2.0*x[0]*x[0]+x[1]*x[1]-4.0*x[2];
  533. y[2]=3.0*x[0]*x[0]-4.0*x[1]+x[2]*x[2];
  535. return 0.0;
  536. }
  537. };
  539. // 求解
  540. CNLeq nleq;
  541.     double x[3]={1.0,1.0,1.0};
  542.     double t=0.1; 
  543. double h=0.1;
  544. int n = 3;
  545.     int nMaxIt = 100;
  546. BOOL bRet = nleq.GetRootsetNewton(n, x, t, h, nMaxIt);
  548. // 显示结果
  549. CString sMsg;
  550. if (bRet)
  551. {
  552. sMsg.Format("求得的 %d 个根为：nn", n);
  553. for (int i=0; i<n; ++i)
  554. {
  555. CString ss;
  556. ss.Format("x(%d) = %fn", i, x[i]);
  558. sMsg += ss;
  559. }
  560. }
  561. else
  562. sMsg = "求解失败";
  564. AfxMessageBox(sMsg, MB_OK|MB_ICONINFORMATION);
  565. }
  567. // 求非线性方程组最小二乘解的广义逆法
  568. void CNLequationCalculatorDlg::OnButton12() 
  569. {
  570. // 建立CNLequation的子类，在其中重载函数Func
  571. class CNLeq : public CNLequation
  572. {
  573. double Func(double x[], double y[])
  574. {
  575. y[0]=x[0]*x[0]+7.0*x[0]*x[1]+3.0*x[1]*x[1]+0.5;
  576. y[1]=x[0]*x[0]-2.0*x[0]*x[1]+x[1]*x[1]-1.0;
  577. y[2]=x[0]+x[1]+1.0;
  579. return 0.0;
  580. }
  581. void FuncMJ(int n, double x[], double p[])
  582. {
  583. p[0*n+0]=2.0*x[0]+7.0*x[1];
  584. p[0*n+1]=7.0*x[0]+6.0*x[1];
  585. p[1*n+0]=2.0*x[0]-2.0*x[1];
  586. p[1*n+1]=-2.0*x[0]+2.0*x[1];
  587. p[2*n+0]=1.0;
  588. p[2*n+1]=1.0;
  589. }
  590. };
  592. // 求解
  593. CNLeq nleq;
  594.     double eps1 = 0.000001;
  595. double eps2 = 0.000001;
  596.     double x[2]={1.0,-1.0};
  597.     int m=3; 
  598. int n=2;
  599. BOOL bRet = nleq.GetRootsetGinv(m, n, x, eps1, eps2);
  601. // 显示结果
  602. CString sMsg;
  603. if (bRet)
  604. {
  605. sMsg.Format("求得的 %d 个根为：nn", n);
  606. for (int i=0; i<n; ++i)
  607. {
  608. CString ss;
  609. ss.Format("x(%d) = %fn", i, x[i]);
  611. sMsg += ss;
  612. }
  613. }
  614. else
  615. sMsg = "求解失败";
  617. AfxMessageBox(sMsg, MB_OK|MB_ICONINFORMATION);
  618. }
  620. // 求非线性方程组一组实根的蒙特卡洛法
  621. void CNLequationCalculatorDlg::OnButton13() 
  622. {
  623. // 建立CNLequation的子类，在其中重载函数Func
  624. class CNLeq : public CNLequation
  625. {
  626. double Func(int n, double x[])
  627. { 
  628. double f,f1,f2,f3;
  629. n=n;
  630. f1=3.0*x[0]+x[1]+2.0*x[2]*x[2]-3.0;
  631. f2=-3.0*x[0]+5.0*x[1]*x[1]+2.0*x[0]*x[2]-1.0;
  632. f3=25.0*x[0]*x[1]+20.0*x[2]+12.0;
  633. f=sqrt(f1*f1+f2*f2+f3*f3);
  634. return(f);
  635. }
  636. };
  638. // 求解
  639. CNLeq nleq;
  640.     double x[3]={0.0,0.0,0.0};
  641.     double b=2.0; 
  642. int m=10; 
  643. int n=3; 
  644. double eps=0.000001;
  645. nleq.GetRootsetMonteCarlo(n, x, b, m, eps);
  647. // 显示结果
  648. CString sMsg;
  649. sMsg.Format("求得的 %d 个根为：nn", n);
  650. for (int i=0; i<n; ++i)
  651. {
  652. CString ss;
  653. ss.Format("x(%d) = %fn", i, x[i]);
  655. sMsg += ss;
  656. }
  658. AfxMessageBox(sMsg, MB_OK|MB_ICONINFORMATION);
  659. }