Vous êtes sur la page 1sur 81

TP1 MMFI

Simulation de processus gaussiens

Alexandre GRAMFORT - Cécile MALINAUD

20 juin 2005
Question 1 : Simulations de mouvements browniens
1. Méthode des incréments
La méthode des incréments consiste à prendre :

T
B0 = 0, Bti+1 = Bti + √ Yi
L
avec ti = iT /L, pour i varie de 1 à L et (Yi ) est une suite de v.a. indépendantes
de loi gaussienne centrée réduite.

Increments avec nb = 128 Increments avec nb = 512


1 0.5

0.5 0

0 −0.5

−0.5 −1

−1 −1.5
0 0.5 1 0 0.5 1

Increments avec nb = 1024 Increments avec nb = 4096


2 1

1
0.5
0
0
−1

−2 −0.5
0 0.5 1 0 0.5 1

F IG . 1 – Résultats par la méthode des incréments

1
2. Méthode de Karhunen-Loève
Dans la méthode de Karhunen-Loève, on pose :

2 2T (2n + 1)πt
φn (t) = sin( )
(2n + 1)π 2T
Soit (Zn ) une suite de v.a. indépendantes de loi gaussienne centrée réduite.
Alors, on a dans L2 (Ω × [0, T ]) :

X
Bt = Zn φn (t)
n=0

Il existe une sous-suite de la suite des sommes partielles qui convergent p.s.
vers B. On approxime par troncature de la série.
Dans notre simulation, nous avons, après plusieurs essais, choisi de tronquer la
série à 5000 termes.

Karhunen avec nb = 128 Karhunen avec nb = 512


2.5 1

2 0.5

1.5 0

1 −0.5

0.5 −1

0 −1.5
0 0.5 1 0 0.5 1

Karhunen avec nb = 1024 Karhunen avec nb = 4096


0.5 2

1.5
0
1
−0.5
0.5
−1
0

−1.5 −0.5
0 0.5 1 0 0.5 1

F IG . 2 – Résultats par la méthode de Karhunen-Loève

2
3. Méthode de Cholesky
Pour simuler un vecteur gaussien de vecteur moyen m et de matrice de cova-
riance Γ, on peut utiliser la méthode de Cholevsky.
Comme la matrice Γ est symétrique positive, il existe une matrice carrée A
telle que
AAt = Γ
Soit Y = AG + m, avec G un vecteur de v.a. indépendantes gaussiennes
centrées réduites. On remarque que Y est un vecteur gaussien (par combinaison
linéaire de v.a. gaussiennes indépendantes et de constantes). Y est donc caractéridé
par le vecteur de ses moyennes et sa matrice de covariance.
Par linéarité, E(Y ) = m + AE(G) = m.
De plus, par un simple calcul on trouve : Cov(Yi , Yj ) = Γij .
Pour simuler un vecteur gaussien m, Γ, il suffit donc de :
– Calculer une racine carrée A de γ.
– Tirer G un vecteur de v.a. indépendantes gaussiennes centrées. réduites
– Retourner le vecteur Y = AG + m
Cela conduit à la méthode de simulation du mouvement brownien, en posant
Γij = min(ti , tj ).

Cholesky avec nb = 128 Cholesky avec nb = 512


2 0.5

1.5
0
1

0.5
−0.5
0

−0.5 −1
0 0.5 1 0 0.5 1

Cholesky avec nb = 1024 Cholesky avec nb = 4096


1 1.5

1
0.5
0.5
0
0
−0.5
−0.5

−1 −1
0 0.5 1 0 0.5 1

F IG . 3 – Résultats par la méthode de Cholesky

3
4. Méthode du point médian
On part de B0 = 0 et BT = Z0 où Z0 est une v.a. gaussienne centrée de
variance T . On procède ensuite récursivement :

BT /2 = (B0 + BT + Z1 )/2

où Z1 est de variance T indépendante de Z0 .


Pour les rangs impaires, de la forme k2−i T avec k impair, on pose :

Bk2−i T = (B(k−1)2−i T + B(k+1)2−i T + Zi,k )/2

avec Zi,k est de variance T 2−(i−1) indépendantes des Zj,l pour j < i.

Median avec nb = 128 Median avec nb = 512


2.5 1

2
0.5
1.5
0
1
−0.5
0.5

0 −1
0 0.5 1 0 0.5 1

Median avec nb = 1024 Median avec nb = 4096


3 1

2 0.5

1 0

0 −0.5

−1 −1
0 0.5 1 0 0.5 1

F IG . 4 – Résultats par la méthode du point médian

4
Sommes calculées avec les différentes simulations

points Σ|∆Bi | Σ|∆Bi |2 Σ|∆Bi |3

Méthode des incréments 128 8.1895 0.9360 0.092228


512 17.348 0.93241 s3=0.062825
1024 25.8621 1.0233 0.05128
4096 51.5128 1.0342 0.026721

Méthode de Karhunen-Loève 128 8.7776 0.78934 0.14252


512 18.4725 1.0551 0.07683
1024 26.0279 1.0303 0.052915
4096 47.0778 0.85092 0.019482

Méthode de Cholesky 128 8.828 0.97867 0.13627


512 17.1341 0.87349 0.05581
1024 26.2624 1.0657 0.05511
4096 51.594 1.0164 0.025514

Méthode du point médian 128 10.255 1.2737 0.20565


512 17.713 1.0067 0.074524
1024 25.9792 1.0186 0.051198
4096 51.2659 1.014 0.0254


On conjecture que Σ|∆Bi | se comporte comme O( n) et tend vers ∞, que
Σ|∆Bi |2 converge vers 1 et que Σ|∆Bi |3 converge vers 0.

5
temps d’exécution (en secondes)

Méthode des incréments 0.982

Méthode de Karhunen-Loève 7.07

Méthode de Cholesky 45.5

Méthode du point médian 3.39

On constate que les méthodes du point médian et des incréments sont les plus
rapides. On les privilégiera donc dans les simulations suivantes. En effet, la mé-
thode de Cholesky est très lente, en raison notamment de la nécessité de calculer
la racine carrée de la matrice auto-adjointe. En ce qui concerne la méthode de
Karhunen-Loève, on constate qu’avec 5000 termes, la méthode reste approxima-
tive et lente. On n’utilisera donc pas ces deux dernières méthodes de simulation
dans la suite.

Remarque : il faut noter que ces résultats sont intrinsèquement liés à notre pro-
grammation des algorithmes. Ils ont été obtenus avec Matlab qui reste un langage
interprété et qui nécessite une programmation vectorielle pour arriver à de bons ré-
sultats. Ainsi dans d’autres langages, les vitesses d’exécutions seraient sans doute
bien différentes.

6
Question 2
On utilise la méthode des incréments en modifiant l’intervalle de calcul. Cela
vient de la propriété d’accroissements indépendants des mouvements browniens.

Methode des increments sur [1/2;3/4]


1

0.8

0.6

0.4

0.2

−0.2
0.5 0.55 0.6 0.65 0.7 0.75

F IG . 5 – Résultat par la méthode des incréments sur [1/2; 3/4]

Question 3
Grâce à l’indépendance des accroissements, on peut recoller 2 trajectoires si-
mulées sur 2 intervalles distincts pour obtenir une simulation sur l’union de ces 2
intervalles.

Question 4
|B1 | est une variable aléatoire à valeurs sur [0; ∞] donc la densité est :
r
2 − x2
p(x) = e 2
π

7
Ainsi les équations à résoudre pour trouver les (ai ), i ∈ {0...19} sont :
Z ai
i
p(x)dx = , ∀ai
0 20
Ces équations sont résolues numériquement à partir des tables de la fonction
erreur intégrées aux logiciels de calcul classiques.
Ainsi sous matlab on vérifie :

>> 2*(stderf(0.062706777)-stderf(0))
ans =

0.0500

où stderf désigne la fonction erreur. (implémentation personnelle)

Question 5 : test de loi


Soit B1∗ = inf s<1 Bs . On évalue avec le test du χ2 l’hypothèse selon laquelle
la loi de B1 − B1∗ est égale à la loi de |B1 |.
Sur un essai numérique, la valeur de la statistique obtenue est 26.8000. Elle doit
être inférieure à 31.4104 pour que l’hypothèse soit acceptée. Ainsi on en conclue
que les deux variables aléatoires ont même loi.

8
Question 6 : Mouvement brownien fractionnaire
Grâce à la méthode de Cholesky, il est aisé de simuler un processus gaussien en
connaissant sa covariance. Simulons un mouvement brownien fractionnaire dont la
covariance est donnée par :
Z min(t,s)
E[BtH BsH ] = (t − s)H−1/2 (s − r)H−1/2 dr
0

avec H ∈ ]0, 1].


On remarque que si H = 0.5, on retrouve un mouvement brownien classique.
Si H > 0.5 on constate une corrélation plus grande comme l’illustre la figure 6.
On y observe une trajectoire beaucoup moins “bruitée” et une tendance à accentuer
les sauts. Au contraire si H < 0.5, la corrélation est plus faible. Ceci signifie que
le processus a plus tendance à “contrer” les sauts ce qui entraîne un mouvement
très oscillant avec peu de tendance à la hausse ou à la baisse.

Brownien Fractionnaire (Cholesky) sur [0;1] avec L=500 et H=0.2


3

−1

−2

−3

−4
0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1

F IG . 6 – Résultat de brownien fractionnaire avec H=0.2, L=500, T=1

9
Brownien Fractionnaire sur [0;1] avec L=500 et H=0.8
0.15

0.1

0.05

−0.05

−0.1

−0.15

−0.2

−0.25
0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1

F IG . 7 – Résultat de brownien fractionnaire avec H=0.8, L=500, T=1

Brownien Fractionnaire sur [0;1] avec L=500 et H=0.5


0.3

0.2

0.1

−0.1

−0.2

−0.3

−0.4

−0.5

−0.6

−0.7
0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1

F IG . 8 – Résultat de brownien fractionnaire avec H=0.5, L=500, T=1

10
Question 7 : Représentation intégrale
Ce processus est représenté sous forme intégrale par :
Z t
BtH = (t − s)H−1/2 dBs
0
On approche le processus par la formule (qui semble être une généralisation de
la formule de Riemann) :
Z ti+1
H
X 1
Bt ≃ (t − s)H−1/2 dr∆Bi
ti+1 − ti ti
ti ≤t

Brownien Fractionnaire (qu7) sur [0;1] avec L=500 et H=0.2


3

−1

−2

−3

−4
0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1

F IG . 9 – Simulation de mouvement brownien fractionnaire par la méthode de la


question 7 avec H=0.2, L=500, T=1

Pour finir, on peut constater que le temps de calcul nécessaire à la simulation de


mouvements browniens fractionnaires est énorme avec ces deux méthodes. Ainsi
si l’on a à ce servir de tels processus avec Matlab, on pourra utiliser la fonction
wfbm qui utilise une méthode par ondelettes bien plus rapide.

11
Brownien Fractionnaire (qu7) sur [0;1] avec L=500 et H=0.8
0.3

0.2

0.1

−0.1

−0.2

−0.3

−0.4

−0.5
0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1

F IG . 10 – Simulation de mouvement brownien fractionnaire par la méthode de la


question 7 avec H=0.8, L=500, T=1

Brownien Fractionnaire (qu7) sur [0;1] avec L=500 et H=0.5


0.5

−0.5

−1

−1.5

−2
0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1

F IG . 11 – Simulation de mouvement brownien fractionnaire par la méthode de la


question 7 avec H=0.5, L=500, T=1

12
Annexe - TP1 MMFI
Simulation de processus gaussiens

Alexandre GRAMFORT - Cécile MALINAUD

10 juin 2005
Table des matières
1 Sortie du programme Matlab global (script demo tp1.m) 2

2 Listing du code Matlab 2


2.1 Script de lançement des programmes du tp . . . . . . . . . . . . . . . . . . . . . . . . . . 2
2.2 Programme générant un mouvement brownien par méthode des incréments . . . . . . . . 4
2.3 Programme générant un mouvement brownien par méthode des cholesky . . . . . . . . . . 5
2.4 Programme générant un mouvement brownien par méthode de Karhunen-Loève . . . . . . 5
2.5 Programme générant un mouvement brownien par méthode du médian . . . . . . . . . . . 7
2.6 Programme effectuant le test du χ2 de la question 5 . . . . . . . . . . . . . . . . . . . . . 7
2.7 Programme générant un mouvement brownien fractionnaire (Question 6) . . . . . . . . . 8
2.8 Programme générant un mouvement brownien fractionnaire (Question 7) . . . . . . . . . 9
2.9 Programme générant un mouvement brownien fractionnaire par la fonction intégrée de
Matlab . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

