Docstoc

BGM interest rate model

Document Sample
BGM interest rate model Powered By Docstoc
					    UNIVERSITÉ PARIS I – PANTHÉON-SORBONNE
                       M2 – Spécialité Recherche – MMMEF


                              Youssef MALIKI ALAOUI


                         Le modèle de taux d’intérêt BGM
                    Calibration et diffusion de la courbe de taux

   Intégration du modèle BGM dans le système d’information de pricing de la BNP AMS


Résumé : le modèle BGM présente l’avantage de prendre en input la courbe de taux
forward observable sur le marché pour se calibrer. Cela donne une plus grande justesse dans
le pricing de produits de base mais rend la calibration plus complexe. En effet, cela implique
un traitement sur les produits observés sur le marché comme les caps qui serviront à la
calibration de la volatilité des taux puis sur les swaption pour la calibration des corrélations
entre les forward et par conséquent, le modèle de marché permet de reproduire les bon prix
des ZC, caplets et swaption.
Pour sa dérivée on arrive, grâce à un changement de mesure répétitif sur l’ensemble des dates
de paiements des taux forward concernés, à diffuser toute la courbe de taux d’intérêt à chaque
pas. En effet, on ne rediffuse pas la courbe avant la date actuelle de diffusion mais juste les
taux forward futurs avec une équation de diffusion correspondant à une mesure donnée pour
chacun d’entre eux.


Rapport de stage présenté le 9 juillet 2008



Jury :
Mme Dominique GUEGAN                                                  M. Xavier MATHIEU
Professeure Paris1-Panthéon-Sorbonne                                  Head of analyste quant
UMR CNRS 8174 - MSE                                                   BNP AMS SIGMA



Université Paris 1- Panthéon Sorbonne
106-112 Boulevard de l’Hôpital
75013 PARIS


Période de stage : du 9mai 2007 au 31 janvier 2008

Lieu du stage : BNP AMS, 5 avenue Kléber 75116 PARIS
2
                                                        SOMMAIRE

REMERCIEMENTS .................................................................................................................. 5


INTRODUCTION...................................................................................................................... 6


PRESENTATION BNP & ENVIRONNEMENT DU STAGE ................................................. 7

   A  BNP Paribas Asset Management.................................................................................... 8
    1. Les activités d’une société de gestion ........................................................................ 8
    2. Structure de la société .............................................................................................. 10
   B Présentation de l’équipe ............................................................................................... 12
   C Contexte du stage ......................................................................................................... 12


REVUE HISTORIQUE DES MODELES DE TAUX............................................................. 14

   A  Modèle de Black -modèle de marché usuel- ................................................................ 15
   B  Modèles d’équilibre général ou partiel......................................................................... 15
    1. Modèle d’équilibre général ...................................................................................... 15
    2. Modèle d’équilibre partiel ........................................................................................ 15
   C Modèles basés sur l’AOA ............................................................................................ 18
    1. Cadre HJM ............................................................................................................... 18
    2. Modèle markovien.................................................................................................... 20
    3. Modèle de marché –Libor Market Modèle- ............................................................. 23


MODELE DE MARCHE BGM............................................................................................... 24

   A  DERIVATION DU MODELE :................................................................................... 25
       Modélisation :........................................................................................................... 25
       1.
       Changement de mesure : .......................................................................................... 25
       2.
   B CALIBRATION DU MODELE : ................................................................................ 26
    1. Calibration de la volatilité : ...................................................................................... 26
    2. Calibration de la corrélation ..................................................................................... 29
   C ALGORITHME DE MINIMISATION: ...................................................................... 31


SYSTEME INFORMATIQUE DE PRICING SI_PROJECT ................................................. 33

   A        Descriptif de SI_project ............................................................................................... 34
       1.     Les sous_jacents ....................................................................................................... 34
       2.     La diffusion .............................................................................................................. 35
       3.     les modeles ............................................................................................................... 36
       4.     les calibrateurs.......................................................................................................... 37
       5.     edml2.0 & interface payOff ..................................................................................... 37


                                                                                                                                          3
   B  Implémentation du modèle BGM................................................................................. 40
        Modèle de taux d’intérêt : entre terme structure et modèle de diffusion ................. 40
       1.
        Descriptif de la classe T_IR _model ........................................................................ 41
       2.
        implémentation du modele BGM ............................................................................. 43
       3.
   C Propriétés des modèles de taux dans un système de pricing ........................................ 45
    1. UNICITE DES COURBES DE TAUX D’INTERET lors de la création: ............... 45
    2. GESTION DES DOUBLONS DE MODELES lors de la diffusion : ...................... 46
    3. ORDONNANCEMENT DES MODELES à diffuser :............................................ 47
    4. INITIALISATION DE LA CORRELATION : ....................................................... 47
    5. GENERATION DES BROWNIENS :..................................................................... 48
    6. ACTUALISATION DES COUPONS : ................................................................... 49
    7. Numéraire :............................................................................................................... 49
   D Exemples et test de validité.......................................................................................... 49


CONCLUSION ........................................................................................................................ 52


ANNEXE ................................................................................................................................. 53

   A  Inventaire de Produits de taux d’intérêt ....................................................................... 53
        Définitions ................................................................................................................ 53
       1.
        Produits de taux d’intérêt Vanilles ........................................................................... 53
       2.
        Produits de taux d’intérêt complexes ....................................................................... 56
       3.
   B APPELS D’OFFRES SIGMA QUANT....................................................................... 63
    1. DIFFERENCE DE DATES : ................................................................................... 63
    2. STRATEGIE : .......................................................................................................... 64
    3. BACKTEST & ENVELOPPES ............................................................................... 67


BIBLIOGRAPHIE ................................................................................................................... 68




                                                                                                                                         4
                            REMERCIEMENTS


     Je remercie tout particulièrement M. Xavier MATHIEU pour son soutien moral et
professionnel tout au long de ce stage.

   Je remercie tous les membres de l’équipe Quant SIGMA dont M. guillaume
KOVARSIC pour leur esprit d’équipe et leur bonne humeur qui a facilité ma mission.

      Je remercie également tous les responsables et membres de l’équipe SIGMA de
m’avoir ouvert toutes les portes susceptibles de m’apprendre plus sur le fonctionnement
de la BNP et aussi pour leur participation active à mon intégration dans l’équipe.




                                                                                     5
                               INTRODUCTION

        Cette mission s’inscrit dans le cadre de mon stage de validation du master
MMMEF. Mon choix s’est porté sur l’analyse quantitative en banque qui reflète
parfaitement la formation théorique prodiguée par ce master.
        Ma mission au sein de l’équipe SIGMA de la BNP AMS a été tout d’abord
d’appréhender au mieux le fonctionnement général du système d’information (projet
SI_projet et shapeGenerator) utilisé par l’équipe Quant dans leurs valorisations
quotidiennes et générations d’enveloppes de fonds pour les structureurs et traders.
Ensuite, il a été question de traiter de la théorie mathématique du modèle de marché des
taux d’intérêt (BGM) pour l’implémenter dans le système SI_projet. Le but étant de
permettre une utilisation de ce modèle aussi bien pour la valorisation de produits de taux
d’intérêt que pour une utilisation conjointe entre tous les modèles existant des autres
assets. Enfin, j’ai participé à des appels d’offres de l’équipe Quant en provenance des
traders et structureurs tels que l’implémentation de stratégies d’investissement, backtest,
génération de calendrier…
        Ce rapport se présente de la manière suivante :
            o Une première section sera dédiée à la présentation de l’entreprise, de
                l’équipe et de l’environnement technique du stage.
            o Dans la deuxième partie, on présentera une revue historique et critique
                des modèles de taux d’intérêt
            o Ensuite, la troisième partie sera réservée à la théorie mathématique du
                modèle BGM ; sa diffusion et sa calibration.
            o La quatrième partie concernera l’implémentation de ce modèle dans le
                système d’information.
            o Enfin, l’annexe traitera, sans rentrer dans les détails, les appels d’offres
                auxquels j’ai participé au sein de l’équipe Quant BNP ainsi qu’un
                inventaire de produits de taux d’intérêt.




                                                                                         6
PRESENTATION BNP & ENVIRONNEMENT DU STAGE




                                            7
A BNP Paribas Asset Management
      BNP PAM est un gérant d’actifs majeur en Europe. Il représente à lui seul 285
milliards d’euros d’actifs sous gestion -dont la moitié gérée pour le compte
d’investisseurs institutionnels- et 1 450 personnes au service de clients dans 66 pays
(chiffres au 31 décembre 2005).

 1.    Les activités d’une société de gestion

                a.      En bref…

      La société de gestion en tant qu’entreprise d’investissement se définit au travers de
portefeuilles individuels et collectifs –les Organisme de Placement Commun en Valeurs
Mobilières (OPCVM) et mandats- qu’elle représente. Ces portefeuilles, constitués de
valeurs mobilières, sont gérés par des professionnels et détenus par des investisseurs
particuliers ou institutionnels. En outre la société de gestion a obligation de moyens
mais pas de résultats et n’est autorisée à gérer que pour compte de tiers.

                b.      Les missions

               Les missions de la société de gestion sont les suivantes :
               - assurer la gestion financière (acheter les titres, respecter les ratios de
         compliance…) ;
               - assurer la gestion juridique (c’est-à-dire assurer la vie sociale des
         OPCVM, les relations avec l’AMF, la veille réglementaire…) ;
               - assurer la gestion comptable (calculer les valeurs liquidatives, produire
         les reportings réglementaires…).

                Il est important de mentionner que la société de gestion peut déléguer
         chacune de ses missions, mais elle ne peut en aucun cas les déléguer toutes en
         même temps ; si la société reste en coquille vide plus d’un an, l’AMF procède
         à sa liquidation.

                c.      La gestion pour compte de tiers

               Concrètement, l’asset manager (littéralement le gestionnaire d’actifs ou
         la société de gestion) est la personne physique ou morale à laquelle les
         particuliers et les entreprises peuvent confier de l'argent -soit en achetant des
         parts ou des actions d’OPCVM, soit en contractant un mandat- afin que celui-
         ci soit géré ; d'où le nom de « gestion pour compte de tiers ».

               La gestion pour compte de tiers se scinde alors en deux parties : la
         gestion collective et la gestion sous mandat.

                               1) La gestion collective




                                                                                         8
       Représentant environ 60% des encours, les principaux produits
   proposés par la gestion collective sont les OPCVM. Ils sont généralement
   destinés à de nombreux porteurs qui les achètent par parts ou par actions.
   Le fonctionnement de base est résumé ci-dessous :




                   2) La gestion sous mandat

         Un mandat de gestion n'a pour sa part pas de matérialisation, il
   s’agit tout simplement d’un contrat entre la société de gestion et
   l’investisseur. Un mandat de gestion ne s'adresse donc qu'à un seul client.

         Au final, les titres acquis sur les marchés par les gérants de la
   société de gestion constituent ce que l’on appelle le portefeuille de
   l’OPCVM ou du mandat ; d’où l’appellation juridique de « société de
   gestion de portefeuille ».

     d.     Quels liens entre sociétés de gestion et investisseurs ?

      Dans le cas de la gestion collective, la souscription vaut adhésion au
contrat de gestion ; elle est matérialisée par le prospectus. Remis
obligatoirement à tout investisseur préalablement à la souscription, le
prospectus présente les informations fondamentales de l’OPCVM de manière
claire, synthétique et facile à comprendre.
      Dans le cas de la gestion individuelle il y a signature d'un contrat
synallagmatique (qui comporte obligation réciproque entre les parties).

     e.     Pourquoi des OPCVM ?

      Les OPCVM sont des produits financiers qui présentent deux
caractéristiques fondamentales. Ils permettent
      - d’une part de diviser les risques en détenant une partie d'un
portefeuille de valeurs mobilières (actions, obligations…) commun à
plusieurs investisseurs ;


                                                                            9
             - d’autre part d'obtenir à moindre frais -en partageant le prix- les
        bénéfices d'un professionnel.

             f.     Les différents types d’OPCVM

             Il existe deux types d’OPCVM : les SICAV (Société d’Investissement à
        Capital Variable) et les FCP (Fonds Communs de Placement).


2.   Structure de la société
              De part son développement de compétences de gestions ciblées
        (approche multi-spécialiste, par « boutique »), BNP PAM parvient à couvrir
        l’ensemble des classes d’actifs :
              - les taux européens (BNP PAM) ;
              - les taux internationaux avec Fischer Francis Trees and Watts (FFTW)
              - les actions (BNP PAM) ;
              - les investissements structurés et indiciels (BNP PAM) ;
              - les stratégies alternatives avec Fauchier Partners et Cooper Neff ;
              - la gestion des devises avec Overlay Asset Management (OAM) ;
              - le multimanagement avec FundQuest ;
              - l’allocation d’actifs (BNP PAM).




                                                                                10
 Tableau 3 - Organigramme de BNP Paribas Asset Management

    On notera la mise en place d’une structure de holding (BNP PAM Group).
    Par ailleurs les sigles BPF et BPI correspondent respectivement à la
Banque Privée France et à la Banque Privée Internationale.



                                                                       11
           Enfin il faut savoir que les New Markets regroupent les pays suivants :
      Argentine, Brésil, Chine, Corée du Sud, Inde et Maroc.

            BNP PAM est également fortement engagée dans l’investissement
      responsable. Ce thème clé est décliné sous une gamme de fonds et de mandats de
      gestion (actions et obligations) grâce à une équipe dédiée à l’analyse extra-
      financière.
            Ses équipes de gestion spécialisées sont présentes dans les principaux
      centres financiers mondiaux : Paris, Londres, New York, Tokyo et Hong Kong.

           Pour conclure, sa SICAV Parvest, l’un des plus importants fonds
      luxembourgeois, propose aux clients plus de 60 compartiments enregistrés dans
      24 pays et couvrant toutes les classes d’actifs.

B Présentation de l’équipe

    L’équipe sur paris est composée de 3 analystes quantitatifs
       M. xavier MATHIEU : chef d’equipe
       M. guillaume KOVARSIC et M. antony MC BRIDE junior à l’équipe quant

    Rôles de l’équipe
           Valorisations de l’ensemble des structures OTC de SI
               o Contrôle quotidien des prix
               o Plus de 100 swaps exotiques
               o Plusieurs centaines de swaps/dérivés vanilles
               o Sous-jacents actions, indices, taux, change, fonds, paniers, etc.

            Support à la structuration de nouveaux pay-offs :
               o Backtesting des pay-offs, études probabilistes
               o Modélisation et pricing des structures
               o Suivi des différents paramètres de marché (volatilité, corrélations.)
               o Réflexion sur les structures adéquates par rapport aux spécificités
                  de marché (volatilité, etc.)

            Support quant pour la gestion (garantie / indicielle) : études diverses
               o Benchmarking / réplication des gestions à coussins par des modèles
                  systématiques
               o Évaluation de stratégies d’arbitrage
               o Optimisation de stratégies de réplication d’indices, etc.

