Total')
168 | table = parts3[0] # the html table containing the data
169 | table = table.replace('class="dataTable">', 'Pricing day')
170 |
171 | # replace tags by commas and newlines
172 | table = table.replace('', '\n')
173 | table = table.replace(',', '')
174 | table = table.replace('| ', ',')
175 | table = table.replace(' | ', '')
176 | table = table.replace('', ',')
177 | table = table.replace(' | ', '')
178 | table = table.replace(' | ', '\n')
179 |
180 | # the resulting string looks like a CSV file
181 | date_string = date.strftime('%d.%m.%Y')
182 | table = table.replace('', date_string)
183 |
184 | string = StringIO(table) # mask the string as file
185 | dataset = pd.read_csv(string, parse_dates=[0], index_col=(0, 1),
186 | dayfirst=True) # read the 'file' as pandas DataFrame object
187 |
188 | return dataset
189 |
190 |
191 | def data_collection(path):
192 | ''' Main function which saves data into the HDF5 file
193 | 'index_option_series.h5' for later use.
194 |
195 | Parameters
196 | ==========
197 | path: string
198 | path to store the data
199 | '''
200 | # file to store data
201 | store = pd.HDFStore(path + 'index_option_series.h5', 'a')
202 |
203 | today = dt.datetime.today()
204 | start = today - dt.timedelta(31) # the last 31 days
205 |
206 | day = start.day
207 | month = start.month
208 | year = start.year
209 |
210 | for i in range(4): # iterates over the next 4 months
211 | dummy_month = month + i
212 | dummy_year = year
213 | if dummy_month > 12:
214 | dummy_month -= 12
215 | dummy_year += 1
216 |
217 | # collect daily data beginning 31 days ago (start) for
218 | # option series with expiry dummy_month, dummy_year
219 | dataset = collect_option_series(dummy_month, dummy_year, start)
220 |
221 | dummy_date = dt.datetime(dummy_year, dummy_month, day)
222 |
223 | # abbreviation for expiry date (for example Oct14)
224 | series_name = dummy_date.strftime('%b%y')
225 |
226 | if series_name in store.keys(): # if data for that series exists
227 | index_old = store[series_name].index
228 | index_new = dataset.index
229 |
230 | if len(index_new - index_old) > 0:
231 | dummy = pd.concat((store[series_name],
232 | dataset.ix[index_new - index_old])) # add the new data
233 |
234 | store[series_name] = dummy
235 | else:
236 | if len(dataset) > 0:
237 | # if series is new, write whole data set into data store
238 | store[series_name] = dataset
239 |
240 | store.close()
241 |
--------------------------------------------------------------------------------
/legacy/python2/scripts/srd_simulation_analysis.py:
--------------------------------------------------------------------------------
1 | #
2 | # Valuation of European volatility options
3 | # by Monte Carlo simulation in
4 | # Gruenbichler and Longstaff (1996) model
5 | # -- analysis of valuation results
6 | #
7 | # (c) Dr. Yves J. Hilpisch
8 | # Listed Volatility and Variance Derivatives
9 | #
10 | import time
11 | import math
12 | import numpy as np
13 | from datetime import datetime
14 | from srd_functions import generate_paths, call_price
15 | from srd_simulation_results import *
16 |
17 | # Model Parameters
18 | v0 = 20.0 # initial volatility
19 | kappa = 3.0 # speed of mean reversion
20 | theta = 20.0 # long-term volatility
21 | sigma = 3.2 # standard deviation coefficient
22 | zeta = 0.0 # factor of the expected volatility risk premium
23 | r = 0.01 # risk-free short rate
24 |
25 | # General Simulation Parameters
26 | write = True
27 | var_red = [(False, False), (False, True), (True, False), (True, True)]
28 | # 1st = mo_match -- random number correction (std + mean + drift)
29 | # 2nd = anti_paths -- antithetic paths for variance reduction
30 | # number of time steps
31 | steps_list = [25, 50, 75, 100]
32 | # number of paths per valuation
33 | paths_list = [2500, 50000, 75000, 100000, 125000, 150000]
34 | SEED = 100000 # seed value
35 | runs = 3 # number of simulation runs
36 | PY1 = 0.010 # performance yardstick 1: abs. error in currency units
37 | PY2 = 0.010 # performance yardstick 2: rel. error in decimals
38 | maturity_list = [1.0 / 12 , 1.0 / 4, 1.0 / 2, 1.0] # maturity list
39 | strike_list = [15.0, 17.5, 20.0, 22.5, 25.0] # strike list
40 |
41 |
42 | def generate_paths(x0, kappa, theta, sigma, T, M, I):
43 | ''' Simulation of square-root diffusion with exact discretization
44 |
45 | Parameters
46 | ==========
47 | x0: float (positive)
48 | starting value
49 | kappa: float (positive)
50 | mean-reversion factor
51 | theta: float (positive)
52 | long-run mean
53 | sigma: float (positive)
54 | volatility (of volatility)
55 | T: float (positive)
56 | time-to-maturity
57 | M: int
58 | number of time intervals
59 | I: int
60 | number of simulation paths
61 |
62 | Returns
63 | =======
64 | x: NumPy ndarray object
65 | simulated paths
66 | '''
67 | dt = float(T) / M
68 | x = np.zeros((M + 1, I), dtype=np.float)
69 | x[0, :] = x0
70 | # matrix filled with standard normally distributed rv
71 | ran = randoms(M, I)
72 | d = 4 * kappa * theta / sigma ** 2
73 | # constant factor in the integrated process of x
74 | c = (sigma ** 2 * (1 - math.exp(-kappa * dt))) / (4 * kappa)
75 | if d > 1:
76 | for t in range(1, M + 1):
77 | # non-centrality parameter
78 | l = x[t - 1, :] * math.exp(-kappa * dt) / c
79 | # matrix with chi-squared distributed rv
80 | chi = np.random.chisquare(d - 1, I)
81 | x[t, :] = c * ((ran[t] + np.sqrt(l)) ** 2 + chi)
82 | else:
83 | for t in range(1, M + 1):
84 | l = x[t - 1, :] * math.exp(-kappa * dt) / c
85 | N = np.random.poisson(l / 2, I)
86 | chi = np.random.chisquare(d + 2 * N, I)
87 | x[t, :] = c * chi
88 | return x
89 |
90 |
91 | def randoms(M, I):
92 | ''' Function to generate pseudo-random numbers with variance reduction.
93 |
94 | Parameters
95 | ==========
96 | M: int
97 | number of discrete time intervals
98 | I: int
99 | number of simulated paths
100 |
101 | Returns
102 | =======
103 | rand: Numpy ndarray object
104 | object with pseudo-random numbers
105 | '''
106 | if anti_paths is True:
107 | rand_ = np.random.standard_normal((M + 1, I / 2))
108 | rand = np.concatenate((rand_, -rand_), 1)
109 | else:
110 | rand = np.random.standard_normal((M + 1, I))
111 | if mo_match is True:
112 | rand = rand / np.std(rand)
113 | rand = rand - np.mean(rand)
114 | return rand
115 |
116 |
117 | t0 = time.time()
118 | sim_results = pd.DataFrame()
119 |
120 | for vr in var_red: # variance reduction techniques
121 | mo_match, anti_paths = vr
122 | for M in steps_list: # number of time steps
123 | for I in paths_list: # number of paths
124 | t1 = time.time()
125 | d1 = datetime.now()
126 | abs_errors = []
127 | rel_errors = []
128 | l = 0.0
129 | errors = 0
130 | # name of the simulation setup
131 | name = ('Call_' + str(runs) + '_'
132 | + str(M) + '_' + str(I / 1000)
133 | + '_' + str(mo_match)[0] + str(anti_paths)[0] +
134 | '_' + str(PY1 * 100) + '_' + str(PY2 * 100))
135 | np.random.seed(SEED) # RNG seed value
136 | for run in range(runs): # simulation runs
137 | print "\nSimulation Run %d of %d" % (run + 1, runs)
138 | print "----------------------------------------------------"
139 | print ("Elapsed Time in Minutes %8.2f"
140 | % ((time.time() - t0) / 60))
141 | print "----------------------------------------------------"
142 | z = 0
143 | for T in maturity_list: # time-to-maturity
144 | dt = T / M # time interval in year fractions
145 | V = generate_paths(v0, kappa, theta, sigma, T, M, I)
146 | # volatility process paths
147 | print "\n Results for Time-to-Maturity %6.3f" % T
148 | print " -----------------------------------------"
149 | for K in strike_list: # Strikes
150 | h = np.maximum(V[-1] - K, 0) # inner value matrix
151 | # MCS estimator
152 | call_estimate = math.exp(-r * T) * np.sum(h) / I * 100
153 | # BSM analytical value
154 | callalue = call_price(v0, kappa, theta, sigma,
155 | zeta, T, r, K) * 100
156 | # errors
157 | diff = call_estimate - callalue
158 | rdiff = diff / callalue
159 | abs_errors.append(diff)
160 | rel_errors.append(rdiff * 100)
161 | # output
162 | br = " ----------------------------------"
163 | print "\n Results for Strike %4.2f\n" % K
164 | print (" European Op. Value MCS %8.4f" %
165 | call_estimate)
166 | print (" European Op. Value Closed %8.4f" %
167 | callalue)
168 | print " Valuation Error (abs) %8.4f" % diff
169 | print " Valuation Error (rel) %8.4f" % rdiff
170 | if abs(diff) < PY1 or abs(diff) / callalue < PY2:
171 | print " Accuracy ok!\n" + br
172 | CORR = True
173 | else:
174 | print " Accuracy NOT ok!\n" + br
175 | CORR = False
176 | errors = errors + 1
177 | print " %d Errors, %d Values, %.1f Min." \
178 | % (errors, len(abs_errors),
179 | float((time.time() - t1) / 60))
180 | print (" %d Time Intervals, %d Paths"
181 | % (M, I))
182 | z = z + 1
183 | l = l + 1
184 |
185 | t2 = time.time()
186 | d2 = datetime.now()
187 | if write is True: # append simulation results
188 | sim_results = write_results(sim_results, name, SEED,
189 | runs, M, I, mo_match, anti_paths,
190 | l, PY1, PY2, errors,
191 | float(errors) / l, np.array(abs_errors),
192 | np.array(rel_errors), t2 - t1, (t2 - t1) / 60, d1, d2)
193 |
194 | if write is True:
195 | # write/append DataFrame to HDFStore object
196 | write_to_database(sim_results)
197 |
--------------------------------------------------------------------------------
![\"The](\"http://hilpisch.com/tpq_logo.png\"){kind=logo}
![\"Derivatives](\"http://hilpisch.com/images/lvvd_cover.png\")
"
19 | ]
20 | },
21 | {
22 | "cell_type": "markdown",
23 | "metadata": {},
24 | "source": [
25 | "# Terms of the VSTOXX and its Derivatives"
26 | ]
27 | },
28 | {
29 | "cell_type": "markdown",
30 | "metadata": {},
31 | "source": [
32 | "## The EURO STOXX 50 Index"
33 | ]
34 | },
35 | {
36 | "cell_type": "markdown",
37 | "metadata": {},
38 | "source": [
39 | "## The VSTOXX Index"
40 | ]
41 | },
42 | {
43 | "cell_type": "markdown",
44 | "metadata": {},
45 | "source": [
46 | "## VSTOXX Futures Contracts"
47 | ]
48 | },
49 | {
50 | "cell_type": "markdown",
51 | "metadata": {},
52 | "source": [
53 | "## VSTOXX Options Contracts"
54 | ]
55 | },
56 | {
57 | "cell_type": "markdown",
58 | "metadata": {},
59 | "source": [
60 | "## Conclusions"
61 | ]
62 | },
63 | {
64 | "cell_type": "markdown",
65 | "metadata": {},
66 | "source": [
67 | "![\"Derivatives](\"http://hilpisch.com/../images/lvvd_cover.png\")
"
23 | ]
24 | },
25 | {
26 | "cell_type": "markdown",
27 | "metadata": {},
28 | "source": [
29 | "# Model-Free Replication of Variance"
30 | ]
31 | },
32 | {
33 | "cell_type": "markdown",
34 | "metadata": {},
35 | "source": [
36 | "## Simple Spanning with Options"
37 | ]
38 | },
39 | {
40 | "cell_type": "code",
41 | "execution_count": null,
42 | "metadata": {},
43 | "outputs": [],
44 | "source": [
45 | "import numpy as np"
46 | ]
47 | },
48 | {
49 | "cell_type": "code",
50 | "execution_count": null,
51 | "metadata": {},
52 | "outputs": [],
53 | "source": [
54 | "S = np.array((20, 5))\n",
55 | "B = np.array((11, 11))"
56 | ]
57 | },
58 | {
59 | "cell_type": "code",
60 | "execution_count": null,
61 | "metadata": {},
62 | "outputs": [],
63 | "source": [
64 | "S0 = 10\n",
65 | "B0 = 10"
66 | ]
67 | },
68 | {
69 | "cell_type": "code",
70 | "execution_count": null,
71 | "metadata": {},
72 | "outputs": [],
73 | "source": [
74 | "M = np.array((S, B)).T\n",
75 | "M"
76 | ]
77 | },
78 | {
79 | "cell_type": "code",
80 | "execution_count": null,
81 | "metadata": {},
82 | "outputs": [],
83 | "source": [
84 | "M0 = np.array((S0, B0))"
85 | ]
86 | },
87 | {
88 | "cell_type": "code",
89 | "execution_count": null,
90 | "metadata": {},
91 | "outputs": [],
92 | "source": [
93 | "K = 14"
94 | ]
95 | },
96 | {
97 | "cell_type": "code",
98 | "execution_count": null,
99 | "metadata": {},
100 | "outputs": [],
101 | "source": [
102 | "C = np.maximum(S - K, 0)\n",
103 | "C"
104 | ]
105 | },
106 | {
107 | "cell_type": "code",
108 | "execution_count": null,
109 | "metadata": {},
110 | "outputs": [],
111 | "source": [
112 | "P = np.maximum(K - S, 0)\n",
113 | "P"
114 | ]
115 | },
116 | {
117 | "cell_type": "code",
118 | "execution_count": null,
119 | "metadata": {},
120 | "outputs": [],
121 | "source": [
122 | "phi_C = np.linalg.solve(M, C)\n",
123 | "phi_C"
124 | ]
125 | },
126 | {
127 | "cell_type": "code",
128 | "execution_count": null,
129 | "metadata": {},
130 | "outputs": [],
131 | "source": [
132 | "phi_P = np.linalg.solve(M, P)\n",
133 | "phi_P"
134 | ]
135 | },
136 | {
137 | "cell_type": "code",
138 | "execution_count": null,
139 | "metadata": {},
140 | "outputs": [],
141 | "source": [
142 | "C0 = np.dot(M0, phi_C)\n",
143 | "C0"
144 | ]
145 | },
146 | {
147 | "cell_type": "code",
148 | "execution_count": null,
149 | "metadata": {},
150 | "outputs": [],
151 | "source": [
152 | "P0 = np.dot(M0, phi_P)\n",
153 | "P0"
154 | ]
155 | },
156 | {
157 | "cell_type": "code",
158 | "execution_count": null,
159 | "metadata": {},
160 | "outputs": [],
161 | "source": [
162 | "M_ = np.array((C, P)).T\n",
163 | "M_"
164 | ]
165 | },
166 | {
167 | "cell_type": "code",
168 | "execution_count": null,
169 | "metadata": {},
170 | "outputs": [],
171 | "source": [
172 | "M0_ = np.array((C0, P0))\n",
173 | "M0_"
174 | ]
175 | },
176 | {
177 | "cell_type": "code",
178 | "execution_count": null,
179 | "metadata": {},
180 | "outputs": [],
181 | "source": [
182 | "s1 = np.array((1, 0))\n",
183 | "s2 = np.array((0, 1))"
184 | ]
185 | },
186 | {
187 | "cell_type": "code",
188 | "execution_count": null,
189 | "metadata": {},
190 | "outputs": [],
191 | "source": [
192 | "phi_s1 = np.linalg.solve(M_, s1)\n",
193 | "phi_s1"
194 | ]
195 | },
196 | {
197 | "cell_type": "code",
198 | "execution_count": null,
199 | "metadata": {},
200 | "outputs": [],
201 | "source": [
202 | "phi_s2 = np.linalg.solve(M_, s2)\n",
203 | "phi_s2"
204 | ]
205 | },
206 | {
207 | "cell_type": "code",
208 | "execution_count": null,
209 | "metadata": {},
210 | "outputs": [],
211 | "source": [
212 | "p1 = np.dot(M0_, phi_s1)\n",
213 | "p1"
214 | ]
215 | },
216 | {
217 | "cell_type": "code",
218 | "execution_count": null,
219 | "metadata": {},
220 | "outputs": [],
221 | "source": [
222 | "p2 = np.dot(M0_, phi_s2)\n",
223 | "p2"
224 | ]
225 | },
226 | {
227 | "cell_type": "code",
228 | "execution_count": null,
229 | "metadata": {},
230 | "outputs": [],
231 | "source": [
232 | "M0_s = np.array((p1, p2))"
233 | ]
234 | },
235 | {
236 | "cell_type": "code",
237 | "execution_count": null,
238 | "metadata": {},
239 | "outputs": [],
240 | "source": [
241 | "g = np.array((13, 3))"
242 | ]
243 | },
244 | {
245 | "cell_type": "code",
246 | "execution_count": null,
247 | "metadata": {},
248 | "outputs": [],
249 | "source": [
250 | "g0 = np.dot(M0_s, g)\n",
251 | "g0"
252 | ]
253 | },
254 | {
255 | "cell_type": "markdown",
256 | "metadata": {},
257 | "source": [
258 | "![\"Listed](\"https://hilpisch.com/images/lvvd_cover.png\")
"
23 | ]
24 | },
25 | {
26 | "cell_type": "markdown",
27 | "metadata": {},
28 | "source": [
29 | "# Model-Free Replication of Variance"
30 | ]
31 | },
32 | {
33 | "cell_type": "markdown",
34 | "metadata": {},
35 | "source": [
36 | "## Simple Spanning with Options"
37 | ]
38 | },
39 | {
40 | "cell_type": "code",
41 | "execution_count": null,
42 | "metadata": {},
43 | "outputs": [],
44 | "source": [
45 | "import numpy as np"
46 | ]
47 | },
48 | {
49 | "cell_type": "code",
50 | "execution_count": null,
51 | "metadata": {},
52 | "outputs": [],
53 | "source": [
54 | "S = np.array((20, 5))\n",
55 | "B = np.array((11, 11))"
56 | ]
57 | },
58 | {
59 | "cell_type": "code",
60 | "execution_count": null,
61 | "metadata": {},
62 | "outputs": [],
63 | "source": [
64 | "S0 = 10\n",
65 | "B0 = 10"
66 | ]
67 | },
68 | {
69 | "cell_type": "code",
70 | "execution_count": null,
71 | "metadata": {},
72 | "outputs": [],
73 | "source": [
74 | "M = np.array((S, B)).T\n",
75 | "M"
76 | ]
77 | },
78 | {
79 | "cell_type": "code",
80 | "execution_count": null,
81 | "metadata": {},
82 | "outputs": [],
83 | "source": [
84 | "M0 = np.array((S0, B0))"
85 | ]
86 | },
87 | {
88 | "cell_type": "code",
89 | "execution_count": null,
90 | "metadata": {},
91 | "outputs": [],
92 | "source": [
93 | "K = 14"
94 | ]
95 | },
96 | {
97 | "cell_type": "code",
98 | "execution_count": null,
99 | "metadata": {},
100 | "outputs": [],
101 | "source": [
102 | "C = np.maximum(S - K, 0)\n",
103 | "C"
104 | ]
105 | },
106 | {
107 | "cell_type": "code",
108 | "execution_count": null,
109 | "metadata": {},
110 | "outputs": [],
111 | "source": [
112 | "P = np.maximum(K - S, 0)\n",
113 | "P"
114 | ]
115 | },
116 | {
117 | "cell_type": "code",
118 | "execution_count": null,
119 | "metadata": {},
120 | "outputs": [],
121 | "source": [
122 | "phi_C = np.linalg.solve(M, C)\n",
123 | "phi_C"
124 | ]
125 | },
126 | {
127 | "cell_type": "code",
128 | "execution_count": null,
129 | "metadata": {},
130 | "outputs": [],
131 | "source": [
132 | "phi_P = np.linalg.solve(M, P)\n",
133 | "phi_P"
134 | ]
135 | },
136 | {
137 | "cell_type": "code",
138 | "execution_count": null,
139 | "metadata": {},
140 | "outputs": [],
141 | "source": [
142 | "C0 = np.dot(M0, phi_C)\n",
143 | "C0"
144 | ]
145 | },
146 | {
147 | "cell_type": "code",
148 | "execution_count": null,
149 | "metadata": {},
150 | "outputs": [],
151 | "source": [
152 | "P0 = np.dot(M0, phi_P)\n",
153 | "P0"
154 | ]
155 | },
156 | {
157 | "cell_type": "code",
158 | "execution_count": null,
159 | "metadata": {},
160 | "outputs": [],
161 | "source": [
162 | "M_ = np.array((C, P)).T\n",
163 | "M_"
164 | ]
165 | },
166 | {
167 | "cell_type": "code",
168 | "execution_count": null,
169 | "metadata": {},
170 | "outputs": [],
171 | "source": [
172 | "M0_ = np.array((C0, P0))\n",
173 | "M0_"
174 | ]
175 | },
176 | {
177 | "cell_type": "code",
178 | "execution_count": null,
179 | "metadata": {},
180 | "outputs": [],
181 | "source": [
182 | "s1 = np.array((1, 0))\n",
183 | "s2 = np.array((0, 1))"
184 | ]
185 | },
186 | {
187 | "cell_type": "code",
188 | "execution_count": null,
189 | "metadata": {},
190 | "outputs": [],
191 | "source": [
192 | "phi_s1 = np.linalg.solve(M_, s1)\n",
193 | "phi_s1"
194 | ]
195 | },
196 | {
197 | "cell_type": "code",
198 | "execution_count": null,
199 | "metadata": {},
200 | "outputs": [],
201 | "source": [
202 | "phi_s2 = np.linalg.solve(M_, s2)\n",
203 | "phi_s2"
204 | ]
205 | },
206 | {
207 | "cell_type": "code",
208 | "execution_count": null,
209 | "metadata": {},
210 | "outputs": [],
211 | "source": [
212 | "p1 = np.dot(M0_, phi_s1)\n",
213 | "p1"
214 | ]
215 | },
216 | {
217 | "cell_type": "code",
218 | "execution_count": null,
219 | "metadata": {},
220 | "outputs": [],
221 | "source": [
222 | "p2 = np.dot(M0_, phi_s2)\n",
223 | "p2"
224 | ]
225 | },
226 | {
227 | "cell_type": "code",
228 | "execution_count": null,
229 | "metadata": {},
230 | "outputs": [],
231 | "source": [
232 | "M0_s = np.array((p1, p2))"
233 | ]
234 | },
235 | {
236 | "cell_type": "code",
237 | "execution_count": null,
238 | "metadata": {},
239 | "outputs": [],
240 | "source": [
241 | "g = np.array((13, 3))"
242 | ]
243 | },
244 | {
245 | "cell_type": "code",
246 | "execution_count": null,
247 | "metadata": {},
248 | "outputs": [],
249 | "source": [
250 | "g0 = np.dot(M0_s, g)\n",
251 | "g0"
252 | ]
253 | },
254 | {
255 | "cell_type": "markdown",
256 | "metadata": {},
257 | "source": [
258 | "