def main():
''' Main Function'''
# List of symbols
ls_symbols = ["AAPL", "GLD", "IJR", "SPY", "XOM"]
# Start and End date of the charts
dt_start = dt.datetime(2006, 1, 1)
dt_end = dt.datetime(2010, 12, 31)
# We need closing prices so the timestamp should be hours=16.
dt_timeofday = dt.timedelta(hours=16)
# Get a list of trading days between the start and the end.
ldt_timestamps = du.getNYSEdays(dt_start, dt_end, dt_timeofday)
# Creating an object of the dataaccess class
c_dataobj = da.DataAccess('EODHistoricalData')
# Keys to be read from the data, it is good to read everything in one go.
ls_keys = ['open', 'high', 'low', 'close', 'volume', 'actual_close']
# Reading the data, now d_data is a dictionary with the keys above.
# Timestamps and symbols are the ones that were specified before.
ldf_data = c_dataobj.get_data(ldt_timestamps, ls_symbols, ls_keys)
d_data = dict(zip(ls_keys, ldf_data))
# Filling the data for NAN
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)
# Getting the numpy ndarray of close prices.
na_price = d_data['close'].values
# Plotting the prices with x-axis=timestamps
plt.clf()
plt.plot(ldt_timestamps, na_price)
plt.legend(ls_symbols)
plt.ylabel('Adjusted Close')
plt.xlabel('Date')
plt.savefig('adjustedclose.pdf', format='pdf')
# Normalizing the prices to start at 1 and see relative returns
na_normalized_price = na_price / na_price[0, :]
# Plotting the prices with x-axis=timestamps
plt.clf()
plt.plot(ldt_timestamps, na_normalized_price)
plt.legend(ls_symbols)
plt.ylabel('Normalized Close')
plt.xlabel('Date')
plt.savefig('normalized.pdf', format='pdf')
# Copy the normalized prices to a new ndarry to find returns.
na_rets = na_normalized_price.copy()
# Calculate the daily returns of the prices. (Inplace calculation)
# returnize0 works on ndarray and not dataframes.
tsu.returnize0(na_rets)
# Plotting the plot of daily returns
plt.clf()
plt.plot(ldt_timestamps[0:50], na_rets[0:50, 3]) # $SPX 50 days
plt.plot(ldt_timestamps[0:50], na_rets[0:50, 4]) # XOM 50 days
plt.axhline(y=0, color='r')
plt.legend(['$SPX', 'XOM'])
plt.ylabel('Daily Returns')
plt.xlabel('Date')
plt.savefig('rets.pdf', format='pdf')
# Plotting the scatter plot of daily returns between XOM VS $SPX
plt.clf()
plt.scatter(na_rets[:, 3], na_rets[:, 4], c='blue')
plt.ylabel('XOM')
plt.xlabel('$SPX')
plt.savefig('scatterSPXvXOM.pdf', format='pdf')
# Plotting the scatter plot of daily returns between $SPX VS GLD
plt.clf()
plt.scatter(na_rets[:, 3], na_rets[:, 1], c='blue') # $SPX v GLD
plt.ylabel('GLD')
plt.xlabel('$SPX')
plt.savefig('scatterSPXvGLD.pdf', format='pdf')
def main():
'''Main Function'''
# S&P 100
ls_symbols = ['AAPL', 'ABT', 'ACN', 'AEP', 'ALL', 'AMGN', 'AMZN', 'APC', 'AXP', 'BA', 'BAC', 'BAX', 'BHI', 'BK', 'BMY', 'CAT', 'C', 'CL', 'CMCSA', 'COF', 'COP', 'COST', 'CPB', 'CSCO', 'CVS', 'CVX', 'DD', 'DELL', 'DIS', 'DOW', 'DVN', 'EBAY', 'EMC', 'EXC', 'F', 'FCX', 'FDX', 'GD', 'GE', 'GILD', 'GOOG', 'GS', 'HAL', 'HD', 'HNZ', 'HON', 'HPQ', 'IBM', 'INTC', 'JNJ', 'JPM', 'KO', 'LLY', 'LMT', 'LOW', 'MA', 'MCD', 'MDT', 'MET', 'MMM', 'MO', 'MON', 'MRK', 'MS', 'MSFT', 'NKE', 'NOV', 'NSC', 'NWSA', 'NYX', 'ORCL', 'OXY', 'PEP', 'PFE', 'PG', 'PM', 'QCOM', 'RF', 'RTN', 'SBUX', 'SLB', 'SO', 'SPG', 'T', 'TGT', 'TWX', 'TXN', 'UNH', 'UPS', 'USB', 'UTX', 'VZ', 'WFC', 'WMB', 'WMT', 'XOM']
# Creating an object of the dataaccess class with Yahoo as the source.
c_dataobj = da.DataAccess('EODHistoricalData')
ls_all_syms = c_dataobj.get_all_symbols()
# Bad symbols are symbols present in portfolio but not in all syms
ls_bad_syms = list(set(ls_symbols) - set(ls_all_syms))
for s_sym in ls_bad_syms:
i_index = ls_symbols.index(s_sym)
ls_symbols.pop(i_index)
# Start and End date of the charts
dt_end = dt.datetime(2010, 1, 1)
dt_start = dt_end - dt.timedelta(days=365)
dt_test = dt_end + dt.timedelta(days=365)
# We need closing prices so the timestamp should be hours=16.
dt_timeofday = dt.timedelta(hours=16)
# Get a list of trading days between the start and the end.
ldt_timestamps = du.getNYSEdays(dt_start, dt_end, dt_timeofday)
ldt_timestamps_test = du.getNYSEdays(dt_end, dt_test, dt_timeofday)
# Reading just the close prices
df_close = c_dataobj.get_data(ldt_timestamps, ls_symbols, "close")
df_close_test = c_dataobj.get_data(ldt_timestamps_test, ls_symbols, "close")
# Filling the data for missing NAN values
df_close = df_close.fillna(method='ffill')
df_close = df_close.fillna(method='bfill')
df_close_test = df_close_test.fillna(method='ffill')
df_close_test = df_close_test.fillna(method='bfill')
# Copying the data values to a numpy array to get returns
na_data = df_close.values.copy()
na_data_test = df_close_test.values.copy()
# Getting the daily returns
tsu.returnize0(na_data)
tsu.returnize0(na_data_test)
# Calculating the frontier.
(lf_returns, lf_std, lna_portfolios, na_avgrets, na_std) = getFrontier(na_data)
(lf_returns_test, lf_std_test, unused, unused, unused) = getFrontier(na_data_test)
# Plotting the efficient frontier
plt.clf()
plt.plot(lf_std, lf_returns, 'b')
plt.plot(lf_std_test, lf_returns_test, 'r')
# Plot where the efficient frontier would be the following year
lf_ret_port_test = []
lf_std_port_test = []
for na_portfolio in lna_portfolios:
na_port_rets = np.dot(na_data_test, na_portfolio)
lf_std_port_test.append(np.std(na_port_rets))
lf_ret_port_test.append(np.average(na_port_rets))
plt.plot(lf_std_port_test, lf_ret_port_test, 'k')
# Plot indivisual stock risk/return as green +
for i, f_ret in enumerate(na_avgrets):
plt.plot(na_std[i], f_ret, 'g+')
# # Plot some arrows showing transistion of efficient frontier
# for i in range(0, 101, 10):
# plt.arrow(lf_std[i], lf_returns[i], lf_std_port_test[i] - lf_std[i],
# lf_ret_port_test[i] - lf_returns[i], color='k')
# Labels and Axis
plt.legend(['2009 Frontier', '2010 Frontier',
'Performance of \'09 Frontier in 2010'], loc='lower right')
plt.title('Efficient Frontier For S&P 100 ')
plt.ylabel('Expected Return')
plt.xlabel('StDev')
plt.savefig('tutorial8.pdf', format='pdf')
def main():
''' Main Function'''
# Reading the csv file.
na_data = np.loadtxt('tutorial2_data.csv', delimiter=',', skiprows=1)
na_price = na_data[:, 3:] # Default np.loadtxt datatype is float.
na_dates = np.int_(na_data[:, 0:3]) # Dates should be int
ls_symbols = ['$SPX', 'XOM', 'GOOG', 'GLD']
# Printing the first 5 rows
print("First 5 rows of Price Data:")
print(na_price[:5, :])
print
print("First 5 rows of Dates:")
print(na_dates[:5, :])
# Creating the timestamps from dates read
ldt_timestamps = []
for i in range(0, na_dates.shape[0]):
ldt_timestamps.append(
dt.date(na_dates[i, 0], na_dates[i, 1], na_dates[i, 2]))
# Plotting the prices with x-axis=timestamps
plt.clf()
plt.plot(ldt_timestamps, na_price)
plt.legend(ls_symbols)
plt.ylabel('Adjusted Close')
plt.xlabel('Date')
plt.savefig('adjustedclose.pdf', format='pdf')
# Normalizing the prices to start at 1 and see relative returns
na_normalized_price = na_price / na_price[0, :]
# Plotting the prices with x-axis=timestamps
plt.clf()
plt.plot(ldt_timestamps, na_normalized_price)
plt.legend(ls_symbols)
plt.ylabel('Normalized Close')
plt.xlabel('Date')
plt.savefig('normalized.pdf', format='pdf')
# Copy the normalized prices to a new ndarry to find returns.
na_rets = na_normalized_price.copy()
# Calculate the daily returns of the prices. (Inplace calculation)
tsu.returnize0(na_rets)
# Plotting the plot of daily returns
plt.clf()
plt.plot(ldt_timestamps[0:50], na_rets[0:50, 0]) # $SPX 50 days
plt.plot(ldt_timestamps[0:50], na_rets[0:50, 1]) # XOM 50 days
plt.axhline(y=0, color='r')
plt.legend(['$SPX', 'XOM'])
plt.ylabel('Daily Returns')
plt.xlabel('Date')
plt.savefig('rets.pdf', format='pdf')
# Plotting the scatter plot of daily returns between XOM VS $SPX
plt.clf()
plt.scatter(na_rets[:, 0], na_rets[:, 1], c='blue')
plt.ylabel('XOM')
plt.xlabel('$SPX')
plt.savefig('scatterSPXvXOM.pdf', format='pdf')
# Plotting the scatter plot of daily returns between $SPX VS GLD
plt.clf()
plt.scatter(na_rets[:, 0], na_rets[:, 3], c='blue') # $SPX v GLD
plt.ylabel('GLD')
plt.xlabel('$SPX')
plt.savefig('scatterSPXvGLD.pdf', format='pdf')
def main():
''' Main Function'''
# Reading the portfolio
na_portfolio = np.loadtxt('tutorial3_portfolio.csv',
dtype='U5,f4',
delimiter=',',
comments="#",
skiprows=1)
print(na_portfolio)
# Sorting the portfolio by symbol name
na_portfolio = sorted(na_portfolio, key=lambda x: x[0])
print(na_portfolio)
# Create two list for symbol names and allocation
ls_port_syms = []
lf_port_alloc = []
for port in na_portfolio:
ls_port_syms.append(port[0])
lf_port_alloc.append(port[1])
# Creating an object of the dataaccess class with Yahoo as the source.
c_dataobj = da.DataAccess('EODHistoricalData')
ls_all_syms = c_dataobj.get_all_symbols()
print(ls_all_syms)
# Bad symbols are symbols present in portfolio but not in all syms
ls_bad_syms = list(set(ls_port_syms) - set(ls_all_syms))
if len(ls_bad_syms) != 0:
print("Portfolio contains bad symbols : ", ls_bad_syms)
for s_sym in ls_bad_syms:
i_index = ls_port_syms.index(s_sym)
ls_port_syms.pop(i_index)
lf_port_alloc.pop(i_index)
# Reading the historical data.
dt_end = dt.datetime(2011, 1, 1)
dt_start = dt_end - dt.timedelta(days=1095) # Three years
# We need closing prices so the timestamp should be hours=16.
dt_timeofday = dt.timedelta(hours=16)
# Get a list of trading days between the start and the end.
ldt_timestamps = du.getNYSEdays(dt_start, dt_end, dt_timeofday)
# Keys to be read from the data, it is good to read everything in one go.
ls_keys = ['open', 'high', 'low', 'close', 'volume', 'actual_close']
# Reading the data, now d_data is a dictionary with the keys above.
# Timestamps and symbols are the ones that were specified before.
ldf_data = c_dataobj.get_data(ldt_timestamps, ls_port_syms, ls_keys)
d_data = dict(zip(ls_keys, ldf_data))
# Copying close price into separate dataframe to find rets
df_rets = d_data['close'].copy()
# Filling the data.
df_rets = df_rets.fillna(method='ffill')
df_rets = df_rets.fillna(method='bfill')
df_rets = df_rets.fillna(1.0)
# Numpy matrix of filled data values
na_rets = df_rets.values
# returnize0 works on ndarray and not dataframes.
tsu.returnize0(na_rets)
# Estimate portfolio returns
na_portrets = np.sum(na_rets * lf_port_alloc, axis=1)
na_port_total = np.cumprod(na_portrets + 1)
na_component_total = np.cumprod(na_rets + 1, axis=0)
# Plotting the results
plt.clf()
fig = plt.figure()
fig.add_subplot(111)
plt.plot(ldt_timestamps, na_component_total, alpha=0.4)
plt.plot(ldt_timestamps, na_port_total)
ls_names = ls_port_syms
ls_names.append('Portfolio')
plt.legend(ls_names)
plt.ylabel('Cumulative Returns')
plt.xlabel('Date')
fig.autofmt_xdate(rotation=45)
plt.savefig('tutorial3.pdf', format='pdf')
def eventprofiler(df_events_arg, d_data, i_lookback=20, i_lookforward=20,
s_filename='study', b_market_neutral=True, b_errorbars=True,
s_market_sym='SPY'):
''' Event Profiler for an event matix'''
df_close = d_data['close'].copy()
df_rets = df_close.copy()
# Do not modify the original event dataframe.
df_events = df_events_arg.copy()
tsu.returnize0(df_rets.values)
if b_market_neutral == True:
df_rets = df_rets - df_rets[s_market_sym]
del df_rets[s_market_sym]
del df_events[s_market_sym]
df_close = df_close.reindex(columns=df_events.columns)
# Removing the starting and the end events
df_events.values[0:i_lookback, :] = np.NaN
df_events.values[-i_lookforward:, :] = np.NaN
# Number of events
i_no_events = int(np.logical_not(np.isnan(df_events.values)).sum())
assert i_no_events > 0, "Zero events in the event matrix"
na_event_rets = "False"
# Looking for the events and pushing them to a matrix
for i, s_sym in enumerate(df_events.columns):
for j, dt_date in enumerate(df_events.index):
if df_events[s_sym][dt_date] == 1:
na_ret = df_rets[s_sym][j - i_lookback:j + 1 + i_lookforward]
if type(na_event_rets) == type(""):
na_event_rets = na_ret
else:
na_event_rets = np.vstack((na_event_rets, na_ret))
if len(na_event_rets.shape) == 1:
na_event_rets = np.expand_dims(na_event_rets, axis=0)
# Computing daily rets and retuns
na_event_rets = np.cumprod(na_event_rets + 1, axis=1)
na_event_rets = (na_event_rets.T / na_event_rets[:, i_lookback]).T
# Study Params
na_mean = np.mean(na_event_rets, axis=0)
na_std = np.std(na_event_rets, axis=0)
li_time = range(-i_lookback, i_lookforward + 1)
# Plotting the chart
plt.clf()
plt.axhline(y=1.0, xmin=-i_lookback, xmax=i_lookforward, color='k')
if b_errorbars == True:
plt.errorbar(li_time[i_lookback:], na_mean[i_lookback:],
yerr=na_std[i_lookback:], ecolor='#AAAAFF',
alpha=0.7)
plt.plot(li_time, na_mean, linewidth=3, label='mean', color='b')
plt.xlim(-i_lookback - 1, i_lookforward + 1)
if b_market_neutral == True:
plt.title('Market Relative mean return of ' +\
str(i_no_events) + ' events')
else:
plt.title('Mean return of ' + str(i_no_events) + ' events')
plt.xlabel('Days')
plt.ylabel('Cumulative Returns')
plt.savefig(s_filename, format='pdf')