C Contexte du stage
       Si_project est le principal outil informatique de l’équipe d’analyse quantitative
 gestion structurée. Son développement actuel vise au remplacement de l’ancien outil
 informatique shapeGenerator.
       L’intérêt pour le développement de ce projet naît d’une triple volonté :
           o celle d’augmenter la souplesse et la modularité du programme en vue de
               simplifier l’enrichissement en nouveaux modèles, en particulier pour les
               taux et la prise en compte de l’hybridité.


                                                                                     12
         o celle de clarifier la structure pour corriger certains bugs et simplifier
           l’écriture de certains payoffs.
         o celle d’intégrer de nouvelles fonctionnalités, notamment concernant les
           enveloppes de portefeuille ou les statistiques de chaque coupon d’un
           produit exotique.

     Le projet doit être capable de réaliser différentes tâches :
        o Calibration des différents modèles
        o Pricing de produits exotiques
        o Calcul de trajectoire de produits exotiques, de portefeuilles ou de
            stratégies actives
        o Calcul d’enveloppes probabilistes et production des statistiques associées
            pour les produits exotiques, les portefeuilles ou les stratégies actives.

      Si_project apporte d’importantes améliorations par rapport à l’ancienne version
du projet, shapeGenerator. La principale concerne la souplesse de l’architecture qui
devient adaptée à la prise en compte de nouveaux types de sous-jacents et permet le
travail sur produits hybrides.
      Si_project utilise un langage générique de description des payoffs (EDML,
développement in-house). Un fichier au format XML permet la transmission des
données au programme. Ainsi, les informations indispensables à la réalisation de la
tâche, y compris la description du produit financier sur lequel on désire travailler,
peuvent être lues par le programme. Ce processus est très utile et efficace puisque le
programme C++ n’a pas besoin d’être modifié quel que soit le produit et la tâche
considérés ; il suffit d’écrire le fichier d’input correspondant en utilisant la syntaxe
prédéfinie.




                                                                                     13
REVUE HISTORIQUE DES MODELES DE TAUX




                                       14
A Modèle de Black -modèle de marché usuel-
        L’habitude de traiter avec ce modèle les options sur les différents actifs de
  marché et surtout la facilité de mise ne place de couverture expliquent l’essor qu’a
  connu ce modèle dans la classe d’actif des taux d’intérêt. Ainsi, une grande majorité
  des prix de produits de taux cotés sur le marché sont fait avec ce modèle. Ceci est
  parmi les raisons qui motivent le choix du modèle BGM, comme nous
  l’expliquerons en détails dans ce rapport. En effet, il s’adapte bien avec les
  valorisations par B&S des caps et swaptions.

       Le modèle de black consiste à calculer le payoff espéré de l’option en
  supposant :
       •         La lognormalité des taux d’intérêt
       •         l’espérance du ss-jacent à la date T est égale à la valeur de son prix
  forward à l’instant 0.

        Cependant, malgré une large utilisation sur le marché, le modèle présente
  quelques limites flagrantes telles que la constance de la volatilité du ss-jacent et
  l’absence de conjoncture quand à l’évolution stochastique de la courbe des taux.

B Modèles d’équilibre général ou partiel

 1.     Modèle d’équilibre général
            Le but est d’expliquer le prix des actifs comme résultant d’un problème
      d’optimisation des agents qui peuplent l’économie. L’équilibre est dit général
      lorsqu’il s’applique aussi bien aux consommateurs qu’aux producteurs. Ces
      modèles nécessitent de faire des hypothèses draconiennes pour définir l’économie
      dans laquelle on se trouve (action des entreprises en terme de production, goût des
      individus en terme de consommation…).

 2.     Modèle d’équilibre partiel
           On pourrait l’appeler « modèle à variable d’état » ou « modèle à
      facteurs ».

            Nous entendons par variable d’état, un processus d’Ito suivant une équation
      différentielle stochastique du type :
                  dXt=b(t,Xt)dt+sigma(t,Xt)dWt réalisant les conditions suivante :
                  b et sigma sont des fonctions continues et K-Lipchitzienne
                  X0 appartient à L2 et est indépendante de Wt.
            Ceci nous assure une solution unique et markovienne.

            Concernant l’équilibre partiel, il a été montré en effet (Duffie et Kan) que
      toute dynamique raisonnable postulée pour les variables d’état peut être obtenue
      dans le cadre d’un modèle d’équilibre, à la seule différence qu’on s’intéresse, dans
      notre cas ici par exemple, aux variables appartenant à la sphère financière qui est



                                                                                       15
déconnecté de l’économie réelle. Le modèle CIR exemplifie bien cette catégorie.
En effet, Le taux court r(t) d’équilibre est obtenu linéairement par rapport à un
processus Y(t) censé représenté l’état de la technologie caractérisant l’économie à
l’instant t.

          a.     Explication :
          Le modèle est une explication en temps continue d’une économie
       compétitive.

            Hypothèse :

            il existe un seul bien physique qui peut être alloué soit à la
       consommation soit à l’investissement. Les valeurs sont exprimées en
       termes d’unités de ce bien.

            Le secteur industriel est représenté pour n firmes compétitives qui
       produisent toutes le même bien, mais qui se distingue par le type de
       processus de production dans lequel chacune investit.

               Il existe une seule variable d’état exogène Y qui représente l’état de
       la technologie et intervient sur le processus de production.
        d (Y (t )) = (a * Y (t ) + b)dt + c * Y (t )dW (t )

               Les n processus de production notés η j pour j=1…n vérifient :
        d (η j (t ))
                        = α j Y (t )dt + g j Y (t )dW (t ) associé à chaque firme j.
         η j (t )

             Il existe un marché où tous les agents économiques peuvent
       instantanément emprunter et prêter au taux d’intérêt court r(t).

            Le marché est sans friction : les coûts de transaction, taxes et impôts
       sont nuls. L’accès à l’information est identique pour tous. Les titres
       financiers sont parfaitement divisibles. Les transactions s’effectuent sur le
       marché en continu. Les achats et ventes à découvert sont autorisés.

           L’économie est composée d’individus, dont les préférences tiennent
       comptes des opportunités de production et de l’état de la technologie.

             Au court de sa vie chaque individu cherche à maximiser l’espérance
       de sa fonction d’utilité U :
                    T                              T
       max Et ( ∫ U ( s, C ( s ))ds ) = max Et ( ∫ e − ρt ln(C ( s ))ds )   ,   C(s)   flux   de
                    t                              t
       consommation

             Chaque individu détermine la proportion de sa richesse allouée à la
       consommation courante et celle allouée à la consommation future en tenant
       compte des opportunités d’investissement. C'est-à-dire, si on admet que la
       richesse totale de l’individu en t est R(t). Celui-ci répartit R(t) entre sa


                                                                                              16
        consommation C(t), un montant a j (t ) R (t ) investi dans le jème processus de
        production et le reste dans le taux court r(t)


                Ainsi, le problème est :
                         T
                max Et ( ∫ e − ρs ln(C ( s ))ds ) ssc la contrainte de budget
                         t
          n            dη j (t )                               n                             n                  
dR(t ) = ∑ a j R(t )             − C (t )dt + r (t )( R(t ) − ∑ a j R(t ) − C (t )  R(t ) − ∑ a j R(t ) − C (t ) dt
         j =1           η j (t )                              j =1                          j =1                

            à l’équilibre, il existe une relation linéaire entre le taux court r(t) et la
        variable d’état Y(t).
            En pratique, ce type de modèle n’est pas compatible avec la courbe
        observée au comptant mais certains utilisateurs tentent une calibration aux
        données de marché, ce qui ne donne pas forcement des résultats
        convaincants. Surtout si le modèle n’arrive pas à reproduire le prix
        d’obligation sur lesquelles il s’est callé !

              b.        Simplification :

                d (r ) = m(r )dt + s (r )dw(t ) le processus risque-neutre du taux cour

                                   1) modèle de rendleman et Bartter

                      m( r ) = µ * r
                      s(r ) = σ * r )
                      Le taux court suit un mouvement géométrique.
                      Ce modèle ne prend pas en compte le phénomène de retour à la
                moyenne !

                                   2) modèle de vasicek

                       m(r ) = a (b − r )
                       s (r ) = σ )
                      Ce modèle prend en compte le phénomène de retour à la
                moyenne puisque le taux court est poussé vers b à un rythme définit par
                a.
                         P (t , T ) = A(t , T )e − B ( t ,T ) r (t )
                                                         1 − e − a (T − t )
                       avec               B (t , T ) =                      ,
                                                               a
                                                                       σ2                 
                                        ( B (t , T ) − T + t )(a 2 b −    )             2 
                                                                         2 − σ B (t , T ) 
                                                                              2
                       A(t , T ) = exp                     2
                                                         a                     4a         
                                       
                                                                                          
                                                                                           
                       Cette forme a l’avantage de pouvoir reproduire une croissance
                des taux, une décroissance mais aussi une légère « bosse ».


                                                                                                        17
                                      3) modèle de Cox-Ingersoll-Ross

                                       m(r ) = a (b − r )
                                       s(r ) = σ * r )

                                    L’avantage de ce modèle réside dans le fait qu’il évite
                            au taux court de tomber dans des cas négatifs. En effet, son
                            écart type est proportionnel à la racine carrée de r(t). Par
                            conséquent, lorsque le taux court diminue, son écart type fait de
                            même et à la limite lorsque ce taux devient nul, le terme
                            stochastique devient nul aussi et il reste un drift positif qui fait
                            que les taux repartent vers les valeurs positives.

                           L’évaluation des actifs de taux d’intérêt dans ce type de modèle
                  se fait en trois étapes :
                           • générer une courbe de taux théorique à partir d’un modèle à
                  variable d’état exogène
                           • caller le modèle sur les prix du marché pour générer les
                  valeurs des paramètres
                           • évaluer les actifs en utilisant ces paramètres.


C Modèles basés sur l’AOA
       Ces modèles priment aux yeux des utilisateurs car ils sont compatibles avec la
courbe de ZC au comptant. C'est-à-dire que ces modèles prennent la courbe initiale en
input alors que pour les modèles d’équilibre, la courbe ZC représente leur output. C’est
en effet, la raison pour laquelle on travaille sur les taux forward instantanés, ainsi on
utilise les taux spot au comptant comme donnée de marché en input.

 1.     Cadre HJM
       (Heath, Jarrow et Morton – 1992)

            En partant de la courbe au comptant observée sur le marché, l’idée consiste à
      assimiler le sous-jacent à l’entière courbe des taux, dont la dynamique repose sur
      les taux ZC ou les taux forward instantanés.


           On a :

            dB (t , T )
                         = µ (t , T )dt + 〈σ (t , T ).dW P (t )〉
             B (t , T )
                     σ (t , T ) = (σ 1 (t , T ),..., σ n (t , T ))
           avec
                     W (t ) = (Wi (t )) i =1,..., n Sous la proba histo

           Sous la proba Q risque neutre (conséquence de l’AOA), on a :


                                                                                              18
           dB (t , T )
                       = r (t )dt + 〈σ (t , T ).d ¨W Q (t )〉
            B (t , T )

       La solution de cette EDS est (lemme d’Itô dln(B(t,T) puis division par B(t,t))
       :
               B (0, T )     t                                         1
                                                                          t
                                                                                                         
                         exp  ∫ 〈σ ( s, T ) − σ ( s, t ), dW Q ( s )〉 − ∫ ( σ ( s, T ) − σ ( s, t ) )ds 
                                                                                       2            2
B (t , T ) =
               B (0, t )     0                                         20                               

    On remarque que le prix des ZC futur à l’instant t, dépend de la structure au
comptant des ZC et de la structure des volatilités entre 0 et t.

       On peut en déduire le taux futur en t d’échéance T à travers la relation :
                            1
       R (t , T − t ) = −      ln B (t , T )
                          T −t

       Puis le taux forward calculé à s, commencant à t et d’échéance T :
                        ln B ( s, t ) − ln B ( s, T )
       F ( s, t , T ) =
                                    T −t

     Et finalement le taux forward instantané f(t,T) ou le taux court r(t)=f(t,t)
grâce à la formule de dérivation :

                                     t                           t
           f (t , T ) = f (0, T ) − ∫ 〈γ ( s, t ), dW Q ( s )〉 + ∫ 〈γ ( s, T ), σ ( s, T )ds〉
                                    0                            0

           ∂σ (t , T )
       avec            = γ (t , T ) = (γ 1 (t , T ),..., γ n (t , T )) vecteur des volatilités du taux
              σT
forward instantané.

                                         t                           t
       D’où r (t ) = f (0, t ) − ∫ 〈γ ( s, t ), dW Q ( s )〉 + ∫ 〈γ ( s, t ), σ ( s, t )ds〉
                                         0                           0


      On remarque malheureusement que le taux court r(t) n’est pas forcément
markovien car les volatilités présentes dans l’équation peuvent dépendre de
variables aléatoires observées avant la date t.

       C’est le principal inconvénient du cadre HJM ! En effet, ceci rend le modèle
difficile à implémenter numériquement.
       Ayant le choix entre la construction d’arbre, MC ou les schémas aux
différences finies, on s’appuie sur l’arbre pour exemplifier cette difficulté :
 P (rT = x / rt , rt +1 ,..., rT −1 ) ≠ P (rT = x / rT −1 ) implique qu’on aura besoin pour suivre
l’évolution du taux court d’un vrai arbre au lieu d’un treillis ! grosso modo, un
treillis binomial à 10 pas de temps aura 11etats finaux alors qu’un arbre en aura
 210 , ce qui rend très long la valorisation de produits dérivés en un temps
convenable.




                                                                                                        19
         2.      Modèle markovien

                             a.         Généralisation de Inui & Kijima

                             D’une part Inui et kijima propose un modèle à n sources d’incertitudes
                       et 2n variables d’état développé dans le cadre HJM mais avec une forme de
                       volatilité spécifique, qui rend le modèle markovien.

                             En considérant que le vecteur de volatilité des taux forward instantanés
                       vérifie :
                                                                T
                              γ i (t , T ) = γ i (t , t ) exp(− ∫ κ i ( x)dx) avec i=1,…,n
                                                                t

                              où les κ i (x) des fonctions déterministes.

                              On a ainsi,

                                                                    n −1
                                          ∂f (0, t ) n                                                    n
dr (t ) = κ n (t )[ f (0, t ) − r (t )] +           + ∑ φ i (t ) + ∑ (κ n (t ) − κ i (t )) χ i (t )dt + ∑ γ i (t , t )dW Q (t )
                                             ∂t       i =1         i =1                                 i =1


                                                t
                                     φi (t ) = ∫ γ i ( s, t ) 2 ds
                                                0
                              avec                  t                         t
                                     χ i (t ) = ∫ γ i ( s, t )σ i ( s, t )ds + ∫ γ i ( s, t )dW Q ( s)
                                                 0                            0


                                                                                                          n
                              en écrivant le taux court comme : r (t ) = f (0, t ) + ∑ χ i (t ) , on peut dire
                                                                                                         i =1

                       que le taux court est markovien par rapport aux 2n variables d’état χ i (t ) ,
                       φi (t ) pour i=1,...,n. Il en va de même pour le ZC, le taux ZC et le taux
                       forward.

                             Ce modèle, développé en 1998, se veut être la généralisation de tous les
                       modèles à système markovien respectant le cadre HJM. En effet, on peut
                       citer quelques sous-modèles :

                   •    En réduisant la dimension du mouvement brownien à n=1

                                                        1) Modèle de R&S
                                                          (Ritchken et Sankarasubramanian - 1995)

                                                          Modèle markovien à deux variables d’etat r(t) et φ (t ) .

                   •    En contraignant la fonction de volatilité

                                                        2) Modèle de Vasicek généralisé




                                                                                                                            20
               On représente la volatilité des taux fwd instantanés par
                 γ i (t , T ) = σ i exp(−λi (T − t )) où σ i ∈ ℜ et λi ∈ ℜ + *
               Le taux court sera représenté par conséquent par un processus
               d’Ornstein Uhlenbeck étendu à des coefficients dépendant du
               temps.
               Les fonctions de vol sont deterministes et stationnaires dans le
               temps car ne dépendant que de T-t. La vol des ZC est croissante
               par rapport à T-t, tandis que les vol des tx ZC et des tx fwd
               instantanés sont décroissantes.
                                                                         2
                                    n
                                        σ                       
               Vol des ZC :        ∑  λ i (1 − exp(−λi (T − t ))
                                   i =1  i                      
                                                       n
               Vol des tx fwd instantanés :          ∑σ
                                                      i =1
                                                             i
                                                              2
                                                                  exp(−2λi (T − t ))

                                                                                 2
                                 1           n
                                                 σ                       
               Vol des tx ZC :
                               T −t
                                            ∑  λ i (1 − exp(−λi (T − t ))
                                            i =1  i                      


•   En modifiant la dimension du brownien et la volatilité

                        3) Modèle de M&V
                         Moraleda et Vorst - 1996

               On prend n=1 et on choisit la forme suivante de la vol
                              1 + κT
               γ (t , T ) = σ        exp(−λ (T − t ))
                              1 + κt

                                                                             t
               On exprime ainsi dr(t) en fonction de φ (t ) = ∫ γ ( s, t ) 2 ds qui est
                                                                             0
               déterministe (contrairement au modèle de R&S).
               Le taux court est la seule variable d’état.
                                          αβ (t , T )
               La volatilité des tx ZC :              n’est pas stationnaires. Elle
                                            T −t
               peut être aussi bien croissante, décroissante ou en bosse comme
               remarqué dans le marché.


                        4) Modèle de H&W
                        (Hull et White – 1990)

         équivalent à vasicek avec n=1 ou encore à M&V avec κ = 0
         c'est-à-dire avec une vol des taux forward instantanés :
         γ (t , T ) = σ exp(−λ (T − t )
         et          un      taux       court  qui    s’écrit     comme :
                              t
                                                                   σ2
         r (t ) = f (0, t ) − σ ∫ exp(−λ (t − s ))dW Q ( s ) +          [1 − exp(−λt )]2   c’est
                              0                                    2λ 2




                                                                                             21
      un processus d’Ornstein-Uhlenbeck avec des coefficients dépendant
      du temps, dr (t ) = (θ (t ) − λr (t ))dt − σdW Q (t )


                   5) Modèle de H&L
                   (Ho et Lee – 1986)

        Cas particulier du modèle de H&W avec λ  0         →
                                                ∂f (0, t )
        Le taux court s’écrit alors : dr (t ) =            dt + σdW Q (t )
                                                   ∂t
        On remarque que ce modèle ne prend pas en compte le
 phénomène de retour à la moyenne. De plus, les taux ZC auront la
 même volatilité V (t , T ) = σ , ce qui veut dire que toutes les courbes de
 taux ZC possibles à une date future sont parallèles deux à deux.

 b.        Log-normalités des taux

    Comme nous l’avons vu, dans le cadre HJM, le taux court peut être
