Lezione 12 - Economia

Introduzione alla Programmazione e Applicazioni per la
Finanza M2 (Prodotti Derivati)
Lezione 12
Anno accademico 2005-06
Titolare corso: Prof. Costanza Torricelli
Docente a contratto: Dott. Marianna Brunetti
Il pricing delle opzioni in VBA

Il pricing delle opzioni in VBA
In particolare implementeremo:
1. Binomiale
Sub
Fun
Fun
Sub
a. per opzioni europee
b. per opzioni europee, sotto l’ipotesi che
c. per opzioni americane
2. B&S
a. per call e put
S ~ logN
Sub
Fun
b. per call e put con l’ausilio di Inputbox e Msgbox
c. per il calcolo della volatilità implicita
Il pricing delle opzioni in VBA

C
=
n
∑
i = 0
1a) Il Binomiale per opzioni Europee
⎛
⎜
⎝
n
i
⎞
⎟
⎠
q
i
u
q
n − i
d
Max
(
i
n −i
S ( 1 + u ) ( 1 + d ) − X ; 0)
P
n
= ∑
i = 0
⎛
⎜
⎝
n
i
⎞
⎟
⎠
q
i
u
q
n−
i
d
Max
(
i
n−
i
X − S( 1 + u ) ( 1 + d ) ; 0)
Sub PrezziBinomiali ()
Dim S, X, r, u, d As Double
Dim n As Integer
S = 50, X = 50, r = 0.06, u = 0.1, d = -0.03, n = 2
Dim q_up, q_down, C, P As Double
Dim i As Integer
q_up = (r - d) / ((1 + r) * (u - d))
q_down = (u - r) / ((1 + r) * (u - d))
(segue)
Il pricing delle opzioni in VBA

1a) Il Binomiale per opzioni Europee (2)
(segue)
C = 0
For i = 0 To n
C = C + Application.WorksheetFunction.Combin(n, i) * q_up ^ i * q_down ^ (n - i) * _
Application.WorksheetFunction.Max(S * (1 + u) ^ (i) * (1 + d) ^ (n - i) - X, 0)
Next i
P = 0
For i = 0 To n
P = P + Application.WorksheetFunction.Combin(n, i) *q_up ^ i * q_down ^ (n - i) * _
Application.WorksheetFunction.Max(X - S * (1 + u) ^ (i) * (1 + d) ^ (n - i), 0)
Next i
End Sub
RICORDA: usiamo Application.WorksheetFunction.Qualcosa (o anche solo
Application.Qualcosa) per richiamare in VBA la funzione Qualcosa di Excel
Il pricing delle opzioni in VBA

1b) Il Binomiale per opzioni Europee, con S ~ logN
Faremo approssimazioni tali che i movimenti “up” e “down” di S convergano
ad una log-Normale:
1.
2.
T
∆t =
n
r
R = e
∆t
3.
u
e
∆t
4.
5.
6.
= σ t
up = 1 + u
−σ
∆
d = e
down = 1 + d
R − down
q u =
R *(
up − down)
up − R
q d =
R *(
up − down)
Il pricing delle opzioni in VBA

1b) Il Binomiale per call Europee, con S ~ logN
Function EuroCall(S, X, T, rf, sigma, n)
delta_t = T / n
up = Exp(sigma * Sqr(delta_t))
down = Exp(-sigma * Sqr(delta_t))
r = Exp(rf * delta_t)
q_up = (r - down) / (r * (up - down))
q_down = (up - r) / (r * (up - down))
EuroCall = 0
For i = 0 To n
EuroCall = EuroCall + Application.Combin(n, i) * q_up ^ i * q_down ^ (n - i) * _
Application.Max(S * up ^ i * down ^ (n - i) - X, 0)
Next i
End Function
Il pricing delle opzioni in VBA

1b) Il Binomiale per put Europee, con S ~ logN
Function EuroPut(S, X, T, rf, sigma, n)
delta_t = T / n
up = Exp(sigma * Sqr(delta_t))
down = Exp(-sigma * Sqr(delta_t))
r = Exp(rf * delta_t)
q_up = (r - down) / (r * (up - down))
q_down = 1 / r - q_up
EuroPut = 0
For i = 0 To n
EuroPut = EuroPut + Application.WorksheetFunction.combin(n, i) * _
q_up ^ i * q_down ^ (n - i) * _
Application.WorksheetFunction.Max(X - S * up ^ i * down ^ (n - i), 0)
Next i
End Function
Il pricing delle opzioni in VBA

