コード例 #1
0
ファイル: tutorial1.py プロジェクト: DariuszOstolski/courses
def simulate(dt_start, dt_end, ls_symbols, allocations):
  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)
  c_dataobj = da.DataAccess('Yahoo')
  # 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))

  # Getting the numpy ndarray of close prices.
  na_price = d_data['close'].values
  # Normalizing the prices to start at 1 and see relative returns
  na_normalized_price = na_price / na_price[0, :]
  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)

  #print na_normalized_price
  daily = np.zeros(len(na_normalized_price))
  i = 0
  for row in na_normalized_price:
    daily[i] = row[0]*allocations[0]+row[1]*allocations[1]+row[2]*allocations[2]+row[3]*allocations[3]
    i += 1
  #print daily
  daily_returns = daily.copy()
  tsu.returnize0(daily_returns)
  #print daily_returns
  return (tsu.get_sharpe_ratio(daily_returns), np.std(daily_returns), np.average(daily_returns), (daily[-1]/daily[0]))
コード例 #2
0
def getPortfolioStats(na_price, allocation):
    # Getting the numpy ndarray or pandas dataframe of close prices.
    
    #Normalize the prices according to the first day. The first row for each stock should have a value of 1.0 at this point.
    # Normalizing the prices to start at 1 and see relative returns
    if type(na_price) == type(pd.DataFrame()):
        na_price = na_price.values
        na_normalized_price = na_price / na_price[0,:]
    else:
        na_normalized_price = na_price / na_price[0]
   
    #Multiply each colunpmn by the allocation to the corresponding equity. 
    allocatedprice =  na_normalized_price * allocation
    
    #Sum each row for each day. That is your cumulative daily portfolio value.
    cum_daily_port_value = allocatedprice
    cum_ret = cum_daily_port_value[-1]
    
    #daily return
    daily_port_returns = cum_daily_port_value.copy()
    tsu.returnize0(daily_port_returns)
    
    vol = np.std(daily_port_returns)
    daily_ret = np.average(daily_port_returns)
    
    sharpe = tsu.get_sharpe_ratio(daily_port_returns)
    #tsu.sharpeRatio(cum_daily_port_value)
    return cum_ret, vol, daily_ret, sharpe, na_normalized_price
コード例 #3
0
ファイル: fundutil.py プロジェクト: Afey/QuantSoftwareToolkit
def get_sharpe_ratio(fund_ts):
    """
    @summary Returns daily computed Sharpe ratio of fund time series
    @param fund_ts: pandas time series of daily fund values
    @return  Sharpe ratio of  fund time series
    """
    return tsu.get_sharpe_ratio(tsu.daily(fund_ts))
コード例 #4
0
def print_performance( fund, bench):
    print "Details of the Performance of the portfolio :\n"

    print "Data Range : ", fund.index[0], " to " ,fund.index[-1],"\n"

    print "Sharpe Ratio of Fund : ", tsu.get_sharpe_ratio(tsu.daily(fund))[0]
    print "Sharpe Ratio of " + benchmark +" :", tsu.get_sharpe_ratio(tsu.daily(bench))[0],"\n"

    print 'Total Return of Fund :', (fund[-1] / fund[0] - 1) + 1
    print 'Total Return of ' + benchmark + ' : ', (bench[-1] / bench[0] -1) + 1, "\n"

    print 'Standard Deviation of Fund : ' + str(np.std(tsu.daily(fund.values)))
    print 'Standard Deviation of ' + benchmark + ' : ', np.std(tsu.daily(bench.values)), "\n"

    print 'Average Daily Return of Fund : ', np.mean( tsu.daily(fund.values))
    print 'Average Daily Return of ' + benchmark + ' : ', np.mean( tsu.daily(bench.values))
コード例 #5
0
def simulate(startdate, enddate, symbols, allocation, type):
  timeofday = dt.timedelta(hours=16)
  timestamps = du.getNYSEdays(startdate, enddate, timeofday)
  c_dataobj = da.DataAccess('Yahoo')
  ls_keys = [type]
  ldf_data = c_dataobj.get_data(timestamps, symbols, ls_keys)
  d_data = dict(zip(ls_keys, ldf_data))
  #print d_data.values
  na_price = d_data[type].values
  print 'price', na_price[0], na_price[-1]
  #print 'na', na_price
  #print 'na_price', na_price
  normalized_price = na_price / na_price[0, :]
  #print 'norm', normalized_price
  c = normalized_price * allocation
  #print 'n*a', allocation, c
  invest = c.sum(axis=1)
  #print 'c', c
  #print 'invesi', invest


  daily_returns = tsu.daily(invest) 
  mean_daily_return = np.mean(daily_returns) 
  stdev_daily_return = np.std(daily_returns)
  sharpe_ratio = tsu.get_sharpe_ratio(daily_returns)
  return stdev_daily_return, mean_daily_return, sharpe_ratio, invest[-1]
コード例 #6
0
def portfolio_simulate(start_date, end_date, symbols, allocations):
    """ For the given portfolio and dates, calculate the std deviation of daily returns (volatility), the average
     daily return, the sharpe ratio, and the cumulative return """

    # Generate timestamps for the NYSE closing times
    closing_time = dt.timedelta(hours=16)
    timestamps = date_util.getNYSEdays(start_date, end_date, closing_time)

    # Get adjusted closing prices
    #stock_dao = data_access.DataAccess('Yahoo', cachestalltime=0)
    stock_dao = data_access.DataAccess('Yahoo')
    stock_data_as_list_of_data_frames = stock_dao.get_data(timestamps, symbols, ['close'])
    portfolio_closing_values = stock_data_as_list_of_data_frames[0]

    # Calculate adjusted closing prices normalized relative to initial closing prices
    initial_portfolio_closing_values = portfolio_closing_values.values[0,:]
    portfolio_normalized_closing_values = portfolio_closing_values / initial_portfolio_closing_values

    # Calculated portfolio normalized values
    portfolio_normalized_weighted_closing_values = portfolio_normalized_closing_values * allocations
    portfolio_normalized_values = portfolio_normalized_weighted_closing_values.sum(axis=1)

    # Calculate the portfolio statistics
    cumulative_return = portfolio_normalized_values[-1]
    daily_returns = tsu.returnize0(portfolio_normalized_values)
    ave_daily_return = daily_returns.mean()
    std_deviation = daily_returns.std()
    sharpe_ratio = tsu.get_sharpe_ratio(daily_returns, 0.0)[0]

    return start_date, end_date, symbols, allocations, sharpe_ratio, std_deviation, ave_daily_return, cumulative_return
