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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 行业应用 > 金融证券系统 > 查看源码
TechSwing.cpp
资源名称：clking_src.rar　[点击查看]
上传用户：zhanglf88
上传日期：2013-11-19
资源大小：6036k
文件大小：50k
源码类别：

金融证券系统

开发平台：

Visual C++

TechSwing.cpp：源码内容
  1. /*
  2. Cross Platform Core Code.
  4. Copyright(R) 2001-2002 Balang Software.
  5. All rights reserved.
  7. */
  9. #include "StdAfx.h"
  10. #include "../Include/Stock.h"
  11. #include "../Include/Technique.h"
  13. #ifdef _DEBUG
  14. #undef THIS_FILE
  15. static char THIS_FILE[] = __FILE__;
  16. #endif
  18. #ifdef _DEBUG
  19. #define new DEBUG_NEW
  20. #endif
  22. //////////////////////////////////////////////////////////////////////
  23. // CKDJ
  24. CKDJ::CKDJ( )
  25. {
  26. SetDefaultParameters( );
  27. }
  29. CKDJ::CKDJ( CKData * pKData )
  30. : CTechnique( pKData )
  31. {
  32. SetDefaultParameters( );
  33. }
  35. CKDJ::~CKDJ()
  36. {
  37. Clear( );
  38. }
  40. void CKDJ::SetDefaultParameters( )
  41. {
  42. m_nRSVDays = 9;
  43. m_nKDays = 3;
  44. m_nDDays = 3;
  45. m_nJ = 1;
  46. m_itsGoldenFork = ITS_BUY;
  47. m_itsDeadFork = ITS_SELL;
  48. }
  50. void CKDJ::AttachParameters( CKDJ & src )
  51. {
  52. m_nRSVDays = src.m_nRSVDays;
  53. m_nKDays = src.m_nKDays;
  54. m_nDDays = src.m_nDDays;
  55. m_nJ = src.m_nJ;
  56. m_itsGoldenFork = src.m_itsGoldenFork;
  57. m_itsDeadFork = src.m_itsDeadFork;
  58. }
  60. BOOL CKDJ::IsValidParameters( )
  61. {
  62. return ( VALID_DAYS(m_nRSVDays) && VALID_DAYS(m_nKDays)
  63. && VALID_DAYS(m_nDDays) && VALID_DAYS(m_nJ)
  64. && VALID_ITS(m_itsGoldenFork) && VALID_ITS(m_itsDeadFork) );
  65. }
  67. void CKDJ::Clear( )
  68. {
  69. CTechnique::Clear( );
  70. }
  72. // 计算RSV值
  73. BOOL CKDJ::CalculateRSV( double * pValue, int nIndex )
  74. {
  75. STT_ASSERT_CALCULATE1( m_pKData, nIndex );
  77. double dH = 0, dL = 0, dRSV = 0;
  78. int nCount = 0;
  79. for( int k=nIndex; k>=0; k-- )
  80. {
  81. if( nIndex == k )
  82. {
  83. dH = m_pKData->ElementAt(k).m_fHigh;
  84. dL = m_pKData->ElementAt(k).m_fLow;
  85. }
  86. if( dH < m_pKData->ElementAt(k).m_fHigh )
  87. dH = m_pKData->ElementAt(k).m_fHigh;
  88. if( dL > m_pKData->ElementAt(k).m_fLow )
  89. dL = m_pKData->ElementAt(k).m_fLow;
  91. nCount ++;
  92. if( nCount == m_nRSVDays )
  93. {
  94. if( dH-dL < 1e-4 )
  95. dRSV = 100;
  96. else
  97. dRSV = (m_pKData->ElementAt(nIndex).m_fClose - dL) * 100 / (dH - dL);
  98. if( pValue ) *pValue = dRSV;
  99. return TRUE;
  100. }
  101. }
  102. return FALSE;
  103. }
  105. int CKDJ::GetSignal( int nIndex, UINT * pnCode )
  106. {
  107. if( pnCode ) *pnCode = ITSC_NOTHING;
  108. if( !PrepareCache( 0, -1, FALSE ) )
  109. return ITS_NOTHING;
  111. double dK, dD, dJ;
  112. if( !Calculate( &dK, &dD, &dJ, nIndex, FALSE ) )
  113. return ITS_NOTHING;
  115. if( dK < 25 && dD < 25 && IsGoldenFork(nIndex, m_pdCache1, m_pdCache2) )
  116. { // 低位金叉
  117. if( pnCode ) *pnCode = ITSC_GOLDENFORK;
  118. return m_itsGoldenFork;
  119. }
  120. if( dK > 75 && dD > 75 && IsDeadFork(nIndex, m_pdCache1, m_pdCache2) )
  121. { // 高位死叉
  122. if( pnCode ) *pnCode = ITSC_DEADFORK;
  123. return m_itsDeadFork;
  124. }
  125. return ITS_NOTHING;
  126. }
  128. BOOL CKDJ::GetMinMaxInfo(int nStart, int nEnd, double *pdMin, double *pdMax )
  129. {
  130. return AfxGetMinMaxInfo3( nStart, nEnd, pdMin, pdMax, this );
  131. }
  133. /***
  134. AX = 今天的收盘价 - N天中的最低价
  135. BX = N天中的最高价 - N天中的最低价
  136. RSV = （AX ÷ BX）× 100%
  137. NK = K计算天数，一般取3
  138. ND = D计算天数，一般取3
  139. K = 前一日K×(NK-1)/NK + RSV×1/NK 
  140. D = 前一日D×(ND-1)/ND + K×1/3
  141. J = 3D － 2K （或 J = 3K - 2D）
  142. 第一次计算时，前一日的K、D值皆以50代替。
  143. */
  144. BOOL CKDJ::Calculate( double *pValue1, double *pValue2, double *pValue3, int nIndex, BOOL bUseLast )
  145. {
  146. STT_ASSERT_CALCULATE1( m_pKData, nIndex );
  148. if( m_nRSVDays > nIndex+1 )
  149. return FALSE;
  151. if( LoadFromCache( nIndex, pValue1, pValue2, pValue3 ) )
  152. return TRUE;
  154. double dRSV = 0;
  155. double dK = 50, dD = 50, dJ = 50;
  156. if( bUseLast && pValue1 && pValue2 )
  157. {
  158. if( CalculateRSV( &dRSV, nIndex ) )
  159. {
  160. dK = (m_nKDays-1)*(*pValue1)/m_nKDays + dRSV/m_nKDays;
  161. dD = (m_nDDays-1)*(*pValue2)/m_nDDays + dK/m_nDDays;
  162. if( mode3K2D == m_nJ )
  163. dJ = 3 * dK - 2 * dD;
  164. else
  165. dJ = 3 * dD - 2 * dK;
  166. if( pValue1 ) *pValue1 = dK;
  167. if( pValue2 ) *pValue2 = dD;
  168. if( pValue3 ) *pValue3 = dJ;
  169. StoreToCache( nIndex, pValue1, pValue2, pValue3 );
  170. return TRUE;
  171. }
  172. }
  173. else
  174. {
  175. double factor1 = 1, factor2 = 1;
  176. for( int k=nIndex; k > 0; k-- )
  177. {
  178. factor1 *= ((double)(m_nKDays-1))/m_nKDays;
  179. factor2 *= ((double)(m_nDDays-1))/m_nDDays;
  180. if( factor1 < 0.001 && factor2 < 0.001 )
  181. break;
  182. }
  183. for( ; k<=nIndex; k++ )
  184. {
  185. if( CalculateRSV( &dRSV, k ) )
  186. {
  187. dK = (m_nKDays-1)*(dK)/m_nKDays + dRSV/m_nKDays;
  188. dD = (m_nDDays-1)*(dD)/m_nDDays + dK/m_nDDays;
  189. if( mode3K2D == m_nJ )
  190. dJ = 3 * dK - 2 * dD;
  191. else
  192. dJ = 3 * dD - 2 * dK;
  193. if( nIndex == k )
  194. {
  195. if( pValue1 ) *pValue1 = dK;
  196. if( pValue2 ) *pValue2 = dD;
  197. if( pValue3 ) *pValue3 = dJ;
  198. StoreToCache( nIndex, pValue1, pValue2, pValue3 );
  199. return TRUE;
  200. }
  201. }
  202. }
  203. }
  205. return FALSE;
  206. }
  208. //////////////////////////////////////////////////////////////////////
  209. // CR
  210. CR::CR( )
  211. {
  212. SetDefaultParameters( );
  213. }
  215. CR::CR( CKData * pKData )
  216. : CTechnique( pKData )
  217. {
  218. SetDefaultParameters( );
  219. }
  221. CR::~CR()
  222. {
  223. Clear( );
  224. }
  226. void CR::SetDefaultParameters( )
  227. {
  228. m_nDays = 20;
  229. }
  231. void CR::AttachParameters( CR & src )
  232. {
  233. m_nDays = src.m_nDays;
  234. }
  236. BOOL CR::IsValidParameters( )
  237. {
  238. return ( VALID_DAYS(m_nDays) );
  239. }
  241. void CR::Clear( )
  242. {
  243. CTechnique::Clear( );
  244. }
  246. int CR::GetSignal( int nIndex, UINT * pnCode )
  247. {
  248. if( pnCode ) *pnCode = ITSC_NOTHING;
  249. /* double dR;
  250. if( !Calculate( &dR, nIndex, FALSE ) )
  251. return ITS_NOTHING;
  252. if( dR > 80 )
  253. {
  254. if( pnCode ) *pnCode = ITSC_OVERSOLD;
  255. return m_itsSold;
  256. }
  257. if( dR < 20 )
  258. {
  259. if( pnCode ) *pnCode = ITSC_OVERBOUGHT;
  260. return m_itsBought;
  261. }
  262. */
  263. // 无买卖信号
  264. return ITS_NOTHING;
  265. }
  267. BOOL CR::GetMinMaxInfo(int nStart, int nEnd, double *pdMin, double *pdMax )
  268. {
  269. if( pdMin ) *pdMin = 0;
  270. if( pdMax ) *pdMax = 100;
  271. return TRUE;
  272. }
  274. /***
  275.             H - C
  276. W%R指标值= ———— ×100
  277.             H - L                
  278. H = N日内最高价 L = N日内最低价 C = 当天收盘价
  279. */
  280. BOOL CR::Calculate( double * pValue, int nIndex, BOOL bUseLast )
  281. {
  282. STT_ASSERT_CALCULATE1( m_pKData, nIndex );
  284. if( m_nDays > nIndex+1 )
  285. return FALSE;
  286. if( LoadFromCache( nIndex, pValue ) )
  287. return TRUE;
  289. double dH = 0, dL = 0, dR = 0;
  290. int nCount = 0;
  291. for( int k=nIndex; k>=0; k-- )
  292. {
  293. if( nIndex == k )
  294. {
  295. dH = m_pKData->ElementAt(k).m_fHigh;
  296. dL = m_pKData->ElementAt(k).m_fLow;
  297. }
  298. if( dH < m_pKData->ElementAt(k).m_fHigh )
  299. dH = m_pKData->ElementAt(k).m_fHigh;
  300. if( dL > m_pKData->ElementAt(k).m_fLow )
  301. dL = m_pKData->ElementAt(k).m_fLow;
  303. nCount ++;
  304. if( nCount == m_nDays )
  305. {
  306. if( dH-dL < 1e-4 )
  307. dR = 100;
  308. else
  309. dR = (dH - m_pKData->ElementAt(nIndex).m_fClose) * 100 / (dH - dL);
  310. if( pValue ) *pValue = dR;
  311. StoreToCache( nIndex, pValue );
  312. return TRUE;
  313. }
  314. }
  315. return FALSE;
  316. }
  318. //////////////////////////////////////////////////////////////////////
  319. // CRSI
  320. CRSI::CRSI( )
  321. {
  322. SetDefaultParameters( );
  323. }
  325. CRSI::CRSI( CKData * pKData )
  326. : CTechnique( pKData )
  327. {
  328. SetDefaultParameters( );
  329. }
  331. CRSI::~CRSI()
  332. {
  333. Clear( );
  334. }
  336. void CRSI::SetDefaultParameters( )
  337. {
  338. m_adwDays.RemoveAll();
  339. m_adwDays.Add( 10 );
  340. m_adwDays.Add( 20 );
  341. m_itsSold = ITS_BUY;
  342. m_itsGoldenFork = ITS_BUYINTENSE;
  343. m_itsDeadFork = ITS_SELLINTENSE;
  344. }
  346. void CRSI::AttachParameters( CRSI & src )
  347. {
  348. m_adwDays.Copy( src.m_adwDays );
  349. m_itsSold = src.m_itsSold;
  350. m_itsGoldenFork = src.m_itsGoldenFork;
  351. m_itsDeadFork = src.m_itsDeadFork;
  352. }
  354. BOOL CRSI::IsValidParameters( )
  355. {
  356. STT_VALID_DAYSARRAY( m_adwDays );
  357. return ( VALID_ITS(m_itsSold) && VALID_ITS(m_itsGoldenFork) && VALID_ITS(m_itsDeadFork) );
  358. }
  360. void CRSI::Clear( )
  361. {
  362. CTechnique::Clear( );
  363. }
  365. int CRSI::GetSignal( int nIndex, UINT * pnCode )
  366. {
  367. if( pnCode ) *pnCode = ITSC_NOTHING;
  369. if( nIndex <= 0 )
  370. return ITS_NOTHING;
  372. int nForkSignal = GetForkSignal(nIndex, m_adwDays, m_itsGoldenFork, m_itsDeadFork, pnCode );
  373. for( int k=0; k<m_adwDays.GetSize(); k++ )
  374. {
  375. double dRSI, dRSILast;
  376. if( !Calculate( &dRSILast, nIndex-1, m_adwDays[k], FALSE )
  377. || !Calculate( &dRSI, nIndex, m_adwDays[k], FALSE ) )
  378. return ITS_NOTHING;
  379. if( dRSI < 20 )
  380. { // 超卖
  381. if( pnCode ) *pnCode = ITSC_OVERSOLD;
  382. return m_itsSold;
  383. }
  384. if( dRSI < 40 && nForkSignal == m_itsGoldenFork )
  385. { // 低位金叉
  386. if( pnCode ) *pnCode = ITSC_GOLDENFORK;
  387. return m_itsGoldenFork;
  388. }
  389. if( dRSI > 60 && nForkSignal == m_itsDeadFork )
  390. { // 高位死叉
  391. if( pnCode ) *pnCode = ITSC_DEADFORK;
  392. return m_itsDeadFork;
  393. }
  394. }
  396. return ITS_NOTHING;
  397. }
  399. BOOL CRSI::GetMinMaxInfo(int nStart, int nEnd, double *pdMin, double *pdMax )
  400. {
  401. if( pdMin ) *pdMin = 0;
  402. if( pdMax ) *pdMax = 100;
  403. return TRUE;
  404. }
  406. /***
  407. RSI =（N日内上涨幅度累计÷N日内上涨及下跌幅度累计）×100%
  408. */
  409. BOOL CRSI::Calculate( double * pValue, int nIndex, int nDays, BOOL bUseLast )
  410. {
  411. STT_ASSERT_CALCULATE( m_pKData, nIndex, nDays );
  413. if( nDays > nIndex )
  414. return FALSE;
  416. double dUC = 0, dDC = 0, dRSI = 0;
  417. int nCount = 0;
  418. for( int k=nIndex; k>=1; k-- )
  419. {
  420. if( m_pKData->MaindataAt(k) > m_pKData->MaindataAt(k-1) )
  421. dUC += ( m_pKData->MaindataAt(k) - m_pKData->MaindataAt(k-1) );
  422. else
  423. dDC += ( m_pKData->MaindataAt(k-1) - m_pKData->MaindataAt(k) );
  425. nCount ++;
  426. if( nCount == nDays )
  427. {
  428. if( dUC+dDC < 1e-4 )
  429. dRSI = 100;
  430. else
  431. dRSI = 100*dUC/(dUC+dDC);
  432. if( pValue ) *pValue = dRSI;
  433. return TRUE;
  434. }
  435. }
  436. return FALSE;
  437. }
  439. //////////////////////////////////////////////////////////////////////
  440. // CBIAS
  441. CBIAS::CBIAS( )
  442. {
  443. SetDefaultParameters( );
  444. }
  446. CBIAS::CBIAS( CKData * pKData )
  447. : CTechnique( pKData )
  448. {
  449. SetDefaultParameters( );
  450. }
  452. CBIAS::~CBIAS()
  453. {
  454. Clear( );
  455. }
  457. void CBIAS::SetDefaultParameters( )
  458. {
  459. m_nDays = 10;
  460. m_itsSold = ITS_BUY;
  461. m_itsBought = ITS_SELL;
  462. }
  464. void CBIAS::AttachParameters( CBIAS & src )
  465. {
  466. m_nDays = src.m_nDays;
  467. m_itsSold = src.m_itsSold;
  468. m_itsBought = src.m_itsBought;
  469. }
  471. BOOL CBIAS::IsValidParameters( )
  472. {
  473. return ( VALID_DAYS(m_nDays) && VALID_ITS(m_itsSold) && VALID_ITS(m_itsBought) );
  474. }
  476. void CBIAS::Clear( )
  477. {
  478. CTechnique::Clear( );
  479. }
  481. int CBIAS::GetSignal( int nIndex, UINT * pnCode )
  482. {
  483. if( pnCode ) *pnCode = ITSC_NOTHING;
  485. double dBIAS;
  486. if( !Calculate( &dBIAS, nIndex, FALSE ) )
  487. return ITS_NOTHING;
  489. if( dBIAS < -10 )
  490. { // 超卖
  491. if( pnCode ) *pnCode = ITSC_OVERSOLD;
  492. return m_itsSold;
  493. }
  494. if( dBIAS > 5 )
  495. { // 超买
  496. if( pnCode ) *pnCode = ITSC_OVERBOUGHT;
  497. return m_itsBought;
  498. }
  500. return ITS_NOTHING;
  501. }
  503. BOOL CBIAS::GetMinMaxInfo(int nStart, int nEnd, double *pdMin, double *pdMax )
  504. {
  505. return AfxGetMinMaxInfo1( nStart, nEnd, pdMin, pdMax, this );
  506. }
  508. /***
  509.               当日收盘价-N日移动平均值
  510. N日乖离率 = —————————————— ×100%
  511.                    N日移动平均值
  512. */
  513. BOOL CBIAS::Calculate( double * pValue, int nIndex, BOOL bUseLast )
  514. {
  515. STT_ASSERT_CALCULATE1( m_pKData, nIndex );
  517. if( m_nDays > nIndex+1 )
  518. return FALSE;
  519. if( LoadFromCache( nIndex, pValue ) )
  520. return TRUE;
  522. double dMA = 0;
  523. int nCount = 0;
  524. for( int k=nIndex; k>=0; k -- )
  525. {
  526. dMA += m_pKData->MaindataAt(k);
  528. nCount ++;
  529. if( nCount == m_nDays )
  530. {
  531. double dResult = 0;
  532. dMA = dMA / m_nDays;
  533. if( dMA > 1e-4 )
  534. dResult = 100. * ( m_pKData->MaindataAt(nIndex) - dMA ) / dMA;
  535. if( pValue ) *pValue = dResult;
  536. StoreToCache( nIndex, pValue );
  537. return TRUE;
  538. }
  539. }
  540. return FALSE;
  541. }
  543. //////////////////////////////////////////////////////////////////////
  544. // CMTM
  545. CMTM::CMTM( )
  546. {
  547. SetDefaultParameters( );
  548. }
  550. CMTM::CMTM( CKData * pKData )
  551. : CTechnique( pKData )
  552. {
  553. SetDefaultParameters( );
  554. }
  556. CMTM::~CMTM()
  557. {
  558. Clear( );
  559. }
  561. void CMTM::SetDefaultParameters( )
  562. {
  563. m_nDays = 10;
  564. m_nMADays = 10;
  566. m_itsGoldenFork = ITS_BUY;
  567. m_itsDeadFork = ITS_SELL;
  568. }
  570. void CMTM::AttachParameters( CMTM & src )
  571. {
  572. m_nDays = m_nDays;
  573. m_nMADays = m_nMADays;
  575. m_itsGoldenFork = src.m_itsGoldenFork;
  576. m_itsDeadFork = src.m_itsDeadFork;
  577. }
  579. BOOL CMTM::IsValidParameters( )
  580. {
  581. return ( VALID_DAYS( m_nDays ) && VALID_DAYS( m_nMADays )
  582. && VALID_ITS(m_itsGoldenFork) && VALID_ITS(m_itsDeadFork) );
  583. }
  585. void CMTM::Clear( )
  586. {
  587. CTechnique::Clear( );
  588. }
  590. int CMTM::GetSignal( int nIndex, UINT * pnCode )
  591. {
  592. if( pnCode ) *pnCode = ITSC_NOTHING;
  594. int nMaxDays = m_nDays + m_nMADays;
  595. double dLiminalLow = 0, dLiminalHigh = 0;
  596. if( !IntensityPrepare( nIndex, pnCode, nMaxDays, ITS_GETMINMAXDAYRANGE, &dLiminalLow, &dLiminalHigh, 0.3, 0.6 ) )
  597. return ITS_NOTHING;
  599. double dMTM, dMA;
  600. if( !Calculate( &dMTM, &dMA, nIndex, FALSE ) )
  601. return ITS_NOTHING;
  603. if( dMTM < dLiminalLow && dMA < dLiminalLow && IsGoldenFork( nIndex, m_pdCache1, m_pdCache2 ) )
  604. { // 低位金叉
  605. if( pnCode ) *pnCode = ITSC_GOLDENFORK;
  606. return m_itsGoldenFork;
  607. }
  608. if( dMTM > dLiminalHigh && dMA > dLiminalHigh && IsDeadFork( nIndex, m_pdCache1, m_pdCache2 ) )
  609. { // 高位死叉
  610. if( pnCode ) *pnCode = ITSC_DEADFORK;
  611. return m_itsDeadFork;
  612. }
  614. return ITS_NOTHING;
  615. }
  617. BOOL CMTM::GetMinMaxInfo(int nStart, int nEnd, double *pdMin, double *pdMax )
  618. {
  619. return AfxGetMinMaxInfo2( nStart, nEnd, pdMin, pdMax, this );
  620. }
  622. /***
  623. MTM ＝ C/Cn
  624. 其中：C为当日收市价，Cn为Ｎ日前收市价，
  625. N为设定参数，一般选设10日，亦可在6日至14日之间选择。
  626. */
  627. BOOL CMTM::Calculate( double * pValue, int nIndex, BOOL bUseLast )
  628. {
  629. STT_ASSERT_CALCULATE1( m_pKData, nIndex );
  631. if( m_nDays > nIndex )
  632. return FALSE;
  634. if( LoadFromCache( nIndex, pValue ) )
  635. return TRUE;
  637. if( m_pKData->MaindataAt(nIndex-m_nDays) > 0 )
  638. {
  639. if( pValue )
  640. *pValue = 100. * m_pKData->MaindataAt(nIndex) / m_pKData->MaindataAt(nIndex-m_nDays);
  641. StoreToCache( nIndex, pValue );
  642. return TRUE;
  643. }
  644. return FALSE;
  645. }
  647. BOOL CMTM::Calculate( double * pValue, double *pMA, int nIndex, BOOL bUseLast )
  648. {
  649. return CalculateMA( pValue, pMA, nIndex, bUseLast, m_nMADays );
  650. }
  652. //////////////////////////////////////////////////////////////////////
  653. // CDMI
  654. CDMI::CDMI( )
  655. {
  656. SetDefaultParameters( );
  657. m_pdDMICache = NULL;
  658. m_pnDMICacheIndex = NULL;
  659. m_nDMICacheCurrent = -1;
  660. }
  662. CDMI::CDMI( CKData * pKData )
  663. : CTechnique( pKData )
  664. {
  665. SetDefaultParameters( );
  666. m_pdDMICache = NULL;
  667. m_pnDMICacheIndex = NULL;
  668. m_nDMICacheCurrent = -1;
  669. }
  671. CDMI::~CDMI()
  672. {
  673. Clear( );
  674. }
  676. void CDMI::SetDefaultParameters( )
  677. {
  678. m_nDays = 7;
  679. }
  681. void CDMI::AttachParameters( CDMI & src )
  682. {
  683. m_nDays = src.m_nDays;
  684. }
  686. BOOL CDMI::IsValidParameters( )
  687. {
  688. return ( VALID_DAYS(m_nDays) );
  689. }
  691. void CDMI::Clear( )
  692. {
  693. CTechnique::Clear( );
  695. if( m_pdDMICache )
  696. {
  697. delete [] m_pdDMICache;
  698. m_pdDMICache = NULL;
  699. }
  700. if( m_pnDMICacheIndex )
  701. {
  702. delete [] m_pnDMICacheIndex;
  703. m_pnDMICacheIndex = NULL;
  704. }
  705. m_nDMICacheCurrent = -1;
  706. }
  708. /***
  709. 求出真正波幅TR，TR是下列三者中绝对值最大的一个：
  710. 昨收盘-今 最高、昨收盘-今最低、今最高-今最低
  712. +DM = 今最高-昨最高
  713. -DM = 昨最低-今最低
  714. */
  715. BOOL CDMI::CalculateDM( double *pDMPlus, double *pDMMinus, double *pTR, int nIndex )
  716. {
  717. STT_ASSERT_CALCULATE1( m_pKData, nIndex );
  719. if( nIndex < 1 )
  720. return FALSE;
  722. double dDMPlus = 0, dDMMinus = 0, dTR = 0;
  723. KDATA kdNow = m_pKData->ElementAt(nIndex);
  724. KDATA kdLast = m_pKData->ElementAt(nIndex-1);
  726. dDMPlus = max( 0, ((double)kdNow.m_fHigh) - kdLast.m_fHigh );
  727. dDMMinus = max( 0, ((double)kdLast.m_fLow) - kdNow.m_fLow );
  729. dTR = max( fabs(((double)kdNow.m_fClose)-kdNow.m_fLow), fabs(((double)kdNow.m_fHigh)-kdLast.m_fClose) );
  730. dTR = max( dTR, fabs(((double)kdNow.m_fLow)-kdLast.m_fClose) );
  732. if( pDMPlus ) *pDMPlus = dDMPlus;
  733. if( pDMMinus ) *pDMMinus = dDMMinus;
  734. if( pTR ) *pTR = dTR;
  735. return TRUE;
  736. }
  738. /***
  739. TRn = N天TR之和
  740. +DMn = N天+DM之和
  741. -DMn = N天-DM之和
  742. +DI = （+DMn ÷ TRn）×100
  743. -DI = （-DMn ÷ TRn）×100
  744. DI差 = +DI-（-DI）
  745. DI和 = +DI+（-DI）
  746. DX = （DI差÷DI和）×100
  747. */
  748. BOOL CDMI::CalculateDIDX( double *pDIPlus, double *pDIMinus, double *pDX, int nIndex, int nDays )
  749. {
  750. STT_ASSERT_CALCULATE( m_pKData, nIndex, nDays );
  752. if( m_nDays > nIndex )
  753. return FALSE;
  755. double dDX, dADX = 0;
  756. double dDIPlus = 0, dDIMinus = 0, dTRSum = 0;
  757. int nCount = 0;
  758. for( int k=nIndex; k>=1; k-- )
  759. {
  760. double dDMPlus = 0, dDMMinus = 0, dTR = 0;
  761. if( !CalculateDM( &dDMPlus, &dDMMinus, &dTR, k ) )
  762. return FALSE;
  764. dDIPlus += dDMPlus;
  765. dDIMinus += dDMMinus;
  766. dTRSum += dTR;
  768. nCount ++;
  769. if( nCount == nDays )
  770. {
  771. if( fabs(dTRSum) < 1e-4 || fabs(dDIPlus+dDIMinus) < 1e-4 )
  772. return FALSE;
  773. dDIPlus = (dDIPlus * 100/dTRSum);
  774. dDIMinus = (dDIMinus * 100/dTRSum);
  775. dDX = fabs(dDIPlus-dDIMinus) * 100 / (dDIPlus+dDIMinus);
  776. if( pDIPlus ) *pDIPlus = dDIPlus;
  777. if( pDIMinus ) *pDIMinus = dDIMinus;
  778. if( pDX ) *pDX = dDX;
  779. return TRUE;
  780. }
  781. }
  782. return FALSE;
  783. }
  785. int CDMI::GetSignal( int nIndex, UINT * pnCode )
  786. {
  787. if( pnCode ) *pnCode = ITSC_NOTHING;
  788. /* PrepareCache( 0, -1, FALSE );
  790. if( nIndex <= 0 )
  791. return ITS_NOTHING;
  793. double dDIPlus, dDIMinus, dADX, dADXR;
  794. double dDIPlusLast, dDIMinusLast, dADXLast, dADXRLast;
  795. if( !Calculate( &dDIPlusLast, &dDIMinusLast, &dADXLast, &dADXRLast, nIndex-1, FALSE )
  796. || !Calculate( &dDIPlus, &dDIMinus, &dADX, &dADXR, nIndex, FALSE ) )
  797. return ITS_NOTHING;
  799. if( dDIPlusLast < dDIMinusLast && dDIPlus > dDIMinus )
  800. {
  801. if( pnCode ) *pnCode = ITSC_GOLDENFORK;
  802. return m_itsGoldenFork;
  803. }
  804. if( dDIMinusLast < dDIPlusLast && dDIMinus > dDIPlus )
  805. {
  806. if( pnCode ) *pnCode = ITSC_DEADFORK;
  807. return m_itsDeadFork;
  808. }
  809. */
  810. // 无买卖信号
  811. return ITS_NOTHING;
  812. }
  814. BOOL CDMI::GetMinMaxInfo(int nStart, int nEnd, double *pdMin, double *pdMax )
  815. {
  816. return AfxGetMinMaxInfo4( nStart, nEnd, pdMin, pdMax, this );
  817. }
  819. /***
  820. 求出真正波幅TR，TR是下列三者中绝对值最大的一个：
  821. 昨收盘-今 最高、昨收盘-今最低、今最高-今最低
  823. +DM = 今最高-昨最高
  824. -DM = 昨最低-今最低
  826. TRn = N天TR之和
  827. +DMn = N天+DM之和
  828. -DMn = N天-DM之和
  829. +DI = （+DMn ÷ TRn）×100
  830. -DI = （-DMn ÷ TRn）×100
  831. DI差 = +DI-（-DI）
  832. DI和 = +DI+（-DI）
  833. DX = （DI差÷DI和）×100
  835. ADX = DX的平滑均值
  836. ADXR = ADX的均值
  837. */
  838. BOOL CDMI::Calculate( double * pDIPlus, double * pDIMinus, double *pADX, double *pADXR, int nIndex, BOOL bUseLast )
  839. {
  840. STT_ASSERT_CALCULATE1( m_pKData, nIndex );
  842. if( m_nDays > nIndex )
  843. return FALSE;
  845. if( LoadFromCache( nIndex, pDIPlus, pDIMinus, pADX, pADXR ) )
  846. return TRUE;
  848. double dDX = 0, dADX = 0, dADXR = 0;
  849. if( !CalculateDIDX( pDIPlus, pDIMinus, &dDX, nIndex, m_nDays ) )
  850. return FALSE;
  852. if( NULL == m_pdDMICache )
  853. {
  854. m_pdDMICache = new double[m_nDays];
  855. m_pnDMICacheIndex = new int[m_nDays];
  856. if( NULL == m_pdDMICache || NULL == m_pnDMICacheIndex )
  857. return FALSE;
  858. for( int i=0; i<m_nDays; i++ )
  859. m_pnDMICacheIndex[i] = -1;
  860. m_nDMICacheCurrent = -1;
  861. }
  863. if( bUseLast && pADX )
  864. {
  865. // Calculate ADX and ADXR
  866. dADX = ( (m_nDays-1)*(*pADX) + dDX ) / m_nDays;
  867. for( int i=0; i<m_nDays; i++ )
  868. {
  869. if( m_pnDMICacheIndex[i] == nIndex-m_nDays )
  870. {
  871. dADXR = (m_pdDMICache[i] + dADX) / 2;
  872. break;
  873. }
  874. }
  876. // Save ADX to cache
  877. m_nDMICacheCurrent ++;
  878. if( m_nDMICacheCurrent < 0 || m_nDMICacheCurrent >= m_nDays )
  879. m_nDMICacheCurrent = 0;
  880. m_pdDMICache[m_nDMICacheCurrent] = dADX;
  881. m_pnDMICacheIndex[m_nDMICacheCurrent] = nIndex;
  883. if( pADX ) *pADX = dADX;
  884. if( pADXR ) *pADXR = dADXR;
  885. StoreToCache( nIndex, pDIPlus, pDIMinus, pADX, pADXR );
  886. return TRUE;
  887. }
  888. else
  889. {
  890. double factor = 1;
  891. for( int k=nIndex; k > 0; k-- )
  892. {
  893. factor *= ((double)(m_nDays-1))/m_nDays;
  894. if( factor < 0.001 )
  895. break;
  896. }
  897. double dADXLast = 0;
  898. BOOL bHasADXR = FALSE;
  899. for( ; k<=nIndex; k++ )
  900. {
  901. if( !CalculateDIDX( NULL, NULL, &dDX, k, m_nDays ) )
  902. continue;
  904. // Calculate ADX and ADXR
  905. dADX = ( (m_nDays-1)*dADX + dDX )/m_nDays;
  906. if( k == nIndex-m_nDays )
  907. {
  908. dADXLast = dADX;
  909. bHasADXR = TRUE;
  910. }
  912. // Save ADX to cache
  913. m_nDMICacheCurrent ++;
  914. if( m_nDMICacheCurrent < 0 || m_nDMICacheCurrent >= m_nDays )
  915. m_nDMICacheCurrent = 0;
  916. m_pdDMICache[m_nDMICacheCurrent] = dADX;
  917. m_pnDMICacheIndex[m_nDMICacheCurrent] = k;
  918. }
  919. dADXR = (dADX + dADXLast) / 2;
  920. if( pADX ) *pADX = dADX;
  921. if( pADXR && bHasADXR ) *pADXR = dADXR;
  922. StoreToCache( nIndex, pDIPlus, pDIMinus, pADX, pADXR );
  923. return TRUE;
  924. }
  925. return FALSE;
  926. }
  928. //////////////////////////////////////////////////////////////////////
  929. // CROC
  930. CROC::CROC( )
  931. {
  932. SetDefaultParameters( );
  933. }
  935. CROC::CROC( CKData * pKData )
  936. : CTechnique( pKData )
  937. {
  938. SetDefaultParameters( );
  939. }
  941. CROC::~CROC()
  942. {
  943. Clear( );
  944. }
  946. void CROC::SetDefaultParameters( )
  947. {
  948. m_nDays = 10;
  949. m_nMADays = 10;
  951. m_itsGoldenFork = ITS_BUY;
  952. m_itsDeadFork = ITS_SELL;
  953. }
  955. void CROC::AttachParameters( CROC & src )
  956. {
  957. m_nDays = src.m_nDays;
  958. m_nMADays = src.m_nMADays;
  960. m_itsGoldenFork = src.m_itsGoldenFork;
  961. m_itsDeadFork = src.m_itsDeadFork;
  962. }
  964. BOOL CROC::IsValidParameters( )
  965. {
  966. return ( VALID_DAYS(m_nDays) && VALID_DAYS(m_nMADays)
  967. && VALID_ITS(m_itsGoldenFork) && VALID_ITS(m_itsDeadFork) );
  968. }
  970. void CROC::Clear( )
  971. {
  972. CTechnique::Clear( );
  973. }
  975. int CROC::GetSignal( int nIndex, UINT * pnCode )
  976. {
  977. if( pnCode ) *pnCode = ITSC_NOTHING;
  979. int nMaxDays = m_nDays + m_nMADays;
  980. double dLiminalLow = 0, dLiminalHigh = 0;
  981. if( !IntensityPrepare( nIndex, pnCode, nMaxDays, ITS_GETMINMAXDAYRANGE, &dLiminalLow, &dLiminalHigh, 0.309, 0.6 ) )
  982. return ITS_NOTHING;
  984. double dROC, dMA;
  985. if( !Calculate( &dROC, &dMA, nIndex, FALSE ) )
  986. return ITS_NOTHING;
  988. if( dROC < dLiminalLow && dMA < dLiminalLow && IsGoldenFork( nIndex, m_pdCache1, m_pdCache2 ) )
  989. { // 低位金叉
  990. if( pnCode ) *pnCode = ITSC_GOLDENFORK;
  991. return m_itsGoldenFork;
  992. }
  993. if( dROC > dLiminalHigh && dMA > dLiminalHigh && IsDeadFork( nIndex, m_pdCache1, m_pdCache2 ) )
  994. { // 高位死叉
  995. if( pnCode ) *pnCode = ITSC_DEADFORK;
  996. return m_itsDeadFork;
  997. }
  999. return ITS_NOTHING;
  1000. }
  1002. BOOL CROC::GetMinMaxInfo(int nStart, int nEnd, double *pdMin, double *pdMax )
  1003. {
  1004. return AfxGetMinMaxInfo2( nStart, nEnd, pdMin, pdMax, this );
  1005. }
  1007. /***
  1008. ROC=（今收盘-前N日收盘）÷前N日的收盘×100 
  1009. */
  1010. BOOL CROC::Calculate( double * pValue, int nIndex, BOOL bUseLast )
  1011. {
  1012. STT_ASSERT_CALCULATE1( m_pKData, nIndex );
  1014. if( m_nDays > nIndex )
  1015. return FALSE;
  1017. if( LoadFromCache( nIndex, pValue ) )
  1018. return TRUE;
  1020. if( m_pKData->MaindataAt(nIndex-m_nDays) <= 0
  1021. || m_pKData->MaindataAt(nIndex) <= 0 )
  1022. return FALSE;
  1024. double x = m_pKData->MaindataAt(nIndex);
  1025. double y = m_pKData->MaindataAt(nIndex-m_nDays);
  1026. if( pValue )
  1027. *pValue = (x - y) * 100 / y;
  1028. StoreToCache( nIndex, pValue );
  1029. return TRUE;
  1030. }
  1032. BOOL CROC::Calculate( double * pValue, double * pMA, int nIndex, BOOL bUseLast )
  1033. {
  1034. return CalculateMA( pValue, pMA, nIndex, bUseLast, m_nMADays );
  1035. }
  1037. //////////////////////////////////////////////////////////////////////
  1038. // CCCI
  1039. CCCI::CCCI( )
  1040. {
  1041. SetDefaultParameters( );
  1042. }
  1044. CCCI::CCCI( CKData * pKData )
  1045. : CTechnique( pKData )
  1046. {
  1047. SetDefaultParameters( );
  1048. }
  1050. CCCI::~CCCI()
  1051. {
  1052. Clear( );
  1053. }
  1055. void CCCI::SetDefaultParameters( )
  1056. {
  1057. m_nDays = 14;
  1058. m_dQuotiety = 0.015;
  1059. m_nMADays = 10;
  1061. m_itsGoldenFork = ITS_BUY;
  1062. m_itsDeadFork = ITS_SELL;
  1063. }
  1065. void CCCI::AttachParameters( CCCI & src )
  1066. {
  1067. m_nDays = src.m_nDays;
  1068. m_dQuotiety = src.m_dQuotiety;
  1069. m_nMADays = src.m_nMADays;
  1071. m_itsGoldenFork = src.m_itsGoldenFork;
  1072. m_itsDeadFork = src.m_itsDeadFork;
  1073. }
  1075. BOOL CCCI::IsValidParameters( )
  1076. {
  1077. return ( VALID_DAYS(m_nDays) && m_dQuotiety > 0 && VALID_DAYS(m_nMADays)
  1078. && VALID_ITS(m_itsGoldenFork) && VALID_ITS(m_itsDeadFork) );
  1079. }
  1081. void CCCI::Clear( )
  1082. {
  1083. CTechnique::Clear( );
  1084. }
  1086. int CCCI::GetSignal( int nIndex, UINT * pnCode )
  1087. {
  1088. if( pnCode ) *pnCode = ITSC_NOTHING;
  1090. double dCCI;
  1091. if( !Calculate( &dCCI, nIndex, FALSE ) )
  1092. return ITS_NOTHING;
  1094. int nForkSignal = GetForkSignal( nIndex, m_itsGoldenFork, m_itsDeadFork, pnCode );
  1096. if( dCCI < -100 && nForkSignal == m_itsGoldenFork )
  1097. { // 低位金叉
  1098. if( pnCode ) *pnCode = ITSC_GOLDENFORK;
  1099. return m_itsGoldenFork;
  1100. }
  1101. if( dCCI > 100 && nForkSignal == m_itsDeadFork )
  1102. { // 高位死叉
  1103. if( pnCode ) *pnCode = ITSC_DEADFORK;
  1104. return m_itsDeadFork;
  1105. }
  1107. return ITS_NOTHING;
  1108. }
  1110. BOOL CCCI::GetMinMaxInfo(int nStart, int nEnd, double *pdMin, double *pdMax )
  1111. {
  1112. return AfxGetMinMaxInfo2( nStart, nEnd, pdMin, pdMax, this );
  1113. }
  1115. /***
  1116. TP = 收盘价+收盘价+最高价+最低价
  1117. A是TP的N日均值
  1118. D是TP与A的离差均值
  1119. CCI=(C-D)/(0.015D)
  1120. */
  1121. BOOL CCCI::Calculate( double * pValue, int nIndex, BOOL bUseLast )
  1122. {
  1123. STT_ASSERT_CALCULATE1( m_pKData, nIndex );
  1125. if( m_nDays > nIndex+1 )
  1126. return FALSE;
  1128. if( LoadFromCache( nIndex, pValue ) )
  1129. return TRUE;
  1131. double dTP = 0, dMATP = 0, dD = 0;
  1132. int nCount = 0;
  1133. for( int k=nIndex; k>=0; k-- )
  1134. {
  1135. KDATA kd = m_pKData->ElementAt(k);
  1136. double dTemp = (kd.m_fHigh+kd.m_fClose+kd.m_fClose+kd.m_fLow)/4;
  1137. if( nIndex == k )
  1138. dTP = dTemp;
  1139. dMATP += dTemp;
  1141. nCount ++;
  1142. if( nCount == m_nDays )
  1143. break;
  1144. }
  1145. dMATP = dMATP / m_nDays;
  1147. nCount = 0;
  1148. for( k=nIndex; k>=0; k-- )
  1149. {
  1150. KDATA kd = m_pKData->ElementAt(k);
  1151. double dTemp = (kd.m_fHigh+kd.m_fClose+kd.m_fClose+kd.m_fLow)/4;
  1152. dD += fabs(dTemp-dMATP);
  1154. nCount ++;
  1155. if( nCount == m_nDays )
  1156. break;
  1157. }
  1159. dD = dD / m_nDays;
  1160. if( fabs(dD) < 1e-4 )
  1161. return FALSE;
  1162. if( pValue )
  1163. *pValue = (dTP - dMATP) / (m_dQuotiety * dD);
  1164. StoreToCache( nIndex, pValue );
  1165. return TRUE;
  1166. }
  1168. /***
  1169. CCI 及其 移动平均值
  1170. */
  1171. BOOL CCCI::Calculate( double * pValue, double * pMA, int nIndex, BOOL bUseLast )
  1172. {
  1173. return CalculateMA( pValue, pMA, nIndex, bUseLast, m_nMADays );
  1174. }
  1176. //////////////////////////////////////////////////////////////////////
  1177. // CCV
  1178. CCV::CCV( )
  1179. {
  1180. SetDefaultParameters( );
  1181. }
  1183. CCV::CCV( CKData * pKData )
  1184. : CTechnique( pKData )
  1185. {
  1186. SetDefaultParameters( );
  1187. }
  1189. CCV::~CCV()
  1190. {
  1191. Clear( );
  1192. }
  1194. void CCV::SetDefaultParameters( )
  1195. {
  1196. m_nMAHLDays = 10;
  1197. m_nCVDays = 10;
  1198. m_itsSold = ITS_BUY;
  1199. m_itsBought = ITS_SELL;
  1200. }
  1202. void CCV::AttachParameters( CCV & src )
  1203. {
  1204. m_nMAHLDays = src.m_nMAHLDays;
  1205. m_nCVDays = src.m_nCVDays;
  1206. m_itsSold = src.m_itsSold;
  1207. m_itsBought = src.m_itsBought;
  1208. }
  1210. BOOL CCV::IsValidParameters( )
  1211. {
  1212. return ( VALID_DAYS(m_nMAHLDays) && VALID_DAYS(m_nCVDays)
  1213. && VALID_ITS(m_itsSold) && VALID_ITS(m_itsBought) );
  1214. }
  1216. void CCV::Clear( )
  1217. {
  1218. CTechnique::Clear( );
  1219. }
  1221. int CCV::GetSignal( int nIndex, UINT * pnCode )
  1222. {
  1223. if( pnCode ) *pnCode = ITSC_NOTHING;
  1225. if( nIndex <= 1 )
  1226. return ITS_NOTHING;
  1228. double dNow, dLast, dLastLast;
  1229. if( !Calculate( &dLastLast, nIndex-2, FALSE )
  1230. || !Calculate( &dLast, nIndex-1, FALSE )
  1231. || !Calculate( &dNow, nIndex, FALSE ) )
  1232. return ITS_NOTHING;
  1234. if( dLastLast < 0 && dLast < 0 && dNow < 0 && dLast <= dLastLast && dNow > dLast )
  1235. { // 超卖
  1236. if( pnCode ) *pnCode = ITSC_OVERSOLD;
  1237. return m_itsSold;
  1238. }
  1239. if( dLastLast > 0 && dLast > 0 && dNow > 0 && dLast >= dLastLast && dNow < dLast )
  1240. { // 超买
  1241. if( pnCode ) *pnCode = ITSC_OVERBOUGHT;
  1242. return m_itsBought;
  1243. }
  1245. return ITS_NOTHING;
  1246. }
  1248. BOOL CCV::GetMinMaxInfo(int nStart, int nEnd, double *pdMin, double *pdMax )
  1249. {
  1250. return AfxGetMinMaxInfo1( nStart, nEnd, pdMin, pdMax, this );
  1251. }
  1253. /***
  1254. A = 最高价 - 最低价
  1255. MAHL = A的m_nMAHLDays日平均值
  1256. MAHLLast= m_nCVDays日前的MAHL
  1257. CCI = 100 * (MAHL - MAHLLast) / MAHLLast;
  1258. */
  1259. BOOL CCV::Calculate( double * pValue, int nIndex, BOOL bUseLast )
  1260. {
  1261. STT_ASSERT_CALCULATE1( m_pKData, nIndex );
  1263. if( m_nMAHLDays+m_nCVDays > nIndex+2 )
  1264. return FALSE;
  1266. if( LoadFromCache( nIndex, pValue ) )
  1267. return TRUE;
  1269. double dMAHLNow = 0, dMAHLLast = 0;
  1270. int nCount = 0;
  1271. for( int k=nIndex; k>=0; k-- )
  1272. {
  1273. KDATA kd = m_pKData->ElementAt(k);
  1274. dMAHLNow += (kd.m_fHigh-kd.m_fLow);
  1276. nCount ++;
  1277. if( nCount == m_nMAHLDays )
  1278. break;
  1279. }
  1281. nCount = 0;
  1282. for( k=nIndex-m_nCVDays+1; k>=0; k-- )
  1283. {
  1284. KDATA kd = m_pKData->ElementAt(k);
  1285. dMAHLLast += (((double)kd.m_fHigh)-kd.m_fLow);
  1287. nCount ++;
  1288. if( nCount == m_nMAHLDays )
  1289. break;
  1290. }
  1292. dMAHLNow = dMAHLNow / m_nMAHLDays;
  1293. dMAHLLast = dMAHLLast / m_nMAHLDays;
  1294. if( fabs(dMAHLLast) < 1e-4 )
  1295. return FALSE;
  1296. if( pValue )
  1297. *pValue = (dMAHLNow - dMAHLLast) * 100 / dMAHLLast;
  1298. StoreToCache( nIndex, pValue );
  1299. return TRUE;
  1300. }
  1302. //////////////////////////////////////////////////////////////////////
  1303. // CARBR
  1304. CARBR::CARBR( )
  1305. {
  1306. SetDefaultParameters( );
  1307. }
  1309. CARBR::CARBR( CKData * pKData )
  1310. : CTechnique( pKData )
  1311. {
  1312. SetDefaultParameters( );
  1313. }
  1315. CARBR::~CARBR()
  1316. {
  1317. Clear( );
  1318. }
  1320. void CARBR::SetDefaultParameters( )
  1321. {
  1322. m_nDays = 26;
  1323. m_itsGoldenFork = ITS_BUYINTENSE;
  1324. m_itsDeadFork = ITS_SELLINTENSE;
  1325. m_itsSold = ITS_BUY;
  1326. m_itsBought = ITS_SELL;
  1327. }
  1329. void CARBR::AttachParameters( CARBR & src )
  1330. {
  1331. m_nDays = src.m_nDays;
  1332. m_itsGoldenFork = src.m_itsGoldenFork;
  1333. m_itsDeadFork = src.m_itsDeadFork;
  1334. m_itsSold = src.m_itsSold;
  1335. m_itsBought = src.m_itsBought;
  1336. }
  1338. BOOL CARBR::IsValidParameters( )
  1339. {
  1340. return ( VALID_DAYS(m_nDays)
  1341. && VALID_ITS(m_itsGoldenFork) && VALID_ITS(m_itsDeadFork)
  1342. && VALID_ITS(m_itsSold) && VALID_ITS(m_itsBought) );
  1343. }
  1345. void CARBR::Clear( )
  1346. {
  1347. CTechnique::Clear( );
  1348. }
  1350. int CARBR::GetSignal( int nIndex, UINT * pnCode )
  1351. {
  1352. if( pnCode ) *pnCode = ITSC_NOTHING;
  1354. double dAR, dBR;
  1355. if( !Calculate( &dAR, &dBR, nIndex, FALSE ) )
  1356. return ITS_NOTHING;
  1358. int nForkSignal = GetForkSignal( nIndex, m_itsGoldenFork, m_itsDeadFork, pnCode );
  1360. if( (dAR < 50 || dBR < 50 ) && nForkSignal == m_itsGoldenFork )
  1361. { // 低位金叉
  1362. if( pnCode ) *pnCode = ITSC_GOLDENFORK;
  1363. return m_itsGoldenFork;
  1364. }
  1365. if( (dAR > 180 || dBR > 300) && nForkSignal == m_itsDeadFork )
  1366. { // 高位死叉
  1367. if( pnCode ) *pnCode = ITSC_DEADFORK;
  1368. return m_itsDeadFork;
  1369. }
  1370. if( dAR < 50 )
  1371. { // 超卖
  1372. if( pnCode ) *pnCode = ITSC_OVERSOLD;
  1373. return m_itsSold;
  1374. }
  1375. if( dAR > 200 )
  1376. { // 超买
  1377. if( pnCode ) *pnCode = ITSC_OVERBOUGHT;
  1378. return m_itsBought;
  1379. }
  1381. return ITS_NOTHING;
  1382. }
  1384. BOOL CARBR::GetMinMaxInfo(int nStart, int nEnd, double *pdMin, double *pdMax )
  1385. {
  1386. return AfxGetMinMaxInfo2( nStart, nEnd, pdMin, pdMax, this );
  1387. }
  1389. /***
  1390.       （H-O）n天之和
  1391. AR = ———————— × 100
  1392.       （O-L）n天之和
  1393.       （H-C）n天之和
  1394. BR = ———————— × 100
  1395.       （C-L）n天之和
  1397. H：最高价 L：最低价 O：开盘价 C：收盘价 
  1398. */
  1399. BOOL CARBR::Calculate( double * pAR, double *pBR, int nIndex, BOOL bUseLast )
  1400. {
  1401. STT_ASSERT_CALCULATE1( m_pKData, nIndex );
  1403. if( m_nDays > nIndex )
  1404. return FALSE;
  1406. if( LoadFromCache( nIndex, pAR, pBR ) )
  1407. return TRUE;
  1409. double dUP = 0, dDG = 0, dBS = 0, dSS = 0;
  1410. int nCount = 0;
  1411. for( int k=nIndex; k>=1; k-- )
  1412. {
  1413. KDATA kd = m_pKData->ElementAt(k);
  1414. KDATA kdLast = m_pKData->ElementAt(k-1);
  1415. dUP += (((double)kd.m_fHigh)-kd.m_fOpen);
  1416. dDG += (((double)kd.m_fOpen)-kd.m_fLow);
  1417. dBS += max( 0, ((double)kd.m_fHigh) - kdLast.m_fClose );
  1418. dSS += max( 0, ((double)kdLast.m_fClose) - kd.m_fLow );
  1420. nCount ++;
  1421. if( nCount == m_nDays )
  1422. break;
  1423. }
  1425. if( dDG < 1e-4 || dSS < 1e-4 )
  1426. return FALSE;
  1427. if( pAR )
  1428. *pAR = dUP * 100 / dDG;
  1429. if( pBR )
  1430. *pBR = dBS * 100 / dSS;
  1431. StoreToCache( nIndex, pAR, pBR );
  1432. return TRUE;
  1433. }
  1435. //////////////////////////////////////////////////////////////////////
  1436. // CCR
  1437. CCR::CCR( )
  1438. {
  1439. SetDefaultParameters( );
  1440. }
  1442. CCR::CCR( CKData * pKData )
  1443. : CTechnique( pKData )
  1444. {
  1445. SetDefaultParameters( );
  1446. }
  1448. CCR::~CCR()
  1449. {
  1450. Clear( );
  1451. }
  1453. void CCR::SetDefaultParameters( )
  1454. {
  1455. m_nDays = 26;
  1456. m_nMADaysA = 10;
  1457. m_nMADaysB = 20;
  1458. m_nMADaysC = 40;
  1459. m_nMADaysD = 62;
  1461. m_itsSold = ITS_BUY;
  1462. m_itsBought = ITS_SELL;
  1463. }
  1465. void CCR::AttachParameters( CCR & src )
  1466. {
  1467. m_nDays = src.m_nDays;
  1468. m_nMADaysA = src.m_nMADaysA;
  1469. m_nMADaysB = src.m_nMADaysB;
  1470. m_nMADaysC = src.m_nMADaysC;
  1471. m_nMADaysD = src.m_nMADaysD;
  1473. m_itsSold = src.m_itsSold;
  1474. m_itsBought = src.m_itsBought;
  1475. }
  1477. BOOL CCR::IsValidParameters( )
  1478. {
  1479. return ( VALID_DAYS( m_nDays ) && VALID_DAYS( m_nMADaysA ) && VALID_DAYS( m_nMADaysB )
  1480. && VALID_DAYS( m_nMADaysC ) && VALID_DAYS( m_nMADaysD )
  1481. && VALID_ITS(m_itsSold) && VALID_ITS(m_itsBought) );
  1482. }
  1484. void CCR::Clear( )
  1485. {
  1486. CTechnique::Clear( );
  1487. }
  1489. int CCR::GetSignal( int nIndex, UINT * pnCode )
  1490. {
  1491. if( pnCode ) *pnCode = ITSC_NOTHING;
  1493. double dCR;
  1494. if( !Calculate( &dCR, nIndex, FALSE ) )
  1495. return ITS_NOTHING;
  1497. if( dCR < 40 )
  1498. { // 超卖
  1499. if( pnCode ) *pnCode = ITSC_OVERSOLD;
  1500. return m_itsSold;
  1501. }
  1502. if( dCR > 300 )
  1503. { // 超买
  1504. if( pnCode ) *pnCode = ITSC_OVERBOUGHT;
  1505. return m_itsBought;
  1506. }
  1507. return ITS_NOTHING;
  1508. }
  1510. BOOL CCR::GetMinMaxInfo(int nStart, int nEnd, double *pdMin, double *pdMax )
  1511. {
  1512. return AfxGetMinMaxInfo5( nStart, nEnd, pdMin, pdMax, this );
  1513. }
  1515. /***
  1516. MID = （开盘价 + 收盘价 + 最高价 + 最低价）÷ 2
  1517. 上升值 = 今最高 - 昨日MID （负值记为0）
  1518. 下跌值 = 昨MID - 今最低
  1519.        n天上升值之和
  1520. CR = ———————— × 100
  1521.        n天下跌值之和
  1522. */
  1523. BOOL CCR::Calculate( double * pValue, int nIndex, BOOL bUseLast )
  1524. {
  1525. STT_ASSERT_CALCULATE1( m_pKData, nIndex );
  1527. if( m_nDays > nIndex )
  1528. return FALSE;
  1530. if( LoadFromCache( nIndex, pValue ) )
  1531. return TRUE;
  1533. double dBS = 0, dSS = 0, dCR = 0;
  1534. int nCount = 0;
  1535. for( int k=nIndex; k>=1; k-- )
  1536. {
  1537. KDATA kd = m_pKData->ElementAt(k);
  1538. KDATA kdLast = m_pKData->ElementAt(k-1);
  1539. double dTP = (kdLast.m_fHigh+kdLast.m_fLow+kdLast.m_fOpen+kdLast.m_fClose)/4;
  1540. dBS += max( 0, kd.m_fHigh - dTP );
  1541. dSS += max( 0, dTP - kd.m_fLow );
  1543. nCount ++;
  1544. if( nCount == m_nDays )
  1545. break;
  1546. }
  1548. if( dSS < 1e-4 )
  1549. return FALSE;
  1550. dCR = dBS * 100 / dSS;
  1551. if( pValue )
  1552. *pValue = dCR;
  1553. StoreToCache( nIndex, pValue );
  1554. return TRUE;
  1555. }
  1557. /***
  1558. A, B, C, D 分别是CR的N日平均值
  1559. N分别为m_nMADaysA,m_nMADaysB,m_nMADaysC,m_nMADaysD
  1560. */
  1561. BOOL CCR::Calculate( double * pValue, double * pA, double * pB, double * pC, double * pD, int nIndex, BOOL bUseLast )
  1562. {
  1563. STT_ASSERT_CALCULATE1( m_pKData, nIndex );
  1565. int nMaxMADays = max( max(m_nMADaysA,m_nMADaysB), max(m_nMADaysC,m_nMADaysD) );
  1566. if( m_nDays+nMaxMADays > nIndex+1 )
  1567. return FALSE;
  1569. if( LoadFromCache( nIndex, pValue, pA, pB, pC, pD ) )
  1570. return TRUE;
  1572. double dCR = 0, dA = 0, dB = 0, dC = 0, dD = 0;
  1573. int nCount = 0;
  1574. for( int k=nIndex; k>=m_nDays; k-- )
  1575. {
  1576. double dTemp;
  1577. if( Calculate( &dTemp, k, FALSE ) )
  1578. {
  1579. if( nIndex == k )
  1580. dCR = dTemp;
  1581. nCount ++;
  1582. if( nCount <= m_nMADaysA )
  1583. dA += dTemp;
  1584. if( nCount <= m_nMADaysB )
  1585. dB += dTemp;
  1586. if( nCount <= m_nMADaysC )
  1587. dC += dTemp;
  1588. if( nCount <= m_nMADaysD )
  1589. dD += dTemp;
  1591. if( nCount > nMaxMADays )
  1592. {
  1593. if( pValue ) *pValue = dCR;
  1594. if( pA ) *pA = dA / m_nMADaysA;
  1595. if( pB ) *pB = dB / m_nMADaysB;
  1596. if( pC ) *pC = dC / m_nMADaysC;
  1597. if( pD ) *pD = dD / m_nMADaysD;
  1598. StoreToCache( nIndex, pValue, pA, pB, pC, pD );
  1599. return TRUE;
  1600. }
  1601. }
  1602. }
  1604. return FALSE;
  1605. }
  1607. //////////////////////////////////////////////////////////////////////
  1608. // COSC
  1609. COSC::COSC( )
  1610. {
  1611. SetDefaultParameters( );
  1612. }
  1614. COSC::COSC( CKData * pKData )
  1615. : CTechnique( pKData )
  1616. {
  1617. SetDefaultParameters( );
  1618. }
  1620. COSC::~COSC()
  1621. {
  1622. Clear( );
  1623. }
  1625. void COSC::SetDefaultParameters( )
  1626. {
  1627. m_nDays = 10;
  1628. m_nMADays = 6;
  1629. m_itsGoldenFork = ITS_BUY;
  1630. m_itsDeadFork = ITS_SELL;
  1631. }
  1633. void COSC::AttachParameters( COSC & src )
  1634. {
  1635. m_nDays = src.m_nDays;
  1636. m_nMADays = src.m_nMADays;
  1637. m_itsGoldenFork = src.m_itsGoldenFork;
  1638. m_itsDeadFork = src.m_itsDeadFork;
  1639. }
  1641. BOOL COSC::IsValidParameters( )
  1642. {
  1643. return ( VALID_DAYS(m_nDays) && VALID_DAYS(m_nMADays)
  1644. && VALID_ITS(m_itsGoldenFork) && VALID_ITS(m_itsDeadFork) );
  1645. }
  1647. void COSC::Clear( )
  1648. {
  1649. CTechnique::Clear( );
  1650. }
  1652. int COSC::GetSignal( int nIndex, UINT * pnCode )
  1653. {
  1654. if( pnCode ) *pnCode = ITSC_NOTHING;
  1656. int nMaxDays = m_nDays+m_nMADays;
  1657. double dLiminalLow = 0, dLiminalHigh = 0;
  1658. if( !IntensityPrepare( nIndex, pnCode, nMaxDays, ITS_GETMINMAXDAYRANGE, &dLiminalLow, &dLiminalHigh, 0.3, 0.6 ) )
  1659. return ITS_NOTHING;
  1661. double dOSC;
  1662. if( !Calculate( &dOSC, nIndex, FALSE ) )
  1663. return ITS_NOTHING;
  1665. int nSignal = GetForkSignal( nIndex, m_itsGoldenFork, m_itsDeadFork, pnCode );
  1666. if( dOSC < dLiminalLow && nSignal == m_itsGoldenFork )
  1667. { // 低位金叉
  1668. if( pnCode ) *pnCode = ITSC_GOLDENFORK;
  1669. return m_itsGoldenFork;
  1670. }
  1671. if( dOSC > dLiminalHigh && nSignal == m_itsDeadFork )
  1672. { // 高位死叉
  1673. if( pnCode ) *pnCode = ITSC_DEADFORK;
  1674. return m_itsDeadFork;
  1675. }
  1677. return ITS_NOTHING;
  1678. }
  1680. BOOL COSC::GetMinMaxInfo(int nStart, int nEnd, double *pdMin, double *pdMax )
  1681. {
  1682. return AfxGetMinMaxInfo2( nStart, nEnd, pdMin, pdMax, this );
  1683. }
  1685. /***
  1686. OSC = 今日收盘价/N日收盘价平均值
  1687. */
  1688. BOOL COSC::Calculate( double * pValue, int nIndex, BOOL bUseLast )
  1689. {
  1690. STT_ASSERT_CALCULATE1( m_pKData, nIndex );
  1692. if( m_nDays > nIndex+1 )
  1693. return FALSE;
  1695. if( LoadFromCache( nIndex, pValue ) )
  1696. return TRUE;
  1698. double dCt = m_pKData->MaindataAt(nIndex);
  1699. double dMA = 0;
  1700. int nCount = 0;
  1701. for( int k=nIndex; k>=0; k-- )
  1702. {
  1703. dMA += m_pKData->MaindataAt(k);
  1705. nCount ++;
  1706. if( nCount == m_nDays )
  1707. {
  1708. dMA = dMA / m_nDays;
  1709. if( dMA < 1e-4 )
  1710. return FALSE;
  1711. if( pValue )
  1712. *pValue = (dCt/dMA);
  1713. StoreToCache( nIndex, pValue );
  1714. return TRUE;
  1715. }
  1716. }
  1717. return FALSE;
  1718. }
  1720. /***
  1721. 计算OSC及其移动平均值
  1722. */
  1723. BOOL COSC::Calculate( double * pValue, double * pMA, int nIndex, BOOL bUseLast )
  1724. {
  1725. return CalculateMA( pValue, pMA, nIndex, bUseLast, m_nMADays );
  1726. }
  1728. //////////////////////////////////////////////////////////////////////
  1729. // CUOS
  1730. CUOS::CUOS( )
  1731. {
  1732. SetDefaultParameters( );
  1733. }
  1735. CUOS::CUOS( CKData * pKData )
  1736. : CTechnique( pKData )
  1737. {
  1738. SetDefaultParameters( );
  1739. }
  1741. CUOS::~CUOS()
  1742. {
  1743. Clear( );
  1744. }
  1746. void CUOS::SetDefaultParameters( )
  1747. {
  1748. m_nDays1 = 7;
  1749. m_nDays2 = 14;
  1750. m_nDays3 = 28;
  1751. m_nMADays = 6;
  1752. m_itsGoldenFork = ITS_BUY;
  1753. m_itsDeadFork = ITS_SELL;
  1754. }
  1756. void CUOS::AttachParameters( CUOS & src )
  1757. {
  1758. m_nDays1 = src.m_nDays1;
  1759. m_nDays2 = src.m_nDays2;
  1760. m_nDays3 = src.m_nDays3;
  1761. m_nMADays = src.m_nMADays;
  1762. m_itsGoldenFork = src.m_itsGoldenFork;
  1763. m_itsDeadFork = src.m_itsDeadFork;
  1764. }
  1766. BOOL CUOS::IsValidParameters( )
  1767. {
  1768. return ( VALID_DAYS(m_nDays1) && VALID_DAYS(m_nDays2) && VALID_DAYS(m_nDays3) && VALID_DAYS(m_nMADays)
  1769. && VALID_ITS(m_itsGoldenFork) && VALID_ITS(m_itsDeadFork) );
  1770. }
  1772. void CUOS::Clear( )
  1773. {
  1774. CTechnique::Clear( );
  1775. }
  1777. int CUOS::GetSignal( int nIndex, UINT * pnCode )
  1778. {
  1779. if( pnCode ) *pnCode = ITSC_NOTHING;
  1781. int nMaxDays = max( max(m_nDays1,m_nDays2),m_nDays3) +m_nMADays;
  1782. double dLiminalLow = 0, dLiminalHigh = 0;
  1783. if( !IntensityPrepare( nIndex, pnCode, nMaxDays, ITS_GETMINMAXDAYRANGE, &dLiminalLow, &dLiminalHigh, 0.4, 0.6 ) )
  1784. return ITS_NOTHING;
  1786. double dUOS;
  1787. if( !Calculate( &dUOS, nIndex, FALSE ) )
  1788. return ITS_NOTHING;
  1790. int nSignal = GetForkSignal( nIndex, m_itsGoldenFork, m_itsDeadFork, pnCode );
  1791. if( dUOS < dLiminalLow && nSignal == m_itsGoldenFork )
  1792. { // 低位金叉
  1793. if( pnCode ) *pnCode = ITSC_GOLDENFORK;
  1794. return m_itsGoldenFork;
  1795. }
  1796. if( dUOS > dLiminalHigh && nSignal == m_itsDeadFork )
  1797. { // 高位死叉
  1798. if( pnCode ) *pnCode = ITSC_DEADFORK;
  1799. return m_itsDeadFork;
  1800. }
  1802. return ITS_NOTHING;
  1803. }
  1805. BOOL CUOS::GetMinMaxInfo(int nStart, int nEnd, double *pdMin, double *pdMax )
  1806. {
  1807. return AfxGetMinMaxInfo2( nStart, nEnd, pdMin, pdMax, this );
  1808. }
  1810. /***
  1811. OSC1 = m_nDays1日OSC
  1812. OSC2 = m_nDays2日OSC
  1813. OSC3 = m_nDays3日OSC
  1814. UOS = (OSC1+OSC2+OSC3)/3
  1815. */
  1816. BOOL CUOS::Calculate( double * pValue, int nIndex, BOOL bUseLast )
  1817. {
  1818. STT_ASSERT_CALCULATE1( m_pKData, nIndex );
  1820. if( LoadFromCache( nIndex, pValue ) )
  1821. return TRUE;
  1823. double dOSC1 = 0, dOSC2 = 0, dOSC3 = 0;
  1824. COSC osc1(m_pKData), osc2(m_pKData), osc3(m_pKData);
  1825. osc1.m_nDays = m_nDays1;
  1826. osc2.m_nDays = m_nDays2;
  1827. osc3.m_nDays = m_nDays3;
  1828. if( osc1.Calculate( &dOSC1, nIndex, FALSE )
  1829. && osc2.Calculate( &dOSC2, nIndex, FALSE )
  1830. && osc3.Calculate( &dOSC3, nIndex, FALSE ) )
  1831. {
  1832. if( pValue )
  1833. *pValue = (dOSC1+dOSC2+dOSC3)/3;
  1834. StoreToCache( nIndex, pValue );
  1835. return TRUE;
  1836. }
  1837. return FALSE;
  1838. }
  1840. /***
  1841. 计算UOS及其移动平均值
  1842. */
  1843. BOOL CUOS::Calculate( double * pValue, double * pMA, int nIndex, BOOL bUseLast )
  1844. {
  1845. return CalculateMA( pValue, pMA, nIndex, bUseLast, m_nMADays );
  1846. }
  1848. //////////////////////////////////////////////////////////////////////
  1849. // CMAOSC
  1850. CMAOSC::CMAOSC( )
  1851. {
  1852. SetDefaultParameters( );
  1853. }
  1855. CMAOSC::CMAOSC( CKData * pKData )
  1856. : CTechnique( pKData )
  1857. {
  1858. SetDefaultParameters( );
  1859. }
  1861. CMAOSC::~CMAOSC()
  1862. {
  1863. Clear( );
  1864. }
  1866. void CMAOSC::SetDefaultParameters( )
  1867. {
  1868. m_nDays1 = 6;
  1869. m_nDays2 = 12;
  1870. m_nMADays = 6;
  1871. m_itsGoldenFork = ITS_BUY;
  1872. m_itsDeadFork = ITS_SELL;
  1873. }
  1875. void CMAOSC::AttachParameters( CMAOSC & src )
  1876. {
  1877. m_nDays1 = src.m_nDays1;
  1878. m_nDays2 = src.m_nDays2;
  1879. m_nMADays = src.m_nMADays;
  1880. m_itsGoldenFork = src.m_itsGoldenFork;
  1881. m_itsDeadFork = src.m_itsDeadFork;
  1882. }
  1884. BOOL CMAOSC::IsValidParameters( )
  1885. {
  1886. return ( VALID_DAYS(m_nDays1) && VALID_DAYS(m_nDays2) && VALID_DAYS(m_nMADays)
  1887. && VALID_ITS(m_itsGoldenFork) && VALID_ITS(m_itsDeadFork) );
  1888. }
  1890. void CMAOSC::Clear( )
  1891. {
  1892. CTechnique::Clear( );
  1893. }
  1895. int CMAOSC::GetSignal( int nIndex, UINT * pnCode )
  1896. {
  1897. if( pnCode ) *pnCode = ITSC_NOTHING;
  1899. int nMaxDays = m_nMADays + max(m_nDays1,m_nDays2);
  1900. double dLiminalLow = 0, dLiminalHigh = 0;
  1901. if( !IntensityPrepare( nIndex, pnCode, nMaxDays, ITS_GETMINMAXDAYRANGE, &dLiminalLow, &dLiminalHigh, 0.4, 0.5 ) )
  1902. return ITS_NOTHING;
  1904. double dMAOSC;
  1905. if( !Calculate( &dMAOSC, nIndex, FALSE ) )
  1906. return ITS_NOTHING;
  1908. int nSignal = GetForkSignal( nIndex, m_itsGoldenFork, m_itsDeadFork, pnCode );
  1909. if( dMAOSC < dLiminalLow && nSignal == m_itsGoldenFork )
  1910. { // 低位金叉
  1911. if( pnCode ) *pnCode = ITSC_GOLDENFORK;
  1912. return m_itsGoldenFork;
  1913. }
  1914. if( dMAOSC > dLiminalHigh && nSignal == m_itsDeadFork )
  1915. { // 高位死叉
  1916. if( pnCode ) *pnCode = ITSC_DEADFORK;
  1917. return m_itsDeadFork;
  1918. }
  1920. return ITS_NOTHING;
  1921. }
  1923. BOOL CMAOSC::GetMinMaxInfo(int nStart, int nEnd, double *pdMin, double *pdMax )
  1924. {
  1925. return AfxGetMinMaxInfo2( nStart, nEnd, pdMin, pdMax, this );
  1926. }
  1928. /***
  1929. MAOSC = m_nDays1日收盘价移动平均值 - m_nDays2日收盘价移动平均值
  1930. */
  1931. BOOL CMAOSC::Calculate( double * pValue, int nIndex, BOOL bUseLast )
  1932. {
  1933. STT_ASSERT_CALCULATE1( m_pKData, nIndex );
  1935. if( LoadFromCache( nIndex, pValue ) )
  1936. return TRUE;
  1938. double dMA1 = 0, dMA2 = 0;
  1939. int nCount = 0;
  1940. for( int k=nIndex; k>=0; k-- )
  1941. {
  1942. if( nCount < m_nDays1 )
  1943. dMA1 += m_pKData->MaindataAt(k);
  1944. if( nCount < m_nDays2 )
  1945. dMA2 += m_pKData->MaindataAt(k);
  1947. nCount ++;
  1948. if( nCount >= m_nDays1 && nCount >= m_nDays2 )
  1949. {
  1950. if( pValue )
  1951. *pValue = (dMA1/m_nDays1 - dMA2/m_nDays2);
  1952. StoreToCache( nIndex, pValue );
  1953. return TRUE;
  1954. }
  1955. }
  1957. return FALSE;
  1958. }
  1960. /***
  1961. 计算MAOSC及其移动平均值
  1962. */
  1963. BOOL CMAOSC::Calculate( double * pValue, double * pMA, int nIndex, BOOL bUseLast )
  1964. {
  1965. return CalculateMA( pValue, pMA, nIndex, bUseLast, m_nMADays );
  1966. }
  1968. //////////////////////////////////////////////////////////////////////
  1969. // C36BIAS
  1970. C36BIAS::C36BIAS( )
  1971. {
  1972. SetDefaultParameters( );
  1973. }
  1975. C36BIAS::C36BIAS( CKData * pKData )
  1976. : CTechnique( pKData )
  1977. {
  1978. SetDefaultParameters( );
  1979. }
  1981. C36BIAS::~C36BIAS()
  1982. {
  1983. Clear( );
  1984. }
  1986. void C36BIAS::SetDefaultParameters( )
  1987. {
  1988. m_itsSold = ITS_BUY;
  1989. m_itsBought = ITS_SELL;
  1990. }
  1992. void C36BIAS::AttachParameters( C36BIAS & src )
  1993. {
  1994. m_itsSold = src.m_itsSold;
  1995. m_itsBought = src.m_itsBought;
  1996. }
  1998. BOOL C36BIAS::IsValidParameters( )
  1999. {
  2000. return ( VALID_ITS(m_itsSold) && VALID_ITS(m_itsBought) );
  2001. }
  2003. void C36BIAS::Clear( )
  2004. {
  2005. CTechnique::Clear( );
  2006. }
  2008. int C36BIAS::GetSignal( int nIndex, UINT * pnCode )
  2009. {
  2010. if( pnCode ) *pnCode = ITSC_NOTHING;
  2012. int nMaxDays = 6;
  2013. double dLiminalLow = 0, dLiminalHigh = 0;
  2014. if( !IntensityPrepare( nIndex, pnCode, nMaxDays, 40, &dLiminalLow, &dLiminalHigh, 0.02, 0.98 ) )
  2015. return ITS_NOTHING;
  2017. double d36BIAS;
  2018. if( !Calculate( &d36BIAS, nIndex, FALSE ) )
  2019. return ITS_NOTHING;
  2021. if( d36BIAS < dLiminalLow )
  2022. { // 超卖
  2023. if( pnCode ) *pnCode = ITSC_OVERSOLD;
  2024. return m_itsSold;
  2025. }
  2026. if( d36BIAS > dLiminalHigh )
  2027. { // 超买
  2028. if( pnCode ) *pnCode = ITSC_OVERBOUGHT;
  2029. return m_itsBought;
  2030. }
  2032. return ITS_NOTHING;
  2033. }
  2035. BOOL C36BIAS::GetMinMaxInfo(int nStart, int nEnd, double *pdMin, double *pdMax )
  2036. {
  2037. return AfxGetMinMaxInfo1( nStart, nEnd, pdMin, pdMax, this );
  2038. }
  2040. /***
  2041. 3-6BIAS = 3日收盘价移动平均值 - 6日收盘价移动平均值
  2042. */
  2043. BOOL C36BIAS::Calculate( double * pValue, int nIndex, BOOL bUseLast )
  2044. {
  2045. STT_ASSERT_CALCULATE1( m_pKData, nIndex );
  2047. if( LoadFromCache( nIndex, pValue ) )
  2048. return TRUE;
  2050. double dMA1 = 0, dMA2 = 0;
  2051. int nCount = 0;
  2052. for( int k=nIndex; k>=0; k-- )
  2053. {
  2054. if( nCount < 3 )
  2055. dMA1 += m_pKData->MaindataAt(k);
  2056. if( nCount < 6 )
  2057. dMA2 += m_pKData->MaindataAt(k);
  2059. nCount ++;
  2060. if( nCount >= 3 && nCount >= 6 )
  2061. {
  2062. if( pValue )
  2063. *pValue = (dMA1/3 - dMA2/6);
  2064. StoreToCache( nIndex, pValue );
  2065. return TRUE;
  2066. }
  2067. }
  2069. return FALSE;
  2070. }
  2072. //////////////////////////////////////////////////////////////////////
  2073. // CDPO
  2074. CDPO::CDPO( )
  2075. {
  2076. SetDefaultParameters( );
  2077. }
  2079. CDPO::CDPO( CKData * pKData )
  2080. : CTechnique( pKData )
  2081. {
  2082. SetDefaultParameters( );
  2083. }
  2085. CDPO::~CDPO()
  2086. {
  2087. Clear( );
  2088. }
  2090. void CDPO::SetDefaultParameters( )
  2091. {
  2092. m_nDays = 10;
  2093. m_nMADays = 6;
  2094. m_itsGoldenFork = ITS_BUY;
  2095. m_itsDeadFork = ITS_SELL;
  2096. }
  2098. void CDPO::AttachParameters( CDPO & src )
  2099. {
  2100. m_nDays = src.m_nDays;
  2101. m_nMADays = src.m_nMADays;
  2102. m_itsGoldenFork = src.m_itsGoldenFork;
  2103. m_itsDeadFork = src.m_itsDeadFork;
  2104. }
  2106. BOOL CDPO::IsValidParameters( )
  2107. {
  2108. return ( VALID_DAYS( m_nDays ) && VALID_DAYS( m_nMADays )
  2109. && VALID_ITS(m_itsGoldenFork) && VALID_ITS(m_itsDeadFork) );
  2110. }
  2112. void CDPO::Clear( )
  2113. {
  2114. CTechnique::Clear( );
  2115. }
  2117. int CDPO::GetSignal( int nIndex, UINT * pnCode )
  2118. {
  2119. if( pnCode ) *pnCode = ITSC_NOTHING;
  2121. int nMaxDays = 3*m_nDays + m_nMADays;
  2122. double dLiminalLow = 0, dLiminalHigh = 0;
  2123. if( !IntensityPrepare( nIndex, pnCode, nMaxDays, ITS_GETMINMAXDAYRANGE, &dLiminalLow, &dLiminalHigh, 0.2, 0.7 ) )
  2124. return ITS_NOTHING;
  2126. double dDPO;
  2127. if( !Calculate( &dDPO, nIndex, FALSE ) )
  2128. return FALSE;
  2130. int nSignal = GetForkSignal( nIndex, m_itsGoldenFork, m_itsDeadFork, pnCode );
  2131. if( dDPO < dLiminalLow && nSignal == m_itsGoldenFork )
  2132. { // 低位金叉
  2133. if( pnCode ) *pnCode = ITSC_GOLDENFORK;
  2134. return m_itsGoldenFork;
  2135. }
  2136. if( dDPO > dLiminalHigh && nSignal == m_itsDeadFork )
  2137. { // 高位死叉
  2138. if( pnCode ) *pnCode = ITSC_DEADFORK;
  2139. return m_itsDeadFork;
  2140. }
  2142. return ITS_NOTHING;
  2143. }
  2145. BOOL CDPO::GetMinMaxInfo(int nStart, int nEnd, double *pdMin, double *pdMax )
  2146. {
  2147. return AfxGetMinMaxInfo2( nStart, nEnd, pdMin, pdMax, this );
  2148. }
  2150. /***
  2151. DPO = 今日收盘价 - N日前的（N+N）日平均收盘价
  2152. */
  2153. BOOL CDPO::Calculate( double * pValue, int nIndex, BOOL bUseLast )
  2154. {
  2155. STT_ASSERT_CALCULATE1( m_pKData, nIndex );
  2157. if( 3*m_nDays-2 > nIndex+1 )
  2158. return FALSE;
  2160. if( LoadFromCache( nIndex, pValue ) )
  2161. return TRUE;
  2163. double dCt = 0, dMA = 0;
  2164. double nCount = 0;
  2165. for( int k=nIndex-m_nDays+1; k>=0; k-- )
  2166. {
  2167. dMA += m_pKData->MaindataAt(k);
  2169. nCount ++;
  2170. if( nCount == m_nDays+m_nDays )
  2171. {
  2172. dCt = m_pKData->MaindataAt(nIndex);
  2173. dMA = dMA / (m_nDays+m_nDays);
  2174. if( pValue )
  2175. *pValue = (dCt-dMA);
  2176. StoreToCache( nIndex, pValue );
  2177. return TRUE;
  2178. }
  2179. }
  2181. return FALSE;
  2182. }
  2184. /***
  2185. 计算DPO及其移动平均值
  2186. */
  2187. BOOL CDPO::Calculate( double * pValue, double * pMA, int nIndex, BOOL bUseLast )
  2188. {
  2189. return CalculateMA( pValue, pMA, nIndex, bUseLast, m_nMADays );
  2190. }
  2192. //////////////////////////////////////////////////////////////////////
  2193. // CKST
  2194. CKST::CKST( )
  2195. {
  2196. SetDefaultParameters( );
  2197. }
  2199. CKST::CKST( CKData * pKData )
  2200. : CTechnique( pKData )
  2201. {
  2202. SetDefaultParameters( );
  2203. }
  2205. CKST::~CKST()
  2206. {
  2207. Clear( );
  2208. }
  2210. void CKST::SetDefaultParameters( )
  2211. {
  2212. m_adwROCDays.RemoveAll();
  2213. m_adwROCDays.Add( 9 );
  2214. m_adwROCDays.Add( 12 );
  2215. m_adwROCDays.Add( 18 );
  2216. m_adwROCDays.Add( 24 );
  2217. m_nMADays = 6;
  2218. m_itsGoldenFork = ITS_BUY;
  2219. m_itsDeadFork = ITS_SELL;
  2220. }
  2222. void CKST::AttachParameters( CKST & src )
  2223. {
  2224. m_adwROCDays.Copy( src.m_adwROCDays );
  2225. m_nMADays = src.m_nMADays;
  2226. m_itsGoldenFork = src.m_itsGoldenFork;
  2227. m_itsDeadFork = src.m_itsDeadFork;
  2228. }
  2230. BOOL CKST::IsValidParameters( )
  2231. {
  2232. STT_VALID_DAYSARRAY( m_adwROCDays );
  2233. return ( VALID_DAYS(m_nMADays) && VALID_ITS(m_itsGoldenFork) && VALID_ITS(m_itsDeadFork) );
  2234. }
  2236. void CKST::Clear( )
  2237. {
  2238. CTechnique::Clear( );
  2239. }
  2241. int CKST::GetSignal( int nIndex, UINT * pnCode )
  2242. {
  2243. if( pnCode ) *pnCode = ITSC_NOTHING;
  2245. int nMaxDays = AfxGetMaxDays( m_adwROCDays )+m_nMADays;
  2246. double dLiminalLow = 0, dLiminalHigh = 0;
  2247. if( !IntensityPrepare( nIndex, pnCode, nMaxDays, ITS_GETMINMAXDAYRANGE, &dLiminalLow, &dLiminalHigh, 0.2, 0.6 ) )
  2248. return ITS_NOTHING;
  2250. if( nIndex <= 1 )
  2251. return ITS_NOTHING;
  2253. double dKST;
  2254. if( !Calculate( &dKST, nIndex, FALSE ) )
  2255. return ITS_NOTHING;
  2257. int nSignal = GetForkSignal( nIndex, m_itsGoldenFork, m_itsDeadFork, pnCode );
  2258. if( dKST < dLiminalLow && nSignal == m_itsGoldenFork )
  2259. { // 低位金叉
  2260. if( pnCode ) *pnCode = ITSC_GOLDENFORK;
  2261. return m_itsGoldenFork;
  2262. }
  2263. if( dKST > dLiminalHigh && nSignal == m_itsDeadFork )
  2264. { // 高位死叉
  2265. if( pnCode ) *pnCode = ITSC_DEADFORK;
  2266. return m_itsDeadFork;
  2267. }
  2269. return ITS_NOTHING;
  2270. }
  2272. BOOL CKST::GetMinMaxInfo(int nStart, int nEnd, double *pdMin, double *pdMax )
  2273. {
  2274. return AfxGetMinMaxInfo2( nStart, nEnd, pdMin, pdMax, this );
  2275. }
  2277. /***
  2278.        9日ROC + 12日ROC×2 + 18日ROC×3 + 24日ROC×4
  2279. KST = ------------------------------------------------
  2280.                            10
  2281. */
  2282. BOOL CKST::Calculate( double * pValue, int nIndex, BOOL bUseLast )
  2283. {
  2284. STT_ASSERT_CALCULATE1( m_pKData, nIndex );
  2286. UINT nMaxDays = AfxGetMaxDays( m_adwROCDays );
  2287. if( (int)nMaxDays > nIndex )
  2288. return FALSE;
  2290. if( LoadFromCache( nIndex, pValue ) )
  2291. return TRUE;
  2293. double dKST = 0;
  2294. int nCount = 0;
  2295. for( int m=0; m<m_adwROCDays.GetSize(); m++ )
  2296. {
  2297. CROC roc(m_pKData);
  2298. roc.m_nDays = m_adwROCDays[m];
  2299. double dROC = 0;
  2300. if( !roc.Calculate( &dROC, nIndex, FALSE ) )
  2301. return FALSE;
  2302. dKST += dROC*(m+1);
  2303. nCount += (m+1);
  2304. }
  2306. if( nCount <= 0 )
  2307. return FALSE;
  2309. dKST = dKST / nCount;
  2310. if( pValue )
  2311. *pValue = dKST;
  2312. StoreToCache( nIndex, pValue );
  2313. return TRUE;
  2314. }
  2316. /***
  2317. 计算KST及其移动平均值
  2318. */
  2319. BOOL CKST::Calculate( double * pValue, double * pMA, int nIndex, BOOL bUseLast )
  2320. {
  2321. return CTechnique::CalculateMA( pValue, pMA, nIndex, bUseLast, m_nMADays );
  2322. }