FLASH INFORMATIQUE FI



Age de la retraite et Sysquake




Yves PIGUET


Sysquake [1], un logiciel de calcul numérique et de représentation graphique déjà présenté dans ces colonnes (FI de décembre 2007), a un langage de programmation compatible avec Matlab. Pour illustrer ce que les graphiques interactifs, avantage essentiel de Sysquake, apportent à la compréhension d’un problème, nous nous intéresserons à l’effet de l’âge de la retraite sur l’évolution des primes AVS.
La simulation de l’évolution de la population, dans un modèle simple qui néglige les flux migratoires et dont les paramètres de natalité et de mortalité sont constants, est basée sur un système d’équations qui donne le nombre d’hommes et de femmes pour chaque tranche d’âge en fonction de la population de l’année précédente. Soient l_{xi}(a) et l_{yi}(a) le nombre d’hommes et de femmes d’âge i = 0,1,...,99 l’année a ; la population l’année suivante est

l_{x0}(a+1)  =  r_x \sum_k f_k l_{yk}(a)

l_{xi}(a+1)  =  (1 - q_{xi}) l_{xi-1}(a), i \ge 1

l_{y0}(a+1)  =  (1 - r_x) \sum_k f_k l_{yk}(a)

l_{yi}(a+1)  =  (1 - q_{yi}) l_{yi-1}(a), i \ge 1

fk est la probabilité pour une femme d’avoir un bébé à l’âge k, rx est la proportion de naissances de garçons, et qxi et qyi sont les probabilités de décès à l’âge i pour les hommes et les femmes.
Ces équations sont faciles à écrire sous la forme d’une fonction Matlab. En partant de conditions initiales connues, comme celles du recensement de 1990, on peut simuler l’évolution de la population sur une certaine durée et afficher la pyramide des âges dans le futur, par exemple en 2020, ou calculer la population totale, \sum_i (l_{xi}(a) + l_{yi}(a)) .
Pour fixer l’âge de la retraite, une valeur importante à connaître est le nombre d’actifs par retraité R : si l’on suppose pour simplifier que le revenu est conservé après la retraite et que les effets de l’épargne sont négligeables, elle donne directement la part du salaire à consacrer au financement des retraites. Avec quatre actifs par retraité, par exemple, 20% du salaire doivent être consacrés à la retraite pour qu’en moyenne, les quatre actifs et le retraité touchent chacun 80% d’un salaire.
À partir des chiffres pour chaque tranche d’âge au fil des ans, il est facile de tracer l’évolution de R.

fig. 1 - Âge de la retraite à 65 ans

On obtient la figure 1, préoccupante puisqu’avec une retraite à 65 ans pour tous et une entrée dans la vie active à 20 ans, on observe une stabilisation autour de deux actifs par retraité vers 2030. Quel moyen a-t-on pour changer les choses ?
Avec Matlab [2] ou avec un document imprimé comme Flash Informatique, on peut changer les paramètres de la simulation et obtenir d’autres graphiques figés. L’intérêt de Sysquake est de permettre une manipulation directe des graphiques avec la souris et de rendre l’effet des paramètres perceptible en continu, de manière beaucoup plus parlante.

fig. 2 - Âge de la retraite à 73 ans

L’âge de la retraite, représenté par une droite horizontale dans la pyramide des âges, peut être relevé ; on verra alors R se stabiliser à 4 pour une retraite à 73 ans. Choix politique simpliste et inapplicable ? Un taux de natalité de 2,1, qui assure le maintien de la population à 7,5 millions, ferait déjà remonter R à 3.
Au-delà de ces constatations qui ne font pas dans la nuance, l’interactivité de Sysquake permet de comprendre les mécanismes qui se cachent derrière les chiffres bien mieux qu’avec des graphiques statiques, et cela contre un effort très faible en terme de programmation supplémentaire, comme le montre le listing suivant.

fonctions (compatibles Matlab) en un ou plusieurs blocs

functions
{@

modèle

function [lx1, ly1] = nextYear(lx, ly, dData)
babies = dData.f * ly';
lx1 = [0.5*babies, lx(1:end-1).*(1-dData.
 qx(1:end-1))];
ly1 = [0.5*babies, ly(1:end-1).*(1-dData.
  qy(1:end-1))];

recensement de 1990

function dData = loadSwitzerland1990
paramètres}</p><code>
        dData.age = 0:99;
        dData.qx = [...];
        dData.qy = [...];
        dData.f = [...];

conditions initiales

        dData.year0 = 1990;
        dData.lx0 = [...];
        dData.ly0 = [...];
}

