Computational Investment:Coursera Work

QSTK_Tutorial_.idea_misc.xml

<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
  <component name="ProjectLevelVcsManager" settingsEditedManually="false">
    <OptionsSetting value="true" id="Add" />
    <OptionsSetting value="true" id="Remove" />
    <OptionsSetting value="true" id="Checkout" />
    <OptionsSetting value="true" id="Update" />
    <OptionsSetting value="true" id="Status" />
    <OptionsSetting value="true" id="Edit" />
    <ConfirmationsSetting value="0" id="Add" />
    <ConfirmationsSetting value="0" id="Remove" />
  </component>
  <component name="ProjectRootManager" version="2" project-jdk-name="Python 2.7.10 (C:\Users\csaini\Anaconda2\python.exe)" project-jdk-type="Python SDK" />
</project>

QSTK_Tutorial_.idea_modules.xml

<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
  <component name="ProjectModuleManager">
    <modules>
      <module fileurl="file://$PROJECT_DIR$/.idea/QSTK_Tutorial.iml" filepath="$PROJECT_DIR$/.idea/QSTK_Tutorial.iml" />
    </modules>
  </component>
</project>

QSTK_Tutorial_.idea_QSTK_Tutorial.iml

<?xml version="1.0" encoding="UTF-8"?>
<module type="PYTHON_MODULE" version="4">
  <component name="NewModuleRootManager">
    <content url="file://$MODULE_DIR$" />
    <orderEntry type="inheritedJdk" />
    <orderEntry type="sourceFolder" forTests="false" />
  </component>
  <component name="TestRunnerService">
    <option name="projectConfiguration" value="Nosetests" />
    <option name="PROJECT_TEST_RUNNER" value="Nosetests" />
  </component>
</module>

QSTK_Tutorial_DataFrame.csv

QSTK_Tutorial_HomeWork1.py

# QSTK Imports
import QSTK.qstkutil.qsdateutil as du
import QSTK.qstkutil.tsutil as tsu
import QSTK.qstkutil.DataAccess as da

# Third Party Imports
import datetime as dt
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd

amount = 10

def main():
    allocation = [0.4, 0.4, 0.0, 0.2]
    # List of symbols
    ls_symbols = ['AAPL', 'GLD', 'GOOG', 'XOM']
    start_date = dt.datetime(2011, 1, 1)
    end_date = dt.datetime(2011, 12, 31)
    std_dev,avg_daily_ret,sharp_ratio,cum_ret=simulate(start_date,end_date,ls_symbols,allocation)
    print 'Std dev: ', std_dev
    print 'avg daily return:', avg_daily_ret
    print 'Sharp ratio:', sharp_ratio
    print 'cumulative return:', cum_ret


def sendToCSV(pd_DataFrame,filename):
    pd_DataFrame.to_csv(filename,sep=',', header=True)

def FundDailyReturn(pd_DataFrame):
        rows=pd_DataFrame.__len__()
        np_arr=np.zeros(rows)
        for n in range(1,rows):
            np_arr[n]=(pd_DataFrame[n]/pd_DataFrame[n-1])-1
        return np_arr