1
1 Sortie du programme Matlab global (script demo tp1.m)
>> demo_tp1
Question 1
Increments
Increments s1=8.5892 :: s2=0.84431 :: s3=0.10536
Increments s1=18.462 :: s2=1.0896 :: s3=0.080473
Increments s1=24.8224 :: s2=0.9477 :: s3=0.045802
Increments s1=51.1561 :: s2=0.99723 :: s3=0.024762
Temps passe dans le calcul par methode des increments =0.98204s
Karhunen
Karhunen s1=8.2934 :: s2=0.80899 :: s3=0.095819
Karhunen s1=18.1448 :: s2=1.0011 :: s3=0.070298
Karhunen s1=24.0608 :: s2=0.903 :: s3=0.043905
Karhunen s1=47.3052 :: s2=0.86103 :: s3=0.019826
Temps passe dans le calcul par methode de Karhunen-Loeve =7.0681s
Cholesky
Cholesky s1=9.6211 :: s2=1.1966 :: s3=0.1889
Cholesky s1=18.7098 :: s2=1.0359 :: s3=0.071294
Cholesky s1=25.3598 :: s2=0.97857 :: s3=0.048152
Cholesky s1=50.8614 :: s2=0.992 :: s3=0.02485
Temps passe dans le calcul par methode de Cholesky =45.4508s
Methode point Median
Median s1=8.2978 :: s2=0.809 :: s3=0.097018
Median s1=19.4587 :: s2=1.1444 :: s3=0.083952
Median s1=25.9814 :: s2=1.0541 :: s3=0.055702
Median s1=50.5697 :: s2=0.98086 :: s3=0.024451
Temps passe dans le calcul par methode du point median =3.3902s
Question 2
Question 5

T_khi2 =

26.8000

Test_accepte =

Question 6
Temps passe dans le calcul des browniens fractionnaires par Cholesky=3790.5939s
Question 7
Temps passe dans le calcul des browniens fractionnaires par integrale stochastique =79.2083s

2 Listing du code Matlab


2.1 Script de lançement des programmes du tp
close all
clear
clc

global CALCULE S FIGURE

2
randn(’state’,0) ;

CALCULE S = 1 ;
FIGURE = 1 ;

disp ’Question 1’

tic
disp ’Increments’
figure,
subplot(2,2,1), B = increments(128,0,1); set(gca,’FontSize’,13) ;
title(’Increments avec nb = 128’) ; set(gca,’FontSize’,13) ;
subplot(2,2,2), B = increments(512,0,1); set(gca,’FontSize’,13) ;
title(’Increments avec nb = 512’) ; set(gca,’FontSize’,13) ;
subplot(2,2,3), B = increments(1024,0,1); set(gca,’FontSize’,13) ;
title(’Increments avec nb = 1024’) ; set(gca,’FontSize’,13) ;
subplot(2,2,4), B = increments(4096,0,1); set(gca,’FontSize’,13) ;
title(’Increments avec nb = 4096’) ; set(gca,’FontSize’,13) ;
saveas(gcf, ’res increments.eps’, ’psc2’) ;
t=toc ;
disp([’Temps passe dans le calcul par methode des increments =’ num2str(t) ’s’]) ;

tic
disp ’Karhunen’
figure,
subplot(2,2,1), B = karhunen(128,0,1) ; set(gca,’FontSize’,13) ;
title(’Karhunen avec nb = 128’) ; set(gca,’FontSize’,13) ;
subplot(2,2,2), B = karhunen(512,0,1) ; set(gca,’FontSize’,13) ;
title(’Karhunen avec nb = 512’) ; set(gca,’FontSize’,13) ;
subplot(2,2,3), B = karhunen(1024,0,1) ; set(gca,’FontSize’,13) ;
title(’Karhunen avec nb = 1024’) ; set(gca,’FontSize’,13) ;
subplot(2,2,4), B = karhunen(4096,0,1) ; set(gca,’FontSize’,13) ;
title(’Karhunen avec nb = 4096’) ; set(gca,’FontSize’,13) ;
saveas(gcf, ’res karhunen.eps’, ’psc2’) ;
t=toc ;
disp([’Temps passe dans le calcul par methode de Karhunen-Loeve =’ num2str(t) ’s’]) ;

tic
disp ’Cholesky’
figure,
subplot(2,2,1), B = cholesky(128,0,1) ; set(gca,’FontSize’,13) ;
title(’Cholesky avec nb = 128’) ; set(gca,’FontSize’,13) ;
subplot(2,2,2), B = cholesky(512,0,1) ; set(gca,’FontSize’,13) ;
title(’Cholesky avec nb = 512’) ; set(gca,’FontSize’,13) ;
subplot(2,2,3), B = cholesky(1024,0,1) ; set(gca,’FontSize’,13) ;
title(’Cholesky avec nb = 1024’) ; set(gca,’FontSize’,13) ;
subplot(2,2,4), B = cholesky(4096,0,1) ; set(gca,’FontSize’,13) ;
title(’Cholesky avec nb = 4096’) ; set(gca,’FontSize’,13) ;
saveas(gcf, ’res cholesky.eps’, ’psc2’) ;
t=toc ;
disp([’Temps passe dans le calcul par methode de Cholesky =’ num2str(t) ’s’]) ;

tic
disp ’Methode point Median’
figure,
subplot(2,2,1), B = median(128,0,1) ; set(gca,’FontSize’,13) ;

3
title(’Median avec nb = 128’) ; set(gca,’FontSize’,13) ;
subplot(2,2,2), B = median(512,0,1) ; set(gca,’FontSize’,13) ;
title(’Median avec nb = 512’) ; set(gca,’FontSize’,13) ;
subplot(2,2,3), B = median(1024,0,1) ; set(gca,’FontSize’,13) ;
title(’Median avec nb = 1024’) ; set(gca,’FontSize’,13) ;
subplot(2,2,4), B = median(4096,0,1) ; set(gca,’FontSize’,13) ;
title(’Median avec nb = 4096’) ; set(gca,’FontSize’,13) ;
saveas(gcf, ’res median.eps’, ’psc2’) ;
t=toc ;
disp([’Temps passe dans le calcul par methode du point median =’ num2str(t) ’s’]) ;

disp ’Question 2’

CALCULE S = 0 ;
FIGURE = 1 ;

figure,
B = increments(512,1/2,3/4) ; set(gca,’FontSize’,13) ;
title(’Methode des increments sur [1/2;3/4]’) ; set(gca,’FontSize’,13) ;
saveas(gcf, ’res increments2.eps’, ’psc2’) ;

disp ’Question 5’

CALCULE S = 0 ;
FIGURE = 0 ;

demo qu5

disp ’Question 6’

FIGURE = 1 ;

tic
figure, B = brow frac(500,0,1,0.2); set(gca,’FontSize’,13) ;
title(’Brownien Fractionnaire (Cholesky) sur [0;1] avec L=500 et H=0.2’) ;
set(gca,’FontSize’,13) ;
saveas(gcf, ’res brow frac H2.eps’, ’psc2’) ;
figure, B = brow frac(500,0,1,0.8); set(gca,’FontSize’,13) ;
title(’Brownien Fractionnaire sur [0;1] avec L=500 et H=0.8’) ;
set(gca,’FontSize’,13) ;
saveas(gcf, ’res brow frac H8.eps’, ’psc2’) ;
figure, B = brow frac(500,0,1,0.5); set(gca,’FontSize’,13) ;
title(’Brownien Fractionnaire sur [0;1] avec L=500 et H=0.5’) ;
set(gca,’FontSize’,13) ;
saveas(gcf, ’res brow frac H5.eps’, ’psc2’) ;
t=toc ;
disp([’Temps passe dans le calcul des browniens fractionnaires par Cholesky=’ num2str(t) ’s’]) ;

disp ’Question 7’

FIGURE = 1 ;

tic
figure, B = brow frac2(500,0,1,0.2); set(gca,’FontSize’,13) ;

4
title(’Brownien Fractionnaire (qu7) sur [0;1] avec L=500 et H=0.2’) ;
set(gca,’FontSize’,13) ;
saveas(gcf, ’res brow frac2 H2.eps’, ’psc2’) ;
figure, B = brow frac2(500,0,1,0.8); set(gca,’FontSize’,13) ;
title(’Brownien Fractionnaire (qu7) sur [0;1] avec L=500 et H=0.8’) ;
set(gca,’FontSize’,13) ;
saveas(gcf, ’res brow frac2 H8.eps’, ’psc2’) ;
figure, B = brow frac2(500,0,1,0.5); set(gca,’FontSize’,13) ;
title(’Brownien Fractionnaire (qu7) sur [0;1] avec L=500 et H=0.5’) ;
set(gca,’FontSize’,13) ;
saveas(gcf, ’res brow frac2 H5.eps’, ’psc2’) ;
t=toc ;
disp([’Temps passe dans le calcul des browniens fractionnaires par integrale stochastique =’...
num2str(t) ’s’]) ;

2.2 Programme générant un mouvement brownien par méthode des incréments


function B = increments(nb,T1,T2)

%FIGURE = 0 ;
global CALCULE S FIGURE

T = T2-T1 ;

r = sqrt(T/nb).*randn(1,nb-1) ;
B = [0 , cumsum(r)] ;

if CALCULE S
s1 = sum(abs(r)) ;
s2 = sum(abs(r).^2) ;
s3 = sum(abs(r).^3) ;
disp([’Increments s1=’ num2str(s1) ’ :: s2=’ num2str(s2) ’ :: s3=’ num2str(s3)])
end

if FIGURE
plot(T1:(T/nb):T2,[0 B]);
end

2.3 Programme générant un mouvement brownien par méthode des cholesky


function B = cholesky(nb,T1,T2)

global CALCULE S FIGURE

T = T2-T1 ;

t=linspace(T/nb,T,nb-1);
% on commence en T/nb et non 0 car sinon gam n’est plus inversible

gam = ones(length(t),1)*t ;
gam = min(gam,gam’) ;

[R,p] = chol(gam);

B = R’ * randn(size(R,2),1) ;

5
B = [0 ; B] ; % toujours on prend B = 0 en t=0

t = [ 0 t ] ;

if FIGURE
plot(T1+t,B);
end

if CALCULE S
s1 = 0 ;
s2 = 0 ;
s3 = 0 ;

for i=2:size(B,1)
s1 = s1 + abs(B(i)-B(i-1)) ;
s2 = s2 + (B(i)-B(i-1))^2 ;
s3 = s3 + abs(B(i)-B(i-1))^3 ;
end

disp([’Cholesky s1=’ num2str(s1) ’ :: s2=’ num2str(s2) ’ :: s3=’ num2str(s3)])


end

2.4 Programme générant un mouvement brownien par méthode de Karhunen-


Loève
function B = karhunen(nb,T1,T2)

global FIGURE CALCULE S

TEST N = 0 ;

N = 5000 ; % taille de la somme partielle

T = T2-T1 ;
t=linspace(0,T,nb);

z = randn(1,N+1) ;

n=0 ;
B = z(n+1)*2*sqrt(2*T)/((2*n+1)*pi).*sin((2*n+1)*pi/(2*T).*t) ;

for n=1:N
B = B + z(n+1)*2*sqrt(2*T)/((2*n+1)*pi).*sin((2*n+1)*pi/(2*T).*t) ;
end

if TEST N
% pour tester l’influence du nombre de termes dans la serie
B1 = z(n+1)*2*sqrt(2*T)/((2*n+1)*pi).*sin((2*n+1)*pi/(2*T).*t) ;
B2 = z(n+1)*2*sqrt(2*T)/((2*n+1)*pi).*sin((2*n+1)*pi/(2*T).*t) ;
B3 = z(n+1)*2*sqrt(2*T)/((2*n+1)*pi).*sin((2*n+1)*pi/(2*T).*t) ;
B4 = z(n+1)*2*sqrt(2*T)/((2*n+1)*pi).*sin((2*n+1)*pi/(2*T).*t) ;

for n=1:1000
B1 = B1 + z(n+1)*2*sqrt(2*T)/((2*n+1)*pi).*sin((2*n+1)*pi/(2*T).*t) ;
end

6
for n=1:2000
B2 = B2 + z(n+1)*2*sqrt(2*T)/((2*n+1)*pi).*sin((2*n+1)*pi/(2*T).*t) ;
end
for n=1:3000
B3 = B3 + z(n+1)*2*sqrt(2*T)/((2*n+1)*pi).*sin((2*n+1)*pi/(2*T).*t) ;
end
for n=1:4000
B4 = B4 + z(n+1)*2*sqrt(2*T)/((2*n+1)*pi).*sin((2*n+1)*pi/(2*T).*t) ;
end
end

if FIGURE
plot(t,B);
end

if TEST N
plot(t,[B ; B1 ; B2 ; B3 ; B4]);
end

if CALCULE S
s1 = 0 ;
s2 = 0 ;
s3 = 0 ;

for i=2:size(B,2)
s1 = s1 + abs(B(i)-B(i-1)) ;
s2 = s2 + (B(i)-B(i-1))^2 ;
s3 = s3 + abs(B(i)-B(i-1))^3 ;
end

disp([’Karhunen s1=’ num2str(s1) ’ :: s2=’ num2str(s2) ’ :: s3=’ num2str(s3)])


end

2.5 Programme générant un mouvement brownien par méthode du médian


function B = median(nb,T1,T2)

global CALCULE S

FIGURE = 1 ;

T = T2-T1 ;

t=0:(T/nb):T ;

