Tps Mmfi Gramfort Malinaud

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
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
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
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


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

12
Annexe - TP1 MMFI
Simulation de processus gaussiens
Alexandre GRAMFORT - Cécile MALINAUD
10 juin 2005
Table des matières
1 Sortie du programme Matlab global (script demo tp1.m) 2
2 Listing du code Matlab 2

2.1 Script de lançement des programmes du tp . . . . . . . . . . . . . . . . . . . . . . . . . . 2
2.2 Programme générant un mouvement brownien par méthode des incréments . . . . . . . . 4
2.3 Programme générant un mouvement brownien par méthode des cholesky . . . . . . . . . . 5
2.4 Programme générant un mouvement brownien par méthode de Karhunen-Loève . . . . . . 5
2.5 Programme générant un mouvement brownien par méthode du médian . . . . . . . . . . . 7
2.6 Programme effectuant le test du χ2 de la question 5 . . . . . . . . . . . . . . . . . . . . . 7
2.7 Programme générant un mouvement brownien fractionnaire (Question 6) . . . . . . . . . 8
2.8 Programme générant un mouvement brownien fractionnaire (Question 7) . . . . . . . . . 9
2.9 Programme générant un mouvement brownien fractionnaire par la fonction intégré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 lanç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) ;
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) ;
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) ;
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) ;
saveas(gcf, ’res median.eps’, ’psc2’) ;
t=toc ;
disp([’Temps passe dans le calcul par methode du point median =’ num2str(t) ’s’]) ;
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’) ;
CALCULE S = 0 ;
FIGURE = 0 ;
demo qu5
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’) ;
title(’Brownien Fractionnaire sur [0;1] avec L=500 et H=0.8’) ;
title(’Brownien Fractionnaire sur [0;1] avec L=500 et H=0.5’) ;
t=toc ;
disp([’Temps passe dans le calcul des browniens fractionnaires par Cholesky=’ num2str(t) ’s’]) ;
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’) ;
saveas(gcf, ’res brow frac2 H2.eps’, ’psc2’) ;
t=toc ;
disp([’Temps passe dans le calcul des browniens fractionnaires par integrale stochastique =’...
num2str(t) ’s’]) ;
2.2 Programme générant un mouvement brownien par méthode des incréments

function B = increments(nb,T1,T2)
%FIGURE = 0 ;
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 générant un mouvement brownien par méthode des cholesky

function B = cholesky(nb,T1,T2)
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 générant un mouvement brownien par méthode de Karhunen-

Loè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) ;
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
end
for n=1:3000
end
for n=1:4000
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 générant un mouvement brownien par méthode du mé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 géné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 générant un mouvement brownien fractionnaire (Question

7)
function B = brow frac2(L,T1,T2,H)
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 générant un mouvement brownien fractionnaire par la fonc-

tion intégré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’);
10
TP2 MMFI
Simulations d’options put et call
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
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
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
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
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.
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
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
10 juin 2005
1 Sortie du programme Matlab (demo tp2.m) 2

