- À propos de la résolution des systèmes d'équations avec SymPy
- Résoudre un système linéaire avec solve()
- Créer un système avec Eq()
- Résoudre un système de trois équations
- Résoudre un système avec linsolve()
- Étudier les systèmes sans solution ou avec une infinité de solutions
- Résoudre un système non linéaire avec nonlinsolve()
- Résoudre un système linéaire avec les matrices
- Vérifier les solutions d'un système
- À retenir !
1. À propos de la résolution des systèmes d'équations avec SymPy
Un système d'équations est un ensemble de plusieurs équations faisant intervenir plusieurs inconnues. Résoudre un système consiste à rechercher les valeurs des inconnues qui vérifient simultanément toutes les équations.
La bibliothèque SymPy fournit plusieurs outils pour effectuer cette résolution symboliquement. Parmi les plus importants figurent solve(), linsolve() pour les systèmes linéaires et nonlinsolve() pour les systèmes non linéaires.
Le programme suivant résout un premier système constitué des équations x + y = 5 et x - y = 1.
1 2 3 4 5 6 7 | from sympy import symbols, solve x, y = symbols("x y") equation1 = x + y - 5 equation2 = x - y - 1 solution = solve([equation1, equation2], [x, y]) print(solution) |
Sortie :
1 | {x: 3, y: 2} |
La solution est x = 3 et y = 2. Ces deux valeurs vérifient simultanément les deux équations du système.
2. Résoudre un système linéaire avec solve()
La fonction solve() peut recevoir une liste d'équations et une liste d'inconnues. La syntaxe courante est solve([equation1, equation2], [x, y]). Lorsque les équations sont fournies sous forme d'expressions, SymPy considère que chacune d'elles est égale à zéro.
Le programme suivant résout le système 2x + y = 7 et x - y = 2.
1 2 3 4 5 6 7 | from sympy import symbols, solve x, y = symbols("x y") equation1 = 2*x + y - 7 equation2 = x - y - 2 solution = solve([equation1, equation2], [x, y]) print(solution) |
Sortie :
1 | {x: 3, y: 1} |
Le résultat est retourné sous forme d'un dictionnaire associant chaque inconnue à sa valeur.
Lorsque nous souhaitons imposer explicitement une sortie sous forme de liste de dictionnaires, nous pouvons utiliser l'option dict=True.
1 2 3 4 5 6 7 | from sympy import symbols, solve x, y = symbols("x y") equation1 = 3*x + 2*y - 12 equation2 = x - y - 1 solution = solve([equation1, equation2], [x, y], dict=True) print(solution) |
Sortie :
1 | [{x: 14/5, y: 9/5}] |
Cette représentation est particulièrement pratique lorsqu'un système possède plusieurs solutions, car chaque solution peut être représentée par un dictionnaire distinct.
3. Créer un système avec Eq()
La classe Eq permet d'écrire les équations sous une forme proche de la notation mathématique habituelle. Au lieu de transformer chaque équation en une expression égale à zéro, nous pouvons écrire directement ses membres gauche et droit.
Le programme suivant utilise Eq() pour représenter le système 2x + 3y = 12 et x + y = 5.
1 2 3 4 5 6 7 | from sympy import symbols, Eq, solve x, y = symbols("x y") equation1 = Eq(2*x + 3*y, 12) equation2 = Eq(x + y, 5) solution = solve([equation1, equation2], [x, y]) print(solution) |
Sortie :
1 | {x: 3, y: 2} |
La classe Eq n'est pas obligatoire pour utiliser solve(), mais elle améliore souvent la lisibilité du programme en faisant apparaître explicitement les deux membres de chaque équation.
Nous pouvons également afficher les équations avant de résoudre le système.
1 2 3 4 5 6 7 8 | from sympy import symbols, Eq x, y = symbols("x y") equation1 = Eq(3*x - y, 7) equation2 = Eq(x + 2*y, 7) print(equation1) print(equation2) |
Sortie :
1 2 | Eq(3*x - y, 7) Eq(x + 2*y, 7) |
Les objets Eq peuvent ensuite être transmis directement aux fonctions de résolution de SymPy.
4. Résoudre un système de trois équations
SymPy peut résoudre des systèmes comportant plus de deux inconnues. Il suffit de définir tous les symboles nécessaires et de transmettre l'ensemble des équations à solve().
Le programme suivant résout un système de trois équations à trois inconnues x, y et z.
1 2 3 4 5 6 7 8 | from sympy import symbols, Eq, solve x, y, z = symbols("x y z") equation1 = Eq(x + y + z, 6) equation2 = Eq(x - y + z, 4) equation3 = Eq(2*x + y - z, 1) solution = solve([equation1, equation2, equation3], [x, y, z]) print(solution) |
Sortie :
1 | {x: 2, y: 1, z: 3} |
La solution du système est donc x = 2, y = 1 et z = 3.
Le même principe peut être utilisé avec un nombre plus important d'équations et d'inconnues, même si pour les grands systèmes linéaires, les outils matriciels ou linsolve() sont souvent mieux adaptés.
5. Résoudre un système avec linsolve()
La fonction linsolve() est spécialement conçue pour résoudre des systèmes d'équations linéaires. Elle retourne les solutions sous la forme d'un ensemble de tuples, ce qui donne une représentation cohérente des systèmes ayant une solution unique ou une famille de solutions.
Le programme suivant résout un système linéaire de deux équations avec linsolve().
1 2 3 4 5 6 7 | from sympy import symbols, linsolve x, y = symbols("x y") equation1 = 2*x + y - 7 equation2 = x - y - 2 solution = linsolve([equation1, equation2], (x, y)) print(solution) |
Sortie :
1 | {(3, 1)} |
Le tuple (3, 1) correspond respectivement aux variables (x, y). Nous obtenons donc x = 3 et y = 1.
La fonction linsolve() peut également recevoir directement une représentation matricielle du système sous la forme (A, b), où A est la matrice des coefficients et b le vecteur des seconds membres.
1 2 3 4 5 6 7 | from sympy import symbols, Matrix, linsolve x, y = symbols("x y") A = Matrix([[2, 1], [1, -1]]) b = Matrix([7, 2]) solution = linsolve((A, b), (x, y)) print(solution) |
Sortie :
1 | {(3, 1)} |
Cette écriture est particulièrement adaptée lorsque le système provient naturellement d'un calcul matriciel.
6. Étudier les systèmes sans solution ou avec une infinité de solutions
Un système linéaire ne possède pas nécessairement une solution unique. Il peut être incompatible et ne posséder aucune solution, ou être indéterminé et posséder une infinité de solutions.
Le programme suivant utilise linsolve() sur deux équations incompatibles : x + y = 2 et x + y = 5.
1 2 3 4 5 6 7 | from sympy import symbols, linsolve x, y = symbols("x y") equation1 = x + y - 2 equation2 = x + y - 5 solution = linsolve([equation1, equation2], (x, y)) print(solution) |
Sortie :
1 | EmptySet |
Le résultat EmptySet indique que l'ensemble des solutions est vide. Les deux équations représentent ici deux droites parallèles distinctes.
Le programme suivant utilise au contraire deux équations dépendantes. La deuxième est simplement le double de la première, ce qui conduit à une infinité de solutions.
1 2 3 4 5 6 7 | from sympy import symbols, linsolve x, y = symbols("x y") equation1 = x + y - 2 equation2 = 2*x + 2*y - 4 solution = linsolve([equation1, equation2], (x, y)) print(solution) |
Sortie :
1 | {(2 - y, y)} |
Cette écriture signifie que y est libre et que x = 2 - y. Chaque valeur de y fournit donc une solution du système.
7. Résoudre un système non linéaire avec nonlinsolve()
Lorsque le système contient des termes tels que x², xy ou d'autres expressions non linéaires, nous pouvons utiliser la fonction nonlinsolve(). Elle est conçue pour résoudre des systèmes non linéaires et retourne un ensemble de tuples.
Le programme suivant cherche les points d'intersection de la parabole y = x² et de la droite horizontale y = 4.
1 2 3 4 5 6 7 | from sympy import symbols, nonlinsolve x, y = symbols("x y") equation1 = y - x**2 equation2 = y - 4 solutions = nonlinsolve([equation1, equation2], [x, y]) print(solutions) |
Sortie :
1 | {(-2, 4), (2, 4)} |
Le système possède deux solutions : (x, y) = (-2, 4) et (x, y) = (2, 4).
Le programme suivant résout le système x² + y² = 5 et x - y = 1.
1 2 3 4 5 6 7 | from sympy import symbols, nonlinsolve x, y = symbols("x y") equation1 = x**2 + y**2 - 5 equation2 = x - y - 1 solutions = nonlinsolve([equation1, equation2], [x, y]) print(solutions) |
Sortie :
1 | {(-1, -2), (2, 1)} |
Les deux couples (-1, -2) et (2, 1) vérifient simultanément les deux équations du système.
8. Résoudre un système linéaire avec les matrices
Un système linéaire peut être écrit sous la forme matricielle AX = B. SymPy fournit la classe Matrix ainsi que plusieurs méthodes permettant de résoudre directement ce type de problème.
Pour un système carré admettant une solution unique, la méthode LUsolve() permet de résoudre efficacement l'équation matricielle sans calculer explicitement l'inverse de la matrice.
Le programme suivant résout le système 2x + y = 7 et x - y = 2 avec des matrices.
1 2 3 4 5 6 | from sympy import Matrix A = Matrix([[2, 1], [1, -1]]) B = Matrix([7, 2]) X = A.LUsolve(B) print(X) |
Sortie :
1 | Matrix([[3], [1]]) |
Le premier élément du vecteur solution correspond à x = 3 et le second à y = 1.
Pour mieux visualiser les différentes parties du système, nous pouvons afficher séparément la matrice des coefficients et le vecteur des seconds membres.
1 2 3 4 5 6 7 8 9 10 11 | from sympy import Matrix A = Matrix([[1, 1, 1], [1, -1, 1], [2, 1, -1]]) B = Matrix([6, 4, 1]) print("Matrice A :") print(A) print("Vecteur B :") print(B) print("Solution :") print(A.LUsolve(B)) |
Sortie :
1 2 3 4 5 6 | Matrice A : Matrix([[1, 1, 1], [1, -1, 1], [2, 1, -1]]) Vecteur B : Matrix([[6], [4], [1]]) Solution : Matrix([[2], [1], [3]]) |
Le vecteur obtenu correspond à la solution x = 2, y = 1 et z = 3.
9. Vérifier les solutions d'un système
Après avoir résolu un système, il est utile de vérifier les solutions obtenues. La méthode subs() permet de remplacer simultanément les inconnues par leurs valeurs dans chaque équation.
Le programme suivant résout un système puis remplace les inconnues par les valeurs obtenues dans les expressions originales.
1 2 3 4 5 6 7 8 9 10 | from sympy import symbols, solve x, y = symbols("x y") equation1 = 2*x + y - 7 equation2 = x - y - 2 solution = solve([equation1, equation2], [x, y]) print("Solution :", solution) print("Équation 1 :", equation1.subs(solution)) print("Équation 2 :", equation2.subs(solution)) |
Sortie :
1 2 3 | Solution : {x: 3, y: 1} Équation 1 : 0 Équation 2 : 0 |
Les deux expressions donnent 0. La solution vérifie donc simultanément les deux équations.
Lorsque le système est représenté avec des objets Eq, nous pouvons également effectuer les substitutions directement dans les équations.
1 2 3 4 5 6 7 8 9 | from sympy import symbols, Eq, solve x, y = symbols("x y") equation1 = Eq(x + y, 5) equation2 = Eq(x - y, 1) solution = solve([equation1, equation2], [x, y]) print(equation1.subs(solution)) print(equation2.subs(solution)) |
Sortie :
1 2 | True True |
Les deux valeurs True confirment que la solution x = 3 et y = 2 satisfait les deux équations.
10. À retenir !
La bibliothèque SymPy propose plusieurs méthodes complémentaires pour la résolution des systèmes d'équations. Le choix de la fonction dépend principalement de la nature du système et de la représentation souhaitée des solutions.
- solve() permet de résoudre de nombreux systèmes linéaires et non linéaires avec une interface générale.
- Eq() permet de représenter explicitement les deux membres d'une équation.
- linsolve() est spécialement conçue pour les systèmes linéaires.
- linsolve() retourne les solutions sous la forme d'un ensemble de tuples.
- EmptySet indique qu'un système ne possède aucune solution.
- Un système linéaire indéterminé peut être représenté à l'aide de variables ou de paramètres libres.
- nonlinsolve() est destinée aux systèmes non linéaires.
- Matrix permet de représenter un système linéaire sous la forme AX = B.
- LUsolve() permet de résoudre certains systèmes matriciels sans calculer explicitement l'inverse de la matrice.
- subs() permet de vérifier les solutions en les remplaçant dans les équations originales.
Le programme suivant résume l'utilisation de solve(), linsolve() et nonlinsolve() sur trois systèmes différents.
1 2 3 4 5 6 7 8 9 10 11 | from sympy import symbols, solve, linsolve, nonlinsolve x, y = symbols("x y") systeme1 = solve([x + y - 5, x - y - 1], [x, y]) systeme2 = linsolve([2*x + y - 7, x - y - 2], (x, y)) systeme3 = nonlinsolve([y - x**2, y - 4], [x, y]) print("solve() :", systeme1) print("linsolve() :", systeme2) print("nonlinsolve() :", systeme3) |
Sortie :
1 2 3 | solve() : {x: 3, y: 2} linsolve() : {(3, 1)} nonlinsolve() : {(-2, 4), (2, 4)} |
Auteur : Younes Derfoufi
Lieu de travail : CRMEF OUJDA
Site Web : www.tresfacile.net
Chaine YouTube : https://www.youtube.com/user/InformatiquesFacile
Me contacter : https://www.tresfacile.net/me-contacter/
