- À propos de nonlinsolve() en SymPy
- Résoudre un système non linéaire simple
- Résoudre un système contenant des équations du second degré
- Résoudre l'intersection de deux courbes
- Résoudre un système à trois inconnues
- Comprendre les solutions multiples et complexes
- Résoudre un système avec une infinité de solutions
- Résoudre des systèmes avec des fonctions non polynomiales
- Exploiter et vérifier les solutions de nonlinsolve()
- À retenir !
1. À propos de nonlinsolve() en SymPy
La bibliothèque SymPy propose la fonction nonlinsolve() pour résoudre symboliquement des systèmes d'équations non linéaires. Un système est non linéaire lorsqu'il contient, par exemple, des puissances comme x², des produits d'inconnues comme xy ou certaines fonctions non linéaires.
La syntaxe générale est nonlinsolve([equation1, equation2, ...], [x, y, ...]). Les équations sont généralement données sous forme d'expressions supposées égales à zéro.
Le programme suivant résout le système x² = 4 et y = x + 1.
1 2 3 4 5 6 7 | from sympy import symbols, nonlinsolve x, y = symbols("x y") equation1 = x**2 - 4 equation2 = y - x - 1 solutions = nonlinsolve([equation1, equation2], [x, y]) print(solutions) |
Sortie :
1 | {(-2, -1), (2, 3)} |
Le résultat est un ensemble de tuples. Les solutions sont donc (x, y) = (-2, -1) et (x, y) = (2, 3).
2. Résoudre un système non linéaire simple
Un système peut devenir non linéaire dès qu'une inconnue apparaît avec une puissance supérieure à 1. La fonction nonlinsolve() recherche alors les différents couples ou tuples satisfaisant simultanément toutes les équations.
Le programme suivant résout le système x² + y = 5 et x + y = 3.
1 2 3 4 5 6 7 | from sympy import symbols, nonlinsolve x, y = symbols("x y") equation1 = x**2 + y - 5 equation2 = x + y - 3 solutions = nonlinsolve([equation1, equation2], [x, y]) print(solutions) |
Sortie :
1 | {(-2, 5), (1, 2)} |
Le système possède deux solutions : (-2, 5) et (1, 2). Chacun de ces couples vérifie simultanément les deux équations.
Un produit entre deux inconnues rend également le système non linéaire. L'exemple suivant résout xy = 6 avec x + y = 5.
1 2 3 4 5 6 7 | from sympy import symbols, nonlinsolve x, y = symbols("x y") equation1 = x*y - 6 equation2 = x + y - 5 solutions = nonlinsolve([equation1, equation2], [x, y]) print(solutions) |
Sortie :
1 | {(2, 3), (3, 2)} |
Les deux solutions correspondent aux deux possibilités d'obtenir un produit égal à 6 et une somme égale à 5.
3. Résoudre un système contenant des équations du second degré
La fonction nonlinsolve() est particulièrement utile pour les systèmes contenant plusieurs équations polynomiales du second degré. Plusieurs solutions peuvent alors être obtenues.
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 le système.
Nous pouvons également résoudre un système constitué de deux équations quadratiques. Le programme suivant cherche les solutions de x² + y² = 2 et x² - y² = 0.
1 2 3 4 5 6 7 | from sympy import symbols, nonlinsolve x, y = symbols("x y") equation1 = x**2 + y**2 - 2 equation2 = x**2 - y**2 solutions = nonlinsolve([equation1, equation2], [x, y]) print(solutions) |
Sortie :
1 | {(-1, -1), (-1, 1), (1, -1), (1, 1)} |
Le système possède ici quatre solutions réelles. Comme le résultat est un ensemble mathématique, l'ordre d'affichage des tuples ne doit pas être considéré comme significatif.
4. Résoudre l'intersection de deux courbes
Un système non linéaire peut représenter géométriquement les points d'intersection de deux courbes. Chaque solution retournée par nonlinsolve() correspond alors aux coordonnées d'un point commun aux deux courbes.
Le programme suivant cherche les points d'intersection de la parabole y = x² et de la droite 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)} |
Les points d'intersection sont donc (-2, 4) et (2, 4).
Nous pouvons également rechercher l'intersection du cercle x² + y² = 5 et de la droite y = x.
1 2 3 4 5 6 7 | from sympy import symbols, nonlinsolve x, y = symbols("x y") equation1 = x**2 + y**2 - 5 equation2 = y - x solutions = nonlinsolve([equation1, equation2], [x, y]) print(solutions) |
Sortie :
1 | {(-sqrt(10)/2, -sqrt(10)/2), (sqrt(10)/2, sqrt(10)/2)} |
SymPy conserve ici les coordonnées sous une forme exacte utilisant sqrt(), plutôt que de produire automatiquement des approximations décimales.
5. Résoudre un système à trois inconnues
La fonction nonlinsolve() n'est pas limitée aux systèmes comportant deux inconnues. Nous pouvons lui fournir trois variables ou davantage, à condition de préciser leur ordre dans la liste des inconnues.
Le programme suivant résout un système non linéaire à trois inconnues dans lequel x² = 4, y = x + 1 et z = x + y.
1 2 3 4 5 6 7 8 | from sympy import symbols, nonlinsolve x, y, z = symbols("x y z") equation1 = x**2 - 4 equation2 = y - x - 1 equation3 = z - x - y solutions = nonlinsolve([equation1, equation2, equation3], [x, y, z]) print(solutions) |
Sortie :
1 | {(-2, -1, -3), (2, 3, 5)} |
Chaque tuple respecte l'ordre (x, y, z). Les deux solutions sont donc (-2, -1, -3) et (2, 3, 5).
L'ordre des variables transmis à nonlinsolve() détermine l'ordre des valeurs dans les tuples retournés. Il est donc important de conserver cet ordre lors de l'interprétation du résultat.
6. Comprendre les solutions multiples et complexes
Les systèmes non linéaires peuvent posséder plusieurs solutions. Par défaut, SymPy travaille symboliquement et peut également retourner des solutions complexes lorsque celles-ci satisfont les équations.
Le programme suivant résout x² + 1 = 0 avec la contrainte y = x.
1 2 3 4 5 6 7 | from sympy import symbols, nonlinsolve x, y = symbols("x y") equation1 = x**2 + 1 equation2 = y - x solutions = nonlinsolve([equation1, equation2], [x, y]) print(solutions) |
Sortie :
1 | {(-I, -I), (I, I)} |
Le symbole I représente l'unité imaginaire vérifiant I² = -1. Les deux solutions sont donc complexes.
Si nous souhaitons orienter un problème vers des variables réelles, nous pouvons déclarer les symboles avec l'hypothèse real=True. Dans l'exemple suivant, aucune valeur réelle de x ne peut vérifier x² + 1 = 0.
1 2 3 4 5 | from sympy import symbols, nonlinsolve x, y = symbols("x y", real=True) solutions = nonlinsolve([x**2 + 1, y - x], [x, y]) print(solutions) |
Sortie :
1 | EmptySet |
Le résultat EmptySet indique qu'il n'existe aucun couple réel satisfaisant ce système sous les hypothèses imposées aux symboles.
7. Résoudre un système avec une infinité de solutions
Un système non linéaire peut également posséder une infinité de solutions. Dans ce cas, nonlinsolve() peut retourner des solutions paramétrées à l'aide de variables libres ou d'ensembles symboliques.
Le programme suivant considère une seule relation non linéaire entre deux inconnues : xy = 1.
1 2 3 4 5 | from sympy import symbols, nonlinsolve x, y = symbols("x y") solutions = nonlinsolve([x*y - 1], [x, y]) print(solutions) |
Sortie possible :
1 | {(1/y, y)} |
Cette écriture signifie que y est libre et que x = 1/y, avec naturellement y ≠ 0. Il existe donc une infinité de couples satisfaisant l'équation. La forme exacte de paramétrisation peut varier selon la version de SymPy.
Un autre exemple consiste à imposer x² + y² = 1. Cette équation représente le cercle unité et possède une infinité de solutions.
1 2 3 4 5 | from sympy import symbols, nonlinsolve x, y = symbols("x y") solutions = nonlinsolve([x**2 + y**2 - 1], [x, y]) print(solutions) |
Sortie possible :
1 | {(-sqrt(1 - y**2), y), (sqrt(1 - y**2), y)} |
Le résultat exprime ici x en fonction de la variable libre y. Selon les hypothèses et le domaine considérés, il faut également tenir compte des conditions nécessaires pour que les expressions représentent des solutions admissibles.
8. Résoudre des systèmes avec des fonctions non polynomiales
La fonction nonlinsolve() peut également traiter certains systèmes contenant des fonctions non polynomiales, notamment des fonctions exponentielles ou d'autres fonctions transcendantes. Cependant, tous les systèmes de ce type ne possèdent pas nécessairement une solution symbolique explicite.
Le programme suivant combine une équation exponentielle avec une relation entre deux inconnues.
1 2 3 4 5 6 7 | from sympy import symbols, exp, nonlinsolve x, y = symbols("x y", real=True) equation1 = exp(x) - 2 equation2 = y - x solutions = nonlinsolve([equation1, equation2], [x, y]) print(solutions) |
Sortie :
1 | {(log(2), log(2))} |
La solution réelle est x = log(2) et y = log(2). SymPy conserve une fois encore la valeur sous sa forme exacte.
Pour les systèmes transcendantes plus complexes, SymPy peut ne pas être capable d'isoler explicitement toutes les inconnues. Il est donc important d'examiner la structure de la sortie plutôt que de supposer qu'un ensemble de tuples numériques sera toujours obtenu.
9. Exploiter et vérifier les solutions de nonlinsolve()
Le résultat de nonlinsolve() est généralement un ensemble contenant des tuples. Lorsque les solutions sont explicites et finies, nous pouvons parcourir cet ensemble afin de récupérer les différentes valeurs des inconnues.
Le programme suivant parcourt les solutions du système x² = 4 et y = x + 1.
1 2 3 4 5 6 7 8 9 | from sympy import symbols, nonlinsolve x, y = symbols("x y") equation1 = x**2 - 4 equation2 = y - x - 1 solutions = nonlinsolve([equation1, equation2], [x, y]) for solution in solutions: print("x =", solution[0], ", y =", solution[1]) |
Sortie possible :
1 2 | x = -2 , y = -1 x = 2 , y = 3 |
Comme solutions est un ensemble, l'ordre de parcours des solutions ne doit pas être considéré comme garanti.
La méthode subs() permet ensuite de vérifier chaque solution en la remplaçant dans les expressions originales. Une solution correcte doit annuler toutes les équations écrites sous la forme expression = 0.
1 2 3 4 5 6 7 8 9 10 | from sympy import symbols, nonlinsolve x, y = symbols("x y") equation1 = x**2 - 4 equation2 = y - x - 1 solutions = nonlinsolve([equation1, equation2], [x, y]) for valeur_x, valeur_y in solutions: valeurs = {x: valeur_x, y: valeur_y} print(valeur_x, valeur_y, "->", equation1.subs(valeurs), equation2.subs(valeurs)) |
Sortie possible :
1 2 | -2 -1 -> 0 0 2 3 -> 0 0 |
Les deux expressions donnent 0 pour chaque couple, ce qui confirme que les solutions retournées vérifient simultanément le système.
10. À retenir !
La fonction nonlinsolve() de SymPy est conçue pour la résolution symbolique des systèmes non linéaires. Elle complète notamment linsolve(), qui est réservée aux systèmes linéaires.
- nonlinsolve([equations], [variables]) permet de résoudre un système non linéaire.
- Les équations fournies sous forme d'expressions sont considérées comme égales à zéro.
- Une puissance comme x² ou un produit comme xy peut rendre un système non linéaire.
- Le résultat est généralement représenté sous forme d'un ensemble de tuples.
- Un système non linéaire peut posséder une, plusieurs ou une infinité de solutions.
- EmptySet représente un ensemble de solutions vide dans le contexte considéré.
- Les solutions peuvent être réelles ou complexes.
- Les systèmes sous-déterminés peuvent produire des solutions contenant des variables libres ou des expressions paramétrées.
- Les systèmes contenant des fonctions transcendantes ne sont pas toujours résolubles sous une forme symbolique explicite.
- subs() permet de vérifier les solutions obtenues en les remplaçant dans les équations originales.
Le programme suivant rassemble trois exemples : un système polynomial à plusieurs solutions, un système avec un produit d'inconnues et un système possédant des solutions complexes.
1 2 3 4 5 6 7 8 9 10 11 | from sympy import symbols, nonlinsolve x, y = symbols("x y") systeme1 = nonlinsolve([x**2 + y**2 - 5, x - y - 1], [x, y]) systeme2 = nonlinsolve([x*y - 6, x + y - 5], [x, y]) systeme3 = nonlinsolve([x**2 + 1, y - x], [x, y]) print("Système 1 :", systeme1) print("Système 2 :", systeme2) print("Système 3 :", systeme3) |
Sortie :
1 2 3 | Système 1 : {(-1, -2), (2, 1)} Système 2 : {(2, 3), (3, 2)} Système 3 : {(-I, -I), (I, I)} |
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/