B = zeros(1,nb+1) ;
B(1) = 0 ;
B(nb+1) = sqrt(T)*randn ;

B = median aux(B,0,nb,T1,T2) ;

if FIGURE
plot(T1+t,B);
end

if CALCULE S

7
s1 = 0 ;
s2 = 0 ;
s3 = 0 ;

for i=2:size(B,2)
s1 = s1 + abs(B(i)-B(i-1)) ;
s2 = s2 + (B(i)-B(i-1))^2 ;
s3 = s3 + abs(B(i)-B(i-1))^3 ;
end

disp([’Median s1=’ num2str(s1) ’ :: s2=’ num2str(s2) ’ :: s3=’ num2str(s3)])


end

function Bout = median aux(B,n1,n2,t1,t2)

if ((n2-n1)>1)
B((n2+n1)/2+1)=(B(n1+1)+B(n2+1)+sqrt(t2-t1)*randn)/2 ;
Bout = median aux(B,n1,((n2+n1)/2),t1,((t2+t1)/2)) ;
Bout = median aux(Bout,((n2+n1)/2),n2,((t2+t1)/2),t2) ;
else
Bout = B ;
end

2.6 Programme effectuant le test du χ2 de la question 5


L=2000 ;
nb traj = 400 ;

for i=1:nb traj


B = increments(L,0,1) ;
v1(i) = B(L)-min(B) ;
end

a = [0 0.0627 0.1257 0.1891 0.2533 0.3186 0.3853 0.4538 0.5244 0.5978 .6744...
0.7554 0.8416 0.9346 1.0364 1.1503 1.2816 1.4395 1.6449 1.9600 inf] ;

nb inter = length(a) - 1 ; % =20

[histo 1,bin 1] = histc(v1,a) ;


histo 1 = histo 1(1:nb inter) ; % car on veut pas les valeurs inf

T khi2 = sum(((nb traj*1/nb inter*ones(1,nb inter) - histo 1).^2)./...


(nb traj*1/nb inter*ones(1,nb inter)))

% nb deg de lib du khi2 = nb inter-1 = 20 ;


% T khi2 doit etre en dessous de 31.4

Test accepte = (T khi2 < 31.4104)

2.7 Programme générant un mouvement brownien fractionnaire (Question


6)
function B = brow frac(nb,T1,T2,H)

8
global FIGURE

T = T2-T1 ;

t=(T/nb):(T/nb):T ;

gam = zeros(length(t)) ;
diagonale = zeros(length(t)) ;

for i=1:length(t)
F = @(r) (t(i)-r).^(H-0.5) .* (t(i)-r).^(H-0.5) ;
diagonale(i,i) = quadl(F,0,t(i));
for j=(i+1):length(t)
F = @(r) (t(i)-r).^(H-0.5) .* (t(j)-r).^(H-0.5) ;
gam(i,j) = quadl(F,0,min(t(i),t(j)));
end
end

gam = gam + gam’ + diagonale ;

[R,p] = chol(gam);

B = R’ * randn(size(R,2),1) ;

if FIGURE
plot(T1+t,B);
end

2.8 Programme générant un mouvement brownien fractionnaire (Question


7)
function B = brow frac2(L,T1,T2,H)

global CALCULE S FIGURE

FIGURE = 1 ;

T = T2-T1 ;

y = sqrt(T/L).*randn(1,L) ;

B=zeros(1,L) ;
t=0:(T/L):T ;

for i=1:L
B(i)=0 ;

% on connait la primitive ce qui evite le calcul numerique de l’integrale


P = @(r) -(t(i+1)-r).^(H+0.5)./(H+0.5) ;

for j=1:i
B(i) = B(i) + (L/T)*y(j)*(P(t(j+1))-P(t(j))) ;
end
end

if FIGURE

9
plot(t,[0 B]);
end

2.9 Programme générant un mouvement brownien fractionnaire par la fonc-


tion intégrée de Matlab
close all

lg = 1000;
% Generation de browniens fractionnaires par la fonction wfbm
% celle methode utilise une methode par ondelettes
figure, fBm03 = wfbm(0.2,lg,’plot’);
figure, fBm05 = wfbm(0.5,lg,’plot’);
figure, fBm08 = wfbm(0.8,lg,’plot’);

10
TP2 MMFI
Simulations d’options put et call

Alexandre GRAMFORT - Cécile MALINAUD

20 juin 2005
Question 1 : Calcul numérique d’options
1. Calcul du call
Dans un modèle de type Black and Scholes, le call est donné par :

C = E[(eβG − K)+ ]

On en déduit explicitement la valeur de C :

2 /2 log(K) log(K)
C = eβ N (β − ) − KN (− )
β β
En prenant β = 1 et K = 1, on trouve :

C(β = 1, K = 1) = 0.88714

2. Calcul du put
De même, le put est donné par :

P = E[(K − eβG )+ ]

On en déduit explicitement la valeur du put :

2 /2 log(K) log(K)
P = eβ (N (β − ) − 1) − K(N (− ) − 1)
β β
En prenant β = 1 et K = 1, on trouve :

P (β = 1, K = 1) = 0.23842

1
Question 2 : Simulations d’options par la méthode de Monte-
Carlo
1. Simulation du call
On peut également choisir de simuler directement le call par une méthode de
Monte-Carlo. On prend encore β = 1 et K = 1.

taille de l’échantillon valeur empirique du call intervalle de confiance

100 0.67992 [0.44851, 0.91133]

1000 0.7657 [0.66316, 0.86824]

10000 0.9139 [0.872, 0.9558]

100000 0.89106 [0.87854, 0.90358]

Evolution de l intervalle de confiance (call eur.)


1
borne inferieure
borne superieure
0.9

0.8

0.7

0.6

0.5

0.4
2 2.5 3 3.5 4 4.5 5
log10(nombre de tirages)

F IG . 1 – Evolution des intervalles de confiance

2
2. Simulation du put

taille de l’échantillon valeur empirique du put intervalle de confiance

100 0.28686 [0.22897, 0.34476]

1000 0.23397 [0.2156, 0.25235]

10000 0.23764 [0.23184, 0.24344]

100000 0.23884 [0.237, 0.24068]

Evolution de l intervalle de confiance (put eur.)


0.36
borne inferieure
borne superieure
0.34

0.32

0.3

0.28

0.26

0.24

0.22

0.2
2 2.5 3 3.5 4 4.5 5
log10(nombre de tirages)

F IG . 2 – Evolution des intervalles de confiance

On remarque que les intervalles de confiance ne diminuent pas régulièrement


(à cause de l’aléa des mouvements browniens). On remarque également que les
intervalles de confiance sont beaucoup plus réduits pour le put que pour le call, car
ce dernier a une variance plus importante.

3
Question 3 : Simulations d’options avec réduction de la va-
riance
Une idée assez naturelle est donc de simuler le call à partir du put, car la parité
entre le put et le call est parfaitement connue. C’est ce qu’on appelle une méthode
de réduction de la variance.
On écrit
C = P + (C − P )
On va donc simuler P par une méthode de Monte-Carlo classique et ajouter
2
K − eβ /2 . Cela permet une simulation du call avec de meilleurs intervalles de
confiance.

taille de l’échantillon valeur empirique du put intervalle de confiance

100 0.88374 [0.82475, 0.94273]

1000 0.888585 [0.87014, 0.90702]

10000 0.88734 [0.88153, 0.89316]

100000 0.88713 [0.88529, 0.88896]

La précision est de 6 à 10 fois meilleure avec cette méthode de réduction de


la variance. Il est donc très intéressant de trouver des bonnes variables de contrôle
afin d’avoir des simulations les plus précises possibles.

4
Evolution de l intervalle de confiance (call avec reduction de variance)
0.96
borne inferieure
borne superieure
0.94

0.92

0.9

0.88

0.86

0.84

0.82
2 2.5 3 3.5 4 4.5 5
log10(nombre de tirages)

F IG . 3 – Evolution des intervalles de confiance

Question 4 : Simulations de call sur moyenne


1. Présentation du modèle théorique
L’actif financier obéit à une loi :
dS(t) = S(t)(rdt + σdBt ), S(0) = x
où r représente un taux d’intérêt et σ une volatilité.
On trouve, par résolution de l’EDS :
2 /2)t+σB(t)
S(t) = xe(r−σ
Une option sur moyenne est une option dont le prix est :
1 T
Z
M = E[e−rt ( S(s)ds − K)+ ]
T 0
Cela signifie que l’acheteur de ce call peut acheter le sous-jacent à son prix
moyen entre la date d’achat de l’option et la date d’exercice, actualisé par le taux
d’intérêt. Cette option permet donc de lisser les variations du prix du sous-jacent
pour l’acheteur.

2. Simulation du call
Comme pour le call de type européen, on peut simuler ce call (de type asia-
tique) par une méthode de Monte-Carlo. On utilise pour cela les valeurs numé-
riques σ = 0.5, r = 1, x = 1 et T = 1.

5
taille de l’échantillon valeur empirique du call intervalle de confiance

100 0.25478 [0.21669, 0.29288]

1000 0.26463 [0.25209, 0.27717]

10000 0.26622 [0.26212, 0.27031]

100000 0.26584 [0.26455, 0.26714]

Evolution de l intervalle de confiance (call moy.)


0.3
borne inferieure
0.29 borne superieure

0.28

0.27

0.26

0.25

0.24

0.23

0.22

0.21
2 2.5 3 3.5 4 4.5 5
log10(nombre de tirages)

F IG . 4 – Evolution des intervalles de confiance

6
Question 5 : Simulations d’options sur moyenne avec ré-
duction de variance
1. Présentation de la méthode
De même que dans le cas du call européen, on va chercher à réduire la variance
en utilisant une variable de contrôle. R
T RT
L’énoncé du TP suggère que e1/T 0 log(S(s))ds et T1 0 S(s)ds sont assez proches,
ce qui nous amène à utiliser la variable de contrôle :
RT
Y = e−rT (eZ − K)+ avec Z = T1 0 log(S(s))ds

Dans un premier temps, montrons que Z est une variable gaussienne.


RT
Z = T1 0 log(S(s))
RT 2
= T1 0 log(xe(r−σ /2)s+σB(s) )ds
T
= T1 0 (log x + (r − σ 2 /2)s + σB(s))ds
R
RT
= log x + T2 (r − σ 2 /2) + Tσ 0 B(s)ds
Z est donc bien une variable gaussienne. Sa valeur moyenne est
T
log x + (r − σ 2 /2)
2
Sa variance V est donnée par
σ T σ T3 σ2T
Z
V = E[( B(s)ds)2 ] = ( )2 =
T 0 T 3 3
car
RT RT RT
E[( 0 B(s)ds)2 ] = E[ 0 0 B(s)B(s′ )dsds′ ]
RT RT
= E[B(s)B(s′ )]dsds′
R0T R0T
= inf(s, s′ )dsds′
R0T R0 s′ RT
= ( sds + s′ s′ ds)ds′
R0T s0′2
= ( + (T − s′ )s′ )ds′
R0T 2 s′2 ′ ′
= 0 (− 2 + T s )ds
3
= T3
Afin de pouvoir l’utiliser comme variable de contrôle, calculons
√ :
−rt Z −rt log x+ T2 (r−σ2 /2)+σ T /3G
E[e (e − K)+ ] = E[e (e √ − K)+ ]
T 2 T 2 /2)
= e−rt elog x+ 2 (r−σ /2) E[eσ T /3G − Ke− log x− 2 (r−σ )+ ]
T 2
e−rt elog x+ 2 (r−σ /2) E[(eβ G − K ′ )+ ]

=
T 2
avec β ′ = σ T /3 et K ′ = e− log x− 2 (r−σ /2) K
p

On peut donc utiliser la résolution de la première question :


