codingprolab@gmail.com

$40.00

Order Now
Category: ECE 478

Description

5/5 - (6 votes)

Write code to simulate the BAPM and perform analysis as suggested. Notation and so forth

follows as given in Shreve, Stochastic Calculus for Finance vol. 1. Your simulation should

take r; d; u as given, and constant at all time steps. Building in error detection to ensure

these satisfy the no-arbitrage constraint is optional. Might as well take S0 = 1. We will

assume the coin toss distribution is constant over time, but the particular (p; q) values can

be variable. Two special cases are the ìactualî probabilities (p0; q0), and the risk-neutral

measure (~p; q~). Let Fn be the -algebra generated by the Örst n tosses, which covers the

time span f0 k ng. Let ~!n = (!1 !n) 2 fH; Tg

n

denote a particular ëpathíthrough

the Örst n tosses. Assume every stochastic process here, say Xn is adapted to this Öltration.

Your model should cover the time steps f0 n Ng. When you perform a Monte Carlo

simulation, M is the number of samples used (i.e., for purposes of Monte Carlo, you repeat

the experiment M times and average over those results).

There are two types of derivatives: one type has a payout VN = VN (SN ) that depends only

on the Önal value of the security; this is called ëpath independentí. Another type can depend

on the values of the security over the whole time span, i.e., VN = VN (S0; S1; ; SN ). Here

we will only build out simulation for the case of path-independent payouts, so feel free to

write your code assuming that condition holds. [A more complete BAPM simulation would

have to be able to handle the more general case.]

Finally, in what follows, for any stochastic process Xn, the discounted process is X~

n =

1

(1+r)

n Xn.

1. Distributions: Before you start coding: Assuming the coin-toss distribution (p; q),

Önd the distribution of Sn. That is, list all the possible values (there are n+1 of them),

and their probabilities. Also, if Rn = log (Sn=S0), show that Rn = cnYn + dn where

Yn binomial (n; p) (Önd the constants cn; dn). Note: In the continuous-time case,

something similar will occur: we will get Rt = log (St=S0) Gaussian (what else?),

and hence the distribution of St will be what is called lognormal.

2. Exact simulation: Assume we have code to compute the payout function V (SN ) for

a path-independent derivative.

(a) Write code to compute V0 = Ep~

V~N

using the known distribution for SN .

(b) Write code to generate one step of the replicating portfolio. If at time n there

are n shares of the stock, and wealth Xn, then the amount Mn = Xn nSn is

held in the money market. From n ! n + 1, the stock price changes from Sn to

Sn+1, and the amount in the money market grows to (1 + r) Mn. Thus, at time

n + 1, the wealth equation states:

Xn+1 = nSn+1 + (1 + r) (Xn nSn)

For this to be a replicating portfolio, Xn = Vn, the price of the derivative at time n,

where at n = N this should matchVN (SN ) exactly. Give ~!n, 0 n N 1, there

are two possibities for ~!n+1, namely (~!nH) and (~!nT). Assuming Vn+1 (~!nH),

Vn+1 (~!nT) are both known, and of course Sn+1 (~!nH); Sn+1 (~!nT); Sn (~!n) are

all known, with given r, the wealth equation yields two linear equations in the

unknowns n (~!n); Xn = Vn (~!n). By running this recursively backwards, you

should be able to derive fn (~!n)gall ~!n, for 0nN1

, and of course X0 = V0. Write

code to do this! Also as you do this, keep track of whether any n or Xn nSn

values are negative (the Örst is short selling the stock, the second is ìshort selling

the money marketî, i.e., borrowing money to buy stock).

(c) Now let us take a speciÖc example to test your code. Take r = 0:05, u = 1:1,

d = 1:01, N = 5, and the derivative a European call option with strike price

K = Ep~ (SN ) (you know the distribution of SN so should be able to Önd a simple

formula for this!) There are only 2

N = 32 paths so it should not be unreasonable

to compute and store the complete set of replicating portfolio values fn (~!n)g.

In any case, compute V0 using each of your two methods, and check that they

match! Question: Do you have to do any short selling the stock or borrowing

from the money market along the way?

3. Monte Carlo simulation: Next is to deal with the case N = 100. There are 2

100

paths, so rather than computing over all paths, we will use a Monte Carlo approach.

So let me Örst describe the code you should create. For Öxed m, and an adapted

stochastic process Xn, we want to compute Yn = Ep~ (Xn+mjFn). What this means

is Yn = Yn (~!n), a function of the path associated with the Örst n tosses. So assume

that is given. You will generate M random paths (!n+1 !n+m) according to the

distribution, compute Xn+m (~!n!n+1 !n+m) for each, and average over them to get

Yn. The details of computing Xn+m should be contained in a function that is called by

the Monte Carlo ìwrapperî. It is ok if you have to modify your wrapper code a little

bit in terms of the variables you pass to or receive back from this core function.

(a) As a Örst step, let us check the underlying behavior of your Monte Carlo code. Go

back to the previous case, with N = 5 and r; u; d as given. Taking M = 1; 5; 10; 32,

estimate S0 from SN , and V0 from VN . Note that you are not going through every

path systematically! You are generating paths independently, and so it is possible

(especially in the low order case) the same path will occur multiple times, so even

with M = 32 there is no guarantee you will get all paths! Hence your S0; V0

estimate will not be exact. The idea is to see how close your estimates are for

various M.

(b) Now take the case N = 100. In this case, we should change some of the parameters. Take r = 103

(so over 100 steps there is a total return of about 10%),

u = 1 + 5 103

, d = 1 + 104

. Take di§erent values of M, starting small so your

computer doesnít take too long to run, and increasing it somewhat. We want to

hopefully see an e§ect of increasing M, without forcing you to run simulations

overnight! First, as a check, we know we should get S0 = Ep~

S~N

and fortunately we know S0 = 1. See how this works for various M. Next, again let V (S

be a European call with K = Ep~ (SN ) [Note: Careful, this is not the discounted

value, since the strike price applies at tine N; also we are computing the expectation assuming p~; there is nothing formal here, this is just a SUGGESTION I am

making so you have a reasonable value K that lies somewhere between min SN

and max SN ] Compute V0 = Ep~

V~N

for the same M as before. Also compute

V10 assuming the Örst ten tosses are all heads, and again assuming all are tails.

Last thing to do: instead of using p~, take two cases for the ìactualîprobabilities:

p0 = 0:9~p, and p0 = 1:1~p. For each case, compute Ep0

S~N

, and compare with

S0, and Ep0

V~N

. In the latter case, if the answer with p0 is below V0 then

you should not have purchased the option (putting the cash into a money market

would have been better), if above V0 then purchasing the option gave you a higher

return than stashing you money in the money market 😀 So last question: even

if I told you that your expected return was better than putting it into a money

market, you may still have decided not to purchase this option. Why not? Hint:

Even if you know p0 (which in this case would lead to this result), we still donít

have an arbitrage here. What does that mean?

3

WhatsApp us