Les suites mathématiques constituent un pilier fondamental dans de nombreux domaines, de l’analyse financière à la modélisation des phénomènes naturels. Qu’il s’agisse de prévoir la croissance d’une population, de calculer des intérêts composés ou d’analyser des séquences numériques, les suites mathématiques offrent un cadre puissant pour décrire des processus itératifs. Dans ce contexte, Python s’impose comme un outil idéal pour programmer et explorer ces suites, grâce à sa syntaxe claire et ses nombreuses bibliothèques dédiées au calcul scientifique. Dans cet article, nous allons explorer comment programmer diverses suites mathématiques en Python, en commençant par les suites les plus simples jusqu’aux applications plus complexes.

Alors, une suite mathématique est simplement une succession de nombres obéissant à une règle définie. Cette règle peut être explicite (chaque terme est donné par une formule) ou récursive (chaque terme dépend des précédents). Nous aborderons successivement les suites arithmétiques, géométriques, récurrentes comme la suite de Fibonacci, et nous verrons comment les visualiser graphiquement. Nous explorerons également comment appliquer ces connaissances à des problèmes concrets.

Que vous soyez étudiant, enseignant, développeur ou simplement curieux, ce guide vous donnera les clés pour maîtriser la programmation des suites mathématiques en Python.

Prérequis techniques pour programmer des suites mathématiques en Python 

Pour commencer, vous devez disposer d’une installation fonctionnelle de Python (version 3.6 ou supérieure recommandée). Vous pouvez suivre ce guide pour installer python ou voir comment utiliser une distribution IDE comme Pycharm, particulièrement adaptée aux calculs scientifiques.

Ainsi, les modules suivants seront indispensables pour notre travail sur les suites mathématiques :

• NumPy : cette bibliothèque permet de manipuler efficacement des tableaux multidimensionnels et offre des fonctions mathématiques avancées. Installez-la via la commande : 
  • pip install numpy
• Matplotlib : ce module de visualisation nous permettra de représenter graphiquement nos suites. Installez-le avec : 
  • pip install matplotlib

Un environnement de développement intégré (IDE) comme PyCharm, VS Code facilitera grandement l’expérimentation avec les suites mathématiques. Personnellement, j’ai utilisé Visual Studio Code pour faire les programmes python et les visualisations graphiques de cet article.

Rappel mathématique sur les suites

Brièvement, les suites mathématiques sont des séquences ordonnées de nombres qui suivent un certain motif ou une règle. Voici un rappel simple pour comprendre les concepts de base des suites.

Définition d’une suite mathématique

Une suite est une liste ordonnée de nombres, souvent notée (u_n), où n est un entier naturel qui représente la position du terme dans la suite.

On distingue principalement deux types de Suites :

• Suite Arithmétique : Chaque terme augmente ou diminue par une valeur constante appelée la « raison ».
  • Par exemple, la suite : 2 ; 4 ; 6 ; 8 ; … est arithmétique avec une raison égale à 2.
• Suite Géométrique : Chaque terme est obtenu en multipliant le terme précédent par une valeur constante appelée la « raison ».
  • Par exemple, la suite : 3 ; 9 ; 27 ; … est géométrique avec une raison égale à 3.

Notation des suites mathématiques

• U₁ est le premier terme de la suite U;
• U_n désigne le n-ième terme de la suite.
• U_n+1 est le terme suivant U_n.

Formule Générale des suites mathématiques

• Pour une suite arithmétique : U_n=U₁+(n−1)⋅r, où r est la raison.
• Pour une suite géométrique : U_n=U₁⋅q⁽ⁿ⁻¹⁾, où q est la raison.

Somme des Termes d’une suite arithmétique

La somme des n premiers termes d’une suite arithmétique est donnée par :

S_n=(U₁+U_n)

Somme des Termes d’une suite géométrique

La somme des n premiers termes d’une suite géométrique est donnée par :

Sn=[(1-qn)/(1-q)].U1 (avec q différent de 1)

Ces concepts de base permettent de comprendre et de manipuler les suites mathématiques dans divers contextes.

