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

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

金融证券系统

开发平台：

Visual C++

Technique.cpp：源码内容
  1. /*
  2. Cross Platform Core Code.
  4. Copyright(R) 2001-2002 Balang Software.
  5. All rights reserved.
  7. Using:
  8. class CTechnique;
  9. */
  11. #include "StdAfx.h"
  12. #include "../Include/Stock.h"
  13. #include "../Include/Technique.h"
  15. #ifdef _DEBUG
  16. #undef THIS_FILE
  17. static char THIS_FILE[] = __FILE__;
  18. #endif
  20. #ifdef _DEBUG
  21. #define new DEBUG_NEW
  22. #endif
  24. //////////////////////////////////////////////////////////////////
  25. // GetMinMaxInfo
  26. // 一些反复使用的代码，用函数代替，得到技术指标在指定范围内的最大最小值
  27. // 技术指标有不同日期作为参数
  28. BOOL AfxGetMinMaxInfo( int nStart, int nEnd, double *pdMin, double *pdMax, CTechnique * pTech, CSPDWordArray & adwDays )
  29. {
  30. SP_ASSERT( pTech );
  31. if( nStart < 0 || nEnd < 0 || nStart > nEnd || !pTech )
  32. return FALSE;
  34. double dMin = 0, dMax = 0;
  35. double dValue = 0;
  36. BOOL bFirst = TRUE;
  37. for( int i=0; i<adwDays.GetSize(); i++ )
  38. {
  39. for( int k=nStart; k<=nEnd; k++ )
  40. {
  41. if( pTech->Calculate( &dValue, k, adwDays[i], !bFirst ) )
  42. {
  43. if( bFirst || dValue < dMin ) dMin = dValue;
  44. if( bFirst || dValue > dMax ) dMax = dValue;
  45. bFirst = FALSE;
  46. }
  47. }
  48. }
  49. dMin -= fabs(dMin)*0.02;
  50. dMax += fabs(dMax)*0.02;
  51. if( dMax - dMin < 0.03 )
  52. dMax = dMin + 0.05;
  53. if( pdMin ) *pdMin = dMin;
  54. if( pdMax ) *pdMax = dMax;
  56. return !bFirst;
  57. }
  59. // 技术指标有1个最终值
  60. BOOL AfxGetMinMaxInfo1( int nStart, int nEnd, double *pdMin, double *pdMax, CTechnique * pTech )
  61. {
  62. SP_ASSERT( pTech );
  63. if( nStart < 0 || nEnd < 0 || nStart > nEnd || !pTech )
  64. return FALSE;
  66. double dMin = 0, dMax = 0;
  67. double dValue = 0;
  68. BOOL bFirst = TRUE;
  69. for( int k=nStart; k<=nEnd; k++ )
  70. {
  71. if( pTech->Calculate( &dValue, k, !bFirst ) ) // 技术指标有1个最终值
  72. {
  73. if( bFirst || dValue < dMin ) dMin = dValue;
  74. if( bFirst || dValue > dMax ) dMax = dValue;
  75. bFirst = FALSE;
  76. }
  77. }
  78. dMin -= fabs(dMin)*0.02;
  79. dMax += fabs(dMax)*0.02;
  80. if( dMax - dMin < 0.03 )
  81. dMax = dMin + 0.05;
  82. if( pdMin ) *pdMin = dMin;
  83. if( pdMax ) *pdMax = dMax;
  85. return !bFirst;
  86. }
  88. // 技术指标有2个最终值
  89. BOOL AfxGetMinMaxInfo2( int nStart, int nEnd, double *pdMin, double *pdMax, CTechnique * pTech )
  90. {
  91. SP_ASSERT( pTech );
  92. if( nStart < 0 || nEnd < 0 || nStart > nEnd || !pTech )
  93. return FALSE;
  95. double dMin = 0, dMax = 0;
  96. double dValue1 = 0, dValue2 = 0;
  97. BOOL bFirst = TRUE;
  98. for( int k=nStart; k<=nEnd; k++ )
  99. {
  100. if( pTech->Calculate( &dValue1, &dValue2, k, !bFirst ) ) // 技术指标有2个最终值
  101. {
  102. if( bFirst || dValue1 < dMin ) dMin = dValue1;
  103. if( bFirst || dValue1 > dMax ) dMax = dValue1;
  104. if( dValue2 < dMin ) dMin = dValue2;
  105. if( dValue2 > dMax ) dMax = dValue2;
  106. bFirst = FALSE;
  107. }
  108. }
  109. dMin -= fabs(dMin)*0.02;
  110. dMax += fabs(dMax)*0.02;
  111. if( dMax - dMin < 0.03 )
  112. dMax = dMin + 0.05;
  113. if( pdMin ) *pdMin = dMin;
  114. if( pdMax ) *pdMax = dMax;
  116. return !bFirst;
  117. }
  119. // 技术指标有3个最终值
  120. BOOL AfxGetMinMaxInfo3( int nStart, int nEnd, double *pdMin, double *pdMax, CTechnique * pTech )
  121. {
  122. SP_ASSERT( pTech );
  123. if( nStart < 0 || nEnd < 0 || nStart > nEnd || !pTech )
  124. return FALSE;
  126. double dMin = 0, dMax = 0;
  127. double dValue1 = 0, dValue2 = 0, dValue3 = 0;
  128. BOOL bFirst = TRUE;
  129. for( int k=nStart; k<=nEnd; k++ )
  130. {
  131. if( pTech->Calculate( &dValue1, &dValue2, &dValue3, k, !bFirst ) ) // 技术指标有3个最终值
  132. {
  133. if( bFirst || dValue1 < dMin ) dMin = dValue1;
  134. if( bFirst || dValue1 > dMax ) dMax = dValue1;
  135. if( dValue2 < dMin ) dMin = dValue2;
  136. if( dValue2 > dMax ) dMax = dValue2;
  137. if( dValue3 < dMin ) dMin = dValue3;
  138. if( dValue3 > dMax ) dMax = dValue3;
  139. bFirst = FALSE;
  140. }
  141. }
  142. dMin -= fabs(dMin)*0.02;
  143. dMax += fabs(dMax)*0.02;
  144. if( dMax - dMin < 0.03 )
  145. dMax = dMin + 0.05;
  146. if( pdMin ) *pdMin = dMin;
  147. if( pdMax ) *pdMax = dMax;
  149. return !bFirst;
  150. }
  152. // 技术指标有4个最终值
  153. BOOL AfxGetMinMaxInfo4( int nStart, int nEnd, double *pdMin, double *pdMax, CTechnique * pTech )
  154. {
  155. SP_ASSERT( pTech );
  156. if( nStart < 0 || nEnd < 0 || nStart > nEnd || !pTech )
  157. return FALSE;
  159. double dMin = 0, dMax = 0;
  160. double dValue1 = 0, dValue2 = 0, dValue3 = 0, dValue4 = 0;
  161. BOOL bFirst = TRUE;
  162. for( int k=nStart; k<=nEnd; k++ )
  163. {
  164. if( pTech->Calculate( &dValue1, &dValue2, &dValue3, &dValue4, k, !bFirst ) ) // 技术指标有4个最终值
  165. {
  166. if( bFirst || dValue1 < dMin ) dMin = dValue1;
  167. if( bFirst || dValue1 > dMax ) dMax = dValue1;
  168. if( dValue2 < dMin ) dMin = dValue2;
  169. if( dValue2 > dMax ) dMax = dValue2;
  170. if( dValue3 < dMin ) dMin = dValue3;
  171. if( dValue3 > dMax ) dMax = dValue3;
  172. if( dValue4 < dMin ) dMin = dValue4;
  173. if( dValue4 > dMax ) dMax = dValue4;
  174. bFirst = FALSE;
  175. }
  176. }
  177. dMin -= fabs(dMin)*0.02;
  178. dMax += fabs(dMax)*0.02;
  179. if( dMax - dMin < 0.03 )
  180. dMax = dMin + 0.05;
  181. if( pdMin ) *pdMin = dMin;
  182. if( pdMax ) *pdMax = dMax;
  184. return !bFirst;
  185. }
  187. // 技术指标有5个最终值
  188. BOOL AfxGetMinMaxInfo5( int nStart, int nEnd, double *pdMin, double *pdMax, CTechnique * pTech )
  189. {
  190. SP_ASSERT( pTech );
  191. if( nStart < 0 || nEnd < 0 || nStart > nEnd || !pTech )
  192. return FALSE;
  194. double dMin = 0, dMax = 0;
  195. double dValue1 = 0, dValue2 = 0, dValue3 = 0, dValue4 = 0, dValue5 = 0;
  196. BOOL bFirst = TRUE;
  197. for( int k=nStart; k<=nEnd; k++ )
  198. {
  199. if( pTech->Calculate( &dValue1, &dValue2, &dValue3, &dValue4, &dValue5, k, !bFirst ) ) // 技术指标有5个最终值
  200. {
  201. if( bFirst || dValue1 < dMin ) dMin = dValue1;
  202. if( bFirst || dValue1 > dMax ) dMax = dValue1;
  203. if( dValue2 < dMin ) dMin = dValue2;
  204. if( dValue2 > dMax ) dMax = dValue2;
  205. if( dValue3 < dMin ) dMin = dValue3;
  206. if( dValue3 > dMax ) dMax = dValue3;
  207. if( dValue4 < dMin ) dMin = dValue4;
  208. if( dValue4 > dMax ) dMax = dValue4;
  209. if( dValue5 < dMin ) dMin = dValue5;
  210. if( dValue5 > dMax ) dMax = dValue5;
  211. bFirst = FALSE;
  212. }
  213. }
  214. dMin -= fabs(dMin)*0.02;
  215. dMax += fabs(dMax)*0.02;
  216. if( dMax - dMin < 0.03 )
  217. dMax = dMin + 0.05;
  218. if( pdMin ) *pdMin = dMin;
  219. if( pdMax ) *pdMax = dMax;
  221. return !bFirst;
  222. }
  224. DWORD AfxGetMaxDays( CSPDWordArray & adw )
  225. {
  226. DWORD dwMax = 0;
  227. for( int i=0; i<adw.GetSize(); i++ )
  228. {
  229. if( adw.ElementAt(i) > dwMax )
  230. dwMax = adw.ElementAt(i);
  231. }
  232. return dwMax;
  233. }
  235. //////////////////////////////////////////////////////////////////////
  236. // CTechnique
  238. CTechnique::CTechnique( )
  239. {
  240. m_pKData = NULL;
  242. m_pdCache1 = NULL;
  243. m_pdCache2 = NULL;
  244. m_pdCache3 = NULL;
  245. m_pdCache4 = NULL;
  246. m_pdCache5 = NULL;
  247. m_pbHasCache1 = NULL;
  248. m_pbHasCache2 = NULL;
  249. m_pbHasCache3 = NULL;
  250. m_pbHasCache4 = NULL;
  251. m_pbHasCache5 = NULL;
  252. m_nLength = 0;
  253. m_nIndexStart = -1;
  255. m_nLastIntensity = ITS_NOTHING;
  256. m_nLastIntensityCode = ITSC_NOTHING;
  257. }
  259. CTechnique::CTechnique( CKData * pKData )
  260. {
  261. m_pKData = pKData;
  263. m_pdCache1 = NULL;
  264. m_pdCache2 = NULL;
  265. m_pdCache3 = NULL;
  266. m_pdCache4 = NULL;
  267. m_pdCache5 = NULL;
  268. m_pbHasCache1 = NULL;
  269. m_pbHasCache2 = NULL;
  270. m_pbHasCache3 = NULL;
  271. m_pbHasCache4 = NULL;
  272. m_pbHasCache5 = NULL;
  273. m_nLength = 0;
  274. m_nIndexStart = -1;
  276. m_nLastIntensity = ITS_NOTHING;
  277. m_nLastIntensityCode = ITSC_NOTHING;
  278. }
  280. CTechnique::~CTechnique()
  281. {
  282. CTechnique::Clear( );
  283. }
  285. void CTechnique::SetKData( CKData * pKData )
  286. {
  287. m_pKData = pKData;
  288. CTechnique::Clear( );
  289. }
  291. CKData * CTechnique::GetKData( )
  292. {
  293. return m_pKData;
  294. }
  296. void CTechnique::Clear( )
  297. {
  298. if( m_pdCache1 )
  299. delete [] m_pdCache1;
  300. if( m_pdCache2 )
  301. delete [] m_pdCache2;
  302. if( m_pdCache3 )
  303. delete [] m_pdCache3;
  304. if( m_pdCache4 )
  305. delete [] m_pdCache4;
  306. if( m_pdCache5 )
  307. delete [] m_pdCache5;
  309. if( m_pbHasCache1 )
  310. delete [] m_pbHasCache1;
  311. if( m_pbHasCache2 )
  312. delete [] m_pbHasCache2;
  313. if( m_pbHasCache3 )
  314. delete [] m_pbHasCache3;
  315. if( m_pbHasCache4 )
  316. delete [] m_pbHasCache4;
  317. if( m_pbHasCache5 )
  318. delete [] m_pbHasCache5;
  320. m_pdCache1 = NULL;
  321. m_pdCache2 = NULL;
  322. m_pdCache3 = NULL;
  323. m_pdCache4 = NULL;
  324. m_pdCache5 = NULL;
  325. m_pbHasCache1 = NULL;
  326. m_pbHasCache2 = NULL;
  327. m_pbHasCache3 = NULL;
  328. m_pbHasCache4 = NULL;
  329. m_pbHasCache5 = NULL;
  330. m_nLength = 0;
  331. m_nIndexStart = -1;
  333. m_nLastIntensity = ITS_NOTHING;
  334. m_nLastIntensityCode = ITSC_NOTHING;
  335. }
  337. void CTechnique::ClearLastIntensity( )
  338. {
  339. m_nLastIntensity = ITS_NOTHING;
  340. m_nLastIntensityCode = ITSC_NOTHING;
  341. }
  343. // 准备缓冲区
  344. BOOL CTechnique::PrepareCache( int nStart, int nEnd, BOOL bForceRecalculate )
  345. {
  346. SP_ASSERT( m_pKData );
  347. if( NULL == m_pKData )
  348. return FALSE;
  349. if( -1 == nEnd )
  350. nEnd = m_pKData->GetSize()-1;
  351. if( nStart < 0 || nEnd < nStart || nEnd >= m_pKData->GetSize() )
  352. return FALSE;
  354. if( bForceRecalculate )
  355. Clear( );
  357. return GetMinMaxInfo( nStart, nEnd, NULL, NULL );
  358. }
  360. // 从缓冲区中读取计算好的数据
  361. BOOL CTechnique::LoadFromCache( int nIndex, double * pValue1, double * pValue2, double * pValue3, double * pValue4, double * pValue5 )
  362. {
  363. if( m_nLength <= 0 || m_nIndexStart < 0
  364. || nIndex < m_nIndexStart || nIndex-m_nIndexStart>=m_nLength )
  365. return FALSE;
  367. BOOL bOK = TRUE;
  368. if( pValue1 && !( m_pdCache1 && m_pbHasCache1 && m_pbHasCache1[nIndex-m_nIndexStart] ) )
  369. bOK = FALSE;
  370. if( pValue2 && !( m_pdCache2 && m_pbHasCache2 && m_pbHasCache2[nIndex-m_nIndexStart] ) )
  371. bOK = FALSE;
  372. if( pValue3 && !( m_pdCache3 && m_pbHasCache3 && m_pbHasCache3[nIndex-m_nIndexStart] ) )
  373. bOK = FALSE;
  374. if( pValue4 && !( m_pdCache4 && m_pbHasCache4 && m_pbHasCache4[nIndex-m_nIndexStart] ) )
  375. bOK = FALSE;
  376. if( pValue5 && !( m_pdCache5 && m_pbHasCache5 && m_pbHasCache5[nIndex-m_nIndexStart] ) )
  377. bOK = FALSE;
  379. if( !bOK )
  380. return FALSE;
  382. if( pValue1 )
  383. *pValue1 = m_pdCache1[nIndex-m_nIndexStart];
  384. if( pValue2 )
  385. *pValue2 = m_pdCache2[nIndex-m_nIndexStart];
  386. if( pValue3 )
  387. *pValue3 = m_pdCache3[nIndex-m_nIndexStart];
  388. if( pValue4 )
  389. *pValue4 = m_pdCache4[nIndex-m_nIndexStart];
  390. if( pValue5 )
  391. *pValue5 = m_pdCache5[nIndex-m_nIndexStart];
  392. return TRUE;
  393. }
  395. // 将计算好的数据保存至缓冲区
  396. BOOL CTechnique::StoreToCache( int nIndex, double * pValue1, double *pValue2, double *pValue3, double * pValue4, double * pValue5 )
  397. {
  398. STT_ASSERT_CALCULATE1( m_pKData, nIndex );
  400. if( m_nLength <= 0 || m_nIndexStart < 0 )
  401. {
  402. m_nLength = ( NULL!=m_pKData ? m_pKData->GetSize() : 0 );
  403. if( m_nLength > 0 )
  404. m_nIndexStart = 0;
  405. }
  406. if( m_nLength <= 0 || m_nIndexStart <  0 )
  407. return FALSE;
  409. // Realocate
  410. if( pValue1 )
  411. {
  412. if( !m_pdCache1 )
  413. m_pdCache1 = new double[m_nLength];
  414. if( !m_pbHasCache1 )
  415. {
  416. m_pbHasCache1 = new BOOL[m_nLength];
  417. if( !m_pbHasCache1 ) return FALSE;
  418. for( int i=0; i<m_nLength; i++ )
  419. m_pbHasCache1[i] = FALSE;
  420. }
  421. if( NULL == m_pbHasCache1 || NULL == m_pdCache1 )
  422. return FALSE;
  423. }
  424. if( pValue2 )
  425. {
  426. if( !m_pdCache2 )
  427. m_pdCache2 = new double[m_nLength];
  428. if( !m_pbHasCache2 )
  429. {
  430. m_pbHasCache2 = new BOOL[m_nLength];
  431. if( !m_pbHasCache2 ) return FALSE;
  432. for( int i=0; i<m_nLength; i++ )
  433. m_pbHasCache2[i] = FALSE;
  434. }
  435. if( NULL == m_pbHasCache2 || NULL == m_pdCache2 )
  436. return FALSE;
  437. }
  438. if( pValue3 )
  439. {
  440. if( !m_pdCache3 )
  441. m_pdCache3 = new double[m_nLength];
  442. if( !m_pbHasCache3 )
  443. {
  444. m_pbHasCache3 = new BOOL[m_nLength];
  445. if( !m_pbHasCache3 ) return FALSE;
  446. for( int i=0; i<m_nLength; i++ )
  447. m_pbHasCache3[i] = FALSE;
  448. }
  449. if( NULL == m_pbHasCache3 || NULL == m_pdCache3 )
  450. return FALSE;
  451. }
  452. if( pValue4 )
  453. {
  454. if( !m_pdCache4 )
  455. m_pdCache4 = new double[m_nLength];
  456. if( !m_pbHasCache4 )
  457. {
  458. m_pbHasCache4 = new BOOL[m_nLength];
  459. if( !m_pbHasCache4 ) return FALSE;
  460. for( int i=0; i<m_nLength; i++ )
  461. m_pbHasCache4[i] = FALSE;
  462. }
  463. if( NULL == m_pbHasCache4 || NULL == m_pdCache4 )
  464. return FALSE;
  465. }
  466. if( pValue5 )
  467. {
  468. if( !m_pdCache5 )
  469. m_pdCache5 = new double[m_nLength];
  470. if( !m_pbHasCache5 )
  471. {
  472. m_pbHasCache5 = new BOOL[m_nLength];
  473. if( !m_pbHasCache5 ) return FALSE;
  474. for( int i=0; i<m_nLength; i++ )
  475. m_pbHasCache5[i] = FALSE;
  476. }
  477. if( NULL == m_pbHasCache5 || NULL == m_pdCache5 )
  478. return FALSE;
  479. }
  481. if( nIndex < m_nIndexStart || nIndex-m_nIndexStart>=m_nLength )
  482. return FALSE;
  484. // Store
  485. if( pValue1 && m_pdCache1 && m_pbHasCache1 )
  486. {
  487. m_pdCache1[nIndex-m_nIndexStart] = *pValue1;
  488. m_pbHasCache1[nIndex-m_nIndexStart] = TRUE;
  489. }
  490. if( pValue2 && m_pdCache2 && m_pbHasCache2 )
  491. {
  492. m_pdCache2[nIndex-m_nIndexStart] = *pValue2;
  493. m_pbHasCache2[nIndex-m_nIndexStart] = TRUE;
  494. }
  495. if( pValue3 && m_pdCache3 && m_pbHasCache3 )
  496. {
  497. m_pdCache3[nIndex-m_nIndexStart] = *pValue3;
  498. m_pbHasCache3[nIndex-m_nIndexStart] = TRUE;
  499. }
  500. if( pValue4 && m_pdCache4 && m_pbHasCache4 )
  501. {
  502. m_pdCache4[nIndex-m_nIndexStart] = *pValue4;
  503. m_pbHasCache4[nIndex-m_nIndexStart] = TRUE;
  504. }
  505. if( pValue5 && m_pdCache5 && m_pbHasCache5 )
  506. {
  507. m_pdCache5[nIndex-m_nIndexStart] = *pValue5;
  508. m_pbHasCache5[nIndex-m_nIndexStart] = TRUE;
  509. }
  510. return TRUE;
  511. }
  513. // 准备数据，得到较大值和较小值
  514. BOOL CTechnique::IntensityPrepare( int nIndex, UINT * pnCode, int nMaxDays, int nMinMaxDays, double *pdLiminalLow, double *pdLiminalHigh, double dGateLow, double dGateHigh )
  515. {
  516. if( pnCode ) *pnCode = ITSC_NOTHING;
  518. if( nIndex < nMaxDays + nMinMaxDays )
  519. return FALSE;
  520. int nStart = nIndex - nMinMaxDays + 1;
  521. if( nStart < 0 )
  522. return FALSE;
  524. double dMin = 0, dMax = 0;
  525. if( !GetMinMaxInfo( nStart, nIndex, &dMin, &dMax ) )
  526. return FALSE;
  528. if( pdLiminalLow ) *pdLiminalLow = dMin + (dMax-dMin)*dGateLow;
  529. if( pdLiminalHigh ) *pdLiminalHigh = dMin + (dMax-dMin)*dGateHigh;
  530. return TRUE;
  531. }
  533. // 准备数据，得到价格较大值和较小值
  534. BOOL CTechnique::IntensityPreparePrice( int nIndex, UINT * pnCode, int nMaxDays, int nMinMaxDays, double *pdLiminalLow, double *pdLiminalHigh, double dGateLow, double dGateHigh )
  535. {
  536. if( pnCode ) *pnCode = ITSC_NOTHING;
  538. if( nIndex < nMaxDays + nMinMaxDays )
  539. return FALSE;
  540. int nStart = nIndex - nMinMaxDays + 1;
  541. if( nStart < 0 )
  542. return FALSE;
  544. float fMin = 0, fMax = 0;
  545. if( !m_pKData || !m_pKData->GetMinMaxInfo( nStart, nIndex, &fMin, &fMax ) )
  546. return FALSE;
  548. if( pdLiminalLow ) *pdLiminalLow = (fMin + (fMax-fMin)*dGateLow);
  549. if( pdLiminalHigh ) *pdLiminalHigh = (fMin + (fMax-fMin)*dGateHigh);
  550. return TRUE;
  551. }
  553. // 是否创新高或者创新低
  554. BOOL CTechnique::IsNewValue( int nIndex, BOOL bTopOrBottom, int nDays, double * pdValue1, double * pdValue2 )
  555. {
  556. SP_ASSERT( nDays > 3 );
  557. if( nDays < 3 )
  558. return FALSE;
  559. SP_ASSERT( NULL != pdValue1 || NULL != pdValue2 );
  560. if( NULL == pdValue1 && NULL == pdValue2 )
  561. return FALSE;
  562. if( m_nLength <= 0 || m_nIndexStart < 0
  563. || nIndex < m_nIndexStart || nIndex-m_nIndexStart>=m_nLength
  564. || nIndex-m_nIndexStart < nDays-1 )
  565. return FALSE;
  567. BOOL bFirst = TRUE;
  568. double dLast1 = 0, dLast2 = 0;
  569. int nLast1 = 0, nLast2 = 0;
  570. double dNow1 = 0, dNow2 = 0;
  571. if( NULL != pdValue1 )
  572. dNow1 = pdValue1[nIndex-m_nIndexStart];
  573. if( NULL != pdValue2 )
  574. dNow2 = pdValue2[nIndex-m_nIndexStart];
  575. for( int k=nIndex-m_nIndexStart-1; k>=0 && k>nIndex-m_nIndexStart-nDays; k-- )
  576. {
  577. if( bFirst )
  578. {
  579. if( pdValue1 ) dLast1 = pdValue1[k];
  580. if( pdValue2 ) dLast2 = pdValue2[k];
  581. nLast1 = nLast2 = k;
  582. bFirst = FALSE;
  583. }
  585. if( bTopOrBottom )
  586. {
  587. if( pdValue1 && pdValue1[k] > dNow1 )
  588. return FALSE;
  589. if( pdValue2 && pdValue2[k] > dNow2 )
  590. return FALSE;
  592. if( pdValue1 && pdValue1[k] > dLast1 )
  593. {
  594. dLast1 = pdValue1[k];
  595. nLast1 = k;
  596. }
  597. if( pdValue2 && pdValue2[k] > dLast2 )
  598. {
  599. dLast2 = pdValue2[k];
  600. nLast2 = k;
  601. }
  602. }
  603. else
  604. {
  605. if( pdValue1 && pdValue1[k] < dNow1 )
  606. return FALSE;
  607. if( pdValue2 && pdValue2[k] < dNow2 )
  608. return FALSE;
  610. if( pdValue1 && pdValue1[k] < dLast1 )
  611. {
  612. dLast1 = pdValue1[k];
  613. nLast1 = k;
  614. }
  615. if( pdValue2 && pdValue2[k] < dLast2 )
  616. {
  617. dLast2 = pdValue2[k];
  618. nLast2 = k;
  619. }
  620. }
  621. }
  623. if( bFirst )
  624. return FALSE;
  626. if( ( !pdValue1 || (nLast1 >= nIndex-30 && nLast1 <= nIndex-5) )
  627. && ( !pdValue2 || (nLast2 >= nIndex-30 && nLast2 <= nIndex-5) ) )
  628. return TRUE;
  630. return FALSE;
  631. }
  633. // 是否底背离
  634. BOOL CTechnique::IsDeviateOnBottom( int nIndex, double * pdValue1, double * pdValue2 )
  635. {
  636. STT_ASSERT_CALCULATE1( m_pKData, nIndex );
  638. if( !m_pKData->IsNewValue( nIndex, FALSE, ITS_DAYS_DEVIATE ) )
  639. return FALSE;
  641. if( IsNewValue( nIndex, FALSE, ITS_DAYS_DEVIATE, pdValue1, pdValue2 ) )
  642. return FALSE;
  644. return TRUE;
  645. }
  647. // 是否顶背离
  648. BOOL CTechnique::IsDeviateOnTop( int nIndex, double * pdValue1, double * pdValue2 )
  649. {
  650. STT_ASSERT_CALCULATE1( m_pKData, nIndex );
  652. if( !m_pKData->IsNewValue( nIndex, TRUE, ITS_DAYS_DEVIATE ) )
  653. return FALSE;
  655. if( IsNewValue( nIndex, TRUE, ITS_DAYS_DEVIATE, pdValue1, pdValue2 ) )
  656. return FALSE;
  658. return TRUE;
  659. }
  661. // 是否金叉
  662. BOOL CTechnique::IsGoldenFork( int nIndex, double * pdValue1, double * pdValue2 )
  663. {
  664. SP_ASSERT( NULL != pdValue1 && NULL != pdValue2 );
  665. if( NULL == pdValue1 || NULL == pdValue2 )
  666. return FALSE;
  667. if( m_nLength <= 0 || m_nIndexStart < 0
  668. || nIndex < m_nIndexStart || nIndex-m_nIndexStart>=m_nLength
  669. || nIndex-m_nIndexStart < 1 )
  670. return FALSE;
  672. int k = nIndex-m_nIndexStart;
  673. if( pdValue1[k-1] <= pdValue2[k-1] && pdValue1[k] > pdValue2[k]
  674. && pdValue1[k] >= pdValue1[k-1] && pdValue2[k] >= pdValue2[k-1] )
  675. return TRUE;
  676. return FALSE;
  677. }
  679. // 是否死叉
  680. BOOL CTechnique::IsDeadFork( int nIndex, double * pdValue1, double * pdValue2 )
  681. {
  682. SP_ASSERT( NULL != pdValue1 && NULL != pdValue2 );
  683. if( NULL == pdValue1 || NULL == pdValue2 )
  684. return FALSE;
  685. if( m_nLength <= 0 || m_nIndexStart < 0
  686. || nIndex < m_nIndexStart || nIndex-m_nIndexStart>=m_nLength
  687. || nIndex-m_nIndexStart < 1 )
  688. return FALSE;
  690. int k = nIndex-m_nIndexStart;
  691. if( pdValue1[k-1] >= pdValue2[k-1] && pdValue1[k] < pdValue2[k]
  692. && pdValue1[k] <= pdValue1[k-1] && pdValue2[k] <= pdValue2[k-1] )
  693. return TRUE;
  694. return FALSE;
  695. }
  697. // 得到金叉或者死叉信号
  698. int CTechnique::GetForkSignal(int nIndex, CSPDWordArray & adwDays,
  699.  UINT itsGoldenFork, UINT itsDeadFork, UINT * pnCode )
  700. {
  701. if( pnCode ) *pnCode = ITSC_NOTHING;
  702. if( nIndex <= 0 )
  703. return ITS_NOTHING;
  705. for( int k=1; k<adwDays.GetSize(); k++ )
  706. {
  707. double dMANow1, dMANow2, dMALast1, dMALast2;
  708. if( !Calculate( &dMANow1, nIndex, min(adwDays[k-1],adwDays[k]), FALSE )
  709. || !Calculate( &dMANow2, nIndex, max(adwDays[k-1],adwDays[k]), FALSE )
  710. || !Calculate( &dMALast1, nIndex-1, min(adwDays[k-1],adwDays[k]), FALSE )
  711. || !Calculate( &dMALast2, nIndex-1, max(adwDays[k-1],adwDays[k]), FALSE ) )
  712. return ITS_NOTHING;
  714. if( dMALast1 <= dMALast2 && dMANow1 > dMANow2
  715. && dMANow1 >= dMALast1 && dMANow2 >= dMALast2 )
  716. {
  717. if( adwDays.GetSize()-1 == k )
  718. {
  719. if( pnCode ) *pnCode = ITSC_GOLDENFORK;
  720. return itsGoldenFork;
  721. }
  722. for( int l=k+1; l<adwDays.GetSize(); l++ )
  723. {
  724. double dMANow3, dMALast3;
  725. if( !Calculate( &dMANow3, nIndex, adwDays[l], FALSE )
  726. || !Calculate( &dMALast3, nIndex-1, adwDays[l], FALSE ) )
  727. return ITS_NOTHING;
  728. if( dMANow3 >= dMALast3 )
  729. {
  730. if( pnCode ) *pnCode = ITSC_GOLDENFORK;
  731. return itsGoldenFork;
  732. }
  733. }
  734. }
  735. if( dMALast1 >= dMALast2 && dMANow1 < dMANow2
  736. && dMANow1 <= dMALast1 && dMANow2 <= dMALast2 )
  737. {
  738. if( adwDays.GetSize()-1 == k )
  739. {
  740. if( pnCode ) *pnCode = ITSC_DEADFORK;
  741. return itsDeadFork;
  742. }
  743. for( int l=k+1; l<adwDays.GetSize(); l++ )
  744. {
  745. double dMANow3, dMALast3;
  746. if( !Calculate( &dMANow3, nIndex, adwDays[l], FALSE )
  747. || !Calculate( &dMALast3, nIndex-1, adwDays[l], FALSE ) )
  748. return ITS_NOTHING;
  749. if( dMANow3 <= dMALast3 )
  750. {
  751. if( pnCode ) *pnCode = ITSC_DEADFORK;
  752. return itsDeadFork;
  753. }
  754. }
  755. }
  756. }
  757. return ITS_NOTHING;
  758. }
  760. // 得到金叉或者死叉信号
  761. int CTechnique::GetForkSignal( int nIndex, UINT itsGoldenFork, UINT itsDeadFork, UINT *pnCode )
  762. {
  763. if( pnCode ) *pnCode = ITSC_NOTHING;
  764. if( nIndex <= 0 )
  765. return ITS_NOTHING;
  767. double dLast1 = 0, dLast2 = 0, dNow1 = 0, dNow2 = 0;
  768. if( !Calculate( &dLast1, &dLast2, nIndex-1, FALSE )
  769. || !Calculate( &dNow1, &dNow2, nIndex, FALSE ) )
  770. return ITS_NOTHING;
  772. if( dLast1 <= dLast2 && dNow1 > dNow2
  773. && dNow1 >= dLast1 && dNow2 >= dLast2 )
  774. {
  775. if( pnCode ) *pnCode = ITSC_GOLDENFORK;
  776. return itsGoldenFork;
  777. }
  778. if( dLast1 >= dLast2 && dNow1 < dNow2
  779. && dNow1 <= dLast1 && dNow2 <= dLast2 )
  780. {
  781. if( pnCode ) *pnCode = ITSC_DEADFORK;
  782. return itsDeadFork;
  783. }
  785. return ITS_NOTHING;
  786. }
  788. // 得到金叉或者死叉信号
  789. int CTechnique::GetForkSignal(int nIndex, double * pdValue1, double * pdValue2,
  790.   UINT itsGoldenFork, UINT itsDeadFork, UINT *pnCode )
  791. {
  792. if( pnCode ) *pnCode = ITSC_NOTHING;
  794. if( IsGoldenFork( nIndex, pdValue1, pdValue2 ) )
  795. {
  796. if( pnCode ) *pnCode = ITSC_GOLDENFORK;
  797. return itsGoldenFork;
  798. }
  799. if( IsDeadFork( nIndex, pdValue1, pdValue2 ) )
  800. {
  801. if( pnCode ) *pnCode = ITSC_DEADFORK;
  802. return itsDeadFork;
  803. }
  804. return ITS_NOTHING;
  805. }
  807. // 得到趋势信号
  808. int CTechnique::GetTrendIntensity(int nIndex, CSPDWordArray & adwDays,
  809.  UINT itsLong, UINT itsShort, UINT * pnCode )
  810. {
  811. if( pnCode ) *pnCode = ITSC_NOTHING;
  812. if( nIndex <= 0 )
  813. return ITS_NOTHING;
  815. int nRet = ITS_NOTHING;
  816. for( int k=1; k<adwDays.GetSize(); k++ )
  817. {
  818. double dMALast1, dMALast2, dMANow1, dMANow2;
  819. if( !Calculate( &dMALast1, nIndex-1, min(adwDays[k-1],adwDays[k]), FALSE )
  820. || !Calculate( &dMALast2, nIndex-1, max(adwDays[k-1],adwDays[k]), FALSE )
  821. || !Calculate( &dMANow1, nIndex, min(adwDays[k-1],adwDays[k]), FALSE )
  822. || !Calculate( &dMANow2, nIndex, max(adwDays[k-1],adwDays[k]), FALSE ) )
  823. return ITS_NOTHING;
  825. if( dMANow1 >= dMALast1 && dMANow2 >= dMALast2
  826. && dMANow1 > dMANow2 && (dMANow1-dMANow2)>=(dMALast1-dMALast2)
  827. && (ITS_ISBUY(nRet) || 1==k) )
  828. {
  829. if( pnCode ) *pnCode = ITSC_LONG;
  830. nRet = itsLong;
  831. }
  832. else if( dMANow1 <= dMALast1 && dMANow2 <= dMALast2
  833. && dMANow1 < dMANow2 && (dMANow1-dMANow2)<=(dMALast1-dMALast2)
  834. && (ITS_ISSELL(nRet) || 1==k) )
  835. {
  836. if( pnCode ) *pnCode = ITSC_SHORT;
  837. nRet = itsShort;
  838. }
  839. else
  840. {
  841. if( pnCode ) *pnCode = ITSC_NOTHING;
  842. return ITS_NOTHING;
  843. }
  844. }
  845. return nRet;
  846. }
  848. // 得到趋势信号
  849. int CTechnique::GetTrendIntensity1( int nIndex, UINT itsLong, UINT itsShort, UINT *pnCode )
  850. {
  851. if( pnCode ) *pnCode = ITSC_NOTHING;
  852. if( nIndex <= 0 )
  853. return ITS_NOTHING;
  855. double dLast = 0, dNow = 0;
  856. if( !Calculate( &dLast, nIndex-1, FALSE )
  857. || !Calculate( &dNow, nIndex, FALSE ) )
  858. return ITS_NOTHING;
  860. if( dNow > dLast )
  861. {
  862. if( pnCode ) *pnCode = ITSC_LONG;
  863. return itsLong;
  864. }
  865. if( dNow < dLast )
  866. {
  867. if( pnCode ) *pnCode = ITSC_SHORT;
  868. return itsShort;
  869. }
  870. return ITS_NOTHING;
  871. }
  873. // 得到趋势信号
  874. int CTechnique::GetTrendIntensity2( int nIndex, UINT itsLong, UINT itsShort, UINT *pnCode )
  875. {
  876. if( pnCode ) *pnCode = ITSC_NOTHING;
  877. if( nIndex <= 0 )
  878. return ITS_NOTHING;
  880. double dLast1 = 0, dLast2 = 0, dNow1 = 0, dNow2 = 0;
  881. if( Calculate( &dLast1, &dLast2, nIndex-1, FALSE )
  882. && Calculate( &dNow1, &dNow2, nIndex, FALSE ) )
  883. {
  884. if( dNow1 >= dLast1 && dNow2 >= dLast2
  885. && dNow1 > dNow2 && (dNow1-dNow2)>=(dLast1-dLast2) )
  886. {
  887. if( pnCode ) *pnCode = ITSC_LONG;
  888. return itsLong;
  889. }
  890. if( dNow1 <= dLast1 && dNow2 <= dLast2
  891. && dNow1 < dNow2 && (dNow1-dNow2)<=(dLast1-dLast2) )
  892. {
  893. if( pnCode ) *pnCode = ITSC_SHORT;
  894. return itsShort;
  895. }
  896. }
  897. return ITS_NOTHING;
  898. }
  900. // 得到趋势信号
  901. int CTechnique::GetTrendIntensity(int nIndex, double * pdValue1, double * pdValue2,
  902.   UINT itsLong, UINT itsShort, UINT *pnCode )
  903. {
  904. if( pnCode ) *pnCode = ITSC_NOTHING;
  906. SP_ASSERT( NULL != pdValue1 && NULL != pdValue2 );
  907. if( NULL == pdValue1 || NULL == pdValue2 )
  908. return FALSE;
  909. if( m_nLength <= 0 || m_nIndexStart < 0
  910. || nIndex < m_nIndexStart || nIndex-m_nIndexStart>=m_nLength
  911. || nIndex-m_nIndexStart < 1 )
  912. return FALSE;
  914. int k = nIndex-m_nIndexStart;
  915. if( pdValue1[k] >= pdValue1[k-1] && pdValue2[k] >= pdValue2[k-1]
  916. && pdValue1[k] > pdValue2[k] && (pdValue1[k]-pdValue2[k])>=(pdValue1[k-1]-pdValue2[k-1]) )
  917. {
  918. if( pnCode ) *pnCode = ITSC_LONG;
  919. return itsLong;
  920. }
  921. if( pdValue1[k] <= pdValue1[k-1] && pdValue2[k] <= pdValue2[k-1]
  922. && pdValue1[k] < pdValue2[k] && (pdValue1[k]-pdValue2[k])<=(pdValue1[k-1]-pdValue2[k-1]) )
  923. {
  924. if( pnCode ) *pnCode = ITSC_SHORT;
  925. return itsShort;
  926. }
  927. return ITS_NOTHING;
  928. }
  930. void CTechnique::SetDefaultParameters( )
  931. {
  932. SP_ASSERT( FALSE );
  933. }
  935. void CTechnique::AttachParameters( CTechnique & src )
  936. {
  937. SP_ASSERT( FALSE );
  938. }
  940. BOOL CTechnique::IsValidParameters( )
  941. {
  942. SP_ASSERT( FALSE );
  943. return FALSE;
  944. }
  946. // 创建新的技术指标对象
  947. CTechnique * CTechnique::CreateTechnique( UINT nTech, CKData * pKData )
  948. {
  949. CTechnique * pTech = NULL;
  950. switch( nTech )
  951. {
  952. case STT_MA: pTech = new CMA( pKData ); break;
  953. case STT_BBI: pTech = new CBBI( pKData ); break;
  954. case STT_BOLL: pTech = new CBOLL( pKData ); break;
  955. case STT_PV: pTech = new CPV( pKData ); break;
  956. case STT_SAR: pTech = new CSAR( pKData ); break;
  957. case STT_DJ: pTech = new CDJ( pKData ); break;
  958. case STT_CW: pTech = new CCW( pKData ); break;
  960. case STT_MACD: pTech = new CMACD( pKData ); break;
  961. case STT_MIKE: pTech = new CMIKE( pKData ); break;
  962. case STT_PSY: pTech = new CPSY( pKData ); break;
  964. case STT_VOLUME: pTech = new CVOLUME( pKData ); break;
  965. case STT_NVI: pTech = new CNVI( pKData ); break;
  966. case STT_PVI: pTech = new CPVI( pKData ); break;
  967. case STT_VR: pTech = new CVR( pKData ); break;
  968. case STT_VROC: pTech = new CVROC( pKData ); break;
  969. case STT_OBV: pTech = new COBV( pKData ); break;
  970. case STT_MOBV: pTech = new CMOBV( pKData ); break;
  971. case STT_MFI: pTech = new CMFI( pKData ); break;
  972. case STT_VMACD: pTech = new CVMACD( pKData ); break;
  973. case STT_WVAD: pTech = new CWVAD( pKData ); break;
  974. case STT_EMV: pTech = new CEMV( pKData ); break;
  975. case STT_VRSI: pTech = new CVRSI( pKData ); break;
  976. case STT_NVRSI: pTech = new CNVRSI( pKData ); break;
  977. case STT_AD: pTech = new CAD( pKData ); break;
  978. case STT_CI: pTech = new CCI( pKData ); break;
  980. case STT_KDJ: pTech = new CKDJ( pKData ); break;
  981. case STT_R: pTech = new CR( pKData ); break;
  982. case STT_RSI: pTech = new CRSI( pKData ); break;
  983. case STT_BIAS: pTech = new CBIAS( pKData ); break;
  984. case STT_MTM: pTech = new CMTM( pKData ); break;
  985. case STT_DMI: pTech = new CDMI( pKData ); break;
  986. case STT_ROC: pTech = new CROC( pKData ); break;
  987. case STT_CCI: pTech = new CCCI( pKData ); break;
  988. case STT_CV: pTech = new CCV( pKData ); break;
  989. case STT_ARBR: pTech = new CARBR( pKData ); break;
  990. case STT_CR: pTech = new CCR( pKData ); break;
  991. case STT_OSC: pTech = new COSC( pKData ); break;
  992. case STT_UOS: pTech = new CUOS( pKData ); break;
  993. case STT_MAOSC: pTech = new CMAOSC( pKData ); break;
  994. case STT_36BIAS: pTech = new C36BIAS( pKData ); break;
  995. case STT_DPO: pTech = new CDPO( pKData ); break;
  996. case STT_KST: pTech = new CKST( pKData ); break;
  998. case STT_REI: pTech = new CREI( pKData ); break;
  999. case STT_DMKI: pTech = new CDMKI( pKData ); break;
  1000. case STT_PCNT: pTech = new CPCNT( pKData ); break;
  1001. case STT_HLC: pTech = new CHLC( pKData ); break;
  1002. case STT_CDP: pTech = new CCDP( pKData ); break;
  1003. case STT_ASI: pTech = new CASI( pKData ); break;
  1004. case STT_ATR: pTech = new CATR( pKData ); break;
  1006. case STT_CYO: pTech = new CCYO( pKData ); break;
  1007. case STT_DCYO: pTech = new CDCYO( pKData ); break;
  1008. case STT_HSL: pTech = new CHSL( pKData ); break;
  1009. case STT_DPER: pTech = new CDPER( pKData ); break;
  1011. default:
  1012. SP_ASSERT( FALSE );
  1013. }
  1014. return pTech;
  1015. }
  1017. // 得到买卖信号
  1018. int CTechnique::GetSignal( int nIndex, UINT * pnCode )
  1019. {
  1020. if( pnCode ) *pnCode = ITSC_NOTHING;
  1021. return ITS_NOTHING;
  1022. }
  1024. // 得到趋势信号
  1025. int CTechnique::GetIntensity( int nIndex, UINT * pnCode, BOOL bTraceBack )
  1026. {
  1027. UINT nCode = ITSC_NOTHING;
  1028. int nSignal = GetSignal( nIndex, &nCode );
  1029. if( ITS_NOTHING != nSignal )
  1030. {
  1031. m_nLastIntensity = nSignal;
  1032. m_nLastIntensityCode = nCode;
  1033. if( pnCode ) *pnCode = nCode;
  1034. return nSignal;
  1035. }
  1037. if( m_nLastIntensity > 1 )
  1038. m_nLastIntensity --;
  1039. if( m_nLastIntensity < -1  )
  1040. m_nLastIntensity ++;
  1042. if( bTraceBack && ITS_NOTHING == m_nLastIntensity )
  1043. m_nLastIntensity = GetIntensityTraceback( nIndex, &m_nLastIntensityCode );
  1045. if( pnCode ) *pnCode = m_nLastIntensityCode;
  1046. return m_nLastIntensity;
  1047. }
  1049. int CTechnique::GetIntensityTraceback( int nIndex, UINT * pnCode )
  1050. {
  1051. if( pnCode ) *pnCode = ITSC_NOTHING;
  1053. int nIntensity = ITS_NOTHING;
  1054. UINT nCode = ITSC_NOTHING;
  1055. for( int k=nIndex; k>=0; k -- )
  1056. {
  1057. nIntensity = GetSignal(k,&nCode);
  1058. if( ITS_NOTHING != nIntensity )
  1059. break;
  1060. }
  1061. if( k < 0 )
  1062. return ITS_NOTHING;
  1063. for( k=k+1; k<=nIndex; k++ )
  1064. {
  1065. if( nIntensity > 1 )
  1066. nIntensity --;
  1067. else if( nIntensity < -1  )
  1068. nIntensity ++;
  1069. else
  1070. break;
  1071. }
  1072. if( pnCode ) *pnCode = nCode;
  1073. return nIntensity;
  1074. }
  1076. BOOL CTechnique::GetMinMaxInfo( int nStart, int nEnd, double *pdMin, double *pdMax )
  1077. {
  1078. SP_ASSERT( FALSE );
  1079. return FALSE;
  1080. }
  1082. BOOL CTechnique::Calculate( double * pValue, int nIndex, int nDays, BOOL bUseLast )
  1083. {
  1084. SP_ASSERT( FALSE );
  1085. return FALSE;
  1086. }
  1088. BOOL CTechnique::Calculate( double * pValue, int nIndex, BOOL bUseLast )
  1089. {
  1090. SP_ASSERT( FALSE );
  1091. return FALSE;
  1092. }
  1094. BOOL CTechnique::Calculate( double * pValue1, double * pValue2, int nIndex, BOOL bUseLast )
  1095. {
  1096. SP_ASSERT( FALSE );
  1097. return FALSE;
  1098. }
  1100. BOOL CTechnique::Calculate( double * pValue1, double * pValue2, double * pValue3, int nIndex, BOOL bUseLast )
  1101. {
  1102. SP_ASSERT( FALSE );
  1103. return FALSE;
  1104. }
  1106. BOOL CTechnique::Calculate( double * pValue1, double * pValue2, double * pValue3, double *pValue4, int nIndex, BOOL bUseLast )
  1107. {
  1108. SP_ASSERT( FALSE );
  1109. return FALSE;
  1110. }
  1112. BOOL CTechnique::Calculate( double * pValue1, double * pValue2, double * pValue3, double *pValue4, double *pValue5, int nIndex, BOOL bUseLast )
  1113. {
  1114. SP_ASSERT( FALSE );
  1115. return FALSE;
  1116. }
  1118. // 计算指标值和均值
  1119. BOOL CTechnique::CalculateMA( double * pValue, double * pMA, int nIndex, BOOL bUseLast, int nMADays )
  1120. {
  1121. STT_ASSERT_CALCULATE1( m_pKData, nIndex );
  1123. if( nMADays > nIndex+1 )
  1124. return FALSE;
  1126. if( LoadFromCache( nIndex, pValue, pMA ) )
  1127. return TRUE;
  1129. double dValue = 0, dMA = 0;
  1130. int nCount = 0;
  1131. for( int k=nIndex; k>=0; k-- )
  1132. {
  1133. double dTemp = 0;
  1134. if( Calculate( &dTemp, k, FALSE ) )
  1135. {
  1136. if( nIndex == k )
  1137. dValue = dTemp;
  1138. dMA += dTemp;
  1140. nCount ++;
  1141. if( nCount == nMADays )
  1142. {
  1143. dMA = dMA / nMADays;
  1144. if( pValue ) *pValue = dValue;
  1145. if( pMA ) *pMA = dMA;
  1146. StoreToCache( nIndex, pValue, pMA );
  1147. return TRUE;
  1148. }
  1149. }
  1150. }
  1151. return FALSE;
  1152. }