2.1 Script global pour lancer l’ensemble du tp . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
2.2 Calcul d’un call européen par la formule fermée de Black-Scholes . . . . . . . . . . . . . . 8
2.3 Calcul d’un put européen par la formule fermée de Black-Scholes . . . . . . . . . . . . . . 8
2.4 Calcul d’un call européen par méthode de Monte-Carlo . . . . . . . . . . . . . . . . . . . . 9
2.5 Calcul d’un put européen par méthode de Monte-Carlo . . . . . . . . . . . . . . . . . . . . 9
2.6 Calcul d’un call européen par méthode de Monte-Carlo avec réduction de variance . . . . 9
2.7 Calcul d’un call sur moyenne par méthode de Monte-Carlo . . . . . . . . . . . . . . . . . . 9
2.8 Calcul d’un put sur moyenne par méthode de Monte-Carlo . . . . . . . . . . . . . . . . . . 9
2.9 Calcul d’un call sur moyenne par méthode de Monte-Carlo avec réduction de variance . . 10
2.10 Fonction servant au calcul des intervalles de confiance . . . . . . . . . . . . . . . . . . . . 11
2.11 Fonction de ré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
call(beta=1,K=1,N=10000) = 0.9139
call(beta=1,K=1,N=100000) = 0.89106
VALEUR EMPIRIQUE DU PUT :
put(beta=1,K=1,N=100) = 0.28686
put(beta=1,K=1,N=1000) = 0.23397
put(beta=1,K=1,N=10000) = 0.23764
put(beta=1,K=1,N=100000) = 0.23884
VALEUR EMPIRIQUE DU CALL AVEC REDUCTION DE VARIANCE:
call(beta=1,K=1,N=100) = 0.88374
call(beta=1,K=1,N=1000) = 0.88858
call(beta=1,K=1,N=10000) = 0.88734
call(beta=1,K=1,N=100000) = 0.88713
VALEUR EMPIRIQUE DU CALL SUR MOYENNE :
call_moy(sigma=0.5,r=1,T=1,K=1,N=100) = 0.25478
2
VALEUR EMPIRIQUE DU CALL SUR MOYENNE AVEC REDUCTION DE VARIANCE:
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 = [ 6.0252e-05 , 0.00041153]
INFLUENCE DE SIGMA SUR LE CALL SUR MOYENNE AVEC REDUCTION DE VARIANCE:
call_moy(sigma=1,r=1,T=1,K=1,N=1000) = 0.19955
3
Intervalle de confiance = [ -1.6762 , 5.2285]

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’) ;
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) ;
title(’Evolution de l intervalle de confiance (call eur.)’) ;
xlabel(’log10(nombre de tirages)’) ;
legend(’borne inferieure’,’borne superieure’) ;
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) ;
disp([’put(beta=’ num2str(beta) ’,K=’ num2str(K) ’,N=’ num2str(N) ’) = ’ num2str(val) ]) ;
ind = ind+1 ;
end

figure,
title(’Evolution de l intervalle de confiance (put eur.)’) ;
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) ;
disp([’call(beta=’ num2str(beta) ’,K=’ num2str(K) ’,N=’ num2str(N) ’) = ’ num2str(val) ]) ;
ind = ind+1 ;
end

figure,
5
title(’Evolution de l intervalle de confiance (call avec reduction de variance)’) ;
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) ;
disp([’call moy(sigma=’ num2str(sigma) ’,r=’ num2str(r) ’,T=’ num2str(T)...
’,K=’ num2str(K) ’,N=’ num2str(N) ’) = ’ num2str(val) ]) ;
ind = ind+1 ;
end

figure,
title(’Evolution de l intervalle de confiance (call moy.)’) ;
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) ;
disp([’call moy(sigma=’ num2str(sigma) ’,r=’ num2str(r) ’,T=’ num2str(T) ...
6
ind = ind+1 ;
end

figure,
title(’Evolution de l intervalle de confiance (call sur moyenne avec RV)’) ;
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]
evo delta intconf(ind,1) = bsup-binf ;
%
disp(’ ’)
ind = ind+1 ;
end

figure,
plot(log([0.01,0.1,1,10,100])/log(10),evo delta intconf) ;
xlabel(’log10(T)’) ;
legend(’largeur de l intervalle de confiance avec RV’,...
’largeur de l intervalle de confiance sans RV’,2) ;
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]
%
disp(’ ’)
ind = ind+1 ;
end

figure,
plot(log([0.01,0.1,1,10])/log(10),evo delta intconf) ;
xlabel(’log10(SIGMA)’) ;
legend(’largeur de l intervalle de confiance avec RV’,...
’largeur de l intervalle de confiance sans RV’,2) ;
saveas(gca,’call moy rv sigma.eps’,’psc2’) ;
2.2 Calcul d’un call européen par la formule fermé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 européen par la formule fermé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 européen par mé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 européen par méthode de Monte-Carlo

function [val,sample] = put estimation(beta,K,N)
G = randn(1,N) ;
sample = max(0,K-exp(beta.*G)) ;
2.6 Calcul d’un call européen par méthode de Monte-Carlo avec ré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));
2.7 Calcul d’un call sur moyenne par mé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
2.8 Calcul d’un put sur moyenne par méthode de Monte-Carlo

