- À propos de la résolution d'équations avec solveset()
- Résoudre une équation simple avec solveset()
- Résoudre des équations polynomiales
- Choisir le domaine avec S.Reals et S.Complexes
- Résoudre des équations rationnelles
- Résoudre des équations exponentielles et logarithmiques
- Résoudre des équations trigonométriques
- Comprendre les ensembles retournés par solveset()
- Comparer solveset() et solve()
- À retenir !
1. À propos de la résolution d'équations avec solveset()
La bibliothèque SymPy propose la fonction solveset() pour résoudre des équations symboliques en représentant leurs solutions sous forme d'ensembles mathématiques. Contrairement à solve(), qui peut retourner différents types d'objets selon le problème, solveset() retourne un objet appartenant au système d'ensembles de SymPy.
Cette approche est particulièrement intéressante lorsque l'équation possède plusieurs solutions, une infinité de solutions ou lorsque nous souhaitons imposer explicitement un domaine de résolution comme les nombres réels ou les nombres complexes.
Le programme suivant résout l'équation x² - 4 = 0 avec solveset().
1 2 3 4 5 | from sympy import symbols, solveset x = symbols("x") solutions = solveset(x**2 - 4, x) print(solutions) |
Sortie :
1 | {-2, 2} |
Le résultat est un ensemble contenant les deux solutions -2 et 2.
2. Résoudre une équation simple avec solveset()
La syntaxe courante est solveset(expression, variable). Comme avec solve(), lorsqu'une expression est fournie, SymPy cherche les valeurs de la variable pour lesquelles cette expression est égale à zéro.
Le programme suivant résout l'équation 3x - 12 = 0.
1 2 3 4 5 | from sympy import symbols, solveset x = symbols("x") solutions = solveset(3*x - 12, x) print(solutions) |
Sortie :
1 | {4} |
L'ensemble retourné contient uniquement 4, qui est l'unique solution de l'équation.
Nous pouvons également représenter explicitement une équation avec Eq. Dans ce cas, solveset() résout l'égalité entre les deux membres.
1 2 3 4 5 6 | from sympy import symbols, Eq, solveset x = symbols("x") equation = Eq(5*x + 2, 3*x + 10) solutions = solveset(equation, x) print(solutions) |
Sortie :
1 | {4} |
SymPy effectue automatiquement les transformations nécessaires pour obtenir la valeur de x.
3. Résoudre des équations polynomiales
La fonction solveset() permet de résoudre des équations polynomiales de différents degrés. Les racines trouvées sont regroupées dans un ensemble.
Le programme suivant résout une équation du second degré possédant deux solutions réelles.
1 2 3 4 5 6 | from sympy import symbols, solveset x = symbols("x") equation = x**2 - 5*x + 6 solutions = solveset(equation, x) print(solutions) |
Sortie :
1 | {2, 3} |
Le polynôme x² - 5x + 6 se factorise sous la forme (x - 2)(x - 3), ce qui donne les solutions 2 et 3.
La fonction peut également résoudre des polynômes de degré supérieur. L'exemple suivant utilise un polynôme de degré 3.
1 2 3 4 5 6 | from sympy import symbols, solveset x = symbols("x") equation = x**3 - 6*x**2 + 11*x - 6 solutions = solveset(equation, x) print(solutions) |
Sortie :
1 | {1, 2, 3} |
Les trois racines sont 1, 2 et 3. Comme il s'agit d'un ensemble, l'ordre d'affichage des éléments ne doit généralement pas être considéré comme une propriété mathématique du résultat.
4. Choisir le domaine avec S.Reals et S.Complexes
L'un des principaux avantages de solveset() est la possibilité de préciser explicitement le domaine dans lequel les solutions doivent être recherchées. Le paramètre domain peut notamment recevoir S.Reals pour les nombres réels ou S.Complexes pour les nombres complexes.
Le programme suivant cherche les solutions réelles de l'équation x² + 1 = 0.
1 2 3 4 5 | from sympy import symbols, solveset, S x = symbols("x") solutions = solveset(x**2 + 1, x, domain=S.Reals) print(solutions) |
Sortie :
1 | EmptySet |
L'équation x² + 1 = 0 ne possède aucune solution réelle. SymPy retourne donc EmptySet, c'est-à-dire l'ensemble vide.
Si nous résolvons la même équation dans l'ensemble des nombres complexes, deux solutions apparaissent.
1 2 3 4 5 | from sympy import symbols, solveset, S x = symbols("x") solutions = solveset(x**2 + 1, x, domain=S.Complexes) print(solutions) |
Sortie :
1 | {-I, I} |
Les solutions complexes sont -I et I, où I représente l'unité imaginaire vérifiant I² = -1.
Il faut noter que le domaine par défaut de solveset() est le domaine complexe. Pour rechercher uniquement des solutions réelles, il est donc préférable d'indiquer explicitement domain=S.Reals.
5. Résoudre des équations rationnelles
La fonction solveset() peut résoudre des équations contenant des fractions rationnelles. Les valeurs qui rendent un dénominateur nul doivent être exclues du domaine de définition de l'équation.
Le programme suivant résout l'équation 1/x = 2 dans les nombres réels.
1 2 3 4 5 6 | from sympy import symbols, Eq, solveset, S x = symbols("x") equation = Eq(1/x, 2) solutions = solveset(equation, x, domain=S.Reals) print(solutions) |
Sortie :
1 | {1/2} |
La solution est x = 1/2. La valeur x = 0 ne peut pas être solution puisque l'expression 1/x n'y est pas définie.
Le programme suivant résout une équation comportant deux fractions.
1 2 3 4 5 6 | from sympy import symbols, Eq, solveset, S x = symbols("x") equation = Eq(1/(x - 1), 2/(x + 1)) solutions = solveset(equation, x, domain=S.Reals) print(solutions) |
Sortie :
1 | {3} |
La solution est x = 3. Les valeurs x = 1 et x = -1 sont exclues du domaine de l'équation originale puisqu'elles annulent un dénominateur.
6. Résoudre des équations exponentielles et logarithmiques
La fonction solveset() peut également résoudre de nombreuses équations faisant intervenir des fonctions exponentielles et logarithmiques. Nous pouvons préciser le domaine réel lorsque nous souhaitons travailler uniquement avec des solutions réelles.
Le programme suivant résout l'équation eˣ = 5.
1 2 3 4 5 6 | from sympy import symbols, exp, solveset, S x = symbols("x") equation = exp(x) - 5 solutions = solveset(equation, x, domain=S.Reals) print(solutions) |
Sortie :
1 | {log(5)} |
La solution réelle est x = log(5), où log désigne le logarithme naturel.
Le programme suivant résout maintenant l'équation logarithmique log(x) = 2.
1 2 3 4 5 6 | from sympy import symbols, log, solveset, S x = symbols("x") equation = log(x) - 2 solutions = solveset(equation, x, domain=S.Reals) print(solutions) |
Sortie :
1 | {exp(2)} |
La solution est x = e². Cette valeur est positive et respecte donc le domaine réel du logarithme.
7. Résoudre des équations trigonométriques
La fonction solveset() est particulièrement intéressante pour les équations trigonométriques, car celles-ci possèdent souvent une infinité de solutions. SymPy peut représenter ces solutions à l'aide d'ensembles symboliques.
Le programme suivant résout l'équation sin(x) = 0 dans les nombres réels.
1 2 3 4 5 | from sympy import symbols, sin, solveset, S x = symbols("x") solutions = solveset(sin(x), x, domain=S.Reals) print(solutions) |
Sortie :
1 | ImageSet(Lambda(_n, _n*pi), Integers) |
Cette écriture représente l'ensemble des nombres de la forme nπ, où n parcourt les entiers. Autrement dit, la solution générale est x = nπ avec n ∈ ℤ.
Une équation telle que cos(x) = 0 possède également une infinité de solutions réelles.
1 2 3 4 5 | from sympy import symbols, cos, solveset, S x = symbols("x") solutions = solveset(cos(x), x, domain=S.Reals) print(solutions) |
Sortie possible :
1 | ImageSet(Lambda(_n, _n*pi + pi/2), Integers) |
Cette représentation correspond à x = π/2 + nπ avec n ∈ ℤ. La forme exacte d'affichage d'un ensemble symbolique peut varier selon la version de SymPy tout en représentant le même ensemble mathématique.
8. Comprendre les ensembles retournés par solveset()
Contrairement à solve(), solveset() retourne des ensembles SymPy. Selon le problème, le résultat peut notamment être un FiniteSet, EmptySet, ImageSet ou ConditionSet.
Pour une équation ayant un nombre fini de solutions, le résultat est généralement un FiniteSet. Le programme suivant permet de vérifier son type.
1 2 3 4 5 6 | from sympy import symbols, solveset x = symbols("x") solutions = solveset(x**2 - 1, x) print(solutions) print(type(solutions)) |
Sortie :
1 2 | {-1, 1} <class 'sympy.sets.sets.FiniteSet'> |
Lorsque l'équation ne possède aucune solution dans le domaine choisi, solveset() retourne l'ensemble vide.
1 2 3 4 5 6 | from sympy import symbols, solveset, S x = symbols("x") solutions = solveset(x**2 + 1, x, domain=S.Reals) print(solutions) print(solutions == S.EmptySet) |
Sortie :
1 2 | EmptySet True |
Lorsque SymPy ne parvient pas à résoudre complètement une équation, solveset() peut retourner un ConditionSet. Celui-ci représente symboliquement l'ensemble des valeurs qui satisfont une condition sans prétendre que l'équation a été explicitement résolue.
Le programme suivant construit directement un ConditionSet afin d'en montrer la structure.
1 2 3 4 5 | from sympy import symbols, ConditionSet, S x = symbols("x") ensemble = ConditionSet(x, x**5 - x + 1, S.Reals) print(ensemble) |
Sortie :
1 | ConditionSet(x, x**5 - x + 1, Reals) |
Cette notation signifie : l'ensemble des nombres réels x satisfaisant la condition x⁵ - x + 1 = 0. Un ConditionSet retourné par solveset() indique donc généralement que SymPy conserve la condition sous une forme symbolique plutôt que de fournir une liste explicite de solutions.
9. Comparer solveset() et solve()
Les fonctions solve() et solveset() servent toutes les deux à résoudre des équations, mais leurs philosophies diffèrent. solve() possède une interface historique très flexible et peut retourner différents types de résultats, tandis que solveset() représente systématiquement les solutions sous forme d'ensembles mathématiques.
Le programme suivant compare les résultats des deux fonctions sur une équation du second degré.
1 2 3 4 5 6 7 | from sympy import symbols, solve, solveset, S x = symbols("x") equation = x**2 - 5*x + 6 print("solve() :", solve(equation, x)) print("solveset() :", solveset(equation, x, domain=S.Reals)) |
Sortie :
1 2 | solve() : [2, 3] solveset() : {2, 3} |
solve() retourne ici une liste, tandis que solveset() retourne un ensemble.
La différence devient particulièrement intéressante avec les équations possédant une infinité de solutions, comme les équations trigonométriques.
1 2 3 4 5 | from sympy import symbols, sin, solveset, S x = symbols("x") solutions = solveset(sin(x), x, domain=S.Reals) print(solutions) |
Sortie :
1 | ImageSet(Lambda(_n, _n*pi), Integers) |
La fonction solveset() représente ici l'ensemble infini des solutions x = nπ. Elle est donc particulièrement adaptée lorsque le domaine et la représentation mathématique complète de l'ensemble des solutions sont importants.
10. À retenir !
La fonction solveset() de SymPy permet de résoudre des équations symboliques tout en représentant les solutions sous forme d'ensembles. Elle est particulièrement adaptée lorsque nous souhaitons contrôler précisément le domaine de résolution ou représenter des ensembles infinis de solutions.
- solveset(expression, x) recherche les valeurs de x qui annulent une expression.
- Une équation peut également être représentée avec Eq().
- solveset() retourne des objets appartenant au système d'ensembles de SymPy.
- S.Reals permet de limiter la recherche aux nombres réels.
- S.Complexes permet de rechercher les solutions complexes.
- Le domaine par défaut de solveset() est le domaine complexe.
- EmptySet indique qu'aucune solution n'existe dans le domaine considéré.
- FiniteSet représente un ensemble contenant un nombre fini de solutions.
- ImageSet permet notamment de représenter certaines familles infinies de solutions.
- ConditionSet peut apparaître lorsque SymPy conserve une condition qu'il ne parvient pas à résoudre explicitement.
Le programme suivant rassemble plusieurs exemples permettant de comparer la résolution sur les réels, sur les complexes et pour une équation trigonométrique.
1 2 3 4 5 6 7 8 9 10 11 12 13 | from sympy import symbols, solveset, sin, S x = symbols("x") solution1 = solveset(x**2 - 4, x, domain=S.Reals) solution2 = solveset(x**2 + 1, x, domain=S.Reals) solution3 = solveset(x**2 + 1, x, domain=S.Complexes) solution4 = solveset(sin(x), x, domain=S.Reals) print("x² - 4 sur R :", solution1) print("x² + 1 sur R :", solution2) print("x² + 1 sur C :", solution3) print("sin(x) = 0 sur R :", solution4) |
Sortie :
1 2 3 4 | x² - 4 sur R : {-2, 2} x² + 1 sur R : EmptySet x² + 1 sur C : {-I, I} sin(x) = 0 sur R : ImageSet(Lambda(_n, _n*pi), Integers) |
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/
