Calcul de caractères avec Python. Partie 1. Les bases

Pour résoudre les problèmes de modélisation mathématique des processus et des objets, il est souvent très pratique d'utiliser des algorithmes Python utilisant des calculs symboliques. Basé sur la bibliothèque SymPy, Python réussit à résoudre des équations et des systèmes, à intégrer et à différencier, à calculer des limites, à étendre en série et à sommer des séries, à simplifier les expressions et à rechercher des solutions aux équations et systèmes différentiels.

Lors de l'utilisation de calculs symboliques, l'utilisateur a la possibilité de contrôler le programme pendant son exécution en entrant des fonctions valides avec un nombre donné de variables.

En tant que professeur de la discipline "Génie informatique et programmation", dans le module de programmation en Python, je présente aux étudiants les possibilités de ce langage pour la recherche scientifique. Votre attention est une série d'articles dans lesquels vous pouvez vous familiariser avec l'informatique symbolique en Python. Je tiens à avertir immédiatement que ces articles ne revendiquent pas l'unicité absolue, car ils sont collectés sur la base de matériaux provenant de diverses sources, leur objectif est d'enseigner aux étudiants les bases de l'informatique symbolique.

La toute première étape vers l'informatique symbolique consiste à importer les fonctions du module SymPy à l'aide de pip, le système de gestion de packages Python. Si vous pouvez gérer cela, passons à la déclaration des variables.

Remarque Pour raccourcir l'enregistrement, la ligne suivante n'est pas affichée dans tous les exemples suivants: from sympy import *

Déclaration explicite des variables de caractère

Pour les calculs symboliques utilisant le module SymPy, les variables et fonctions symboliques doivent être déclarées comme telles. Dans les programmes informatiques mathématiques tels que Mathematica ou Maple, les variables sont immédiatement considérées comme symboliques. En Python, ils doivent être déclarés symboliquement de force, ce qui peut être fait de plusieurs manières. La manière la plus simple consiste à utiliser les fonctions symboles () ou var () . La première fonction renvoie une référence à un objet caractère sous forme de variable. La seconde, sans affectation, crée une variable de caractère.


La principale différence entre les fonctions symboles () et var () est que la première fonction renvoie une référence à l'objet symbole. Pour une utilisation future, il doit être affecté à n'importe quelle variable. La seconde, sans affectation, crée une variable de caractère.
Dans les fonctions symboles () et var (), vous pouvez déclarer des variables de symbole avec un index:


Vous pouvez également affecter un type et imposer des restrictions sur les variables de symbole directement dans les fonctions symboles () et var (). Parfois, sans de telles restrictions, les transformations évidentes ne fonctionnent pas, par exemple, comparez:


Pour créer un conteneur pour un seul caractère, utilisez l'argument seq = True:

 >>> symbols('x',seq=True) (x,) 

Détermination des valeurs valides pour les variables de caractère:

 >>> x, y, z = symbols('x,y,z', real=True) >>> x.is_real and y.is_real and z.is_real True 

Fonction s ()

Parfois, les expressions de caractères peuvent être interprétées comme des constantes numériques Python plutôt que SymPy. Par conséquent, pour déclarer des variables symboliques, ainsi que pour convertir des constantes numériques en symboles, utilisez la fonction S (), par exemple, comparez:

 >>> expr = x**2 + sin(y) + S(10)/2; expr x**2 + sin(y) + 5 >>> type(10) <class 'int'> >>> type(S(10)) #    <class 'sympy.core.numbers.Integer'> 

La différence entre une constante Python et une constante de caractère est qu'une constante de caractère peut être calculée avec un degré de précision donné, comme indiqué dans l'exemple suivant, par rapport à la fonction standard round () :

 z=1/7; z #   z    0.14285714285714285 z1=S(1)/7; z1 1/7 z2=z1.n(30); z2 #   z2    30   0.142857142857142857142857142857 z3=round(z1,30); z3 0.14285714285714285 

Noms des personnages

Si vous devez constamment utiliser les mathématiques symboliques dans la session en cours, vous pouvez importer des noms symboliques courants à partir du module sympy.abc :


Le nom de la variable peut être supprimé de l'espace de noms avec la commande del name1, name2, .. :

 >>> type(x) <class 'sympy.core.symbol.Symbol'> >>> del x,y >>> x NameError: name 'x' is not defined 

Pour restaurer les valeurs des constantes standard, ainsi que les noms de certaines fonctions, vous devez recharger le module sympy.

 >>> from sympy import * 

Méthode subs (...)

Il convient de rappeler que lors de l'écriture d'une expression symbolique, sa simplification peut être effectuée automatiquement, par exemple:

 >>> a,b,c,d,x,y,z,u,v,w = symbols('abcdxyzuv w') >>> x - z + 20 -z- 15 + 3*sin(pi/2)+2*z x + 8 

