Introduction :
Ce TP a pour objectif de travailler sur deux aspects importants du calcul scientifique : la
manipulation de matrices en Python et la résolution numérique d’une équation différentielle
ordinaire simple. Dans la première partie, nous aborderons la création et le produit de deux
matrices A et B de dimensions respectives (M, L) et (L, M) , avec M et L définis par
l’utilisateur. Cette étape permet de se familiariser avec les opérations algébriques de base en
Python, notamment via la bibliothèque NumPy, largement utilisée pour le calcul matriciel
efficace.
La seconde partie du TP porte sur l’étude de l’équation différentielle
\frac{du}{dx} + u = 0, \quad x \in [0, 2]
avec la condition initiale u(0) = 1 . Il s’agit d’une EDO linéaire du premier ordre, dont la
solution analytique est connue, mais que l’on souhaite aborder d’un point de vue numérique.
L’objectif est de comprendre comment discrétiser le problème, d’estimer la solution sur
l’intervalle donné, et d’en analyser le comportement, notamment en vérifiant la condition
limite \text{Im}(x, x) = 0.5 pour x = -5 , qui semble faire référence à un prolongement ou à
une condition particulière liée au problème.
Ce travail permet ainsi de lier compétences en programmation et modélisation mathématique,
en vue de préparer des traitements numériques plus complexes.
Programe1:
import numpy as np
# I.1) Remplir les matrices A et B
def create_matrices(N, L, M):
"""
Crée deux matrices A(N, L) et B(L, M) avec des valeurs aléatoires entre 0 et 10.
"""
A = [Link](0, 10, size=(N, L))
B = [Link](0, 10, size=(L, M))
return A, B
# I.2) Calculer le produit A * B
def matrix_product(A, B):
"""
Calcule le produit matriciel A * B en utilisant numpy.
"""
# Vérification des dimensions
if [Link][1] != [Link][0]:
raise ValueError(f"Dimensions incompatibles : [Link]={[Link]},
[Link]={[Link]}")
# Produit matriciel
C = [Link](A, B)
return C
# Exemple d'utilisation
if __name__ == "__main__":
N, L, M = 3, 4, 2 # Exemple de dimensions
A, B = create_matrices(N, L, M)
print("Matrice A :")
print(A)
print("\nMatrice B :")
print(B)
C = matrix_product(A, B)
print("\nProduit A * B :")
print(C)
Exécution :
%runfile C:/Users/X280/[Link] --wdir
Matrice A :
[[4 7 1 4]
[0 1 6 2]
[7 9 8 2]]
Matrice B :
[[6 2]
[5 7]
[5 4]
[9 9]]
Produit A * B :
[[100 97]
[ 53 49]
[145 127]]
Programe2 :
import numpy as np
import [Link] as plt
from [Link] import solve_ivp
# II.1) Définition de l'EDO
def ode_system(x, u):
"""
Système : du/dx = -u
"""
return -u
# Condition initiale
u0 = [1.0] # u(x=0) = 1
x_span = (0, 2) # Intervalle [0, 2]
x_eval = [Link](0, 2, 100) # Points d'évaluation
# II.2) Résolution numérique
sol = solve_ivp(ode_system, x_span, u0, t_eval=x_eval, method='RK45')
# Extraction des résultats
x_vals = sol.t
u_vals = sol.y[0]
# II.3) Solution analytique pour comparaison
u_exact = [Link](-x_vals)
# II.4) Tracé
[Link](figsize=(10, 6))
[Link](x_vals, u_vals, 'b-', linewidth=2, label='Solution numérique')
[Link](x_vals, u_exact, 'r--', linewidth=1.5, label='Solution exacte $e^{-x}$')
[Link]('$x$', fontsize=12)
[Link]('$u(x)$', fontsize=12)
[Link]('Résolution de $\\frac{du}{dx} + u = 0$, $u(0)=1$', fontsize=14)
[Link](True, alpha=0.3)
[Link]()
[Link]()
# II.5) Affichage des valeurs en quelques points ----------
print("Vérification en quelques points :")
print("x\tu_numérique\tu_exact\t\tErreur")
for i in range(0, len(x_vals), len(x_vals)//5):
print(f"{x_vals[i]:.2f}\t{u_vals[i]:.6f}\t\t{u_exact[i]:.6f}\t\t{abs(u_vals[i]-
u_exact[i]):.2e}")
Exécution:
%runfile C:/Users/X280/[Link] --wdir
Vérification en quelques points :
x u_numérique u_exact Erreur
0.00 1.000000 1.000000 0.00e+00
0.40 0.667210 0.667617 4.07e-04
0.81 0.445681 0.445713 3.19e-05
1.21 0.297716 0.297565 1.51e-04
1.62 0.198746 0.198660 8.62e-05
Conclusion :
À travers ce TP, nous avons réalisé deux tâches complémentaires en calcul scientifique.
Premièrement, nous avons implémenté en Python la génération de matrices A et B de tailles
variables (M, L) et (L, M) , puis calculé leur produit matriciel. Cela a permis de mettre en
pratique des outils essentiels pour le calcul haute performance, avec une attention portée à
l’efficacité et à la gestion des dimensions.
Deuxièmement, nous nous sommes intéressés à la résolution numérique de l’équation
différentielle
\frac{du}{dx} + u = 0
sur l’intervalle [0, 2] avec u(0) = 1 . La solution théorique exponentielle décroissante a pu
être comparée à une approche numérique (par exemple la méthode d’Euler ou un solveur
dédié), confirmant la validité de la modélisation. La condition \text{Im}(x, x) = 0.5 pour x =
-5 a soulevé des questions d’interprétation — peut-être liée à une extension complexe ou à
une condition aux limites additionnelle — et montre l’importance de bien préciser le cadre
physique ou mathématique du problème.
En somme, ce TP offre une initiation concrète à deux outils fondamentaux du scientifique :
l’algèbre linéaire numérique et l’intégration d’équations différentielles, en soulignant l’utilité
de Python comme environnement unifié pour la simulation et l’analyse.