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

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

金融证券系统

开发平台：

Visual C++

TechCLK.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. // CCYO
  24. CCYO::CCYO( )
  25. {
  26. SetDefaultParameters( );
  27. }
  29. CCYO::CCYO( CKData * pKData )
  30. : CTechnique( pKData )
  31. {
  32. SetDefaultParameters( );
  33. }
  35. CCYO::~CCYO()
  36. {
  37. Clear( );
  38. }
  40. void CCYO::SetDefaultParameters( )
  41. {
  42. m_adwMTMDays.RemoveAll();
  43. m_adwMTMDays.Add( 9 );
  44. m_adwMTMDays.Add( 12 );
  45. m_adwMTMDays.Add( 18 );
  46. m_adwMTMDays.Add( 24 );
  47. m_nMADays = 6;
  48. m_itsGoldenFork = ITS_BUY;
  49. m_itsDeadFork = ITS_SELL;
  50. }
  52. void CCYO::AttachParameters( CCYO & src )
  53. {
  54. m_adwMTMDays.Copy( src.m_adwMTMDays );
  55. m_nMADays = src.m_nMADays;
  56. m_itsGoldenFork = src.m_itsGoldenFork;
  57. m_itsDeadFork = src.m_itsDeadFork;
  58. }
  60. BOOL CCYO::IsValidParameters( )
  61. {
  62. STT_VALID_DAYSARRAY( m_adwMTMDays );
  63. return ( VALID_DAYS(m_nMADays) && VALID_ITS(m_itsGoldenFork) && VALID_ITS(m_itsDeadFork) );
  64. }
  66. void CCYO::Clear( )
  67. {
  68. CTechnique::Clear( );
  69. }
  71. int CCYO::GetSignal( int nIndex, UINT * pnCode )
  72. {
  73. if( pnCode ) *pnCode = ITSC_NOTHING;
  75. int nMaxDays = AfxGetMaxDays( m_adwMTMDays )+m_nMADays;
  76. double dLiminalLow = 0, dLiminalHigh = 0;
  77. if( !IntensityPrepare( nIndex, pnCode, nMaxDays, ITS_GETMINMAXDAYRANGE, &dLiminalLow, &dLiminalHigh, 0.2, 0.6 ) )
  78. return ITS_NOTHING;
  80. if( nIndex <= 1 )
  81. return ITS_NOTHING;
  83. double dValue;
  84. if( !Calculate( &dValue, nIndex, FALSE ) )
  85. return ITS_NOTHING;
  87. int nSignal = GetForkSignal( nIndex, m_itsGoldenFork, m_itsDeadFork, pnCode );
  88. if( dValue < dLiminalLow && nSignal == m_itsGoldenFork )
  89. { // 低位金叉
  90. if( pnCode ) *pnCode = ITSC_GOLDENFORK;
  91. return m_itsGoldenFork;
  92. }
  93. if( dValue > dLiminalHigh && nSignal == m_itsDeadFork )
  94. { // 高位死叉
  95. if( pnCode ) *pnCode = ITSC_DEADFORK;
  96. return m_itsDeadFork;
  97. }
  99. return ITS_NOTHING;
  100. }
  102. BOOL CCYO::GetMinMaxInfo(int nStart, int nEnd,
  103.    double *pdMin, double *pdMax )
  104. {
  105. return AfxGetMinMaxInfo2( nStart, nEnd, pdMin, pdMax, this );
  106. }
  108. /***
  109.        9日MTM + 12日MTM×2 + 18日MTM×3 + 24日MTM×4
  110. CYO = ------------------------------------------------
  111.                            10
  112. */
  113. BOOL CCYO::Calculate( double * pValue, int nIndex, BOOL bUseLast )
  114. {
  115. STT_ASSERT_CALCULATE1( m_pKData, nIndex );
  117. if( LoadFromCache( nIndex, pValue ) )
  118. return TRUE;
  120. UINT nMaxDays = AfxGetMaxDays( m_adwMTMDays );
  121. if( (int)nMaxDays > nIndex )
  122. return FALSE;
  124. double dValue = 0;
  125. int nCount = 0;
  126. for( int m=0; m<m_adwMTMDays.GetSize(); m++ )
  127. {
  128. if( int(nIndex-m_adwMTMDays[m]) < 0 )
  129. return FALSE;
  131. double dMTM = 100;
  132. if( m_pKData->MaindataAt(nIndex-m_adwMTMDays[m]) > 0 )
  133. dMTM = 100. * m_pKData->MaindataAt(nIndex) / m_pKData->MaindataAt(nIndex-m_adwMTMDays[m]);
  135. dValue += dMTM*(m+1);
  136. nCount += (m+1);
  137. }
  139. if( nCount <= 0 )
  140. return FALSE;
  142. dValue = dValue / nCount;
  144. if( pValue )
  145. *pValue = dValue;
  146. StoreToCache( nIndex, pValue );
  147. return TRUE;
  148. }
  150. /***
  151. 计算CYO及其移动平均值
  152. */
  153. BOOL CCYO::Calculate( double * pValue, double * pMA, int nIndex, BOOL bUseLast )
  154. {
  155. return CalculateMA( pValue, pMA, nIndex, bUseLast, m_nMADays );
  156. }
  158. //////////////////////////////////////////////////////////////////////
  159. // CDCYO
  160. CDCYO::CDCYO( )
  161. {
  162. SetDefaultParameters( );
  163. }
  165. CDCYO::CDCYO( CKData * pKData )
  166. : CTechnique( pKData )
  167. {
  168. SetDefaultParameters( );
  169. }
  171. CDCYO::~CDCYO()
  172. {
  173. Clear( );
  174. }
  176. void CDCYO::SetDefaultParameters( )
  177. {
  178. m_adwMTMDays.RemoveAll();
  179. m_adwMTMDays.Add( 9 );
  180. m_adwMTMDays.Add( 12 );
  181. m_adwMTMDays.Add( 18 );
  182. m_adwMTMDays.Add( 24 );
  183. m_nMADays = 6;
  184. m_itsGoldenFork = ITS_BUY;
  185. m_itsDeadFork = ITS_SELL;
  186. }
  188. void CDCYO::AttachParameters( CDCYO & src )
  189. {
  190. m_adwMTMDays.Copy( src.m_adwMTMDays );
  191. m_nMADays = src.m_nMADays;
  192. m_itsGoldenFork = src.m_itsGoldenFork;
  193. m_itsDeadFork = src.m_itsDeadFork;
  194. }
  196. BOOL CDCYO::IsValidParameters( )
  197. {
  198. STT_VALID_DAYSARRAY( m_adwMTMDays );
  199. return ( VALID_DAYS(m_nMADays)
  200. && VALID_ITS(m_itsGoldenFork) && VALID_ITS(m_itsDeadFork) );
  201. }
  203. void CDCYO::Clear( )
  204. {
  205. CTechnique::Clear( );
  206. }
  208. int CDCYO::GetSignal( int nIndex, UINT * pnCode )
  209. {
  210. if( pnCode ) *pnCode = ITSC_NOTHING;
  212. int nMaxDays = AfxGetMaxDays( m_adwMTMDays )+m_nMADays;
  213. double dLiminalLow = 0, dLiminalHigh = 0;
  214. if( !IntensityPrepare( nIndex, pnCode, nMaxDays, ITS_GETMINMAXDAYRANGE, &dLiminalLow, &dLiminalHigh, 0.45, 0.55 ) )
  215. return ITS_NOTHING;
  217. if( nIndex <= 1 )
  218. return ITS_NOTHING;
  220. double dValue;
  221. if( !Calculate( &dValue, nIndex, FALSE ) )
  222. return ITS_NOTHING;
  224. int nSignal = GetForkSignal( nIndex, m_itsGoldenFork, m_itsDeadFork, pnCode );
  225. if( dValue < dLiminalLow && nSignal == m_itsGoldenFork )
  226. { // 低位金叉
  227. if( pnCode ) *pnCode = ITSC_GOLDENFORK;
  228. return m_itsGoldenFork;
  229. }
  230. if( dValue > dLiminalHigh && nSignal == m_itsDeadFork )
  231. { // 高位死叉
  232. if( pnCode ) *pnCode = ITSC_DEADFORK;
  233. return m_itsDeadFork;
  234. }
  236. return ITS_NOTHING;
  237. }
  239. BOOL CDCYO::GetMinMaxInfo(int nStart, int nEnd,
  240.    double *pdMin, double *pdMax )
  241. {
  242. return AfxGetMinMaxInfo2( nStart, nEnd, pdMin, pdMax, this );
  243. }
  245. /***
  246.        9日MTM + 12日MTM×2 + 18日MTM×3 + 24日MTM×4
  247. CYO = ------------------------------------------------
  248.                            10
  249. DCYO = CYO的m_nMADays日平均值
  250. */
  251. BOOL CDCYO::Calculate( double * pValue, int nIndex, BOOL bUseLast )
  252. {
  253. STT_ASSERT_CALCULATE1( m_pKData, nIndex );
  255. if( LoadFromCache( nIndex, pValue ) )
  256. return TRUE;
  258. UINT nMaxDays = AfxGetMaxDays( m_adwMTMDays );
  259. if( (int)nMaxDays > nIndex )
  260. return FALSE;
  262. int nMACount = 0;
  263. double dMA = 0;
  264. for( int k=nIndex; k>=0; k-- )
  265. {
  266. double dValue = 0;
  267. double nCount = 0;
  268. for( int m=0; m<m_adwMTMDays.GetSize(); m++ )
  269. {
  270. if( int(k-m_adwMTMDays[m]) < 0 )
  271. return FALSE;
  273. double dMTM = 100;
  274. if( m_pKData->MaindataAt(k-m_adwMTMDays[m]) > 0 )
  275. dMTM = 100. * m_pKData->MaindataAt(k) / m_pKData->MaindataAt(k-m_adwMTMDays[m]);
  277. dValue += dMTM*(m+1);
  278. nCount += (m+1);
  279. }
  281. if( nCount <= 0 )
  282. return FALSE;
  284. dValue = dValue / nCount;
  286. dMA += dValue;
  287. nMACount ++;
  288. if( nMACount >= m_nMADays )
  289. {
  290. dMA = dMA/m_nMADays;
  291. if( pValue )
  292. *pValue = dMA;
  293. StoreToCache( nIndex, pValue );
  294. return TRUE;
  295. }
  296. }
  297. return FALSE;
  298. }
  300. /***
  301. 计算DCYO及其移动平均值
  302. */
  303. BOOL CDCYO::Calculate( double * pValue, double * pMA, int nIndex, BOOL bUseLast )
  304. {
  305. return CalculateMA( pValue, pMA, nIndex, bUseLast, m_nMADays );
  306. }
  308. //////////////////////////////////////////////////////////////////////
  309. // CHSL
  310. CHSL::CHSL( )
  311. {
  312. SetDefaultParameters( );
  313. }
  315. CHSL::CHSL( CKData * pKData )
  316. : CTechnique( pKData )
  317. {
  318. SetDefaultParameters( );
  319. }
  321. CHSL::~CHSL()
  322. {
  323. Clear( );
  324. }
  326. double CHSL::GetMainChangeHand( DWORD dwMarket, CKData & kdata, int nIndexKD )
  327. {
  328. if( nIndexKD < 0 || nIndexKD >= kdata.GetSize() )
  329. return 0.0;
  331. KDATA kd = kdata.ElementAt(nIndexKD);
  333. // ignore dwMarket
  334. dwMarket = CStock::marketSHSE;
  336. CStock & stockMain = AfxGetStockMain( dwMarket );
  337. CStockInfo & infoMain = stockMain.GetStockInfo();
  338. CKData & kdataMain = stockMain.GetKData( kdata.GetKType() );
  339. int nIndexMain = kdataMain.GetIndexByDate( kd.m_date );
  340. if( nIndexMain < 0 || nIndexMain >= kdataMain.GetSize() )
  341. return 0.0;
  342. KDATA kdMain = kdataMain.ElementAt( nIndexMain );
  344. double dPriceAvg = 0.0;
  345. if( kdMain.m_fVolume > 1 )
  346. dPriceAvg = kdMain.m_fAmount / kdMain.m_fVolume;
  348. double dCapitalValue = 0.0;
  349. if( 0 == strcmp( STKLIB_CODE_MAIN, infoMain.GetStockCode() ) )
  350. {
  351. double dFactor = 5.85 * 1e8;
  352. CSPTime sptime;
  353. if( sptime.FromStockTime( kd.m_date, CKData::IsDayOrMin(kdata.GetKType()) ) )
  354. {
  355. CSPTime tm0(2004,5,19,0,0,0);
  356. CSPTimeSpan span = sptime - tm0;
  358. if( span.GetDays() < -3000 )
  359. {
  360. dFactor *= ( 1 - 0.08*3000.0/365.0);
  361. dFactor *= ( 1 - (-3000 - span.GetDays())/2000.0 );
  362. }
  363. else
  364. {
  365. dFactor *= ( 1 + 0.08*span.GetDays()/365.0 );
  366. }
  367. }
  368. dCapitalValue = dFactor * (kdMain.m_fClose+kdMain.m_fOpen+kdMain.m_fHigh+kdMain.m_fLow)/4;
  369. }
  370. else if( 0 == strcmp( STKLIB_CODE_MAINSZN, infoMain.GetStockCode() ) )
  371. {
  372. // 深证成指
  373. dCapitalValue = 0.41 * 1e8 * (kdMain.m_fClose+kdMain.m_fOpen+kdMain.m_fHigh+kdMain.m_fLow)/4;
  374. }
  376. double dChangeHand = 0.0;
  377. if( dCapitalValue > 1e-6 )
  378. dChangeHand = 100. * kdMain.m_fAmount / dCapitalValue;
  380. return dChangeHand;
  381. }
  383. void CHSL::SetDefaultParameters( )
  384. {
  385. m_nDays = 30;
  386. m_nMADays = 6;
  387. m_itsGoldenFork = ITS_BUY;
  388. m_itsDeadFork = ITS_SELL;
  389. }
  391. void CHSL::AttachParameters( CHSL & src )
  392. {
  393. m_nDays = src.m_nDays;
  394. m_nMADays = src.m_nMADays;
  395. m_itsGoldenFork = src.m_itsGoldenFork;
  396. m_itsDeadFork = src.m_itsDeadFork;
  397. }
  399. BOOL CHSL::IsValidParameters( )
  400. {
  401. return ( VALID_DAYS(m_nDays) && VALID_DAYS(m_nMADays) && VALID_ITS(m_itsGoldenFork) && VALID_ITS(m_itsDeadFork) );
  402. }
  404. void CHSL::Clear( )
  405. {
  406. CTechnique::Clear( );
  407. }
  409. int CHSL::GetSignal( int nIndex, UINT * pnCode )
  410. {
  411. if( pnCode ) *pnCode = ITSC_NOTHING;
  412. return ITS_NOTHING;
  413. }
  415. BOOL CHSL::GetMinMaxInfo(int nStart, int nEnd,
  416.    double *pdMin, double *pdMax )
  417. {
  418. return AfxGetMinMaxInfo1( nStart, nEnd, pdMin, pdMax, this );
  419. }
  421. /***
  422. 相对换手率
  423. */
  424. BOOL CHSL::Calculate( double * pValue, int nIndex, BOOL bUseLast )
  425. {
  426. STT_ASSERT_CALCULATE1( m_pKData, nIndex );
  428. if( LoadFromCache( nIndex, pValue ) )
  429. return TRUE;
  431. double dRatioChangeHand = 0;
  432. double dVolume = m_pKData->ElementAt(nIndex).m_fVolume;
  433. if( m_stockinfo.IsValidStock() && m_stockinfo.GetRatioChangeHand( &dRatioChangeHand, dVolume ) )
  434. {
  435. // 相对换手率
  436. double dMainChangeHand = GetMainChangeHand( m_stockinfo.GetMarket(), *m_pKData, nIndex );
  437. double dRelativeChangeHand = 1.0;
  438. if( dMainChangeHand > 1e-6 )
  439. {
  440. dRelativeChangeHand = dRatioChangeHand / dMainChangeHand;
  441. if( pValue )
  442. *pValue = dRelativeChangeHand;
  443. StoreToCache( nIndex, pValue );
  444. return TRUE;
  445. }
  446. }
  447. else
  448. {
  449. if( pValue )
  450. *pValue = 1.0;
  451. StoreToCache( nIndex, pValue );
  452. return TRUE;
  453. }
  455. return FALSE;
  456. }
  458. /***
  459. 计算HSL及其移动平均值
  460. */
  461. BOOL CHSL::Calculate( double * pValue, int nIndex, int nDays, BOOL bUseLast )
  462. {
  463. STT_ASSERT_CALCULATE1( m_pKData, nIndex );
  465. if( nDays > nIndex+1 )
  466. return FALSE;
  468. double dValue = 0, dMA = 0;
  469. int nCount = 0;
  470. for( int k=nIndex; k>=0; k-- )
  471. {
  472. double dTemp = 0;
  473. if( Calculate( &dTemp, k, FALSE ) )
  474. {
  475. if( nIndex == k )
  476. dValue = dTemp;
  477. dMA += dTemp;
  479. nCount ++;
  480. if( nCount == nDays )
  481. {
  482. dMA = dMA / nDays;
  483. if( pValue ) *pValue = dMA;
  484. return TRUE;
  485. }
  486. }
  487. }
  488. return FALSE;
  489. }
  491. //////////////////////////////////////////////////////////////////////
  492. // CDPER
  493. CDPER::CDPER( )
  494. {
  495. SetDefaultParameters( );
  496. }
  498. CDPER::CDPER( CKData * pKData )
  499. : CTechnique( pKData )
  500. {
  501. SetDefaultParameters( );
  502. }
  504. CDPER::~CDPER()
  505. {
  506. Clear( );
  507. }
  509. void CDPER::SetDefaultParameters( )
  510. {
  511. m_nDays = 30;
  512. m_nMADays = 6;
  513. m_nDetrendDays = 12;
  514. m_itsGoldenFork = ITS_BUY;
  515. m_itsDeadFork = ITS_SELL;
  516. }
  518. void CDPER::AttachParameters( CDPER & src )
  519. {
  520. m_nDays = src.m_nDays;
  521. m_nMADays = src.m_nMADays;
  522. m_nDetrendDays = src.m_nDetrendDays;
  523. m_itsGoldenFork = src.m_itsGoldenFork;
  524. m_itsDeadFork = src.m_itsDeadFork;
  525. }
  527. BOOL CDPER::IsValidParameters( )
  528. {
  529. return ( VALID_DAYS(m_nDays) && VALID_DAYS(m_nMADays) && VALID_DAYS(m_nDetrendDays)
  530. && VALID_ITS(m_itsGoldenFork) && VALID_ITS(m_itsDeadFork) );
  531. }
  533. void CDPER::Clear( )
  534. {
  535. CTechnique::Clear( );
  536. }
  538. int CDPER::GetSignal( int nIndex, UINT * pnCode )
  539. {
  540. if( pnCode ) *pnCode = ITSC_NOTHING;
  542. int nMaxDays = m_nDays+m_nMADays+m_nDetrendDays;
  543. double dLiminalLow = 0, dLiminalHigh = 0;
  544. if( !IntensityPrepare( nIndex, pnCode, nMaxDays, ITS_GETMINMAXDAYRANGE, &dLiminalLow, &dLiminalHigh, 0.15, 0.7 ) )
  545. return ITS_NOTHING;
  547. if( nIndex <= 1 )
  548. return ITS_NOTHING;
  550. double dValue;
  551. if( !Calculate( &dValue, nIndex, FALSE ) )
  552. return ITS_NOTHING;
  554. int nSignal = GetForkSignal( nIndex, m_itsGoldenFork, m_itsDeadFork, pnCode );
  555. if( dValue < dLiminalLow && nSignal == m_itsGoldenFork )
  556. { // 低位金叉
  557. if( pnCode ) *pnCode = ITSC_GOLDENFORK;
  558. return m_itsGoldenFork;
  559. }
  560. if( dValue > dLiminalHigh && nSignal == m_itsDeadFork )
  561. { // 高位死叉
  562. if( pnCode ) *pnCode = ITSC_DEADFORK;
  563. return m_itsDeadFork;
  564. }
  566. return ITS_NOTHING;
  567. }
  569. BOOL CDPER::GetMinMaxInfo(int nStart, int nEnd,
  570.    double *pdMin, double *pdMax )
  571. {
  572. if( pdMin ) *pdMin = 0;
  573. if( pdMax ) *pdMax = 100;
  574. return TRUE;
  575. }
  577. /***
  578. A = 今日收盘价 - （m_nDetrendDays+m_nDetrendDays）日的平均收盘价
  579.        N日内A小于今日A的天数
  580. DPER = ----------------------
  581.                 N
  583. */
  584. BOOL CDPER::Calculate( double * pValue, int nIndex, BOOL bUseLast )
  585. {
  586. STT_ASSERT_CALCULATE1( m_pKData, nIndex );
  588. if( m_nDays+m_nDetrendDays > nIndex+1 )
  589. return FALSE;
  591. if( LoadFromCache( nIndex, pValue ) )
  592. return TRUE;
  594. double dNow = 0;
  595. int nCount = 0;
  596. double dCountLow = 0;
  597. for( int k=nIndex; k>=0; k-- )
  598. {
  599. double dCur = 0;
  601. double dCt = 0, dMA = 0;
  602. double nDetrendCount = 0;
  603. for( int l=k-1; l>=0; l-- )
  604. {
  605. dMA += m_pKData->MaindataAt(l);
  607. nDetrendCount ++;
  608. if( nDetrendCount == m_nDetrendDays+m_nDetrendDays )
  609. {
  610. dCt = m_pKData->MaindataAt(k);
  611. dMA = dMA / (m_nDetrendDays+m_nDetrendDays);
  612. dCur = dCt - dMA;
  613. break;
  614. }
  615. }
  617. if( nIndex == k )
  618. {
  619. dNow = dCur;
  620. continue;
  621. }
  624. if( dCur < dNow )
  625. dCountLow += 1;
  627. nCount ++;
  628. if( nCount >= m_nDays )
  629. {
  630. if( pValue )
  631. *pValue = 100. * dCountLow / m_nDays;
  632. StoreToCache( nIndex, pValue );
  633. return TRUE;
  634. }
  635. }
  637. return FALSE;
  638. }
  640. /***
  641. 计算CYO及其移动平均值
  642. */
  643. BOOL CDPER::Calculate( double * pValue, double * pMA, int nIndex, BOOL bUseLast )
  644. {
  645. return CalculateMA( pValue, pMA, nIndex, bUseLast, m_nMADays );
  646. }