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

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

金融证券系统

开发平台：

Visual C++

KData.cpp：源码内容
  1. /*
  2. Cross Platform Core Code.
  4. Copyright(R) 2001-2002 Balang Software.
  5. All rights reserved.
  7. Using:
  8. class CKData;
  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. /////////////////////////////////////////////////////////////////////////////
  24. CKData::CKData()
  25. {
  26. m_nKType = ktypeDay;
  27. m_nCurFormat= formatOriginal;
  28. m_nCurMaindataType = mdtypeClose;
  29. m_pDataOriginal = NULL;
  30. m_nSizeOriginal = m_nMaxSizeOriginal = 0;
  31. m_pData = NULL;
  32. m_nSize = m_nMaxSize = m_nGrowBy = 0;
  33. }
  35. CKData::CKData( int ktype, int maindatatype )
  36. {
  37. m_nKType = ktype;
  38. m_nCurFormat= formatOriginal;
  39. m_nCurMaindataType = maindatatype;
  40. m_pDataOriginal = NULL;
  41. m_nSizeOriginal = m_nMaxSizeOriginal = 0;
  42. m_pData = NULL;
  43. m_nSize = m_nMaxSize = m_nGrowBy = 0;
  44. }
  46. CKData::CKData( const CKData &src )
  47. {
  48. m_nKType = ktypeDay;
  49. m_nCurFormat= formatOriginal;
  50. m_nCurMaindataType = mdtypeClose;
  51. m_pDataOriginal = NULL;
  52. m_nSizeOriginal = m_nMaxSizeOriginal = 0;
  53. m_pData = NULL;
  54. m_nSize = m_nMaxSize = m_nGrowBy = 0;
  55. *this = src;
  56. }
  58. CKData & CKData::operator = ( const CKData &src )
  59. {
  60. Clear();
  62. m_nKType = src.m_nKType;
  63. m_nCurFormat = src.m_nCurFormat;
  64. m_nCurMaindataType = src.m_nCurMaindataType;
  65. m_drdata = src.m_drdata;
  67. CopyData( src );
  69. return *this;
  70. }
  72. BOOL CKData::IsDayOrMin( int nKType )
  73. {
  74. return (nKType == CKData::ktypeDay || nKType == CKData::ktypeWeek || nKType == CKData::ktypeMonth);
  75. }
  77. CKData::~CKData()
  78. {
  79. Clear();
  80. }
  82. int CKData::GetSize() const
  83. { return m_nSize; }
  84. int CKData::Add(KDATA newElement)
  85. { int nIndex = m_nSize;
  86. SetAtGrow(nIndex, newElement);
  87. return nIndex; }
  89. void CKData::SetSize(int nNewSize, int nGrowBy /* = -1 */)
  90. {
  91. SP_ASSERT(nNewSize >= 0);
  93. if (nGrowBy != -1)
  94. m_nGrowBy = nGrowBy;  // set new size
  96. if (nNewSize == 0)
  97. {
  98. // shrink to nothing
  99. delete [] (BYTE*)m_pData;
  100. m_pData = NULL;
  101. m_nSize = m_nMaxSize = 0;
  102. }
  103. else if (m_pData == NULL)
  104. {
  105. // create one with exact size
  106. #ifdef SIZE_T_MAX
  107. SP_ASSERT((long)nNewSize * sizeof(KDATA) <= SIZE_T_MAX);  // no overflow
  108. #endif
  109. m_pData = (KDATA*) new BYTE[nNewSize * sizeof(KDATA)];
  111. memset(m_pData, 0, nNewSize * sizeof(KDATA));  // zero fill
  113. m_nSize = m_nMaxSize = nNewSize;
  114. }
  115. else if (nNewSize <= m_nMaxSize)
  116. {
  117. // it fits
  118. if (nNewSize > m_nSize)
  119. {
  120. // initialize the new elements
  122. memset(&m_pData[m_nSize], 0, (nNewSize-m_nSize) * sizeof(KDATA));
  124. }
  126. m_nSize = nNewSize;
  127. }
  128. else
  129. {
  130. // Otherwise grow array
  131. int nNewMax;
  132. if (nNewSize < m_nMaxSize + m_nGrowBy)
  133. nNewMax = m_nMaxSize + m_nGrowBy;  // granularity
  134. else
  135. nNewMax = nNewSize;  // no slush
  137. #ifdef SIZE_T_MAX
  138. SP_ASSERT((long)nNewMax * sizeof(KDATA) <= SIZE_T_MAX);  // no overflow
  139. #endif
  140. KDATA* pNewData = (KDATA*) new BYTE[nNewMax * sizeof(KDATA)];
  142. // copy new data from old
  143. memcpy(pNewData, m_pData, m_nSize * sizeof(KDATA));
  145. // construct remaining elements
  146. SP_ASSERT(nNewSize > m_nSize);
  148. memset(&pNewData[m_nSize], 0, (nNewSize-m_nSize) * sizeof(KDATA));
  151. // get rid of old stuff (note: no destructors called)
  152. delete [] (BYTE*)m_pData;
  153. m_pData = pNewData;
  154. m_nSize = nNewSize;
  155. m_nMaxSize = nNewMax;
  156. }
  157. }
  159. void CKData::FreeExtra()
  160. {
  161. if (m_nSize != m_nMaxSize)
  162. {
  163. // shrink to desired size
  164. #ifdef SIZE_T_MAX
  165. SP_ASSERT((long)m_nSize * sizeof(KDATA) <= SIZE_T_MAX);  // no overflow
  166. #endif
  167. KDATA* pNewData = NULL;
  168. if (m_nSize != 0)
  169. {
  170. pNewData = (KDATA*) new BYTE[m_nSize * sizeof(KDATA)];
  171. // copy new data from old
  172. memcpy(pNewData, m_pData, m_nSize * sizeof(KDATA));
  173. }
  175. // get rid of old stuff (note: no destructors called)
  176. delete [] (BYTE*)m_pData;
  177. m_pData = pNewData;
  178. m_nMaxSize = m_nSize;
  179. }
  180. }
  182. BOOL CKData::LatestDate( int &nYear, int &nMonth, int &nDay, int &nHour, int &nMinute ) const
  183. {
  184. nYear = nMonth = nDay = nHour = nMinute = 0;
  185. if( GetSize() > 0 )
  186. return DateAt( GetSize()-1, nYear, nMonth, nDay, nHour, nMinute );
  187. return FALSE;
  188. }
  190. DWORD CKData::GetDate( int nIndex )
  191. {
  192. if( nIndex >=0 && nIndex < GetSize() )
  193. return ElementAt(nIndex).m_date;
  194. if( GetSize() > 0 )
  195. return ElementAt(GetSize()-1).m_date;
  196. return 0;
  197. }
  199. DWORD CKData::GetDateDay( int nIndex )
  200. {
  201. DWORD date = GetDate(nIndex);
  202. if( CKData::ktypeMin5 == m_nKType || CKData::ktypeMin15 == m_nKType
  203. || CKData::ktypeMin30 == m_nKType || CKData::ktypeMin60 == m_nKType )
  204. {
  205. CSPTime sptime;
  206. if( sptime.FromStockTimeMin( date ) )
  207. return sptime.ToStockTimeDay();
  208. else
  209. return 0;
  210. }
  211. return date;
  212. }
  214. int CKData::GetIndexByDate( DWORD date )
  215. {
  216. if( GetSize() > 0 && ElementAt(GetSize()-1).m_date < date )
  217. return -1;
  218. if( GetSize() > 0 && ElementAt(0).m_date > date )
  219. return -1;
  220. for( int k=GetSize()-1; k >= 0 ; k-- )
  221. {
  222. if( ElementAt(k).m_date == date )
  223. return k;
  224. else if( ElementAt(k).m_date < date )
  225. break;
  226. }
  227. return -1;
  228. }
  230. int CKData::GetAboutIndexByDate( DWORD date )
  231. {
  232. for( int k=GetSize()-1; k >= 0 ; k-- )
  233. {
  234. if( ElementAt(k).m_date <= date )
  235. return k;
  236. }
  237. return -1;
  238. }
  240. /////////////////////////////////////////////////////////////////////////////
  242. void CKData::SetAtGrow(int nIndex, KDATA newElement)
  243. {
  244. SP_ASSERT(nIndex >= 0);
  246. if (nIndex >= m_nSize)
  247. SetSize(nIndex+1);
  248. m_pData[nIndex] = newElement;
  249. }
  251. void CKData::InsertAt(int nIndex, KDATA newElement, int nCount /*=1*/)
  252. {
  253. SP_ASSERT(nIndex >= 0);    // will expand to meet need
  254. SP_ASSERT(nCount > 0);     // zero or negative size not allowed
  256. if (nIndex >= m_nSize)
  257. {
  258. // adding after the end of the array
  259. SetSize(nIndex + nCount);  // grow so nIndex is valid
  260. }
  261. else
  262. {
  263. // inserting in the middle of the array
  264. int nOldSize = m_nSize;
  265. SetSize(m_nSize + nCount);  // grow it to new size
  266. // shift old data up to fill gap
  267. memmove(&m_pData[nIndex+nCount], &m_pData[nIndex],
  268. (nOldSize-nIndex) * sizeof(KDATA));
  270. // re-init slots we copied from
  272. memset(&m_pData[nIndex], 0, nCount * sizeof(KDATA));
  274. }
  276. // insert new value in the gap
  277. SP_ASSERT(nIndex + nCount <= m_nSize);
  278. while (nCount--)
  279. m_pData[nIndex++] = newElement;
  280. }
  282. int CKData::InsertKDataSort( KDATA newElement )
  283. {
  284. for( int i=0; i<GetSize(); i++ )
  285. {
  286. KDATA & temp = ElementAt(i);
  287. if( temp.m_date == newElement.m_date )
  288. {
  289. SetAt(i,newElement);
  290. return i;
  291. }
  292. if( temp.m_date > newElement.m_date )
  293. {
  294. InsertAt(i,newElement);
  295. return i;
  296. }
  297. }
  298. return Add( newElement );
  299. }
  301. BOOL CKData::IsNewValue( int nIndex, BOOL bTopOrBottom, int nDays )
  302. {
  303. if( nIndex < nDays-1 || nIndex < 0 || nIndex >= GetSize() || nDays < 3 )
  304. return FALSE;
  306. BOOL bFirst = TRUE;
  307. float fLast = 0;
  308. int nLast = 0;
  309. float fNow = MaindataAt( nIndex );
  311. for( int k=nIndex-1; k>=0 && k>nIndex-nDays; k-- )
  312. {
  313. float fCur = MaindataAt(k);
  314. if( bFirst )
  315. {
  316. fLast = fCur;
  317. nLast = k;
  318. bFirst = FALSE;
  319. }
  321. if( bTopOrBottom )
  322. {
  323. if( fCur > fNow )
  324. return FALSE;
  326. if( fCur > fLast )
  327. {
  328. fLast = fCur;
  329. nLast = k;
  330. }
  331. }
  332. else
  333. {
  334. if( fCur < fNow )
  335. return FALSE;
  337. if( fCur < fLast )
  338. {
  339. fLast = fCur;
  340. nLast = k;
  341. }
  342. }
  343. }
  344. if( bFirst )
  345. return FALSE;
  347. if( nLast >= nIndex-30 && nLast <= nIndex-5 )
  348. return TRUE;
  350. return FALSE;
  351. }
  353. BOOL CKData::GetMinMaxInfo( int nStart, int nEnd, float * pfMin, float *pfMax )
  354. {
  355. if( nStart < 0 || nEnd < 0 || nStart > nEnd || nEnd >= GetSize() )
  356. return FALSE;
  358. float fMin = 0, fMax = 0;
  359. BOOL bFirst = TRUE;
  360. for( int k=nStart; k<=nEnd; k++ )
  361. {
  362. KDATA & kd = ElementAt(k);
  363. if( bFirst )
  364. {
  365. fMin = kd.m_fLow;
  366. fMax = kd.m_fHigh;
  367. bFirst = FALSE;
  368. }
  369. if( kd.m_fLow < fMin )
  370. fMin = kd.m_fLow;
  371. if( kd.m_fHigh > fMax )
  372. fMax = kd.m_fHigh;
  373. }
  375. if( pfMin ) *pfMin = fMin;
  376. if( pfMax ) *pfMax = fMax;
  377. return !bFirst;
  378. }
  380. void CKData::RemoveAt(int nIndex, int nCount /* = 1 */)
  381. {
  382. SP_ASSERT(nIndex >= 0);
  383. SP_ASSERT(nCount >= 0);
  384. SP_ASSERT(nIndex + nCount <= m_nSize);
  386. // just remove a range
  387. int nMoveCount = m_nSize - (nIndex + nCount);
  389. if (nMoveCount)
  390. memcpy(&m_pData[nIndex], &m_pData[nIndex + nCount],
  391. nMoveCount * sizeof(KDATA));
  392. m_nSize -= nCount;
  393. }
  395. void CKData::InsertAt(int nStartIndex, CKData* pNewArray)
  396. {
  397. SP_ASSERT(pNewArray != NULL);
  398. SP_ASSERT(nStartIndex >= 0);
  400. if (pNewArray->GetSize() > 0)
  401. {
  402. InsertAt(nStartIndex, pNewArray->GetAt(0), pNewArray->GetSize());
  403. for (int i = 0; i < pNewArray->GetSize(); i++)
  404. SetAt(nStartIndex + i, pNewArray->GetAt(i));
  405. }
  406. }
  409. /////////////////////////////////////////////////////////////////////////////
  410. // Extra Operations
  412. void CKData::SetKType( int ktype ) { m_nKType = ktype; }
  413. void CKData::AutoSetKType( )
  414. {
  415. if( GetSize() >= 4 )
  416. {
  417. long elapse1 = ElementAt(1).m_time - ElementAt(0).m_time;
  418. long elapse2 = ElementAt(2).m_time - ElementAt(1).m_time;
  419. long elapse3 = ElementAt(3).m_time - ElementAt(2).m_time;
  420. long elapse = min(elapse1,elapse2);
  421. elapse = min(elapse,elapse3);
  422. if( elapse < 600 )
  423. m_nKType = ktypeMin5;
  424. else if( elapse < 1200 )
  425. m_nKType = ktypeMin15;
  426. else if( elapse < 2400 )
  427. m_nKType = ktypeMin30;
  428. else if( elapse < 7200 )
  429. m_nKType = ktypeMin60;
  430. else if( elapse < 172800 )
  431. m_nKType = ktypeDay;
  432. else if( elapse < 864000 )
  433. m_nKType = ktypeWeek;
  434. else if( elapse < 4320000 )
  435. m_nKType = ktypeWeek;
  436. }
  437. }
  438. int CKData::GetKType( ) { return m_nKType; }
  439. int CKData::GetCurFormat( ) { return m_nCurFormat; }
  440. void CKData::SetMaindataType( int type ) { m_nCurMaindataType = type; }
  441. int CKData::GetMaindataType( ) { return m_nCurMaindataType; }
  443. void CKData::SetDRData( CDRData &drdata ) { m_drdata = drdata; }
  444. CDRData &CKData::GetDRData( ) { return m_drdata; }
  446. void CKData::ChangeCurFormat( int format, DWORD dateAutoDRBegin, double dAutoDRLimit )
  447. {
  448. SP_ASSERT( GetKType() != ktypeMonth && GetKType() != ktypeWeek );
  450. if( m_nCurFormat == format )
  451. return;
  453. switch( format )
  454. {
  455. case formatOriginal:
  456. LoadDataOriginal( );
  457. m_nCurFormat = format;
  458. break;
  459. case formatXDRup:
  460. StoreDataOriginal( );
  461. ConvertXDR( TRUE, dateAutoDRBegin, dAutoDRLimit );
  462. m_nCurFormat = format;
  463. break;
  464. case formatXDRdown:
  465. StoreDataOriginal( );
  466. ConvertXDR( FALSE, dateAutoDRBegin, dAutoDRLimit );
  467. m_nCurFormat = format;
  468. break;
  469. default:
  470. SP_ASSERT( FALSE );
  471. }
  472. }
  474. void CKData::Clear( )
  475. {
  476. if( m_pDataOriginal )
  477. {
  478. delete [] (BYTE*)m_pDataOriginal;
  479. m_pDataOriginal = NULL;
  480. }
  481. if( m_pData )
  482. {
  483. delete [] (BYTE*)m_pData;
  484. m_pData = NULL;
  485. }
  486. m_nKType = ktypeDay;
  487. m_nCurFormat= formatOriginal;
  488. m_nCurMaindataType = mdtypeClose;
  489. m_pDataOriginal = NULL;
  490. m_nSizeOriginal = m_nMaxSizeOriginal = 0;
  491. m_pData = NULL;
  492. m_nSize = m_nMaxSize = m_nGrowBy = 0;
  493. }
  495. int CKData::CompareLatestDate( CKData &kd )
  496. {
  497. // compare this kdata with kd's latest time
  498. int nYearThis, nMonthThis, nDayThis, nHourThis, nMinuteThis;
  499. int nYear, nMonth, nDay, nHour, nMinute;
  500. LatestDate( nYearThis, nMonthThis, nDayThis, nHourThis, nMinuteThis );
  501. kd.LatestDate( nYear, nMonth, nDay, nHour, nMinute );
  503. if( nYearThis > nYear || nMonthThis > nMonth || nDayThis > nDay
  504. || nHourThis > nHour || nMinuteThis > nMinute )
  505. return 1;
  506. if( nYearThis < nYear || nMonthThis < nMonth || nDayThis < nDay
  507. || nHourThis < nHour || nMinuteThis < nMinute )
  508. return -1;
  509. return 0;
  510. }
  512. int CKData::Min5ToMin15( CKData &kdm5, CKData &kdm15 )
  513. {
  514. SP_ASSERT( ktypeMin5 == kdm5.GetKType() );
  515. SP_ASSERT( ktypeMin15 == kdm15.GetKType() );
  516. return ConvertKData( kdm5, kdm15, 3 );
  517. }
  519. int CKData::Min5ToMin30( CKData &kdm5, CKData &kdm30 )
  520. {
  521. SP_ASSERT( ktypeMin5 == kdm5.GetKType() );
  522. SP_ASSERT( ktypeMin30 == kdm30.GetKType() );
  523. return ConvertKData( kdm5, kdm30, 6 );
  524. }
  526. int CKData::Min5ToMin60( CKData &kdm5, CKData &kdm60 )
  527. {
  528. SP_ASSERT( ktypeMin5 == kdm5.GetKType() );
  529. SP_ASSERT( ktypeMin60 == kdm60.GetKType() );
  530. return ConvertKData( kdm5, kdm60, 12 );
  531. }
  533. int CKData::DayToMonth( CKData &kdday, CKData &kdmonth )
  534. {
  535. // convert day k line to month k line
  536. SP_ASSERT( ktypeDay == kdday.GetKType() );
  537. SP_ASSERT( ktypeMonth == kdmonth.GetKType() );
  539. kdmonth.SetSize( 0, kdday.GetSize() / 20 + 5 );
  541. int nStart = kdday.GetSize() % 3;
  542. int nCount = 0;
  543. KDATA dataDest;
  544. memset( &dataDest, 0, sizeof(dataDest) );
  545. int nYearCur = 0, nMonthCur = 0 ;
  546. for( int pos=nStart; pos<kdday.GetSize(); pos++ )
  547. {
  548. KDATA & dataSrc = kdday.ElementAt( pos );
  550. CSPTime tm;
  551. if( !tm.FromStockTimeDay(dataSrc.m_date) )
  552. continue;
  553. int nYear = tm.GetYear();
  554. int nMonth = tm.GetMonth();
  556. if( nYear != nYearCur || nMonth != nMonthCur ) // a new month
  557. {
  558. if( 0 != pos )
  559. kdmonth.Add( dataDest ); // add a month
  561. memcpy( &dataDest, &dataSrc, sizeof(dataDest) ); // begin a new month
  562. nYearCur = nYear;
  563. nMonthCur = nMonth;
  564. }
  565. else
  566. {
  567. dataDest.m_fAmount += dataSrc.m_fAmount;
  568. if( dataDest.m_fHigh < dataSrc.m_fHigh ) dataDest.m_fHigh = dataSrc.m_fHigh;
  569. if( dataDest.m_fLow > dataSrc.m_fLow ) dataDest.m_fLow = dataSrc.m_fLow;
  570. dataDest.m_fVolume += dataSrc.m_fVolume;
  571. dataDest.m_fClose = dataSrc.m_fClose;
  572. }
  574. if( pos == kdday.GetSize()-1 ) // the latest one
  575. kdmonth.Add( dataDest );
  576. }
  578. return kdmonth.GetSize();
  579. }
  581. int CKData::DayToWeek( CKData &kdday, CKData &kdweek )
  582. {
  583. // convert day k line to week k line
  584. SP_ASSERT( ktypeDay == kdday.GetKType() );
  585. SP_ASSERT( ktypeWeek == kdweek.GetKType() );
  587. kdweek.SetSize( 0, kdday.GetSize() / 5 + 5 );
  589. int nStart = kdday.GetSize() % 3;
  590. int nCount = 0;
  591. KDATA dataDest;
  592. memset( &dataDest, 0, sizeof(dataDest) );
  593. for( int pos=nStart; pos<kdday.GetSize(); pos++ )
  594. {
  595. KDATA & dataSrc = kdday.ElementAt( pos );
  597. CSPTime tm;
  598. if( !tm.FromStockTimeDay(dataSrc.m_date) )
  599. continue;
  601. if( tm.GetDayOfWeek() == 2 ) // a new week
  602. {
  603. if( 0 != pos )
  604. kdweek.Add( dataDest ); // add a week
  606. memcpy( &dataDest, &dataSrc, sizeof(dataDest) ); // begin a new week
  607. }
  608. else
  609. {
  610. dataDest.m_fAmount += dataSrc.m_fAmount;
  611. if( dataDest.m_fHigh < dataSrc.m_fHigh ) dataDest.m_fHigh = dataSrc.m_fHigh;
  612. if( dataDest.m_fLow > dataSrc.m_fLow ) dataDest.m_fLow = dataSrc.m_fLow;
  613. dataDest.m_fVolume += dataSrc.m_fVolume;
  614. dataDest.m_fClose = dataSrc.m_fClose;
  615. }
  617. if( pos == kdday.GetSize()-1 ) // the latest one
  618. kdweek.Add( dataDest );
  619. }
  621. return kdweek.GetSize();
  622. }
  624. DWORD CKData::ToDayDate( DWORD date )
  625. {
  626. switch( GetKType() )
  627. {
  628. case ktypeMin60:
  629. case ktypeMin30:
  630. case ktypeMin15:
  631. case ktypeMin5:
  632. return (date / 10000 + 1990 * 10000);
  633. default:
  634. return date;
  635. }
  636. }
  638. int CKData::MergeKData( CKData * pother )
  639. {
  640. if( !pother || pother->GetSize() == 0 )
  641. return 0;
  642. if( GetKType() != pother->GetKType() )
  643. return 0;
  645. if( GetSize() == 0 )
  646. {
  647. CopyData( *pother );
  648. return GetSize();
  649. }
  651. int nCount = 0;
  652. SetSize( GetSize(), pother->GetSize()+1 );
  653. for( int i=0; i<pother->GetSize(); i++ )
  654. {
  655. KDATA kdnew = pother->ElementAt(i);
  656. if( kdnew.m_fClose < 1e-4 || kdnew.m_fOpen < 1e-4 || kdnew.m_fHigh < 1e-4 || kdnew.m_fLow < 1e-4 )
  657. continue;
  659. for( int j=0; j<GetSize(); j++ )
  660. {
  661. if( kdnew.m_date == ElementAt(j).m_date )
  662. {
  663. SetAt(j,kdnew);
  664. break;
  665. }
  666. if( kdnew.m_date < ElementAt(j).m_date )
  667. {
  668. InsertAt(j,kdnew);
  669. break;
  670. }
  671. }
  672. if( GetSize() == j )
  673. Add( kdnew );
  674. nCount ++;
  675. }
  677. return nCount;
  679. /* The Old Version
  680. if( !pother || pother->GetSize() == 0 )
  681. return GetSize();
  682. if( GetKType() != pother->GetKType() )
  683. return GetSize();
  685. if( GetSize() == 0 )
  686. {
  687. CopyData( *pother );
  688. return GetSize();
  689. }
  691. int nLen = GetSize();
  692. int nLenOther = pother->GetSize();
  694. SP_ASSERT( 0 != nLen && 0 != nLenOther );
  696. if( ElementAt(nLen-1).m_date < pother->ElementAt(0).m_date )
  697. CopyData( *pother );
  698. // else if( ElementAt(0).m_date > pother->ElementAt(nLenOther-1).m_date )
  699. // ;
  700. // else if( ElementAt(0).m_date <= pother->ElementAt(0).m_date
  701. // && ElementAt(nLen-1).m_date >= pother->ElementAt(nLenOther-1).m_date )
  702. // ;
  703. else if( ElementAt(0).m_date > pother->ElementAt(0).m_date
  704. && ElementAt(nLen-1).m_date < pother->ElementAt(nLenOther-1).m_date )
  705. CopyData( *pother );
  706. else if( ElementAt(0).m_date <= pother->ElementAt(0).m_date
  707. && ElementAt(nLen-1).m_date < pother->ElementAt(nLenOther-1).m_date )
  708. {
  709. // append from pother
  710. DWORD date = ElementAt(nLen-1).m_date;
  711. SetSize( GetSize(), pother->GetSize() );
  712. for( int i=0; i<pother->GetSize(); i++ )
  713. {
  714. KDATA & kd = pother->ElementAt(i);
  715. if( kd.m_date > m_data )
  716. Add( kd );
  717. }
  718. }
  719. else if( ElementAt(0).m_date >= pother->ElementAt(0).m_date
  720. && ElementAt(nLen-1).m_date > pother->ElementAt(nLenOther-1).m_date )
  721. {
  722. // insert from pother
  723. CKData temp = (*pother);
  724. DWORD date = pother->ElementAt(nLenOther-1).m_date;
  725. temp.SetSize( temp.GetSize(), GetSize()+5 );
  726. for( int i=0; i<GetSize(); i++ )
  727. {
  728. KDATA & kd = ElementAt(i);
  729. if( kd.m_date > date )
  730. temp.Add( kd );
  731. }
  732. CopyData( temp );
  733. }
  735. return GetSize();
  736. */
  737. }
  739. int CKData::FullFillKData( CKData & kdataMain, BOOL bFillToEnd )
  740. {
  741. SP_ASSERT( GetKType() == kdataMain.GetKType() );
  742. if( GetKType() != kdataMain.GetKType() )
  743. return 0;
  744. if( GetSize() == 0 || kdataMain.GetSize() == 0 )
  745. return 0;
  747. DWORD dateBegin = ElementAt(0).m_date;
  748. DWORD dateMainEnd5 = (kdataMain.GetSize() >= 5 ? kdataMain.ElementAt(kdataMain.GetSize()-5).m_date : 0);
  749. DWORD dateEnd5 = (GetSize() >= 5 ? ElementAt(GetSize()-5).m_date : 0);
  750. int iMain = 0, iSelf = 0;
  751. for( iMain=0; iMain<kdataMain.GetSize(); iMain ++ )
  752. {
  753. if( dateBegin == kdataMain.ElementAt(iMain).m_date )
  754. break;
  755. }
  757. SetSize( GetSize(), kdataMain.GetSize()-iMain-GetSize() > 0 ? kdataMain.GetSize()-iMain-GetSize() : -1 );
  758. int nCount = 0;
  759. for( ; iMain <= kdataMain.GetSize() && iSelf <= GetSize(); iMain++, iSelf++ )
  760. {
  761. if( !bFillToEnd && iSelf == GetSize() && ElementAt(iSelf-1).m_date < dateMainEnd5 )
  762. break;
  763. if( !bFillToEnd && iMain == kdataMain.GetSize() && kdataMain.ElementAt(iMain-1).m_date < dateEnd5 )
  764. break;
  765. while( iMain > 0 && iMain <= kdataMain.GetSize() && iSelf < GetSize()
  766. && ( iMain == kdataMain.GetSize() || kdataMain.ElementAt(iMain).m_date > ElementAt(iSelf).m_date ) )
  767. {
  768. // KDATA kd;
  769. // memset( &kd, 0, sizeof(kd) );
  770. // kd.m_date = ElementAt(iSelf).m_date;
  771. // kd.open = kd.high = kd.low = kd.close = kdataMain.ElementAt(iMain-1).close;
  772. // kdataMain.InsertAt( iMain, kd );
  773. // iMain ++;
  774. iSelf ++;
  775. // nCount ++;
  776. }
  778. while( iMain < kdataMain.GetSize() && iSelf <= GetSize() && iSelf > 0
  779. && ( iSelf == GetSize() || kdataMain.ElementAt(iMain).m_date < ElementAt(iSelf).m_date ) )
  780. {
  781. KDATA kd;
  782. memset( &kd, 0, sizeof(kd) );
  783. kd.m_date = kdataMain.ElementAt(iMain).m_date;
  784. kd.m_fOpen = kd.m_fHigh = kd.m_fLow = kd.m_fClose = ElementAt(iSelf-1).m_fClose;
  785. InsertAt( iSelf, kd );
  786. iMain ++;
  787. iSelf ++;
  788. nCount ++;
  789. }
  790. }
  792. return nCount;
  793. }
  795. BOOL CKData::IsAdjacentDays( int nIndex, int nDays )
  796. {
  797. // check parameters
  798. SP_ASSERT( nIndex >= 0 && nIndex < GetSize() && nDays >= 1 );
  799. if( nIndex < 0 || nIndex >= GetSize() || nDays < 1 )
  800. return FALSE;
  802. // data not enougy
  803. if( nDays > nIndex )
  804. return FALSE;
  806. CSPTime sptime1, sptime2;
  807. sptime1.FromStockTime( ElementAt(nIndex-nDays).m_date, CKData::IsDayOrMin(m_nKType) );
  808. sptime1.FromStockTime( ElementAt(nIndex).m_date, CKData::IsDayOrMin(m_nKType) );
  810. if( CKData::ktypeMonth == m_nKType )
  811. {
  812. if( sptime2 - sptime1 >= CSPTimeSpan(nDays+63,0,0,0) )
  813. return FALSE;
  814. }
  815. else if( CKData::ktypeWeek == m_nKType )
  816. {
  817. if( sptime2 - sptime1 >= CSPTimeSpan(nDays+15,0,0,0) )
  818. return FALSE;
  819. }
  820. else
  821. {
  822. if( sptime2 - sptime1 >= CSPTimeSpan(nDays+8,0,0,0) )
  823. return FALSE;
  824. }
  825. return TRUE;
  826. }
  828. BOOL CKData::GetDiff( double * pValue, DWORD dateCur, int nDays )
  829. {
  830. SP_ASSERT( pValue && nDays > 0 );
  832. // Find date Current to calculate from
  833. int nIndex = GetIndexByDate( dateCur );
  834. if( -1 == nIndex )
  835. return FALSE;
  837. // data not enough
  838. if( nDays > nIndex )
  839. return FALSE;
  841. // 检查是否是相邻成交日
  842. if( !IsAdjacentDays( nIndex, nDays ) )
  843. return FALSE;
  845. if( ElementAt(nIndex-nDays).m_fClose < 1e-4 )
  846. return FALSE;
  847. if( pValue )
  848. *pValue = ElementAt(nIndex).m_fClose - ElementAt(nIndex-nDays).m_fClose;
  849. return TRUE;
  850. }
  852. BOOL CKData::GetDiffPercent( double * pValue, DWORD dateCur, int nDays )
  853. {
  854. SP_ASSERT( pValue && nDays > 0 );
  856. // Find date Current to calculate from
  857. int nIndex = GetIndexByDate( dateCur );
  858. if( -1 == nIndex )
  859. return FALSE;
  861. // data not enough
  862. if( nDays > nIndex )
  863. return FALSE;
  865. // 检查是否是相邻成交日
  866. if( !IsAdjacentDays( nIndex, nDays ) )
  867. return FALSE;
  869. if( ElementAt(nIndex-nDays).m_fAmount < 1e-4 )
  870. return FALSE;
  871. if( pValue )
  872. *pValue = (100. * ElementAt(nIndex).m_fClose) / ElementAt(nIndex-nDays).m_fClose - 100;
  873. return TRUE;
  874. }
  876. BOOL CKData::GetScope( double * pValue, DWORD dateCur, int nDays )
  877. {
  878. SP_ASSERT( pValue && nDays > 0 );
  880. // Find date Current to calculate from
  881. int nIndex = GetIndexByDate( dateCur );
  882. if( -1 == nIndex )
  883. return FALSE;
  885. // data not enough
  886. if( nDays > nIndex )
  887. return FALSE;
  889. // 检查是否是相邻成交日
  890. if( !IsAdjacentDays( nIndex, nDays ) )
  891. return FALSE;
  893. double dMax = 0, dMin = 0;
  894. int nCount = 0;
  895. for( int k=nIndex; k>=0; k-- )
  896. {
  897. if( nIndex == k )
  898. {
  899. dMin = ElementAt(k).m_fLow;
  900. dMax = ElementAt(k).m_fHigh;
  901. }
  902. if( dMin > ElementAt(k).m_fLow ) dMin = ElementAt(k).m_fLow;
  903. if( dMax < ElementAt(k).m_fHigh ) dMax = ElementAt(k).m_fHigh;
  905. nCount ++;
  906. if( nCount == nDays )
  907. break;
  908. }
  909. // data not enough
  910. if( nCount != nDays || nCount <= 0 )
  911. return FALSE;
  913. if( ElementAt(nIndex-nDays).m_fClose <= 0 )
  914. return FALSE;
  915. if( pValue )
  916. *pValue = ( 100. * (dMax-dMin) ) / ElementAt(nIndex-nDays).m_fClose ;
  917. return TRUE;
  918. }
  920. BOOL CKData::GetVolumeSum( double * pValue, DWORD dateCur, int nDays )
  921. {
  922. SP_ASSERT( pValue && nDays > 0 );
  924. // Find date Current to calculate from
  925. int nIndex = GetIndexByDate( dateCur );
  926. if( -1 == nIndex )
  927. return FALSE;
  929. // data not enough
  930. if( nDays > nIndex )
  931. return FALSE;
  933. // 检查是否是相邻成交日
  934. if( !IsAdjacentDays( nIndex, nDays ) )
  935. return FALSE;
  937. // begin calculate
  938. double dAll = 0;
  939. int nCount = 0;
  940. for( int i=nIndex; i>=0; i-- )
  941. {
  942. dAll += ElementAt(i).m_fVolume;
  943. nCount ++;
  944. if( nCount >= nDays )
  945. break;
  946. }
  947. // data not enough
  948. if( nCount != nDays || nCount <= 0 )
  949. return FALSE;
  951. if( pValue )
  952. *pValue = dAll;
  953. return TRUE;
  954. }
  956. BOOL CKData::GetRatioVolume( double * pValue, DWORD dateCur, int nDays )
  957. {
  958. SP_ASSERT( pValue && nDays > 0 );
  960. // Find date Current to calculate from
  961. int nIndex = GetIndexByDate( dateCur );
  962. if( -1 == nIndex )
  963. return FALSE;
  965. // data not enough
  966. if( nDays > nIndex )
  967. return FALSE;
  969. // 检查是否是相邻成交日
  970. if( !IsAdjacentDays( nIndex, nDays ) )
  971. return FALSE;
  973. // begin calculate
  974. double dAll = 0;
  975. int nCount = 0;
  976. for( int i=nIndex-1; i>=0; i-- )
  977. {
  978. dAll += ElementAt(i).m_fVolume;
  979. nCount ++;
  980. if( nCount >= nDays )
  981. break;
  982. }
  983. // data not enough
  984. if( nCount != nDays || nCount <= 0 )
  985. return FALSE;
  987. if( fabs(dAll) < 1 )
  988. return FALSE;
  990. if( pValue )
  991. *pValue = (ElementAt(nIndex).m_fVolume / dAll ) * nCount;
  992. return TRUE;
  993. }
  995. BOOL CKData::GetRS( double * pValue, DWORD dateCur, int nDays )
  996. {
  997. SP_ASSERT( pValue && nDays > 0 );
  999. // Find date Current to calculate from
  1000. int nIndex = GetIndexByDate( dateCur );
  1001. if( -1 == nIndex )
  1002. return FALSE;
  1004. // data not enough
  1005. if( nDays > nIndex )
  1006. return FALSE;
  1008. // 检查是否是相邻成交日
  1009. if( !IsAdjacentDays( nIndex, nDays ) )
  1010. return FALSE;
  1012. int nCount = 0;
  1013. double dA = 0, dB = 0;
  1014. for( int k=nIndex; k>=1; k-- )
  1015. {
  1016. if( ElementAt(k).m_fClose > ElementAt(k-1).m_fClose )
  1017. dA += (ElementAt(k).m_fClose - ElementAt(k-1).m_fClose);
  1018. else
  1019. dB += (ElementAt(k-1).m_fClose - ElementAt(k).m_fClose);
  1021. nCount ++;
  1022. if( nCount == nDays )
  1023. {
  1024. double dResult;
  1025. if( fabs(dB) < 1e-4 )
  1026. dResult = 100;
  1027. else
  1028. dResult = dA / dB;
  1029. if( pValue )
  1030. *pValue = dResult;
  1031. return TRUE;
  1032. }
  1033. }
  1034. return FALSE;
  1035. }
  1037. BOOL CKData::GetMA( double * pValue, int nIndex, int nDays )
  1038. {
  1039. SP_ASSERT( nIndex >= 0 && nIndex < GetSize() && nDays > 0 );
  1040. if( nIndex < 0 || nIndex >=GetSize() || nDays <= 0 )
  1041. return FALSE;
  1043. int nCount = 0;
  1044. if( nDays > nIndex+1 )
  1045. return FALSE;
  1046. double dResult = 0;
  1047. for( int k=nIndex; k>=0; k-- )
  1048. {
  1049. dResult += MaindataAt(k);
  1050. nCount ++;
  1051. if( nCount == nDays )
  1052. {
  1053. if( pValue )
  1054. *pValue = dResult / nDays;
  1055. return TRUE;
  1056. }
  1057. }
  1058. return FALSE;
  1059. }
  1061. /////////////////////////////////////////////////////////////////////////////
  1062. // Private Operations
  1063. int CKData::ConvertKData( CKData &kdSrc, CKData &kdDest, int multiple )
  1064. {
  1065. // convert kdSrc k line to kdDest k line accordding to their multiple
  1066. SP_ASSERT( multiple > 1 );
  1067. if( multiple < 2 ) return 0;
  1069. kdDest.SetSize( 0, kdSrc.GetSize() / multiple + 5 );
  1071. int nStart = kdSrc.GetSize() % multiple;
  1072. int nCount = 0;
  1073. KDATA dataDest;
  1074. for( int pos=nStart; pos<kdSrc.GetSize(); pos++ )
  1075. {
  1076. KDATA & dataSrc = kdSrc.ElementAt( pos );
  1078. nCount ++;
  1079. if( 1 == nCount )
  1080. {
  1081. memcpy( &dataDest, &dataSrc, sizeof(dataDest) );
  1082. }
  1083. else
  1084. {
  1085. dataDest.m_fAmount += dataSrc.m_fAmount;
  1086. if( dataDest.m_fHigh < dataSrc.m_fHigh ) dataDest.m_fHigh = dataSrc.m_fHigh;
  1087. if( dataDest.m_fLow > dataSrc.m_fLow ) dataDest.m_fLow = dataSrc.m_fLow;
  1088. dataDest.m_fVolume += dataSrc.m_fVolume;
  1089. dataDest.m_fClose = dataSrc.m_fClose;
  1090. }
  1092. if( multiple == nCount ) // new dataDest is over
  1093. {
  1094. nCount = 0;
  1095. kdDest.Add( dataDest );
  1096. }
  1097. }
  1099. return kdDest.GetSize();
  1100. }
  1102. void CKData::CopyData( const CKData &src )
  1103. {
  1104. if( m_pDataOriginal )
  1105. {
  1106. delete [] (BYTE*)m_pDataOriginal;
  1107. m_pDataOriginal = NULL;
  1108. m_nSizeOriginal = m_nMaxSizeOriginal = 0;
  1109. }
  1110. if( m_pData )
  1111. {
  1112. delete [] (BYTE*)m_pData;
  1113. m_pData = NULL;
  1114. m_nSize = m_nMaxSize = m_nGrowBy = 0;
  1115. }
  1117. if( src.m_nSizeOriginal > 0 )
  1118. {
  1119. SP_ASSERT( src.m_pDataOriginal );
  1120. SP_ASSERT( src.m_nMaxSizeOriginal >= src.m_nSizeOriginal );
  1121. m_pDataOriginal = (KDATA*) new BYTE[src.m_nMaxSizeOriginal * sizeof(KDATA)];
  1122. if( m_pDataOriginal )
  1123. {
  1124. memset( m_pDataOriginal, 0, src.m_nMaxSizeOriginal * sizeof(KDATA) );  // zero fill
  1125. memcpy( m_pDataOriginal, src.m_pDataOriginal, src.m_nSizeOriginal * sizeof(KDATA) );
  1126. m_nSizeOriginal = src.m_nSizeOriginal;
  1127. m_nMaxSizeOriginal = src.m_nMaxSizeOriginal;
  1128. }
  1129. }
  1130. if( src.m_nSize > 0 )
  1131. {
  1132. SP_ASSERT( src.m_pData );
  1133. SP_ASSERT( src.m_nMaxSize >= src.m_nSize );
  1134. m_pData = (KDATA*) new BYTE[src.m_nMaxSize * sizeof(KDATA)];
  1135. if( m_pData )
  1136. {
  1137. memset( m_pData, 0, src.m_nMaxSize * sizeof(KDATA) );  // zero fill
  1138. memcpy( m_pData, src.m_pData, src.m_nSize * sizeof(KDATA) );
  1139. m_nSize = src.m_nSize;
  1140. m_nMaxSize = src.m_nMaxSize;
  1141. }
  1142. }
  1143. }
  1145. void CKData::LoadDataOriginal( )
  1146. {
  1147. if( m_pDataOriginal )
  1148. {
  1149. if( m_pData )
  1150. delete [] (BYTE*)m_pData;
  1152. m_pData = m_pDataOriginal;
  1153. m_nSize = m_nSizeOriginal;
  1154. m_nMaxSize = m_nMaxSizeOriginal;
  1156. m_pDataOriginal = NULL;
  1157. m_nSizeOriginal = m_nMaxSizeOriginal = 0;
  1158. }
  1159. }
  1161. void CKData::StoreDataOriginal( )
  1162. {
  1163. if( NULL == m_pDataOriginal )
  1164. {
  1165. m_pDataOriginal = m_pData;
  1166. m_nSizeOriginal = m_nSize;
  1167. m_nMaxSizeOriginal = m_nMaxSize;
  1169. m_pData = NULL;
  1170. m_nSize = m_nMaxSize = 0;
  1171. }
  1172. }
  1174. float CKData::GetRatio( float fLastClose, DRDATA & dr )
  1175. {
  1176. if( fLastClose < 1e-4 )
  1177. return 1.0000;
  1179. float fRatio = 1.0000;
  1180. if( dr.m_fProfit > 1e-4 )
  1181. {
  1182. fRatio = fRatio * ( 1 - dr.m_fProfit/fLastClose );
  1183. }
  1184. if( dr.m_fGive > 1e-4 )
  1185. {
  1186. fRatio = (float)( fRatio * 1./(1.+dr.m_fGive) );
  1187. }
  1188. if( dr.m_fPei > 1e-4 )
  1189. {
  1190. float priceNow = (float)( (dr.m_fPeiPrice * dr.m_fPei + fLastClose)/(1.+dr.m_fPei) );
  1191. fRatio = fRatio * priceNow / fLastClose;
  1192. }
  1193. return fRatio;
  1194. }
  1196. void CKData::ConvertXDR( BOOL bUP, DWORD dateAutoDRBegin, double dAutoDRLimit )
  1197. {
  1198. CDRData drtemp;
  1199. drtemp = m_drdata;
  1200. drtemp.Sort( );
  1202. if( m_pData )
  1203. {
  1204. delete [] (BYTE*)m_pData;
  1205. m_nSize = m_nMaxSize = 0;
  1206. m_pData = NULL;
  1207. }
  1209. if( NULL == m_pDataOriginal || 0 == m_nSizeOriginal )
  1210. return;
  1212. /* if( drtemp.GetSize() == 0 )
  1213. {
  1214. SetSize( m_nSizeOriginal );
  1215. if( m_pData )
  1216. memcpy( m_pData, m_pDataOriginal, sizeof(KDATA)*m_nSize );
  1217. return;
  1218. }
  1219. */
  1220. dAutoDRLimit = dAutoDRLimit / 100;
  1222. if( bUP )
  1223. {
  1224. SetSize( 0, m_nSizeOriginal );
  1225. int drPos = 0;
  1226. float fRatio = 1.000000;
  1227. for( int i=0; i<m_nSizeOriginal; i++ )
  1228. {
  1229. KDATA & kd = m_pDataOriginal[i];
  1230. KDATA newkd = kd;
  1232. if( drPos < drtemp.GetSize() && ToDayDate(kd.m_date) >= drtemp.ElementAt(drPos).m_date )
  1233. {
  1234. if( i > 0 )
  1235. {
  1236. KDATA kdLast = m_pDataOriginal[i-1];
  1237. fRatio = fRatio * GetRatio( kdLast.m_fClose, drtemp.ElementAt(drPos) );
  1238. }
  1240. drPos ++;
  1241. }
  1242. else if( ToDayDate(kd.m_date) >= dateAutoDRBegin && i > 0 ) // Auto XDR
  1243. {
  1244. KDATA kdLast = m_pDataOriginal[i-1];
  1245. if( kdLast.m_fClose > 1e-4 && kd.m_fOpen < kdLast.m_fClose
  1246. && fabs(kd.m_fOpen/kdLast.m_fClose-1) > dAutoDRLimit )
  1247. fRatio = fRatio * kd.m_fOpen / kdLast.m_fClose;
  1248. }
  1250. newkd.m_fOpen = (kd.m_fOpen / fRatio);
  1251. newkd.m_fHigh = (kd.m_fHigh / fRatio);
  1252. newkd.m_fLow = (kd.m_fLow / fRatio);
  1253. newkd.m_fClose = (kd.m_fClose / fRatio);
  1254. newkd.m_fVolume = (kd.m_fVolume * fRatio);
  1255. Add( newkd );
  1256. }
  1257. }
  1258. else
  1259. {
  1260. SetSize( m_nSizeOriginal );
  1261. int drPos = drtemp.GetSize()-1;
  1262. float fRatio = 1.000000;
  1263. for( int i=m_nSizeOriginal-1; i>=0; i-- )
  1264. {
  1265. KDATA & kd = m_pDataOriginal[i];
  1266. KDATA newkd = kd;
  1268. if( drPos >= 0 && ToDayDate(kd.m_date) < drtemp.ElementAt(drPos).m_date )
  1269. {
  1270. if( i < m_nSizeOriginal-1 )
  1271. fRatio = fRatio * GetRatio( kd.m_fClose, drtemp.ElementAt(drPos) );
  1273. drPos --;
  1274. }
  1275. else if( ToDayDate(kd.m_date) >= dateAutoDRBegin && i+1 < m_nSizeOriginal ) // Auto XDR
  1276. {
  1277. KDATA kdNext = m_pDataOriginal[i+1];
  1278. if( kdNext.m_fOpen > 1e-4 && kdNext.m_fOpen < kd.m_fClose
  1279. && fabs(kdNext.m_fOpen/kd.m_fClose-1) > dAutoDRLimit )
  1280. fRatio = fRatio * kdNext.m_fOpen / kd.m_fClose;
  1281. }
  1283. newkd.m_fOpen = (kd.m_fOpen * fRatio);
  1284. newkd.m_fHigh = (kd.m_fHigh * fRatio);
  1285. newkd.m_fLow = (kd.m_fLow * fRatio);
  1286. newkd.m_fClose = (kd.m_fClose * fRatio);
  1287. newkd.m_fVolume = (kd.m_fVolume / fRatio);
  1288. SetAt( i, newkd );
  1289. }
  1290. }
  1291. }