négatif ! Pour combler cet inconvénient, Black Derman & Toy ont
développé un modèle markovien à temps discret où le taux court,
distribué de façon lognormale, guide l’évolution future de la courbe des
taux.
    En temps continu, cela donne :
                                     σ ' (t )
            d ln r (t ) = (θ (t ) +           ln r (t ))dt + σ (t )dW Q (t )
                                      σ (t )
    Le lemme d’îto nous donne :
                              σ ' (t )             1        
    dr (t ) = r (t ) θ (t ) +          ln r (t ) + σ (t ) 2  dt + r (t )σ (t )dW Q (t )
                              σ (t )               2        

   Inconvénients :
   Ce modèle ne permet pas au taux forward instantanés d’être négatif
ce qui est le cas dans des périodes dans lesquelles la courbe des taux à
une pente fortement orientée à la baisse.
   De plus, l’évaluation de produits de taux est difficile car elle ne
débouche pas sur des solutions analytiques.

   Black & Karasinski suggèrent une variante du modèle pour contenir
un maximum d’information. En effet, ils veulent récupérer aussi bien la
courbe des taux ZC au comptant que les termes de structure des vols des
ZC, caplets et swaptions.
   d ln r (t ) = φ (t )(ln µ (t ) − ln r (t ))dt + σ (t )dW Q (t )
   où µ (t ) désigne la valeur moyenne du taux
   φ (t ) la fonction de vitesse de retour à la moyenne
   σ (t ) Volatilité locale du logarithme du taux court

      Remarque :



                                                                                     22
                  •    il est faux de considérer qu’on peut expliquer l’incertitude sur
              une courbe de taux avec une seule variable d’état. En effet, la matrice de
              corrélation entre les variations de taux dans ces modèles à un facteur est à
              1. Or, cette matrice de corrélation a une incidence directe sur la volatilité
              des taux fwd.

                 On a en effet,
                                            (T2 − t ) R(t , T2 − t ) − (T1 − t ) R(t , T1 − t )
                       F (t , T1 , T2 ) =
                                                                T2 − T1

                 ce qui nous donne la volatilité des taux forward,
                          (T1 − t ) 2 V12 + (T2 − t ) 2 V22 − 2(T2 − t )(T1 − t ) ρ1, 2V1V2
                  VF =
                                                  T2 − T1
                  où V1 , V2 etρ1, 2 sont respectivement les vol des taux R(t,Ti) et leur
              corrélation.

                  On vérifie ainsi que pour les modèles à une variable d’état où la
              correl est à 1, amène à sous estimer la vol des taux fwd par rapport à la
              réalité.

3.    Modèle de marché –Libor Market Modèle-


          Basé sur le principe d’absence d’opportunité d’arbitrage, ce modèle est le
     plus couramment utilisé dans les marchés financiers. L’avantage qu’il a sur le
     modèle HJM par exemple est que ce dernier prend en entrée la courbe des taux
     forward instantanée qu’on ne peut pas constater sur le marché. Hors, BGM prend
     en entrée la courbe de taux forward observable sur le marché. Cela donne une plus
     grande justesse dans le pricing de produits de base mais rend la calibration plus
     complexe.




                                                                                                  23
MODELE DE MARCHE BGM




                       24
A DERIVATION DU MODELE :

1.     Modélisation :
           On peut écrire le taux forward en fonction du terme d’actualisation :
                          1 Bi (t ) − Bi +1 (t )
                Fi (t ) =                        .
                          τi     Bi +1 (t )
                                            1
           On peut considérer que             ( Bi (t ) − Bi +1 (t )) est un actif du marché. On sait
                                        τi
     alors, par absence d’opportunité d’arbitrage, qu’il existe une mesure pour laquelle
     cet actif est martingale. On considère alors le numéraire Bi +1 (t ) , correspondant à
     la mesure Q i +1 et son brownien W i +1 . On a alors :
                  dFi (t )
                           = σ i (t )dWt i +1
                   Fi (t )
            Notons l’apparition de la volatilité du taux qu’il nous faudra déterminer. En
     effet, il suffira de considérer un caplet portant sur la période [Ti , Ti +1 ] . Il porte sur
     le taux Fi (t ) et son paiement s’effectue à Ti +1 donc nous utiliserons le numéraire
     Bi+1 (t ) pour actualiser son payOff.
           La mesure, pour laquelle tout actif exprimé avec le numéraire Bi+1 (t ) est une
     martingale, est bien la Ti +1 forward neutre. En effet, si f actif de marché,
        f ( 0)              f (t )
                = E i +1 (            ) .
      Bi +1 (0)            Bi +1 (t )
             En faisant le rapprochement avec la modélisation de la dynamique des taux
     vu précédemment, on se rend compte que c’est bien le caplet l’instrument qui
     s’impose par nature pour calibrer la volatilité des taux. Cette remarque nous sera
     très utile lors de la calibration.