Structures pour manipuler les suites mathématiques en Python

En effet, il existe plusieurs structures essentielles pour coder les suites mathématiques en python. On peut citer à titre d’exemples :

• Les listes pour stocker les valeurs.
• Les fonctions pour définir des suites paramétrables.
• Les boucles pour générer les termes successifs.

Programmer une suite arithmétique en Python : le code pas à pas

Comme expliqué plus haut, une suite arithmétique est une séquence de nombres où chaque terme est obtenu en ajoutant une constante (la raison) au terme précédent. 

Étape 1 : Définir les Paramètres

Tout d’abord, pour programmer une suite arithmétique en python, vous devez définir :

• Le premier terme (U1).
• La raison (r).
• Le nombre de termes (n) que vous souhaitez générer.

Étape 2 : Écrire le Code de la suite mathématique en python

Ensuite écrire le programme, voici comment vous pouvez écrire un programme Python pour générer une suite arithmétique :

def suite_arithmetique(premier_terme, raison, nombre_de_termes):
    # Initialiser une liste vide pour stocker les termes de la suite
    suite = []

    # Calculer chaque terme de la suite
    for i in range(nombre_de_termes):
        # Calculer le terme actuel
        terme = premier_terme + i * raison
        # Ajouter le terme à la liste
        suite.append(terme)

    return suite

# Exemple d'utilisation
premier_terme = 2
raison = 3
nombre_de_termes = 10

# Générer la suite arithmétique
suite = suite_arithmetique(premier_terme, raison, nombre_de_termes)
print(suite)

# Visualisation graphique
import matplotlib.pyplot as plt
plt.figure(figsize=(10, 6))
plt.plot(suite, marker='o', linestyle='-', color='b')
plt.title('Suite Arithmétique')
plt.xlabel('Rang du Terme')
plt.ylabel('Valeur du Terme')
plt.grid(True)
plt.show()

Étape 3 : Explication du Code

1. Fonction suite_arithmetique :
   • Elle prend trois arguments : premier_terme, raison, et nombre_de_termes.
   • Elle initialise une liste vide suite pour stocker les termes.
2. Boucle for :
   • Elle itère nombre_de_termes fois.
   • À chaque itération, elle calcule le terme actuel en utilisant la formule terme=premier_terme+i×raison. Il faut noter que’ en mathématiques, les suites commencent souvent à l’indice 1, tandis qu’en programmation, les boucles commencent souvent à l’indice 0. Cela nécessite un ajustement dans la formule pour s’assurer que le premier terme est correctement calculé.
   • Elle ajoute le terme calculé à la liste suite.
3. Retourne la Liste :
   • La fonction retourne la liste complète des termes de la suite arithmétique.

Étape 4 : Tester le Code

Evidemment, vous pouvez tester le code avec différentes valeurs pour premier_terme, raison, et nombre_de_termes pour voir comment la suite change.

Applications pratiques des suites arithmétiques

De plus, voici quelques applications pratiques des suites arithmétiques :

Économie et Finance : Épargne et intérêts simples

Si une personne dépose 100 € par mois sur un compte sans intérêts composés, la somme totale accumulée suit une suite arithmétique.

• Premier dépôt : u1=100
• Montant ajouté chaque mois : r=100
• Somme après n mois : U_n=U₁+(n-1)×r

Après 12 mois, le total sera : U₁₂=100+(12-1)×100=1200€

Informatique et Algorithmique : Allocation mémoire

Dans certains langages de programmation, l’allocation dynamique de mémoire suit une suite arithmétique.

• Un programme peut allouer 256 octets initialement.
• Si la mémoire est insuffisante, 64 octets sont ajoutés à chaque augmentation.
• La mémoire allouée après n augmentations suit la suite : un=256+(n-1)×64

Construction et Architecture : Placement des marches d’un escalier

Lors de la construction d’un escalier régulier, chaque marche est placée à une hauteur constante.

• Si la première marche est à 20 cm du sol,
• et que la hauteur de chaque marche est 17 cm,
• alors la hauteur de la n-ième marche suit la suite :
  • h_n=20+(n−1)×17

