def comb_strat_settings_from_ml_prob(test_prob_dict, cut_num_dict, bt_fromdate, df_prc, shift_flag=False, comb_only=False, \
trade_cost=0., ls_target_weight=0.5):
weight_sig_data_dict = {}
strats = []
fsets = list(test_prob_dict.keys())
weight_divisor = 1. / len(fsets)
allidx = list(test_prob_dict[fsets[0]].index)
codesToLoad = list(test_prob_dict[fsets[0]].columns)
comb_sig = pd.DataFrame(0., index=allidx,
columns=codesToLoad).loc[bt_fromdate:]
for fset in fsets:
print(fset)
sig_data = qcut_signal(test_prob_dict[fset], cut_num_dict[fset],
test_prob_dict[fset].index[0])
sig_data = sig_data.pivot(index='tdate',
columns='code',
values='value')
sig_data.index = pd.to_datetime(sig_data.index)
long_sig = cut_num_dict[fset] * 1. - 1.
short_sig = 0.
# do below if you want to check lagging effect
if shift_flag:
sig_data = sig_data.reindex(df_prc.index).shift(1).dropna(
axis=0, how='all')
weight_sig_data_dict[fset] = sig_data.copy().apply(
sig_to_weight,
axis=1,
args=(long_sig, short_sig, ls_target_weight)).loc[bt_fromdate:]
if not comb_only:
s = bt.Strategy(fset, [
bt.algos.RunOnDate(*weight_sig_data_dict[fset].index),
bt.algos.WeighTarget(weight_sig_data_dict[fset]),
bt.algos.Rebalance()
])
strats.append(bt.Backtest(s, df_prc.loc[weight_sig_data_dict[fset].index[0]:].fillna(method='ffill'), initial_capital=10.**9, \
commissions=lambda q, p: abs(q*p)*trade_cost))
tmp_sig_data = weight_sig_data_dict[fset].loc[
bt_fromdate:] * weight_divisor
comb_sig = comb_sig.add(tmp_sig_data.fillna(0.), fill_value=0.)
weight_sig_data_dict[
'comb'] = comb_sig #[df_prc.loc[comb_sig.index, comb_sig.columns].notnull()]
weight_sig_data_dict['comb'].fillna(0, inplace=True)
s = bt.Strategy('comb', [
bt.algos.RunOnDate(*weight_sig_data_dict['comb'].index),
bt.algos.WeighTarget(weight_sig_data_dict['comb']),
bt.algos.Rebalance()
])
strats.append(bt.Backtest(s, df_prc.loc[weight_sig_data_dict['comb'].index[0]:].fillna(method='ffill').fillna(0), initial_capital=10.**9, \
commissions=lambda q, p: abs(q*p)*trade_cost))
return strats, weight_sig_data_dict
def test_run_period():
target = mock.MagicMock()
dts = pd.date_range('2010-01-01', periods=35)
data = pd.DataFrame(index=dts, columns=['c1', 'c2'], data=100)
algo = algos.RunPeriod()
# adds the initial day
backtest = bt.Backtest(
bt.Strategy('', [algo]),
data
)
target.data = backtest.data
dts = target.data.index
target.now = None
assert not algo(target)
# run on first date
target.now = dts[0]
assert not algo(target)
# run on first supplied date
target.now = dts[1]
assert algo(target)
# run on last date
target.now = dts[len(dts) - 1]
assert not algo(target)
algo = algos.RunPeriod(
run_on_first_date=False,
run_on_end_of_period=True,
run_on_last_date=True
)
# adds the initial day
backtest = bt.Backtest(
bt.Strategy('', [algo]),
data
)
target.data = backtest.data
dts = target.data.index
# run on first date
target.now = dts[0]
assert not algo(target)
# first supplied date
target.now = dts[1]
assert not algo(target)
# run on last date
target.now = dts[len(dts) - 1]
assert algo(target)
# date not in index
target.now = datetime(2009, 2, 15)
assert not algo(target)
def abovema_trainandtest(tickers,
sma=50,
start_train='06-01-2015',
end_train='05-31-2017',
start_test='06-01-2017',
end_test='05-31-2019',
name1='above_sma50_train',
name2='above_sma50_test'):
#training test
data_train = bt.get(tickers, start=start_train, end=end_train)
sma_train = data_train.rolling(sma).mean()
signal = data_train > sma_train
s = bt.Strategy(name1, [
bt.algos.SelectWhere(signal),
bt.algos.WeighEqually(),
bt.algos.Rebalance()
])
#testing set
data_test = bt.get(tickers, start=start_test, end=end_test)
sma_test = data_test.rolling(sma).mean()
signal2 = data_test > sma_test
s2 = bt.Strategy(name2, [
bt.algos.SelectWhere(signal2),
bt.algos.WeighEqually(),
bt.algos.Rebalance()
])
return (bt.Backtest(s, data_train), bt.Backtest(s2, data_test))
def test_run_yearly():
dts = pd.date_range('2010-01-01', periods=367)
data = pd.DataFrame(index=dts, columns=['c1', 'c2'], data=100)
target = mock.MagicMock()
target.data = data
algo = algos.RunYearly()
# adds the initial day
backtest = bt.Backtest(bt.Strategy('', [algo]), data)
target.data = backtest.data
# end of year
target.now = dts[364]
assert not algo(target)
# new year
target.now = dts[365]
assert algo(target)
algo = algos.RunYearly(run_on_first_date=False,
run_on_end_of_period=True,
run_on_last_date=True)
# adds the initial day
backtest = bt.Backtest(bt.Strategy('', [algo]), data)
target.data = backtest.data
# end of year
target.now = dts[364]
assert algo(target)
# new year
target.now = dts[365]
assert not algo(target)
def test_run_quarterly():
dts = pd.date_range('2010-01-01', periods=367)
data = pd.DataFrame(index=dts, columns=['c1', 'c2'], data=100)
target = mock.MagicMock()
target.data = data
algo = algos.RunQuarterly()
# adds the initial day
backtest = bt.Backtest(
bt.Strategy('', [algo]),
data
)
target.data = backtest.data
# end of quarter
target.now = dts[89]
assert not algo(target)
# new quarter
target.now = dts[90]
assert algo(target)
algo = algos.RunQuarterly(
run_on_first_date=False,
run_on_end_of_period=True,
run_on_last_date=True
)
# adds the initial day
backtest = bt.Backtest(
bt.Strategy('', [algo]),
data
)
target.data = backtest.data
# end of quarter
target.now = dts[89]
assert algo(target)
# new quarter
target.now = dts[90]
assert not algo(target)
dts = pd.DatetimeIndex([datetime(2016, 1, 3), datetime(2017, 1, 8), datetime(2018, 1, 7)])
data = pd.DataFrame(index=dts, columns=['c1', 'c2'], data=100)
# adds the initial day
backtest = bt.Backtest(
bt.Strategy('', [algo]),
data
)
target.data = backtest.data
# check next year
target.now = dts[1]
assert algo(target)
def test_select_randomly():
s = bt.Strategy('s')
dts = pd.date_range('2010-01-01', periods=3)
data = pd.DataFrame(index=dts, columns=['c1', 'c2', 'c3'], data=100.)
data['c1'][dts[0]] = np.nan
data['c2'][dts[0]] = 95
data['c3'][dts[0]] = -5
s.setup(data)
s.update(dts[0])
algo = algos.SelectRandomly(n=1)
assert algo(s)
assert s.temp.pop('selected') == ['c2']
random.seed(1000)
algo = algos.SelectRandomly(n=1, include_negative=True)
assert algo(s)
assert s.temp.pop('selected') == ['c3']
random.seed(1009)
algo = algos.SelectRandomly(n=1, include_no_data=True)
assert algo(s)
assert s.temp.pop('selected') == ['c1']
random.seed(1009)
# If selected already set, it will further filter it
s.temp['selected'] = ['c2']
algo = algos.SelectRandomly(n=1, include_no_data=True)
assert algo(s)
assert s.temp.pop('selected') == ['c2']
def test_rebalance_with_commissions():
algo = algos.Rebalance()
s = bt.Strategy('s')
s.set_commissions(lambda q, p: 1)
dts = pd.date_range('2010-01-01', periods=3)
data = pd.DataFrame(index=dts, columns=['c1', 'c2'], data=100)
s.setup(data)
s.adjust(1000)
s.update(dts[0])
s.temp['weights'] = {'c1': 1}
assert algo(s)
assert s.value == 999
assert s.capital == 99
c1 = s['c1']
assert c1.value == 900
assert c1.position == 9
assert c1.weight == 900 / 999.
s.temp['weights'] = {'c2': 1}
assert algo(s)
assert s.value == 997
assert s.capital == 97
c2 = s['c2']
assert c1.value == 0
assert c1.position == 0
assert c1.weight == 0
assert c2.value == 900
assert c2.position == 9
assert c2.weight == 900. / 997
def test_rebalance():
algo = algos.Rebalance()
s = bt.Strategy('s')
dts = pd.date_range('2010-01-01', periods=3)
data = pd.DataFrame(index=dts, columns=['c1', 'c2'], data=100)
s.setup(data)
s.adjust(1000)
s.update(dts[0])
s.temp['weights'] = {'c1': 1}
assert algo(s)
assert s.value == 1000
assert s.capital == 0
c1 = s['c1']
assert c1.value == 1000
assert c1.position == 10
assert c1.weight == 1.
s.temp['weights'] = {'c2': 1}
assert algo(s)
assert s.value == 1000
assert s.capital == 0
c2 = s['c2']
assert c1.value == 0
assert c1.position == 0
assert c1.weight == 0
assert c2.value == 1000
assert c2.position == 10
assert c2.weight == 1.
def test_run_if_out_of_bounds():
algo = algos.RunIfOutOfBounds(0.5)
dts = pd.date_range('2010-01-01', periods=3)
s = bt.Strategy('s')
data = pd.DataFrame(index=dts, columns=['c1', 'c2'], data=100)
s.setup(data)
s.temp['selected'] = ['c1', 'c2']
s.temp['weights'] = {'c1': .5, 'c2':.5}
s.update(dts[0])
s.children['c1'] = bt.core.SecurityBase('c1')
s.children['c2'] = bt.core.SecurityBase('c2')
s.children['c1']._weight = 0.5
s.children['c2']._weight = 0.5
assert not algo(s)
s.children['c1']._weight = 0.25
s.children['c2']._weight = 0.75
assert not algo(s)
s.children['c1']._weight = 0.24
s.children['c2']._weight = 0.76
assert algo(s)
s.children['c1']._weight = 0.75
s.children['c2']._weight = 0.25
assert not algo(s)
s.children['c1']._weight = 0.76
s.children['c2']._weight = 0.24
assert algo(s)
def test_limit_weights():
s = bt.Strategy('s')
dts = pd.date_range('2010-01-01', periods=3)
data = pd.DataFrame(index=dts, columns=['c1', 'c2'], data=100.)
s.setup(data)
s.temp['weights'] = {'c1': 0.6, 'c2':0.2, 'c3':0.2}
algo = algos.LimitWeights(0.5)
assert algo(s)
w = s.temp['weights']
assert w['c1'] == 0.5
assert w['c2'] == 0.25
assert w['c3'] == 0.25
algo = algos.LimitWeights(0.3)
assert algo(s)
w = s.temp['weights']
assert w == {}
s.temp['weights'] = {'c1': 0.4, 'c2':0.3, 'c3':0.3}
algo = algos.LimitWeights(0.5)
assert algo(s)
w = s.temp['weights']
assert w['c1'] == 0.4
assert w['c2'] == 0.3
assert w['c3'] == 0.3
def main():
days = 5
change = .02
with open('ticker_sectors.data', 'rb') as f:
tickerSectors = pickle.load(f)
companies = tickerSectors[0]
companyList = 'aos'
for i in range(1, 10):
companyList = companyList + ',' + companies[i].lower()
print(companyList)
data = bt.get(companyList, start='2014-01-01')
print(data)
weights = getPredictions(days, change)
print(weights)
s = bt.Strategy('s1', [
bt.algos.RunWeekly(),
bt.algos.SelectAll(),
bt.algos.WeighTarget(weights),
bt.algos.Rebalance()
])
test = bt.Backtest(s, data)
res = bt.run(test)
res.plot()
res.display()
print("GOOD")
def SMA(data):
sma = data.rolling(50).mean()
plot = bt.merge(data, sma).plot(figsize=(15, 5))
plt.savefig("sma.png")
# 建立策略
s = bt.Strategy("above50sma",
[SelectWhere(data > sma),
bt.algos.WeighEqually(),
bt.algos.Rebalance()
])
# 建立回测
t = bt.Backtest(s, data)
# 执行回测
res = bt.run(t)
# 输出结果
res.display()
res.plot()
plt.savefig("sma_result.png")
# 多种策略的测试
sma10 = above_sma(data, sma_per = 10, name = "sma10")
sma20 = above_sma(data, sma_per = 10, name = "sma20")
sma40 = above_sma(data, sma_per = 10, name = "sma40")
base_line = baseTest(data)
# 一起运行回测
res2 = bt.run(sma10, sma20, sma40, base_line)
# 输出结果
res2.display()
res2.plot()
plt.savefig("sma.png")
plt.savefig("multi_sma_result.png")
def SMA_cross(data):
sma50 = data.rolling(50).mean()
sma200 = data.rolling(200).mean()
tw = sma200.copy()
tw[sma50 > sma200] = 1.0
tw[sma50 <= sma200] = -1.0
tw[sma200.isnull()] = 0.0
tmp = bt.merge(tw, data, sma50, sma200)
tmp.columns = ["tw", "price", "sma50", "sma200"]
# tmp.columns = ['tw', 'price', 'sma50', 'sma200']
ax = tmp.plot(figsize = (15, 5), secondary_y = ["tw"])
plt.savefig("smacross.png")
ma_cross = bt.Strategy("ma_cross",
[WeighTarget(tw),
bt.algos.Rebalance()
])
t = bt.Backtest(ma_cross, data)
res = bt.run(t)
res.display()
res.plot()
plt.savefig("smacross_res")
def run():
df_price, df_thred = transfer()
signal = df_thred > 0.7
for col in range(signal.shape[1]):
eng = 0
for i in range(signal.shape[0]):
if signal.iloc[i, col]:
eng = 4
elif eng > 0:
signal.iloc[i, col] = True
eng -= 1
else:
pass
# first we create the Strategy
s = bt.Strategy('above50sma', [SelectWhere(signal),
bt.algos.WeighEqually(),
bt.algos.Rebalance()])
# now we create the Backtest
t = bt.Backtest(s, df_price, initial_capital=9000)
# and let's run it!
res = bt.run(t)
res.plot('d')
ser = res._get_series('d').rebase()
plot = ser.plot()
fig = plot.get_figure()
fig.savefig(os.path.join(root, "report", "backtest.png"))
def main():
'''entry point'''
# Get Test Data with all fields
symbol_list = ['BTC', 'ETH']
history = coinrepo.get_coinhistory(symbol_list)
history = history.set_index('Date')
# Pivot to have only price as timeseries
pricehistory = history.pivot(columns='Symbol')['Price']
# Create the strategy
s = bt.Strategy('s1', [
bt.algos.RunMonthly(),
bt.algos.SelectAll(),
bt.algos.WeighEqually(),
bt.algos.Rebalance()
])
# create a backtest and run it
test = bt.Backtest(s, pricehistory)
res = bt.run(test)
res.display()
# Save figures
plot = pricehistory.plot(figsize=(15, 5))
fig = plot.get_figure()
fig.savefig("price.png")
plot1 = res.plot_weights(figsize=(15, 5))
fig1 = plot1.get_figure()
fig1.savefig("bt_rest.png")
def test_select_types():
c1 = bt.Security('c1')
c2 = bt.CouponPayingSecurity('c2')
c3 = bt.HedgeSecurity('c3')
c4 = bt.CouponPayingHedgeSecurity('c4')
c5 = bt.FixedIncomeSecurity('c5')
s = bt.Strategy('p', children = [c1, c2, c3, c4, c5])
dts = pd.date_range('2010-01-01', periods=3)
data = pd.DataFrame(index=dts, columns=['c1', 'c2', 'c3', 'c4', 'c5'], data=100.)
coupons = pd.DataFrame(index=dts, columns=['c2', 'c4'], data=0.)
s.setup(data, coupons = coupons)
i = 0
s.update(dts[i])
algo = algos.SelectTypes(include_types=(bt.Security, bt.HedgeSecurity), exclude_types=())
assert algo(s)
assert set(s.temp.pop('selected')) == set(['c1', 'c3'])
algo = algos.SelectTypes(include_types=(bt.core.SecurityBase,), exclude_types=(bt.CouponPayingSecurity,))
assert algo(s)
assert set(s.temp.pop('selected')) == set(['c1', 'c3', 'c5'])
s.temp['selected'] = ['c1', 'c2', 'c3']
algo = algos.SelectTypes(include_types=(bt.core.SecurityBase,))
assert algo(s)
assert set(s.temp.pop('selected')) == set(['c1', 'c2', 'c3'])
def run():
""" Run the code that illustrates the pairs trading strategy """
data = make_data()
# Define the "entry" strategy of the trade. In this case, we give each asset unit weight and trade it
trade_entry = bt.AlgoStack( bt.algos.RunOnce(), WeighPair(1.), bt.algos.Rebalance() )
# Define the "exit" strategy of the trade. Here we exit when we cross either an upper/lower
# threshold on the price of the strategy, or hold it for a fixed length of time.
trade_exit = bt.AlgoStack(
bt.algos.Or( [PriceCompare( 96., is_greater=False ),
PriceCompare( 104., is_greater=True),
bt.algos.RunAfterDays( 5 ) ] ),
ClosePositions()
)
# Combine the entry, exit and debug algos for each trade
trade_algos = [ bt.algos.Or( [ trade_entry, trade_exit, DebugTradeLevel() ] )]
# Define the strategy for the master portfolio.
strategy_algos = [
PairsSignal( threshold = 4., indicator_name = 'my_indicator' ),
SetupPairsTrades( trade_algos ),
SizePairsTrades( pct_of_capital = 0.2 ),
DebugPortfolioLevel()
]
# Build and run the strategy
strategy = bt.Strategy( 'PairsStrategy', strategy_algos )
test = bt.Backtest( strategy, data, additional_data={'my_indicator':data} )
out = bt.run( test )
print(out.stats)
return out
def test_turnover():
dts = pd.date_range('2010-01-01', periods=5)
data = pd.DataFrame(index=dts, columns=['a', 'b'], data=100)
data['a'][dts[1]] = 105
data['b'][dts[1]] = 95
data['a'][dts[2]] = 110
data['b'][dts[2]] = 90
data['a'][dts[3]] = 115
data['b'][dts[3]] = 85
s = bt.Strategy('s', [bt.algos.SelectAll(),
bt.algos.WeighEqually(),
bt.algos.Rebalance()])
t = bt.Backtest(s, data, commissions=lambda x, y: 0, progress_bar=False)
res = bt.run(t)
t = res.backtests['s']
# these numbers were (tediously) calculated in excel
assert np.allclose(t.turnover[dts[0]], 0. / 1000000)
assert np.allclose(t.turnover[dts[1]], 24985. / 1000000)
assert np.allclose(t.turnover[dts[2]], 24970. / 997490)
assert np.allclose(t.turnover[dts[3]], 25160. / 992455)
assert np.allclose(t.turnover[dts[4]], 76100. / 1015285)
def test_select_where():
s = bt.Strategy('s')
dts = pd.date_range('2010-01-01', periods=3)
data = pd.DataFrame(index=dts, columns=['c1', 'c2'], data=100.)
where = pd.DataFrame(index=dts, columns=['c1', 'c2'], data=True)
where.loc[ dts[1] ] = False
where['c1'].loc[ dts[2] ] = False
algo = algos.SelectWhere(where)
s.setup(data)
s.update(dts[0])
assert algo(s)
selected = s.temp['selected']
assert len(selected) == 2
assert 'c1' in selected
assert 'c2' in selected
s.update(dts[1])
assert algo(s)
assert s.temp['selected'] == []
s.update(dts[2])
assert algo(s)
assert s.temp['selected'] == ['c2']
def combine_backtests(backtests):
return bt.Strategy('{}'.format([b.name for b in backtests]), [
bt.algos.RunOnce(),
bt.algos.SelectAll(),
bt.algos.WeighEqually(),
bt.algos.Rebalance()
], backtests)
def get_benchmark_bt():
return bt.Strategy('benchmark', [
bt.algos.RunOnce(),
bt.algos.SelectAll(),
bt.algos.WeighEqually(),
bt.algos.Rebalance()
])
def test_weigh_mean_var(mock_mv):
algo = algos.WeighMeanVar(lookback=pd.DateOffset(days=5))
mock_mv.return_value = pd.Series({'c1': 0.3, 'c2': 0.7})
s = bt.Strategy('s')
dts = pd.date_range('2010-01-01', periods=5)
data = pd.DataFrame(index=dts, columns=['c1', 'c2'], data=100.)
s.setup(data)
s.update(dts[4])
s.temp['selected'] = ['c1', 'c2']
assert algo(s)
assert mock_mv.called
rets = mock_mv.call_args[0][0]
assert len(rets) == 4
assert 'c1' in rets
assert 'c2' in rets
weights = s.temp['weights']
assert len(weights) == 2
assert weights['c1'] == 0.3
assert weights['c2'] == 0.7
def test_30_min_data():
names = ['foo']
dates = pd.date_range(start='2017-01-01', end='2017-12-31', freq='30min')
n = len(dates)
rdf = pd.DataFrame(np.zeros((n, len(names))), index=dates, columns=names)
np.random.seed(1)
rdf[names[0]] = np.random.normal(loc=0.1 / n,
scale=0.2 / np.sqrt(n),
size=n)
pdf = 100 * np.cumprod(1 + rdf)
sma50 = pdf.rolling(50).mean()
sma200 = pdf.rolling(200).mean()
tw = sma200.copy()
tw[sma50 > sma200] = 1.0
tw[sma50 <= sma200] = -1.0
tw[sma200.isnull()] = 0.0
ma_cross = bt.Strategy('ma_cross',
[bt.algos.WeighTarget(tw),
bt.algos.Rebalance()])
t = bt.Backtest(ma_cross, pdf, progress_bar=False)
res = bt.run(t)
wait = 1
def test_select_all():
algo = algos.SelectAll()
s = bt.Strategy('s')
dts = pd.date_range('2010-01-01', periods=3)
data = pd.DataFrame(index=dts, columns=['c1', 'c2'], data=100.)
data['c1'][dts[1]] = np.nan
data['c2'][dts[1]] = 95
s.setup(data)
s.update(dts[0])
assert algo(s)
selected = s.temp['selected']
assert len(selected) == 2
assert 'c1' in selected
assert 'c2' in selected
# make sure don't keep nan
s.update(dts[1])
assert algo(s)
selected = s.temp['selected']
assert len(selected) == 1
assert 'c2' in selected
# if specify include_no_data then 2
algo = algos.SelectAll(include_no_data=True)
assert algo(s)
selected = s.temp['selected']
assert len(selected) == 2
assert 'c1' in selected
assert 'c2' in selected
def test_weigh_inv_vol():
algo = algos.WeighInvVol(lookback=pd.DateOffset(days=5))
s = bt.Strategy('s')
dts = pd.date_range('2010-01-01', periods=5)
data = pd.DataFrame(index=dts, columns=['c1', 'c2'], data=100.)
# high vol c1
data['c1'].ix[dts[1]] = 105
data['c1'].ix[dts[2]] = 95
data['c1'].ix[dts[3]] = 105
data['c1'].ix[dts[4]] = 95
# low vol c2
data['c2'].ix[dts[1]] = 100.1
data['c2'].ix[dts[2]] = 99.9
data['c2'].ix[dts[3]] = 100.1
data['c2'].ix[dts[4]] = 99.9
s.setup(data)
s.update(dts[4])
s.temp['selected'] = ['c1', 'c2']
assert algo(s)
weights = s.temp['weights']
assert len(weights) == 2
assert weights['c2'] > weights['c1']
aae(weights['c1'], 0.020, 3)
aae(weights['c2'], 0.980, 3)
def buy_and_hold(ticker: str, start: Union[str, datetime], name: str):
"""
Generates a backtest object for the given ticker
Parameters
----------
ticker: str
Stock to test
start: Union[str, datetime]
Backtest start date. Can be either string or datetime
name:
Name of the backtest (for labeling purposes)
Returns
-------
bt.Backtest object for buy and hold strategy
"""
prices = bt.get(ticker, start=start)
bt_strategy = bt.Strategy(
name,
[
bt.algos.RunOnce(),
bt.algos.SelectAll(),
bt.algos.WeighEqually(),
bt.algos.Rebalance(),
],
)
return bt.Backtest(bt_strategy, prices)
def test_select_these():
s = bt.Strategy('s')
dts = pd.date_range('2010-01-01', periods=3)
data = pd.DataFrame(index=dts, columns=['c1', 'c2'], data=100.)
data['c1'][dts[1]] = np.nan
data['c2'][dts[1]] = 95
data['c1'][dts[2]] = -5
s.setup(data)
s.update(dts[0])
algo = algos.SelectThese( ['c1', 'c2'])
assert algo(s)
selected = s.temp['selected']
assert len(selected) == 2
assert 'c1' in selected
assert 'c2' in selected
algo = algos.SelectThese( ['c1'])
assert algo(s)
selected = s.temp['selected']
assert len(selected) == 1
assert 'c1' in selected
# make sure don't keep nan
s.update(dts[1])
algo = algos.SelectThese( ['c1', 'c2'])
assert algo(s)
selected = s.temp['selected']
assert len(selected) == 1
assert 'c2' in selected
# if specify include_no_data then 2
algo2 = algos.SelectThese( ['c1', 'c2'], include_no_data=True)
assert algo2(s)
selected = s.temp['selected']
assert len(selected) == 2
assert 'c1' in selected
assert 'c2' in selected
# behavior on negative prices
s.update(dts[2])
assert algo(s)
selected = s.temp['selected']
assert len(selected) == 1
assert 'c2' in selected
algo3 = algos.SelectThese(['c1', 'c2'], include_negative=True)
assert algo3(s)
selected = s.temp['selected']
assert len(selected) == 2
assert 'c1' in selected
assert 'c2' in selected
def CreateStrategy(name):
strategy = bt.Strategy(name,
[bt.algos.RunWeekly(),
bt.algos.SelectAll(),
bt.algos.WeighEqually(),
bt.algos.Rebalance()
])
return strategy
def above_sma(data, sma_per = 50, name = "above_sma"):
sma = data.rolling(sma_per).mean()
s = bt.Strategy(name,
[bt.algos.SelectWhere(data > sma),
bt.algos.WeighEqually(),
bt.algos.Rebalance()
])
return bt.Backtest(s, data)
def baseTest(data):
s = bt.Strategy("base_line",
[bt.algos.RunOnce(),
bt.algos.SelectAll(),
bt.algos.WeighEqually(),
bt.algos.Rebalance()
])
return bt.Backtest(s, data)
