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

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

金融证券系统

开发平台：

Visual C++

Minute.cpp：源码内容
  1. /*
  2. Cross Platform Core Code.
  4. Copyright(R) 2001-2002 Balang Software.
  5. All rights reserved.
  7. Using:
  8. class CMinute;
  9. */
  11. #include "StdAfx.h"
  12. #include "../Include/Stock.h"
  14. #ifdef _DEBUG
  15. #undef THIS_FILE
  16. static char THIS_FILE[] = __FILE__;
  17. #endif
  19. #ifdef _DEBUG
  20. #define new DEBUG_NEW
  21. #endif
  23. /////////////////////////////////////////////////////////////////////////////
  25. CMinute::CMinute()
  26. {
  27. m_pData = NULL;
  28. m_nSize = m_nMaxSize = m_nGrowBy = 0;
  29. }
  31. CMinute::CMinute( const CMinute &src )
  32. {
  33. m_pData = NULL;
  34. m_nSize = m_nMaxSize = m_nGrowBy = 0;
  36. *this = src;
  37. }
  39. CMinute::~CMinute()
  40. {
  41. if( m_pData )
  42. delete [] (BYTE*)m_pData;
  43. }
  45. void CMinute::SetSize(int nNewSize, int nGrowBy /* = -1 */)
  46. {
  47. SP_ASSERT(nNewSize >= 0);
  49. if (nGrowBy != -1)
  50. m_nGrowBy = nGrowBy;  // set new size
  52. if (nNewSize == 0)
  53. {
  54. // shrink to nothing
  55. delete [] (BYTE*)m_pData;
  56. m_pData = NULL;
  57. m_nSize = m_nMaxSize = 0;
  58. }
  59. else if (m_pData == NULL)
  60. {
  61. // create one with exact size
  62. #ifdef SIZE_T_MAX
  63. SP_ASSERT((long)nNewSize * sizeof(MINUTE) <= SIZE_T_MAX);  // no overflow
  64. #endif
  65. m_pData = (MINUTE*) new BYTE[nNewSize * sizeof(MINUTE)];
  67. memset(m_pData, 0, nNewSize * sizeof(MINUTE));  // zero fill
  69. m_nSize = m_nMaxSize = nNewSize;
  70. }
  71. else if (nNewSize <= m_nMaxSize)
  72. {
  73. // it fits
  74. if (nNewSize > m_nSize)
  75. {
  76. // initialize the new elements
  78. memset(&m_pData[m_nSize], 0, (nNewSize-m_nSize) * sizeof(MINUTE));
  80. }
  82. m_nSize = nNewSize;
  83. }
  84. else
  85. {
  86. // Otherwise grow array
  87. int nNewMax;
  88. if (nNewSize < m_nMaxSize + m_nGrowBy)
  89. nNewMax = m_nMaxSize + m_nGrowBy;  // granularity
  90. else
  91. nNewMax = nNewSize;  // no slush
  93. #ifdef SIZE_T_MAX
  94. SP_ASSERT((long)nNewMax * sizeof(MINUTE) <= SIZE_T_MAX);  // no overflow
  95. #endif
  96. MINUTE* pNewData = (MINUTE*) new BYTE[nNewMax * sizeof(MINUTE)];
  98. // copy new data from old
  99. memcpy(pNewData, m_pData, m_nSize * sizeof(MINUTE));
  101. // construct remaining elements
  102. SP_ASSERT(nNewSize > m_nSize);
  104. memset(&pNewData[m_nSize], 0, (nNewSize-m_nSize) * sizeof(MINUTE));
  107. // get rid of old stuff (note: no destructors called)
  108. delete [] (BYTE*)m_pData;
  109. m_pData = pNewData;
  110. m_nSize = nNewSize;
  111. m_nMaxSize = nNewMax;
  112. }
  113. }
  115. void CMinute::FreeExtra()
  116. {
  117. if (m_nSize != m_nMaxSize)
  118. {
  119. // shrink to desired size
  120. #ifdef SIZE_T_MAX
  121. SP_ASSERT((long)m_nSize * sizeof(MINUTE) <= SIZE_T_MAX);  // no overflow
  122. #endif
  123. MINUTE* pNewData = NULL;
  124. if (m_nSize != 0)
  125. {
  126. pNewData = (MINUTE*) new BYTE[m_nSize * sizeof(MINUTE)];
  127. // copy new data from old
  128. memcpy(pNewData, m_pData, m_nSize * sizeof(MINUTE));
  129. }
  131. // get rid of old stuff (note: no destructors called)
  132. delete [] (BYTE*)m_pData;
  133. m_pData = pNewData;
  134. m_nMaxSize = m_nSize;
  135. }
  136. }
  138. /////////////////////////////////////////////////////////////////////////////
  140. void CMinute::SetAtGrow(int nIndex, MINUTE newElement)
  141. {
  142. SP_ASSERT(nIndex >= 0);
  144. if (nIndex >= m_nSize)
  145. SetSize(nIndex+1);
  146. m_pData[nIndex] = newElement;
  147. }
  149. void CMinute::InsertAt(int nIndex, MINUTE newElement, int nCount /*=1*/)
  150. {
  151. SP_ASSERT(nIndex >= 0);    // will expand to meet need
  152. SP_ASSERT(nCount > 0);     // zero or negative size not allowed
  154. if (nIndex >= m_nSize)
  155. {
  156. // adding after the end of the array
  157. SetSize(nIndex + nCount);  // grow so nIndex is valid
  158. }
  159. else
  160. {
  161. // inserting in the middle of the array
  162. int nOldSize = m_nSize;
  163. SetSize(m_nSize + nCount);  // grow it to new size
  164. // shift old data up to fill gap
  165. memmove(&m_pData[nIndex+nCount], &m_pData[nIndex],
  166. (nOldSize-nIndex) * sizeof(MINUTE));
  168. // re-init slots we copied from
  170. memset(&m_pData[nIndex], 0, nCount * sizeof(MINUTE));
  172. }
  174. // insert new value in the gap
  175. SP_ASSERT(nIndex + nCount <= m_nSize);
  176. while (nCount--)
  177. m_pData[nIndex++] = newElement;
  178. }
  180. void CMinute::RemoveAt(int nIndex, int nCount /* = 1 */)
  181. {
  182. SP_ASSERT(nIndex >= 0);
  183. SP_ASSERT(nCount >= 0);
  184. SP_ASSERT(nIndex + nCount <= m_nSize);
  186. // just remove a range
  187. int nMoveCount = m_nSize - (nIndex + nCount);
  189. if (nMoveCount)
  190. memcpy(&m_pData[nIndex], &m_pData[nIndex + nCount],
  191. nMoveCount * sizeof(MINUTE));
  192. m_nSize -= nCount;
  193. }
  195. int CMinute::InsertMinuteSort( MINUTE newElement )
  196. {
  197. if( newElement.m_time <= 0 )
  198. return -1;
  199. else if( newElement.m_fNew < 1e-4 )
  200. return -1;
  201. else if( newElement.m_fVolume < 1e-4 )
  202. return -1;
  203. else if( !CSPTime::InTradeTime( newElement.m_time, 60 ) )
  204. return -1;
  206. time_t tmBegin = 0;
  207. if( GetSize() > 0 )
  208. {
  209. time_t tmLatest = ElementAt(GetSize()-1).m_time;
  210. CSPTime sptime(tmLatest);
  211. CSPTime sptimeBegin(sptime.GetYear(),sptime.GetMonth(),sptime.GetDay(),0,0,0);
  212. tmBegin = sptimeBegin.GetTime();
  213. }
  214. if( newElement.m_time <= tmBegin )
  215. return -1;
  217. for( int i=GetSize()-1; i>=0; i-- )
  218. {
  219. MINUTE & temp = ElementAt(i);
  220. if( newElement.m_time == temp.m_time )
  221. {
  222. SetAt(i,newElement);
  223. return i;
  224. }
  225. if( newElement.m_time > temp.m_time )
  226. {
  227. InsertAt(i+1,newElement);
  228. return i+1;
  229. }
  230. }
  232. InsertAt( 0, newElement );
  233. return 0;
  234. }
  236. int SortMinute(const void *p1,const void *p2)
  237. {
  238. MINUTE *pTemp1 = (MINUTE *)p1;
  239. MINUTE *pTemp2 = (MINUTE *)p2;
  241. if( pTemp1 && pTemp2 && pTemp1->m_time < pTemp2->m_time )
  242. return -1;
  243. else if( pTemp1 && pTemp2 && pTemp1->m_time > pTemp2->m_time )
  244. return 1;
  245. return 0;
  246. }
  248. void CMinute::Sort( )
  249. {
  250. if( m_pData )
  251. qsort( m_pData, GetSize(), sizeof(MINUTE), SortMinute );
  252. }
  254. void CMinute::RemoveDirty( )
  255. {
  256. time_t tmBegin = 0;
  257. if( GetSize() > 0 )
  258. {
  259. time_t tmLatest = ElementAt(GetSize()-1).m_time;
  260. CSPTime sptime(tmLatest);
  261. CSPTime sptimeBegin(sptime.GetYear(),sptime.GetMonth(),sptime.GetDay(),0,0,0);
  262. tmBegin = sptimeBegin.GetTime();
  263. }
  265. for( int i=GetSize()-1; i>=0; i-- )
  266. {
  267. if( ElementAt(i).m_time <= 0 )
  268. RemoveAt(i);
  269. else if( ElementAt(i).m_fNew < 1e-4 )
  270. RemoveAt(i);
  271. else if( ElementAt(i).m_fVolume < 1e-4 )
  272. RemoveAt(i);
  273. else if( !CSPTime::InTradeTime( ElementAt(i).m_time, 60 ) )
  274. RemoveAt(i);
  275. else if( ElementAt(i).m_time < tmBegin )
  276. RemoveAt(i);
  277. else if( i>1 && ElementAt(i).m_time == ElementAt(i-1).m_time )
  278. RemoveAt(i);
  279. }
  280. }
  282. void CMinute::InsertAt(int nStartIndex, CMinute* pNewArray)
  283. {
  284. SP_ASSERT(pNewArray != NULL);
  285. SP_ASSERT(nStartIndex >= 0);
  287. if (pNewArray->GetSize() > 0)
  288. {
  289. InsertAt(nStartIndex, pNewArray->GetAt(0), pNewArray->GetSize());
  290. for (int i = 0; i < pNewArray->GetSize(); i++)
  291. SetAt(nStartIndex + i, pNewArray->GetAt(i));
  292. }
  293. }
  295. CMinute & CMinute::operator = ( const CMinute &src )
  296. {
  297. Copy( src );
  298. return *this;
  299. }
  301. void CMinute::Copy( const CMinute &src )
  302. {
  303. SetSize( 0, src.GetSize()+5 );
  304. for( int i=0; i<src.GetSize(); i++ )
  305. {
  306. Add( src.GetAt(i) );
  307. }
  308. }
  310. BOOL CMinute::StatVolumeInfo( double *pdVolNow, double *pdVolOuter, double *pdVolInner )
  311. {
  312. time_t tmLatest = 0;
  313. double dVolNow = 0, dVolOuter = 0, dVolInner = 0;
  314. double dPriceLast = -1;
  315. BOOL bRise = TRUE;
  316. for( int k=0; k<GetSize(); k++ )
  317. {
  318. if( ElementAt(k).m_time > tmLatest )
  319. {
  320. tmLatest = ElementAt(k).m_time;
  321. dVolNow = ElementAt(k).m_fVolume;
  322. }
  323. double dPrice = ElementAt(k).m_fNew;
  324. if( 0 != k )
  325. {
  326. double dVolume = ElementAt(k).m_fVolume - ElementAt(k-1).m_fVolume;
  327. if( dPrice - dPriceLast > 1e-4 )
  328. bRise = TRUE;
  329. if( dPrice - dPriceLast < -1e-4 )
  330. bRise = FALSE;
  331. if( bRise ) dVolOuter += dVolume;
  332. else dVolInner += dVolume;
  333. }
  334. dPriceLast = dPrice;
  335. }
  337. if( pdVolNow )
  338. *pdVolNow = dVolNow;
  339. if( pdVolOuter )
  340. *pdVolOuter = dVolOuter;
  341. if( pdVolInner )
  342. *pdVolInner = dVolInner;
  343. return TRUE;
  344. }
  346. BOOL CMinute::StatDealInfo( CSPDWordArray & adwPrice, CSPDWordArray & adwVolume, double * pdMaxVolume )
  347. {
  348. adwPrice.RemoveAll();
  349. adwVolume.RemoveAll();
  351. for( int k=0; k<GetSize(); k++ )
  352. adwPrice.AddUnique( DWORD(ElementAt(k).m_fNew * 1000) );
  353. adwPrice.Sort( );
  355. adwVolume.SetSize( adwPrice.GetSize() );
  356. for( k=0; k<GetSize(); k++ )
  357. {
  358. DWORD dwPrice = DWORD(ElementAt(k).m_fNew * 1000);
  359. DWORD dwVolume = DWORD(ElementAt(k).m_fVolume);
  360. if( k > 0 )
  361. dwVolume = DWORD( ElementAt(k).m_fVolume - ElementAt(k-1).m_fVolume );
  363. for( int i=0; i<adwPrice.GetSize(); i++ )
  364. {
  365. if( adwPrice[i] == dwPrice )
  366. break;
  367. }
  368. if( i >= adwPrice.GetSize() )
  369. continue;
  371. adwVolume[i] += dwVolume;
  372. }
  374. double dMaxVolume = 0;
  375. for( k=0; k<adwVolume.GetSize(); k++ )
  376. {
  377. if( dMaxVolume < (double)adwVolume[k] )
  378. dMaxVolume = (double)adwVolume[k];
  379. }
  380. if( pdMaxVolume )
  381. *pdMaxVolume = dMaxVolume;
  383. return adwPrice.GetSize() > 0;
  384. }
  386. BOOL CMinute::GetDiffPercentMin5( double * pValue )
  387. {
  388. if( GetSize( ) < 2 )
  389. return FALSE;
  390. MINUTE & minCurrent = ElementAt(GetSize()-1);
  391. for( int i=GetSize()-2; i>=0; i-- )
  392. {
  393. LONG l = minCurrent.m_time - ElementAt(i).m_time;
  394. if( l >= 200 && l <= 600 )
  395. {
  396. if( ElementAt(i).m_fNew > 1e-4 && minCurrent.m_fNew > 1e-4 )
  397. {
  398. if( pValue ) *pValue = 100*minCurrent.m_fNew / ElementAt(i).m_fNew - 100;
  399. return TRUE;
  400. }
  401. break;
  402. }
  403. }
  405. return FALSE;
  406. }
  408. BOOL CMinute::GetLBDKMinMaxInfo( double dVolAverage, double *pdMin, double *pdMax )
  409. {
  410. if( dVolAverage < 1e-4 )
  411. return FALSE;
  413. double dMulti = 1 / dVolAverage;
  414. double dMin = 0, dMax = 1;
  415. for( int i=0; i<GetSize(); i++ )
  416. {
  417. CSPTime sptime(ElementAt(i).m_time);
  418. double dCurrent = dMulti * ElementAt(i).m_fVolume / CSPTime::GetTimeTradeRatioOfOneDay( sptime, sptime );
  419. if( 0 == i )
  420. {
  421. dMin = dCurrent;
  422. dMax = dCurrent;
  423. }
  424. if( dCurrent < dMin ) dMin = dCurrent;
  425. if( dCurrent > dMax ) dMax = dCurrent;
  426. }
  428. if( dMax < 1e-4 ) // 数据为零，缺省dMax=1
  429. dMax = 1;
  430. if( pdMin ) *pdMin = dMin;
  431. if( pdMax ) *pdMax = dMax;
  432. return TRUE;
  433. }
  435. BOOL CMinute::GetIndexWave( double *pdWave, int nIndex )
  436. {
  437. double dWave = 0;
  438. for( int k=nIndex-12; k<=nIndex; k++ )
  439. {
  440. if( k > 0 && k < GetSize() )
  441. dWave += ElementAt(k).m_fNew - ElementAt(k-1).m_fNew;
  442. }
  443. if( pdWave )
  444. *pdWave = dWave;
  445. return TRUE;
  446. }
  448. int CMinute::ToKData( CKData & kdata )
  449. {
  450. // WILLCHECK
  452. kdata.Clear();
  453. if( GetSize() <= 0 )
  454. return 0;
  455. DWORD dwType = ElementAt(0).m_dwType;
  456. if( 5 == dwType || 15 == dwType || 30 == dwType || 60 == dwType )
  457. {
  458. if( 5 == dwType )
  459. kdata.SetKType(CKData::ktypeMin5);
  460. else if( dwType )
  461. kdata.SetKType(CKData::ktypeMin15);
  462. else if( 30 == dwType )
  463. kdata.SetKType(CKData::ktypeMin30);
  464. else if( 60 == dwType )
  465. kdata.SetKType(CKData::ktypeMin60);
  466. kdata.SetSize( 0, GetSize() + 1 );
  467. for( int i=0; i<GetSize(); i++ )
  468. {
  469. MINUTE & min = ElementAt(i);
  470. KDATA kd;
  471. memset( &kd, 0, sizeof(kd) );
  472. kd.m_dwMarket = min.m_dwMarket;
  473. strncpy( kd.m_szCode, min.m_szCode, sizeof(kd.m_szCode)-1 );
  474. kd.m_time = min.m_time;
  475. CSPTime sptime(min.m_time);
  476. kd.m_date = sptime.ToStockTimeMin();
  477. kd.m_fOpen = (min.m_fHigh+min.m_fLow+min.m_fNew)/3;
  478. kd.m_fHigh = min.m_fHigh;
  479. kd.m_fLow = min.m_fLow;
  480. kd.m_fClose = min.m_fNew;
  481. kd.m_fVolume = min.m_fVolume;
  482. kd.m_fAmount = min.m_fAmount;
  483. kdata.Add( kd );
  484. }
  485. return kdata.GetSize();
  486. }
  488. kdata.SetKType(CKData::ktypeMin5);
  489. kdata.SetSize( 0, GetSize() / 5 + 5 );
  491. int nCount = 0;
  492. KDATA kd;
  493. for( int pos=0; pos<GetSize(); pos++ )
  494. {
  495. MINUTE & min = ElementAt( pos );
  497. nCount ++;
  498. if( 1 == nCount )
  499. {
  500. memset( &kd, 0, sizeof(kd) );
  501. kd.m_dwMarket = min.m_dwMarket;
  502. strncpy( kd.m_szCode, min.m_szCode, sizeof(kd.m_szCode)-1 );
  503. kd.m_fOpen = min.m_fNew;
  504. kd.m_fHigh = min.m_fHigh;
  505. kd.m_fLow = min.m_fLow;
  506. kd.m_fClose = min.m_fNew;
  507. kd.m_fVolume = min.m_fVolume;
  508. kd.m_fAmount = min.m_fAmount;
  509. }
  510. else
  511. {
  512. if( kd.m_fHigh < min.m_fHigh ) kd.m_fHigh = min.m_fHigh;
  513. if( kd.m_fLow > min.m_fLow ) kd.m_fLow = min.m_fLow;
  514. kd.m_fAmount += min.m_fAmount;
  515. kd.m_fVolume += min.m_fVolume;
  516. kd.m_fClose = min.m_fNew;
  517. }
  519. CSPTime sptime(min.m_time);
  520. DWORD date = sptime.ToStockTimeMin();
  521. if( !(date % 5) )
  522. {
  523. kd.m_time = min.m_time;
  524. kd.m_date = date;
  525. kdata.Add( kd );
  526. nCount = 0;
  527. }
  528. }
  530. return kdata.GetSize();
  531. }
  532. /////////////////////////////////////////////////////////////////////////////