La 10e marche sera donc à :

h₁₀=20+9×17=173 cm

Sport et Entraînement : Augmentation progressive des charges

Un athlète suit un programme où il augmente sa charge de 5 kg à chaque séance.

• Départ à 50 kg,
• Progression de 5 kg par séance,
• Charge après n séances : U_n=50+(n-1)×5

Après 8 séances, il soulèvera :

U₈=50+7×5=85 kg

Exemples réels d’applications des suites arithmétiques :

1. Un salarié reçoit une augmentation fixe chaque année.

• Salaire initial de 2000€
• Augmentation de 50€ par an
• Salaire après n années : Un=2000+(n-1)×50 

Après 5 ans, il gagnera : U₅=2000+4×50=2200€

• Un coureur augmente progressivement sa distance hebdomadaire.

• Distance initiale de 2 km
• Progression de 0.5 km par semaine
• Distance après n semaines : Un=2+(n-1)×0.5 

Après 8 semaines, il courra : U₈=2+7×0.5=5.5 km

• Un jardinier mesure la croissance d’une plante chaque semaine.

• Taille initiale de 5 cm
• Croissance de 2 cm par semaine
• Taille après n semaines : Un=5+(n-1)×2

Après 6 semaines, la plante mesurera : U₆=5+5×2=15 cm

Ces exemples montrent comment les suites arithmétiques permettent de modéliser simplement des situations de progression régulière dans la vie quotidienne.

Comment coder et visualiser des suites géométriques en Python

En outre, une suite géométrique est une séquence de nombres où chaque terme est obtenu en multipliant le terme précédent par une constante appelée la « raison ». La formule générale pour le n-ième terme d’une suite géométrique est :

U_n=U₁⋅q⁽ⁿ⁻¹⁾,

où :

• U₁ est le premier terme de la suite.
• q est la raison, le facteur constant par lequel chaque terme est multiplié pour obtenir le terme suivant.
• n est la position, ou le rang, du terme dans la suite.

Code Python pour Générer une Suite Géométrique

Par ailleurs, voici un code Python détaillé pour générer une suite géométrique, suivi d’une visualisation graphique des résultats :

import matplotlib.pyplot as plt

def suite_geometrique(premier_terme, raison, nombre_de_termes):
    # Initialiser une liste vide pour stocker les termes de la suite
    suite = []

    # Calculer chaque terme de la suite
    for i in range(nombre_de_termes):
        # Calculer le terme actuel
        terme = premier_terme * (raison ** i)
        # Ajouter le terme à la liste
        suite.append(terme)

    return suite

# Exemple d'utilisation
premier_terme = 100
raison = 0.6
nombre_de_termes = 10

# Générer la suite géométrique
suite = suite_geometrique(premier_terme, raison, nombre_de_termes)
print(suite)
# Visualisation graphique
plt.figure(figsize=(10, 6))
plt.plot(suite, marker='o', linestyle='-', color='b')
plt.title('Suite Géométrique')
plt.xlabel('Rang du Terme')
plt.ylabel('Valeur du Terme')
plt.grid(True)
plt.show()

Explication du code pour suite mathématiques en python

1. Fonction suite_geometrique :
   • Elle prend trois arguments : premier_terme, raison, et nombre_de_termes.
   • Elle initialise une liste vide, suite, pour stocker les termes.
2. Boucle for :
   • Elle itère nombre_de_termes fois.
   • À chaque itération, elle calcule le terme actuel en utilisant la formule 
     • terme = premier_terme × raisonⁱ.
   • Elle ajoute le terme calculé à la liste suite.
3. Visualisation Graphique :
   • Utilise matplotlib pour tracer les termes de la suite.
   • Le graphique montre comment les termes de la suite augmentent de manière exponentielle.

Visualisation Graphique de suite géométrique en python

Comme on peut le constater, le graphique ci-dessus montre la progression des termes de la suite géométrique. Vous pouvez voir comment chaque terme est un multiple du précédent, illustrant la croissance exponentielle typique des suites géométriques.