T 2 /2) ′2 /2 log(K ′ ) log(K ′ )
E[e−rt (eZ −K)+ ] = e−rt elog x+ 2 (r−σ (eβ N (β ′ − )−K ′
N (− ))
β′ β′

7
2. Simulation du call avec réduction de variance
On peut maintenant simuler

1 T
 Z RT

1
log(S(s))ds
e−rt ( S(s)ds − K)+ − (e T 0 − K)+
T 0

et ajouter la valeur E[e−rt (eZ − K)+ ] calculée précédemment.

taille de l’échantillon valeur empirique du call intervalle de confiance

100 0.23094 [0.21669, 0.29288]

1000 0.2324 [0.22962, 0.23518]

10000 0.23177 [0.23088, 0.23265]

100000 0.23231 [0.23203, 0.23259]

L’utilisation de la variable de contrôle permet là encore de gagner un facteur


d’environ 10 dans la précision.

3. Influence des paramètres sur l’efficacité de la réduction de variance


On s’intéresse ici à la qualité de la méthode de réduction de variance. Plus
précisément on cherche à estimer sa robustesse face à une modification des para-
mètres. Pour cela, on a joué sur les paramètres T (Fig. 6) et σ (Fig. 7).
On a pu constater que plus, la maturité T augmente, moins la méthode de ré-
duction de variance arrive à fournir des intervalles de confiance de faible longueur.
On arrive même à un plus grand intervalle de confiance avec cette méthode pour
T = 100.
De la même manière, on a pu observer que l’intervalle de confiance devient
moins bon avec la méthode de réduction de variance si l’on augmente trop la vola-
tilité σ.
Pour conclure sur la question, on peut remarquer qu’il est tout à fait normal
que ces deux commentaires aillent dans le même sens. En effet, il est facile de voir
qu’augmenter la maturité d’une option peut se ramener à augmenter la volatilité du
sous-jacent sur lequel est l’option.

8
Evolution de l intervalle de confiance (call sur moyenne avec RV)
0.24
borne inferieure
0.238 borne superieure

0.236

0.234

0.232

0.23

0.228

0.226

0.224

0.222
2 2.5 3 3.5 4 4.5 5
log10(nombre de tirages)

F IG . 5 – Evolution des intervalles de confiance

0.035
largeur de l intervalle de confiance avec RV
largeur de l intervalle de confiance sans RV
0.03

0.025

0.02

0.015

0.01

0.005

0
−2 −1.5 −1 −0.5 0 0.5 1 1.5 2
log10(T)

F IG . 6 – Influence de la maturité T sur l’efficacité de la méthode de réduction de


variance

9
7
largeur de l intervalle de confiance avec RV
largeur de l intervalle de confiance sans RV
6

0
−2 −1.5 −1 −0.5 0 0.5 1
log10(SIGMA)

F IG . 7 – Influence de la volatilité σ sur l’efficacité de la méthode de réduction de


variance

10
Annexe - TP3 MMFI
Simulation d’options - Put et Call

Alexandre GRAMFORT - Cécile MALINAUD

10 juin 2005
Table des matières
1 Sortie du programme Matlab (demo tp2.m) 2

2 Listing du code Matlab 4


2.1 Script global pour lancer l’ensemble du tp . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
2.2 Calcul d’un call européen par la formule fermée de Black-Scholes . . . . . . . . . . . . . . 8
2.3 Calcul d’un put européen par la formule fermée de Black-Scholes . . . . . . . . . . . . . . 8
2.4 Calcul d’un call européen par méthode de Monte-Carlo . . . . . . . . . . . . . . . . . . . . 9
2.5 Calcul d’un put européen par méthode de Monte-Carlo . . . . . . . . . . . . . . . . . . . . 9
2.6 Calcul d’un call européen par méthode de Monte-Carlo avec réduction de variance . . . . 9
2.7 Calcul d’un call sur moyenne par méthode de Monte-Carlo . . . . . . . . . . . . . . . . . . 9
2.8 Calcul d’un put sur moyenne par méthode de Monte-Carlo . . . . . . . . . . . . . . . . . . 9
2.9 Calcul d’un call sur moyenne par méthode de Monte-Carlo avec réduction de variance . . 10
2.10 Fonction servant au calcul des intervalles de confiance . . . . . . . . . . . . . . . . . . . . 11
2.11 Fonction de répartition de la distribution gaussienne standard . . . . . . . . . . . . . . . . 11

1
1 Sortie du programme Matlab (demo tp2.m)
>> demo_tp2

VALEUR EXACTE DU CALL :

call(beta=1,K=1) = 0.88714

VALEUR EXACTE DU PUT :

put(beta=1,K=1) = 0.23842

VALEUR EMPIRIQUE DU CALL :

call(beta=1,K=1,N=100) = 0.67992
Intervalle de confiance = [ 0.44851 , 0.91133]
call(beta=1,K=1,N=1000) = 0.7657
Intervalle de confiance = [ 0.66316 , 0.86824]
call(beta=1,K=1,N=10000) = 0.9139
Intervalle de confiance = [ 0.872 , 0.9558]
call(beta=1,K=1,N=100000) = 0.89106
Intervalle de confiance = [ 0.87854 , 0.90358]

VALEUR EMPIRIQUE DU PUT :

put(beta=1,K=1,N=100) = 0.28686
Intervalle de confiance = [ 0.22897 , 0.34476]
put(beta=1,K=1,N=1000) = 0.23397
Intervalle de confiance = [ 0.2156 , 0.25235]
put(beta=1,K=1,N=10000) = 0.23764
Intervalle de confiance = [ 0.23184 , 0.24344]
put(beta=1,K=1,N=100000) = 0.23884
Intervalle de confiance = [ 0.237 , 0.24068]

VALEUR EMPIRIQUE DU CALL AVEC REDUCTION DE VARIANCE:

call(beta=1,K=1,N=100) = 0.88374
Intervalle de confiance = [ 0.82475 , 0.94273]
call(beta=1,K=1,N=1000) = 0.88858
Intervalle de confiance = [ 0.87014 , 0.90702]
call(beta=1,K=1,N=10000) = 0.88734
Intervalle de confiance = [ 0.88153 , 0.89316]
call(beta=1,K=1,N=100000) = 0.88713
Intervalle de confiance = [ 0.88529 , 0.88896]

VALEUR EMPIRIQUE DU CALL SUR MOYENNE :

call_moy(sigma=0.5,r=1,T=1,K=1,N=100) = 0.25478
Intervalle de confiance = [ 0.21669 , 0.29288]
call_moy(sigma=0.5,r=1,T=1,K=1,N=1000) = 0.26463
Intervalle de confiance = [ 0.25209 , 0.27717]
call_moy(sigma=0.5,r=1,T=1,K=1,N=10000) = 0.26622
Intervalle de confiance = [ 0.26212 , 0.27031]
call_moy(sigma=0.5,r=1,T=1,K=1,N=100000) = 0.26584
Intervalle de confiance = [ 0.26455 , 0.26714]

2
VALEUR EMPIRIQUE DU CALL SUR MOYENNE AVEC REDUCTION DE VARIANCE:

call_moy(sigma=0.5,r=1,T=1,K=1,N=100) = 0.23094
Intervalle de confiance = [ 0.223 , 0.23889]
call_moy(sigma=0.5,r=1,T=1,K=1,N=1000) = 0.2324
Intervalle de confiance = [ 0.22962 , 0.23518]
call_moy(sigma=0.5,r=1,T=1,K=1,N=10000) = 0.23177
Intervalle de confiance = [ 0.23088 , 0.23265]
call_moy(sigma=0.5,r=1,T=1,K=1,N=100000) = 0.23231
Intervalle de confiance = [ 0.23203 , 0.23259]

INFLUENCE DE T SUR LE CALL SUR MOYENNE AVEC REDUCTION DE VARIANCE:

call_moy(sigma=0.5,r=1,T=0.01,K=1,N=1000) = 0.013741
Intervalle de confiance = [ 0.013729 , 0.013752]
call_moy(sigma=0.5,r=1,T=0.01,K=1,N=1000) = 0.013745
Intervalle de confiance = [ 0.012584 , 0.014906]

call_moy(sigma=0.5,r=1,T=0.1,K=1,N=1000) = 0.058298
Intervalle de confiance = [ 0.058136 , 0.058461]
call_moy(sigma=0.5,r=1,T=0.1,K=1,N=1000) = 0.06086
Intervalle de confiance = [ 0.05666 , 0.065061]

call_moy(sigma=0.5,r=1,T=1,K=1,N=1000) = 0.23215
Intervalle de confiance = [ 0.22927 , 0.23504]
call_moy(sigma=0.5,r=1,T=1,K=1,N=1000) = 0.26081
Intervalle de confiance = [ 0.24806 , 0.27357]

call_moy(sigma=0.5,r=1,T=10,K=1,N=1000) = 0.085593
Intervalle de confiance = [ 0.070569 , 0.10062]
call_moy(sigma=0.5,r=1,T=10,K=1,N=1000) = 0.10179
Intervalle de confiance = [ 0.084434 , 0.11914]

call_moy(sigma=0.5,r=1,T=100,K=1,N=1000) = 0.0021952
Intervalle de confiance = [ 0.00013283 , 0.0042575]
call_moy(sigma=0.5,r=1,T=100,K=1,N=1000) = 0.00023589
Intervalle de confiance = [ 6.0252e-05 , 0.00041153]

INFLUENCE DE SIGMA SUR LE CALL SUR MOYENNE AVEC REDUCTION DE VARIANCE:

call_moy(sigma=0.01,r=1,T=1,K=1,N=1000) = 0.26426
Intervalle de confiance = [ 0.26422 , 0.2643]
call_moy(sigma=0.01,r=1,T=1,K=1,N=1000) = 0.26419
Intervalle de confiance = [ 0.26394 , 0.26445]

call_moy(sigma=0.1,r=1,T=1,K=1,N=1000) = 0.26301
Intervalle de confiance = [ 0.26259 , 0.26344]
call_moy(sigma=0.1,r=1,T=1,K=1,N=1000) = 0.26422
Intervalle de confiance = [ 0.26164 , 0.26679]

call_moy(sigma=1,r=1,T=1,K=1,N=1000) = 0.19955
Intervalle de confiance = [ 0.1885 , 0.21059]
call_moy(sigma=1,r=1,T=1,K=1,N=1000) = 0.28421
Intervalle de confiance = [ 0.2582 , 0.31023]

3
call_moy(sigma=10,r=1,T=1,K=1,N=1000) = 0.060006
Intervalle de confiance = [ 0.016339 , 0.10367]
call_moy(sigma=10,r=1,T=1,K=1,N=1000) = 1.7762
Intervalle de confiance = [ -1.6762 , 5.2285]

2 Listing du code Matlab


2.1 Script global pour lancer l’ensemble du tp
clear
close all
clc
randn(’state’,0) % inialisation du generateur aleatoire

FIGURE = 0 ;
% fonction erreur
if FIGURE
plot(stderf(-10:0.2:10)), title(’fonction erreur’) ;
set(gca,’FontSize’,15) ;
end

beta = 1 ;
K = 1 ;

% calcul d’un call


disp ’VALEUR EXACTE DU CALL :’
disp ’ ’
disp([’call(beta=’ num2str(beta) ’,K=’ num2str(K) ’) = ’ num2str(call(beta,K)) ]) ;
disp ’ ’

% calcul d’un put


disp ’VALEUR EXACTE DU PUT :’
disp ’ ’
disp([’put(beta=’ num2str(beta) ’,K=’ num2str(K) ’) = ’ num2str(put(beta,K)) ]) ;
disp ’ ’

% calcul d’un call par moyenne sur des trajectoires


disp ’ ’
disp ’VALEUR EMPIRIQUE DU CALL :’
disp ’ ’
alpha = 0.95 ;
ind = 1 ;
for N=[100,1000,10000,100000]
[val,sample] = call estimation(beta,K,N) ;
[binf,bsup] = intconf(sample,alpha) ;
disp([’call(beta=’ num2str(beta) ’,K=’ num2str(K) ’,N=’ num2str(N) ’) = ’ num2str(val) ]) ;
disp([’Intervalle de confiance = [ ’ num2str(binf) ’ , ’ num2str(bsup) ’]’ ]) ;
% stockage des bornes de l’intervalle de confiance
evo intconf(ind,1) = binf ;
evo intconf(ind,2) = bsup ;
ind = ind+1 ;
end

% affichage de l’evolution de l’intervalle de confiance

4
figure,
plot(log([100,1000,10000,100000])./log(10),evo intconf) ;
set(gca,’FontSize’,15) ;
title(’Evolution de l intervalle de confiance (call eur.)’) ;
xlabel(’log10(nombre de tirages)’) ;
legend(’borne inferieure’,’borne superieure’) ;
set(gca,’FontSize’,15) ;
saveas(gca,’call eur.eps’,’psc2’) ;

% calcul d’un put par moyenne sur des trajectoires


disp ’ ’
disp ’VALEUR EMPIRIQUE DU PUT :’
disp ’ ’

alpha = 0.95 ;
ind = 1 ;
for N=[100,1000,10000,100000]
[val,sample] = put estimation(beta,K,N) ;
[binf,bsup] = intconf(sample,alpha) ;
disp([’put(beta=’ num2str(beta) ’,K=’ num2str(K) ’,N=’ num2str(N) ’) = ’ num2str(val) ]) ;
disp([’Intervalle de confiance = [ ’ num2str(binf) ’ , ’ num2str(bsup) ’]’ ]) ;
% stockage des bornes de l’intervalle de confiance
evo intconf(ind,1) = binf ;
evo intconf(ind,2) = bsup ;
ind = ind+1 ;
end

% affichage de l’evolution de l’intervalle de confiance


figure,
plot(log([100,1000,10000,100000])./log(10),evo intconf) ;
set(gca,’FontSize’,15) ;
title(’Evolution de l intervalle de confiance (put eur.)’) ;
xlabel(’log10(nombre de tirages)’) ;
legend(’borne inferieure’,’borne superieure’) ;
set(gca,’FontSize’,15) ;
saveas(gca,’put eur.eps’,’psc2’) ;

% calcul d’un call avec reduction de variance


disp ’ ’
disp ’VALEUR EMPIRIQUE DU CALL AVEC REDUCTION DE VARIANCE:’
disp ’ ’
alpha = 0.95 ;
ind = 1 ;
for N=[100,1000,10000,100000]
[val,sample] = call estimation reduced var(beta,K,N) ;
[binf,bsup] = intconf(sample,alpha) ;
disp([’call(beta=’ num2str(beta) ’,K=’ num2str(K) ’,N=’ num2str(N) ’) = ’ num2str(val) ]) ;
disp([’Intervalle de confiance = [ ’ num2str(binf) ’ , ’ num2str(bsup) ’]’ ]) ;
% stockage des bornes de l’intervalle de confiance
evo intconf(ind,1) = binf ;
evo intconf(ind,2) = bsup ;
ind = ind+1 ;
end

% affichage de l’evolution de l’intervalle de confiance


figure,

5
plot(log([100,1000,10000,100000])./log(10),evo intconf) ;
set(gca,’FontSize’,15) ;
title(’Evolution de l intervalle de confiance (call avec reduction de variance)’) ;
xlabel(’log10(nombre de tirages)’) ;
legend(’borne inferieure’,’borne superieure’) ;
set(gca,’FontSize’,15) ;
saveas(gca,’call rv eur.eps’,’psc2’) ;

% calcul d’un call sur moyenne par moyenne sur des trajectoires
disp ’ ’
disp ’VALEUR EMPIRIQUE DU CALL SUR MOYENNE :’
disp ’ ’
sigma = 0.5 ;
r = 1 ;
T = 1 ;
K = 1 ;
alpha = 0.95 ;
ind = 1 ;
for N=[100,1000,10000,100000]
[val,sample] = call moy estimation(sigma,r,T,K,N) ;
[binf,bsup] = intconf(sample,alpha) ;
disp([’call moy(sigma=’ num2str(sigma) ’,r=’ num2str(r) ’,T=’ num2str(T)...
’,K=’ num2str(K) ’,N=’ num2str(N) ’) = ’ num2str(val) ]) ;
disp([’Intervalle de confiance = [ ’ num2str(binf) ’ , ’ num2str(bsup) ’]’ ]) ;
% stockage des bornes de l’intervalle de confiance
evo intconf(ind,1) = binf ;
evo intconf(ind,2) = bsup ;
ind = ind+1 ;
end

% affichage de l’evolution de l’intervalle de confiance


figure,
plot(log([100,1000,10000,100000])./log(10),evo intconf) ;
set(gca,’FontSize’,15) ;
title(’Evolution de l intervalle de confiance (call moy.)’) ;
xlabel(’log10(nombre de tirages)’) ;
legend(’borne inferieure’,’borne superieure’) ;
set(gca,’FontSize’,15) ;
saveas(gca,’call moy.eps’,’psc2’) ;

% calcul d’un call sur moyenne avec reduction de variance


disp ’ ’
disp ’VALEUR EMPIRIQUE DU CALL SUR MOYENNE AVEC REDUCTION DE VARIANCE:’
disp ’ ’
alpha = 0.95 ;
ind = 1 ;
for N=[100,1000,10000,100000]
[val,sample] = call moy estimation reduced var(sigma,r,T,K,N) ;
[binf,bsup] = intconf(sample,alpha) ;
disp([’call moy(sigma=’ num2str(sigma) ’,r=’ num2str(r) ’,T=’ num2str(T) ...
’,K=’ num2str(K) ’,N=’ num2str(N) ’) = ’ num2str(val) ]) ;
disp([’Intervalle de confiance = [ ’ num2str(binf) ’ , ’ num2str(bsup) ’]’ ]) ;
% stockage des bornes de l’intervalle de confiance
evo intconf(ind,1) = binf ;

6
evo intconf(ind,2) = bsup ;
ind = ind+1 ;
end

% affichage de l’evolution de l’intervalle de confiance


figure,
plot(log([100,1000,10000,100000])./log(10),evo intconf) ;
set(gca,’FontSize’,15) ;
title(’Evolution de l intervalle de confiance (call sur moyenne avec RV)’) ;
xlabel(’log10(nombre de tirages)’) ;
legend(’borne inferieure’,’borne superieure’) ;
set(gca,’FontSize’,15) ;
saveas(gca,’call moy rv.eps’,’psc2’) ;

% influence des parametres sur le calcul d’un call


% sur moyenne avec reduction de variance
disp ’ ’
disp ’INFLUENCE DE T SUR LE CALL SUR MOYENNE AVEC REDUCTION DE VARIANCE:’
disp ’ ’
sigma = 0.5 ;
r = 1 ;
T = 1 ;
K = 1 ;
N = 1000 ;
alpha = 0.95 ;
ind = 1 ;
for T=[0.01,0.1,1,10,100]
[val,sample] = call moy estimation reduced var(sigma,r,T,K,N) ;
[binf,bsup] = intconf(sample,alpha) ;
disp([’call moy(sigma=’ num2str(sigma) ’,r=’ num2str(r) ’,T=’ num2str(T) ...
’,K=’ num2str(K) ’,N=’ num2str(N) ’) = ’ num2str(val) ]) ;
disp([’Intervalle de confiance = [ ’ num2str(binf) ’ , ’ num2str(bsup) ’]’ ]) ;
% stockage des bornes de l’intervalle de confiance
evo delta intconf(ind,1) = bsup-binf ;
%
[val,sample] = call moy estimation(sigma,r,T,K,N) ;
[binf,bsup] = intconf(sample,alpha) ;
disp([’call moy(sigma=’ num2str(sigma) ’,r=’ num2str(r) ’,T=’ num2str(T) ...
’,K=’ num2str(K) ’,N=’ num2str(N) ’) = ’ num2str(val) ]) ;
disp([’Intervalle de confiance = [ ’ num2str(binf) ’ , ’ num2str(bsup) ’]’ ]) ;
disp(’ ’)
% stockage des bornes de l’intervalle de confiance
evo delta intconf(ind,2) = bsup-binf ;
ind = ind+1 ;
end

% affichage de l’evolution de l’intervalle de confiance


figure,
plot(log([0.01,0.1,1,10,100])/log(10),evo delta intconf) ;
set(gca,’FontSize’,15) ;
xlabel(’log10(T)’) ;
legend(’largeur de l intervalle de confiance avec RV’,...
’largeur de l intervalle de confiance sans RV’,2) ;
set(gca,’FontSize’,15) ;
saveas(gca,’call moy rv T.eps’,’psc2’) ;

7
%
disp ’ ’
disp ’INFLUENCE DE SIGMA SUR LE CALL SUR MOYENNE AVEC REDUCTION DE VARIANCE:’
disp ’ ’
sigma = 0.5 ;
r = 1 ;
T = 1 ;
K = 1 ;
N = 1000 ;
alpha = 0.95 ;
ind = 1 ;
clear evo delta intconf
for sigma=[0.01,0.1,1,10]
[val,sample] = call moy estimation reduced var(sigma,r,T,K,N) ;
[binf,bsup] = intconf(sample,alpha) ;
disp([’call moy(sigma=’ num2str(sigma) ’,r=’ num2str(r) ’,T=’ num2str(T)...
’,K=’ num2str(K) ’,N=’ num2str(N) ’) = ’ num2str(val) ]) ;
disp([’Intervalle de confiance = [ ’ num2str(binf) ’ , ’ num2str(bsup) ’]’ ]) ;
% stockage des bornes de l’intervalle de confiance
evo delta intconf(ind,1) = bsup-binf ;
%
[val,sample] = call moy estimation(sigma,r,T,K,N) ;
[binf,bsup] = intconf(sample,alpha) ;
disp([’call moy(sigma=’ num2str(sigma) ’,r=’ num2str(r) ’,T=’ num2str(T)...
’,K=’ num2str(K) ’,N=’ num2str(N) ’) = ’ num2str(val) ]) ;
disp([’Intervalle de confiance = [ ’ num2str(binf) ’ , ’ num2str(bsup) ’]’ ]) ;
disp(’ ’)
% stockage des bornes de l’intervalle de confiance
evo delta intconf(ind,2) = bsup-binf ;
ind = ind+1 ;
end

% affichage de l’evolution de l’intervalle de confiance


figure,
plot(log([0.01,0.1,1,10])/log(10),evo delta intconf) ;
set(gca,’FontSize’,15) ;
xlabel(’log10(SIGMA)’) ;
legend(’largeur de l intervalle de confiance avec RV’,...
’largeur de l intervalle de confiance sans RV’,2) ;
set(gca,’FontSize’,15) ;
saveas(gca,’call moy rv sigma.eps’,’psc2’) ;

2.2 Calcul d’un call européen par la formule fermée de Black-Scholes


function out = call(beta,K)

out = exp(beta^2/2) * stderf(beta - log(K)/beta) - K*stderf(-log(K)/beta) ;

2.3 Calcul d’un put européen par la formule fermée de Black-Scholes


function out = put(beta,K)

% par parite call-put


out = call(beta,K) - exp(beta^2/2) + K ;

8
2.4 Calcul d’un call européen par méthode de Monte-Carlo
function [val,sample] = call estimation(beta,K,N)

G = randn(1,N) ;
sample = max(0,exp(beta.*G)-K) ;
val = mean(sample) ;

2.5 Calcul d’un put européen par méthode de Monte-Carlo


function [val,sample] = put estimation(beta,K,N)

G = randn(1,N) ;
sample = max(0,K-exp(beta.*G)) ;
val = mean(sample) ;

2.6 Calcul d’un call européen par méthode de Monte-Carlo avec réduction
de variance
function [val,sample] = call estimation reduced var(beta,K,N)

A = exp(beta^2/2) - K ;
G = randn(1,N) ;
sample = max(A,A+K-exp(beta.*G));
val = mean(sample) ;

2.7 Calcul d’un call sur moyenne par méthode de Monte-Carlo


function [val,sample] = call moy estimation(sigma,r,T,K,N)

nb = 1000 ; % nb de points de la trajectoire du brownien

sample = zeros(1,N) ;

S0 = 1 ; % valeur initiale de S
t = 0:(T/nb):T ;

for i=1:N
aux = sqrt(T/nb).*randn(1,nb) ;
B = [0 , cumsum(aux)] ;

S = S0 .* exp((r-sigma^2/2).*t + sigma.*B) ;

intS = T/nb * sum(S(2:end) + S(1:(end-1))) / 2 ;

m = exp(-r*T) * max(intS/T - K,0) ;


sample(i) = m ;
end

val = mean(sample) ;

2.8 Calcul d’un put sur moyenne par méthode de Monte-Carlo


function val = put moy estimation(sigma,r,T,K,N)

nb = 1000 ; % nb de points de la trajectoire du brownien

9
sample = zeros(1,N) ;

S0 = 1 ; % valeur initiale de S
t = 0:(T/nb):T ;

for i=1:N
aux = sqrt(T/nb).*randn(1,nb) ;
B = [0 , cumsum(aux)] ;

S = S0 .* exp((r-sigma^2/2).*t + sigma.*B) ;

intS = T/nb * sum(S(2:end) + S(1:(end-1))) / 2 ;

m = exp(-r*T) * max(K-intS/T,0) ;
sample(i) = m ;
end

val = mean(sample) ;

2.9 Calcul d’un call sur moyenne par méthode de Monte-Carlo avec réduction
de variance
function [val,sample] = call moy estimation reduced var(sigma,r,T,K,N)

nb = 1000 ; % nb de points de la trajectoire du brownien

S0 = 1 ; % valeur initiale de S (x dans le texte du tp)

A = log(S0) + (r-sigma^2)*T/2 ;

B = sigma/T * sqrt(T^3/3) ;

EY = exp(-r*T) * exp(A) * call(B,K*exp(-A)) ;

sample = zeros(1,N) ;
t=0:(T/nb):T ;

for i=1:N
aux = sqrt(T/nb).*randn(1,nb) ;
BR = [0 , cumsum(aux)] ;

S = S0 .* exp((r-sigma^2/2).*t + sigma.*BR) ;
logS = log(S) ;

% calcul des integrales par methode des rectangles


intS = T/nb * sum(S(2:end) + S(1:(end-1))) / 2 ;
intlogS = T/nb * sum(logS(2:end) + logS(1:(end-1))) / 2 ;

m = exp(-r*T) * (max(intS/T - K,0) - max(exp(intlogS/T)-K,0));


sample(i) = EY + m ;
end

val = mean(sample) ;

10
2.10 Fonction servant au calcul des intervalles de confiance
function [binf,bsup] = intconf(sample,alpha)

N = length(sample) ;
m = mean(sample) ;
sigma = sqrt(var(sample)) ;

beta = -sqrt(2)*erfcinv(1+alpha) ;

binf = m - beta*sigma/sqrt(N) ;
bsup = m + beta*sigma/sqrt(N) ;

2.11 Fonction de répartition de la distribution gaussienne standard


function out = stderf(in)

out = 0.5 .* erfc(-in./sqrt(2)) ;

11
TP3 MMFI
Résolutions d’équations différentielles
stochastiques

Alexandre GRAMFORT - Cécile MALINAUD

20 juin 2005
Question 1 : Schéma d’Euler classique
1. Présentation de la méthode générale
Le schéma d’Euler permet de résoudre des équations différentielles classiques
du type :
x′ (t) = f (x(t)), x(0) donné
La version discrète du schéma d’Euler permet de travailler avec un nombre fini
T
de points et d’approcher la fonction f solution. Considérons N points, tn = n N
pour n ∈ {0...N }, on calcule :

xN N N N
0 = x(0), xn+1 = xn + f (xn )(tn+1 − tn )

Si f est suffisamment régulière, xN N


n − x(tn ) converge vers zéro quand N tend
vers l’infini, avec x la solution de l’équation différentielle.

2. Simulation de la solution
Résolvons l’équation différentielle sur [0, 5] :
3
x′ (t) = x(t), x(0) = 1
2

2000
dx=0.50
1800 dx=0.10
dx=0.01
1600 Solution theorique

1400

1200

1000

800

600

400

200

0
0 1 2 3 4 5

F IG . 1 – Approximation de la solution pour différents pas

1
Question 2 : Application du schéma d’Euler aux équations
différentielles stochastiques
1. Présentation de la méthode
Dans cette question, il s’agit de transposer la méthode d’Euler à des équations
différentielles stochastiques.
On cherche à résoudre une équation (qui décrit par exemple l’évolution d’un
actif financier) du type :

dSt = aSt dt + bSt dBt , S(0) donné


Des problèmes d’indépendance entre les mouvements browninens sur les dif-
férentes périodes apparaissent.
On se propose d’essayer 3 simulations différentes :

y0N = y(0) N
yn+1 = ynN + aynN (tn+1 − tn ) + bynN (Btn+1 − Btn )

z0N = y(0) N
zn+1 = znN + aznN (tn+1 − tn ) + bznN (Btn − Btn−1 )

w0N = y(0) N
wn+1 = wnN + awnN (tn+1 − tn ) + bwnN (Btn+1 − Btn−1 )/2

Il s’agit de comparer les solutions obtenues grâce à ces simulations avec la


solution exacte :
1 2
St = S0 e(a− 2 b )t+Bt

2. Comparaison des 3 approximations


On va faire les simulations pour des trajectoires identiques de mouvement
browniens.
On prendra les valeurs numériques a = 32 , S0 = 1 et b = 1.
On observe que la solution w simulée par :

w0N = y(0) N
wn+1 = wnN + awnN (tn+1 − tn ) + bwnN (Btn+1 − Btn−1 )/2

ne convient pas.

2
Resolution numerique de l EDS avec T/N=0.01
7
s
y
6 z
w
5

0
0 0.2 0.4 0.6 0.8 1

F IG . 2 – Résultats des schémas d’approximation

Rt = exp(a*t+b*Bt) avec T/N=0.01


30

25

20

15

10

0
0 0.2 0.4 0.6 0.8 1

F IG . 3 – Solution suggérée par l’écriture physicienne

3
2. Solution obtenue en négligeant un terme d’Ito
Traçons maintenant la fonction Rt = eat+bBt avec le même mouvement brow-
nien que précédemment :
La fonction Rt pourrait être suggérée comme solution en partant de l’écriture
physicienne de l’équation différentielle dSt = aSt dt + bSt dBt , S(0) donné
On remarque que négliger le terme en 21 b2 t rend la trajectoire très différente
et très éloignée des trajectoires précédentes. Il faut donc être très prudent avec
l’écriture physicienne de l’équation différentielle.

3. Mais pourquoi ça marche ?


Si on a E[ynN (Btn+1 − Btn )] = 0), cela signifie que ynN est indépendant des
mouvements browniens de la subdivision suivante qui est utilisé dans la simulation.