2.     Changement de mesure :
           Nous venons de voir que le taux forward est une martingale sous son
     numéraire de fin de période. La formule est simple et nous somme tenter de faire
     nos simulation ainsi. Mais pour effectuer des simulations de Monté Carlo, on est
     obligé de se placer sous une mesure unique ! En effet, on diffuse toute la courbe
     lors de chaque simulation et du coup on doit fixer un numéraire à chaque fois.
           Le changement de numéraire n’a pas d’impact sur la volatilité mais
     seulement sur son drift.
           Donnons la dynamique de Fi (t ) sous le numéraire Bi (t ) .

                                                  dQ i                Bi (t ) Bi +1 (Ti )
           Radon Nikodym nous donne           L=                  =
                                                 dQ i +1     Ti
                                                                      Bi +1 (t ) Bi (Ti )

           Girsanov nous donne les résultats suivants :
                E i +1 ( L) = 1


                                                                                                  25
                  L        est              martingale              exponentielle                sous         Q i +1 :
                                  t
                  t          1 2
      L = exp(− ∫ ϕdWui −     ∫ ϕ du avec dQt = dQt + ϕdt
                                            i +1   i
                  0          20
           Il nous suffit alors de connaître ϕ pour expliciter la dynamique de Fi (t )
      sous Q i
                                       Bi (t )
                                 d(               )
            dL                         Bi +1 (t )     d (1 + τ i Fi (t ))   τ dF (t ) τ i Fi (t )σ i (t )
               = ϕdWt i +1 =                        =                     = i i            =                 dWt i +1
             L                        Bi (t )          1 + τ i Fi (t )     1 + τ i Fi (t )   1 + τ i Fi (t )
                                      Bi +1 (t )
           donc
                                 τ i Fi (t )σ i (t )
            dWt i +1 = dWt i +                       dt
                                  1 + τ i Fi (t )

           par récurrence, on trouve :

                                           dFi            i δ j F jσ jσ i ρ i , j
            num < i + 1 , t ≤ Ti ,
                                            Fi
                                               =     ∑
                                                    j = num     1 + δ j Fj
                                                                                  dt + σ i dWt num

                                            dFi
            num = i + 1 , t ≤ Ti +1 ,           = σ i dWt num
                                             Fi
                                                    num −1 δ F σ σ ρ
                                              dFi
                                                  =−∑                       dt + σ i dWt num
                                                             j j   j i i, j
            num > i + 1 , t ≤ Tnum          ,
                                               Fi    j =i +1  1 + δ j Fj


            On remarquera que le produit entre les volatilités correspond à un produit
      scalaire. C’est ainsi que la corrélation entre les taux forward devient un élément
      essentiel qu’il faudra déterminer.


B CALIBRATION DU MODELE :
      Nous avons vu que le modèle BGM a été conçu pour se calibrer sur les volatilités
des caplets, d’où la nécessité d’extraire des données de marché les volatilités des caplets
cotés.
      Nous avons vu aussi que la nécessité de travailler sur une mesure unique implique
l’apparition de la corrélation entre les différents taux modélisés. Nous allons voir qu’on
aura par conséquent besoin des cotations des volatilités des swaptions, car celles-ci
contiennent de l’information sur les corrélations des taux. En réalité ces informations
concernent les corrélations terminales et non pas instantanées comme souhaité. Nous
verrons par la suite comment combler ce problème.

 1.     Calibration de la volatilité :

            Pour des soucies de clarification, on commence par représenter les volatilités
      instantanées des taux modélisés dans un tableau :


                                                                                                                   26
                [T0 , T1 ]           [T1 ,T2 ]             [T2 , T3 ]   …          [Tm−1 , Tm ]
F1 (t )         σ 1,1                expiré               expiré        …          Expiré
F2 (t )         σ 2,1                σ 2,2                expiré        …          expiré
F3 (t )         σ 3,1                σ 3, 2                σ 3,3        …          expiré
…               …                    …                    …             …          …
Fm (t )         σ m,1                σ m, 2                σ m,3        …          σ m,m


                  Le choix intuitif serait de considérer que chaque σ i , j est indépendante et de
          fitter (décomposer) le marché des caps. Mais, comme cela a été souligné dans
          Brigo&Mercurio, ceci cause beaucoup de problèmes notamment celui de la
          surparamétrisation.
                  H&W propose une structure qui ne dépend que de la distance à la maturité et
          en considérant la volatilité constante sur chaque intervalle de temps, appelée :
          General peacewize constant.
                   σ i (t ) = σ (Ti − t )
                  Son principal défaut est qu’elle donne une terme structure de volatilité
          stationnaire !
                  Un bon compromis serait de rajouter un jeu de paramètre pour tenir en
          compte en même temps du temps et de la distance à la maturité.
          σ i (t ) = φi (t )ψ (Ti − t )
                  On distingue deux cas :
                   La « separable piecewize constant » pour laquelle on met φ (t ) = 1 et
          ψ (Ti − t ) = λi .
                  La           formule    de      rebenato,     la         « linear-Exponential » :

                             [
          σ (t , T − t ) = φi (a(Ti − t ) + d )e −b (T −t ) + c
                                                      i
                                                                  ]
                Celle-ci correspond à la concrétisation d’une observation importante qu’a
          faite Rebenato. En effet, il a observé que la partie stationnaire de la volatilité suit
          la plupart du temps une décroissance exponentielle accompagnée parfois d’une
          « bosse » en début de courbe. Ainsi en combinant les deux remarques, il a proposé
          la forme LE vu précédemment et sur cette forme que notre choix s’est porté, car
          c’est le meilleur compromis entre l’obtention du fit de la courbe et le nombre de
          paramètre.
                Le choix de la forme de la volatilité ainsi fait, on peut commencer leur
          calibration.
                     a.      1ère étape :

                On récupère en input les données de marché sur les volatilités des caps.
          Avant de commencer à les stripper en caplets, on a besoin de faire une hypothèse
          sur la constance des volatilités des caplets composant un même cap. Par exemple
          les deux volatilités des caplets de tenor 6 mois composant un cap d’1 an seront
          égales à la volatilité de ce dernier.



                                                                                                  27
       On commence par transformer la volatilité des caps en volatilité des caplets
callée sur les maturités des taux modélisés.
       Ceci ce fait dans un premier temps en interpolant les volatilités et strike des
caps selon les maturités des taux.
       Dans un deuxième temps, on utilise une méthode de bootsrapping pour
déduire la volatilité des caplets selon les maturités des taux modélisés.
       Grâce à la formule de B&S, c’est cette dernière surface de volatilité qui sera
utilisée pour calibrer les volatilités des taux.

               b.              2ème étape :

       Le choix de la volatilité s’est fait sur la volatilité de Rebenato, la LE vol

                                                                       [
‘linear-Exponetial’ : σ (t , T − t ) = φi (a (Ti −1 − t ) + d )e −b (Ti −1 −t ) + c                                 ]
      On remarque 5 inconnus : a, b, c, d, φi
      Leur détermination se fait en 2 étapes : la première consiste à minimiser la
différence entre les volatilités théoriques des caplets et leurs valeurs du marché
correspondant à la surface de vol en input. Ce mécanisme nous donne les 4
premiers paramètres. La deuxième étape se résume à ajuster le dernier paramètre.

       Détermination des paramètres a, b, c, d :
       Le payoff d’un caplet : τ i ( Fi (Ti ) − K ) + payé en Ti +1
       Avec l’hypothèse que Fi soit lognormal sous la probabilité Q i +1 avec une
volatilité σ i , on a la formule de pricing d’une option de B&S :
       C i (t ) = τ i P(t , t i +1 )( Fi (t )φ (d1 ) − Kφ (d 2 ))
                                Fi (t ) σ i (t )
                                                         2

                          ln(          )+
       avec d 1 =                K           2
                                    σ i (t )
       où : σ i (t ) = σ i . Ti
                                                                                                        T
                                                      1 i
       on en déduit ainsi la volatilité du caplet: υ = ∫ σ i (t ) 2 dt                      2
                                                                                            Ti
                                                      Ti 0

       Grâce à l’expression paramétrique de la LE vol, on a :
                                                    Ti                                                  2

       Ti (σ         )                              ∫ [(a(T                                            ]
               thq 2                                                                  − b (Ti −t )
                         = Tiυ           = φi
                                                2
               i
                                 2
                                 Ti −1                             i   − t ) + d )e                  + c dt
                                                    0


                                                                                                 ∑ [(σ             ) − (σ ) ]
                                                                                                                              2
                                                                                                             marché 2   thq 2
       On cherche à minimiser ainsi la différence :                                                         i           i

      Pour se faire, on met le vecteur φi à 1, on détermine les paramètres a, b, c, d
puis on ajuste phi :
                Ti                                                         2


                ∫ [(a(T                                                    ]
                                                    −b (Ti − t )
                           i   − t ) + d )e                        + c dt
       φi =
          2      0

                                         (
                                  Ti σ imarché           )
                                                         2




                                                                                                                                  28
                                                 cap vol surface
                                                                                                    35


                                                                                                    30


                                                                                                    25


                                                                                                20                       30-35
                                                                                                         volatility      25-30
                                                                                                15                       20-25
                                                                                                                         15-20
                                                                                                10                       10-15
                                                                                                                         5-10
                                                                                                5                        0-5

              maturity
                         15




                                                                                                0
                              6




                                                                                              175
                                                                                      20
                                                                                     225
                                                                                25
                                                                           30
                                                                      35
                                                                 40
                                                            50
                                                       60
                                                  70
                                             80
                                       90
                                  00
                                  1




                                                                                     strike



                                  Volatilité cubique des cap de marché



                                             EUR Cap ATM flat vol

         18

         16

         14

         12

         10
                                                                                                               Series1
          8

          6

          4

          2

          0
              0               5             10              15                  20                  25


                                   Volatilité ATM des cap de marché



2.     Calibration de la corrélation

          La volatilité des swaptions contient de l’information sur les corrélations
     terminales des forward qui les composent. Par exemple, une swaption portant sur
     un swap qui commence dans 1an pour 2ans ( S1,3 ), dépendra des corrélation entre
     les forward F2 et F3 .




                                                                                                                                 29
                                                Bm (t ) − Bn (t )
     On sait que : S m,n (t ) =                     n

                                                  ∑τ B (t )
                                                 i = m +1
                                                            i   i


     Ainsi, on peut considérer que les swaps sont lognormaux sous la mesure
                                                                    n
proba SwapForward pour le numéraire ∑τ j B(t , T j + τ j ) .
                                                                    j=m

     En effet , on peut écrire la diffusion du swap :
          dS m,n (t ) = σ m ,n (t ) S m,n (t )dω tm,n
     On utilise la formule de Black pour le pricing des swaptions :


      Swaption (0) = Bm ,n (0)[E m ,n ( S m,n (T )) N (d1 ) − KN (d 2 )]
                             E m ,n ( S m,n ) 1
                      ln(                ) ± Tmυ m ,n (Tm )
                                                    2

      où d1, 2 =                   K          2
                                     Tm υ m,n (Tm )
                                   T
                          1
     avec υ   2
              m,n   (T ) = ∫ (σ m,n (t )) 2 dt
                          T 0
     et E m,n ( S m ,n (T )) = S m,n (0)

      Pour bien comprendre la procédure choisie de calibration, il faut noter
l’origine de la volatilité implicite vue dans la formule de Black :
       dS m, n dS m, n
                       = σ m , n dt
                           2

        S m, n Sm , n
                        T                               T
                             dS m,n dS m, n
                        ∫                         = ∫ σ m,n (t )dt = υ m ,nT
                                                        2              2
      et donc
                        0
                              S m,n S m,n               0


      Cette écriture pousse la curiosité des chercheurs à trouver la bonne
expression du swap pour exprimer aisément la volatilité théorique et par
conséquent pouvoir faire une minimisation entre cette volatilité et celle du marché.
      Rebenato propose ainsi une méthode qui a prouvé son efficacité.
      On exprime tout d’abord le taux de swap comme combinaison linéaire des
taux libor modélisés :
                       n
                                                  τ B(t , Ti + τ i )
       S m,n (t ) = ∑ Wi Fi (t )  avec Wi = n i
                   i = m +1
                                                ∑τ j B(t , T j + τ j )    j =m



      L’approximation faite par Rebenato consiste à considérer que les poids Wi à
tout instant t sont les mêmes qu’à l’instant 0. Ainsi on a :
                         n
      dS m,n (t ) =    ∑W
                      k = m +1
                                  k
                                 m ,n   (0)dFk (t )

     Et par un simple calcul on trouve :
           dS m ,n dS m ,n      n      Wm, n (0)Wmj,n (0) ρ k , j σ k σ j Fk (t ) F j (t )
                                        k

                           = ∑                              2
                                                                                           dt
           dS m ,n dS m ,n j ,k = m +1                    S m,n


                                                                                                30
             Et par conséquent :

                                       n

                                       ∑W
                                  i , j = m +1
                                                 k   (0)W j (0) Fk (0) F j (0) ρ i , j   Tm

              (σ          ) =                                                            ∫σ       (t )σ j (t )dt
                   thq      2
                   swaption                                2                                  i
                                                         S m ,n (0)T m                   0


             On utilise une forme paramétrique de la corrélation proposée par Rebenato :
             ρ i , j = ρ ∞ + 1 − ρ ∞ exp(− β i − j )

             On cherche à minimiser les écarts entre la volatilité théorique et celle donnée
             par le marché.
             On fixe ainsi les paramètres ρ ∞ et β .


    25,00                                                                                                          0A
                                                                                                                   0B
                                                                                                                   0C
    20,00                                                                                                          0F
                                                                                                                   0I
                                                                                                                   18
    15,00                                                                                                          01
                                                                                                                   02
                                                                                                                   03
    10,00                                                                                                          04
                                                                                                                   05
                                                                                                                   07
     5,00                                                                                                          10
                                                                                                                   15
                                                                                                                   20
      -                                                                                                            25
            0            5             10                15          20          25               30         35    30

                                vol des swaption selon différentes maturités




C ALGORITHME DE MINIMISATION:
      On vient de voir que la calibration du modèle BGM se concrétise dans 2 étapes
essentielles : la calibration des volatilités des taux et des corrélations. Sachant que la
calibration se résume en générale à minimiser la différence (quadratique dans notre cas)
entre les données de marché et ceux générées par le modèle lui-même en faisant varier
les paramètres de ce dernier, on se permet de choisir une méthode de minimisation.
      La méthode devrait permettre de minimiser la fonction de coût définit par :
                                 n
      F ( x1 , x 2 ,.., x m ) = ∑ ( Fi mod ele ( x1 , x 2 ,.., x m ) − Fi marché ) 2
                                i =1




                                                                                                                        31
       Le vecteur X = ( x1 , x 2 ,.., x m ) est le vecteur de paramètres que l’on souhaite
calibrer (dans notre cas ce vecteur sera dans un premier temps constitué des paramètres
a, b, c, et d pour la volatilité puis de ρ ∞ et β pour la corrélation)

      Notre choix de la méthode de minimisation s’est porté sur la méthode quasi-
newton dite BFGS tenant son nom des initiales des mathématiciens qui l’on découverte
indépendamment dans les années 60 (Broyden, Fletcher, Goldfarb et Shanno).
      Cette méthode permet une approximation directe de ∇ 2 F ( X ) par la matrice
hessienne dont l’inverse est calculé par une formule fermée proposé propre à la méthode
BFGS :
                   d yT                     d yT          d dT
      H k−1 = ( I − kT−1 k −1 ) H k−−1 ( I − k −1 k −1 ) + k −1 k −1
                                    1
                                              T             T
                   d k −1 y k −1            d k −1 y k −1 d k −1 y k −1
      avec d k −1 = X k − X k −1
         y k −1 = ∇F ( X k ) − ∇F ( X k −1 )

      Ainsi l’algorithme se résume en :
      Output : approximation de la solution de X * = arg min F ( X )
      Initialisation :
      Une première approximation de la solution X 0 (et nous verrons par la suite qu’il
est conseillé d’utiliser une méthode d’ACP pour trouver cette approximation)
      Une première approximation de l’inverse de la matrice hessienne (en générale on
la considère égale au vecteur unitaire)
      La précision recherchée

     Itérations :
     Calcule de : d k = − H k−1∇F ( X )
     Déterminer α k grâce à un algorithme de recherche linéaire
     Calculer X k +1 = X k + α k d k
     k=k+1

                  L’algorithme converge vers une solution lorsque la fonction de coût
atteint le niveau de précision demandé spécifié par l’utilisateur.




                                                                                       32
SYSTEME INFORMATIQUE DE PRICING SI_PROJECT




                                             33
A Descriptif de SI_project

     Le développement du projet SI_project a pour objectif de remplacer un ancien
 outil informatique shapeGenerator, developpé par l’équipe quant elle-même.

    En effet, les motivations de ce choix sont:
    •       l’apport de plus de clarté dans la structure pour corriger certains bugs
    •       simplifier l’écriture des payOff grâce à un module EDML2.0 (interface
 xml pour le saisie des payOff),
    •       augmenter la modularité du projet, notamment grâce à une modélisation
 objet, pour simplifier l’intégration de nouveaux modèles ou nouvelles fonctionnalités


     Les différentes tâches que doit êtres en mesure de réaliser le projet sont les
 suivantes :
         Calibration des différents modèles
         Pricing de produits exotiques
         Calcul de trajectoire de produits exotiques, de portefeuilles ou de stratégies
 actives
         Calcul d’enveloppes probabilistes et production des statistiques associées pour
 les produits exotiques, les portefeuilles ou les stratégies actives.

 1.     Les sous_jacents
            Les sous-jacents sont représentés par la classe Tunderlying. Une première
      distinction est faite permettant de déterminer si ce sous-jacent peut être acheté ou
      non. Si un sous-jacent peut être acheté, il entre alors dans la catégorie des
      TmarketAsset.




           4 types de TmarketAsset ont été implémentés jusque-là :


                                                                                       34
                 Le Tequity : sa valeur est liée à un modèle action
                 Le Tbasket : le panier est un portefeuille pondéré de sous-jacent. Sa
     valeur est égale à la somme pondérée des valeurs de ses constituants.
                 Le Tderivatve : le dérivé est un produit constitué d’une liste de coupons.
     Pour obtenir le prix du dérivé, des simulations seront effectuées, le prix du dérivé
     étant l’espérance du payoff actualisée.
                 La Tstrategy : elle décrit une méthode de gestion classique : CPPI,
     OBPI, mixte des deux.


          Les actifs qui dérivent directement de Tunderlying sont des sous jacent qui
     ne sont pas traitable directement sur le marché mais qu’on peut utiliser dans les
     payoff d’où l’intérêt de les modéliser. Citons par exemple le Tlibor qui est un taux
     forward ou Tcms qui est un taux de swap.

2.     La diffusion
           Une classe a été spécialement créée pour s’occuper de la diffusion des
     modèles : la classe TdiffusionManager. Chaque TdiffusionManager est
     fondamentalement lié au sous-jacent qui le possède. Il y a un et un seul
     diffusionManager par sous-jacent. Le diffusion manager est responsable de
     l’avancée dans le temps et du retour en arrière de ce sous-jacent. Il va alors être en
     charge de :
                La diffusion des modèles avec des pas de taille inférieure à une durée
     limite (exemple : 10 jours pour Heston)
                L’arrêt de la diffusion aux dates où une variable ou un sous-jacent doit
     être évalué.
                Le test des early redemptions éventuelles pour arrêter la diffusion une
     fois que celle-ci n’est plus nécessaire.
                Le rebalancement des portefeuilles utilisés par l’actif courant s’il y a
     lieu.

           Toutes ces informations sont fournies au diffusion manager au moment de
     son initialisation par le TmarketAsset. Il est donc indispensable de bien remplir
     tous ces champs au moment de l’initialisation du TmarketAsset.

           Le TdiffusionManager est également chargé de regrouper les corrélations
     pour former la matrice de corrélation dont il a besoin pour diffuser ses modèles. La
     principale difficulté réside dans le fait qu’il existe deux type de corrélations : celles
     internes aux modèles (ex : corrélation vol/spot du modèle de Heston, corrélation
     entre taux forward dans BGM) et celles intermodèles (corrélation spot/spot entre
     deux actifs). On a envie de spécifier ce premier type de corrélation dans le modèle
     lui-même (la valeur de cette corrélation est d’ailleurs issue de la calibration de ce
     modèle), tandis que le deuxième apparaît plutôt comme une donnée de marché. La
     solution qui a été apportée (et qu’il faudra peut-être modifier) est une gestion des
     corrélations point par point. On lit alors dans le fichier XML d’input les valeurs de
     corrélations historiques que l’on ajoute point par point à une liste et chaque modèle
     complète cette liste en ajoutant point par point sa corrélation interne.
           Le diffusion manager interroge la liste des modèles qu’il doit diffuser (ceux-
     ci lui sont fournis par le sous-jacent auquel il est lié) pour connaître la liste des


                                                                                           35
     browniens à diffuser. Il récupère alors dans la liste tous les points de corrélation
     dont il a besoin pour construire la matrice de corrélation puis la matrice de
     Cholesky.

3.     les modeles

         Les modèles sont regroupés à l’intérieur d’une classe abstraite : la classe
     Tmodel. Cette classe se divise en deux catégories.

           Tout d’abord sont regroupés sous la classe TequityModel tous les modèles
     d’actif représentant la valeur d’un actif simple. Le dénomination n’est pas
     parfaitement adaptée ces TequityModels peuvent servir à modéliser les forexs.
     Quatre types de modèles ont été implémentés jusque là :
                Le modèle de Black-Scholes
                Le modèle à volatilité locale
                Le modèle d’Heston
                Le modèle de Bates

           Ensuite, la classe T_IR_model qui est censé contenir tous les modèles de
     taux d’intérêt (pour l’instant seul T_LMM_model a été intégré).




            Le diffusion manager est chargé de la diffusion des modèles. Il donnera
     principalement 4 types d’ordre aux modèles. Les méthodes relatives doivent alors
     être implémentées pour chaque modèle :
                 diffuse (Date nextDate) : ordre de diffusion du modèle jusqu’à la
     prochaine date
                 backup_current_state() : enregistrement de l’ensemble des paramètres
     courants pour pouvoir revenir en arrière
                 rest_current_state() : retour au dernier état enregistré
                 delete_current_state() : suppression du dernier état courant et retour à
     l’état précédent
            Pour l’enregistrement des états, la méthode qui a été utilisées utilise des piles
     d’états courants. Dès que l’on veut faire un backup, on ajoute à la pile une copie de
     l’état courant. Pour retourner à l’état précédent (reset), il suffit alors de copier
     l’avant dernier état de la pile dans le dernier. Pour supprimer un état courant et
     revenir au précédent, il suffit de supprimer le dernier élément de la pile.



                                                                                          36
4.     les calibrateurs

           Les calibrateurs des modèles sont regroupés sous la classe abstraite
     Tcalibrator. Cette classe permet de simplifier l’organisation des tâches de
     calibration mais ne présente pas d’utilité fondamentale.




           Chaque calibrateur doit pouvoir lancer la calibration dans deux contextes
     différents. La première concerne la tâche de calibration proprement dite. Le
     calibrateur va alors trouver l’ensemble des données de marché dans le fichier
     XML. L’initialisation à partir du fichier XML est alors la responsabilité du
     calibrateur. Le deuxième type d’utilisation concerne la recalibration au cours d’une
     tâche de pricing pour le calcul de sensibilités. Dans ce contexte, le modèle doit
     pouvoir s’initialiser à partir des données existantes (notamment, le Manager qui
     regroupe l’ensemble des données de marché).

5.     edml2.0 & interface payOff
           Edml (exotic derivative markup langage) est un langage développé en interne
     permettant la description de payoffs et leur interprétation par le programme.
           Un produit dérivé y est décrit par une liste de coupons, pouvant
     éventuellement donner lieu à une sortie anticipée (early redemption). A chaque
     coupon est associé une formule, implémenté sous la forme d’un arbre de pricing.
     L’utilisation de variables y est possible.

               a.     Les nœuds de calcul
              Les formules pour les coupons et les variables sont décrites à l’aide
          d’arbres de pricing. Cet arbre est constitué de nœuds de calculs
          TcalculationNode pouvant retourner une valeur. Un TcalculationNode a été
          implémenté pour chaque fonction. Un TcalculationNode peut avoir une liste
          de nœuds enfants, qui constitueront les arguments de la fonction. Lorsque


                                                                                      37
l’on cherche à connaître la valeur d’un nœud, chaque nœud enfant sera
calculé pour pouvoir déduire la valeur du nœud courant. Le fonctionnement
du TcalculationNode est donc fondamentalement récursif.

    Un TcalculationNode a deux méthodes fondamentales : une méthode
d’initialisation à partir d’un nœud XML et une méthode permettant de
connaître la valeur du nœud.

   Remarque : un TcalculationNode ne retourne en réalité pas une valeur
mais une liste de valeurs. Cela est notamment utile pour la création de
fonctions qui permettent de sélectionner une sous liste à partir d’une liste.

      b.      Les coupons
    Il existe deux types de coupons : les coupons classiques et les coupons
pouvant donner lieu à une sortie anticipée.
    Un coupon classique est décrit par un TcalculationNode et une date
associée.
    Pour décrire un coupon pouvant donner lieu à une sortie anticipée, il faut
tout d’abord préciser un nœud de calcul décrivant la condition à laquelle la
sortie anticipée se produit. On précise ensuite sous formes de deux
TcalculationNode la valeur du coupon dans le cas où l’early redemption se
produit et sa valeur dans le cas où elle ne se produit pas.




      c.     Les variables
      Une variable peut être utilisée pour représenter l’évolution d’une
donnée dans le temps. Le grand avantage des variables est que le calcul de
leur valeur peut utiliser la valeur de cette même variable à une date
antérieure.
      Attention toutefois à l’utilisation des variables : à chaque date
d’évaluation de la variable est créé un arbre de pricing spécifique. La
quantité d’arbres peut alors croître très rapidement si des variables doivent
être évaluées tous les jours. Attention donc à ne pas saturer la mémoire.

     d.      Le parsing du fichier XML dans C++




                                                                           38
                             Pour faciliter l’écriture des fichiers XML et augmenter leur lisibilité, il
                       a été très utile de développer des raccourcis d’écriture. Ces raccourcis se
                       présentent sous forme de boucles de répétition. Elles permettent de définir
                       des variables qui vont itérer sur des listes. Par exemple, si l’on veut faire la
                       moyenne des performances de 50 actions, on peut définir une boucle à
                       l’intérieur d’un nœud de calcul « average ».
                             Il est très important de comprendre tout de suite la différence entre ces
                       variables (dite de parsing) et les variables décrites précédemment (dites
                       variables edml). Les variables edml ont des valeurs qui vont dépendre des
                       simulations. Les variables de parsing, elles, sont connues avant la simulation.
                       Elles servent simplement à construire les objets C++ et n’interviennent qu’au
                       moment de l’initialisation des objets. Ces variables disparaissent avant le
                       début des simulations.

                               e.         Exemple fichier xml en edml2.0

                             Nous allons étudier un exemple de pricing d’un Cap (somme de
                       caplets) :

                               payOff :


                                          p (t ) = ∑ (Ti +1 − Ti ) N ( Fi (t ) − K ) + Bi (t )



                       Ecriture xml
<exotic currency="EUR" name="Cap">
           <declarations>
                      <declare type="double" setName="$Nominal">
                                 <double>1</double>
                      </declare>
                      <declare type="double" setName="$strike">
                                 <double>0.042</double>
                      </declare>
                      <declare type="date" setName="$$resetDates">
                                 <slidingStartDate ddmmyyyy="10-09-2007"/>
                                 <slidingEndDate ddmmyyyy="10-09-2009"/>
                                 <step months="6"/>
                      </declare>
                      <declare type="date" setName="$$paimentDate">
                                 <slidingStartDate ddmmyyyy="10-03-2008"/>
                                 <slidingEndDate ddmmyyyy="10-03-2010"/>
                                 <step months="6"/>
                      </declare>
           </declarations>
           <coupons>
                      <iterate>
                                 <on type="date" setName="$date1">
                                            <in name="$$resetDates"/>
                                 </on>
                                 <on type="date" setName="$date2">
                                            <in name="$$paimentDate"/>
                                 </on>
                      <repeat>
                                 <coupon>
                                            <Actualise currency="EUR" country="FR" type="SWAP"></Actualise>
                                            <paymentDate name="$date2"/>
                                            <paymentAmount>
                                                      <product>
                                                                <scalar name="$Nominal"/>
                                                                <timeDiff fraction="true" convention="ACT360">
                                                                          <date name="$date1"/>



                                                                                                                 39
                                                                           <date name="$date2"/>
                                                                 </timeDiff>
                                                                 <max>
                                                                           <scalar>0</scalar>
                                                                           <minus>
                                                                                     <quote>
                                                                                     <underlying_id>1</underlying_id>
                                                                                     <date name="$date1"/>
                                                                                     </quote>
                                                                                     <scalar name="$strike"/>
                                                                           </minus>
                                                                 </max>
                                                       </product>
                                                       <scalar/>
                                              </paymentAmount>
                                  </coupon>
                     </repeat>
                     </iterate>
            </coupons>
</exotic>




       B Implémentation du modèle BGM

            1. Modèle de taux d’intérêt : entre terme structure et modèle de
            diffusion
                          Selon qu’on souhaitera utiliser le modèle de taux pour le pricing d’un asset
                 (drift ou dividende …) ou d’un produits de taux ou encore pour l’actualisation
                 d’un payOff, il nous sera utile de pouvoir créer cette courbe de taux dans différents
                 emplacement du code, contrairement aux autres modèles qui sont liés
                 incontestablement à leur asset et donc leur initialisation se fait lors de
                 l’initialisation de l’asset lui même
                          C’est pour cette raison qu’on a décidé de considérer un modèle de taux
                 comme étant une terme structure en soit mais aussi en gardant sa particularité de
                 modèle et par conséquent se diffuser avec les autres modèles dans le diffusion
                 manager. Ainsi, toute classe de modèle de taux héritera en même temps de la
                 classe TermStructure et de la class Tmodel.




                        Ce procédé porte le nom de multi-heritage. Il est conseillé de l’éviter car il
                 réserve des surprises lors de la compilation. En effet, le multi-heritage cause des
                 problèmes lorsque les deux classes mères ont des attributs ou fonctions similaires.


                                                                                                                        40
     Par conséquent le compilateur trouve une grande difficulté à différencier les
     similarités lors de l’instanciation des classes filles. Dans notre cas, une
     termeStrcuture et un modèle de diffusion n’ont pas grand-chose en commun sauf
     peut être le dayCounter qui nous donne les convention de décompte des jours
     ouvrés et la encore il s’agit du package TermStructures et non pas la classe
     TermeStructure de la quantLib.


2.     Descriptif de la classe T_IR _model
              Un modèle de taux doit pouvoir être autonome lors de son initialisation. En
     effet il doit pouvoir récupérer par lui-même tous les détails le caractérisant.
              L’initialisation d’un modèle de taux nécessite une courbe en entrée.
              Chaque modèle de taux aura, en plus des attributs qu’il lui faut pour sa
     diffusion, deux attributs primordiaux : son id et sa référence. L’id correspond à son
     nom intime en quelque sorte, il le différencie des autres modèles. Il se compose
     comme suite :ModelDeviseRisquePays (exemple : LMMEURSWAPFR). Sa
     référence quand à elle se compose de DeviseRisquePays. Elle décrit la courbe
     modélisée par le modèle et donc assurera l’unicité des courbes modélisées. On
     traitera cette partie plus en détails dans la section « unicité des modèles de taux ».

                a.        Différents cas d’Initialisation EDML2.0 :

                Comme il a été souligné avant, l’initialisation des modèles de taux se
          fait dans plusieurs endroits du code selon leur utilisation. On distinguera par
          la suite 3 cas :
                   Donnée de marché :

                <market_data>
                       <rate_curves>
                       <curve currency="EUR" type="GOUV" country="FR" >
                               <instrument_piecewise_flat_forward>
                                       <observationDate ddmmyyyy="10-06-2007"/>
                                               <rate type="deposit">
                                               <value>0.03816</value>
                                               <maturity unit="day">1</maturity>
                                               </rate>
                                               …



                         On veut dire par données des marchés, les courbes de taux en
                     entrée constituées des prix d’instruments de taux cotées sur le marché
                     qu’on va utiliser pour reconstituer une courbe de taux (en réalité, il
                     s’agira d’une termeStructure, c'est-à-dire une reconstruction de la
                     courbe de taux à partir des prix cotés sur le marché d’instruments
                     financiers de taux, dans ce cas il s’agor d’une instance de la classe
                     TshifatbleTermeStructure comme ceci sera expliqué par la suite)


                     Diffusion:




                                                                                        41
              Plusieurs cas sont à distinguer. Drift d’un equity ou d’un commo,
          leurs dividendes et enfin les modèles de diffusion des produits de
          taux.

               1er cas : Drift

               Lorsqu’il s’agit d’un drift, l’initialisation du modèle de taux se
          fait lors de la création de l’underlying concerné par ce drift
               Cas d’un drift equity stochastique:
                       <growth_rate id=”LMMEURSWAPFR” >
             Cas d’un drift equity:
                       <growth_rate id=”EURSWAPFR” >

               2ème cas : dividende

             C’est exactement la même chose pour le drift sauf lorsque la
     devise n’est pas renseignée. Dans ce cas, le dividende est spécifique à
     l’asset et donc son id sera (par convention) NomequityDIV.
               <dividend >
               <flat_forward>0.02</flat_forward>
               <\dividend >

            Rq : Il faut noter qu’un changement a été apporté au stockage
     des div. En effet, on avait l’habitude de les stocker dans une liste à part
     (div_curves). Maintenant, on stocke juste le nom de l’asset concerné
     (div_assetNames_ ) et l’id de sa courbe de div (div_id). C'est-à-dire,
     qu’on aura pour chaque nom d’asset, un id de courbe correspondant à la
     courbe de div qu’on pourra récupérer avec un simple
     get_IR_model(div_id). Ceci représente une économie de mémoire
     d‘autant de courbe de dividende crées.

               3ème cas : produit de taux

               Cas d’un produit de taux:
               <cms currency="EUR" name="cms2Y">
               <IR_model id=”LMMEURSWAPFR” >

     b.        création d’un modele de taux

       La classe T_IR_Model contient entre autre une fonction creat_IR() qui
s’occupe exclusivement de créer tous les types de courbes de taux à tous les
endroits du code. Les raisons de ce choix sont d’une part une généralisation
et la centralisation la création des courbes et d’autre part la possibilité de
veiller à l’unicité d’une courbe.
       Il y a deux types de liste de taux différentes : la liste de courbe de taux
de marché ir_curves_ et la liste global de modèle de taux : IRModelList_. La
différence primordiale est que la deuxième représente les courbes qui sont
effectivement utilisées par le programme hors la première est juste une
donnée de marché.




                                                                                42
                 On veillera toujours à accéder aux courbes de taux par cette fonction
           create_IR(), car c’est bien elle qui assurera l’unicité des courbes de taux et
           évitera la création de doublants.


3.   implémentation du modele BGM

                a.         initialisation BGM

             Deux objet sont crées pour modéliser à bien la courbe des taux avec
           BGM :
                               o Libor est une structure qui représente un taux libor
                                   modélisé avec sa date de départ, sa date de maturité
                                   et sa valeur
                               o TliborString est une classe qui est censé contenir
                                   tous les libors modélisés et aussi décrire les
                                   caractéristiques de la courbe. Par conséquent, on y
                                   retrouve la devise, un vecteur de libor, la date de
                                   fin des libors, la longueur des taux modélisés (3M,
                                   6M, 1Y…). C’est cet objet même qui représentera
                                   le résultat de chaque diffusion.

                           Description de l’initialisation des taux :

      t0             t1       t2         t3                                        t nbRates   t nbRates +1




                  F1          F2        F3                                          FnbRates

                          avec Fi (t ) = F (t , t i , t i +1 ) et qui correspond à l’objet Libor vu ci-
                     dessus.
                          De ce fait, le premier taux F0 est connu d’avance et n’a plus
                     besoin d’être modélisé. C’est le taux spot, vu de t0.
                          L’objet Rates contiendra l’ensemble des libor pour i=0 à
                     nbRates.

         •     Les autres attributs :
         T_IR_correlaion et TcapletVolSurface sont crées pour initialiser la
     corrélation et la volatilité des taux d’intérêt modélisés.


                b.         Taux forward/ la fonction fwdRate(startDate ,endDate)

                 Plusieurs cas s’imposent, la graphique suivant explicite assez bien ces
           différents cas :




                                                                                                          43
   1er cas : dateCourante<stratDate && startDate<endDate
           La courbe courante est la bonne.
                                            1        DS (Tcour , Tstar )
           F (Tcour , Tstar , Tend ) =             (                     − 1)
                                       Tend − Tstar DS (Tcour , Tend )

   2ème cas : dateCourante=startdate && startDate<endDate
          La courbe courante est tjrs la bonne
          DS(Tcour,Tstart)=1

   3ème cas : dateCourante>startDate && dateCourante<endDate
          Les choses se compliquent. En effet, le DS entre Tcour et Tend
          utilise bien la courbe courante. Par contre, pour la Tstar, il s’agit
          de la courbe à une date antérieure.
              Ceci revient à calculer le premier taux de Tstart à Tcour et le
          rajouter au taux de Tcour à Tend.
        1                  1                     1                 1
=                (                  − 1) +               (                      − 1)
  Tend − Tcour DS (Tcour , Tend )          Tcour − Tstar DS (Tstar , Tcour )

            Le but étant de généraliser les calculs. Ainsi pour le deuxième
           terme, vu que startDat<datecourrante, La DS utilisera une
           courbe antérieure.

   4ème cas : dateCourante>startDate && dateCourante=endDate
          La courbe courante n’est plus la bonne.
          Il s’agit des courbes à des dates antérieures.
                                            1              1
           F (Tstar , Tstar , Tend ) =             (                   − 1)
                                       Tend − Tstar DS (Tstar , Tend )
          en sachant que la DS utilisera une courbe antérieur car Tstar et
          Tend <Tcour
   5ème cas : dateCourante>startDate && dateCourante>endDate
          il s’agit de courbes antérieures
          même chose pour le cas 4.
   6ème cas : les même cas 1 jusqu’à s’appliquent en remplaçant startdate
   par endDate et en inversant le taux (-).




                                                                                44
               c.       Le taux d’actualisation/ la fonction
                    DiscountFactor(stratDate,endDate)




                1er et 2ème cas : on utilise la courbe en court de diffusion

                4ème et 5ème cas : on utilise la courbe initiale pur l’instant (TOD :
               historier les courbes diffuser pour pouvoir faire des compositions selon
               les dates de début et fin demandées).

                3ème cas : on ne prend pas en compte la startDate. On actualise entre
               endDate et currentDate.

               Le 6ème cas : n’est pas censé se produire car on n’actualise pas d’une
               date avenir à une date passée.



C Propriétés des modèles de taux dans un système de pricing

          L’enregistrement des modèles de taux se fait dans deux endroits du code :
    lors de leur création, dans quel cas on les rajoute à la liste des modèles de taux de
    TmarketData. Puis lors de l’initialisation des assets, où on les rajoute à la liste des
    modèles dont a besoin l’underlying pour se diffuser.
          Il y a cependant une liste des contraintes à respecter pour les modèles de taux
    qu’on n’avait pas l’habitude de gérer avec les modèles de diffusion des assets.


 1. UNICITE DES COURBES DE TAUX D’INTERET lors de la
 création:
          Tout d’abord il serait judicieux de parler de l’unicité d’une courbe de taux
    dans un pricing. Si on veut utiliser une courbe de taux liée à un pays donné, un
    risque donné et une devise donnée (EURSWAPFR) il est essentielle qu’elle soit
    unique sous ces critères. Ceci veut dire qu’on ne peut pas utiliser en même temps
    une courbe EURSWAPFR diffusée par LMM et une autre EURSWAPFR diffusée



                                                                                        45
     par un autre modèle ou celle du marché par exemple, car des opportunités
     d’arbitrage pourront avoir lieu.
           La classe mère T_IR_model contient deux attributs essentiels : réf et id. Le
     premier correspond à la composition : DeviseRisquePays et le deuxième à :
     ModelDeviseRisquePays.
           C’est bien grâce à la référence (ref) qu’on va veiller à l’unicité d’un modèle
     de taux. En effet, on doit pouvoir créer autant de réf que l’on souhaite mais chaque
     réf doit être modélisée d’une seule manière (soit courbe en donnée soit avec un
     modèle de diffusion de taux).
           Ce check se fait dans la classe mère lors de la création des modèles
     (T_IR_model ::Creat_IR()). Cette dernière vérifie l’existence de réf ou pas dans la
     liste des models et si c’est le cas, il faut que l’id soit le même entre la courbe
     existante et la courbe à créer sinon un message d’erreur est lancé.

        Algorithme unicité lors de la creation :
               Si ref(modelCrée)==ref(modelExistant)
                       Alors
                              Si id(modelCrée)==id(modelExistant)
                                      Alors on recupere le modele de la liste
                              Sinon
                                      Message d ‘erreure !!
               Sinon
                       On crée le modèle et on le rajoute a liste de modeles


2.     GESTION DES DOUBLONS DE MODELES lors de la diffusion :
            Cette problématique est propre aux modèles de taux car une courbe de taux
     spécifique sera diffusée une seule fois et utilisée par tous les underlyning
     concernés. Alors que les modèles des asset sont propres à leur asset car leur
     diffusion dépend de l’historique qui est propre à chaque asset.
            En effet, lors de la création des modèles de taux, comme on vient de le voir
     on fait attention à ne pas recréer des modèles existants et aussi à ne pas générer
     une courbe donnée avec plus d’un modèle de taux. Mais pour la diffusion, on se
     retrouve avec une liste de modèle à diffuser dans laquelle se trouve des doublons
     de modèles de taux, car chaque asset fournit à diffusionManager la liste des
     modèles dont il a besoin.
            Pour combler ce problème on a le choix entre traiter la liste de modèle à
     diffuser, qui est un argument de la classe TdiffusionManager, lors de
     l’initialisation du diffusionManager ou d’éviter d’en créer depuis le début. Pour
     des raisons d’économie de mémoire interne du programme, on choisit la deuxième
     possibilité.
            En effet, la fonction UnionVector pourra empêcher les doublant d’apparaître.
     Cette fonction est appelé à chaque fois qu’un coupon est crée et c’est elle qui se
     charge de copier les modèles dont ont besoin les underlying du coupon dans la
     liste de modèle du coupon et celle de l’underlying père qui correspond à l’exotique
            UnionVector copie un vecteur d’objet dans un autre. Elle a la capacité de ne
     copier que les éléments du vecteur source qui n’existent pas déjà dans le vecteur
     de la liste destination. Il ne nous reste par conséquent qu’a redéfinir l’opérateur ==



                                                                                        46
     pour les models de taux. On choisit de comparer la ref_ du model comme expliqué
     précédemment.

3.     ORDONNANCEMENT DES MODELES à diffuser :

           Lors de l’initialisation du TdiffusionManager, en copiant la liste des models
     en paramètres dans la liste de models qui va se diffuser, on aura dedans les models
     de diffusions des assets et les modèles de taux utilisés aussi bien pour la diffusion
     des produits de taux que pour les drifts et dividendes.

           Le problème qui s’impose est l’ordonnancement de cette liste. En effet, il
     faut que les models des assets se diffusent en premier puis les modèles de taux.
     Car les models des assets utilisent la courbe de taux vue de l’instant de départ de la
     diffusion et par conséquent diffuser les modèles de taux avant ceux des assets
     risque de fausser le résultat.

        Algorithme d’ordonnancement des listes :
                 On utilise la fonction sort de la librairie std
                 On redéfinit l’opérateur ‘<’ sur les modèles de manières à ce que les
        modèles asset soient avant les modèles taux. Pour cela on met les modèles de
        type equityModel (CommoModel aussi par la suite) avant les modèles de
        type interestRateModel.
                 Puis on crée la structure sortModels pour lequel on définit l’opérateur ()
        (il s’agit d’un foncteur)
                 Et enfin on appel la fonction std ::sort(listBegin,listEnd,sortModels())


4.     INITIALISATION DE LA CORRELATION :
           Pour ce qui est de la matrice de corrélation qu’on utilisera pour générer les
     browniens, elle est crée dans TDiffusionManager. C’est bien lui qui s’occupe de
     regrouper les corrélations dont a besoin chaque modèle de diffusion.
            Il y a un seul changement apporté dans cette classe : lorsqu’on renseigne la
     liste des brownienIdentifier qui nous servira a construire la matrice de correl, on
     fait un test pour chaque modèle (ce test ne s’applique en fait qu’au models de taux)
     pour savoir s’il doit se diffuser ou pas, et donc s’il a besoin d’un (s) brownien ou
     pas. Si oui on appelle sa fonction getNeededBrowniens sinon on continue à
     parcourir la liste ! En effet, les modèles déterministes par exemple n’ont pas
     besoin de browniens .
           Cependant, les changements principaux concernent le renseignement de la
     corrélation pour les taux.
           En effet, il y a deux cas : corrélation entre les taux modélisés d’un même
     modèle et corrélation hybride entre modèle de taux et d’asset ou deux modèles de
     taux différents.
           Pour le premier cas, elle est renseignée au sein de la description du modèle
     de taux dans le fichier xml puis traité par le modèle lui-même. En effet, cette
     information fait partie des paramètres du modèle et vu que ce dernier doit être
     capable de s’initialiser lui-même, il doit être capable de lire ses corrélations
     internes tout seul.



                                                                                        47
            Pour ce faire, on utilise tout simplement la matrice de corrélation déjà
     initialisée par le modèle lors de sa propre initialisation grâce à T_IR_correlation
     (correl expbeta ou autres) puis on affecte les corrélations point par point aux taux
     modélisés dans la fonction setInternalCorrelation().
            Pour les correlations hybrides. Leur saisie se fait exactement de la même
     manière que ceux des assets dans le cas où on veut les spécifier point par point.
     Mais l’utilisateur se rendra rapidement compte de la difficulté de sa mission et
     aussi de la lourdeur du fichier xml .
            Dans ce cas, on utilise une balise <correlation_hybrid> qui signifie la saisie
     d’un vecteur de corrélation.

        Exemple XML :
        <correlations>
        <correlation_Hybrid>
                <brownian name="LMM" related_data="LMMEURSWAPFR"></brownian>
                        <brownian name=”BNP" related_data="SPOT"></brownian>
                        <value>
                        <matrix>
                                <row>
                                       <cell></cell>
                                       <cell></cell>
                                         ...
                                       <cell>0.00</cell>
                                </row>
                        </matrix>
                        </value>
                </correlation_points>
                </correlations>

            Pour ce faire, une classe TcorrelationHybrid est crée. Elle aura comme
     attributs, deux brownienIdentifiers_ (nom de l’asset ou du model et donnée
     concernée) et un vecteur de valeurs.
            Cette classe servira à l’initialisation des différents nœuds de
     correlation_hybrid.
            Une fonction static dans T_IR_correlation a été crée pour transformer les
     correlation_hybrid en correlation_Point. En effet, c’est bien un vecteur d’objet de
     cette dernière classe qui est utilisé pour construire la matrice de corrélation. Ainsi
     aucun changement ne sera apporté à la classe TdiffusionManager.
            Les liens entre les related_data et les strings qu’on lit dans le fichier xml se
     fait grâce à un map d’énumérateur.
            La convention d’identification du brownien est ModelDeviseRisquePays :
     par exemple LMMEURSWAPFR. On y accède avec l’attribut id_.


5.     GENERATION DES BROWNIENS :
             Notons tout simplement que pour la génération des brownien, il s’agit
     maintenant d’un vecteur de pointeur initialisé comme les autres models. En effet, il
     fait pointer chaque composante de ce vecteur sur l’élément du vecteur
     CorrelatedBrowniens_ (objet de TdiffusionManager) qui lui correspond ; et avant
     chaque diffusion, on appel la fonction updateBrowniens() qui s’occupera de
     générer les browniens corrélés avec un simple produit d’une matrice triangle
     inférieur et un vecteur. Le résultat étant stocké dans ce dernier vecteur et qui


                                                                                         48
              correspond bien sur à CorrelatedBrowniens_. Ainsi chaque pointeur de brownien
              des models pourra récupérer la valeur actuelle du vecteur dont il a besoin.
                     L’identifiant du brownien est récupéré grâce à getID() en composition avec
              le nom du model et le numéro du taux modélisé => (LMM6,LMMEURSWAPFR
              par exemple)

         6.     ACTUALISATION DES COUPONS :

                      L’actualisation d’un coupon se fait en appelant la courbe modélisée
              correspondant à la devise renseignée dans la balise <currency>. (get_IR_model).
                       L’appel d’une courbe de taux étant assurée par ModelDeviseRisquePays,
              on a rajouté une balise < Actualise id= ‘’><\Actualise>
                      Pour permettre l’utilisation d’une courbe donnée avec un risque différent,
              on a le choix entre créer cette courbe ou récupérer une courbe déjà modélisée puis
              lui appliquer un shift résultant d’une constante spread précisée dans le fichier xml
              ou modélisé grâce à un modèle de risque de crédit.
                      La conception de Si_projet nous oblige à faire le deuxième choix car la
              diffusion d’un modèle est appelée par le sous jacent lui-même lors du pricing et
              non pas lors de l’actualisation ! Par conséquent, nous préciserons dans la balise
              <Actualisation> soit un shift constant soit un modèle de risque de crédit qu’il
              faudra diffuser à part.

         7.     Numéraire :

                    Lors de l’initialisation d’un modèle LMM, on doit préciser s’il utilisera un
              numéraire Rolling ou spot. En effet, si on souhaite évaluer un prix d’un produit de
              taux exclusivement, il s’agira d’un numéraire spot et c’est lors de l’initialisation de
              ce produit la qu’on intégrera cette information au modèle de taux. Sinon, le
              numéraire par défaut sera en Rolling, et au modèle LMM de préciser son
              numéraire en fonction de la date de diffusion demandée par le diffusionManager.

                    Rappel :
                    •     le numéraire SPOT correspond à la date de fin du premier taux fwd à
              modéliser dans la structure du produit de taux qu’on souhaite évaluer.
                    •     Le numéraire Rolling correspondra pour chaque diffusion à la date de
              fin du taux en cours de modélisation.

       D Exemples et test de validité
              Nous allons étudier un exemple de pricing d’un Cap (somme de caplets) :

              payOff :


                   p (t ) = ∑ (Ti +1 − Ti ) N ( Fi (t ) − K ) + Bi (t )



              Ecriture xml
<exotic currency="EUR" name="Cap">
           <declarations>



                                                                                                  49
                       <declare type="double" setName="$Nominal">
                                  <double>1</double>
                       </declare>
                       <declare type="double" setName="$strike">
                                  <double>0.042</double>
                       </declare>
                       <declare type="date" setName="$$resetDates">
                                  <slidingStartDate ddmmyyyy="10-09-2007"/>
                                  <slidingEndDate ddmmyyyy="10-09-2009"/>
                                  <step months="6"/>
                       </declare>
                       <declare type="date" setName="$$paimentDate">
                                  <slidingStartDate ddmmyyyy="10-03-2008"/>
                                  <slidingEndDate ddmmyyyy="10-03-2010"/>
                                  <step months="6"/>
                       </declare>
            </declarations>
            <coupons>
                       <iterate>
                                  <on type="date" setName="$date1">
                                             <in name="$$resetDates"/>
                                  </on>
                                  <on type="date" setName="$date2">
                                             <in name="$$paimentDate"/>
                                  </on>
                       <repeat>
                                  <coupon>
                                             <Actualise currency="EUR" country="FR" type="SWAP"></Actualise>
                                             <paymentDate name="$date2"/>
                                             <paymentAmount>
                                                       <product>
                                                                 <scalar name="$Nominal"/>
                                                                 <timeDiff fraction="true" convention="ACT360">
                                                                           <date name="$date1"/>
                                                                           <date name="$date2"/>
                                                                 </timeDiff>
                                                                 <max>
                                                                           <scalar>0</scalar>
                                                                           <minus>
                                                                                       <quote>
                                                                                       <underlying_id>1</underlying_id>
                                                                                       <date name="$date1"/>
                                                                                       </quote>
                                                                                       <scalar name="$strike"/>
                                                                           </minus>
                                                                 </max>
                                                       </product>
                                                       <scalar/>
                                             </paymentAmount>
                                  </coupon>
                       </repeat>
                       </iterate>
            </coupons>
</exotic>




                 Explication

                         •    La premeire balise d edeclaration nous permet comme son nom l’indique
                              à declarer les dates et listes de dates comme variables qu’on utilisera par
                              la suite facilement.
                         •    La balise coupons veut tout simplement dire dans notre cas qu’il y aura
                              des paiements sur des dates prédéfinis (notamment date2)
                         •    On remarque qu’on a besoin aussi de faire une boucle sur la date1 qui
                              correspond aux dates de reset des taux forward, c'est-à-dire à partir
                              desquelles les taux forward sont connus (et aussi pour faire la différence
                              de date –timeFraction- qui permettra de calculer les intérêt à payer)..



                                                                                                                          50
•   La balise quote nous permet de demander aux programme C++ de
    récupérer le prix d’un sous-jacent donné (ici le libor) à une date donnée
    (ici la date de reset, date1).
•   La balise actualise permet de choisir la courbe avec laquelle on va
    actualiser les coupons un à un.
•   On remarque que cette description du produits est incluse dans la balise
    exotique et notant qu’il aurait fallut definir aussi une balise du ss-jacent
    libor (underlying1),puis une balise marketData, option de diffusion… (
    voir descriptif edml dans la section d’avant).




                                                                               51
                              CONCLUSION




      Ce stage a été pour moi une occasion d’appliquer mes connaissances théoriques
apprises lors du master MMMEF et de découvrir l’environnement d’une société de
gestion (BNP AMS).
      L’apport a été aussi bien technique que humain.
      En effet, techniquement j’ai pu appréhender la complexité de l’implémentation
d’un modèle mathématique et aussi de comprendre parfaitement que la compréhension
théorique n’es pas suffisante mais c’est bien le résultat et la rapidité du traitement
informatique d’un modèle qui compte dans un environnement bancaire, car la
complétude voudrait un traitement instantané de l’information.
      Humainement, ce stage m’a permit de travailler sur ma communication en étant
le garant de l’intégration de nouvelles fonctionnalités dans le système SI_projet,
d’affiner mon sens de l’analyse et de la synthèse, et de développer ma résistance au
stresse et fournir un travail soutenu dans un environnement exigent.
      Malheureusement le temps n’a pas été suffisant pour développer une vision plus
critique des modèles de valorisation des taux d’intérêt notamment la prise en compte
du skew de volatilité qui pourrait être comblé grâce au modèle SABR par exemple et
qui servirait à pricer des produits sensibles au skew tels que les rangeAccruel ou les
Caption.
      Néanmoins, j’ai pu avoir une idée globale des méthodes de valorisation et de la
complexité technique des développements de modèles, ce qui me permettrait de mieux
appréhender mes missions futures.




                                                                                   52
                                           ANNEXE

A Inventaire de Produits de taux d’intérêt

 1.      Définitions

 •     Bi (t ) = B(t , Ti ) : le prix à l’instant t d’un ZC donnant 1 à la date Ti.
 •     Fi (t ) = F (t , Ti , Ti +1 ) : taux libor vu de t, reseté en T(i-1) et payé en Ti
 •    τ i = (Ti +1 − Ti ) l’intervalle permettant de calculer les interêts à payer
 •     S i , j taux de swap débutant à Ti et se terminant à Tj .

 2.      Produits de taux d’intérêt Vanilles

                   a.        FRA

           Un Forward Rate Agreement est un contrat de gré à gré, conclu entre deux
     parties, qui permet de se garantir un taux d’intérêt sur un emprunt ou un placement
     qu’on envisage de réaliser dans le futur sur le marché monétaire.

           PayOff :
           VFRA = N ( RK − F1 (t ))τ 1 B1 (t )
           N est le nominal sur lequel est calculé l’intérêt à payer
           Rk est le taux fixe de référence du contrat

           De ce fait, si Tx variable de réf > Tx fixe ; le vendeur du FRA rembourse la
     différence actualisée entre ces deux taux et si c’est le cas contraire, ce sera à
     l’acheteur de rembourser la différence.

          Remarque :Le FRA est dissocié d’un éventuel emprunt/prêt, que les
     contreparties contractent ailleurs.

           Stratégie :
           Un emprunteur fige le coût de son endettement futur en achetant le FRA, il se
     protège contre une hausse des taux d’intérêts ; un prêteur s’assure un taux de
     placement garanti en vendant le FRA, il se protège contre une baisse des taux
     d’intérêts.

                   b.        Swap

          Contrat permettant d’échanger un taux fixe contre un taux variable (vendeur de
     swap) ou le contraire pour l’acheteur, selon une périodicité prédéterminée.




                                                                                            53
                                                                       Le client souhaite payer un
                                                                       taux fixe.
                                                                       Il entre dans une swap payeuse
                                                                       et reçoit les mensualité
                                                                       variable qu’il rend à son
                                                                       prêteur et paye un taux fixe.

             Payoff
                         n
             JF (t ) = ∑ Sτ i Bi (t )
                        i =1
                          n
             JV (t ) = ∑ Fi (t )τ i Bi (t ) = B0 (t ) − Bn (t )
                        i =1



     on a donc : Vswap = JV (t ) − JF (t )         pour une swap payeuse de fixe.

      Remarque : Le taux fixe (appelé taux de swap ou CMS) est le taux qui égalise
les deux jambe au début du contrat
      La périodicité des flux fixes peut être différentes des flux variables.

             c.       CMS

      Le CMS (ou taux de swap de référence) est le taux qui égalise les deux jambes
(fixe et variable d’un swap) à la date de départ.

                                                       Bm (t ) − Bn (t )
                                        S m,n (t ) =       n

                                                         ∑τ B (t )
                                                        i = m +1
                                                                   i   i




             d.       Cap/Caplet

      C’est la contrepartie d’un call sur le marché des equity.
      Un Caplet est une option donnant le droit à son détenteur (acheteur) de se
couvrir contre la hausse d’un taux variable pendant une période donnée moyennant
le paiement d’une prime.
      Un Cap est la somme de caplets

     Payoff
     Le payoff d’un caplet avec une date de paiement t i et une reset date t i −1
     τ .N max( R(t i −1 , t i ) − Rk ,0) avec R(,) est le taux spot.

             e.       Floor/Floorlet

      Même principe que les Caplet sauf que les floorlets permettent de se couvrir
contre la baisse d’un tx variable. De même pour le floor qui est une somme de
floorlets.
      Payoff d’un floorlet :



                                                                                                        54
     τ .N max( Rk − R(t i −1 , t i ),0) avec R(,) est le taux spot.

             f.       Cap /Floor quanto :

      Une variante du cap standard : la devise dans laquelle est référencé le taux
variable diffère de celle servant au paiement de la prime et des différentiels d’intérêt.

             g.       Swap OIS (Overnight Indexed Swap) :

      Swap de taux indexé sur un taux au jour le jour. Par convention, si les flux sont
libellés en euro, le taux variable est indexé sur l’ « EONIA » et s’ils sont libellé en
dollar, il sera indexé sur le Overnight.

      Remarque : le niveau du taux variable de référence est constaté et capitalisé
sur les jours ouvrés jusqu’à la date de paiement du flux.



             h.       Swap variable – variable postfixé :

     Swap de taux pour lequel on compare un taux déterminé en début de période
d’application (préfixé) à un taux déterminé en fin de période (postfixé) moins une
marge déterminé lors de la conclusion du contrat, portant sur un nominal fixé et sur
une périodicité prédéterminée.

     Rq : le taux variable ici correspond au taux postfixé.

                                                                            Le client endetté
                                                                      à euribor 3 mois fixé
                                                                      en début de période
                                                                      d’application des
                                                                      intérêts, se retrouve
                                                                      endetté à Euribor en
                                                                      fin de période
                                                                      d’application des
                                                                      intérêts moins une
                                                                      marge fixée à 0.22%.

             i.       Swap de devises (Cross Currency Swap) :

      Contrat par lequel les parties s’échangent un nominal et des flux d’intérêt
libellés en devises différentes respectant une certaine périodicité prédéterminée.

     Remarque : le swap de devise est autant une garantie de taux qu’une garantie
de change.




                                                                                           55
              j.      Swap Quanto :

       Contrat pour lequel deux contreparties s’échangent des flux d’intérêts
 référencés sur des taux libellés en devises pour un montant notionnel (sans échange
 de ce dernier) MAIS réglés dans une devise unique.


              k.      Swap inflation :

       Contrat d’échange de flux d’intérêt indexés sur la progression de l’indice des
 prix à la consommation contre des flux d’intérêts à taux fixe ou variable dans une
 même devise portant sur un même montant notionnel.

      Remarque : les parties doivent convenir à la conclusion du contrat de l’indice
 de référence utilisé pour le calcul de la jambe inflation et la formule de cette
 dernière.



3.   Produits de taux d’intérêt complexes

              a.      Asset Swap (swap d’actif) :

        Combinaison de deux produits différents : un swap de taux d’intérêt et un achat
 de titre à un taux fixe.
        En achetant le titre, l’investisseur se voit payer des coupons, qu’ils donnent à la
 banque avec laquelle il rentre en swap payeuse. Le résultat est qu’il recevra le taux
 variable. En effet, l’investisseur détient un actif à taux variable qui ne se déprécie
 pas en cas de hausse des taux, contrairement à un titre à taux fixe.

              b.      Swap annulable :

      C’est un swap vanille dans lequel l’une des deux parties peut terminer le swap
 à une ou plusieurs dates.

      Remarque: il est considéré comme une combinaison entre un swap vanille et
 une swaption sur un swap symétrique.




                                                                                        56
             c.         Cap Up&Out / Up&In (Floor Down&out/Down&In) :

      Une variante du Cap standard : la protection n’est active que si le taux variable
est supérieur (inférieur) au strik (K) et Inférieur/Supérieur (Supérieur/Inférieur) à la
barre désactivante (Ref):Up&Out/Up&In (Down&Out )

     Remarque 1: pour le Cap, la barre désactivante est tjrs supérieur au strike, le
contraire pour le floor.
     Remarque 2 : l’activation ou désactivation se fait aux dates de reset, càd T(i-1)
pour un taux qui commence à T(i-1) et se termine à T(i).

     Exemple payoff : Cap Up&Out (K=3%; Ref=4%)
                    [
     V (t ) = ∑τ i max( Fi (t ) − K ;0)* ⇑ {Fi (t )< Re f }   ]




      stratégie :
       si un investisseur cherche a s’endetter mais ne veut pas payer plus de 3% et
qu’il a une idée précise sur l’évolution du taux (le taux libor ne dépassera jamais
4% !). il choisira d’acheter un Cap Up&Out, car celui-ci lui assurera un paiement
capé à 3%, si le libor ne depasse jamais 4% !

     Exemple payoff : Floor Down&In (K=2,2% ;ref=2%)

                    [
     V (t ) = ∑τ i max( K − Fi (t );0)* ⇑ {Fi ( t )< Re f }   ]




     stratégie :


                                                                                     57
      un client prêteur voudra se couvrir conter la baisse de taux au delà d’un
certain niveau (2% par exemple). Il achètera un floor down&in.

              d.         Cap /Floor à degrés (dual strike cap/floor):

     Variante du Cap standard : cette fois ci on aura deux strikes K1 et K2
(K1<Ref<K2) et un taux de référence Ref.
     Si le taux variable est inférieur/supérieur à Ref, le cap/Floor à degrés se
comporte comme un cap/floor standard avec K1 comme strike. Si le tx variable est
supérieur/inférieur à Ref, c’est le K2 qui devient strike du cap/floor standard.


     Payoff d’un dual floor:

                     [
     V (t ) = ∑τ i max( K 1 − Fi (t );0)* ⇑ {Fi (t )< Re f } + max( K 2 − Fi (t );0)* ⇑ {Fi (t )>= Re f }   ]
     graphe : ref =4%, K1=3.5% , K2=5%




              e.         Incremental fixed swap

     Variante du swap qui consiste à remplacer le taux fixe par une composition
conditionnelle au tx libor.

     Exemple de payoff :

                   Condition/libor3M                              Taux fixe
                   Libor3M>5.5                                    100% SwapRate
                   4.5<libor3M<5.5                                75%       SwapRate
                                                             +25%libor3M
                   3.5<Libor3M<4.5                                50% SwapRate +
                                                             50%libor3M
                   Libor3M<3.5                                    Libor3M

     JF (annuelle) et JV(trimestrielle)



                                                                                                                58
      JF = N * ( p * SwapRate + (1 − p ) * libor 3M )
      JV =   N
             4   * Libor 3M

     Remarque : Le taux de swap d’un IFS est supérieur à celui d’un swap
standard.


     Stratégie :
     Pour comprendre l’importance de ce produit, prenons l’exemple d’une
entreprise qui s’endette à taux variable libor3M dans 3 situation :
     (1) Elle ne fait rien
     (2) Elle contracte un swap de taux à 6%
     (3) Elle contracte un IFS à 6,3%




     Quand le taux variable augmente, la composante fixe augmente en proportion.
Une entreprise endettée à taux variable et payeuse de la patte fixe bénéficiera ainsi
d’une couverture efficace en cas de hausse des taux tout en profitant d’un coût de
financement réduit si les taux restent bas.

             f.        Subsidized Swap

      Est composé d’un swap payeur et de la vente d’un cap
      Prenons l’exemple d’une entreprise endetté à libor3M pendant 2ans.
      Elle décide de rentrer dans un swap grâce auquel elle aura à payer le tx fixe
(disons 5%). Elle vend aussi un cap de strike 6.5% (par exemple : le prix de chaque
caplet est 0.2%).

         Libor3M<=6.5%                          4.8%                    =5%-
                                                                 0.2%
         Libor3M>6.5%                           Libor3M-              =libor3M-
                                         1.7%                    6.5%+5%-0.2%

      Remarque : ce genre de produit est contracté lorsque l’investisseur prévoit une
limite sup raisonnable au libor qui ne sera pas dépassée.



                                                                                  59
                   g.          CMS swap

        Swap dont l’une des jambe est indexée sur un taux de swap long terme. En
  général, la date d’observation du taux de swap correspond à la période antérieure à tt
  flux.

       payOff :
       Exemple :tx fixe                   Swap2ans

        C t = ∑τ i N ( S ti ,ti + 2 ans (t ) − R) B(t , t i )

                   h.          CMS spread Note:

       Un swap dont le payoff est basé sur la différence entre deux taux de swap de
  maturités différentes (par exemple swap 10 ans et 5 ans).

       payOff :
       Exemple : swap20ans                         swap10ans

        C t = ∑τ i N ( S ti ,ti + 20 (t ) − S ti ,ti +10 (t )) B(t , t i )

                   i.          Swap à flux décales :

        Swap de taux pour lequel les paiements effectués à une date sont calculés avec
  le taux variable observé à cette même date et non pas à la date antécédente comme
  c’est le cas pour les swap vanille.

       Remarque : l’évaluation du swap se fait avec le taux forward après ajustement
  de convexité. (le ss-jacent est donc un tx forward )

                   j.          Swap à capitalisation conditionnelle (Acrual swap) :

        L’intérêt d’une des deux parties n’est capitalisé que si la référence du taux
variable se situe dans un certain intervalle. Cet intervalle peut être fixe ou modifié
périodiquement.


                                                                                         60
               k.        Swaption payeuse/receveuse :

       Option européenne portant sur un swap qui confère à son acheteur le droit de
rentrer dans un swap.
       Stratégies :
       Une entreprise prévoit un endettement dans 1an, pour une durée de 5ans à taux
variable. Elle préfère payer un taux fixe (ne depassant pas 6% par exemple) donc
elle achète une swaption qui lui permettera de payer un taux fixe 6% et de recevoir
le libor. Si ds un an, le tx de swap est superieur à 6%, elle exerce sa swaption sinon
elle rentre ds un nouveau swap.

      Exemple : swaption donnant le droit de entrer ds un swap 10ans à l’instant T1.
                               1

                               ∫ rds
      Swaption(0) = E (e 0             max(S T1 ,T1 +10 (t ) − S K ,0))
                                          [
      Swaption (0) = BT1 ,T1 +10 (0) ET1 ,T1 +10 ( S T1 ,T110 (T )) N (d 1 ) − KN (d 2 )   ]




               l.        Swaption bermudéenne payeuse/receveuse :

      Une variante de la swaption payeuse/receveuse dans le sens où il s’agit d’une
sorte d’option américaine discrète. C’est-à-dire qu’on peut exercer l’option tout au
long de la période du contrat à diverses dates correspondant aux dates de
détermination du taux variable (l’option donnant le droit de l’exercer à tt moment
tout au long de la vie du produit !)


               m.        Range accrual (accrual swap)

      Titre dont le coupon dépend du nombre de jours pendant lesquels le taux de
référence s’est trouvé à l’intérieur d’un tunnel (une fourchette prédéterminée).

                                                 nbdejour ( Rmin < F (t , t st , t st ) < Rmax )
     Ci = τ i * R * Θ i        avec Θ i =
                                                             nbdejour (τ i )



                                                                                                   61
      Cette formule correspond au paiement à la date Ti d’un range accrual basé sur
un libor k mois. Ces libor de référence sont constaté (disons à la date t) et fixé tt au
long de l’intervalle [Ti-1,Ti] aux dates Tst.
      Chaque jour Tst contribue par conséquent au paiement :
                                τ i R 1 → Rmin < F (t, t st ,t st +k ) < Rmax
       Ci (t ) = B(t , ti ) *      *                                            avec   Mi =
                                M i 0 → else
nbjour τ i



               n.        Ratchet Cap

      Même concept qu’un cap vanille avec des strike Ki (K strike et m limite
définie) :
            K ...............i = 1
      Ki = 
           min( Li −1 + X , m)....i > 1



      le payoff ainsi sera donné par la formule :

       L * (t k +1 − t k ) * max( Lk − min( Lk −1 + X , m),0)




               o.        Sticky Cap :

      Même principe :

            min( K , m)..............................i = 1
       Ki = 
            min(min(K i −1 , Li −1 ) + X , m)....i > 1

               p.        Flexi Cap:

     La particularité de cette instrument réside dans le fait que seulement les n
premiers in-the-money caplets qui sont exercés.

               q.        Chooser Cap :



                                                                                         62
        La seule différence avec un flexi cap est que les n caplets sont choisit par
  l’acheteur lui-même avant leurs reset dates (date de détermination du taux pour
  chaque période).

                r.       Snowballs (callable snowballs)

        Est un produit « path-dependent ». Le coupon actuel est déterminé grâce au(x)
  coupon(s) précèdent en y ajoutant un spread fixe moins un taux variable (libor 3mois
  « par exemple). La particularité du produit réside dans le fait que le coupon peut être
  nul (si par exemple le libor 3mois est plusieurs fois de suite supérieur au spread).
  L’option est le plus souvent flooret.

         C i (t ) = ∑ B(t , t i ) Ri avec Ri = max(ai Ri −1 + xi + bi Fi , Gi ) avec bi négative




B APPELS D’OFFRES SIGMA QUANT


1.     DIFFERENCE DE DATES :

                a.       Problématique :

            La problématique concerne le décompte de jours calendaire ainsi que le
     nombre de jour d’une année. En effet, il existe des conventions très précises, qui
     dépendent du pays concerné ou encore du produit financier traité, concernant les
     jours considérés comme ouvrés et comment les accidents de calendrier (samedi,
     dimanche et jours fériés) affectent, instrument par instrument, les durées standards
     de calcul.
            Il nous faut par conséquent définir des bases de calcul, qui se présentent sous
     la forme : nombreDeJourD’interet/nombreDeJourAnnée.
            Citons par exemple :
            •     ACT/360
            •     ACT/365
            •     ACT/ACT
            •     30 E/360 (euro bond basis)
            •     30 U/360 (american bond basis)
            Notons que l’ISDA (International Swap Dealer Association) nous précise
     une convention (appelée ISDA) pour cadrer les conditions générales relatives à la
     négociation de produits dérivés entre deux parties.
            Afin de sécuriser les paiements interbancaires en Europe, il a été mis en
     place un noyau officialisé obéissant à des règles très strictes, réservé aux
     principales places financières, aux banque nationales et à la BCE, tous relié par le
     système informatique TARGET de la BCE. C’est justement ce calendrier qui sera
     utilisé dans nos développements.

                b.       Le développement C++ :



                                                                                                   63
            La librairie quantLib nous donne une large gamme de choix de conventions
     pour effectuer des fractions de dates. Ces bases de calcul sont représentées sous
     forme de classes objet héritant de la classe mère DayCounter.

             Exemple (ACT/360) :

     if(conv== "30EU360") //EU
     diffDate= (double)Thirty360(Thirty360::European).yearFraction(argument1_,argument2_)

            Pour pouvoir utiliser la convention ISDA, il nous est imperatif d’utiliser la
     base de calcul ACT/ACT :

     diffDate= (double)ActualActual(ActualActual::ISDA).yearFraction(argument1_,argument2_);

             On peut aussi être amené à faire une simple différence de date. Pour cela, il
     n’existe pas dans la quantLib une fonction explicite qui nous permet de le faire. On
     a eu recourt au calendrier TARGET, qui nous permet de connaître les jours fériées
     et week-ends exacts. Ainsi, grâce à une simple boucle, on arrive se décaler pour ne
     comptabiliser que les jours ouvrés.

                 c.        L’utilisation EDML

           La balise xml qui permet de faire le calcul de dates est nommée : timeDiff

           <timeDiff fraction="true" convention="ACT360">
                 <date name="$date2"></date>
                 <date name="$date1"></date>
           </timeDiff>

          Lorsque l’attribue « fraction » est à false. Ceci veut dire que l’utilisateur veut
     simplement faire une différence de dates. S’il est à true, il faudra qu’il spécifie la
     convention qui lui permettra de faire une fraction de dates.


2.     STRATEGIE :

                 a.        OBPI vs CPPI

             Les méthodes portfolio insurance consistent à permettre à un investisseur
     de se couvrir contre les baisses du marché tout en profitant des hausses favorables.
             OBPI et CPPI sont deux stratégies qui rentrent dans ce cadre :

             •       OBPI (Option Based Portfolio Insurance) : consiste à investir dans
     un stock ou un indice (ou plusieurs) et à se couvrir grâce à un put sur le même
     actif. Ceci revient, grâce à la parité call/put, à acheter un zéro coupon et un call.

                 OBPI T = S T + ( K − S T ) + = K + ( S T − K ) +
             et donc OBPI t = Ke − r (T −t ) + Call (t , S t , K )

             •      CPPI (Constant Proportion Portfolio Insurance) : consiste en une
     stratégie dynamique qui permet d’assurer à tout instant t un niveau de garantie


                                                                                               64
dépendant du temps. Le principe est que la somme d’actifs investie dans les
produits risqués dépend du coussin (qui lui-même dépend de la garantie) et d’un
multiple.


        La stratégie OBPI donne à son détenteur la possibilité de profiter beaucoup
plus des hausses de prix de l’actif risqué mais à l’opposé ne permet pas de couvrir
une baisse. Cependant, la stratégie CPPI est plus conservatrice car elle permet une
decorrélation des performances de l’actif risqué mais par conséquent ne permet pas
de profiter des hausses.




        payOffs d’OBPI et CPPI en fonction de la valeur de l’actif risqué

          b.          formules :

       OBPI t = q tcall * callt + q tZC * ZC t + q tmonetaire * monetairet
                    −1               −1             −1

                       0 → t = 0
                       
       avec q =  OBPI t − [( garanty t * fees * τ ) + ( garanty t * ZC t )]
               call
               t
                                          call t
                       
                    0 → t = 0
          qtZC = 
                     garanty t
          q tgaranty = OBPI 0
                         OBPI 0 → t = 0
           qtmonetaire = 
                          garanty t * fees *τ




       CPPI t = qtstock *S t + q tZC * ZC t + q tmonétaire * monetairet
                   −1             −1             −1




                                                                                  65
                                               qtstock → min ≤ multiple ≤ max
                                                   −1
                                               
                          avec qtstock        =       multiple * cous sin t CPPI t * max Exposition
                                               min(         stock t
                                                                            ,
                                                                                      stock t
                                                                                                     )
                                               
                                   cous sin t = CPPI t − [( garanty t * fees * τ ) + ( garanty t * ZC t ) ]
                                   garanty t = CPPI 0
                                         q tZC → min ≤ multiplet ≤ max
                                             −1
                                         
                                   qt = 
                                    ZC

                                           min( garanty t ,
                                                                                   [
                                                               CPPI t − stock t * q tstock + garanty t * fees * τ                     ]
                                                                                      ZC t
                                         
                                                stock t * q tstock
                                                              −1
                                   multiplet =
                                                  cous sin t

                                 monetaire garanty t * fees
                                qt −1     −                 → min ≤ multiplet ≤ max
              q   monetaire
                  t            =                365
                                          t                 t         t           [
                                [garanty * fees * τ + CPPI ] − garanty * fees * τ + stock * q stock + ZC * q ZC
                                                                                          t   t          t   t                                     ]
                                  c.          Développements :

                   Le but du projet est la modification de la façon dont les stratégies sont prises
             en compte dans le système d’information SI_projet pour permettre leur
             spécification analytique directement grâce au langage EDML2.0
                   De plus, le but est de permettre un suivi instantané de l’évolution des cours
             de sous-jacent, des paramètres des stratégies et de leurs valeurs
                   Clairement, les stratégies étaient des actifs à part et n’héritaient pas
             forcement d’une classe mère représentant un actif particulier. Un premier travail a
             été mené par une stagiaire pour considérer les stratégies comme des marketAsset
             mais leur description dans le langage EDML2.0 a été trop encadrée pour donner
             aux investisseurs la liberté de créativité. Ainsi, on a décidé de considérer les
             stratégies du même niveau qu’un dérivé (c'est-à-dire dérivant de la classe
             TPayOff) et composées de leur propre calendrier de diffusion,
             d’earlyRedemption…
                   Le graphique ci-dessous nous montre les résultats d’une stratégie mix
             (40%OBPI, 60%CPPI). Ces développements permettent par conséquent d’utiliser
             plusieurs stratégies en même temps et de suivre l’évolution de leurs composants et
             de leurs valeurs tout au long du temps.

 1,3
1,25
 1,2                                                                                                                                  obpi

1,15                                                                                                                                  cppi
                                                                                                                                      zc
 1,1
                                                                                                                                      monetaire
1,05
                                                                                                                                      stock
  1                                                                                                                                   MIX
0,95
 0,9
17/06/2007   06/08/2007       25/09/2007   14/11/2007   03/01/2008   22/02/2008   12/04/2008   01/06/2008   21/07/2008   09/09/2008


               Comparaison entre une stratégie OBPI et CPPI & résultats de leur mix



                                                                                                                                              66
3.     BACKTEST & ENVELOPPES

                a.      principe

          Le backtest consiste à reproduire un scénario sur un intervalle durant une
     période précise en se décalant à chaque fois d’un jour. Concrètement, ceci nous
     donnera le comportement de notre fond historiquement. C'est-à-dire si les
     conditions historiques concernant une certaine période venait à se reproduire, le
     backtest refléterait le résultat qu’on aurait eu. Ceci est d’autant plus intéressant
     qu’on sait que les marchés financiers sont animés par la théorie du mime.

                b.       Automatisation
           Mon dernier projet a concerné l’automatisation de backtest pour le compte
     des structureur. En effet, ces derniers nous sollicitent toujours pour des backtest de
     dernières minutes et une idée était d’automatiser cela pour que çela prenne moins
     de temps.
           Le but était d’écrire le payOff du fond sous format xml et de le mettre en
     input dans le système SI_projet. Ce dernier nous donnerait le résultat du backtest
     dans un fichier xml.




                                                                                            67
                                  BIBLIOGRAPHIE


Produits de Taux d'Intérêt : Méthodes dynamiques d'évaluation et de couverture ;Lionel
Martellini, Philippe Priaulet


Interest Rate Models: Theory and Practice;Brigo Damiano, Mercurio Fabio


Modeling Derivatives in C++; Justin London


Options, futures and other derivatives; John hull




                                                                                    68

				
DOCUMENT INFO
Shared By:
Tags:
Stats:
views:851
posted:5/14/2010
language:French
pages:68