Vous êtes sur la page 1sur 102

Stage de Recherche

Interpolation du smile de corrlation sur les CDO


Thomas JANNAUD - X2005
Avril-Aot 2008

1
TABLE DES MATIRES TABLE DES MATIRES

Table des matires

I Cadre du stage 4
1 Prsentation du stage 5
1.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.2 Sujet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.3 Contraintes imposes . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.4 Dmarche et pistes explores . . . . . . . . . . . . . . . . . . . . . . . 6
1.4.1 Optimisation du spread . . . . . . . . . . . . . . . . . . . . . . 7
1.4.2 Optimisation de la Market Law . . . . . . . . . . . . . . . . . . 8
1.4.3 Recherche mathmatique . . . . . . . . . . . . . . . . . . . . . 8
1.4.4 Recherche sur linterpolation . . . . . . . . . . . . . . . . . . . 9
1.5 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

2 Le march du crdit 11
2.1 Les CDS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.1.1 Dfinition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.1.2 Prix . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.1.3 Modle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.1.4 Autres modles . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.2 Les CDO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
2.2.1 Dfinition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
2.2.2 Prix . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
2.2.3 Modle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
2.3 Implmentation des pricers . . . . . . . . . . . . . . . . . . . . . . . . 20
2.3.1 Pricer de CDS . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
2.3.2 Pricer de CDO . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2.4 Base correlation - Compound correlation . . . . . . . . . . . . . . . . . 25

II Interpolation du smile de corrlation 27


3 Contraintes 28
3.1 Condition de non arbitrage . . . . . . . . . . . . . . . . . . . . . . . . 28
3.2 Arbitrage thorique : Market Law of Losses . . . . . . . . . . . . . . . 29
3.3 Contrainte Mathmatique . . . . . . . . . . . . . . . . . . . . . . . . . 31
3.4 Mise en oeuvre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
3.5 Donnes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38

4 Linterpolation 40
4.1 Problmes gnraux dinterpolation . . . . . . . . . . . . . . . . . . . . 40
4.2 Stabilit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
4.3 Explication des diffrentes interpolations . . . . . . . . . . . . . . . . . 44
4.3.1 Linaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44

2
TABLE DES MATIRES TABLE DES MATIRES

4.3.2 Mthode de Steffen . . . . . . . . . . . . . . . . . . . . . . . . . 44


4.3.3 Interpolation Exponentielle . . . . . . . . . . . . . . . . . . . . 49
4.3.4 Interpolation par Bzier . . . . . . . . . . . . . . . . . . . . . . 53
4.3.5 Interpolation par convolution . . . . . . . . . . . . . . . . . . . 58
4.3.6 Interpolation par intgrale . . . . . . . . . . . . . . . . . . . . . 60

5 Loptimisation 63
5.1 Algorithme doptimisation . . . . . . . . . . . . . . . . . . . . . . . . . 63
5.1.1 Modification locale de fonction . . . . . . . . . . . . . . . . . . 63
5.1.2 Critre dvaluation . . . . . . . . . . . . . . . . . . . . . . . . 64
5.2 Rsultats . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
5.3 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73

III Extrapolation du smile de corrlation 74


A Preuves mathmatiques 76
A.1 Interpolation exponentielle . . . . . . . . . . . . . . . . . . . . . . . . . 76
A.2 Market Law of Losses . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
A.3 Simulation dune variable alatoire normale centre rduite . . . . . . 78
A.4 Loi normale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
A.5 Loi normale bi-dimensionnelle . . . . . . . . . . . . . . . . . . . . . . . 79

B Implmentation des fonctions 80


B.1 Pricer de CDS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
B.2 Pricer de CDO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
B.3 Interpolations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
B.3.1 Stefen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
B.3.2 Exponentielle . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
B.3.3 Convolution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
B.3.4 Bzier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
B.3.5 Intgrale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98

3
Premire partie
Cadre du stage

4
1 PRSENTATION DU STAGE

1 Prsentation du stage
Cette courte partie a pour vocation dcrire le droulement scientifique de ce
stage : description du sujet, dmarche, voies explores, mthodes employes.

1.1 Introduction
Le stage de recherche de 3me anne lEcole Polytechnique, en majeur math-
matiques appliques la finance, sest droul la Socit Gnrale, Londres, au
sein de lquipe "Recherche Quantitative sur les Drivs de Crdit". Cette quipe est
constitue dune dizaine de personnes, la plupart bases Paris puisque nous ntions
que 2 (mon manager et moi) Londres.

La premire partie du stage a consist essentiellement dans la lecture de docu-


mentation sur les CDO (le principal produit exotique trait sur notre floor) et leur
pricing. La seconde partie de ce rapport traite ce sujet en profondeur. Le principal
support, outre les recherches documentaires ponctuelles sur Internet, ft un cours
donn lEcole Centrale Paris sur les CDO [5] ainsi quun second article de la SG [3].
Dautre part, afin de mhabituer au contexte de mon stage, et afin de mieux "sen-
tir" les paramtres importants des produits de crdit, jai implment leurs pricers.
Pricer soit mme un produit est en effet une excellente aide la comprhension de
celui-ci puisque cela ncessite de connatre les tenants et les aboutissants des diffrents
paramtres entrant en jeu. Cela a aussi permis dapprendre le C# par la pratique, lan-
guage driv du Java et du Visual Basic, utilis la Socit Gnrale. Cest dailleurs
dans ce language que sont crites les dll permettant de pricer dans cette entreprise
tous les produits financiers existants.
Jai donc pu comparer les rsultats de mes pricers avec les prix plus justes de
Marx, le systme de pricing de la SG.

1.2 Sujet
La seconde partie du stage a consist entrer dans le sujet du stage proprement
dit intitul "interpolation et lextrapolation du smile de corrlation".
Seule linterpolation fut considre pour linstant, tant donn que le stage nen
est encore qu mi-parcours.

Pour tenter dtre clair sans entrer dans les dtails que lon donnera plus loin, di-
sons que le pricing doptions simples (Call, Put, ...) tient compte du smile de volatilit
implicit du march. Limplicitation se fait grce la formule de Black-Scholes.
Il existe aujourdhui un modle utilis "universellement" quivalent au modle de
Black-Scholes sur le march des actions, mais sur le march des drivs de crdit. Ce
modle permet aussi dimpliciter un smile de quelque chose (la corrlation) et cest
cette donne qui est importante.

Le problme est que le march du crdit est moins liquide que le march des
actions : les produits traits sont plus "lourds", et valent des centaines de millions

5
1.3 Contraintes imposes 1 PRSENTATION DU STAGE

deuros. Ce qui fait quil ny a que certaines valeurs qui se traitent et pas toutes.
Pour faire un parallle, cela revient ce que le march cte les puts une date T
un strike de 5, 10, 15, 20, ... On connait alors le smile de volatilit sur ces valeurs,
mais on ne sait pas ce quil vaut en 6,34 ou en 12. Il faut alors interpoler le smile
entre les valeurs donnes. Concernant les valeurs en dessous de 5, ce nest plus de
linterpolation, mais de lextrapolation.
Mais ceci ne peut pas se faire les yeux ferms en interpolant linairement par
exemple. En effet il y a des contraintes de non-arbitrage respecter. Ainsi un put de
strike 5 a un prix plus lev quun put de strike 6 par exemple. Et il faut donc faire
attention la manire dinterpoler puisque cest elle qui dtermine, in fine, le prix des
produits.

1.3 Contraintes imposes


Une des principales difficults du sujet rside dans une contrainte "pratique" vis-
-vis des traders, structureurs, ou toute autre personne qui aurait utiliser notre
interpolation : il faut quelle soit rapide. A titre dexemple pricer un produit se fait
en une ou deux secondes avec les dll de Marx (dll C# dveloppes par la SG pour
pricer tous les produits).
Le second problme est quil est demand par le manager une mthode qui ne
dpende pas du CDO choisi. Le problme se rduit donc "tant donn une suite de
points (abscisse, ordonne), trouver la meilleure mthode interpolation/extrapolation
qui donne pour la plupart des CDO des possibilits darbitrage minimales."
Cela un impact considrable sur la manire de voir les choses et sur la stratgie
adopter.

1.4 Dmarche et pistes explores


Il y a eu 4 manires daborder le sujet. Les trois premires ont une une dmarche
"arbitrage" qui na pas vraiment fonctionn, et la dernire tait une approche plus
"interpolation pure".

Aprs avoir implment notre pricer, nous nous sommes rendus compte que lon
aurait justement besoin de calculer souvent des rsultats. Nous avons choisi de crer
un fichier norme contenant des millions de rsultats dj calculs, que lon charge
dans la mmoire vive chaque excution. Nous avons ensuite cr un optimiseur qui
part dune fonction dinterpolation linaire, et qui cherche modifier localement les
ordonnes afin dobtenir une fonction qui minimise le plus possible, un sens que lon
prcisera, larbitrage. Si la cration de ce fichier est trop longue, nous avons cr une
seconde fonction doptimisation, beaucoup moins coteuse en temps de calcul.

Mis part la dernire approche, on ne peut pas vraiment affirmer que les 3 pre-
mires approches se sont produites dans un ordre chronologique. La dmarche ft en
fait plus "brouillone" avec le recul, mais il ny avait pas vraiment le choix non plus.
On ne peut pas dcider davoir de la chronologie dans les ides ! On a donc explor

6
1.4 Dmarche et pistes explores 1 PRSENTATION DU STAGE

les 3 premires pistes plus ou moins en mme temps, avanant sur 3 fronts diffrents,
lchant lun quand on ne trouve plus grand chose pour mieux revenir sur un autre.

Concernant lextrapolation, nous avons lu plusieurs documents traitant du sujet,


et sinspirant de ces sources, nous avons developp nos propres mthodes. Lextrapo-
lation tant un sujet sensible, nos mthodes ne sont pas divulgus ici.

Il y a aussi eu des moments un peu "difficiles", lorsque lon se rend compte quil
y a une erreur dans notre algorithme de calcul et que les rsultats et les courbes que
lon trace depuis 2 semaines sont donc tous refaire. Le stage ne ft donc pas aussi
structur que le rapport rsultant ! Mais cest le propre dun stage de recherche. Ce
qui a compt pour nous y retrouver tait davoir une "grande ligne directrice" : on
a eu quelques ides de piste au dpart, puis en les explorant on a pens dautres
pistes. Mais on a toujours eu lobjectif final en vue.

1.4.1 Optimisation du spread


La premire approche ft de sintresser la courbe de spread obtenue en fonc-
tion dune interpolation donne, et doptimiser numriquement linterpolation afin
dobtenir la meilleure courbe de spread possible.
loptimisation numrique consiste dans notre cas modifier trs peu les ordonnes
dune fonction, vrifier si cela optimise plus un critre que "lancienne" fonction, et
ritrer le procd. Le critre est ici "y-a til beaucoup darbitrage sur la courbe de
spread rsultant de linterpolation de la corrlation ?"
Ce faisant, on se serait pench sur la forme de linterpolation rendant optimale le
spread, et en comparant plusieurs graphes, on aurait ensuite recherch une quation
ou une formule permettant de retrouver directement (de manire approche) linter-
polation sans refaire tourner lalgorithme doptimisation.

Remarque : Par rapport au parallle dress plus avant, le spread est ce qui joue le
rle du prix dans le domaine du crdit.

Cela na malheureusement donn que peu de rsultats, ce qui ft quelque peu dce-
vant. Plusieurs raisons cela : lalgorithme de minimisation partait dune fonction, la
modifiait localement, et dcidait de la "qualit" de cette nouvelle fonction au travers
dune fonction dvaluation.

La premire raison est quil nest pas si simple que cela de choisir une fonction
dvaluation : il faut jouer sur "est ce que la fonction est lisse", tout autant que "ny a
til pas trop darbitrage ?" sachant que ces questions ont toutes des rponses diffrentes
suivant les "normes" que lon choisit (somme des carrs des erreurs de lissages, ou des
valeurs absolues ...) la calibration nest pas simple.

Dautre part le processus de modification de la fonction "bougeait" une seule


ordonne la fois, crant un "pic" local, mme si calibr pour tre de faible intensit.
Ceci cre donc un dfaut dans le lissage pour esprer gagner en arbitrage. Mais sur
toutes les simulations lalgorithme convergeait vers une fonction qui ne nous intressait

7
1.4 Dmarche et pistes explores 1 PRSENTATION DU STAGE

pas : la cration dun "pic" local stait amplifie avec les itrations en un seul endroit.,
d la fonction dvaluation qui prfrait augmenter un pic afin de crer une "marche"
sur larbitrage plutt que de lisser la fonction.

Enfin, lide initiale tait dutiliser la mthode du recuit simul, qui fonctionne
trs bien pour le problme du voyageur de commerce par exemple. Le principe de
cet algorithme est plus ou moins le mme que celui que lon a fait, une diffrence
prs : on part dune fonction, on la modifie lgrement, et si elle a une "qualit"
meilleure que la fonction prcdente, on conserve le changement. Ou bien on accepte
avec une certaine probabilit une nouvelle fonction qui nest pas forcment meilleure
que la prcdente (probabilit dpendant du nombre ditrations dj ralises et de
la diffrence numrique entre les 2 "qualits" values).
Cet algorithme est trs allchant : en thorie il peut permettre dviter de converger
vers un extremum local mais pas global en "sautant" avec une certaine probabilit
pour "schapper" de ces mauvais puits attractifs. Mais en pratique, il est trs dlicat
mettre en oeuvre : les versions que lon a testes voyaient leur "qualit" se dgrader
progressivement plutt que de grimper, suite des probabilits de saut trop leves.
Les changements en ce sens ne rsolvaient rien, part revenir lalgorithme simple
doptimisation (basique, sans probabilits).

1.4.2 Optimisation de la Market Law


Cette seconde approche ft semblable la premire. Cette fois, ce nest pas la
courbe de spread qui tait regarde, mais une courbe plus thorique de probabilit de
dfaut implcite par le march. Elle possde de fait naturellement des contraintes de
continuit et de croissance. Il ny a pas darbitrage rel qui correspond cette courbe
abstraite, mais on a pu se rendre compte au moyen de tests numriques quil y avait
un rapport entre cette courbe abstraite et les prix rels du march.

Lide de la fonction "abstraite" associe au march est tire de larticle "Pricing


a CDO with a smile", SG, Fvrier 2005 et il a suffit de rajuster notre fonction
dvaluation (sans modifier quoique ce soit dautre notre fonction doptimisation).
Ceci ne donnait pas de rsultats trs cohrents non plus, pour les raisons invoques
plus haut.

1.4.3 Recherche mathmatique


Nous avons aussi dcid de chercher des conditions thoriques sur la fonction
dinterpolation. Ces conditions ne sont pas faciles trouver puisque les CDO sont des
produits somme toute complexes et quil ny a pas de formule ferme.
Cependant aprs des recherches laborieuses qui semblaient ne pas aboutir, puis en
reprenant le travail et en effectuant des approximations successives nous avons russi
formuler une contrainte thorique sur le smile de corrlation, respectant labsence
darbitrage.
Malheureusement lquation diffrentielle obtenue est beaucoup trop complique
pour tre utilise aisment. Et numriquement elle ne donne pas de bons rsultats
non plus.

8
1.5 Conclusion 1 PRSENTATION DU STAGE

1.4.4 Recherche sur linterpolation


Puisque ces trois premires mthodes ne fonctionnaient pas, il nous a fallu rflchir
une quatrime. Nous avons donc dcid de nous intresser purement linterpola-
tion de points, cest dire trouver une manire dinterpoler la plus "lisse" possible,
tout en veillant ce quelle respecte certaines contraintes de monotonie par exemple.
Nous nous sommes inspirs de [4] Puis, tant donne cette interpolation, on constate
simplement quelle est la forme de la courbe de spread qui en rsulte. Nous avons
implment beaucoup de mthodes diffrentes afin de pouvoir faire un choix parmi le
plus de mthodes possible et valuer les avantages et les inconvnients de chacune.
Et ce choix sest avr plus appropri que les prcdents. En effet, il apparaissait
clair dans certains articles [2] que les discontinuits (dune fonction ou de ses drives)
craient des discontinuits sur la courbe de spread, et par voie de consquence des
possibilits darbitrage. Le choix judicieux semble avec le recul tre de faire fi de la
courbe de spread rsultante et de se concentrer sur des manires dinterpoler.

Il nous a donc fallu nous documenter une seconde fois sur un sujet compltement
diffrent de la finance, beaucoup plus "maths appliques". Mais si la documentation
sur linterpolation est plutt bien fournie concernant linterpolation dune fonction
par des polynmes par exemple, elle est assez faible concernant linterpolation entre
un nombre fini de points et il nous a fallu inventer nos propres mthodes.
Il y a en fait un intrt certain ce quil ny ait pas beaucoup de documentation
sur un sujet : dune part cest un gain de temps de ne pas avoir beaucoup darticles
lire, et dautre part on peut rflchir quelque chose de neuf puisque nos penses ne
sont pas biaises par des lectures sur le sujet.

1.5 Conclusion
Ce stage fut loccasion de dcouvrir dune part une entreprise en fonctionnement
et dautre part de se lancer dans un projet de recherche de relativement longue dure
(vis--vis des expriences que lon a eu), seul, plein temps.
En effet dans une salle de trading cohabitent beaucoup de personnes, des quants
aux structureurs en passant par traders, sales, commandos, ... Il nest pas facile de
sexpliquer la manire dont les quipes simbriquent les unes dans les autres pour
former un tout, et lire des explications sur le sujet sans lavoir vcu napporte pas
toujours beaucoup dinformations. Cest important davoir t au contact des quipes
pour comprendre leur rle.

Concernant le mtier de quant, cela donne une ide de la manire dont fonctionnent
les chercheurs, et de la vie quils mnent. A laube de sengager dans la vie active et de
se dcider pour un mtier, choix non dfinitif notre ge mais qui reprsente toutefois
une tape importante de notre vie, il est essentiel davoir une petite ide sur les divers
mtiers quoffre une grande banque.
Le travail de chercheur est assez particulier : on peut tre sur une voie pendant
1 semaine, puis se rendre compte que la voie est bloque et quil faut en choisir une
autre. On a alors un sentiment au pire de "dfaite" et au mieux de temps perdu. A

9
1.5 Conclusion 1 PRSENTATION DU STAGE

ce titre, la recherche a des cts dcourageants. Il faut aussi lire beaucoup darticles
pour se faire une ide des connaissances accumules sur un sujet, et la lecture est
souvent un travail fastidieux auquel il faut pourtant shabituer. Il faut bien oser dire
que certains articles ne fourmillent en gnral pas dexplications mais se perdent dans
les gnralits ce qui rend la tche difficile.
Il y a bien entendu les "bons moments" aussi : apprendre puis comprendre de
nouveaux modles, sintresser de nouvelles mthodes, discuter les rsultats avec ses
collgues, voir son programme marcher avec satisfaction, ...

10
2 LE MARCH DU CRDIT

2 Le march du crdit
Aprs une dfinition des diffrents produits (CDS, CDO), nous lverons le voile
sur leur prix et la manire de les pricer.

2.1 Les CDS


2.1.1 Dfinition
Les CDS sont au march du crdit ce que les actions sont au march equity : ils
reprsentent en quelque sorte lentit de base, sur laquelle des produits drivs vont
tre crs.
Une entit A prte de largent B. B doit lui rembourser une certaine somme
(un peu plus que le prt) la date T. Cependant A veut sassurer contre le risque de
dfaut de B (faillite, ...). A fait appel une entit externe C qui va prendre le risque
de le couvrir moyennant une certaine somme payable tous les 3 mois par exemple.

Ainsi :
Si B ne fait pas dfaut avant T, il rembourse compltement A.
A verse de largent (le spread) C tous les 3 mois tant que B na pas fait dfaut.

Si B fait dfaut avant T, C verse A largent que B lui doit.

Ce type de contrat porte le nom de CDS : Credit Default Swap.


En pratique, mme si B fait dfaut, il peut rembourser une petite partie de ce quil
doit A : cest ce quon appelle le taux de recouvrement. Si B doit rembourser
N en T, sil fait dfaut il dlivrera bien en mal en la somme N*R. C ne devra alors
rembourser A que N*(1-R).

