Maths-cours

COURS & EXERCICES DE MATHÉMATIQUES

Close

Modélisation par une fonction exponentielle


Le maire d'une ville française a effectué un recensement de la population de sa municipalité pendant 7 ans.
Les données recueillies sont présentées dans le tableau ci-dessous :

Année 2013 2014 2015 2016 2017 2018 2019
Rang 0 1 2 3 4 5 6
Habitants 2 502 2 475 2 452 2 430 2 398 2 378 2 351

Dans la première partie de l'exercice, on modélisera le nombre d'habitants à l'aide d'une suite géométrique et dans la seconde partie, on utilisera une fonction exponentielle.

Partie 1 : Modélisation à l'aide d'une suite

  1. Calculer le pourcentage d'évolution de la population de la ville entre 2013 et 2014, entre 2014 et 2015, entre 2015 et 2016 et entre 2018 et 2019.

  2. Par la suite on estimera que la population diminue de 1% par an.

    On note pn p_n le nombre d'habitants l'année 2013+nn.

    Montrer que la suite (pn)(p_n) est une suite géométrique dont on donnera le premier terme et la raison.

  3. À l'aide de la suite (pn) (p_n) estimer la population de la ville en 2030 en supposant que la diminution de la population s'effectue au même rythme pendant les années à venir.

