Sommaire

CHAMPION Matthieu
Modèles de Marché en Visual Basic
ESILV S04 S6
Sommaire
Sommaire ................................................................................................................... 1
Introduction................................................................................................................ 2
1
Trois différentes techniques de pricing................................................................... 3
1.1
Le modèle de Cox Ross Rubinstein. ............................................................... 3
1.2
Le modèle de Black & Scholes....................................................................... 8
1.3
Méthode de Monte Carlo. ............................................................................. 10
2
Analyse des différentes techniques de pricing...................................................... 12
2.1
L’influence des paramètres sur les techniques de pricing. ........................... 12
2.2
Comparaison de prix des pricers................................................................... 15
3
Les informations contenues dans les données historiques.................................... 17
3.1
La nappe de volatilité.................................................................................... 17
3.2
La densité risque neutre ................................................................................ 19
Conclusion ............................................................................................................... 20
Professeur : Florian IELPO
1
CHAMPION Matthieu
Modèles de Marché en Visual Basic
ESILV S04 S6
Introduction
Etant étudiants en troisième année à L’ESILV et donc en première année de
spécialisation dans l’option ingénierie financière, nous avons suivi des cours permettant
de maîtriser les techniques simples de pricing d’options. Dans le but de pouvoir les
appliquer en stage, ce projet nous a proposé de coder ces techniques dans le langage
utilisé dans le monde de la finance : Visual Basic for Applications (VBA). VBA est une
implémentation de Microsoft Visual Basic qui est intégrée dans toutes les applications de
Microsoft Office. Elle permet à son utilisateur de coder des fonctions et des macros qui
vont pouvoir l’aider à réaliser des calculs à partir d’une feuille Excel par exemple. Le but
de notre projet a donc été de réaliser des fonctions et des macros permettant à un
utilisateur de la feuille Excel de générer les résultats dont il a besoin à partir des
paramètres qu’il aura entré dans les cellules appropriées.
Afin de vous expliquer les différentes étapes de notre projet, je vais articuler
mon développement en trois parties :
-
Tout d’abord j’exposerai les différentes techniques de pricing que j’ai codé.
-
Par la suite, nous verrons les différences entre ces techniques et l’influence
qu’ont certains paramètres sur les résultats obtenus
-
Enfin je vous montrerai quels informations les données historiques peuvent
nous révéler.
Professeur : Florian IELPO
2
CHAMPION Matthieu
Modèles de Marché en Visual Basic
1
Trois différentes techniques de pricing.
1.1
Le modèle de Cox Ross Rubinstein.
ESILV S04 S6
Le modèle de Cox Ross Rubinstein a pour but de pricer une option en
représentant l’évolution du cours de son sous jacent suivant un arbre binomial. La
première étape du codage de ce modèle a donc été de représenter un arbre binomial
modélisant l’évolution du cours de l’action suivant des paramètres entrés en argument.
Afin de vérifier le bon fonctionnement de mon raisonnement j’ai tout d’abord
codé une macro qui affiche l’arbre trouvé dans la feuille Excel :
Ainsi, u et n sont pris en argument dans des cellules de la feuille Arbre
binomial. T a été mis par défaut à 1 mais il ne serait pas difficile de le prendre en
argument. La macro n’a été codé que pour vérifier le bon fonctionnement de notre
raisonnement dans la programmation. Ainsi, en entrant en paramètres 0.1 pour u et 10
pour n on obtient ces résultats :
Professeur : Florian IELPO
3
CHAMPION Matthieu
Modèles de Marché en Visual Basic
ESILV S04 S6
A la vue du résultat, j’ai pu affirmer que mon code est correct.
La première étape du code étant terminée, j’ai pu m’occuper du calcul du prix
de notre option grâce à deux fonctions. La première est la fonction payoff qui calcule la
dernière colonne des nœuds de l’arbre. Grâce à ce vecteur elle calcule ensuite le payoff
en retranchant le strike price, entré en argument, à ces prix. Evidemment, si le résultat de
la soustraction est négatif, elle remplace ce résultat par zéro. Enfin la fonction renvoi le
vecteur du payoff :
Nous pouvons remarquer que le calcul de u et d se fait à partir de la volatilité du
sous jacent entrée en argument. Ainsi les coefficients de monté et de descente du prix du
sous jacent sont plus précis.
Professeur : Florian IELPO
4
CHAMPION Matthieu
Modèles de Marché en Visual Basic
ESILV S04 S6
La deuxième fonction de mon code afin de calculer les prix de l’option est la
fonction proba. Elle calcule la probabilité pour chaque événement de l’évolution du cours
du sous jacent de se produire. En effet, pour mettre en évidence le prix de notre option, il
faut calculer l’espérance actualisée de notre sous jacent à la maturité de l’option.
Pour ce faire il nous a tout d’abord fallu calculer la probabilité risque neutre. En
effet le pricing d’une option repose sur une règle :l’absence d’opportunité d’arbitrage.
Une fois cette probabilité calculée grâce à la volatilité de notre sous jacent et du taux sans
risque, le time to maturity et le nombre de périodes permettent de calculer le vecteur des
probabilités. Ainsi j’ai codé ma fonction proba de la façon suivante :
Ainsi les deux fonctions que nous venons de voir renvoient des vecteurs qui , si
j’ai bien codé, doivent être de même taille. Il suffit alors de réaliser une fonction prenant
les paramètres de l’option en argument. Cette fonction va alors appeler proba et payoff et
va réaliser le produit scalaire des deux vecteurs renvoyés. Voici le code de cette
fonction :
Professeur : Florian IELPO
5
CHAMPION Matthieu
Modèles de Marché en Visual Basic
ESILV S04 S6
Regardons à présent les différents résultats obtenus avec nos fonctions.
Tout d’abord, regardons les résultats numériques que nous obtenons :
Nous pouvons supposer que les résultats obtenus sont corrects. En effet les deux
vecteurs calculés sont de même longueur. Le vecteur payoff a des valeurs positives en
haut et nulles en bas ce qui est en concordance avec le payoff d’un call. Pour vérifier que
Professeur : Florian IELPO
6
CHAMPION Matthieu
Modèles de Marché en Visual Basic
ESILV S04 S6
notre vecteur probabilité est correct, j’ai réalisé un graphique représentant la distribution
des probabilités en fonction des différents payoff. On peut s’attendre à une distribution
s’apparentant à une loi normale car il y a plus de chances que le sous jacent connaisse les
évolutions du centre que celles de l’extrême dans le modèle CRR. Regardons le
graphique obtenu :
0,09
0,08
0,07
proba
0,06
0,05
0,04
0,03
0,02
0,01
0
0
0
0
0
0
0
0
0
0
0
64
8,
53 905
9, 61
6
44 538
6, 3
36 55
7, 56
29 222
9, 52
24 619
2, 33
0
19 116
2, 9
15 92
1, 17
11 089
5, 97
4
85 433
,0 2
59 672
5
,
37 182
,1 47
18 249
,3 15
2, 287
31 0
16 7
34
6
0
Conformément à ce que nous attendions, la distribution de probabilités a l’allure
d’une loi normale.
Nous pouvons donc conclure que le prix de notre modèle de Cox Ross
Rubinstein devrait être correct. Afin de nous conforter dans cette idée, deux autres
modèles de pricing d’options vont pouvoir être codé.
Professeur : Florian IELPO
7
CHAMPION Matthieu
1.2
Modèles de Marché en Visual Basic
ESILV S04 S6
Le modèle de Black & Scholes.
La formule de BS découle directement de CRR. Le schéma binomial de CRR
peut converger vers le schéma normal de Black Scholes (Cas européen). Or, une
binomiale converge vers une loi normale pour un ∆t suffisamment petit. On retrouve
donc la formule de Black & Scholes en faisant tendre notre pas vers 0 c'est-à-dire en
faisant tendre n vers l’infini.
Ainsi en prenant les mêmes paramètres en entrées que pour le modèle CRR, on
peut réaliser la fonction Call_BS qui va calculer les prix de l’option call grâce aux
formules suivantes :
Avec :
la fonction
de
répartition de la loi normale
centrée
réduite
dire :
, c'est-à-
Et :
Ainsi j’ai pu programmer la fonction Call_BS :
Professeur : Florian IELPO
8
CHAMPION Matthieu
Modèles de Marché en Visual Basic
ESILV S04 S6
Nous pouvons à présent regarder les résultats obtenus grâce à la fonction
Call_BS. Nous prenons les mêmes paramètres que pour les tests de notre fonction
prixCRR :
Ainsi nous avons réalisé notre fonction Call_BS qui, vu les résultats obtenus,
paraît correct. Nous pouvons à présent nous intéresser à notre dernière technique de
pricing : la méthode de Monte Carlo.
Professeur : Florian IELPO
9
CHAMPION Matthieu
1.3
Modèles de Marché en Visual Basic
ESILV S04 S6
Méthode de Monte Carlo.
L’évaluation des options par simulation de Monte Carlo repose en grande partie
sur l’évaluation risque neutre. Les paiements futurs espérés sont en effet calculés dans un
univers risque neutre en suivant une procédure d’échantillonnage avant d’être actualisé
au taux sans risque. Nous allons donc coder notre pricer grâce à deux fonctions. Tout
d’abord nous créons une fonction simulation, qui comme son nom l’indique permet de
simuler un vecteur de nombres ayant une distribution normale. Cette fonction se sert de la
fonction d’Excel NORMINV. On prendra donc en entré la moyenne mu, l’écart type
sigma, et n qui est le nombre de simulation que l’on effectue :
Nous pouvons alors notre fonction prixMonteCarlo. Pour cela notre programme
réalisera un tirage au hasard d’une trajectoire de S dans un univers risque neutre. Puis
nous calculerons le payoff à l’échéance pour cette trajectoire. Nous répéterons cela Z fois
pour avoir un plus grand nombre de flux terminaux. Enfin nous calculerons le prix en
faisant la moyenne des payoff pour obtenir une espérance du flux terminal que nous
actualiserons au taux sans risque :
Professeur : Florian IELPO
10
CHAMPION Matthieu
Modèles de Marché en Visual Basic
ESILV S04 S6
Cette fonction nous renvoi donc le prix Monte Carlo. Je viens donc de vous
présenter les trois pricer mis en place en VBA.
Regardons à présent quelles conclusions on peut tirer des résultats renvoyés par
nos fonctions.
Professeur : Florian IELPO
11
CHAMPION Matthieu
Modèles de Marché en Visual Basic
ESILV S04 S6
2
Analyse des différentes techniques de pricing.
2.1
L’influence des paramètres sur les techniques de pricing.
Tout d’abord intéressons nous à la variation du prix d’un call en fonction de la
variation de la volatilité de son sou jacent. Regardons tout d’abord le graphique que l’on
obtient :
prix en fonction de la volatilité
50
45
40
30
25
20
15
10
5
volatilité en %
Nous pouvons remarquer que plus la volatilité du sous jacent augmente et plus le
prix de notre option augmente. On aurait pu faire cette déduction par logique. En effet si
la volatilité du sous jacent est forte, il est plus probable que le sous jacent atteigne des
prix forts. Si le sous jacent atteint un prix fort, la valeur de l’option sera elle aussi forte.
Cependant si le sous jacent baisse, l’option permettra de couvrir les pertes. Il est donc
tout naturel qu’une option avec un sous jacent à forte volatilité soit plus cher qu’une
option avec un sous jacent à faible volatilité.
Professeur : Florian IELPO
12
97
93
89
85
81
77
73
69
65
61
57
53
49
45
41
37
33
29
25
21
17
13
9
5
0
1
prix du call
35
CHAMPION Matthieu
Modèles de Marché en Visual Basic
ESILV S04 S6
Regardons à présent le prix de l’option en fonction de la valeur de son sous
jacent :
prix en fonction de la valeur du sous jacent
90
80
70
prix du call
60
50
40
30
20
10
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
valeur du sous jacent
Nous remarquons que plus la valeur du sous jacent est élevée et plus le prix de
notre option call est élevé. En effet plus la valeur du sous jacent sera élevée et plus elle a
de chance d’être, à terme, supérieure au strike price K. Il est donc tout naturel que la
valeur de notre option augmente si la valeur du sous jacent augmente.
Voici le graphique du prix de l’option call en fonction de la valeur du strike price
K:
Professeur : Florian IELPO
13
16
CHAMPION Matthieu
Modèles de Marché en Visual Basic
ESILV S04 S6
prix en fonction du strike
120
100
60
40
20
strike
La valeur de notre option baisse à mesure que le strike price augmente. En effet
sin notre strike price augmente les chances que la valeur du sous jacent soit au dessus du
strike à terme se réduisent.
Professeur : Florian IELPO
14
97
93
89
85
81
77
73
69
65
61
57
53
49
45
41
37
33
29
25
21
17
13
9
5
0
1
prix du call
80
CHAMPION Matthieu
Modèles de Marché en Visual Basic
ESILV S04 S6
Le graphique du prix de l’option call en fonction de la maturité est le suivant :
prix en fonction de la maturité
100
90
80
prix du call
70
60
50
40
30
20
10
97
93
89
85
81
77
73
69
65
61
57
53
49
45
41
37
33
29
25
21
17
13
9
5
1
0
m aturité
Plus la maturité de l’option est lointaine et plus la valeur du sous jacent a de
chances d’augmenter et donc passer au dessus du strike price. Il est donc naturel que le
prix du call augmente lorsque le time to maturity augmente.
2.2
Comparaison de prix des pricers.
Cette comparaison va nous permettre d’étudier plusieurs caractéristiques :
-
tout d’abord, nous pourrons étudier la convergence du prix CRR vers le prix
Black Scholes
-
Nous pourrons aussi regarder le comportement du prix Monte Carlo par
rapport aux deux autres prix.
Nous allons effectuer cette comparaison grâce à un graphique qui aura en
abscisse, le nombre de simulation à réaliser dans le cas de Monte Carlo et le nombre de
Professeur : Florian IELPO
15
CHAMPION Matthieu
Modèles de Marché en Visual Basic
ESILV S04 S6
subdivisions du temps pour CRR. Bien évidemment, ce paramètre n’influera aucunement
sur le prix Black Scholes.
Black Scholes sera donc une « référence » vers laquelle nos deux prix devraient
tendre à mesure que n croit.
Regardons le graphique obtenu :
Comparaison des différents pricers
30
25
prix du call
20
Prix BS
Prix CRR
15
Prix MC
10
5
0
0
10
20
30
40
50
60
n
Nous pouvons tout de suite constater que le prix CRR converge vers Black
Scholes ce qui conforte l’idée que le modèle de Black & Scholes vient du modèle CRR
avec un pas de temps tendant vers zéro.
Nous remarquons aussi que le prix du modèle de Monte Carlo oscille autour du
prix Black Scholes et tend vers celui-ci à mesure que n grandit.
Professeur : Florian IELPO
16
CHAMPION Matthieu
3
Modèles de Marché en Visual Basic
ESILV S04 S6
Les informations contenues dans les données
historiques
3.1
La nappe de volatilité
Lors de la première partie, nous avons vu que l’un des facteurs permettant le
calcul du prix grâce à la formule de Black & Scholes est la volatilité du sous jacent de
l’option.
En inversant notre raisonnement, on peut retrouver l’un des paramètres si l’on a le
prix de l’option et les autres paramètres. Ici le paramètre que nous cherchons est la
volatilité.
En inversant le raisonnement, on va pouvoir retrouver la volatilité du sous jacent
de l’option. Cette volatilité sera appelée volatilité implicite du sous jacent.
Au moyen de la méthode de dichotomie, on va pouvoir retrouver la volatilité
implicite :
Professeur : Florian IELPO
17
CHAMPION Matthieu
Modèles de Marché en Visual Basic
ESILV S04 S6
Ainsi, notre fonction volimpl va permettre de retrouver la vol implicite grâce aux
paramètres de l’option et de son prix.
On constate que la volatilité implicite aux options fortement hors de la monnaie
ou largement dans la monnaie est plus élevée que la volatilité implicite recalculée à partir
des options à la monnaie. On appelle ce phénomène smile de volatilité
A l’aide d’une série de données, on va tenter de tracer le smile de volatilité :
volatilité implicite
0,18
0,16
0,14
0,12
0,16-0,18
0,1
0,14-0,16
0,08
0,12-0,14
0,06
0,1-0,12
0,04
K=4400
K=4500
K=4600
K=4700
K=4800
K=4900
118
K=5000
109
100
91
82
73
55
time to maturity
64
46
28
37
1
10
19
0
K=4300
0,08-0,1
0,02
0,06-0,08
0,04-0,06
strike prices
0-0,02
On retrouve bien le principe du smile de volatilité avec ce graphique. En effet nous
voyons que la volatilité implicite est plus grande aux extrémités du graphe qu’au centre.
Professeur : Florian IELPO
0,02-0,04
18
CHAMPION Matthieu
3.2
Modèles de Marché en Visual Basic
ESILV S04 S6
La densité risque neutre
Notre dernière étape dans ce projet a été de créer le graphique de la fonction de
densité risque neutre. Pour ce faire, notre première étape a été de dériver deux fois le prix
Black & Scholes en fonction du strike price. On obtient la formule suivante :
Par la suite nous avons réalisé une régression linéaire d’ordre 3 de la volatilité
implicite en fonction de K afin de trouver les coefficients a0,a1,a2,a3.
Cette régression linéaire nous a permis de coder la fonction de calcul de la fonctions
densité risque neutre. En effet le calcul de la volatilité implicite mais aussi de ses dérivées
première et seconde par rapport à K est alors possible en entrant K et les différents
coefficients en argument.
Le calcul de la fonction de densité a alors été possible sur la série de données en
notre possession. Nous avons alors pu réaliser un graphique que voici :
Professeur : Florian IELPO
19
CHAMPION Matthieu
Modèles de Marché en Visual Basic
ESILV S04 S6
Conclusion
En définitive, ce projet nous a permis d’assimiler les bases de la programmation en
VBA. Nous avons pu coder les pricers que nous avons vu pendant nos cours théoriques
mais nous avons aussi assimilé de nouvelles notions.
L’outil informatique s’est révélé indispensable. Nous avons pu entrevoir la
puissance de calcul et l’ergonomie du langage VBA.
Les notions assimilées pendant ce projet nous ont permis d’élargir encore nos
connaissances sur le pricing des options.
Professeur : Florian IELPO
20