function val = put moy estimation(sigma,r,T,K,N)
9
S0 = 1 ; % valeur initiale de S
t = 0:(T/nb):T ;
for i=1:N
B = [0 , cumsum(aux)] ;
S = S0 .* exp((r-sigma^2/2).*t + sigma.*B) ;
m = exp(-r*T) * max(K-intS/T,0) ;
sample(i) = m ;
end
2.9 Calcul d’un call sur moyenne par méthode de Monte-Carlo avec réduction
de variance
function [val,sample] = call moy estimation reduced var(sigma,r,T,K,N)
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)) ;
t=0:(T/nb):T ;
for i=1:N
BR = [0 , cumsum(aux)] ;
S = S0 .* exp((r-sigma^2/2).*t + sigma.*BR) ;
logS = log(S) ;
% calcul des integrales par methode des rectangles

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
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 ré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
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
Résolution d’équations différentielles stochastiques
10 juin 2005
1 Sortie du programme Matlab 2

2.1 Fonction servant au calcul d’intervalle de confiance . . . . . . . . . . . . . . . . . . . . . . 2
2.2 Résolution d’EDO par schéma d’Euler . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
2.3 Résolution d’EDS par schéma d’Euler . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
2.4 Comparaison de l’approximation par y et w . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.5 Mise en é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
N = 10
Distance moyenne = 9.1369
Temps de calcul = 0.77454 s
N = 31.6228
N = 100
N = 316.2278
N = 1000
N = 3162.2777
N = 10000

2.1 Fonction servant au calcul d’intervalle de confiance
m = mean(sample) ;
2
2.2 Résolution d’EDO par sché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 Résolution d’EDS par schéma d’Euler

clear
close all
% resolution numerique d’EDS

x0 = 1 ;
xmin=0 ;
3
xmax=1 ;
a = 3/2 ;
b = 3 ;
dx tab = [0.01] ; % differents pas d’approximation

% 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;
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)
title([’Resolution numerique de l EDS avec T/N=’ num2str(dx)]) ;
saveas(gca,[’res eds ’ num2str(nb dx) ’.eps’],’psc2’) ;
R=exp(a.*t+b*B) ;
figure,
plot(t,R) ;
title([’R t = exp(a*t+b*B t) avec T/N=’ num2str(dx)]) ;
saveas(gca,[’res RT ’ num2str(nb dx) ’.eps’],’psc2’) ;
end
4
2.4 Comparaison de l’approximation par y et w
clear
close all
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
E y = zeros(length(nb tirages),1) ;
E w = zeros(length(nb tirages),1) ;
for i=1:nb tirages

% st
sol th = exp((a-b^2/2).*t+b.*B) ;
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;
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 é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 ;
lt = length(t) ;
dist tab = zeros(1,nb tirages) ;
for i=1:nb tirages

% on initialise y
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([’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)’) ;
saveas(gca,[’res err y.eps’],’psc2’) ;
7
TP4 MMFI
Schéma de Mihlstein
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
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
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
Résolution d’équations différentielles stochastiques par schéma de
Mihlstein
20 juin 2005
1 Sortie du programme Matlab 2

2.1 Script servant à comparer la qualité des schémas d’Euler et Mihlstein . . . . . . . . . . . . 8
2.2 Script servant à illustrer la vitesse de convergence . . . . . . . . . . . . . . . . . . . . . . . 9
2.3 Illustration de l’impossibilité d’application de cette méthode aux EDS à 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



