""" suites_arithmetico_geometrique.py 
"""
#! /usr/bin/python3
# -*- coding: utf-8 -*-
# lettres accentuées interdites sauf chaînes de caractères et commentaires
from math import log
doc="""
# calcul de la suite arithmético-géométrique : u(n+1) = q u(n) + r
# données : u0, q, r
# u0 = population initiale
# q  = diminution relative à chaque itération (raison géométrique)
# r  = apport à chaque itération (raison arithmétique)
# Pour une suite arithmétique : q = 1
# Pour une suite géométrique  : r = 0 
"""
# données de la suite :
# 
u0 = 2000
r =  100 # arrivées annuelles
q =  0.9 # départ de 10% des habitants chaque année
nmax = 6 # quelle sera la population après 6 ans ?

print("# Enoncé :")
print(f"  population initiale : u(0) = {u0}")
print(f"  u(n+1) = {q} u(n) + {r}")

# Population après "nmax" ans
print("# Evolution annuelle de la population (arrondie à l'unité) :")
# ne jamais séparer (n et u)
n = 0
u = u0
print(f"  u({n:2d}) = {u:.0f}")
for i in range(nmax) : # boucle "nmax" fois
    # indentation des instructions de la boucle par 4 espaces
    # u(n+1) = q u(n) + r
    n = n + 1
    u = q * u + r
    print(f"  u({n:2d}) = {u:.0f}")
    # fin de la boucle, donc de l'indentation par 4 espaces

# Quand la population atteindra-t-elle un certain seuil
seuil = 1050
print(f"# Quand la population atteindra-t-elle le seuil de {seuil} ?")
print("# Calcul par boucle jusqu'à ce que u(n) < seuil")
n = 0
u = u0
while u > seuil : # boucle jusqu'à ce que u(n) <= seuil
    # u(n+1) = q u(n) + r
    n = n + 1
    u = q * u + r
print(f"  résultat : u({n:2d}) = {u:.0f}")
print()

print("# Calcul explicite du seuil (arrondi à 0.01) :")
# 1) limite, si |q| < 1
#    L = q L + r
L = r / (1 - q)
print(f"  limite u(infini) = L = r / (1 - q) = {L:8.2f}")

print("# fonction explicite u(n) :")
# u(n+1)-L = q (u(n)-L)
# u(n)-L = q**n (u(0)-L)
# u(n) = (u(0)-L) q**n + L
u = lambda n :  (u0-L) * q**n + L
print(f"  formule explicite : u(n) = {u0-L:8.2f} * {q}**n + {L:8.2f}")

print("# équation à résoudre : seuil = (u0-L) * q**n + L ; inconnue n")
# on prend le logarithme népérien :
# ln(seuil-L) = ln(u0-L) + n ln(q)
# n = (ln(seuil-L) - ln(u0-L)) / ln(q)
n_seuil = (log(seuil-L) - log(u0-L)) / log(q)
print(f"  n_seuil={n_seuil} -> u(n_seuil)={u(n_seuil)}")
"""
"""