コード例 #7
0
def get_sharpe_ratio(fund_ts):
    """
    @summary Returns daily computed Sharpe ratio of fund time series
    @param fund_ts: pandas time series of daily fund values
    @return  Sharpe ratio of  fund time series
    """
    return tsu.get_sharpe_ratio(tsu.daily(fund_ts))
コード例 #8
0
def simulate(values):
    values = values
    normalizedvalues = values
    normalizedvalues = normalizedvalues[:] / normalizedvalues[0]
    dailyreturns = normalizedvalues.copy()
    tsutil.returnize0(dailyreturns)
    standarddeviation = numpy.std(dailyreturns)
    averagedailyreturn = numpy.average(dailyreturns)
    sharperatio = tsutil.get_sharpe_ratio(dailyreturns)
    # Estimate portfolio returns>
    cumulativereturn = numpy.prod(dailyreturns+1)
    return sharperatio,standarddeviation,averagedailyreturn,cumulativereturn
def simulate(dt_start, dt_end, ls_symbols, allocation):
    # 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 with Yahoo as the source.
    c_dataobj = da.DataAccess('Yahoo')

    # 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

    # Compute normalized daily returns

    # Normalizing the prices to start at 1 and see relative returns
    na_normalized_price = na_price / na_price[0, :]

    # 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)

    # Compute average daily return of the total portfolio
    # Compute standard deviation of daily returns of the total portfolio
    daily_ret_portfolio = np.average(na_rets, axis=1, weights=allocation)
    avg_daily_ret_portfolio = np.average(daily_ret_portfolio)
    std_daily_ret_portfolio = np.std(daily_ret_portfolio)

    # Compute sharpe ratio (252 trading days in year, risk free rate = 0)
    sharpe_ratio_portfolio = tsu.get_sharpe_ratio(rets=daily_ret_portfolio, risk_free=0.00)

    # Compute return of the total portfolio
    yearly_ret_portfolio = np.average(na_normalized_price[-1], weights=allocation)

    return (sharpe_ratio_portfolio, std_daily_ret_portfolio, avg_daily_ret_portfolio, yearly_ret_portfolio)
コード例 #10
0
def simulate(startdate, enddate, symbols, allocations):
    # 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(startdate, enddate, dt_timeofday)

    # Creating an object of the dataaccess class with Yahoo as the source.
    c_dataobj = da.DataAccess('Yahoo')

    # Keys to be read from the data, it is good to read everything in one go.
    ls_keys = ['close']

    # Reading the data, now d_data is a dictionary with the keys above.
    # Timestamps and symbols are the ones that were specified before.
    data = c_dataobj.get_data(ldt_timestamps, symbols, ls_keys)[0]

    returns = tsu.returnize1(data)

    previous_day = None

    for row in data.iterrows():
        day = row[0]
        series = row[1]
        if previous_day is None:
            for symbol in symbols:
                index = symbols.index(symbol)
                allocation = allocations[index]
                series[symbol] = allocation
        else:
            daily_returns = returns.loc[day]
            for (symbol, price) in series.iteritems():
                series[symbol] = previous_day[symbol] * daily_returns[symbol]

        previous_day = series

    daily_sum = data.apply(lambda row : row[0] + row[1] + row[2] + row[3], 1)

    tsu.returnize0(daily_sum)

    stats = daily_sum.describe()

    std_dr = stats['std']
    mean_dr = stats['mean']
    sharpe = tsu.get_sharpe_ratio(daily_sum.values)

    cumulative_return = 1
    for value in daily_sum:
        value += 1
        cumulative_return = cumulative_return * value

    return std_dr, mean_dr, sharpe, cumulative_return
コード例 #11
0
ファイル: analyze.py プロジェクト: RiskUniverse/compinvest
def get_performance(na_price):
    na_normalized_price = na_price / na_price[0.0, :]

    # Our daily return
    tsu.returnize0(na_normalized_price)

    sharpe_ratio = tsu.get_sharpe_ratio(na_normalized_price)[0]
    na_cumulative_returns = np.cumprod(na_normalized_price + 1)
    total_returns = na_cumulative_returns[-1]
    std_dev = np.std(na_normalized_price)
    mean = np.mean(na_normalized_price)

    return sharpe_ratio, total_returns, std_dev, mean
コード例 #12
0
ファイル: marketsim.py プロジェクト: drbothen/Coursera
def calculate_ratios(portfolio_plus_cash, column_name):

    total_return = portfolio_plus_cash.iloc[len (portfolio_plus_cash.index) - 1][column_name] / portfolio_plus_cash.iloc[0][column_name]

    returns = tsu.returnize0(portfolio_plus_cash)

    stats = returns.describe()

    sharpe_ratio = tsu.get_sharpe_ratio(returns.values)[0]
    standard_deviation = stats.ix['std'][column_name]
    average_daily_return = stats.ix['mean'][column_name]

    return total_return, sharpe_ratio, standard_deviation, average_daily_return
コード例 #13
0
ファイル: One.py プロジェクト: calesennett/comp_inv_hw1
def simulate(distro, data):
  prices = data['close'].values
  normal_prices = normalize(prices)
  adj_values = alloc_adj(normal_prices.copy(), distro)
  daily_values = daily_value(adj_values)
  daily_rets = tsu.daily(daily_values)

  volatility = np.std(daily_rets)
  sharpe = tsu.get_sharpe_ratio(daily_rets)[0]
  cum_ret = np.sum(daily_rets, axis=0)[0]
  avg_daily_ret = cum_ret / len(daily_rets)

  return daily_rets, volatility, avg_daily_ret, sharpe, (cum_ret + 1)
コード例 #14
0
ファイル: homework1.py プロジェクト: dbarkman/CompFinHomework
def calculatePortfolio(startDate, endDate, symbols, allocations):
    stockDataDictionary = getStockData(startDate, endDate, symbols)
    closePrices = stockDataDictionary['close'].values

    tsu.returnize0(closePrices)
    sumDailyreturns = np.sum(closePrices * allocations, axis=1)

    sharpeRatio = tsu.get_sharpe_ratio(sumDailyreturns)
    standardDeviation = np.std(sumDailyreturns)
    averageDailyReturn = np.average(sumDailyreturns)
    totalReturn = np.prod(sumDailyreturns + 1)

    return sharpeRatio, standardDeviation, averageDailyReturn, totalReturn