Dans la pratique encore, un CDS est un contrat, et les termes de celui-ci sont
stipuls de manire trs prcise : dfinition de ce quest un "dfaut" (faillite de B,
incapacit rembourser, ngociation dans la manire de rembourser la dette (= "re-
structuring"), ...), dates des paiements des spreads. Celles-ci sont en fait normalises,
de manire pouvoir rendre le march des CDS plus liquide : les maturits des CDS,
ainsi que les dates de paiement de spreads sont les 20 mars, 20 juin, 20 septembre et
20 dcembre.

2.1.2 Prix
C devra verser A :
F loatLeg = E Q (B N (1 R) 1{ T ) )
La float Leg est aussi appele jambe de prime ; elle correspond lesprance sous
la probabilit risque-neutre de la prime dassurance que payera C A. Si le taux
dintrt tait nul, on aurait F loatLeg = N (1 R).Q( T ). Cest dire probabilit
risque neutre de dfaut multipli par ce quil faudrait payer sil y avait dfaut.

Notations

11
2.1 Les CDS 2 LE MARCH DU CRDIT

Bt est le zro-coupon (que lon peut prendre gal exp(r t)).


est linstant de dfaut de B.

Quant lui, A devra verser C (en notant s le spread par unit de nominal) :

Xn Xn
F ixedLeg = E Q ( Bti N s i 1 >ti + E Q ( B N s 1ti1 < <ti )
i=1 i=1

(le spread se paye tous les ti et est proportionnel la priode passe (deltai =
ti1 < < ti = 3 mois environ). Sil y a dfaut avec ti1 < < ti , il faut donc payer
le spread sur [ti1 , ] car on est protg sur cette priode.

Le spread de march (ou fair-spread) est celui qui galise la Floatleg et la FixedLeg.

2.1.3 Modle
En se rfrant aux formules ci-dessus, on note que le problme revient enti-
rement modliser linstant de dfaut de B.

En pratique, est vu comme une variable alatoire qui suit une loi dextinction
de Poisson : sur [t, t + dt], la probabilit de dfaut sachant quil ny a pas eu dfaut
avant est t dt.

Zt
Ainsi, P ( > t) = exp( s ds)
0

Pour calibrer , comme le march des CDS est assez liquide, on dispose des fair-
spread dun certain CDS sur plusieurs maturits. En supposant constant par mor-
ceaux, on en dduit par bootstrapping.
Exemple : on connait le prix dun CDS (son spread) pour T = 5 ans, 7 ans et 10
ans.
On cherche [05] tel que spread([05] ) = spread_march 5 ans. Ensuite,
on cherche [57] tel que notre spread galisera celui du march 7 ans, puisque
maintenant [05] est connu. Et ainsi de suite.
Connaissant enfin compltement, on peut en dduire le prix dun CDS toute
date comprise entre 0 et 10 ans.

2.1.4 Autres modles


Merton Ce modle est lun des tout premiers concernant les CDS. Il est un petit
peu lquivalent du modle de Black Scholes pour ceux-ci.

Voici le principe : plutt que de sen tenir un modle abstrait comme celui o
la probabilit de dfaut suit une loi exponentielle, on prfre ici une reprsentation

12
2.1 Les CDS 2 LE MARCH DU CRDIT

plus conomique de ce quest un dfaut : il y a dfaut quand lentreprise ne peut pas


sacquitter de sa dette, cest dire si sa valeur liquide totale (actifs + passifs) est en
dessous dun certain seuil (la dette).

Formalisation :
At = Et + Dt o At reprsente la valeur dune entreprise, Et ses actifs, et Dt sa
dette.

Lentreprise doit rembourser L en T. Il y aura dfaut si AT < L.

On suppose que dAt


At = r.dt + .dWtQ .

Le spread doit se voir comme la diffrence entre le rendement sans risque et le


rendement risqu.
S(t, T ) = Y (t, T ) Y (t, T ) o Y = ln B(t,T
T t
)
et Y = ln B(t,T
T t
)
avec B(t, T ) =
Q AT
B(t, T ) E (min( L , 1)|Ft )

Rq : B(t, T ) est le zro-coupon pay la date t, de maturit T. min( ALT , 1) signifie


que si lentreprise ne fait pas dfaut, on rcupre notre mise (1), sinon, on rcupre
un certain pourcentage sur ce que lon a investi ( ALt )

Calibration de :

Et peut dsigner la valeur de laction de lentreprise. On peut donc connatre E .

DT = min(AT , L) do Dt = E Q (exp(r(T t)) min(AT , L))


et donc ET = E Q (exp(r(T t)) (AT L)+ ) (hypothse de compltude du
march)
 
Et = At .N (d1 ) B(t, T ).L.N (d2 ) (formule de Black Scholes)
soit
E = A Et .N (d1 ).
t

En inversant ce systme numriquement (d1 et d2 dpendent de E ) on peut


connatre At et .

Remarque : Inconvnients du modle :


_ Nous navons pas implment ce modle. Cependant la documentation ce sujet
laisse entendre que ce modle sous-value les spreads sur les petites maturits, ou de
manire quivalente que la probabilit de dfaut est sous-value par rapport celle
implicite sur le march.
_ Dautre part, ce modle ne donne pas de temps de dfaut : il prvoit un dfaut
maturit T, ou rien ; il ne prend pas en compte le "pass" avant T.

13
2.1 Les CDS 2 LE MARCH DU CRDIT

Fig. 1 allure de la probabilit de dfaut donne par le modle de Merton, en fonction


du temps

Modle "Credit Grade" Ce modle fut dvelopp par JP Morgan en 2001. Il


reprend le modle de Merton dans la mesure o il se base sur une donne conomique
encore une fois et pas abstraite.
Principe : une entreprise a une valeur Vt (qui ne reprsente pas exactement le cours
de laction, mais plutt la capacit de lentreprise rembourser sa dette, sa qualit
de crdit).

Quand cette valeur descend en dessous dune certaine valeur barrire (fixe ou
alatoire) il y a dfaut.
Implmentation :
dVt
Vt = dWt o Vt est la "valeur" dune entreprise qui doit rembourser L en T.

Il y aura dfaut si Vt L.

2
On peut prendre L log-normale : L = L exp(Z 2 ) o Z suit une loi normale
centre rduite.
= inf{t > 0, Vt < L}
Calibration de :

On a surtout accs la valeur de laction dune entreprise, et il faut donc avoir un


Vt qui dpende de L et de St (cours de laction).
Comme conditions aux limites on peut poser :
_ lorsque S 0, Vt est de lordre de grandeur de L
_ et lorsque S , Vt S.

Par exemple Vt = S + L convient.

Dautre part, Vt = f (S) donc par application de la formule dIt, on obtient :

14
2.1 Les CDS 2 LE MARCH DU CRDIT

Vt .dWt = f 0 (S).(S .S.dWt + .dt) + 12 .f 00 (S).S2 .dt


do
Vt = f 0 (S).S .S
soit = S . VS . V
S

S
On peut donc choisir "arbitrairement" = S . S+L . Et afin davoir une volatilit
non stochastique, on peut utiliser une valeur de rfrence S constante au lieu de S,
et de mme pour S .

Rsultats :
Cherchons la loi de dfaut donne par ce modle, et commenons par un rsultat
utile :
Proposition I.1 Si Wt est un mouvement brownien, alors P (inf st (Ws .s) >
b) = N ( ba.t

t
) e2a.b N ( ba.t
)
t
2
Il sensuit que la loi de dfaut scrit P ( > t) = P (inf st Vs > L exp(Z 2 )) =
2 2 2
P (inf st exp(Ws 2 s) > VL0 exp(Z 2 )) = P (inf st (Ws 2 s) > ln( VL0 ) +
2
2
2 F (z) 2 t
Z 2 ) = P (inf st (Ws 2 s) > 1 ln( VL0 ) + Z 2
R
) = R (z)dz.(N (
t
)
2
F (z) 2 t 2
eF (z) N (
t
)) o F (z) = ln( VL0 ) + z 2 )

L
Voyons lallure, en prenant V0 = 12 , = 0.3 et = 0.3.

Conclusion Les lois de probabilits des temps de dfaut gnres par ces 2 derniers
modles _qui se basent sur des raisonnements conomiques_ sont assez complexes,
et impliquent une utilisation de Monte-Carlo puisquil ny a pas de formule ferme
(ou alors simuler la loi, stocker beaucoup de ses valeurs et rechercher un rsultat dans
ces donnes ; et encore on peut avoir besoin de la drive, ou dintgrer...).
En outre, le modle de Merton ne donne au final quune probabilit de dfaut
maturit fixe (au lieu de donner en plus le temps de dfaut associ) et il suffit donc de
connatre un seul rel (la probabilit) plutt que de simuler beaucoup de trajectoires.
Son utilit ft en fait de pricer les premiers CDS, quand le march nen tait encore
qu ses dbuts.

Le second modle semble plus "prcis", ayant un sens encore conomique mais
donnant en plus de la probabilit de dfaut linstant de dfaut. Mais la loi de celui-ci
est trs complexe. Et comme on a pu sen rendre compte dans le pricing dun CDS, ce
qui importe au final est la densit de la loi de linstant de dfaut , pas la manire dont
on arrive cette loi. Si la loi exponentielle na certes aucun fondement conomique
(quoique dans la "nature" elle a un sens concret), quand elle est bien paramtre
(par une fonction en escalier) elle approche remarquablement la loi donne par un
modle plus terre--terre.

15
2.1 Les CDS 2 LE MARCH DU CRDIT

Fig. 2 Probabilit de dfaut donne par le modle Crdit Grade

Fig. 3 Comparaison entre les probabilits donnes par le modle de Merton et la


loi exponentielle

16
2.2 Les CDO 2 LE MARCH DU CRDIT

Exemple : En bleu, la probabilit donne par le modle de Merton (barrire fixe).


En rose, une loi exponentielle gnralise avec en escalier (3 "marches" seule-
ment, dtermines " la main"). Nous navons pas fait beaucoup deffort pour calculer
les et cependant la loi exponentielle en escalier approche trs bien la loi donne par
le modle de Merton.

Conclusion La loi exponentielle se rvle trs flexible, et trs simple mettre en


place. Dautre part elle permet des calculs exacts dans ceux de la Fixed Leg et de la
Float Leg.

2.2 Les CDO


2.2.1 Dfinition
CDO est labbrviation de "Collateralised debt obligation" : un CDO est en
quelque sorte un "panier de CDS" : on regroupe un certain nombre de CDS (une
centaine en pratique) en un seul produit. Acheter un CDS revient vendre de la
protection : on reoit un spread rgulirement, mais on paye sil y a un dfaut. Le
CDO fonctionne sur le mme principe : acheter une part de CDO revient vendre
de la protection. Mais le CDO est un produit plus complexe que le CDS : ici on peut
dcider quelle part de risque on prend (et par voie de consquence quelle sera notre
rendement risqu).

Pour simplifier, considrons 100 CDS avec des nominaux de 1 et une recovery de
0, payant tous le mme spread s.
Tant quil ny a aucun dfaut, il y a 100 * s de spread qui est pay. Ds quil y a
un dfaut, 99 * s, puis ainsi de suite.
On cre abstraitement les "tranches" [0-1%[, [1%-2%[, ... Acheter une "tranche"
revient vendre de la protection mais uniquement sur cette tranche.

Exemple : on achte la tranche [3%-4%[. On reoit une certaine quantit dargent


( dfinir) rgulirement. La contrepartie, cest quon rembourse le 4me dfaut
parmi lensemble des 100 CDS (sil arrive avant la maturit T) et on cesse alors de
recevoir notre argent/prime de risque.
Ainsi, sil y a 0, 1, 2 ou 3 dfauts cela ne change rien pour nous : on reoit ce quil
tait prvu initialement. Quil y en ait 4 ou plus revient aussi au mme : on paye la
prime (=on rembourse le dfaut) et on cesse de recevoir notre spread.

En pratique, les "tranches" ne sont pas aussi troites : [0%-3%[, [3%-6%[, [6%-9%[,
[9%-12%[, [12%-22%[, [22%-100%] (il sagit des tranches junior, mezzanine, senior et
super-senior), et par ailleurs il ny a pas exactement 100 CDS et ceux-ci nont pas
tous la mme recovery, et ils ne payent pas tous le mme spread. Il se peut donc que
la tranche sur laquelle on vend de la protection ne soit "croque" que sur une partie.
Les recovery sont par contre connues lavance.
Dire que lon vend de la protection sur la tranche [a%, b%[ signifie que lon couvre
X XN
la partie du montant des dfauts (= Ni (1Ri )) comprise entre a% Ni
i fait dfaut i=1

17
2.2 Les CDO 2 LE MARCH DU CRDIT

N
X
et b% Ni .
i=1

On paye alors le dfaut correspondant, et on continue de recevoir du spread sur le


reste de la tranche "non touche" (que lon continue dassurer).

Il est assez clair que plus la tranche que lon assure est "basse", plus lon prend
de risques. Il faut donc que lon soit mieux rmunr sur ces tranches.

Il y a donc une sorte de "redistribution" de la somme des spreads reus : on paye les
tranches senior (au prix convenu au dpart), puis les mezzanine (sil reste de largent),
puis enfin les junior (sil reste de largent). Mais ces derniers sont pays au prorata
du risque quils encourent.

2.2.2 Prix
Encore une fois, le spread reu sur une tranche se calcule en galisant en esprance
risque-neutre ce que lon va recevoir en spread, et ce que lon risque de payer.

Notations

Bt est le zro-coupon (que lon peut prendre gal exp(r t)).


[K ,K ]
Lt 1 2 = perte linstant t sur la tranche [K1 , K2 ] (K1 , K2 en pourcents) =
(Lt K1 )+ (Lt K2 )+ o Lt est la perte cumule linstant t sur le portefeuille
(= somme des dfauts sur les CDS du panier, jusqu t).
RT [K ,K ]
F loatLeg = E Q ( 0 Bt .dLt 1 2 )
n Z ti
[K1 ,K2 ]
X
F ixedLeg = E Q (s Bti (K2 K1 Lt )dt)
i=1 ti1

Le fair-spread est le spread s qui galise FloatLeg et FixedLeg.

Cette image rend bien lintuition que lon a sur les prix des CDO :
une tranche quity va tre beaucoup plus risque si la corrlation est faible, et
donc son prix est beaucoup plus fort. Il suffit en effet quil ny ait quun ou deux
dfauts pour faire "tomber" la tranche et cela est plus probable dans le cas dune
trs faible corrlation (indpendance des dfauts). Cest linverse qui se produit sur
les tranches senior : elles seront atteintes sil y a beaucoup de dfauts, et cela arrivera
plus facilement si les noms sont trs corrls. (dans le cas le plus extrme, la corrlation
vaut 1, et la probabilit que tous les noms fassent dfaut est la probabilit dun seul
dfaut ; dans le cas o la corrlation vaut 0, la probabilit vaut le produit de toutes
les probabilits... qui est quasi nul)
Entre ces tranches, les tranches mezzanines sont un peu sujettes plusieurs ten-
dances et il est plus difficile dexpliquer simplement leur prix en fonction de la corr-
lation.

18
2.2 Les CDO 2 LE MARCH DU CRDIT

Fig. 4 Fair spread en fonction de la corrlation

2.2.3 Modle
Modliser Lt revient modliser les instants des temps de dfaut 1 , 2 , ... Ce
qui compte, cette fois, cest la dpendance entre ces variables alatoires. En effet, les
temps de dfaut ne sont pas des objets purement abstraits, ils correspondent des
situations bien relles (faillite, ...) et quand "lconomie mondiale" ne va pas trs bien,
cest que beaucoup dentreprises risquent de faire dfaut : il y a bien une corrlation
entre les temps de dfaut.

Plusieurs modles ont t invents pour traiter de ces variables alatoires. En


pratique, cest celui de la copule gaussienne qui est utilis.
Explication :
- pour les CDS, on connait la loi de probabilit P ( t). On na donc besoin que
dune variable alatoire uniforme sur [0-1].
- ici on veut corrler les temps. On garde les lois de probabilit P ( t) que lon
suppose connues. Il nous faut donc simuler un vecteur alatoire corrl sur [0, 1]n et
pour ce faire on utilise le rsultat suivant : si X est une variable alatoire, et F() sa
fonction de partition, alors F(X) suit une loi uniforme sur 0-1. (Rsultat dmontr en
Appendice)
On choisit Z, 1 , ... des gaussiennes centres rduites indpendantes ainsi que
1 , 2 , ... p
On pose Xi = i .Z + 1 2i .i de telle sorte que les Xi sont des gaussiennes
centres rduites et Corr(Xi , Xj ) = i .j
Alors (F (X1 ), F (X2 ), ...) est une copule gaussienne de variables corrles (F(X)
suit une loi uniforme sur 0-1).

En pratique toutefois, plutt que de choisir 1 , 2 , ...on prend 1 = 2 = ... =


afin de faciliter les calculs et lharmonisation des modles sur les marchs.

19
2.3 Implmentation des pricers 2 LE MARCH DU CRDIT

Fig. 5 Spread dun CDS en fonction de la probabilit de dfaut

Remarque : Z reprsente ici la "variable de march", ou encore "comment va lco-


nomie mondiale/nationale".
_ SiX1 , X2 , ... sont des variablesalatoires relles quelconques, alors
[0, 1]n [0, 1]
C: est une copule si (x1 , ..., xn ), C(x1 , ..., xn ) =
(x1 , ...xn ) C(x1 , ..., xn )
P (X1 x1 , ..., Xn xn ).

La notion de Copule est surtout thorique puisquil nexiste pas (encore !) de for-
mule exprimant par exemple la fonction C pour n gaussiennes corrles.

2.3 Implmentation des pricers


2.3.1 Pricer de CDS
Le pricer de CDS a t implment de 2 manires : par MonteCarlo et par calcul
direct.
Il nous faut en effet calculer la FloatLeg et la FixedLeg (divise par le spread, que
lon appelle aussi RBPV), qui sont toutes les deux des esprances de quelque chose.

La loi tant connue, on peut soit calculer les esprances correspondantes par Mon-
Xn
teCarlo (Esperance = limn ( n1 Xi ) ) soit par intgrale sur la loi (Esperance =
R i=1
xd(x)).

Ces 2 mthodes sont quivalentes en temps et en prcision.


Les difficults dans limplmentation consistent souvent dans la connaissance des
Rx 2
fonctions elles-mmes. (ex : exp( x2 )dx ; cf Appendice pour limplmentation de

cette fonction)

20
2.3 Implmentation des pricers 2 LE MARCH DU CRDIT

Fig. 6 y = xln(1 x)

Cette courbe reprsente le spread vers par un CDS en fonction de la probabilit


de dfaut estime, en supposant lintensit de dfaut constante.
Sur une trs grande plage (en pratique la probabilit de dfaut dune entreprise
dpasse rarement les 50% !), le spread est affine en la probabilit de dfaut horizon
fix. On peut essayer de comprendre le rsultat sur les quations :
prenons r = 0 pour simplifier. Il vient F loatLeg = N (1R).Pdef aut et F ixedLeg =
Xn n
X n
X
EQ( N si 1{ >ti ) )+E Q ( N s 1{ti1 < <ti ) ) N s i E Q (1{ >ti ) ) =
i=1 i=1 i=1
n
X
N s P ( > ti ) N s E Q ( ) (i reprsente plus ou moins une dure
i=1
de 3 mois, qui est variable en nombre de jours suivant la date laquelle on se trouve)
P
Ainsi le fair spread vaut s Edef aut
Q ( )

Si a une intensit de dfaut constante, Pdef aut = 1 eT et E Q ( ) = 1 do



s .Pdef aut . = c.Pdef aut . ln(1 Pdef aut )

s c.Pdef aut . ln(1 Pdef aut )

Cette approximation permet bien dobtenir le mme type de courbe que la courbe
de fair-spread simule.

2.3.2 Pricer de CDO


Cette fois 3 implmentations ont t effectues : par MonteCarlo, par rcurrence,
et par loi Beta.

Par Monte-Carlo La programmation par Monte Carlo est "sans surprises" bien
que quelque peu longue : il faut en effet tirer 1 , 2 , ... puis trier ces temps par ordre
croissant, et retracer toute la "vie" du produit CDO, cest dire tous les primes
payer, quels coupons lon reoit, ...
Cela marche trs bien mais le temps de calcul est assez long (1 minute). On peut
rduire ce temps 10 secondes en faisant 6 fois moins de simulations, sans rduire
significativement la prcision. En effet, rappelons que la convergence en prcision de

21
2.3 Implmentation des pricers 2 LE MARCH DU CRDIT

Monte Carlo est en 1N o N est le nombre de simulations. Cependant, pour le calcul


de delta (ncessitant les drives partielles de certains rsultats) la meilleure prcision
est ncessaire.
Notons quon peut rduire un peu le temps de calcul en remarquant que le cas o
il ny a aucun dfaut nest pas forcment un vnement rare, et que lon peut donc
enregistrer la valeur de la jambe de protection pour ce cas.

Par rcurrence La programmation par rcurrence rejoint le calcul "exact" par in-
tgrale du pricer de CDS. Le principe est de calculer exactement toutes les probabilits
P(Lt = a) pour tout a, par rcurrence.
Lide est que lon a "a priori" quelque chose comme PN +1 emetteurs (Lt = a) =
PN emetteurs (Lt = a) P (n+1 > T ) + PN emetteurs (Lt = a ln+1 ) P (n+1 T )

En fait, ceci est faux car il ny a pas indpendance entre les i ! Mais lgalit
reste vraie quand on conditionne suivant la variable Z "de march". Il faut donc tout
calculer pour chaque z et calculer lintgrale ensuite et lon a en ralit :
PN +1emetteurs (Lt = a|Z) = PN emetteurs (Lt = a|Z) P (n+1 > T |Z)
+PN emetteurs (Lt = a ln+1 |Z) P (n+1 T |Z)

Implmentation :
Pour commencer il faut trouver une "loss default unit", i.e le plus grand nombre
u tel que toutes les pertes des CDS (les Ni .(1 Ri )) soient multiples de ce nombre
u. Cest en quelque sorte le PGCD de ces pertes unitaires, mais un PGCD rel et
non plus entier. On peut encore le calculer par lalgorithme dEuclide qui fonctionne
toujours. La seule difficult est quun ordinateur a une prcision parfaite sur les entiers
(compris jusqu 4.3 milliards environ, ce qui laisse souvent une marge confortable)
mais pas sur les nombres virgule flottante.
Ainsi de temps en temps on peut obtenir que 5,0 - 4,0= 0.999999999 par exemple,
ce qui fausse ensuite les calculs de PGCD. Il ne faut donc pas comparer en galit un
nombre flottant 0, mais plutt crire If (abs(x) 0.00000001) then .... Cest une
manire de faire fonctionner lalgorithme dEuclide pour calculer le nombre u.

EtantPnmaintenant assurs que tous les dfauts sont un multiple de u, on sait que
N N/ i=1 Ni .(1 Ri ) = N.u
Il faut construire une suite de "matrices" Mi indexes sur Z, t, et {1, ..., N } tel
que Mi (z, j, t) = Pi emetteurs (Lt = j.u|Z = z).
Il ne sert rien de stocker tous les tableaux tri-dimensionnels Mi , juste le dernier
suffit, puisque pour calculer Mi+1 on a juste besoin de Mi .
On comprend que cet algorithme consomme immanquablement du temps, quoique
lon fasse pour loptimiser : il faut "discrtiser R" (pour la variable alatoire Z qui
suit une loi gaussienne), discrtiser [0, T] pour connaitre les probabilits de dfaut
chaque instant t afin de calculer Fixed Leg et Float Leg. Il faut enfin faire ceci autant
de fois quil y a de noms dans le CDO. On peut faire varier Z entre -5 et 5 disons,
tant donn la densit de probabilit de la loi gaussienne.

22
2.3 Implmentation des pricers 2 LE MARCH DU CRDIT

Fig. 7 loi Beta pour diffrentes valeurs de a et b. Successivement (a, b) = (3, 10),
(2, 3), (3, 2), (10, 3)

Une fois ces matrices calcules, on connait P (Lt = j.u|Z = z) pour tout j, z et t,
probabilit sur le portefeuille total. En intgrant sur z, on obtient P (Lt = j.u) pour
tout t et j.
Une fois les probabilits calcules, on peut calculer la FloatLeg et la FixedLeg
[K ,K ]
avec les "formules" que lon a. (on a en fait besoin de calculer E Q (Lt 1 2 )). Le

temps de calcul est similaire MonteCarlo (pour une prcision quivalente) et il est
encourageant de voir apparatre les mmes rsultats (au pourcent prs) donns par
ces 2 mthodes.

Linconvnient de cette mthode par rcurrence est quelle est beaucoup moins
flexible que Monte Carlo : si un trader dsire un rsultat rapidement (10 secondes)
il peut appeler le pricing par MonteCarlo avec un nombre de simulations faible. Ce
nest pas vraiment le cas avec le pricing par rcurrence. (mme si lon peut jouer sur
le pas de lintgrale sur Z, et la prcision sur les instants t aussi, dans la grille que
lon btit)

Par loi Beta _ La programmation par "loi Beta" : on peut supposer que lorsque
lon a un nombre lev de CDS dans le panier, la loi de perte cumule suit une loi
Beta(at , bt ).
En effet, quand t est petit, il y a une grande probabilit pour quil ny ait eu encore
aucun dfaut, puis au fur et mesure que le temps augmente, il y a de plus en plus
de dfauts (aussi d la corrlation intrinsque des dfauts). On rgle les paramtres
at , bt de telle sorte que esprance et variance dune loi Beta(at , bt ) galisent esprance
et variance de Lt .
[K ,K ]
On en dduit alors E Q (Lt 1 2 ) (en les calquant sur la loi Beta).

Implmentation :
Soit lt = PnLt Li = Pn NLit(1Ri ) . On rappelle que Lt correspond la perte
i=1 i=1
courante linstant t. lt est simplement la normalise de la perte : lt [0, 1].
La loi beta de paramtres a et b est une loi continue sur [0, 1], de densit fa,b (x) =
xa1 (1x)b1 R1
B(a,b) .10x1 o B(a, b) = 0 ua1 (1 u)b1 du

Elle est dfinie pour a, b > 0 et a pour moyenne et variance :

23
2.3 Implmentation des pricers 2 LE MARCH DU CRDIT

a ab
= a+b et 2 = (a+b)2 (a+b+1) .

Preuve En admettant que B(a, b) = (a).(b)


(a+b) o (x) est la fonction Gamma usuelle,
qui vrifie (x + 1) = x(x), on a :
1
R1 1
R1 a
= B(a,b) 0
u.ua1 (1 u)b1 du = B(a,b) 0
u (1 u)b1 du
(a+1).(b)
B(a+1,b) (a+b+1)
= B(a,b) = (a).(b)
(a+b)
(a+1).(a+b) a
= (a).(a+b+1) = a+b

B(a+2,b)
De mme 2 = B(a,b) 2
(a+2).(b)
(a+b+2) a 2
= (a).(b) ( a+b )
(a+b)
(a+2).(a+b) a 2
= (a).(a+b+2) ( a+b )
a(a+1) a2
= (a+b)(a+b+1) (a+b)2
a a+1 a ab
= a+b ( a+b+1 a+b ) = (a+b)2 (a+b+1)

Concernant le calibrage de at , bt pour tout t, il nous faut calculer la moyenne


et la variance de Lt afin didentifier at et bt .
Pn
(1R ).N .p (t)
E(lt ) = Pn E(L t)
= i=1
Pn i i i
. Il ny a pas lieu de se soucier ici de la
i=1 Ni (1Ri ) i=1 Ni (1Ri )
corrlation contrairement au cas de lesprance.

V ar(lPt ) = E(lt2 ) E(lt )2


n 2
( n (1Ri ).Ni .pi (t))2
P
E( i=1 (1Ri ).Ni .1i t )
= P n
( i=1 Ni (1Ri )) 2 i=1
( n
P
Ni (1Ri ))2
i=1
Pn 1
P P 2 2
= ( i=1 Li )2 ( ij Li Lj P (i t, j t) + i Li .(pi (t) pi (t)))
1
P 1 (pi (t)), N 1 (pj (t)), ij ) + i L2i .(pi (t) p2i (t)))
P P
= ( n Li )2 ( ij Li Lj N2 (N
i=1

On connait les lois pi (t) puisque ce sont des lois de Poisson de paramtre t pris
en escalier et dduit par bootstrapping des prix des CDS. (cf la part sur les CDS)
Dautre part il y a lexistence de ci (t) telle que P (i t) = P (Xi <= ci (t)) et
donc P (i t, j t) = P (Xi <= ci (t), Xj <= cj (t))
Comme les Xi sont des variables gaussiennes centres rduites corrles, on a bien
P (i t, j t) = N2 (N 1 (pi (t)), N 1 (pj (t)), ij )
o N2 (a, b, ) = P (X1 < a, X2 < b) sachant que X1 et X2 sont gaussiennes
centres rduites de corrlation .

On a donc accs, numriquement, E(lt ) et V ar(lt ). On note ces variables


t et t2 .
Il
( faut maintenant rsoudre ) le systme :
t = ata+b t
t
t2 = (at +bt )a2t(a
.bt
t +bt +1)

24
2.4 Base correlation - Compound correlation 2 LE MARCH DU CRDIT

 
t (1t ) at = t .t
En notant t = t2
1 on peut vrifier que convient.
bt = (1 t )t

Les rsultats sont similaires ceux donns par rcurrence et Monte Carlo pour de
faibles strikes, mais pas sur de plus grands strikes.
Le temps de calcul est similaire aussi (de lordre dune minute). Encore une fois
on peut gagner en temps en diminuant la prcision lors des calculs dintgrale par
exemple.

Ces implmentations de pricers ainsi que des lectures darticles ont permis de com-
prendre le fonctionnement du march des CDS et des CDO. Il fallait ensuite comparer
les pricers crs avec celui utilis par la Socit Gnrale (Marx). Les rsultats furent
concordants.

Remarque : On notera encore une fois la difficult dimplmenter certaines fonctions


en informatique. (exemple : N 2 (x, y, ) = P (X <= x, Y <= y) o X et Y sont
gaussiennes centres de corrlationR x (cf Appendice pour limplmentation de cette
fonction) ; ou encore la loi Beta : 0 ua1 (1 u)b1 du)
_ les pricers ont t implments sur Excel en VBA. Cest cet environnement qui
a t choisi, en premier lieu, pour sa facilit lire les donnes du march dExcel.
Dautre part Excel implmente dj la loi Beta ce qui est pour le moins providentiel.
_ Enfin, il nest pas forcment facile de crer un pricer qui sadapte la taille du
march. Dans toutes nos simulations dessais il y avait un nombre fix (10) de CDS
dans le panier. Mais il faut donc rentrer 10 lignes de donnes CDS (pour diffrentes
maturits) afin davoir accs la loi (t). Il faut aussi rentrer 10 nominaux, 10 taux
de recovery, ...
et tout ceci prend de la place sur la feuille et nest pas aisment paramtrable.

2.4 Base correlation - Compound correlation


Grce au modle de la copule gaussienne on peut impliciter la corrlation utilise
pour pricer nimporte quelle tranche cte du march. Il y a donc une corrlation
implicite pour la tranche [0, 3%], [3, 6%], ... Si lon souhaite pricer une tranche [2,
4%] par exemple, on a besoin de connatre la corrlation sur cette tranche. On peut
alors interpoler les corrlations des tranches [0, 3%] et [3, 6%] par exemple. Cest
cette manire de faire qui a t utilise pendant un certain temps jusqu ce quon se
rende compte quelle ntait pas trs pratique : en effet, ce na pas trop de sens que de
moyenner des corrlations sur 2 tranches diffrentes. Cela ne donne pas des rsultats
trs prcis. Et dautre part il y a beaucoup de tranches diffrentes de type [x, y%].

A la compound correlation est ainsi prfre la base correlation. Celle-ci dnote la


correlation que lon utiliserait sur une tranche [0, x%]. On a ainsi une dimension en
moins sans perte de gnralits (connaitre les prix des CDO sur toutes les tranches
[0, x%] permet de pricer nimporte quel [x, y%]). Et dautre part il y a plus de sens
interpoler entre deux tranches [0, a%] et [0, b%] connues afin de dterminer la
corrlation sur [0, x%].

25
2.4 Base correlation - Compound correlation 2 LE MARCH DU CRDIT

Il existe un dernier type de corrlation : la local correlation. Celle-ci correspond


la compound correlation sur des tranches trs fines [x, x+dx%]. Celle-ci a aussi un
sens puisquelle a naturellement vocation tre continue. Cependant on ne peut pas
limpliciter des donnes de march, et dautre part la connatre ne permet pas de
pricer aussi simplement les produits que lorsque lon connait la base correlation par
exemple. Cependant tant donne la base-correlation on en dduit facilement la local
correlation. On peut ainsi vrifier quune interpolation donne sur la base correlation
produit une local correlation sans "surprises", ce qui fournit un critre supplmentaire.

26
Deuxime partie
Interpolation du smile de corrlation

27
3 CONTRAINTES

3 Contraintes
3.1 Condition de non arbitrage
Rappelons quil nous faut trouver une manire dinterpoler le smile de corrlation
de faon ce quil ny ait pas darbitrage possible.
Il nous faut donc comprendre dans un premier temps o peut se trouver larbitrage
sur le spread afin de chercher lliminer.
Une premire ide ft de penser que le spread sur la tranche [0, K] tait une
fonction dcroissante de K, puisque lon prend a priori plus de risque sur les tranches
les plus basses.
Mais il savre que ceci est faux : si la corrlation est trs leve, on peut prendre
plus de risque en assurant une tranche equity quune tranche senior.
Par contre, si on sintresse des tranches de largeur fixe, le rsultat devient vrai :

Proposition II.1 Pour des raisons darbitrage, la courbe de spread sur les tran-
ches [K, K+dK] doit tre dcroissante et strictement positive.

Preuve Le caractre positif de la courbe de spread est naturel : on vend de la


protection sur une tranche, cest dire que lon reoit un spread rgulirement jusqu
ce quil y ait un dfaut (ou pas) et auquel cas on paye la prime dassurance (positive).
Si le spread tait ngatif on naurait aucune raison de vouloir assurer le "client", car
on serait perdant dans tous les cas.
_ Concernant la dcroissance : Considrons a, b et tels que a, b, > 0, a + < b
et b + 1.
Supposons que le spread sur [a, a+] soit infrieur celui ci sur [b, b+] (sa, < sb, )
Stratgie darbitrage : On achte de la protection sur [a, a + ] et on vend de la
protection sur [b, b + ].
On considre plusieurs cas, suivant le montant accumul des dfauts :
Si Lt < a, on touche chaque date de paiement sb, sa, > 0.
Si a Lt a + , on touche chaque date de paiement sb, a+L
t
.sa, > 0.
Si a + < Lt b, on touche chaque date de paiement sb, > 0.
Si b < Lt b + , on touche chaque date de paiement b+L
t
.sb, > 0.
Sinon on ne touche rien.
On est donc gagnant dans tous les cas sur les montants des spreads perus. Il faut
maintenant vrifier que lon ne risque pas de payer de prime. On sintresse cette fois
LT .
Si LT < a, on ne paye ni ne touche aucune prime.
Si a LT a + , on nous payera la jambe de prime (LT a).N > 0 car on est
acheteur de protection sur [a, a + ].
Si a + < LT b, on nous a pay la jambe de prime sur [a, a + ] (= .N > 0)
Si b < LT b + , on nous a pay la jambe de prime sur [a, a + ] (= .N ) mais on
paye celle sur [b, LT ] (soit (LT b).N ) donc au final on touche ( (LT b)).N > 0
Sinon on touche la prime sur [a, a + ] mais on paye la prime sur [b, b + ] et elles
se compensent exactement.
Au final, si sa, < sb, il y a une possibilit de raliser un arbitrage.

28
3.2 Arbitrage thorique : Market Law of Losses 3 CONTRAINTES

Fig. 8 Spread sur tranchette, calcul par Marx. Des arbitrages sont possibles aux
alentours de 16% et 33%.

Le spread sur des tranches trs fines de mme taille est donc dcroissant.

Exemple : Afin de travailler sur "quelque chose de solide" et davoir des rsultats
tangibles, Marx a t prfr : il y a certainement moins de bugs dans le pricer de la
Socit Gnrale, qui est utilis depuis des annes, que dans le notre !
Pour un march donn (iTrax4) avec environ 120 noms dans le panier, ainsi que
les corrlations donnes par le march, MarxExcel a calcul les spread, fixedleg et
floatleg sur toute une tendue de strikes, avec un faible pas.

Ceci mne la problmatique du stage : comment interpoler le smile de corrlation


afin de rendre la courbe de spread non arbitrable ?

3.2 Arbitrage thorique : Market Law of Losses


Une deuxime contrainte de non-arbitrage, thorique cette fois, est apporte par
larticle [2]. Il est fait mention de la "Market law of Losses", cest dire "tant donns
les prix du march, quelle loi pour les pertes (en probabilits) peut-on en dduire ?".

P (Loss < K) = P (Loss < K, K ) Skew(K, K ) Rho(K, K )

Notation : P (Loss < K, ) est la probabilit calcule grce la copule gaussienne.


Skew(K, K ) = K
K reprsente la sensibilit de par rapport K.
R K L
Enfin, Rho(K, ) = 0 (x, )dx.

Remarque : Cette formule est dmontre en appendice.

P (Loss < K) doit tre croissante, mais rien ne semble indiquer mathmatiquement
parlant que sil y a des dcroissances locales de cette fonction, il y a de petits arbitrages
faire sur le spread. Mais pourtant cest ce qui se passe : sur ce graphique on a

29
3.2 Arbitrage thorique : Market Law of Losses 3 CONTRAINTES

Fig. 9 en bleu : arbitrage local sur le spread ; en rouge : dcroissance locale de la


Market Law of Losses.

Fig. 10 Probabilit de march donne par linterpolation linaire sur la corrlation

compar (pour linterpolation linaire) les dcroissances des tranches de spread, et les
dcroissances locales de la Market Law of Losses.
On a en fait subdivis [0, 100%] en intervalles de taille 1%, et on a cherch des
dcroissances locales et des arbitrages locaux tous les 0.1%. On compte ensuite sur
chaque intervalle de taille 1% combien il y a de "problmes", soit un nombre entier
entre 0 et 10.
Ceci a t fait pour mieux rendre compte des concidences entre larbitrage local
et la dcroissance locale de la Market Law of Losses : sinon, sil y a quelque chose sur
larbitrage pur en 5.6% et rien en 5.7% et inversement sur la loi, cela ne serait pas
compt alors que a "mriterait" de ltre. En quelque sorte cela permet dintroduire
une "tolrance la concidence" entre les deux lois.
On se rend compte quil y a une corrlation plus quheureuse entre les arbitrages
locaux sur le spread et sur la loi de probabilit.
La courbe est trs lisse et croissante. Elle vrifie aussi limK0% P (k, k ) = 0 ainsi
que limK100% P (k, k ) = 0.

30
3.3 Contrainte Mathmatique 3 CONTRAINTES

Fig. 11 Fixed Leg en fonction de la corrlation

Certains articles demandent ce que la courbe soit concave en justifiant par le


fait que P (L K) est qui doit naturellement tre croissante, a pour drive dP =
P (K L K + dK) qui est dcroissante. Il ny a aucune raison cela puisque cette
probabilit doit dpendre aussi de la corrlation (dpendante de K).

3.3 Contrainte Mathmatique


Rappel : on avait
RT [K ,K ]
F loatLeg = E Q ( 0 Bt .dLt 1 2 )

n Z ti
[K1 ,K2 ]
X
F ixedLeg = E Q (s Bti (K2 K1 Lt )dt)
i=1 ti1

E Q ( 0T Bt .dLK
R
F loatLeg )
et donc f airspread[0,K] = F ixedLeg(s)/s = n
X Z ti t cest
E Q (s Bti (K LK
t )dt)
i=1 ti1
er.T E Q LK r.t Q
RT
T + 0 r.e E (LK
t )dt
dire n Z ti
X
EQ ( Bti (K LKt )dt)
i=1 ti1
(on a intgr par partie lintgrande de la FloatLeg dLt qui est en fait un "peigne
de Dirac" stochastique, et on a suppos que le zro coupon scrit Bt = er.t )

En estimant que r 0, F loatLeg E Q LK T .


Comme on peut le remarquer, la FixedLeg ne dpend que trs peu de la corrlation
ce qui peut sembler curieux au premier abord. Une explication possible est que sil y
a un dfaut qui intervient, a priori cest plutt vers la fin de la maturit quau dbut,
de sorte quil y a quand mme du spread qui a t reu par le vendeur de protection.
Une autre explication est que la Fixed Leg est calcule sur des tranches "equity" cest

31
3.3 Contrainte Mathmatique 3 CONTRAINTES

dire de la forme [0-K%]. Ainsi comme les tranches basses ne sont pas sensibles de
la mme manire la corrlation que les tranches plus hautes, sur une tranche equity
une sorte de nivellement se cre sur la Fixed Leg.

Toujours est-il que daprs ces courbes, on peut naturellement poser F ixedLeg
.K du moins pour un strike au dela de 10%.
E Q LK
Finalement, spread[0K%] .KT .

La grandeur plus qui nous intresse plus est, nous lavons dit, le spread sur tran-
F loatLegK
chelette, soit spread[KK+dK] = F ixedLegK .

Avec les approximations effectues, on obtient spread[KK+dK] .K (E Q LK


T )

Nous nous rapprochons dune contrainte purement formelle sur le smile de corrla-
tion. Il nous faudrait pour cela connatre une formule ferme pour LK T . Ceci nest pas
une tche aise, et nous allons avoir recours plusieurs hypothses et approximations :

Sans aucune hypothse, en notant pour le crdit j : 0 pour lvnement "pas de


dfaut avant la maturit" de probabilit pj (z) et 1 pour lvnement contraire, on a :
X N
X
E LK T = P (i1 , ...iN ) Lj ij
(i1 ,...,iN ){0,1}N j=1
Z n
+ Y N
1ij
X X
= pij (z)(1 pij (z))ij .(z).dz Lj ij
(i1 ,...,iN ){0,1}N j=1 j=1

Faisons tout dabord lhypothse d"homognit" : nous considrons que les noms
du paniers sont "homognes", cest dire quils ont tous le mme taux de recouvre-
ment, la mme fonction de probabilit de dfaut et le mme nominal. Cette "hypo-
thse" a dj t utilise, afin de considrer dans nos optimisations numriques quun
panier "standard" tait suffisament reprsentatif, et quune bonne mthode dinter-
polation sur le smile pour ce panier serait aussi bonne sur nimporte quel autre panier
(iTraxx, ...)

Alors on peut cette fois-ci sommer sur le nombre de dfauts dans le panier.
X N
X
Cela donne E LK T = P (i1 , ...iN ) Lj ij
(i1 ,...,iN ){0,1}N j=1
N
X
= P (k def auts) L k
k=0
N
X
=L k.P (k def auts)
k=0

32
3.3 Contrainte Mathmatique 3 CONTRAINTES

N
X Z +
=L k
k.CN . pN kj (z)(1 p(z))k .(z).dz
k=0

Cest cette formule qui a t utilise pour calculer les probabilits de dfaut dans
notre pricer.

Mais rappelons que lon cherche obtenir une formule ferme. Etant donn lin-
trication des probabilits due la corrlation, nous sommes contraints de faire une
hypothse plus forte encore que celle d"homognit" : celle de "large-pool".

Nous faisons donc lhypothse de "large-pool", cest dire que lon considre quil
y a N noms dans le panier, tous "homognes", de probabilit de dfaut p(t) et que N
 1. p
Nous rappelons que le dfaut est caractris par le fait que Xi = Z. + i . 1 2 ,
qui suit une loi normale centre rduite, passe en dessous de la "barre" N 1 (p(t)) de
telle sorte que la probabilit soit effectivement de p(t).

De fait, nous avons, pour laPloi de la probabilit de perte totale cumule :


Q(L < K) = Q{(1 R). N1 j=1 1{Z.+ .12 N 1 (p(t)} < K}
N
j

Remarque : R dsigne le taux de recouvrement, pris 40% dans la pratique.

Quand N est trs grand, N1 j=1 1{Z.+ .12 N 1 (p(t)} tend "intuitivement"
PN
j
p
vers la P (Z. + j . 1 2 N 1 (p(t))).
Cela est vrai conditionnellement Z car on a alors une somme de variables ala-
toires indpendantes et identiquement distribues. Q(L < K) vaut alors 0 ou 1 selon
que les probabilits de dfaut conditionnes Z sont faibles ou fortes.
Ainsi Q(L < K | Z) = 1N ( N 1(p(t))Z. )< K
12 1R

=1 K )N 1 (p(t))
12 N 1 (
1R
Z<
et donc comme Zet -Z ont mme loi,
12 N 1 ( 1R
K
)N 1 (p(t))
Q(L < K) = N ( )

RK
Enfin, on peut prouver que E Q LKT = 0 Q(K > LT > x).dx.
RK RK Rx
En effet, E Q LK K
T = 0 x.Q(LT [x, x + dx] = 0 0
Q(LK
T [x, x + dx])dudx =
RK RK K K
( u Q(LT [x, x + dx]))du = 0 Q(LT [u, K])du = 0 Q(K > LK
K K
R R
0 T > u)du

E Q LK
Cette esprance dpend de manire cache de mais on a K
T
= K. dQ(LdK
T >K)
.

On peut donc dire en premire approximation que


RK
F loatLeg E Q LK K
T = 0 Q(LT > x).dx et donc que

33
3.3 Contrainte Mathmatique 3 CONTRAINTES

Fig. 12 Premier terme : K. dQ(LdK


T >K)

E Q LK
T ,(K)
Q K
d E LT ,
F loatLeg
K K = K. dQ(LdKT >K)
+ dK .
Q K
d E LT ,
soit F loatLeg
K K. dQ(LdK T >K)
+ dK .
R K Q(LKT , >x)
K. dQ(LdKT >K)
+ dKd
. 0 dx

Lide est desprer que le premier terme soit numriquement plus fort que le
second, et ainsi dobtenir en premire approximation une contrainte purement formelle
d
sur dK , car dQ(LdK
T >K)
est connu.

On rappelle que la contrainte principale est que la drive de la jambe de


prime (la float leg) soit dcroissante.

Le premier terme, K. dQ(LdKT >K)


, est ngatif. Mais la jambe de prime est croissante
en le strike, et donc la somme des 2 termes est positive. On peut donc en dduire que
le second est plus gros que le premier, mais encore rien pour linstant ne peut donner
dindications sur les variations de ces termes : aprs tout, cest cela qui compte.

Etant donn que lon na pas de formule pour le second terme (on connait lint-
grande, mais pas lintgrale), nous sommes obligs davoir recours au calcul numrique.
Rsultats :
Il arrive que la thorie est peu en concordance avec la pratique numrique, et cest
ce qui se passe ici. Les intgrales numriques de drives partielles dapproximations
ne donnent pas un rsultat concordant : la FloatLeg est bien croissante, et a une belle
allure concave. Sa drive devrait tre positive. Cependant la somme des deux termes
que nous tudions donne numriquement un rsultat ngatif, si bien que lon ne peut
pas conclure.

Le second terme semble en effet plus ratique que le premier.

34
3.3 Contrainte Mathmatique 3 CONTRAINTES

d
R K Q(LK
T , >x)
Fig. 13 Second terme : dK . 0 dx

Fig. 14 drive du premier terme

35
3.3 Contrainte Mathmatique 3 CONTRAINTES

Fig. 15 drive de la Float Leg

Fig. 16 Ratio des drives

36
3.3 Contrainte Mathmatique 3 CONTRAINTES

Lorsque lon trace la drive du premier terme, et celle de la floatleg puis leur
ratio, on obtient ces graphes(coups au dessous de 7% de strike)
Dans une certaine mesure, on peut estimer que lon a donc
T dQ(L >K)
F loatLeg d(K. dK )
boxed
K dK

et la loi de Q est donne par


p
1 2 N 1 ( 1R
K
) N 1 (p(t))
boxedQ(L < K) = N ( )

On obtient donc la contrainte formelle suivante sur (K) :

d2 (K. dQ(LdK
T >K)
)
boxed <0
dK 2

Pour rsumer cette partie, on a vu quune contrainte dabsence darbitrage est


que le spread sur les tranchettes doit tre dcroissant.
F loatLegK
Or spread sur tranchette = spread[KK+dK] = F ixedLegK .

et par ailleurs la jambe de prime (fixedLeg) est quasi linaire ce qui donne spread
sur tranchette = spread[KK+dK] .F loatLegK qui doit tre dcroissant, et donc
F loatLegK doit tre dcroissant.
R K Q(LKT , >x)
Ce dernier terme est la somme de K. dQ(LdK T >K) d
et de dK . 0 dx
Mais cette dernire intgrale est numriquement parlant trs instable Mais ses
variations sont faibles par rapport celles du premier terme, et finalement on a encore
dQ(LT >K)
2 F loatLegK d(K. )
une fois : 2K . dK
dK
do le rsultat final approch :
dQ(LT >K)
d(K. )
la condition de non-arbitrage se rduit dK
dK
< 0 (sachant que la loi de
Q est connue explicitement dans notre modle).

On a donc enfin une condition purement formelle.


Malheureusement celle-ci est trop dlicate pour tre utilisable en pratique :
dQ(LT >K)
d(K. )
dK
dK
<0
2
se rduit K. d (Q(L T >K))
dK 2 + dQ(LT >K)
dK <0

12 N 1 ( 1R
K
)N 1 (p(t)) 12 aK b
o Q(L < K) = N ( ) = N( )

dQ(LT >K) 12 aK b 0 12
soit dK = ( ).( 2 (b a 2
) . (N 11( K )) ) o N (x)
1 1R
x 2
est la fonction de rpartition de la loi gaussienne et (x) sa drive ((x) = 1 e 2 )
2

37
3.4 Mise en oeuvre 3 CONTRAINTES

3.4 Mise en oeuvre


A priori, pour chaque CDO donn (et ses points de corrlations donns par le
march) il existe au moins une manire de chercher une "bonne interpolation". Seule-
ment, ceci nest pas compatible avec Marx et avec la ralit : on ne peut pas faire
de chaque cas un cas particulier, et calculer la meilleure interpolation possible. Une
raison est que cela prendrait vraiment trop de temps a priori, temps que les traders
nont pas.
Par contre, on peut faire tourner lordinateur 4 heures de suite une bonne fois
pour toutes pour calculer la meilleure interpolation possible pour un CDO "type",
enregistrer le rsultat, et appliquer cette interpolation tous les CDO (donc aucun
temps de calcul).
Lide retenue est donc de calculer plusieurs courbes dinterpolation, et de chercher
une fonction qui ressemble le plus aux courbes obtenues (de la mme manire que
linterpolation linaire ne dpend que des points dentre).
Lide de loptimisation consiste trouver une fonction dinterpolation qui passe
par les points donns par le march, qui soit aussi lisse que possible, et qui minimise
les possibilits darbitrage sur la courbe de spread.

On peut mme se demander sil existe une interpolation permettant de rendre


la courbe non interpolable. Auquel cas faudrait-il trouver la meilleure interpolation
possible au sens "minimiser le potentiel darbitrage de la courbe de spread" ( un sens
qui reste dfinir).

Le pricer Marx tant assez lent, nous avons dcid denregistrer les rsultas obtenus
aprs une nuit de calculs dans un fichier texte, que lon charge dans la mmoire vive
afin de pouvoir se concentrer sur linterpolation une bonne fois pour toutes, et non
plus sur les calculs de prix.

3.5 Donnes
Pour le moment, le march "donne" les corrlations sur quelques tranches ([0%-
3%], [0%-6%], [0%-9%], [0%-12%], [0%-22%], ...) et linterpolation est faite linaire-
ment ou quadratiquement (de manire avoir une courbe C 1 au lieu de continue
seulement).

Valeurs prises par la corrlation implicite :

Strike 3% 6% 9% 12% 22%


Corrlation 17% 26% 34% 41% 57%

On note cette fois encore dans la croissance de la courbe de lgres convexits


locales. Ces points dinflexion sont lorigine des arbitrages sur la courbe de spread
sur tranchelet.
(cf les points autour de 35% de strike) et le saut sur la courbe de spread plus haut.

38
3.5 Donnes 3 CONTRAINTES

Fig. 17 Corrlation implicite du march

Fig. 18 Courbe de la Float Leg

39
4 LINTERPOLATION

4 Linterpolation
Linterpolation sest faite chronologiquement en plusieurs tapes :
_ initialement linterpolation sest base sur les conditions de non-arbitrage sur la
courbe de spread : linterpolation se faisait purement numriquement par optimisation,
sans chercher lisser le smile de corrlation, en prenant pour point de dpart lo.
Loptimisation de fonction sous contraintes est cependant un problme difficile et
notre algorithme faisait converger rapidement la suite de fonctions dinterpolation
vers une fonction peu lisse et dont le spread final navait pas une allure agrable.
Cette premire approche a donc t mise de ct en faveur dune seconde, dont
lide, eue plus tt, semblait moins prometteuse mais qui a pourtant port ses fruits.
_ laccent sest port sur linterpolation pure, cest dire trouver partir dun
ensemble de points donns une courbe dont lallure et le lissage soient les plus convain-
cants possible.

Ce qui gnait dans cette dernire mthode, cest quil ny avait plus vraiment
de tenant conomique au problme. Mais cest pourtant cette mthode qui russit
le plus : comme on le faisait remarquer dans la partie concernant la "market law of
losses" (cest dire la loi de pertes sur le portefeuille implicite par le march), ce sont
les discontinuits sur la fonction de corrlation et sur ses drives qui se rpercutent
en des discontinuits et des irrgularits sur la fonction de spread sur tranchelette
(donnant lieu des opportunits darbitrage).

Appliquer notre optimiseur numrique sur une fonction interpole par les mthodes
que lon a employes narrangeait pas vraiment lallure du spred sur tranchette, bien
que lide ft tentante.

4.1 Problmes gnraux dinterpolation


Linterpolation est un problme difficile au sens o il existe plusieurs solutions
un seul jeu de donnes. (il existe en effet une infinit de polynmes passant par n
points (x1 , y1 )...(xn , yn ))

A titre dexemple :
Ces 3 courbes passent toutes par 3 points donns. Cependant les tendances quelles
donnent pour le "futur" sont trs diffrentes les unes des autres, et cela sen patt sur
les normes carts entre les 2 derniers points dinterpolation.

Il y a donc une infinit de faon dinterpoler un jeu de donnes, et cest un problme


subjectif que de dterminer quelle courbe interpole le mieux, lorsquil ny a pas de
contraintes.

Afin de comprendre comment ragit linterpolation vis--vis du smile de corrlation


nous avons cr un logiciel trs pratique, en C#. A la base celui-ci ne devait que
calculer le spread et pricer des CDO, puis nous lavons fait voluer pour quil optimise
le smile de corrlation, et progressivement nous avons eu finalement un outil capable
de nous aider dans la comprhension de notre problme.

40
4.1 Problmes gnraux dinterpolation 4 LINTERPOLATION

Fig. 19 exemple dinterpolation

Fig. 20 Environnement logiciel cr en C#

41
4.2 Stabilit 4 LINTERPOLATION

Les boutons du haut correspondent au chargement des donnes (la premire partie
de ce rapport expliquait comment calculer le spread dun CDO, et comment nous
avions optimis les temps de calcul en crant un fichier assez lourd contenant des
calculs dj faits ce qui permet une utilisation particulirement souple de ce prsent
logiciel)

Les boutons sur la droite correspondent au type dinterpolation que lon choisit
entre les points (nous en avons implments 8 en tout), et les boutons du bas per-
mettent de faire varier dynamiquement linterpolation en modifiant les ordonnes de
points (dont les abscisses ont t dcides lavance afin de respecter les donnes que
lon obtient gnralement du march : par exemple le march iTraxx cte seulement
les tranches [0%, 3%], [3%, 6%], [6%, 9%], [9%, 12%], [12%, 22%] et [22%, 100%]).

Tout en bougeant ces "ascenseurs", la courbe dinterpolation est redessine (et on


peut vrifier quelle passe bien par les petits carrs rouges), et la courbe de spread sur
tranchelettes dduite de cette courbe est aussi re-dessine (ici il sagit de la courbe
quasi-dcroissante, prsentant quelques "pics").
Cet outil ft trs pratique pour concevoir et vrifier des mthodes dinterpolation,
permettant donc de vrifier "en temps rel" une mthode thorique.
Notons que la programmation oriente objet (notamment en C#) rend trs simple
la possibilit de passer des fonctions en paramtre.

4.2 Stabilit

Une notion naturelle bien que jamais dfinie dans les nombreuses documentations
sur linterpolation est la stabilit des interpolations.
En effet, beaucoup de documents traitent de linterpolation dune fonction, cest
dire quils cherchent une fonction (ou une suite de fonctions) approximant une autre
plus complique, et sinterrogent sur la convergence de cette mthode (exemple :
polynmes de Legendre, de Tchebychev, ...). La fonction interpoler est connue, et
les polynmes approchant la fonction essaient de passer par de plus en plus de points
sur le graphe de la fonction de rfrence.

Pour les problmes dinterpolation de donnes, on ne peut pas prendre "de plus
en plus de points" : le problme est dune toute autre nature, et il sagit de dfinir les
rgles au cas par cas suivant le problme que lon a.

Ici par exemple, les donnes du march sont par "dfaut" croissantes et convexes.
On peut donc imposer nos mthodes dinterpolations de garantir la convexit et la
monotonie de nos jeux de donnes.

Ceci garantira par la mme occasion la "stabilit" de notre systme, sens que
lon na encore pas dfini. En effet, si linterpolation dun graphe monotone est encore
monotone, alors cela signifie que linterpolation reste borne vis vis du jeu de donne
en entre.

42
4.2 Stabilit 4 LINTERPOLATION

Fig. 21 phnomne de Runge

Voici un exemple bien connu issu de la thorie de linterpolation polynmiale


1
des fonctions continues : il sagit dinterpoler la fonction f (x) = 1+x 2 . La suite de

polynmes de Lagrange dont les abscisses sont prises quirparties sur [5, 5] ne
converge pas vraiment vers la fonction f (x) et mme les polynmes divergent. Ceci
est du au fait que pour passer par n points le polynme Pn doit se courber de plus
en plus entre les points afin de corriger sa trajectoire. Les coefficients des monmes le
constituant sont donc de plus en plus grands pour se corriger les uns les autres.

Remarque : Afin dviter ces divergences, aussi connues sous le nom de "Phnomne
de Runge", une bonne manire dinterpoler les fonctions grce aux polynmes de
Lagrange est dutiliser des abscisses de Tchebychev au lieu dabscisses quirparties.

Il faut veiller ce quil ne se produise pas le mme type de drglement dans nos
interpolations. Une difficult est de formaliser ce raisonnement.
Dans notre cas, o les donnes forment un ensemble monotone et convexe, nous
demandons ce que les interpolations conservent la monotonie et la convexit, tout
en passant par les points dentre.

Mais on peut aussi demander aux fonctions dinterpolation dtre stable par rap-
port aux donnes, et de ne pas diverger lorsque les donnes nont plus de proprit
de convexit ni de monotonie.

Notation : Nous noterons I(x) une fonction dinterpolation associe des abscisses
(x1 , ..., xn ) fixes et des ordonnes (y1 , ..., yn ) mobiles.

On propose donc, outre la conservation de la monotonie et de la convexit , de


sintresser aux 3 proprits suivantes :
_ invariance de linterpolation par changement de repre. Ceci traduit le fait
que linterpolation doit tre purement gomtrique et ne doit pas dpendre en toute
logique du choix du repre, ce qui semble assez naturel.

43
4.3 Explication des diffrentes interpolations 4 LINTERPOLATION

_ continuit de la fonction qui un n_uplet (les abscisses fixes (x1 , ..., xn )) associe
la fonction dinterpolation correspondante :

Rn C([x1 , xn ] R)
 
(y1 , y2 , ..., yn ) I(x1 , ...xn , y1 , ..., yn )

La continuit est dfinie sur lespace darrive par la norme suprieure sur usuelle
des fonctions continues sur un intervalle.
_ "bornitude" : A / (y1 , ..., yn ), x[x1 , xn ], |I(x1 ,...xn ) (x)| < A. maxi, |yi |. Cette
proprit traduit le fait quil y a une sorte de stabilit. Ainsi des interpolations sen-
sibles au phnomne de Runge ne "passeraient" pas ce test, du moins on lespre.
Sinon la valeur minimale de A vrifiant cette proprit pourrait tre un bon indica-
teur.

4.3 Explication des diffrentes interpolations


4.3.1 Linaire
Cette mthode est la plus simple de toutes. Elle consiste uniquement relier les
points, tris par abscisse croissante, par des droites.
xxi
Sur [xi , xi+1 ], la fonction dinterpolation vaut en x : yi + xi+1 xi .(yi+1 yi )

Cette mthode est invariante par changement de repre puisque "purement go-
mtrique". En outre elle est naturellement continue aussi puisque : x, i/I(x) =
xxi
yi + xi+1 xi .(yi+1 yi ). Ainsi les points (x, I(x)) de linterpolation linaire dpendent

continuement des yi (qui sont en nombre fini) et ce sur un intervalle fixe ferm born
[x1 , xn ].
Enfin elle vrifie le critre de bornitude avec la constante A = 1.
La convexit et la monotonie sont aussi respectes par cette mthode.

Le principal problme de cette mthode est bien entendu d au fait que linter-
polation linaire ne donne pas une courbe naturelle, puisque affine par morceaux,
alors quon cherche quelque chose de lisse (cf contrainte sur la "implied market law
of losses")

4.3.2 Mthode de Steffen

Cette mthode est aussi appele mthode du spline cubique. Elle diffre de la
mthode du spline de lissage sur laquelle nous reviendrons plus loin.
Cette mthode est tire de [6]. Elle a t cre dans le but de conserver la monotonie
sur un jeu de donnes.

44
4.3 Explication des diffrentes interpolations 4 LINTERPOLATION

Fig. 22 Exemple de non monotonie de la parabole passant par A, B et C

Principe : le dfaut de linterpolation linaire est son manque de "lissage" autre-


ment dit elle nest pas continment drivable. Plutt que dutiliser une fonction affine
par morceaux on va utiliser cette fois-ci une fonction polynmiale de degr 3 par mor-
ceaux. Puisquil y a plus de degrs de libert sur les coefficients on va pouvoir obtenir
un rsultat C 1 .

Ralisation : Etant donns i, (yi , yi0 ) o les drives en chaque point sont donns,
sur [xi , xi+1 ], on cherche ai , bi , ci et di tels que fi (x) = ai .(x xi )3 + bi .(x xi )2 +
ci .(x xi ) + di

Remarque : Il ne faut pas confondre avec linterpolation dHermite : on veut juste-


ment viter le phnomne de Runge.
3.si 2.yi0 yi+1
0
Il faut bien sr choisir di = yi , ci = yi0 puis sen dduisent bi = hi et
0 0
yii +yi+1 2.si yi+1 yi
ai = h2i
o hi = xi+1 xi et si = xi+1 xi

Il reste dterminer les yi0 avec soin. Pour cela nous ne considrons que les points
intrieurs (cest dire 1 < i < n). Lide est quil existe une unique parabole passant
par (xi1 , yi1 ), (xi , yi ), (xi+1 , yi+1 ). Si cette parabole est monotone sur [xi1 , xi+1 ],
on va prendre pour yi0 la pente de cette parabole en xi .
Sinon, on choisit la plus petite pente p, en valeur absolue, telle que les para-
boles passant par (xi1 , yi1 ), (xi , yi ) et ayant pour pente p en xi et passant par
(xi , yi ), (xi+1 , yi+1 ) et ayant pour pente p en xi soient toutes les deux monotones sur
leurs intervalles respectifs. Gardons lesprit que ceci est un choix purement arbi-
traire.

La parabole passant par (xi1 , yi1 ), (xi , yi ), (xi+1 , yi+1 ) a pour quation y =
a.(x xi )2 + b.(x xi ) + yi

45
4.3 Explication des diffrentes interpolations 4 LINTERPOLATION

yi+1 = a.(xi+1 xi )2 + b.(xi+1 xi ) + yi


 
Soit 2 ou encore avec nos notations
yi1 = a.(xi1 xi ) + b.(xi1 xi ) + yi
yi+1 = a.h2i + b.hi + yi


yi1 = a.h2i1 + b.hi1 + yi


on a donc h2i1 .yi+1 h2i .yi1 = b.hi .hi1 .(hi1 hi ) + (h2i1 h2i ).yi
h2i1 .yi+1 h2i .yi1 +(h2i h2i1 ).yi si1 .hi +si .hi1
soit b = hi .hi1 .(hi1 hi ) = pi = hi1 +hi

Il nous faut encore chercher une condition sur la pente en xi pour quelle soit

monotone sur lintervalle [xi1 , xi+1 ]. Cela arrive si et seulement si, en notant pi la
pente de la parabole en xi , les paraboles passant par (xi1 , yi1 ), (xi , yi ) et ayant
pour pente pi en xi et passant par (xi , yi ), (xi+1 , yi+1 ) et ayant pour pente pi en xi
soient toutes les deux monotones sur leurs intervalles respectifs.

Leurs quations sont respectivement y = yi + pi .(x xi ) + yi1 yhi2pi .hi1 (x xi )2


i1
yi+1 yi pi .hi
et y = yi + pi .(x xi ) + h2i
(x xi )2
Les extremas ont pour abscisses respectives xi 2(phi1 .pi
i si1)
et xi + 2(phii .p
si) . Pour que
i

pi
ces abscisses soient en dehors des intervalles, il faut que 0 si1 2 et 0 psii 2.
Finalement :
_ Si si1 et si sont de signes distincts, alors il ne peut pas y avoir de parabole
passant par (xi1 , yi1 ), (xi , yi ), (xi+1 , yi+1 ) qui soit monotone. On choisit alors yi0 =
0. (Daprs les petits calculs que lon a fait cest la seule condition permettant davoir
la branche gauche et la branche droite monotones sur leurs intervalles respectifs)

_ Sinon : si pi (pente "naturelle" de la parabole passant par les 3 points cons-


0
cutifs) vrifie |pi | 2.|si | et |pi | 2.|si1 | alors on peut choisir yi = pi
0
_Sinon, on prend yi = 2.signe(si ). min(|si1 |, |si |)

Cet algorithme est bien entendu purement "heuristique", mais il permet de prouver
quavec les choix de yi0 que lon a fait, la monotonie des donnes est conserve par
linterpolation.

Remarque : Concernant les points extremaux y1 et yn , nous avons un petit peu


le choix. Linterpolation est cubique par morceau, et C 1 sur lintrieur du domaine.
Mais nous avons implment 2 mthodes diffrentes ("Steffen 1" et "Steffen 2" ), lune
raccordant les points extrmaux par des polynmes du second degr (en se basant sur
0
la donne de yn1 , yn1 et yn ) lautre effectuant un raccordement C 2 (en se basant
0 00
sur la donne de yn1 , yn1 , yn1 (puisque lon connait lquation de la courbe sur
laquell est le point n 1) et yn )

46
4.3 Explication des diffrentes interpolations 4 LINTERPOLATION

Preuve Considrons des "donnes monotones" (x1 , ..., xn ) et (y1 , ..., yn ).


Par monotonie il suffit de prouver que linterpolation I correspondante est mono-
tone sur chaque intervalle [xi , xi+1 ].
Fixons i avec 1 < i < n 1.
Sur [xi , xi+1 ], la courbe est cubique dquation fi (x) = ai .(x xi )3 + bi .(x xi )2 +
ci .(x xi ) + yi .
Sa drive vaut fi0 (x) = 3ai (x xi )2 + 2bi (x xi ) + ci .
xxi
soit fi0 (t) = 3(yi0 + yi+1
0
2si ).t2 + 2(3si 2yi0 yi+1
0
)t + yi0 o t = xi+1 xi varie
entre 0 et 1 sur lintervalle considr.
f 0 (t) y0 y0
En posant t = isi , 1 = sii 0 et 2 = i+1
s 0 (par "construction") on obtient
2
i
t = ( 1 (1 t) 2 t) + 2t(1 t)(3 + 1 2 1 2 )
soit t = U 2 + V W
V = 2t(1 t) 0 sur notre intervalle. Le terme qui pourrait poser problme est
W . Mais on a par "construction" encore unefois : 0 1 , 2 2.
Il suffit donc de prouver que 0 x, y 2, x2 + y 2 xy 3 afin de prouver que
W reste positif.

A y fix, on a une fonction de x seulement qui prend son maximum en 0 ou en 2.
En 0 cela donne y 2 plus petit que 2 et donc que 3. En 2, on doit avoir y 2 2y 1.
Encore un polynme du second degr, qui vaut 0 en 0 et en 2 (et qui est convexe).
La preuve est faite pour les intervalles intrieurs.

Considrons lintervalle [xn1 , xn ] dans le cas dun raccordement du second degr :


0 s y 0
On a f (x) = yn1 + yn1 (x xn1 ) + a(x xn1 )2 et a = n1 hn1
n1
. Dautre
0
part on a encore la condition |yn1 | 2|sn1 |. En faisant lhypothse que lon nous
0
a donn un jeu de donnes croissant, yn1 0 et donc pour vrifier la croissance sur
lintervalle [xn1 , xn ], comme on a une parabole, il suffit de vrifier f 0 (xn ) 0.
Or f 0 (xn ) = 2a.hn + yn1
0 0
= 2(sn1 yn1 0
) + yn1 = 2sn1 yn10
0.
La condition est donc vrifie. On peut prouver de mme sur le premier intervalle.
Concernant le raccordement C 2 on ne peut pas conclure.

En pratique cette mthode donne de trs bons rsultats.


Concernant les 3 proprits :
_ il y a encore respect de la continuit dans linterpolation : les fonctions cubiques
dpendent continment des n-uplets (y1 , ..., yn ) et (y10 , ..., yn0 ). Dautre part les calculs
de ces derniers dpendent encore continment de (y1 , ..., yn )
_ proprit de changement dchelle : elle est vrifie aussi.
Preuve La preuve se fait en 2 tapes : premirement, il faut montrer qutant donn
2 points A et B du plan, lunique courbe cubique passant par A et B, et ayant les
pentes donnes en ces points ne change pas aprs modification de lchelle. (les pentes
changeant en consquence bien entendu). Il faut ensuite vrifier que lalgorithme de
choix du n-uplet (y10 , ..., yn0 ) donne le mme n-uplet aprs changement dchelle.

47
4.3 Explication des diffrentes interpolations 4 LINTERPOLATION

Fig. 23 Diffrents cas considrer

_ Pour simplifier, considrons dans un repre R les points A(0, 0) et B(a, b) qui
ont pour quivalent dans R A(0, 0) et B(a0, b0). Les pentes dans R valent y00 et y10 .
0
b0 a 0
Dans R, il faut tester avec bbaa0 y00 et ba 0 y1 .

Lunique courbe cubique passant par A et B et ayant pour pentes y00 et y10 en A et
y 0 +y 0 2 b 3 b 2y 0 y 0
B a pour quation dans R : f (x) = 0 a12 a x3 + a a 0 1 x2 + y00 .x
0
b0 a 0
Lunique courbe cubique passant par A et B et ayant pour pentes bbaa0 y00 et ba0 y1 en
b0 a 0 b0 a b0 b0 0 0
y00. . ba 0 +y1 . ba0 2 a0 3a 2y00 . bbaa0 y10 . bbaa0
A et B a pour quation dans R : g(x) = a02 x03 + a
0
x02 +
0
y00 . bbaa0 .x0
La courbe est invariante par changement dchelle si (x0, y0 = g(x0)) point de R
est sur la courbe reprsente par le mme point (x, y) dans R.
0 0
Avec x0 = aa x et y 0 = bb y il faut vrifier si on a bien y = f (x) sachant que
y0 = g(x0).
0 0 0
Or bb y = g( aa x) soit y = bb0 g( aa x) = ... = f (x) (il suffit dcrire, il ny a aucune
astuce particulire)
La courbe est donc bien invariante par changement dchelle.

_ proprit de "bornitude" : elle est vrifie aussi avec une constante de 1. On


a mme plus fort que la bornitude en fait : pour tous points A et B "fixes", la
courbe interpolatrice a ses ordonnes comprises entre celles de A et celle de B, sur le
segment [xA , xB ]. (de mme que pour linterpolation linaire) Ceci est toujours vrai,
pas seulement dans notre cas o les donnes sont monotones.
Preuve On a vu que la monotonie est conserve par linterpolation ce qui est en
soit une preuve partielle de bornitude.
Le graphique montre la disjonction de cas que lon opre.
On considre la courbe sur [B, C]. (Autres cas possibles : D est au dessus de C,
mais alors bornitude par monotonie pour le cas 1, ou symtrie par rapport laxe des
ordonnes du cas 2)
0
Cas 1 : Par "construction", on a yC = 0. On a alors
0 0
Cas 2 : Par "construction", on a yB = 0 et yC = 0. On a alors entre B et C
2
I(x) = h2 (x xb )3 + hii (x xb )2 + yB = yB + si .hi. (xx
2si 3s
h2
b)
(3 2. xx
hi )
b
i i

48
4.3 Explication des diffrentes interpolations 4 LINTERPOLATION

Fig. 24 Exemple de fonction f vrifiant ces contraintes

2
= yB + (yC yB ). (xx
h2i
b)
(3 2. xx b 2
hi ) = yB + (yC yB ).X (3 2X) et X varie
entre 0 et 1.
Or x x2 (3 2x) est croissante sur [0, 1] donc et varie de 0 1. Le rsultat est
donc prouv.

4.3.3 Interpolation Exponentielle


En reprenant lide de larticle [1] traitant de la "Market Law of Losses", expliquant
que les discontinuits sur le smile de corrlation entranent des discontinuits et donc
srement des arbitrages sur la courbe de spread de tranchelette, et en voyant que
linterpolation de Stefen donnait de bons rsultats alors que C 1 seulement, nous avons
dcid de rechercher une interpolation C .

Principe : soit f une fonction C valant 0 en 0 et 1 en 1, avec toutes les drives


nulles en 0 et en 1. (cf Appendice pour une formule)
Considrons que lon doive raccorder les points A et B, et o les suites des drives
successives en ces 2 points sont connues : a0 , a1 , ..., an et de mme avec b0 , b1 , ..., bn
(o a0 = yA et b0 = yB ).
Alors sur [xA , xB ], la fonction g(x) = (a0 + a1 .(x xA ) + a22 .(x xA )2 + a3!3 .(x
xA )3 +...)(1f ( xxx A
B xA
))+(b0 +b1 .(xB x)+ b22 .(xB x)2 + b3!2 .(xB x)3 +...).f ( xxx A
B xA
)

est C et vrifie que toutes ses drives en A et B respectivement valent a0 , a1 , ..., an
et b0 , b1 , ..., bn .

Afin de crer une suite de drives en chaque point, nous utilisons lalgorithme de
linterpolation de Stefen, qui nous fournit au moins la premire drive pour chaque
point (ceci pour "exponentielle 1") et mme, connaissant lquation de la fonction
cubique sur chaque segment, la drive seconde. Pour "exponentielle 2" nous prenons
comme valeurs des drives premires en chaque point la moyenne entre la pente
gauche et droite (vis vis des diffrences finies) : si A, B et C sont 3 points qui
se succdent ; AB ayant une pente et BC une pente , alors on prend b1 = + 2 .
Les drives dordre suprieur sont toujours prises nulles. Aux points extrmaux on

49
4.3 Explication des diffrentes interpolations 4 LINTERPOLATION

Fig. 25 Rsultat de linterpolation exponentielle

ne prend bien sr que la valeur de la "diffrence finie" entre le point extrmal en


question et son point adjacent.
Ce procd dinterpolation nest pas vraiment la hauteur de nos attentes. Il y a
plusieurs raisons cela, que lon dcouvre "aprs coup" :

_ la premire cest que si linterpolation est effectivement C elle nen reste pas
moins trs linaire aux abords des points. Et pour cause. La fonction f que lon a choisit
dans le graphe prcdent (ralliant 0 1de manire C ) est beaucoup trop "plate"
aux alentours de 0 et de 1. Ce qui fait que sur [xA , xB ], la fonction g(x) = (a0 + a1 .x +
a2 2 a3 3 b2 2 ab 3
2 .x + 3! .x + ...)(1 f (x)) + (b0 + b1 .(1 x) + 2 .(1 x) + 3! .(1 x) + ...).f (x)
se rduit (on simplifie en prenant [0,1]) g(x) = (a0 + a1 .x).(1 f (x)) + (b0 +
b1 .(1 x)).f (x)
Vers 0 : f (x) = 0 pendant assez longtemps donc g(x) = a0 + a1 .x pendant assez
longtemps aussi.
Et idem en 1 : g(x) = b0 + b1 (1 x)

_ La seconde raison est que lon cre un point dinflexion preque "automatique-
ment" en interpolant sur chaque segment. Alors que si lon a un jeu de donnes convexe
interpoler, il ne devrait logiquement pas y avoir de point dinflexion.

Exemples : Cette image dcrit linterpolation exponentielle ralise entre A (abs-


cisse 0, ordonne 0, drive 1) et B (abscisse 1, ordonne 0.5, drive 0). Signe que
notre fonction nest pas parfaite, elle slve au dessus de B avant de redescendre, au
lieu de ne jamais dpasser lordonne de ce point, comme on laimerait.

Autre exemple :

50
4.3 Explication des diffrentes interpolations 4 LINTERPOLATION

Fig. 26 Point dinflexion non dsir

Fig. 27 Autre exemple de point dinflexion non dsir

Cette fois : A(abscisse 0, ordonne 0.5, drive 1) et B (abscisse 1, ordonne 0.1,


drive -1). Alors que la fonction pourrait tre convexe elle ne lest pas (on note un
lger point dinflexion vers labscisse 1/4).

Par contre : en choisissant des points initiaux qui demandent naturellement une
interpolation point dinflexion, les rsultats sont assez satisfaisants.

Une manire de bien interpoler serait peut tre de choisir 2 types de fonction
diffrents. Notre manire actuelle dinterpoler de manire exponentielle pour les points
ncessitant un point dinflexion, et une autre mthode pour les graphes ne ncessitant

Fig. 28 A(0.5 ; 1) et B (0.5 ; 1) sur le premier graphe, et A(0.7, 1) et B(0.5 ; 2) sur


le second.

51
4.3 Explication des diffrentes interpolations 4 LINTERPOLATION

Fig. 29 Invariance graphique par changement de repre

pas naturellement de point dinflexion dans linterpolation (cf les 2 premiers "contre-
exemples" que lon a donn dans cette partie). Seulement il est difficile de gnraliser
une telle mthode : supposons que lon ait une fonction f, C , convexe, croissante,
partant de A(0,0) et arrivant en B(1,1), de premires drives respectives 2 et 0. On
na pas trouv de moyen simple, partir de f, de reconstituer une fonction g, C ,
convexe, croissante, partant de A(0,0) et arrivant en B(1,1), de premires drives
respectives 4 et 0.

Caractristiques de limplmentation actuelle :


_ continuit par rapport aux ordonnes : elle est vrifie, puisque lon prend pour
drives aux points fixes soit les drives donnes par la mthode de Steffen (continues)
soit les diffrences finies (continues aussi). Ensuite on a une formule qui dpend encore
continuement de ces drives, et ce sur un nombre fini de points et un intervalle born.
_ invariance par changement de repre : celle-ci nest pas respecte en toute g-
nralits, mais lest avec notre mthode.
En effet considrons notre interpolation avec A(0,0) de drive premire nulle et
de drive seconde 2, et B(1,1) de drives 0. (dans R, A(0,0) drive seconde ( ab )2
et B(a, b) drives 0).
La fonction dinterpolation a dans R lquation y = x2 .f (x) + (1 f (x)) et dans
0 0
R : y 0 = ( ab )2 x02 .f ( xa ) + b(1 f ( xa )) soit dans R une courbe dquation b.y =
b2 x2 .f (x) + b(1 f (x)) ou encore y = b.x2 .f (x) + (1 f (x)). Et cela ne donne pas
lieu aux deux mme courbes ! (si b est diffrent de 1)

52
4.3 Explication des diffrentes interpolations 4 LINTERPOLATION

on voit nettement sur le second graphe que la courbe passe au dessus du point B,
alors que cela ne se produit pas sur le second. (premier : "fentre" (0,0)-(0.5, 0.5) ;
second : "fentre" (0,0) - (1,1))

Par contre dans notre mthode on nutilise les drives que jusquau premier ordre.
Et en considrant les formules du contre exemple, on voit bien que le b disparaitrait
compltement.

_ "bornitude" de cette mthode : on peut le prouver pour les 2 mthodes la


fois : choix des drives de Stefen ou choix de la moiti des diffrences finies gauche
et droite du point. Dans les 2 cas on a en chaque point xi : |yi0 | 2. |yxi+1 yi |
i+1 xi
et
|yi0 | 2. |yxii y i1 | 0 |yi+1 yi1 |
xi1 ou bien |yi | xi+1 xi1
Ainsi entre i et i + 1 : y = (yi + yi0 .(x xi ))(1 f (t)) + (yi+1 + yi+1
0
(x xi+1 ))f (t)
0 0
et donc |y| max(|yi | + (xi+1 xi ).|yi |, |yi+1 | + (xi+1 xi ).|yi+1 |)
Or (xi+1 xi ).|yi0 | 2|yi+1 yi | dans tous les cas. Soit (xi+1 xi ).|yi0 | 2
2 maxi (|yi |) = 4 maxi (|yi |). Idem pour le deuxime cas.
On a donc finalement |y| 5 maxi (|yi |) et la constante A vaut donc 5. On peut
en fait rduire cette approximation quelque peu grossire et avoir 3 en remarquant
que t.f (1 t) est plus petit que 12 au lieu de 1.

Cela reste encore grossier puisque avec notre programme nous voyons bien quil
ny a pas dnormes disparits entre les donnes et cette interpolation. Cependant
la constante A doit tre strictement suprieure 1 tant donn les dessins o lon
montrait la non convexit de cette interpolation. (entre A(xA , yA ) et B(xB , yB ) on
peut avoir y nappartient pas [yA , yB ]).

4.3.4 Interpolation par Bzier


Les courbes de bzier tant connues pour donner de jolies courbures, il a paru trs
naturel de vouloir les utiliser ici. Historiquement, les courbes de Bzier furent inven-
tes par lingnieur du mme nom, en 1962, chez Renault, qui cherchait modliser
certaines pices automobiles par ordinateur.

Pnde contrle P1 , ..., Pn , on dfinit une courbe de Bzier par len-


Pour n+1 points
semble des points i=0 Bin (t)Pi , t[0, 1] et o les Bin sont les polynmes de Bernstein.
Le polygne est appel polygne convexe de Bzier .
Dfinition : Pour un degr n, il y a n+1 polynmes de Bernstein dfinis, sur linter-
valle [0,1], par Bin = ni X i (1 X)ni

Pn n
Remarque : Puisque i=0 Bi (t) = 1, alors la courbe est correctement dfinie.
Chaque point de la courbe peut tre vu comme un barycentre des points de contrle
Pi .
Remarque : Les courbes de Bzier dpendent de lordre que lon donne aux points
P1 , ..., Pn = {(x1 , y1 ), ..., (xn , yn )}. On considrera toujours pour nos interpolations
que ces points correspondent aux A1 , ..., An = {(x1 , y1 ), ..., (xn , yn )} (les n points
fixes interpoler) o x1 < ... < xn .

53
4.3 Explication des diffrentes interpolations 4 LINTERPOLATION

Remarque : Nous navons pas implment linterpolation de Lagrange (ou de Her-


mite) pour les raisons que lon a donnes plus tt ("phnomne de Runge"). Mais
il ne faut pas se fier aux apparences : une courbe de Bzier nest pas une courbe
polynmiale. En effet x(t) et y(t) dpendent polynmialement du temps, mais lon
na pas y = P (x) o P serait un polynme. En effet, x = Q(t) et lon aurait alors
y = P (Q(t)) o Q et P (Q) doivent avoir mme degr (n). Ainsi P serait de degr 1
et la courbe obtenue serait affine. Ce qui nest bien sr pas le cas (dans le cas gnral

tout du moins : P1 P2 est en effet le vecteur tangent la courbe en t = 0 et Pn1 Pn
celui en t = 1.

En fait une courbe de Bzier passe toujours pas P1 et Pn . Elle ne passe gnrale-
ment pas par les autres points. Notre problme consiste donc trouver P2 , ..., Pn1 tels
que la courbe de Bzier associe soit une interpolation "exacte".

Commenons par prouver quelques rsultats de notre cru concernant les courbes
de Bzier :
_ Etant donns A1 , ..., An = {(x1 , y1 ), ..., (xn , yn )} il existe n points uniques aux
abscisses fixes x1 , ..., xn tels que la courbe de Bzier issue de ces points passe par
A1 , ..., An . On peut alors parler de "linterpolation de Bzier aux points A1 , ..., An ".
Etablissons en premier lieu un lemme intermdiaire avant dattaquer la preuve.
Lemme II.2 Montrons dabord que t x(t) est strictement croissante lorsque les xi
sont tris par ordre croissant comme cest le cas. On suppose dans un premier temps
que les xi sont tous positifs.
Pn n

Preuve On a x(t) = i=0 i xi .ti .(1 t)ni .

Fixons 0 t < u 1. Soit k0 tel que k k0 , tk (1 t)nk uk (1 u)nk et


k > k0 , tk (1 t)nk < uk (1 u)nk . k0 existe car en k = 0, tk (1 t)nk = (1 t)n >
k
(1t)nk
(1 u)n et en k = n, , tk (1 t)nk = tn < un et dautre part sk = utk (1u) nk vrifie
t
1t n 1t k t u
sk = ( 1u ) ( u ) et comme t < u, 1t < 1u et ainsi (sk ) est une suite dcroissante
1u
suprieure 1 en 0 et infrieure 1 en n. k0 est donc "linstant de passage" de sk
sous 1.
Pn
Ceci fait, on a x(u)P x(t) = k=0 xk (bnk (u) P
bnk (t)) (bnk polynme de Bernstein)
soit x(u) x(t) = k>k0 xk (bk (u) bk (t)) kk0 xk (bnk (t) bnk (u)) o chaque
n n

P des xk . (positifs eux aussi


terme est une pondration positive P comme on la suppos)
Ainsi x(u) x(t) > xk0 ( k>k0 bnk (u) bnk (t)) xk0 ( kk0 bnk (t) bnk (u)). Or
Pn n
Pn n
Pn n
Pn n
k=0 bk (t) = k=0 bk (u) = 1 donc x(u) x(t) > xk0 ( k=0 bk (u) k=0 bk (t)) = 0.
Ceci prouve le lemme en partie.

MaintenantPnsi les xi ne sont pas tous positifs : soit A tel que i, (xi + A) 0.
x(t) = A + i=0 ni (xi + A).ti .(1 t)ni et les (xi + A) sont encore tris par ordre
croissant et sont maintenant positifs. x(t) est donc encore strictement croissant en t.

54
4.3 Explication des diffrentes interpolations 4 LINTERPOLATION

Preuve Prouvons maintenant lexistence et lunicit dune courbe de Bzier issue


de (n+1) points aux abscisses fixes x0 , ..., xn (tries par ordre croissant) passant par
A0 , ..., An = {(x0 , y0 ), ..., (xn , yn )}.
Premirement, t x(t) est croissante daprs notre lemme prcdent, et continue
(car polynmiale). De plus, x(0) = x0 et x(1) = xn . Ainsi, comme t x(t) est stricte-
ment croissante, par le thorme des valeurs intermdiaires, !(t0 , ..., tn )[0, 1]n+1 tel
que i, x(ti ) = xi . Bien sr, t0 = 0, tn = 1. Les ti sont encore strictement croissants.

La fonction dinterpolation de Bzier scrit :


(z0 , ..., zn ) B(z0 , ..., zn ) = (y00 , ..., yn0 ). Il nous faut montrer quil existe un unique
n+1 uplet (z0 , ..., zn ) qui donne (y0 , ..., yn ). (les ordonnes des points Ai )
Pn
En fait B est linaire : B(z0 , ..., zn ) = (y00 , ..., yn0 ) et yj0 = i=0 Bin (tj )zi .
Sa matrice est donc : Bi,j = Bjn (ti ) soit
n 0 n 1 n n
 n
 n1
 0
0 t0 (1 t0 ) 1 t0 (1 t0 ) ... nt0 (1 t0 )
n 0 n n n 0
t (1 t1 ) ... ... t (1 t 1 )
B= 0 1 n 1
... ... ... ...
n 0
... nn tnn (1 tn )0
 n

0 tn (1 tn ) ...
t00 (1 t0 )n t10 (1 t0 )n1 ... tn0 (1 t0 )0
Qn n t0 (1 t1 )n ... ... tn1 (1 t1 )0
det(B) = i=0 i . det( 1 )
... ... ... ...
t0n (1 tn )n ... ... tnn (1 tn )0
1 0 ... 0
t1 t1
( 1t1 )0 ... ... ( 1t1 )n
t 0 t
Qn  Qn1 ( 2
) ... ... ( 1t2 )n 2

= i=0 ni . i=1 (1 ti )n . det( 1t2 )


... ... ... ...
tn1 t
( 1tn1 )0 ( 1tn1 )n
n1

0 0 0 1
t1 t1
( 1t1 )1 ... ... ( 1t1 )n
t2 1 t2
( 1t2 ) ... ... ( 1t2 )n
Qn n Qn1
= i=0 i . i=1 (1 ti )n . det( ... ... ... ... )
tn1 1 tn1
( 1tn1 ) ( 1tn1 )n
0 0 0 1
t1 t1
( 1t1 )1 ... ... ( 1t1 )n1
t t
Qn  Qn1 ( 2 )1 ... ... ( 1t 2
)n1
= i=0 ni . i=1 (1 ti )n . det( 1t2 2
)
... ... ... ...
tn1 tn1
( 1t n1
)1 ( 1t n1
)n1
et ce dernier est un dterminant de Vandermonde (transpos mais cela revient au
mme) et comme les ti sont distincts, B est donc inversible, ce qui prouve le rsultat
final.

_ Concernant la proprit de changement dchelle, comme lapplication est li-


naire elle le respecte.

55
4.3 Explication des diffrentes interpolations 4 LINTERPOLATION

Fig. 30 Exemple dinterpolation par Bzier trs russie

_ Concernant la proprit de bornitude, celle-ci est forcment vrifie (les appli-


cations linaires en dimension finie sont continues). La constante A est relier la
norme de B 1 .
On peut clairement majorer la norme infinie (celle que lon a choisie pour la
"bornitude") de B par 1. Comme 1 ||B||.||B 1 || on a ||B 1 || 1. Mais cela reste
encore trs grossier.

_ Concernant la continuit par rapport au changement des points : encore respec-


te puisquune courbe de Bzier dpend continuement sur un intervalle ferm born
([0,1]) des points, et quici le systme est linaire en dimension finie par rapport aux
points, donc continu aussi.
Avec les donnes de base, linterpolation est vraiment agrable, lisse et la courbe
passe sans trop de difficults par tous les "points rouges" = les valeurs du march que
lon doit "cibler".

Implmentation : il sagit dinverser la matrice dont on a calcul le dterminant


dans la preuve ci-dessus afin de connatre les ordonnes des points Pi . Ceci fait, on
calcule une bonne fois pour toutes les instants ti tels que x(ti ) = xi (par dichotomie ;
unicit de ces instants prouve par notre premier rsultat) puis il nest pas compliqu
de faire calculer par lordinateur la formule dfinissant Pt en fonction des ti .

Remarque : Si lon cherche dterminer heuristiquement ces ordonnes, on part


de P1 , ..., Pn = {(x1 , y1 ), ..., (xn , yn )} (les points que lon a interpoler). On calcule
ensuite la distance de la courbe de Bzier ces points, cest dire la somme des carrs
des diffrences entre les yi et lordonne de la courbe de Bzier au point dabscisse xi .
Reste ensuite modifier les yi (sauf y1 et yn qui sont naturellement des points de la
courbe) jusqu approcher  prs notre but. A nombre ditrations fix, lalgorithme
converge assez bien en gnral. Mais parfois il y a divergence : une sorte de phnomne
de Runge se produit et les Pi ont leurs ordonnes qui grandissent afin de satisfaire les
contraintes.

Etant donn que lon a une matrice inverser, de dimension souvent faible, cet
algorithme heuristique semble inutile. Il donne cependant de trs bonnes courbes de
tendance, comme vous pouvez le constater sur les figures.

56
4.3 Explication des diffrentes interpolations 4 LINTERPOLATION

Fig. 31 Interpolation difficile, mais bonne courbe de tendance.

Fig. 32 Steffen et Bzier en vis vis

57
4.3 Explication des diffrentes interpolations 4 LINTERPOLATION

Cette dernire est effectivement faite pour passer par tous les points (ce que lon
veut). Mme si quand on y rflchis bien la courbe de Bzier semble mieux afficher la
"tendance" de la courbe.

En fait linterpolation de Bzier est trs bonne quand les points par lesquels ont
doit passer suivent un "spline naturel". Sinon quand il y a une "imperfection" comme
cest le cas dans lexemple ci-dessous, il est normal que linterpolation soit mauvaise
puisque les polynmes ne sont pas faits pour modliser des imperfections (Diracs, ...)
et ils y ragissent trs mal.

4.3.5 Interpolation par convolution

Lide de cette mthode vient dun rsultat bien connu : Si f L1 et gC , alors
f gC . Et si lon choisit gn 0 alors f gn f . (Rsultat de la thorie des
distributions)
Bref la convolution peut lisser une fonction sans trop la modifier. On a donc
dcid dutiliser cette mthode en partant non pas de linterpolation linaire, mais de
linterpolation qui a donn les meilleurs rsultats jusquici : linterpolation de Steffen.
On convole ensuite cette fonction, et on regarde si le rsultat nest pas trop loign
des points que lon veut atteindre. Au besoin on modifie lgrement les ordonnes, on
rinterpole selon Steffen, on convole le tout, et on recommence jusqu atteindre avec
une prcision fixe lavance chacun des points que lon a en entre.

Implmentation : dans la pratique cette ide ne fonctionne pas aussi bien que cela.
On a en effet un nombre fini de points espacs rgulirement. La convolution revient
donc prendre pour chaque point une sorte de moyenne des points autour, avec une
pondration. Normalement la "vraie convolution" peut aller chercher des points trs
loigns et les pondrer trs peu par rapport aux points voisins de celui en question,
mais quitte mettre un coefficient quasi nul, autant ne pas en mettre dans la pratique.
n y n +0.7(ytn1 +ytn+1 )+0.3(ytn2 +ytn+2 )
Nous avons donc choisi de prendre yt+1 = t 1+0.7+0.7+0.3+0.3 (tout
en veillant aux effets de bords) et ditrer sur la suite (yt ) obtenue.
Donc aux points dabscisses fixes A0 , ..., An = {(x0 , y0 ), ..., (xn , yn )} par lesquels
on doit passer, on choisit dabord dinterpoler selon Steffen, de convoler, et de modifier
les yti jusqu se rapprocher des yi . Le mme algorithme "doptimisation" que celui
pour Bzier peut tre utilis (modification dune fonction, choix de la garder ou non
suivant la distance une autre fonction, ...).

Seulement il se trouve que le rsultat obtenu est trs trs trs proche de linterpola-
tion de Steffen (en tout cas sur les cas usuels du smile de corrlation) : la convolution
ne modifie presque pas la fonction initiale ce qui fait quelle passe presque par les
points initiaux et quil y a trs peu modifier pour que cela se produise.
On peut voir sur cette image (en vert : convolution, en violet Steffen) que cette
dernire est trs proche de Steffen sur les points sans trop de "pics" mais que ds quil
y en a (vers la gauche) la convolution explose.

58
4.3 Explication des diffrentes interpolations 4 LINTERPOLATION

Fig. 33 Comparaison Steffen - interpolation par convolution

Pour prouver thoriquement lexistence et lunicit des ordonnes avoir afin


datteindre tous les points voulus, il faut comme pour Bzier rsoudre un systme sauf
que cette fois-ci il est beaucoup trop compliqu puisquil dpend de linterpolation de
Steffen.
Sinon, la convolution que lon cre est en elle-mme linaire.
Sa matrice est :
1 .7 .3
2 2 2
.7 1 .7 .3
1+2.7+.3 1+2.7+.3 1+2.7+.3 1+2.7+.3
.3 .7 1 .7 .3
1+2.7+2.3 1+2.7+2.3 1+2.7+2.3 1+2.7+2.3 1+2.7+2.3
.3 .7 1 .7 .3
1+2.7+2.3 1+2.7+2.3 1+2.7+2.3 1+2.7+2.3 1+2.7+2.3
.3 .7 1 .7 .3
1+2.7+2.3 1+2.7+2.3 1+2.7+2.3 1+2.7+2.3 1+2.7+2.3
... ... ... ... ...
et ce nest pas un problme facile que dtudier sa norme ou son inversibilit, mme
si les matrices plus ou moins diagonale dominante le sont souvent. (Dailleurs les
matrices diagonale dominante le sont : Hadamard)

Cependant on ne modifie pas le caractre inversible ou non dune matrice en


multipliant une ligne ou une colonne par un coefficient non nul.
2
On multiplie donc la premire et la dernire ligne par 1+2.7+2.3 et la seconde et
1+2.7+.3
lavant dernire par 1+2.7+2.3 .
1 .7 .3
En notant alors a = 1+2.7+2.3 et b = 1+2.7+2.3 et c = 1+2.7+2.3 linversibilit

59
4.3 Explication des diffrentes interpolations 4 LINTERPOLATION

a b c
b a b c
c b a b c
de notre matrice est quivalente celle de
c b a b c
c b a b
... ... ...

Le calcul du dterminant par rcurrence, en dveloppant ce dernier suivant une


ligne ou une colonne, est difficile : les matrices successives obtenues sont frquemment
"nouvelles".
Quoi quil en soit, cette mthode est rejeter, en tout cas lorsque le nombre de
points disposition est faible. Linterpolation par "convolution" ne sadapte vraiment
pas bien aux brusques changement dans les donne. Mais tant donn notre problme
(interpolation dun jeu de donne forte pente initiale), il ny a pas de raison de
vouloir moyenner des points avec dautres surtout lorsque la pente est trs forte et
que leffet de bord ne permet pas de compenser gauche.
Sinon les "splines de lissages" qui reposent sur le mme principe fonctionnent trs
bien.

4.3.6 Interpolation par intgrale


Cette mthode, comme celle de lexponentielle ou lide dutiliser des courbes de
Bzier en "inversant les points" ou de la convolution est de nous. Lide de cette
interpolation-ci repose sur 3 principes : le premier est quil ny a que peu dinterpo-
lations existantes et quil faut donc se reposer dessus (Steffen, Bzier) : nos fonctions
"faites maisons" ne donnent pas de bons rsultats et ne font vraiment pas le poids
face des mthodes qui ont fait leurs preuves, sont mondialement connues, et ont
perdur dans le temps. Le second principe est que le lissage est quelque chose gn-
ralement introduit par intgration (exemple : la convolution) car lintgration ajoute
un degr de plus la continuit ou la drivabilit. Le troisime principe est quen
gnral litration ou le passage la limite apportent souvent des degrs de driva-
bilit supplmentaires (comme les itrations de Picard). Par exemple si lon possde
une mthode de lissage, on peut lisser une premire fois, puis appliquer cette mthode
au rsultat obtenu et ainsi de suite.
Notre ide est donc tant donn un jeu de points A1 , ..., An = {(x1 , y1 ), ..., (xn , yn )}
(les n points fixes interpoler), dassocier chacun une drive, dinterpoler entre ces
drives par Stefen (qui donne un rsultat toujours satisfaisant) puis dintgrer cette
courbe drive obtenue. Rien nindique encore une fois que cette manire de procder
permet de retomber sur A1 , ..., An = {(x1 , y1 ), ..., (xn , yn )}. Il faut donc comme pour
Bzier ou la convolution modifier les drives en ces points en ttonnant jusqu
obtenir une courbe passant par tous les points.

Le rsultat obtenu est trs encourageant (cf Figure).


Il ressemble en fait linterpolation de Steffen, mais notre jeu de donnes initial
ne laisse en fin de compte que peu de libert aux interpolations.

60
4.3 Explication des diffrentes interpolations 4 LINTERPOLATION

Fig. 34 Interpolation par intgrale

Fig. 35 Comparaison Steffen - Interpolation par intgrale

Ci-dessous un comparatif avec linterpolation de Steffen : (Steffen est en violet, la


notre en orange)

On peut noter que notre interpolation possde une certaine "inertie" contrairement
Steffen. Ainsi au maximum de ce dernier graphique, Steffen replonge directement,
puisque son interpolation ne donne que des courbes entre les points. Avec lintgrale,
la courbe continue de monter encore un peu aprs le point. Cest notre avis un
avantage : il ny a aucune raison pour quune interpolation qui passe par des points
doit modifier sa pente en ces points l exactement.

Linconvnient de cette mthode est comme toujours lorsquil faut rsoudre un


systme numrique son imprcision. Ainsi sur des jeux de donnes "gentils", linter-
polation atteint exactement les points (de mme que Bzier et consorts) tandis que si
on injecte plus de "pics" dans les donnes, notre interpolation ne suit pas. Mais ceci

61
4.3 Explication des diffrentes interpolations 4 LINTERPOLATION

est peut tre d au fait que lon a que 100 points sur tout notre graphique. Si lon
sautorise un maillage toujours plus fin il y a fort parier que lon puisse parvenir
nos fins.

Implmentation : nous utilisons la mme fonction doptimisation : choix initial des


drives en les points fixes, interpolation de Steffen sur ces points, puis calcul de la
fonction intgrande rsultante, et calcul de la "distance aux points atteindre" que
lon itre en modifiant les drives en les points cl, jusqu tomber sous une barre de
.

Lintgration se fait basiquement, en prenant pour ordonne de dpart lordonne


du premier point par lequel on doit passer, puis en sommant les x.y 0 (x).
Concernant le choix initial des yi0 on dcide de prendre pour pentes entre les points :
i+1 yi
yi = xyi+1
0 0 0
xi (et yn = yn1 ).
On pourrait pousser le vice interpoler par la mthode intgrale entre les drives
(plutt quavec Steffen) (interpolation qui utilisera linterpolation de Steffen) et ainsi
gagner encore un cran sur la drivabilit. Cependant on ne la pas fait pour des
questions de temps dans un premier temps (interpoler une fois par lintgrale est
tolrable puisque derrire Steffen est en temps constant, mais interpoler plusieurs fois
implique un temps puissance 2 puisque linterpolation intgrale ncessite dinverser un
systme numriquement et donc ditrer en recalculant des interpolations intgrale.

Conclusion Concernant les interpolations, cette dernire nous semble finalement la


plus agrable : linterpolation de Steffen fonctionne trs bien, mais elle a t dveloppe
surtout pour bien ragir face aux donnes "monotones". Lorsque les donnes ne le
sont plus, elle ne donne pas de formes trs naturelles contrairement linterpolation
intgrale que lon a dvelopp : celle-ci bnficie en fait dune sorte "dinertie" qui lisse
plus les disparits et qui permet de diffrencier en gnral les points de changement
de monotonie avec les points "fixes" par lesquels on doit passer.
Les interpolations pures et simples donnent de bien meilleurs rsultats que notre
optimiseur numrique de fonction : celui-ci permet effectivement de faire diminuer le
"dfaut" de spread par rapport aux critres que lon impose, mais le rsultat obtenu
nest jamais acceptable puisque loptimiseur cre naturellement des "sauts" certains
endroits afin dtre pnalis quelque part pour ne pas tre pnalis beaucoup dautres
endroits.

62
5 LOPTIMISATION

5 Loptimisation
Nous avons tent doptimiser la courbe de spread pour la rendre non arbitrable
grce un algorithme se basant sur 2 fonctions principales : une premire procdure
modifie une fonction faiblement, et une seconde teste la fonction obtenue afin de
dterminer si cette dernire est plus acceptable quoriginellement.

Ces deux procdures offrent cependant leur lot de surprises que nous dtaillons.

5.1 Algorithme doptimisation


Lalgorithme stait dans un premier temps bas sur la mthode du recuit-simul :
la procdure de test renvoie un nombre reprsentant le "dfaut" par rapport au carac-
tre arbitrable de la courbe de spread. Partant dune solution donne, en la modifiant,
on en obtient une seconde. Soit celle-ci amliore le critre que lon cherche optimiser,
on dit alors quon a fait baisser lenergie du systme, soit celle-ci le dgrade. Si on
accepte une solution amliorant le critre, on tend ainsi chercher loptimum dans le
voisinage de la solution de dpart. Lacceptation dune "mauvaise" solution permet
alors dexplorer une plus grande partie de lespace de solution et tend viter de
senfermer trop vite dans la recherche dun optimum local.
Tout ceci se fait avec une temprature qui dcroit continment avec le nombre
dtapes et tend vers 0.
A chaque itration de lalgorithme une modification lmentaire de la solution
est effectue. Cette modification entrane une variation E de lnergie du systme
(toujours calcule partir du critre que lon cherche optimiser). Si cette variation
est ngative (cest--dire quelle fait baisser lnergie du systme), elle est applique
E
la solution courante. Sinon, elle est accepte avec une probabilit e T de sorte que
lorsque T tend vers 0 les changements ne sont presque plus accepts, alors quinitia-
lement, il y a une plus grande libert.
On itre ensuite selon ce procd en gardant la temprature constante.

Le seul problme est que la dcroissance de T est trs difficile grer. Dans tous
nos cas nous navons obtenu que des processus faisant augmenter lnergie, ce qui
nest pas normal. Nous avons donc dcid darrter cette mthode et de naccepter
que les solutions faisant dcrotre lnergie.

5.1.1 Modification locale de fonction

Concernant la modification, il y a l aussi plusieurs manires de faire : dans le cas


dune fonction cherche croissante, on peut tre un peu plus "prcis" concernant la
modification.
Nous avons souvent 100 points (xi , yi ). Nous dcidons donc de tirer au sort i puis
de modifier yi .

Une premire manire est de choisir yi alatoirement entre yi1 et yi+1 . Cela
conserve la croissance de la courbe.

63
5.1 Algorithme doptimisation 5 LOPTIMISATION

Une seconde manire de faire est de multiplier yi par 0.995 + 0.01U o U est
uniforme sur [0-1]. Cela permet de modifier localement la fonction de 0.5% environ et
cest cette mthode qui fonctionne le mieux.
yi
Une troisime manire de faire est dagir de mme avec les pentes : di = xyi+1
i+1 xi
.
On choisit de modifier la pente dun certain coefficient : yi = yi1 +(0.995+0.01U )(xi
xi1 )di .

La modification nest pas ce qui pose le plus de problmes quoique dans notre cas,
on souhaite obtenir une courbe de corrlation croissante.

5.1.2 Critre dvaluation

Nous avons mis en exergue deux critres darbitrage : la non-dcroissance du spread


de tranchelette, et la ngativit de celui-ci.
A ceci nous pouvons rajouter que nous souhaitons obtenir une courbe la plus lisse
possible.

Il y a encore plusieurs manires dvaluer le dfaut dune courbe de spread donne.


Par exemple on peut sommer toutes les valeurs absolues des fois o le spread est
ngatif. Ou bien le carr de cela, ou ...

Par rapport la non-dcroissance, si le spread sur [a, a+dx] est infrieur celui sur
[b, b+dx] avec a < b, alors il y a arbitrage. Il faudrait donc ajouter tous les arbitrages
possibles sil y a une faible valeur de spread sur tranchelette un endroit.
Ainsi
P Pon peut ajouter aux valeurs+ absolues des spreads ngatifs la somme
i j>i (spread(j) spread(i)) ou bien le carr de ces nombres.
On peut aussi ne pas regarder sur tous les j suprieurs i, mais juste sur certains
immdiatement suprieurs, de manire ce que sil y a une petite erreur on ne soit
pas trop pnaliss sur toute une srie.

Concernant le
Pcritre de "lissitude" de la courbe, nous choisissons dajouter au
dfaut la valeur i ((2si si+1 si1 )+ )2 , puisque la courbe de spread trace semble
tre convexe. On pnalise donc la dcroissance.

Il y a donc A que lon peut imputer la ngativit du spread, B la non dcrois-


sance, et C la non lissitude.
La difficult consiste ensuite chercher des coefficients , , et retourner A +
B + C. Cest dire quil faut "doser" les quantits calcules pour retourner quelque
chose de cohrent.

Paramtre de comptage de croissance du spread Simulations de smile de cor-


rlation /courbe de spread optimis en prenant originellement linterpolation linaire.
On sintresse au nombre de "j" prendre en compte aprs un indice i. Dans
lordre avant optimisation, puis 1, 5, 10 et 20 (sur 100 indices au total)3

64
5.1 Algorithme doptimisation 5 LOPTIMISATION

Fig. 36 Interpolation linaire avant optimisation numrique

Fig. 37 Interpolation linaire aprs optimisation numrique. Croissance compte


sur 1 suivant

Fig. 38 Interpolation linaire aprs optimisation numrique. Croissance compte


sur 5 suivants

65
5.1 Algorithme doptimisation 5 LOPTIMISATION

Fig. 39 Interpolation linaire aprs optimisation numrique. Croissance compte


sur 10 suivants

Fig. 40 Interpolation linaire aprs optimisation numrique. Croissance compte


sur 20 suivants

66
5.2 Rsultats 5 LOPTIMISATION

Fig. 41 Interpol. de Steffen aprs optimisation numrique. Croissance compte sur


10 suivants, norme 1

On voit que lorsque lon prend 1 par exemple, loptimiseur prfre sacrifier un seul
endroit de la courbe en crant une grosse croissance, tandis quavec des plus grands
nombres ceci ne "passe plus" puisque un saut est compt 5 fois, 10 fois, 20 fois. (pour
chaque point avant le saut, soit 1+2+3+4+5 fois, 1+2+3+...+10 fois, 1+2+...+20
fois)
Par contre prendre en compte les 10 ou 20 voisins suivant sur un point donn na
pas beaucoup dinfluence.

Choix de la norme Intressons nous maintenant au choix de la norme : "norme 1"


ou "norme 2". Les images prcdentes ont t faites avec une optimisation numrique
qui se basait sur une interpolation linaire avec une norme 1.
La norme 1 ou 2 traduit le fait que lon prend la valeur absolue ou le carr de lcart
entre un spread et un autre sens tre infrieur (compt seulement si ce dernier est
suprieur).
Nous choisissons ici linterpolation de Steffen avec la norme 1 (5 puis 10 "suivants")
puis pour la norme 2 (mme nombres).
Sur ces graphiques on se rend compte que le "nombre de suivants" est finalement
pas trs important tant quil est suprieur 5.
Par contre la norme 1 donne de meilleurs rsultats que la norme 2 : contrairement
ce qui est prvu celle-ci lisse la courbe sur de grandes parties mais privilgie les
"sauts" brusques.

5.2 Rsultats

La courbe de spread est en fait trs sensible la corrlation et si loptimiseur


modifie la courbe de spread on ne voit pas forcment beaucoup de changements sur la

67
5.2 Rsultats 5 LOPTIMISATION

Fig. 42 Interpol. de Steffen aprs optimisation numrique. Croissance compte sur


20 suivants, norme 1

Fig. 43 Interpol. de Steffen aprs optimisation numrique. Croissance compte sur


10 suivants, norme 2

68
5.2 Rsultats 5 LOPTIMISATION

Fig. 44 Interpol. de Steffen aprs optimisation numrique. Croissance compte sur


20 suivants, norme 2

Fig. 45 Comparaison entre linterpolation de Steffen (violet) et linterpolation li-


naire (bleu)

corrlation. Loptimiseur ne permet donc absolument pas dexpliciter une "fonction" :


on lui donne une interpolation de base, et il la modifie trs lgrement. Mais en
partant de linterpolation linaire on ne tombe pas du tout sur les autres interpolations
meilleures ! La convergence est trs rapide, et la complexit dune bonne fonction
dvaluation est la cl du problme de non-convergence vers de meilleures fonctions.

Un intrt cependant : il y a un rsultat chiffr (lvaluation du dfaut, que lon


espre minimale) et lon peut donc comparer diffrentes interpolations entre elles grce
ce nombre. Cest donc un critre objectif.
Voici diffrents graphiques obtenus. Rappelons que la courbe plus ou moins d-
croissante sur les figures est la courbe de spread, que lon cherche rendre totalement
dcroissante.

69
5.2 Rsultats 5 LOPTIMISATION

Fig. 46 Comparaison entre linterpolation de Steffen (violet) et linterpolation par


convolution (vert)

Fig. 47 Comparaison entre linterpolation de Bzier (marron) et linterpolation


linaire (bleu)

70
5.2 Rsultats 5 LOPTIMISATION

Fig. 48 Comparaison entre linterpolation de Steffen (cyan) et linterpolation de


Bzier (marron)

Fig. 49 Comparaison entre linterpolation par convolution (vert) et linterpolation


linaire (bleu)

71
5.2 Rsultats 5 LOPTIMISATION

Fig. 50 Comparaison entre linterpolation exponentielle (orange) et linterpolation


linaire (bleu)

Fig. 51 Comparaison entre linterpolation de Steffen (violet) et linterpolation ex-


ponentielle (orange)

72
5.3 Conclusion 5 LOPTIMISATION

5.3 Conclusion
Ces images sont loccasion de montrer que les courbes interpolarices les plus lisses
sont effectivement celles qui donnent lieu aux courbes de spread les plus harmonieuses.
A notre sens seules les interpolation de Bzier, par intgrale et de Steffen sont
retenir. Les deux premires donnent galement dexcellentes courbes de tendance dans
les cas o lon opte pour une interpolation "inexacte", qui ne passe pas exactement
par les points voulus.
Linterpolation de Steffen est sans surprises puisque sa consistance se prouve ma-
thmatiquement. Elle interpole trs bien les donnes monotones (ce que lon a ici)
cependant son comportement nest pas satisfaisant lorsque les donnes ne le sont
plus. Elle reste nanmoins non divergente mais toujours trop rigide dans ce cas.
Linterpolation par intgrale semble raliser une alternative prometteuse Bzier
et Steffen : elle interpole trs bien les donnes monotones et affiche de jolies courbures
sur les donnes non monotones compare Steffen. Elle diverge cependant un petit
peu comme pour Bzier lorsque les donnes interpoler sont trop disparates.
Linterpolation exponentielle reste quant elle creuser.

73
Troisime partie
Extrapolation du smile de corrlation

74
Cette partie est confidentielle.

75
A PREUVES MATHMATIQUES

A Preuves mathmatiques
A.1 Interpolation exponentielle
Afin de choisir une fonction (pour linterpolation exponentielle) qui vrifie f (0) =
0, f (1) = 1 et n 1, f (n) (0) = f (n) (1) = 0 on a choisit de se baser sur le rsultat
suivant :
RR
f : x 0 si x 0 est C . Il faut vrifier en 0 que toutes les drives de la
1
x
xe sinon

fonction cot "strictement positif" vaillent 0.

Pn (x) 1
Preuve Hypothse de rcurrence en n : Pn , Qn R[X] tels que f (n) (x) = Q n (x)
e x
(quand x > 0)
Hypothse vraie en 0 (P0 = 1 = Q0 )
Pn (x) 1 Pn (x) 0 Pn (x) 1
n n + 1 : f (n) (x) = Q n (x)
e x => f (n+1) (x) = (( Qn (x)
) + x12 Q n (x)
)e x donc
le rsultat est prouv et la rcurrence se propage. (prendre par exemple Pn+1 (x) =
Pn Qn + X 2 (Pn0 Qn Q0n Pn ) et Qn+1 = X 2 Q2n )
Pn (x) 1
Une fois ce rsultat prouv, il est facile de voir que limx0+ Q n (x)
e x = 0, par
exemple en prenant le logarithme et en voyant quil tend vers . (ln(x) est ngli-
geable devant x1 en 0)

f est donc une fonction C , o toutes les drives sont nulles en 0, et qui vaut 0
en 0 et 1 linfini. (Et toutes les drives tendant naturellement vers 0 linfini).
Il faut "rduire" f pour la faire "tenir" dans [0,1], tout en respectant les contraintes.

Pour cela on considre g(x) = f (x.ex ). Cette fonction a vocation a tendre vers
linfini trs rapidement afin davoir rapidement toutes les drives nulles vers linfini,
de sorte ce quune "compression" de R+ [0, 1] ne cre pas de drives non nulles
en 1.

En considrant la preuve par rcurrence prcdente, on peut noter que pour n


1, an 2 tel que f (n) (x) xa1n quand x + (en effet le degr de Qn augmente
plus que celui de Pn )
Cependant x x.ex a toutes ses drives du type P (x)ex o P est un polynme.
Donc g (n) (x) = e(an 1)x (1 + o(e(an 1)x )) en linfini. En 0 f a toutes ses drives
nulles tandis que x x.ex ne prsente pas de "soucis" : toutes ses drives sont finies
en 0. g a donc aussi toutes ses drives nulles en 0.

sin( x)
Quand x 1 , tan( 2 x) = cos( 2 x) (1x)
1
donc h(x) = g(tan( 2 x)) a encore
2 2
toutes ses drives nulles en 0 (puisque les drives en 0 de tan ne posent pas de soucis
1
particulier et que dans g il y a encore du e x en facteur) et idem en linfini (d au
e(an 1)x en facteur dans g tandis que tan a des drives quivalentes des fractions
rationnelles)

76
A.2 Market Law of Losses A PREUVES MATHMATIQUES

On obtient ainsi le rsultat :


h(x)+1h(1x)
h(x) =
Afin de symtriser la fonction h obtenue, on peut poser b 2 .

A.2 Market Law of Losses

Soi LK lesprance de la perte sur la tranche [0, K%] vue par le march, et L(K)
la probabilit vue par le march pour que la perte atteigne K.
RK
LK = 0 xdL(x) + K(1 L(K)), par dfinition
RK
Ceci se rcrit LK = K 0 L(x)dx et donc L K = 1 L(K)
K

Soit maintenant L(K, K ) la probabilit que la perte soit infrieure K tant


donne une corrlation K et calcule grce au modle de la copule gaussienne.
RK
Alors LK = 0 xdL(x, K ) + K(1 L(K, K )) puisque la base correlation sur la

tranche [0, K%] est faite pour que justement on ait que la perte calcule par la copule
gaussienne soit gale celle du march.
RK
Soit LK = K 0 L(x, K )dx
K K L
Ainsi L
R
K = 1 L(K, K ) K 0 (x, K )dx
K

R K L
ou encore LK = 1 L(K, K ) Skew(K, K ) 0 (x, K )dx
K

Mais si lon dfinit Rho(K, K ) = L


K , on a
K

R K L
Rho(K, K ) = 0 (x, K )dx
En combinant les 2 expressions que lon a, on retrouve :

L(K) = L(K, K ) Skew(K, K ) (K, K )

soit P (Loss < K) = P (Loss < K, K ) Skew(K, K ) Rho(K, K )

77
A.3 Simulation dune variable alatoire normale
A centre
PREUVES
rduite
MATHMATIQUES

A.3 Simulation dune variable alatoire normale centre r-


duite
Lordinateur peut fournir des nombres (pseudos-)alatoires de manire uniforme
et indpendante compris entre 0 et 1. Cest ce que lon suppose, et en pratique le
gnrateur pseudo-alatoire des ordinateurs tient bien ses promesses.
Si Up
1 et U2 sont 2 variables alatoires indpendantes et uniformes sur [0, 1] alors
si X = 2ln(U1 ) cos(2U2 ), X N (0, 1).

La preuve se fait en 2 temps.

Lemme III.1 Si X, Y N (0, 1) et sont indpendantes, si R et sont tels que X =


R cos , Y = R sin avec R positif, alors est uniforme sur [0, 2] et R2 suit une loi
exponentielle de paramtre 12 .

t2
Preuve On rappelle que si X N (0, 1) alors E(eitX ) = e 2 .
Fixons et intressons nous au couple (X cos + Y sin , X sin Y cos ).
Sa fonction caractristique vautE(eit(X cos +Y sin )+iu(X sin Y cos ) )
= E(ei(t cos +u sin )X+i(t sin u cos ) )
(t cos +u sin )2 (t sin u cos )2
= e 2 e 2 , par indpendance de X et de Y.
t2 +u2
Cest dire aprs dveloppement e 2 qui est la fonction caractristique de (X,
Y). Ainsi par rotation dun angle la loi du couple ne change pas. Cest donc que
suit une loi uniforme sur [0, 2].
2 2 2
QuantZ Z R2 , E(eitR ) = E(eit(X +Y ) )
2 2 x2 y2
1
= 2 eit(x +y ) e 2 e 2 dxdy
R2
On effectue un changement de variable polaire. Il vient :
2
1
R 2 R + itr2 r2
E(eitR ) = 2 e e 2 rdrd
R + itr2 r02 0 1
= 0 e e 2 rdr = 12it (pas de difficults)

Or si A suit une loi exponentielle de paramtre , f (x) = ex et sa fonction


R +
caractristique est E(eitA ) = 0
eitx ex dx =
it .
Do le rsultat.


Passons maintenant au rsultat final. On prouve en fait que 2 ln U1 cos(2U2 )
et 2 ln U1 sin(2U2 ) sont normales centres rduites et indpendantes.

Preuve
Rappelons que si F dsigne la fonction de rpartition dune variable alatoire relle
X, et si U est uniforme sur [0, 1] alors F 1 (U ) X (en effet, P (X < a) = F (a) =
P (U <= F (a)) = P (F 1 (U ) < a))

78
A.4 Loi normale A PREUVES MATHMATIQUES

Si X est une variable alatoire qui suit une loi exponentielle de paramtre 12 ,
1 Rx 1
f (x) = 12 e 2 x et F (x) = 0 f (t)dt = 1 e 2 x ainsi si U est uniforme sur [0, 1],
2 ln(1 U ) exp 12 et donc comme U a mme loi que 1 U , 2 ln U exp 12 .

Ainsi ( 2 ln U1 cos(2U2 ), 2 ln U1 sin(2U2 )) a mme loi quun couple de 2
variables normales centres rduites indpendantes.
On aurait pu prouver directement par changement de variable le rsultat, mais il
semble plus comprhensible de dtailler de cette manire.

A.4 Loi normale


Rx x2
Nous utilisons souvent dans nos pricers la fonction N (x) = 12 e 2 dx.
Seulement il faut pouvoir implmenter cette fonction, et que ceci se fasse rapidement
vu le nombre de fois o nous allons lutiliser.
Une solution est par exemple donne dans le cours de Gobet-El Karoui :
1 2
N (x) 1 12 e 2 x (ay + by 2 + cy 3 )
1
o y = 1+.33267x , a = 0.4361836, b = 0.1201676 et c = 0.937298

Nous utilisons cette formule pour x 0. Pour x < 0, N (x) = 1 N (x)


Pour calculer N 1 , nous utilisons la dichotomie en majorant le rsultat obtenu
x = 6 puisquil faut bien prendre une limite.

A.5 Loi normale bi-dimensionnelle

Si X et Y sont deux variables alatoires normales centres rduites, de corrlation


, on note :
Ra Rb 2 2
N (a, b, ) = P (X < a, Y < b) = 1 2 exp( 12 x 2xy+y 12 )dxdy
2 1

Une manire dapproximer cette intgrale est dcrite dans Hull, 1993, chapitre 10.

Public Function N2(ByVal a As Double, ByVal b As Double, ByVal rho As Double)


As Double
Dim aa As Variant, bb As Variant
Dim aprim As Double, bprim As Double, summ As Double
Dim i As Integer, j As Integer, delta As Double, rho1 As Double, rho2 As Double,
denum As Double

If a <= 0 And b >= 0 And rho <= 0 Then


aprim = a / Math.Sqr(2# * (1# - rho * rho))
bprim = b / Math.Sqr(2# * (1# - rho * rho))
aa = Array(0.325303, 0.4211071, 0.1334425, 0.006374323)
bb = Array(0.1337764, 0.6243247, 1.3425378, 2.2626645)
summ = 0#
For i = 0 To 3

79
B IMPLMENTATION DES FONCTIONS

For j = 0 To 3
summ = summ + aa(i) * aa(j) * f(bb(i), bb(j), aprim, bprim, rho)
Next j
Next i
summ = summ * Math.Sqr(1# - rho * rho) / pi
N2 = summ
Exit Function

ElseIf (a * b * rho) <= 0 Then


If a <= 0 And b >= 0 And rho >= 0 Then
N2 = N1(a) - N2(a, -b, -rho)
Exit Function
ElseIf a >= 0 And b <= 0 And rho >= 0 Then
N2 = N1(b) - N2(-a, b, -rho)
Exit Function
ElseIf a >= 0 And b >= 0 And rho <= 0 Then
N2 = N1(a) + N1(b) - 1# + N2(-a, -b, rho)
Exit Function
End If

Else
denum = Math.Sqr(a * a - 2# * rho * a * b + b * b)
rho1 = (rho * a - b) * sign(a) / denum
rho2 = (rho * b - a) * sign(b) / denum
delta = (1# - sign(a) * sign(b)) / 4#
N2 = N2(a, 0#, rho1) + N2(b, 0#, rho2) - delta
Exit Function
End If

End Function

B Implmentation des fonctions


B.1 Pricer de CDS
Comme indiqu dans la partie Pricer de CDS, nous crons une fonction qui aux
lambdas calcule le spread rsultant, et nous calculons les lambdas successivement par
dichotomie. Le code est en VBA, mais il se gnralise trs facilement dans nimporte
quel langage, sauf peut tre la premire partie o les paramtres du march sont lus
directement depuis la feuille Excel. On suppose donns le spread dun CDS sur toutes
les maturits de 1 10.
Le tableau des lambdas (intensits de dfaut par unit de temps) ainsi que dautres
paramtres (recovery, taux dintrt, ...) sont ici des variables globales.
Option Explicit

80
B.1 Pricer de CDS B IMPLMENTATION DES FONCTIONS

Dim r As Double, recovery As Double, rbpv As Double


Dim spreads(1 To 10) As Double, lambdas(1 To 10) As Double
initialisation des donnes utilisateur

puis calcul des lambdas (intensits de dfaut par unit de temps)


Private Sub btncompute_Click()
Dim k As Integer
r = CDbl(Me.Range("MarketData").Cells(2, 2))
recovery = CDbl(Me.Range("MarketData").Cells(3, 2))
For k = 1 To 10
spreads(k) = CDbl(Me.Range("MarketData").Cells(6 + k, 2))
Next k
For k = 1 To 10
lambdas(k) = impliciter_lambda(k)
Me.Range("MarketData").Cells(6 + k, 3) = lambdas(k)
Next k
End Sub

k indique sur quelle plage impliciter lambda (0 1 an, 1 2 ans, ...)


Private Function impliciter_lambda(ByVal k As Integer) As Double
Dim a As Double, b As Double, s As Double
a=0
b=1
Do While (b - a) > 0.00000001
lambdas(k) = (a + b) / 2
s = calcule_spread(CDbl(k))
If s < spreads(k) Then
a = (a + b) / 2
Else
b = (a + b) / 2
End If
Loop
impliciter_lambda = (a + b) / 2
End Function

Private Function calcule_spread(ByVal tfinal As Double) As Double


Dim s As Double, k As Integer, n As Integer
Dim integr_lambda As Double
Dim temp As Double, l As Double, aa As Double, bb As Double
Dim floatleg As Double
CALCUL DE LA FLOAT LEG
s = 0#
n = Int(tfinal)
For k = 1 To n
l = lambdas(k)
s = s + (l / (l + r)) * (Math.Exp(-(r + l) * (k - 1))) * (1 - Math.Exp(-(r + l)))

81
B.2 Pricer de CDO B IMPLMENTATION DES FONCTIONS

Next k
If (tfinal < 10) And (tfinal > n) Then
l = lambdas(n + 1)
s = s + (l / (l + r)) * (Math.Exp(-(r + l) * n)) * (1 - Math.Exp(-(r + l) * (tfinal
- n)))
End If
floatleg = s * (1 - recovery)
CALCUL DE LA FIXED LEG
integr_lambda = 1 = exp (integrale de lambda de 0 ti)
n = Int(4 * tfinal)
s = 0#
For k = 1 To n
l = lambdas(1 + Int((k - 1) / 4))
temp = integr_lambda * l * Math.Exp(-r * (k - 1) * 4)
aa = l + r
temp = temp * ((1 - Math.Exp(-0.25 * aa)) / (aa * aa) - 0.25 * Math.Exp(-0.25
* aa) / aa)
integr_lambda = integr_lambda * Math.Exp(-0.25 * l)
s = s + 0.25 * Math.Exp(-r * k / 4) * integr_lambda + temp
Next k
If (tfinal < 10) And (tfinal > (n / 4)) Then
l = lambdas(Int(tfinal) + 1)
temp = integr_lambda * l * Math.Exp(-r * n * 4)
aa = l + r
bb = tfinal - n / 4
temp = temp * ((1 - Math.Exp(-bb * aa) / (aa * aa)) - bb * Math.Exp(-bb * aa)
/ aa)
integr_lambda = integr_lambda * Math.Exp(-bb * l)
s = s + bb * Math.Exp(-r * tfinal) * integr_lambda + temp
End If
rbpv = s
calcule_spread = floatleg / rbpv
End Function

B.2 Pricer de CDO


On a implment ici les 3 diffrentes manires dcrire un pricer, comme on la
dcrit plus tt, en VBA toujours. On rutilise le code de pricing de CDS afin de
dduire les intensits de dfaut lambdas.

Nous utilisons quelques fonctions dExcel (fonction Beta et Gamma) grce au snip-
pet : Application.WorksheetFunction.GammaLn(x) (on peut remplacer GammaLn
par nimporte quelle fonction dExcel).
Dans lordre de ce code : calcul par rcurrence, par loi beta puis par monteCarlo.
Chacune de ces fonctions utilise beaucoup de petites fonctions.

82
B.2 Pricer de CDO B IMPLMENTATION DES FONCTIONS

Il faut faire attention quelque chose dautre : lorsque lon dit que lon achte la
tranche [K1 , K2 ], cela veut dire que lorsque les pertes (en prenant en compte le taux
de recouvrement) atteignent K1 % du nominal on commence payer.
Ainsi en considrant un taux de recouvrement de 40% par exemple, la tranche
[60%, 100%] est de fait "fictive" puisque les pertes natteindront au pire que 60%.
Par contre la loi Beta est "rgle" sur [0, 1]. Il faut donc effectuer un "change-
ment dchelle", cest dire rajuster la perte afin quelle concorde avec les autres
algorithmes.

Option Explicit
Public recovery(1 To 10) As Double, correl(1 To 10) As Double, leverage(1 To 10)
As Double
Public lambdas(1 To 10, 1 To 10) As Double
Public k1 As Double, k2 As Double
Public floatleg As Double, rbpv As Double
Dim pi(1 To 10, 0 To 10) As Double pour calculer la loi inverse de TAUi

Public Function calculer_spread_recurrence(tfin As Double) As Double


Dim integr As Double, n As Integer, k As Integer, t As Double, i As Integer, j As
Integer, nt As Integer, ligne As Integer
Const nb_integr = 1000, nb_integr2 = 100, nb_integr_t = 20, nb_integr_z =
200
Dim u As Double, grandL As Double, grandN As Integer, z As Double, grandT
As Integer, nz As Integer, NTFinal As Integer
Dim levera(1 To 10) As Integer levera * u = leverage
Dim table() As Double, temp() As Double, p As Double, nn As Integer
u = leppcm()
grandL = 0#

For i = 1 To 10
grandL = grandL + leverage(i) * (1 - recovery(i))
Next i
k1 = k1 * grandL
k2 = k2 * grandL
grandN = Int((grandL / u) + 0.0001)
grandT = Int(tfin * nb_integr_t)
For i = 1 To 10
levera(i) = Int((leverage(i) * (1 - recovery(i))) / u)
Next i
cration de la table des probabilits
ReDim table(0 To grandT, 0 To grandN) As Double contient P(Lt = n*u)
ReDim temp(0 To 1, 0 To grandN) As Double contient P(Lt,i = n*u)
initialise_TAUiMoins1
For nt = 0 To grandT
t = tfin * (CDbl(nt) / CDbl(grandT))
For j = 0 To grandN

83
B.2 Pricer de CDO B IMPLMENTATION DES FONCTIONS

table(nt, j) = 0#
Next j
For nz = 1 To nb_integr_z
z = -6# + 12# * CDbl(nz) / CDbl(nb_integr_z)
effacer temp, grandN
temp(0, 0) = 1#
For i = 1 To 10
ligne = i Mod 2
For j = 0 To grandN
p = proba_condition(i, t, z)
If j >= levera(i) Then
temp(ligne, j) = temp(1 - ligne, j) * (1 - p) + temp(1 - ligne, j - levera(i)) * p
Else
temp(ligne, j) = temp(1 - ligne, j) * (1 - p)
End If
Next j
Next i
For j = 0 To grandN
table(nt, j) = table(nt, j) + temp(0, j) * Exp(-z * z * 0.5) * 12# / nb_integr_z
Next j
Next nz
For j = 0 To grandN
table(nt, j) = table(nt, j) / Math.Sqr(2 * Tout.pi)
Next j
Next nt
fin de cration de la table

floatleg
floatleg = Math.Exp(-Tout.r * tfin) * espe_recur(grandT, table, grandN, u) espe
= E(Lt[k1-k2])
integr = 0#
For nt = 1 To grandT
t = tfin * (CDbl(nt) / CDbl(grandT))
integr = integr + Math.Exp(-Tout.r * t) * espe_recur(nt, table, grandN, u) * tfin
/ CDbl(grandT)
Next nt
floatleg = floatleg + integr * Tout.r

fixedleg
rbpv = 0#
n = Int(tfin * 4)
NTFinal = Int(0.25 * CDbl(grandT) / tfin)
For k = 1 To n
integr = 0#
For nt = 0 To (NTFinal - 1)
t = k / 4# + 0.25 * CDbl(nt) / CDbl(NTFinal)

84
B.2 Pricer de CDO B IMPLMENTATION DES FONCTIONS

nn = nt + Int(CDbl(k - 1) / (4# * tfin) * CDbl(grandT))


integr = integr + (k2 - k1 - espe_recur(nn, table, grandN, u)) * 0.25 / NTFinal
Next nt
rbpv = rbpv + Math.Exp(-Tout.r * CDbl(k) / 4#) * integr
Next k
calculer_spread_recurrence = floatleg / rbpv
End Function

Private Function espe_recur(ByVal t As Integer, ByRef table() As Double, ByVal


n As Double, ByVal u As Double) As Double
Dim l As Double, i As Integer
l = 0#
For i = 0 To n
l = l + table(t, i) * (plus(u * CDbl(i) - k1) - plus(CDbl(i) * u - k2))
Next i
espe_recur = l
End Function

Public Function calculer_spread_betalaw(tfin As Double) As Double


Dim integr As Double, n As Integer, k As Integer, t As Double, i As Integer
Const nb_integr = 1000, nb_integr2 = 100
initialise_TAUiMoins1
floatleg
floatleg = Math.Exp(-Tout.r * tfin) * espe(tfin) espe = E(Lt[k1-k2])
integr = 0#
For k = 1 To nb_integr
t = (tfin * k) / nb_integr
integr = integr + Tout.r * Math.Exp(-Tout.r * t) * espe(t) * tfin / nb_integr
Next k
floatleg = floatleg + integr
fixedleg
rbpv = 0#
n = Int(tfin * 4)
For k = 1 To n
integr = 0#
For i = 1 To nb_integr2
t = (k - 1) / 4 + 0.25 * i / nb_integr2
integr = integr + (k2 - k1 - espe(t)) * 0.25 / nb_integr2
Next i
rbpv = rbpv + Math.Exp(-Tout.r * k / 4) * integr
Next k
calculer_spread_betalaw = floatleg / rbpv
redimensionnement du floatleg
t = 0#
For i = 1 To 10
t = t + leverage(i) * (1 - recovery(i))

85
B.2 Pricer de CDO B IMPLMENTATION DES FONCTIONS

Next i
floatleg = floatleg * t
End Function

Private Function espe(t As Double) As Double


espe = espe_plus(k1, t) - espe_plus(k2, t)
End Function

Private Function espe_plus(ByVal k As Double, ByVal t As Double) As Double


= E(Lt-k)+
Dim i As Integer, j As Integer, l As Double, lbis As Double, mu As Double, sigma2
As Double, chi As Double, s As Double
Dim a As Double, b As Double
moyenne de Lt
l = 0#
lbis = 0#
For i = 1 To 10
l = l + leverage(i) * (1 - recovery(i))
lbis = lbis + leverage(i) * (1 - recovery(i)) * proba(i, t) = proba(Taui <= t)
Next i
mu = lbis / l
variance de Lt
s = 0#
For i = 1 To 10
For j = 1 To 10
If i <> j Then
a = Tout.N1moins1(proba(i, t))
b = Tout.N1moins1(proba(j, t))
s = s + leverage(i) * (1 - recovery(i)) * leverage(j) * (1 - recovery(j)) * Tout.N2(a,
b, correl(i) * correl(j))
Else
s = s + (leverage(i) * (1 - recovery(i))) ^2 * proba(i, t)
End If
Next j
Next i
sigma2 = s / (l * l) - mu * mu
chi = mu * (1 - mu) / sigma2 - 1
a = mu * chi
b = (1 - mu) * chi
espe_plus = -k * (1 - grandF(a, b, k)) + (1 - grandF(a + 1, b, k)) * a / (a + b)
End Function

Public Function calculer_spread_montecarlo(tfin As Double) As Double


Dim i As Integer, k As Long, n As Integer, l As Double
Dim xi As Double, ii As Double
Dim correlbis(1 To 10) As Double

86
B.2 Pricer de CDO B IMPLMENTATION DES FONCTIONS

Dim taui(1 To 2, 1 To 10) As Double


Dim z As Double, s As Double, t As Double
Dim dejacalcule As Boolean, dejafloat As Double, dejarbpv As Double, ok As
Boolean
Const nb_simulations = 100000
initialise_TAUiMoins1
floatleg = 0#
rbpv = 0#
dejacalcule = False
l = 0#
For i = 1 To 10
correlbis(i) = Math.Sqr(1 - correl(i) * correl(i))
l = l + leverage(i) * (1 - recovery(i))
Next i
CALIBRAGE des DONNEES ; choix dune chelle une bonne fois pour toutes
k1 = k1 * l
k2 = k2 * l
For k = 1 To nb_simulations
z = Tout.gaussienne_reduite()
ok = False
For i = 1 To 10

calcul des temps de dfaut


xi = z * correl(i) + correlbis(i) * Tout.gaussienne_reduite()
taui(2, i) = TAUiMoins1(i, Tout.N1(xi))
taui(1, i) = i
If taui(2, i) <= tfin Then ok = True
Next i
If Not ok And dejacalcule Then GoTo dejacalcul
trier taui par ordre croissant
floatleg
s = 0#
For i = 1 To 10
If (taui(2, i) <= tfin) Then
If i = 1 Then
s = s + Math.Exp(-Tout.r * taui(2, i)) * rembourser(i, taui)
Else
s = s + Math.Exp(-Tout.r * taui(2, i)) * (rembourser(i, taui) - rembourser(i - 1,
taui))
End If
Else
Exit For
End If
Next i
If Not ok Then dejafloat = s
fixedleg

87
B.2 Pricer de CDO B IMPLMENTATION DES FONCTIONS

t = 0#
n = Int(tfin * 4)
For i = 1 To n i designe cette fois le ieme intervalle de temps
ii = CDbl(i)
t = t + Math.Exp(-Tout.r * ii / 4) * ((k2 - k1) / 4 - evaluer_loss(taui, (ii - 1#)
/ 4#, ii / 4#))
Next i
t = t + Math.Exp(-Tout.r * tfin) * ((k2 - k1) * (tfin - CDbl(n) / 4#) - eva-
luer_loss(taui, CDbl(n) / 4#, tfin))
If Not ok Then
dejarbpv = t
dejacalcule = True
End If
dejacalcul :
floatleg = floatleg + IIf(ok, s, dejafloat)
rbpv = rbpv + IIf(ok, t, dejarbpv)
Next k
floatleg = floatleg / nb_simulations
rbpv = rbpv / nb_simulations
calculer_spread_montecarlo = floatleg / rbpv
End Function
Private Function rembourser(i As Integer, taui() As Double) As Double
Dim k As Integer, l As Double
For k = 1 To i
l = l + leverage(taui(1, k)) * (1 - recovery(taui(1, k)))
Next k
rembourser = plus(l - k1) - plus(l - k2)
End Function

Private Function evaluer_loss(ByRef taui() As Double, deb As Double, fin As


Double) As Double
Dim i As Integer, l As Double, ltranche As Double, lasti As Integer
lasti = 0
l = 0#
ltranche = 0#
For i = 1 To 10
If taui(2, i) < deb Then
l = l + leverage(taui(1, i)) * (1 - recovery(taui(1, i)))
lasti = i
ElseIf taui(2, i) >= deb And taui(2, i) < fin Then
lasti = i
If i > 1 Then sinon il y a l = 0 !
ltranche = ltranche + (taui(2, i) - maxi(taui(2, i - 1), deb)) * (plus(l - k1) - plus(l
- k2))
End If
l = l + leverage(taui(1, i)) * (1 - recovery(taui(1, i)))

88
B.2 Pricer de CDO B IMPLMENTATION DES FONCTIONS

ElseIf taui(2, i) >= fin Then


Exit For
End If
Next i
If lasti >= 1 Then sinon il y a l = 0 !
ltranche = ltranche + (fin - maxi(taui(2, lasti), deb)) * (plus(l - k1) - plus(l - k2))
End If
evaluer_loss = ltranche
End Function

Public Sub initialise_TAUiMoins1()


Dim i As Integer, k As Integer
For i = 1 To 10
pi(i, 0) = 1
For k = 1 To 10
pi(i, k) = pi(i, k - 1) * Math.Exp(-lambdas(i, k))
Next k
Next i
End Sub
Private Function TAUiMoins1(ByVal i As Integer, ByVal x As Double) trouver
T tel que P(Tau <= T) = x
Dim k As Integer
For k = 1 To 10
If x < (1 - pi(i, k)) Then
TAUiMoins1 = k - 1 - 1 / lambdas(i, k) * Math.Log((1 - x) / pi(i, k - 1))
Exit Function
End If
Next k
TAUiMoins1 = 11
End Function
Public Function proba(ByVal i As Integer, ByVal t As Double) As Double
Dim j As Integer
j = Int(t)
If j < 10 Then
proba = 1 - pi(i, j) * Math.Exp(-lambdas(i, j + 1) * (t - j))
Else
proba = 1 - pi(i, j)
End If
End Function

Public Function proba_condition(ByVal i As Integer, ByVal t As Double, ByVal


z As Double) As Double
Dim rho As Double
rho = correl(i)
proba_condition = Tout.N1((Tout.N1moins1(proba(i, t)) - rho * z) / Math.Sqr(1
- rho * rho))

89
B.2 Pricer de CDO B IMPLMENTATION DES FONCTIONS

End Function
Private Sub effacer(ByRef temp() As Double, ByVal grandN As Integer)
Dim i As Integer
For i = 0 To grandN
temp(0, i) = 0#
temp(1, i) = 0#
Next i
End Sub
Private Function leppcm() As Double
Dim retour As Double, i As Integer
retour = leverage(1) * (1 - recovery(1))
For i = 2 To 10
retour = ppcm(retour, leverage(i) * (1 - recovery(i)))
Next i
leppcm = retour
End Function

Public Function grandF(a As Double, b As Double, k As Double) As Double


renvoie integr(x^a-1.(1-x)^b-1) ,sur [0-k]/integr(0-1)
If k = 1 Then
grandF = 1
ElseIf k = 0 Then
grandF = 0
ElseIf a > 15 Then
grandF = 0.001
ElseIf b > 15 Then
grandF = 1
Else
grandF = Application.WorksheetFunction.BetaDist(k, a, b)
End If
End Function
Public Function betta(a As Double, b As Double) As Double
renvoie integr(x^a-1.(1-x)^b-1) sur [0-1]
If a > 10 Or b > 10 Then
betta = 0#
Else
betta = gamma(a) * gamma(b) / gamma(a + b)
End If
End Function

Public Function gamma(x As Double) As Double


gamma = Math.Exp(Application.WorksheetFunction.GammaLn(x))
End Function

90
B.3 Interpolations B IMPLMENTATION DES FONCTIONS

B.3 Interpolations
Notre logiciel a t crit en C# et cest donc dans ce langage que lon crit toutes
nos interpolations. Encore une fois, le code est essentiellement fait de boucles et de
petites conditions. Il est donc aisment transposable dans nimporte quel langage.
Toutes nos fonction dinterpolation ont la mme signature : elles prennent en en-
tre deux tableaux de nombres rels, les abscisses et ordonnes des points interpoler.
Le rsultat est un tableau de 101 rels, dcrivant les ordonnes de la fonction din-
terpolation dont les abscisses sont distribues rgulirement entre la premire et la
dernire abscisse.
Ce choix de 101 nest pas anodin : nous donnons 0 et 1 en premire et dernire
abscisses et les abscisses dinterpolation sont donc tous les 0.01.
Enfin, la convolution, lintgrale et Bzier utilisent des fonctions communes : dis-
tance() qui mesure la distance (somme des carrs des diffrences) entre les points
dentre par lesquels on doit passer, et les points de linterpolation ; il y a aussi la
fonction de modification locale de points cls crant ces diffrentes interpolation.

B.3.1 Stefen

public static double[] interpol_steffen2(double[] abs_depart, double[] ord_depart)


// aux extrmits : choix dune 2nd degr C1
{
double[] fonction = new double[101] ;
int n = abs_depart.Length ;
double[,] coeffs = new double[n - 1, 4] ; // ax^3+bx^2++cx+d pour 1 n-3, sinon
ax^2+bx+c pour 0 et n-2
double[] pentes = new double[n] ; // pente en xi. 0 et n-1 ne sont pas remplis
// calcul des pentes en chaque point
for (int i = 1 ; i < (n - 1) ; i++)
{
double si = (ord_depart[i+1]-ord_depart[i])/(abs_depart[i+1]-abs_depart[i]) ;
double simoins1 = (ord_depart[i]-ord_depart[i-1])/(abs_depart[i]-abs_depart[i-
1]) ;
double hi = abs_depart[i + 1] - abs_depart[i] ;
double himoins1 = abs_depart[i] - abs_depart[i - 1] ;
double pi = (simoins1 * hi + si * himoins1) / (himoins1 + hi) ;
if (si * simoins1 <= 0) // signe oppos
pentes[i] = 0.0 ;
else if (Math.Abs(pi) > (2 * Math.Min(Math.Abs(simoins1), Math.Abs(si))))
pentes[i] = 2 * Math.Min(Math.Abs(simoins1), Math.Abs(si)) * ((si > 0) ? 1.0 :
-1.0) ;
else
pentes[i] = pi ;
}
// calcul des coeffs

91
B.3 Interpolations B IMPLMENTATION DES FONCTIONS

// en 0
double deltax = abs_depart[0] - abs_depart[1] ;
coeffs[0, 0] = (ord_depart[0] - ord_depart[1] - deltax * pentes[1]) / (deltax *
deltax) ;
coeffs[0, 1] = 2.0 * coeffs[0, 0] * deltax + pentes[1] ;
coeffs[0, 2] = ord_depart[0] ;
for (int i = 1 ; i < (n - 2) ; i++)
{
deltax = abs_depart[i + 1] - abs_depart[i] ;
double pent = (ord_depart[i + 1] - ord_depart[i]) / deltax ;
coeffs[i, 0] = (pentes[i] + pentes[i + 1] - 2.0 * pent) / (deltax * deltax) ;
coeffs[i, 1] = (3.0 * pent - 2.0 * pentes[i] - pentes[i + 1]) / deltax ;
coeffs[i, 2] = pentes[i] ;
coeffs[i, 3] = ord_depart[i] ;
}
// en n-2
deltax = abs_depart[n - 1] - abs_depart[n - 2] ;
coeffs[n - 2, 0] = (ord_depart[n - 1] - ord_depart[n - 2] - deltax * pentes[n - 2]) /
(deltax * deltax) ;
coeffs[n - 2, 1] = pentes[n - 2] ;
coeffs[n - 2, 2] = ord_depart[n - 2] ;
// calcul final : utilisation des coeffs calculs plus tt
int ind = 0 ;
for (int i = 0 ; i < 101 ; i++)
{
double x = .01 * (double)(i) ;
if (x > abs_depart[ind + 1])
ind++ ;
double xx = x - abs_depart[ind] ;
if (ind == 0 || ind == (n - 2))
fonction[i] = coeffs[ind, 0] * xx * xx + coeffs[ind, 1] * xx + coeffs[ind, 2] ;
else
fonction[i] = coeffs[ind, 0] * xx * xx * xx + coeffs[ind, 1] * xx * xx + coeffs[ind,
2] * xx + coeffs[ind, 3] ;
}
return fonction ;
}

B.3.2 Exponentielle

// utilise le calcul des pentes de steffen en les points dentre


public static double[] interpol_expon(double[] abs_depart, double[] ord_depart)
{
double[] fonction = new double[101] ;
int n = abs_depart.Length ;

92
B.3 Interpolations B IMPLMENTATION DES FONCTIONS

double[] pentes = new double[n] ; // pente en xi. 0 et n-1 sont remplis aprs
double[,] coeffs = new double[n - 1, 4] ; // ax^3+bx^2++cx+d pour 1 n-3, sinon
ax^2+bx+c pour 0 et n-2
// calcul des pentes en chaque point
for (int i = 1 ; i < (n - 1) ; i++)
{
double si = (ord_depart[i+1]-ord_depart[i])/(abs_depart[i+1]-abs_depart[i]) ;
double simoins1 = (ord_depart[i]-ord_depart[i-1])/(abs_depart[i]-abs_depart[i -
1]) ;
double hi = abs_depart[i + 1] - abs_depart[i] ;
double himoins1 = abs_depart[i] - abs_depart[i - 1] ;
double pi = (simoins1 * hi + si * himoins1) / (himoins1 + hi) ;
if (si * simoins1 <= 0) // signe oppos
pentes[i] = 0.0 ;
else if (Math.Abs(pi) > (2 * Math.Min(Math.Abs(simoins1), Math.Abs(si))))
pentes[i] = 2 * Math.Min(Math.Abs(simoins1), Math.Abs(si)) * ((si > 0) ? 1.0 :
-1.0) ;
else
pentes[i] = pi ;
}
double deltax ;
// calcul des coeffs
for (int i = 1 ; i < (n - 2) ; i++)
{
deltax = abs_depart[i + 1] - abs_depart[i] ;
double pent = (ord_depart[i + 1] - ord_depart[i]) / deltax ;
coeffs[i, 0] = (pentes[i] + pentes[i + 1] - 2.0 * pent) / (deltax * deltax) ;
coeffs[i, 1] = (3.0 * pent - 2.0 * pentes[i] - pentes[i + 1]) / deltax ;
coeffs[i, 2] = pentes[i] ;
coeffs[i, 3] = ord_depart[i] ;
}
// calcul des pentes en 0 et en n-1
// en 0
deltax = abs_depart[0] - abs_depart[1] ;
double a = (ord_depart[0] - ord_depart[1] - deltax * pentes[1]) / (deltax * deltax) ;
pentes[0] = 2.0 * a * deltax + pentes[1] ;
// en n-1
deltax = abs_depart[n - 1] - abs_depart[n - 2] ;
a = (ord_depart[n - 1] - ord_depart[n - 2] - deltax * pentes[n - 2]) / (deltax *
deltax) ;
pentes[n - 1] = pentes[n - 2] + 2 * a * deltax ;

// calcul final : utilisation des coeffs calculs plus tt


int ind = 0 ;
for (int i = 0 ; i < 100 ; i++)
{

93
B.3 Interpolations B IMPLMENTATION DES FONCTIONS

double x = .01 * (double)(i) ;


if (x > abs_depart[ind + 1])
ind++ ;
double xx = x - abs_depart[ind] ;
if (ind != 0 && ind != (n - 2))
{
double[] tt = { ord_depart[ind], pentes[ind], coeffs[ind, 1] / 2 } ;
double[] qq ={ ord_depart[ind + 1], pentes[ind + 1], coeffs[ind+1, 1] / 2} ;
fonction[i] = f(abs_depart[ind], abs_depart[ind + 1], x, tt, qq) ;
}
else if (ind == 0)
{
double[] tt = { ord_depart[ind], pentes[ind] } ;
double[] qq ={ ord_depart[ind + 1], pentes[ind + 1], coeffs[ind + 1, 1] / 2 } ;
fonction[i] = f(abs_depart[ind], abs_depart[ind + 1], x, tt, qq) ;
}
else
{
double[] tt = { ord_depart[ind], pentes[ind], coeffs[ind, 1] / 2 } ;
double[] qq ={ ord_depart[ind + 1], pentes[ind] } ;
fonction[i] = f(abs_depart[ind], abs_depart[ind + 1], x, tt, qq) ;
}
}
fonction[100] = ord_depart[n - 1] ;
return fonction ;
}

Fonctions annexes linterpolation exponentielle

private static double ff(double x) // en 0 : vaut 0 et toutes les drives nulles.


idem en 1 pour les drives, et vaut 1
{
double y = Math.Tan(.5 * Math.PI * x) ;
if (y == 0.0)
return 0.0 ;
else
return Math.Exp(-Math.Exp(-y) / y) ;
}
private static double f(double x) // pour symtriser ff
{
return (.5 + .5 * (ff(x) - ff(1 - x))) ;
}
public static double f(double a, double b, double x, double[] derivees_en_a, double[]
derivees_en_b)
{
double y = (x - a) ;

94
B.3 Interpolations B IMPLMENTATION DES FONCTIONS

double s1= 0.0 ;


double power = 1.0 ;
double factorielle = 1.0 ;
for (int i = 0 ; i < derivees_en_a.Length ; i++)
{
s1 += power * derivees_en_a[i] / factorielle ;
power *= y ;
factorielle *= (double)(i+1) ;
}
double s2 = 0.0 ;
double yy = (x - b) ;
power = 1.0 ; factorielle = 1.0 ;
for (int i = 0 ; i < derivees_en_b.Length ; i++)
{
s2 += power * derivees_en_b[i] / factorielle ;
power *= yy ;
factorielle *= (double)(i + 1) ;
}
double ff = f((x-a)/(b-a)) ;
return s1 * (1 - ff) + s2 * ff ;
}

B.3.3 Convolution

public static double[] interpol_convolution(double[] abs_depart, double[] ord_depart)


{
int n = abs_depart.Length ;
double[] ord_bis = new double[n] ;
Array.Copy(ord_depart, ord_bis, n) ;
double[] fonction = interpol_steffen2(abs_depart, ord_depart) ;
double[] result = convoler(fonction) ;
double erreur = distance(result, abs_depart, ord_depart) ;
Random r = new Random() ;
for (int i = 0 ; i < 5000 ; i++)
{
int indice = r.Next(n) ;
double last_val = ord_bis[indice] ;
modifier(ord_bis, indice, r) ;
fonction = interpol_steffen2(abs_depart, ord_bis) ;
result = convoler(fonction) ;
if (erreur < distance(result, abs_depart, ord_depart))
ord_bis[indice] = last_val ;
else
erreur = distance(result, abs_depart, ord_depart) ;

95
B.3 Interpolations B IMPLMENTATION DES FONCTIONS

}
return interpol_steffen2(abs_depart, ord_bis) ;
}
private static double[] convoler(double[] fonction)
{
double[] bis = new double[101] ;
for (int i = 0 ; i < 101 ; i++)
{
double s = 0.0 ;
double s_poids = 0.0 ;
for (int j = -3 ; j <= 3 ; j++)
{
double poids = f_convol(Math.Abs(j)) ;
if ((i + j) >= 0 && (i + j) < 101)
{
s_poids += poids ;
s += poids * fonction[i + j] ;
}
}
bis[i] = s / s_poids ;
}
return bis ;
}
private static double f_convol(int x)
{
if (x == 0)
return 1.0 ;
else if (x == 1)
return .7 ;
else if (x == 2)
return .3 ;
else if (x == 3)
return .1 ;
else
return 0.0 ;
}

B.3.4 Bzier

Nous dveloppons ici lalgorithme des courbes de tendance, non pas celui par
inversion de matrice. Linterpolation de Bzier ncessite dans un premier temps de

calculer tous les temps ti tels que x(ti ) = xi.


public static double[] interpol_bezier(double[] abs_depart, double[] ord_depart)

96
B.3 Interpolations B IMPLMENTATION DES FONCTIONS

{
int n = abs_depart.Length ;
double[] ord_bis = new double[n] ;
Array.Copy(ord_depart, ord_bis, n) ;
if (les_t == null)
les_t = calculer_t(abs_depart) ;
double[] fonction = bezier(abs_depart, ord_depart, les_t) ;
double erreur = distance(fonction, abs_depart, ord_depart) ;
Random r = new Random() ;
for (int i = 0 ; i < 2500 ; i++)
{
int indice = r.Next(n) ;
double last_val = ord_bis[indice] ;
modifier(ord_bis, indice, r) ;
fonction = bezier(abs_depart, ord_bis, les_t) ;
if (erreur < distance(fonction, abs_depart, ord_depart))
{
ord_bis[indice] = 2 * last_val - ord_bis[indice] ;
fonction = bezier(abs_depart, ord_bis, les_t) ;
if (erreur < distance(fonction, abs_depart, ord_depart))
ord_bis[indice] = last_val ;
else
erreur = distance(fonction, abs_depart, ord_depart) ;
}
else
erreur = distance(fonction, abs_depart, ord_depart) ;
}
return fonction ;
}
private static double[] bezier(double[] abs_depart, double[] ord_depart, double[]
les_t)
{
double[] result = new double[101] ;
int n = abs_depart.Length ;
result[0] = ord_depart[0] ;
result[100] = ord_depart[n - 1] ;
for (int i = 1 ; i < 100 ; i++)
{
double s = 0.0 ;
for (int k = 0 ; k < n ; k++)
s += MesMaths.ckn[n - 1][k] * ord_depart[k] * Math.Exp(k * Math.Log(les_t[i])
+ (n - 1 - k) * Math.Log(1 - les_t[i])) ;
result[i] = s ;
}
return result ;
}

97
B.3 Interpolations B IMPLMENTATION DES FONCTIONS

private static double[] calculer_t(double[] abs_depart) // calcule les ti tels que


abscisse courbe_bezier(t) = 0.01 * i
{
double[] les_t_finaux = new double[101] ;
les_t_finaux[0] = 0.0 ;
les_t_finaux[100] = 1.0 ;
double t = 0.0 ;
int i = 0 ;
while (i < 99)
{
double abscis = calcul_abs_bezier(t, abs_depart) ;
if (abscis > (((double)(i+1)) * .01))
{
i++ ;
les_t_finaux[i] = t ;
}
t += 0.001 ;
}
return les_t_finaux ;
}
private static double calcul_abs_bezier(double t, double[] abs_depart)
{
int n = abs_depart.Length ;
double s = 0.0 ;
for (int k = 0 ; k < n ; k++)
s += MesMaths.ckn[n - 1][k] * abs_depart[k] * Math.Exp(k * Math.Log(t) + (n
- 1 - k) * Math.Log(1 - t)) ;
return s ;
}

B.3.5 Intgrale
public static double[] interpol_integrale(double[] abs_depart, double[] ord_depart)
{
int n = abs_depart.Length ;
double[] abs_derivees = new double[n + 1] ;
double[] derivees = new double[n + 1] ;
abs_derivees[0] = 0.0 ; abs_derivees[n] = 1.0 ;
for (int i = 0 ; i < n - 1 ; i++)
{
abs_derivees[i + 1] = 0.5 * (abs_depart[i] + abs_depart[i + 1]) ;
derivees[i + 1] = (ord_depart[i + 1] - ord_depart[i]) / (abs_depart[i + 1] -
abs_depart[i]) ;
}
derivees[0] = derivees[1] ;

98
B.3 Interpolations B IMPLMENTATION DES FONCTIONS

derivees[n] = derivees[n - 1] ;
double[] fonction = interpo_integr(ord_depart, abs_derivees, derivees) ;
double erreur = distance(fonction, abs_depart, ord_depart) ;
Random r = new Random() ;
for (int i = 0 ; i < 2000 ; i++)
{
int indice = r.Next(n+1) ;
double last_val = derivees[indice] ;
modifier(derivees, indice, r) ;
fonction = interpo_integr(ord_depart, abs_derivees, derivees) ;
if (erreur < distance(fonction, abs_depart, ord_depart))
{
derivees[indice] = 2 * last_val - derivees[indice] ;
fonction = interpo_integr(ord_depart, abs_derivees, derivees) ;
if (erreur < distance(fonction, abs_depart, ord_depart))
derivees[indice] = last_val ;
else
erreur = distance(fonction, abs_depart, ord_depart) ;
}
else
erreur = distance(fonction, abs_depart, ord_depart) ;
}
return fonction ;
}
private static double[] interpo_integr(double[] ord_depart, double[] abs_derivees,
double[] derivees)
{
double[] fonc = interpol_steffen2(abs_derivees, derivees) ;
double[] fonction = new double[101] ;
fonction[0] = ord_depart[0] ;
for (int i = 1 ; i < 101 ; i++)
fonction[i] = fonction[i - 1] + .01 * fonc[i] ;
return fonction ;
}

99
TABLE DES FIGURES TABLE DES FIGURES

Table des figures


1 allure de la probabilit de dfaut donne par le modle de Merton, en
fonction du temps . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
2 Probabilit de dfaut donne par le modle Crdit Grade . . . . . . . 16
3 Comparaison entre les probabilits donnes par le modle de Merton
et la loi exponentielle . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
4 Fair spread en fonction de la corrlation . . . . . . . . . . . . . . . . . 19
5 Spread dun CDS en fonction de la probabilit de dfaut . . . . . . . . 20
6 y = xln(1 x) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
7 loi Beta pour diffrentes valeurs de a et b. Successivement (a, b) = (3,
10), (2, 3), (3, 2), (10, 3) . . . . . . . . . . . . . . . . . . . . . . . . . . 23
8 Spread sur tranchette, calcul par Marx. Des arbitrages sont possibles
aux alentours de 16% et 33%. . . . . . . . . . . . . . . . . . . . . . . . 29
9 en bleu : arbitrage local sur le spread ; en rouge : dcroissance locale
de la Market Law of Losses. . . . . . . . . . . . . . . . . . . . . . . . . 30
10 Probabilit de march donne par linterpolation linaire sur la corrlation 30
11 Fixed Leg en fonction de la corrlation . . . . . . . . . . . . . . . . . . 31
12 Premier terme : K. dQ(LdK T >K)
. . . . . . . . . . . . . . . . . . . . . . . 34
K
d
R K Q(L T , >x)
13 Second terme : dK . 0 dx . . . . . . . . . . . . . . . . . . . 35
14 drive du premier terme . . . . . . . . . . . . . . . . . . . . . . . . . 35
15 drive de la Float Leg . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
16 Ratio des drives . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
17 Corrlation implicite du march . . . . . . . . . . . . . . . . . . . . . 39
18 Courbe de la Float Leg . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
19 exemple dinterpolation . . . . . . . . . . . . . . . . . . . . . . . . . . 41
20 Environnement logiciel cr en C# . . . . . . . . . . . . . . . . . . . . 41
21 phnomne de Runge . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
22 Exemple de non monotonie de la parabole passant par A, B et C . . . 45
23 Diffrents cas considrer . . . . . . . . . . . . . . . . . . . . . . . . . 48
24 Exemple de fonction f vrifiant ces contraintes . . . . . . . . . . . . . . 49
25 Rsultat de linterpolation exponentielle . . . . . . . . . . . . . . . . . 50
26 Point dinflexion non dsir . . . . . . . . . . . . . . . . . . . . . . . . 51
27 Autre exemple de point dinflexion non dsir . . . . . . . . . . . . . . 51
28 A(0.5 ; 1) et B (0.5 ; 1) sur le premier graphe, et A(0.7, 1) et B(0.5 ; 2)
sur le second. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
29 Invariance graphique par changement de repre . . . . . . . . . . . . . 52
30 Exemple dinterpolation par Bzier trs russie . . . . . . . . . . . . . 56
31 Interpolation difficile, mais bonne courbe de tendance. . . . . . . . . . 57
32 Steffen et Bzier en vis vis . . . . . . . . . . . . . . . . . . . . . . . . 57
33 Comparaison Steffen - interpolation par convolution . . . . . . . . . . 59
34 Interpolation par intgrale . . . . . . . . . . . . . . . . . . . . . . . . . 61
35 Comparaison Steffen - Interpolation par intgrale . . . . . . . . . . . . 61
36 Interpolation linaire avant optimisation numrique . . . . . . . . . . . 65

100
TABLE DES FIGURES TABLE DES FIGURES

37 Interpolation linaire aprs optimisation numrique. Croissance comp-


te sur 1 suivant . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
38 Interpolation linaire aprs optimisation numrique. Croissance comp-
te sur 5 suivants . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
39 Interpolation linaire aprs optimisation numrique. Croissance comp-
te sur 10 suivants . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
40 Interpolation linaire aprs optimisation numrique. Croissance comp-
te sur 20 suivants . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
41 Interpol. de Steffen aprs optimisation numrique. Croissance compte
sur 10 suivants, norme 1 . . . . . . . . . . . . . . . . . . . . . . . . . . 67
42 Interpol. de Steffen aprs optimisation numrique. Croissance compte
sur 20 suivants, norme 1 . . . . . . . . . . . . . . . . . . . . . . . . . . 68
43 Interpol. de Steffen aprs optimisation numrique. Croissance compte
sur 10 suivants, norme 2 . . . . . . . . . . . . . . . . . . . . . . . . . . 68
44 Interpol. de Steffen aprs optimisation numrique. Croissance compte
sur 20 suivants, norme 2 . . . . . . . . . . . . . . . . . . . . . . . . . . 69
45 Comparaison entre linterpolation de Steffen (violet) et linterpolation
linaire (bleu) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
46 Comparaison entre linterpolation de Steffen (violet) et linterpolation
par convolution (vert) . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
47 Comparaison entre linterpolation de Bzier (marron) et linterpolation
linaire (bleu) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
48 Comparaison entre linterpolation de Steffen (cyan) et linterpolation
de Bzier (marron) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
49 Comparaison entre linterpolation par convolution (vert) et linterpo-
lation linaire (bleu) . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
50 Comparaison entre linterpolation exponentielle (orange) et linterpo-
lation linaire (bleu) . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
51 Comparaison entre linterpolation de Steffen (violet) et linterpolation
exponentielle (orange) . . . . . . . . . . . . . . . . . . . . . . . . . . . 72

101
TABLE DES FIGURES TABLE DES FIGURES

Bibliographie
[1] SG Credit Research Team. Pricing CDOs with a smile. Fvrier 2005.
[2] SG Credit Research Team. Bespoke CDO : latest Developments. Juillet 2006.
[3] SG Credit Research Team. Pricing and hedging correlation products. Juillet
2004.
[4] James Wood and Ed Parcell (Derivative Fitch). Wiping the smile off your base.
Juin 2007.
[5] SG Credit Research Team. Modlisation et valuation des produits drivs de
crdit. Dcembre 2007.
[6] M.Steffen (Astronomy and Astrophysics). A simple method for monotonic in-
terpolation in one dimension. Aot 1990.

102