def sharpe_func(allocs, prices):
"compute sharpe ratio given allocs and price data"
port_val = get_portfolio_value(prices, allocs, 1)
port_stats = get_portfolio_stats(port_val)
sharpe_ratio = port_stats[3]
return (-1 * sharpe_ratio)
def simulateOrders(start_date, end_date, orders_file, start_val, title="Portfolio Value"):
# Process orders
portvals = compute_portvals(start_date, end_date, orders_file, start_val)
if isinstance(portvals, pd.DataFrame):
portvals = portvals[portvals.columns[0]] # if a DataFrame is returned select the first column to get a Series
# Get portfolio stats
cum_ret, avg_daily_ret, std_daily_ret, sharpe_ratio = get_portfolio_stats(portvals)
# Simulate a $SPX-only reference portfolio to get stats
prices_SPX = get_data(['$SPX'], pd.date_range(start_date, end_date))
prices_SPX = prices_SPX[['$SPX']] # remove SPY
portvals_SPX = get_portfolio_value(prices_SPX, [1.0])
cum_ret_SPX, avg_daily_ret_SPX, std_daily_ret_SPX, sharpe_ratio_SPX = get_portfolio_stats(portvals_SPX)
# Compare portfolio against $SPX
print "Data Range: {} to {}".format(start_date, end_date)
print
print "Sharpe Ratio of Fund: {}".format(sharpe_ratio)
print "Sharpe Ratio of $SPX: {}".format(sharpe_ratio_SPX)
print
print "Cumulative Return of Fund: {}".format(cum_ret)
print "Cumulative Return of $SPX: {}".format(cum_ret_SPX)
print
print "Standard Deviation of Fund: {}".format(std_daily_ret)
print "Standard Deviation of $SPX: {}".format(std_daily_ret_SPX)
print
print "Average Daily Return of Fund: {}".format(avg_daily_ret)
print "Average Daily Return of $SPX: {}".format(avg_daily_ret_SPX)
print
print "Final Portfolio Value: {}".format(portvals[-1])
# Plot computed daily portfolio value
df_temp = pd.concat([portvals, prices_SPX['$SPX']], keys=['Portfolio', 'SPY'], axis=1)
plot_normalized_data(df_temp, title)
def optimize_portfolio(start_date, end_date, symbols):
"""Simulate and optimize portfolio allocations."""
# Read in adjusted closing prices for given symbols, date range
dates = pd.date_range(start_date, end_date)
prices_all = get_data(symbols, dates) # automatically adds SPY
prices = prices_all[symbols] # only portfolio symbols
prices_SPY = prices_all['SPY'] # only SPY, for comparison later
# Get optimal allocations
allocs = find_optimal_allocations(prices)
allocs = allocs / np.sum(allocs) # normalize allocations, if they don't sum to 1.0
# Get daily portfolio value (already normalized since we use default start_val=1.0)
port_val = get_portfolio_value(prices, allocs)
# Get portfolio statistics (note: std_daily_ret = volatility)
cum_ret, avg_daily_ret, std_daily_ret, sharpe_ratio = get_portfolio_stats(port_val)
# Print statistics
print "Start Date:", start_date
print "End Date:", end_date
print "Symbols:", symbols
print "Optimal allocations:", allocs
print "Sharpe Ratio:", sharpe_ratio
print "Volatility (stdev of daily returns):", std_daily_ret
print "Average Daily Return:", avg_daily_ret
print "Cumulative Return:", cum_ret
# Compare daily portfolio value with normalized SPY
normed_SPY = prices_SPY / prices_SPY.ix[0, :]
df_temp = pd.concat([port_val, normed_SPY], keys=['Portfolio', 'SPY'], axis=1)
plot_data(df_temp, title="Daily Portfolio Value and SPY")
def optimize_portfolio(start_date, end_date, symbols):
"""Simulate and optimize portfolio allocations."""
# Read in adjusted closing prices for given symbols, date range
dates = pd.date_range(start_date, end_date)
prices_all = get_data(symbols, dates) # automatically adds SPY
prices = prices_all[symbols] # only portfolio symbols
prices_SPY = prices_all['SPY'] # only SPY, for comparison later
# Get optimal allocations
allocs = find_optimal_allocations(prices)
allocs = allocs / np.sum(allocs) # normalize allocations, if they don't sum to 1.0
# Get daily portfolio value (already normalized since we use default start_val=1.0)
port_val = get_portfolio_value(prices, allocs)
# Get portfolio statistics (note: std_daily_ret = volatility)
cum_ret, avg_daily_ret, std_daily_ret, sharpe_ratio = get_portfolio_stats(port_val)
# Print statistics
print "Start Date:", start_date
print "End Date:", end_date
print "Symbols:", symbols
print "Optimal allocations:", allocs
print "Sharpe Ratio:", sharpe_ratio
print "Volatility (stdev of daily returns):", std_daily_ret
print "Average Daily Return:", avg_daily_ret
print "Cumulative Return:", cum_ret
# Compare daily portfolio value with normalized SPY
normed_SPY = prices_SPY / prices_SPY.ix[0, :]
df_temp = pd.concat([port_val, normed_SPY], keys=['Portfolio', 'SPY'], axis=1)
plot_data(df_temp, title="Daily Portfolio Value and SPY")
def optimize_portfolio(sd=dt.datetime(2008,1,1), ed=dt.datetime(2009,1,1),
syms=['GOOG','AAPL','GLD','XOM'], gen_plot=False):
# Read in adjusted closing prices for given symbols, date range
dates = pd.date_range(sd, ed)
prices_all = get_data(syms, dates) # automatically adds SPY
prices = prices_all[syms] # only portfolio symbols
prices_SPY = prices_all['SPY'] # only SPY, for comparison later
# find the allocations for the optimal portfolio
# note that the values here ARE NOT meant to be correct for a test case
sv = 1000000
rfr = 0.0
sf = 252.0
allocs = find_optimal_allocations(prices, sv, rfr, sf) # add code here to find the allocations
port_val = analysis.get_portfolio_value(prices,allocs,sv)
cr, adr, sddr, sr = analysis.compute_portfolio_stats(port_val, rfr, sf)
# Compare daily portfolio value with SPY using a normalized plot
if gen_plot:
# add code to plot here
df_temp = pd.concat([port_val, prices_SPY], keys=['Portfolio', 'SPY'], axis=1)
pass
return allocs, cr, adr, sddr, sr
def f(X):
Y = get_portfolio_stats(get_portfolio_value(
prices, [X[0], X[1], X[2], X[3]], start_val=1),
daily_rf=0,
samples_per_year=252)[3] * -1
return Y
def error_alloc_vol(allocs, portfolio, start_val=1):
"""Function that takes allocations and portfolio and returns the
portfolio's sharpe ratio*(-1). Used with find_optimsed_alloc."""
port_final = get_portfolio_value(portfolio, allocs, start_val)
cum_ret, ave_daily_ret, std_daily_ret, sharpe_ratio = get_portfolio_stats(
port_final)
return cum_ret
def statistics(weights):
global gprices
weights = np.array(weights)
port_val = get_portfolio_value(gprices, weights)
gret = port_val.sum()
cum_ret, avg_daily_ret, std_daily_ret, sharpe_ratio = get_portfolio_stats(port_val)
return np.array([gret, std_daily_ret, sharpe_ratio])
def get_negative_sharp_ratio(prices, allocs):
# Get daily portfolio value
port_val = get_portfolio_value(prices=prices, allocs=allocs)
#plot_data(port_val, title="Daily Portfolio Value")
# Get portfolio statistics (note: std_daily_ret = volatility)
_, _, _, sharpe_ratio = get_portfolio_stats(port_val)
return sharpe_ratio * -1
def get_negative_sharp_ratio(prices, allocs):
# Get daily portfolio value
port_val = get_portfolio_value(prices=prices, allocs=allocs)
#plot_data(port_val, title="Daily Portfolio Value")
# Get portfolio statistics (note: std_daily_ret = volatility)
_, _, _, sharpe_ratio = get_portfolio_stats(port_val)
return sharpe_ratio * -1
def find_sharpe_ratio(allocs, prices):
start_val = 1
port_val = get_portfolio_value(prices, allocs, start_val)
daily_rf = 0
samples_per_year = 252
cum_ret, avg_daily_ret, std_daily_ret, sharpe_ratio = get_portfolio_stats(port_val, daily_rf, samples_per_year)
return -sharpe_ratio
def negSharpeRatio(allocs, prices):
# Get daily portfolio value (already normalized since we use default start_val=1.0)
port_val = get_portfolio_value(prices, allocs)
# Get portfolio statistics (note: std_daily_ret = volatility)
cum_ret, avg_daily_ret, std_daily_ret, sharpe_ratio = get_portfolio_stats(
port_val)
return (sharpe_ratio * -1)
def test_run():
"""Driver function."""
# Define input parameters
# Test 1
# start_date = '2011-01-05'
# end_date = '2011-01-20'
# orders_file = os.path.join(".\orders", "orders-short.csv")
# start_val = 1000000
# Test 2
# start_date = '2011-01-10'
# end_date = '2011-12-20'
# orders_file = os.path.join(".\orders", "orders.csv")
# start_val = 1000000
# Test 3
start_date = '2011-01-14'
end_date = '2011-12-14'
orders_file = os.path.join(".\orders", "orders2.csv")
start_val = 1000000
# Process orders
portvals = compute_portvals(start_date, end_date, orders_file, start_val)
if isinstance(portvals, pd.DataFrame):
portvals = portvals[portvals.columns[0]] # if a DataFrame is returned select the first column to get a Series
# Get portfolio stats
cum_ret, avg_daily_ret, std_daily_ret, sharpe_ratio = get_portfolio_stats(portvals)
# Simulate a $SPX-only reference portfolio to get stats
prices_SPX = get_data(['$SPX'], pd.date_range(start_date, end_date))
prices_SPX = prices_SPX[['$SPX']] # remove SPY
portvals_SPX = get_portfolio_value(prices_SPX, [1.0])
cum_ret_SPX, avg_daily_ret_SPX, std_daily_ret_SPX, sharpe_ratio_SPX = get_portfolio_stats(portvals_SPX)
# Compare portfolio against $SPX
print "Data Range: {} to {}".format(start_date, end_date)
print
print "Sharpe Ratio of Fund: {}".format(sharpe_ratio)
print "Sharpe Ratio of $SPX: {}".format(sharpe_ratio_SPX)
print
print "Cumulative Return of Fund: {}".format(cum_ret)
print "Cumulative Return of $SPX: {}".format(cum_ret_SPX)
print
print "Standard Deviation of Fund: {}".format(std_daily_ret)
print "Standard Deviation of $SPX: {}".format(std_daily_ret_SPX)
print
print "Average Daily Return of Fund: {}".format(avg_daily_ret)
print "Average Daily Return of $SPX: {}".format(avg_daily_ret_SPX)
print
print "Final Portfolio Value: {}".format(portvals[-1])
# Plot computed daily portfolio value
df_temp = pd.concat([portvals, prices_SPX['$SPX']], keys=['Portfolio', '$SPX'], axis=1)
plot_normalized_data(df_temp, title="Daily portfolio value and $SPX")
def optimise_portfolio(sd, ed, syms, rfr=0.0, sf=252, gen_plot=True):
"""Find the optimal allocation for a given set of stocks, optimised for
volatility (standard deviation of daily return).
Parameters:
-----------
sd: A datetime object that represents the start date
ed: A datetime object that represents the end date
syms: A list of symbols that make up the portfolio
rfr: float - risk free rate, default to 0.0 per day.
sf: int - sampling frequency per year, default to 252 days
gen_plot: If True, create a plot named plot.png
Returns:
-------
allocs: A 1-d Numpy ndarray of allocations to the stocks. All the
allocations must be between 0.0 and 1.0 and they must sum to 1.0.
cr: Cumulative return
adr: Average daily return
sddr: Standard deviation of daily return
sr: Sharpe ratio
"""
#---------Build the portfolio---------------------------------
joint_df = get_port_SPY(sd, ed, syms) #syms + SPY df
port = joint_df[0] #portfolio df w/o SPY
SPY = joint_df[1] #SPY df - used to add to plot later
normed_SPY = normalise_data(SPY) #Normalise SPY
#Find the optimal allocations
optimised_alloc = find_optimised_alloc(port, error_alloc_vol)
#portfolio based on optimised allocations
optimised_port = get_portfolio_value(port, optimised_alloc)
#Get optimised portfolio's performance statistics
cum_ret, ave_daily_ret, std_daily_ret, sharpe_ratio = get_portfolio_stats(
optimised_port)
#----------Plot the normalised portfolio and SPY prices--------
if gen_plot == True:
df_temp = pd.concat([optimised_port, normed_SPY],
keys=['Portfolio', 'SPY'],
axis=1)
plot_data(df_temp,
title='Daily portfolio value and SPY',
fontsize=2,
xlabel='Date',
ylabel='Normalised price')
return optimised_alloc, cum_ret, ave_daily_ret, std_daily_ret, sharpe_ratio
def sharpe_maximizer(allocs, prices):
"""Optimization function to be passed to the optimizer.
Parameters
----------
prices: daily prices for each stock in portfolio
allocs: Allocation for each portfolio component
Returns
-------
sharpe_ratio: Negative sharpe ratio so the minimizer finds the maximum
"""
#Get portfolio value
port_val = get_portfolio_value(prices, allocs)
#Get portfolio statistics
cum_ret, avg_daily_ret, std_daily_ret, sharpe_ratio = get_portfolio_stats(port_val)
return -sharpe_ratio
def sharpe_maximizer(allocs, prices):
"""Optimization function to be passed to the optimizer.
Parameters
----------
prices: daily prices for each stock in portfolio
allocs: Allocation for each portfolio component
Returns
-------
sharpe_ratio: Negative sharpe ratio so the minimizer finds the maximum
"""
#Get portfolio value
port_val = get_portfolio_value(prices, allocs)
#Get portfolio statistics
cum_ret, avg_daily_ret, std_daily_ret, sharpe_ratio = get_portfolio_stats(
port_val)
return -sharpe_ratio
def test_run(start_date, end_date, orders, start_val,plot=True):
# Process orders
portvals = compute_portvals(start_date, end_date, orders, start_val)
if isinstance(portvals, pd.DataFrame):
portvals = portvals[portvals.columns[0]] # if a DataFrame is returned select the first column to get a Series
# Get portfolio stats
cum_ret, avg_daily_ret, std_daily_ret, sharpe_ratio = get_portfolio_stats(portvals)
# Simulate a SPY-only reference portfolio to get stats
prices_SPX = get_data(['SPY'], pd.date_range(start_date, end_date))
prices_SPX = prices_SPX[['SPY']] # remove SPY
portvals_SPX = get_portfolio_value(prices_SPX, [1.0])
cum_ret_SPX, avg_daily_ret_SPX, std_daily_ret_SPX, sharpe_ratio_SPX = get_portfolio_stats(portvals_SPX)
# Compare portfolio against $SPX
print "Data Range: {} to {}".format(start_date, end_date)
print
print "Sharpe Ratio of Fund: {}".format(sharpe_ratio)
print "Sharpe Ratio of $SPX: {}".format(sharpe_ratio_SPX)
print
print "Cumulative Return of Fund: {}".format(cum_ret)
print "Cumulative Return of $SPX: {}".format(cum_ret_SPX)
print
print "Standard Deviation of Fund: {}".format(std_daily_ret)
print "Standard Deviation of $SPX: {}".format(std_daily_ret_SPX)
print
print "Average Daily Return of Fund: {}".format(avg_daily_ret)
print "Average Daily Return of $SPX: {}".format(avg_daily_ret_SPX)
print
print "Final Portfolio Value: {}".format(portvals[-1])
print "Final SPY Value: {}".format(portvals_SPX[-1]*start_val)
# Plot computed daily portfolio value
if plot == True:
df_temp = pd.concat([portvals, prices_SPX['SPY']], keys=['Portfolio', 'SPY'], axis=1)
plot_normalized_data(df_temp, title="Daily portfolio value", ylabel="Normalized Price")
def optimize_portfolio(sd=dt.datetime(2008,1,1), ed=dt.datetime(2009,1,1), \
syms=['GOOG','AAPL','GLD','XOM'], gen_plot=False):
start_val = 1000000
daily_rf = 0
samples_per_year = 252
# Read in adjusted closing prices for given symbols, date range
dates = pd.date_range(sd, ed)
prices_all = get_data(syms, dates) # automatically adds SPY
prices = prices_all[syms] # only portfolio symbols
prices_SPY = prices_all['SPY'] # only SPY, for comparison later
# find the allocations for the optimal portfolio
allocGuess = np.ones(len(syms), dtype='float32') / len(syms)
setBnds = tuple([(0, 1) for x, y in enumerate(allocGuess)
]) #create tuple of (0,1) tuples
# 'constraints' below constrains allocations to sum to 1
# and 'setBnds' forces each allocation to lie in (0,1)
srMax = spo.minimize(cost, allocGuess, bounds = setBnds, \
constraints = ({ 'type': 'eq', 'fun': lambda inputs: 1.0 - np.sum(inputs) }), \
args = (prices,start_val,daily_rf,samples_per_year,), \
method = 'SLSQP', options = {'disp': True})
allocs = srMax.x
portVal = get_portfolio_value(prices, allocs, start_val)
cr, adr, sddr, sr = get_portfolio_stats(portVal, daily_rf,
samples_per_year)
# Compare daily portfolio value with SPY using a normalized plot
if gen_plot:
df_temp = pd.concat([portVal, prices_SPY],
keys=['Portfolio', 'SPY'],
axis=1)
plot_normalized_data(df_temp, 'Optimized portfolio values', 'date', \
'normalized price')
return allocs, cr, adr, sddr, sr
def cost(allocs, prices, start_val, daily_rf, samples_per_year):
portVal = get_portfolio_value(prices, allocs, start_val)
cr, adr, sddr, sr = get_portfolio_stats(portVal, daily_rf,
samples_per_year)
return -sr
def min_fun(x):
x = np.array(x)
port_val = get_portfolio_value(prices, x)
cum_ret, avg_daily_ret, std_daily_ret, sharpe_ratio = get_portfolio_stats(port_val)
return -sharpe_ratio
def error_optimal_allocations(allocs, prices):
port_val = get_portfolio_value(prices, allocs, 1)
cum_ret, avg_daily_ret, std_daily_ret, sharpe_ratio = get_portfolio_stats(port_val)
error = sharpe_ratio * -1
return error
def find_negative_sharpe(allocs, prices):
port_val = get_portfolio_value(prices, allocs)
cum_ret, avg_daily_ret, std_daily_ret, sharpe_ratio = get_portfolio_stats(
port_val)
return sharpe_ratio * (-1.0)
def statistics(weights):
weights = np.array(weights)
port_val = get_portfolio_value(df, weights, 1)
cum_ret, avg_daily_ret, std_daily_ret, sharpe_ratio = get_portfolio_stats(
port_val)
return sharpe_ratio
def min_sharpe_ratio(allocs):
'''Returns the sharpe ratio of the portfolio with weights.'''
port_val = get_portfolio_value(prices, allocs, start_val=1)
sharpe = get_portfolio_stats(port_val)[3]
return -sharpe
def sharpe_ratio(allocs,prices):
port_val = get_portfolio_value(prices, allocs)
cum_ret, avg_daily_ret, std_daily_ret, sharpe_ratio = get_portfolio_stats(port_val)
return -1*sharpe_ratio
def min_func_sharpe(allocs, prices):
cum_ret, avg_daily_ret, std_daily_ret, sharpe_ratio = get_portfolio_stats(
get_portfolio_value(prices, allocs, 1))
return (-1 * sharpe_ratio)
def test_run():
"""Driver function."""
# Define input parameters
start_date = '2007-12-31'
end_date = '2009-12-31'
orders_file = os.path.join("orders", "current_order.csv")
dates = pd.date_range(start_date, end_date)
symbols = ['IBM']
df = get_data(symbols, dates, True)
window_size = 20
sma_band, upper_band, lower_band = get_bands(df['IBM'],window=window_size)
#+1 going out, -1 coming in
transition_array_upper = np.pad(np.diff(np.array(df['IBM'] > upper_band).astype(int)),
(1,0), 'constant', constant_values = (0,))
#+2 stock price going up,-2 stock price going down
transition_array_sma = np.pad(np.diff(np.array(df['IBM'] > sma_band).astype(int)*2),
(1,0), 'constant', constant_values = (0,))
#+3 stock price going up from lower_band,-3 stock price going down from lower_band
transition_array_lower = np.pad(np.diff(np.array(df['IBM'] > lower_band).astype(int)*3),
(1,0), 'constant', constant_values = (0,))
write_orders(df,transition_array_upper,transition_array_sma,transition_array_lower, orders_file)
ax = df['IBM'].plot(title="Bollinger Bands", label='IBM')
sma_band.plot(label='SMA', ax=ax, color = 'Goldenrod')
upper_band.plot(label='Upper Bollinger Band', ax=ax, color = 'Turquoise')
lower_band.plot(label='Lower Bollinger Band', ax=ax, color = 'Turquoise')
ax.set_xlabel("Date")
ax.set_ylabel("Price")
ax.legend(loc='upper left')
plt.show()
portvals = compute_portvals(start_date, end_date, orders_file, 10000)
# Get portfolio stats
cum_ret, avg_daily_ret, std_daily_ret, sharpe_ratio = get_portfolio_stats(portvals)
# Simulate a $SPX-only reference portfolio to get stats
prices_SPX = get_data(['$SPX'], pd.date_range(start_date, end_date))
prices_SPX = prices_SPX[['$SPX']] # remove SPY
portvals_SPX = get_portfolio_value(prices_SPX, [1.0])
cum_ret_SPX, avg_daily_ret_SPX, std_daily_ret_SPX, sharpe_ratio_SPX = get_portfolio_stats(portvals_SPX)
# Compare portfolio against $SPX
print "Data Range: {} to {}".format(start_date, end_date)
print
print "Sharpe Ratio of Fund: {}".format(sharpe_ratio)
print "Sharpe Ratio of $SPX: {}".format(sharpe_ratio_SPX)
print
print "Cumulative Return of Fund: {}".format(cum_ret)
print "Cumulative Return of $SPX: {}".format(cum_ret_SPX)
print
print "Standard Deviation of Fund: {}".format(std_daily_ret)
print "Standard Deviation of $SPX: {}".format(std_daily_ret_SPX)
print
print "Average Daily Return of Fund: {}".format(avg_daily_ret)
print "Average Daily Return of $SPX: {}".format(avg_daily_ret_SPX)
print
print "Final Portfolio Value: {}".format(portvals[-1])
# Plot computed daily portfolio value
df_temp = pd.concat([portvals, prices_SPX['$SPX']], keys=['Portfolio', 'SPY'], axis=1)
plot_normalized_data(df_temp, title="Daily portfolio value")
def test_run():
"""Driver function."""
# Define input parameters
start_date = '2007-12-31'
end_date = '2009-12-31'
symbol = 'IBM'
dates = pd.date_range(start_date, end_date)
prices_all = get_data([symbol], dates)
prices = prices_all[symbol]
# Compute Bollinger Bands
rm = get_rolling_mean(prices, window=20)
rstd = get_rolling_std(prices, window=20)
upper_band, lower_band = get_bollinger_bands(rm, rstd)
# Find Bollinger strategy orders
df_orders = get_orders_bollinger(symbol, prices, rm, upper_band,
lower_band, window=20)
# Plot raw values, rolling mean and Bollinger Bands
plot_data_bollinger(symbol, prices, rm, upper_band, lower_band, df_orders)
#orders_file = os.path.join(".\orders", "orders-short.csv")
with open('orders3.csv', 'wb') as outfile:
writer = csv.writer(outfile, delimiter=',')
writer.writerow(['Date', 'Symbol', 'Order', 'Shares'])
for i in range(len(df_orders)):
writer.writerow([df_orders.ix[i,0].strftime('%Y-%m-%d'),
df_orders.ix[i,1], df_orders.ix[i,2], df_orders.ix[i,3]])
###########################################################################
orders_file = os.path.join("orders3.csv")
start_val = 10000
# Process orders
portvals = compute_portvals(start_date, end_date, orders_file, start_val)
if isinstance(portvals, pd.DataFrame):
portvals = portvals[portvals.columns[0]]
# Get portfolio stats
cum_ret, avg_daily_ret, std_daily_ret, sharpe_ratio = get_portfolio_stats(portvals)
# Simulate a $SPX-only reference portfolio to get stats
prices_SPX = get_data(['$SPX'], pd.date_range(start_date, end_date))
prices_SPX = prices_SPX[['$SPX']] # remove SPY
portvals_SPX = get_portfolio_value(prices_SPX, [1.0])
cum_ret_SPX, avg_daily_ret_SPX, std_daily_ret_SPX, sharpe_ratio_SPX = get_portfolio_stats(portvals_SPX)
# Compare portfolio against $SPX
print "Data Range: {} to {}".format(start_date, end_date)
print
print "Sharpe Ratio of Fund: {}".format(sharpe_ratio)
print "Sharpe Ratio of $SPX: {}".format(sharpe_ratio_SPX)
print
print "Cumulative Return of Fund: {}".format(cum_ret)
print "Cumulative Return of $SPX: {}".format(cum_ret_SPX)
print
print "Standard Deviation of Fund: {}".format(std_daily_ret)
print "Standard Deviation of $SPX: {}".format(std_daily_ret_SPX)
print
print "Average Daily Return of Fund: {}".format(avg_daily_ret)
print "Average Daily Return of $SPX: {}".format(avg_daily_ret_SPX)
print
print "Final Portfolio Value: {}".format(portvals[-1])
def min_func_sharpe(weights, prices):
port_val = get_portfolio_value(prices, weights)
return -get_portfolio_stats(port_val)[3]
def min_func_sharpe(allocs, prices):
cum_ret, avg_daily_ret, std_daily_ret, sharpe_ratio = get_portfolio_stats(get_portfolio_value(prices, allocs, 1))
return (-1*sharpe_ratio)
def sharp_func(allocs, prices):
port_val = get_portfolio_value(prices, allocs, start_val=1)
sharpe_ratio = get_portfolio_stats(port_val)[3]
return sharpe_ratio * -1
def function_to_minimize(allocs, prices):
port_val = get_portfolio_value(prices, allocs, start_val=1000000)
stats = get_portfolio_stats(port_val)
sharpe_ratio = stats[3]
return -sharpe_ratio
def sharp_func(allocs, prices):
port_val = get_portfolio_value(prices, allocs, start_val=1)
sharpe_ratio = get_portfolio_stats(port_val)[3]
return sharpe_ratio * -1
def get_sharpe_ratio(allocs,prices):
port_val = get_portfolio_value(prices,allocs)
sharpe_ratio = get_portfolio_stats(port_val)[-1]
sharpe_ratio = -1.0 * sharpe_ratio
return sharpe_ratio