4. Vitesse de convergence du schéma d’approximation


On va s’intéresser à la vitesse de convergence du schéma d’approximation. On
introduit la distance qui mesure l’erreur avec la solution théorique :

d(y N , S) = E[|yTN − ST |]
On évalue cette valeur par une méthode de Monte-Carlo :

1 X N,j
K
E[|yTN − ST |] = lim |yT − STj |
K→∞ K
j=1

avec y N,j est la j-ème réalisation de y N et STj est la j-ème réalisation de ST .


On représente les intervalles de confiance à 95%.
On observe bien :
c
d(y N , S) < √
N

4
16
N
Erreur d(y ,S)
14 50*sqrt(N)

12

10

0
1 1.5 2 2.5 3 3.5 4

F IG . 4 – Evolution de l’erreur

5
Annexe - TP3 MMFI
Résolution d’équations différentielles stochastiques

Alexandre GRAMFORT - Cécile MALINAUD

10 juin 2005
Table des matières
1 Sortie du programme Matlab 2

2 Listing du code Matlab 2


2.1 Fonction servant au calcul d’intervalle de confiance . . . . . . . . . . . . . . . . . . . . . . 2
2.2 Résolution d’EDO par schéma d’Euler . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
2.3 Résolution d’EDS par schéma d’Euler . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
2.4 Comparaison de l’approximation par y et w . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.5 Mise en évidence de la vitesse de convergence . . . . . . . . . . . . . . . . . . . . . . . . . 6

