Modelisation stochastique du BE

Modelisation stochastique du BE

1. Construction du GSE

Les générateurs de scénarios économiques sont conçus pour évaluer les impacts potentiels des variations économiques sur les investissements et les décisions commerciales, en fournissant une gamme de scénarios possibles. Ils sont utilisés pour la planification, la gestion des risques, la prévision financière et l’allocation d’actifs. Aujourd’hui, nous allons les utiliser pour la construction d’un modèle stochastique afin d’évaluer le BEL de notre action. Nous utiliserons la méthode des taux d’intérêt à court terme en modélisation financière.

a. Modèles de taux courts

La méthode des taux d’intérêt à court terme en modélisation financière vise à modéliser l’évolution des taux d’intérêt sur une période courte. Elle utilise des équations de taux, des variables aléatoires, et des relations de récurrence pour simuler l’impact des fluctuations des taux sur les décisions financières. Plusieurs méthodes sont disponibles pour simuler ces taux :

Le modèle de Vasicek

Le modèle proposé par Vasicek (1977) est l’un des plus largement utilisés pour évaluer le prix des options. Il se base sur le processus d’Ornstein-Uhlenbeck pour modéliser le taux d’intérêt instantané \(r\) :

\[ dr = \alpha(\gamma - r)dt + \sigma dB \]

où \(\gamma\) est la moyenne à long terme du taux spot, \(\alpha\) est le drift du processus (vitesse de retour à la moyenne), et \(\sigma\) est l’écart-type instantané.

Simulations du modèle de Vasicek

Le modèle de Vasicek est un modèle à un facteur où tous les taux dépendent des taux d’intérêt à court terme, appelés simplement taux spots \(r\). Pour simuler ce taux, on discrétise l’équation de Vasicek en considérant des variations dans les taux d’intérêt pendant de petites périodes \(\Delta t\) :

\[ \Delta r = \alpha(\gamma - r)\Delta t + \sigma Z\sqrt{\Delta t} \]

Contrairement au modèle de prix des actions, qui est multiplicatif, le modèle de la structure des taux est additif. Ainsi, si \(r_t\) représente le taux spot à l’instant \(t\), alors le taux spot à \(t + \Delta t\) est donné par :

\[ r_{t + \Delta t} = r_t + \Delta r = r_t + \alpha(\gamma - r)\Delta t + \sigma Z\sqrt{\Delta t} \]

Il est important de noter que si nous augmentons le nombre de simulations, le processus de Vasicek peut conduire à des valeurs négatives des taux d’intérêt anticipés.

Le prix d’une obligation Zéro Coupon (ZC) pour un taux d’intérêt \(r\) aujourd’hui est donné par :

\[ P(r,0,T) = \exp\left(\frac{1}{\alpha}(1 - e^{-\alpha T})(R_{\infty} - r) - TR_{\infty} - \frac{\sigma^2}{4 \alpha^3} (1 - e^{-\alpha T})^2\right) \]

où \(R_{\infty} = \gamma + \frac{\sigma \lambda}{\alpha} - \frac{\sigma^2}{2\alpha^2}\).

Le modèle de Cox-Ingersoll-Ross (CIR)

Le modèle CIR considère le processus des taux d’intérêt suivant :

\[ dr = \alpha(\gamma - r)dt + \sigma\sqrt{r}dB \]

où \(\alpha > 0\), \(\gamma\) est la moyenne à long terme du taux d’intérêt, et \(r\) est le taux d’intérêt courant. La solution de cette équation pour les obligations ZC est de la forme :

\[ P(t,T) = A(t,T)e^{-B(t,T)r} \]

avec :

\[ A(t,T) = \frac{2\alpha \gamma \eta e^{\frac{(\alpha + \eta)(T-t)}{2}}}{\sigma^2((\alpha + \eta)(e^{\eta(T-t)} - 1) + 2\eta)} \]

\[ B(t,T) = \frac{2(e^{\eta(T-t)} - 1)}{(\alpha + \eta)(e^{\eta(T-t)} - 1) + 2\eta} \]

Comme précédemment, nous pouvons simuler le processus de taux court selon le modèle CIR.

Le modèle de Vasicek généralisé (Hull et White)

Nous utilisons le modèle de Vasicek généralisé (Hull et White). Les paramètres de base incluent l’horizon de projection (\(H\)) et la volatilité des taux courts (\(vol\)). Les variables aléatoires sont représentées par une matrice \(\varepsilon\) suivant une loi normale standard. Le taux de référence est fourni par les taux forward 1 an Zéro-Coupon (\(\tau^{ZC}\)).

L’équation \(L(t, \sigma, k)\)

Cette équation modélise la volatilité des taux d’intérêt :

\[ L(t, \sigma, k) = \frac{\sigma^2}{2} \times (1 - e^{-2kt}) \]

L’équation \(K(t, k)\)

Cette équation calcule un facteur d’ajustement :

\[ K(t, k) = \frac{1 - e^{-2kt}}{k} \]

En combinant ces éléments, nous générons des scénarios pour les taux courts. La matrice \(\epsilon\) est définie comme suit :

\[ \epsilon = \begin{pmatrix} \epsilon_{1,1} & \epsilon_{1,2} & \dots & \epsilon_{1,h}\\ \epsilon_{2,1} & \epsilon_{2,2} & \dots & \epsilon_{2,h}\\ \vdots & \vdots & \ddots & \vdots\\ \epsilon_{h,1} & \epsilon_{h,2} & \dots & \epsilon_{h,h} \end{pmatrix} \]

où chaque \(\epsilon_{i,j}\) pour \((i,j) \in [1,h]\) suit une loi normale centrée réduite.

On définit la suite suivante :

