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

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

金融证券系统

开发平台：

Visual C++

TechEnergy.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. // CVOLUME
  24. CVOLUME::CVOLUME( )
  25. {
  26. SetDefaultParameters( );
  27. }
  29. CVOLUME::CVOLUME( CKData * pKData )
  30. : CTechnique( pKData )
  31. {
  32. SetDefaultParameters( );
  33. }
  35. CVOLUME::~CVOLUME()
  36. {
  37. Clear( );
  38. }
  40. void CVOLUME::SetDefaultParameters( )
  41. {
  42. m_adwMADays.RemoveAll();
  43. m_adwMADays.Add( 5 );
  44. m_adwMADays.Add( 10 );
  45. m_itsDeviateOnBottom = ITS_BUYINTENSE;
  46. m_itsDeviateOnTop = ITS_SELLINTENSE;
  47. m_itsLong = ITS_BUY;
  48. m_itsShort = ITS_SELL;
  49. }
  51. void CVOLUME::AttachParameters( CVOLUME & src )
  52. {
  53. m_adwMADays.Copy( src.m_adwMADays );
  54. m_itsDeviateOnBottom = src.m_itsDeviateOnBottom;
  55. m_itsDeviateOnTop = src.m_itsDeviateOnTop;
  56. m_itsLong = src.m_itsLong;
  57. m_itsShort = src.m_itsShort;
  58. }
  60. BOOL CVOLUME::IsValidParameters( )
  61. {
  62. STT_VALID_DAYSARRAY( m_adwMADays );
  63. return ( VALID_ITS(m_itsDeviateOnBottom) && VALID_ITS(m_itsDeviateOnTop)
  64. && VALID_ITS(m_itsLong) && VALID_ITS(m_itsShort) );
  65. }
  67. void CVOLUME::Clear( )
  68. {
  69. CTechnique::Clear( );
  70. }
  72. int CVOLUME::GetSignal( int nIndex, UINT * pnCode )
  73. {
  74. if( pnCode ) *pnCode = ITSC_NOTHING;
  75. if( !m_pKData || nIndex < 0 || nIndex >= m_pKData->GetSize() )
  76. return ITS_NOTHING;
  78. int nIntensity = GetTrendIntensity( nIndex, m_adwMADays, m_itsLong, m_itsShort, pnCode );
  79. if( ITS_BUY == nIntensity
  80. && m_pKData->IsNewValue( nIndex, FALSE, ITS_DAYS_DEVIATE ) )
  81. { // 底背离，股价创新低并且成交量趋势向上
  82. if( pnCode ) *pnCode = ITSC_DEVIATEONBOTTOM;
  83. return m_itsDeviateOnBottom;
  84. }
  85. if( ITS_SELL == nIntensity
  86. && m_pKData->IsNewValue( nIndex, TRUE, ITS_DAYS_DEVIATE ) )
  87. { // 顶背离，股价创新高并且成交量趋势向下
  88. if( pnCode ) *pnCode = ITSC_DEVIATEONTOP;
  89. return m_itsDeviateOnTop;
  90. }
  92. return nIntensity;
  93. }
  95. BOOL CVOLUME::GetMinMaxInfo(int nStart, int nEnd,
  96.    double *pdMin, double *pdMax )
  97. {
  98. STT_ASSERT_GETMINMAXINFO( m_pKData, nStart, nEnd );
  100. double dMin = 0;
  101. double dMax = 1;
  102. for( int k=nStart; k<=nEnd; k++ )
  103. {
  104. KDATA & kd = m_pKData->ElementAt(k);
  105. if( dMax < kd.m_fVolume )
  106. dMax = (double)kd.m_fVolume;
  107. }
  109. dMax = dMax + 1;
  110. if( dMax - dMin < 3 )
  111. dMax = dMin + 3;
  113. if( pdMin ) *pdMin = dMin;
  114. if( pdMax ) *pdMax = dMax;
  115. return TRUE;
  116. }
  118. /***
  119. 计算nDays的平均成交量
  120. */
  121. BOOL CVOLUME::Calculate( double * pValue, int nIndex, int nDays, BOOL bUseLast )
  122. {
  123. STT_ASSERT_CALCULATE( m_pKData, nIndex, nDays );
  125. int nCount = 0;
  126. if( nDays > nIndex+1 )
  127. return FALSE;
  128. double dResult = 0;
  129. for( int k=nIndex; k>=0; k-- )
  130. {
  131. dResult += m_pKData->ElementAt(k).m_fVolume;
  132. nCount ++;
  133. if( nCount == nDays )
  134. {
  135. if( pValue )
  136. *pValue = dResult / nDays;
  137. return TRUE;
  138. }
  139. }
  140. return FALSE;
  141. }
  143. //////////////////////////////////////////////////////////////////////
  144. // CNVI
  145. CNVI::CNVI( )
  146. {
  147. SetDefaultParameters( );
  148. }
  150. CNVI::CNVI( CKData * pKData )
  151. : CTechnique( pKData )
  152. {
  153. SetDefaultParameters( );
  154. }
  156. CNVI::~CNVI()
  157. {
  158. Clear( );
  159. }
  161. void CNVI::SetDefaultParameters( )
  162. {
  163. m_nMADays = 25;
  164. m_itsGoldenFork = ITS_BUY;
  165. m_itsDeadFork = ITS_SELL;
  166. }
  168. void CNVI::AttachParameters( CNVI & src )
  169. {
  170. m_nMADays = src.m_nMADays;
  171. m_itsGoldenFork = src.m_itsGoldenFork;
  172. m_itsDeadFork = src.m_itsDeadFork;
  173. }
  175. BOOL CNVI::IsValidParameters( )
  176. {
  177. return ( VALID_DAYS( m_nMADays ) && VALID_ITS(m_itsGoldenFork) && VALID_ITS(m_itsDeadFork) );
  178. }
  180. void CNVI::Clear( )
  181. {
  182. CTechnique::Clear( );
  183. }
  185. int CNVI::GetSignal( int nIndex, UINT * pnCode )
  186. {
  187. PrepareCache( 0, -1, FALSE );
  188. // 金叉死叉
  189. return GetForkSignal( nIndex, m_itsGoldenFork, m_itsDeadFork, pnCode );
  190. }
  192. BOOL CNVI::GetMinMaxInfo(int nStart, int nEnd, double *pdMin, double *pdMax )
  193. {
  194. return AfxGetMinMaxInfo2( nStart, nEnd, pdMin, pdMax, this );
  195. }
  197. /***
  198. NVI初值 = 100
  199. 如果今天成交量比昨日小 NVI = 前一日NVI + 100 * 涨跌幅 否则，NVI = 前一天NVI
  200. */
  201. BOOL CNVI::Calculate( double * pValue, double *pMA, int nIndex, BOOL bUseLast )
  202. {
  203. STT_ASSERT_CALCULATE1( m_pKData, nIndex );
  205. // Calculate
  206. if( m_nMADays > nIndex+1 )
  207. return FALSE;
  209. if( LoadFromCache( nIndex, pValue, pMA ) )
  210. return TRUE;
  212. double dValueNew = 0, dMANew = 0;
  213. if( bUseLast && pValue && pMA )
  214. {
  215. if( 0 == nIndex )
  216. dValueNew = 100;
  217. else if( m_pKData->ElementAt(nIndex).m_fVolume < m_pKData->ElementAt(nIndex-1).m_fVolume
  218. && m_pKData->MaindataAt(nIndex-1) > 1e-4 && m_pKData->MaindataAt(nIndex) > 1e-4 )
  219. dValueNew = (*pValue) * m_pKData->MaindataAt(nIndex) / m_pKData->MaindataAt(nIndex-1);
  220. else
  221. dValueNew = *pValue;
  222. dMANew = (*pMA) * (m_nMADays-1) / (m_nMADays+1) + dValueNew * 2 / (m_nMADays+1);
  223. StoreToCache( nIndex, &dValueNew, &dMANew );
  224. }
  225. else
  226. {
  227. for( int k=0; k<=nIndex; k++ )
  228. {
  229. if( 0 == k )
  230. dValueNew = 100;
  231. else if( m_pKData->ElementAt(k).m_fVolume < m_pKData->ElementAt(k-1).m_fVolume
  232. && m_pKData->MaindataAt(k-1) > 1e-4 && m_pKData->MaindataAt(k) > 1e-4 )
  233. dValueNew = dValueNew * m_pKData->MaindataAt(k) / m_pKData->MaindataAt(k-1);
  235. if( 0 == k )
  236. dMANew = dValueNew;
  237. else
  238. dMANew = dMANew * (m_nMADays-1) / (m_nMADays+1) + dValueNew * 2 / (m_nMADays+1);
  240. StoreToCache( k, &dValueNew, &dMANew );
  241. }
  242. }
  244. if( pValue ) *pValue = dValueNew;
  245. if( pMA ) *pMA = dMANew;
  246. return TRUE;
  247. }
  249. //////////////////////////////////////////////////////////////////////
  250. // CPVI
  251. CPVI::CPVI( )
  252. {
  253. SetDefaultParameters( );
  254. }
  256. CPVI::CPVI( CKData * pKData )
  257. : CTechnique( pKData )
  258. {
  259. SetDefaultParameters( );
  260. }
  262. CPVI::~CPVI()
  263. {
  264. Clear( );
  265. }
  267. void CPVI::SetDefaultParameters( )
  268. {
  269. m_nMADays = 25;
  270. m_itsGoldenFork = ITS_BUY;
  271. m_itsDeadFork = ITS_SELL;
  272. }
  274. void CPVI::AttachParameters( CPVI & src )
  275. {
  276. m_nMADays = src.m_nMADays;
  277. m_itsGoldenFork = src.m_itsGoldenFork;
  278. m_itsDeadFork = src.m_itsDeadFork;
  279. }
  281. BOOL CPVI::IsValidParameters( )
  282. {
  283. return ( VALID_DAYS( m_nMADays ) && VALID_ITS(m_itsGoldenFork) && VALID_ITS(m_itsDeadFork) );
  284. }
  286. void CPVI::Clear( )
  287. {
  288. CTechnique::Clear( );
  289. }
  291. int CPVI::GetSignal( int nIndex, UINT * pnCode )
  292. {
  293. PrepareCache( 0, -1, FALSE );
  294. // 金叉死叉
  295. return GetForkSignal( nIndex, m_itsGoldenFork, m_itsDeadFork, pnCode );
  296. }
  298. BOOL CPVI::GetMinMaxInfo(int nStart, int nEnd, double *pdMin, double *pdMax )
  299. {
  300. return AfxGetMinMaxInfo2( nStart, nEnd, pdMin, pdMax, this );
  301. }
  303. /***
  304. PVI初值100
  305. 如果今天成交量比昨日大 PVI = 前一日PVI + 100 * 涨跌幅 否则，PVI = 前一日PVI
  306. */
  307. BOOL CPVI::Calculate( double * pValue, double *pMA, int nIndex, BOOL bUseLast )
  308. {
  309. STT_ASSERT_CALCULATE1( m_pKData, nIndex );
  311. // Calculate
  312. if( m_nMADays > nIndex+1 )
  313. return FALSE;
  315. if( LoadFromCache( nIndex, pValue, pMA ) )
  316. return TRUE;
  318. double dValueNew = 0, dMANew = 0;
  319. if( bUseLast && pValue && pMA )
  320. {
  321. if( 0 == nIndex )
  322. dValueNew = 100;
  323. else if( m_pKData->ElementAt(nIndex).m_fVolume > m_pKData->ElementAt(nIndex-1).m_fVolume
  324. && m_pKData->MaindataAt(nIndex-1) > 1e-4 && m_pKData->MaindataAt(nIndex) > 1e-4 )
  325. dValueNew = (*pValue) * m_pKData->MaindataAt(nIndex) / m_pKData->MaindataAt(nIndex-1);
  326. else
  327. dValueNew = *pValue;
  328. dMANew = (*pMA) * (m_nMADays-1) / (m_nMADays+1) + dValueNew * 2 / (m_nMADays+1);
  329. StoreToCache( nIndex, &dValueNew, &dMANew );
  330. }
  331. else
  332. {
  333. for( int k=0; k<=nIndex; k++ )
  334. {
  335. if( 0 == k )
  336. dValueNew = 100;
  337. else if( m_pKData->ElementAt(k).m_fVolume > m_pKData->ElementAt(k-1).m_fVolume
  338. && m_pKData->MaindataAt(k-1) > 1e-4 && m_pKData->MaindataAt(k) > 1e-4 )
  339. dValueNew = dValueNew * m_pKData->MaindataAt(k) / m_pKData->MaindataAt(k-1);
  341. if( 0 == k )
  342. dMANew = dValueNew;
  343. else
  344. dMANew = dMANew * (m_nMADays-1) / (m_nMADays+1) + dValueNew * 2 / (m_nMADays+1);
  345. StoreToCache( k, &dValueNew, &dMANew );
  346. }
  347. }
  349. if( pValue ) *pValue = dValueNew;
  350. if( pMA ) *pMA = dMANew;
  351. return TRUE;
  352. }
  354. //////////////////////////////////////////////////////////////////////
  355. // CVR
  356. CVR::CVR( )
  357. {
  358. SetDefaultParameters( );
  359. }
  361. CVR::CVR( CKData * pKData )
  362. : CTechnique( pKData )
  363. {
  364. SetDefaultParameters( );
  365. }
  367. CVR::~CVR()
  368. {
  369. Clear( );
  370. }
  372. void CVR::SetDefaultParameters( )
  373. {
  374. m_nDays = 12;
  375. m_itsLong = ITS_BUY;
  376. m_itsShort = ITS_SELL;
  377. }
  379. void CVR::AttachParameters( CVR & src )
  380. {
  381. m_nDays = src.m_nDays;
  382. m_itsLong = src.m_itsLong;
  383. m_itsShort = src.m_itsShort;
  384. }
  386. BOOL CVR::IsValidParameters( )
  387. {
  388. return ( VALID_DAYS(m_nDays) && VALID_ITS(m_itsLong) && VALID_ITS(m_itsShort) );
  389. }
  391. void CVR::Clear( )
  392. {
  393. CTechnique::Clear( );
  394. }
  396. int CVR::GetSignal( int nIndex, UINT * pnCode )
  397. {
  398. if( pnCode ) *pnCode = ITSC_NOTHING;
  399. if( !m_pKData || nIndex < 0 || nIndex >= m_pKData->GetSize() )
  400. return ITS_NOTHING;
  402. int nMaxDays = m_nDays;
  403. double dLiminalLow = 0, dLiminalHigh = 0;
  404. if( !IntensityPrepare( nIndex, pnCode, nMaxDays, ITS_GETMINMAXDAYRANGE, &dLiminalLow, &dLiminalHigh, 0.309, 0.682 ) )
  405. return ITS_NOTHING;
  407. double dNowClose = m_pKData->ElementAt(nIndex).m_fClose;
  409. double dVRNow;
  410. if( !Calculate( &dVRNow, nIndex, FALSE ) )
  411. return ITS_NOTHING;
  413. int nIntensity = GetTrendIntensity1( nIndex, m_itsLong, m_itsShort, pnCode );
  414. if( dVRNow < dLiminalLow && nIntensity == m_itsLong )
  415. { // 低位趋势向上
  416. if( pnCode ) *pnCode = ITSC_LONG;
  417. return m_itsLong;
  418. }
  419. if( dVRNow > dLiminalHigh && nIntensity == m_itsShort )
  420. { // 高位趋势向下
  421. if( pnCode ) *pnCode = ITSC_SHORT;
  422. return m_itsShort;
  423. }
  424. return ITS_NOTHING;
  425. }
  427. BOOL CVR::GetMinMaxInfo(int nStart, int nEnd, double *pdMin, double *pdMax )
  428. {
  429. return AfxGetMinMaxInfo1( nStart, nEnd, pdMin, pdMax, this );
  430. }
  432. /***
  433.      n日中上涨日成交量+1/2最近n日总成交量
  434. VR = ————————————---------—- ×100
  435.      n日中下跌日成交量+1/2最近n日总成交量
  436. */
  437. BOOL CVR::Calculate( double * pValue, int nIndex, BOOL bUseLast )
  438. {
  439. STT_ASSERT_CALCULATE1( m_pKData, nIndex );
  441. if( m_nDays > nIndex )
  442. return FALSE;
  443. if( LoadFromCache( nIndex, pValue ) )
  444. return TRUE;
  446. double dINTV = 0, dDETV = 0, dTV = 0;
  447. int nCount = 0;
  448. for( int k=nIndex; k>=1; k-- )
  449. {
  450. double dAmount = m_pKData->ElementAt(k).m_fVolume;
  451. if( m_pKData->MaindataAt(k) > m_pKData->MaindataAt(k-1) )
  452. dINTV += dAmount;
  453. if( m_pKData->MaindataAt(k) < m_pKData->MaindataAt(k-1) )
  454. dDETV += dAmount;
  455. dTV += dAmount;
  457. nCount ++;
  458. if( nCount == m_nDays )
  459. {
  460. if( dDETV + dTV/2 < 1e-4 )
  461. return FALSE;
  462. if( pValue ) *pValue = (dINTV + dTV/2) * 100 /(dDETV + dTV/2);
  463. StoreToCache( nIndex, pValue );
  464. return TRUE;
  465. }
  466. }
  468. return FALSE;
  469. }
  471. //////////////////////////////////////////////////////////////////////
  472. // CVROC
  473. CVROC::CVROC( )
  474. {
  475. SetDefaultParameters( );
  476. }
  478. CVROC::CVROC( CKData * pKData )
  479. : CTechnique( pKData )
  480. {
  481. SetDefaultParameters( );
  482. }
  484. CVROC::~CVROC()
  485. {
  486. Clear( );
  487. }
  489. void CVROC::SetDefaultParameters( )
  490. {
  491. m_nDays = 10;
  492. m_nMADays = 10;
  493. m_itsDeviateOnBottom = ITS_BUY;
  494. m_itsDeviateOnTop = ITS_SELL;
  495. }
  497. void CVROC::AttachParameters( CVROC & src )
  498. {
  499. m_nDays = src.m_nDays;
  500. m_nMADays = src.m_nMADays;
  501. m_itsDeviateOnBottom = src.m_itsDeviateOnBottom;
  502. m_itsDeviateOnTop = src.m_itsDeviateOnTop;
  503. }
  505. BOOL CVROC::IsValidParameters( )
  506. {
  507. return ( VALID_DAYS(m_nDays) && VALID_DAYS(m_nMADays)
  508. && VALID_ITS(m_itsDeviateOnBottom) && VALID_ITS(m_itsDeviateOnTop) );
  509. }
  511. void CVROC::Clear( )
  512. {
  513. CTechnique::Clear( );
  514. }
  516. int CVROC::GetSignal( int nIndex, UINT * pnCode )
  517. {
  518. if( pnCode ) *pnCode = ITSC_NOTHING;
  520. int nMaxDays = m_nDays+m_nMADays;
  521. double dLiminalLow = 0, dLiminalHigh = 0;
  522. if( !IntensityPrepare( nIndex, pnCode, nMaxDays, ITS_GETMINMAXDAYRANGE, &dLiminalLow, &dLiminalHigh ) )
  523. return ITS_NOTHING;
  525. if( IsDeviateOnBottom( nIndex, m_pdCache1, m_pdCache2 ) )
  526. { // 底背离
  527. if( pnCode ) *pnCode = ITSC_DEVIATEONBOTTOM;
  528. return m_itsDeviateOnBottom;
  529. }
  530. if( IsDeviateOnTop( nIndex, m_pdCache1, m_pdCache2 ) )
  531. { // 顶背离
  532. if( pnCode ) *pnCode = ITSC_DEVIATEONTOP;
  533. return m_itsDeviateOnTop;
  534. }
  536. return ITS_NOTHING;
  537. }
  539. BOOL CVROC::GetMinMaxInfo(int nStart, int nEnd, double *pdMin, double *pdMax )
  540. {
  541. return AfxGetMinMaxInfo2( nStart, nEnd, pdMin, pdMax, this );
  542. }
  544. /***
  545.           今日成交量-n日前成交量
  546. VROC =   ---------------------- * 100
  547.               今日成交量
  548. */
  549. BOOL CVROC::Calculate( double * pValue, int nIndex, BOOL bUseLast )
  550. {
  551. STT_ASSERT_CALCULATE1( m_pKData, nIndex );
  553. if( m_nDays > nIndex )
  554. return FALSE;
  555. if( LoadFromCache( nIndex, pValue ) )
  556. return TRUE;
  558. if( m_pKData->ElementAt(nIndex-m_nDays).m_fVolume <= 0
  559. || m_pKData->ElementAt(nIndex).m_fVolume <= 0 )
  560. return FALSE;
  562. double x = m_pKData->ElementAt(nIndex).m_fVolume;
  563. double y = m_pKData->ElementAt(nIndex-m_nDays).m_fVolume;
  564. if( pValue )
  565. *pValue = (x - y) * 100 / y;
  566. StoreToCache( nIndex, pValue );
  567. return TRUE;
  568. }
  570. BOOL CVROC::Calculate( double * pValue, double * pMA, int nIndex, BOOL bUseLast )
  571. {
  572. return CalculateMA( pValue, pMA, nIndex, bUseLast, m_nMADays );
  573. }
  575. //////////////////////////////////////////////////////////////////////
  576. // COBV
  577. COBV::COBV( )
  578. {
  579. SetDefaultParameters( );
  580. }
  582. COBV::COBV( CKData * pKData )
  583. : CTechnique( pKData )
  584. {
  585. SetDefaultParameters( );
  586. }
  588. COBV::~COBV()
  589. {
  590. Clear( );
  591. }
  593. void COBV::SetDefaultParameters( )
  594. {
  595. m_itsDeviateOnBottom = ITS_BUY;
  596. m_itsDeviateOnTop = ITS_SELL;
  597. }
  599. void COBV::AttachParameters( COBV & src )
  600. {
  601. m_itsDeviateOnBottom = src.m_itsDeviateOnBottom;
  602. m_itsDeviateOnTop = src.m_itsDeviateOnTop;
  603. }
  605. BOOL COBV::IsValidParameters( )
  606. {
  607. return ( VALID_ITS(m_itsDeviateOnBottom) && VALID_ITS(m_itsDeviateOnTop) );
  608. }
  610. void COBV::Clear( )
  611. {
  612. CTechnique::Clear( );
  613. }
  615. int COBV::GetSignal( int nIndex, UINT * pnCode )
  616. {
  617. if( pnCode ) *pnCode = ITSC_NOTHING;
  618. PrepareCache( 0, -1, FALSE );
  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 COBV::GetMinMaxInfo(int nStart, int nEnd, double *pdMin, double *pdMax )
  635. {
  636. return AfxGetMinMaxInfo1( nStart, nEnd, pdMin, pdMax, this );
  637. }
  639. /***
  640. 当日收盘价比前一日收盘价高，其成交量记为正数
  641. 当日收盘价较前一日收盘价低，其成交量记为负数
  642. 累计每日之正或负成交量，即得OBV值
  643. */
  644. BOOL COBV::Calculate( double * pValue, int nIndex, BOOL bUseLast )
  645. {
  646. STT_ASSERT_CALCULATE1( m_pKData, nIndex );
  648. if( LoadFromCache( nIndex, pValue ) )
  649. return TRUE;
  651. // Calculate
  652. double dValueNew = 0;
  653. if( bUseLast && pValue )
  654. {
  655. if( 0 == nIndex )
  656. dValueNew = m_pKData->ElementAt(nIndex).m_fVolume;
  657. else if( m_pKData->MaindataAt(nIndex) > m_pKData->MaindataAt(nIndex-1) )
  658. dValueNew = *pValue + m_pKData->ElementAt(nIndex).m_fVolume;
  659. else if( m_pKData->MaindataAt(nIndex) < m_pKData->MaindataAt(nIndex-1) )
  660. dValueNew = *pValue - m_pKData->ElementAt(nIndex).m_fVolume;
  661. else
  662. dValueNew = *pValue;
  664. StoreToCache( nIndex, &dValueNew );
  665. }
  666. else
  667. {
  668. for( int k=0; k<=nIndex; k++ )
  669. {
  670. if( 0 == k )
  671. dValueNew = m_pKData->ElementAt(k).m_fVolume;
  672. else if( m_pKData->MaindataAt(k) > m_pKData->MaindataAt(k-1) )
  673. dValueNew += m_pKData->ElementAt(k).m_fVolume;
  674. else if( m_pKData->MaindataAt(k) < m_pKData->MaindataAt(k-1) )
  675. dValueNew -= m_pKData->ElementAt(k).m_fVolume;
  677. StoreToCache( k, &dValueNew );
  678. }
  679. }
  681. if( pValue )
  682. *pValue = dValueNew;
  683. return TRUE;
  684. }
  686. //////////////////////////////////////////////////////////////////////
  687. // CMOBV
  688. CMOBV::CMOBV( )
  689. {
  690. SetDefaultParameters( );
  691. }
  693. CMOBV::CMOBV( CKData * pKData )
  694. : COBV( pKData )
  695. {
  696. SetDefaultParameters( );
  697. }
  699. CMOBV::~CMOBV()
  700. {
  701. Clear( );
  702. }
  704. void CMOBV::SetDefaultParameters( )
  705. {
  706. COBV::SetDefaultParameters();
  707. m_nDays1 = 12;
  708. m_nDays2 = 26;
  709. m_itsGoldenFork = ITS_BUY;
  710. m_itsDeadFork = ITS_SELL;
  711. }
  713. void CMOBV::AttachParameters( CMOBV & src )
  714. {
  715. COBV::AttachParameters( src );
  716. m_nDays1 = src.m_nDays1;
  717. m_nDays2 = src.m_nDays2;
  718. m_itsGoldenFork = src.m_itsGoldenFork;
  719. m_itsDeadFork = src.m_itsDeadFork;
  720. }
  722. BOOL CMOBV::IsValidParameters( )
  723. {
  724. return ( COBV::IsValidParameters()
  725. && VALID_DAYS(m_nDays1) && VALID_DAYS(m_nDays2)
  726. && VALID_ITS(m_itsGoldenFork) && VALID_ITS(m_itsDeadFork) );
  727. }
  729. void CMOBV::Clear( )
  730. {
  731. CTechnique::Clear( );
  732. }
  734. int CMOBV::GetSignal( int nIndex, UINT * pnCode )
  735. {
  736. if( pnCode ) *pnCode = ITSC_NOTHING;
  737. if( !m_pKData || nIndex < 0 || nIndex >= m_pKData->GetSize() )
  738. return ITS_NOTHING;
  740. PrepareCache( 0, -1, FALSE );
  742. int nMaxDays = max( m_nDays1 , m_nDays2 );
  743. double dLiminalLow = 0, dLiminalHigh = 0;
  744. if( !IntensityPreparePrice( nIndex, pnCode, nMaxDays, ITS_GETMINMAXDAYRANGE, &dLiminalLow, &dLiminalHigh, 0.5, 0.5 ) )
  745. return ITS_NOTHING;
  747. double dPriceNow = m_pKData->MaindataAt(nIndex);
  749. if( dPriceNow < dLiminalLow
  750. && ( IsGoldenFork( nIndex, m_pdCache1, m_pdCache2 ) || IsGoldenFork( nIndex, m_pdCache2, m_pdCache3 ) ) )
  751. { // 低位金叉
  752. if( pnCode ) *pnCode = ITSC_GOLDENFORK;
  753. return m_itsGoldenFork;
  754. }
  755. if( dPriceNow > dLiminalHigh
  756. && ( IsDeadFork( nIndex, m_pdCache1, m_pdCache2 ) || IsDeadFork( nIndex, m_pdCache2, m_pdCache3 ) ) )
  757. { // 高位死叉
  758. if( pnCode ) *pnCode = ITSC_DEADFORK;
  759. return m_itsDeadFork;
  760. }
  762. return ITS_NOTHING;
  763. }
  765. BOOL CMOBV::GetMinMaxInfo(int nStart, int nEnd, double *pdMin, double *pdMax )
  766. {
  767. return AfxGetMinMaxInfo3( nStart, nEnd, pdMin, pdMax, this );
  768. }
  770. /***
  771. *pValue1  = 当日OBV
  772. *pValue2  = m_nDays1日OBV平均值
  773. *pValue3  = m_nDays2日OBV平均值
  774. */
  775. BOOL CMOBV::Calculate( double * pValue1, double * pValue2, double * pValue3, int nIndex, BOOL bUseLast )
  776. {
  777. STT_ASSERT_CALCULATE1( m_pKData, nIndex );
  779. int nMaxDays = max(m_nDays1,m_nDays2);
  780. if( nMaxDays > nIndex+1 )
  781. return FALSE;
  783. if( LoadFromCache( nIndex, pValue1, pValue2, pValue3 ) )
  784. return TRUE;
  786. double dOBV = 0, dMOBV1 = 0, dMOBV2 = 0;
  787. int nCount = 0;
  788. BOOL bHasLast = bUseLast;
  789. for( int k=nIndex; k>=0; k-- )
  790. {
  791. double dTemp = 0;
  792. if( bUseLast && nIndex == k && pValue1 )
  793. dTemp = *pValue1;
  794. if( COBV::Calculate( &dTemp, k, bUseLast && nIndex == k && pValue1 ) )
  795. {
  796. if( nIndex == k )
  797. dOBV = dTemp;
  798. if( nCount < m_nDays1 )
  799. dMOBV1 += dTemp;
  800. if( nCount < m_nDays2 )
  801. dMOBV2 += dTemp;
  803. nCount ++;
  804. if( nCount >= m_nDays1 && nCount >= m_nDays2 )
  805. {
  806. if( pValue1 ) *pValue1 = dOBV;
  807. if( pValue2 ) *pValue2 = dMOBV1 / m_nDays1;
  808. if( pValue3 ) *pValue3 = dMOBV2 / m_nDays2;
  809. StoreToCache( nIndex, pValue1, pValue2, pValue3 );
  810. return TRUE;
  811. }
  812. }
  813. }
  815. return FALSE;
  816. }
  818. //////////////////////////////////////////////////////////////////////
  819. // CMFI
  820. CMFI::CMFI( )
  821. {
  822. SetDefaultParameters( );
  823. }
  825. CMFI::CMFI( CKData * pKData )
  826. : CTechnique( pKData )
  827. {
  828. SetDefaultParameters( );
  829. }
  831. CMFI::~CMFI()
  832. {
  833. Clear( );
  834. }
  836. void CMFI::SetDefaultParameters( )
  837. {
  838. m_nDays = 10;
  839. m_itsLong = ITS_BUY;
  840. m_itsShort = ITS_SELL;
  841. }
  843. void CMFI::AttachParameters( CMFI & src )
  844. {
  845. m_nDays = src.m_nDays;
  846. m_itsLong = src.m_itsLong;
  847. m_itsShort = src.m_itsShort;
  848. }
  850. BOOL CMFI::IsValidParameters( )
  851. {
  852. return ( VALID_DAYS(m_nDays) && VALID_ITS(m_itsLong) && VALID_ITS(m_itsShort) );
  853. }
  855. void CMFI::Clear( )
  856. {
  857. CTechnique::Clear( );
  858. }
  860. int CMFI::GetSignal( int nIndex, UINT * pnCode )
  861. {
  862. if( pnCode ) *pnCode = ITSC_NOTHING;
  864. double dValue = 0;
  865. if( !Calculate( &dValue, nIndex, FALSE ) )
  866. return ITS_NOTHING;
  868. if( dValue <= 20 )
  869. { // 低位
  870. if( pnCode ) *pnCode = ITSC_LONG;
  871. return m_itsLong;
  872. }
  873. if( dValue >= 80 )
  874. { // 高位
  875. if( pnCode ) *pnCode = ITSC_SHORT;
  876. return m_itsShort;
  877. }
  878. return ITS_NOTHING;
  879. }
  881. BOOL CMFI::GetMinMaxInfo(int nStart, int nEnd, double *pdMin, double *pdMax )
  882. {
  883. if( pdMin ) *pdMin = 0;
  884. if( pdMax ) *pdMax = 100;
  885. return TRUE;
  886. }
  888. /***
  889. PMF 和 NMF 如下计算：
  891. TP = (High+Low+Close)/3   当日的中间价
  893. PMF = n日内，TP上涨日的 (TP*成交量) 之和。
  894. NMF = n日内，TP下降日的 (TP*成交量) 之和。
  896. MFI = 100 * PMF / (PMF + NMF)
  897. 备注：MR = PMF/NMF
  898. */
  899. BOOL CMFI::Calculate( double * pValue, int nIndex, BOOL bUseLast )
  900. {
  901. STT_ASSERT_CALCULATE1( m_pKData, nIndex );
  903. if( m_nDays > nIndex )
  904. return FALSE;
  906. if( LoadFromCache( nIndex, pValue ) )
  907. return TRUE;
  909. double dPMF = 0, dNMF = 0;
  910. int nCount = 0;
  911. for( int k=nIndex; k>=1; k-- )
  912. {
  913. KDATA kd = m_pKData->ElementAt(k);
  914. KDATA kdLast = m_pKData->ElementAt(k-1);
  915. double dTP = (kd.m_fHigh+kd.m_fLow+kd.m_fClose)/3.;
  916. double dTPLast = (kdLast.m_fHigh+kdLast.m_fLow+kdLast.m_fClose)/3.;
  917. if( dTP > dTPLast )
  918. dPMF += dTP * kd.m_fVolume;
  919. if( dTPLast > dTP )
  920. dNMF += dTP * kd.m_fVolume;
  922. nCount ++;
  923. if( nCount == m_nDays )
  924. {
  925. if( fabs(dPMF+dNMF) < 1e-4 )
  926. return FALSE;
  927. if( pValue ) *pValue = 100 * dPMF / (dPMF + dNMF);
  928. StoreToCache( nIndex, pValue );
  929. return TRUE;
  930. }
  931. }
  933. return FALSE;
  934. }
  936. //////////////////////////////////////////////////////////////////////
  937. // CVMACD
  938. CVMACD::CVMACD( )
  939. {
  940. SetDefaultParameters( );
  941. }
  943. CVMACD::CVMACD( CKData * pKData )
  944. : CMACD( pKData )
  945. {
  946. SetDefaultParameters( );
  947. }
  949. CVMACD::~CVMACD()
  950. {
  951. Clear( );
  952. }
  954. /***
  955. 成交量的MACD
  956. EMA  = 短期移动均值
  957. EMA2 = 长期移动均值
  958. DIF  = 短期移动均值 - 长期移动均值
  959. DEA  = DIF的移动平滑值
  960. 柱状线值 = DIF - DEA
  961. */
  962. BOOL CVMACD::Calculate( double *pdEMA1, double *pdEMA2, double *pdDIF, double *pdDEA,
  963. int nIndex, BOOL bUseLast )
  964. {
  965. STT_ASSERT_CALCULATE1( m_pKData, nIndex );
  967. if( m_nEMA1Days > nIndex+1 || m_nEMA2Days > nIndex+1 || m_nDIFDays > nIndex+1 )
  968. return FALSE;
  970. if( LoadFromCache( nIndex, pdEMA1, pdEMA2, pdDIF, pdDEA ) )
  971. return TRUE;
  973. // Calculate EMA1, EMA2, DIF, DEA
  974. double dEMA1New = 0, dEMA2New = 0, dDIFNew = 0, dDEANew = 0;
  975. if( bUseLast && pdEMA1 && pdEMA2 && pdDEA )
  976. {
  977. dEMA1New = (*pdEMA1)*(m_nEMA1Days-1)/(m_nEMA1Days+1) + 2 * m_pKData->ElementAt(nIndex).m_fVolume/(m_nEMA1Days+1);
  978. dEMA2New = (*pdEMA2)*(m_nEMA2Days-1)/(m_nEMA2Days+1) + 2 * m_pKData->ElementAt(nIndex).m_fVolume/(m_nEMA2Days+1);
  979. dDIFNew = dEMA1New-dEMA2New;
  980. dDEANew = (*pdDEA)*(m_nDIFDays-1)/(m_nDIFDays+1) + 2 * dDIFNew/(m_nDIFDays+1);
  981. }
  982. else
  983. {
  984. double factor1 = 1, factor2 = 1;
  985. for( int k=nIndex; k > 0; k-- )
  986. {
  987. factor1 *= ((double)(m_nEMA1Days-1))/(m_nEMA1Days+1);
  988. factor2 *= ((double)(m_nEMA2Days-1))/(m_nEMA2Days+1);
  989. if( factor1 < 0.001 && factor2 < 0.001 ) // 太久以前的数据影响很小，忽略不计
  990. break;
  991. }
  992. dEMA1New = m_pKData->ElementAt(k).m_fVolume;
  993. dEMA2New = m_pKData->ElementAt(k).m_fVolume;
  994. dDIFNew = dEMA1New - dEMA2New;
  995. dDEANew = dDIFNew;
  996. for( ; k<=nIndex; k++ )
  997. {
  998. dEMA1New = dEMA1New * (m_nEMA1Days-1)/(m_nEMA1Days+1) + 2 * m_pKData->ElementAt(k).m_fVolume/(m_nEMA1Days+1);
  999. dEMA2New = dEMA2New * (m_nEMA2Days-1)/(m_nEMA2Days+1) + 2 * m_pKData->ElementAt(k).m_fVolume/(m_nEMA2Days+1);
  1000. dDIFNew = dEMA1New - dEMA2New;
  1001. dDEANew = dDEANew * (m_nDIFDays-1)/(m_nDIFDays+1) + 2 * dDIFNew / (m_nDIFDays+1);
  1002. }
  1003. }
  1005. if( pdEMA1 ) *pdEMA1 = dEMA1New;
  1006. if( pdEMA2 ) *pdEMA2 = dEMA2New;
  1007. if( pdDIF ) *pdDIF = dDIFNew;
  1008. if( pdDEA ) *pdDEA = dDEANew;
  1009. StoreToCache( nIndex, pdEMA1, pdEMA2, pdDIF, pdDEA );
  1010. return TRUE;
  1011. }
  1013. //////////////////////////////////////////////////////////////////////
  1014. // CWVAD
  1015. CWVAD::CWVAD( )
  1016. {
  1017. SetDefaultParameters( );
  1018. }
  1020. CWVAD::CWVAD( CKData * pKData )
  1021. : CTechnique( pKData )
  1022. {
  1023. SetDefaultParameters( );
  1024. }
  1026. CWVAD::~CWVAD()
  1027. {
  1028. Clear( );
  1029. }
  1031. void CWVAD::SetDefaultParameters( )
  1032. {
  1033. m_nDays = 24;
  1034. m_itsLong = ITS_BUY;
  1035. m_itsShort = ITS_SELL;
  1036. }
  1038. void CWVAD::AttachParameters( CWVAD & src )
  1039. {
  1040. m_nDays = src.m_nDays;
  1041. m_itsLong = src.m_itsLong;
  1042. m_itsShort = src.m_itsShort;
  1043. }
  1045. BOOL CWVAD::IsValidParameters( )
  1046. {
  1047. return ( VALID_DAYS( m_nDays )
  1048. && VALID_ITS(m_itsLong) && VALID_ITS(m_itsShort) );
  1049. }
  1051. void CWVAD::Clear( )
  1052. {
  1053. CTechnique::Clear( );
  1054. }
  1056. int CWVAD::GetSignal( int nIndex, UINT * pnCode )
  1057. {
  1058. if( pnCode ) *pnCode = ITSC_NOTHING;
  1060. int nMaxDays = m_nDays;
  1061. double dLiminalLow = 0, dLiminalHigh = 0;
  1062. if( !IntensityPrepare( nIndex, pnCode, nMaxDays, ITS_GETMINMAXDAYRANGE, &dLiminalLow, &dLiminalHigh ) )
  1063. return ITS_NOTHING;
  1065. if( nIndex <= 0 )
  1066. return ITS_NOTHING;
  1068. double dLast, dNow;
  1069. if( !Calculate( &dLast, nIndex-1, FALSE )
  1070. || !Calculate( &dNow, nIndex, FALSE ) )
  1071. return ITS_NOTHING;
  1073. if( dNow < dLiminalLow )
  1074. { // 低位
  1075. if( pnCode ) *pnCode = ITSC_LONG;
  1076. return m_itsLong;
  1077. }
  1078. if( dNow > dLiminalHigh  )
  1079. { // 高位
  1080. if( pnCode ) *pnCode = ITSC_SHORT;
  1081. return m_itsShort;
  1082. }
  1084. return ITS_NOTHING;
  1085. }
  1087. BOOL CWVAD::GetMinMaxInfo(int nStart, int nEnd, double *pdMin, double *pdMax )
  1088. {
  1089. return AfxGetMinMaxInfo1( nStart, nEnd, pdMin, pdMax, this );
  1090. }
  1092. /***
  1093. A = 当天收盘价 - 当天开盘价
  1094. B = 当天最高价 - 当天最低价
  1095. C = A÷B×V(成交量)
  1096. WVAD = 累计n天的C值
  1097. */
  1098. BOOL CWVAD::Calculate( double * pValue, int nIndex, BOOL bUseLast )
  1099. {
  1100. STT_ASSERT_CALCULATE1( m_pKData, nIndex );
  1102. if( m_nDays > nIndex+1 )
  1103. return FALSE;
  1105. if( LoadFromCache( nIndex, pValue ) )
  1106. return TRUE;
  1108. int nCount = 0;
  1109. double dResult = 0;
  1110. for( int k=nIndex; k>=0; k-- )
  1111. {
  1112. KDATA kd = m_pKData->ElementAt(k);
  1113. if( kd.m_fHigh > kd.m_fLow )
  1114. dResult += (((double)kd.m_fClose) - kd.m_fOpen)*kd.m_fVolume/(((double)kd.m_fHigh)-kd.m_fLow);
  1116. nCount ++;
  1117. if( nCount == m_nDays )
  1118. {
  1119. if( pValue ) *pValue = dResult;
  1120. StoreToCache( nIndex, pValue );
  1121. return TRUE;
  1122. }
  1123. }
  1124. return FALSE;
  1125. }
  1127. //////////////////////////////////////////////////////////////////////
  1128. // CEMV
  1129. CEMV::CEMV( )
  1130. {
  1131. SetDefaultParameters( );
  1132. }
  1134. CEMV::CEMV( CKData * pKData )
  1135. : CTechnique( pKData )
  1136. {
  1137. SetDefaultParameters( );
  1138. }
  1140. CEMV::~CEMV()
  1141. {
  1142. Clear( );
  1143. }
  1145. void CEMV::SetDefaultParameters( )
  1146. {
  1147. m_nDays = 14;
  1148. m_nMADays = 9;
  1149. m_itsGoldenFork = ITS_BUY;
  1150. m_itsGoldenFork = ITS_SELL;
  1151. }
  1153. void CEMV::AttachParameters( CEMV & src )
  1154. {
  1155. m_nDays = src.m_nDays;
  1156. m_nMADays = src.m_nMADays;
  1157. m_itsGoldenFork = src.m_itsGoldenFork;
  1158. m_itsDeadFork = src.m_itsDeadFork;
  1159. }
  1161. BOOL CEMV::IsValidParameters( )
  1162. {
  1163. return ( VALID_DAYS(m_nDays) && VALID_DAYS(m_nMADays)
  1164. && VALID_ITS(m_itsGoldenFork) && VALID_ITS(m_itsDeadFork) );
  1165. }
  1167. void CEMV::Clear( )
  1168. {
  1169. CTechnique::Clear( );
  1170. }
  1172. int CEMV::GetSignal( int nIndex, UINT * pnCode )
  1173. {
  1174. if( pnCode ) *pnCode = ITSC_NOTHING;
  1176. int nMaxDays = m_nDays+m_nMADays;
  1177. double dLiminalLow = 0, dLiminalHigh = 0;
  1178. if( !IntensityPrepare( nIndex, pnCode, nMaxDays, ITS_GETMINMAXDAYRANGE, &dLiminalLow, &dLiminalHigh, 0.5, 0.5 ) )
  1179. return ITS_NOTHING;
  1181. double dEMV;
  1182. if( !Calculate( &dEMV, nIndex, FALSE ) )
  1183. return ITS_NOTHING;
  1185. int nSignal = GetForkSignal( nIndex, m_itsGoldenFork, m_itsDeadFork, pnCode );
  1186. if( dEMV < dLiminalLow && nSignal == m_itsGoldenFork )
  1187. { // 低位金叉
  1188. if( pnCode ) *pnCode = ITSC_GOLDENFORK;
  1189. return m_itsGoldenFork;
  1190. }
  1191. if( dEMV > dLiminalHigh && nSignal == m_itsDeadFork )
  1192. { // 高位死叉
  1193. if( pnCode ) *pnCode = ITSC_DEADFORK;
  1194. return m_itsDeadFork;
  1195. }
  1196. return ITS_NOTHING;
  1197. /*  FROM BOOK */
  1198. /* if( pnCode ) *pnCode = ITSC_NOTHING;
  1200. double dValue;
  1201. if( !Calculate( &dValue, nIndex, FALSE ) )
  1202. return ITS_NOTHING;
  1204. if( dValue > 0 )
  1205. {
  1206. if( pnCode ) *pnCode = ITSC_LONG;
  1207. return m_itsLong;
  1208. }
  1209. if( dValue < 0 )
  1210. {
  1211. if( pnCode ) *pnCode = ITSC_SHORT;
  1212. return m_itsShort;
  1213. }
  1215. return ITS_NOTHING;
  1216. */
  1217. }
  1219. BOOL CEMV::GetMinMaxInfo(int nStart, int nEnd, double *pdMin, double *pdMax )
  1220. {
  1221. return AfxGetMinMaxInfo2( nStart, nEnd, pdMin, pdMax, this );
  1222. }
  1224. /***
  1225. A = （今天最高 + 今天最低）÷ 2
  1226. B = （前一天最高 + 前一天最低）÷2
  1227. C = 今天最高 - 今天最低
  1228. EM = （A-B）×C÷今天成交额
  1229. EMV = 累计n天的EM值
  1230. */
  1231. BOOL CEMV::Calculate( double * pValue, int nIndex, BOOL bUseLast )
  1232. {
  1233. STT_ASSERT_CALCULATE1( m_pKData, nIndex );
  1235. if( m_nDays > nIndex )
  1236. return FALSE;
  1238. if( LoadFromCache( nIndex, pValue ) )
  1239. return TRUE;
  1241. double dEMV = 0;
  1242. int nCount = 0;
  1243. for( int k=nIndex; k>=1; k-- )
  1244. {
  1245. KDATA kd = m_pKData->ElementAt(k);
  1246. KDATA kdLast = m_pKData->ElementAt(k-1);
  1247. if( 0 == kd.m_fVolume )
  1248. return FALSE;
  1249. double dDIF = 0;
  1250. dDIF = (kd.m_fHigh+kd.m_fLow)/2 - (((double)kdLast.m_fHigh)+kdLast.m_fLow)/2;
  1251. dEMV += dDIF * (kd.m_fHigh-kd.m_fLow) / kd.m_fVolume;
  1253. nCount ++;
  1254. if( nCount == m_nDays )
  1255. {
  1256. if( pValue )
  1257. *pValue = dEMV / m_nDays;
  1258. StoreToCache( nIndex, pValue );
  1259. return TRUE;
  1260. }
  1261. }
  1263. return FALSE;
  1264. }
  1266. BOOL CEMV::Calculate( double * pValue, double * pMA, int nIndex, BOOL bUseLast )
  1267. {
  1268. return CalculateMA( pValue, pMA, nIndex, bUseLast, m_nMADays );
  1269. }
  1271. //////////////////////////////////////////////////////////////////////
  1272. // CVRSI
  1273. CVRSI::CVRSI( )
  1274. {
  1275. SetDefaultParameters( );
  1276. }
  1278. CVRSI::CVRSI( CKData * pKData )
  1279. : CTechnique( pKData )
  1280. {
  1281. SetDefaultParameters( );
  1282. }
  1284. CVRSI::~CVRSI()
  1285. {
  1286. Clear( );
  1287. }
  1289. void CVRSI::SetDefaultParameters( )
  1290. {
  1291. m_nDays = 10;
  1292. m_itsDeviateOnBottom = ITS_BUYINTENSE;
  1293. m_itsDeviateOnTop = ITS_SELLINTENSE;
  1294. m_itsSold = ITS_BUY;
  1295. m_itsBought = ITS_SELL;
  1296. }
  1298. void CVRSI::AttachParameters( CVRSI & src )
  1299. {
  1300. m_nDays = src.m_nDays;
  1301. m_itsDeviateOnBottom = src.m_itsDeviateOnBottom;
  1302. m_itsDeviateOnTop = src.m_itsDeviateOnTop;
  1303. m_itsSold = src.m_itsSold;
  1304. m_itsBought = src.m_itsBought;
  1305. }
  1307. BOOL CVRSI::IsValidParameters( )
  1308. {
  1309. return ( VALID_DAYS( m_nDays )
  1310. && VALID_ITS(m_itsDeviateOnBottom) && VALID_ITS(m_itsDeviateOnTop)
  1311. && VALID_ITS(m_itsSold) && VALID_ITS(m_itsBought) );
  1312. }
  1314. void CVRSI::Clear( )
  1315. {
  1316. CTechnique::Clear( );
  1317. }
  1319. int CVRSI::GetSignal( int nIndex, UINT * pnCode )
  1320. {
  1321. if( pnCode ) *pnCode = ITSC_NOTHING;
  1323. int nMaxDays = m_nDays;
  1324. double dLiminalLow = 0, dLiminalHigh = 0;
  1325. if( !IntensityPrepare( nIndex, pnCode, nMaxDays, ITS_GETMINMAXDAYRANGE, &dLiminalLow, &dLiminalHigh ) )
  1326. return ITS_NOTHING;
  1328. double dNow;
  1329. if( !Calculate( &dNow, nIndex, FALSE ) )
  1330. return ITS_NOTHING;
  1332. if( IsDeviateOnBottom( nIndex, m_pdCache1, m_pdCache2 ) )
  1333. { // 底背离
  1334. if( pnCode ) *pnCode = ITSC_DEVIATEONBOTTOM;
  1335. return m_itsDeviateOnBottom;
  1336. }
  1337. if( IsDeviateOnTop( nIndex, m_pdCache1, m_pdCache2 ) )
  1338. { // 顶背离
  1339. if( pnCode ) *pnCode = ITSC_DEVIATEONTOP;
  1340. return m_itsDeviateOnTop;
  1341. }
  1342. if( dNow < dLiminalLow )
  1343. { // 超卖
  1344. if( pnCode ) *pnCode = ITSC_OVERSOLD;
  1345. return m_itsSold;
  1346. }
  1347. if( dNow > dLiminalHigh )
  1348. { // 超买
  1349. if( pnCode ) *pnCode = ITSC_OVERBOUGHT;
  1350. return m_itsBought;
  1351. }
  1353. return ITS_NOTHING;
  1354. }
  1356. BOOL CVRSI::GetMinMaxInfo(int nStart, int nEnd, double *pdMin, double *pdMax )
  1357. {
  1358. if( pdMin ) *pdMin = 0;
  1359. if( pdMax ) *pdMax = 100;
  1360. return TRUE;
  1361. }
  1363. /***
  1364. VP = N日内成交量增加日的平均成交量
  1365. VQ = N日内成交量减少日的平均成交量
  1366. VRSI = 100 * VP / (VP+VQ)
  1367. */
  1368. BOOL CVRSI::Calculate( double * pValue, int nIndex, BOOL bUseLast )
  1369. {
  1370. STT_ASSERT_CALCULATE1( m_pKData, nIndex );
  1372. if( m_nDays > nIndex )
  1373. return FALSE;
  1375. if( LoadFromCache( nIndex, pValue ) )
  1376. return TRUE;
  1378. double dVP = 0, dVQ = 0, dResult = 0;
  1379. int nCount = 0, p = 0, q = 0;
  1380. for( int k=nIndex; k>=1; k-- )
  1381. {
  1382. if( m_pKData->MaindataAt(k) >= m_pKData->MaindataAt(k-1) )
  1383. {
  1384. dVP += m_pKData->ElementAt(k).m_fVolume;
  1385. p ++;
  1386. }
  1387. else
  1388. {
  1389. dVQ += m_pKData->ElementAt(k).m_fVolume;
  1390. q ++;
  1391. }
  1393. nCount ++;
  1394. if( nCount == m_nDays )
  1395. {
  1396. if( p > 0 ) dVP = dVP / p;
  1397. if( q > 0 ) dVQ = dVQ / q;
  1398. if( dVQ < 1e-4 )
  1399. dResult = 100;
  1400. else
  1401. dResult = 100 - 100. / (1 + dVP / dVQ);
  1402. if( pValue ) *pValue = dResult;
  1403. StoreToCache( nIndex, pValue );
  1404. return TRUE;
  1405. }
  1406. }
  1408. return FALSE;
  1409. }
  1411. //////////////////////////////////////////////////////////////////////
  1412. // CNVRSI
  1413. CNVRSI::CNVRSI( )
  1414. {
  1415. SetDefaultParameters( );
  1416. }
  1418. CNVRSI::CNVRSI( CKData * pKData )
  1419. : CVRSI( pKData )
  1420. {
  1421. SetDefaultParameters( );
  1422. }
  1424. CNVRSI::~CNVRSI()
  1425. {
  1426. Clear( );
  1427. }
  1429. /***
  1430. VP = N日内成交量增加日的总成交量
  1431. VQ = N日内成交量减少日的总成交量
  1432. VRSI = 100 * VP / (VP+VQ)
  1433. */
  1434. BOOL CNVRSI::Calculate( double * pValue, int nIndex, BOOL bUseLast )
  1435. {
  1436. STT_ASSERT_CALCULATE1( m_pKData, nIndex );
  1438. if( m_nDays > nIndex )
  1439. return FALSE;
  1441. if( LoadFromCache( nIndex, pValue ) )
  1442. return TRUE;
  1444. double dUV = 0, dV = 0, dResult = 0;
  1445. int nCount = 0;
  1446. for( int k=nIndex; k>=1; k-- )
  1447. {
  1448. if( m_pKData->ElementAt(k).m_fVolume > m_pKData->ElementAt(k-1).m_fVolume )
  1449. dUV += m_pKData->ElementAt(k).m_fVolume;
  1450. dV += m_pKData->ElementAt(k).m_fVolume;
  1452. nCount ++;
  1453. if( nCount == m_nDays )
  1454. {
  1455. if( dV < 1e-4 )
  1456. dResult = 50;
  1457. else
  1458. dResult = 100. * dUV / dV;
  1459. if( pValue ) *pValue = dResult;
  1460. StoreToCache( nIndex, pValue );
  1461. return TRUE;
  1462. }
  1463. }
  1465. return FALSE;
  1466. }
  1468. //////////////////////////////////////////////////////////////////////
  1469. // CAD
  1470. CAD::CAD( )
  1471. {
  1472. SetDefaultParameters( );
  1473. }
  1475. CAD::CAD( CKData * pKData )
  1476. : CTechnique( pKData )
  1477. {
  1478. SetDefaultParameters( );
  1479. }
  1481. CAD::~CAD()
  1482. {
  1483. Clear( );
  1484. }
  1486. void CAD::SetDefaultParameters( )
  1487. {
  1488. m_nDays = 8;
  1489. }
  1491. void CAD::AttachParameters( CAD & src )
  1492. {
  1493. m_nDays = src.m_nDays;
  1494. }
  1496. BOOL CAD::IsValidParameters( )
  1497. {
  1498. return ( VALID_DAYS(m_nDays) );
  1499. }
  1501. void CAD::Clear( )
  1502. {
  1503. CTechnique::Clear( );
  1504. }
  1506. int CAD::GetSignal( int nIndex, UINT * pnCode )
  1507. {
  1508. if( pnCode ) *pnCode = ITSC_NOTHING;
  1509. // 无买卖信号
  1510. return ITS_NOTHING;
  1511. }
  1513. BOOL CAD::GetMinMaxInfo(int nStart, int nEnd, double *pdMin, double *pdMax )
  1514. {
  1515. return AfxGetMinMaxInfo1( nStart, nEnd, pdMin, pdMax, this );
  1516. }
  1518. /***
  1519. A = 当日最高价 - 当日最低价
  1520. B = 2 * 当日收盘价 - 当日最高价 - 当日最低价
  1521. C = 当日成交量 * B / A
  1522. AD = N日内C的总和
  1523. */
  1524. BOOL CAD::Calculate( double * pValue, int nIndex, BOOL bUseLast )
  1525. {
  1526. STT_ASSERT_CALCULATE1( m_pKData, nIndex );
  1528. if( m_nDays > nIndex+1 )
  1529. return FALSE;
  1531. if( LoadFromCache( nIndex, pValue ) )
  1532. return TRUE;
  1534. double dAD = 0;
  1535. int nCount = 0;
  1536. for( int k=nIndex; k>=0; k-- )
  1537. {
  1538. KDATA kd = m_pKData->ElementAt(k);
  1540. if( kd.m_fHigh-kd.m_fLow > 1e-4 )
  1541. dAD += kd.m_fVolume * (((double)kd.m_fClose)-kd.m_fLow-kd.m_fHigh+kd.m_fClose)/(((double)kd.m_fHigh)-kd.m_fLow);
  1543. nCount ++;
  1544. if( nCount == m_nDays )
  1545. {
  1546. if( pValue ) *pValue = dAD;
  1547. StoreToCache( nIndex, pValue );
  1548. return TRUE;
  1549. }
  1550. }
  1552. return FALSE;
  1553. }
  1555. //////////////////////////////////////////////////////////////////////
  1556. // CCI
  1557. CCI::CCI( )
  1558. {
  1559. SetDefaultParameters( );
  1560. }
  1562. CCI::CCI( CKData * pKData )
  1563. : CTechnique( pKData )
  1564. {
  1565. SetDefaultParameters( );
  1566. }
  1568. CCI::~CCI()
  1569. {
  1570. Clear( );
  1571. }
  1573. void CCI::SetDefaultParameters( )
  1574. {
  1575. }
  1577. void CCI::AttachParameters( CCI & src )
  1578. {
  1579. }
  1581. BOOL CCI::IsValidParameters( )
  1582. {
  1583. return TRUE;
  1584. }
  1586. void CCI::Clear( )
  1587. {
  1588. CTechnique::Clear( );
  1589. }
  1591. int CCI::GetSignal( int nIndex, UINT * pnCode )
  1592. {
  1593. if( pnCode ) *pnCode = ITSC_NOTHING;
  1594. // 无买卖信号
  1595. return ITS_NOTHING;
  1596. }
  1598. BOOL CCI::GetMinMaxInfo(int nStart, int nEnd, double *pdMin, double *pdMax )
  1599. {
  1600. return AfxGetMinMaxInfo1( nStart, nEnd, pdMin, pdMax, this );
  1601. }
  1603. /***
  1604. CI = (当日收盘价 - 当日开盘价)/(当日最高价 - 当日最低价)
  1605. */
  1606. BOOL CCI::Calculate( double * pValue, int nIndex, BOOL bUseLast )
  1607. {
  1608. STT_ASSERT_CALCULATE1( m_pKData, nIndex );
  1610. if( LoadFromCache( nIndex, pValue ) )
  1611. return TRUE;
  1613. KDATA kd = m_pKData->ElementAt(nIndex);
  1614. if( kd.m_fHigh-kd.m_fLow < 1e-4)
  1615. return FALSE;
  1616. double dCI = (((double)kd.m_fClose)-kd.m_fOpen)/(((double)kd.m_fHigh)-kd.m_fLow);
  1617. /*
  1618. if( nIndex > 0 )
  1619. {
  1620. KDATA kdLast = m_pKData->ElementAt(nIndex-1);
  1621. if( max(kd.m_fOpen,kd.m_fClose) > kdLast.m_fClose*1.08 && kd.m_fHigh>kdLast.m_fClose)
  1622. dCI += (2.*kd.m_fClose-kd.m_fLow-kdLast.m_fClose)/(((double)kd.m_fHigh)-kdLast.m_fClose);
  1623. if( kd.m_fOpen < kdLast.m_fClose*0.92 )
  1624. dCI += (2.*kd.m_fLow-kd.m_fHigh-kdLast.m_fClose)/(((double)kd.m_fClose)-kd.m_fLow);
  1625. }
  1626. */
  1627. dCI = kd.m_fVolume * dCI;
  1628. if( pValue )
  1629. *pValue = dCI;
  1630. StoreToCache( nIndex, pValue );
  1631. return TRUE;
  1632. }