コード例 #15
0
def simulate(dt_start, dt_end, ls_symbols, allocations):
    """
    outputs:
        - stadard deviation of returns
        - average daily returns
        - sharpe ratio 
        - cumulative return of portfolio
        data : dict of keys (ie close, vol, open etc) 
        where each value is a data fram
    """
    portfolio_stdev_ret = 0
    avg_daily_ret = 0
    sharpe = 0
    cum_ret = 0

    dt_timeofday = dt.timedelta(hours=16)
    ldt_timestamps = du.getNYSEdays(dt_start, dt_end, dt_timeofday)
    data = get_data(ldt_timestamps, ls_symbols, ["close","vol"])
    d_allocations = dict(zip(ls_symbols, allocations))
    # for each day,the weighted sum of the returns of all stocks

    #  calculate the portfolio return to date

    price = data["close"].values
    normalized_price = (price/price[0,:])
    normalized_prices = normalized_price.copy()
    #daily_returns = tsu.returnize1(na_returns)
    daily_returns = normalized_prices
    
    #df_cum =  pd.DataFrame(cum_returns, index=ldt_timestamps, columns=ls_symbols)
    df_dr = pd.DataFrame(daily_returns, index=ldt_timestamps, columns=ls_symbols)
    df_dr.to_csv("/home/mcstar/daily_returns_cum.csv")     
    portfolio_dr = pd.DataFrame()
    portfolio_cum = pd.DataFrame()

    for symbol in ls_symbols:
        portfolio_dr[symbol] = (df_dr[symbol]) * d_allocations[symbol]

    portfolio_dr["ret"] = portfolio_dr.sum(axis=1)
    ret = portfolio_dr["ret"].copy()
    portfolio_dr["daily_ret"] = tsu.returnize0(ret)
    #portfolio_dr["ret_cum"] = (1+ portfolio_dr["ret"]).cumprod() -1 
    
    portfolio_dr.to_csv("/home/mcstar/portfolio.csv")
    portfolio_stdev_ret = float(portfolio_dr["daily_ret"].std())
    cum_ret = float(portfolio_dr["ret"].iloc[-1])
    avg_daily_ret = float(portfolio_dr["daily_ret"].mean())
    sharpe = float(tsu.get_sharpe_ratio(portfolio_dr["daily_ret"]))
    return (portfolio_stdev_ret, avg_daily_ret, sharpe, cum_ret)
コード例 #16
0
ファイル: Three.py プロジェクト: calesennett/comp_inv_hw3
def main():
    if (len(sys.argv) == 3):
        order_book = list(read_csv(sys.argv[2]))

        s_date = dt.datetime(2008, 2, 25)
        e_date = dt.datetime(2009, 12, 31)

        symbols, data = setup(s_date, e_date, order_book)
        dates, port = trade(float(sys.argv[1]), order_book, symbols, data)
        port = [x for x in port if not np.isnan(x)]
        print port
        returns = tsu.returnize0(port)

        spx_data = [{'Sym': '$SPX'}]
        symbols, data = setup(s_date, e_date, spx_data)
        spx_returns = tsu.returnize0(data['close']['$SPX'].values)

        sharpe = tsu.get_sharpe_ratio(returns)[0]
        spx_sharpe = tsu.get_sharpe_ratio(spx_returns)[0]
        std_dev = np.std(returns)
        spx_std_dev = np.std(spx_returns)
        avg_daily = returns / len(returns)
        spx_avg_daily = spx_returns / len(spx_returns)

        print "Sharpe Ratio: " + str(sharpe)
        print "SPX Sharpe Ratio: " + str(spx_sharpe)
        print "\nTotal Return: " + str(float(sum(returns) + 1))
        print "SPX Total Return: " + str(float(sum(spx_returns) + 1))
        print "\nStandard Deviation: " + str(std_dev)
        print "SPX Standard Deviation: " + str(spx_std_dev)
        print "\nAverage Daily Return: " + str(float(sum(avg_daily)))
        print "SPX Average Daily Return: " + str(float(sum(spx_avg_daily)))


    else:
        print("Please specify orders file and output file.")
コード例 #17
0
def simulate (startDate, endDate, stocks, stocksDistribution):
    stockDataDictionary=getStockDataAsDictionary(startDate,endDate,stocks)
    closePrices = stockDataDictionary['close'].values
    closePrices = closePrices
    normalizedPrices = closePrices.copy()
    normalizedPrices = normalizedPrices / normalizedPrices[0,:]
    dailyReturns = normalizedPrices.copy()
    tsutil.returnize0(dailyReturns)
    sumDailyreturns = numpy.sum(dailyReturns*stocksDistribution,axis=1)
    standardDeviation = numpy.std(sumDailyreturns)
    averageDailyReturn = numpy.average(sumDailyreturns)
    sharpeRatio = tsutil.get_sharpe_ratio(sumDailyreturns)
    # Estimate portfolio returns
    cumulativeReturn = numpy.prod(sumDailyreturns+1)
    return sharpeRatio,standardDeviation,averageDailyReturn,cumulativeReturn
コード例 #18
0
ファイル: homework_1.py プロジェクト: RiskUniverse/compinvest
def simulate(dt_start, dt_end, ls_syms, ls_alloc):

    """
    # 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 with Yahoo as the source.
    c_dataobj = da.DataAccess('Yahoo')

    # 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_syms, 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)
    """
    d_data = get_stock_data(dt_start, dt_end, ls_syms)
    # Getting the numpy ndarray of close prices.
    na_price = d_data['close'].values

    na_normalized_price = na_price / na_price[0, :]

    # Daily returns by allocation
    na_returns_alloc = np.sum(na_normalized_price * ls_alloc, axis=1)

    na_rets = na_returns_alloc.copy()
    # Our daily return
    tsu.returnize0(na_returns_alloc)

    sharpe_ratio = tsu.get_sharpe_ratio(na_returns_alloc)
    na_cumulative_returns = np.cumprod(na_returns_alloc + 1)
    std_dev = np.std(na_returns_alloc)
    mean = np.mean(na_returns_alloc)

    return na_rets, sharpe_ratio, std_dev, mean, na_cumulative_returns[-1]
コード例 #19
0
def run(values, symbol):
  #data = pd.read_csv(values, header=False)
  data = np.loadtxt(values, delimiter=';', skiprows=0)
  values = data[:,3]
  #values = data.values[:,3]
  #invest = values.sum(axis=1)
  normalized_price = values / values[0]
  daily_returns = tsu.daily(normalized_price) 
  mean_daily_return = np.mean(daily_returns) 
  stdev_daily_return = np.std(daily_returns)
  sharpe_ratio = tsu.get_sharpe_ratio(daily_returns)
  total_return = values[-1] / values[0]
  print 'returns', sharpe_ratio, total_return, stdev_daily_return, mean_daily_return
  
  startdate = dt.datetime(int(data[0][0]), int(data[0][1]), int(data[0][2]), 16)
  enddate = dt.datetime(int(data[-1][0]), int(data[-1][1]), int(data[-1][2]), 16)
  allocation = [1.0]
  print 'SPX', startdate, enddate, symbol, allocation
  result = sm.simulate(startdate, enddate, [symbol], allocation, 'close')
  print 'result', result[2], result[3], result[0], result[1]
