- À propos de linsolve() en SymPy
- Résoudre un système linéaire simple avec linsolve()
- Résoudre un système écrit avec Eq()
- Résoudre un système de trois équations
- Résoudre un système sous forme matricielle
- Résoudre un système avec une infinité de solutions
- Détecter un système sans solution
- Résoudre un système avec des paramètres
- Exploiter et vérifier les solutions retournées par linsolve()
- À retenir !
1. À propos de linsolve() en SymPy
La bibliothèque SymPy fournit la fonction linsolve() pour résoudre symboliquement des systèmes d'équations linéaires. Elle est spécialement conçue pour les systèmes dans lesquels les inconnues apparaissent uniquement au premier degré et ne sont pas multipliées entre elles.
Un système comme 2x + y = 7 et x - y = 2 est linéaire. En revanche, une équation contenant x² ou xy rend généralement le système non linéaire.
Le programme suivant utilise linsolve() pour résoudre un premier système à deux inconnues.
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)} |
La fonction retourne un ensemble de tuples. Le tuple (3, 1) correspond à l'ordre des inconnues (x, y). Nous avons donc x = 3 et y = 1.
2. Résoudre un système linéaire simple avec linsolve()
Pour utiliser linsolve(), nous pouvons placer les expressions correspondant aux différentes équations dans une liste. Chaque expression est considérée comme étant égale à zéro.
Par exemple, l'équation 3x + 2y = 12 peut être écrite sous la forme 3*x + 2*y - 12. Le programme suivant résout cette équation avec x - y = 1.
1 2 3 4 5 6 7 | from sympy import symbols, linsolve x, y = symbols("x y") equation1 = 3*x + 2*y - 12 equation2 = x - y - 1 solution = linsolve([equation1, equation2], (x, y)) print(solution) |
Sortie :
1 | {(14/5, 9/5)} |
La solution exacte est donc x = 14/5 et y = 9/5. SymPy conserve les valeurs sous forme rationnelle exacte au lieu de les convertir automatiquement en nombres décimaux.
L'ordre dans lequel nous indiquons les variables est important, car il détermine l'ordre des valeurs dans le tuple retourné.
1 2 3 4 5 6 7 | from sympy import symbols, linsolve x, y = symbols("x y") equations = [2*x + y - 7, x - y - 2] print(linsolve(equations, (x, y))) print(linsolve(equations, (y, x))) |
Sortie :
1 2 | {(3, 1)} {(1, 3)} |
Dans le premier résultat, les coordonnées correspondent à (x, y). Dans le second, elles correspondent à (y, x).
3. Résoudre un système écrit avec Eq()
Les équations peuvent également être représentées avec la classe Eq. Cette écriture est souvent plus lisible car elle permet de conserver explicitement le membre gauche et le membre droit de chaque équation.
Le programme suivant représente le système x + y = 5 et x - y = 1 avec Eq(), puis le résout avec linsolve().
1 2 3 4 5 6 7 | from sympy import symbols, Eq, linsolve x, y = symbols("x y") equation1 = Eq(x + y, 5) equation2 = Eq(x - y, 1) solution = linsolve([equation1, equation2], (x, y)) print(solution) |
Sortie :
1 | {(3, 2)} |
La solution est x = 3 et y = 2. L'utilisation de Eq() ne change pas le résultat, mais rend la représentation du système plus proche de son écriture mathématique.
Nous pouvons naturellement mélanger des coefficients entiers et rationnels dans les équations.
1 2 3 4 5 6 7 | from sympy import symbols, Eq, linsolve, Rational x, y = symbols("x y") equation1 = Eq(x + y, 3) equation2 = Eq(Rational(1, 2)*x - y, 0) solution = linsolve([equation1, equation2], (x, y)) print(solution) |
Sortie :
1 | {(2, 1)} |
La classe Rational permet ici de représenter exactement le coefficient 1/2.
4. Résoudre un système de trois équations
La fonction linsolve() peut résoudre des systèmes comportant un nombre quelconque d'inconnues, sous réserve que les équations restent linéaires. Pour trois inconnues, le résultat est représenté par un tuple de trois composantes.
Le programme suivant résout un système en x, y et z.
1 2 3 4 5 6 7 8 | from sympy import symbols, linsolve x, y, z = symbols("x y z") equation1 = x + y + z - 6 equation2 = x - y + z - 4 equation3 = 2*x + y - z - 1 solution = linsolve([equation1, equation2, equation3], (x, y, z)) print(solution) |
Sortie :
1 | {(2, 1, 3)} |
Le tuple suit l'ordre (x, y, z). La solution du système est donc x = 2, y = 1 et z = 3.
La méthode reste identique pour un système contenant davantage d'inconnues : nous ajoutons simplement les équations et les symboles correspondants.
5. Résoudre un système sous forme matricielle
Un système linéaire peut être écrit sous la forme AX = B, où A représente la matrice des coefficients, X le vecteur des inconnues et B le vecteur des seconds membres. La fonction linsolve() accepte directement le couple (A, B).
Le programme suivant représente le système 2x + y = 7 et x - y = 2 sous forme matricielle.
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)} |
La matrice A contient les coefficients des inconnues tandis que le vecteur B contient les seconds membres des équations.
La même méthode peut être appliquée à un système de trois équations à trois inconnues.
1 2 3 4 5 6 7 | from sympy import symbols, Matrix, linsolve x, y, z = symbols("x y z") A = Matrix([[1, 1, 1], [1, -1, 1], [2, 1, -1]]) B = Matrix([6, 4, 1]) solution = linsolve((A, B), (x, y, z)) print(solution) |
Sortie :
1 | {(2, 1, 3)} |
La représentation matricielle est particulièrement utile pour les systèmes de grande taille ou lorsque les coefficients proviennent déjà d'un calcul matriciel.
6. Résoudre un système avec une infinité de solutions
Un système linéaire peut posséder une infinité de solutions. Cela se produit notamment lorsque certaines équations sont dépendantes et n'apportent pas de nouvelle contrainte.
Dans l'exemple suivant, la deuxième équation est exactement le double de la première.
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)} |
La variable y est libre. Pour toute valeur de y, nous obtenons x = 2 - y. Le système possède donc une infinité de solutions.
Un système comportant trois inconnues peut également contenir plusieurs variables libres. Le programme suivant en donne un exemple.
1 2 3 4 5 6 | from sympy import symbols, linsolve x, y, z = symbols("x y z") equation = x + y + z - 5 solution = linsolve([equation], (x, y, z)) print(solution) |
Sortie :
1 | {(-y - z + 5, y, z)} |
Les variables y et z sont libres et x dépend de leurs valeurs selon la relation x = 5 - y - z.
7. Détecter un système sans solution
Un système est incompatible lorsque ses équations imposent des conditions contradictoires. Dans ce cas, linsolve() retourne EmptySet, qui représente l'ensemble vide.
Le programme suivant tente de résoudre simultanément 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 |
Aucun couple (x, y) ne peut vérifier simultanément ces deux équations. Géométriquement, elles représentent deux droites parallèles distinctes.
Nous pouvons tester directement si le résultat est l'ensemble vide avec S.EmptySet.
1 2 3 4 5 6 7 | from sympy import symbols, linsolve, S x, y = symbols("x y") solution = linsolve([x + y - 2, x + y - 5], (x, y)) print(solution) print(solution == S.EmptySet) |
Sortie :
1 2 | EmptySet True |
Ce test est utile dans un programme qui doit effectuer automatiquement un traitement différent lorsqu'un système ne possède aucune solution.
8. Résoudre un système avec des paramètres
La fonction linsolve() peut également résoudre des systèmes contenant des paramètres symboliques. Les solutions sont alors exprimées en fonction de ces paramètres, dans le cas générique où les opérations algébriques effectuées restent valides.
Le programme suivant résout un système dépendant du paramètre a.
1 2 3 4 5 6 7 | from sympy import symbols, linsolve x, y, a = symbols("x y a") equation1 = x + y - a equation2 = x - y - 2 solution = linsolve([equation1, equation2], (x, y)) print(solution) |
Sortie :
1 | {(a/2 + 1, a/2 - 1)} |
Nous obtenons x = a/2 + 1 et y = a/2 - 1. Ces expressions donnent une solution pour chaque valeur admissible du paramètre a.
Les paramètres peuvent également apparaître dans les coefficients. Dans ce cas, certaines valeurs particulières du paramètre peuvent modifier la nature du système et doivent être étudiées séparément.
1 2 3 4 5 6 7 | from sympy import symbols, linsolve x, y, a = symbols("x y a") equation1 = a*x + y - 1 equation2 = x + y - 2 solution = linsolve([equation1, equation2], (x, y)) print(solution) |
Sortie :
1 | {(-1/(a - 1), (2*a - 1)/(a - 1))} |
Cette formule correspond au cas générique a ≠ 1. Pour a = 1, les deux équations deviennent x + y = 1 et x + y = 2 : elles sont incompatibles et le système n'a alors aucune solution. Cet exemple montre qu'avec des paramètres, il est important d'étudier séparément les valeurs qui annulent les dénominateurs apparaissant dans les solutions symboliques.
9. Exploiter et vérifier les solutions retournées par linsolve()
Le résultat de linsolve() est un ensemble SymPy contenant généralement un tuple. Lorsque le système possède une solution unique, nous pouvons récupérer ce tuple puis utiliser ses composantes dans la suite du programme.
Le programme suivant extrait les valeurs de x et y de la solution retournée par linsolve().
1 2 3 4 5 6 7 8 9 | from sympy import symbols, linsolve x, y = symbols("x y") solution = linsolve([2*x + y - 7, x - y - 2], (x, y)) couple = next(iter(solution)) valeur_x, valeur_y = couple print("x =", valeur_x) print("y =", valeur_y) |
Sortie :
1 2 | x = 3 y = 1 |
Cette méthode est pratique lorsque nous savons que le système possède une solution unique. Avant de l'utiliser dans un programme général, il est toutefois préférable de vérifier que l'ensemble des solutions n'est pas vide.
Nous pouvons ensuite utiliser subs() pour vérifier que les valeurs obtenues annulent bien toutes les expressions du système.
1 2 3 4 5 6 7 8 9 10 | 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)) valeur_x, valeur_y = next(iter(solution)) print(equation1.subs({x: valeur_x, y: valeur_y})) print(equation2.subs({x: valeur_x, y: valeur_y})) |
Sortie :
1 2 | 0 0 |
Les deux résultats sont nuls, ce qui confirme que x = 3 et y = 1 vérifient simultanément les deux équations.
10. À retenir !
La fonction linsolve() de SymPy est spécialement conçue pour la résolution symbolique des systèmes linéaires. Elle offre une représentation cohérente des solutions et permet de traiter aussi bien les systèmes à solution unique que les systèmes indéterminés ou incompatibles.
- linsolve([equations], (variables)) permet de résoudre un système linéaire donné sous forme d'équations.
- Les expressions transmises à linsolve() sont considérées comme égales à zéro.
- Les équations peuvent également être représentées avec Eq().
- linsolve() retourne un ensemble contenant des tuples de solutions.
- L'ordre des composantes du tuple correspond à l'ordre des variables fourni à linsolve().
- Un système peut être fourni sous forme matricielle avec le couple (A, B).
- Les variables libres permettent de représenter une infinité de solutions.
- EmptySet indique qu'un système est incompatible et ne possède aucune solution.
- Les systèmes paramétriques peuvent nécessiter une étude séparée des valeurs particulières des paramètres.
- subs() permet de vérifier les solutions obtenues en les remplaçant dans les équations originales.
Le programme suivant rassemble trois situations fondamentales : un système possédant une solution unique, un système possédant une infinité de solutions et un système sans solution.
1 2 3 4 5 6 7 8 9 10 11 | from sympy import symbols, linsolve x, y = symbols("x y") unique = linsolve([2*x + y - 7, x - y - 2], (x, y)) infinite = linsolve([x + y - 2, 2*x + 2*y - 4], (x, y)) aucune = linsolve([x + y - 2, x + y - 5], (x, y)) print("Solution unique :", unique) print("Infinité de solutions :", infinite) print("Aucune solution :", aucune) |
Sortie :
1 2 3 | Solution unique : {(3, 1)} Infinité de solutions : {(2 - y, y)} Aucune solution : EmptySet |
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/