Erreur du schema de Mihlstein = 2.9274e-07
>> erreur_approx
>> q2
Theta = -4
Moyenne theorique = 0.036619
Moyenne empirique = 0.033496
Theta = -3.5
Theta = -3
Theta = -2.5
Theta = -2
2
Theta = -1.5
Theta = -1
Theta = -0.5
Theta = 0
Moyenne theorique = 1
Moyenne empirique = 1
Intervalle de confiance = [ 1 , 1]
Theta = 0.5
Theta = 1
Theta = 1.5
Theta = 2
Theta = 2.5
3
Theta = 3
Theta = 3.5
Theta = 4
Theta = -4
Theta = -3.5
Theta = -3
Theta = -2.5
Theta = -2
Theta = -1.5
4
Theta = -1
Theta = -0.5
Theta = 0
Theta = 0.5
Theta = 1
Theta = 1.5
Theta = 2
Theta = 2.5
Theta = 3
Theta = 3.5
5
Theta = 4
Theta = -4
Theta = -3.5
Theta = -3
Theta = -2.5
Theta = -2
Theta = -1.5
Theta = -1
Theta = -0.5
6
Theta = 0
Theta = 0.5
Theta = 1
Theta = 1.5
Theta = 2
Theta = 2.5
Theta = 3
Theta = 3.5
Theta = 4
7
2.1 Script servant à comparer la qualité des sché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 ;


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) ;
y(1) = x0 ;
z(1) = x0 ;
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)
title([’Resolution numerique de l EDS avec T/N=’ num2str(dx)]) ;
saveas(gca,[’res euler mihlstein ’ num2str(nb dx) ’.eps’],’psc2’) ;
end
end
2.2 Script servant à illustrer la vitesse de convergence

clear
clc
close all

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 j=1:N

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) ;
y(1) = x0 ;
z(1) = x0 ;
9
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) ;
title([’Evolution de l erreur en fonction de h’]) ;
xlabel(’h’) ;
saveas(gca,[’res evo err.eps’],’psc2’) ;
2.3 Illustration de l’impossibilité d’application de cette méthode aux EDS à

plusieurs dimensions
clear
close all
clc

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) ;
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 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(’ ’) ;
end
figure,
plot(theta tab,[moyenne theorique , moyenne empirique, binf theta, bsup theta]) ;
xlabel(’theta’) ;
legend(’moyenne theorique’ , ’moyenne empirique’, ’binf theta’,...
’bsup theta’,’Location’,’SouthOutside’) ;
title([’Nb tirages = ’ num2str(N) ’, dt = ’ num2str(dt)]) ;
saveas(gca,[’cosh ’ num2str(dt ind) ’.eps’] ,’psc2’) ;
pause(0.1) ;
end
2.4 Fonction servant au calcul d’intervalle de confiance

m = mean(sample) ;
11
12

Tps Mmfi Gramfort Malinaud

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Tps Mmfi Gramfort Malinaud

Transféré par

Droits d'auteur :

Formats disponibles

TP1 MMFI

Simulation de processus gaussiens

Alexandre GRAMFORT - Cécile MALINAUD

Increments avec nb = 128 Increments avec nb = 512

Increments avec nb = 1024 Increments avec nb = 4096

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

Karhunen avec nb = 128 Karhunen avec nb = 512

Karhunen avec nb = 1024 Karhunen avec nb = 4096

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

Cholesky avec nb = 128 Cholesky avec nb = 512

Cholesky avec nb = 1024 Cholesky avec nb = 4096

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

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

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

Median avec nb = 128 Median avec nb = 512

Median avec nb = 1024 Median avec nb = 4096

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

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

Méthode des incréments 128 8.1895 0.9360 0.092228

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

Méthode de Cholesky 128 8.828 0.97867 0.13627

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

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

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

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

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

Question 5 : test de loi

avec H ∈ ]0, 1].

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

F IG . 6 – Résultat de brownien fractionnaire avec H=0.2, L=500, T=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

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

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

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

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

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

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

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

Alexandre GRAMFORT - Cécile MALINAUD

2 Listing du code Matlab 2

2 Listing du code Matlab

global CALCULE S FIGURE

2.2 Programme générant un mouvement brownien par méthode des incréments

2.3 Programme générant un mouvement brownien par méthode des cholesky

global CALCULE S FIGURE

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

2.4 Programme générant un mouvement brownien par méthode de Karhunen-

global FIGURE CALCULE S

N = 5000 ; % taille de la somme partielle

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

2.5 Programme générant un mouvement brownien par méthode du médian

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

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

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

for i=1:nb traj

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

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

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

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

Test accepte = (T khi2 < 31.4104)

T khi2 = sum(((nb traj1/nb interones(1,nb inter) - histo 1).^2)./...