コード例 #20
0
def run(values, symbol):
  #data = pd.read_csv(values, header=False)
  data = np.loadtxt(values, delimiter=';', skiprows=0)
  #print 'Data', data
  values = data[:,3]
  #print 'Values', values
  #values = data.values[:,3]
  #invest = values.sum(axis=1)
  normalized_price = values / values[0]
  daily_returns = tsu.daily(normalized_price) 
  mean_daily_return = np.mean(daily_returns) 
  stdev_daily_return = np.std(daily_returns)
  sharpe_ratio = tsu.get_sharpe_ratio(daily_returns)
  total_return = values[-1] / values[0]
  print 'Total', values[-1], values[0]
#  print 'returns', sharpe_ratio, total_return, stdev_daily_return, mean_daily_return
  
  startdate = dt.datetime(int(data[0][0]), int(data[0][1]), int(data[0][2]), 16)
  enddate = dt.datetime(int(data[-1][0]), int(data[-1][1]), int(data[-1][2]), 16)
  allocation = [1.0]
#  print 'SPX', startdate, enddate, symbol, allocation
  result = sm.simulate(startdate, enddate, [symbol], allocation, 'close')
#  print 'result', result[2], result[3], result[0], result[1]
  f = data[-1]
  print 'The final value of the portfolio using the sample file is -- %d-%d-%d -> %.2f ' % (f[0], f[1], f[2], f[3]) #2009,12,28,54824.0
  print ''
  print 'Details of the Performance of the portfolio'
  print ''
  print 'Data Range : %d-%d-%d to %d-%d-%d' % (data[0][0], data[0][1], data[0][2], data[-1][0], data[-1][1], data[-1][2])
  print ''
  print 'Sharpe Ratio of Fund : %.12f' % (sharpe_ratio)# 0.527865227084
  print 'Sharpe Ratio of $SPX : %.12f'% (result[2])#-0.184202673931
  print ''
  print 'Total Return of Fund %.12f:' % (total_return)#  1.09648
  print 'Total Return of $SPX %.12f:' % (result[3])# 0.779305674563'
  print ''
  print 'Standard Deviation of Fund : %.12f' % stdev_daily_return# 0.0060854156452
  print 'Standard Deviation of $SPX : %.12f' % result[0]#0.022004631521'
  print ''
  print 'Average Daily Return of Fund : %.12f' % mean_daily_return# 0.000202354576186
  print 'Average Daily Return of $SPX : %.12f' % result[1]#-0.000255334653467'
コード例 #21
0
ファイル: analyze.py プロジェクト: ferpsanta/Comp-Investing
def calculatePerformance(na_portfolio_value):
  #Normalize data 
  na_norm_return = na_portfolio_value / na_portfolio_value[1]

  #Portfolio daily return => ret(t) = (price(t)/price(t-1)) -1
  na_ret = na_norm_return.copy()
  tsu.returnize0(na_ret)

  #Portfolio stadistics
  ##Standard daily deviation
  na_std_ret = np.std(na_ret)
  ##Final return
  na_final_ret = na_norm_return[-1]
  ##Mean portfolio return
  na_mean_ret = np.mean(na_ret)
  ##Average daily return
  na_avg_ret = np.mean(na_ret)
  ##Sharpe Ratio
  na_sharpe_ratio = tsu.get_sharpe_ratio(na_ret)

  return (na_std_ret, na_final_ret, na_mean_ret, na_sharpe_ratio)
コード例 #22
0
ファイル: hmwork_1.py プロジェクト: ferpsanta/Comp-Investing
def simulate(startdate, enddate, symbols, allocation, plot):
    #Get data values (only interested in close ftm)
    dt_timeofday = dt.timedelta(hours=16)
    ldt_timestamps = du.getNYSEdays(dt_start, dt_end, dt_timeofday)
    c_dataobj = da.DataAccess('Yahoo')
    ls_keys = ['close']
    ldf_data = c_dataobj.get_data(ldt_timestamps, ls_symbols, ls_keys)
    d_data = dict(zip(ls_keys, ldf_data))
    
    #Normalize data
    na_price = d_data['close'].values
    na_norm_price = na_price / na_price[0,:]
    
    #Weight normalized values with portfolio allocation
    na_normAllocated_price = na_norm_price.copy() * allocation

    #Cumulative daily portfolio value (normalized)
    na_cumulative_price = np.sum(na_normAllocated_price, axis=1)
    
    #Portfolio daily return => ret(t) = (price(t)/price(t-1)) -1
    na_ret = na_cumulative_price.copy()
    tsu.returnize0(na_ret)

    #Portfolio stadistics
    ##Standard daily deviation
    na_std_ret = np.std(na_ret)
    ##Final return
    na_final_ret = na_cumulative_price[-1]
    ##Mean portfolio return
    na_mean_ret = np.mean(na_ret)
    ##Average daily return
    na_avg_ret = np.mean(na_ret)
    ##Sharpe Ratio
    na_sharpe_ratio = tsu.get_sharpe_ratio(na_ret)

    if plot:
        plotNormalized(ldt_timestamps, na_cumulative_price)
        
    return (na_std_ret, na_final_ret, na_mean_ret, na_sharpe_ratio)
コード例 #23
0
def simulate(startdate, enddate, symbols, allocations, use_cache=0):
    """
    A Python function that can simulate and assess the performance of a 4 stock portfolio.
    Inputs to the function include:
      Start date
      End date
      Symbols for for equities (e.g., GOOG, AAPL, GLD, XOM)
      Allocations to the equities at the beginning of the simulation (e.g., 0.2, 0.3, 0.4, 0.1)
    """

    # Get actual end timestamps for trading days on NYSE
    trading_duration = dt.timedelta(hours=16)
    trading_timestamps = du.getNYSEdays(startdate, enddate, trading_duration)

    # Get data from Yahoo
    data_provider = da.DataAccess('Yahoo', cachestalltime=use_cache) 
    data_keys = ['open', 'high', 'low', 'close', 'volume', 'actual_close']
    data_list = data_provider.get_data(trading_timestamps, symbols, data_keys)
    data = dict(zip(data_keys, data_list))

    # Get 'close' prices and normalized then
    close_prices = data['close'].values
    normalized_close = close_prices / close_prices[0, :]

    # Compute portfolio by multiplying weights
    portfolio_prices = (allocations * normalized_close).sum(axis=1)

    # Compute daily returns for portfolio
    portfolio_rets = portfolio_prices.copy()
    tsu.returnize0(portfolio_rets)

    # Final statistics
    volatility = portfolio_rets.std()
    avg_return = portfolio_rets.mean()
    sharpe = tsu.get_sharpe_ratio(portfolio_rets)
    cum_return = np.prod(1 + portfolio_rets)

    return (volatility, avg_return, sharpe, cum_return)