1
1 Sortie du programme Matlab
>> q1
>> q2
>> q3
Nombre de tirages = 10000
Erreur moyenne en N pour y = 6.6922e-05
Erreur moyenne en N pour w = 0.0020995
>> q4
Nombre de tirages = 5000

N = 10
Distance moyenne = 9.1369
Intervalle de confiance = [ 7.6373 , 10.6366]
Temps de calcul = 0.77454 s

N = 31.6228
Distance moyenne = 4.4845
Intervalle de confiance = [ 2.713 , 6.256]
Temps de calcul = 0.73211 s

N = 100
Distance moyenne = 2.1582
Intervalle de confiance = [ 1.1493 , 3.1672]
Temps de calcul = 1.3589 s

N = 316.2278
Distance moyenne = 1.0424
Intervalle de confiance = [ 0.60397 , 1.4808]
Temps de calcul = 3.1248 s

N = 1000
Distance moyenne = 0.60492
Intervalle de confiance = [ 0.37789 , 0.83195]
Temps de calcul = 9.0838 s

N = 3162.2777
Distance moyenne = 0.30074
Intervalle de confiance = [ 0.21242 , 0.38905]
Temps de calcul = 36.8182 s

N = 10000
Distance moyenne = 0.16366
Intervalle de confiance = [ 0.11909 , 0.20822]
Temps de calcul = 107.5796 s

2 Listing du code Matlab


2.1 Fonction servant au calcul d’intervalle de confiance
function [binf,bsup] = intconf(sample,alpha)

N = length(sample) ;
m = mean(sample) ;
sigma = sqrt(var(sample)) ;

2
beta = -sqrt(2)*erfcinv(1+alpha) ;

binf = m - beta*sigma/sqrt(N) ;
bsup = m + beta*sigma/sqrt(N) ;

2.2 Résolution d’EDO par schéma d’Euler


clear
close all

% resolution numerique d’EDO


x0 = 1 ;
xmin=0 ;
xmax=5 ;

dx tab = [0.5 0.1 0.01] ; % differents pas d’approximation


colors = {’r’,’g’,’b’} ;

hold on
for nb dx=1:length(dx tab)
dx = dx tab(nb dx) ;

t=(xmin:dx:xmax)’ ;

sol = zeros(length(t),1) ;

sol(1) = x0 ;

for i=1:(length(t)-1)
sol(i+1) = sol(i) + 3/2*sol(i)*dx ;
end

plot(t,sol,colors{nb dx}) ;
end

% solution theorique
sol th = exp(3.*t./2) ;

plot(t,sol th,’k’) ;
legend(’dx=0.50’,’dx=0.10’,’dx=0.01’,’Solution theorique’,2)
set(gca,’FontSize’,15);
hold off

saveas(gca,’res edo.eps’,’psc2’) ;

2.3 Résolution d’EDS par schéma d’Euler


clear
close all
randn(’state’,0) ;

% resolution numerique d’EDS


x0 = 1 ;
xmin=0 ;

3
xmax=1 ;

a = 3/2 ;
b = 3 ;

dx tab = [0.01] ; % differents pas d’approximation

for nb dx=1:length(dx tab)


dx = dx tab(nb dx) ;

t=(xmin:dx:xmax)’ ;

% on simule le brownien par methode des increments


r = sqrt(dx).*randn(length(t)-1,1) ;
B = [0 ; cumsum(r)] ; % on veut B 0 = 0

% st
s = exp((a-b^2/2).*t+b.*B) ;

% on initialise y, z et w
y = zeros(length(t),1) ;
z = zeros(length(t),1) ;
w = zeros(length(t),1) ;

y(1) = x0 ;
z(1) = x0 ;
w(1) = x0 ;

i=1 ;
y(i+1) = y(i) + a*y(i)*dx + b*y(i)*(B(i+1)-B(i));
z(i+1) = z(i) + a*z(i)*dx + b*z(i)*(B(i));
w(i+1) = w(i) + a*w(i)*dx + b*w(i)*(B(i+1))/2;

for i=2:(length(t)-1)
y(i+1) = y(i)*(1 + a*dx + b*(B(i+1)-B(i)));
z(i+1) = z(i)*(1 + a*dx + b*(B(i)-B(i-1)));
w(i+1) = w(i)*(1 + a*dx + b*(B(i+1)-B(i-1))/2);
end

figure,
plot(t,[s, y , z, w]) ;
legend([’s’ ; ’y’ ; ’z’ ; ’w’],2)
set(gca,’FontSize’,15);
title([’Resolution numerique de l EDS avec T/N=’ num2str(dx)]) ;
set(gca,’FontSize’,15);
saveas(gca,[’res eds ’ num2str(nb dx) ’.eps’],’psc2’) ;

R=exp(a.*t+b*B) ;
figure,
plot(t,R) ;
set(gca,’FontSize’,15);
title([’R t = exp(a*t+b*B t) avec T/N=’ num2str(dx)]) ;
set(gca,’FontSize’,15);
saveas(gca,[’res RT ’ num2str(nb dx) ’.eps’],’psc2’) ;
end

4
2.4 Comparaison de l’approximation par y et w
clear
close all
randn(’state’,0) ;
clc

% mise en evidence du fait que E(y^N) = solution theorique


% mais que E(w^N) n’approxime pas la solution theorique

% resolution numerique d’EDS


x0 = 1 ;
xmin=0 ;
xmax=1 ;

a = 3/2 ;
b = 3 ;

dx = 0.01 ;

nb tirages = 10000 ;% nb de tirages de y^N

t=(xmin:dx:xmax)’ ;

E y = zeros(length(nb tirages),1) ;
E w = zeros(length(nb tirages),1) ;

for i=1:nb tirages


% on simule le brownien par methode des increments
r = sqrt(dx).*randn(length(t)-1,1) ;
B = [0 ; cumsum(r)] ; % on veut B 0 = 0

% st
sol th = exp((a-b^2/2).*t+b.*B) ;

% on initialise y, z et w
y = zeros(length(t),1) ;
w = zeros(length(t),1) ;

y(1) = x0 ;
w(1) = x0 ;

i=1 ;
y(i+1) = y(i) + a*y(i)*dx + b*y(i)*(B(i+1)-B(i));
w(i+1) = w(i) + a*w(i)*dx + b*w(i)*(B(i+1))/2;

for i=2:(length(t)-1)
y(i+1) = y(i)*(1 + a*dx + b*(B(i+1)-B(i)));
w(i+1) = w(i)*(1 + a*dx + b*(B(i+1)-B(i-1))/2);
end

E y(i) = abs(sol th(length(t)) - y(length(t))) ;


E w(i) = abs(sol th(length(t)) - w(length(t))) ;

end

5
erreur y = mean(E y) ;
erreur w = mean(E w) ;

disp([’Nombre de tirages = ’ num2str(nb tirages)]) ;


disp([’Erreur moyenne en N pour y = ’ num2str(erreur y)]) ;
disp([’Erreur moyenne en N pour w = ’ num2str(erreur w)]) ;

2.5 Mise en évidence de la vitesse de convergence


close all
clear
clc
%randn(’state’,0) ;

% on s’interesse ici a la vitesse de convergence

x0 = 1 ;
xmin=0 ;
xmax=1 ; % T=1

a = 3/2 ;
b = 3 ;

nb tirages = 5000 ; % nb de tirages de y^N (le K de l’enonce)


disp([’Nombre de tirages = ’ num2str(nb tirages) ]) ;
disp(’ ’) ;

%N tab = [10, 100, 1000, 10000] ;


N tab = 10.^(1:0.5:4) ;

for N ind = 1:length(N tab)


tic

N = N tab(N ind) ;
dx = xmax/N ;

t=(xmin:dx:xmax)’ ;
lt = length(t) ;

dist tab = zeros(1,nb tirages) ;

for i=1:nb tirages


% on simule le brownien par methode des increments
r = sqrt(dx).*randn(length(t)-1,1) ;
B = [0 ; cumsum(r)] ; % on veut B 0 = 0

% on initialise y
y = zeros(length(t),1) ;

y(1) = x0 ;

for j=1:(length(t)-1)
y(j+1) = y(j)*(1 + a*dx + b*(B(j+1)-B(j)));
end

6
% st
s = exp((a-b^2/2).*t+b.*B) ;

dist tab(i) = abs(y(lt)-s(lt)) ;


end

[binf,bsup] = intconf(dist tab,0.95) ;