# Method simulate. It takes startdate,enddate,list of symbols,and allocation
def simulate(start_date, end_date,symbols,allocation):
    if type(start_date) == dt.datetime:
        if type(end_date) == dt.datetime:
            if type(symbols)==list and len(symbols)==4 :
                if type(allocation)==list and len(allocation)==4:
                    ls_symbols=symbols
                    # We need closing prices so the timestamp should be hours=16.
                    dt_timeofday = dt.timedelta(hours=16)
                    days_market_open = du.getNYSEdays(start_date, end_date, dt_timeofday)
                    print 'Total Number of trading days between the dates {0!s} : {1!s}  -> {2!s}'.format(
                        start_date.date(),end_date.date(),days_market_open.__len__())
                    # 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']
                    # get the data from the data source related to symbols for the days specified and columns specified
                    # Timestamps and symbols are the ones that were specified before.
                    ldf_data = c_dataobj.get_data(days_market_open, ls_symbols, ls_keys)
                    # add this data to dictionary
                    d_data = dict(zip(ls_keys, ldf_data))
                    # now lets gets data related to key = close
                    np_close_price = d_data['close'].values
                    pd_dataframe = pd.DataFrame(np_close_price, columns=[ls_symbols[0]+'  Closing',
                                                                         ls_symbols[1]+'  closing',
                                                                         ls_symbols[2]+'  Closing',
                                                                         ls_symbols[3]+'  closing'])  # insert stock closing prices cols values into DF
                    na_normalized_price = np_close_price / np_close_price[0,:]  # Dividing the entire matrix by first row to get normalized matrix
                    allocation_cal = na_normalized_price * allocation
                    pd_dataframe.insert(loc=0, column='Date', value=days_market_open)
                    pd_dataframe[ls_symbols[0]+'  Norm_closing'] = pd.DataFrame(na_normalized_price[:, 0])
                    pd_dataframe[ls_symbols[1]+'  Norm_closing'] = pd.DataFrame(na_normalized_price[:, 1])
                    pd_dataframe['GOOD Norm_closing'] = pd.DataFrame(na_normalized_price[:, 2])
                    pd_dataframe[ls_symbols[3]+'  Norm_closing'] = pd.DataFrame(na_normalized_price[:, 3])
                    # Now I am creating and excel like sheet or data frame
                    pd_dataframe[ls_symbols[0]+'  Norm_closing_allocation'] = pd.DataFrame(allocation_cal[:, 0])
                    pd_dataframe[ls_symbols[1]+'  Norm_closing_allocation'] = pd.DataFrame(allocation_cal[:, 1])
                    pd_dataframe[ls_symbols[2]+'  Norm_closing_allocation'] = pd.DataFrame(allocation_cal[:, 2])
                    pd_dataframe[ls_symbols[3]+'  Norm_closing_allocation'] = pd.DataFrame(allocation_cal[:, 3])
                    # Adding normalized closing amt to dataframe
                    pd_dataframe[ls_symbols[0]+'  AMT invested'] = pd.DataFrame(
                        na_normalized_price[:, 0] * (amount * allocation[0]))
                    pd_dataframe[ls_symbols[1]+'  AMT invested'] = pd.DataFrame(
                        na_normalized_price[:, 1] * (amount * allocation[1]))
                    pd_dataframe[ls_symbols[2]+'  AMT invested'] = pd.DataFrame(
                        na_normalized_price[:, 2] * (amount * allocation[2]))
                    pd_dataframe[ls_symbols[3]+'  AMT invested'] = pd.DataFrame(
                        na_normalized_price[:, 3] * (amount * allocation[3]))
                    pd_dataframe['TotRetFund EoD'] = pd_dataframe[ls_symbols[0]+'  AMT invested'] + pd_dataframe[
                        ls_symbols[1]+'  AMT invested'] + pd_dataframe[ls_symbols[2]+'  AMT invested'] + pd_dataframe[ls_symbols[3]+'  AMT invested']
                    print '\ncalculating Fund daily return\n'
                    # print tsu.daily(pd.Series(data=pd_dataframe['TotRetFund EoD'], index=days_market_open))
                    pd_dataframe['FundDailyRet'] = FundDailyReturn(pd_dataframe['TotRetFund EoD'])

                    # print 'DataFrame\n', pd_dataframe
                    sendToCSV(pd_dataframe, 'DataFrame.csv')
                    std_dev=np.std(pd_dataframe['FundDailyRet'])
                    sharp_ratio_ret = tsu.get_sharpe_ratio(FundDailyReturn(pd_dataframe['TotRetFund EoD']))
                    avg_daily_return =  (pd_dataframe['TotRetFund EoD'][251] - pd_dataframe['TotRetFund EoD'][0])/days_market_open.__len__()
                    cumlative_return=  pd_dataframe['TotRetFund EoD'][251] - pd_dataframe['TotRetFund EoD'][0]
                    return std_dev,avg_daily_return,sharp_ratio_ret,cumlative_return

if __name__ == '__main__':
    main()

QSTK_Tutorial_tutorial1.py

#Reading data and basic time series operations and plotting

# QSTK Imports
import QSTK.qstkutil.qsdateutil as du
import QSTK.qstkutil.tsutil as tsu
import QSTK.qstkutil.DataAccess as da

# Third Party Imports
import datetime as dt
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd


def main():
    # List of symbols
    ls_symbols = ["AAPL", "GLD", "GOOG", "$SPX", "XOM"]

    # Start and End date of the charts
    dt_start = dt.datetime(2010, 1, 1)
    dt_end = dt.datetime(2011, 1, 15)
    # 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. days market was open
    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
    plt.clf()
    plt.plot(ldt_timestamps,na_price)
    plt.legend(ls_symbols)
    plt.xlabel('Date')
    plt.ylabel('Adjusted Close')
    plt.show() # this data is not normalised, so we normise it in next step

    na_normalized_price=na_price/na_price[0,:] # Dividing the entire matrix by first row to get normalized matrix
# Plot the normalized

    plt.clf()
    plt.plot(ldt_timestamps, na_normalized_price)
    plt.legend(ls_symbols)
    plt.xlabel('Date')
    plt.ylabel('Adjusted Close')
    plt.show()


    #Daily Returns
# The first 50 days of daily returns for $SPX and XOM.
# It is very often useful to look at the returns by day for individual stocks. The general equation for daily return on day t is:
# ret(t) = (price(t)/price(t-1)) -1
# We can compute this in Python all at once as using the builtin QSTK function returnize0:

    na_rets = na_normalized_price.copy() # copy to another locations
    tsu.returnize0(na_rets)
    plt.clf()
    plt.plot(ldt_timestamps,na_rets[:,0])
    plt.legend(ls_symbols)
    plt.xlabel('Date')
    plt.ylabel('Adjusted Close')
    plt.show()

    #Scatter plot
    plt.clf()
    plt.scatter(na_rets[:, 3], na_rets[:, 1], c='blue') # X= all rows, 4nd col and Y= all rows, 2nd col
    plt.xlabel(ls_symbols[3])
    plt.ylabel(ls_symbols[1])
    plt.show()

    # fit the regressioin line throught he scatter plot
    fit_function= np.polyfit(na_rets[:, 3], na_rets[:, 1],1)
    fit_line=np.poly1d(fit_function)
    plt.clf()
    plt.plot(na_rets[:, 3], na_rets[:, 1], 'bo',na_rets[:, 3],fit_line(na_rets[:, 3]), '--k')  # X= all rows, 4nd col and Y= all rows, 2nd col
    plt.xlabel(ls_symbols[3])
    plt.ylabel(ls_symbols[1])
    plt.show()









if __name__ == '__main__':
        main()