コード例 #24
0
def run(cash, orders, values, key):
  #print 'Thomas'
  data = pd.read_csv(orders, parse_dates=True, names=['year','month','day','symbol','transaction','nr_shares','empty'], header=0)
  data = data.sort(['year', 'month', 'day']);
  old = data
  #print 'Gyldig', data[(data.day == 10) & (data.month == 6) ]
  #print 'Ugyldug', data[(data.day == 31) & (data.month == 6) ]
  
  array = np.array(data)
  #print array
  symbols = np.unique(array[:,3])
  symbols = np.array(symbols, dtype='S').tolist()
  dt_start = dt.datetime(array[0,0], array[0,1], array[0,2])
  dt_end = dt.datetime(array[-1,0], array[-1,1], array[-1,2], 16)
  print dt_start, dt_end
  'Get stock prices'
  timestamps = du.getNYSEdays(dt_start, dt_end, dt.timedelta(hours=16))
  #print 'Ti', timestamps[-1] 
  dataobj = da.DataAccess('Yahoo')
  data = dataobj.get_data(timestamps, symbols, key)
  price = data.values
  p = pd.DataFrame(price, timestamps)
  
  #print 'price', price
  
  dict = {}
  for i in range(0, len(array)):
    orderRow = array[i]
    date = dt.datetime(orderRow[0], orderRow[1], orderRow[2], 16)
    datacolumn = symbols.index(orderRow[3])
    cell = p.ix[date][datacolumn]    
    #cell = dict[date][datacolumn]
    quantity = orderRow[5]

    if (orderRow[4] == 'Buy'):
      cash = cash - cell * quantity
      #stocks[i][datacolumn] = stockcell + quantity 
    elif (orderRow[4] == 'Sell'):
      cash = cash + cell * quantity
      #stocks[i][datacolumn] = stockcell - quantity
    dict[date] = cash
   # print 'cash', orderRow[4], cash, cell, quantity
  #print dict

  cash_array = np.zeros(len(timestamps))
  for i in range(0, len(timestamps)):
    k = timestamps[i]
    #print k, k in dict
    if (k in dict):
      cash_array[i] = dict[k]
    else:
      cash_array[i] = cash_array[i-1]
    #print cash_array[i]
  #print cash_array

  
  stocks = np.zeros((len(timestamps), len(symbols)))
  for i in range(0, len(timestamps)):
    ts = timestamps[i]
    for j in range(0, len(symbols)):
      o = old[(old.day == ts.day) & (old.month == ts.month) & (old.year == ts.year) & (old.symbol == symbols[j])]
      if i > 0:
        stocks[i][j] = stocks[i-1][j]
      val = stocks[i][j]
      if len(o) > 0:       
        gf = o.values.tolist()
        for k in range(0, len(gf)):         
          row = gf[k]
          if row[4] == 'Buy':
            val = val + row[5]
          else:
            val = val - row[5]
      stocks[i][j]  = val
  #print 'stocks', stocks

  value = np.zeros((len(timestamps), 3))
  for i in range(0,len(timestamps)):
    rowprice = 0
    for j in range(0, len(symbols)):
      rowprice = rowprice + stocks[i][j] * price[i][j]
    value[i][0] = rowprice
    value[i][1] = cash_array[i]
    value[i][2] = rowprice + cash_array[i]
  
  #print 'value', value[:,2]  
  
  #print 'stocks', stocks[5:], len(stocks)
  #print 'Data', data[:5]
  na_price = value[:,0]
  #print 'na', len(na_price), na_price[0]
  #print 'type', type(na_price)
  normalized_price = price / price[0, :]
  #print 'normal', normalized_price[5:], len(normalized_price)
  #invest = normalized_price.sum()
  #stocks = [1.0, 1.0, 1.0, 0.0]
  #print 'stocks', stocks[:5]
  c = normalized_price * stocks
  #print 'n*a', allocation, c
  #print "c", c[:10]
  #print 'normal', normalized_price[:20]
  #invest = c.sum(axis=1)
  invest = c.sum(axis=1)
  
  print 'c', c#[-5:]
  print 'invest', invest[:20]

  #daily_returns = tsu.returnize0(invest)
  daily_returns = tsu.daily(invest) 
  mean_daily_return = np.mean(daily_returns) 
  stdev_daily_return = np.std(daily_returns)
  sharpe_ratio = tsu.get_sharpe_ratio(daily_returns)
  
  print 'returns', mean_daily_return, stdev_daily_return, sharpe_ratio, invest[-1]
  times = np.zeros((len(timestamps),4))
  for i in range(0, len(timestamps)):
    times[i][0] = timestamps[i].year
    times[i][1] = timestamps[i].month
    times[i][2] = timestamps[i].day
    times[i][3] = value[:,2][i]

  np.savetxt(values, times, fmt='%d', delimiter=';')
コード例 #25
0
    dataobj = da.DataAccess('Yahoo')
    close = dataobj.get_data(timestamps, [symbol], "close", verbose=True)
    close = close.fillna(method='ffill')
    close = close.fillna(method='bfill')
    return close[symbol]

ts_fund = _csv_read_fund(sys.argv[1])
benchmark = sys.argv[2]
bench_vals = _read_bench(benchmark, list(ts_fund.index))
# print bench_vals
multiple = ts_fund[0] / bench_vals[0]
bench_vals = bench_vals * multiple

print "Details of the Performance of the portfolio"
print 'Data Range : ', ts_fund.index[0], ' to ', ts_fund.index[-1]
print 'Sharpe Ratio of Fund :', tsu.get_sharpe_ratio(tsu.daily(ts_fund))[0]
print 'Sharpe Ratio of ' + benchmark + ' :', tsu.get_sharpe_ratio(
                                          tsu.daily(bench_vals))[0]
