Le but de ce travail est de permettre à nos concitoyens de mieux appréhender certains concepts de la science économique (qui n'est pas une science exacte mais une science de l'homme) par le calcul de modèles simplistes présentés sous forme de jeux. En effet, le jeu et l'expérimentation exacte, en plus de constituer une excellente pédagogie, constituent un vecteur de propagande efficace via l'Internet.
L'expérimentation est exacte. L'interprétation que l'on en fait sur le monde réel ne l'est pas. Les modèles sont décrits dans un langage formel facilement compréhensible. Les modèles se perfectionnent pour introduire à chaque fois un nouvel indicateur, un nouvel objet, un nouveau concept économique. L'utilisateur choisit des paramètres et des options puis lance le modèle, procédant ainsi à une expérimentation exacte.
Les modèles vont mettre en avant certains indicateurs. Ce sont des systèmes mécaniques décrivant de façon simpliste l'évolution économique d'une société. Et il y aura toujours plusieurs critères à optimiser, tel que celle garantissant la fortune à tous, et à toutes les époques de la vie.
Puis au delà du jeu, une résolution par tâtonnement en appliquant la méthode vectorielle de Newton est envissageable, et pourra donner des solutions pour chaque ensemble choisi de critères à optimiser .
Commençons par le simplifier en supprimant le travail (un modèle sans travailleur), l'écologie (sans contrainte écologique ni limitation des ressources), l'espace (pas de transport nécessaire), en usant d'une monnaie, en unifiant le bien (une seule sorte de bien) en unifiant l'outils de production (une seule sorte d'usine), en unifiant l'unité de temps (un bien périssable en une unité de temps, une usine périssable en 1000 unités de temps), en supprimant les delais de construction d'usine (la construction d'usine demande seulement une quantité de biens et non de temps, mais elle peut accumuler dans le temps les biens nécessaires sachant que l'obsolescence programmée de l'usine commence dès le premier bien mis à sa construction), en unifiant la personne et le foyer en une entité consommatrice et propriétaire d'usines et de monnaie, en instaurant un seul marché et une règle de mise en concurrence simple.
Le modèle se définit en deux chapitres de nature bien différente. Un premier chapitre matérielle qui définit les règles régissant les flux et transformations des biens et des usines ainsi que les règles du marché. Puis un second chapitre qui définit le comportement plus ou moins irrationnel des entités, qui dans le modèle le plus simple est au hasard.
On developpe un langage de modèle, en même temps que l'on définit notre premier modèle et qui doit être le plus simple de tous. On utilise JavaScript et le framework jQuery. On utilise une programmation orienté objet. Toutes les variables dite du noyau qui définissent l'état du modèle à un instant et qui permettent de calculer son état à l'instant suivant, sont contenues dans un unique objet M qui représente le modèle à un instant donné.
La chose la plus importante et qu'il faut faire en premier dans la conception d'un programme informatique, est de bien nommer les variables selon une nomenclature qui les structurent.
Il y a 5 catégories de variables :
L'interface web du jeu se présente sous la forme d'un tableau de bord composée de 5 zones :
---- 12 avril 2023 ---- jeu-economique-txt-001
Toutes les variables du modèle ainsi que tous les paramètres sont regroupés dans une arborescence d'objets de racine M. La première variable à considérer est le temps T qui est un entier. Par soucis de simplicité, on nomme l'unité de temps, le jour, qui correspondra à un centième d'années réel c'est à dire à environ une demi-semaine dans le monde réel. On débute à 10 ans, pour bien rappeler que l'initialisation du modèle doit intégrer 10 ans d'histoire. On utilise l'opérateur "." pour définir les attributs d'une classe :
M.T=1000 // Temps exprimé en jours.
Une usine est caractérisée uniquement par sa date de début de construction exprimée en nombre de jours. Et toutes les usines possèdent les mêmes paramètres de durée de vie, de puissance de production de biens, et possède un coût de construction en nombre de biens. On regroupe les paramètres globaux des Usines dans l'object Usine :
M.Usine.V = 800 // Durée de vie en jours. M.Usine.W = 30 // Puissance de production en nombre de biens par jour. M.Usine.C = 2000 // Coût de construction en nombre de biens.
Une entité représente une personne ou un foyer. Chaque entité possède de la monnaie et plusieurs usines caractérisées uniquement par leur date de début de construction. Les comptes n'étant rarement entier, l'entité possède en plus une usine en cours de construction, caractérisée par la date de début de construction et le nombre de biens déjà utilisés pour sa construction.
Entité.F = 0 // Nombre de Franc que possède l'entité. Entité.U = [ ] // Liste des usines que possède l'entité. Entité.D = 0 // Usine en cours de construction, c'est sa date de début de construction. Entité.E = 0 // Nombre de biens déjà utilisé pour la construction de l'usine.
L'entité ne peut pas utiliser ses propres biens qu'elle produit. Elle doit les acquérir sur le marché, traduisant la diversité nécessaire des biens prévus pour la consommation domestique et pour la construction d'usine. L'entité vend au marché sa production, et les invendus étant périssables sont détruits. Et elle achète des biens sur le marché.
Entité.I = 0 // Nombre de biens mis à la vente. Entité.B = 0 // Nombre de biens achetés.
On regroupe les entités en une liste L comme suit que l'on rattache à notre modèle comme attribut. Un p
M.L = [] // Liste des entités. M.N = 200 // Nombre d'entités.
Au cours du jour précédent, on établit le prix moyen des biens qui ont été échangés. Cet indicateur correspond au cours de la vie. Il permet de calculer l'inflation d'un jour à l'autre.
M.Bm = 2.00 // prix moyen d'un bien le jour d'avant. M.F = 0 // Masse monétaire en circulation
Il y a 4 formes d'imposition posées à taux fixes : La taxe à la vente qui est l'équivalent de la TVA. La taxe à la production qui constitue un prélèvement proportionnel au nombre de biens produits évalué selon son prix moyen. L'impot sur le revenue. L'impot sur la fortune, le prix de l'usine étant évalué par le prix moyen du bien multiplié par le nombre de biens utilisés pour construire l'usine le tout pondéré par le temps de vie restant de l'usine :
M.Tv = 0.1 // Taxe à la vente.
M.Tp = 0.1 // Taxe à la production. M.Tr = 0.1 // Taxe sur le revenu. M.Tf = 0.001 // Taxe sur la fortune.
Il y a un nombre de biens journalier nécessaire pour assurer la vie des entités.
M.Min = 10 // Nombre de biens par jours nécessaires pour la vie des entités.
Le train de vie minimum est assuré par un revenu universel.
M.R = 30 // Revenu universel.
Par simplicité on applique les taxes et revenu universelle chaque jour.
On applique une règle de gestion, à savoir, indexer le revenu universel sur l'inflation. De tel sorte que le rapport entre le revenu universel et le prix moyen du bien est constant. Le facteur d'aisance est M.R/(M.Bm*M.Min).
Chaque biens mi sur le marché qui n'est pas vendu est détruite par obsolésence. Ce surplus invendu le jours d'avant est comptabilisé dans la variable M.I. Les aléas du marchés fonts que certaines entités ne peuvent subvenir à leur besoin, le nombre de biens réquisitionnés pour subvenir à ces entitées le jour d'avant est comptabilisé dans la variable M.RC. Bien entendu M.RC < M.I sinon "game over".
M.I = 0 // Nombre de biens invendus le jours d'avant. M.RC = 0 // Nombre de biens réquidsitionnés pour les démunis (Resto du Coeur).
A ce stade, il n'y a pas d'activité banquaire autre que la politique monétaire de l'Etat, qui crée et détruit la monnaie à volonté.
On définit le comportement journalier au hasard des entités. Chaque entité dépense une partie de sa trésorie, un pourcentage au hasard, pour l'achat de biens, et après avoir acquis les biens, en utilise une partie aléatoire mais au minimum 5 biens pour son train de vie, le reste étant consacré à la construction d'usines. Puis elle fixe le prix du bien produits par ses usines. Elle choisit un prix au hasard compris entre 0 et 2 fois le prix moyen d'un bien le jour d'avant. Noter que le seul hasard ainsi défini ne changera pas le prix moyen d'un jour à l'autre.
Entité.A = 0 // Nombre de francs utilisés pour l'achat de bien. Entité.C = 0 // Nombre de biens utilisés pour la construction d'usines. Entité.P = 0 // Prix de vente des biens qu'il produit.
Chaque objet possède un ensemble d'attributs formant un espace de noms :
|
|
L'initialisation doit se rapprocher à ce qu'aurait produit une évolution du système pendant une dixaine d'année. On le fait aproximativement en respectant certaine règles linéaires :
Pour percevoir la situation économique du système, on calcul différents indicateurs numériques en une et deux dimensions.
On utilise un script pour afficher des courbes. La répartition des richesses monétaire par ordre croissant.
Téléchargez le fichiers http://vulgate.toile-libre.org/Economie/courbe.js est placez ce fichier courbe.js dans le même répertoire que votre site web, et saississez dans votre page web, dans l'entête : <script src="courbe.js"></script> Ce script compend la fonction draw qui premret de dessiner facilement des courbes dans des canevas :
<style> canvas {background:#EEEEEE} </style>
<canvas id="canvas1" width="400" height="200"></canvas>
<canvas id="canvas2" width="400" height="200"></canvas>
<script type="text/javascript"> function Affiche(X){
</script>
var L = new Array()
for (var i=0;i<X.N;i++){
L[i] = X.L[i].F
}
L.sort(function(a,b){return a>=b;})
W1 = document.getElementById("canvas1")
draw(W1,L,4,4,"Porte monnaie en Francs", "Entité", "Rangement des entités", "du moins riche au plus riches")
var U = new Array()
for (var i=0;i<X.N;i++){
var x = 0;
var l = X.L[i].U.length;
for(var j=0;j<l;j++){
x = x + X.T - X.L[i].U[j]
}
U[i]=x;
}
U.sort(function(a,b){return a>=b;})
W2 = document.getElementById("canvas2")
draw(W2,U,4,4,"Nombre d'usine-jours futurs de production", "Entité", "Rangement des entités", "du plus petit propriétaire au plus grand")
}
---- 9 avril 2023 ----
L'instruction with(M){...} permet d'ommetre M dans le nom de l'objet. Ainsi dans le bloc de code représenté par ... nous avons :
with (M) {
var x
for (var i=0; i<N; i++)
{
x = new Object()
x.F=0;
x.U=[];
x.D=0;
x.B=0;
L.push(x);
}
nu = 2*N*Min/Usine.W
for (var i=0; i<nu ;i++)
{
var n=Math.floor(N*Math.random());
var u=T - i*Usine.V/nu;
L[n].U.push(u);
}
var f = nu*Usine.W*Bm;
for (var i=0; i<f ;i++)
{
var n=Math.floor(N*Math.random());
L[n].F++;
}
}
L'utilisation de l'instruction with(M){...} nécessite de bien connaitre l'espace de noms que forment les attributs de M qui ne peuvent plus être utilisés comme nom de nouvelle variable. L'espace de nom de M est :
{T, Usine, L, N, Bm, Tv, Tp, Tr, Tf, Min, A, R}
4) Programmation javascript avec le framework jquery
On utilise le framework jquery. On commence par récupérer le framework compressé jquery jquery-3.6.4.min.js que l'on enregistre dans le dossier du site web, et on ajoute dans l'entête de la page web : <script src="jquery-3.6.4.min.js"></script>
On utilise un worker w pour faire le calcul du modèle au cours d'une ou plusieurs itérations. C'est un script javascript w.js qui est lancé en arrière plan et avec lequel on communique par envoi et réception de messages via des gestionnaires d'évènements. On crée le worker w qui exécutera le script w.js avec la commande suivante :
var w = new Worker('w.js');
On regroupe tous les paramètres et variables du modèle dans une arborescence d'objets, avec comme objet racine, M. Délors l'intégralité des données du modèle à un instant donné se trouve dans l'objet M et peut être convertie en une chaine de caractères m grâce à la commande :
var m = JSON.stringify(M);
Et on transmet cette chaine de caractère m dans un message au worker w par la commande :
w.postMessage(m);
Puis le worker w est à l'écoute des messages grâce à la commande suivante écrite dans le script w.js :
onmessage = function(e) {
...
}Il récupère le message et recompose l'objet M par la commande suivante :
local M = JSON.parse(e.data);
Puis une fois que le worker w à fini son calcul, il renvoit l'objet M en le convertissant en chaine de caractère m par les commandes :
var m = JSON.stringify(M);
postMessage(m);Puis la page web est à l'écoute des messages provenant du worker w, et récupère le message, et recompose l'objet M2 grâce aux commandes :
w.onmessage = function(e){
var M2 = JSON.parse(e.data);
}On a ainsi définit deux scripts l'un se trouvant sur la page web jeu-economique.htm et l'autre se trouvant dans le même répertoire dans le fichier w.js comme suit :
jeu-economique.html
<script type="text/javascript"> var M = (initialisation de M)
</script>
var w = new Worker('w.js');
w.onmessage = function(e){
var M2 = JSON.parse(e.data);
...
... (traitement de M2)
...
}
var m = JSON.stringify(M);
w.postMessage(m);w.js
onmessage = function(e) {
var M = JSON.parse(e.data);
...
... (traitement de M)
...
var m = JSON.stringify(M);
postMessage(m);
}
, et en procédant au calcul du modèle par un processus en arrière plan qui est pilotés par transmission de messages à travers des gestionnaires d'évènements.