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

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

金融证券系统

开发平台：

Visual C++

Report.cpp：源码内容
  1. /*
  2. Cross Platform Core Code.
  4. Copyright(R) 2001-2002 Balang Software.
  5. All rights reserved.
  7. Using:
  8. class CReport;
  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. CReport::CReport()
  26. {
  27. m_pData = NULL;
  28. m_nSize = m_nMaxSize = m_nGrowBy = 0;
  29. }
  31. CReport::CReport( const CReport &src )
  32. {
  33. m_pData = NULL;
  34. m_nSize = m_nMaxSize = m_nGrowBy = 0;
  36. *this = src;
  37. }
  39. CReport::~CReport()
  40. {
  41. if( m_pData )
  42. delete [] (BYTE*)m_pData;
  43. }
  45. void CReport::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(REPORT) <= SIZE_T_MAX);  // no overflow
  64. #endif
  65. m_pData = (REPORT*) new BYTE[nNewSize * sizeof(REPORT)];
  67. memset(m_pData, 0, nNewSize * sizeof(REPORT));  // 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(REPORT));
  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(REPORT) <= SIZE_T_MAX);  // no overflow
  95. #endif
  96. REPORT* pNewData = (REPORT*) new BYTE[nNewMax * sizeof(REPORT)];
  98. // copy new data from old
  99. memcpy(pNewData, m_pData, m_nSize * sizeof(REPORT));
  101. // construct remaining elements
  102. SP_ASSERT(nNewSize > m_nSize);
  104. memset(&pNewData[m_nSize], 0, (nNewSize-m_nSize) * sizeof(REPORT));
  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 CReport::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(REPORT) <= SIZE_T_MAX);  // no overflow
  122. #endif
  123. REPORT* pNewData = NULL;
  124. if (m_nSize != 0)
  125. {
  126. pNewData = (REPORT*) new BYTE[m_nSize * sizeof(REPORT)];
  127. // copy new data from old
  128. memcpy(pNewData, m_pData, m_nSize * sizeof(REPORT));
  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 CReport::SetAtGrow(int nIndex, REPORT newElement)
  141. {
  142. SP_ASSERT(nIndex >= 0);
  144. if (nIndex >= m_nSize)
  145. SetSize(nIndex+1);
  146. m_pData[nIndex] = newElement;
  147. }
  149. void CReport::InsertAt(int nIndex, REPORT 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(REPORT));
  168. // re-init slots we copied from
  170. memset(&m_pData[nIndex], 0, nCount * sizeof(REPORT));
  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 CReport::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(REPORT));
  192. m_nSize -= nCount;
  193. }
  195. void CReport::InsertAt(int nStartIndex, CReport* pNewArray)
  196. {
  197. SP_ASSERT(pNewArray != NULL);
  198. SP_ASSERT(nStartIndex >= 0);
  200. if (pNewArray->GetSize() > 0)
  201. {
  202. InsertAt(nStartIndex, pNewArray->GetAt(0), pNewArray->GetSize());
  203. for (int i = 0; i < pNewArray->GetSize(); i++)
  204. SetAt(nStartIndex + i, pNewArray->GetAt(i));
  205. }
  206. }
  208. int CReport::InsertReportSort( REPORT newElement )
  209. {
  210. if( newElement.m_time <= 0 )
  211. return -1;
  212. if( newElement.m_fNew < 1e-4 )
  213. return -1;
  214. if( newElement.m_fVolume < 1e-4 )
  215. return -1;
  216. if( !CSPTime::InTradeTime( newElement.m_time, 60 ) )
  217. return -1;
  219. for( int i=GetSize()-1; i>=0; i-- )
  220. {
  221. REPORT & temp = ElementAt(i);
  222. if( newElement.m_time == temp.m_time )
  223. {
  224. SetAt(i,newElement);
  225. return i;
  226. }
  227. if( fabs(newElement.m_fVolume - temp.m_fVolume) < 1e-4 )
  228. {
  229. SetAt(i,newElement);
  230. return i;
  231. }
  232. if( newElement.m_time >= temp.m_time && newElement.m_fVolume > temp.m_fVolume )
  233. {
  234. InsertAt(i+1,newElement);
  235. return i+1;
  236. }
  237. if( newElement.m_time > temp.m_time && newElement.m_fVolume < temp.m_fVolume )
  238. return -1;
  239. if( newElement.m_time < temp.m_time && newElement.m_fVolume > temp.m_fVolume )
  240. return -1;
  241. }
  243. InsertAt( 0, newElement );
  244. return 0;
  245. }
  247. int SortReport(const void *p1,const void *p2)
  248. {
  249. REPORT *pTemp1 = (REPORT *)p1;
  250. REPORT *pTemp2 = (REPORT *)p2;
  252. if( pTemp1 && pTemp2 && pTemp1->m_time < pTemp2->m_time )
  253. return -1;
  254. else if( pTemp1 && pTemp2 && pTemp1->m_time > pTemp2->m_time )
  255. return 1;
  256. if( pTemp1 && pTemp2 && pTemp1->m_fVolume < pTemp2->m_fVolume )
  257. return -1;
  258. else if( pTemp1 && pTemp2 && pTemp1->m_fVolume > pTemp2->m_fVolume )
  259. return 1;
  260. return 0;
  261. }
  263. void CReport::Sort( )
  264. {
  265. if( m_pData )
  266. qsort( m_pData, GetSize(), sizeof(REPORT), SortReport );
  267. }
  269. void CReport::RemoveDirty( )
  270. {
  271. for( int i=GetSize()-1; i>=0; i-- )
  272. {
  273. if( ElementAt(i).m_time <= 0 )
  274. RemoveAt(i);
  275. else if( ElementAt(i).m_fNew < 1e-4 )
  276. RemoveAt(i);
  277. else if( ElementAt(i).m_fVolume < 1e-4 )
  278. RemoveAt(i);
  279. else if( !CSPTime::InTradeTime( ElementAt(i).m_time, 60 ) )
  280. RemoveAt(i);
  281. else if( i>0 && ElementAt(i).m_fVolume - ElementAt(i-1).m_fVolume < 1e-4 )
  282. RemoveAt(i);
  283. }
  284. }
  286. CReport & CReport::operator = ( const CReport &src )
  287. {
  288. Copy( src );
  289. return *this;
  290. }
  292. void CReport::Copy( const CReport &src )
  293. {
  294. SetSize( 0, src.GetSize()+5 );
  295. for( int i=0; i<src.GetSize(); i++ )
  296. {
  297. Add( src.GetAt(i) );
  298. }
  299. }
  301. BOOL CReport::GetMMLD( int nIndex, double *pdVolBuy, double *pdVolSell, double * pdVolDiff )
  302. {
  303. SP_ASSERT( nIndex >= 0 && nIndex < GetSize() );
  304. if( nIndex < 0 || nIndex > GetSize()-1 )
  305. return FALSE;
  307. double dVolBuy = 0;
  308. double dVolSell = 0;
  309. REPORT & rpt = ElementAt(nIndex);
  310. for(int k=0; k<sizeof(rpt.m_fBuyVolume)/sizeof(rpt.m_fBuyVolume[0]); k++ )
  311. dVolBuy += rpt.m_fBuyVolume[k];
  312. for( k=0; k<sizeof(rpt.m_fSellVolume)/sizeof(rpt.m_fSellVolume[0]); k++ )
  313. dVolSell += rpt.m_fSellVolume[k];
  315. if( pdVolBuy ) *pdVolBuy = dVolBuy;
  316. if( pdVolSell ) *pdVolSell = dVolSell;
  317. if( pdVolDiff ) *pdVolDiff = (dVolBuy-dVolSell);
  318. return TRUE;
  319. }
  321. BOOL CReport::GetMMLDMinMaxInfo( double *pdMin, double *pdMax )
  322. {
  323. double dMin = 0, dMax = 1;
  324. for( int i=0; i<GetSize(); i++ )
  325. {
  326. double dVolBuy = 0;
  327. double dVolSell = 0;
  328. GetMMLD( i, &dVolBuy, &dVolSell, NULL );
  330. if( 0 == i )
  331. {
  332. dMin = dVolBuy;
  333. dMax = dVolBuy;
  334. }
  335. if( dVolBuy < dMin ) dMin = dVolBuy;
  336. if( dVolBuy > dMax ) dMax = dVolBuy;
  337. if( dVolSell < dMin ) dMin = dVolSell;
  338. if( dVolSell > dMax ) dMax = dVolSell;
  339. }
  341. if( dMax < 500 )
  342. dMax = 500; // 最小为5手
  344. if( pdMin ) *pdMin = dMin;
  345. if( pdMax ) *pdMax = dMax;
  346. return TRUE;
  347. }
  349. BOOL CReport::StatBuySellEx( float * fSellPrice, float * fSellVolume, float * fBuyPrice, float * fBuyVolume, int nSize )
  350. {
  351. for( int k=0; k<nSize; k++ )
  352. {
  353. fSellPrice[k] = 0.;
  354. fSellVolume[k] = 0.;
  355. fBuyPrice[k] = 0.;
  356. fBuyVolume[k] = 0.;
  357. }
  359. CSPDWordArray adwSellPrice, adwSellVolume, adwBuyPrice, adwBuyVolume;
  360. REPORT rpt;
  361. memset( &rpt, 0, sizeof(rpt) );
  362. int nBSCount = sizeof(rpt.m_fBuyPrice)/sizeof(float);
  364. for( k=0; k<GetSize(); k++ )
  365. {
  366. REPORT & report = ElementAt(k);
  368. // Insert
  369. for( int i=nBSCount-1; i>=0; i-- )
  370. {
  371. if( report.m_fSellPrice[i] > 1e-4 )
  372. {
  373. adwSellPrice.InsertAt( 0, DWORD(report.m_fSellPrice[i]*1000) );
  374. adwSellVolume.InsertAt( 0, DWORD(report.m_fSellVolume[i]) );
  375. }
  376. if( report.m_fBuyPrice[i] > 1e-4 )
  377. {
  378. adwBuyPrice.InsertAt( 0, DWORD(report.m_fBuyPrice[i]*1000) );
  379. adwBuyVolume.InsertAt( 0, DWORD(report.m_fBuyVolume[i]) );
  380. }
  381. }
  383. // Remove 
  384. DWORD dwSellMin = 0;
  385. for( i=0; i<adwSellPrice.GetSize(); i++ )
  386. {
  387. if( adwSellPrice[i] < dwSellMin+1e-4 )
  388. {
  389. adwSellPrice.RemoveAt(i);
  390. adwSellVolume.RemoveAt(i);
  391. i --;
  392. }
  393. else
  394. {
  395. dwSellMin = adwSellPrice[i];
  396. }
  397. }
  399. DWORD dwBuyMax = 0;
  400. for( i=0; i<adwBuyPrice.GetSize(); i++ )
  401. {
  402. if( 0 != dwBuyMax && adwBuyPrice[i] > dwBuyMax-1e-4 )
  403. {
  404. adwBuyPrice.RemoveAt(i);
  405. adwBuyVolume.RemoveAt(i);
  406. i --;
  407. }
  408. else
  409. {
  410. dwBuyMax = adwBuyPrice[i];
  411. }
  412. }
  413. }
  415. // Store
  416. for( k=0; k<nSize && k<adwSellPrice.GetSize(); k++ )
  417. {
  418. fSellPrice[k] = float(0.001 * adwSellPrice[k]);
  419. fSellVolume[k] = float(adwSellVolume[k]);
  420. }
  421. for( k=0; k<nSize && k<adwBuyPrice.GetSize(); k++ )
  422. {
  423. fBuyPrice[k] = float(0.001 * adwBuyPrice[k]);
  424. fBuyVolume[k] = float(adwBuyVolume[k]);
  425. }
  427. return TRUE;
  428. }
  430. /////////////////////////////////////////////////////////////////////////////