Gli Array
Ad 1 dimensione (“vettore”)
“serie di elementi omogenei
individuati da un indice”
Sintassi ed assegnazione
Dim NomeVettore (i) [As Tipo]
A 2 dimensioni (“matrice”)
“tabella di elementi omogenei
individuati da una coppia di indici,
uno per riga ed uno per colonna”
Dim NomeMatrice (i, j) [As Tipo]
Dim Vettore (3) As Double
Dim Matrice (3,3) As Double
• La sintassi completa per quanto riguarda gli indici è ([min to] max)
Dim Vettore2 (1 to 3) As Double
Dim Matrice2 (1 to 3, 1 to 3) As Double
• Option Base 0 => se dichiaro indice i, il numero degli elementi è (i +1)
• Option Base 1 => dichiarando i, il numero degli elementi è effettivamente i
• Assegnazione avviene sempre con l’ = è Vettore(i) = 3
Il pricing delle opzioni in VBA

Gli Array (2)
‣ Statici = il numero di elementi rimane costante in tutta la procedura.
‣ Dinamici = utili quando non sappiamo a priori il numero di elementi
è ridimensioniamo con il comando ReDim
Esempi
Sub provaArray()
Dim vettore() As Double
n = InputBox("inserire il numero di elementi")
ReDim vettore(n) As Double
End Sub
Sub provaArray2()
Dim Matrice() As Double
i = InputBox("inserire il numero di righe della matrice")
j = InputBox("inserire il numero di colonne della matrice")
ReDim Matrice(i, j) As Double
End Sub
Il pricing delle opzioni in VBA

1c) Il Binomiale per opzioni call Americane
‣ Modifichiamo le funzioni viste prima per il pricing delle opzioni europee in
modo da tener conto dell’eventuale convenienza dell’esercizio anticipato in
ciascun nodo intermedio dell’albero
‣La prima parte della funzione è uguale…
Function AmericanCall(S, X, T, rf, sigma, n)
Dim delta_t, up, down, r, q_up, q_down As Double
Dim State, Index As Integer
delta_t = T / n
up = Exp(sigma * Sqr(delta_t))
down = Exp(-sigma * Sqr(delta_t))
r = Exp(rf * delta_t)
q_up = (r - down) / (r * (up - down))
q_down = (up - r) / (r * (up - down))
(segue)
Il pricing delle opzioni in VBA

1c) Il Binomiale per opzioni call Americane (2)
‣ Nella seconda parte della funzione creiamo due vettori:
•OptionReturnEnd è valori opzione in ciascuno stato del mondo in t+1
•OptionReturnMiddle è valori opzione in ciascuno stato del mondo in t
‣ ...che ridimensioniamo una volta noto il numero dei passi complessivi (n)
Dim OptionReturnEnd() As Double
Dim OptionReturnMiddle() As Double
ReDim OptionReturnEnd(n + 1)
(segue)
‣ ora possiamo valutare l’opzione in ciascun possibile stato del mondo a
scadenza calcolandone semplicemente il payoff
For State = 0 To n
OptionReturnEnd(State) = Application.Max(S * (up ^ State) * down ^ (n - State) - X, 0)
Next State
Il pricing delle opzioni in VBA
(segue)

1c) Il Binomiale per opzioni call Americane (3)
‣ per ciascun istante di tempo intermedio tra la scadenza e oggi (ovvero
tra n-1 e 0), ridimensioniamo il vettore che contiene i valori dell'opzione
nei nodi intermedi
For Index = n - 1 To 0 Step -1
ReDim OptionReturnMiddle(Index)
(segue)
‣ utilizzando un ciclo For, riempiamo ciascun elemento di questo vettore con
il massimo tra il payoff dell’opzione in quel nodo e la valutazione dell'opzione
con i prezzi nei vari stati del mondo
For State = 0 To Index
OptionReturnMiddle(State) = Application.Max(S * up ^ State * down ^ (Index - State) - X, _
q_down * OptionReturnEnd(State) + q_up * OptionReturnEnd(State + 1))
Next State
Il pricing delle opzioni in VBA
(segue)

1c) Il Binomiale per opzioni call Americane (4)
‣ trovato il valore dell’opzione in ogni State (stato del mondo) di
quell’Index (tempo), chiamo il vettore di valori appena trovato
OptionReturnEnd, poiché la valutazione nei nodi precedenti sarà basata su
questo (questo stesso vettore passa da OptionReturnMiddle a
OptionReturnEnd!) è Ridimensiono e assegno stessi valori:
ReDim OptionReturnEnd(Index)
For State = 0 To Index
OptionReturnEnd(State) = OptionReturnMiddle(State)
Next State
Next Index
‣ Il ciclo ripete questa valutazione backward fino all’istante 0. Il prezzo
dell’opzione è quindi dato da:
AmericanCall = OptionReturnMiddle(0)
End Function
Il pricing delle opzioni in VBA
(segue)