Cas Particuliers des Suites Géométriques

Suite géométrique avec une Raison égale à 1 :

Si la raison q=1, la suite géométrique devient une suite constante où tous les termes sont égaux au premier terme. Par exemple, 5,5,5,…

Suite géométrique avec une Raison égale à -1 :

Si la raison q=−1, la suite alterne entre le premier terme et son opposé. 

Par exemple : 2,−2,2,−2,…

Suite géométrique avec une Raison égale à 0 :

Si la raison q=0, tous les termes après le premier sont égaux à 0. 

Par exemple : 3,0,0,…

Suite géométrique avec une Raison négative :

Si la raison est négative, la suite oscille entre des valeurs positives et négatives. 

Par exemple, avec q=−2, la suite 1,−2,4,−8,… alterne en signe.

Exemples d’application des suites géométriques

Ainsi, voici des exemples réels d’applications des suites géométriques :

Un placement financier avec intérêts composés annuels.

• Capital initial de la première année 1000€
• Taux d’intérêt de 5% par an (coefficient multiplicateur : 1.05)
• Capital après n années : Un=1000×(1.05)^n-1

Après 3 ans, le capital sera : U3=1000×(1.05)²=1102.50€

La propagation d’un virus dans une population.

• Départ avec 10 personnes infectées le premier jour. 
• Chaque personne infecte 2 nouvelles personnes par jour
• Nombre des nouveaux cas infectés après n jours : Un=10×2^n-1

Donc, il y aura : U₅=10×2⁴=160 personnes infectées le 5^ème jours

La dépréciation d’une voiture.

• Valeur initiale de 20 000€
• Perte de 15% par an (coefficient multiplicateur : 0.85)
• Valeur après n années : Un=20 000×(0.85)^n-1

Alors, après 4 ans, la valeur sera : U4=20 000×(0.85)³=12 282€

L’augmentation du trafic d’un site web.

• Départ avec 100 visiteurs le 1^er mois
• Augmentation de 50% par mois (coefficient multiplicateur : 1.5)
• Nombre de visiteurs après n mois : Un=100×(1.5)^n-1

Ainsi, après 4 mois, il y aura : U4=100×(1.5)³=338 visiteurs

Le rebond d’une balle.

• Hauteur initiale de 100 cm
• À chaque rebond, la balle atteint 60% de sa hauteur précédente
• Hauteur après n rebonds : Un=100×(0.6)^n-1

Par conséquent, après 5 rebonds, la hauteur sera : U5=100×(0.6)⁴=12.96 cm

Ces exemples illustrent comment les suites géométriques permettent de modéliser des situations où la variation est proportionnelle à la valeur précédente, que ce soit en croissance ou en décroissance.

Programmer des suites récurrentes comme Fibonacci en Python

Les suites récurrentes représentent une catégorie fascinante des suites mathématiques en Python, où chaque terme est défini en fonction des termes précédents. Contrairement aux suites arithmétiques ou géométriques qui suivent une règle simple, les suites récurrentes peuvent modéliser des comportements plus complexes et plus proches de la réalité.

Qu’est-ce qu’une suite récurrente ?

Une suite récurrente est définie par :

• Une ou plusieurs valeurs initiales (U₀, U₁, etc.)
• Une relation de récurrence qui exprime Un en fonction des termes précédents

En particulier, la principale difficulté dans leur implémentation réside dans le fait qu’on ne peut pas calculer directement le n-ième terme : il faut calculer tous les termes précédents.

La Suite de Fibonacci

Probablement, la suite de Fibonacci est la suite récurrente la plus célèbre. Elle est définie par :

F_n+2=F_n+1+F_n

avec les conditions initiales : F₀=0 et F₁=1.

import matplotlib.pyplot as plt

def fibonacci(n):
    # Initialisation des premiers termes
    if n == 0: return [0]
    termes = [0, 1]
    
    # Calcul des termes suivants
    for i in range(2, n + 1):
        termes.append(termes[-1] + termes[-2])
    return termes

