solutions
April 28, 2025
1 Méthode de Gauss (sans permutation de lignes)
[4]: # ----------------------------------------------------------------------------
# Résolution d'un système linéaire par la méthode d'élimination de Gauss
# ----------------------------------------------------------------------------
# Matrice des coefficients du système (n x n)
A = [[1, 2, 1], [2, 2, 3], [-1, -3, 0]]
# Vecteur du second membre
b = [0, 3, 2]
# Dimension du système (nombre d'équations)
n = len(b)
# ----------------------------------------------------------------------------
# Phase d'élimination (transformation en matrice triangulaire supérieure)
# ----------------------------------------------------------------------------
for i in range(n-1): # i = indice de la ligne pivot
# Vérification que le pivot n'est pas nul
pivot = A[i][i]
if pivot == 0:
raise ValueError(f"Pivot nul à la position ({i},{i})")
# Normalisation de la ligne du pivot
# On divise toute la ligne par A[i][i] pour avoir 1 sur la diagonale
for j in range(i, n):
A[i][j] /= pivot
b[i] /= pivot
# Élimination des termes sous le pivot
for k in range(i+1, n): # k = lignes à modifier
# Calcul du facteur pour éliminer A[k][i]
factor = A[k][i]
# Soustraction de la ligne pivot multipliée par le facteur
for j in range(i, n): # j = colonnes à modifier
A[k][j] -= factor * A[i][j]
1
b[k] -= factor * b[i]
# ----------------------------------------------------------------------------
# Phase de remontée (résolution du système triangulaire)
# ----------------------------------------------------------------------------
# Initialisation du vecteur solution
x = [0 for _ in range(n)]
# Parcours des équations de la dernière à la première
for i in range(n-1, -1, -1):
# On part de la valeur du second membre
x[i] = b[i]
# Soustraction des termes déjà calculés
for j in range(i+1, n):
x[i] -= A[i][j] * x[j]
# Division par le coefficient diagonal
x[i] /= A[i][i]
# ----------------------------------------------------------------------------
# Affichage des résultats
# ----------------------------------------------------------------------------
print("Matrice après élimination:")
for row in A:
print(row)
print("\nSecond membre après élimination:", b)
print("\nSolution du système:", x)
Matrice après élimination:
[1.0, 2.0, 1.0]
[-0.0, 1.0, -0.5]
[0.0, 0.0, 0.5]
Second membre après élimination: [0.0, -1.5, 0.5]
Solution du système: [1.0, -1.0, 1.0]
2 Méthode de Jacobi
[6]: # ----------------------------------------------------------------------------
# Résolution d'un système linéaire par la méthode itérative de Jacobi
# ----------------------------------------------------------------------------
2
# Importation de la bibliothèque mathématique pour la racine carrée
import math
# ----------------------------------------------------------------------------
# Saisie des paramètres du système
# ----------------------------------------------------------------------------
print("----------------------------------------------------")
print("Méthode de Jacobi pour les systèmes linéaires")
print("----------------------------------------------------")
# Dimension du système
n = int(input("Entrez la dimension du système n : "))
# Tolérance pour le critère de convergence
tol = 1e-6
# Nombre maximal d'itérations
max_iterations = int(input("Entrez le nombre maximal d'itérations : "))
# ----------------------------------------------------------------------------
# Saisie de la matrice A
# ----------------------------------------------------------------------------
print("\nSaisie de la matrice A (coefficients du système):")
A = []
for i in range(n):
ligne = []
for j in range(n):
element = float(input(f"Entrez A[{i+1}][{j+1}] : "))
[Link](element)
[Link](ligne)
# ----------------------------------------------------------------------------
# Saisie du vecteur b (second membre)
# ----------------------------------------------------------------------------
print("\nSaisie du vecteur b (second membre):")
b = []
for i in range(n):
element = float(input(f"Entrez b[{i+1}] : "))
[Link](element)
# ----------------------------------------------------------------------------
# Initialisation du vecteur solution x
# ----------------------------------------------------------------------------
print("\nInitialisation du vecteur solution x:")
x = []
for i in range(n):
element = float(input(f"Entrez la valeur initiale x[{i+1}] : "))
3
[Link](element)
# Création du vecteur pour la nouvelle solution
x_new = []
for i in range(n):
x_new.append(0.0)
# ----------------------------------------------------------------------------
# Affichage de l'en-tête du tableau de résultats
# ----------------------------------------------------------------------------
print("\nItération", end="")
for i in range(n):
print(f"\tx{i+1}", end="\t")
print()
# ----------------------------------------------------------------------------
# Méthode itérative de Jacobi
# ----------------------------------------------------------------------------
for k in range(max_iterations):
# Calcul des nouvelles valeurs
for i in range(n):
somme = b[i]
for j in range(n):
if j != i:
somme = somme - A[i][j] * x[j]
x_new[i] = somme / A[i][i]
# Calcul de la norme de la différence
norm_carre = 0.0
for i in range(n):
difference = x_new[i] - x[i]
norm_carre += difference * difference
norm = [Link](norm_carre)
# Affichage de l'itération courante
print(k+1, end="\t")
for val in x_new:
print(f"\t{val:.6f}", end="")
print()
# Copie de x_new dans x
for i in range(n):
x[i] = x_new[i]
# Test de convergence
if norm < tol:
print(f"\nConvergence atteinte après {k+1} itérations.")
4
break
# Message si convergence non atteinte
if norm >= tol:
print(f"\nNombre maximal d'itérations ({max_iterations}) atteint sans␣
↪convergence.")
# ----------------------------------------------------------------------------
# Affichage de la solution finale
# ----------------------------------------------------------------------------
print("\nSolution finale:")
for i in range(n):
print(f"x[{i+1}] = {x[i]:.8f}")
----------------------------------------------------
Méthode de Jacobi pour les systèmes linéaires
----------------------------------------------------
Entrez la dimension du système n : 3
Entrez le nombre maximal d'itérations : 100
Saisie de la matrice A (coefficients du système):
Entrez A[1][1] : 3
Entrez A[1][2] : 1
Entrez A[1][3] : -1
Entrez A[2][1] : 1
Entrez A[2][2] : 5
Entrez A[2][3] : 2
Entrez A[3][1] : 2
Entrez A[3][2] : -1
Entrez A[3][3] : -6
Saisie du vecteur b (second membre):
Entrez b[1] : 2
Entrez b[2] : 17
Entrez b[3] : -18
Initialisation du vecteur solution x:
Entrez la valeur initiale x[1] : 0
Entrez la valeur initiale x[2] : 0
Entrez la valeur initiale x[3] : 0
Itération x1 x2 x3
1 0.666667 3.400000 3.000000
2 0.533333 2.066667 2.655556
5
3 0.862963 2.231111 2.833333
4 0.867407 2.094074 2.915802
5 0.940576 2.060198 2.940123
6 0.959975 2.035835 2.970159
7 0.978108 2.019941 2.980686
8 0.986915 2.012104 2.989379
9 0.992425 2.006865 2.993621
10 0.995585 2.004067 2.996331
11 0.997421 2.002351 2.997851
12 0.998500 2.001375 2.998749
13 0.999124 2.000801 2.999271
14 0.999490 2.000467 2.999575
15 0.999703 2.000272 2.999752
16 0.999827 2.000159 2.999856
17 0.999899 2.000092 2.999916
18 0.999941 2.000054 2.999951
19 0.999966 2.000031 2.999971
20 0.999980 2.000018 2.999983
21 0.999988 2.000011 2.999990
22 0.999993 2.000006 2.999994
23 0.999996 2.000004 2.999997
24 0.999998 2.000002 2.999998
25 0.999999 2.000001 2.999999
26 0.999999 2.000001 2.999999
Convergence atteinte après 26 itérations.
Solution finale:
x[1] = 0.99999922
x[2] = 2.00000072
x[3] = 2.99999935
3 Méthode de Vandermonde
[2]: # Points de données pour l'interpolation
x = [0, 1, 2] # Abscisses des points
y = [0, 2, 4] # Ordonnées des points
n = len(x) # Nombre de points
# ----------------------------------------------------------------------------
# Construction de la matrice de Vandermonde
# ----------------------------------------------------------------------------
V = []
for i in range(n):
ligne = []
6
for j in range(n):
# Chaque ligne i correspond à [x_i^0, x_i^1, x_i^2, ..., x_i^{n-1}]
[Link](x[i] ** j)
[Link](ligne)
print("Matrice de Vandermonde:")
for ligne in V:
print(ligne)
# ----------------------------------------------------------------------------
# Phase d'élimination (transformation en matrice triangulaire supérieure)
# ----------------------------------------------------------------------------
for i in range(n-1): # i = indice de la ligne pivot
# Vérification que le pivot n'est pas nul
pivot = V[i][i]
if pivot == 0:
raise ValueError(f"Pivot nul à la position ({i},{i})")
# Normalisation de la ligne du pivot
# On divise toute la ligne par V[i][i] pour avoir 1 sur la diagonale
for j in range(i, n):
V[i][j] /= pivot
y[i] /= pivot
# Élimination des termes sous le pivot
for k in range(i+1, n): # k = lignes à modifier
# Calcul du facteur pour éliminer V[k][i]
factor = V[k][i]
# Soustraction de la ligne pivot multipliée par le facteur
for j in range(i, n): # j = colonnes à modifier
V[k][j] -= factor * V[i][j]
y[k] -= factor * y[i]
# ----------------------------------------------------------------------------
# Phase de remontée (résolution du système triangulaire)
# ----------------------------------------------------------------------------
# Initialisation du vecteur solution (coefficients du polynôme)
coeffs = [0 for _ in range(n)]
# Parcours des équations de la dernière à la première
for i in range(n-1, -1, -1):
# On part de la valeur du second membre
coeffs[i] = y[i]
# Soustraction des termes déjà calculés
for j in range(i+1, n):
7
coeffs[i] -= V[i][j] * coeffs[j]
# Division par le coefficient diagonal
coeffs[i] /= V[i][i]
print("\nCoefficients du polynôme d'interpolation (ordre croissant):")
print(coeffs)
Matrice de Vandermonde:
[1, 0, 0]
[1, 1, 1]
[1, 2, 4]
Coefficients du polynôme d'interpolation (ordre croissant):
[0.0, 2.0, 0.0]
4 Méthode de Lagrange
[3]: def lagrange_interpolation(points_x, points_y, x_to_interpolate):
"""
Interpolation polynomiale par la méthode de Lagrange
Paramètres:
points_x (list): Liste des abscisses des points connus
points_y (list): Liste des ordonnées des points connus
x_to_interpolate (float): Point où évaluer le polynôme d'interpolation
Retourne:
float: Valeur interpolée du polynôme au point x_to_interpolate
"""
n = len(points_x) # Nombre de points d'interpolation
result = 0 # Initialisation du résultat
# Calcul de la somme des polynômes de Lagrange pondérés
for i in range(n):
# Initialisation du polynôme de Lagrange L_i(x)
lagrange_poly = 1
# Construction du polynôme de Lagrange L_i(x)
for j in range(n):
if j == i:
continue # On saute le cas j=i pour éviter une division par␣
zéro
↪
# Multiplication des termes (x-x_j)/(x_i-x_j)
8
lagrange_poly *= (x_to_interpolate - points_x[j]) / (points_x[i] -␣
points_x[j])
↪
# Ajout du terme y_i*L_i(x) à la somme totale
result += points_y[i] * lagrange_poly
return result
# Points connus pour l'interpolation
known_points_x = [0, 1, 2] # Abscisses des points connus
known_points_y = [0, 2, 4] # Ordonnées des points connus
# Évaluation du polynôme d'interpolation en différents points
print("Interpolation en x = 3 :", lagrange_interpolation(known_points_x,␣
↪known_points_y, 3))
print("Interpolation en x = 8 :", lagrange_interpolation(known_points_x,␣
↪known_points_y, 8))
Interpolation en x = 3 : 6.0
Interpolation en x = 8 : 16.0
5 Informations sur le cours
Titre du cours : Analyse Numérique et Programmation (Python)
Enseignant : Mohamed SHAIMI
Etablissement : Faculté des Sciences Aïn Chock, Université Hassan II de Casablanca, Casablanca,
Maroc
Date de création : 28 avril 2025
