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

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

金融证券系统

开发平台：

Visual C++

TechOther.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. // CREI
  24. CREI::CREI( )
  25. {
  26. SetDefaultParameters( );
  27. }
  29. CREI::CREI( CKData * pKData )
  30. : CTechnique( pKData )
  31. {
  32. SetDefaultParameters( );
  33. }
  35. CREI::~CREI()
  36. {
  37. Clear( );
  38. }
  40. void CREI::SetDefaultParameters( )
  41. {
  42. m_nDays = 8;
  43. m_itsLong = ITS_BUY;
  44. m_itsShort = ITS_SELL;
  45. }
  47. void CREI::AttachParameters( CREI & src )
  48. {
  49. m_nDays = src.m_nDays;
  50. m_itsLong = src.m_itsLong;
  51. m_itsShort = src.m_itsShort;
  52. }
  54. BOOL CREI::IsValidParameters( )
  55. {
  56. return ( VALID_DAYS(m_nDays) && VALID_ITS(m_itsLong) && VALID_ITS(m_itsShort) );
  57. }
  59. void CREI::Clear( )
  60. {
  61. CTechnique::Clear( );
  62. }
  64. int CREI::GetSignal( int nIndex, UINT * pnCode )
  65. {
  66. if( pnCode ) *pnCode = ITSC_NOTHING;
  68. if( nIndex <= 0 )
  69. return ITS_NOTHING;
  71. double dLast, dNow;
  72. if( !Calculate( &dLast, nIndex-1, FALSE )
  73. || !Calculate( &dNow, nIndex, FALSE ) )
  74. return ITS_NOTHING;
  76. if( dLast < -0.6 && dNow > -0.6 )
  77. { // 低位做多
  78. if( pnCode ) *pnCode = ITSC_LONG;
  79. return m_itsLong;
  80. }
  81. if( dLast > 0.6 && dNow < 0.6 )
  82. { // 高位做空
  83. if( pnCode ) *pnCode = ITSC_SHORT;
  84. return m_itsShort;
  85. }
  87. return ITS_NOTHING;
  88. }
  90. BOOL CREI::GetMinMaxInfo(int nStart, int nEnd, double *pdMin, double *pdMax )
  91. {
  92. return AfxGetMinMaxInfo1( nStart, nEnd, pdMin, pdMax, this );
  93. }
  95. /***
  96. DIF1 = 今日最高价 - 2日前最高价
  97. DIF2 = 今日最低价 - 2日前最低价
  98. A = N日内除满足以下情况日的（DIF1+DIF2）之和
  99. 1. 2日前最高价 小于 7日前收盘价
  100. 2. 2日前最高价 小于 8日前收盘价
  101. 3. 今日前最高价 小于 5日前最低价
  102. 4. 今日前最高价 小于 6日前最低价
  103. 5. 2日前最低价 小于 7日前收盘价
  104. 6. 2日前最低价 小于 8日前收盘价
  105. 7. 今日前最低价 小于 5日前最高价
  106. 8. 今日前最低价 小于 6日前最高价
  107. REIA = N日的DIF1绝对值之和 + N日的DIF2绝对值之和
  108. REI  = A / REIA
  109. */
  110. BOOL CREI::Calculate( double * pValue, int nIndex, BOOL bUseLast )
  111. {
  112. STT_ASSERT_CALCULATE1( m_pKData, nIndex );
  114. if( m_nDays+7 > nIndex )
  115. return FALSE;
  117. if( LoadFromCache( nIndex, pValue ) )
  118. return TRUE;
  120. double dREI = 0, dREIA = 0;
  121. int nCount = 0;
  122. for( int k=nIndex; k>=8; k-- )
  123. {
  124. double dDIF1 = 0, dDIF2 = 0;
  125. int num1 = 1, num2 = 1;
  126. dDIF1 = ((double)m_pKData->ElementAt(k).m_fHigh) - m_pKData->ElementAt(k-2).m_fHigh;
  127. dDIF2 = ((double)m_pKData->ElementAt(k).m_fLow) - m_pKData->ElementAt(k-2).m_fLow;
  128. if( m_pKData->ElementAt(k-2).m_fHigh < m_pKData->ElementAt(k-7).m_fClose
  129. && m_pKData->ElementAt(k-2).m_fHigh < m_pKData->ElementAt(k-8).m_fClose
  130. && m_pKData->ElementAt(k).m_fHigh < m_pKData->ElementAt(k-5).m_fLow
  131. && m_pKData->ElementAt(k).m_fHigh < m_pKData->ElementAt(k-6).m_fLow )
  132. num1 = 0;
  133. if( m_pKData->ElementAt(k-2).m_fLow > m_pKData->ElementAt(k-7).m_fClose
  134. && m_pKData->ElementAt(k-2).m_fLow > m_pKData->ElementAt(k-8).m_fClose
  135. && m_pKData->ElementAt(k).m_fLow > m_pKData->ElementAt(k-5).m_fHigh
  136. && m_pKData->ElementAt(k).m_fLow > m_pKData->ElementAt(k-6).m_fHigh )
  137. num2 = 0;
  138. dREI += (dDIF1+dDIF2) * num1 * num2;
  139. dREIA += fabs(dDIF1) + fabs(dDIF2);
  141. nCount ++;
  142. if( nCount == m_nDays )
  143. {
  144. if( fabs(dREIA) < 1e-4 )
  145. return FALSE;
  146. if( pValue )
  147. *pValue = dREI / dREIA;
  148. StoreToCache( nIndex, pValue );
  149. return TRUE;
  150. }
  151. }
  153. return FALSE;
  154. }
  156. //////////////////////////////////////////////////////////////////////
  157. // CDMKI
  158. CDMKI::CDMKI( )
  159. {
  160. SetDefaultParameters( );
  161. }
  163. CDMKI::CDMKI( CKData * pKData )
  164. : CTechnique( pKData )
  165. {
  166. SetDefaultParameters( );
  167. }
  169. CDMKI::~CDMKI()
  170. {
  171. Clear( );
  172. }
  174. void CDMKI::SetDefaultParameters( )
  175. {
  176. m_nDays = 13;
  177. m_itsSold = ITS_BUY;
  178. m_itsBought = ITS_SELL;
  179. }
  181. void CDMKI::AttachParameters( CDMKI & src )
  182. {
  183. m_nDays = src.m_nDays;
  184. m_itsSold = src.m_itsSold;
  185. m_itsBought = src.m_itsBought;
  186. }
  188. BOOL CDMKI::IsValidParameters( )
  189. {
  190. return ( VALID_DAYS(m_nDays) && VALID_ITS(m_itsSold) && VALID_ITS(m_itsBought) );
  191. }
  193. void CDMKI::Clear( )
  194. {
  195. CTechnique::Clear( );
  196. }
  198. int CDMKI::GetSignal( int nIndex, UINT * pnCode )
  199. {
  200. if( pnCode ) *pnCode = ITSC_NOTHING;
  202. double dDMKI;
  203. if( !Calculate( &dDMKI, nIndex, FALSE ) )
  204. return ITS_NOTHING;
  205. if( dDMKI < 0.3 )
  206. { // 超卖
  207. if( pnCode ) *pnCode = ITSC_OVERSOLD;
  208. return m_itsSold;
  209. }
  210. if( dDMKI > 0.7 )
  211. { // 超买
  212. if( pnCode ) *pnCode = ITSC_OVERBOUGHT;
  213. return m_itsBought;
  214. }
  215. return ITS_NOTHING;
  216. }
  218. BOOL CDMKI::GetMinMaxInfo(int nStart, int nEnd, double *pdMin, double *pdMax )
  219. {
  220. return AfxGetMinMaxInfo1( nStart, nEnd, pdMin, pdMax, this );
  221. }
  223. /***
  224. DMH = N日内最高价大于昨日最高价日的 （最高价-昨日最高价）
  225. DML = N日内最低价小于昨日最低价日的 （昨日最低价-最低价）
  226. DMKI = DMH / (DMH+DML)
  227. */
  228. BOOL CDMKI::Calculate( double * pValue, int nIndex, BOOL bUseLast )
  229. {
  230. STT_ASSERT_CALCULATE1( m_pKData, nIndex );
  232. if( m_nDays > nIndex )
  233. return FALSE;
  235. if( LoadFromCache( nIndex, pValue ) )
  236. return TRUE;
  238. double dDMH = 0, dDML = 0;
  239. int nCount = 0;
  240. for( int k=nIndex; k>=1; k-- )
  241. {
  242. KDATA kd = m_pKData->ElementAt(k);
  243. KDATA kdLast = m_pKData->ElementAt(k-1);
  244. if( kd.m_fHigh > kdLast.m_fHigh )
  245. dDMH += (((double)kd.m_fHigh)-kdLast.m_fHigh);
  246. if( kd.m_fLow < kdLast.m_fLow )
  247. dDML += (((double)kdLast.m_fLow)-kd.m_fLow);
  249. nCount ++;
  250. if( nCount == m_nDays )
  251. {
  252. if( fabs(dDMH + dDML) < 1e-4 )
  253. return FALSE;
  254. if( pValue ) *pValue = dDMH / (dDMH+dDML);
  255. StoreToCache( nIndex, pValue );
  256. return TRUE;
  257. }
  258. }
  260. return FALSE;
  261. }
  263. //////////////////////////////////////////////////////////////////////
  264. // CPCNT
  265. CPCNT::CPCNT( )
  266. {
  267. SetDefaultParameters( );
  268. }
  270. CPCNT::CPCNT( CKData * pKData )
  271. : CTechnique( pKData )
  272. {
  273. SetDefaultParameters( );
  274. }
  276. CPCNT::~CPCNT()
  277. {
  278. Clear( );
  279. }
  281. void CPCNT::SetDefaultParameters( )
  282. {
  283. m_nMADays = 6;
  284. m_itsGoldenFork = ITS_BUY;
  285. m_itsDeadFork = ITS_SELL;
  286. }
  288. void CPCNT::AttachParameters( CPCNT & src )
  289. {
  290. m_nMADays = src.m_nMADays;
  291. m_itsGoldenFork = src.m_itsGoldenFork;
  292. m_itsDeadFork = src.m_itsDeadFork;
  293. }
  295. BOOL CPCNT::IsValidParameters( )
  296. {
  297. return ( VALID_DAYS(m_nMADays) && VALID_ITS(m_itsGoldenFork) && VALID_ITS(m_itsDeadFork) );
  298. }
  300. void CPCNT::Clear( )
  301. {
  302. CTechnique::Clear( );
  303. }
  305. int CPCNT::GetSignal( int nIndex, UINT * pnCode )
  306. {
  307. if( pnCode ) *pnCode = ITSC_NOTHING;
  309. int nMaxDays = m_nMADays;
  310. double dLiminalLow = 0, dLiminalHigh = 0;
  311. if( !IntensityPrepare( nIndex, pnCode, nMaxDays, ITS_GETMINMAXDAYRANGE, &dLiminalLow, &dLiminalHigh, 0.5, 0.5 ) )
  312. return ITS_NOTHING;
  314. double dPCNT;
  315. if( !Calculate( &dPCNT, nIndex, FALSE ) )
  316. return ITS_NOTHING;
  318. int nSignal = GetForkSignal( nIndex, m_itsGoldenFork, m_itsDeadFork, pnCode );
  319. if( dPCNT < dLiminalLow && nSignal == m_itsGoldenFork )
  320. { // 低位金叉
  321. if( pnCode ) *pnCode = ITSC_GOLDENFORK;
  322. return m_itsGoldenFork;
  323. }
  324. if( dPCNT > dLiminalHigh && nSignal == m_itsDeadFork )
  325. { // 高位死叉
  326. if( pnCode ) *pnCode = ITSC_DEADFORK;
  327. return m_itsDeadFork;
  328. }
  330. return ITS_NOTHING;
  331. }
  333. BOOL CPCNT::GetMinMaxInfo(int nStart, int nEnd, double *pdMin, double *pdMax )
  334. {
  335. return AfxGetMinMaxInfo2( nStart, nEnd, pdMin, pdMax, this );
  336. }
  338. /***
  339.          今日收盘 - N日前收盘
  340. PCNT = ———————————— × 100%
  341.               昨日收盘
  342. */
  343. BOOL CPCNT::Calculate( double * pValue, int nIndex, BOOL bUseLast )
  344. {
  345. STT_ASSERT_CALCULATE1( m_pKData, nIndex );
  347. if( LoadFromCache( nIndex, pValue ) )
  348. return TRUE;
  350. int nDays = 1; // same as ROC with m_nDays==1
  351. if( nDays > nIndex )
  352. return FALSE;
  354. double dROC = 0;
  355. if( m_pKData->MaindataAt(nIndex-nDays) <= 0
  356. || m_pKData->MaindataAt(nIndex) <= 0 )
  357. return FALSE;
  359. double x = m_pKData->MaindataAt(nIndex);
  360. double y = m_pKData->MaindataAt(nIndex-nDays);
  361. if( pValue )
  362. *pValue = (x - y) * 100 / y;
  363. StoreToCache( nIndex, pValue );
  364. return TRUE;
  365. }
  367. /***
  368. 计算PCNT及其移动平均值
  369. */
  370. BOOL CPCNT::Calculate( double * pValue, double * pMA, int nIndex, BOOL bUseLast )
  371. {
  372. return CTechnique::CalculateMA( pValue, pMA, nIndex, bUseLast, m_nMADays );
  373. }
  375. //////////////////////////////////////////////////////////////////////
  376. // CHLC
  377. CHLC::CHLC( )
  378. {
  379. SetDefaultParameters( );
  380. }
  382. CHLC::CHLC( CKData * pKData )
  383. : CTechnique( pKData )
  384. {
  385. SetDefaultParameters( );
  386. }
  388. CHLC::~CHLC()
  389. {
  390. Clear( );
  391. }
  393. void CHLC::SetDefaultParameters( )
  394. {
  395. m_nDays = 12;
  396. m_nMADays = 6;
  397. m_itsGoldenFork = ITS_BUY;
  398. m_itsDeadFork = ITS_SELL;
  399. }
  401. void CHLC::AttachParameters( CHLC & src )
  402. {
  403. m_nDays = src.m_nDays;
  404. m_nMADays = src.m_nMADays;
  405. m_itsGoldenFork = src.m_itsGoldenFork;
  406. m_itsDeadFork = src.m_itsDeadFork;
  407. }
  409. BOOL CHLC::IsValidParameters( )
  410. {
  411. return ( VALID_DAYS(m_nDays) && VALID_DAYS(m_nMADays)
  412. && VALID_ITS(m_itsGoldenFork) && VALID_ITS(m_itsDeadFork) );
  413. }
  415. void CHLC::Clear( )
  416. {
  417. CTechnique::Clear( );
  418. }
  420. int CHLC::GetSignal( int nIndex, UINT * pnCode )
  421. {
  422. if( pnCode ) *pnCode = ITSC_NOTHING;
  424. int nMaxDays = m_nDays + m_nMADays;
  425. double dLiminalLow = 0, dLiminalHigh = 0;
  426. if( !IntensityPrepare( nIndex, pnCode, nMaxDays, ITS_GETMINMAXDAYRANGE*3, &dLiminalLow, &dLiminalHigh, 0.4, 0.6 ) )
  427. return ITS_NOTHING;
  429. double dHLC;
  430. if( !Calculate( &dHLC, nIndex, FALSE ) )
  431. return ITS_NOTHING;
  433. int nSignal = GetForkSignal( nIndex, m_itsGoldenFork, m_itsDeadFork, pnCode );
  434. if( nSignal == m_itsGoldenFork )
  435. { // 低位金叉
  436. if( pnCode ) *pnCode = ITSC_GOLDENFORK;
  437. return m_itsGoldenFork;
  438. }
  439. if( nSignal == m_itsDeadFork )
  440. { // 高位死叉
  441. if( pnCode ) *pnCode = ITSC_DEADFORK;
  442. return m_itsDeadFork;
  443. }
  445. return ITS_NOTHING;
  446. }
  448. BOOL CHLC::GetMinMaxInfo(int nStart, int nEnd, double *pdMin, double *pdMax )
  449. {
  450. return AfxGetMinMaxInfo2( nStart, nEnd, pdMin, pdMax, this );
  451. }
  453. /***
  454. TP = (收盘价+收盘价+最高价+最低价)/4
  455. HLC = N日TP平均值
  456. */
  457. BOOL CHLC::Calculate( double * pValue, int nIndex, BOOL bUseLast )
  458. {
  459. STT_ASSERT_CALCULATE1( m_pKData, nIndex );
  461. if( m_nDays > nIndex+1 )
  462. return FALSE;
  464. if( LoadFromCache( nIndex, pValue ) )
  465. return TRUE;
  467. double dMATP = 0;
  468. int nCount = 0;
  469. for( int k=nIndex; k>=0; k-- )
  470. {
  471. KDATA kd = m_pKData->ElementAt(k);
  472. double dTP = (kd.m_fHigh+kd.m_fLow+kd.m_fClose*2)/4.;
  473. dMATP += dTP;
  475. nCount ++;
  476. if( nCount == m_nDays )
  477. {
  478. if( pValue ) *pValue = dMATP / m_nDays;
  479. StoreToCache( nIndex, pValue );
  480. return TRUE;
  481. }
  482. }
  483. return FALSE;
  484. }
  486. /***
  487. 计算HLC及其移动平均值
  488. */
  489. BOOL CHLC::Calculate( double * pValue, double * pMA, int nIndex, BOOL bUseLast )
  490. {
  491. return CTechnique::CalculateMA( pValue, pMA, nIndex, bUseLast, m_nMADays );
  492. }
  494. //////////////////////////////////////////////////////////////////////
  495. // CCDP
  496. CCDP::CCDP( )
  497. {
  498. SetDefaultParameters( );
  499. }
  501. CCDP::CCDP( CKData * pKData )
  502. : CTechnique( pKData )
  503. {
  504. SetDefaultParameters( );
  505. }
  507. CCDP::~CCDP()
  508. {
  509. Clear( );
  510. }
  512. void CCDP::SetDefaultParameters( )
  513. {
  514. }
  516. void CCDP::AttachParameters( CCDP & src )
  517. {
  518. }
  520. BOOL CCDP::IsValidParameters( )
  521. {
  522. return TRUE;
  523. }
  525. void CCDP::Clear( )
  526. {
  527. CTechnique::Clear( );
  528. }
  530. int CCDP::GetSignal( int nIndex, UINT * pnCode )
  531. {
  532. if( pnCode ) *pnCode = ITSC_NOTHING;
  533. // 无买卖信号
  534. return ITS_NOTHING;
  535. }
  537. BOOL CCDP::GetMinMaxInfo(int nStart, int nEnd, double *pdMin, double *pdMax )
  538. {
  539. return AfxGetMinMaxInfo4( nStart, nEnd, pdMin, pdMax, this );
  540. }
  542. /***
  543. TP = (昨日收盘价+昨日收盘价+昨日最高价+昨日最低价)/4
  544. AH = TP + 昨日最高价 - 昨日最低价
  545. AL = TP - 最日最高价 + 昨日最低价
  546. NH = TP + TP - 最日最低价
  547. NL = TP + TP - 最日最高价
  548. */
  549. BOOL CCDP::Calculate( double * pAH, double * pNH, double * pAL, double * pNL, int nIndex, BOOL bUseLast )
  550. {
  551. STT_ASSERT_CALCULATE1( m_pKData, nIndex );
  553. if( nIndex < 1 )
  554. return FALSE;
  556. if( LoadFromCache( nIndex, pAH, pNH, pAL, pNL ) )
  557. return TRUE;
  559. KDATA kdLast = m_pKData->ElementAt(nIndex-1);
  560. double dTP = (kdLast.m_fHigh+kdLast.m_fLow+kdLast.m_fClose*2)/4.;
  561. if( pAH ) *pAH = (dTP + kdLast.m_fHigh - kdLast.m_fLow);
  562. if( pNH ) *pNH = (dTP + dTP - kdLast.m_fLow);
  563. if( pAL ) *pAL = (dTP - kdLast.m_fHigh + kdLast.m_fLow);
  564. if( pNL ) *pNL = (dTP - kdLast.m_fHigh + dTP);
  565. StoreToCache( nIndex, pAH, pNH, pAL, pNL );
  566. return TRUE;
  567. }
  569. //////////////////////////////////////////////////////////////////////
  570. // CASI
  571. CASI::CASI( )
  572. {
  573. SetDefaultParameters( );
  574. }
  576. CASI::CASI( CKData * pKData )
  577. : CTechnique( pKData )
  578. {
  579. SetDefaultParameters( );
  580. }
  582. CASI::~CASI()
  583. {
  584. Clear( );
  585. }
  587. void CASI::SetDefaultParameters( )
  588. {
  589. m_nDays = 6;
  590. m_itsDeviateOnBottom = ITS_BUY;
  591. m_itsDeviateOnTop = ITS_SELL;
  592. }
  594. void CASI::AttachParameters( CASI & src )
  595. {
  596. m_nDays = src.m_nDays;
  597. m_itsDeviateOnBottom = src.m_itsDeviateOnBottom;
  598. m_itsDeviateOnTop = src.m_itsDeviateOnTop;
  599. }
  601. BOOL CASI::IsValidParameters( )
  602. {
  603. return ( VALID_DAYS(m_nDays) && VALID_ITS(m_itsDeviateOnBottom) && VALID_ITS(m_itsDeviateOnTop) );
  604. }
  606. void CASI::Clear( )
  607. {
  608. CTechnique::Clear( );
  609. }
  611. int CASI::GetSignal( int nIndex, UINT * pnCode )
  612. {
  613. if( pnCode ) *pnCode = ITSC_NOTHING;
  615. int nMaxDays = m_nDays;
  616. double dLiminalLow = 0, dLiminalHigh = 0;
  617. if( !IntensityPrepare( nIndex, pnCode, nMaxDays, ITS_GETMINMAXDAYRANGE, &dLiminalLow, &dLiminalHigh ) )
  618. return ITS_NOTHING;
  620. if( IsDeviateOnBottom( nIndex, m_pdCache1, m_pdCache2 ) )
  621. { // 底背离
  622. if( pnCode ) *pnCode = ITSC_DEVIATEONBOTTOM;
  623. return m_itsDeviateOnBottom;
  624. }
  625. if( IsDeviateOnTop( nIndex, m_pdCache1, m_pdCache2 ) )
  626. { // 顶背离
  627. if( pnCode ) *pnCode = ITSC_DEVIATEONTOP;
  628. return m_itsDeviateOnTop;
  629. }
  631. return ITS_NOTHING;
  632. }
  634. BOOL CASI::GetMinMaxInfo(int nStart, int nEnd, double *pdMin, double *pdMax )
  635. {
  636. return AfxGetMinMaxInfo1( nStart, nEnd, pdMin, pdMax, this );
  637. }
  639. /***
  640. A = 今最高 - 昨收盘
  641. B = 今最低 - 昨最低
  642. C = 今最高 - 昨最低
  643. D = 昨收盘 - 昨开盘
  644. E = 今收盘 - 昨收盘
  645. F = 今收盘 - 昨开盘
  646. G = 昨收盘 - 昨开盘
  647. X = E + 1/(2F) + G
  648. K = A、B二者之间较大者
  649. 比较A、B、C三者的大小
  650. 若A大，则R = A+1/(2B)+1/(4D)
  651. 若B大，则R = B+1/(2A)+1/(4D)
  652. 若C大，则R = C+1/(4D)
  653. L = 3
  654. SI = 50·X·K/(R·L)
  655. ASI = N日SI之和
  656. */
  657. BOOL CASI::Calculate( double * pValue, int nIndex, BOOL bUseLast )
  658. {
  659. STT_ASSERT_CALCULATE1( m_pKData, nIndex );
  661. if( m_nDays > nIndex )
  662. return FALSE;
  664. if( LoadFromCache( nIndex, pValue ) )
  665. return TRUE;
  667. double dASI = 0;
  668. double A, B, C, D, E, F, G;
  669. double R, X, K, SI;
  670. int nCount = 0;
  671. for( int k=nIndex; k>=1; k-- )
  672. {
  673. KDATA kd = m_pKData->ElementAt(k);
  674. KDATA kdLast = m_pKData->ElementAt(k-1);
  675. A = fabs(((double)kd.m_fHigh) - kdLast.m_fClose);
  676. B = fabs(((double)kd.m_fLow) - kdLast.m_fClose);
  677. C = fabs(((double)kd.m_fHigh) - kdLast.m_fLow);
  678. D = fabs(((double)kdLast.m_fClose) - kdLast.m_fOpen);
  679. E = ((double)kd.m_fClose) - kdLast.m_fClose;
  680. F = ((double)kd.m_fClose) - kd.m_fOpen;
  681. G = ((double)kdLast.m_fClose) - kdLast.m_fOpen;
  683. if( fabs(A) < 1e-4 || fabs(B) < 1e-4 || fabs(D) < 1e-4 || fabs(F) < 1e-4 )
  684. continue;
  686. if( A >= B && A >= C )
  687. R = A + 1/(2*B) + 1/(4*D);
  688. else if( B >= A && B >= C )
  689. R = B + 1/(2*A) + 1/(4*D);
  690. else
  691. R = C + 1/(4*D);
  693. if( fabs(R) < 1e-4 )
  694. continue;
  696. X = E + 1/(2*F) + G;
  697. K = ( A > B ? A : B );
  698. SI = X * K * 50 / (3*R);
  700. dASI += SI;
  702. nCount ++;
  703. if( nCount == m_nDays )
  704. {
  705. if( pValue ) *pValue = dASI;
  706. StoreToCache( nIndex, pValue );
  707. return TRUE;
  708. }
  709. }
  711. return FALSE;
  712. }
  714. //////////////////////////////////////////////////////////////////////
  715. // CATR
  716. CATR::CATR( )
  717. {
  718. SetDefaultParameters( );
  719. }
  721. CATR::CATR( CKData * pKData )
  722. : CTechnique( pKData )
  723. {
  724. SetDefaultParameters( );
  725. }
  727. CATR::~CATR()
  728. {
  729. Clear( );
  730. }
  732. void CATR::SetDefaultParameters( )
  733. {
  734. m_nDays = 14;
  735. m_itsSold = ITS_BUY;
  736. m_itsBought = ITS_SELL;
  737. }
  739. void CATR::AttachParameters( CATR & src )
  740. {
  741. m_nDays = src.m_nDays;
  742. m_itsSold = src.m_itsSold;
  743. m_itsBought = src.m_itsBought;
  744. }
  746. BOOL CATR::IsValidParameters( )
  747. {
  748. return ( VALID_DAYS(m_nDays) && VALID_ITS(m_itsSold) && VALID_ITS(m_itsBought) );
  749. }
  751. void CATR::Clear( )
  752. {
  753. CTechnique::Clear( );
  754. }
  756. int CATR::GetSignal( int nIndex, UINT * pnCode )
  757. {
  758. if( pnCode ) *pnCode = ITSC_NOTHING;
  760. int nMaxDays = m_nDays;
  761. double dLiminalLow = 0, dLiminalHigh = 0;
  762. if( !IntensityPrepare( nIndex, pnCode, nMaxDays, ITS_GETMINMAXDAYRANGE, &dLiminalLow, &dLiminalHigh ) )
  763. return ITS_NOTHING;
  765. double dATR;
  766. if( !Calculate( &dATR, nIndex, FALSE ) )
  767. return ITS_NOTHING;
  769. if( dATR > dLiminalHigh )
  770. { // 超卖
  771. if( pnCode ) *pnCode = ITSC_OVERSOLD;
  772. return m_itsSold;
  773. }
  774. if( dATR < dLiminalLow )
  775. { // 超买
  776. if( pnCode ) *pnCode = ITSC_OVERBOUGHT;
  777. return m_itsBought;
  778. }
  779. return ITS_NOTHING;
  780. }
  782. BOOL CATR::GetMinMaxInfo(int nStart, int nEnd, double *pdMin, double *pdMax )
  783. {
  784. return AfxGetMinMaxInfo1( nStart, nEnd, pdMin, pdMax, this );
  785. }
  787. /***
  788. TR 为以下三者中的最大值
  789. 最高价-最低价，(昨日收盘价-今日最高价)的绝对值，昨日收盘价-昨日最低价
  791. ATR = TR的N日平均
  792. */
  793. BOOL CATR::Calculate( double * pValue, int nIndex, BOOL bUseLast )
  794. {
  795. STT_ASSERT_CALCULATE1( m_pKData, nIndex );
  797. if( m_nDays > nIndex )
  798. return FALSE;
  800. if( LoadFromCache( nIndex, pValue ) )
  801. return TRUE;
  803. double dATR = 0;
  804. int nCount = 0;
  805. for( int k=nIndex; k>=1; k-- )
  806. {
  807. KDATA kd = m_pKData->ElementAt(k);
  808. KDATA kdLast = m_pKData->ElementAt(k-1);
  810. double dTR = fabs(((double)kd.m_fHigh)-kd.m_fLow);
  811. if( fabs(((double)kdLast.m_fClose)-kd.m_fHigh) > dTR )
  812. dTR = fabs(((double)kdLast.m_fClose)-kd.m_fHigh);
  813. if( fabs(((double)kdLast.m_fClose)-kdLast.m_fLow) > dTR )
  814. dTR = fabs(((double)kdLast.m_fClose)-kdLast.m_fLow);
  816. dATR += dTR;
  818. nCount ++;
  819. if( nCount == m_nDays )
  820. {
  821. if( pValue ) *pValue = dATR/m_nDays;
  822. StoreToCache( nIndex, pValue );
  823. return TRUE;
  824. }
  825. }
  826. return FALSE;
  827. }