print 'Total Return of Fund : ', (((ts_fund[-1] / ts_fund[0]) - 1) + 1)
print 'Total Return of ' + benchmark + ' :', (((bench_vals[-1]
                                            / bench_vals[0]) - 1) + 1)
print 'Standard Deviation of Fund : ', np.std(tsu.daily(
                                       ts_fund.values))
print 'Standard Deviation of ' + benchmark + ' :', np.std(
                                       tsu.daily(bench_vals.values))

print 'Average Daily Return of Fund : ', np.mean(tsu.daily(
                                       ts_fund.values))
print 'Average Daily Return of ' + benchmark + ' :', np.mean(
                                       tsu.daily(bench_vals.values))
コード例 #26
0
    close = dataobj.get_data(timestamps, [symbol], "close", verbose=True)
    close = close.fillna(method='ffill')
    close = close.fillna(method='bfill')
    return close[symbol]


ts_fund = _csv_read_fund(sys.argv[1])
benchmark = sys.argv[2]
bench_vals = _read_bench(benchmark, list(ts_fund.index))
# print bench_vals
multiple = ts_fund[0] / bench_vals[0]
bench_vals = bench_vals * multiple

print "Details of the Performance of the portfolio"
print 'Data Range : ', ts_fund.index[0], ' to ', ts_fund.index[-1]
print 'Sharpe Ratio of Fund :', tsu.get_sharpe_ratio(tsu.daily(ts_fund))[0]
print 'Sharpe Ratio of ' + benchmark + ' :', tsu.get_sharpe_ratio(
    tsu.daily(bench_vals))[0]
print '\n'
print 'Total Return of Fund : ', (((ts_fund[-1] / ts_fund[0]) - 1) + 1)
print 'Total Return of ' + benchmark + ' :', ((
    (bench_vals[-1] / bench_vals[0]) - 1) + 1)
print '\n'
print 'Standard Deviation of Fund : ', np.std(tsu.daily(ts_fund.values))
print 'Standard Deviation of ' + benchmark + ' :', np.std(
    tsu.daily(bench_vals.values))
print '\n'
print 'Average Daily Return of Fund : ', np.mean(tsu.daily(ts_fund.values))
print 'Average Daily Return of ' + benchmark + ' :', np.mean(
    tsu.daily(bench_vals.values))
コード例 #27
0
ファイル: analyze.py プロジェクト: DariuszOstolski/courses
def compute_sharpe_ratio(values):
  return tsu.get_sharpe_ratio(values)
コード例 #28
0
ファイル: analyze.py プロジェクト: z0r00/ML4T_coursera

##
##dataobj = da.DataAccess('Yahoo') #data from yahoo
##close = dataobj.get_data(list(ts_fundvalues.index), ['SPY'], ['Close']) #pass a list of symbols to da.get_data
##close = close.fillna(method='ffill')
##close = close.fillna(method='bfill')
##ts_benchmark_values = pd.TimeSeries( dict(zip(list(ts_fundvalues.index), close['SPY'])))
####



# calculate charpe ratios
daily_fund_rets = tsu.daily(ts_fundvalues)
daily_benchmark_rets = tsu.daily(ts_benchmark_values)
sharpe_fund = tsu.get_sharpe_ratio(daily_fund_rets)[0] #note the tsu.get_sharpe_raio returns an ARRAY of ONE value (sharpe ratio)
sharpe_benchmark = tsu.get_sharpe_ratio(daily_benchmark_rets)[0]
std_fund = np.std(daily_fund_rets, axis = 0)[0] #numpy.std returns an ARRAY, so take the 0th elt in the array
std_benchmark = np.std(daily_benchmark_rets, axis = 0)[0]
avg_dailyret_fund = np.mean(daily_fund_rets, axis = 0)[0]
avg_dailyret_benchmark = np.mean(daily_benchmark_rets, axis = 0)[0]

print 'The final value of the portfolio using the sample file is: ' , ts_fundvalues.index[-1], ': $' , ts_fundvalues[-1]
print "Details of the performance of the portfolio: "
print "Data range: ", start_date, " to " , end_date
print "Sharpe Ratio of fund: ", sharpe_fund
print "Sharpe Ratio of Benchmark: ", input_benchmark, ": ", sharpe_benchmark
print "Standard Deviation of Fund :  ", std_fund
print "Standard Deviation of $SPX : ", std_benchmark
print "Average Daily Return of Fund :  ", avg_dailyret_fund
print "Average Daily Return of $SPX : ", avg_dailyret_benchmark
コード例 #29
0
ファイル: analyze.py プロジェクト: kzjeef/comp_invest
def do_analysis(values, benchmark_sym):
    # first, needs figure out begin and end date.
    # then needs to take out benchmark values.
    # finnaly plot together.

    first_value = values[0]
    last_value = values[-1]
    dt_start = dt.datetime(first_value[0], first_value[1], first_value[2])
    dt_end = dt.datetime(last_value[0], last_value[1], last_value[2])
    dt_end += dt.timedelta(days=1)
    symbols = [benchmark_sym]
    dt_timeofday = dt.timedelta(hours=16)

    ldt_timestamps = du.getNYSEdays(dt_start, dt_end, dt_timeofday);

    dataobj = da.DataAccess('Yahoo')
    ls_keys =  ['close']#['open', 'high', 'low', 'close', 'volume', 'actual_close']
    ldf_data = dataobj.get_data(ldt_timestamps, symbols, ls_keys, verbose=True)

    d_data = dict(zip(ls_keys, ldf_data))

    # print d_data

    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)


    benchmark = d_data['close'][benchmark_sym];
#    print normalized_benchmark[0];
    factory = values[0][3] / benchmark[0];

    # normalized to same factory to fund value.
    normalized_benchmark = benchmark * factory

    normalized_values = map(lambda x: x[3], values)

    plt.clf()
    plt.plot(ldt_timestamps, normalized_benchmark, "r",
             ldt_timestamps, normalized_values)
    plt.legend([ benchmark_sym, 'fund value'])
    plt.ylabel('Fund Value')
    plt.xlabel('Date')
    plt.savefig('analysis.pdf', format='pdf')

    daily_ret_my = daily_ret(normalized_values)
    daily_ret_bm = tsu.daily(d_data['close'][benchmark_sym])

    sharp_ratio_my = tsu.get_sharpe_ratio(daily_ret_my)
    sharp_ratio_bm = tsu.get_sharpe_ratio(daily_ret_bm)[0]
    # why -1 and +1 ?
    total_ret_my =  (float(normalized_values[-1]) / float(normalized_values[0]))

    total_ret_bm = float(benchmark[-1] / float(benchmark[0]))

    stddev_my = np.std(daily_ret_my)
    stddev_bm = np.std(daily_ret_bm)
    avg_my  = np.average(daily_ret_my)
    avg_bm  = np.average(daily_ret_bm)

    print "Details of the Performance of the portfolio :"
    print ""
    print "Data Range :  %s  to  %s" % (ldt_timestamps[0], ldt_timestamps[-1])
    print ""
    print "Sharpe Ratio of Fund : %f" % sharp_ratio_my
    print "Sharpe Ratio of $SPX : %fy" % sharp_ratio_bm
    print ""
    print "Total Return of Fund :  %f" % total_ret_my
    print "Total Return of $SPX : %f" % total_ret_bm
    print ""
    print "Standard Deviation of Fund :  %f" % stddev_my
    print "Standard Deviation of $SPX : %f" % stddev_bm
    print ""
    print "Average Daily Return of Fund :  %f" % avg_my
    print "Average Daily Return of %s : %f" % (benchmark_sym, avg_bm)
