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

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

金融证券系统

开发平台：

Visual C++

TechKLine.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. // CKLine
  24. CKLine::CKLine( )
  25. {
  26. SetDefaultParameters( );
  27. }
  29. CKLine::CKLine( CKData * pKData )
  30. : CTechnique( pKData )
  31. {
  32. SetDefaultParameters( );
  33. }
  35. CKLine::~CKLine()
  36. {
  37. Clear( );
  38. }
  40. void CKLine::SetDefaultParameters( )
  41. {
  42. }
  44. void CKLine::AttachParameters( CKLine & src )
  45. {
  46. }
  48. BOOL CKLine::IsValidParameters( )
  49. {
  50. return TRUE;
  51. }
  53. void CKLine::Clear( )
  54. {
  55. CTechnique::Clear( );
  56. }
  58. /***
  59. 得到K线价格的从nStart到nEnd的最小值和最大值
  60. */
  61. BOOL CKLine::GetMinMaxInfo( int nStart, int nEnd, double *pdMin, double *pdMax )
  62. {
  63. STT_ASSERT_GETMINMAXINFO( m_pKData, nStart, nEnd );
  65. double dMin = -1;
  66. double dMax = 1;
  67. for( int k=nStart; k<=nEnd; k++ )
  68. {
  69. KDATA & kd = m_pKData->ElementAt(k);
  70. if( nStart == k || dMin > kd.m_fLow ) dMin = (double)kd.m_fLow;
  71. if( nStart == k || dMax < kd.m_fHigh ) dMax = (double)kd.m_fHigh;
  72. }
  73. dMin -= fabs(dMin) * 0.01;
  74. dMax += fabs(dMax) * 0.01;
  75. if( dMin <= 0 )
  76. dMin = 0;
  77. if( dMax - dMin < 0.03 )
  78. dMax = dMin + 0.03;
  80. if( pdMin ) *pdMin = dMin;
  81. if( pdMax ) *pdMax = dMax;
  82. return TRUE;
  83. }
  85. //////////////////////////////////////////////////////////////////////
  86. // CMA
  87. CMA::CMA( )
  88. {
  89. SetDefaultParameters( );
  90. }
  92. CMA::CMA( CKData * pKData )
  93. : CTechnique( pKData )
  94. {
  95. SetDefaultParameters( );
  96. }
  98. CMA::~CMA()
  99. {
  100. Clear( );
  101. }
  103. void CMA::SetDefaultParameters( )
  104. {
  105. m_nType = typeMA;
  106. m_adwMADays.RemoveAll();
  107. m_adwMADays.Add( 5 );
  108. m_adwMADays.Add( 10 );
  109. m_adwMADays.Add( 20 );
  110. m_itsGoldenFork = ITS_BUYINTENSE;
  111. m_itsDeadFork = ITS_SELLINTENSE;
  112. m_itsLong = ITS_BUY;
  113. m_itsShort = ITS_SELL;
  114. }
  116. void CMA::AttachParameters( CMA & src )
  117. {
  118. m_nType = src.m_nType;
  119. m_adwMADays.Copy( src.m_adwMADays );
  120. m_itsGoldenFork = src.m_itsGoldenFork;
  121. m_itsDeadFork = src.m_itsDeadFork;
  122. m_itsLong = src.m_itsLong;
  123. m_itsShort = src.m_itsShort;
  124. }
  126. BOOL CMA::IsValidParameters( )
  127. {
  128. STT_VALID_DAYSARRAY( m_adwMADays );
  129. return ( (typeMA == m_nType || typeEXPMA == m_nType)
  130. && VALID_ITS(m_itsGoldenFork) && VALID_ITS(m_itsDeadFork)
  131. && VALID_ITS(m_itsLong) && VALID_ITS(m_itsShort) );
  132. }
  134. void CMA::Clear( )
  135. {
  136. CTechnique::Clear( );
  137. }
  139. int CMA::GetSignal( int nIndex, UINT * pnCode )
  140. {
  141. // 金叉或者死叉
  142. int nSignal = GetForkSignal( nIndex, m_adwMADays, m_itsGoldenFork, m_itsDeadFork, pnCode );
  143. if( ITS_ISBUY(nSignal) || ITS_ISSELL(nSignal) )
  144. return nSignal;
  145. // 趋势
  146. return GetTrendIntensity( nIndex, m_adwMADays, m_itsLong, m_itsShort, pnCode );
  147. }
  149. BOOL CMA::GetMinMaxInfo(int nStart, int nEnd,
  150.    double *pdMin, double *pdMax )
  151. {
  152. return AfxGetMinMaxInfo( nStart, nEnd, pdMin, pdMax, this, m_adwMADays );
  153. }
  155. /***
  156. 两种：
  157. 1. MA
  158.     MA = n日收盘价的平均值
  159. 2. EXPMA
  160.     EXPMA(1) = CLOSE(1)
  161. EXPMA(i) = (1-α)EXPMA(i-1) + αCLOSE(i)
  162. 其中 α = 2 / (n+1)
  163. */
  164. BOOL CMA::Calculate( double * pValue, int nIndex, int nDays, BOOL bUseLast )
  165. {
  166. STT_ASSERT_CALCULATE( m_pKData, nIndex, nDays );
  168. int nCount = 0;
  169. if( nDays > nIndex+1 )
  170. return FALSE;
  172. double dResult = 0;
  173. int k = 0;
  174. switch( m_nType )
  175. {
  176. case typeMA:
  177. return m_pKData->GetMA( pValue, nIndex, nDays );
  178. break;
  179. case typeEXPMA:
  180. if( bUseLast && pValue )
  181. {
  182. if( 0 == nIndex )
  183. dResult = m_pKData->MaindataAt(nIndex);
  184. else
  185. dResult = (*pValue)*(nDays-1)/(nDays+1) + m_pKData->MaindataAt(nIndex) * 2./(nDays+1);
  186. }
  187. else
  188. {
  189. for( k=0; k<=nIndex; k++ )
  190. {
  191. if( 0 == k )
  192. dResult = m_pKData->MaindataAt(k);
  193. else
  194. dResult = dResult*(nDays-1)/(nDays+1) + m_pKData->MaindataAt(k) * 2./(nDays+1);
  195. }
  196. }
  197. if( pValue )
  198. *pValue = dResult;
  199. break;
  200. default:
  201. SP_ASSERT( FALSE );
  202. }
  203. return TRUE;
  204. }
  206. //////////////////////////////////////////////////////////////////////
  207. // CBBI
  208. CBBI::CBBI( )
  209. {
  210. SetDefaultParameters( );
  211. }
  213. CBBI::CBBI( CKData * pKData )
  214. : CTechnique( pKData )
  215. {
  216. SetDefaultParameters( );
  217. }
  219. CBBI::~CBBI()
  220. {
  221. Clear( );
  222. }
  224. void CBBI::SetDefaultParameters( )
  225. {
  226. m_nMA1Days = 3;
  227. m_nMA2Days = 6;
  228. m_nMA3Days = 12;
  229. m_nMA4Days = 24;
  230. m_itsGoldenFork = ITS_BUY;
  231. m_itsDeadFork = ITS_SELL;
  232. }
  234. void CBBI::AttachParameters( CBBI & src )
  235. {
  236. m_nMA1Days = src.m_nMA1Days;
  237. m_nMA2Days = src.m_nMA2Days;
  238. m_nMA3Days = src.m_nMA3Days;
  239. m_nMA4Days = src.m_nMA4Days;
  240. m_itsGoldenFork = src.m_itsGoldenFork;
  241. m_itsDeadFork = src.m_itsDeadFork;
  242. }
  244. BOOL CBBI::IsValidParameters( )
  245. {
  246. return ( VALID_DAYS( m_nMA1Days ) && VALID_DAYS( m_nMA2Days )
  247. && VALID_DAYS( m_nMA3Days ) && VALID_DAYS( m_nMA4Days )
  248. && VALID_ITS(m_itsGoldenFork) && VALID_ITS(m_itsDeadFork) );
  249. }
  251. void CBBI::Clear( )
  252. {
  253. CTechnique::Clear( );
  254. }
  256. int CBBI::GetSignal( int nIndex, UINT * pnCode )
  257. {
  258. if( pnCode ) *pnCode = ITSC_NOTHING;
  259. if( nIndex <= 0 )
  260. return ITS_NOTHING;
  262. double dLiminalLow = 0, dLiminalHigh = 0;
  263. if( !IntensityPreparePrice( nIndex, pnCode, 0, ITS_GETMINMAXDAYRANGE, &dLiminalLow, &dLiminalHigh, 0.4, 0.6 ) )
  264. return ITS_NOTHING;
  266. double dBBINow = 0, dBBILast = 0;
  267. if( !Calculate( &dBBILast, nIndex-1, FALSE )
  268. || !Calculate( &dBBINow, nIndex, FALSE ) )
  269. return ITS_NOTHING;
  271. double dNowHigh = m_pKData->ElementAt(nIndex).m_fHigh;
  272. double dNowLow = m_pKData->ElementAt(nIndex).m_fLow;
  273. double dNowClose = m_pKData->ElementAt(nIndex).m_fClose;
  274. double dLastHigh = m_pKData->ElementAt(nIndex-1).m_fHigh;
  275. double dLastLow = m_pKData->ElementAt(nIndex-1).m_fLow;
  276. double dLastClose = m_pKData->ElementAt(nIndex-1).m_fClose;
  278. if( dNowClose < dLiminalLow && dLastLow < dBBILast && dNowLow > dBBINow )
  279. { // 低位趋势向上
  280. if( pnCode ) *pnCode = ITSC_GOLDENFORK;
  281. return m_itsGoldenFork;
  282. }
  283. if( dNowClose > dLiminalHigh && dLastHigh > dBBILast && dNowHigh < dBBINow )
  284. { // 高位趋势向下
  285. if( pnCode ) *pnCode = ITSC_DEADFORK;
  286. return m_itsDeadFork;
  287. }
  288. return ITS_NOTHING;
  289. }
  291. BOOL CBBI::GetMinMaxInfo(int nStart, int nEnd,
  292.    double *pdMin, double *pdMax )
  293. {
  294. return AfxGetMinMaxInfo1( nStart, nEnd, pdMin, pdMax, this );
  295. }
  297. /***
  298. BBI = 4 个 不同日期的MA 的平均值
  299. */
  300. BOOL CBBI::Calculate( double * pValue, int nIndex, BOOL bUseLast )
  301. {
  302. STT_ASSERT_CALCULATE1( m_pKData, nIndex );
  304. if( LoadFromCache( nIndex, pValue ) )
  305. return TRUE;
  307. double dResult = 0;
  308. double dTemp = 0;
  310. if( !m_pKData->GetMA( &dTemp, nIndex, m_nMA1Days ) )
  311. return FALSE;
  312. dResult += dTemp;
  314. if( !m_pKData->GetMA( &dTemp, nIndex, m_nMA2Days ) )
  315. return FALSE;
  316. dResult += dTemp;
  318. if( !m_pKData->GetMA( &dTemp, nIndex, m_nMA3Days ) )
  319. return FALSE;
  320. dResult += dTemp;
  322. if( !m_pKData->GetMA( &dTemp, nIndex, m_nMA4Days ) )
  323. return FALSE;
  324. dResult += dTemp;
  326. dResult = dResult / 4;
  327. if( pValue )
  328. *pValue = dResult;
  330. StoreToCache( nIndex, pValue );
  331. return TRUE;
  332. }
  334. //////////////////////////////////////////////////////////////////////
  335. // CBOLL
  336. CBOLL::CBOLL( )
  337. {
  338. SetDefaultParameters( );
  339. }
  341. CBOLL::CBOLL( CKData * pKData )
  342. : CTechnique( pKData )
  343. {
  344. SetDefaultParameters( );
  345. }
  347. CBOLL::~CBOLL()
  348. {
  349. Clear( );
  350. }
  352. void CBOLL::SetDefaultParameters( )
  353. {
  354. m_dMultiUp = 2;
  355. m_dMultiDown = 2;
  356. m_nMADays = 20;
  357. m_itsSupport = ITS_BUY;
  358. m_itsResistance = ITS_SELL;
  359. }
  361. void CBOLL::AttachParameters( CBOLL & src )
  362. {
  363. m_dMultiUp = src.m_dMultiUp;
  364. m_dMultiDown = src.m_dMultiDown;
  365. m_nMADays = src.m_nMADays;
  366. m_itsSupport = src.m_itsSupport;
  367. m_itsResistance = src.m_itsResistance;
  368. }
  370. BOOL CBOLL::IsValidParameters( )
  371. {
  372. return ( m_dMultiUp > 0 && m_dMultiDown > 0 && VALID_DAYS( m_nMADays )
  373. && VALID_ITS(m_itsSupport) && VALID_ITS(m_itsResistance) );
  374. }
  376. void CBOLL::Clear( )
  377. {
  378. CTechnique::Clear( );
  379. }
  381. int CBOLL::GetSignal( int nIndex, UINT * pnCode )
  382. {
  383. if( pnCode ) *pnCode = ITSC_NOTHING;
  385. double dMA = 0, dUp = 0, dDown = 0;
  386. if( !Calculate( &dMA, &dUp, &dDown, nIndex, FALSE ) )
  387. return ITS_NOTHING;
  389. double dClose = m_pKData->ElementAt(nIndex).m_fClose;
  391. if( dClose < dDown )
  392. { // 跌破支撑位
  393. if( pnCode ) *pnCode = ITSC_SUPPORT;
  394. return m_itsSupport;
  395. }
  396. if( dClose > dUp )
  397. { // 涨过阻力位
  398. if( pnCode ) *pnCode = ITSC_RESISTANCE;
  399. return m_itsResistance;
  400. }
  401. return ITS_NOTHING;
  402. }
  404. BOOL CBOLL::GetMinMaxInfo(int nStart, int nEnd,
  405.    double *pdMin, double *pdMax )
  406. {
  407. return AfxGetMinMaxInfo3( nStart, nEnd, pdMin, pdMax, this );
  408. }
  410. /***
  411. 布林带是以股价平均线MA为中心线，上方阻力线MA+αSn和下方支撑线MA-αSn之间的带状区域
  412. 其中 Sn为n日收盘价的标准差
  413. */
  414. BOOL CBOLL::Calculate( double * pdMA, double * pdUp, double * pdDown, int nIndex, BOOL bUseLast )
  415. {
  416. STT_ASSERT_CALCULATE1( m_pKData, nIndex );
  418. if( m_nMADays < 2 )
  419. return FALSE;
  421. if( LoadFromCache( nIndex, pdMA, pdUp, pdDown ) )
  422. return TRUE;
  424. double dMA = 0, dUp = 0, dDown = 0, dS = 0;
  426. if( !m_pKData->GetMA( &dMA, nIndex, m_nMADays ) )
  427. return FALSE;
  429. int nCount = 0;
  430. for( int k=nIndex; k>=0; k-- )
  431. {
  432. dS += (m_pKData->MaindataAt(k) - dMA) * (m_pKData->MaindataAt(k) - dMA);
  433. nCount ++;
  434. if( nCount == m_nMADays )
  435. break;
  436. }
  438. dS = sqrt( dS / (m_nMADays-1) );
  440. dUp = dMA + m_dMultiUp * dS;
  441. dDown = dMA - m_dMultiDown * dS;
  442. if( pdMA ) *pdMA = dMA;
  443. if( pdUp ) *pdUp = dUp;
  444. if( pdDown ) *pdDown = dDown;
  446. StoreToCache( nIndex, pdMA, pdUp, pdDown );
  447. return TRUE;
  448. }
  450. //////////////////////////////////////////////////////////////////////
  451. // CPV
  452. CPV::CPV( )
  453. {
  454. SetDefaultParameters( );
  455. }
  457. CPV::CPV( CKData * pKData )
  458. : CTechnique( pKData )
  459. {
  460. SetDefaultParameters( );
  461. }
  463. CPV::~CPV()
  464. {
  465. Clear( );
  466. }
  468. void CPV::SetDefaultParameters( )
  469. {
  470. }
  472. void CPV::AttachParameters( CPV & src )
  473. {
  474. }
  476. BOOL CPV::IsValidParameters( )
  477. {
  478. return TRUE;
  479. }
  481. void CPV::Clear( )
  482. {
  483. CTechnique::Clear( );
  484. }
  486. int CPV::GetSignal( int nIndex, UINT * pnCode )
  487. {
  488. if( pnCode ) *pnCode = ITSC_NOTHING;
  489. // 无买卖信号
  490. return ITS_NOTHING;
  491. }
  493. BOOL CPV::GetMinMaxInfo(int nStart, int nEnd,
  494.    double *pdMin, double *pdMax )
  495. {
  496. return AfxGetMinMaxInfo1( nStart, nEnd, pdMin, pdMax, this );
  497. }
  499. /***
  500. PV就是当日成交均价，成交额除以成交量
  501. */
  502. BOOL CPV::Calculate( double * pValue, int nIndex, BOOL bUseLast )
  503. {
  504. STT_ASSERT_CALCULATE1( m_pKData, nIndex );
  506. if( LoadFromCache( nIndex, pValue ) )
  507. return TRUE;
  509. KDATA kd = m_pKData->ElementAt(nIndex);
  510. if( kd.m_fVolume <= 1e-4 || kd.m_fAmount <= 1e-4 )
  511. return  FALSE;
  513. int nCount = 0;
  514. double average = ((double)(kd.m_fAmount)) / kd.m_fVolume;
  515. while( average < kd.m_fLow && nCount < 10 ) { average *= 10; nCount ++; }
  516. while( average > kd.m_fHigh && nCount < 20 ) { average /= 10; nCount ++; }
  517. if( average < kd.m_fLow ) // 说明是指数
  518. average = (kd.m_fOpen+kd.m_fHigh+kd.m_fLow+kd.m_fClose)/4;
  520. double dPV = average;
  521. if( pValue )
  522. *pValue = dPV;
  524. StoreToCache( nIndex, pValue );
  525. return TRUE;
  526. }
  528. //////////////////////////////////////////////////////////////////////
  529. // CSAR
  530. CSAR::CSAR( )
  531. {
  532. SetDefaultParameters( );
  533. }
  535. CSAR::CSAR( CKData * pKData )
  536. : CTechnique( pKData )
  537. {
  538. SetDefaultParameters( );
  540. m_bCurUp = m_bFirstUp;
  541. m_bTurn = FALSE;
  542. m_dCurAF = m_dAFStep;
  543. m_dCurHigh = -1;
  544. m_dCurLow = -1;
  545. }
  547. CSAR::~CSAR()
  548. {
  549. Clear( );
  550. }
  552. void CSAR::SetDefaultParameters( )
  553. {
  554. m_nInitDays = 4;
  555. m_bFirstUp = TRUE;
  556. m_dAFStep = 0.02;
  557. m_dAFMax = 0.2;
  558. m_itsBuy = ITS_BUY;
  559. m_itsSell = ITS_SELL;
  560. }
  562. void CSAR::AttachParameters( CSAR & src )
  563. {
  564. m_nInitDays = src.m_nInitDays;
  565. m_bFirstUp = src.m_bFirstUp;
  566. m_dAFStep = src.m_dAFStep;
  567. m_dAFMax = src.m_dAFMax;
  568. m_itsBuy = src.m_itsBuy;
  569. m_itsSell = src.m_itsSell;
  570. }
  572. BOOL CSAR::IsValidParameters( )
  573. {
  574. return ( VALID_DAYS(m_nInitDays) && m_bFirstUp >= 0 && m_dAFStep > 0 && m_dAFMax > 0
  575. && VALID_ITS(m_itsBuy) && VALID_ITS(m_itsSell) );
  576. }
  578. void CSAR::Clear( )
  579. {
  580. CTechnique::Clear( );
  581. }
  583. BOOL CSAR::CalculateSAR( double * pValue, int nIndex, BOOL bUseLast )
  584. {
  585. STT_ASSERT_CALCULATE1( m_pKData, nIndex );
  587. if( m_nInitDays > nIndex + 1 )
  588. return FALSE;
  590. double dResult = 0;
  591. if( bUseLast && pValue && nIndex > 0 && !m_bTurn )
  592. {
  593. KDATA kd = m_pKData->ElementAt(nIndex-1);
  594. if( m_bCurUp )
  595. {
  596. dResult = (*pValue) + m_dCurAF * (kd.m_fHigh - (*pValue) );
  597. if( kd.m_fHigh > m_dCurHigh )
  598. {
  599. m_dCurHigh = kd.m_fHigh;
  600. m_dCurAF = m_dCurAF + m_dAFStep;
  601. if( m_dCurAF > m_dAFMax )
  602. m_dCurAF = m_dAFMax;
  603. }
  604. if( m_pKData->ElementAt(nIndex).m_fLow < dResult )
  605. m_bTurn = TRUE;
  606. }
  607. else
  608. {
  609. dResult = (*pValue) - m_dCurAF * ((*pValue) - kd.m_fLow );
  610. if( kd.m_fLow < m_dCurLow )
  611. {
  612. m_dCurLow = kd.m_fLow;
  613. m_dCurAF = m_dCurAF + m_dAFStep;
  614. if( m_dCurAF > m_dAFMax )
  615. m_dCurAF = m_dAFMax;
  616. }
  617. if( m_pKData->ElementAt(nIndex).m_fHigh > dResult )
  618. m_bTurn = TRUE;
  619. }
  620. }
  621. else
  622. {
  623. for( int k=nIndex; k>=nIndex-m_nInitDays+1; k-- )
  624. {
  625. KDATA kd = m_pKData->ElementAt(k);
  626. if( nIndex == k )
  627. {
  628. m_dCurHigh = kd.m_fHigh;
  629. m_dCurLow = kd.m_fLow;
  630. }
  631. else if( kd.m_fHigh > m_dCurHigh )
  632. m_dCurHigh = kd.m_fHigh;
  633. else if( kd.m_fLow < m_dCurLow )
  634. m_dCurLow = kd.m_fLow;
  635. }
  636. if( m_bTurn )
  637. m_bCurUp = ! m_bCurUp;
  638. else
  639. m_bCurUp = m_bFirstUp;
  640. m_bTurn = FALSE;
  641. m_dCurAF = m_dAFStep;
  642. if( m_bCurUp )
  643. dResult = m_dCurLow;
  644. else
  645. dResult = m_dCurHigh;
  646. }
  648. if( pValue )
  649. *pValue = dResult;
  650. return TRUE;
  651. }
  653. int CSAR::GetSignal( int nIndex, UINT * pnCode )
  654. {
  655. if( pnCode ) *pnCode = ITSC_NOTHING;
  656. Clear( );
  657. double dValue;
  658. if( !Calculate( &dValue, nIndex, FALSE ) )
  659. return ITS_NOTHING;
  661. if( m_bTurn && !m_bCurUp )
  662. { // 反转向上
  663. if( pnCode ) *pnCode = ITSC_LONG;
  664. return m_itsBuy;
  665. }
  666. if( m_bTurn && m_bCurUp )
  667. { // 反转向下
  668. if( pnCode ) *pnCode = ITSC_SHORT;
  669. return m_itsSell;
  670. }
  671. return ITS_NOTHING;
  672. }
  674. BOOL CSAR::GetMinMaxInfo(int nStart, int nEnd,
  675.    double *pdMin, double *pdMax )
  676. {
  677. return AfxGetMinMaxInfo1( nStart, nEnd, pdMin, pdMax, this );
  678. }
  680. /***
  681. 计算SAR值
  682. 先选定时间，判断价格是在上涨还是在下跌。
  683. 若是看涨，则进场第一天的SAR必须是近期内的最低价，是看跌 则进场第一天的SAR必须是近期内的最高价。
  684. 本处为缺省定义为看涨。
  686. 进场第二天的SAR则为第一天的最高价（看涨时）或最低价（看跌时）与第一天的SAR的差距乘上调整系数，
  687. 再加上第一天的SAR就可求得。
  688. 按逐步递推的方法，每日的SAR可归纳如下： SAR（N）= SAR（N-1）+ AF * [ EP（N-1）-SAR（N-1）]
  689. 其中SAR（N）为第N日的SAR值，AF是调整系数，EP为极点价
  691. 第一个调整系数AF为0.02，若每隔一天的最高价比前一天的最高价还高，则AF递增0.02，若未创新高，
  692. 则AF沿用前一天的数值，但调整系数最高不超过0.2。
  693. 若是买进期间，计算出某日的SAR比当日或前一日的最低价还高，则应以当日或者前一日的最低价为某日之SAR，
  694. 卖出期间也对应服从类似原则。
  695. */
  696. BOOL CSAR::Calculate( double * pValue, int nIndex, BOOL bUseLast )
  697. {
  698. if( LoadFromCache( nIndex, pValue ) )
  699. return TRUE;
  701. if( bUseLast && pValue && nIndex > 0 )
  702. {
  703. if( CalculateSAR( pValue, nIndex, bUseLast ) )
  704. {
  705. StoreToCache( nIndex, pValue );
  706. return TRUE;
  707. }
  708. return FALSE;
  709. }
  710. else
  711. {
  712. double dResult;
  713. BOOL bHasLast = FALSE;
  714. for( int k=0; k<=nIndex; k++ )
  715. {
  716. if( CalculateSAR( &dResult, k, bHasLast ) )
  717. {
  718. bHasLast = TRUE;
  719. StoreToCache( k, &dResult );
  720. }
  721. }
  722. if( !bHasLast )
  723. return FALSE;
  724. if( pValue )
  725. *pValue = dResult;
  726. return TRUE;
  727. }
  728. }
  730. //////////////////////////////////////////////////////////////////////
  731. // CDJ
  732. CStock CDJ::m_stockSha;
  733. CStock CDJ::m_stockSzn;
  734. CSPString CDJ::m_strCodeOrg;
  735. CDJ::CDJ( )
  736. {
  737. SetDefaultParameters( );
  738. }
  740. CDJ::CDJ( CKData * pKData )
  741. : CTechnique( pKData )
  742. {
  743. SetDefaultParameters( );
  744. }
  746. CDJ::~CDJ()
  747. {
  748. Clear( );
  749. }
  751. void CDJ::SetDefaultParameters( )
  752. {
  753. m_strCodeSha = STKLIB_CODE_MAIN;
  754. m_strCodeSzn = STKLIB_CODE_MAINSZN;
  755. }
  757. void CDJ::AttachParameters( CDJ & src )
  758. {
  759. m_strCodeSha = src.m_strCodeSha;
  760. m_strCodeSzn = src.m_strCodeSzn;
  761. }
  763. BOOL CDJ::IsValidParameters( )
  764. {
  765. return ( m_strCodeSha.GetLength() > 0 && m_strCodeSzn.GetLength() > 0 );
  766. }
  768. void CDJ::Clear( )
  769. {
  770. CTechnique::Clear( );
  771. }
  773. /***
  774. K线叠加图，准备叠加K线的数据
  775. */
  776. BOOL CDJ::PrepareStockData(CStDatabase * pDatabase, const char * szCodeOrg,
  777.    int nCurKType, int nCurKFormat, int nCurMaindataType,
  778.    DWORD dwAutoResumeDRBegin, int nAutoResumeDRLimit )
  779. {
  780. SP_ASSERT( pDatabase );
  782. // bReload and kdayMain
  783. BOOL bReload = (NULL!=szCodeOrg && 0!=strncmp(szCodeOrg,m_strCodeOrg,m_strCodeOrg.GetLength()) );
  784. m_strCodeOrg = szCodeOrg;
  786. // m_stockSha
  787. m_stockSha.SetStockCode( CStock::marketSHSE, m_strCodeSha );
  788. AfxPrepareStockData( pDatabase, m_stockSha, nCurKType, nCurKFormat, nCurMaindataType, FALSE, bReload );
  790. // m_stockSzn
  791. m_stockSzn.SetStockCode( CStock::marketSZSE, m_strCodeSzn );
  792. AfxPrepareStockData( pDatabase, m_stockSzn, nCurKType, nCurKFormat, nCurMaindataType, FALSE, bReload );
  794. return TRUE;
  795. }
  797. //////////////////////////////////////////////////////////////////////
  798. // CCW
  799. CCW::CCW( )
  800. {
  801. SetDefaultParameters( );
  802. }
  804. CCW::CCW( CKData * pKData )
  805. : CTechnique( pKData )
  806. {
  807. SetDefaultParameters( );
  808. }
  810. CCW::~CCW()
  811. {
  812. Clear( );
  813. }
  815. void CCW::SetDefaultParameters( )
  816. {
  817. m_dChangeHand = 1.5;
  818. }
  820. void CCW::AttachParameters( CCW & src )
  821. {
  822. m_dChangeHand = src.m_dChangeHand;
  823. }
  825. BOOL CCW::IsValidParameters( )
  826. {
  827. return ( m_dChangeHand > 0 );
  828. }
  830. void CCW::Clear( )
  831. {
  832. CTechnique::Clear( );
  833. }
  835. /***
  836. 根据换手率m_dChangeHand和终止日，计算起始日
  837. */
  838. BOOL CCW::GetRange( int & nStart, int & nEnd, CStockInfo & info )
  839. {
  840. if( !m_pKData || m_pKData->GetSize() <= 0 )
  841. return FALSE;
  842. if( nEnd < 0 || nEnd >= m_pKData->GetSize() )
  843. nEnd = m_pKData->GetSize()-1;
  845. BOOL bIndex = FALSE;
  846. double dShareCurrency = 0;
  847. if( !info.GetShareCurrency( &dShareCurrency ) || dShareCurrency < 1e+6 )
  848. bIndex = TRUE;
  850. if( bIndex )
  851. dShareCurrency = 100 * m_dChangeHand;
  852. else
  853. dShareCurrency *= m_dChangeHand;
  855. double dVol = 0;
  856. for( int k=nEnd; k>=0; k-- )
  857. {
  858. if( bIndex )
  859. dVol += 1;
  860. else
  861. dVol += m_pKData->ElementAt(k).m_fVolume;
  863. if( dVol > dShareCurrency )
  864. break;
  865. }
  866. nStart = k;
  867. if( nStart < 0 )
  868. nStart = 0;
  869. return TRUE;
  870. }
  872. BOOL CCW::GetMinMaxInfo(int nStart, int nEnd, double dMinPrice, double dMaxPrice, double dStep,
  873. double *pdMinVolume, double *pdMaxVolume )
  874. {
  875. STT_ASSERT_GETMINMAXINFO( m_pKData, nStart, nEnd );
  876. if( dMinPrice >= dMaxPrice || dStep < 1e-4 )
  877. return FALSE;
  879. double dMinVolume = 0, dMaxVolume = 0, dVolume = 0;
  880. BOOL bFirst = TRUE;
  881. for( double dPrice = dMinPrice; dPrice < dMaxPrice; dPrice += dStep )
  882. {
  883. if( CalculateCW( &dVolume, nStart, nEnd, dPrice, dStep ) )
  884. {
  885. if( bFirst || dVolume < dMinVolume ) dMinVolume = dVolume;
  886. if( bFirst || dVolume > dMaxVolume ) dMaxVolume = dVolume;
  887. bFirst = FALSE;
  888. }
  889. }
  891. dMinVolume -= fabs(dMinVolume)*0.01;
  892. dMaxVolume += fabs(dMaxVolume)*0.01;
  893. if( dMaxVolume - dMinVolume < 3 )
  894. dMaxVolume = dMinVolume + 3;
  895. if( pdMinVolume ) *pdMinVolume = dMinVolume;
  896. if( pdMaxVolume ) *pdMaxVolume = dMaxVolume;
  898. return !bFirst;
  899. }
  901. /***
  902. 筹码分布图，计算价格区间包括dPrice的日线的成交量
  903. */
  904. BOOL CCW::CalculateCW( double *pdVolume, int nStart, int nEnd, double dPrice, double dStep )
  905. {
  906. STT_ASSERT_GETMINMAXINFO( m_pKData, nStart, nEnd );
  908. double dVolume = 0;
  909. for( int k=nStart; k<=nEnd; k++ )
  910. {
  911. KDATA kd = m_pKData->ElementAt(k);
  912. if( kd.m_fHigh-kd.m_fLow > 1e-4
  913. && kd.m_fLow < dPrice && kd.m_fHigh > dPrice )
  914. {
  915. // 均匀分布 dVolAve
  916. double dVolAve = kd.m_fVolume;
  917. if( dStep < kd.m_fHigh-kd.m_fLow )
  918. dVolAve = kd.m_fVolume * dStep / (kd.m_fHigh-kd.m_fLow);
  920. // 三角分布
  921. double dFactor = min(dPrice-kd.m_fLow, kd.m_fHigh-dPrice);
  922. dVolume += dVolAve * dFactor * 4 / (kd.m_fHigh-kd.m_fLow);
  923. }
  924. }
  926. if( pdVolume )
  927. *pdVolume = dVolume;
  928. return TRUE;
  929. }
  931. /***
  932. 筹码分布图计算，计算筹码分布
  933. */
  934. BOOL CCW::CalculateCW( int nStart, int nEnd, CStockInfo & info, double dStep,
  935. CSPDWordArray & adwPrice, CSPDWordArray & adwVolume,
  936. double * pdMinVolume, double * pdMaxVolume, double * pdTotalVolume, double * pdVolPercent )
  937. {
  938. STT_ASSERT_GETMINMAXINFO( m_pKData, nStart, nEnd );
  939. if( dStep < 1e-4 )
  940. return FALSE;
  942. float dMinPrice = 0, dMaxPrice = 0;
  943. if( !m_pKData->GetMinMaxInfo( nStart, nEnd, &dMinPrice, &dMaxPrice ) )
  944. return FALSE;
  946. // Calculate
  947. int nMaxCount = (int)((dMaxPrice-dMinPrice)/dStep) + 10;
  948. adwPrice.SetSize( 0, nMaxCount );
  949. adwVolume.SetSize( 0, nMaxCount );
  950. double dMinVolume = 0, dMaxVolume = 0, dTotalVolume = 0, dVolume = 0;
  951. BOOL bFirst = TRUE;
  952. for( double dPrice = dMinPrice; dPrice < dMaxPrice; dPrice += dStep )
  953. {
  954. if( CalculateCW( &dVolume, nStart, nEnd, dPrice, dStep ) )
  955. {
  956. if( bFirst || dVolume < dMinVolume ) dMinVolume = dVolume;
  957. if( bFirst || dVolume > dMaxVolume ) dMaxVolume = dVolume;
  958. adwPrice.Add( DWORD(dPrice * 1000) );
  959. adwVolume.Add( DWORD(dVolume) );
  960. dTotalVolume += dVolume;
  961. bFirst = FALSE;
  962. }
  963. }
  965. // Return
  966. // Min Max
  967. dMinVolume -= fabs(dMinVolume)*0.01;
  968. dMaxVolume += fabs(dMaxVolume)*0.01;
  969. if( dMaxVolume - dMinVolume < 3 )
  970. dMaxVolume = dMinVolume + 3;
  971. if( pdMinVolume ) *pdMinVolume = dMinVolume;
  972. if( pdMaxVolume ) *pdMaxVolume = dMaxVolume;
  973. if( pdTotalVolume ) *pdTotalVolume = dTotalVolume;
  975. // VolPercent
  976. double dVolPercent = 1.0;
  977. double dShareCurrency = 0;
  978. if( (!info.GetShareCurrency( &dShareCurrency ) || dShareCurrency < 1e+6) && nEnd-nStart+1 > 0 )
  979. dShareCurrency = dTotalVolume * 100 / (nEnd-nStart+1);
  980. if( dShareCurrency > 1e-4 )
  981. dVolPercent = dTotalVolume / (dShareCurrency*m_dChangeHand);
  982. if( dVolPercent > 1.0 ) dVolPercent = 1.0;
  983. if( dVolPercent < 0.0 ) dVolPercent = 0.0;
  984. if( pdVolPercent ) *pdVolPercent = dVolPercent;
  986. return adwPrice.GetSize() > 0;
  987. }
  989. /***
  990. 筹码分布图计算，计算最近nDays天内的筹码分布
  991. */
  992. BOOL CCW::CalculateRecentCW(int nEnd, int nDays, CStockInfo & info, double dStep,
  993. CSPDWordArray & adwPrice, CSPDWordArray & adwVolume,
  994. double * pdMinVolume, double * pdMaxVolume, double * pdTotalVolume, double * pdVolPercent )
  995. {
  996. // Prepare
  997. if( !m_pKData || m_pKData->GetSize() <= 0 )
  998. return FALSE;
  999. if( nEnd < 0 || nEnd >= m_pKData->GetSize() )
  1000. nEnd = m_pKData->GetSize()-1;
  1001. int nStart = nEnd - nDays + 1;
  1002. if( nStart < 0 || nStart >= m_pKData->GetSize() )
  1003. return FALSE;
  1005. return CalculateCW( nStart, nEnd, info, dStep, adwPrice, adwVolume, pdMinVolume, pdMaxVolume, pdTotalVolume, pdVolPercent );
  1006. }
  1008. /***
  1009. 筹码分布图计算，计算nDays天前内的筹码分布
  1010. */
  1011. BOOL CCW::CalculatePastCW(int nEnd, int nDays, CStockInfo & info, double dStep,
  1012. CSPDWordArray & adwPrice, CSPDWordArray & adwVolume,
  1013. double * pdMinVolume, double * pdMaxVolume, double * pdTotalVolume, double * pdVolPercent )
  1014. {
  1015. // Prepare
  1016. if( !m_pKData || m_pKData->GetSize() <= 0 )
  1017. return FALSE;
  1018. if( nEnd < 0 || nEnd >= m_pKData->GetSize() )
  1019. nEnd = m_pKData->GetSize()-1;
  1020. int nStart = nEnd - nDays;
  1021. if( nStart < 0 || nStart >= m_pKData->GetSize() )
  1022. return FALSE;
  1024. nEnd = nStart;
  1025. if( !GetRange( nStart, nEnd, info ) )
  1026. return FALSE;
  1028. BOOL bOK = CalculateCW( nStart, nEnd, info, dStep, adwPrice, adwVolume, pdMinVolume, pdMaxVolume, pdTotalVolume, pdVolPercent );
  1030. // TotalVolumeRecent
  1031. double dTotalVolumeRecent = 0;
  1032. for( int k=nEnd+1; k<=nEnd+nDays && k<m_pKData->GetSize(); k ++ )
  1033. dTotalVolumeRecent += m_pKData->ElementAt(k).m_fVolume;
  1035. // VolPercent
  1036. double dVolPercent = 1.0;
  1037. double dShareCurrency = 0;
  1038. if( (!info.GetShareCurrency( &dShareCurrency ) || dShareCurrency < 1e+6) && nDays > 0 )
  1039. dShareCurrency = dTotalVolumeRecent * 100 / nDays;
  1040. if( dShareCurrency > 1e-4 )
  1041. dVolPercent = dTotalVolumeRecent / (dShareCurrency*m_dChangeHand);
  1042. dVolPercent = 1.0 - dVolPercent;
  1043. if( dVolPercent > 1.0 ) dVolPercent = 1.0;
  1044. if( dVolPercent < 0.0 ) dVolPercent = 0.0;
  1045. if( pdVolPercent ) *pdVolPercent = dVolPercent;
  1047. return bOK;
  1048. }
  1050. /***
  1051. 筹码分布图统计，获利比例统计
  1052. */
  1053. BOOL CCW::StatGainPercent( double *pdGainPercent, CSPDWordArray &adwPrice, CSPDWordArray &adwVolume, double dPriceSel )
  1054. {
  1055. double dTotalVolume = 0;
  1056. double dGainVolume = 0;
  1057. for( int k=0; k<adwPrice.GetSize() && k<adwVolume.GetSize(); k++ )
  1058. {
  1059. dTotalVolume += adwVolume[k];
  1060. if( adwPrice[k] * 0.001 <= dPriceSel )
  1061. dGainVolume += adwVolume[k];
  1062. }
  1064. double dGainPercent = 0;
  1065. if( dTotalVolume > 1e-4 )
  1066. dGainPercent = dGainVolume / dTotalVolume;
  1068. if( pdGainPercent ) *pdGainPercent = dGainPercent;
  1069. return TRUE;
  1070. }
  1072. /***
  1073. 筹码分布图统计，平均成本统计
  1074. */
  1075. BOOL CCW::StatCostAverage( double *pdCostAve, CSPDWordArray &adwPrice, CSPDWordArray &adwVolume )
  1076. {
  1077. double dTotalVolume = 0;
  1078. double dTotalCost = 0;
  1079. for( int k=0; k<adwPrice.GetSize() && k<adwVolume.GetSize(); k++ )
  1080. {
  1081. dTotalVolume += adwVolume[k];
  1082. dTotalCost += 0.001 * adwPrice[k] * adwVolume[k];
  1083. }
  1085. double dCostAve = 0;
  1086. if( dTotalVolume > 1e-4 )
  1087. dCostAve = dTotalCost / dTotalVolume;
  1089. if( pdCostAve ) *pdCostAve = dCostAve;
  1090. return TRUE;
  1091. }
  1093. /***
  1094. 筹码分布图统计，集中度统计
  1095. */
  1096. BOOL CCW::StatMass( double *pdLower, double *pdUpper, double *pdMassPrice, CSPDWordArray &adwPrice, CSPDWordArray &adwVolume, double dMassVol )
  1097. {
  1098. if( adwPrice.GetSize() != adwVolume.GetSize() || dMassVol < 0 || dMassVol > 1 )
  1099. return FALSE;
  1101. double dTotalVolume = 0;
  1102. for( int k=0; k<adwPrice.GetSize() && k<adwVolume.GetSize(); k++ )
  1103. dTotalVolume += adwVolume[k];
  1105. if( dTotalVolume > 1e-4 )
  1106. {
  1107. double dUpperVolume = dTotalVolume * (1-dMassVol) * 0.5;
  1108. double dLowerVolume = dUpperVolume;
  1109. int nLower = 0, nUpper = adwPrice.GetSize()-1;
  1111. for( k=0; k<adwPrice.GetSize(); k++ )
  1112. {
  1113. dLowerVolume -= (double)adwVolume[k];
  1114. if( dLowerVolume < 0 )
  1115. break;
  1116. }
  1117. nLower = k;
  1119. for( k=adwPrice.GetSize()-1; k>=0; k-- )
  1120. {
  1121. dUpperVolume -= (double)adwVolume[k];
  1122. if( dUpperVolume < 0 )
  1123. break;
  1124. }
  1125. nUpper = k;
  1127. if( nLower < 0 || nLower > nUpper || nUpper >= adwPrice.GetSize() )
  1128. return FALSE;
  1130. double dLower = 0.001 * adwPrice[nLower];
  1131. double dUpper = 0.001 * adwPrice[nUpper];
  1132. if( pdLower ) *pdLower = dLower;
  1133. if( pdUpper ) *pdUpper = dUpper;
  1134. if( pdMassPrice && adwPrice.GetSize() >= 2 )
  1135. {
  1136. double dPriceRange = 0.001 * ((double)adwPrice[adwPrice.GetSize()-1] - (double)adwPrice[0]);
  1137. if( dPriceRange > 1e-4 )
  1138. *pdMassPrice = (dUpper-dLower)/dPriceRange;
  1139. if( *pdMassPrice < 0 ) *pdMassPrice = 0;
  1140. if( *pdMassPrice > 1 ) *pdMassPrice = 1;
  1141. }
  1142. }
  1144. return TRUE;
  1145. }