1c) Il Binomiale per opzioni put Americane
Function AmericanPut(S, X, T, rf, sigma, n)
Dim delta_t, up, down, r, q_up, q_down As Double
Dim State, Index As Integer
delta_t = T / n
up = Exp(sigma * Sqr(delta_t))
down = Exp(-sigma * Sqr(delta_t))
r = Exp(rf * delta_t)
q_up = (r - down) / (r * (up - down))
q_down = (up - r) / (r * (up - down))
Dim OptionReturnEnd() As Double
Dim OptionReturnMiddle() As Double
ReDim OptionReturnEnd(n + 1)
For State = 0 To n
OptionReturnEnd(State) = Application.Max(X - S * up ^ State * down ^ (n - State), 0)
Next State
Il pricing delle opzioni in VBA
(segue)

1c) Il Binomiale per opzioni put Americane (2)
(segue)
For Index = n - 1 To 0 Step -1
ReDim OptionReturnMiddle(Index)
For State = 0 To Index
OptionReturnMiddle(State) = Application.Max(X - S * up ^ State * down ^ (Index - State), _
q_down * OptionReturnEnd(State) + q_up * OptionReturnEnd(State + 1))
Next State
ReDim OptionReturnEnd(Index)
For State = 0 To Index
OptionReturnEnd(State) = OptionReturnMiddle(State)
Next State
Next Index
End Function
AmericanPut = OptionReturnMiddle(0)
Il pricing delle opzioni in VBA

2a) B&S per opzioni Europee
Sub PrezzoCall()
Dim S, X, r, T, sigma, D1, D2, ND1, ND2, MenoND1, MenoND2, C, P As Double
S = 25
X = 25
r = 0.06
T = 0.5
sigma = 0.3
D1 = (Log(S / X) + (r + 0.5 * (sigma ^ 2)) * T) / (sigma * Sqr(T))
D2 = D1 - Sqr(T) * sigma
ND1 = Application.NormSDist(D1)
ND2 = Application.NormSDist(D2)
MenoND1 = Application.NormSDist(-D1)
MenoND2 = Application.NormSDist(-D2)
C = S * ND1 - (X * Exp(-r * T) * ND2)
P = (X * Exp(-r * T) * (MenoND2)) - (S * (MenoND1))
End Sub
Il pricing delle opzioni in VBA

2b) B&S per opzioni Europee – InputBox e MsgBox
Sub PrezzoCallePutBlackAndSholes()
Dim CalcoloD1, CalcoloD2, NormalD1, NormalD2, C, P As Double
Dim S As Double
S = InputBox("Immettere il prezzo del Sottostante", "Calcolo prezzo B&S")
Dim X As Double
X = InputBox("Immettere lo Strike della Call", "Calcolo prezzo B&S")
Dim r As Double
r = InputBox("Immettere il tasso risk-free", "Calcolo prezzo B&S")
Dim T As Double
T = InputBox("Immettere la scandenza della call", "Calcolo prezzo B&S")
Dim sigma As Double
sigma = InputBox("Immettere la varianza del sottostante", "Calcolo prezzo B&S")
CalcoloD1 = (Log(S / X) + (r + 0.5 * (sigma ^ 2)) * T) / (sigma * Sqr(T))
CalcoloD2 = CalcoloD1 - (Sqr(T) * sigma)
NormalD1 = Application.NormSDist(CalcoloD1)
NormalD2 = Application.NormSDist(CalcoloD2)
C = S * NormalD1 - (X * Exp(-r * T) * NormalD2)
P = C + (X * Exp(-r * T)) - S
MsgBox "Il prezzo della Call è " & Str(Round(C, 3)), , "Calcolo prezzo Call"
MsgBox "Il prezzo della corrispondente Put è " & Str(Round(P, 3)), , "Calcolo Prezzo Put"
End Sub
Il pricing delle opzioni in VBA

2c) B&S per il calcolo della Volatilità Implicita
Function VolatilityCall(S, X, T, r, C)
Dim High, Low, CalcoloD1, CalcoloD2, NormalD1, NormalD2, PrezzoCall As Double
High = 1
Low = 0
Do While (High - Low) > 0.00001
CalcoloD1 = (Log(S / X) + (r + 0.5 * (((High + Low) / 2) ^ 2)) * T) / (((High + Low) / 2) * Sqr(T))
CalcoloD2 = CalcoloD1 - Sqr(T) * ((High + Low) / 2)
NormalD1 = Application.NormSDist(CalcoloD1)
NormalD2 = Application.NormSDist(CalcoloD2)
PrezzoCall = S * NormalD1 - (X * Exp(-r * T) * NormalD2)
If PrezzoCall > C Then
High = (High + Low) / 2
Else:
Low = (High + Low) / 2
End If
Loop
VolatilityCall = (High + Low) / 2
End Function
Il pricing delle opzioni in VBA