#include <iostream>
#include <vector>
#include <cmath>
#include <numeric>
#include <gsl/gsl_rng.h>
#include <gsl/gsl_randist.h>
#include <fstream>
using namespace std;
// Fonction pour calculer la moyenne d'un vecteur
double mean(const vector<double>& vec) {
return accumulate([Link](), [Link](), 0.0) / [Link]();
}
// Algorithme 6.3 : Simulation d'une trajectoire de log(St) avec GSL
vector<double> simulateLogTrajectory(double x0, double T, int nSteps, double
lambda, double muJump, double sigmaJump,
double mu, double sigma, gsl_rng* rng) {
vector<double> logSt(nSteps + 1, x0); // Trajectoire de log(S_t)
double dt = T / nSteps;
for (int i = 1; i <= nSteps; ++i) {
// Générer le nombre de sauts
int P = gsl_ran_poisson(rng, lambda * dt);
// Ajouter l'impact des sauts si P > 0
double jumpImpact = 0.0;
if (P > 0) {
for (int j = 0; j < P; ++j) {
double Zj = gsl_ran_gaussian(rng, sigmaJump) + muJump; //
Distribution des sauts
jumpImpact += Zj;
}
}
logSt[i] = logSt[i - 1] + jumpImpact;
// Ajouter les termes de drift et diffusion
double Z = gsl_ran_gaussian(rng, 1.0); // N(0, 1)
logSt[i] += mu * dt + sigma * sqrt(dt) * Z;
}
return logSt;
}
// Fonction pour calculer une trajectoire de St à partir de log(St)
vector<double> calculateTrajectory(const vector<double>& logSt) {
vector<double> St([Link]());
for (size_t i = 0; i < [Link](); ++i) {
St[i] = exp(logSt[i]);
}
return St;
}
// Fonction pour calculer le payoff d'une option asiatique
double calculateAsianPayoff(const vector<double>& St, double K, bool isCall) {
double avgPrice = mean(St);
if (isCall) {
return max(0.0, avgPrice - K); // Payoff pour une option Call
} else {
return max(0.0, K - avgPrice); // Payoff pour une option Put
}
}
// Fonction principale pour le calcul Monte Carlo
double monteCarloAsianOption(double S0, double K, double T, int nSteps, int
nSimulations,
double lambda, double muJump, double sigmaJump,
double mu, double sigma, bool isCall = true) {
// Initialisation du générateur aléatoire GSL
const gsl_rng_type* T_rng;
gsl_rng_env_setup();
T_rng = gsl_rng_default;
gsl_rng* rng = gsl_rng_alloc(T_rng);
double payoffSum = 0.0;
for (int i = 0; i < nSimulations; ++i) {
// Étape 1 : Simuler une trajectoire de log(St)
vector<double> logSt = simulateLogTrajectory(log(S0), T, nSteps, lambda,
muJump, sigmaJump, mu-muJump*lambda-sigma*sigma/2, sigma, rng);
// Étape 2 : Calculer la trajectoire de St
vector<double> St = calculateTrajectory(logSt);
// Étape 3 : Calculer le payoff pour cette trajectoire
payoffSum += calculateAsianPayoff(St, K, isCall);
}
// Libérer le générateur GSL
gsl_rng_free(rng);
// Étape 4 : Retourner le prix moyen (actualisé si nécessaire)
return payoffSum / nSimulations;
}
// Programme principal
int main() {
// Paramètres de l'option asiatique
double S0 = 120.0; // Prix initial de l'actif
double K = 130.0; // Prix d'exercice
double T = 1.0; // Maturité (en années)
int nSteps = 252; // Nombre de pas de temps (par exemple, jours de
bourse)
int nSimulations = 10000; // Nombre de simulations Monte Carlo
double lambda = 1.0; // Intensité des sauts (nombre moyen de sauts par an)
double muJump = -0.1; // Moyenne logarithmique des sauts
double sigmaJump = 0.2; // Volatilité des sauts
double mu = 0.1; // Taux de rendement attendu
double sigma = 0.3; // Volatilité
// Maturités différentes
vector<double> maturities;
maturities.push_back(0.5);
maturities.push_back(1.0);
maturities.push_back(2.0);
vector<double> K_values; // Prix d'exercice
vector<vector<double> > callPrices([Link]()); // Prix des options
Call pour chaque maturité
vector<vector<double> > putPrices([Link]()); // Prix des options Put
pour chaque maturité
// Générer des prix pour plusieurs valeurs de K et différentes maturités
for (double K_start = 100.0; K_start <= 180.0; K_start += 5.0) {
K_values.push_back(K_start);
for (size_t i = 0; i < [Link](); ++i) {
// Calcul du prix de l'option asiatique Call
callPrices[i].push_back(monteCarloAsianOption(S0, K_start,
maturities[i], nSteps, nSimulations, lambda, muJump, sigmaJump, mu, sigma, true));
// Calcul du prix de l'option asiatique Put
putPrices[i].push_back(monteCarloAsianOption(S0, K_start,
maturities[i], nSteps, nSimulations, lambda, muJump, sigmaJump, mu, sigma, false));
}
}
// Sauvegarder les résultats dans un fichier pour Gnuplot
ofstream dataFile("asian_option_prices.dat");
for (size_t i = 0; i < K_values.size(); ++i) {
dataFile << K_values[i];
for (size_t j = 0; j < [Link](); ++j) {
dataFile << " " << callPrices[j][i] << " " << putPrices[j][i];
}
dataFile << endl;
}
[Link]();
// Affichage des résultats dans la console
cout << "Les prix des options asiatiques ont été enregistrés dans
'asian_option_prices.dat'." << endl;
// Utilisation de Gnuplot pour afficher le graphique
FILE* gnuplot = popen("C:\\gnuplot\\bin\\[Link]", "w");
if (gnuplot) {
fprintf(gnuplot, "set title 'Prix de l\'option asiatique en fonction du
prix d\'exercice K'\n");
fprintf(gnuplot, "set xlabel 'Prix d\'exercice K'\n");
fprintf(gnuplot, "set ylabel 'Prix de l\'option'\n");
fprintf(gnuplot, "set key outside\n");
fprintf(gnuplot, "plot 'asian_option_prices.dat' using 1:2 with lines title
'Call - 0.5 an', \\\n");
fprintf(gnuplot, " 'asian_option_prices.dat' using 1:4 with lines title
'Put - 0.5 an', \\\n");
fprintf(gnuplot, " 'asian_option_prices.dat' using 1:3 with lines title
'Call - 1 an', \\\n");
fprintf(gnuplot, " 'asian_option_prices.dat' using 1:5 with lines title
'Put - 1 an', \\\n");
fprintf(gnuplot, " 'asian_option_prices.dat' using 1:6 with lines title
'Call - 2 ans', \\\n");
fprintf(gnuplot, " 'asian_option_prices.dat' using 1:7 with lines title
'Put - 2 ans'\n");
fprintf(gnuplot, "pause mouse close\n"); // Keep the graph open until the
user closes it
fflush(gnuplot);
pclose(gnuplot);
} else {
cerr << "Impossible d'ouvrir Gnuplot." << endl;
}
return 0;
}