def testShort3(self): strat = self.__createStrategy() stratAnalyzer = trades.Trades() strat.attachAnalyzer(stratAnalyzer) # Enter short strat.addOrder(buildUTCDateTime(2011, 1, 3, 15, 0), strat.getBroker().createMarketOrder, broker.Order.Action.SELL_SHORT, TradesAnalyzerTestCase.TestInstrument, 2) # 127.14 # Decrease short position strat.addOrder(buildUTCDateTime(2011, 1, 3, 15, 16), strat.getBroker().createMarketOrder, broker.Order.Action.BUY_TO_COVER, TradesAnalyzerTestCase.TestInstrument, 1) # 127.16 # Exit short strat.addOrder(buildUTCDateTime(2011, 1, 3, 15, 30), strat.getBroker().createMarketOrder, broker.Order.Action.BUY_TO_COVER, TradesAnalyzerTestCase.TestInstrument, 1) # 127.2 strat.run() self.assertTrue( round(strat.getBroker().getCash(), 2) == round( 1000 + (127.14 - 127.16) + (127.14 - 127.2), 2)) self.assertTrue(stratAnalyzer.getCount() == 1) self.assertTrue(stratAnalyzer.getEvenCount() == 0) self.assertTrue(round(stratAnalyzer.getAll().mean(), 2) == -0.08) self.assertTrue(stratAnalyzer.getUnprofitableCount() == 1) self.assertTrue(round(stratAnalyzer.getLosses().mean(), 2) == -0.08) self.assertTrue(stratAnalyzer.getProfitableCount() == 0)
def testLong2(self): strat = self.__createStrategy() stratAnalyzer = trades.Trades() strat.attachAnalyzer(stratAnalyzer) # Enter long strat.addOrder(buildUTCDateTime(2011, 1, 3, 15, 0), strat.getBroker().createMarketOrder, broker.Order.Action.BUY, TradesAnalyzerTestCase.TestInstrument, 1) # 127.14 # Extend long position strat.addOrder(buildUTCDateTime(2011, 1, 3, 15, 16), strat.getBroker().createMarketOrder, broker.Order.Action.BUY, TradesAnalyzerTestCase.TestInstrument, 1) # 127.16 # Exit long strat.addOrder(buildUTCDateTime(2011, 1, 3, 15, 30), strat.getBroker().createMarketOrder, broker.Order.Action.SELL, TradesAnalyzerTestCase.TestInstrument, 2) # 127.2 strat.run() self.assertTrue( round(strat.getBroker().getCash(), 2) == round( 1000 + (127.2 - 127.14) + (127.2 - 127.16), 2)) self.assertTrue(stratAnalyzer.getCount() == 1) self.assertTrue(stratAnalyzer.getEvenCount() == 0) self.assertTrue(round(stratAnalyzer.getAll().mean(), 2) == 0.1) self.assertTrue(stratAnalyzer.getProfitableCount() == 1) self.assertTrue(round(stratAnalyzer.getProfits().mean(), 2) == 0.1) self.assertTrue(stratAnalyzer.getUnprofitableCount() == 0)
def testStrategy(): from engine import bar strat = thrSMA instrument = '600288' market = 'SH' fromDate = '20150101' toDate ='20150601' frequency = bar.Frequency.MINUTE paras = [2, 20, 60, 10] plot = True #############################################path set ############################33 import os print os.path.split(os.path.realpath(__file__)) if frequency == bar.Frequency.MINUTE: path = os.path.join(os.environ.get('STRATEGYPATH'), '..', 'histdata', 'minute') elif frequency == bar.Frequency.DAY: path = os.path.join(os.environ.get('STRATEGYPATH'), '..', 'histdata', 'day') filepath = os.path.join(path, instrument + market + ".csv") #############################################don't change ############################33 from engine.barfeed.csvfeed import Feed barfeed = Feed(frequency) barfeed.setDateTimeFormat('%Y-%m-%d %H:%M:%S') barfeed.loadBars(instrument, market, fromDate, toDate, filepath) engine_id = instrument + '.' + market strat = strat(barfeed, engine_id, *paras) from engine.stratanalyzer import returns from engine.stratanalyzer import sharpe from engine.stratanalyzer import drawdown from engine.stratanalyzer import trades retAnalyzer = returns.Returns() strat.attachAnalyzer(retAnalyzer) sharpeRatioAnalyzer = sharpe.SharpeRatio() strat.attachAnalyzer(sharpeRatioAnalyzer) drawDownAnalyzer = drawdown.DrawDown() strat.attachAnalyzer(drawDownAnalyzer) tradesAnalyzer = trades.Trades() strat.attachAnalyzer(tradesAnalyzer) strat.run() #夏普率 sharp = sharpeRatioAnalyzer.getSharpeRatio(0.05) #最大回撤 maxdd = drawDownAnalyzer.getMaxDrawDown() #收益率 return_ = retAnalyzer.getCumulativeReturns()[-1] #收益曲线 return_list = [] for item in retAnalyzer.getCumulativeReturns(): return_list.append(item)
def testSomeTrades_Position(self): strat = self.__createPositionStrategy() stratAnalyzer = trades.Trades() strat.attachAnalyzer(stratAnalyzer) # Winning trade strat.addPosEntry(buildUTCDateTime(2011, 1, 3, 15, 0), strat.enterLong, TradesAnalyzerTestCase.TestInstrument, 1) # 127.14 strat.addPosExitMarket(buildUTCDateTime(2011, 1, 3, 15, 16)) # 127.16 # Losing trade strat.addPosEntry(buildUTCDateTime(2011, 1, 3, 15, 30), strat.enterLong, TradesAnalyzerTestCase.TestInstrument, 1) # 127.2 strat.addPosExitMarket(buildUTCDateTime(2011, 1, 3, 15, 31)) # 127.16 # Winning trade strat.addPosEntry(buildUTCDateTime(2011, 1, 3, 15, 38), strat.enterLong, TradesAnalyzerTestCase.TestInstrument, 1) # 127.16 strat.addPosExitMarket(buildUTCDateTime(2011, 1, 3, 15, 42)) # 127.26 # Unfinished trade not closed strat.addPosEntry(buildUTCDateTime(2011, 1, 3, 15, 47), strat.enterLong, TradesAnalyzerTestCase.TestInstrument, 1) # 127.34 strat.run() self.assertTrue( round(strat.getBroker().getCash(), 2) == round( 1000 + (127.16 - 127.14) + (127.16 - 127.2) + (127.26 - 127.16) - 127.34, 2)) self.assertTrue(stratAnalyzer.getCount() == 3) self.assertTrue(stratAnalyzer.getEvenCount() == 0) self.assertTrue(round(stratAnalyzer.getAll().mean(), 2) == 0.03) self.assertTrue(round(stratAnalyzer.getAll().std(ddof=1), 2) == 0.07) self.assertTrue(round(stratAnalyzer.getAll().std(ddof=0), 2) == 0.06) self.assertTrue(stratAnalyzer.getProfitableCount() == 2) self.assertTrue(round(stratAnalyzer.getProfits().mean(), 2) == 0.06) self.assertTrue( round(stratAnalyzer.getProfits().std(ddof=1), 2) == 0.06) self.assertTrue( round(stratAnalyzer.getProfits().std(ddof=0), 2) == 0.04) self.assertEqual(stratAnalyzer.getPositiveReturns()[0], (127.16 - 127.14) / 127.14) self.assertEqual(stratAnalyzer.getPositiveReturns()[1], (127.26 - 127.16) / 127.16) self.assertTrue(stratAnalyzer.getUnprofitableCount() == 1) self.assertTrue(round(stratAnalyzer.getLosses().mean(), 2) == -0.04) if version.LooseVersion( numpy.__version__) >= version.LooseVersion("1.6.2"): self.assertTrue(math.isnan(stratAnalyzer.getLosses().std(ddof=1))) else: self.assertTrue(stratAnalyzer.getLosses().std(ddof=1) == 0) self.assertTrue(stratAnalyzer.getLosses().std(ddof=0) == 0) self.assertEqual(stratAnalyzer.getNegativeReturns()[0], (127.16 - 127.2) / 127.2)
def testNoTrades(self): strat = self.__createStrategy() stratAnalyzer = trades.Trades() strat.attachAnalyzer(stratAnalyzer) strat.run() self.assertTrue(strat.getBroker().getCash() == 1000) self.assertTrue(stratAnalyzer.getCount() == 0) self.assertTrue(stratAnalyzer.getEvenCount() == 0) self.assertTrue(stratAnalyzer.getProfitableCount() == 0) self.assertTrue(stratAnalyzer.getUnprofitableCount() == 0)
def testSomeTradesWithCommissions(self): strat = self.__createStrategy() strat.getBroker().setCommission(backtesting.FixedPerTrade(0.01)) stratAnalyzer = trades.Trades() strat.attachAnalyzer(stratAnalyzer) # Losing trade strat.addOrder(buildUTCDateTime(2011, 1, 3, 15, 30), strat.getBroker().createMarketOrder, broker.Order.Action.BUY, TradesAnalyzerTestCase.TestInstrument, 1) # 127.2 strat.addOrder(buildUTCDateTime(2011, 1, 3, 15, 31), strat.getBroker().createMarketOrder, broker.Order.Action.SELL, TradesAnalyzerTestCase.TestInstrument, 1) # 127.16 # Winning trade strat.addOrder(buildUTCDateTime(2011, 1, 3, 15, 38), strat.getBroker().createMarketOrder, broker.Order.Action.BUY, TradesAnalyzerTestCase.TestInstrument, 1) # 127.16 strat.addOrder(buildUTCDateTime(2011, 1, 3, 15, 42), strat.getBroker().createMarketOrder, broker.Order.Action.SELL, TradesAnalyzerTestCase.TestInstrument, 1) # 127.26 # Open trade. strat.addOrder(buildUTCDateTime(2011, 1, 3, 15, 47), strat.getBroker().createMarketOrder, broker.Order.Action.BUY, TradesAnalyzerTestCase.TestInstrument, 1) # 127.34 strat.run() self.assertTrue( round(strat.getBroker().getCash(), 2) == round( 1000 + (127.16 - 127.2) + (127.26 - 127.16) - 127.34 - 0.01 * 5, 2)) self.assertTrue( numpy.array_equal(stratAnalyzer.getCommissionsForAllTrades(), numpy.array([0.02, 0.02]))) self.assertTrue( numpy.array_equal( stratAnalyzer.getCommissionsForProfitableTrades(), numpy.array([0.02]))) self.assertTrue( numpy.array_equal( stratAnalyzer.getCommissionsForUnprofitableTrades(), numpy.array([0.02]))) self.assertTrue( numpy.array_equal(stratAnalyzer.getCommissionsForEvenTrades(), numpy.array([])))
def testProportionalCommissionBug(self): # Regression test for a bug reported by 'Jackson Sam' on 30/Aug/2013. strat = self.__createStrategy() strat.getBroker().setCommission(backtesting.FixedPerTrade(0.01)) stratAnalyzer = trades.Trades() strat.attachAnalyzer(stratAnalyzer) # There are 3 trades here: # Trade 1 (Long) # Buy 1 @ 127.16 Commission: 0.01 # Sell 1 @ 127.26 Commission: 0.005 # Trade 2 (Short) # Sell 1 @ 127.26 Commission: 0.005 # Buy 1 @ 127.37 Commission: 0.005 # Trade 3 (Long) # Buy 1 @ 127.37 Commission: 0.005 # Sell 1 @ 127.4 Commission: 0.01 strat.addOrder(buildUTCDateTime(2011, 1, 3, 15, 38), strat.getBroker().createMarketOrder, broker.Order.Action.BUY, TradesAnalyzerTestCase.TestInstrument, 1) # Fill at 127.16 strat.addOrder(buildUTCDateTime(2011, 1, 3, 15, 42), strat.getBroker().createMarketOrder, broker.Order.Action.SELL, TradesAnalyzerTestCase.TestInstrument, 2) # Fill at 127.26 strat.addOrder(buildUTCDateTime(2011, 1, 3, 15, 53), strat.getBroker().createMarketOrder, broker.Order.Action.BUY, TradesAnalyzerTestCase.TestInstrument, 2) # Fill at 127.37 strat.addOrder(buildUTCDateTime(2011, 1, 3, 15, 58), strat.getBroker().createMarketOrder, broker.Order.Action.SELL, TradesAnalyzerTestCase.TestInstrument, 1) # Fill at 127.4 strat.run() allReturns = stratAnalyzer.getAllReturns() self.assertEqual(round(allReturns[0], 6), 0.000668) self.assertEqual(round(allReturns[1], 6), -0.000943) self.assertEqual(round(allReturns[2], 6), 0.000118)
def testLongShort(self): strat = self.__createStrategy() stratAnalyzer = trades.Trades() strat.attachAnalyzer(stratAnalyzer) # Enter long strat.addOrder(buildUTCDateTime(2011, 1, 3, 15, 0), strat.getBroker().createMarketOrder, broker.Order.Action.BUY, TradesAnalyzerTestCase.TestInstrument, 1) # 127.14 # Exit long and enter short strat.addOrder(buildUTCDateTime(2011, 1, 3, 15, 16), strat.getBroker().createMarketOrder, broker.Order.Action.SELL, TradesAnalyzerTestCase.TestInstrument, 2) # 127.16 # Exit short strat.addOrder(buildUTCDateTime(2011, 1, 3, 15, 30), strat.getBroker().createMarketOrder, broker.Order.Action.BUY_TO_COVER, TradesAnalyzerTestCase.TestInstrument, 1) # 127.2 strat.run() self.assertTrue( round(strat.getBroker().getCash(), 2) == round( 1000 + (127.16 - 127.14) + (127.16 - 127.2), 2)) self.assertTrue(stratAnalyzer.getCount() == 2) self.assertTrue(stratAnalyzer.getEvenCount() == 0) self.assertTrue(round(stratAnalyzer.getAll().mean(), 2) == -0.01) self.assertTrue(round(stratAnalyzer.getAll().std(ddof=1), 4) == 0.0424) self.assertTrue(stratAnalyzer.getProfitableCount() == 1) self.assertTrue(round(stratAnalyzer.getProfits().mean(), 2) == 0.02) self.assertTrue(stratAnalyzer.getUnprofitableCount() == 1) self.assertTrue(round(stratAnalyzer.getLosses().mean(), 2) == -0.04)
def testStrategy(): from engine import bar from engine import plotter strat = Bollinger_Bandit instrument = '600288' market = 'SH' fromDate = '20150101' toDate ='20150601' frequency = bar.Frequency.MINUTE paras = [40, 15, 35, 15, 60, 2] plot = True #############################################path set ############################33 import os if frequency == bar.Frequency.MINUTE: path = os.path.join('..', 'histdata', 'minute') elif frequency == bar.Frequency.DAY: path = os.path.join('..', 'histdata', 'day') filepath = os.path.join(path, instrument + market + ".csv") #############################################don't change ############################33 from engine.barfeed.csvfeed import Feed barfeed = Feed(frequency) barfeed.setDateTimeFormat('%Y-%m-%d %H:%M:%S') barfeed.loadBars(instrument, market, fromDate, toDate, filepath) engine_id = instrument + '.' + market strat = strat(barfeed, engine_id, *paras) from engine.stratanalyzer import returns from engine.stratanalyzer import sharpe from engine.stratanalyzer import drawdown from engine.stratanalyzer import trades retAnalyzer = returns.Returns() strat.attachAnalyzer(retAnalyzer) sharpeRatioAnalyzer = sharpe.SharpeRatio() strat.attachAnalyzer(sharpeRatioAnalyzer) drawDownAnalyzer = drawdown.DrawDown() strat.attachAnalyzer(drawDownAnalyzer) tradesAnalyzer = trades.Trades() strat.attachAnalyzer(tradesAnalyzer) if plot: plt = plotter.StrategyPlotter(strat, True, True, True) strat.run() if plot: plt.plot() #夏普率 sharp = sharpeRatioAnalyzer.getSharpeRatio(0.05) #最大回撤 maxdd = drawDownAnalyzer.getMaxDrawDown() #收益率 return_ = retAnalyzer.getCumulativeReturns()[-1] #收益曲线 return_list = [] for item in retAnalyzer.getCumulativeReturns(): return_list.append(item)
def testSomeTrades(self): strat = self.__createStrategy() stratAnalyzer = trades.Trades() strat.attachAnalyzer(stratAnalyzer) # Winning trade strat.addOrder(buildUTCDateTime(2011, 1, 3, 15, 0), strat.getBroker().createMarketOrder, broker.Order.Action.BUY, TradesAnalyzerTestCase.TestInstrument, 1) # 127.14 strat.addOrder(buildUTCDateTime(2011, 1, 3, 15, 16), strat.getBroker().createMarketOrder, broker.Order.Action.SELL, TradesAnalyzerTestCase.TestInstrument, 1) # 127.16 # Losing trade strat.addOrder(buildUTCDateTime(2011, 1, 3, 15, 30), strat.getBroker().createMarketOrder, broker.Order.Action.BUY, TradesAnalyzerTestCase.TestInstrument, 1) # 127.2 strat.addOrder(buildUTCDateTime(2011, 1, 3, 15, 31), strat.getBroker().createMarketOrder, broker.Order.Action.SELL, TradesAnalyzerTestCase.TestInstrument, 1) # 127.16 # Winning trade strat.addOrder(buildUTCDateTime(2011, 1, 3, 15, 38), strat.getBroker().createMarketOrder, broker.Order.Action.BUY, TradesAnalyzerTestCase.TestInstrument, 1) # 127.16 strat.addOrder(buildUTCDateTime(2011, 1, 3, 15, 42), strat.getBroker().createMarketOrder, broker.Order.Action.SELL, TradesAnalyzerTestCase.TestInstrument, 1) # 127.26 # Open trade. strat.addOrder(buildUTCDateTime(2011, 1, 3, 15, 47), strat.getBroker().createMarketOrder, broker.Order.Action.BUY, TradesAnalyzerTestCase.TestInstrument, 1) # 127.34 strat.run() self.assertTrue( round(strat.getBroker().getCash(), 2) == round( 1000 + (127.16 - 127.14) + (127.16 - 127.2) + (127.26 - 127.16) - 127.34, 2)) self.assertTrue(stratAnalyzer.getCount() == 3) self.assertTrue(stratAnalyzer.getEvenCount() == 0) self.assertTrue(round(stratAnalyzer.getAll().mean(), 2) == 0.03) self.assertTrue(round(stratAnalyzer.getAll().std(ddof=1), 2) == 0.07) self.assertTrue(round(stratAnalyzer.getAll().std(ddof=0), 2) == 0.06) self.assertTrue(stratAnalyzer.getProfitableCount() == 2) self.assertTrue(round(stratAnalyzer.getProfits().mean(), 2) == 0.06) self.assertTrue( round(stratAnalyzer.getProfits().std(ddof=1), 2) == 0.06) self.assertTrue( round(stratAnalyzer.getProfits().std(ddof=0), 2) == 0.04) self.assertTrue(stratAnalyzer.getUnprofitableCount() == 1) self.assertTrue(round(stratAnalyzer.getLosses().mean(), 2) == -0.04) if version.LooseVersion( numpy.__version__) >= version.LooseVersion("1.6.2"): self.assertTrue(math.isnan(stratAnalyzer.getLosses().std(ddof=1))) else: self.assertTrue(stratAnalyzer.getLosses().std(ddof=1) == 0) self.assertTrue(stratAnalyzer.getLosses().std(ddof=0) == 0)