Simulation numérique d’épargné financière
Chapitre IV:
Simulation numérique d’épargné financière
(24)(25)(26)(27)(28)(29)
Un modèle est une représentation testable d’un système et la simulation est l’action d’utiliser ce modèle.
Les calculs émanant de ces simulations étant souvent complexes, les outils numériques sont utilisés pour les exécuter; on parle alors de simulation numérique d’épargné financière.
Cette technique offre un potentiel immense mais beaucoup utilisée dans les entreprises de l’industrie. Les perceptives de cette recherche est d’appliquer cette innovation en finance.
L’épargne financière étant une variable aléatoire à cause du taux d’intérêt (i) et du temps (t), un algorithme permettra d’étudier son évolution de manière séquentielle, conditionnelle ou itérative.
IV.1 Conception du système informatique
Le langage utilisé est un orienté objet. Le passage de la programmation fonctionnelle à l’orienté objet n’était pas facile. L’un des soucis était d’avoir une idée globale en avance de ce qu’on doit programmer.
Les algorithmiques qui sont utilisés dans ce modeste œuvre ne pourront pas suffire car le souhait est d’avoir des interfaces graphiques.
Le besoin d’avoir des méthodes ou langages pour la modélisation en orienté objet se faisait sentir. La méthode UP avec le langage UML qui permet à la conception d’un processus simplifié sont alors adoptés.
IV.1.1 Notion sur UML
De nos jours UML possède treize diagrammes qui sont classés en deux catégories (dynamique et statique). Pour ce faire, on va commencer par les diagrammes de cas d’utilisation (Use Case) qui permettent de donner une vue globale de l’application.
Pas seulement pour un client non avisé qui aura l’idée de sa future application, mais aussi le développeur s’en sert pour le développement des interfaces.
24 Mourad ELHAMDI (2015), Modélisation et simulation de chaînes de valeurs en entreprise – Une approche dynamique des systèmes et aide à la décision : Simulator, Thèse de doctorat en génie industriel, EC-Parais.
25 Guillaume JOUVET(2010), Modélisation, analyse mathématique et simulation numérique de la dynamique des
glaciers, Thèse de doctorat en informatique, EPFL-Suisse.
26 Georges HABCHI(2001), conceptualisation et modélisation pour la simulation des systèmes de production, ESIA.
27 Edwige GODLEWSKI, Alexandra CLAISSE (2008), Introduction à la simulation numérique, ENS-Paris 6.
28 MINOKO, (2015), Notes de cours de calcul numérique, G1 Math-Info, UPN.
29 P. ROQUES, (2008), les cahiers du programmeur-UML2, EYROLLES, VOL : 264.
Notons qu’au début des années 90, il existait une cinquantaine de méthodes objets, liées par un certain consensus autour d’idées communes : objets, classes, sous- systèmes, etc.
Mais chacune possédait sa propre notation, ses points forts et ses manques, et son orientation privilégiée vers un domaine d’application. L’idée d’une certaine unification des méthodes objet est née de ce constat.
La communauté informatique, autour de l’OMG (‘Object Management Group’) qui standardise les technologies de l’objet, s’est attachée à la définition d’un langage commun unique, utilisable par toutes les méthodes objets, dans toutes les phases du cycle de vie et compatible avec les techniques de réalisation du moment.
UML n’est pas une méthode : ses auteurs ont en effet estimé qu’il n’était pas opportun de définir une méthode en raison de la diversité des cas particuliers.
Ils ont préféré se borner à définir un langage graphique qui permet de représenter, de communiquer les divers aspects d’un système d’information (aux graphiques sont bien sûr associés des textes qui expliquent leur contenu).
UML est donc un métalangage car il fournit les éléments permettant de construire le modèle qui, lui, sera le langage du projet.
Il est impossible de donner une représentation graphique complète d’un logiciel, ou de tout autre système complexe, de même qu’il est impossible de représenter entièrement une statue (à trois dimensions) par des photographies (à deux dimensions).
Mais il est possible de donner sur un tel système des vues partielles, analogues chacune à une photographie d’une statue, et dont la juxtaposition donnera une idée utilisable en pratique sans risque d’erreur grave.
Ainsi, le langage UML permet de réaliser un système logiciel en le représentant, en le spécifiant, en le construisant et en le documentant au préalable.
Il existe ainsi deux types de vues du système qui comportent chacune leurs propres diagrammes permettant de représenter des concepts particuliers du système d’information.
- Les vues statiques :
- diagrammes de cas d’utilisation
- diagrammes d’objets
- diagrammes de classes
- diagrammes de composants
- diagrammes de déploiement
- Les vues dynamiques :
- diagrammes de collaboration
- diagrammes de séquence
- diagrammes d’états-transitions
- diagrammes d’activités
- etc…
Ces diagrammes sont d’une utilité variable selon les cas, ne sont pas nécessairement tous produits à l’occasion d’une modélisation.
Les plus utiles pour la maîtrise d’ouvrage sont les diagrammes d’activités, de cas d’utilisation, de classes, d’objets, de séquence et d’états-transitions.
Les diagrammes de composants, de déploiement et de communication sont surtout utiles pour la maîtrise d’œuvre à qui ils permettent de formaliser les contraintes de la réalisation et la solution technique.
Mais pour notre étude, on a trouvé utile de n’utiliser que le diagramme de cas d’utilisations, le diagramme de séquences et le diagramme d’activités.
IV.1.2 Diagramme de cas d’utilisations
IV.1.2.1 Identification des acteurs
Utilisateur : un utilisateur représente ici un créditeur ou un débiteur, aussi appeler un acheteur ou un vendeur et voir même toute personne manifestant un besoin d’épargne ou de crédit bancaire;
Ingénieur Financier (IF) : un ingénieur financier est un agent de la salle de marché financier;
Système Informatique (SI) : l’application informatique qui permet d’expérimenter les opérations;
IV.1.2.2 Fonction de la salle des marchés financiers
- Saisir les données;
- Expérimenter les opérations;
- Gérer le système.
IV.1.2.3 Identification de cas d’utilisations
Utilisateur : donner un montant, déterminer l’opération et fixer l’échéance;
Ingénieur financier : démarrer le système, actualiser le système et fermer le système;
Système Informatique (SI) : effectuer les opérations et simuler graphiquement.
IV.1.2.4 Présentation de diagrammes de cas d’utilisations
a. Capture du diagramme de cas d’utilisations avec acteur Ingénieur Financier
Source : Réalisation personnelle avec StarUML
b. Capture du diagramme de cas d’utilisations avec acteur Utilisateur
Source : Réalisation personnelle avec StarUML
c. Capture du diagramme de cas d’utilisations global
Source : Réalisation personnelle avec StarUML
IV.1.3 Description textuelle de cas d’utilisations
Cette description textuelle de cas d’utilisations se résume aux scénarios suivants :
- L’ingénieur financier démarre le système, il actualise le système et il ferme le système;
- L’utilisateur se présente devant le système, il insère un montant, une échéance et un taux d’intérêts;
- Le système informatique effectue les opérations et simule graphiquement;
- Le L’utilisateur visualise les opérations et expérimente ses opérations.
IV.1.4 Présentation du diagramme de séquences
Les cas d’utilisation décrivent les interactions des acteurs avec PAWELOLE-SIMULATEUR.
Lors de ces interactions, les acteurs produisent des messages qui affectent le système informatique et appellent généralement une réponse de celui-ci.
Pour les messages propres à un cas d’utilisation, le diagramme de séquences montrent non seulement les acteurs externes qui interagissent directement avec le système, mais également ce système (en tant que boîte noire) et les événements système déclenchés par les acteurs.
L’ordre chronologique se déroule vers le bas et l’ordre des messages doit suivre la séquence décrite dans le cas d’utilisation.
Nous allons représenter le diagramme de séquences d’un scénario représentatif de chacun des cas d’utilisation décrits précédemment, en commençant par ceux des utilisateurs.
IV.1.4.1 Capture du diagramme de séquence avec acteur : Utilisateur
Source : Réalisation personnelle avec StarUML
IV.1.4.2 Capture du diagramme de séquence avec acteur Ingénieur Financier
Source : Réalisation personnelle avec StarUML
IV.1.4.3 Capture du diagramme de séquence global
Source : Réalisation personnelle avec StarUML
IV.1.5 Présentation du diagramme d’activités
Le diagramme d’activité est l’un des diagrammes dynamiques d’UML. Il ressemble fondamentalement à un ordinogramme, montrant le flot de contrôle d’action en action.
Les éléments de base du diagramme d’activité sont les suivants :
- des actions,
- des flots de contrôle entre actions,
- des décisions (aussi appelés branchements conditionnels),
- un début et une ou plusieurs terminaison(s) possible(s).
Signalons qu’une action est l’unité fondamentale de spécification comportementale en UML 2. Elle représente un traitement ou une transformation.
Les actions sont contenues dans les activités, qui fournissent leur contexte. Un flot est un contrôle de séquençage pendant l’exécution de nœuds d’activité.
Les flots de contrôle sont de simples flèches reliant deux nœuds (actions, décisions, etc.). Le diagramme d’activité permet également d’utiliser des flots d’objets (reliant une action et un objet consommé ou produit).
Une décision est un nœud de contrôle structuré représentant un choix dynamique entre plusieurs conditions. Il est représenté par un losange qui possède un arc entrant et plusieurs arcs sortants.
Source : Réalisation personnelle avec StarUML
IV.2.Implémentation de l’application
IV.2.1 Présentation du langage Visuel Basic Point Net
Avant de présenter le langage orienté object utilisé, il est important de signaler que choix est justifié par le fait qu’il est préféré à la Banque Centrale du Congo qui est notre champ d’étude, et les utisateurs le préfèrent par la présentation ses interfaces graphiques belles à voir.
Visual Basic.NET est un langage de programmation à la syntaxe similaire à celle Visual Basic 6 et il est aussi classé parmi les langages orientés objets. VB.NET permet de développer en NET via Visual Studio, sur les systèmes d’exploitation (98, 2000, XP, Vista, 7, 8, 8.1 et 10 qu’on a utilisé ici.
L’IDE (environnements de développement) commun et incontournable de tous les langages .NET est Visual Studio. Celui-ci est payant mais dispose d’une version gratuite pour les développeurs et petites sociétés.
VB10 marque un tournant majeur dans l’évolution de VB. Outre est le fait qu’il sera intégré dans le Frameword4, il devrait surtout combler totalement ce retard par rapport à C≠ sur certains points.
Cela assure non seulement un futur stable à VB.NET qui ne pourra pas être délaissé par Microsoft mais aussi une garantie que tout ce qui est faisable en c≠ le sera toujours sur VB.NET.
IV.2.2 Les fonctionnalités de VB.NET2010
Les objets dynamiques (permet notamment la programmation orientée prototype et la communication entre des langages dynamiques et les langages de la Plateforme .NET).
La gestion implicite des interfaces comme c≠; la gestion des méthodes anonymes et la simplification de l’écriture des tableaux, collections, listes et dictionnaires.
IV.3 Prétention des interfaces graphiques de l’application
IV.3.1 Capture représentative de l’interface d’accueil à l’application
Source : application PAWELOLE-SIMULATEUR
IV.3.2 Capture représentative de l’interface d’administration
Source : application PAWELOLE-SIMULATEUR
IV.3.3 Capture représentative de l’interface de simulation pour la capitalisation financière
Source : application PAWELOLE-SIMULATEUR
IV.3.4. Capture représentative de l’interface de simulation pour l’actualisation financière
Source : application PAWELOLE-SIMULATEUR
IV.4 Quelques simulations
IV.4.1 Capture représentative du test de simulations partant de 1 000 USD à 10 000 USD pour la capitalisation financière
Source : application PAWELOLE-SIMULATEUR
IV.4.2 Capture représentative du test des simulations partant de 100 000 USD à 10 000 USD pour l’actualisation financière
Source : application PAWELOLE-SIMULATEUR
IV.5 Quelques codes sources de l’application
Public Class Form1
Private Sub GroupBox1_Enter(ByVal sender As System.Object, ByVal e As
System.EventArgs) Handles GroupBox1.Enter
Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As
System.EventArgs) Handles Button1.Click
If TextBox1.Text = «pawelole2020» Then
Me.Hide()
Form2.Show()
Else
MsgBox(«Mauvais code d’accès», MsgBoxStyle.Exclamation, «Erreur de connection à
l’application PAWELOLE-SIMULATEUR»)
End If
End Sub
Private Sub TextBox1_TextChanged(ByVal sender As System.Object, ByVal e As
System.EventArgs) Handles TextBox1.TextChanged
End Sub
Private Sub Label1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs)
Handles Label1.Click
Private Sub RetourToolStripMenuItem_Click(ByVal sender As System.Object, ByVal e As
System.EventArgs) Handles RetourToolStripMenuItem.Click
Me.Hide()
Form1.Show()
End Sub
Private Sub OpérationDeCapitalisationFinancièreToolStripMenuItem_Click(ByVal sender
As System.Object, ByVal e As System.EventArgs) Handles
OpérationDeCapitalisationFinancièreToolStripMenuItem.Click
Me.Hide()
Form3.Show()
End Sub
Private Sub OpérationDeCapitalisationFinancToolStripMenuItem_Click(ByVal sender As
System.Object, ByVal e As System.EventArgs) Handles
OpérationDeCapitalisationFinancToolStripMenuItem.Click
Me.Hide()
Form4.Show()
End Sub
Private Sub GroupBox1_Enter(ByVal sender As System.Object, ByVal e As
System.EventArgs) Handles GroupBox1.Enter
End Sub
End Class
Public Class Form3
Private Sub Label1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs)
Handles Label1.Click
End Sub
Private Sub Form3_Load(ByVal sender As System.Object, ByVal e As System.EventArgs)
Handles MyBase.Load
End Sub
Private Sub Button3_Click(ByVal sender As System.Object, ByVal e As
System.EventArgs)
Me.Hide()
Form2.Show()
End Sub
Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As
System.EventArgs) Handles Button1.Click
Dim Element As New ListViewItem
Element.Text = TextBox1.Text
Element.SubItems.Add(TextBox2.Text / 100)
Element.SubItems.Add(TextBox3.Text)
Element.SubItems.Add(TextBox1.Text * (1 + TextBox2.Text / 100))
Element.SubItems.Add(TextBox1.Text * (1 + TextBox2.Text / 100) * (1 + TextBox2.Text
/ 100))
Element.SubItems.Add(TextBox1.Text * (1 + TextBox2.Text / 100) * (1 + TextBox2.Text
/ 100) * (1 + TextBox2.Text / 100))
Element.SubItems.Add(TextBox1.Text * (1 + TextBox2.Text / 100) * (1 + TextBox2.Text
/ 100) * (1 + TextBox2.Text / 100) * (1 + TextBox2.Text / 100))
Element.SubItems.Add(TextBox1.Text * (1 + TextBox2.Text / 100) * (1 + TextBox2.Text
/ 100) * (1 + TextBox2.Text / 100) * (1 + TextBox2.Text / 100) * (1 + TextBox2.Text / 100))
Element.SubItems.Add(TextBox1.Text * (1 + TextBox2.Text / 100) * (1 + TextBox2.Text
/ 100) * (1 + TextBox2.Text / 100) * (1 + TextBox2.Text / 100) * (1 + TextBox2.Text / 100) * (1
+ TextBox2.Text / 100))
Element.SubItems.Add(TextBox1.Text * (1 + TextBox2.Text / 100) * (1 + TextBox2.Text
/ 100) * (1 + TextBox2.Text / 100) * (1 + TextBox2.Text / 100) * (1 + TextBox2.Text / 100) * (1
+ TextBox2.Text / 100) * (1 + TextBox2.Text / 100))
Element.SubItems.Add(TextBox1.Text * (1 + TextBox2.Text / 100) * (1 + TextBox2.Text
/ 100) * (1 + TextBox2.Text / 100) * (1 + TextBox2.Text / 100) * (1 + TextBox2.Text / 100) * (1
+ TextBox2.Text / 100) * (1 + TextBox2.Text / 100) * (1 + TextBox2.Text / 100))
Element.SubItems.Add(TextBox1.Text * (1 + TextBox2.Text / 100) * (1 + TextBox2.Text
/ 100) * (1 + TextBox2.Text / 100) * (1 + TextBox2.Text / 100) * (1 + TextBox2.Text / 100) * (1
+ TextBox2.Text / 100) * (1 + TextBox2.Text / 100) * (1 + TextBox2.Text / 100) * (1 +
TextBox2.Text / 100))
Element.SubItems.Add(TextBox1.Text * (1 + TextBox2.Text / 100) * (1 + TextBox2.Text
/ 100) * (1 + TextBox2.Text / 100) * (1 + TextBox2.Text / 100) * (1 + TextBox2.Text / 100) * (1
+ TextBox2.Text / 100) * (1 + TextBox2.Text / 100) * (1 + TextBox2.Text / 100) * (1 +
TextBox2.Text / 100) * (1 + TextBox2.Text / 100))
ListView1.Items.Add(Element)
End Sub
Private Sub Button2_Click(ByVal sender As System.Object, ByVal e As
System.EventArgs) Handles Button2.Click
Me.Hide()
Form2.Show()
End Sub
Private Sub Button4_Click(ByVal sender As System.Object, ByVal e As
System.EventArgs) Handles Button4.Click
Close()
End Sub
Private Sub TextBox3_TextChanged(ByVal sender As System.Object, ByVal e As
System.EventArgs) Handles TextBox3.TextChanged
End Sub
Private Sub Label3_Click(ByVal sender As System.Object, ByVal e As System.EventArgs)
Handles Label3.Click
End Sub
Private Sub Button5_Click(ByVal sender As System.Object, ByVal e As
System.EventArgs) Handles Button5.Click
Me.Hide()
Form4.Show()
End Sub
2.2. Conclusion générale
Nous voici à la fin de la rédaction du mémoire qui clôture notre deuxième cycle universitaire en Sciences dans la filière Mathématique-Informatique sur la thématique choisie « Modélisation et Simulation Numérique d’Epargne Financière ».
Depuis l’intégration de la modélisation mathématique en finance par son précurseur Louis Bachelier à travers sa thèse intitulée « Théorie de la spéculation » en 1900 a accompagné une modernisation profonde de tous les compartiments de la finance, spécifiquement à la découverte de la finance de marché et de la finance comportementale.
Malheureusement l’industrie financière n’a pas su piloter, ni même mesurer la montée des risques qui se développaient dû à l’erreur de modélisation par la propagation de l’erreur d’approximation qui a entrainé le monde dans des plus grandes crises financières depuis celle de 1929.
Dès lors l’industrie financière est à la recherche des outils performants pour la résolution du problème de quantification de l’incertitude financière.
Il était question pour nous de montrer dans le cadre de cette étude à travers l’épargne financière que la modélisation et la simulation numérique sont des outils indispensables pour la quantification de l’incertitude financière car ces outils prennent en compte les erreurs de modélisations grâce aux outils numériques.
Notre hypothèse est alors vérifiée car la mise en place de l’application PAWELOLE-SIMULATEUR est une modeste contribution non négligeable.
Comme testé avec exemples dans la page 93, l’application permet de calculer l’opération de la capitalisation financière avec négligence de l’erreur de modélisation.
En cas de doute ou de perte, l’opération d’actualisation financière de l’application permettra aussi à son tour de vérifier le passé avec diminution de la dite erreur afin de détecter la cause du dysfonctionnement ou de déterminer si cela est dû à des causes systématiques ou à des jeux de hasard.
Au-delà de l’application PAWELOLE-SIMULATEUR, ce mémoire apporte quelques contributions, parmi lesquelles :
La réalisation deux algorithmes itératifs pour l’actualisation et la capitalisation à la page 78-79.
L’algorithme de capitalisation permet de calculer de manière itérative l’évolution d’un portefeuille d’épargne ou de crédit avec un minimum de détail possible sur l’augmentation périodique.
L’algorithme d’actualisation est alors un vérificateur de portefeuilles, en cas de doute ou de toute surprise désagréable;il permet de faire une rétroflexion sur le passé afin de détecter la cause d’une perte ou d’une crise financière;
La revue de littérature à l’introduction qui donne la limite des méthodes comptables et l’évolution de l’application mathématique en finance jusqu’à l’adaptation aux moyens numériques de la modélisation mathématique;
Une explication claire de différents concepts utilisés dans le cadre de notre étude, dont certains mots semblent être compris à tort.
Même si les apports de ce mémoire sont apparemment abondants, l’application PAWELOLE-SIMULATEUR relève certaines limites car elle ne prend en compte qu’un taux d’intérêt non variante et une échéance bien déterminée d’avance. Et pour des périodicités très longues, elle est applicable que dans une économie stable.
Il reste également un certain nombre de problèmes, dont nous énumérons certaines améliorations suivantes :
Mise en place d’un système de montage de portefeuilles et de sécurisation des données dans une salle de marché financier;
Conception d’un outil de simulation financière capable de prendre en compte les intérêts variantes;
Modélisation et simulation numérique avec un outil décisionnel pour le contrôle en temps réel du paradigme financier-rentabilité.
Nous posons que la finance de marché est un moteur de la croissance économique; et permettre à l’ensemble de la population d’expérimenter leurs activités financières serait une contribution pertinente pour promouvoir l’inclusion financière numérique.
Pour finir, on ne peut pas parler de la finance de marché sans les mathématiques et les outils numériques, dont la Mathématique-Informatique reste une filière de haute formation pour industrie financière.
Vous pouvez télécharger ce travail de mémoire (en PDF ci-dessousfichier).