Partie 2 : Modélisation à l'aide d'une fonction exponentielle

  1. On cherche à modéliser le nombre d'habitants à l'aide de la fonction ff définie sur [0 ; +[ \left[ 0~;~ +\infty \right[ par :

    f : t2500 e0,01tf~: \ t \longmapsto 2500\ \text{e}^{ - 0,01t }

    tt désigne la durée écoulée, en année, depuis 2013.

    Montrer que la fonction ff est strictement décroissante sur l'intervalle [0 ; +[ \left[ 0~;~ +\infty \right[ .

  2. Compléter la fonction Python ci-dessous afin qu'elle retourne les images de la variable tt par la fonction ff :

    def f(t) :
        return ...
    À l'aide d'une boucle, écrire un script Python qui retourne les images par ff des entiers compris entre 0 et 6.
    Comparer aux données de l'énoncé.
    Cette modélisation vous semble-t-elle valable ?

  3. Le maire souhaite prévoir en quelle année le nombre d'habitants de sa ville passera sous la barre des 2 200 d'après ce modèle.

    En utilisant la fonction précédente, écrire un programme Python qui répond à cette question.

Corrigé

Partie 1

  1. Le pourcentage d'évolution de la population entre 2013 et 2014 est (voir formule de calcul d'une évolution) :

    t1=p1p0p0=2 4752 5022 502 t_1 = \frac{ p_1 - p_0 }{ p_0 } = \frac{ 2~475 - 2~502 }{ 2~502 } 0,01081,08100=1,08% \approx - 0,0108 \approx \frac{ - 1,08 }{ 100 } = - 1,08\%

    De même, le pourcentage d'évolution entre 2014 et 2015 est :

    t2=p2p1p1=2 4522 4752 475 t_2 = \frac{ p_2 - p_1}{ p_1 } = \frac{ 2~452 - 2~475 }{ 2~475 } 0,00930,93100=0,93% \approx - 0,0093 \approx \frac{ - 0,93 }{ 100 } = - 0,93\%

    entre 2015 et 2016 :

    t3=p3p2p2=2 4302 4522 452 t_3 = \frac{ p_3 - p_2}{ p_2 } = \frac{ 2~430 - 2~452 }{ 2~452 } 0,00900,90100=0,90% \approx - 0,0090 \approx \frac{ - 0,90 }{ 100 } = - 0,90\%

    enfin, entre 2018 et 2019 :

    t6=p6p5p5=2 3512 3782 378 t_6 = \frac{ p_6 - p_5}{ p_5 } = \frac{ 2~351 - 2~378 }{ 2~378 } 0,01141,14100=1,14% \approx - 0,0114 \approx \frac{ - 1,14 }{ 100 } = - 1,14\%

    On remarque que, dans tous les cas, la diminution est proche de 1%.

  2. Le coefficient multiplicateur qui fait passer de pn+1p_{n+1} à pnp_n correspondant à une baisse de 1% est (voir coefficient multiplicateur) :

    CM=11100=0,99 CM=1 - \frac{ 1 }{ 100 } =0,99

    On a donc, pour tout entier naturel nn :

    pn+1=0,99pnp_{n+1} = 0,99p_n

    La suite (pn) \left( p_n \right) est donc une suite géométrique de raison q=0,99. q = 0,99. Son premier terme est p0=2502. p_0=2502.

  3. La population de la ville à l'année de rang nn est :

    pn=p0 qn=2502×0,99n p_n=p_0\ q^n = 2502 \times 0,99^n

    L'année 2030 correspond au rang 17. La population en 2030 peut donc, d'après ce modèle, être estimée à :

    p17=2502×0,99172109. p_{ 17 } = 2502 \times 0,99^{ 17 } \approx 2109.

Partie 2

  1. ff est dérivable sur [0 ; +[ \left[ 0~;~ +\infty \right[ . Pour déterminer le sens de variation de ff, on calcule sa dérivée f f^{\prime} .
    Sachant que la dérivée de la fonction teat t \longmapsto \text{e}^{ at } est la fonction ta eat t \longmapsto a\ \text{e}^{ at } on obtient :

    f(t)=2500×0,01e0,01t=25 e0,01tf^{\prime}(t)=2500 \times - 0,01 \text{e}^{ - 0,01t } = - 25 \ \text{e}^{ - 0,01t }

    25 - 25 est strictement négatif tandis que e0,01t\text{e}^{ - 0,01t } est strictement positif (car la fonction exponentielle ne prend que des valeurs strictement positives) donc f(t)<0f^{\prime}(t) < 0 sur [0 ; +[ \left[ 0~;~ +\infty \right[ .

    Par conséquent, la fonction ff est strictement décroissante sur l'intervalle [0 ; +[ \left[ 0~;~ +\infty \right[ .

  2. La fonction Python se définit simplement comme suit :

    def f(t) :
        return 2500 * exp(-0.01 * t)

    On doit toutefois importer le module math qui contient la fonction exp ; par exemple :

    from math import exp
    def f(t) :
        return 2500 * exp(0.01 * t)

    Comme on connait le nombre d'itérations, on peut employer une boucle for pour afficher les images des 7 premières valeurs entières de tt :

    from math import exp
    def f(t) :
        return 2500 * exp(-0.01 * t)
    
    for t in range(7) : 
        print(f(t))


    On obtient le résultat suivant :

    2500.0
    2475.1245843729203
    2450.4966832668883
    2426.1138338712703
    2401.973597880808
    2378.073561251785
    2354.411333960622

    Ces valeurs sont suffisamment proches de celles du tableau donné dans l'énoncé pour considérer que cette modélisation est satisfaisante.

  3. On utilise une boucle while pour répondre à la question.
    On reste dans la boucle tant que le nombre d'habitants est supérieur ou égal à 2 200 et on sort de la boucle dès que ce nombre devient strictement inférieur à 2 200.

    Il faut penser à initialiser la variable t avant la boucle et à l’incrémenter à l'intérieur de la boucle (voir : boucles while). On peut ensuite afficher la valeur de t à la sortie de la boucle :

    from math import exp
    def f(t) :
        return 2500 * exp(-0.01 * t)
    
    t=0
    while f(t) >= 2200: 
        t=t+1
    print(t)

    Ce programme affiche la valeur 13.

    D'après ce modèle, la population passera sous la barre des 2 200 l'année de rang 13 c'est à dire en 2013+13 = 2026.