erreur y(N ind) = mean(dist tab) ;

tps = toc ;
disp([’N = ’ num2str(N) ]) ;
disp([’Distance moyenne = ’ num2str(erreur y(N ind)) ]) ;
disp([’Intervalle de confiance = [ ’ num2str(binf) ’ , ’ num2str(bsup) ’]’ ]) ;
disp([’Temps de calcul = ’ num2str(tps) ’ s’]) ;
disp(’ ’) ;
end

figure,
plot(log(N tab)/log(10),[(erreur y)’ , 50./sqrt(N tab)’]) ;
legend(’Erreur d(y^N,S)’,’50*sqrt(N)’) ;
set(gca,’FontSize’,15);
saveas(gca,[’res err y.eps’],’psc2’) ;

7
TP4 MMFI
Schéma de Mihlstein

Alexandre GRAMFORT - Cécile MALINAUD

20 juin 2005
Introduction : Présentation du schéma de Mihlstein
On considère l’équation :

dX(t) = σ(X(t))dBt , X(0) = x

On pose :
Rt
X(t) = X(tk ) + tk dXs
Rt
= X(tk ) + tk σ(X(s))dBs
Rt
≃ X(tk ) + tk σ(X(tk ))dBs
= X(tk ) + σ(X(tk ))(B(t) − B(tk ))

En réinjectant ce résultat dans σ, on trouve

σ(X(s)) = σ(X(tk ) + σ(X(tk ))(B(s) − B(tk )))


≃ σ(X(tk )) + σ ′ (X(tk ))σ(X(tk ))(B(s) − B(tk ))

Grâce à la formule d’Ito, on trouve :

d(Bs2 ) = 2Bs dBs + ds

C’est à dire :
1
Bs dBs = (d(Bs2 ) − ds)
2
d’où :

R tk+1 R
1 tk+1
Rt Rt
tk (B(s) − B(tk ))dBs = 2 tk d(Bs2 ) − 21 tkk+1 ds − B(tk ) tkk+1 dBs
1 2 2 1
= 2 (B(tk+1 ) − B(tk ) ) − 2 h − B(tk )(B(tk+1 ) − B(tk ))
1 2
= 2 ((B(tk+1 ) − B(tk )) − h)

D’où le schéma de Mihlstein pour une équation :

dXt = bXt dt + σ(Xt )dBt

s’écrit sous la forme :


X((k + 1)h) = X(kh) + h[b(X(kh)) − 21 σ ′ (X(kh))σ(X (kh))]
+σ(X(kh))[B((k + 1)h) − B(kh)]
+ 21 σ ′ (X(kh))σ(X(kh))[B((k + 1)h) − B(kh)]2

1
Question 1 : Application du schéma de Mihlstein à un actif
financier
1. Comparaison avec le schéma d’Euler
Il s’agit maintenant d’appliquer le schéma pour simuler l’évolution d’un actif
financier. On s’intéresse donc à l’équation :
dSt = St (rdt + σdBt ), S(0) = x
On trouve donc :
1 1
S((k+1)h) = S(kh)(1+h(r− σ 2 )+σ[B((k+1)h)−B(kh)]+ σ 2 [B((k+1)h)−B(kh))2 ]
2 2

Resolution numerique de l EDS avec T/N=0.06


140
Solution exacte
Schema d Euler
120 Schema de Mihlstein

100

80

60

40

20

0
0 1 2 3 4 5

F IG . 1 – Comparaison du schéma d’Euler et du schéma de Mihlstein

Le schéma de Milhstein semble meilleur que celui d’Euler, nous allons confir-
mer cela en s’intéressant à l’erreur.

2. Majoration numérique de l’erreur


Montrons que l’erreur est majorée par une constante une fonction quadratique
en h :

2
E[sup |S(kh) − S(kh)|] ≤ ch2
k

Evolution de l erreur en fonction de h


500
erreur moyenne par euler
450 erreur moyenne par milhstein
1000*h2
400

350

300

250

200

150

100

50

0
0 0.002 0.004 0.006 0.008 0.01
h

F IG . 2 – Comparaison des erreurs entre les 2 schémas

On constate que le schéma de Milhstein permet d’obtenir une erreur bien in-
férieure au schéma d’Euler. Il est donc plus approprié à la simulation d’un actif
financier.

Question 2 : Extension du schéma pour une EDS à plu-


sieurs dimensions
On cherche à généraliser la métholde de Mihlstein pour une EDS de la forme :

X
d
dXti = b(Xt )dt + σi,j (Xt )dBj (t)
j=1

où B1 ...Bd sont d mouvements browniens indépendants et X(t) = (X 1 (t)...X N (t))


est un processus à valeurs dans RN .

3
Pour cela, il nous faudrait simuler le triplet :
Z h Z h
[B1 (h), B2 (h), B1 (s)dB2 (s) − B2 (s)dB1 (s)]
0 0
Rh Rh
Il apparait des difficultés dans la simulation de 0 B1 (s)dB2 (s)− 0 B2 (s)dB1 (s)

Cherchons à simuler la fonction f de θ définie par


Z h Z h
f (θ) = E[cos(θ( B1 (s)dB2 (s) − B2 (s)dB1 (s)))]
0 0
et à montrer que :
1
f (θ) =
cosh(θ)

Nb tirages = 1000, dt = 0.01


1

0.8

0.6

0.4

0.2

−0.2
−4 −3 −2 −1 0 1 2 3 4
theta
valeur theorique
valeur empirique
borne inferieure de l intervalle de confiance
borne superieure de l intervalle de confiance

F IG . 3 – Estimation par méthode de Monte-Carlo de f (θ)

4
Nb tirages = 1000, dt = 0.001
1

0.8

0.6

0.4

0.2

0
−4 −3 −2 −1 0 1 2 3 4
theta
valeur theorique
valeur empirique
borne inferieure de l intervalle de confiance
borne superieure de l intervalle de confiance

F IG . 4 – Estimation par méthode de Monte-Carlo de f (θ)

Nb tirages = 1000, dt = 0.0001


1

0.8

0.6

0.4

0.2

−0.2
−4 −3 −2 −1 0 1 2 3 4
theta
valeur theorique
valeur empirique
borne inferieure de l intervalle de confiance
borne superieure de l intervalle de confiance

F IG . 5 – Estimation par méthode de Monte-Carlo de f (θ)

5
Même si l’approximation semble correcte, on observe que lorsque l’on dimi-
nue le pas d’approximation des mouvements browniens, le résultat ne s’affine pas
(l’intervalle de confiance reste de largeur constante).
Cela provient du fait que la fonction suivante :

C([′, ∞] × [′, ∞], R) −→ R


Rh Rh
(B1 , B2 ) −→ 0 B1 (s)dB2 (s) − 0 B2 (s)dB1 (s)

n’est pas continue sauf en dimension 1 (par application de la formule d’Ito).

6
Annexe - TP4 MMFI
Résolution d’équations différentielles stochastiques par schéma de
Mihlstein

Alexandre GRAMFORT - Cécile MALINAUD

20 juin 2005
Table des matières
1 Sortie du programme Matlab 2

2 Listing du code Matlab 8


2.1 Script servant à comparer la qualité des schémas d’Euler et Mihlstein . . . . . . . . . . . . 8
2.2 Script servant à illustrer la vitesse de convergence . . . . . . . . . . . . . . . . . . . . . . . 9
2.3 Illustration de l’impossibilité d’application de cette méthode aux EDS à plusieurs dimensions 10
2.4 Fonction servant au calcul d’intervalle de confiance . . . . . . . . . . . . . . . . . . . . . . 11

1
1 Sortie du programme Matlab
>> mihlstein_vs_euler
Resolution avec avec T/N = 0.06
Erreur du schema d Euler = 96.1041
Erreur du schema d Euler / (T/N)^2 = 26695.5919
Erreur du schema de Mihlstein = 16.4996
Erreur du schema de Mihlstein / (T/N)^2 = 4583.2264

Resolution avec avec T/N = 0.01


Erreur du schema d Euler = 2.2483
Erreur du schema d Euler / (T/N)^2 = 22482.981
Erreur du schema de Mihlstein = 1.2413
Erreur du schema de Mihlstein / (T/N)^2 = 12413.0244

Resolution avec avec T/N = 0.001


Erreur du schema d Euler = 0.49514
Erreur du schema d Euler / (T/N)^2 = 495135.3889
Erreur du schema de Mihlstein = 0.012286
Erreur du schema de Mihlstein / (T/N)^2 = 12286.0195

Resolution avec avec T/N = 0.0001


Erreur du schema d Euler = 0.00094657
Erreur du schema d Euler / (T/N)^2 = 94656.8635
Erreur du schema de Mihlstein = 2.9274e-07
Erreur du schema de Mihlstein / (T/N)^2 = 29.2742

>> erreur_approx

>> q2

Theta = -4
Moyenne theorique = 0.036619
Nombre de tirages = 1000
Moyenne empirique = 0.033496
Intervalle de confiance = [ -0.010477 , 0.077469]

Theta = -3.5
Moyenne theorique = 0.06034
Nombre de tirages = 1000
Moyenne empirique = 0.046563
Intervalle de confiance = [ 0.0020369 , 0.091088]

Theta = -3
Moyenne theorique = 0.099328
Nombre de tirages = 1000
Moyenne empirique = 0.059735
Intervalle de confiance = [ 0.016283 , 0.10319]

Theta = -2.5
Moyenne theorique = 0.16307
Nombre de tirages = 1000
Moyenne empirique = 0.19481
Intervalle de confiance = [ 0.15139 , 0.23823]

Theta = -2

2
Moyenne theorique = 0.2658
Nombre de tirages = 1000
Moyenne empirique = 0.25596
Intervalle de confiance = [ 0.21434 , 0.29758]

Theta = -1.5
Moyenne theorique = 0.4251
Nombre de tirages = 1000
Moyenne empirique = 0.39691
Intervalle de confiance = [ 0.35897 , 0.43486]

Theta = -1
Moyenne theorique = 0.64805
Nombre de tirages = 1000
Moyenne empirique = 0.643
Intervalle de confiance = [ 0.61413 , 0.67187]

Theta = -0.5
Moyenne theorique = 0.88682
Nombre de tirages = 1000
Moyenne empirique = 0.89629
Intervalle de confiance = [ 0.88488 , 0.90769]

Theta = 0
Moyenne theorique = 1
Nombre de tirages = 1000
Moyenne empirique = 1
Intervalle de confiance = [ 1 , 1]

Theta = 0.5
Moyenne theorique = 0.88682
Nombre de tirages = 1000
Moyenne empirique = 0.89526
Intervalle de confiance = [ 0.88406 , 0.90647]

Theta = 1
Moyenne theorique = 0.64805
Nombre de tirages = 1000
Moyenne empirique = 0.64145
Intervalle de confiance = [ 0.61271 , 0.67018]

Theta = 1.5
Moyenne theorique = 0.4251
Nombre de tirages = 1000
Moyenne empirique = 0.44776
Intervalle de confiance = [ 0.4113 , 0.48423]

Theta = 2
Moyenne theorique = 0.2658
Nombre de tirages = 1000
Moyenne empirique = 0.28642
Intervalle de confiance = [ 0.24575 , 0.32709]

Theta = 2.5
Moyenne theorique = 0.16307
Nombre de tirages = 1000

3
Moyenne empirique = 0.21221
Intervalle de confiance = [ 0.16907 , 0.25535]

Theta = 3
Moyenne theorique = 0.099328
Nombre de tirages = 1000
Moyenne empirique = 0.1005
Intervalle de confiance = [ 0.056803 , 0.1442]

Theta = 3.5
Moyenne theorique = 0.06034
Nombre de tirages = 1000
Moyenne empirique = 0.013025
Intervalle de confiance = [ -0.030898 , 0.056947]

Theta = 4
Moyenne theorique = 0.036619
Nombre de tirages = 1000
Moyenne empirique = 0.0022453
Intervalle de confiance = [ -0.041968 , 0.046459]

Theta = -4
Moyenne theorique = 0.036619
Nombre de tirages = 1000
Moyenne empirique = 0.017409
Intervalle de confiance = [ -0.02714 , 0.061959]

Theta = -3.5
Moyenne theorique = 0.06034
Nombre de tirages = 1000
Moyenne empirique = 0.058504
Intervalle de confiance = [ 0.015361 , 0.10165]

Theta = -3
Moyenne theorique = 0.099328
Nombre de tirages = 1000
Moyenne empirique = 0.10706
Intervalle de confiance = [ 0.063462 , 0.15065]

Theta = -2.5
Moyenne theorique = 0.16307
Nombre de tirages = 1000
Moyenne empirique = 0.12814
Intervalle de confiance = [ 0.085465 , 0.17081]

Theta = -2
Moyenne theorique = 0.2658
Nombre de tirages = 1000
Moyenne empirique = 0.2788
Intervalle de confiance = [ 0.23599 , 0.32161]

Theta = -1.5
Moyenne theorique = 0.4251
Nombre de tirages = 1000
Moyenne empirique = 0.41699
Intervalle de confiance = [ 0.37884 , 0.45513]