description de l’interface

title "Swiss population"
identificateurs des éléments manipulables}</p><code>
define currentYearId = _auto
define retirementId = _auto

variables gérées par Sysquake pour synchroniser les figures, undo/redo, save...

variable dData

variable year
variable retirement

initialisation

init dData = loadSwitzerland1990
init year = 1990
init retirement = 65
init initFig

définition des figures

figure "Population"

affichage

draw drawPyramid(dData, year, retirement)

effet de la souris

mousedrag retirementId retirement = max(_y1,
 20)

figure "Population Evolution"
draw drawPop(dData, retirement, year, 0)
mousedrag currentYearId year = round(_x1)

figure "Employed/Retired Ratio"
draw drawPop(dData, retirement, year, 1)
mousedrag currentYearId year = round(_x1)

fonctions propres à Sysquake

functions
{

disposition initiale des figures

function initFig
subplots(['Population\tPopulation
 Evolution\n',...
 '\tEmployed/Retired Ratio']);

affichage de la pyramide des âges

function drawPyramid(dData, year, retirement)
lx = dData.lx0;
ly = dData.ly0;

simulation de year0 à year

for i = dData.year0+1:year
 [lx, ly] = nextYear(lx, ly, dData);
end
line([1, 0], 0, 'k');

ID d’objet manipulable

plot(-lx*1e-3, dData.age, 'bs');
plot(ly*1e-3, dData.age, 'ms');

droite 0 x + 1 y = retirement

line([0, 1], retirement, 'g', retirementId);
scale lock;

affichage de l’évolution au cours du temps

function drawPop(dData, retirement, year,
 ratio)
children = dData.age < 20;
adults = dData.age >= 20 & dData.age < retirement;
retired = dData.age >= retirement;
select = [children; adults; retired];

if ratio
 scale([dData.year0 + [0, 70], 0, 8]);
else
 scale(dData.year0 + [0, 70]);
end

l’utilisateur peut avoir changé l’échelle..

.
sc = scale;
yearmax = ceil(sc(2));
c = zeros(3, yearmax + 1 - dData.year0);
c(:, 1) = select * (dData.lx0 + dData.ly0)';
lx = dData.lx0;
ly = dData.ly0;

simulation assez longue pour la zone affichée

for i = dData.year0+1:yearmax
 [lx, ly] = nextYear(lx, ly, dData);
 c(:, i - dData.year0) = select * (lx +
  ly)';
end

rapport actifs/retraité

s
if ratio
 plot(dData.year0, 0, ' ');
 plot(dData.year0:yearmax, c(2,:) ./c(3,:));
else

jeunes/actifs/retraités area((dData.year0:yearmax)’, c’*1e-6, ’yrg’) ; end

droite 1 x + 0 y = year (année de la pyramide des âges)

line([1, 0], year, 'k', currentYearId);
plotoption ygrid;

}

Une application de simulation démographique plus complète est fournie avec Sysquake.

[1] Disponible à l’EPFL sur Distrilog et Poséidon - www.calerga.com

[2] Matlab possède certaines possibilités de manipulation interactive des graphiques, mais au prix d’une grande lourdeur de mise en oeuvre et d’une fluidité bien moindre



Cherchez ...

- dans tous les Flash informatique
(entre 1986 et 2001: seulement sur les titres et auteurs)
- par mot-clé

Avertissement

Cette page est un article d'une publication de l'EPFL.
Le contenu et certains liens ne sont peut-être plus d'actualité.

Responsabilité

Les articles n'engagent que leurs auteurs, sauf ceux qui concernent de façon évidente des prestations officielles (sous la responsabilité du DIT ou d'autres entités). Toute reproduction, même partielle, n'est autorisée qu'avec l'accord de la rédaction et des auteurs.


Archives sur clé USB

Le Flash informatique ne paraîtra plus. Le dernier numéro est daté de décembre 2013.

Taguage des articles

Depuis 2010, pour aider le lecteur, les articles sont taggués:
  •   tout public
    que vous soyiez utilisateur occasionnel du PC familial, ou bien simplement propriétaire d'un iPhone, lisez l'article marqué tout public, vous y apprendrez plein de choses qui vous permettront de mieux appréhender ces technologies qui envahissent votre quotidien
  •   public averti
    l'article parle de concepts techniques, mais à la portée de toute personne intéressée par les dessous des nouvelles technologies
  •   expert
    le sujet abordé n'intéresse que peu de lecteurs, mais ceux-là seront ravis d'approfondir un thème, d'en savoir plus sur un nouveau langage.