- À propos de l'évaluation numérique avec SymPy
- Évaluer une expression avec evalf()
- Choisir la précision avec evalf()
- Évaluer une expression avec N()
- Comprendre la différence entre evalf() et N()
- Évaluer une expression contenant des variables
- Utiliser subs() avant l'évaluation numérique
- Évaluer des constantes et fonctions mathématiques
- Conserver la précision dans les calculs numériques
- À retenir !
1. À propos de l'évaluation numérique avec SymPy
La bibliothèque SymPy travaille principalement avec des expressions mathématiques exactes. Par exemple, les nombres pi, sqrt(2) ou une fraction comme 1/3 peuvent être conservés sous une forme symbolique exacte.
Lorsque nous souhaitons obtenir une approximation décimale, SymPy propose principalement la méthode evalf() et la fonction N().
Le programme suivant montre la différence entre une valeur exacte et son approximation numérique.
1 2 3 4 5 | from sympy import sqrt expression = sqrt(2) print(expression) print(expression.evalf()) |
Sortie :
1 2 | sqrt(2) 1.41421356237310 |
L'expression sqrt(2) est exacte, tandis que le résultat retourné par evalf() est une approximation numérique.
2. Évaluer une expression avec evalf()
La méthode evalf() permet d'obtenir directement une évaluation numérique d'une expression SymPy. Sans argument, elle utilise généralement une précision d'environ 15 chiffres significatifs.
Le programme suivant évalue numériquement le nombre π.
1 2 3 4 | from sympy import pi print(pi) print(pi.evalf()) |
Sortie :
1 2 | pi 3.14159265358979 |
La constante pi reste exacte tant que nous ne demandons pas explicitement son approximation.
La méthode evalf() peut naturellement être appliquée à une expression plus complexe.
1 2 3 4 5 | from sympy import sqrt, pi expression = pi*sqrt(2) print(expression) print(expression.evalf()) |
Sortie :
1 2 | sqrt(2)*pi 4.44288293815837 |
SymPy évalue numériquement l'ensemble de l'expression tout en conservant l'expression originale sous sa forme symbolique.
3. Choisir la précision avec evalf()
La méthode evalf() accepte un argument permettant de préciser le nombre de chiffres significatifs souhaité. Cette possibilité est particulièrement utile lorsque les calculs nécessitent une précision supérieure à la précision habituelle des nombres flottants Python.
Le programme suivant affiche π avec différentes précisions.
1 2 3 4 5 | from sympy import pi print(pi.evalf(10)) print(pi.evalf(20)) print(pi.evalf(50)) |
Sortie :
1 2 3 | 3.141592654 3.1415926535897932385 3.1415926535897932384626433832795028841971693993751 |
L'argument passé à evalf() représente une précision exprimée en chiffres significatifs et non simplement un nombre de chiffres après la virgule.
Le même principe peut être appliqué à une expression quelconque.
1 2 3 4 5 6 | from sympy import sqrt expression = sqrt(3) print(expression.evalf(15)) print(expression.evalf(30)) |
Sortie :
1 2 | 1.73205080756888 1.73205080756887729352744634151 |
4. Évaluer une expression avec N()
La fonction N() constitue une autre manière d'obtenir une approximation numérique d'une expression SymPy. Elle reçoit l'expression à évaluer comme premier argument.
Le programme suivant utilise N() pour obtenir une approximation de √2.
1 2 3 4 5 | from sympy import sqrt, N expression = sqrt(2) print(N(expression)) |
Sortie :
1 | 1.41421356237310 |
Comme avec evalf(), nous pouvons demander une précision particulière en fournissant un second argument à N().
1 2 3 4 | from sympy import pi, N print(N(pi, 10)) print(N(pi, 30)) |
Sortie :
1 2 | 3.141592654 3.14159265358979323846264338328 |
La syntaxe générale est donc N(expression, precision).
5. Comprendre la différence entre evalf() et N()
La méthode evalf() et la fonction N() réalisent essentiellement la même opération : elles demandent une évaluation numérique d'une expression SymPy.
La principale différence visible concerne leur syntaxe. evalf() est appelée comme méthode de l'expression, tandis que N() reçoit l'expression comme argument.
Le programme suivant compare les deux écritures.
1 2 3 4 5 6 7 8 9 10 | from sympy import sqrt, N expression = sqrt(5) a = expression.evalf(20) b = N(expression, 20) print(a) print(b) print(a == b) |
Sortie :
1 2 3 | 2.2360679774997896964 2.2360679774997896964 True |
Les deux méthodes donnent ici le même résultat. Nous pouvons donc choisir l'écriture qui convient le mieux au programme : expression.evalf(n) ou N(expression, n).
6. Évaluer une expression contenant des variables
Une expression contenant encore un symbole indéterminé ne peut pas toujours être transformée entièrement en nombre. La méthode evalf() évalue alors les parties numériques tout en laissant les variables symboliques présentes.
Le programme suivant évalue une expression contenant la variable x.
1 2 3 4 5 6 | from sympy import symbols, pi x = symbols("x") expression = pi*x + 2 print(expression.evalf()) |
Sortie :
1 | 3.14159265358979*x + 2.0 |
La variable x reste symbolique, tandis que π et les parties numériques sont convertis en nombres approchés.
La méthode evalf() permet également de fournir directement une valeur numérique pour un symbole grâce à l'option subs.
1 2 3 4 5 6 7 | from sympy import symbols, pi x = symbols("x") expression = pi*x**2 resultat = expression.evalf(subs={x: 3}) print(resultat) |
Sortie :
1 | 28.2743338823081 |
Le dictionnaire fourni à subs indique ici que x doit prendre la valeur 3 au moment de l'évaluation numérique.
7. Utiliser subs() avant l'évaluation numérique
Une autre méthode très courante consiste à effectuer d'abord une substitution avec subs(), puis à demander l'approximation numérique avec evalf() ou N().
Le programme suivant remplace x par 3 avant d'effectuer l'évaluation numérique.
1 2 3 4 5 6 7 8 9 | from sympy import symbols, pi x = symbols("x") expression = pi*x**2 resultat = expression.subs(x, 3) print(resultat) print(resultat.evalf()) |
Sortie :
1 2 | 9*pi 28.2743338823081 |
Cette méthode permet de conserver d'abord le résultat exact 9*pi, puis de calculer son approximation uniquement lorsque cela est nécessaire.
Nous pouvons procéder de la même manière avec plusieurs variables.
1 2 3 4 5 6 7 8 9 | from sympy import symbols, sqrt, N x, y = symbols("x y") expression = sqrt(x**2 + y**2) resultat = expression.subs({x: 2, y: 3}) print(resultat) print(N(resultat, 20)) |
Sortie :
1 2 | sqrt(13) 3.6055512754639892931 |
L'intérêt de cette approche est de conserver le plus longtemps possible le résultat exact avant de passer à son approximation décimale.
8. Évaluer des constantes et fonctions mathématiques
Les méthodes evalf() et N() peuvent être utilisées avec les constantes et les nombreuses fonctions mathématiques disponibles dans SymPy.
Le programme suivant évalue numériquement plusieurs constantes et expressions.
1 2 3 4 5 | from sympy import pi, E, sqrt, N print(N(pi)) print(N(E)) print(N(sqrt(2))) |
Sortie :
1 2 3 | 3.14159265358979 2.71828182845905 1.41421356237310 |
Nous pouvons également évaluer des expressions contenant des fonctions trigonométriques, exponentielles ou logarithmiques.
1 2 3 4 5 6 | from sympy import sin, cos, log, E, pi, N print(N(sin(pi/4), 20)) print(N(cos(pi/3), 20)) print(N(log(2), 20)) print(N(E**2, 20)) |
Sortie :
1 2 3 4 | 0.70710678118654752440 0.50000000000000000000 0.69314718055994530942 7.3890560989306502272 |
SymPy calcule d'abord les expressions de manière symbolique, puis produit leur approximation avec la précision demandée.
9. Conserver la précision dans les calculs numériques
Pour profiter pleinement de la haute précision de SymPy, il est préférable de construire les expressions avec des nombres SymPy exacts plutôt qu'avec des nombres float Python déjà arrondis.
Le programme suivant utilise Rational pour représenter exactement la fraction 1/3 avant de demander une approximation de 50 chiffres significatifs.
1 2 3 4 5 6 | from sympy import Rational, N x = Rational(1, 3) print(x) print(N(x, 50)) |
Sortie :
1 2 | 1/3 0.33333333333333333333333333333333333333333333333333 |
SymPy possède ici la valeur exacte 1/3 et peut donc calculer autant de chiffres que la précision demandée le permet.
En revanche, si une approximation Python a déjà été introduite avant la création de l'objet SymPy, augmenter ensuite la précision d'affichage ne permet pas de retrouver les informations perdues lors de cet arrondi initial.
1 2 3 4 5 6 | from sympy import Float, N x = Float(0.1) print(x) print(N(x, 50)) |
Sortie possible :
1 2 | 0.100000000000000 0.10000000000000000555111512312578270211815834045410 |
Le nombre 0.1 a d'abord été créé comme float Python, dont la représentation binaire est déjà approchée. Demander ensuite davantage de chiffres ne transforme pas cette approximation initiale en valeur exacte 1/10.
Lorsque nous voulons représenter exactement un nombre décimal comme 0,1, nous pouvons utiliser une chaîne de caractères lors de la création du nombre SymPy.
1 2 3 4 5 | from sympy import Float, N x = Float("0.1", 50) print(N(x, 50)) |
Sortie :
1 | 0.10000000000000000000000000000000000000000000000000 |
Il est donc recommandé de conserver les nombres sous une forme exacte aussi longtemps que possible, puis d'effectuer l'évaluation numérique à la fin du calcul.
10. À retenir !
SymPy permet de travailler avec des expressions exactes puis d'obtenir leurs approximations grâce à evalf() et N().
- evalf() permet d'obtenir l'approximation numérique d'une expression SymPy.
- N() est une autre manière d'effectuer une évaluation numérique.
- expression.evalf(n) demande une précision de n chiffres significatifs.
- N(expression, n) permet de demander la même précision avec la fonction N().
- evalf() et N() donnent généralement des résultats équivalents.
- Une expression contenant encore des symboles peut rester partiellement symbolique après evalf().
- evalf(subs={...}) permet de fournir des valeurs aux symboles lors de l'évaluation.
- subs() peut être utilisé avant evalf() afin de conserver d'abord une expression exacte.
- Une grande précision ne permet pas de récupérer une précision déjà perdue lors de l'utilisation prématurée d'un float Python.
- Il est préférable de conserver les expressions exactes aussi longtemps que possible et d'effectuer l'évaluation numérique à la fin.
Le programme suivant rassemble les principales utilisations de evalf() et N() avec une expression contenant π et √2.
1 2 3 4 5 6 7 8 9 | from sympy import pi, sqrt, N expression = pi*sqrt(2) print("Expression exacte :", expression) print("evalf() :", expression.evalf()) print("evalf(30) :", expression.evalf(30)) print("N() :", N(expression)) print("N(..., 30) :", N(expression, 30)) |
Sortie :
1 2 3 4 5 | Expression exacte : sqrt(2)*pi evalf() : 4.44288293815837 evalf(30) : 4.44288293815836624701588099006 N() : 4.44288293815837 N(..., 30) : 4.44288293815836624701588099006 |
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/