# Calculer les 10 premiers termes
fib = fibonacci(10)
print(fib)  # [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55]

# Visualisation graphique
plt.figure(figsize=(10, 6))
plt.plot(fib, marker='o', linestyle='-', color='b')
plt.title('Suite Fibonacci')
plt.xlabel('Rang du Terme')
plt.ylabel('Valeur du Terme')
plt.grid(True)
plt.show()

Visualisation Graphique de la suite de Fibonacci

En particulier, la suite de Fibonacci montre une croissance exponentielle, visible sur un graphique où les valeurs augmentent rapidement.

Ainsi, cette suite apparaît fréquemment dans la nature, comme dans la disposition des pétales de fleurs ou la croissance des coquillages.

Exercice : Modélisation de la reproduction des lapins avec la suite de Fibonacci 🐰

Supposons qu’un éleveur commence avec un couple de lapins (un mâle et une femelle) encore trop jeunes pour se reproduire. En revanche, à partir du deuxième mois, chaque couple de lapins adulte donne naissance à un nouveau couple chaque mois. On suppose que :

1. Les lapins ne meurent jamais.
2. Un couple devient adulte après un mois et commence à se reproduire dès le mois suivant.
3. Chaque couple adulte donne naissance à exactement un nouveau couple par mois.

Questions :

1. Complétez le tableau suivant jusqu’au 10ᵉ mois :

2. À partir de combien de mois y a-t-il plus de 100 couples de lapins ?
3. Écrivez un programme en Python qui affiche le nombre total de couples de lapins chaque mois.

Code python avec une modélisation graphique

Par exemple, voici un code python qui donne la solution de l’exercice de modélisation de la reproduction des lapins avec la suite de Fibonacci.

import matplotlib.pyplot as plt

def fibonacci_lapins_tableau_et_graphique(n):
    # Initialisation : Mois 1 -> 1 jeune couple, 0 adulte
    jeunes = [1] + [0] * (n-1)  # Liste des jeunes couples
    adultes = [0] * n           # Liste des adultes
    total = [1] + [0] * (n-1)   # Liste du total des couples

    # Calcul des valeurs mois par mois
    for mois in range(1, n):
        adultes[mois] = adultes[mois-1] + jeunes[mois-1]  # Adultes du mois précédent + jeunes devenus adultes
        jeunes[mois] = adultes[mois-1]  # Chaque adulte du mois précédent donne naissance à un nouveau couple
        total[mois] = adultes[mois] + jeunes[mois]  # Total = jeunes + adultes

    # Affichage du tableau
    print(f"{'Mois':<5}{'Jeunes couples':<20}{'Adultes':<10}{'Total couples'}")
    print("-" * 50)
    for mois in range(n):
        print(f"{mois+1:<5}{jeunes[mois]:<20}{adultes[mois]:<10}{total[mois]}")

    # Tracer le graphique
    mois_list = list(range(1, n+1))
    
    plt.figure(figsize=(10, 5))
    plt.plot(mois_list, jeunes, marker='o', linestyle='-', label="Jeunes couples", color="blue")
    plt.plot(mois_list, adultes, marker='s', linestyle='--', label="Adultes", color="green")
    plt.plot(mois_list, total, marker='d', linestyle='-', label="Total couples", color="red")

    # Personnalisation du graphique
    plt.xlabel("Mois")
    plt.ylabel("Nombre de couples")
    plt.title("Évolution du nombre de lapins selon la suite de Fibonacci")
    plt.legend()
    plt.grid(True)
    plt.show()

# Exécuter pour 10 mois
fibonacci_lapins_tableau_et_graphique(10)

En résumé, le graphique illustre l’évolution du nombre de couples de lapins selon la célèbre suite de Fibonacci. On observe trois courbes distinctes :

• 🔵 Les jeunes couples : Ils apparaissent chaque mois en fonction du nombre d’adultes du mois précédent. Leur croissance suit une tendance irrégulière au début, mais s’accélère progressivement.
• 🟢 Les adultes : Ils augmentent chaque mois à mesure que les jeunes couples du mois précédent deviennent matures.
• 🔴 Le total des couples : La somme des jeunes et des adultes suit une croissance exponentielle, caractéristique de la suite de Fibonacci.