\[ \begin{equation} \left\{ \begin{aligned} r_{1}(.) &= \tau_{1}^{ZC} \\ r_{i+1}(.) &= a + b + c, \forall i \in [2,h] \end{aligned} \right. \end{equation} \]

• \(a = r_{i}(.) \times e^{-k} \times \tau^{ZC}_{i+1}\)
• \(b = \frac{vol^2}{2} \times \left(K(i,k)^2 - e^{-k}\times K(i,k)^2\right)\)
• \(c = \sqrt{L(1,vol, k)} \times \epsilon_{i}(.)\)

Petit rappel : \(Z_{i}(.)\) signifie toutes les lignes de la colonne \(i\) de la matrice \(Z\), il s’agit donc d’un vecteur et \(i\) est le numéro de la simulation.

La première équation initialise les taux courts avec les taux forward à la date 1. Les équations de récurrence suivantes calculent les taux futurs en fonction de trois composantes : \(a\), \(b\) et \(c\), qui dépendent des taux actuels, des paramètres de volatilité et de la matrice de variables aléatoires, introduisant ainsi l’incertitude dans l’évolution des taux. Dans la matrice \(r\), nous stockons les taux courts.

b. Les taux d’évolution de l’action

Nous allons utiliser le modèle de Black-Scholes.

Nous avons, comme pour les taux, les paramètres suivants :

• \(stockPaths_0 = q_{1}(.)\) : qui correspond à la valeur initiale de l’action.
• \(vol_{Stock}\) : la volatilité de l’action.
• Une matrice de variables aléatoires \(\varepsilon_2\) suivant une loi normale standard.
• \(\rho\) : la corrélation entre les taux courts et la valeur des actions.

La matrice \(\varepsilon_2\) est définie de la même manière que celle permettant de calculer les taux courts.

On définit alors la valeur des actions de la manière suivante :

\[ \begin{equation} \left\{ \begin{aligned} q_{1}(.) &= q_{1}(.) \\ q_{t+1}(.) &= q_{t}(.) \times e^{x+y} \end{aligned} \right. \end{equation} \]

Avec les variables \(x = r_{t+1}(.) - \frac{vol_{Stock}^2}{2}\) et \(y = vol_{Stock} \times \left(\rho \times \varepsilon_1[,t] + \sqrt{1 - \rho^2} \times \varepsilon_2[,t]\right)\).

Cette méthode utilise le modèle de Black-Scholes pour simuler l’évolution des valeurs d’actions. Les valeurs initiales sont fixées à \(stockPaths_0\), puis elles évoluent au fil du temps en fonction des taux d’intérêt courts simulés (\(r(.)\)), de la volatilité de l’action (\(vol_{Stock}\)), de la corrélation avec les taux courts (\(\rho\)), et de variables aléatoires (\(\varepsilon_1\) et \(\varepsilon_2\)). La formule de récurrence calcule les valeurs futures des actions en utilisant ces facteurs et en introduisant de l’incertitude pour refléter les variations du marché.

2. Modele UC

Dans le cadre de notre projet de modélisation en assurance vie, nous développons un modèle stochastique pour évaluer la valeur du Best Estimate (BE). Pour ce faire, nous allons construire un Générateur de Scénarios Économiques (GSE) qui fournira à la fois les taux courts (r) et les taux des valeurs des actions en unité de compte (q). Nous avons choisi d’utiliser le package ESG pour générer ces scénarios économiques. Pour démarrer, nous importons la bibliothèque ESG en utilisant la commande suivante :

library(ESG)
library(readxl)
library(ggplot2)
library(DT)
library(kableExtra)

La commande ?rStock nous permettra d’accéder à une documentation détaillée sur la fonction rStock, notamment ses arguments, son fonctionnement et des exemples d’utilisation. Cela nous aidera à mieux comprendre comment utiliser cette fonction pour générer les taux des valeurs des Unités de Compte (UC) dans le cadre de votre modèle stochastique en assurance vie.

La librairie ggplot2 nous permettra de faire de beaux graphiques.

Pour nos hypothèses spécifiques, nous utiliserons les paramètres suivants definis dans le code R suivant :

• k : la vitesse de retour à la moyenne des taux courts.
• sTaux : la volatilité du processus de taux courts
• sUC : la volatilité de l’UC
• Horizon : Horizon de projection (nombre d’année de projection)
• nSimulations : Nombre de simulations
• TauxMortalite : Taux de mortalité pour une personne une femme de 45 ans pour 50 ans de plus.
• Taux_ZC : le taux zero coupon (les taux d’intérêt sans risque) en date du 2022-06-01 pour les 51 ans qui suivent ladite date.

k <- 0.2             
sTaux <- 0.001        
sUC <- .14             
Horizon <- 50        
nSimulations <- 40000

TauxMortalite <- c(0.195, 0.210, 0.224, 0.238, 0.251, 0.265, 0.282, 0.302, 0.324,
                   0.346, 0.369, 0.392, 0.414, 0.440, 0.468, 0.503, 0.543, 0.589,
                   0.640, 0.697, 0.763, 0.838, 0.923, 1.020, 1.133, 1.259, 1.401,
                   1.563, 1.752, 1.970, 2.228, 2.527, 2.874, 3.276, 3.749, 4.304,
                   4.956, 5.709, 6.564, 7.518, 8.567, 9.693, 10.865, 12.053, 13.260,
                   14.546, 15.965, 17.531, 19.229, 21.060)/100

Taux_ZC <- read_excel("Taux ZC.xlsx")
datatable(round(Taux_ZC,8), options = list(scrollX = TRUE, scrollY = TRUE))

Pour la suite, nous cherchons à interpoler les Taux_ZC afin d’obtenir des taux mensuels. Plusieurs méthodes d’interpolation sont envisageables : l’interpolation linéaire ou par spline, l’interpolation polynomiale, les méthodes statistiques d’interpolation, le lissage ou encore l’interpolation temporelle. Nous utiliserons une interpolation linéaire.

Taux_ZC_central_annuel = Taux_ZC$Central[1:(Horizon+5)]

Taux_ZC_central_mensuel <- unlist(lapply(1:(length(Taux_ZC_central_annuel) - 1), function(i) {
  seq(Taux_ZC_central_annuel[i], Taux_ZC_central_annuel[i + 1], length.out = 13)[2:13]}))

Nous avons ici les taux, chaque ligne correspond à une année et les colonnes aux mois :

Taux_ZC_central_mensuel_affiche = t(matrix(Taux_ZC_central_mensuel, nrow = 12, ncol = 54))
datatable(round(Taux_ZC_central_mensuel_affiche,5), options = list(scrollX = TRUE, scrollY = TRUE))

Nous allons nous intéresser aux taux mensuels pour les 51 années, ce qui équivaut à 612 taux.

Maintenant que nous avons exploré la documentation de la fonction rStock et que nous avons chargé le package ESG, nous sommes prêts à générer les scénarios économiques. Pour ce faire, nous pouvons utiliser la fonction generateScenarios. Voici comment faire :

traj  = rStock(horizon=Horizon, nScenarios=nSimulations, ZC=Taux_ZC_central_mensuel, vol=sTaux, k=k, volStock=sUC, stock0=1, rho=.5)
TauxShort_central = traj$shortRatePaths
TauxUC_central = traj$stockPaths

Avec les taux courts, nous sommes en mesure de calculer les déflateurs en utilisant la formule suivante. Cette formule nous permet d’actualiser les flux monétaires futurs :

\[Deflateur_{t} = \frac{1}{(1+e^{-r(t)})^t}\]

Où \(r(t)\) est le taux court à la date \(t\). Nous avons :

Deflateur = 1/(1+exp(-TauxShort_central))^(0:50)

Une fois que nous avons établi les taux et les déflateurs, nous pouvons entamer la simulation. Dans notre situation, nous prenons l’exemple d’une femme âgée de 45 ans, désireuse de souscrire un contrat en Unités de Compte (UC) pour une durée de 50 ans. Son dépôt initial s’élève à 100 000€. Le contrat comprend divers types de frais, notamment :

• Les chargements sur encours : charges_encours
• Les frais en pourcentage des encours (PM) : frais_encours_pct
• Les frais de gestion du gérant : frais_gerant

Le contrat est également soumis à un taux d’imposition de 30%. Voici l’initialisation pour notre simulation :

TauxRachat <- 0.04
charges_encours <- 0.005
frais_encours_pct <- 0.002
frais_gerant <- 0.006
taux_imposition <- 0.3
PM_Init <- 100000

Nous pouvons maintenant nous atteler à la détermination du Best Estimate (BE) en fonction des scénarios. Pour ce faire, nous utiliserons une fonction appelée Best_Estimate, qui prend en argument les paramètres suivants :

• ValeurUC: Les valeurs des Unités de Compte (UC) données par le Générateur de Scénarios Économiques (GSE).
• Deflateur: Les déflateurs déterminés grâce aux taux courts.
• TauxMortalite: Les taux de mortalité correspondant au sexe et à l’âge de l’assuré.
• TauxRachat: Le taux de rachat de l’assuré.
• charges_encours: Les chargements sur encours.
• frais_encours_pct: Les frais de gestion des PM.
• frais_gerant: Les frais de gestion du gérant.
• TauxImposition: Le taux d’imposition.
• PM_Init: La prime initiale.

La fonction Best_Estimate effectuera les calculs nécessaires pour déterminer le Best Estimate en fonction de ces paramètres et des scénarios économiques. Voici cette fonction : Cette fonction calcule le Best Estimate (BEL) d’un contrat d’assurance vie en fonction des paramètres et des scénarios économiques fournis.

Best_Estimate <- function(ValeurUC, Deflateur, TauxMortalite, TauxRachat, 
               charges_encours, frais_encours_pct, frais_gerant, 
               taux_imposition, Horizon, PM_Init){
  
  # Initialisation des variables
  PM <- c(PM_Init)        # Les valeurs du contrat au fil du temps
  Résultat_brut <- c()     # Stockage des résultats bruts
  
  # Boucle pour calculer les valeurs du contrat et les résultats bruts
  for (i in 2:(Horizon + 1)) {
    if (i< Horizon + 1) {
      # Calcul du rendement en fonction des valeurs des UC
      rendement <- (ValeurUC[i - 1] - 1) * PM[i - 1]
      # Frais de gestion des actifs et chargement sur encours
      Frais_de_gestion_des_actifs <- PM[i - 1] * frais_gerant
      chargement <- PM[i - 1] * charges_encours
      # Frais de gestion des PM
      Frais_de_gestion_des_PM <- PM[i - 1] * frais_encours_pct
      # Ajustement en fonction des coûts
      Ajustement <- rendement - Frais_de_gestion_des_actifs
      Revalorisation_PM <- Ajustement - chargement
      PM_avant_prestation <- PM[i - 1] + Revalorisation_PM
      # Prestations de rachat et de mortalité
      Prestation_rachat <- PM_avant_prestation * TauxRachat
      Prestation_mortalite <- PM_avant_prestation * TauxMortalite[i - 1]
      Total_prestations <- Prestation_rachat + Prestation_mortalite
      # Mise à jour des valeurs du contrat après les prestations
      PM[i] <- PM_avant_prestation - Total_prestations
      # Calcul des produits financiers, sinistres, frais et variation de PM
      Produits_financiers <- Ajustement
      Sinistres <- Total_prestations
      Frais <- Frais_de_gestion_des_PM
      Variation_PM <- -(PM[i] - PM[i - 1])
      Résultat_brut[i - 1] <- Produits_financiers - Frais - Sinistres + Variation_PM}
    else {
      TauxRachatF<- (PM_avant_prestation-Prestation_mortalite)/PM_avant_prestation
      Prestation_rachat <- PM_avant_prestation * TauxRachatF
      Total_prestations <- Prestation_rachat + Prestation_mortalite
      PM[i] <- PM_avant_prestation - Total_prestations
      Sinistres <- Total_prestations
      Frais <- Frais_de_gestion_des_PM
      Variation_PM <- -(PM[i] - PM[i - 1])
      Résultat_brut[i - 1] <- Produits_financiers - Frais - Sinistres + Variation_PM}
  }
  # Calcul de l'impôt sur les résultats bruts
  Impot <- Résultat_brut * taux_imposition
  # Calcul des résultats nets après impôt
  Résultat_net <- Résultat_brut * (1 - taux_imposition)
  PM_FIN <- PM[2:(Horizon + 1)]   # Les valeurs finales du contrat
  # Calcul du Value of In-Force (VIF) et de la différence d'impôt
  VIF <- sum(Résultat_net * Deflateur)
  Impot_Diff <- sum(Impot * Deflateur)
  # Calcul du Best Estimate (BEL) en soustrayant le VIF et la différence d'impôt de la prime initiale
  BEL <- PM_Init - VIF - Impot_Diff
  # Renvoyer un vecteur contenant VIF, Impot_Diff et BEL
  return(c(VIF, Impot_Diff, BEL)) 
}

Une fois que la fonction est définie, nous allons effectuer les calculs sur les taux renvoyés par les GSE, en supposant qu’à la fin de la période, le contrat est racheté, donc la valeur finale de PM devrait être égale à zéro (\(PM_{finale} = 0\))

NBest_Estimate <- function(nSimulations, TauxUC, Deflateur, TauxMortalite, TauxRachat, 
                  charges_encours, frais_encours_pct, frais_gerant, 
                  taux_imposition, Horizon, PM_Init) {
  
  Data.best_estimate <- data.frame(VIF = numeric(nSimulations), 
                                   Impot_Diff = numeric(nSimulations), 
                                   BEL = numeric(nSimulations))
  for(i in 1:nSimulations) {
    donne.best_estimate <- Best_Estimate(TauxUC[i,2:(1+Horizon)], Deflateur[i,2:(1+Horizon)], TauxMortalite, TauxRachat, 
                           charges_encours, frais_encours_pct, frais_gerant, taux_imposition, Horizon, PM_Init)
    
    Data.best_estimate[i,] <- donne.best_estimate
  }
  colnames(Data.best_estimate) <- c("VIF", "Impot_Diff", "BEL")
  # Filtrer les résultats pour ne garder que les valeurs de BEL comprises entre 0 et 2 fois PM_Init
  Data.best_estimate <- subset(Data.best_estimate, BEL > 0 & BEL < 2 * PM_Init)
  return(Data.best_estimate)
}

Simul.BEL <- NBest_Estimate(nSimulations, TauxUC_central, Deflateur, TauxMortalite, TauxRachat, 
              charges_encours, frais_encours_pct, frais_gerant,taux_imposition, Horizon, PM_Init)

Un exemple de 4 lignes de la matrice des resultats :

datatable(round(Simul.BEL[1:4,],2), options = list(scrollX = TRUE, scrollY = TRUE))

Dans l’ensemble des simulations, environ 0.367575% d’entre elles produisent des valeurs adéquates pour le Best Estimate (BEL). Cependant, il est important de noter que certaines simulations génèrent des valeurs excessivement élevées qui ne correspondent pas du tout à la réalité du marché. Ces valeurs atypiques sont considérées comme des anomalies résultant des choix des parametres.

print(pourcentage)

## [1] 0.367575

la methode deterministe realisée en Excel nous donne les resultats suivants :

BEL_determiste = 95151
VIF_determiste  = 3394 
Impots_diff_determiste = 1455 

Nous allons procéder à une comparaison en utilisant la méthode stochastique. Pour ce faire, nous allons tracer les courbes des moyennes cumulées des VIF (Valeurs Intrinsèques Futures), des impôts différés, et des Best Estimate Liabilities (BEL). Pour cela, nous allons créer une séquence de nombres de simulations valides.

ggplot(Simul.BEL, aes(x = valid_simulations, y = cumsum(VIF) / (1:length(VIF)))) +
  geom_line() +
  geom_hline(yintercept = VIF_determiste, linetype = "dashed", color = "red") +
  xlab("Nombre de Simulations") +
  ylab("VIF") +
  ggtitle("Évolution de la moyenne des VIF") +
  theme(plot.title = element_text(hjust = 0.5))

La similitude entre les VIFs des méthodes stochastique et déterministe est plus remarquable lorsque le nombre de simulations est plus important. Les valeurs deviennent très proches ou presque identiques pour un nombre élevé de simulations (Loi des grand nombre).

# Créer un graphique pour Impot_Diff en fonction du nombre de simulations valides
ggplot(Simul.BEL, aes(x = valid_simulations, y = cumsum(Impot_Diff)/(1:length(Impot_Diff)))) +
  geom_line() +
  geom_hline(yintercept = Impots_diff_determiste, linetype = "dashed", color = "red") +
  xlab("Nombre de Simulations") +
  ylab("impôtes differés") +
  ggtitle("Évolution de la moyenne des impôtes differés")+
  theme(plot.title = element_text(hjust = 0.5)) +
  theme(plot.title = element_text(hjust = 0.5))

De même pour les impots differés.

ggplot(Simul.BEL, aes(x = valid_simulations, y = cumsum(BEL) / (1:length(BEL)))) +
  geom_line() +
  geom_hline(yintercept = BEL_determiste, linetype = "dashed", color = "red") +  
  xlab("Nombre de Simulations") +
  ylab("BEL") +
  ggtitle("Évolution de la moyenne des BEL") +
  theme(plot.title = element_text(hjust = 0.5)) +
  scale_y_continuous(limits = c(50000, 100000))

Grâce à la méthode déterministe, un Best Estimate (BEL) de 95152€ a été obtenu. L’analyse du graphique du BEL révèle une forte convergence vers des valeurs proches de ce BEL déterministe.

BEL_stochastique = mean(Simul.BEL$BEL)
Ecart = 1 - BEL_stochastique/BEL_determiste

result = data.frame(BEL_determiste,BEL_stochastique, Ecart)
colnames(result) = c("BEL deterministe", "BEL stochastique", "Ecart")
datatable(round(result,5), options = list(scrollX = TRUE, scrollY = TRUE))

Avec une moyenne de 95228, nos estimations du Best Estimate (BEL) à l’aide de la méthode stochastique s’avèrent relativement proches de celles obtenues par la méthode déterministe, qui était de \(95152€\). En effet, le BEL de la méthode stochastique est d’environ -0.00080481 inférieur à celui de la méthode déterministe.

# Créer un graphique pour BEL en fonction du nombre de simulations valides
ggplot(Simul.BEL, aes(x = valid_simulations, y = sort(BEL))) +
  geom_line() +
  geom_hline(yintercept = BEL_determiste, linetype = "dashed", color = "red") +  # Ajout de la ligne BEL_deterministe
  xlab("Nombre de Simulations Validées") +
  ylab("BEL") +
  ggtitle("Évolution de BEL trié en fonction du nombre de simulations")

En examinant les valeurs du Best Estimate Liabilities (BEL) obtenues par les simulations et en les triant, on observe que la plupart d’entre elles se regroupent autour de la valeur déterministe du BEL. Ce modèle démontre une tendance à la quasi-symétrie. [Mouvement Brownien]

On a les bilans suivants :

Methode deterministe

Bilan

	Bilan economique Deterministe
Actif	valeur_actif	Passif	valeur_passif
actifs UC	100000	Fond propre	500
trésorerie	500	VIF	3394
		Impôts diff.	1455
		BEL	95151
Total	100500	Total	100500

Methode stochastique

Bilan

	Bilan economique Stochastique
Actif	valeur_actif	Passif	valeur_passif
actifs UC	100000	Fond propre	500.000
trésorerie	500	VIF	3340.695
		Impôts diff.	1431.726
		BEL	95227.579
Total	100500	Total	100500.000

3. Modele UC investit sur une actions et une obligation.

Reprenons le travail effectué précédemment, mais cette fois-ci en considérant deux contrats UC distincts. L’UC 1 sera constituée d’une action et l’UC 2 sera constituée d’une obligation. Pour cela, nous allons prendre en compte les deux contrats avec une valeur initiale de 50 000 € pour chacun d’eux. Les données pour le contrat UC contenant l’action restent inchangées.

Les obligations

Les obligations offrent une diversification de portefeuille en générant des revenus réguliers, préservant le capital et offrant une protection lors de ralentissements économiques.

3.1 Modelisation de l’UC contenant l’action

TauxRachat <- 0.04
charges_encours <- 0.005
frais_encours_pct <- 0.002
frais_gerant <- 0.006
taux_imposition <- 0.3
PM_Init <- 50000

Nous allons simuler d’autres trajectoires pour ces contrats.

traj_deux_contrats  = rStock(horizon=Horizon, nScenarios=nSimulations, ZC=Taux_ZC_central_mensuel, vol=sTaux, k=k, volStock=sUC, stock0=1,
       rho=.5)

TauxShort_deux_actions = traj_deux_contrats$shortRatePaths
TauxUC_deux_contrats = traj_deux_contrats$stockPaths

Faire de même pour les deflateurs.

Deflateur_deux_contrats = 1/(1+exp(-TauxShort_deux_actions))^(0:50)

Nous pouvons maintenant faire le calcul du BEL pour les deux actions.

Data_UC_action = NBest_Estimate(nSimulations,TauxUC_deux_contrats, Deflateur_deux_contrats, TauxMortalite, TauxRachat, 
                charges_encours, frais_encours_pct, frais_gerant, 
                taux_imposition, Horizon, PM_Init)

Data_UC_action <- Data_UC_action[Data_UC_action$BEL>0&Data_UC_action$BEL<2*PM_Init,]

3.2 Modelisation de l’UC contenant l’obligation

Considerons les taux TauxShort_deux_actions comme etant les taux de rendement des obligations. Nous partons de la valeur initiale qui est le prix de l’obligation et est de 50 000€ pour estimer les flux futurs de cette obligation. Considerons des obligations à maturité un an que le souscripeur du contrat prend chaque debut d’année et est remboursé la fin de l’année en cours (pas d’imposition). Nous avons les informations suivantes :

• Taux coupon \(C\) : Le pourcentage du montant nominal de l’obligation payé périodiquement à son détenteur.
• Valeur nominale \(F\) : Montant de l’obligation, remboursé à l’échéance.
• Date d’emission : Date initiale de mise sur le marché de l’obligation.
• Date de maturité \(n\) : Date de fin de vie de l’obligation, à laquelle la valeur nominale est remboursée.
• Taux de rendement \(r\) : Rendement total attendu de l’obligation, tenant compte du taux du coupon, de la durée de détention et du prix d’achat de l’obligation sur le marché.

Nous calculons le prix de l’obligation grace à la formule suivante :

\[Prix \ obligation = \frac{F}{(1+r)^{n}}+\sum_{t=1}^{n}\frac{C}{(1+r)^{t}}\] on a \(C = 0\), \(n=1\) et \(r = TauxShortdeuxactions\)

A l’année de la souscription du contrat on a :

\[Prix \ obligation = \frac{F}{(1+r)} \Leftrightarrow F = Prix \ obligation \times (1+r)\]

Pour évaluer le Best Estimate Liability (BEL), nous choisissons de réaliser tous les calculs à partir de la première année de souscription de tous les contrats (comprenant les deux Unités de Compte - UC). Ainsi, nous capitalisons la valeur de \(F\) à la fin de chaque année pour chaque contrat. On a pour l’année \(t\) le valeur suivante :

\[F = Prix \ obligation \times (1+r)^{t}\]

À la même année, le déflateur est déterminé par la formule suivante

\[\frac{1}{ (1+r)^{t}}\]

Finalement la valeur de l’obligation est donc :

\[F_{deflaté} = \frac{1}{ (1+r)^{t}} \times Prix \ obligation \times (1+r)^{t} = Prix \ obligation = 50 000\]

Ainsi, le Best Estimate Liability (BEL) pour l’obligation serait équivalent à sa valeur, car il s’agit d’actifs sans risque.

Contrairement aux actions, la valeur nominale d’une obligation est intégralement remboursée à l’investisseur à l’échéance. Cette caractéristique des obligations séduit particulièrement les investisseurs rétifs au risque qui craignent de perdre leur capital.

Data_UC_action$BEL = Data_UC_action$BEL+PM_Init 

La commande Data_UC_action$BEL = Data_UC_action$BEL + PM_Init permet d’augmenter le Best Estimate Liability (BEL) de l’action en y ajoutant celui de l’obligation. Les impôts différés et les VIF restent inchangés et spécifiques à l’action.

Visualisons les données :

valid_simulations <- seq(1, nrow(Data_UC_action))
# Créer un graphique pour Impot_Diff en fonction du nombre de simulations valides
ggplot(Data_UC_action, aes(x = valid_simulations, y = cumsum(Impot_Diff)/(1:length(Impot_Diff)))) +
  geom_line() +
  xlab("Nombre de Simulations") +
  ylab("impôtes differés") +
  ggtitle("Évolution de la moyenne des impôtes differés")+
  theme(plot.title = element_text(hjust = 0.5))

ggplot(Data_UC_action, aes(x = valid_simulations, y = cumsum(BEL) / (1:length(BEL)))) +
  geom_line() +
  geom_hline(yintercept = BEL_determiste, linetype = "dashed", color = "red") +
  xlab("Nombre de Simulations") +
  ylab("BEL") +
  ggtitle("Évolution de la moyenne des BEL") +
  theme(plot.title = element_text(hjust = 0.5)) +
  scale_y_continuous(limits = c(90000, 100000), expand = c(0, 0))

On a le bilan suivant :

Bilan

	Bilan economique garantie plancher
Actif	valeur_actif	Passif	valeur_passif
Action UC	50000	Fond propre	500.0000
Obligation UC	50000	VIF	1666.5269
trésorerie	500	Impôts diff.	714.2258
		BEL	97619.2472
Total	100500	Total	100500.0000

Le fait de diversifier le portefeuille avec une action et une obligation repartie à 50% chacune permet d’augmenter le BEL. Soient \(\alpha\) la part d’action dans le portefuille. Nous avons alors :

\[Portefeuille = \alpha \times action +(1-\alpha)\times obligation\]

Lorsque \(\alpha = 1\), cela correspond au cas 1, où seule une action est présente. Pour \(\alpha = 0\), cela équivaut à un actif sans risque inclus dans l’Unité de Compte (UC), assurant un Best Estimate Liability (BEL) de 10 000.

4. Impact des sensibilités sur les BEL

Cette fois nous allons etudier la sensibilité des du BEL en appliquant des chocs. Pour ce faire nous allons appliquer :

• un choc de 10% sur la mortalité
• un choc de 15% sur les rachats
• un choc sur la hausse des taux
• un choc sur la baisse des taux

Appliquons les differents chocs.

PM_Init = 100000
TauxMortalite10 = TauxMortalite + 0.1 # +10% sur la mortalité
TauxRachat15 = TauxRachat + 0.15 # +15% sur le taux de rachat

Nous allons utiliser les taux de hausse et de baisse fournis directement par le marché.

# Hausse des taux
Taux_ZC_Hausse_annuel = Taux_ZC$`Hausse Taux`[1:(Horizon+5)]

Taux_ZC_Hausse_mensuel <- unlist(lapply(1:(length(Taux_ZC_Hausse_annuel) - 1), function(i) {
  seq(Taux_ZC_Hausse_annuel[i], Taux_ZC_Hausse_annuel[i + 1], length.out = 13)[2:13]}))

# Baisse des taux 
Taux_ZC_Baisse_annuel = Taux_ZC$`Baisse Taux`[1:(Horizon+5)]

Taux_ZC_Baisse_mensuel <- unlist(lapply(1:(length(Taux_ZC_Baisse_annuel) - 1), function(i) {
  seq(Taux_ZC_Baisse_annuel[i], Taux_ZC_Baisse_annuel[i + 1], length.out = 13)[2:13]}))

Ici, nous avons une représentation graphique des trois courbes : la courbe des taux centrale, celle représentant les taux à la hausse, et celle représentant les taux à la baisse.

par(mar = c(6, 4, 2, 5))  # c(bottom, left, top, right)
min_taux <- min(0, min(Taux_ZC_Hausse_annuel), min(Taux_ZC_Baisse_annuel), min(Taux_ZC_central_annuel))
max_taux <- max(Taux_ZC_Hausse_annuel, Taux_ZC_Baisse_annuel, Taux_ZC_central_annuel)
plot(1:length(Taux_ZC_Hausse_annuel), Taux_ZC_Hausse_annuel, type = 'l', col = 'blue', xlab = 'Horizon', ylab = 'Taux', ylim = c(0, max_taux))
lines(1:length(Taux_ZC_Baisse_annuel), Taux_ZC_Baisse_annuel, col = 'red')
lines(1:length(Taux_ZC_central_annuel), Taux_ZC_central_annuel, col = 'black')
legend('bottomright', legend = c('Hausse', 'Baisse', 'Normal'), col = c('blue', 'red', 'black'), lty = 1, xjust = 1, yjust = 1)

On peut maintenant resimuler les valeurs des taux.

## A la hausse 
trajHausse  = rStock(horizon=Horizon, nScenarios=nSimulations, ZC=Taux_ZC_Hausse_mensuel, vol=sTaux, k=k, volStock=sUC, stock0=1,rho=.5)
TauxShortHausse = trajHausse$shortRatePaths
TauxUCHausse = trajHausse$stockPaths
DeflateurHausse = 1/(1+exp(-TauxShortHausse))^(0:50)


## A la baisse 
trajBaisse  = rStock(horizon=Horizon, nScenarios=nSimulations, ZC=Taux_ZC_Baisse_mensuel, vol=sTaux, k=k, volStock=sUC, stock0=1,rho=.5)
TauxShortBaisse = trajBaisse$shortRatePaths
TauxUCBaisse = trajBaisse$stockPaths
DeflateurBaisse = 1/(1+exp(-TauxShortBaisse))^(0:50)

Calculons le BEL en appliquant chacun des chocs.

Évolution de la moyenne des BEL apres choc sur les rachats et la mortalité

BEL_choc_rachat_mort = NBest_Estimate(nSimulations,TauxUC_central, Deflateur, TauxMortalite10, TauxRachat15, 
                charges_encours, frais_encours_pct, frais_gerant, 
                taux_imposition, Horizon, PM_Init)
BEL_choc_rachat_mort <- BEL_choc_rachat_mort[BEL_choc_rachat_mort$BEL>0&BEL_choc_rachat_mort$BEL<2*PM_Init,]

valid_simulations <- seq(1, nrow(BEL_choc_rachat_mort))
ggplot(BEL_choc_rachat_mort, aes(x = valid_simulations, y = cumsum(BEL)/(1:length(BEL)))) +
  geom_line() +
  geom_hline(yintercept = BEL_determiste, linetype = "dashed", color = "red") +
  xlab("Nombre de Simulations") +
  ylab("BEL") +
  ggtitle("Évolution de la moyenne des BEL apres choc sur les rachats et la mortalité")+
  theme(plot.title = element_text(hjust = 0.5))

Une augmentation des rachats et de la mortalité entraîne une augmentation du Best Estimate Liability car cela augmente les obligations futures de l’entreprise envers les rachats prévus ainsi que les paiements associés aux prestations de décès, ce qui accroît le montant estimé des engagements financiers à couvrir.

Évolution de la moyenne des BEL apres choc sur les rachats, la mortalité et la hausse des taux

BEL_choc_rachat_mort_Hausse = NBest_Estimate(nSimulations,TauxUCHausse, DeflateurHausse, TauxMortalite10, TauxRachat15, 
                charges_encours, frais_encours_pct, frais_gerant, 
                taux_imposition, Horizon, PM_Init)

BEL_choc_rachat_mort_Hausse <- BEL_choc_rachat_mort_Hausse[BEL_choc_rachat_mort_Hausse$BEL>0&BEL_choc_rachat_mort_Hausse$BEL<2*PM_Init,]

valid_simulations <- seq(1, nrow(BEL_choc_rachat_mort_Hausse))
ggplot(BEL_choc_rachat_mort_Hausse, aes(x = valid_simulations, y = cumsum(BEL)/(1:length(BEL)))) +
  geom_line() +
  geom_hline(yintercept = BEL_determiste, linetype = "dashed", color = "red") +
  xlab("Nombre de Simulations") +
  ylab("BEL") +
  ggtitle("Évolution de la moyenne des BEL apres choc sur \nles rachats, la mortalité et la hausse des taux")+
  theme(plot.title = element_text(hjust = 0.5))

La hausse des taux compense bien les chocs sur la mortalité et les rachats car elle génère davantage de revenus d’investissement, réduit les incitations aux rachats anticipés et améliore la rentabilité à long terme de l’entreprise d’assurance. Cela équilibre les effets négatifs des chocs sur la mortalité et les rachats.

On applique le choc sur les le taux de rachat, le taux de mortalité et la baisse des taux

Évolution de la moyenne des BEL apres choc sur les rachats, la mortalité et la baisse des taux

BEL_choc_rachat_mort_Baisse = NBest_Estimate(nSimulations,TauxUCBaisse, DeflateurBaisse, TauxMortalite10, TauxRachat15, 
                charges_encours, frais_encours_pct, frais_gerant, 
                taux_imposition, Horizon, PM_Init)
BEL_choc_rachat_mort_Baisse <- BEL_choc_rachat_mort_Baisse[BEL_choc_rachat_mort_Baisse$BEL>0&BEL_choc_rachat_mort_Baisse$BEL<2*PM_Init,]

valid_simulations <- seq(1, nrow(BEL_choc_rachat_mort_Baisse))
ggplot(BEL_choc_rachat_mort_Baisse, aes(x = valid_simulations, y = cumsum(BEL)/(1:length(BEL)))) +
  geom_line() +
  geom_hline(yintercept = BEL_determiste, linetype = "dashed", color = "red") +
  xlab("Nombre de Simulations") +
  ylab("BEL") +
  ggtitle("Évolution de la moyenne des BEL apres choc sur les rachats, \nla mortalité et la baisse des taux")+
  theme(plot.title = element_text(hjust = 0.5))

Le choc sur le rachat, l’augmentation de la mortalité et la baisse des taux augmentent le BEL pour plusieurs raisons. Ces chocs peuvent entraîner des rachats anticipés plus fréquents, ce qui signifie que l’entreprise d’assurance reçoit les primes plus tôt et peut les investir pour générer des rendements supplémentaires. De plus, une augmentation de la mortalité peut entraîner le versement de prestations de décès plus fréquentes, mais cela signifie également des primes supplémentaires en cas de décès prématuré. Enfin, bien que la baisse des taux puisse réduire les rendements sur les investissements, elle peut également réduire les charges d’intérêts de l’entreprise, libérant ainsi des ressources financières pour augmenter le BEL. En fin de compte, ces chocs peuvent avoir des effets complexes sur la trésorerie et la rentabilité, mais ils peuvent contribuer à augmenter le BEL

Évolution de la moyenne des BEL apres choc sur la mortalité et la baisse des taux

BEL_choc_mort_Baisse = NBest_Estimate(nSimulations,TauxUCBaisse, DeflateurBaisse, TauxMortalite10, TauxRachat, 
                charges_encours, frais_encours_pct, frais_gerant, 
                taux_imposition, Horizon, PM_Init)

BEL_choc_mort_Baisse <- BEL_choc_mort_Baisse[BEL_choc_mort_Baisse$BEL>0&BEL_choc_mort_Baisse$BEL<2*PM_Init,]

valid_simulations <- seq(1, nrow(BEL_choc_mort_Baisse))
ggplot(BEL_choc_mort_Baisse, aes(x = valid_simulations, y = cumsum(BEL)/(1:length(BEL)))) +
  geom_line() +
  geom_hline(yintercept = BEL_determiste, linetype = "dashed", color = "red") +
  xlab("Nombre de Simulations") +
  ylab("BEL") +
  ggtitle("Évolution de la moyenne des BEL apres choc sur \nla mortalité et la baisse des taux")+
  theme(plot.title = element_text(hjust = 0.5))

Malgré les apparences, l’augmentation de la mortalité et la baisse des taux d’intérêt ont un effet limité sur le Best Estimate Liability (BEL) de la compagnie.

• Mortalité accrue : Bien qu’elle entraîne plus de paiements anticipés, elle peut aussi réduire les coûts futurs pour l’entreprise envers les bénéficiaires des polices.
• Baisse des taux : Elle diminue les rendements sur les investissements, mais peut également réduire les coûts d’actualisation des flux de trésorerie futurs, équilibrant partiellement l’impact sur le BEL.

Évolution de la moyenne des BEL apres choc sur les rachats et la baisse des taux

BEL_choc_rachat_Baisse = NBest_Estimate(nSimulations,TauxUCBaisse, DeflateurBaisse, TauxMortalite, TauxRachat15, 
                charges_encours, frais_encours_pct, frais_gerant, 
                taux_imposition, Horizon, PM_Init)

BEL_choc_rachat_Baisse <- BEL_choc_rachat_Baisse[BEL_choc_rachat_Baisse$BEL>0&BEL_choc_rachat_Baisse$BEL<2*PM_Init,]

valid_simulations <- seq(1, nrow(BEL_choc_rachat_Baisse))
ggplot(BEL_choc_rachat_Baisse, aes(x = valid_simulations, y = cumsum(BEL)/(1:length(BEL)))) +
  geom_line() +
  geom_hline(yintercept = BEL_determiste, linetype = "dashed", color = "red") +
  xlab("Nombre de Simulations") +
  ylab("BEL") +
  ggtitle("Évolution de la moyenne des BEL apres choc sur \nles rachats et la baisse des taux")+
  theme(plot.title = element_text(hjust = 0.5))

Une hausse de 15% du taux de rachat et une baisse des taux entraînent une augmentation du Best Estimate Liability (BEL). Cette hausse du BEL découle de l’augmentation des engagements financiers anticipés envers les bénéficiaires due à la hausse du taux de rachat, combinée à la réduction des rendements des investissements, ce qui accentue le coût global d’évaluation des flux de trésorerie futurs.

Évolution de la moyenne des BEL apres choc sur la mortalité et la hausse des taux

BEL_choc_mort_Hausse = NBest_Estimate(nSimulations,TauxUCHausse, DeflateurHausse, TauxMortalite10, TauxRachat, 
                charges_encours, frais_encours_pct, frais_gerant, 
                taux_imposition, Horizon, PM_Init)

BEL_choc_mort_Hausse <- BEL_choc_mort_Hausse[BEL_choc_mort_Hausse$BEL>0&BEL_choc_mort_Hausse$BEL<2*PM_Init,]

valid_simulations <- seq(1, nrow(BEL_choc_mort_Hausse))
ggplot(BEL_choc_mort_Hausse, aes(x = valid_simulations, y = cumsum(BEL)/(1:length(BEL)))) +
  geom_line() +
  geom_hline(yintercept = BEL_determiste, linetype = "dashed", color = "red") +
  xlab("Nombre de Simulations") +
  ylab("BEL") +
  ggtitle("Évolution de la moyenne des BEL apres choc sur \nla mortalité et la hausse des taux")+
  theme(plot.title = element_text(hjust = 0.5))

À la suite du choc sur la mortalité et de la hausse des taux, on constate une stabilisation des Best Estimate Liability (BEL). Cette détérioration découle de l’effet conjugué de l’augmentation de la mortalité et de la hausse des taux, entraînant une augmentation des engagements financiers prévus de la compagnie.

Évolution de la moyenne des BEL apres choc sur les rachats et la Hausse des taux

BEL_choc_rachat_Hausse = NBest_Estimate(nSimulations,TauxUCHausse, DeflateurHausse, TauxMortalite, TauxRachat15, 
                charges_encours, frais_encours_pct, frais_gerant, 
                taux_imposition, Horizon, PM_Init)

BEL_choc_rachat_Hausse <- BEL_choc_rachat_Hausse[BEL_choc_rachat_Hausse$BEL>0&BEL_choc_rachat_Hausse$BEL<2*PM_Init,]

valid_simulations <- seq(1, nrow(BEL_choc_rachat_Hausse))
ggplot(BEL_choc_rachat_Hausse, aes(x = valid_simulations, y = cumsum(BEL)/(1:length(BEL)))) +
  geom_line() +
  geom_hline(yintercept = BEL_determiste, linetype = "dashed", color = "red") +
  xlab("Nombre de Simulations") +
  ylab("BEL") +
  ggtitle("Évolution de la moyenne des BEL apres choc sur \nles rachats et la Hausse des taux")+
  theme(plot.title = element_text(hjust = 0.5))

Suite au choc sur les rachats et à la hausse des taux, la moyenne des Best Estimate Liability (BEL) montre une stabilisation. Cette stabilité peut résulter de l’équilibre entre l’impact de la hausse des rachats, qui augmente les engagements financiers anticipés de l’entreprise, et celui de la hausse des taux, pouvant influencer le coût d’évaluation des flux de trésorerie futurs.

Évolution de la moyenne des BEL apres la baisse des taux

La valeur des flux futurs (VM) est obtenue en calculant la somme des flux futurs actualisés. Cette estimation est formulée par l’équation suivante :

\[VM = \frac{\sum_{i=0}^{H}Flux_{i}}{(1+\tau)^{i}}\]

En cas d’augmentation des taux d’actualisation \(\tau\), la valeur des flux futurs tend à diminuer. Cette relation découle directement de la formule d’actualisation, où des taux plus élevés entraînent une réduction de la valeur actuelle des flux futurs, impactant ainsi à la baisse la valeur totale estimée (VM).

BEL_Baisse = NBest_Estimate(nSimulations,TauxUCBaisse, DeflateurBaisse, TauxMortalite, TauxRachat, 
                charges_encours, frais_encours_pct, frais_gerant, 
                taux_imposition, Horizon, PM_Init)

BEL_Baisse <- BEL_Baisse[BEL_Baisse$BEL>0&BEL_Baisse$BEL<2*PM_Init,]

valid_simulations <- seq(1, nrow(BEL_Baisse))
ggplot(BEL_Baisse, aes(x = valid_simulations, y = cumsum(BEL)/(1:length(BEL)))) +
  geom_line() +
  geom_hline(yintercept = BEL_determiste, linetype = "dashed", color = "red") +
  xlab("Nombre de Simulations") +
  ylab("BEL") +
  ggtitle("Évolution de la moyenne des BEL apres la baisse des taux")+
  theme(plot.title = element_text(hjust = 0.5))

Évolution de la moyenne des BEL apres Hausse des taux

BEL_Hausse = NBest_Estimate(nSimulations,TauxUCHausse, DeflateurHausse, TauxMortalite, TauxRachat, 
                charges_encours, frais_encours_pct, frais_gerant, 
                taux_imposition, Horizon, PM_Init)

BEL_Hausse <- BEL_Hausse[BEL_Hausse$BEL>0&BEL_Hausse$BEL<2*PM_Init,]

valid_simulations <- seq(1, nrow(BEL_Hausse))
ggplot(BEL_Hausse, aes(x = valid_simulations, y = cumsum(BEL)/(1:length(BEL)))) +
  geom_line() +
  geom_hline(yintercept = BEL_determiste, linetype = "dashed", color = "red") +
  xlab("Nombre de Simulations") +
  ylab("BEL") +
  ggtitle("Évolution de la moyenne des BEL apres Hausse des taux")+
  theme(plot.title = element_text(hjust = 0.5))

Recapitulatif

Resulta_Choc <- data.frame(
  colMeans(BEL_choc_rachat_mort_Hausse),
  colMeans(BEL_choc_rachat_mort_Baisse),
  colMeans(BEL_choc_rachat_mort),
  colMeans(BEL_choc_rachat_Baisse),
  colMeans(BEL_choc_mort_Baisse),
  colMeans(BEL_choc_rachat_Hausse),
  colMeans(BEL_choc_mort_Hausse),
  
  colMeans(BEL_Hausse),
  colMeans(BEL_Baisse),
  
  colMeans(Simul.BEL),
  c(VIF_determiste, Impots_diff_determiste, BEL_determiste)
)
Resulta_Choc = rbind(Resulta_Choc, Var_CHOC_DTER = Resulta_Choc[3,]/BEL_determiste - 1)

# Nommez les colonnes du dataframe
colnames(Resulta_Choc) <- c(
  "10%Mortalite + 15%Rachat + HausseTaux",
  "10%Mortalite + 15%Rachat + BaisseTaux",
  "10%Mortalite + 15%Rachat",
  "BaisseTaux + 15%Rachat",
  "BaisseTaux + 10%Mortalite",
  "HausseTaux + 15%Rachat",
  "HausseTaux + 10%Mortalite",
  "HausseTaux",
  "HausseTaux",
  "Sans choc",
  "Méthode déterministe"
)

On stocke dans la variable Var_CHOC_DTER les variations entre les nouvelles valeurs du BEL et celles de la méthode déterministe.

datatable(round(t(Resulta_Choc),4), options = list(scrollX = TRUE, scrollY = TRUE))

En résumé, la baisse des taux a un impact significatif sur l’augmentation du BEL, mais cette augmentation peut être partiellement compensée par les rachats et les taux de mortalité. À l’inverse, une hausse des taux conduit à une réduction du BEL. Cependant, ces variations restent limitées, de l’ordre de 1%. Même si des fluctuations sont présentes, elles demeurent relativement faibles par rapport à la valeur obtenue grâce à la méthode déterministe.

4. Garantie plancher

La garantie plancher dans un contrat d’assurance vie en unités de compte assure au souscripteur que son capital initial sera préservé, indépendamment de l’évolution des investissements.

L’assureur s’engage à couvrir les éventuelles pertes en capital en échange du paiement d’une prime annuelle. Cette garantie s’active exclusivement en cas de décès du souscripteur, garantissant que les bénéficiaires recevront au moins le montant initial investi.

Dans notre modèle, la garantie est déclenchée lorsque le produit cumulé des valeurs des Unités de Compte (UC) est inférieur à 1. En d’autres termes, cela se produit lorsque la multiplication des valeurs des UC aboutit à un résultat inférieur à 1. Soitent

\[\Pi_{UC} = (\pi_{1}, \pi_{2},..., \pi_{n})\]

le vecteur contenant les valeurs des Unités de Compte (UC) pour une durée de contrat s’étendant sur 50 années. Les rendements cumulés sont donnés par :

\[\eta_{UC} = (\eta_{1}, \eta_{2},..., \eta_{n})\]

Où

\[\eta_{i} = \prod_{j=0}^{i}\pi_{j}\]

La prestation garantie plancher à l’instant \(t\) est déterminée à l’aide de la formule suivante :

\[\Delta_{t} = max(1-\eta_{t},0) \times PM_{t} \times q_{x+t}\] Le coût de la garantie est calculé en prenant en considération le déflateur, et cela se calcule grace à la formule suivante :

\[C_{gp} = Deflateur \times \Delta\]

La fonction Best_Estimate sera adaptée en Best_Estimate_plancher pour calculer le Best Estimate Liabilities (BEL) en prenant en compte cette garantie.

PM_garantie = 100000
Best_Estimate_plancher <- function(ValeurUC, Deflateur, TauxMortalite, TauxRachat, 
                          charges_encours, frais_encours_pct, frais_gerant, 
                          taux_imposition, Horizon, PM_Init){
  
  PM <- c(PM_Init)       
  rendement_cumule = 1 - cumprod(ValeurUC)
  Prestation_garantie_plancher <- c() 
  Bilan <- c()   

  for (i in 2:(Horizon + 1)) {
    if (i< Horizon + 1) {
      rendement <- (ValeurUC[i - 1] - 1) * PM[i - 1]
      Frais_de_gestion_des_actifs <- PM[i - 1] * frais_gerant
      chargement <- PM[i - 1] * charges_encours
      Frais_de_gestion_des_PM <- PM[i - 1] * frais_encours_pct
      Ajustement <- rendement - Frais_de_gestion_des_actifs
      Revalorisation_PM <- Ajustement - chargement
      PM_avant_prestation <- PM[i - 1] + Revalorisation_PM
      Prestation_rachat <- PM_avant_prestation * TauxRachat
      Prestation_garantie_plancher[i-1] <- PM[i-1] * TauxMortalite[i-1]*max(rendement_cumule[i-1],0)
      Prestation_mortalite <- PM_avant_prestation * TauxMortalite[i - 1]
      Total_prestations <- Prestation_rachat + Prestation_mortalite + Prestation_garantie_plancher[i-1]
      PM[i] <- PM_avant_prestation - Total_prestations
      Produits_financiers <- Ajustement
      Sinistres <- Total_prestations
      Frais <- Frais_de_gestion_des_PM
      Variation_PM <- -(PM[i] - PM[i - 1])
      Bilan[i - 1] <- Produits_financiers - Frais - Sinistres + Variation_PM}
    else {
      TauxRachatF<- (PM_avant_prestation-Prestation_mortalite)/PM_avant_prestation
      Prestation_rachat <- PM_avant_prestation * TauxRachatF
      Prestation_garantie_plancher[i-1] <- PM[i-1] * TauxMortalite[i-1]*max(rendement_cumule[i-1],0)
      Total_prestations <- Prestation_rachat + Prestation_mortalite + Prestation_garantie_plancher[i-1]
      PM[i] <- PM_avant_prestation - Total_prestations
      Sinistres <- Total_prestations
      Frais <- Frais_de_gestion_des_PM
      Variation_PM <- -(PM[i] - PM[i - 1])
      Bilan[i - 1] <- Produits_financiers - Frais - Sinistres + Variation_PM}
  }
  Impot <- Bilan * taux_imposition
  Résultat_net <- Bilan * (1 - taux_imposition)
  PM_FIN <- PM[2:(Horizon + 1)]
  VIF <- sum(Résultat_net * Deflateur)
  Impot_Diff <- sum(Impot * Deflateur)
  BEL <- PM_Init - VIF - Impot_Diff
  cout_gar_plancher  <- sum(Prestation_garantie_plancher*Deflateur)
  return(c(VIF, Impot_Diff, BEL,cout_gar_plancher)) 
}

Prestation_garantie_plancher[i-1] <- PM[i-1] * TauxMortalite[i-1]*max(rendement_cumule[i-1],0) cette partie du code permet de prendre en compte la garantie plancher pour l’estimation du BEL pour chaque année.

En continuant le processus, nous calculons ensuite les Valeurs Intrinsèques Futures (VIFs), les impôts différés, les Best Estimate Liabilities (BEL), les paiements en cas de décès, ainsi que les coûts de garantie.

Data_garantie_plancher = data.frame()
   for(i in 1:nSimulations){
   data.plancher = Best_Estimate_plancher(TauxUC_central[i,2:(1+Horizon)], Deflateur[i,2:(1+Horizon)], TauxMortalite, TauxRachat, 
              charges_encours, frais_encours_pct, frais_gerant, 
              taux_imposition, Horizon, PM_Init)
   
Data_garantie_plancher = rbind(Data_garantie_plancher, data.plancher)
   }
colnames(Data_garantie_plancher) = c("VIF", "impot_diff", "BEL", "coutgarantieplancher")

Data_garantie_plancher <- Data_garantie_plancher[which(Data_garantie_plancher[,3] > 0 & Data_garantie_plancher[,3] < 2*PM_Init),]

datatable(round(t(colMeans(Data_garantie_plancher)),4), options = list(scrollX = TRUE, scrollY = TRUE))

on a une moyenne du BEL qui est inferieure à celle de la methode deterministe, avec un cout moyen pour les qui est de 23.9811688.

valid_simulations <- seq(1, nrow(Data_garantie_plancher))
ggplot(Data_garantie_plancher, aes(x = valid_simulations, y = cumsum(BEL)/(1:length(BEL)))) +
  geom_line() +
  geom_hline(yintercept = BEL_determiste, linetype = "dashed", color = "red") +
  xlab("Nombre de Simulations") +
  ylab("BEL") +
  ggtitle("Évolution de la moyenne des BEL de la garantie plancher")+
  theme(plot.title = element_text(hjust = 0.5))

Le Best Estimate Liability (BEL) est étroitement similaire à celui de la méthode déterministe, principalement parce que les variations limitées des taux n’engendrent pas des coûts significativement élevés pour la garantie plancher.

Visualisons l’evolution des cout de la garantie.

valid_simulations <- seq(1, nrow(Data_garantie_plancher))
ggplot(Data_garantie_plancher, aes(x = valid_simulations, y = cumsum(coutgarantieplancher)/(1:length(coutgarantieplancher)))) +
  geom_line() +
  geom_hline(yintercept = 25, linetype = "dashed", color = "red") +
  xlab("Nombre de Simulations") +
  ylab("cout de la garantie plancher") +
  ggtitle("Évolution de la moyenne des couts de la garantie plancher")+
  theme(plot.title = element_text(hjust = 0.5))

Une stabilisation du coût de la garantie autour de 25€ entraînera un bilan qui ne sera pas très différent de celui obtenu par la méthode déterministe ou la méthode stochastique.

Recapitulatif

On a le recapitulatif suivant :

Il est observé que le Best Estimate Liability (BEL) est le même pour le modèle déterministe, qu’il y ait une garantie plancher ou non, car les taux sont préalablement connus et tous supérieurs à 100%. Les taux cumulés dépassent donc les 100%, ce qui signifie que la garantie plancher ne s’active pas (le montant à payer à l’échéance est déjà connu).

Aussi :

\[lim_{n\rightarrow \infty} BEL_{Stochastique} = BEL_{Deterministe}\]

Ce constat est bien illustré dans le tableau, où \(n\) est le nombre de simulation(Lois des grands nombres).

Enfin, le Best Estimate Liability (BEL) de la méthode stochastique avec garantie plancher est supérieur aux autres BEL. Avec plusieurs trajectoires des taux, des taux inférieurs à 100% sont générés, déclenchant ainsi l’activation de la garantie plancher et entraînant une augmentation des prestations, ce qui se traduit par une augmentation du BEL.

Bilan

	Bilan economique garantie plancher
Actif	valeur_actif	Passif	valeur_passif
actifs UC	100000	Fond propre	500.000
trésorerie	500	VIF	3356.132
		Impôts diff.	1438.342
		BEL	95205.525
Total	100500	Total	100500.000