4
Theta = -1
Moyenne theorique = 0.64805
Nombre de tirages = 1000
Moyenne empirique = 0.64956
Intervalle de confiance = [ 0.621 , 0.67813]

Theta = -0.5
Moyenne theorique = 0.88682
Nombre de tirages = 1000
Moyenne empirique = 0.87676
Intervalle de confiance = [ 0.8635 , 0.89001]

Theta = 0
Moyenne theorique = 1
Nombre de tirages = 1000
Moyenne empirique = 1
Intervalle de confiance = [ 1 , 1]

Theta = 0.5
Moyenne theorique = 0.88682
Nombre de tirages = 1000
Moyenne empirique = 0.87996
Intervalle de confiance = [ 0.86636 , 0.89357]

Theta = 1
Moyenne theorique = 0.64805
Nombre de tirages = 1000
Moyenne empirique = 0.64255
Intervalle de confiance = [ 0.61322 , 0.67187]

Theta = 1.5
Moyenne theorique = 0.4251
Nombre de tirages = 1000
Moyenne empirique = 0.43258
Intervalle de confiance = [ 0.39488 , 0.47027]

Theta = 2
Moyenne theorique = 0.2658
Nombre de tirages = 1000
Moyenne empirique = 0.28645
Intervalle de confiance = [ 0.24542 , 0.32748]

Theta = 2.5
Moyenne theorique = 0.16307
Nombre de tirages = 1000
Moyenne empirique = 0.13716
Intervalle de confiance = [ 0.093645 , 0.18067]

Theta = 3
Moyenne theorique = 0.099328
Nombre de tirages = 1000
Moyenne empirique = 0.1061
Intervalle de confiance = [ 0.063599 , 0.1486]

Theta = 3.5

5
Moyenne theorique = 0.06034
Nombre de tirages = 1000
Moyenne empirique = 0.046512
Intervalle de confiance = [ 0.0028967 , 0.090126]

Theta = 4
Moyenne theorique = 0.036619
Nombre de tirages = 1000
Moyenne empirique = 0.015021
Intervalle de confiance = [ -0.028784 , 0.058826]

Theta = -4
Moyenne theorique = 0.036619
Nombre de tirages = 1000
Moyenne empirique = 0.02598
Intervalle de confiance = [ -0.018381 , 0.070342]

Theta = -3.5
Moyenne theorique = 0.06034
Nombre de tirages = 1000
Moyenne empirique = 0.060773
Intervalle de confiance = [ 0.017407 , 0.10414]

Theta = -3
Moyenne theorique = 0.099328
Nombre de tirages = 1000
Moyenne empirique = 0.1098
Intervalle de confiance = [ 0.065905 , 0.15369]

Theta = -2.5
Moyenne theorique = 0.16307
Nombre de tirages = 1000
Moyenne empirique = 0.15011
Intervalle de confiance = [ 0.10714 , 0.19308]

Theta = -2
Moyenne theorique = 0.2658
Nombre de tirages = 1000
Moyenne empirique = 0.26938
Intervalle de confiance = [ 0.22844 , 0.31033]

Theta = -1.5
Moyenne theorique = 0.4251
Nombre de tirages = 1000
Moyenne empirique = 0.43908
Intervalle de confiance = [ 0.40175 , 0.47642]

Theta = -1
Moyenne theorique = 0.64805
Nombre de tirages = 1000
Moyenne empirique = 0.65133
Intervalle de confiance = [ 0.6228 , 0.67986]

Theta = -0.5
Moyenne theorique = 0.88682
Nombre de tirages = 1000

6
Moyenne empirique = 0.89591
Intervalle de confiance = [ 0.88471 , 0.9071]

Theta = 0
Moyenne theorique = 1
Nombre de tirages = 1000
Moyenne empirique = 1
Intervalle de confiance = [ 1 , 1]

Theta = 0.5
Moyenne theorique = 0.88682
Nombre de tirages = 1000
Moyenne empirique = 0.89587
Intervalle de confiance = [ 0.8851 , 0.90663]

Theta = 1
Moyenne theorique = 0.64805
Nombre de tirages = 1000
Moyenne empirique = 0.63159
Intervalle de confiance = [ 0.60166 , 0.66151]

Theta = 1.5
Moyenne theorique = 0.4251
Nombre de tirages = 1000
Moyenne empirique = 0.43218
Intervalle de confiance = [ 0.39457 , 0.46979]

Theta = 2
Moyenne theorique = 0.2658
Nombre de tirages = 1000
Moyenne empirique = 0.3034
Intervalle de confiance = [ 0.26203 , 0.34476]

Theta = 2.5
Moyenne theorique = 0.16307
Nombre de tirages = 1000
Moyenne empirique = 0.15203
Intervalle de confiance = [ 0.10863 , 0.19544]

Theta = 3
Moyenne theorique = 0.099328
Nombre de tirages = 1000
Moyenne empirique = 0.11907
Intervalle de confiance = [ 0.075616 , 0.16252]

Theta = 3.5
Moyenne theorique = 0.06034
Nombre de tirages = 1000
Moyenne empirique = 0.0948
Intervalle de confiance = [ 0.050953 , 0.13865]

Theta = 4
Moyenne theorique = 0.036619
Nombre de tirages = 1000
Moyenne empirique = 0.044913
Intervalle de confiance = [ 0.00053639 , 0.08929]

7
2 Listing du code Matlab
2.1 Script servant à comparer la qualité des schémas d’Euler et Mihlstein
clear
close all
rand(’state’,0) % reset generateur aleatoire

% resolution numerique d’EDS par Schema d’Euler et Mihlstein


x0 = 1 ;
xmin=0 ;
xmax=5 ;

r = 1 ;
sigma = 0.5 ;

dx tab = [0.06 0.01 0.001 0.0001] ; % differents pas d’approximation

FIGURE = 1 ;

for nb dx=1:length(dx tab)


dx = dx tab(nb dx) ;

t=(xmin:dx:xmax)’ ;

% on simule le brownien par methode des increments


rv = sqrt(dx).*randn(length(t)-1,1) ;
B = [0 ; cumsum(rv)] ; % on veut B 0 = 0

% st
s = exp((r-sigma^2/2).*t+sigma.*B) ;

% on initialise y, z et w
y = zeros(length(t),1) ;
z = zeros(length(t),1) ;

y(1) = x0 ;
z(1) = x0 ;

for i=1:(length(t)-1)
y(i+1) = y(i)*(1 + r*dx + sigma*(B(i+1)-B(i))); % euler
z(i+1) = z(i)*(1 + r*dx + sigma*(B(i+1)-B(i)) +...
1/2*sigma^2*(-dx+(B(i+1)-B(i))^2)); % milhstein
end

% evaluation de la precision du schema


Err y(nb dx) = max((s-y).^2) ;
Err z(nb dx) = max((s-z).^2) ;
disp([’Resolution avec avec T/N = ’ num2str(dx)]) ;
disp([’Erreur du schema d Euler = ’ num2str(Err y(nb dx))]) ;
disp([’Erreur du schema d Euler / (T/N)^2 = ’ num2str(Err y(nb dx)/dx^2)]) ;
disp([’Erreur du schema de Mihlstein = ’ num2str(Err z(nb dx))]) ;
disp([’Erreur du schema de Mihlstein / (T/N)^2 = ’ num2str(Err z(nb dx)/dx^2)]) ;

8
disp(’ ’)

if FIGURE
figure,
plot(t,[s, y , z]) ;
legend(’Solution exacte’,’Schema d Euler’,’Schema de Mihlstein’,2)
set(gca,’FontSize’,15);
title([’Resolution numerique de l EDS avec T/N=’ num2str(dx)]) ;
set(gca,’FontSize’,15);
saveas(gca,[’res euler mihlstein ’ num2str(nb dx) ’.eps’],’psc2’) ;
end
end

2.2 Script servant à illustrer la vitesse de convergence


clear
clc
close all
rand(’state’,0) % reset generateur aleatoire

% resolution numerique d’EDS par Schema d’Euler et Mihlstein


x0 = 1 ;
xmin=0 ;
xmax=5 ;

r = 1 ;
sigma = 0.5 ;

dx tab = [0.0001 0.001 0.01] ; % differents pas d’approximation


dx tab = 10.^(-(4:(-0.5):2)) ;
N = 1000 ; % nombre de tirages

Err y = zeros(length(dx tab),1) ;


Err z = zeros(length(dx tab),1) ;

for nb dx=1:length(dx tab)


dx = dx tab(nb dx) ;

t=(xmin:dx:xmax)’ ;

for j=1:N

% on simule le brownien par methode des increments


rv = sqrt(dx).*randn(length(t)-1,1) ;
B = [0 ; cumsum(rv)] ; % on veut B 0 = 0

% st
s = exp((r-sigma^2/2).*t+sigma.*B) ;

% on initialise y, z et w
y = zeros(length(t),1) ;
z = zeros(length(t),1) ;

y(1) = x0 ;
z(1) = x0 ;

9
for i=1:(length(t)-1)
y(i+1) = y(i)*(1 + r*dx + sigma*(B(i+1)-B(i))); % euler
z(i+1) = z(i)*(1 + r*dx + sigma*(B(i+1)-B(i)) +...
1/2*sigma^2*(-dx+(B(i+1)-B(i))^2)); % milhstein
end

% evaluation de la precision du schema


Err y(nb dx) = Err y(nb dx) + max((s-y).^2) ;
Err z(nb dx) = Err z(nb dx) + max((s-z).^2) ;
end

Err y(nb dx) = Err y(nb dx) / N ;


Err z(nb dx) = Err z(nb dx) / N ;

end

figure,
plot(dx tab,[Err y , Err z, (1000*dx tab’).^2]) ;
legend(’erreur moyenne par euler’,’erreur moyenne par milhstein’,’1000*h^2’,2) ;
set(gca,’FontSize’,15);
title([’Evolution de l erreur en fonction de h’]) ;
xlabel(’h’) ;
set(gca,’FontSize’,15);
saveas(gca,[’res evo err.eps’],’psc2’) ;

2.3 Illustration de l’impossibilité d’application de cette méthode aux EDS à


plusieurs dimensions
clear
close all
clc
rand(’state’,0) % reset generateur aleatoire

% resolution numerique d’EDS par Schema d’Euler et Mihlstein


tmin=0 ;
tmax=1 ;
alpha = 0.95 ; % parametre de l’intervalle de confiance

N = 1000 ;

theta tab = (-4:0.5:4)’ ;


moyenne theorique = 1./cosh(theta tab) ;

dt tab = [0.01,0.001,0.0001] ;

for dt ind=1:length(dt tab) % nombre de tirages

dt = dt tab(dt ind) ;
t=(tmin:dt:tmax)’ ;

moyenne empirique = zeros(size(theta tab)) ;


binf theta = zeros(size(theta tab)) ;

10
bsup theta = zeros(size(theta tab)) ;

for n theta=1:length(theta tab)


theta = theta tab(n theta) ;

sample = zeros(1,N) ;

for k=1:N

% on simule les deux browniens par methode des increments


rv1 = sqrt(dt).*randn(length(t)-1,1) ;
B1 = [0 ; cumsum(rv1)] ;

rv2 = sqrt(dt).*randn(length(t)-1,1) ;
B2 = [0 ; cumsum(rv2)] ;

% calcul de la variable aleatoire


sample(k) = cos(theta * sum(cumsum(rv1).*rv2 - cumsum(rv2).*rv1)) ;

end

moyenne empirique(n theta) = mean(sample) ;


[binf,bsup] = intconf(sample,alpha) ;
binf theta(n theta) = binf ;
bsup theta(n theta) = bsup ;

disp([’Theta = ’ num2str(theta) ]) ;
disp([’Moyenne theorique = ’ num2str(moyenne theorique(n theta)) ]) ;
disp([’Nombre de tirages = ’ num2str(N) ]) ;
disp([’Moyenne empirique = ’ num2str(moyenne empirique(n theta)) ]) ;
disp([’Intervalle de confiance = [ ’ num2str(binf) ’ , ’ num2str(bsup) ’]’ ]) ;
disp(’ ’) ;

end

figure,
plot(theta tab,[moyenne theorique , moyenne empirique, binf theta, bsup theta]) ;
set(gca,’FontSize’,15);
xlabel(’theta’) ;
legend(’moyenne theorique’ , ’moyenne empirique’, ’binf theta’,...
’bsup theta’,’Location’,’SouthOutside’) ;
title([’Nb tirages = ’ num2str(N) ’, dt = ’ num2str(dt)]) ;
set(gca,’FontSize’,15);
saveas(gca,[’cosh ’ num2str(dt ind) ’.eps’] ,’psc2’) ;
pause(0.1) ;
end

2.4 Fonction servant au calcul d’intervalle de confiance


function [binf,bsup] = intconf(sample,alpha)

N = length(sample) ;
m = mean(sample) ;
sigma = sqrt(var(sample)) ;

beta = -sqrt(2)*erfcinv(1+alpha) ;

11
binf = m - beta*sigma/sqrt(N) ;
bsup = m + beta*sigma/sqrt(N) ;

12