La méthode subs (...) est utilisée pour calculer une expression de caractère pour des valeurs données de variables, par exemple:

 >>> a, x = symbols('a x') >>> f= a**3*x + 3*a**2*x**2/2 + a*x**3 + x**4/4 >>> f.subs(a,1) #   f   a    x**4/4 + x**3 + 3*x**2/2 + x 

Si deux arguments sont utilisés dans la méthode subs, ils sont interprétés comme subs (old, new), i.e. l'ancien identifiant old est remplacé par le nouveau new. L'argument de la méthode subs () peut être une séquence qui doit contenir des paires (anciennes, nouvelles) ou une expression symbolique, par exemple:

 >>> a,b,c,d,x,y,z = symbols('abcdxy z') >>> f=a*x**3 +b*y**2 + c*z+d >>> f.subs([(a,1),(b,2),(c,3),(d,4)]) #   a=1, b=2, c=3, d=4 x**3 + 2*y**2 + 3*z + 4 >>> pr= x**3+4*x**2+6*x+10 >>> pr.subs(x,1/x) #     10 + 6/x + 4/x**2 + x**(-3) 

Laissez-nous attirer votre attention sur la particularité suivante de travailler avec des variables (variables symboliques et ordinaires de Python). Exécutez le code suivant:

 >>> x='Hello' >>> pr=x+'world' >>> pr 'Helloworld' >>> x='AAA' #   x   >>> pr 'Helloworld' 

La règle s'applique ici: si la variable a changé, alors l'expression précédemment créée contenant cette variable n'est pas automatiquement recalculée. Cette règle fonctionne également pour les variables Python standard.

Opérations de fraction

Le module SymPy peut effectuer des calculs avec des fractions et les amener à un dénominateur commun, par exemple, comparer:

 >>> S(1)/3+S(2)/5 11/15 >>> 1/3+2/5 0.7333333333333334 

Les fonctions Rationnel (numérateur, dénominateur) et Entier (...) permettent de créer des fractions rationnelles sans arrondi décimal:

 >>> z=Rational(1, 7)+Rational(2, 5); z 19/35 >>> Integer(1)/Integer(5) 1/5 >>> 1/5 0.2 >>> z=Integer(1)/Integer(5)+Rational(2, 7); z 17/35 

Arrondir l'informatique

En informatique symbolique, la règle fonctionne - si rien n'est dit, ne arrondissez pas. Voyez comment dans le premier cas, Python transforme l'expression, mais laisse la racine carrée dans l'enregistrement de réponse et n'effectue aucun arrondi, et dans le second, étant donné que l'un des nombres est spécifié avec un point décimal, le résultat sera approximatif:

 >>> sqrt(20) 2*sqrt(5) >>> sqrt(20.0) #        4.47213595499958 

Pour tout objet caractère, il existe une méthode evalf (...) ( eval uate f loat) qui renvoie sa représentation décimale:

 >>> sqrt(20).evalf() #  sqrt()  sympy 4.47213595499958 >>> E.evalf() 2.71828182845905 

La méthode evalf ([n, ...]) peut utiliser un argument spécifiant la précision du résultat (n = le nombre de chiffres significatifs)

 >>> sqrt(20).evalf(30) 4.47213595499957939281834733746 >>> pi.evalf(20) 3.1415926535897932385 

Vous devez également toujours vous rappeler que l'arithmétique réelle ne renvoie pas un résultat exact, comparez:

 >>> from sympy import * >>> one=S('one') >>> one = cos(1)**2 + sin(1)**2 >>> one.evalf() #  1 1.00000000000000 >>> (one-1).evalf() #    0 -0.e-124 

S'il est connu que le résultat contient une erreur de calcul, vous pouvez le supprimer avec l'option chop = True de la méthode evalf () . Dans ce cas, une très petite valeur de la partie réelle ou imaginaire du résultat est remplacée par zéro. Prenons l'exemple précédent:

 >>> (one-1).evalf() #    0 -0.e-124 >>> (one - 1).evalf(chop=True) 0 

Infini

Après avoir exécuté la première ligne de sympy import * , le symbole infini oo (deux lettres «o») devient disponible, avec lequel vous pouvez également effectuer certaines opérations:

 >>> oo+1 oo >>> 1000000<oo True >>> 1/oo 0 

Le symbole infini est principalement utilisé par les fonctions limit () et integr () lors de la définition des limites d'intégration, dont nous parlerons dans l'un des articles suivants.

Conclusion

Les calculs symboliques considérés dans l'article diffèrent des méthodes numériques en ce sens que les résultats peuvent être étudiés plus en détail, par exemple, pour déterminer les extrêmes des fonctions, résoudre des équations avec des variables incorporées, etc.

J'espère que mon article sera utile à tous ceux qui s'intéressent à la programmation Python, aux étudiants et à ceux impliqués dans la recherche scientifique.