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

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

数学计算

开发平台：

Visual C++

Complex.cpp：源码内容
  1. //////////////////////////////////////////////////////////////////////
  2. // Complex.h
  3. //
  4. // 操作复数的类 CComplex 的实现代码
  5. //
  6. // 周长发编制, 2002/8
  7. //////////////////////////////////////////////////////////////////////
  9. #include "stdafx.h"
  10. #include "Complex.h"
  12. #ifdef _DEBUG
  13. #undef THIS_FILE
  14. static char THIS_FILE[]=__FILE__;
  15. #define new DEBUG_NEW
  16. #endif
  18. //////////////////////////////////////////////////////////////////////
  19. // Construction/Destruction
  20. //////////////////////////////////////////////////////////////////////
  22. //////////////////////////////////////////////////////////////////////
  23. // 基本构造函数
  24. //////////////////////////////////////////////////////////////////////
  25. CComplex::CComplex() 
  26. {
  27. m_dblX = 0.0;
  28. m_dblY = 0.0;
  29. }
  31. //////////////////////////////////////////////////////////////////////
  32. // 指定值构造函数
  33. //
  34. // 参数：
  35. // 1. double dblX - 指定的实部
  36. // 2. double dblY - 指定的虚部
  37. //////////////////////////////////////////////////////////////////////
  38. CComplex::CComplex(double dblX, double dblY)
  39. {
  40. m_dblX = dblX;
  41. m_dblY = dblY;
  42. }
  44. //////////////////////////////////////////////////////////////////////
  45. // 拷贝构造函数
  46. //
  47. // 参数：
  48. // 1. const CComplex& other - 源复数
  49. //////////////////////////////////////////////////////////////////////
  50. CComplex::CComplex(const CComplex& other)
  51. {
  52. m_dblX = other.m_dblX;
  53. m_dblY = other.m_dblY;
  54. }
  56. //////////////////////////////////////////////////////////////////////
  57. // 指定复数的实部
  58. //
  59. // 参数：
  60. // 1. double dblX - 复数的实部
  61. //////////////////////////////////////////////////////////////////////
  62. void CComplex::SetReal(double dblX)
  63. {
  64. m_dblX = dblX;
  65. }
  67. //////////////////////////////////////////////////////////////////////
  68. // 指定复数的虚部
  69. //
  70. // 参数：
  71. // 1. double dblX - 复数的虚部
  72. //////////////////////////////////////////////////////////////////////
  73. void CComplex::SetImag(double dblY)
  74. {
  75. m_dblY = dblY;
  76. }
  78. //////////////////////////////////////////////////////////////////////
  79. // 取复数的实部
  80. //
  81. // 参数：  无
  82. //
  83. // 返回值：double 型，复数的实部
  84. //////////////////////////////////////////////////////////////////////
  85. double CComplex::GetReal()
  86. {
  87. return m_dblX;
  88. }
  90. //////////////////////////////////////////////////////////////////////
  91. // 取复数的虚部
  92. //
  93. // 参数：  无
  94. //
  95. // 返回值：double 型，复数的虚部
  96. //////////////////////////////////////////////////////////////////////
  97. double CComplex::GetImag()
  98. {
  99. return m_dblY;
  100. }
  102. //////////////////////////////////////////////////////////////////////
  103. // 将复数转化为"a+bj"形式的字符串
  104. //
  105. // 参数：  无
  106. //
  107. // 返回值：CString 对象，"a+bj"形式的字符串
  108. //////////////////////////////////////////////////////////////////////
  109. CString CComplex::ToString() const
  110. {
  111. CString s;
  112. if (m_dblX != 0.0)
  113. {
  114. if (m_dblY > 0)
  115. s.Format("%f + %fj", m_dblX, m_dblY);
  116. else if (m_dblY < 0)
  117. s.Format("%f - %fj", m_dblX, fabs(m_dblY));
  118. else
  119. s.Format("%f", m_dblX);
  120. }
  121. else
  122. {
  123. if (m_dblY > 0)
  124. s.Format("%fj", m_dblY);
  125. else if (m_dblY < 0)
  126. s.Format("-%fj", fabs(m_dblY));
  127. else
  128. s.Format("%f", m_dblX);
  129. }
  131. return s;
  132. }
  134. //////////////////////////////////////////////////////////////////////
  135. // 将"a,b"形式的字符串转化为复数，以a为复数的实部，b为复数的虚部
  136. //
  137. // 参数：
  138. // 1. CString s - "a,b"形式的字符串，a为复数的实部，b为复数的虚部
  139. // 2. const CString& sDelim - a, b之间的分隔符，默认为空格
  140. //
  141. // 返回值：无
  142. //////////////////////////////////////////////////////////////////////
  143. void CComplex::FromString(CString s, const CString& sDelim /*= " "*/)
  144. {
  145. int nPos = s.Find(sDelim);
  146. if (nPos == -1)
  147. {
  148. s.TrimLeft();
  149. s.TrimRight();
  150. m_dblX = atof(s);
  151. m_dblY = 0;
  152. }
  153. else
  154. {
  155. int nLen = s.GetLength();
  156. CString sLeft = s.Left(nPos);
  157. CString sRight = s.Right(nLen - nPos - 1);
  158. sLeft.TrimLeft();
  159. sRight.TrimRight();
  160. m_dblX = atof(sLeft);
  161. m_dblY = atof(sRight);
  162. }
  163. }
  165. //////////////////////////////////////////////////////////////////////
  166. // 重载运算符==，比较两个复数是否相等
  167. //
  168. // 参数：
  169. // 1. const CComplex& cpxX - 用于比较的复数
  170. //
  171. // 返回值：BOOL型，相等则为TRUE，否则为FALSE
  172. //////////////////////////////////////////////////////////////////////
  173. BOOL CComplex::operator==(const CComplex& cpxX) const
  174. {
  175. return (m_dblX == cpxX.m_dblX && m_dblY == cpxX.m_dblY); 
  176. }
  178. //////////////////////////////////////////////////////////////////////
  179. // 重载运算符!=，比较两个复数是否不等
  180. //
  181. // 参数：
  182. // 1. const CComplex& cpxX - 用于比较的复数
  183. //
  184. // 返回值：BOOL型，不相等则为TRUE，相等为FALSE
  185. //////////////////////////////////////////////////////////////////////
  186. BOOL CComplex::operator!=(const CComplex& cpxX) const
  187. {
  188. return (m_dblX != cpxX.m_dblX || m_dblY != cpxX.m_dblY); 
  189. }
  191. //////////////////////////////////////////////////////////////////////
  192. // 重载运算符=，给复数赋值
  193. //
  194. // 参数：
  195. // 1. const CComplex& cpxX - 用于给复数赋值的源复数
  196. //
  197. // 返回值：CComplex型的引用，所引用的复数与cpxX相等
  198. //////////////////////////////////////////////////////////////////////
  199. CComplex& CComplex::operator=(const CComplex& cpxX)
  200. {
  201. m_dblX = cpxX.m_dblX;
  202. m_dblY = cpxX.m_dblY;
  204. return *this;
  205. }
  207. //////////////////////////////////////////////////////////////////////
  208. // 重载运算符+，实现复数的加法
  209. //
  210. // 参数：
  211. // 1. const CComplex& cpxX - 与指定复数相加的复数
  212. //
  213. // 返回值：CComplex型，指定复数与cpxX相加之和
  214. //////////////////////////////////////////////////////////////////////
  215. CComplex CComplex::operator+(const CComplex& cpxX) const
  216. {
  217. double x = m_dblX + cpxX.m_dblX;
  218. double y = m_dblY + cpxX.m_dblY;
  220. return CComplex(x, y);
  221. }
  223. //////////////////////////////////////////////////////////////////////
  224. // 重载运算符-，实现复数的减法
  225. //
  226. // 参数：
  227. // 1. const CComplex& cpxX - 与指定复数相减的复数
  228. //
  229. // 返回值：CComplex型，指定复数减去cpxX之差
  230. //////////////////////////////////////////////////////////////////////
  231. CComplex CComplex::operator-(const CComplex& cpxX) const
  232. {
  233. double x = m_dblX - cpxX.m_dblX;
  234. double y = m_dblY - cpxX.m_dblY;
  236. return CComplex(x, y);
  237. }
  239. //////////////////////////////////////////////////////////////////////
  240. // 重载运算符*，实现复数的乘法
  241. //
  242. // 参数：
  243. // 1. const CComplex& cpxX - 与指定复数相乘的复数
  244. //
  245. // 返回值：CComplex型，指定复数与cpxX相乘之积
  246. //////////////////////////////////////////////////////////////////////
  247. CComplex CComplex::operator*(const CComplex& cpxX) const
  248. {
  249.     double x = m_dblX * cpxX.m_dblX - m_dblY * cpxX.m_dblY;
  250.     double y = m_dblX * cpxX.m_dblY + m_dblY * cpxX.m_dblX;
  252. return CComplex(x, y);
  253. }
  255. //////////////////////////////////////////////////////////////////////
  256. // 重载运算符/，实现复数的除法
  257. //
  258. // 参数：
  259. // 1. const CComplex& cpxX - 与指定复数相除的复数
  260. //
  261. // 返回值：CComplex型，指定复数除与cpxX之商
  262. //////////////////////////////////////////////////////////////////////
  263. CComplex CComplex::operator/(const CComplex& cpxX) const
  264. {
  265.     double e, f, x, y;
  266.     
  267.     if (fabs(cpxX.m_dblX) >= fabs(cpxX.m_dblY))
  268. {
  269.         e = cpxX.m_dblY / cpxX.m_dblX;
  270.         f = cpxX.m_dblX + e * cpxX.m_dblY;
  271.         
  272.         x = (m_dblX + m_dblY * e) / f;
  273.         y = (m_dblY - m_dblX * e) / f;
  274. }
  275.     else
  276.     {
  277. e = cpxX.m_dblX / cpxX.m_dblY;
  278.         f = cpxX.m_dblY + e * cpxX.m_dblX;
  279.         
  280.         x = (m_dblX * e + m_dblY) / f;
  281.         y = (m_dblY * e - m_dblX) / f;
  282.     }
  284. return CComplex(x, y);
  285. }
  287. //////////////////////////////////////////////////////////////////////
  288. // 计算复数的模
  289. //
  290. // 参数：无
  291. //
  292. // 返回值：double型，指定复数的模
  293. //////////////////////////////////////////////////////////////////////
  294. double CComplex::Abs() const
  295. {
  296.     // 求取实部和虚部的绝对值
  297.     double x = fabs(m_dblX);
  298.     double y = fabs(m_dblY);
  300.     if (m_dblX == 0)
  301. return y;
  302.     if (m_dblY == 0)
  303. return x;
  304.     
  305.     
  306.     // 计算模
  307.     if (x > y)
  308.         return (x * sqrt(1 + (y / x) * (y / x)));
  309.     
  310.     return (y * sqrt(1 + (x / y) * (x / y)));
  311. }
  313. //////////////////////////////////////////////////////////////////////
  314. // 计算复数的根
  315. //
  316. // 参数：
  317. // 1. int n - 待求根的根次
  318. // 2. CComplex cpxR[] - CComplex型数组，长度为n，返回复数的所有根
  319. //
  320. // 返回值：无
  321. //////////////////////////////////////////////////////////////////////
  322. void CComplex::Root(int n, CComplex cpxR[]) const
  323. {
  324. if (n<1) 
  325. return;
  326.     
  327. double q = atan2(m_dblY, m_dblX);
  328.     double r = sqrt(m_dblX*m_dblX + m_dblY*m_dblY);
  329.     if (r != 0)
  330.     { 
  331. r = (1.0/n)*log(r);
  332. r = exp(r);
  333. }
  335.     for (int k=0; k<=n-1; k++)
  336.     { 
  337. double t = (2.0*k*3.1415926+q)/n;
  338.         cpxR[k].m_dblX = r*cos(t); 
  339. cpxR[k].m_dblY = r*sin(t);
  340.     }
  341. }
  343. //////////////////////////////////////////////////////////////////////
  344. // 计算复数的实幂指数
  345. //
  346. // 参数：
  347. // 1. double dblW - 待求实幂指数的幂次
  348. //
  349. // 返回值：CComplex型，复数的实幂指数值
  350. //////////////////////////////////////////////////////////////////////
  351. CComplex CComplex::Pow(double dblW) const
  352. {
  353. // 常量
  354. const double PI = 3.14159265358979;
  356. // 局部变量
  357. double r, t;
  358.     
  359.     // 特殊值处理
  360.     if ((m_dblX == 0) && (m_dblY == 0))
  361. return CComplex(0, 0);
  362.     
  363.     // 幂运算公式中的三角函数运算
  364.     if (m_dblX == 0)
  365. {
  366.         if (m_dblY > 0)
  367.             t = 1.5707963268;
  368.         else
  369.             t = -1.5707963268;
  370. }
  371.     else
  372. {
  373.         if (m_dblX > 0)
  374.             t = atan2(m_dblY, m_dblX);
  375.         else
  376.         {
  377. if (m_dblY >= 0)
  378.                 t = atan2(m_dblY, m_dblX) + PI;
  379.             else
  380.                 t = atan2(m_dblY, m_dblX) - PI;
  381. }
  382.     }
  383.     
  384.     // 模的幂
  385.     r = exp(dblW * log(sqrt(m_dblX * m_dblX + m_dblY * m_dblY)));
  386.     
  387.     // 复数的实幂指数
  388.     return CComplex(r * cos(dblW * t), r * sin(dblW * t));
  389. }
  391. //////////////////////////////////////////////////////////////////////
  392. // 计算复数的复幂指数
  393. //
  394. // 参数：
  395. // 1. CComplex cpxW - 待求复幂指数的幂次
  396. // 2. int n - 控制参数，默认值为0。当n=0时，求得的结果为复幂指数的主值。
  397. //
  398. // 返回值：CComplex型，复数的复幂指数值
  399. //////////////////////////////////////////////////////////////////////
  400. CComplex CComplex::Pow(CComplex cpxW, int n /*= 0*/) const
  401. {
  402. // 常量
  403. const double PI = 3.14159265358979;
  404. // 局部变量
  405.     double r, s, u, v;
  406.     
  407.     // 特殊值处理
  408.     if (m_dblX == 0)
  409. {
  410.         if (m_dblY == 0)
  411. return CComplex(0, 0);
  412.             
  413.         s = 1.5707963268 * (fabs(m_dblY) / m_dblY + 4 * n);
  414. }
  415.     else
  416. {
  417.         s = 2 * PI * n + atan2(m_dblY, m_dblX);
  418.         
  419.         if (m_dblX < 0)
  420. {
  421.             if (m_dblY > 0)
  422.                 s = s + PI;
  423.             else
  424.                 s = s - PI;
  425.         }
  426.     }
  427.     
  428.     // 求幂运算公式
  429.     r = 0.5 * log(m_dblX * m_dblX + m_dblY * m_dblY);
  430.     v = cpxW.m_dblX * r + cpxW.m_dblY * s;
  431.     u = exp(cpxW.m_dblX * r - cpxW.m_dblY * s);
  433.     return CComplex(u * cos(v), u * sin(v));
  434. }
  436. //////////////////////////////////////////////////////////////////////
  437. // 计算复数的自然对数
  438. //
  439. // 参数：无
  440. //
  441. // 返回值：CComplex型，复数的自然对数值
  442. //////////////////////////////////////////////////////////////////////
  443. CComplex CComplex::Log() const
  444. {
  445. double p = log(sqrt(m_dblX*m_dblX + m_dblY*m_dblY));
  446.     return CComplex(p, atan2(m_dblY, m_dblX));
  447. }
  449. //////////////////////////////////////////////////////////////////////
  450. // 计算复数的正弦
  451. //
  452. // 参数：无
  453. //
  454. // 返回值：CComplex型，复数的正弦值
  455. //////////////////////////////////////////////////////////////////////
  456. CComplex CComplex::Sin() const
  457. {
  458.     int i;
  459.     double x, y, y1, br, b1, b2, c[6];
  460.     
  461.     // 切比雪夫公式的常数系数
  462.     c[0] = 1.13031820798497;
  463.     c[1] = 0.04433684984866;
  464.     c[2] = 0.00054292631191;
  465.     c[3] = 0.00000319843646;
  466.     c[4] = 0.00000001103607;
  467.     c[5] = 0.00000000002498;
  468.     
  469.     y1 = exp(m_dblY);
  470.     x = 0.5 * (y1 + 1 / y1);
  471.     if (fabs(m_dblY) >= 1)
  472.         y = 0.5 * (y1 - 1 / y1);
  473.     else
  474.     {
  475. b1 = 0;
  476.         b2 = 0;
  477.         y1 = 2 * (2 * m_dblY * m_dblY - 1);
  478.         for (i = 5; i >=0; --i)
  479. {
  480.             br = y1 * b1 - b2 - c[i];
  481.             if (i != 0)
  482. {
  483.                 b2 = b1;
  484.                 b1 = br;
  485.             }
  486.         }
  487.         
  488.         y = m_dblY * (br - b1);
  489.     }
  490.     
  491.     // 组合计算结果
  492.     x = x * sin(m_dblX);
  493.     y = y * cos(m_dblX);
  495. return CComplex(x, y);
  496. }
  498. //////////////////////////////////////////////////////////////////////
  499. // 计算复数的余弦
  500. //
  501. // 参数：无
  502. //
  503. // 返回值：CComplex型，复数的余弦值
  504. //////////////////////////////////////////////////////////////////////
  505. CComplex CComplex::Cos() const
  506. {
  507.     int i;
  508.     double x, y, y1, br, b1, b2, c[6];
  509.     
  510.     // 切比雪夫公式的常数系数
  511.     c[0] = 1.13031820798497;
  512.     c[1] = 0.04433684984866;
  513.     c[2] = 0.00054292631191;
  514.     c[3] = 0.00000319843646;
  515.     c[4] = 0.00000001103607;
  516.     c[5] = 0.00000000002498;
  517.     
  518.     y1 = exp(m_dblY);
  519.     x = 0.5 * (y1 + 1 / y1);
  520.     if (fabs(m_dblY) >= 1)
  521.         y = 0.5 * (y1 - 1 / y1);
  522.     else
  523.     {
  524. b1 = 0;
  525.         b2 = 0;
  526.         y1 = 2 * (2 * m_dblY * m_dblY - 1);
  527.         for (i=5 ; i>=0; --i)
  528. {
  529.             br = y1 * b1 - b2 - c[i];
  530.             if (i != 0)
  531.             {
  532. b2 = b1;
  533.                 b1 = br;
  534.             }
  535.         }
  536.         
  537.         y = m_dblY * (br - b1);
  538.     }
  539.     
  540.     // 组合计算结果
  541.     x = x * cos(m_dblX);
  542. y = -y * sin(m_dblX);
  544. return CComplex(x, y);
  545. }
  547. //////////////////////////////////////////////////////////////////////
  548. // 计算复数的正切
  549. //
  550. // 参数：无
  551. //
  552. // 返回值：CComplex型，复数的正切值
  553. //////////////////////////////////////////////////////////////////////
  554. CComplex CComplex::Tan() const
  555. {
  556. return Sin()/Cos();
  557. }