
\documentclass{article}


% définition des en-têtes et pieds de page:



\usepackage{xcolor}

\usepackage[linktocpage]{hyperref}

\makeatletter
\makeatother
% Partie d{\'e}clarations (style, nouvelles commandes, etc)
%=========================================================
\usepackage[latin1]{inputenc}
\usepackage[french]{babel}
\usepackage[dvips]{color}
\usepackage{amsmath}
\usepackage{amssymb}
\usepackage{verbatim}

\usepackage{times}
\usepackage{graphicx, algorithm,pdfsync}
\usepackage{graphicx}
%\usepackage{ragged2e}
%\usepackage{rotating}


\usepackage{geometry}

\geometry{ hmargin=2.5cm, vmargin=1.5cm }

\newcommand{\R}{\ensuremath{\mathbb R}}
\newcommand{\N}{\ensuremath{\mathbb N}}
\newcommand{\Z}{\ensuremath{\mathbb Z}}
\newcommand{\C}{\ensuremath{\mathbb C}}
\newcommand{\E}{\ensuremath{\mathbb E}}
\newcommand{\V}{\ensuremath{\mathbb V}}
\def\Rtwo{\R^2}
\def\ds{\displaystyle}
\newcommand{\uim}{{\bf i}}
\title{Calcul et Analyse Numérique \\ Projet : Choix de stratégie avec gestion de risques \footnote{ \emph{Toute la bibliothèque des classes utilisées ainsi que l'ensemble des codes sources de ce projet se trouvent sur le site http://starbrood.free.fr/projetfinance}}} 
\author{Rhita Cherkaoui \\ Marine Ducourant \\ Pouya Eshaghi \\ Florian Gauch \\ Florent Heitzmann \\ Charlotte Laurent}
\begin{document}
\thispagestyle{empty} 
\maketitle
\begin{center}
\includegraphics[width=\textwidth]{logo.jpg}
\end{center}
\newpage
~
\newpage
\tableofcontents 
\newpage

\section{Analyse de données financières}
L'objet de cette partie est d'analyser les cours de trois données financières sur une période d'environ 10 ans. Nous nous intéresserons tout d'abord à l'évolution du taux de change EUR/USD depuis la création de l'euro (données collectées sur le site de la Banque Centrale Européenne : http://www.ecb.int), puis à l'évolution de l'indice CAC 40 depuis le deuxième semestre 2000, et enfin au cours de l'action Teleperformance, côtée sur le marché parisien hors CAC 40, également depuis le deuxième semestre 2000 (les données concernant le CAC et Teleperformance ont été trouvées sur le site de \emph{ABC Bourse} : http://www.abcbourse.com). Pour simplifier, on considèrera pour la simple étude de la variance et de la moyenne, les indices comme des actifs financiers. Les trois séries chronologiques sont analysées ci-dessous.

\subsection{Analyse des séries chronologiques}

\subsubsection{Moyenne et Variance des incréments logarithmiques}
Pour un actif ou un indice donné on note $N$ le nombre de jours de la période d'étude, donc le nombre de données dont on dispose. Le cours de l'actif au jour $i$ est noté $S_i,~1\leqslant i\leqslant N$, et l'on va s'intéresser aux incréments logarithmiques $ \ln(S_{i+1})-\ln(S_i)=\ln(S_{i+1}/S_i)$. On modélisera nos actifs financiers (en temps continu) chacun comme un processus d'Itô s'écrivant :
\begin{equation}
S_t=S_0+\int_0^t \mu S_s \,ds + \int_0^t \sigma S_s \,dW_s
\end{equation}
Où $W_t$ est un mouvement Brownien standard. Il vérifie donc l'équation différentielle stochastique :
\begin{equation}
dS_t = S_t(\mu dt+ \sigma dW_t)
\label{Dynamique}
\end{equation}
Dont on sait qu'elle admet une solution unique donnée par :
\begin{equation}
S_t=S_0 \exp \left\{ (\mu - \frac{\sigma ^2}{2})t + \sigma W_t \right\}
\label{Exacte}
\end{equation}

Pour introduire un schéma discret, nous choisirons un incrément de temps $h$. Pour $i$ fixé, on s'intéresse donc à $\ln(S_{i+h})-\ln(S_i)$. En utilisant la formule (\ref{Exacte}), nous obtenons pour l'espérance :
\[ \begin{split}
\E [\ln(\frac{S_{i+h}}{S_i})] & = \E [ \ln(S_{i+h}) - \ln(S_i)] \\
& = \E [ (\mu - \frac{\sigma^2}{2})h + \sigma (W_{i+h} - W_i) ] \\
& = (\mu - \frac{\sigma^2}{2})h 
\end{split}
\]
En utilisant le fait que $(W_{i+h} - W_i)$ suit une loi $\mathcal{N} (0,h)$. Pour la variance nous obtenons de même, grâce à (\ref{Exacte}) :
\[ 
\V[\ln(\frac{S_{i+h}}{S_i})] = \V[(\mu - \frac{\sigma^2}{2})h + \sigma (W_{i+h} - W_i)] = h\sigma^2 
\]
Nous allons étudier la moyenne et la variance empiriques des incréments logarithmiques de nos trois séries chronologiques, avec dans notre cas $h=1$, les pas de temps seront donc $ih=i,~1\leqslant i\leqslant N$.

\newline\newline

\subsubsection{La parité Euro-Dollar}
Nous avons le cours de la parité EUR/USD du 29/01/1999 au 08/06/2009, ce qui correspond à 2650 jours de cotation. La série chronologique obtenue est présentée ci-dessous :

\begin{center}
\includegraphics[width=0.65\textwidth]{EURUS.pdf}
\end{center}
Nous calculons les moyenne et variance empirique de la série $L(S)=(\ln(\frac{S_{i+1}}{S_i})), 1\leqslant i\leqslant N-1$, soit :
\[ \begin{split}
& \tilde{\E} [L(S)] = \frac{\sum_{i=1}^{N-1} \ln(\frac{S_{i+1}}{S_i})}{N-1} \\
& \tilde{\V} [L(S)] = \frac{\sum_{i=1}^{N-1} ( \ln(\frac{S_{i+1}}{S_i})-\tilde{\E} [L(S)] ) ^2}{N-1}
\end{split}
\]
Ces statistiques se calculent très simplement, et l'on renvoie à la section suivante pour le calcul numérique. Notons que l'estimateur de la variance empirique est celui de la méthode des moments. Il est biaisé, on pourrait le débiaiser en le multipliant par $(N-1)/(N-2)$, mais nous voulons surtout ici pouvoir calculer $\mu$ grâce à cet estimateur, et non l'étudier parfaitement. Le nombre de jours $N$ est suffisamment grand pour que cet estimateur convienne et nous l'utiliserons toujours par la suite. Les valeurs de $\mu$ et $\sigma$ se déduisent de ces estimateurs de la manière suivante :
\[ 
\left\{ \begin{array}{rl}
(\mu -\frac{\sigma^2}{2}) & = \tilde{\E} [L(S)] \\
\sigma^2  & = \tilde{\V} [L(S)] \end{array} \right 
\]
Ce qui donne :
\begin{equation}
\left\{ \begin{array}{rl}
\mu & = \tilde{\E}[L(S)] + \frac{\tilde{\V}[L(S)]}{2} \\
\sigma^2 & = \tilde{\V}[L(S)] \end{array} \right 
\label{MuEtSigma}
\end{equation}

Nous obtenons pour le taux EUR/USD les résultats suivants.
\vspace{7mm}
\begin{center}
\begin{tabular}{|*{2}{c|}l | r|}
 \hline
  Moyenne des incréments logarithmiques &  Variance des incréments logarithmiques & $\mu$ & $\sigma^2$ & \hline
  7,44.10^{-5}& 4,50.10^{-5} & 9,69.10^{-5} & 4,50.10^{-5} & \hline
\end{tabular}
\end{center}
\vspace{7mm}

\newline\newline
\subsubsection{L'indice CAC 40}
Nous disposons pour l'indice CAC 40 d'un échantillon de 2281 valeurs, correspondant aux jours de cotations entre le 03/07/2000 et le 08/06/2009. La série chronologique est représentée ci-dessous.

\begin{center}
\includegraphics[width=0.65\textwidth]{CAC.pdf}
\end{center}
Comme pour l'Euro-Dollar, on utilise les relations (\ref{MuEtSigma}) pour calculer $\mu$ et $\sigma$ à partir des résultats obtenus. Ces derniers sont consignés dans le tableau suivant.
\vspace{7mm}
\begin{center}
\begin{tabular}{|*{2}{c|}l | r|}
 \hline
 Moyenne des incréments logarithmiques &  Variance des incréments logarithmiques & $\mu$ & $\sigma^2$ & \hline
 -2,99.10^{-4}& 2,52.10^{-4} & -1,73.05^{-4} & 2,52.10^{-4} & \hline
\end{tabular}
\end{center}
\vspace{7mm}
\newline\newline
\subsubsection{Le cours de l'action Teleperformance}
Nous disposons d'un echantillon de l'action Teleperformance (code RCF) semblable à celui du CAC 40 : 2281 valeurs correspondant aux jours de cotation entre le 03/07/2000 et le 08/06/2009. La série chronologique est représentée ci-dessous.
\begin{center}
\includegraphics[width=0.65\textwidth]{RCF.pdf}
\end{center}
Grâce à (\ref{MuEtSigma}), on calcule $\mu$ et $\sigma^2$ pour ce titre.
\vspace{7mm}
\begin{center}
\begin{tabular}{|*{2}{c|}l | r|}
 \hline
 Moyenne des incréments logarithmiques &  Variance des incréments logarithmiques & $\mu$ & $\sigma^2$ & \hline
 2,65.10^{-4}& 6,85.10^{-4} & 7,75.10^{-4} & 6,84.10^{-4} & \hline
\end{tabular}
\end{center}
\vspace{7mm}
\newline\newline\newline
\subsection{Programmation}
\subsubsection{Principes et choix de programmation}
Nous avons choisi de programmer nos méthodes en C++. L'inconvénient par rapport à Matlab repose sur le fait que la visualisation des résultats se fait par l'intermédiaire de fichiers texte de coordonnées de points \verb+.dat+. Pour le rendu graphique, nous utilisons principalement Gnuplot. Pour la compilation C++, nous compilons sous cygwin par la commande g++. Après compilation, nos programmes sont exécutables par un double clique sous la condition d'avoir cygwin.dll présent sur le disque et chargé dans la registrie windows ou la console de commande. Il est également possible de créer une interface java (appletscript) pour éxécuter le programme et afficher les résultats sous forme de texte. \newline
Résumons le but du programme de cette partie. À partir d'un fichier texte qui contient une série chronologique sous la forme \verb+[date][cotation]+, on va calculer les incréments logarithmiques $\ln(\frac{S_{i+1}}{S_i}),~ i \in \{1,..,N-1\}$ (on renvoie à la section suivante pour le formalisme des calculs). $i$ représente la $i$-ème journée de cotation en partant du jour $t_0=0$. Pour garder la correspondance date réelle $\leftrightarrow$ journée de cotations, on stocke les dates dans un vecteur dates indexé de la même façon que les cotations. On va ensuite calculer les moyennes et variances empiriques (estimateurs des moments) des incréments logarithmiques précédents. On calculera $\mu$ et $\sigma$ sur l'ensemble de la période puis par périodes mobiles de 3, 6, 9 ou 12 mois. 

\subsubsection{Choix de la structure}
     Le problème entier est traité par la classe \verb+Outils+ que nous allons présenter. Son constructeur prend uniquement en paramètre le nombre de jours et le nom du fichier à considérer. Les noms des fichiers créés par la suite dépendront de cette chaîne de caractère.
\begin{center}
\includegraphics[width=\textwidth]{Outils.pdf}
\end{center}
     On observe que les moyennes et variances empiriques des incréments logarithmiques ne sont pas stockées dans des vecteurs. Ils sont par contre renvoyés par la méthode \verb+KN<R> meanVarMob(int mois)+ puis directement imprimés ou stockés dans le \verb+main+ pour d'éventuelles manipulations. Nous avons donc choisi d'importer la bibliothèque \verb+RNM+ fournie par le laboratoire Jacques-Louis Lions, rattaché à l'université Pierre et Marie Curie. Son code sera placé en annexe. Notons que cette bibliothèque permet l'implémentation de tableaux de tous types grâce à l'utilisation de templates. Dans la même optique, en important la classe \verb+R2+ par le fichier d'en-tête \verb+R2.hpp+, nous pouvons implémenter des tableaux de \verb+R2+ par la déclaration \verb+KN<R2>+ qui permet dans un vecteur de stocker les moyennes et variances par exemple. Présentons tout de suite le code de cette partie : 
\newline
\subsubsection{Code C++ Partie I}
\vspace{7mm}
\hline
\begin{verbatim}
 
Outils::Outils(char* fname2,const int N2):N(N2){
  readFile(fname2);h=1/((R)(N2-1));
} 
   
void Outils::readFile(char* fname){
  name=fname;
  KN<string> datesaux(N);KN<R> cotationsaux(N);double cours=0;
  fstream readera(fname, ios_base::in);
  int compteur=0;
  if(readera.is_open()){  //while(true){ si pbleme de buffer
     for(int i=0;i<N;i++){
        readera >> datesaux[i] >> cotationsaux[i];
        if(readera.eof()){ break;}//developper ou insérer un assert
    }
  }
  //CAS SPECIAL car les dates sont décroissantes pour eurus.dat
  if(fname=="eurus.dat"){
  KN<string> datesinverses(N);
  KN<R> cotationsinverses(N);
  for(int i=0;i<N;i++){
    datesinverses[i]=datesaux[N-1-i];
    cotationsinverses[i]=cotationsaux[N-1-i];
  }
    dates=datesinverses;
    cotations=cotationsinverses;
  }else{
     dates=datesaux;
     cotations=cotationsaux;
  }
}    
 
void Outils::Vectorprinter(KN<R> vecteur, const char* fnamev){
	 ofstream plot(fnamev);
	 for(int it=0;it<=N;it++){
	   plot << it << " " << vecteur[it]<< endl; 
	 }           
}

int Outils::getMobParam(KN<R2> vecteur){
    int compteur=0;R nul=0.;
    for(int i=0;i<N;i++){
      if(!vecteur[i][0]==nul){break;}
      compteur++;    
    }
    return compteur;                  
}

void Outils::printMeanAndVar(KN<R2> vecteur,int i){
  // getMobParam renvoie le nombre de jours utilisés pour moyenne mobile
  int param=getMobParam(vecteur)/21;
  if(i==0){
    KN<R> m(N);
    for(int i=0;i<N;i++){
      m(i)=vecteur[i][0];   
    }
    //cette partie permet de générer un nom de fichier
    //en fonction de param : nbre de jour des périodes glissantes
    string moyfname="moymob";
    stringstream bufferm; 
    bufferm<<moyfname<<param<<"-"<<name;
    const char* fm = bufferm.str().c_str();
    Vectorprinter(m,fm);
    
  }else if(i==1){
     KN<R> v(N);
     for(int i=0;i<N;i++){
       v(i)=vecteur[i][1];}
     string varfname="varmob";
     stringstream bufferv;
     bufferv<<varfname<<param<<"-"<<name;
     const char* fv = bufferv.str().c_str();
     Vectorprinter(v,fv);
  }else if(i==2){ //pour imprimer dates
     string datesfname="table";
     stringstream bufferv;
     bufferv<<datesfname<<"-"<<name;
     const char* days = bufferv.str().c_str();
     ofstream plot(days);
	   for(int it=0;it<N;it++){
	   plot << it << " " << dates[it]<<" "<<cotations[it]<<endl; }
  }
}

R2 Outils::getMeanAndVar(KN<R> vect){
  R mean=0.;R var=0.; //var est en réalité un écart type
  for(int i=1;i<N;i++){
    mean+=log(vect[i]/vect[i-1]); }
  mean=mean/N;
  for(int k=1;k<N;k++){
    var+=pow(log((vect[k]/vect[k-1])-mean),2);}
  var=var/N;
  R2 result(mean,var);
  return result;
}

KN<R2> Outils::meanVarMob(int mois){ 
  KN<R2> meanvarmob(N);
  R meant;R vart;R2 temp(0.,0.);
  for(int k=0;k<21*mois;k++){
    meanvarmob[k]=temp;}
  for(int i=21*mois;i<N;i++){
    meant=0.;vart=0.;
    for(int j=i-21*mois+1;j<=i;j++){
      meant+=log(cotations[j]/cotations[j-1]);  }
    meant=meant/(21*mois-1);
    for(int j=i-21*mois+1;j<=i;j++){
      vart+=pow(log((cotations[j]/cotations[j-1])-meant),2); }
    vart=vart/(21*mois-1);
    R2 meanvaraux(meant,vart);
    meanvarmob[i]=meanvaraux;
  }
  return meanvarmob;
}
\end{verbatim}
\hline
\vspace{7.mm} 

Arrêtons nous ici pour commenter ces méthodes. Le constructeur initialise \verb+N+ et la chaîne de caractère \verb+fname+ et fait appel à la méthode \verb+readFile+ qui lit le fichier de nom "fname" présent dans le même répertoire que le programme. La série chronologique est stockée dans \verb+cotations+ qui est un vecteur de type \verb+KN<R>+ de taille $N$. Le vecteur de \verb+string+ \verb+KN<string>+ \verb+dates+ stocke les dates correspondant à chaque jour de cotation sous forme de chaîne de caractère. On peut ainsi retrouver quelle était la date réelle du cours du \verb+i+-ème jour de cotation enregistré dans \verb+cotations[i]+. Le cas de l'Euro-Dollar est traité spécifiquement car les cotations sont classées par ordre décroissant (en temps). Une méthode aurait pu être programmée dans notre code pour vérifier si les cotations sont classées par ordre croissant, ou encore une grammaire pour traiter les dates et leur affecter des opérateurs. Mais restons ici concentrés plus sur les résultats que sur la syntaxe pour cette partie du problème. 

Commentons le code pour les moyennes mobiles et les variances mobiles des incréments logarithmiques. La méthode \verb+KN<R2> Outils::meanVarMob(int mois)+ renvoie un vecteur de R2 \verb+meanvarmob+ tel que \newline \verb+meanvarmob[i][0]+ désigne la moyenne mobile des incréments logarithmiques pour le $i$-ème jour de cotations. \verb+meanvarmob[i][0]+ renvoie quant à lui la variance mobile du $i$-ème jour de cotation. On a dans ce cas par rapport au paramètre \verb+int mois+ : $\forall i \in \{0,1,...,21*mois-1\}$, \verb+meanvarmob[i][0]=meanvarmob[i][1]=0+. Les périodes glissantes sont décentrées à gauche en temps en chaque points. La méthode \newline \verb+getMobParam(KN<R2>VecteurdeGain)+ permet ainsi par exemple de retourner le paramètre (en nombre de jours) des périodes glissantes utilisées pour calculer le vecteur \verb+VecteurdeGain+. Grâce à cette méthode, la classe \verb+Outils+ permet d'imprimer des noms de fichiers automatiquement correspondants aux paramètres utilisés. Pour la conversion \verb+jour/mois+, nous avons considéré une moyenne de 21 jours de cotations par mois. C'est ce qu'illustre la méthode \verb+void doAll(Outils Objet)+ qui permet l'impression des fichiers qui nous intéressent :
 \newline
 \hline
 \begin{verbatim}    
void doAll(Outils objet){
  R2 meanvar=objet.getMeanAndVar(objet.cotations);
  cout<<"mean and variance des increments "`;
  cout<<logarithmes ln(Si+1/Si) : "<<endl<<meanvar<<endl;
  KN<R2> meanvarmob3mois=objet.meanVarMob(3);
  KN<R2> meanvarmob6mois=objet.meanVarMob(6);
  KN<R2> meanvarmob9mois=objet.meanVarMob(9);
  KN<R2> meanvarmob12mois=objet.meanVarMob(12);
  const char* name;
  string moyfname="tendances";
  {stringstream bufferm;
  bufferm<<moyfname<<"-"<<objet.name;
  name= bufferm.str().c_str();}     
  ofstream plot(name);
  R mu3;R mu6; R mu9; R mu12;
  for(int it=0;it<objet.N;it++){
    mu3=((meanvarmob3mois[it][0]+meanvarmob3mois[it][1]/2.));
    mu6=((meanvarmob6mois[it][0]+meanvarmob6mois[it][1]/2.));
    mu9=((meanvarmob9mois[it][0]+meanvarmob9mois[it][1]/2.));
    mu12=((meanvarmob12mois[it][0]+meanvarmob12mois[it][1]/2.));
    plot << it <<" "<< mu3 << " "<<mu6<<" "<<mu9<<" "<<mu12<<endl;  }
  const char* namevol;
  moyfname="volatilites";
  {stringstream bufferv;
  bufferv<<moyfname<<"-"<<objet.name;
  namevol= bufferv.str().c_str();}     
  ofstream plot2(namevol);
  R sigma3;R sigma6;R sigma9;R sigma12;
  for(int it=0;it<objet.N;it++){  
    sigma3=sqrt(meanvarmob3mois[it][1]); //62 jours
    sigma6=sqrt(meanvarmob6mois[it][1]); //125 jours
    sigma9=sqrt(meanvarmob9mois[it][1]); //188j
    sigma12=sqrt(meanvarmob12mois[it][1]); //251
    plot2<<it<<" "<<sigma3<<" "<<sigma6<<" "<<sigma9<<" "<<sigma12<<endl;}
  objet.printMeanAndVar(meanvarmob3mois,2); //imprimer cotations 
  objet.printMeanAndVar(meanvarmob3mois,0);//et dates et indices
  objet.printMeanAndVar(meanvarmob3mois,1);
  objet.printMeanAndVar(meanvarmob6mois,0);
  objet.printMeanAndVar(meanvarmob6mois,1);
  objet.printMeanAndVar(meanvarmob9mois,0);
  objet.printMeanAndVar(meanvarmob9mois,1);
  objet.printMeanAndVar(meanvarmob12mois,0);
  objet.printMeanAndVar(meanvarmob12mois,1);
}
\end{verbatim}
\hline  
\vspace{7.mm}  

L'appel de la méthode \verb+doAll+ permet l'impression de nombreuses moyennes mobiles, que nous avons dû enlever ici, mais qui sont dans le code présent à l'adresse http://starbrood.free.fr/ProjetFinance/ . Notons que, si l'objet \verb+eurus+ de type \verb+Outils+ existe,  \verb+eurus.printMeanAndVar(meanvarmob7mois,k)+ crée automatiquement le fichier \verb+moymob7-eurus.dat+ ou \verb+varmob7-eurus.dat+, grâce au nombre de 0 présents dans \newline \verb+((meanvarmob7mois[i][k=0])_i)+ (moyennes empiriques des incréments logarithmiques), et \newline  \verb+((meanvarmob7mois[i][k=1])_i)+ (variances empiriques) -- le cas k=2 permettant d'imprimer le vecteur de dates (\verb+KN<R> string+) avec les indices correspondants. Les fichiers générés seront détaillés avec la deuxième partie du projet lors des Simulations de cours d'actifs.
\begin{center}
\includegraphics[width=1.1\textwidth]{utilisation1a.pdf}
\end{center}

\newline\newline
\subsection{Moyenne et Variance mobiles}
Dans cette section, nous allons formaliser un peu le raisonnement et afficher les moyenne et variance sur les 3, 6, 9 et 12 mois précédents pour chaque pas de temps. Nous considérons, pour simplifier, qu'un mois contient 21 jours de cotations. On va donc faire jour après jour le calcul de la moyenne et de la variance empirique des incréments logarithmiques de l'actif sur les 3, 6, 9 ou 12 mois précédents. On note toujours $L(S)$ la série chronologique des incréments logarithmiques d'un actif $S$, i.e. $L(S)_k=\ln(S_{k+1}/S_k), 1\leqslant k\leqslant N-1$ où $N$ est le nombre de jours d'étude de $S$. Dans chaque cas, on définit $\tilde{\E}^i [L(S)]$ et $\tilde{\V}^i [L(S)], i=3,6,9,12$ les séries des moyennes et variances empiriques sur $i$ mois, explicitement :
\begin{equation} 
\begin{split}
& \tilde{\E}^i [L(S)_k] = \frac{\sum_{h=k-21i}^{k-1} L(S)_h }{21i} \qquad (21i+1 \leqslant k\leqslant N-1) \\
& \tilde{\E}^i [L(S)_k] = 0 \qquad \qquad(1\leqslant k\leqslant 21i)
\end{split}
\label{Espi}
\end{equation}
\begin{equation}
\begin{split}
& \tilde{\V}^i [L(S)_k] = \frac{\sum_{h=k-21i}^{k-1} (L(S)_h-\tilde{\E}^i [L(S)_k])^2}{21i} \qquad (21i+1 \leqslant k\leqslant N-1) \\
& \tilde{\V}^i [L(S)_k] = 0 \qquad (1\leqslant k\leqslant 21i)
\end{split}
\label{Vari}
\end{equation}

Nous avons, de la même manière que précédemment,
\[ 
\left\{ \begin{array}{rl}
(\mu -\frac{\sigma^2}{2}) & = \tilde{\E}^i [L(S)] \\
\sigma^2  & = \tilde{\V}^i [L(S)] \end{array} \right 
\]
Ce qui donne :
\[
\left\{ \begin{array}{rl}
\mu & = \tilde{\E}^i[L(S)] + \frac{\tilde{\V}^i[L(S)]}{2} \\
\sigma^2 & = \tilde{\V}^i[L(S)] \end{array} \right 
\]
Et permet de calculer $\mu$ et $\sigma$ (qui bien sûr dépendent de la période de glissement des données c'est-à-dire de $i$).

\subsubsection{La parité Euro-Dollar}

Nous présentons ci-dessous les moyennes et variances mobiles pour les incréments logarithmiques de la parité EUR/USD. Ces graphiques donnent surtout une idée du logarithme des rendements et de leur variance, mais nous nous en servons surtout pour le calcul numérique de $\mu$ et $\sigma$.
\begin{center}
\includegraphics[width=0.7\textwidth]{moymob-eurus.pdf}
\end{center}
\begin{center}
\includegraphics[width=0.7\textwidth]{varmob-eurus.pdf}
\end{center}

Pour les tendances et volatilités ($\mu$ et $\sigma^2$), nous utilisons les formules (\ref{Espi}) et (\ref{Vari}), qui dépendent du type de glissement des moyennes mobiles. Nous obtenons les résultats suivants pour la tendance :
\begin{center}
\includegraphics[width=0.8\textwidth]{tendances-eurus.pdf}
\end{center}
On observe que plus l'intervalle de temps qui sert au calcul de la tendance est grand, plus les variations sont faibles au cours du temps. Ceci est cohérent, car le rôle d'une moyene mobile est précisément de lisser les variations pour détecter la tendance. Pour les variances $\sigma^2$, nous obtenons pour les 4 cas les graphes suivants :
\begin{center}
\includegraphics[width=0.8\textwidth]{volatilites-eurus.pdf}
\end{center}
Sur ce graphique, on s'aperçoit que les courbes baissent à mesure que l'intervalle de glissement grandit. Ceci exprime le fait que la volatilité est plus faible autour de la tendance comme le laissait penser la figure précédente.
\newline

\subsubsection{Le titre RCF}
Nous présentons ci-dessous les résultats obtenus pour la tendance du cours de l'action Teleperformance, d'abord en glissements trimestriel et semestriel, puis en glissements sur 9 mois et 1 an, afin de pouvoir "zoomer" sur les deux courbes les plus lisses.
\begin{center}
\includegraphics[width=0.8\textwidth]{tendances-rcf-36.pdf}
\end{center}
\begin{center}
\includegraphics[width=0.8\textwidth]{tendances-rcf-912.pdf}
\end{center}
On voit qu'après un changement d'échelle, les tendances obtenues en glissement trimestriel ou annuel ont la même allure. Ci-dessous les résultats obtenus pour la volatilité $\sigma^2$.
\begin{center}
\includegraphics[width=0.9\textwidth]{volatilites-rcf.pdf}
\end{center}
\newline

\subsubsection{L'indice CAC 40}

Les graphiques obtenus pour l'indice CAC 40 présentent les mêmes caractéristiques que ceux du titre RCF. Pour $\mu$ :
\begin{center}
\includegraphics[width=0.8\textwidth]{tendances-cac.pdf}
\end{center}
\clearpage
Et pour $\sigma^2$ :
\begin{center}
\includegraphics[width=0.9\textwidth]{volatilites-cac.pdf}
\end{center}
On observe toujours un tassement des valeurs lorsque la période servant au calcul de la moyenne augmente.
\clearpage 

\section{Stratégies d'investissement}
\vspace{7mm}
Nous nous intéressons maintenant à un actif financier, noté $S_t$, et considérons deux stratégies d'investissement : l'une consistant à acheter le titre et à le conserver jusqu'à la fin de la période sauf s'il passe sous un certain seuil, l'autre consistant à acheter une option d'achat sur le titre de maturité la fin de la période et de strike le prix initial. 

\subsection{Modélisation}

\subsubsection{Le schéma d'Euler-Maruyama implicite}
Nous supposons que l'actif est régi par la dynamique (\ref{Dynamique}). Une bonne manière de l'approcher est le schéma d'Euler-Maruyama implicite. nous allons donc discrétiser la période en $N$ points, et nous choisirons ici $N=252$ car nous travaillons sur une période d'un an soit environ 252 jours ouvrés. Nous considérons ensuite la chaîne de Markov ($Y_n, 0\leqslant n\leqslant N$) définie par $Y_0=S_0$ et :
\begin{equation}
Y_{n+1} = Y_n+\mu Y_{n+1} + \sigma Y_n \Delta W_n \qquad (0\leqslant n \leqslant N-1)
\end{equation}
$W_t$ est un mouvement Brownien Standard, et $\Delta W_n = W_{n+1}-W_n$ suit donc une loi $\mathcal{N}(0,1)$. Le schéma d'Euler-Maruyama est fortement et faiblement consistant, et converge fortement à l'ordre 0.5 et faiblement à l'ordre 1, on peut donc travailler convenablement.

\subsubsection{Formule de Cox-Muller}
On utilisera, pour simuler une variable aléatoire de loi normale centrée réduite, la formule de Cox-Muller : 
\[\Delta W_n = \sqrt{-2log(Z_1^n)}\cos(2\pi Z_2^n),
\]
Où $Z_1$ et $Z_2$ sont deux nombres aléatoires générés à chaque étape de temps par la machine. 

\subsubsection{Simulations}
Nous présentons ci-dessous plusieurs réalisations des simulations du cours de l'actif, pour $\mu=0.3$ et $\mu=-0.3$.
\vspace{7mm}
\begin{center}
\includegraphics[width=0.85\textwidth]{simulation03.pdf}
\end{center}
\begin{center}
\includegraphics[width=0.85\textwidth]{simulation-03.pdf}
\end{center}

\subsection{Programmation}

\subsubsection{Cadre de travail}

Nous allons donc simuler un grand nombre de réalisations de cours de notre actif $S_t$ sur des périodes d'un an que nous considèrerons contenir 252 jours. On cherche donc à : \\ \newline
$\rightarrow$ Simuler le cours d'un actif de paramètre $\mu$ et $\sigma$. (cf écriture de $S_t$ en processus d'Itô). \\ \newline
$\rightarrow$ Calculer le gain des stratégies $P1$ et $P2$ selon le cours final de $S_t$ pour $P1$ (achat de call). Le $Gain_{P2}$ dépend de toute la filtration induite par toutes les variations de $S_t$ durant les 252 jours de cotations de l'année. Rappelons que si l'actif passe sous le seuil $S_0 - C_0$, la perte est égale à $C0$ (la perte est égale à $S_0-S_{\tau}$ ou $\tau=\left\{inf t_i>0,S_{t_i}\leq S_0 - C_0\right\}$. avec $t_i$ un des N points de discrétisation. \\ \newline
$\rightarrow$ Calculer et stocker $Gain_{P_1}$ et $Gain_{P_2}$ pour un nombre élevé de simulations : M. \\ \newline
$\rightarrow$ Calculer les moyennes et variances empiriques des Gains à $\mu$ et $\sigma$ fixés. \\ \newline
$\rightarrow$ Effectuer ces calculs pour de nombreuses valeurs de $\mu$ telle qu'on puisse faire une représentation des moyennes et des variances des Gains en fonction de $\mu$. \\
\newline
Pour une meilleure compréhension du code à venir, voici la liste des vecteurs et fichiers manipulés qui permettent des représentations graphiques sous Gnuplot. Pour ne pas encombrer notre répertoire de fichiers textes, les moyennes mobiles sur 3,6,9,12 mois seront enregistrées  en colonnes dans un même fichier.  Le tableau ci-dessous résume les fichiers que notre programme crée. Ces fichiers étant nombreux nous allons réduire leurs nombre pour la partie II.

\begin{center}
\begin{tabular}{|*{2}{c|}l | r|}
 \hline
  Nom de fichier & Format & généré par défaut & Partie &  \hline
  table-eurus.dat & [$\left[jour_i \right]$[$date][cours euros-dollar]$ & code désactivé & 1 & \hline
  moyMobX-eurus.dat & [$\left[jour_i \right]$[$\sum ln(\frac{S_{i+1}}{S_i})*\frac{1}{N}][VarEmpirique]$ & code désactivé & 1 & \hline
  tendances-eurus.dat & [$\left[jour_i\right$][$\mu^3_t]_t$ [$\mu^6_t]_t$ [$\mu^9_t]_t$ [$\mu^{12}_t]_t$ & oui   & 1 &\hline
   tendances-rcf.dat& [$\left[jour_i\right$][$\mu^3_t]_t$ [$\mu^6_t]_t$ [$\mu^9_t]_t$ [$\mu^{12}_t]_t$ & oui    & 1 & \hline
  tendances-cac.dat & [$\left[jour_i\right$][$\mu^3_t]_t$ [$\mu^6_t]_t$ [$\mu^9_t]_t$ [$\mu^{12}_t]_t$ & oui &  1 & \hline
  volatilites-eurus.dat & [$\left[jour_t\right$][$\sigma^3_t]_t$ [$\sigma^6_t]_t$ [$\sigma^9_t]_t$ [$\sigma^{12}_t]_t$& oui & 1&   \hline
  volatilites-rcf.dat & [$\left[jour_t\right$][$\sigma^3_t]_t$ [$\sigma^6_t]_t$ [$\sigma^9_t]_t$ [$\sigma^{12}_t]_t$ & oui & 1 &  \hline
  volatilites-cac.dat & [$\left[jour_t\right$][$\sigma^3_t]_t$ [$\sigma^6_t]_t$ [$\sigma^9_t]_t$ [$\sigma^{12}_t]_t$ & oui & 1 &   \hline
 SimulationGainP1P2.dat & [$\left[Simulation_i\right$][$S^{i}_T]_i$ [$Gain_{P1}^i]_i$ [$Gain_{P2}^i]_i$  & oui & 2 &   \hline
  MeanGainMuP1P2.dat & [$\mu_j]_j$[$\bar{Gain_{P1}}_j]_j$ [$\bar{Gain_{P2}}_j]_j$ & oui & 2 &  \hline
  VarGainMuP1P2.dat & [$\mu_j]_j$ [$\bar{VarGain_{P1}}_j]_j$ [$\bar{VarGain_{P2}}_j]_j$ & oui & 2 & \hline
  Alire!.txt & cf chapitre "Résumé des Résultats" & oui & 1 et 2 & \hline
  \end{tabular}
\begin{flushleft} \\ \newline
  [$\left[jour_i \right]$ $\rightarrow$ désigne les indices des jours i.e $={0,1,....,N-1}$ \\
[$\left[Simulation_i\right]$ $\rightarrow$ désigne les indices des 250 simulations réalisées dans notre cas. \\
[$\mu^3_t]_t$ $\rigtharrow$  $\mu_t$   approximé sur 3 mois grâces aux moyennes et variances empiriques mobiles. \\
[$\sigma^3_t]_t$ $\rightarrow$ variance calculée à partir des variances empiriques des incréments logarithmiques. \\
[$\mu_j]_j$ $\rightarrow$ vecteur faisant varier $\mu$ de $-0.5$ à $0.5$ par sauts de pas h=0.02. \\
[$\bar{Gain_{P1}}_j]_j$ $\rightarrow$ gains moyens calculés avec 250 simulations pour les différentes valeurs de $\mu$. \\
$[VarEmpirique]$ $\rightarrow$ désigne la variance empirique des incréments $(\frac{S_{i+1}}{S_i})_{i=0,..,N}$ \\ 
$moyMobX-eurus.dat$ $\rightarrow$ désigne le vecteur des moyennes mobiles sur 1 de période glissante de $X$ mois. \\
\end{flushleft}

\end{center}

Pour le lecteur interessé,la commande de traitement de nos fichiers sous $Gnuplot$ fonctionne ainsi. Pour tracer en 2D l'évolution des volatilités du Cac40 $\sigma^{6mois}$ sur une période de 9 ans. \textit{La volatilité $\sigma^{3mois}$ sera initialisée à 0 pour les 6 premiers mois pour des raisons évoquées précédemments).}
\begin{verbatim}
plot "volatilites-cac.dat" u 1:3 title "`volatilite mobile" w p
\end{verbatim}

\subsubsection{Structure et Code C++ des Simulations : la classe Simulation}
\begin{center}
\includegraphics[width=1\textwidth]{simulation2.pdf}
\end{center}

Les choix de programmations sont similaires à ceux de la partie I. La classe Simulation permet de réaliser M simulations de l'évolution d'un actif durant N jours. On choisit de stocker dans la classe uniquement les Gains à échéance de stratégies P1 et P2 dans les vecteurs \verb+ KN<R> GainP1(M) et KN<R> GainP2 \verb+ ainsi que les valeurs finales $S_T$ du sous jacent simulé numériquement. (stockées dans \verb+ KN<R> valsfinals(M)+). Puis les Gains moyens sont calculés et stockés uniquement après l'appel de la méthode \verb+ GainMoyenP1 et GainMoyenP2+. Le constructeur de cette classe calcule directement une simulation du sous-jacent grâce au schéma de Euler-Maruyama implicite qui nécessite de calculer des réalisations de lois normales centrées. Ces réalisations sont renvoyées par la méthode \verb+ R simulationNormale() \end{verbatim}+ dont le code est donné dans le chapitre suivant. Voici le code du constructeur : \\
\newline
\begin{center}
\includegraphics[width=1\textwidth]{constructsimulation2.pdf}
\end{center}
\vspace{7mm}
Les vecteurs \verb+ KN<R> GainP1t(M),KN<R> GainP2t(M),KN<R> valfinalst(M)+  sont présents en tant qu'auxiliaire. Lors de la déclaration des vecteurs de type KN il faut préciser la taille, ce qui ne peut pas se faire dans le constructeur,ni dans le squelette quand bien même la taille de ces vecteur dépend du paramètre M, variable locale de la classe. Par contre la classe KN permet l'instanciation par copie. La complexité du constructeur est de l'ordre de N*M, c'est pourquoi la partie des calculs qui consistent à calculer les variables \verb+GainMoyenP1 et GainMoyenP2+ se fera par le simple appel de la fonction \verb+ objet.setGains() \verb+ où  \verb+ objet+ est une instanciation de la classe \verb+ Simulation \verb+ . \\

\begin{center}
\includegraphics[width=1\textwidth]{methodesimulation.pdf}
\end{center}

\subsubsection{Méthode Main et Utilisation des objets $Simulation$}

\begin{center}
\includegraphics[width=1\textwidth]{maina.pdf}
\end{center}
\begin{center}
\includegraphics[width=1\textwidth]{mainb.pdf}
\end{center}
\begin{center}
\includegraphics[width=1\textwidth]{mainc.pdf}
\end{center}

\subsubsection{Résumé des Résultats : le fichier $Alire!.txt$ généré en fin de programme}

\begin{center}
\includegraphics[width=1\textwidth]{sortie.jpg}
\end{center}
\vspace{7mm}
\subsection{Analyse des sorties}

\subsubsection{Espérance de gain}

Dans le cas de la stratégie par achat d'option (stratégie P1), l'investisseur choisit d'acheter une option d'achat européenne sur l'actif $S_t$, de prix d'exercice $S_0$, et d'échance $T=1$. On rappelle que, par la formule de Black et Scholes, le prix en 0 d'une telle option d'achat sur le sous-jacent $S_t$ supposé régi par la dynamique (\ref{Dynamique}) est donné par :
\begin{equation}
C_0 (S_0,K,r,T,\sigma) = S_0\mathcal{N}(d_1) - Ke^{-rT}\mathcal{N}(d_2)
\end{equation}
Où 
\[ \begin{split}
d_1 & = \frac{1}{\sigma\sqrt{T}} \left( \ln(\frac{S_0}{K}) + (r+\frac{\sigma^2}{2})T \right) \\
d_2 & = d_1 - \sigma \sqrt{T}
\end{split}
\]
Et $\mathcal{N}(\cdot)$ est la fonction de répartition d'une loi normale centrée réduite. Avec les valeurs $r=0.03,~\sigma=0.5,~S_0=K=100$, le prix devient :
\begin{equation}
\begin{split}
C_0 & = 100(\mathcal{N}(d_1)-e^{-0.03}\mathcal{N}(d_2)) \\
d_1 & = 0,31 \\
d_2 & = -0,19
\end{split}
\end{equation}
Et après calcul, on trouve $C_0=20,96203$.
Le gain réalisé par une telle stratégie (éventuellement négatif), qui dépend naturellement de $\mu$ est donc $(S_T-S_0)^{+} - C_0$. Pour l'estimer, nous faisons 500 simulations de la chaîne de Markov du processus discrétisé par le schéma d'Euler-Maruyama implicite, calculons le gain réalisé pour chaque réalisation puis faisons la moyenne de ces gains. En étudiant le gain pour chaque réalisation, du processus, nous obtenons un nuage de points très dispersés, ce qui confirme que les différents résultats sont totalement décorrélés. Par exemple, pour $\mu=-0.1$ (marché faiblement baissier),
\begin{center}
\includegraphics[width=0.85\textwidth]{gainsP1-01.pdf}
\end{center}
La stratégie P2 consiste quant à elle à garder le titre, et à ne le vendre que si le cours tombe sous le seuil $S_0-C_0$. Le gain réalisé en T dans ce cas est $(S_T-S_O)\mathbb{I}_{\{S_t\geqslant S_0-C_0, 0\leqslant t\leqslant T \}}$. Ce dernier dépend également de $\mu$, et pour l'estimer nous faisons à nouveau 500 réalisations du gain en $T$ puis en calculons la moyenne. Les 500 réalisations sont à nouveau parfaitement décorrélées, et pour $\mu=0.3$, par exemple, toutes les réalisations présentent un gain positif :
\begin{center}
\includegraphics[width=0.85\textwidth]{gainsP203.pdf}
\end{center}
Finalement, nous présentons dans la figure suivante les gains moyens réalisés en fonction de $\mu$, pour les stratégies P1 et P2.
\begin{center}
\includegraphics[width=0.9\textwidth]{gainsfonctionmu.pdf}
\end{center}

On observe que pour des valeurs de $\mu$ négatives et suffisamment grandes en valeur absolue, les gains moyens associés aux deux stratégies sont grossièrement les mêmes : ils représentent la perte du montant $C_0$, qui est le niveau de perte maximal accepté par les deux stratégies. Lorsque la tendance $\mu$ augmente, le marché est de plus en plus haussier, et les gains moyens des deux stratégies s'en ressentent : dès que la valeur estimée de $S_T$ dépasse $S_0-C_0$, le gain moyen de la stratégie P2 augmente (mais pas linéairement, car même si $S_T \geqslant S_0-C_0$, il peut exister une date où ce seuil est franchi à la baisse, dans ce cas le titre est vendu et la perte est de $-C_0$). Dès que le marché est suffisamment haussier et que la valeur estimée de $S_T$ est supérieure à celle de $S_0$ (ce qui correspond à $\mu \geqslant 0$ par construction du processus), le call, dont le pay-off est linéairement fonction de $S_T$ s'il n'est pas nul, devient payant, et le gain moyen procuré par la stratégie P1 commence à augmenter. Pour des valeurs suffisamment grandes de $\mu$, le marché est très haussier et le cours du titre ne passe plus jamais le seuil $S_0-C_0$ à la baisse. À partir de ces valeurs les évolutions en fonction de $\mu$ (à la hausse) des gains moyens des stratégies P1 et P2 sont parallèles. Finalement, à la vue de ce graphique, on s'aperçoit qu'on a plus à gagner à acheter le titre et à surveiller sa position plutôt qu'à acheter le call de strike $S_0$, dont la prime est élevée puisque la volatilité est élevée. Supposer que l'on exercera un call de strike $S_0$ est -- à un facteur d'actualisation près, égal à $e^{-0.03}$ ici -- équivalent à acheter aujourd'hui le titre pour le revendre, sauf que l'on ne commence à gagner (ou plutôt à rembourser ses pertes) que lorsque $S_T\geqslant S_0$ (contre $S_T\geqslant S_0-C_0$ pour la stratégie P2). La stratégie P2 est donc a priori la meilleure. L'intérêt de la stratégie P1 réside cependant dans le fait de ne jamais dépasser le seuil de perte $C_0$. En effet, comme l'illustre la figure suivante montrant 500 réalisations de gain dans un marché fortement baissier ($\mu=-0.3$), le fait de vendre le titre dès que son cours tombe sous le seuil prévu ne protège pas contre les pertes de la dernière journée où l'on possède le titre. Si le cours s'effondre en une journée, le détenteur de la stratégie P1 vendra le titre à la clôture avec l'assurance que la perte engendrée sera supérieure ou égale à $C_0$, pouvant même être très supérieure si la baisse a été forte :
\begin{center}
\includegraphics[width=.9\textwidth]{gains-03.pdf}
\end{center}
Avec cette tendance, toutes les projections sur le call prédisent qu'il ne sera pas payant, et engendrera donc une perte d'exactement $C_0$. La stratégie P2, elle, finira toujours par la vente du titre à perte, et l'on voit que de nombreuses réalisations du gain donnent une perte en résultant supérieure au prix du call, de parfois 40 ou 50 centimes, ce qui n'est pas négligeable si le nombre de titres à acheter est important. 

\subsubsection{Variance des gains}

La variance des gains est calculée comme toute variance empirique, et en la traçant en fonction de $\mu$, nous obtenons les résultats suivants.
\begin{center}
\includegraphics[width=.9\textwidth]{varfunctionmu.pdf}
\end{center}

On voit qu'à partir de valeurs de $\mu$ telles que le call est payant et que le cours du titre ne descend jamais au-dessous de $S_0-C_0$, les variances des deux stratégies sont les mêmes, puisque les deux gains dépendent dans ce cas pareillement de l'évolution du cours, c'est-à-dire linéairement avec un facteur 1.


\end{document}
