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

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

金融证券系统

开发平台：

Visual C++

Strategy.cpp：源码内容
  1. /*
  2. Cross Platform Core Code.
  4. Copyright(R) 2001-2002 Balang Software.
  5. All rights reserved.
  7. Using:
  8. class CRateParam;
  9. class COpParam;
  10. class CStockOwnContainer;
  11. class COpRecordContainer;
  12. class CAssetSerialContainer;
  13. class CTechStock;
  14. class CTechStockContainer;
  15. class CStrategy;
  16. */
  18. #include "stdafx.h"
  19. #include "../Include/Strategy.h"
  21. #ifdef _DEBUG
  22. #define new DEBUG_NEW
  23. #undef THIS_FILE
  24. static char THIS_FILE[] = __FILE__;
  25. #endif
  27. /////////////////////////////////////////////////////////////////////////////
  28. // CRateParam
  30. CRateParam::CRateParam( )
  31. {
  32. SetDefault( );
  33. }
  35. // 交易费用参数是否合法
  36. BOOL CRateParam::IsValid( )
  37. {
  38. return (m_dShaa >= 0 && m_dShaa < 0.1
  39. && m_dShab >= 0 && m_dShab < 0.1
  40. && m_dShafund >= 0 && m_dShafund < 0.1
  41. && m_dSzna >= 0 && m_dSzna < 0.1
  42. && m_dSznb >= 0 && m_dSznb < 0.1
  43. && m_dSznfund >= 0 && m_dSznfund < 0.1 );
  44. }
  46. // 缺省交易费用
  47. void CRateParam::SetDefault( )
  48. {
  49. m_dShaa = 0.003;
  50. m_dShab = 0.003;
  51. m_dShafund = 0.001;
  52. m_dSzna = 0.003;
  53. m_dSznb = 0.003;
  54. m_dSznfund = 0.001;
  55. }
  57. // 保存交易费用至文件
  58. void CRateParam::Serialize( CSPArchive &ar )
  59. {
  60. if( ar.IsStoring( ) )
  61. {
  62. ar << m_dShaa;
  63. ar << m_dShab;
  64. ar << m_dShafund;
  65. ar << m_dSzna;
  66. ar << m_dSznb;
  67. ar << m_dSznfund;
  68. }
  69. else
  70. {
  71. ar >> m_dShaa;
  72. ar >> m_dShab;
  73. ar >> m_dShafund;
  74. ar >> m_dSzna;
  75. ar >> m_dSznb;
  76. ar >> m_dSznfund;
  77. }
  78. }
  80. // 根据股票选择交易费率
  81. double CRateParam::GetRate( CStockInfo & info )
  82. {
  83. LONG stocktype = info.GetType();
  84. if( CStock::typeshA == stocktype || CStock::typeshIndex == stocktype )
  85. return m_dShaa;
  86. else if( CStock::typeshB == stocktype )
  87. return m_dShab;
  88. else if( info.IsShangHai() && info.IsFund() )
  89. return m_dShafund;
  90. else if( CStock::typeszA == stocktype || CStock::typeszIndex == stocktype )
  91. return m_dSzna;
  92. else if( CStock::typeszB == stocktype )
  93. return m_dSznb;
  94. else if( info.IsShenZhen() && info.IsFund() )
  95. return m_dSznfund;
  97. return 0;
  98. }
  100. /////////////////////////////////////////////////////////////////////////////
  101. // COpParam
  103. // 逻辑字符串，全部指标 任一指标
  104. CSPString AfxGetLogicString( int nLogic )
  105. {
  106. switch( nLogic )
  107. {
  108. case COpParam::logicAnd: return strategy_logicand;
  109. case COpParam::logicOr: return strategy_logicor;
  110. default:
  111. SP_ASSERT( FALSE );
  112. }
  113. return "";
  114. }
  116. // 仓位字符串
  117. CSPString AfxGetStoreDivString( int nStoreDiv )
  118. {
  119. switch( nStoreDiv )
  120. {
  121. case COpParam::storedivOnce: return strategy_sdonce;
  122. case COpParam::storedivTwice: return strategy_sdtwice;
  123. case COpParam::storedivThird: return strategy_sdthird;
  124. case COpParam::storedivForth: return strategy_sdforth;
  125. case COpParam::storedivFifth: return strategy_sdfifth;
  126. case COpParam::storedivSixth: return strategy_sdsixth;
  127. case COpParam::storedivSeventh: return strategy_sdseventh;
  128. case COpParam::storedivEighth: return strategy_sdeighth;
  129. case COpParam::storedivNinth: return strategy_sdninth;
  130. case COpParam::storedivTenth: return strategy_sdtenth;
  131. default:
  132. SP_ASSERT( FALSE );
  133. }
  134. return "";
  135. }
  137. COpParam::COpParam( )
  138. {
  139. SetDefault( );
  140. }
  142. // 操作条件是否合法
  143. BOOL COpParam::IsValid( )
  144. {
  145. if( CKData::ktypeDay != m_nKType && CKData::ktypeWeek != m_nKType && CKData::ktypeMonth != m_nKType )
  146. return FALSE;
  147. if( m_nMaindataType < CKData::mdtypeMin || m_nMaindataType > CKData::mdtypeMax )
  148. return FALSE;
  149. if( m_nBuyLogic < logicMin || m_nBuyLogic > logicMax )
  150. return FALSE;
  151. if( m_nBuyLimit < ITS_MIN || m_nBuyLimit > ITS_MAX )
  152. return FALSE;
  153. if( m_dBuyMulti <= 0.89 || m_dBuyMulti > 1.11 )
  154. return FALSE;
  155. if( m_nSellLogic < logicMin || m_nSellLogic > logicMax )
  156. return FALSE;
  157. if( m_nSellLimit < ITS_MIN || m_nSellLimit > ITS_MAX )
  158. return FALSE;
  159. if( m_dSellMulti <= 0.89 || m_dSellMulti > 1.11 )
  160. return FALSE;
  161. if( m_atmBegin.GetSize() <= 0 || m_atmEnd.GetSize() <= 0
  162. || m_atmBegin.GetSize() != m_atmEnd.GetSize() )
  163. return FALSE;
  164. // TIMEZONES
  165. if( m_nStartAmount < 1000 || m_nStartAmount > 2000000000 )
  166. return FALSE;
  167. if( m_nStoreDiv < storedivMin || m_nStoreDiv > COpParam::storedivMax )
  168. return FALSE;
  170. if( m_bStopLosing && ( m_dStopLosing <= 0 || m_dStopLosing >= 100 ) )
  171. return FALSE;
  172. if( m_bStopProfit && m_dStopProfit <= 0 )
  173. return FALSE;
  174. if( m_bLongTrend && CKData::ktypeDay != m_nKTypeLong && CKData::ktypeWeek != m_nKTypeLong && CKData::ktypeMonth != m_nKTypeLong )
  175. return FALSE;
  176. if( m_bIndexTrend && CKData::ktypeDay != m_nKTypeIndex && CKData::ktypeWeek != m_nKTypeIndex && CKData::ktypeMonth != m_nKTypeIndex )
  177. return FALSE;
  178. return TRUE;
  179. }
  181. // 缺省操作条件
  182. void COpParam::SetDefault( )
  183. {
  184. m_nKType = CKData::ktypeDay;
  185. m_nMaindataType = CKData::mdtypeClose;
  186. m_nBuyLogic = logicAnd;
  187. m_nBuyLimit = ITS_BUY;
  188. m_dBuyMulti = 1.0;
  189. m_nSellLogic = logicOr;
  190. m_nSellLimit = ITS_SELL;
  191. m_dSellMulti = 0.98;
  192. CSPTime tmCurrent = CSPTime::GetCurrentTime();
  193. m_atmBegin.RemoveAll();
  194. m_atmEnd.RemoveAll();
  195. m_atmBegin.Add( tmCurrent - CSPTimeSpan( 365 * 3, 0, 0, 0 ) );
  196. m_atmEnd.Add( tmCurrent );
  197. m_nStartAmount = 1000000;
  198. m_nStoreDiv = storedivThird;
  200. m_bStopLosing = FALSE;
  201. m_bStopProfit = FALSE;
  202. m_dStopLosing = 0.1;
  203. m_dStopProfit = 0.3;
  204. m_bLongTrend = FALSE;
  205. m_bIndexTrend = FALSE;
  206. m_nKTypeLong = CKData::ktypeWeek;
  207. m_nKTypeIndex = CKData::ktypeWeek;
  208. }
  210. // 设定不合法的操作条件为缺省值
  211. void COpParam::SetDefaultOfInvalidMember( )
  212. {
  213. if( CKData::ktypeDay != m_nKType && CKData::ktypeWeek != m_nKType && CKData::ktypeMonth != m_nKType )
  214. m_nKType = CKData::ktypeDay;
  215. if( m_nMaindataType < CKData::mdtypeMin || m_nMaindataType > CKData::mdtypeMax )
  216. m_nMaindataType = CKData::mdtypeClose;
  217. if( m_nBuyLogic < logicMin || m_nBuyLogic > logicMax )
  218. m_nBuyLogic = logicAnd;
  219. if( m_nBuyLimit < ITS_MIN || m_nBuyLimit > ITS_MAX )
  220. m_nBuyLimit = ITS_BUY;
  221. if( m_dBuyMulti <= 0.89 || m_dBuyMulti > 1.11 )
  222. m_dBuyMulti = 1.0;
  223. if( m_nSellLogic < logicMin || m_nSellLogic > logicMax )
  224. m_nSellLogic = logicOr;
  225. if( m_nSellLimit < ITS_MIN || m_nSellLimit > ITS_MAX )
  226. m_nSellLimit = ITS_SELL;
  227. if( m_dSellMulti <= 0.89 || m_dSellMulti > 1.11 )
  228. m_dSellMulti = 0.98;
  229. if( m_atmBegin.GetSize() <= 0 || m_atmEnd.GetSize() <= 0
  230. || m_atmBegin.GetSize() != m_atmEnd.GetSize() )
  231. {
  232. m_atmBegin.RemoveAll();
  233. m_atmEnd.RemoveAll();
  234. CSPTime tmCurrent = CSPTime::GetCurrentTime();
  235. m_atmBegin.Add( tmCurrent - CSPTimeSpan( 365 * 3, 0, 0, 0 ) );
  236. m_atmEnd.Add( tmCurrent );
  237. }
  238. // TIMEZONES
  239. if( m_nStartAmount < 1000 || m_nStartAmount > 2000000000 )
  240. m_nStartAmount = 1000000;
  241. if( m_nStoreDiv < storedivMin || m_nStoreDiv > storedivMax )
  242. m_nStoreDiv = storedivThird;
  244. if( m_bStopLosing && ( m_dStopLosing <= 0 || m_dStopLosing >= 100 ) )
  245. m_dStopLosing = 0.1;
  246. if( m_bStopProfit && m_dStopProfit <= 0 )
  247. m_dStopProfit = 0.3;
  248. if( m_bLongTrend && CKData::ktypeDay != m_nKTypeLong && CKData::ktypeWeek != m_nKTypeLong && CKData::ktypeMonth != m_nKTypeLong )
  249. m_nKTypeLong = CKData::ktypeWeek;
  250. if( m_bIndexTrend && CKData::ktypeDay != m_nKTypeIndex && CKData::ktypeWeek != m_nKTypeIndex && CKData::ktypeMonth != m_nKTypeIndex )
  251. m_nKTypeIndex = CKData::ktypeWeek;
  252. }
  254. // 保存或者读取硬盘文件
  255. void COpParam::Serialize( CSPArchive &ar )
  256. {
  257. if( ar.IsStoring( ) )
  258. {
  259. ar << m_nKType;
  260. ar << m_nMaindataType;
  261. ar << m_nBuyLogic;
  262. ar << m_nBuyLimit;
  263. ar << m_dBuyMulti;
  264. ar << m_nSellLogic;
  265. ar << m_nSellLimit;
  266. ar << m_dSellMulti;
  267. m_atmBegin.Serialize( ar );
  268. m_atmEnd.Serialize( ar );
  269. ar << m_nStartAmount;
  270. ar << m_nStoreDiv;
  272. ar << m_bStopLosing;
  273. ar << m_bStopProfit;
  274. ar << m_dStopLosing;
  275. ar << m_dStopProfit;
  276. ar << m_bLongTrend;
  277. ar << m_bIndexTrend;
  278. ar << m_nKTypeLong;
  279. ar << m_nKTypeIndex;
  280. }
  281. else
  282. {
  283. ar >> m_nKType;
  284. ar >> m_nMaindataType;
  285. ar >> m_nBuyLogic;
  286. ar >> m_nBuyLimit;
  287. ar >> m_dBuyMulti;
  288. ar >> m_nSellLogic;
  289. ar >> m_nSellLimit;
  290. ar >> m_dSellMulti;
  291. m_atmBegin.Serialize( ar );
  292. m_atmEnd.Serialize( ar );
  293. ar >> m_nStartAmount;
  294. ar >> m_nStoreDiv;
  296. ar >> m_bStopLosing;
  297. ar >> m_bStopProfit;
  298. ar >> m_dStopLosing;
  299. ar >> m_dStopProfit;
  300. ar >> m_bLongTrend;
  301. ar >> m_bIndexTrend;
  302. ar >> m_nKTypeLong;
  303. ar >> m_nKTypeIndex;
  304. }
  305. }
  307. // 给定时间是不是在模拟时间内
  308. BOOL COpParam::IsInTimeZones( CSPTime tm )
  309. {
  310. for( int i=0; i<m_atmBegin.GetSize() && i<m_atmEnd.GetSize(); i++ )
  311. {
  312. if( tm >= m_atmBegin.ElementAt(i) && tm <= m_atmEnd.ElementAt(i) )
  313. return TRUE;
  314. }
  315. return FALSE;
  316. }
  318. // 获取模拟开始时间
  319. CSPTime COpParam::GetBeginTime( )
  320. {
  321. if( m_atmBegin.GetSize() > 0 )
  322. return m_atmBegin.ElementAt(0);
  323. return CSPTime::GetCurrentTime();
  324. }
  326. // 获取模拟结束时间
  327. CSPTime COpParam::GetEndTime( )
  328. {
  329. if( m_atmEnd.GetSize() > 0 )
  330. return m_atmEnd.ElementAt(m_atmEnd.GetSize()-1);
  331. return CSPTime::GetCurrentTime();
  332. }
  334. // 获取下一个交易时间
  335. BOOL COpParam::GetNextTradeTime( CSPTime tmNow, CSPTime &tmNext )
  336. {
  337. CSPTime sptime( tmNow.GetTime() );
  338. DWORD dwDate = sptime.ToStockTime( CKData::IsDayOrMin(m_nKType) );
  339. DWORD dwDateNext = CSPTime::GetStockTimeNext( dwDate, m_nKType );
  340. if( sptime.FromStockTime( dwDateNext, CKData::IsDayOrMin(m_nKType) ) )
  341. {
  342. tmNext = sptime.GetTime();
  343. return TRUE;
  344. }
  345. return FALSE;
  346. }
  348. // 获取当前模拟进度
  349. DWORD COpParam::GetProgress( CSPTime tmNow, DWORD dwProgressMax )
  350. {
  351. // TIMEZONES
  352. if( !IsInTimeZones( tmNow ) )
  353. return 0;
  354. CSPTime tmBegin = GetBeginTime( );
  355. CSPTime tmEnd = GetEndTime( );
  356. double dBeginNow = ( tmNow.GetTime() - tmBegin.GetTime() );
  357. double dBeginEnd = ( tmEnd.GetTime() - tmBegin.GetTime() );
  358. double dProgress = 0;
  359. if( fabs(dBeginEnd) > 1e-4 )
  360. {
  361. dProgress = ( dBeginNow / dBeginEnd ) * dwProgressMax;
  362. }
  363. return (DWORD)dProgress;
  364. }
  366. /////////////////////////////////////////////////////////////////////////////
  367. // CStockOwnContainer
  369. // 拥有股票数组，加入股票
  370. BOOL CStockOwnContainer::AddStock( CStockInfo & info, DWORD dwShare, double dBuyPrice )
  371. {
  372. if( dwShare <= 0 )
  373. return FALSE;
  375. // 如果已经有了，改变数量
  376. for( int i=0; i<GetSize(); i++ )
  377. {
  378. STOCKOWN & own = ElementAt(i);
  379. if( info.IsEqualTo( own.dwMarket, own.szCode ) )
  380. {
  381. if( dBuyPrice > 0.005 && own.dwShare + dwShare > 0 )
  382. {
  383. own.dBuyPrice = (own.dBuyPrice * own.dwShare + dBuyPrice * dwShare) / (own.dwShare + dwShare);
  384. }
  385. own.dwShare += dwShare;
  386. return TRUE;
  387. }
  388. }
  389. // 加入新的
  390. STOCKOWN ownnew;
  391. memset( &ownnew, 0, sizeof(ownnew) );
  392. strncpy( ownnew.szCode, info.GetStockCode(), min(sizeof(ownnew.szCode)-1,strlen(info.GetStockCode())) );
  393. ownnew.dwShare = dwShare;
  394. ownnew.dBuyPrice = dBuyPrice;
  395. ownnew.dwMarket = info.GetMarket();
  396. return ( Add(ownnew) >= 0 );
  397. }
  399. // 拥有股票数组，移除股票
  400. BOOL CStockOwnContainer::RemoveStock( CStockInfo & info, DWORD dwShare )
  401. {
  402. for( int i=0; i<GetSize(); i++ )
  403. {
  404. STOCKOWN & own = ElementAt(i);
  405. if( info.IsEqualTo( own.dwMarket, own.szCode ) )
  406. {
  407. if( own.dwShare < dwShare )
  408. return FALSE;
  409. own.dwShare -= dwShare;
  410. if( 0 == own.dwShare )
  411. RemoveAt(i);
  412. return TRUE;
  413. }
  414. }
  415. return FALSE;
  416. }
  418. // 拥有股票数组，是否有这个股票，如果有，返回至lpOwn
  419. BOOL CStockOwnContainer::HasThisStock( CStockInfo & info, LPSTOCKOWN lpOwn )
  420. {
  421. for( int i=0; i<GetSize(); i++ )
  422. {
  423. STOCKOWN & own = ElementAt(i);
  424. if( info.IsEqualTo( own.dwMarket, own.szCode ) )
  425. {
  426. if( lpOwn )
  427. memcpy( lpOwn, &own, sizeof(own) );
  428. return ( own.dwShare > 0 );
  429. }
  430. }
  431. return FALSE;
  432. }
  434. /////////////////////////////////////////////////////////////////////////////
  435. // COpRecordContainer
  436. // 操作描述
  437. CSPString AfxGetStrategyOpTypeString( long lOpType )
  438. {
  439. CSPString strOp;
  440. if( STRATEGY_OPTYPE_BUY == lOpType )
  441. return strategy_optype_buy;
  442. else if( STRATEGY_OPTYPE_SELL == lOpType )
  443. return strategy_optype_sell;
  444. else if( STRATEGY_OPTYPE_ADDSTOCK == lOpType )
  445. return strategy_optype_addstock;
  446. else if( STRATEGY_OPTYPE_REMOVESTOCK == lOpType )
  447. return strategy_optype_removestock;
  448. else if( STRATEGY_OPTYPE_ADDCASH == lOpType )
  449. return strategy_optype_addcash;
  450. else if( STRATEGY_OPTYPE_REMOVECASH == lOpType )
  451. return strategy_optype_removecash;
  452. return strOp;
  453. }
  455. // 操作记录数组，加入记录
  456. int COpRecordContainer::AddRecord(long lOpType, CSPTime tm, const char *szCode,
  457.    DWORD dwShare, double dSharePrice, double dRateCost )
  458. {
  459. SP_ASSERT( NULL != szCode && strlen(szCode) > 0 );
  460. if( NULL == szCode || strlen(szCode) <= 0 )
  461. return -1;
  463. OPRECORD record;
  464. memset( &record, 0, sizeof(record) );
  466. record.lOpType = lOpType;
  467. record.time = tm.GetTime();
  468. strncpy( record.szCode, szCode, min(sizeof(record.szCode)-1,strlen(szCode)) );
  469. record.dwShare = dwShare;
  470. record.dSharePrice = dSharePrice;
  471. record.dRateCost = dRateCost;
  472. record.dwMarket = CStock::marketUnknown;
  473. return Add( record );
  474. }
  476. // 操作记录数组，加入记录，记录中如果已经有该股票的记录，更改为现在的信息
  477. int COpRecordContainer::AddRecordUniqueStock(long lOpType, CSPTime tm, const char *szCode,
  478.    DWORD dwShare, double dSharePrice, double dRateCost )
  479. {
  480. SP_ASSERT( NULL != szCode && strlen(szCode) > 0 );
  481. if( NULL == szCode || strlen(szCode) <= 0 )
  482. return -1;
  484. OPRECORD record;
  485. memset( &record, 0, sizeof(record) );
  487. for( int i=0; i<GetSize(); i++ )
  488. {
  489. if( 0 == strncmp( ElementAt(i).szCode, szCode, sizeof(record.szCode) ) )
  490. {
  491. ElementAt(i).lOpType = lOpType;
  492. ElementAt(i).time = tm.GetTime();
  493. strncpy( ElementAt(i).szCode, szCode, min(sizeof(ElementAt(i).szCode)-1,strlen(szCode)) );
  494. ElementAt(i).dwShare = dwShare;
  495. ElementAt(i).dSharePrice = dSharePrice;
  496. ElementAt(i).dRateCost = dRateCost;
  497. ElementAt(i).dwMarket = CStock::marketUnknown;
  498. return i;
  499. }
  500. }
  502. record.lOpType = lOpType;
  503. record.time = tm.GetTime();
  504. strncpy( record.szCode, szCode, min(sizeof(record.szCode)-1,strlen(szCode)) );
  505. record.dwShare = dwShare;
  506. record.dSharePrice = dSharePrice;
  507. record.dRateCost = dRateCost;
  508. record.dwMarket = CStock::marketUnknown;
  509. return Add( record );
  510. }
  512. // 操作记录数组，得到买入记录数
  513. int COpRecordContainer::GetBuyRecordCount()
  514. {
  515. int nCount = 0;
  516. for( int i=0; i<GetSize(); i++ )
  517. {
  518. OPRECORD & record = ElementAt(i);
  519. if( STRATEGY_OPTYPE_BUY == record.lOpType )
  520. nCount ++;
  521. }
  522. return nCount;
  523. }
  525. // 操作记录数组，是否有szCode股票的买入记录
  526. BOOL COpRecordContainer::HasBuyStock( const char * szCode )
  527. {
  528. if( NULL == szCode || strlen(szCode) < 0 )
  529. return FALSE;
  531. for( int i=0; i<GetSize(); i++ )
  532. {
  533. OPRECORD & record = ElementAt(i);
  534. if( STRATEGY_OPTYPE_BUY == record.lOpType )
  535. {
  536. if( 0 == strncmp( record.szCode, szCode, min(sizeof(record.szCode),strlen(szCode)) ) )
  537. return TRUE;
  538. }
  539. }
  540. return FALSE;
  541. }
  543. // 操作记录数组，统计结果：操作次数，成功次数，最大收益，最低收益
  544. BOOL COpRecordContainer::StatResults( int *pnTimes, int *pnVictoryTimes, double *pdYieldMax, double *pdYieldMin )
  545. {
  546. int nTimes = 0, nVictoryTimes = 0;
  547. double dYieldMax = 0, dYieldMin = 0;
  549. for( int i=0; i<GetSize(); i++ )
  550. {
  551. OPRECORD & record = ElementAt(i);
  552. if( STRATEGY_OPTYPE_BUY != record.lOpType )
  553. continue;
  555. // 查找当前买入操作的对应卖出操作
  556. for( int j=i+1; j<GetSize(); j++ )
  557. {
  558. OPRECORD & record2 = ElementAt(j);
  559. if( STRATEGY_OPTYPE_SELL == record2.lOpType && 0 == strncmp(record.szCode,record2.szCode,sizeof(record.szCode)) )
  560. { // 如果是卖出操作，根据买入价格和卖出价格计算收益率
  561. if( record.dwShare > 0 && record2.dwShare > 0 )
  562. {
  563. double dBuy = record.dSharePrice + record.dRateCost/record.dwShare;
  564. double dSell = record2.dSharePrice - record2.dRateCost/record2.dwShare;
  565. if( dBuy > 1e-4 )
  566. {
  567. double dYield = (dSell - dBuy)/dBuy;
  568. nTimes ++;
  569. if( dYield > 0 ) nVictoryTimes ++;
  570. if( 1 == nTimes ) dYieldMax = dYieldMin = dYield;
  571. if( dYieldMax < dYield ) dYieldMax = dYield;
  572. if( dYieldMin > dYield ) dYieldMin = dYield;
  573. }
  574. }
  575. break;
  576. }
  577. }
  578. }
  579. if( pnTimes ) *pnTimes = nTimes;
  580. if( pnVictoryTimes ) *pnVictoryTimes = nVictoryTimes;
  581. if( pdYieldMax ) *pdYieldMax = dYieldMax;
  582. if( pdYieldMin ) *pdYieldMin = dYieldMin;
  583. return TRUE;
  584. }
  586. //////////////////////////////////////////////////////////////////////
  587. // CAssetSerialContainer 
  588. // 资产序列数组，按时间排序插入
  589. BOOL CAssetSerialContainer::SortInsert( ASSETSERIAL serial )
  590. {
  591. BOOL bAdded = FALSE;
  592. for( int i=GetSize()-1; i>=0; i-- )
  593. {
  594. ASSETSERIAL & se = ElementAt(i);
  595. if( se.time == serial.time )
  596. {
  597. se.dAsset = serial.dAsset;
  598. se.dCash = serial.dCash;
  599. bAdded = TRUE;
  600. break;
  601. }
  602. else if( se.time < serial.time )
  603. {
  604. InsertAt( i+1, serial );
  605. bAdded = TRUE;
  606. break;
  607. }
  608. }
  609. if( !bAdded )
  610. InsertAt( 0, serial );
  611. return TRUE;
  612. }
  614. // 资产序列数组，获得资产序列标准差
  615. BOOL CAssetSerialContainer::GetStdDev( double *pdStdDev, double *pdXiapu )
  616. {
  617. if( GetSize() <= 0 )
  618. return FALSE;
  619. double dInit = ElementAt(0).dAsset;
  620. if( dInit < 1e-4 )
  621. return FALSE;
  623. double dSum = 0., dSquareSum = 0.;
  624. for( int k = 0; k<GetSize(); k++ )
  625. {
  626. double dNow = (ElementAt(k).dAsset - dInit) / dInit;
  627. dSum += dNow;
  628. dSquareSum += dNow*dNow;
  629. }
  631. double dAverage = dSum / GetSize();
  632. if( dAverage < 1e-4 )
  633. return FALSE;
  634. double dStdDev = dSquareSum / GetSize() - ( dAverage*dAverage );
  635. if( dStdDev > 0 )
  636. dStdDev = sqrt( dStdDev );
  637. if( pdStdDev ) *pdStdDev = dStdDev;
  638. if( pdXiapu ) *pdXiapu = (dStdDev / dAverage);
  639. return TRUE;
  640. }
  642. //////////////////////////////////////////////////////////////////////
  643. // CTechStock
  645. CTechStock::CTechStock( )
  646. {
  647. m_bAutoDelete = TRUE;
  649. m_kdata.SetKType(CKData::ktypeDay);
  650. m_kdataLong.SetKType(CKData::ktypeDay);
  651. }
  653. CTechStock::CTechStock( const CTechStock & src )
  654. {
  655. *this = src;
  656. }
  658. CTechStock & CTechStock::operator = ( const CTechStock &src )
  659. {
  660. m_bAutoDelete = FALSE;
  662. m_info = src.m_info;
  663. m_kdata = src.m_kdata;
  664. m_kdataLong = src.m_kdataLong;
  665. m_techs.Copy( src.m_techs );
  666. m_techsLong.Copy( src.m_techsLong );
  667. return *this;
  668. }
  670. void CTechStock::SetAutoDelete( BOOL bAutoDelete )
  671. {
  672. m_bAutoDelete = bAutoDelete;
  673. }
  675. CTechStock::~CTechStock( )
  676. {
  677. Clear( );
  678. }
  680. // 清除内存
  681. void CTechStock::Clear( )
  682. {
  683. if( m_bAutoDelete )
  684. {
  685. for( int i=0; i<m_techs.GetSize(); i++ )
  686. {
  687. CTechnique * pTech = (CTechnique *)m_techs.ElementAt(i);
  688. if( pTech )
  689. delete pTech;
  690. }
  691. for( i=0; i<m_techsLong.GetSize(); i++ )
  692. {
  693. CTechnique * pTech = (CTechnique *)m_techsLong.ElementAt(i);
  694. if( pTech )
  695. delete pTech;
  696. }
  697. }
  698. m_techs.RemoveAll();
  699. m_techsLong.RemoveAll();
  700. }
  702. // 指定日期，指定操作，指定委托价格，得到股票的成交价格
  703. BOOL CTechStock::GetPriceOK( long lOpType, CSPTime tmCur, DWORD dwShare, double dSharePrice, double *pdPriceOK )
  704. {
  705. double dPriceOK = dSharePrice;
  707. CSPTime sptimeCur(tmCur.GetTime());
  708. DWORD dwDate = sptimeCur.ToStockTimeDay();
  709. int nIndex = m_kdata.GetIndexByDate( dwDate );
  710. if( -1 == nIndex )
  711. return FALSE;
  713. KDATA & kd = m_kdata.ElementAt(nIndex);
  714. if( STRATEGY_OPTYPE_BUY == lOpType )
  715. {
  716. if( dSharePrice < kd.m_fLow )
  717. return FALSE;
  718. if( dSharePrice > kd.m_fOpen )
  719. dPriceOK = kd.m_fOpen;
  720. else
  721. dPriceOK = dSharePrice;
  722. }
  723. else if( STRATEGY_OPTYPE_SELL == lOpType )
  724. {
  725. if( dSharePrice > kd.m_fHigh )
  726. return FALSE;
  727. if( dSharePrice < kd.m_fOpen )
  728. dPriceOK = kd.m_fOpen;
  729. else
  730. dPriceOK = dSharePrice;
  731. }
  732. else
  733. return FALSE;
  735. if( pdPriceOK ) *pdPriceOK = dPriceOK;
  736. return TRUE;
  737. }
  739. // 指定日期是否停牌
  740. BOOL CTechStock::IsStopTrading( CSPTime tmCur )
  741. {
  742. CSPTime sptimeCur(tmCur.GetTime());
  743. DWORD dwDate = sptimeCur.ToStockTimeDay();
  744. int nIndex = m_kdata.GetIndexByDate( dwDate );
  745. if( -1 == nIndex )
  746. {
  747. if( -1 != m_kdata.GetAboutIndexByDate( dwDate ) )
  748. return TRUE;
  749. return FALSE;
  750. }
  752. KDATA & kd = m_kdata.ElementAt(nIndex);
  753. float fLastClose = kd.m_fOpen;
  754. if( nIndex > 0 )
  755. fLastClose = m_kdata.ElementAt(nIndex-1).m_fClose;
  757. if( fabs(kd.m_fOpen-kd.m_fClose) < 1e-4 && fabs(kd.m_fOpen-kd.m_fHigh) < 1e-4
  758. && fabs(kd.m_fOpen-kd.m_fLow) < 1e-4 && fabs(kd.m_fOpen-fLastClose) < 1e-4 )
  759. return TRUE;
  760. return FALSE;
  761. }
  763. // 得到股票的收盘价
  764. BOOL CTechStock::GetClosePrice( CSPTime tmCur, double *pdPrice )
  765. {
  766. CSPTime sptimeCur(tmCur.GetTime());
  767. DWORD dwDate = sptimeCur.ToStockTimeDay();
  768. int nIndex = m_kdata.GetAboutIndexByDate( dwDate );
  769. if( -1 == nIndex )
  770. {
  771. SP_ASSERT( FALSE );
  772. return FALSE;
  773. }
  775. KDATA & kd = m_kdata.ElementAt(nIndex);
  776. if( pdPrice ) *pdPrice = kd.m_fClose;
  777. return TRUE;
  778. }
  780. // 得到股票的收盘价涨幅%
  781. BOOL CTechStock::GetCloseDiffPercent( CSPTime tmCur, double *pdDiffPercent )
  782. {
  783. if( pdDiffPercent ) *pdDiffPercent = 0;
  785. CSPTime sptimeCur(tmCur.GetTime());
  786. DWORD dwDate = sptimeCur.ToStockTimeDay();
  787. int nIndex = m_kdata.GetIndexByDate( dwDate );
  788. if( -1 == nIndex || nIndex <= 0 )
  789. {
  790. return FALSE;
  791. }
  793. KDATA & kd = m_kdata.ElementAt(nIndex);
  794. KDATA & kdLast = m_kdata.ElementAt(nIndex-1);
  795. if( pdDiffPercent && kdLast.m_fClose > 1e-4 )
  796. {
  797. *pdDiffPercent = 100. * (kd.m_fClose-kdLast.m_fClose)/kdLast.m_fClose;
  798. }
  799. return TRUE;
  800. }
  802. /////////////////////////////////////////////////////////////////////////////
  803. // CTechStockContainer
  805. CTechStockContainer::~CTechStockContainer( )
  806. {
  807. Clear( );
  808. }
  810. void CTechStockContainer::Clear( )
  811. {
  812. m_infoIndex.Clear();
  813. m_kdataIndex.Clear();
  814. m_kdataIndex.SetKType(CKData::ktypeDay);
  816. for( int i=0; i<m_techsIndex.GetSize(); i++ )
  817. {
  818. CTechnique * pTech = (CTechnique *)m_techsIndex.ElementAt(i);
  819. if( pTech )
  820. delete pTech;
  821. }
  822. m_techsIndex.RemoveAll();
  824. for( i=0; i<GetSize(); i++ )
  825. {
  826. CTechStock & stock = ElementAt(i);
  827. stock.Clear( );
  828. }
  829. RemoveAll();
  830. }
  832. // 给定CTechStock，日期tmCur，资金dCash，交易费率rate，操作条件opparam，
  833. // 现在拥有股票数量nOwnedStockCount，计算需要买入的股票数量和委托价格及委托时间，
  834. // 如果不需要买入，返回FALSE
  835. BOOL CTechStockContainer::GetShouldBuyShare( CTechStock & techstock, CSPTime tmCur, double dCash, CRateParam &rate, COpParam &opparam, int nOwnedStockCount,
  836. CSPTime *ptmOp, DWORD *pdwShare, double *pdSharePrice )
  837. {
  838. CSPTime tmOp = tmCur;
  839. DWORD dwShare = 0;
  840. double dSharePrice = 0;
  842. CSPTime sptimeCur(tmCur.GetTime());
  843. DWORD dwDate = sptimeCur.ToStockTimeDay();
  844. int nIndex = techstock.m_kdata.GetIndexByDate( dwDate ); // 得到nIndex，指向techstock.m_kdata数组的当前日期位置
  845. if( -1 == nIndex )
  846. return FALSE;
  847. double dPriceNow = techstock.m_kdata.ElementAt(nIndex).m_fClose; // 当前价
  849. // 买入判断
  850. BOOL bBuy = TRUE;
  851. if( COpParam::logicOr == opparam.m_nBuyLogic ) // 全部条件还是任一条件
  852. bBuy = FALSE;
  853. for( int i=0; i<techstock.m_techs.GetSize(); i++ ) // 每一个设定指标，分别判断
  854. {
  855. CTechnique * pTech = (CTechnique *)techstock.m_techs.ElementAt(i); // 技术指标
  856. SP_ASSERT( NULL != pTech );
  857. if( NULL == pTech )
  858. continue;
  860. int nIntensity = pTech->GetSignal( nIndex ); // 当前买卖信号
  861. if( COpParam::logicOr == opparam.m_nBuyLogic )
  862. {
  863. if( nIntensity >= opparam.m_nBuyLimit ) // 买卖信号是否达到所需条件
  864. bBuy = TRUE;
  865. }
  866. else
  867. {
  868. if( nIntensity < opparam.m_nBuyLimit )
  869. bBuy = FALSE;
  870. }
  871. }
  873. // Long and Index Trend
  874. if( bBuy )
  875. {
  876. // 如果技术指标判断为买入，判断是否满足长周期趋势和指数趋势
  877. if( opparam.m_bLongTrend ) // 长周期趋势
  878. {
  879. int nIndexLong = techstock.m_kdataLong.GetAboutIndexByDate( dwDate );
  880. if( opparam.m_nKTypeLong > opparam.m_nKType )
  881. nIndexLong --;
  882. if( nIndexLong >= 0 )
  883. {
  884. for( i=0; i<techstock.m_techsLong.GetSize(); i++ )
  885. {
  886. CTechnique * pTech = (CTechnique *)techstock.m_techsLong.ElementAt(i);
  887. SP_ASSERT( NULL != pTech );
  888. if( NULL == pTech )
  889. continue;
  890. pTech->ClearLastIntensity();
  891. int nIntensity = pTech->GetIntensity( nIndexLong ); // 得到当前趋势
  892. if( !ITS_ISBUY(nIntensity) )
  893. bBuy = FALSE;
  894. }
  895. }
  896. }
  897. if( opparam.m_bIndexTrend ) // 指数趋势
  898. {
  899. int nIndexIndex = m_kdataIndex.GetAboutIndexByDate( dwDate );
  900. if( opparam.m_nKTypeIndex > opparam.m_nKType )
  901. nIndexIndex --;
  902. if( nIndexIndex >= 0 )
  903. {
  904. for( i=0; i<m_techsIndex.GetSize(); i++ )
  905. {
  906. CTechnique * pTech = (CTechnique *)m_techsIndex.ElementAt(i);
  907. SP_ASSERT( NULL != pTech );
  908. if( NULL == pTech )
  909. continue;
  910. pTech->ClearLastIntensity();
  911. int nIntensity = pTech->GetIntensity( nIndexIndex );
  912. if( !ITS_ISBUY(nIntensity) )
  913. bBuy = FALSE;
  914. }
  915. }
  916. }
  917. }
  919. if( bBuy ) // 确定买入了
  920. {
  921. if( !opparam.GetNextTradeTime(tmCur, tmOp) ) // 操作日期，下一个交易日
  922. return FALSE;
  924. if( opparam.m_nStoreDiv-nOwnedStockCount <= 0 ) // 股票已经够多了，不能再买入新的了
  925. return FALSE;
  926. double dUseCash = dCash / (opparam.m_nStoreDiv-nOwnedStockCount); // 需使用资金
  928. if( dCash < dUseCash )
  929. dUseCash = dCash; // 资金不够，则有多少用多少
  931. dSharePrice = opparam.m_dBuyMulti * dPriceNow;
  932. double dTemp = dSharePrice * ( 1 + rate.GetRate( techstock.m_info ) );
  933. if( fabs(dTemp) < 1e-4 || dUseCash < 1e-4 )
  934. return FALSE;
  936. dwShare = (DWORD)( dUseCash / dTemp ); // 买入股数
  937. dwShare = ( dwShare / 100 ) * 100; // 取整
  938. if( 0 == dwShare )
  939. return FALSE;
  941. if( ptmOp ) *ptmOp = tmOp;
  942. if( pdwShare ) *pdwShare = dwShare;
  943. if( pdSharePrice ) *pdSharePrice = dSharePrice;
  944. return TRUE;
  945. }
  947. return FALSE;
  948. }
  950. // 给定CTechStock，日期tmCur，资金dCash，拥有股票own(含有买入时价格)，操作条件opparam，
  951. // 现在拥有股票数量nOwnedStockCount，计算需要卖出的股票数量和委托价格及委托时间，
  952. // 如果不需要卖出，返回FALSE
  953. BOOL CTechStockContainer::GetShouldSellShare( CTechStock & techstock, CSPTime tmCur, STOCKOWN & own, COpParam &opparam,
  954. CSPTime *ptmOp, DWORD *pdwShare, double *pdSharePrice )
  955. {
  956. CSPTime tmOp = tmCur;
  957. DWORD dwShare = 0;
  958. double dSharePrice = 0;
  960. CSPTime sptimeCur(tmCur.GetTime());
  961. DWORD dwDate = sptimeCur.ToStockTimeDay();
  962. int nIndex = techstock.m_kdata.GetIndexByDate( dwDate ); // 得到nIndex，指向techstock.m_kdata数组的当前日期位置
  963. if( -1 == nIndex )
  964. return FALSE;
  965. double dPriceNow = techstock.m_kdata.ElementAt(nIndex).m_fClose; // 当前价
  967. // 卖出判断
  968. BOOL bSell = FALSE;
  969. if( COpParam::logicAnd == opparam.m_nSellLogic ) // 全部条件还是任一条件
  970. bSell = TRUE;
  971. for( int i=0; i<techstock.m_techs.GetSize(); i++ ) // 每一个技术指标，分别判断
  972. {
  973. CTechnique * pTech = (CTechnique *)techstock.m_techs.ElementAt(i);
  974. SP_ASSERT( NULL != pTech );
  975. if( NULL == pTech )
  976. continue;
  978. int nIntensity = pTech->GetSignal( nIndex ); // 当前买卖信号
  979. if( COpParam::logicAnd == opparam.m_nSellLogic )
  980. {
  981. if( nIntensity > opparam.m_nSellLimit ) // 买卖信号是否达到所需条件
  982. bSell = FALSE;
  983. }
  984. else
  985. {
  986. if( nIntensity <= opparam.m_nSellLimit )
  987. bSell = TRUE;
  988. }
  989. }
  991. // StopLosing and StopProfit 止损和止赢
  992. if( opparam.m_bStopLosing && dPriceNow < own.dBuyPrice * (1-opparam.m_dStopLosing) ) // 止损
  993. bSell = TRUE;
  994. if( opparam.m_bStopProfit && dPriceNow > own.dBuyPrice * (1+opparam.m_dStopProfit) ) // 止赢
  995. bSell = TRUE;
  997. if( bSell ) // 确定卖出了
  998. {
  999. if( !opparam.GetNextTradeTime(tmCur, tmOp) ) // 操作日期，下一个交易日
  1000. return FALSE;
  1001. dwShare = own.dwShare;
  1002. dSharePrice = opparam.m_dSellMulti * dPriceNow;
  1004. if( ptmOp ) *ptmOp = tmOp;
  1005. if( pdwShare ) *pdwShare = dwShare;
  1006. if( pdSharePrice ) *pdSharePrice = dSharePrice;
  1007. return TRUE;
  1008. }
  1010. return FALSE;
  1011. }
  1013. // 得到某只股票szCode在日期tmCur的收盘价
  1014. BOOL CTechStockContainer::GetClosePrice( const char * szCode, CSPTime tmCur, double * pdPrice )
  1015. {
  1016. if( NULL == szCode || strlen(szCode) <= 0 || GetSize() <= 0 )
  1017. return FALSE;
  1019. for( int j=0; j<GetSize(); j++ )
  1020. {
  1021. CTechStock & techstock = ElementAt(j);
  1022. if( techstock.m_info.IsEqualTo( CStock::marketUnknown, szCode ) )
  1023. {
  1024. return techstock.GetClosePrice( tmCur, pdPrice );
  1025. }
  1026. }
  1028. return FALSE;
  1029. }
  1031. // 得到某日的总资产
  1032. BOOL CTechStockContainer::GetSumAsset( CSPTime tmCur, CStockOwnContainer &container, double * pdAsset )
  1033. {
  1034. if( GetSize() <= 0 )
  1035. return FALSE;
  1037. double dAsset = 0;
  1038. for( int i=0; i<container.GetSize(); i++ )
  1039. {
  1040. STOCKOWN & own = container.ElementAt(i);
  1041. double dPrice = 0;
  1042. if( !GetClosePrice( own.szCode, tmCur, &dPrice ) )
  1043. return FALSE;
  1044. dAsset += dPrice * own.dwShare;
  1045. }
  1047. if( pdAsset ) *pdAsset = dAsset;
  1048. return TRUE;
  1049. }
  1051. // 得到下一个有成交量的交易日
  1052. BOOL CTechStockContainer::GetNextExistTradeTime( CSPTime tmCur, CSPTime & tmNext )
  1053. {
  1054. CSPTime sptime(tmCur.GetTime());
  1055. DWORD dateCur = sptime.ToStockTimeDay( );
  1056. DWORD dateNext = -1;
  1057. for( int i=0; i<GetSize(); i++ )
  1058. {
  1059. CTechStock & techstock = ElementAt(i);
  1060. int nIndex = techstock.m_kdata.GetAboutIndexByDate( dateCur );
  1061. if( -1 != nIndex && nIndex+1 < techstock.m_kdata.GetSize() )
  1062. {
  1063. if( -1 == dateNext )
  1064. dateNext = techstock.m_kdata.ElementAt(nIndex+1).m_date;
  1065. else if( dateNext > techstock.m_kdata.ElementAt(nIndex+1).m_date )
  1066. dateNext = techstock.m_kdata.ElementAt(nIndex+1).m_date;
  1067. }
  1068. }
  1069. if( -1 != dateNext && sptime.FromStockTimeDay( dateNext ) )
  1070. {
  1071. tmNext = sptime.GetTime();
  1072. return TRUE;
  1073. }
  1074. return FALSE;
  1075. }
  1077. /////////////////////////////////////////////////////////////////////////////
  1078. // CStrategy
  1080. // 给定策略文件，得到策略名称
  1081. CSPString CStrategy::GetName( LPCTSTR lpszPath )
  1082. {
  1083. if( NULL == lpszPath || strlen(lpszPath) <= 0 )
  1084. return "";
  1086. CSPString strName;
  1087. CStrategy doc;
  1088. CSPFile file;
  1089. if( file.Open( lpszPath, CSPFile::modeRead) )
  1090. {
  1091. CSPArchive ar(&file, CSPArchive::load | CSPArchive::bNoFlushOnDelete);
  1092. if( file.GetLength() > 0 )
  1093. doc.Serialize( ar, NULL, 0 );
  1095. ar.Close();
  1096. file.Close();
  1097. strName = doc.m_strName;
  1098. }
  1100. if( strName.IsEmpty() )
  1101. strName = lpszPath;
  1102. return strName;
  1103. }
  1105. /////////////////////////////////////////////////////////////////////////////
  1106. // CStrategy construction/destruction
  1108. char szCELFileMagic[] = "BALANG CEL FILE.";
  1109. DWORD dwCELFileVersion = 0x20000000;
  1111. CStrategy::CStrategy()
  1112. {
  1113. SimuReset( );
  1114. RealReset( );
  1115. }
  1117. CStrategy::~CStrategy()
  1118. {
  1119. ClearCache( );
  1120. }
  1122. // 打开策略文件
  1123. BOOL CStrategy::OpenStrategyFile( LPCTSTR lpszPathName, LPSTR lpErr, UINT nMaxSize )
  1124. {
  1125. CSPFile file;
  1126. if( NULL != lpszPathName && file.Open( lpszPathName, CSPFile::modeRead) )
  1127. {
  1128. if( 0 == file.GetLength() )
  1129. {
  1130. SetPathName(lpszPathName);
  1131. return TRUE;
  1132. }
  1134. CSPArchive ar(&file, CSPArchive::load | CSPArchive::bNoFlushOnDelete);
  1135. BOOL bSuccess = Serialize( ar, lpErr, nMaxSize );
  1136. ar.Close();
  1137. file.Close();
  1138. if( bSuccess )
  1139. SetPathName(lpszPathName);
  1140. return bSuccess;
  1141. }
  1143. SetPathName( NULL );
  1144. return FALSE;
  1145. }
  1147. BOOL CStrategy::SaveStrategyFile( LPCTSTR lpszPathName )
  1148. {
  1149. CSPString newName;
  1150. if( lpszPathName )
  1151. newName = lpszPathName;
  1152. if (newName.IsEmpty())
  1153. newName = m_strPathName;
  1155. CSPFile file;
  1156. if( file.Open( newName, CSPFile::modeCreate | CSPFile::modeWrite) )
  1157. {
  1158. CSPArchive ar(&file, CSPArchive::store);
  1159. Serialize( ar, NULL, 0 );
  1160. ar.Close();
  1161. file.Close();
  1162. SetPathName(newName);
  1163. return TRUE;
  1164. }
  1166. return FALSE;
  1167. }
  1169. /////////////////////////////////////////////////////////////////////////////
  1170. // CStrategy serialization
  1172. // 文件保存和读取
  1173. BOOL CStrategy::Serialize(CSPArchive& ar, LPSTR lpErr, UINT nMaxSize )
  1174. {
  1175. if( lpErr && nMaxSize>0 )
  1176. memset(lpErr,0,nMaxSize);
  1178. if (ar.IsStoring())
  1179. {
  1180. ar.Write( szCELFileMagic, sizeof(szCELFileMagic) );
  1182. ar << dwCELFileVersion;
  1183. ar << m_strName;
  1184. ar << m_strDescript;
  1185. m_stocks.Serialize( ar );
  1187. m_rate.Serialize( ar );
  1189. m_paramBuy.Serialize( ar );
  1190. m_paramSell.Serialize( ar );
  1191. m_paramLongTrend.Serialize( ar );
  1192. m_paramIndexTrend.Serialize( ar );
  1194. m_anTechsBuy.Serialize( ar );
  1195. m_anTechsSell.Serialize( ar );
  1196. m_anTechsLongTrend.Serialize( ar );
  1197. m_anTechsIndexTrend.Serialize( ar );
  1199. m_opparam.Serialize( ar );
  1201. // Simulation
  1202. ar << m_SimuCurrentStatus;
  1203. ar << m_SimuCurrentTime;
  1204. ar << m_SimuCurrentCash;
  1205. m_SimuStockOwn.Serialize( ar );
  1206. m_SimuOpRecord.Serialize( ar );
  1207. m_SimuNextOp.Serialize( ar );
  1208. m_SimuAssetSerial.Serialize( ar );
  1210. // Real Operation
  1211. ar << m_RealBeginTime;
  1212. ar << m_RealCurrentTime;
  1213. ar << m_RealCurrentCash;
  1214. m_RealStockOwn.Serialize( ar );
  1215. m_RealOpRecord.Serialize( ar );
  1216. m_RealNextOp.Serialize( ar );
  1217. m_RealAssetSerial.Serialize( ar );
  1218. }
  1219. else
  1220. {
  1221. char buffer[sizeof(szCELFileMagic)+1];
  1222. if( sizeof(szCELFileMagic) != ar.Read( buffer, sizeof(szCELFileMagic) )
  1223. || 0 != strncmp( buffer, szCELFileMagic, sizeof(szCELFileMagic) ) )
  1224. {
  1225. if( lpErr )
  1226. strncpy(lpErr,strategy_errfile,min(nMaxSize-1,strlen(strategy_errfile)) );
  1227. return FALSE;
  1228. }
  1230. ar >> m_dwFileVersion;
  1231. if( m_dwFileVersion > dwCELFileVersion )
  1232. {
  1233. if( lpErr )
  1234. strncpy(lpErr,strategy_errfilever,min(nMaxSize-1,strlen(strategy_errfilever)) );
  1235. return FALSE;
  1236. }
  1238. ar >> m_strName;
  1239. ar >> m_strDescript;
  1240. m_stocks.Serialize( ar );
  1242. m_rate.Serialize( ar );
  1244. m_paramBuy.Serialize( ar );
  1245. m_paramSell.Serialize( ar );
  1246. m_paramLongTrend.Serialize( ar );
  1247. m_paramIndexTrend.Serialize( ar );
  1249. m_anTechsBuy.Serialize( ar );
  1250. m_anTechsSell.Serialize( ar );
  1251. m_anTechsLongTrend.Serialize( ar );
  1252. m_anTechsIndexTrend.Serialize( ar );
  1254. m_opparam.Serialize( ar );
  1256. // Simulation
  1257. ar >> m_SimuCurrentStatus;
  1258. ar >> m_SimuCurrentTime;
  1259. ar >> m_SimuCurrentCash;
  1260. m_SimuStockOwn.Serialize( ar );
  1261. m_SimuOpRecord.Serialize( ar );
  1262. m_SimuNextOp.Serialize( ar );
  1263. m_SimuAssetSerial.Serialize( ar );
  1265. // Real Operation
  1266. ar >> m_RealBeginTime;
  1267. ar >> m_RealCurrentTime;
  1268. ar >> m_RealCurrentCash;
  1269. m_RealStockOwn.Serialize( ar );
  1270. m_RealOpRecord.Serialize( ar );
  1271. m_RealNextOp.Serialize( ar );
  1272. m_RealAssetSerial.Serialize( ar );
  1273. }
  1274. return TRUE;
  1275. }
  1277. BOOL CStrategy::DoFileSave( )
  1278. {
  1279. return SaveStrategyFile( GetPathName() );
  1280. }
  1282. BOOL CStrategy::OnClose( )
  1283. {
  1284. ClearCache( );
  1285. return TRUE;
  1286. }
  1288. void CStrategy::OnRealOpViewed( )
  1289. {
  1290. for( int i=0; i<m_RealNextOp.GetSize(); i++ )
  1291. m_RealNextOp.ElementAt(i).bViewed = TRUE;
  1292. }
  1295. /////////////////////////////////////////////////////////////////////////////
  1296. // CStrategy commands
  1297. void CStrategy::SetPathName( LPCTSTR lpszPathName )
  1298. {
  1299. m_strPathName = lpszPathName;
  1300. }
  1302. CSPString CStrategy::GetPathName( )
  1303. {
  1304. return m_strPathName;
  1305. }
  1307. // 设定策略名称
  1308. void CStrategy::SetName( LPCTSTR lpszName )
  1309. {
  1310. m_strName = lpszName;
  1311. }
  1312. // 得到策略名称
  1313. CSPString CStrategy::GetName( )
  1314. {
  1315. if( m_strName.IsEmpty() )
  1316. return GetPathName();
  1317. return m_strName;
  1318. }
  1319. // 设定策略描述
  1320. void CStrategy::SetDescript( LPCTSTR lpszDescript )
  1321. {
  1322. m_strDescript = lpszDescript;
  1323. }
  1324. // 得到策略描述
  1325. CSPString CStrategy::GetDescript( )
  1326. {
  1327. return m_strDescript;
  1328. }
  1329. // 得到策略被选股票
  1330. CSPStringArray & CStrategy::GetStocks( )
  1331. {
  1332. return m_stocks;
  1333. }
  1334. // 设定策略备选股票
  1335. void CStrategy::SetStocks( CSPStringArray & astr )
  1336. {
  1337. m_stocks.Copy( astr );
  1338. }
  1339. // 加入策略备选股票
  1340. void CStrategy::AddStock( LPCTSTR lpszCode )
  1341. {
  1342. m_stocks.AddStock( lpszCode );
  1343. }
  1344. // 移除策略备选股票
  1345. void CStrategy::RemoveStock( LPCTSTR lpszCode )
  1346. {
  1347. m_stocks.RemoveStock( lpszCode );
  1348. }
  1349. // 得到策略的一般性描述文字
  1350. CSPString CStrategy::GetStockTechString( )
  1351. {
  1352. int nStockShowCount = 3, nTechShowCount = 10;
  1354. CSPString strStock;
  1355. for( int i=0; i<m_stocks.GetSize() && i<nStockShowCount; i++ )
  1356. {
  1357. if( strStock.GetLength() > 0 )
  1358. strStock += ",";
  1359. CStockInfo info;
  1360. if( AfxGetStockContainer().GetStockInfo( m_stocks.ElementAt(i), &info ) )
  1361. //#ifdef CLKLAN_ENGLISH_US
  1362. // strStock += info.GetStockCode();
  1363. //#else
  1364. strStock += info.GetStockName();
  1365. //#endif
  1366. else
  1367. strStock += m_stocks.ElementAt(i);
  1368. }
  1369. if( strStock.GetLength() == 0 )
  1370. strStock = strategy_noselectedstock;
  1371. else if( m_stocks.GetSize() > nStockShowCount )
  1372. strStock += "...";
  1373. strStock += ";    ";
  1375. CSPString strTech;
  1376. for( i=0; i<m_anTechsBuy.GetSize() && i<nTechShowCount; i++ )
  1377. {
  1378. if( strTech.GetLength() > 0 )
  1379. strTech += ",";
  1380. strTech += AfxGetSTTShortName(m_anTechsBuy[i]);
  1381. }
  1382. if( strTech.GetLength() == 0 )
  1383. strTech = strategy_noselectedtech;
  1384. else if( m_anTechsBuy.GetSize() > nTechShowCount )
  1385. strTech += "...";
  1387. return strStock + strTech;
  1388. }
  1389. // 交易费率、操作条件等
  1390. CRateParam & CStrategy::GetRateParam( ) { return m_rate; }
  1391. COpParam & CStrategy::GetOpParam( ) { return m_opparam; }
  1392. CTechParameters & CStrategy::GetTechParametersBuy( ) { return m_paramBuy; }
  1393. CTechParameters & CStrategy::GetTechParametersSell( ) { return m_paramSell; }
  1394. CTechParameters & CStrategy::GetTechParametersLongTrend( ) { return m_paramLongTrend; }
  1395. CTechParameters & CStrategy::GetTechParametersIndexTrend( ) { return m_paramIndexTrend; }
  1396. CSPDWordArray & CStrategy::GetSelectedTechsBuy( ) { return m_anTechsBuy; }
  1397. CSPDWordArray & CStrategy::GetSelectedTechsSell( ) { return m_anTechsSell; }
  1398. CSPDWordArray & CStrategy::GetSelectedTechsLongTrend( ) { return m_anTechsLongTrend; }
  1399. CSPDWordArray & CStrategy::GetSelectedTechsIndexTrend( ) { return m_anTechsIndexTrend; }
  1401. /////////////////////////////////////////////////////////////////////////
  1402. // Cache
  1403. // 准备数据，读取K线数据，长周期K线数据，生成技术指标对象
  1404. BOOL CStrategy::PrepareData( SIMULATION_CALLBACK fnCallback, void * cookie )
  1405. {
  1406. if( m_techstocks.GetSize() == m_stocks.GetSize() )
  1407. return TRUE;
  1409. ClearCache( );
  1411. // m_techstocks.m_kdataIndex m_techstocks.m_infoIndex
  1412. if( m_opparam.m_bIndexTrend ) // 指数K线数据
  1413. {
  1414. CStockInfo infoIndex;
  1415. if( AfxGetStockContainer().GetStockInfo( STKLIB_CODE_MAIN, &infoIndex ) )
  1416. {
  1417. m_techstocks.m_infoIndex = infoIndex;
  1419. CStock stockIndex;
  1420. stockIndex.SetStockInfo( &infoIndex );
  1421. stockIndex.SetDatabase( &AfxGetDB() );
  1422. stockIndex.PrepareData( CStock::dataK, m_opparam.m_nKTypeIndex );
  1423. CKData & kdataIndex = stockIndex.GetKData(m_opparam.m_nKTypeIndex);
  1424. kdataIndex.SetMaindataType( m_opparam.m_nMaindataType );
  1425. m_techstocks.m_kdataIndex = kdataIndex;
  1427. // m_techstocks.m_techsIndex
  1428. for( int j=0; j<m_anTechsIndexTrend.GetSize(); j++ )
  1429. {
  1430. CTechnique * pTech = CTechnique::CreateTechnique( m_anTechsIndexTrend[j], &(m_techstocks.m_kdataIndex) );
  1431. m_paramIndexTrend.FindParameters( m_anTechsIndexTrend[j], pTech );
  1432. m_techstocks.m_techsIndex.Add( pTech );
  1433. }
  1434. }
  1435. }
  1437. m_techstocks.SetSize( m_stocks.GetSize() );
  1438. int nStockCount = 0;
  1439. for( int i=0; i<m_stocks.GetSize(); i++ ) // 读取每一只备选股票的数据
  1440. {
  1441. CStockInfo info;
  1442. if( AfxGetStockContainer().GetStockInfo( m_stocks.ElementAt(i), &info ) )
  1443. {
  1444. // CTechStock::m_info;
  1445. CTechStock temp;
  1446. temp.m_info = info;
  1448. m_techstocks.SetAt( nStockCount, temp );
  1449. CTechStock & techstock = m_techstocks.ElementAt(nStockCount);
  1450. nStockCount ++;
  1452. // CTechStock::m_kdata
  1453. CStock stock;
  1454. stock.SetStockInfo( &info );
  1455. AfxPrepareStockData( &AfxGetDB(), stock, m_opparam.m_nKType, CKData::formatXDRdown, m_opparam.m_nMaindataType, FALSE, FALSE );
  1456. techstock.m_kdata = stock.GetKData(m_opparam.m_nKType);
  1458. // CTechStock::m_techs
  1459. techstock.SetAutoDelete( TRUE );
  1460. for( int j=0; j<m_anTechsBuy.GetSize(); j++ )
  1461. {
  1462. CTechnique * pTech = CTechnique::CreateTechnique( m_anTechsBuy[j], &(techstock.m_kdata) );
  1463. m_paramBuy.FindParameters( m_anTechsBuy[j], pTech );
  1464. techstock.m_techs.Add( pTech );
  1465. }
  1467. // CTechStock::m_kdataLong
  1468. if( m_opparam.m_bLongTrend )
  1469. {
  1470. AfxPrepareStockData( &AfxGetDB(), stock, m_opparam.m_nKTypeLong, CKData::formatXDRdown, m_opparam.m_nMaindataType, FALSE, FALSE );
  1471. techstock.m_kdataLong = stock.GetKData( m_opparam.m_nKTypeLong );
  1473. // CTechStock::m_techsLong
  1474. for( j=0; j<m_anTechsLongTrend.GetSize(); j++ )
  1475. {
  1476. CTechnique * pTech = CTechnique::CreateTechnique( m_anTechsLongTrend[j], &(techstock.m_kdataLong) );
  1477. m_paramLongTrend.FindParameters( m_anTechsLongTrend[j], pTech );
  1478. techstock.m_techsLong.Add( pTech );
  1479. }
  1480. }
  1481. }
  1483. DWORD dwProgress = (DWORD)((i+1)*STRATEGY_MAXF_PROGRESS / m_stocks.GetSize());
  1484. if( fnCallback && !fnCallback( SIMULATION_PROGRESS, dwProgress, NULL, cookie ) )
  1485. {
  1486. ClearCache( );
  1487. nStockCount = 0;
  1488. break;
  1489. }
  1490. }
  1492. m_techstocks.SetSize( nStockCount );
  1494. if( fnCallback )
  1495. fnCallback( SIMULATION_PROGRESS, STRATEGY_MAX_PROGRESS, NULL, cookie );
  1497. return ( m_techstocks.GetSize() == m_stocks.GetSize() );
  1498. }
  1500. // 清除每个指标保存的上次趋势值
  1501. void CStrategy::ClearLastIntensity( )
  1502. {
  1503. for( int i=0; i<m_techstocks.GetSize(); i++ )
  1504. {
  1505. CTechStock & techstock = m_techstocks.ElementAt(i);
  1507. for( int nTech=0; nTech<techstock.m_techs.GetSize(); nTech++ )
  1508. {
  1509. CTechnique * pTech = (CTechnique *)techstock.m_techs.ElementAt(nTech);
  1510. if( pTech )
  1511. pTech->ClearLastIntensity();
  1512. }
  1513. }
  1514. }
  1516. void CStrategy::ClearCache( )
  1517. {
  1518. m_techstocks.Clear();
  1519. }
  1521. CTechStockContainer & CStrategy::GetTechStockContainer( )
  1522. {
  1523. return m_techstocks;
  1524. }
  1526. ////////////////////////////////////////////////////////////////////////
  1527. // Simulation
  1528. // 策略模拟：重新设定
  1529. void CStrategy::SimuReset( )
  1530. {
  1531. SimuSetStatusInit( );
  1532. m_SimuCurrentTime = m_opparam.GetBeginTime( );
  1533. m_SimuCurrentCash = m_opparam.m_nStartAmount;
  1534. m_SimuOpRecord.RemoveAll();
  1535. m_SimuNextOp.RemoveAll();
  1536. m_SimuStockOwn.RemoveAll();
  1537. m_SimuAssetSerial.RemoveAll();
  1539. SP_ASSERT( m_opparam.IsValid() );
  1540. }
  1541. // 策略模拟：进入下一个交易日
  1542. BOOL CStrategy::SimuGotoNextTime( )
  1543. {
  1544. CSPTime tmNext;
  1545. if( m_opparam.GetNextTradeTime( m_SimuCurrentTime, tmNext )
  1546. && m_opparam.IsInTimeZones( tmNext ) )
  1547. {
  1548. m_SimuCurrentTime = tmNext;
  1549. return TRUE;
  1550. }
  1551. return FALSE;
  1552. }
  1553. // 策略模拟：模拟的当前时间
  1554. CSPTime CStrategy::SimuGetCurrentTime( )
  1555. {
  1556. return m_SimuCurrentTime;
  1557. }
  1558. // 策略模拟：模拟的当前资金
  1559. double CStrategy::SimuGetCurrentCash( )
  1560. {
  1561. return m_SimuCurrentCash;
  1562. }
  1563. // 策略模拟：操作执行，bTimeStrict表示是否严格遵守计划时间
  1564. BOOL CStrategy::SimuOperate( OPRECORD record, BOOL bTimeStrict )
  1565. {
  1566. if( ! m_opparam.IsInTimeZones( record.time ) )
  1567. return FALSE;
  1568. if( bTimeStrict && m_SimuOpRecord.GetSize() > 0 && record.time < m_SimuOpRecord.ElementAt(m_SimuOpRecord.GetSize()-1).time )
  1569. return FALSE;
  1570. CStockInfo info;
  1571. if( strlen(record.szCode)>0
  1572. && ( !AfxGetStockContainer().GetStockInfo( record.szCode, &info )
  1573. || !info.IsValidStock() ) )
  1574. return FALSE;
  1576. double dAmount = record.dwShare * record.dSharePrice;
  1577. double dRateCost = record.dRateCost;
  1578. if( STRATEGY_OPTYPE_BUY == record.lOpType ) // 买入
  1579. {
  1580. if( m_SimuCurrentCash < dAmount+dRateCost )
  1581. return FALSE;
  1582. if( !m_SimuStockOwn.AddStock( info, record.dwShare, record.dSharePrice ) )
  1583. return FALSE;
  1584. m_SimuCurrentCash -= (dAmount+dRateCost);
  1585. }
  1586. else if( STRATEGY_OPTYPE_SELL == record.lOpType ) // 卖出
  1587. {
  1588. if( !m_SimuStockOwn.RemoveStock( info, record.dwShare ) )
  1589. return FALSE;
  1590. m_SimuCurrentCash += (dAmount-dRateCost);
  1591. }
  1592. else if( STRATEGY_OPTYPE_ADDSTOCK == record.lOpType )// 添加股票
  1593. {
  1594. if( !m_SimuStockOwn.AddStock( info, record.dwShare, record.dSharePrice ) )
  1595. return FALSE;
  1596. }
  1597. else if( STRATEGY_OPTYPE_REMOVESTOCK == record.lOpType )// 移除股票
  1598. {
  1599. if( !m_SimuStockOwn.RemoveStock( info, record.dwShare ) )
  1600. return FALSE;
  1601. }
  1602. else if( STRATEGY_OPTYPE_ADDCASH == record.lOpType ) // 添加资金
  1603. {
  1604. m_SimuCurrentCash += record.dSharePrice;
  1605. }
  1606. else if( STRATEGY_OPTYPE_REMOVECASH == record.lOpType ) // 移除资金
  1607. {
  1608. if( m_SimuCurrentCash < record.dSharePrice )
  1609. return FALSE;
  1610. m_SimuCurrentCash -= record.dSharePrice;
  1611. }
  1612. else
  1613. return FALSE;
  1615. // Record
  1616. m_SimuOpRecord.Add( record );
  1617. return TRUE;
  1618. }
  1619. // 策略模拟：操作记录
  1620. COpRecordContainer & CStrategy::SimuGetOpRecord( )
  1621. {
  1622. return m_SimuOpRecord;
  1623. }
  1624. // 策略模拟：下一步操作
  1625. COpRecordContainer & CStrategy::SimuGetNextOp( )
  1626. {
  1627. return m_SimuNextOp;
  1628. }
  1629. // 策略模拟：当前拥有股票
  1630. CStockOwnContainer & CStrategy::SimuGetStockOwn( )
  1631. {
  1632. return m_SimuStockOwn;
  1633. }
  1634. // 策略模拟：总资产序列
  1635. CAssetSerialContainer & CStrategy::SimuGetAssetSerial( )
  1636. {
  1637. return m_SimuAssetSerial;
  1638. }
  1639. // 策略模拟：当前进度
  1640. DWORD CStrategy::SimuGetCurrentProgress( DWORD dwProgressMax )
  1641. {
  1642. return m_opparam.GetProgress( m_SimuCurrentTime, dwProgressMax );
  1643. }
  1644. // 策略模拟：给定时间的总资产
  1645. double CStrategy::SimuGetAsset( CSPTime tmCur )
  1646. {
  1647. double dAsset = 0;
  1648. if( m_techstocks.GetSumAsset( tmCur, m_SimuStockOwn, &dAsset ) ) // 计算总资产
  1649. {
  1650. dAsset += m_SimuCurrentCash;
  1652. ASSETSERIAL serial;
  1653. memset( &serial, 0, sizeof(serial) );
  1654. serial.time = tmCur.GetTime();
  1655. serial.dAsset = dAsset;
  1656. serial.dCash = m_SimuCurrentCash;
  1657. m_SimuAssetSerial.SortInsert( serial );
  1658. return dAsset;
  1659. }
  1660. else
  1661. {
  1662. for( int i=m_SimuAssetSerial.GetSize()-1; i>=0; i-- )
  1663. {
  1664. ASSETSERIAL & serial = m_SimuAssetSerial.ElementAt(i);
  1665. if( serial.time <= tmCur.GetTime() )
  1666. return serial.dAsset;
  1667. }
  1668. }
  1669. return m_opparam.m_nStartAmount; // 初始总资产
  1670. }
  1671. // 策略模拟：当前收益
  1672. double CStrategy::SimuGetCurrentYield( )
  1673. {
  1674. if( m_opparam.m_nStartAmount > 0 )
  1675. return STRATEGY_BASEF_YIELD * SimuGetAsset(m_SimuCurrentTime) / m_opparam.m_nStartAmount;
  1676. return STRATEGY_BASEF_YIELD;
  1677. }
  1678. // 策略模拟：当前指数上涨多少
  1679. double CStrategy::SimuGetCurrentYieldIndexPercent( )
  1680. {
  1681. CSPTime sptmBegin( m_opparam.GetBeginTime().GetTime() );
  1682. CSPTime sptmNow( m_SimuCurrentTime.GetTime() );
  1683. DWORD dateBegin = sptmBegin.ToStockTimeDay();
  1684. DWORD dateNow = sptmNow.ToStockTimeDay();
  1686. CKData & kdata = AfxGetStockMain().GetKData(m_opparam.m_nKType);
  1687. int nIndexBegin = kdata.GetAboutIndexByDate( dateBegin );
  1688. int nIndexNow = kdata.GetAboutIndexByDate( dateNow );
  1689. if( -1 == nIndexBegin || -1 == nIndexNow )
  1690. return 0;
  1692. if( kdata.ElementAt(nIndexBegin).m_fClose < 1e-4 )
  1693. return 0;
  1695. double dYield = ((double)kdata.ElementAt(nIndexNow).m_fClose) - kdata.ElementAt(nIndexBegin).m_fClose;
  1696. dYield = dYield / kdata.ElementAt(nIndexBegin).m_fClose;
  1698. return dYield;
  1699. }
  1700. // 策略模拟：当前收益百分数
  1701. double CStrategy::SimuGetCurrentYieldPercent( )
  1702. {
  1703. return ( SimuGetCurrentYield() - STRATEGY_BASEF_YIELD ) / STRATEGY_BASEF_YIELD;
  1704. }
  1705. // 策略模拟：执行下一步操作计划
  1706. BOOL CStrategy::SimuOperateNextop( CSPTime tmCur, COpRecordContainer & nextop, CTechStock & techstock )
  1707. {
  1708. for( int j=0; j<nextop.GetSize(); j++ ) // 每个计划依次执行
  1709. {
  1710. OPRECORD & record = nextop.ElementAt(j);
  1711. if( STRATEGY_OPTYPE_BUY != record.lOpType && STRATEGY_OPTYPE_SELL != record.lOpType )
  1712. continue;
  1714. if( tmCur.GetTime() >= record.time
  1715. && techstock.m_info.IsEqualTo( CStock::marketUnknown, record.szCode ) )
  1716. {
  1717. if( techstock.IsStopTrading(tmCur) ) // 停牌吗
  1718. {
  1719. CSPTime tmNext;
  1720. if( m_opparam.GetNextTradeTime(tmCur, tmNext) )
  1721. record.time = tmNext.GetTime(); // 下次再执行
  1722. continue;
  1723. }
  1725. double dPriceOK = record.dSharePrice;
  1726. if( techstock.GetPriceOK( record.lOpType, tmCur, record.dwShare, record.dSharePrice, &dPriceOK ) ) // 成交价
  1727. {
  1728. record.time = tmCur.GetTime();
  1729. record.dSharePrice = dPriceOK;
  1730. record.dRateCost = record.dwShare * record.dSharePrice * m_rate.GetRate(techstock.m_info);
  1731. SimuOperate( record );
  1732. }
  1733. else if( STRATEGY_OPTYPE_SELL == record.lOpType ) // 如果是卖出而没有成功，则顺延下一个交易日，直至卖出
  1734. {
  1735. CSPTime tmNext;
  1736. if( m_opparam.GetNextTradeTime(tmCur, tmNext) )
  1737. record.time = tmNext.GetTime();
  1738. if( techstock.GetClosePrice(tmCur,&dPriceOK) )
  1739. record.dSharePrice = dPriceOK * m_opparam.m_dSellMulti;
  1740. continue;
  1741. }
  1742. nextop.RemoveAt(j);
  1743. j --;
  1744. }
  1745. }
  1746. return TRUE;
  1747. }
  1748. // 策略模拟：模拟运行
  1749. BOOL CStrategy::SimuRun( SIMULATION_CALLBACK fnCallback, void * cookie )
  1750. {
  1751. // TIMEZONES
  1752. // 准备数据
  1753. if( !PrepareData( fnCallback, cookie ) )
  1754. return FALSE;
  1756. ClearLastIntensity( );
  1758. DWORD dwShare = 0; // Temp Data
  1759. double dSharePrice = 0; // Temp Data
  1760. CSPTime tmOp; // Temp Data
  1762. do {
  1763. CSPTime tmCur = SimuGetCurrentTime(); // 模拟当前时间
  1765. // Process
  1766. for( int i=0; i<m_techstocks.GetSize(); i++ ) // 每只股票依次判断
  1767. {
  1768. CTechStock & techstock = m_techstocks.ElementAt(i);
  1770. // Operate
  1771. SimuOperateNextop( tmCur, m_SimuNextOp, techstock ); // 执行今天的操作计划
  1773. // Judge Whether to operate, if yes, save to nextop
  1774. STOCKOWN own;
  1775. memset( &own, 0, sizeof(own) );
  1776. if( m_SimuStockOwn.HasThisStock( techstock.m_info, &own ) ) // 如果已经有这支股票，判断是否卖出
  1777. {
  1778. if( m_techstocks.GetShouldSellShare( techstock, tmCur, own, m_opparam, &tmOp, &dwShare, &dSharePrice ) )
  1779. { // 如果要卖出，加入下一步操作计划，下一个交易日执行
  1780. m_SimuNextOp.AddRecordUniqueStock( STRATEGY_OPTYPE_SELL, tmOp, techstock.m_info.GetStockCode(), dwShare, dSharePrice, dwShare*dSharePrice*m_rate.GetRate(techstock.m_info) );
  1781. }
  1782. }
  1783. else // 判断是否买入
  1784. {
  1785. if( m_techstocks.GetShouldBuyShare( techstock, tmCur, m_SimuCurrentCash, m_rate , m_opparam, m_SimuStockOwn.GetSize(), &tmOp, &dwShare, &dSharePrice )
  1786. && ( m_SimuStockOwn.GetSize() + m_SimuNextOp.GetBuyRecordCount() < m_opparam.m_nStoreDiv || m_SimuNextOp.HasBuyStock(techstock.m_info.GetStockCode()) ) )
  1787. { // 如果要买入，加入下一步操作计划，下一个交易日执行
  1788. m_SimuNextOp.AddRecordUniqueStock( STRATEGY_OPTYPE_BUY, tmOp, techstock.m_info.GetStockCode(), dwShare, dSharePrice, dwShare*dSharePrice*m_rate.GetRate(techstock.m_info) );
  1789. }
  1790. }
  1791. }
  1793. // 进度显示
  1794. DWORD dwProgress = SimuGetCurrentProgress( STRATEGY_MAX_PROGRESS );
  1795. double dYield = SimuGetCurrentYield( );
  1796. if( fnCallback && !fnCallback( SIMULATION_PROGRESS, dwProgress, NULL, cookie ) )
  1797. return FALSE;
  1798. if( fnCallback && !fnCallback( SIMULATION_YIELD, (DWORD)dYield, NULL, cookie ) )
  1799. return FALSE;
  1801. } while( SimuGotoNextTime() ); // 模拟的下一个交易日
  1803. if( fnCallback )
  1804. fnCallback( SIMULATION_PROGRESS, STRATEGY_MAX_PROGRESS, NULL, cookie );
  1805. return TRUE;
  1806. }
  1808. ////////////////////////////////////////////////////////////////////////
  1809. // Real
  1810. // 策略实战：重新设定
  1811. void CStrategy::RealReset( )
  1812. {
  1813. CSPTime tmLatest = CSPTime::GetCurrentTime();
  1814. AfxGetDB().GetTimeLocalRange( &tmLatest, NULL, NULL );
  1815. m_RealBeginTime = tmLatest;
  1816. m_RealCurrentTime = tmLatest;
  1817. m_RealCurrentCash = m_opparam.m_nStartAmount;
  1818. m_RealOpRecord.RemoveAll();
  1819. m_RealNextOp.RemoveAll();
  1820. m_RealStockOwn.RemoveAll();
  1821. m_RealAssetSerial.RemoveAll();
  1823. SP_ASSERT( m_opparam.IsValid() );
  1824. }
  1825. // 策略实战：下一个交易时间
  1826. BOOL CStrategy::RealGotoNextTime( )
  1827. {
  1828. CSPTime tmNext;
  1829. if( m_techstocks.GetNextExistTradeTime( RealGetCurrentTime(), tmNext ) )
  1830. {
  1831. m_RealCurrentTime = tmNext;
  1832. return TRUE;
  1833. }
  1834. return FALSE;
  1835. }
  1836. // 策略实战：开始时间
  1837. CSPTime CStrategy::RealGetBeginTime( )
  1838. {
  1839. return m_RealBeginTime;
  1840. }
  1841. // 策略实战：当前时间
  1842. CSPTime CStrategy::RealGetCurrentTime( )
  1843. {
  1844. return m_RealCurrentTime;
  1845. }
  1846. // 策略实战：当前资金
  1847. double CStrategy::RealGetCurrentCash( )
  1848. {
  1849. return m_RealCurrentCash;
  1850. }
  1851. // 策略实战：执行一个操作
  1852. BOOL CStrategy::RealOperate( OPRECORD record, BOOL bTimeStrict )
  1853. {
  1854. if( bTimeStrict && m_RealOpRecord.GetSize() > 0 && record.time < m_RealOpRecord.ElementAt(m_RealOpRecord.GetSize()-1).time )
  1855. return FALSE;
  1856. CStockInfo info;
  1857. if( strlen(record.szCode)>0
  1858. && ( !AfxGetStockContainer().GetStockInfo( record.szCode, &info )
  1859. || !info.IsValidStock() ) )
  1860. return FALSE;
  1862. double dAmount = record.dwShare * record.dSharePrice;
  1863. double dRateCost = record.dRateCost;
  1864. if( STRATEGY_OPTYPE_BUY == record.lOpType ) // 买入
  1865. {
  1866. if( m_RealCurrentCash < dAmount+dRateCost )
  1867. return FALSE;
  1868. if( !m_RealStockOwn.AddStock( info, record.dwShare, record.dSharePrice ) )
  1869. return FALSE;
  1870. m_RealCurrentCash -= (dAmount+dRateCost);
  1871. }
  1872. else if( STRATEGY_OPTYPE_SELL == record.lOpType ) // 卖出
  1873. {
  1874. if( !m_RealStockOwn.RemoveStock( info, record.dwShare ) )
  1875. return FALSE;
  1876. m_RealCurrentCash += (dAmount-dRateCost);
  1877. }
  1878. else if( STRATEGY_OPTYPE_ADDSTOCK == record.lOpType ) // 添加股票
  1879. {
  1880. if( !m_RealStockOwn.AddStock( info, record.dwShare, record.dSharePrice ) )
  1881. return FALSE;
  1882. }
  1883. else if( STRATEGY_OPTYPE_REMOVESTOCK == record.lOpType ) // 移除股票
  1884. {
  1885. if( !m_RealStockOwn.RemoveStock( info, record.dwShare ) )
  1886. return FALSE;
  1887. }
  1888. else if( STRATEGY_OPTYPE_ADDCASH == record.lOpType ) // 加入资金
  1889. {
  1890. m_RealCurrentCash += record.dSharePrice;
  1891. }
  1892. else if( STRATEGY_OPTYPE_REMOVECASH == record.lOpType ) // 移除资金
  1893. {
  1894. if( m_RealCurrentCash < record.dSharePrice )
  1895. return FALSE;
  1896. m_RealCurrentCash -= record.dSharePrice;
  1897. }
  1898. else
  1899. return FALSE;
  1901. // Record
  1902. m_RealOpRecord.Add( record );
  1903. return TRUE;
  1904. }
  1905. // 策略实战：操作记录
  1906. COpRecordContainer & CStrategy::RealGetOpRecord( )
  1907. {
  1908. return m_RealOpRecord;
  1909. }
  1910. // 策略实战：下一步操作计划
  1911. COpRecordContainer & CStrategy::RealGetNextOp( )
  1912. {
  1913. return m_RealNextOp;
  1914. }
  1915. // 策略实战：当前拥有股票
  1916. CStockOwnContainer & CStrategy::RealGetStockOwn( )
  1917. {
  1918. return m_RealStockOwn;
  1919. }
  1920. // 策略实战：总资产序列
  1921. CAssetSerialContainer & CStrategy::RealGetAssetSerial( )
  1922. {
  1923. return m_RealAssetSerial;
  1924. }
  1925. // 策略实战：得到指定日期的总资产
  1926. double CStrategy::RealGetAsset( CSPTime tmCur )
  1927. {
  1928. double dAsset = 0;
  1930. if( m_techstocks.GetSumAsset( tmCur, m_RealStockOwn, &dAsset ) )
  1931. {
  1932. dAsset += m_RealCurrentCash;
  1934. ASSETSERIAL serial;
  1935. memset( &serial, 0, sizeof(serial) );
  1936. serial.time = tmCur.GetTime();
  1937. serial.dAsset = dAsset;
  1938. serial.dCash = m_RealCurrentCash;
  1939. m_RealAssetSerial.SortInsert( serial );
  1940. return dAsset;
  1941. }
  1942. else
  1943. {
  1944. for( int i=m_RealAssetSerial.GetSize()-1; i>=0; i-- )
  1945. {
  1946. ASSETSERIAL & serial = m_RealAssetSerial.ElementAt(i);
  1947. if( serial.time <= tmCur.GetTime() )
  1948. return serial.dAsset;
  1949. }
  1950. }
  1951. return m_opparam.m_nStartAmount;
  1952. }
  1953. // 策略实战：当前收益
  1954. double CStrategy::RealGetCurrentYield( )
  1955. {
  1956. if( m_opparam.m_nStartAmount > 0 )
  1957. return STRATEGY_BASEF_YIELD * RealGetAsset(RealGetCurrentTime()) / m_opparam.m_nStartAmount;
  1958. return STRATEGY_BASEF_YIELD;
  1959. }
  1960. // 策略实战：当前指数上涨百分比
  1961. double CStrategy::RealGetCurrentYieldIndexPercent( )
  1962. {
  1963. CSPTime sptmBegin( RealGetBeginTime().GetTime() );
  1964. CSPTime sptmNow( RealGetCurrentTime().GetTime() );
  1965. DWORD dateBegin = sptmBegin.ToStockTimeDay();
  1966. DWORD dateNow = sptmNow.ToStockTimeDay();
  1968. CKData & kdata = AfxGetStockMain().GetKData(m_opparam.m_nKType);
  1969. int nIndexBegin = kdata.GetAboutIndexByDate( dateBegin );
  1970. int nIndexNow = kdata.GetAboutIndexByDate( dateNow );
  1971. if( -1 == nIndexBegin || -1 == nIndexNow )
  1972. return 0;
  1974. if( kdata.ElementAt(nIndexBegin).m_fClose < 1e-4 )
  1975. return 0;
  1977. double dYield = ((double)kdata.ElementAt(nIndexNow).m_fClose) - kdata.ElementAt(nIndexBegin).m_fClose;
  1978. dYield = dYield / kdata.ElementAt(nIndexBegin).m_fClose;
  1980. return dYield;
  1981. }
  1982. // 策略实战：当前收益百分比
  1983. double CStrategy::RealGetCurrentYieldPercent( )
  1984. {
  1985. return ( RealGetCurrentYield() - STRATEGY_BASEF_YIELD ) / STRATEGY_BASEF_YIELD;
  1986. }
  1987. // 策略实战：执行操作计划
  1988. BOOL CStrategy::RealOperateNextop( CSPTime tmCur, COpRecordContainer & nextop, CTechStock & techstock )
  1989. {
  1990. for( int j=0; j<nextop.GetSize(); j++ ) // 依次执行每一个计划
  1991. {
  1992. OPRECORD & record = nextop.ElementAt(j);
  1993. if( STRATEGY_OPTYPE_BUY != record.lOpType && STRATEGY_OPTYPE_SELL != record.lOpType )
  1994. continue;
  1996. if( tmCur.GetTime() >= record.time
  1997. && techstock.m_info.IsEqualTo( CStock::marketUnknown, record.szCode ) )
  1998. {
  1999. if( !record.bViewed ) // Not Viewed
  2000. {
  2001. nextop.RemoveAt(j);
  2002. j --;
  2003. continue;
  2004. }
  2006. if( techstock.IsStopTrading(tmCur) ) // 停牌，转入下一个交易日的计划中
  2007. {
  2008. CSPTime tmNext;
  2009. if( m_opparam.GetNextTradeTime(tmCur, tmNext) )
  2010. record.time = tmNext.GetTime();
  2011. continue;
  2012. }
  2014. double dPriceOK = record.dSharePrice;
  2015. if( techstock.GetPriceOK( record.lOpType, tmCur, record.dwShare, record.dSharePrice, &dPriceOK ) ) // 成交价格
  2016. {
  2017. record.time = tmCur.GetTime();
  2018. record.dSharePrice = dPriceOK;
  2019. record.dRateCost = record.dwShare * record.dSharePrice * m_rate.GetRate(techstock.m_info);
  2020. RealOperate( record );
  2021. }
  2022. else if( STRATEGY_OPTYPE_SELL == record.lOpType ) // 如果是卖出不成功，转入下一个交易日，直至卖出成功
  2023. {
  2024. CSPTime tmNext;
  2025. if( m_opparam.GetNextTradeTime(tmCur, tmNext) )
  2026. record.time = tmNext.GetTime();
  2027. if( techstock.GetClosePrice(tmCur,&dPriceOK) )
  2028. record.dSharePrice = dPriceOK * m_opparam.m_dSellMulti;
  2029. continue;
  2030. }
  2031. nextop.RemoveAt(j);
  2032. j --;
  2033. }
  2034. }
  2035. return TRUE;
  2036. }
  2037. // 策略实战：执行
  2038. BOOL CStrategy::RealRun( SIMULATION_CALLBACK fnCallback, void * cookie )
  2039. {
  2040. // TIMEZONES
  2041. // 准备数据
  2042. if( !PrepareData( fnCallback, cookie ) )
  2043. return FALSE;
  2045. ClearLastIntensity( );
  2047. DWORD dwShare = 0; // Temp Data
  2048. double dSharePrice = 0; // Temp Data
  2049. CSPTime tmOp; // Temp Data
  2051. do {
  2052. CSPTime tmCur = RealGetCurrentTime(); // 当前日期
  2054. // Process
  2055. for( int i=0; i<m_techstocks.GetSize(); i++ ) // 每只股票依次判断
  2056. {
  2057. CTechStock & techstock = m_techstocks.ElementAt(i);
  2059. // Operate
  2060. RealOperateNextop( tmCur, m_RealNextOp, techstock ); // 执行今日操作计划
  2062. // Judge Whether to operate, if yes, save to nextop
  2063. STOCKOWN own;
  2064. memset( &own, 0, sizeof(own) );
  2065. if( m_RealStockOwn.HasThisStock( techstock.m_info, &own ) ) // 如果有这支股票，判断是否卖出
  2066. {
  2067. if( m_techstocks.GetShouldSellShare( techstock, tmCur, own, m_opparam, &tmOp, &dwShare, &dSharePrice ) )
  2068. { // 如果卖出，加入操作计划中
  2069. m_RealNextOp.AddRecordUniqueStock( STRATEGY_OPTYPE_SELL, tmOp, techstock.m_info.GetStockCode(), dwShare, dSharePrice, dwShare*dSharePrice*m_rate.GetRate(techstock.m_info) );
  2070. }
  2071. }
  2072. else // 判断是否买入
  2073. {
  2074. if( m_techstocks.GetShouldBuyShare( techstock, tmCur, m_RealCurrentCash, m_rate , m_opparam, m_RealStockOwn.GetSize(), &tmOp, &dwShare, &dSharePrice )
  2075. && ( m_RealStockOwn.GetSize() + m_RealNextOp.GetBuyRecordCount() < m_opparam.m_nStoreDiv || m_RealNextOp.HasBuyStock(techstock.m_info.GetStockCode()) ) )
  2076. { // 如果买入，加入操作计划中
  2077. m_RealNextOp.AddRecordUniqueStock( STRATEGY_OPTYPE_BUY, tmOp, techstock.m_info.GetStockCode(), dwShare, dSharePrice, dwShare*dSharePrice*m_rate.GetRate(techstock.m_info) );
  2078. }
  2079. }
  2081. // 进度显示
  2082. DWORD dwProgress = (DWORD)((i+1)*STRATEGY_MAX_PROGRESS/m_techstocks.GetSize());
  2083. if( fnCallback && !fnCallback( SIMULATION_PROGRESS, dwProgress, NULL, cookie ) )
  2084. return FALSE;
  2085. }
  2087. RealGetAsset( RealGetCurrentTime() );
  2089. } while( RealGotoNextTime() ); // 下一个交易日
  2091. if( fnCallback )
  2092. fnCallback( SIMULATION_PROGRESS, STRATEGY_MAX_PROGRESS, NULL, cookie );
  2093. return TRUE;
  2094. }
  2095. // 策略实战：加入操作记录，如果成功，同时要删除加入日后的所有操作
  2096. BOOL CStrategy::RealAddOpRecordStrict( OPRECORD record )
  2097. {
  2098. COpRecordContainer recordbk;
  2099. recordbk.Copy( m_RealOpRecord );
  2101. // 重新执行操作记录，到加入新操作日为止
  2102. BOOL bOK = TRUE;
  2103. m_RealCurrentCash = m_opparam.m_nStartAmount;
  2104. m_RealOpRecord.RemoveAll();
  2105. m_RealNextOp.RemoveAll();
  2106. m_RealStockOwn.RemoveAll();
  2107. for( int i=0; i<recordbk.GetSize(); i++ )
  2108. {
  2109. OPRECORD rec = recordbk.ElementAt(i);
  2110. if( bOK && rec.time < record.time )
  2111. bOK &= RealOperate( rec );
  2112. }
  2114. if( bOK && RealOperate( record ) )
  2115. { // 加入成功，重新计算总资产序列
  2116. for( i=m_RealAssetSerial.GetSize()-1; i>=0; i-- )
  2117. {
  2118. ASSETSERIAL serial = m_RealAssetSerial.ElementAt(i);
  2119. if( serial.time >= record.time )
  2120. m_RealAssetSerial.RemoveAt(i);
  2121. }
  2122. RealGetAsset( record.time );
  2123. return TRUE;
  2124. }
  2125. else
  2126. {
  2127. // 加入失败，全部重来，恢复原样
  2128. m_RealCurrentCash = m_opparam.m_nStartAmount;
  2129. m_RealOpRecord.RemoveAll();
  2130. m_RealNextOp.RemoveAll();
  2131. m_RealStockOwn.RemoveAll();
  2132. for( i=0; i<recordbk.GetSize(); i++ )
  2133. {
  2134. OPRECORD rec = recordbk.ElementAt(i);
  2135. RealOperate( rec );
  2136. }
  2137. return FALSE;
  2138. }
  2139. }
  2140. // 策略实战：删除操作记录，如果成功，同时要删除日后的所有操作
  2141. BOOL CStrategy::RealDeleteOpRecordStrict( int nRecord )
  2142. {
  2143. if( nRecord < 0 || nRecord >= m_RealOpRecord.GetSize() )
  2144. {
  2145. SP_ASSERT( FALSE );
  2146. return FALSE;
  2147. }
  2148. OPRECORD record = m_RealOpRecord.ElementAt(nRecord);
  2150. COpRecordContainer recordbk;
  2151. recordbk.Copy( m_RealOpRecord );
  2153. // 重新执行操作记录，到删除日为止
  2154. BOOL bOK = TRUE;
  2155. m_RealCurrentCash = m_opparam.m_nStartAmount;
  2156. m_RealOpRecord.RemoveAll();
  2157. m_RealNextOp.RemoveAll();
  2158. m_RealStockOwn.RemoveAll();
  2159. for( int i=0; i<recordbk.GetSize(); i++ )
  2160. {
  2161. OPRECORD rec = recordbk.ElementAt(i);
  2162. if( bOK && rec.time < record.time )
  2163. bOK &= RealOperate( rec );
  2164. }
  2166. if( bOK )
  2167. { // 成功删除，重新计算总资产序列
  2168. for( i=m_RealAssetSerial.GetSize()-1; i>=0; i-- )
  2169. {
  2170. ASSETSERIAL serial = m_RealAssetSerial.ElementAt(i);
  2171. if( serial.time >= record.time )
  2172. m_RealAssetSerial.RemoveAt(i);
  2173. }
  2174. RealGetAsset( record.time );
  2175. return TRUE;
  2176. }
  2177. else
  2178. {
  2179. // 删除失败，恢复原样
  2180. m_RealCurrentCash = m_opparam.m_nStartAmount;
  2181. m_RealOpRecord.RemoveAll();
  2182. m_RealNextOp.RemoveAll();
  2183. m_RealStockOwn.RemoveAll();
  2184. for( i=0; i<recordbk.GetSize(); i++ )
  2185. {
  2186. OPRECORD rec = recordbk.ElementAt(i);
  2187. RealOperate( rec );
  2188. }
  2189. return FALSE;
  2190. }
  2191. }
  2193. /*
  2194. BOOL CStrategy::RealUnOperate( OPRECORD record )
  2195. {
  2196. CStockInfo info;
  2197. if( strlen(record.szCode)>0
  2198. && ( !AfxGetStockContainer().GetStockInfo( record.szCode, &info )
  2199. || !info.IsValidStock() ) )
  2200. return FALSE;
  2202. double dAmount = record.dwShare * record.dSharePrice;
  2203. double dRateCost = record.dRateCost;
  2204. if( STRATEGY_OPTYPE_BUY == record.lOpType )
  2205. {
  2206. if( !m_RealStockOwn.RemoveStock( info, record.dwShare ) )
  2207. return FALSE;
  2208. m_RealCurrentCash += (dAmount+dRateCost);
  2209. }
  2210. else if( STRATEGY_OPTYPE_SELL == record.lOpType )
  2211. {
  2212. if( m_RealCurrentCash < dAmount-dRateCost )
  2213. return FALSE;
  2214. if( !m_RealStockOwn.AddStock( info, record.dwShare ) )
  2215. return FALSE;
  2216. m_RealCurrentCash -= (dAmount-dRateCost);
  2217. }
  2218. else if( STRATEGY_OPTYPE_ADDSTOCK == record.lOpType )
  2219. {
  2220. if( !m_RealStockOwn.RemoveStock( info, record.dwShare ) )
  2221. return FALSE;
  2222. }
  2223. else if( STRATEGY_OPTYPE_REMOVESTOCK == record.lOpType )
  2224. {
  2225. if( !m_RealStockOwn.AddStock( info, record.dwShare ) )
  2226. return FALSE;
  2227. }
  2228. else if( STRATEGY_OPTYPE_ADDCASH == record.lOpType )
  2229. {
  2230. if( m_RealCurrentCash < record.dSharePrice )
  2231. return FALSE;
  2232. m_RealCurrentCash -= record.dSharePrice;
  2233. }
  2234. else if( STRATEGY_OPTYPE_REMOVECASH == record.lOpType )
  2235. {
  2236. m_RealCurrentCash += record.dSharePrice;
  2237. }
  2238. else
  2239. return FALSE;
  2241. return TRUE;
  2242. }
  2244. BOOL CStrategy::RealAddOpRecordStrict( OPRECORD record )
  2245. {
  2246. COpRecordContainer recordbk;
  2247. recordbk.Copy( m_RealOpRecord );
  2249. BOOL bOK = TRUE;
  2250. for( int i=m_RealOpRecord.GetSize()-1; i>=0; i-- )
  2251. {
  2252. OPRECORD rec = m_RealOpRecord.ElementAt(i);
  2253. if( bOK && rec.time > record.time )
  2254. {
  2255. bOK &= RealUnOperate( rec );
  2256. if( bOK )
  2257. m_RealOpRecord.RemoveAt(i);
  2258. }
  2259. }
  2261. if( bOK && RealOperate( record ) )
  2262. {
  2263. for( i=m_RealAssetSerial.GetSize()-1; i>=0; i-- )
  2264. {
  2265. ASSETSERIAL serial = m_RealAssetSerial.ElementAt(i);
  2266. if( serial.time >= record.time )
  2267. m_RealAssetSerial.RemoveAt(i);
  2268. }
  2269. RealGetAsset( record.time );
  2270. return TRUE;
  2271. }
  2272. else
  2273. {
  2274. // Restore
  2275. m_RealCurrentCash = m_opparam.m_nStartAmount;
  2276. m_RealOpRecord.RemoveAll();
  2277. m_RealNextOp.RemoveAll();
  2278. m_RealStockOwn.RemoveAll();
  2279. for( i=0; i<recordbk.GetSize(); i++ )
  2280. {
  2281. OPRECORD rec = recordbk.ElementAt(i);
  2282. RealOperate( rec );
  2283. }
  2284. return FALSE;
  2285. }
  2286. }
  2288. BOOL CStrategy::RealDeleteOpRecordStrict( int nRecord )
  2289. {
  2290. if( nRecord < 0 || nRecord >= m_RealOpRecord.GetSize() )
  2291. {
  2292. SP_ASSERT( FALSE );
  2293. return FALSE;
  2294. }
  2296. COpRecordContainer recordbk;
  2297. recordbk.Copy( m_RealOpRecord );
  2299. BOOL bOK = TRUE;
  2300. OPRECORD record = m_RealOpRecord.ElementAt(nRecord);
  2301. for( int i=m_RealOpRecord.GetSize()-1; i>=0; i-- )
  2302. {
  2303. OPRECORD rec = m_RealOpRecord.ElementAt(i);
  2304. if( bOK && rec.time >= record.time )
  2305. {
  2306. bOK &= RealUnOperate( rec );
  2307. if( bOK )
  2308. m_RealOpRecord.RemoveAt(i);
  2309. }
  2310. }
  2312. if( bOK )
  2313. {
  2314. for( i=m_RealAssetSerial.GetSize()-1; i>=0; i-- )
  2315. {
  2316. ASSETSERIAL serial = m_RealAssetSerial.ElementAt(i);
  2317. if( serial.time >= record.time )
  2318. m_RealAssetSerial.RemoveAt(i);
  2319. }
  2320. return TRUE;
  2321. }
  2322. else
  2323. {
  2324. // Restore
  2325. m_RealCurrentCash = m_opparam.m_nStartAmount;
  2326. m_RealOpRecord.RemoveAll();
  2327. m_RealNextOp.RemoveAll();
  2328. m_RealStockOwn.RemoveAll();
  2329. for( i=0; i<recordbk.GetSize(); i++ )
  2330. {
  2331. OPRECORD rec = recordbk.ElementAt(i);
  2332. RealOperate( rec );
  2333. }
  2334. return FALSE;
  2335. }
  2336. }
  2337. */