- À propos de la résolution numérique avec nsolve()
- Résoudre une équation simple avec nsolve()
- Comprendre le rôle de la valeur initiale
- Trouver plusieurs solutions d'une équation
- Résoudre des équations transcendantes
- Résoudre un système d'équations avec nsolve()
- Augmenter la précision des solutions
- Vérifier numériquement une solution
- Comprendre les erreurs et les limites de nsolve()
- À retenir !
1. À propos de la résolution numérique avec nsolve()
La bibliothèque SymPy permet de résoudre des équations aussi bien symboliquement que numériquement. Lorsque nous recherchons une solution numérique, notamment pour une équation difficile à résoudre exactement, nous pouvons utiliser la fonction nsolve().
Contrairement à solve() ou solveset(), qui cherchent généralement des solutions symboliques exactes, nsolve() calcule une approximation numérique d'une solution. La fonction nécessite généralement une valeur initiale située suffisamment près de la solution recherchée.
Le programme suivant utilise nsolve() pour rechercher numériquement une solution de l'équation x² - 2 = 0 à partir de la valeur initiale 1.
1 2 3 4 5 | from sympy import symbols, nsolve x = symbols("x") solution = nsolve(x**2 - 2, x, 1) print(solution) |
Sortie :
1 | 1.41421356237310 |
La valeur obtenue est une approximation numérique de √2. La fonction nsolve() a donc trouvé numériquement la racine positive de l'équation.
2. Résoudre une équation simple avec nsolve()
La syntaxe courante pour une équation à une inconnue est nsolve(expression, variable, valeur_initiale). L'expression est considérée comme étant égale à zéro.
Le programme suivant résout numériquement l'équation x³ - x - 1 = 0 en utilisant 1 comme valeur initiale.
1 2 3 4 5 6 | from sympy import symbols, nsolve x = symbols("x") equation = x**3 - x - 1 solution = nsolve(equation, x, 1) print(solution) |
Sortie :
1 | 1.32471795724475 |
La solution obtenue est une approximation numérique de la racine réelle de cette équation.
Nous pouvons également représenter explicitement l'équation avec Eq(). Dans l'exemple suivant, nous résolvons x³ = 10.
1 2 3 4 5 6 | from sympy import symbols, Eq, nsolve x = symbols("x") equation = Eq(x**3, 10) solution = nsolve(equation, x, 2) print(solution) |
Sortie :
1 | 2.15443469003188 |
La valeur obtenue est une approximation numérique de ∛10.
3. Comprendre le rôle de la valeur initiale
La valeur initiale joue un rôle essentiel dans la résolution numérique. La fonction nsolve() utilise une méthode numérique itérative et recherche généralement une racine accessible à partir de cette valeur initiale.
Pour une équation possédant plusieurs racines, différentes valeurs initiales peuvent donc conduire à différentes solutions. L'équation x² - 4 = 0 possède les solutions -2 et 2. Le programme suivant utilise deux valeurs initiales différentes.
1 2 3 4 5 6 7 8 9 10 | from sympy import symbols, nsolve x = symbols("x") equation = x**2 - 4 solution1 = nsolve(equation, x, -3) solution2 = nsolve(equation, x, 3) print(solution1) print(solution2) |
Sortie :
1 2 | -2.00000000000000 2.00000000000000 |
La valeur initiale -3 conduit à la racine négative tandis que la valeur initiale 3 conduit à la racine positive.
La valeur initiale n'est donc pas une simple indication facultative : elle peut déterminer la solution vers laquelle l'algorithme converge.
4. Trouver plusieurs solutions d'une équation
La fonction nsolve() cherche normalement une solution à la fois. Elle ne retourne pas automatiquement toutes les racines d'une équation. Pour rechercher plusieurs solutions, nous pouvons lancer nsolve() avec plusieurs valeurs initiales judicieusement choisies.
L'équation x³ - 4x = 0 possède trois solutions réelles : -2, 0 et 2. Le programme suivant les recherche à partir de trois valeurs initiales.
1 2 3 4 5 6 7 8 9 10 11 12 | from sympy import symbols, nsolve x = symbols("x") equation = x**3 - 4*x solution1 = nsolve(equation, x, -3) solution2 = nsolve(equation, x, 0.5) solution3 = nsolve(equation, x, 3) print(solution1) print(solution2) print(solution3) |
Sortie :
1 2 3 | -2.00000000000000 0 2.00000000000000 |
Nous obtenons ainsi les trois racines. Il faut cependant retenir que nsolve() ne garantit pas que le simple choix de plusieurs valeurs initiales permettra de découvrir toutes les solutions d'une équation quelconque.
Lorsque les solutions exactes sont accessibles symboliquement, des fonctions comme solve(), solveset() ou les outils dédiés aux polynômes peuvent être plus adaptées pour rechercher l'ensemble des solutions.
5. Résoudre des équations transcendantes
La fonction nsolve() est particulièrement utile pour les équations transcendantes, qui contiennent par exemple des fonctions trigonométriques, exponentielles ou logarithmiques et dont les solutions ne sont pas toujours faciles à exprimer sous une forme exacte.
Le programme suivant recherche une solution de l'équation cos(x) = x.
1 2 3 4 5 6 | from sympy import symbols, cos, nsolve x = symbols("x") equation = cos(x) - x solution = nsolve(equation, x, 1) print(solution) |
Sortie :
1 | 0.739085133215161 |
La valeur obtenue est une approximation numérique de la solution réelle de l'équation cos(x) = x.
Nous pouvons également résoudre une équation faisant intervenir la fonction exponentielle. Le programme suivant recherche une solution de eˣ = 3x à partir de la valeur initiale 1.
1 2 3 4 5 6 | from sympy import symbols, exp, nsolve x = symbols("x") equation = exp(x) - 3*x solution = nsolve(equation, x, 1) print(solution) |
Sortie :
1 | 0.619061286735945 |
Cette équation possède plusieurs solutions réelles, mais avec cette valeur initiale, nsolve() converge vers la solution située près de 0,619. Une autre valeur initiale peut conduire à une autre racine.
6. Résoudre un système d'équations avec nsolve()
La fonction nsolve() peut également résoudre numériquement un système d'équations. Nous devons alors fournir la liste des équations, la liste des inconnues et un tuple contenant une valeur initiale pour chaque inconnue.
Le programme suivant résout le système x² + y² = 5 et x - y = 1 en partant du point initial (2, 1).
1 2 3 4 5 6 7 | from sympy import symbols, nsolve x, y = symbols("x y") equation1 = x**2 + y**2 - 5 equation2 = x - y - 1 solution = nsolve([equation1, equation2], [x, y], (2, 1)) print(solution) |
Sortie :
1 | Matrix([[2.00000000000000], [1.00000000000000]]) |
La première composante correspond à x = 2 et la seconde à y = 1.
Le même système possède également la solution (-1, -2). En choisissant un point initial proche de cette solution, nsolve() peut converger vers l'autre couple.
1 2 3 4 5 6 7 | from sympy import symbols, nsolve x, y = symbols("x y") equation1 = x**2 + y**2 - 5 equation2 = x - y - 1 solution = nsolve([equation1, equation2], [x, y], (-1, -2)) print(solution) |
Sortie :
1 | Matrix([[-1.00000000000000], [-2.00000000000000]]) |
Cet exemple montre une nouvelle fois l'importance du point initial lorsque le problème possède plusieurs solutions.
7. Augmenter la précision des solutions
La fonction nsolve() permet de contrôler la précision numérique avec le paramètre prec. Cette possibilité est utile lorsque nous avons besoin d'un nombre important de chiffres significatifs.
Le programme suivant calcule une approximation de √2 avec une précision de 50 chiffres.
1 2 3 4 5 | from sympy import symbols, nsolve x = symbols("x") solution = nsolve(x**2 - 2, x, 1, prec=50) print(solution) |
Sortie :
1 | 1.4142135623730950488016887242096980785696718753769 |
La précision obtenue est beaucoup plus élevée que dans un calcul numérique standard.
Le paramètre prec indique une précision de travail en chiffres décimaux. Il ne faut pas le confondre avec le nombre de chiffres que nous souhaitons simplement afficher à l'écran.
8. Vérifier numériquement une solution
Après avoir obtenu une approximation avec nsolve(), nous pouvons vérifier la qualité de la solution en la remplaçant dans l'expression originale avec subs(), puis en évaluant numériquement le résultat avec evalf().
Le programme suivant calcule une solution de x³ - x - 1 = 0 puis évalue le résidu obtenu en remplaçant x par cette solution.
1 2 3 4 5 6 7 8 9 | from sympy import symbols, nsolve x = symbols("x") equation = x**3 - x - 1 solution = nsolve(equation, x, 1) residu = equation.subs(x, solution).evalf() print("Solution :", solution) print("Résidu :", residu) |
Sortie possible :
1 2 | Solution : 1.32471795724475 Résidu : 2.22044604925031e-16 |
Le résidu est extrêmement proche de zéro. La petite différence éventuelle provient des approximations numériques et de la précision utilisée pour les calculs.
Avec une précision plus importante, nous pouvons obtenir un résidu encore plus petit. Le programme suivant effectue le calcul avec 50 chiffres de précision.
1 2 3 4 5 6 7 8 9 | from sympy import symbols, nsolve x = symbols("x") equation = x**3 - x - 1 solution = nsolve(equation, x, 1, prec=50) residu = equation.subs(x, solution).evalf(50) print("Solution :", solution) print("Résidu :", residu) |
Sortie possible :
1 2 | Solution : 1.3247179572447460259609088544780973407344040569017 Résidu : 0 |
Selon le calcul et la précision interne, le résidu peut être affiché comme zéro ou comme une valeur extrêmement petite. L'objectif est de vérifier qu'il est numériquement négligeable.
9. Comprendre les erreurs et les limites de nsolve()
La fonction nsolve() utilise des méthodes numériques itératives. La convergence n'est donc pas garantie pour n'importe quelle équation et n'importe quelle valeur initiale. Une mauvaise valeur initiale, une fonction présentant des singularités ou un problème numériquement difficile peuvent provoquer un échec de convergence.
Le programme suivant montre comment intercepter une erreur éventuelle avec try et except. Nous imposons ici volontairement un nombre maximal d'itérations très faible afin d'illustrer un échec possible de la résolution.
1 2 3 4 5 6 7 8 9 | from sympy import symbols, cos, nsolve x = symbols("x") try: solution = nsolve(cos(x) - x, x, 10, maxsteps=1) print(solution) except ValueError: print("La méthode numérique n'a pas convergé.") |
Sortie :
1 | La méthode numérique n'a pas convergé. |
Lorsqu'un calcul échoue, nous pouvons essayer une meilleure valeur initiale, augmenter le nombre d'itérations autorisées, augmenter la précision ou examiner la fonction afin de choisir une stratégie numérique plus adaptée.
Il faut également retenir que nsolve() ne recherche pas automatiquement toutes les solutions. Elle cherche généralement une solution accessible depuis le point initial fourni. Pour connaître l'ensemble des solutions lorsque cela est possible symboliquement, solve() ou solveset() sont souvent plus appropriées.
10. À retenir !
La fonction nsolve() de SymPy permet de trouver une solution numérique approchée d'une équation ou d'un système d'équations. Elle est particulièrement utile lorsque la résolution symbolique est difficile ou lorsqu'une approximation numérique suffit.
- nsolve() effectue une résolution numérique et non une résolution symbolique exacte.
- Pour une équation à une variable, la syntaxe courante est nsolve(expression, variable, valeur_initiale).
- Une équation peut également être représentée avec Eq().
- La valeur initiale joue un rôle essentiel dans la convergence de la méthode.
- Différentes valeurs initiales peuvent conduire à différentes solutions.
- nsolve() cherche généralement une solution à la fois et ne garantit pas la découverte de toutes les racines.
- La fonction est particulièrement utile pour les équations transcendantes.
- Elle peut également résoudre numériquement des systèmes d'équations.
- Le paramètre prec permet d'augmenter la précision numérique du calcul.
- subs() et evalf() permettent de calculer un résidu afin de vérifier numériquement une solution.
Le programme suivant rassemble trois utilisations importantes de nsolve() : une équation algébrique, une équation transcendante et un système de deux équations.
1 2 3 4 5 6 7 8 9 10 11 | from sympy import symbols, cos, nsolve x, y = symbols("x y") solution1 = nsolve(x**3 - x - 1, x, 1) solution2 = nsolve(cos(x) - x, x, 1) solution3 = nsolve([x**2 + y**2 - 5, x - y - 1], [x, y], (2, 1)) print("Équation algébrique :", solution1) print("Équation transcendante :", solution2) print("Système :", solution3) |
Sortie :
1 2 3 | Équation algébrique : 1.32471795724475 Équation transcendante : 0.739085133215161 Système : Matrix([[2.00000000000000], [1.00000000000000]]) |
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/