コード例 #30
0
ファイル: SharpeRatio.py プロジェクト: YEULAB/financial_code
import matplotlib.pyplot as plt
from pylab import *
import pandas

print pandas.__version__
#
# Prepare to read the data
startday = dt.datetime(2011, 1, 1)
endday = dt.datetime(2011, 12, 31)
timeofday=dt.timedelta(hours=16)
timestamps = du.getNYSEdays(startday, endday, timeofday)

#
#Read close data from symbols list
dataobj = da.DataAccess('Yahoo')
symbols = dataobj.get_all_symbols()
close = dataobj.get_data(timestamps, symbols, "close", verbose=True)

#
#Calculate daily_return
trading_date = close.index
daily_price = close.values.copy()
daily_rets = close.values.copy()
tsu.fillforward(daily_rets)
tsu.fillbackward(daily_rets)
tsu.returnize0(daily_rets)
sharpe_list = sorted(zip(tsu.get_sharpe_ratio(daily_rets), daily_price[-1, :] / daily_price[0, :] - 1, symbols), reverse=True)
#Filter NaN value
sharpe_list = [f for f in sharpe_list if not math.isnan(f[0]) and not math.isnan(f[1])]
print sharpe_list
コード例 #31
0
def run(cash, orders, values, key):
    # print 'Thomas'
    data = pd.read_csv(
        orders,
        parse_dates=True,
        names=["year", "month", "day", "symbol", "transaction", "nr_shares", "empty"],
        header=0,
    )
    data = data.sort(["year", "month", "day"])
    old = data
    data.to_csv("regneark.csv")
    # print "Data2", data.values
    # print 'Gyldig', data[(data.day == 10) & (data.month == 6) ]
    # print 'Ugyldug', data[(data.day == 31) & (data.month == 6) ]

    array = np.array(data)
    # print array
    symbols = np.unique(array[:, 3])
    symbols = np.array(symbols, dtype="S").tolist()
    dt_start = dt.datetime(array[0, 0], array[0, 1], array[0, 2])
    dt_end = dt.datetime(array[-1, 0], array[-1, 1], array[-1, 2], 16)
    print dt_start, dt_end
    "Get stock prices"
    timestamps = du.getNYSEdays(dt_start, dt_end, dt.timedelta(hours=16))
    # print 'Ti', timestamps[-1]
    dataobj = da.DataAccess("Yahoo")
    data = dataobj.get_data(timestamps, symbols, key)
    price = data.values
    p = pd.DataFrame(price, timestamps)

    # print 'price', price

    dict = {}
    for i in range(0, len(array)):
        orderRow = array[i]
        date = dt.datetime(orderRow[0], orderRow[1], orderRow[2], 16)
        datacolumn = symbols.index(orderRow[3])
        cell = p.ix[date][datacolumn]
        # cell = dict[date][datacolumn]
        quantity = orderRow[5]

        if orderRow[4] == "Buy":
            cash = cash - cell * quantity
            # stocks[i][datacolumn] = stockcell + quantity
        elif orderRow[4] == "Sell":
            cash = cash + cell * quantity
            # stocks[i][datacolumn] = stockcell - quantity
        dict[date] = cash
    # print 'cash', orderRow[4], cash, cell, quantity
    # print dict

    cash_array = np.zeros(len(timestamps))
    for i in range(0, len(timestamps)):
        k = timestamps[i]
        # print k, k in dict
        if k in dict:
            cash_array[i] = dict[k]
        else:
            cash_array[i] = cash_array[i - 1]
        # print cash_array[i]
    # print 'Cash array', cash_array

    stocks = np.zeros((len(timestamps), len(symbols)))
    for i in range(0, len(timestamps)):
        ts = timestamps[i]
        for j in range(0, len(symbols)):
            o = old[(old.day == ts.day) & (old.month == ts.month) & (old.year == ts.year) & (old.symbol == symbols[j])]
            if i > 0:
                stocks[i][j] = stocks[i - 1][j]
            val = stocks[i][j]
            if len(o) > 0:
                gf = o.values.tolist()
                for k in range(0, len(gf)):
                    row = gf[k]
                    if row[4] == "Buy":
                        val = val + row[5]
                    else:
                        val = val - row[5]
            stocks[i][j] = val
    # print 'stocks', stocks[:5]
    # print 'prices', price[:5]

    value = np.zeros((len(timestamps), 3))
    # value[:,2]=cash
    for i in range(0, len(timestamps)):
        rowprice = 0.0
        for j in range(0, len(symbols)):
            st = stocks[i][j]
            pr = price[i][j]
            mul = st * pr
            if not np.isnan(mul):
                rowprice = rowprice + mul
        value[i][0] = rowprice
        value[i][1] = cash_array[i]
        value[i][2] = rowprice + cash_array[i]
    # print 'value dr', value
    # print 'Vvalue', value[:,2]

    # print 'stocks', stocks[5:], len(stocks)
    # print 'Data', data[:5]
    na_price = value[:, 0]
    # print 'na', len(na_price), na_price[0]
    # print 'type', type(na_price)
    normalized_price = price / price[0, :]
    # print 'normal', normalized_price[5:], len(normalized_price)
    # invest = normalized_price.sum()
    # stocks = [1.0, 1.0, 1.0, 0.0]
    # print 'stocks', stocks[:5]
    c = normalized_price * stocks
    # print 'n*a', allocation, c
    # print "c", c[:10]
    # print 'normal', normalized_price[:20]
    invest = c.sum(axis=1)

    # print 'c', c[-5:]
    # print 'invest', invest[:20]

    # daily_returns = tsu.returnize0(invest)
    daily_returns = tsu.daily(invest)
    mean_daily_return = np.mean(daily_returns)
    stdev_daily_return = np.std(daily_returns)
    sharpe_ratio = tsu.get_sharpe_ratio(daily_returns)

    # print 'returns', mean_daily_return, stdev_daily_return, sharpe_ratio, invest[-1]
    times = np.zeros((len(timestamps), 4))
    value = value.astype(np.int64)
    for i in range(0, len(timestamps)):
        times[i][0] = timestamps[i].year
        times[i][1] = timestamps[i].month
        times[i][2] = timestamps[i].day
        times[i][3] = value[:, 2][i]
        # print 'Times', timestamps[i].year, timestamps[i].month, timestamps[i].day, value[:,2][i]

    np.savetxt(values, times, fmt="%d", delimiter=";")