Ainsi, ce modèle simple permet de visualiser comment une population peut croître de manière fulgurante si aucune contrainte (espace, nourriture) ne vient la limiter.

Finalement, la suite de Fibonacci trouve aussi des applications en biologie, économie et modélisation informatique. 

La Suite logistique

Par ailleurs, la suite logistique est un modèle mathématique utilisé pour décrire la croissance d’une population avec des ressources limitées :

• Un+1 = r × Un × (1 – Un) où r est un paramètre de croissance et Un représente la population relative (entre 0 et 1)

import numpy as np
import matplotlib.pyplot as plt

def suite_logistique(u0, r, n):
    """ Génère une suite logistique pour un paramètre r donné """
    u = [u0]
    for _ in range(n - 1):
        u.append(r * u[-1] * (1 - u[-1]))
    return u

# Paramètres
n = 50  # Nombre de termes
u0 = 0.2  # Condition initiale
r_values = [2.5, 3.2, 3.5, 3.9]  # Différentes valeurs du paramètre r

# Tracé des suites pour différentes valeurs de r
plt.figure(figsize=(10, 6))

mark = ["o", "<", "x", "*"]
m=0
for r in r_values:
    suite_log = suite_logistique(u0, r, n)
    plt.plot(range(n), suite_log, marker=mark[m], linestyle="-", label=f"r = {r}")
    m=m+1

plt.title("Évolution de la suite logistique pour différentes valeurs de r")
plt.xlabel("n")
plt.ylabel("u(n)")
plt.legend()
plt.grid()
plt.show()

Visualisation Graphique de la suite logistique

Interprétation :

• Pour r<3, la population se stabilise.
• Pour r>3.57, la suite devient chaotique.

Exercice : Modélisation d’une Population de poissons avec la Suite Logistique

Par exemple, une population de poissons évolue dans un étang avec une capacité maximale de 1000 individus. On suppose que leur croissance suit la suite logistique définie par :

P_n+1=r⋅P_n⋅(1−P_n / K)

où :

• Pn : est la population au mois n,
• r est le taux de reproduction (facteur de croissance),
• K est la capacité maximale de l’étang (ici, 1000 poissons),
• P₀=50 (population initiale).

Questions :

1. Complétez le tableau suivant pour r=2.5r=2.5 et nn allant de 0 à 10.

2. Tracez le graphique de P_n en fonction de n.
3. Que remarquez-vous sur l’évolution de la population ? Se stabilise-t-elle, oscille-t-elle, ou devient-elle chaotique ?
4. Reprenez l’exercice avec r=3.5 et comparez les comportements obtenus.

💡 Indice : Implémentez cette suite en Python pour automatiser les calculs et visualiser le graphique !

Solution de l’exercice de population de poissons

Analyse des résultats :

• Pour r=2.5 : La population tend à se stabiliser à une valeur proche de K.
• Pour r=3.5 : On peut observer des oscillations ou un comportement chaotique selon les itérations.

Explorer les Suites Mathématiques en Python pour Modéliser le Monde Réel

En résumé, les suites mathématiques, qu’elles soient arithmétiques, géométriques, ou récurrentes comme la suite de Fibonacci et la suite logistique, offrent des outils puissants pour modéliser divers phénomènes naturels et systèmes dynamiques. La programmation de suites mathématiques en Python ouvre des possibilités infinies pour explorer ces concepts de manière interactive et visuelle. En comprenant et en implémentant ces suites, vous pouvez non seulement résoudre des problèmes pratiques, mais aussi découvrir des comportements complexes et souvent inattendus, comme le chaos dans la suite logistique.

Pour aller plus loin, je vous encourage à expérimenter avec d’autres types de suites et à explorer leurs applications dans différents domaines. La pratique et l’expérimentation sont essentielles pour maîtriser ces concepts et découvrir de nouvelles applications passionnantes.