def test_rolling_std_1obs(self):
result = mom.rolling_std(np.array([1.0, 2.0, 3.0, 4.0, 5.0]), 1, min_periods=1)
expected = np.zeros(5)
assert_almost_equal(result, expected)
result = mom.rolling_std(np.array([np.nan, np.nan, 3.0, 4.0, 5.0]), 3, min_periods=2)
self.assertTrue(np.isnan(result[2]))
def findEvents(symbols, startday,endday,verbose=False):
timeofday=dt.timedelta(hours=16)
timestamps = du.getNYSEdays(startday,endday,timeofday)
dataobj = da.DataAccess('Norgate')
if verbose:
print __name__ + " reading data"
adjclose = dataobj.get_data(timestamps, symbols, closefield)
adjclose = (adjclose.fillna()).fillna(method='backfill')
adjcloseSPY = dataobj.get_data(timestamps, ['SPY'], closefield)
adjcloseSPY = (adjcloseSPY.fillna()).fillna(method='backfill')
if verbose:
print __name__ + " finding events"
# for symbol in symbols:
# close[symbol][close[symbol]>= 1.0] = np.NAN
# for i in range(1,len(close[symbol])):
# if np.isnan(close[symbol][i-1]) and close[symbol][i] < 1.0 :#(i-1)th was > $1, and (i)th is <$1
# close[symbol][i] = 1.0 #overwriting the price by the bit
# close[symbol][close[symbol]< 1.0] = np.NAN
#print adjclose
# Get the 20 day moving avg and moving stddev
movavg = pa.rolling_mean(adjclose,20,min_periods=20)
movavgSPY = pa.rolling_mean(adjcloseSPY,20,min_periods=20)
movstddev = pa.rolling_std(adjclose, 20, min_periods=20)
movstddevSPY = pa.rolling_std(adjcloseSPY, 20, min_periods=20)
upperband = movavg + 2*movstddev
upperbandSPY = movavgSPY + 2*movstddevSPY
lowerband = movavg - 2*movstddev
lowerbandSPY = movavgSPY - 2*movstddevSPY
# Compute the bollinger %b indicator for all stocks
normalizedindicator = 2*(adjclose - movavg)/(upperband - lowerband)
#print normalizedindicator
normalizedindicatorSPY = 2*(adjcloseSPY - movavgSPY)/(upperbandSPY - lowerbandSPY)
#print normalizedindicatorSPY
#bandwidth = (upperband - lowerband)/movavg
#print bandwidth
#print upperband
# Compute the event matrix as follows:
# Set periods of low volatility to 1
# In from the period of low volatility to the period of say, 15 days, following low volatility
# if the stock price breaks above the upper band, there is a surge. this is a positive event. Set this event to 2
# Finally, set all events other than 2 to NaN. Then, set all 2's to 1
eventMatrix = adjclose.copy()
for symbol in symbols:
for row in range(len(adjclose[:][symbol])):
eventMatrix[symbol][row] = np.NAN
if normalizedindicator[symbol][row] - normalizedindicatorSPY['SPY'][row] >= 0.5:
eventMatrix[symbol][row] = 1
return eventMatrix
def test_rolling_std_1obs(self):
result = mom.rolling_std(np.array([1.,2.,3.,4.,5.]),
1, min_periods=1)
expected = np.zeros(5)
assert_almost_equal(result, expected)
result = mom.rolling_std(np.array([np.nan,np.nan,3.,4.,5.]),
3, min_periods=2)
self.assert_(np.isnan(result[2]))
def forecast_mean_sd(self, returns):
mean_fcst = pd.Panel(
{"Forecast": rolling_mean(returns.data, self.window)})
sd_fcst = pd.Panel(
{"Forecast": rolling_std(returns.data, self.window)})
return (mean_fcst, sd_fcst)
def findEvents(symbols, startday,endday,verbose=False):
timeofday=dt.timedelta(hours=16)
timestamps = du.getNYSEdays(startday,endday,timeofday)
dataobj = da.DataAccess('Norgate')
if verbose:
print __name__ + " reading data"
adjclose = dataobj.get_data(timestamps, symbols, closefield)
adjclose = (adjclose.fillna()).fillna(method='backfill')
if verbose:
print __name__ + " finding events"
# for symbol in symbols:
# close[symbol][close[symbol]>= 1.0] = np.NAN
# for i in range(1,len(close[symbol])):
# if np.isnan(close[symbol][i-1]) and close[symbol][i] < 1.0 :#(i-1)th was > $1, and (i)th is <$1
# close[symbol][i] = 1.0 #overwriting the price by the bit
# close[symbol][close[symbol]< 1.0] = np.NAN
#print adjclose
# Get the 20 day moving avg and moving stddev
movavg = pa.rolling_mean(adjclose,20,min_periods=20)
movstddev = pa.rolling_std(adjclose, 20, min_periods=20)
# Compute the upper and lower bollinger bands
upperband = movavg + 2*movstddev
lowerband = movavg - 2*movstddev
#bandwidth = (upperband - lowerband)/movavg
#print bandwidth
#print upperband
# Compute the event matrix as follows:
# Set periods of low volatility to 1
# In from the period of low volatility to the period of say, 15 days, following low volatility
# if the stock price breaks above the upper band, there is a surge. this is a positive event. Set this event to 2
# Finally, set all events other than 2 to NaN. Then, set all 2's to 1
lookaheadperiod = 15
eventMatrix = adjclose.copy()
for symbol in symbols:
for row in range(len(adjclose[:][symbol])):
eventMatrix[symbol][row] = np.NAN
if upperband[symbol][row] > 0 and lowerband[symbol][row] > 0 and movavg[symbol][row] > 0:
if (upperband[symbol][row] - lowerband[symbol][row])/movavg[symbol][row] < 0.10:
eventMatrix[symbol][row] = 1
else:
currow = row - 1
numOnes = 0
while currow > row - lookaheadperiod and currow >= 0:
if eventMatrix[symbol][currow] != 1:
break
if eventMatrix[symbol][currow] == 1 and adjclose[symbol][row] > upperband[symbol][row]:
numOnes = numOnes + 1
currow = currow - 1
if numOnes >= 5:
eventMatrix[symbol][row] = 2
eventMatrix[symbol][eventMatrix[symbol]!= 2] = np.NAN
eventMatrix[symbol][eventMatrix[symbol]== 2] = 1
return eventMatrix
def bbands(s, n=20, ndev=2):
mavg = moments.rolling_mean(s, n)
mstd = moments.rolling_std(s, n)
hband = mavg + ndev * mstd
lband = mavg - ndev * mstd
return DataFrame(dict(ma=mavg, lband=lband, hband=hband))
def bbands(s, n=20, ndev=2):
mavg = moments.rolling_mean(s, n)
mstd = moments.rolling_std(s, n)
hband = mavg + ndev*mstd
lband = mavg - ndev*mstd
return DataFrame(dict(ma=mavg, lband=lband, hband=hband))
def test_rolling_functions_window_non_shrinkage(self):
# GH 7764
s = Series(range(4))
s_expected = Series(np.nan, index=s.index)
df = DataFrame([[1, 5], [3, 2], [3, 9], [-1, 0]], columns=['A', 'B'])
df_expected = DataFrame(np.nan, index=df.index, columns=df.columns)
df_expected_panel = Panel(items=df.index,
major_axis=df.columns,
minor_axis=df.columns)
functions = [
lambda x: mom.rolling_cov(
x, x, pairwise=False, window=10, min_periods=5),
lambda x: mom.rolling_corr(
x, x, pairwise=False, window=10, min_periods=5),
lambda x: mom.rolling_max(x, window=10, min_periods=5),
lambda x: mom.rolling_min(x, window=10, min_periods=5),
lambda x: mom.rolling_sum(x, window=10, min_periods=5),
lambda x: mom.rolling_mean(x, window=10, min_periods=5),
lambda x: mom.rolling_std(x, window=10, min_periods=5),
lambda x: mom.rolling_var(x, window=10, min_periods=5),
lambda x: mom.rolling_skew(x, window=10, min_periods=5),
lambda x: mom.rolling_kurt(x, window=10, min_periods=5),
lambda x: mom.rolling_quantile(
x, quantile=0.5, window=10, min_periods=5),
lambda x: mom.rolling_median(x, window=10, min_periods=5),
lambda x: mom.rolling_apply(x, func=sum, window=10, min_periods=5),
lambda x: mom.rolling_window(
x, win_type='boxcar', window=10, min_periods=5),
]
for f in functions:
try:
s_result = f(s)
assert_series_equal(s_result, s_expected)
df_result = f(df)
assert_frame_equal(df_result, df_expected)
except (ImportError):
# scipy needed for rolling_window
continue
functions = [
lambda x: mom.rolling_cov(
x, x, pairwise=True, window=10, min_periods=5),
lambda x: mom.rolling_corr(
x, x, pairwise=True, window=10, min_periods=5),
# rolling_corr_pairwise is depracated, so the following line should be deleted
# when rolling_corr_pairwise is removed.
lambda x: mom.rolling_corr_pairwise(x, x, window=10, min_periods=5
),
]
for f in functions:
df_result_panel = f(df)
assert_panel_equal(df_result_panel, df_expected_panel)
def before_trading_start(context, data):
# Pulling VIX
vix = pd.read_csv(
'http://www.cboe.com/publish/scheduledtask/mktdata/datahouse/vixcurrent.csv'
)
vix.columns = ['Date', 'Open', 'High', 'Low', 'Close']
vix = vix[1:]
vix['Date'] = pd.to_datetime(vix['Date'])
vix = vix.set_index(pd.DatetimeIndex(vix['Date']))
# Getting VIX last close
vx = float(vix[-1:].Close[0])
# Pulling Futures Data
vc = pd.read_csv('http://cfe.cboe.com/market-data/futures-settlements')
vc.columns = ['Symbol', 'settle']
vc['expiry'] = pd.to_datetime(vc['Symbol'].str.split(' ').str.get(1))
vc['name'] = vc['Symbol'].str.split(' ').str.get(0)
vc = vc[vc['name'] == 'VX'][['Symbol', 'settle', 'expiry']]
vc = vc[vc['expiry'] > dt.datetime.today().date()]
vc = vc.reset_index()
# Getting Settlements of V1 and V2
v1 = vc['settle'][0]
v2 = vc['settle'][1]
spot_wgt = maturities(context, data)
front_wgt = 1 - spot_wgt
context.threshold = 0.95
# Creating ratio from weighting
sf1_ratio = vx / v1
f1f2_ratio = v1 / v2
#print"Front weight: %.6f"%spot_wgt
#print "V1: %.4f" %data.current('v1','price')
context.last_ratio = spot_wgt * sf1_ratio + front_wgt * f1f2_ratio
#print "Contango: %.6f"%context.last_ratio
context.signal = (context.last_ratio <
context.threshold) and (vx < context.max_vix)
# context.open_price = data.current(context.vxx,'close')
# Pulling spy_hist
request_data(historyData=[(context.spy, '1 day', '22 D')])
spy_hist = data[context.spy].hist['1 day']['close']
log_returns = np.log(spy_hist) - np.log(spy_hist.shift(1))
daily_vol = st.rolling_std(log_returns, context.augen_period, ddof=1)
daily_vol_dollar = (np.exp(daily_vol) - 1) * spy_hist
context.dollar_vol = daily_vol_dollar.ix[-1]
context.spy_last_close = data.current(context.spy, 'close')
context.stop_loss_initializer = False
context.stop_loss_not_triggered = True
context.buyback_not_triggered = True
def before_trading_start(context, data):
spot_wgt = maturities(context, data)
front_wgt = 1 - spot_wgt
print "Front weight: %.4f" % spot_wgt
# Logging Key Notes
settle = data.current('vf', 'settle')
contango = data.current('vf', 'contango')
vix_close = float(data.current('vix', 'Close'))
print "Settlement: " + str(settle) + " Contango: " + str(
contango) + " VIX Close: " + str(vix_close)
# Calculating Ratio for VIX/F1
vixf1 = vix_close / data.current('vf', 'settle')
context.xiv_ratio = spot_wgt * vixf1 + front_wgt * contango
context.xiv_signal = (context.xiv_ratio < context.xiv_threshold) and (
vix_close < context.max_vix)
log.info("Normalized Ratio: %.2f" % context.xiv_ratio)
print "Normalized Ratio: " + str(context.xiv_ratio)
# XIV Stop Loss Triggers Initiation
context.stop_loss_initializer = False
context.stop_loss_not_triggered = True
context.buyback_not_triggered = True
# XIV Buyback Triggers
spy_hist = data.history(context.spy, 'close', context.augen_period + 1,
'1d')
log_returns = np.log(spy_hist) - np.log(spy_hist.shift(1))
daily_vol = st.rolling_std(log_returns, context.augen_period, ddof=1)
daily_vol_dollar = daily_vol * spy_hist
context.dollar_vol = daily_vol_dollar.ix[-1]
# Calculating SPY SMA 25-220
spy_hist = data.history(context.spy, 'close', context.spy_long, '1d')
context.spy_long_sma = spy_hist.mean()
context.spy_shrt_sma = spy_hist.tail(context.spy_short).mean()
context.spy_signal = context.spy_shrt_sma > context.spy_long_sma
context.last_spy_price = data.current(context.spy, 'close')
log.info(
"Last SPY Close: %.2f SPY_Long: %.2f SPY_Short: %.2f" %
(context.last_spy_price, context.spy_long_sma, context.spy_shrt_sma))
# Calculating TLT SMA 35-70
tlt_hist = data.history(context.tlt, 'close', context.tlt_long, '1d')
context.tlt_long_sma = tlt_hist.mean()
context.tlt_shrt_sma = tlt_hist.tail(context.tlt_short).mean()
context.tlt_signal = context.tlt_shrt_sma > context.tlt_long_sma
last_tlt_price = data.current(context.tlt, 'close')
log.info("Last TLT Close: %.2f TLT_Long: %.2f TLT_Short: %.2f" %
(last_tlt_price, context.tlt_long_sma, context.tlt_shrt_sma))
def test_rolling_std_neg_sqrt(self):
# unit test from Bottleneck
# Test move_nanstd for neg sqrt.
a = np.array([0.0011448196318903589,
0.00028718669878572767,
0.00028718669878572767,
0.00028718669878572767,
0.00028718669878572767])
b = mom.rolling_std(a, window=3)
self.assertTrue(np.isfinite(b[2:]).all())
b = mom.ewmstd(a, span=3)
self.assertTrue(np.isfinite(b[2:]).all())
def test_rolling_std_neg_sqrt(self):
# unit test from Bottleneck
# Test move_nanstd for neg sqrt.
a = np.array([
0.0011448196318903589, 0.00028718669878572767,
0.00028718669878572767, 0.00028718669878572767,
0.00028718669878572767
])
b = mom.rolling_std(a, window=3)
self.assert_(np.isfinite(b[2:]).all())
b = mom.ewmstd(a, span=3)
self.assert_(np.isfinite(b[2:]).all())
def bollinger_bands(d_data, ldt_timestamps, ls_symbols=None, lookback = 20,
width = 1, plot_boll=False, ls_symbols_plot=None):
if ls_symbols == None:
ls_symbols = list(d_data.keys())
df_close = copy.deepcopy(d_data)
df_close = df_close[ls_symbols]
df_mean_bollinger = copy.deepcopy(df_close) * np.NAN
df_std_bollinger = copy.deepcopy(df_close) *np.NAN
df_index_bollinger = copy.deepcopy(df_close) *np.NAN
for c_sym in ls_symbols:
df_mean_bollinger[c_sym] = pd_stats.rolling_mean(df_close[c_sym],lookback)
df_std_bollinger[c_sym] = width*pd_stats.rolling_std(df_close[c_sym],lookback)
df_index_bollinger[c_sym] = (df_close[c_sym] -
df_mean_bollinger[c_sym])/df_std_bollinger[c_sym]
if plot_boll:
if ls_symbols_plot == None:
if len(ls_symbols) <= 5:
ls_symbols_plot = ls_symbols
else:
ls_symbols_plot = ls_symbols[0:5]
fig = []
for c_sym in ls_symbols_plot:
fig.append(plt.figure())
ax = fig[-1].add_subplot(211)
ax.plot(ldt_timestamps,df_close[c_sym],'k')
ax.plot(ldt_timestamps,df_mean_bollinger[c_sym],'b')
ax.plot(ldt_timestamps,df_mean_bollinger[c_sym] - df_std_bollinger[c_sym],'b--')
ax.plot(ldt_timestamps,df_mean_bollinger[c_sym] + df_std_bollinger[c_sym],'b--')
ax.set_xlim((ldt_timestamps[0],ldt_timestamps[-1]))
ax.get_xaxis().set_visible(False)
ax.set_ylabel('Adj. Close')
ax = fig[-1].add_subplot(212)
ax.plot(ldt_timestamps, df_index_bollinger)
ax.plot([ldt_timestamps[0], ldt_timestamps[-1]],
[1, 1])
ax.plot([ldt_timestamps[0], ldt_timestamps[-1]],
[-1, -1])
ax.set_xlim((ldt_timestamps[0],ldt_timestamps[-1]))
ax.set_xlabel('Time')
ax.set_ylabel('Bollinger Val.')
plt.show()
return df_index_bollinger
def compute_bollinger_band(basic_portfolio,
period,
source='yahoo',
filename=None):
"""
Compute the bollinger band for a list of stocks.
@param basic_portfolio: A basic portfolio instance
@param period:
@param source: source to get the data
@param filename:
@return:
"""
assert isinstance(basic_portfolio, BasicPortfolio)
stock_close_prices = basic_portfolio.get_stock_close_prices(source)
basic_portfolio.print_information()
print 'Lookback period : ', period
bol_mean = ts.rolling_mean(stock_close_prices, period)
bol_std = ts.rolling_std(stock_close_prices, period)
bollinger_band_up = bol_mean + bol_std
bollinger_band_down = bol_mean - bol_std
plt.clf()
plt.plot(stock_close_prices.index, stock_close_prices.values)
plt.plot(stock_close_prices.index, bollinger_band_up)
plt.plot(stock_close_prices.index, bollinger_band_down)
plt.legend(['Stock adjusted price', 'Bollinger band', 'Bollinger band'])
plt.ylabel('Price')
plt.xlabel('Date')
if filename is not None:
plt.savefig(filename, format='pdf')
else:
plt.show()
bol_val = (stock_close_prices - bol_mean) / bol_std
val = DataFrame(bol_val,
index=stock_close_prices.index,
columns=basic_portfolio.tickers)
# print val[-5:]
val.to_csv('result/bol.csv')
# return the bollinger value
return val
def test_rolling_functions_window_non_shrinkage(self):
# GH 7764
s = Series(range(4))
s_expected = Series(np.nan, index=s.index)
df = DataFrame([[1,5], [3, 2], [3,9], [-1,0]], columns=['A','B'])
df_expected = DataFrame(np.nan, index=df.index, columns=df.columns)
df_expected_panel = Panel(items=df.index, major_axis=df.columns, minor_axis=df.columns)
functions = [lambda x: mom.rolling_cov(x, x, pairwise=False, window=10, min_periods=5),
lambda x: mom.rolling_corr(x, x, pairwise=False, window=10, min_periods=5),
lambda x: mom.rolling_max(x, window=10, min_periods=5),
lambda x: mom.rolling_min(x, window=10, min_periods=5),
lambda x: mom.rolling_sum(x, window=10, min_periods=5),
lambda x: mom.rolling_mean(x, window=10, min_periods=5),
lambda x: mom.rolling_std(x, window=10, min_periods=5),
lambda x: mom.rolling_var(x, window=10, min_periods=5),
lambda x: mom.rolling_skew(x, window=10, min_periods=5),
lambda x: mom.rolling_kurt(x, window=10, min_periods=5),
lambda x: mom.rolling_quantile(x, quantile=0.5, window=10, min_periods=5),
lambda x: mom.rolling_median(x, window=10, min_periods=5),
lambda x: mom.rolling_apply(x, func=sum, window=10, min_periods=5),
lambda x: mom.rolling_window(x, win_type='boxcar', window=10, min_periods=5),
]
for f in functions:
try:
s_result = f(s)
assert_series_equal(s_result, s_expected)
df_result = f(df)
assert_frame_equal(df_result, df_expected)
except (ImportError):
# scipy needed for rolling_window
continue
functions = [lambda x: mom.rolling_cov(x, x, pairwise=True, window=10, min_periods=5),
lambda x: mom.rolling_corr(x, x, pairwise=True, window=10, min_periods=5),
# rolling_corr_pairwise is depracated, so the following line should be deleted
# when rolling_corr_pairwise is removed.
lambda x: mom.rolling_corr_pairwise(x, x, window=10, min_periods=5),
]
for f in functions:
df_result_panel = f(df)
assert_panel_equal(df_result_panel, df_expected_panel)
def compute_bollinger_band(basic_portfolio, period, source='yahoo', filename=None):
"""
Compute the bollinger band for a list of stocks.
@param basic_portfolio: A basic portfolio instance
@param period:
@param source: source to get the data
@param filename:
@return:
"""
assert isinstance(basic_portfolio, BasicPortfolio)
stock_close_prices = basic_portfolio.get_stock_close_prices(source)
basic_portfolio.print_information()
print 'Lookback period : ', period
bol_mean = ts.rolling_mean(stock_close_prices, period)
bol_std = ts.rolling_std(stock_close_prices, period)
bollinger_band_up = bol_mean + bol_std
bollinger_band_down = bol_mean - bol_std
plt.clf()
plt.plot(stock_close_prices.index, stock_close_prices.values)
plt.plot(stock_close_prices.index, bollinger_band_up)
plt.plot(stock_close_prices.index, bollinger_band_down)
plt.legend(['Stock adjusted price', 'Bollinger band', 'Bollinger band'])
plt.ylabel('Price')
plt.xlabel('Date')
if filename is not None:
plt.savefig(filename, format='pdf')
else:
plt.show()
bol_val = (stock_close_prices - bol_mean)/bol_std
val = DataFrame(bol_val, index=stock_close_prices.index,
columns=basic_portfolio.tickers)
# print val[-5:]
val.to_csv('result/bol.csv')
# return the bollinger value
return val
def before_trading_start(context, data):
spot_wgt = maturities(context, data)
front_wgt = 1 - spot_wgt
context.threshold = 0.95
# Creating ratio from weighting
sf1_ratio = data.current('vix', 'Open') / data.current('v1', 'Open')
f1f2_ratio = data.current('v1', 'Open') / data.current('v2', 'Open')
print "Front weight: %.6f" % spot_wgt
print "V1 SOD: %.4f" % data.current('v1', 'Open')
context.last_ratio = spot_wgt * sf1_ratio + front_wgt * f1f2_ratio
print "Contango SOD: %.6f" % context.last_ratio
context.signal = (context.last_ratio < context.threshold) and (
data.current('vix', 'Open') < context.max_vix)
# Creating EOD Ratio from weighting
sf1_ratio_eod = data.current('vix', 'price') / data.current('v1', 'price')
f1f2_ratio_eod = data.current('v1', 'price') / data.current('v2', 'price')
print "V1 EOD: %.4f" % data.current('v1', 'price')
context.last_ratio_eod = spot_wgt * sf1_ratio_eod + front_wgt * f1f2_ratio_eod
print "Contango EOD: %.6f" % context.last_ratio_eod
context.signal_eod = (context.last_ratio_eod < context.threshold) and (
data.current('vix', 'price') < context.max_vix)
# context.open_price = data.current(context.vxx,'close')
spy_hist = data.history(context.spy, 'close', context.augen_period + 1,
'1d')
log_returns = np.log(spy_hist) - np.log(spy_hist.shift(1))
daily_vol = st.rolling_std(log_returns, context.augen_period, ddof=1)
daily_vol_dollar = (np.exp(daily_vol) - 1) * spy_hist
context.dollar_vol = daily_vol_dollar.ix[-1]
context.spy_last_close = data.current(context.spy, 'close')
context.stop_loss_initializer = False
context.stop_loss_not_triggered = True
context.buyback_not_triggered = True
def ComputeBollingerBands(ls_symbols, startdate, enddate, period, filename = ''):
# Get the data from local repository
d_data = GetDataLocalYahoo(startdate, enddate, ls_symbols)
print 'Symbol : ', ls_symbols
print 'Start date : ', startdate
print 'Start date : ', enddate
print 'Lookback period : ', period
df_close = d_data['close']
bol_mean = ts.rolling_mean(df_close, period)
bol_std = ts.rolling_std(df_close, period)
bolband_up = bol_mean + bol_std
bolband_dw = bol_mean - bol_std
# Plotting the prices with x-axis=timestamps
if filename is not '':
plt.clf()
plt.plot(df_close.index, df_close.values)
plt.plot(df_close.index, bolband_up)
plt.plot(df_close.index, bolband_dw)
plt.legend(['Stock adjusted price', 'Bollinger band', 'Bollinger band'])
plt.ylabel('Price')
plt.xlabel('Date')
plt.savefig(filename, format='pdf')
bol_val = (df_close - bol_mean)/bol_std
val = DataFrame(bol_val, index = df_close.index,
columns = ls_symbols)
# print val[-5:]
val.to_csv('bol.csv')
# return the bollinger value
return val
print dt.datetime.now().time(), "Read the data"
data_obj = da.DataAccess('Yahoo')
ls_symbols = data_obj.get_symbols_from_list('sp5002012')
cmp_symbols = ['SPY']
ls_keys = 'close'
ldf_data = data_obj.get_data(ldt_timestamps, ls_symbols + cmp_symbols, ls_keys)
ldf_data = ldf_data.fillna(method='ffill')
ldf_data = ldf_data.fillna(method='bfill')
ldf_data = ldf_data.fillna(1.0)
print dt.datetime.now().time(), "Calculating Bollinger's Value"
data_mean = pd.rolling_mean(ldf_data, window=20, min_periods=1)
data_std = pd.rolling_std(ldf_data, window=20, min_periods=1)
bollinger_value = {}
for s in ls_symbols + cmp_symbols:
bollinger_value[s] = (ldf_data[s][ldt_timestamps] - data_mean[s][ldt_timestamps]) / data_std[s][ldt_timestamps]
print dt.datetime.now().time(), "Finding Events"
total_count = 0
print ldt_timestamps
# f = open('workfile.csv', 'w')
# for s_sym in ls_symbols:
# print "\t", s_sym
# temp_count = 0
# for i in range(1, len(ldt_timestamps)): # range(19, len(ldt_timestamps) - 20):
# if bollinger_value[s_sym][i - 1] >= -2.0 >= bollinger_value[s_sym][i] and bollinger_value['SPY'][i] >= 1.5:
return ts_date[thisind].strftime('%Y-%m-%d')
####################################################
# Bollinger Bands with Pandas #
####################################################
# Select close price as plotting data
close_px = aapl['Close']
# Parameters for Bollinger Bands
period = 10
std = 2
# Calculation of Bollinger Bands: SMA, Upper and Lower
mavg = pa.rolling_mean(close_px, period)
mstd = pa.rolling_std(close_px, period)
uband = mavg + 2 * mstd
lband = mavg - 2 * mstd
# Excercise: Use Matplotlib to plot stock price
#close_px.plot(label='AAPL', style='k*')
#mavg.plot(label='mavg')
#uband.plot()
#lband.plot()
#plt.legend()
#plt.show()
##################################################
# Data for Candlestick Chart #
# Open, Close, High, Low #
##################################################
startday = dt.datetime(2009,1,1)
endday = dt.datetime(2010,1,1)
stock='IBM'
symbols = [stock]
timeofday=dt.timedelta(hours=16)
timestamps = du.getNYSEdays(startday,endday,timeofday)
dataobj = da.DataAccess('Norgate')
adjclose = dataobj.get_data(timestamps, symbols, "close")
adjclose = adjclose.fillna()
adjclose = adjclose.fillna(method='backfill')
# Get the 20 day moving avg and moving stddev
movavg = pa.rolling_mean(adjclose,20,min_periods=20)
movstddev = pa.rolling_std(adjclose, 20, min_periods=20)
# Compute the upper and lower bollinger bands
upperband = movavg + 2*movstddev
lowerband = movavg - 2*movstddev
# Plot the adjclose, movingavg, upper and lower bollinger bands
plt.clf()
plt.plot(adjclose.index,adjclose[stock].values)
plt.plot(adjclose.index,movavg[stock].values)
plt.plot(adjclose.index,upperband[stock].values)
plt.plot(adjclose.index,lowerband[stock].values)
plt.xlim(adjclose.index[0], adjclose.index[len(adjclose.index)-1])
plt.legend(['IBM','Moving Avg.','Upper Bollinger Band','Lower Bollinger Band'], loc='upper left')
import numpy as np
import sys
def rolling_window(a, window):
shape = a.shape[:-1] + (a.shape[-1] - window + 1, window)
strides = a.strides + (a.strides[-1], )
return np.lib.stride_tricks.as_strided(a, shape=shape, strides=strides)
start = datetime.datetime(2004, 11, 21)
stop = datetime.datetime(2014, 11, 21)
broadMarket = web.DataReader(sys.argv[1], 'yahoo', start, stop)
broadMarket = broadMarket['Close']
returns = broadMarket.pct_change()
vol5 = st.rolling_std(returns, window=5) / 5.0
vol30 = st.rolling_std(returns, window=30) / 30.0
vol60 = st.rolling_std(returns, window=60) / 60.0
vol120 = st.rolling_std(returns, window=120) / 120.0
vol240 = st.rolling_std(returns, window=240) / 240.0
for i in range(240, len(vol240) - 30):
print vol5.iloc[i], "\t", \
vol30.iloc[i], "\t", \
vol60.iloc[i], "\t", \
vol120.iloc[i], "\t", \
vol240.iloc[i], "\t", \
vol30.iloc[i+30]
#returns = np.array([broadMarket.iloc[i,3]/broadMarket.iloc[i-1,3] - 1.0 for i in range(1, len(broadMarket))])
def forecast_mean_sd(self, returns):
mean_fcst = pd.Panel({"Forecast":rolling_mean(returns.data, self.window)})
sd_fcst = pd.Panel({"Forecast":rolling_std(returns.data, self.window)})
return (mean_fcst, sd_fcst)
import matplotlib.pyplot as plt
import pandas.util.testing as t
import pandas.stats.moments as m
t.N = 500
ts = t.makeTimeSeries()
ts[::100] = 20
s = ts.cumsum()
plt.figure(figsize=(10, 5))
plt.plot(s.index, m.ewmvol(s, span=50, min_periods=1).values, color='b')
plt.plot(s.index, m.rolling_std(s, 50, min_periods=1).values, color='r')
plt.title('Exp-weighted std with shocks')
plt.legend(('Exp-weighted', 'Equal-weighted'))
f = plt.gcf()
f.autofmt_xdate()
plt.show()
plt.close('all')
print title
ax1.set_title(title)
# ax.set_xlabel('Time (h)')
# ax.set_ylabel('RMSE')
# ax.set_yscale('log')
# ax.set_xlim(0,30)
# colors = sns.color_palette("husl", 25)
# for i in range(0,25):
# ax.scatter(time_by_seed[i], error_by_seed[i], c=cm.hsv(i/25.,1), s=[30]*len(time_by_seed[i]))
# ax.scatter(time_by_seed[i], error_by_seed[i], c=[colors[i]]*len(time_by_seed[i]), s=[30]*len(time_by_seed[i]))
ax1.set_xlabel('Time (h)')
ax1.set_ylabel('RMSE')
ax1.set_xlim(-1, 30)
y_mean = stats.rolling_mean(sorted_errors, 5)
y_std = stats.rolling_std(sorted_errors, 5)
# y_upper = y_mean + 2*y_std
y_upper = stats.rolling_max(sorted_errors, 5)
# y_lower = y_mean - 2*y_std
y_lower = stats.rolling_min(sorted_errors, 5)
sorted_data = DataFrame(data=sorted_points, columns=['time', 'binned_time', 'error', 'seed'])
# sns.jointplot("binned_time", "error", sorted_data)
# ax1.scatter(sorted_binned_time, sorted_errors)
ax1.plot(sorted_time, y_mean, color="red", label="Rolling mean")
# ax1.errorbar(sorted_binned_time, sorted_errors, marker='o', ms=8, yerr=3*y_std, ls='dotted', label="Rolling mean")
ax1.legend()
ax1.fill_between(sorted_time, y_mean, y_upper, facecolor='gray', interpolate=True, alpha=0.5)
ax1.fill_between(sorted_time, y_lower, y_mean, facecolor='gray', interpolate=True, alpha=0.5)
if not os.path.isdir("plots"):
os.mkdir("plots")
#fig.savefig("plots/points.png", bbox_inches='tight')
import datetime
import pandas as pd
import numpy as np
import sys
def rolling_window(a, window):
shape = a.shape[:-1] + (a.shape[-1] - window + 1, window)
strides = a.strides + (a.strides[-1],)
return np.lib.stride_tricks.as_strided(a, shape=shape, strides=strides)
start = datetime.datetime(2004, 11, 21)
stop = datetime.datetime(2014, 11, 21)
broadMarket = web.DataReader(sys.argv[1], 'yahoo', start, stop)
broadMarket = broadMarket['Close']
returns = broadMarket.pct_change()
vol5 = st.rolling_std(returns, window=5)/5.0
vol30 = st.rolling_std(returns, window=30)/30.0
vol60 = st.rolling_std(returns, window=60)/60.0
vol120 = st.rolling_std(returns, window=120)/120.0
vol240 = st.rolling_std(returns, window=240)/240.0
for i in range(240, len(vol240)-30):
print vol5.iloc[i], "\t", \
vol30.iloc[i], "\t", \
vol60.iloc[i], "\t", \
vol120.iloc[i], "\t", \
vol240.iloc[i], "\t", \
vol30.iloc[i+30]
#returns = np.array([broadMarket.iloc[i,3]/broadMarket.iloc[i-1,3] - 1.0 for i in range(1, len(broadMarket))])
data_access = da.DataAccess('Yahoo')
symbols = data_access.get_symbols_from_list("sp5002012")
symbols.append(_benchmark_symbol)
print 'total symbols:', len(symbols), "starts with:", symbols[:20]
print 'getting data...'
ls_keys = ['close'] # 'actual_close'
ldf_data = data_access.get_data(index, symbols, ls_keys)
d_data = dict(zip(ls_keys, ldf_data))
print 'filling n/a with 1.0...'
for s_key in ls_keys:
d_data[s_key] = d_data[s_key].fillna(method='ffill')
d_data[s_key] = d_data[s_key].fillna(method='bfill')
d_data[s_key] = d_data[s_key].fillna(1.0)
print "calculating rolling mean and std"
prices = d_data['close'].copy()
rolling_means = moments.rolling_mean(prices, _lookback, min_periods=_lookback)
rolling_stds = moments.rolling_std(prices, _lookback, min_periods=_lookback)
print "calculating Bollinger values"
bands = pd.DataFrame(0, index, symbols)
for s in symbols:
bands[s] = (prices[s] - rolling_means[s]) / (rolling_stds[s])
print "finding Events for Bollinger data"
find_events(bands, symbols)
print "orders put to:", _orders_fname
print "done."
import matplotlib.pyplot as plt
import pandas.util.testing as t
import pandas.stats.moments as m
t.N = 500
ts = t.makeTimeSeries()
ts[::100] = 20
s = ts.cumsum()
plt.figure(figsize=(10, 5))
plt.plot(s.index, m.ewmvol(s, span=50, min_periods=1).values, color='b')
plt.plot(s.index, m.rolling_std(s, 50, min_periods=1).values, color='r')
plt.title('Exp-weighted std with shocks')
plt.legend(('Exp-weighted', 'Equal-weighted'))
f = plt.gcf()
f.autofmt_xdate()
plt.show()
plt.close('all')
dt_end = dt.datetime(year=2010, month=12, day=31)
print "symbol:", symbol, "from", dt_start, 'to', dt_end
print "reading close prices to DataFrame from Yahoo"
index = du.getNYSEdays(dt_start, dt_end, dt.timedelta(hours=16))
c_datable = da.DataAccess('Yahoo')
key_list = ['open', 'high', 'low', 'close', 'volume', 'actual_close']
data_list = c_datable.get_data(index, symbols, key_list)
d_data = dict(zip(key_list, data_list))
price = d_data['close'].copy()
price = price.fillna(method='ffill')
price = price.fillna(method='bfill')
print "calculating rolling mean and std"
rolling_mean = moments.rolling_mean(price, 20, min_periods=20)
rolling_std = moments.rolling_std(price, 20, min_periods=20)
print "generating graph"
plt.clf()
plt.plot(price.index, price[symbol].values, label=symbol)
plt.plot(price.index, rolling_mean[symbol].values)
#plt.plot(price.index, rolling_std[symbol].values)
plt.legend([symbol, 'Rolling Mean'])
plt.ylabel('Adjusted Close')
graph_file_name = symbol + ".png"
print "saving to", graph_file_name
plt.savefig(graph_file_name, format='png')
print "calculating Bollinger values"
bands = pd.DataFrame(0, index, symbols)
for s in symbols:
print title
ax1.set_title(title)
# ax.set_xlabel('Time (h)')
# ax.set_ylabel('RMSE')
# ax.set_yscale('log')
# ax.set_xlim(0,30)
# colors = sns.color_palette("husl", 25)
# for i in range(0,25):
# ax.scatter(time_by_seed[i], error_by_seed[i], c=cm.hsv(i/25.,1), s=[30]*len(time_by_seed[i]))
# ax.scatter(time_by_seed[i], error_by_seed[i], c=[colors[i]]*len(time_by_seed[i]), s=[30]*len(time_by_seed[i]))
ax1.set_xlabel('Time (h)')
ax1.set_ylabel('RMSE')
ax1.set_xlim(-1, 30)
y_mean = stats.rolling_mean(sorted_errors, 5)
y_std = stats.rolling_std(sorted_errors, 5)
# y_upper = y_mean + 2*y_std
y_upper = stats.rolling_max(sorted_errors, 5)
# y_lower = y_mean - 2*y_std
y_lower = stats.rolling_min(sorted_errors, 5)
sorted_data = DataFrame(data=sorted_points,
columns=['time', 'binned_time', 'error', 'seed'])
# sns.jointplot("binned_time", "error", sorted_data)
# ax1.scatter(sorted_binned_time, sorted_errors)
ax1.plot(sorted_time, y_mean, color="red", label="Rolling mean")
# ax1.errorbar(sorted_binned_time, sorted_errors, marker='o', ms=8, yerr=3*y_std, ls='dotted', label="Rolling mean")
ax1.legend()
ax1.fill_between(sorted_time,
y_mean,
y_upper,
facecolor='gray',