def main():

    # Read in starting cash balance, file names, and orders
    [values_file, comp_symbol] = sys.argv[1:3]
    # loading text from: http://wiki.quantsoftware.org/index.php?title=QSTK_Tutorial_2
    values = pd.read_csv(values_file, index_col=0)

    # from Homework 2
    # TODO: Correct bad naming conventions for values.
    # TODO: make into function for comparision with S&P

    # for fund
    na_price = values['value'].values
    na_normalized_price = na_price / na_price[0]
    na_rets = na_normalized_price.copy()
    tsu.returnize0(na_rets)
    daily_ret_fund = na_rets
    avg_daily_ret_fund = np.average(daily_ret_fund)
    std_daily_ret_fund = np.std(daily_ret_fund)
    sharpe_ratio_fund = tsu.get_sharpe_ratio(rets=daily_ret_fund, risk_free=0.00)
    total_ret_fund = na_normalized_price[-1]
    
    # for comparision symbol
    # Fetch stock data and fill in NANs.
    c_dataobj = da.DataAccess('Yahoo')
    # Start and end dates
    # TODO: Get from values.csv
    dt_start = dt.datetime(2011, 1, 1, 16)
    dt_end = dt.datetime(2011, 12, 31, 16)
    dt_timeofday = dt.timedelta(hours=16)
    ldt_timestamps = du.getNYSEdays(dt_start, dt_end, dt_timeofday)
    ls_symbols = [comp_symbol]
    # ls_keys = ['open', 'high', 'low', 'close', 'volume', 'actual_close']
    ls_keys = ['actual_close']
    ldf_data = c_dataobj.get_data(ldt_timestamps, ls_symbols, ls_keys)
    d_data = dict(zip(ls_keys, ldf_data))
    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)
    # TODO: Flatten na_price list of lists.
    na_price = d_data['actual_close'].values
    na_normalized_price = na_price / na_price[0]
    na_rets = na_normalized_price.copy()
    tsu.returnize0(na_rets)
    daily_ret_comp = na_rets
    avg_daily_ret_comp = np.average(daily_ret_comp)
    std_daily_ret_comp = np.std(daily_ret_comp)
    sharpe_ratio_comp = tsu.get_sharpe_ratio(rets=daily_ret_comp, risk_free=0.00)
    total_ret_comp = na_normalized_price[-1]

    print "sharpe_ratio_fund = ", sharpe_ratio_fund
    print "sharpe_ratio_comp = ", sharpe_ratio_comp

    print "total_ret_fund = ", total_ret_fund
    print "total_ret_comp = ", total_ret_comp

    print "std_daily_ret_fund = ", std_daily_ret_fund
    print "std_daily_ret_comp = ", std_daily_ret_comp

    print "avg_daily_ret_fund = ", avg_daily_ret_fund
    print "avg_daily_ret_comp = ", avg_daily_ret_comp

    return
def main():

    # Read in starting cash balance, file names, and orders
    [values_file, comp_symbol] = sys.argv[1:3]
    # loading text from: http://wiki.quantsoftware.org/index.php?title=QSTK_Tutorial_2
    values = pd.read_csv(values_file, index_col=0)

    # from Homework 2
    # TODO: Correct bad naming conventions for values.
    # TODO: make into function for comparision with S&P

    # for fund
    na_price = values['value'].values
    na_normalized_price = na_price / na_price[0]
    na_rets = na_normalized_price.copy()
    tsu.returnize0(na_rets)
    daily_ret_fund = na_rets
    avg_daily_ret_fund = np.average(daily_ret_fund)
    std_daily_ret_fund = np.std(daily_ret_fund)
    sharpe_ratio_fund = tsu.get_sharpe_ratio(rets=daily_ret_fund,
                                             risk_free=0.00)
    total_ret_fund = na_normalized_price[-1]

    # for comparision symbol
    # Fetch stock data and fill in NANs.
    c_dataobj = da.DataAccess('Yahoo')
    # Start and end dates
    # TODO: Get from values.csv
    dt_start = dt.datetime(2011, 1, 1, 16)
    dt_end = dt.datetime(2011, 12, 31, 16)
    dt_timeofday = dt.timedelta(hours=16)
    ldt_timestamps = du.getNYSEdays(dt_start, dt_end, dt_timeofday)
    ls_symbols = [comp_symbol]
    # ls_keys = ['open', 'high', 'low', 'close', 'volume', 'actual_close']
    ls_keys = ['actual_close']
    ldf_data = c_dataobj.get_data(ldt_timestamps, ls_symbols, ls_keys)
    d_data = dict(zip(ls_keys, ldf_data))
    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)
    # TODO: Flatten na_price list of lists.
    na_price = d_data['actual_close'].values
    na_normalized_price = na_price / na_price[0]
    na_rets = na_normalized_price.copy()
    tsu.returnize0(na_rets)
    daily_ret_comp = na_rets
    avg_daily_ret_comp = np.average(daily_ret_comp)
    std_daily_ret_comp = np.std(daily_ret_comp)
    sharpe_ratio_comp = tsu.get_sharpe_ratio(rets=daily_ret_comp,
                                             risk_free=0.00)
    total_ret_comp = na_normalized_price[-1]

    print "sharpe_ratio_fund = ", sharpe_ratio_fund
    print "sharpe_ratio_comp = ", sharpe_ratio_comp

    print "total_ret_fund = ", total_ret_fund
    print "total_ret_comp = ", total_ret_comp

    print "std_daily_ret_fund = ", std_daily_ret_fund
    print "std_daily_ret_comp = ", std_daily_ret_comp

    print "avg_daily_ret_fund = ", avg_daily_ret_fund
    print "avg_daily_ret_comp = ", avg_daily_ret_comp

    return