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 testIGE_BrokerWithCommission(self):
commision = 0.5
initialCash = 42.09 + commision
# This testcase is based on an example from Ernie Chan's book:
# 'Quantitative Trading: How to Build Your Own Algorithmic Trading Business'
barFeed = yahoofeed.Feed()
barFeed.addBarsFromCSV("ige", common.get_data_file_path("sharpe-ratio-test-ige.csv"))
strat = strategy_test.TestStrategy(barFeed, initialCash)
strat.getBroker().setCommission(backtesting.FixedPerTrade(commision))
strat.setUseAdjustedValues(True)
strat.setBrokerOrdersGTC(True)
stratAnalyzer = sharpe.SharpeRatio()
strat.attachAnalyzer(stratAnalyzer)
# Disable volume checks to match book results.
strat.getBroker().getFillStrategy().setVolumeLimit(None)
# Manually place the order to get it filled on the first bar.
order = strat.getBroker().createMarketOrder(broker.Order.Action.BUY, "ige", 1, True) # Adj. Close: 42.09
order.setGoodTillCanceled(True)
strat.getBroker().placeOrder(order)
strat.addOrder(datetime.datetime(2007, 11, 13), strat.getBroker().createMarketOrder, broker.Order.Action.SELL, "ige", 1, True) # Adj. Close: 127.64
strat.run()
self.assertTrue(round(strat.getBroker().getCash(), 2) == initialCash + (127.64 - 42.09 - commision*2))
self.assertEqual(strat.orderUpdatedCalls, 4)
# The results are slightly different only because I'm taking into account the first bar as well,
# and I'm also adding commissions.
self.assertEqual(round(stratAnalyzer.getSharpeRatio(0.04, True), 6), 0.776443)
def __init__(self,
instruments,
initialCash,
fromYear,
toYear,
debugMode=True,
csvStorage="./googlefinance",
filterInvalidRows=True):
self.__logger = logger.getLogger(GoogleFinanceBacktest.LOGGER_NAME)
self.__finalPortfolioValue = 0
# Create Feed
self.__feed = googlefeed.Feed()
rowFilter = lambda row: row["Close"] == "-" or row["Open"] == "-" or row["High"] == "-" or row["Low"] == "-" or \
row["Volume"] == "-"
self.__feed = googlefinance.build_feed(
instruments,
fromYear,
toYear,
storage=csvStorage,
skipErrors=True,
rowFilter=rowFilter if filterInvalidRows else None)
# Create Broker
comissionModel = backtesting.FixedPerTrade(10)
self.__broker = backtesting.Broker(initialCash,
self.__feed,
commission=comissionModel)
self.__strategy = TradingSystem(self.__feed,
self.__broker,
debugMode=debugMode)
# Create Analyzers
returnsAnalyzer = returns.Returns()
self.__strategy.attachAnalyzer(returnsAnalyzer)
dailyResultsAnalyzer = DailyTradingResults()
self.__strategy.attachAnalyzer(dailyResultsAnalyzer)
self.__tradesAnalyzer = Trades()
self.__strategy.attachAnalyzer(self.__tradesAnalyzer)
# Create plotters
self.__plotters = []
self.__plotters.append(
plotter.StrategyPlotter(self.__strategy,
plotAllInstruments=False,
plotPortfolio=True,
plotBuySell=False))
self.__plotters[0].getOrCreateSubplot("returns").addDataSeries(
"Simple returns", returnsAnalyzer.getReturns())
self.__plotters[0].getOrCreateSubplot("dailyresult").addDataSeries(
"Daily Results", dailyResultsAnalyzer.getTradeResults())
for i in range(0, len(instruments)):
p = plotter.StrategyPlotter(self.__strategy,
plotAllInstruments=False,
plotPortfolio=False)
p.getInstrumentSubplot(instruments[i])
self.__plotters.append(p)
def main(printinfo):
firstyear = 2007
lastyear = 2013
num_instr = 3
posinstruments = daq.find_instruments_by_year(firstyear)
instruments = sample(posinstruments, num_instr)
instruments = ['JCI', 'AAPL', 'YUM', 'ABC']
feed = daq.build_stock_feed(instruments, [firstyear, lastyear])
this_Strategy = sgs.SLTRIXCrossover(feed,
instruments,
100000,
12,
27,
.43,
.43,
printinfo=printinfo)
# this_Strategy = sgs.EMACrossover(feed, instruments, 100000, 28, .5, ('FixedPerTrade', 10))
retAnalyzer = returns.Returns()
this_Strategy.attachAnalyzer(retAnalyzer)
# this_Strategy.getBroker().setCommission(
# backtesting.TradePercentage(.01)) # 1.% commission per trade
this_Strategy.getBroker().setCommission(
backtesting.FixedPerTrade(10)) # $10 commission per trade
# Attach plotters
# Attach the plotter to the strategy.
plt = plotter.StrategyPlotter(this_Strategy)
# Include the SMA in the instrument's subplot to get it displayed along
# with the closing prices.
# for pltinstr in instruments:
# plt.getInstrumentSubplot(pltinstr).addDataSeries(
# "Short TRIX", this_Strategy.getshorttrix(pltinstr))
# plt.getInstrumentSubplot(pltinstr).addDataSeries(
# "Long TRIX", this_Strategy.getlongtrix(pltinstr))
# for pltinstr in instruments:
# plt.getInstrumentSubplot(pltinstr).addDataSeries(
# "EMA", this_Strategy.getEMA(pltinstr))
# # Plot the simple returns on each bar.
# plt.getOrCreateSubplot("returns").addDataSeries(
# "Simple returns", retAnalyzer.getReturns())
# Run the strategy
this_Strategy.run()
# Print the results.
print "Final portfolio value: $%.2f" % this_Strategy.getResult()
print "Annual return: %.2f %%" % (
(retAnalyzer.getCumulativeReturns()[-1] * 100) /
float(lastyear - firstyear))
print "Average daily return: %.2f %%" % (
stats.mean(retAnalyzer.getReturns()) * 100)
print "Std. dev. daily return: %.4f" % (stats.stddev(
retAnalyzer.getReturns()))
plt.plot()
return this_Strategy.getResult()
def __init__(self, feed, longsize, shortsize, riskfactor):
broker = backtesting.Broker(10000, feed, backtesting.FixedPerTrade(10))
super(SMAStrategyOptimizer,
self).__init__(feed=feed,
broker=broker,
tradingAlgorithm=SMATradingAlgorithm(
feed, broker, longsize, shortsize,
riskfactor),
debugMode=False)
def __init__(self, feed, entrySize, exitSize, riskFactor):
broker = backtesting.Broker(10000, feed, backtesting.FixedPerTrade(10))
super(DonchianStrategyOptimizer,
self).__init__(feed=feed,
broker=broker,
tradingAlgorithm=DonchianTradingAlgorithm(
feed, broker, entrySize, exitSize,
riskFactor),
debugMode=False)
def __init__(self, feed, instrument):
super(MyStrategy, self).__init__(feed, 100000)
self.__position = None
self.__instrument = instrument
self.getBroker().setCommission(backtesting.FixedPerTrade(5))
self.__macd = macd.MACD(feed[instrument].getPriceDataSeries(), 12, 26,
9)
self.__analyzer = Analyzer(self, 'hs300')
self.__transaction = Transaction(self)
self.__transposition = TradePosition(self)
def __init__(self, feed, instrument, t, clossarr, alpha):
super(MyStrategy, self).__init__(feed, 100000)
self.__position = None
self.__instrument = instrument
self.getBroker().setCommission(backtesting.FixedPerTrade(5))
self.__BBcurve = BBCurve.BBCurve(feed[self.__instrument].getPriceDataSeries(), t, clossarr, alpha)
self.__analyzer = Analyzer(self, 'hs300')
self.__transaction = Transaction(self)
self.__transposition = TradePosition(self)
self.__Value = []
self.__bull = None
self.__bear = None
def __init__(self, feed, instrument, svmstrategy, scaler, period):
super(MyStrategy, self).__init__(feed, 100000)
self.__histValue = []
self.__svmstrategy = svmstrategy
self.__period = period
self.__scaler = scaler
self.__interval = 5
self.__position = None
self.__price = 0
self.__instrument = instrument
self.getBroker().setCommission(backtesting.FixedPerTrade(5))
self.__analyzer = Analyzer(self, 'hs300')
self.__transaction = Transaction(self)
self.__transposition = TradePosition(self)
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 testFixedPerTrade(self): comm = backtesting.FixedPerTrade(1.2) self.assertEqual(comm.calculate(None, 1, 1), 1.2)
def testSellShortWithCommission(self): sharePrice = 100 commission = 10 brk = backtesting.Broker(1010, barFeed=barfeed.BarFeed(barfeed.Frequency.MINUTE), commission=backtesting.FixedPerTrade(commission)) # Sell 10 shares order = brk.createMarketOrder(broker.Order.Action.SELL_SHORT, BaseTestCase.TestInstrument, 10) brk.placeOrder(order) brk.onBars(self.buildBars(sharePrice, sharePrice, sharePrice, sharePrice)) self.assertTrue(order.isFilled()) self.assertTrue(order.getExecutionInfo().getCommission() == 10) self.assertTrue(brk.getCash() == 2000) self.assertTrue(brk.getShares(BaseTestCase.TestInstrument) == -10) # Buy the 10 shares sold short plus 9 extra order = brk.createMarketOrder(broker.Order.Action.BUY_TO_COVER, BaseTestCase.TestInstrument, 19) brk.placeOrder(order) brk.onBars(self.buildBars(sharePrice, sharePrice, sharePrice, sharePrice)) self.assertTrue(order.isFilled()) self.assertTrue(order.getExecutionInfo().getCommission() == 10) self.assertTrue(brk.getShares(BaseTestCase.TestInstrument) == 9) self.assertTrue(brk.getCash() == sharePrice - commission)
def testBuyWithCommission(self): brk = backtesting.Broker(1020, barFeed=barfeed.BarFeed(barfeed.Frequency.MINUTE), commission=backtesting.FixedPerTrade(10)) # Buy order = brk.createMarketOrder(broker.Order.Action.BUY, BaseTestCase.TestInstrument, 100) brk.placeOrder(order) brk.onBars(self.buildBars(10, 15, 8, 12)) self.assertTrue(order.isFilled()) self.assertTrue(order.getExecutionInfo().getCommission() == 10) self.assertTrue(len(brk.getActiveOrders()) == 0) self.assertTrue(brk.getCash() == 10) self.assertTrue(brk.getShares(BaseTestCase.TestInstrument) == 100)
#the data is in the CSV file (one row per day)
feed = csvfeed.GenericBarFeed(bar.Frequency.DAY)
feed.addBarsFromCSV(ticker, file_name)
#this is where we define the time for the moving average models (slow and fast)
movingAverageStrategy = sma_9.MovingAverageStrategy(
feed, ticker, fastPeriod)
#Set Initial Budget
movingAverageStrategy.initBackTestStrategy(INITIAL_BUDGET)
#Set Risk Percent, default is 2
movingAverageStrategy.setRiskPercent(RISK_PERCENT)
#Set budget useage
movingAverageStrategy.setBudgetUse(BUDGET_USE)
#we can define the cost of trading (cost pre trade)
movingAverageStrategy.getBroker().setCommission(
backtesting.FixedPerTrade(0.1))
#Turn on or off the trade print output
movingAverageStrategy.setInfoOutput(outputInfo)
#Prepare plots
plot = plotter.StrategyPlotter(movingAverageStrategy,
plotAllInstruments=True,
plotBuySell=True,
plotPortfolio=True)
plot.getInstrumentSubplot(ticker).addDataSeries(
'Fast SMA', movingAverageStrategy.getFastMA())
#we can analyze the returns during the backtest
returnAnalyzer = ret.Returns()
movingAverageStrategy.attachAnalyzer(returnAnalyzer)
print([fastPeriod, slowPeriod])
INITIAL_BUDGET = 15000
NSHARES = 20
#the data is in the CSV file
feed = csvfeed.GenericBarFeed(bar.Frequency.DAY)
feed.addBarsFromCSV(instrument, fname)
# define the time for the moving average models
movingAverageStrategy = MovingAverageStrategy(
feed, instrument, fastPeriod, slowPeriod)
#define the cost of trading
movingAverageStrategy.getBroker().setCommission(
backtesting.FixedPerTrade(cost_per_trade))
#analyze the returns during the backtest
returnAnalyzer = ret.Returns()
movingAverageStrategy.attachAnalyzer(returnAnalyzer)
#analyze the Sharpe ratio during backtest
sharpeRatioAnalyzer = sharpe.SharpeRatio()
movingAverageStrategy.attachAnalyzer(sharpeRatioAnalyzer)
# analyze the trades
tradesAnalyzer = trades.Trades()
movingAverageStrategy.attachAnalyzer(tradesAnalyzer)
movingAverageStrategy.run()
fname=fpath+instrument+ftype
#first MA indicator tracks the slow trend with period 50
slowPeriod = 100
#second MA indicator tracks the fast trend with period 30
fastPeriod = 50
#the data is in the CSV file (one row per day)
feed = csvfeed.GenericBarFeed(bar.Frequency.DAY)
feed.addBarsFromCSV(instrument,fname)
#this is where we define the time for the moving average models (slow and fast)
movingAverageStrategy = MovingAverageStrategy(feed,instrument,fastPeriod,slowPeriod)
#we can define the cost of trading (cost pre trade)
movingAverageStrategy.getBroker().setCommission(backtesting.FixedPerTrade(cost_per_trade))
#we want to plot the stock (instrument) with the buy/sell orders
plot = plotter.StrategyPlotter(movingAverageStrategy,plotAllInstruments=True,plotBuySell=True,plotPortfolio=True)
plot.getInstrumentSubplot('S&P500').addDataSeries('Fast SMA',movingAverageStrategy.getFastMA())
plot.getInstrumentSubplot('S&P500').addDataSeries('Slow SMA',movingAverageStrategy.getSlowMA())
#we can analyze the returns during the backtest
returnAnalyzer = ret.Returns()
movingAverageStrategy.attachAnalyzer(returnAnalyzer)
#we can analyze the Sharpe ratio during backtest
sharpeRatioAnalyzer = sharpe.SharpeRatio()
movingAverageStrategy.attachAnalyzer(sharpeRatioAnalyzer)
#we can analyze the trades (maximum profit or loss etc.)
# Load the yahoo feed from CSV files.
feed = yahoofeed.Feed()
feed.addBarsFromCSV("aeti", "aeti-2009-yahoofinance.csv")
feed.addBarsFromCSV("egan", "egan-2009-yahoofinance.csv")
feed.addBarsFromCSV("glng", "glng-2009-yahoofinance.csv")
feed.addBarsFromCSV("simo", "simo-2009-yahoofinance.csv")
# Evaluate the strategy with the feed's bars.
myStrategy = MyStrategy(feed)
# Set commission
# https://github.com/gbeced/pyalgotrade/blob/master/testcases/sharpe_analyzer_test.py
myStrategy.getBroker().setCommission(
backtesting.FixedPerTrade(10)) # $10 commission per trade
myStrategy.getBroker().setCommission(
backtesting.TradePercentage(.10)) # 10.% commission per trade
# Attach returns and sharpe ratio analyzers.
retAnalyzer = returns.Returns()
myStrategy.attachAnalyzer(retAnalyzer)
sharpeRatioAnalyzer = sharpe.SharpeRatio()
myStrategy.attachAnalyzer(sharpeRatioAnalyzer)
# Run the strategy
myStrategy.run()
# Print the results.
print "Final portfolio value: $%.2f" % myStrategy.getResult()
print "Anual return: %.2f %%" % (retAnalyzer.getCumulativeReturns()[-1] * 100)
