Financial and Data Analytics with Python

def optionValue(S0, vol, T, K=40, M=50, I=4096, r=0.06):
    import numpy as np
    np.random.seed(150000)  # fix the seed for every valuation
    dt = T / M  # time interval
    df = np.exp(-r * dt)  # discount factor per time time interval
    # Simulation of Index Levels
    S = np.zeros((M + 1, I), 'd')  # stock price matrix
    S[0, :] = S0  # intial values for stock price
    for t in range(1, M + 1):
        ran = np.random.standard_normal(I / 2)
        ran = np.concatenate((ran, -ran))  # antithetic variates
        ran = ran - np.mean(ran)  # correct first moment
        ran = ran / np.std(ran)  # correct second moment
        S[t, :] = S[t - 1, :] * np.exp((r - vol ** 2 / 2) * dt
                        + vol * ran * np.sqrt(dt))
    h = np.maximum(K - S, 0)  # inner values for put option
    V = np.zeros_like(h)  # value matrix
    V[-1] = h[-1]
    # Valuation by LSM
    for t in range(M - 1, 0, -1):
        rg = np.polyfit(S[t, :], V[t + 1, :] * df, 5)  # regression
        C = np.polyval(rg, S[t, :])  # evaluation of regression
        V[t, :] = np.where(h[t, :] > C, h[t, :],
                         V[t + 1, :] * df)  # exercise decision/optimization
    V0 = np.sum(V[1, :] * df) / I  # LSM estimator
    print "S0 %4.1f|vol %4.2f|T %2.1f| Option Value %8.3f" % (S0, vol, T, V0)
    return V0

def seqValue():
    optionValues = []
    for S0 in (36., 38., 40., 42., 44.):  # initial stock price values
        for vol in (0.2, 0.4):  # volatility values
            for T in (1.0, 2.0):  # times-to-maturity
                optionValues.append(optionValue(S0, vol, T))
    return optionValues

from time import time
t0 = time()
optionValues = seqValue()  # calculate all values
t1 = time(); d1 = t1 - t0
print "Duration in Seconds %6.3f" % d1

# in the shell ...
####
# ipcluster start -n 8
####
# or maybe more cores, if available

from IPython.parallel import Client
cluster_profile = "default"
# the profile is set to the default one
# see IPython docs for further details
c = Client(profile=cluster_profile)
view = c.load_balanced_view()

def parValue():
    optionValues = []
    for S in (36., 38., 40., 42., 44.):
        for vol in (0.2, 0.4):
            for T in (1.0, 2.0):
                value = view.apply_async(optionValue, S, vol, T)
                # asynchronously calculate the option values
                optionValues.append(value)
    return optionValues

def execution():
    optionValues = parValue()  # calculate all values
    print "Submitted tasks %d" % len(optionValues)
    c.wait(optionValues)
    # wait for all tasks to be finished
    return optionValues
t0 = time()
optionValues = execution()
t1 = time(); d2 = t1 - t0
print "Duration in Seconds %6.3f" % d2

d1 / d2  # speed-up of parallel execution

optionValues[0].result

optionValues[0].metadata

for result in optionValues:
    print result.metadata['stdout'],

import pandas as pd
import pandas.io.data as pdd

AAPL = pdd.DataReader('AAPL', data_source='yahoo', start='1/1/1984')  # retrieve stock prices since IPO 

AAPL

AAPL.head()

AAPL['Close'].plot()

AAPL['log_ret'] = log(AAPL['Close'] / AAPL['Close'].shift(1))

AAPL.head()

AAPL['log_ret'].describe()

AAPL['log_ret'].hist(bins=40)

url = 'http://hopey.netfonds.no/posdump.php?date=20130614&paper=AAPL.O&csv_format=csv'
# you may have to adjust the date since only recent dates are available
AAPL = pd.read_csv(url, index_col=0, header=0, parse_dates=True)

AAPL

AAPL['bid'].plot()

AAPL = AAPL[AAPL.index > datetime.datetime(2013, 6, 14, 12, 0, 0)]  # taking a sub-set of the data

# this resamples the record frequency to 10 minutes, using mean as aggregation rule
AAPL_10min = AAPL.resample(rule='10min', how='mean')
AAPL_10min.head()

AAPL_10min['bid'].plot()

# this function can be applied by management to reverse fortune ...
def f(x):
    return 432 - x + 432

AAPL_10min['bid'].apply(f).plot()

import tables as tb
from tables import *

# h5.close()
h5 = open_file('/home/yhilpisch/Temp/example.h5', 'w')

row_des = {
    'DATE': tb.StringCol(26, pos=1),
    'NO1': tb.Float64Col(pos=2),
    'NO2': tb.Float64Col(pos=3),
    'NO3': tb.Float64Col(pos=4),
    'NO4': tb.Float64Col(pos=5),
    }
filters = tb.Filters(complevel=2)

rows = 10000000
tab = h5.create_table('/', 'dummy_data', title='table', description=row_des, expectedrows=rows, filters=filters)

# populating the table with dummy data
r = tab.row
def genTab():
    for i in range(rows):
        rand = standard_normal(4)
        r['DATE'] = datetime.datetime.now()
        r['NO1'], r['NO2'], r['NO3'], r['NO4'] = rand
        r.append()
    tab.flush()
%time genTab()
tab

# looking into the table
tab[:3]

# histogram of a column's values
hist(tab.cols.NO1[::100], bins=30)
grid(True)

# a SQL-like query for data from two columns
%time res = array([(row['NO1'], row['NO2']) for row in tab.where('((NO1 < -0.5) | (NO1 > 0.5)) & ((NO2 < -1) | (NO2 > 1))')])

res = res[::100]  # only every x-th record
res[:5]

plot(res.T[0], res.T[1], 'ro')
grid(True)

import pandas as pd
%time data = pd.DataFrame(tab.read())
data.index = data['DATE']
del data['DATE']
h5.close()

data

%time data.hist(grid=True, bins=30)

%time res = data[['NO1', 'NO2']][(data.NO1 < -0.5) & (data.NO2 < -1)]

plot(res.NO1, res.NO2, 'ro')
grid(True)

data.boxplot(column=['NO1'], by=['SIGN'])

# Autosave Function for IPyton Notebook
def autosave(interval=3):
    """Autosave the notebook every interval (in minutes)"""
    from IPython.core.display import Javascript
    interval *= 60*1000 # JS wants intervals in miliseconds
    tpl = 'setInterval ( "IPython.notebook.save_notebook()", %i );'
    return Javascript(tpl % interval)
autosave()