Créez l'environnement de calcul le plus puissant avec Sympy + Jupyter

Créons l'environnement de calcul le plus puissant avec Sympy + Jupyter.

Qu'est-ce que Sympy?

Sympy est une bibliothèque algébrique écrite en Python, pensez-y comme Mathematica ou Maxima. C'est plus facile à utiliser pour les programmeurs car ils peuvent écrire des formules en Python, la page ci-dessous est une excellente introduction à Sympy, si vous ne connaissez pas Sympy, veuillez la lire.

3.2. Sympy: calcul algébrique en Python

Utiliser Sympy de Jupyter

Vous n'avez rien à faire de spécial, mais tapez «magie» pour afficher les formules et les graphiques dans la première cellule de Jupyter.

from sympy import *
init_printing()

Ensuite, tapons la formule.

x = Symbol('x')
y = Symbol('y')
Rational(3 ,2)*pi + exp(I*x) / (x**2 + y)

Si la formule sort, c'est réussi.

À propos de init_session ()

D'après les informations de @ void99_, il y a quelque chose appelé ʻinit_session qui est plus sophistiqué que ʻinit_printing.

from sympy import *
init_session()

Les variables et fonctions fréquemment utilisées sont prédéfinies, ce qui est pratique.

IPython console for SymPy 1.0 (Python 3.5.2-64-bit) (ground types: python)

These commands were executed:
>>> from __future__ import division
>>> from sympy import *
>>> x, y, z, t = symbols('x y z t')
>>> k, m, n = symbols('k m n', integer=True)
>>> f, g, h = symbols('f g h', cls=Function)
>>> init_printing()

Documentation can be found at http://docs.sympy.org/1.0/

Paramètres des symboles

Les symboles de formule peuvent être définis avec «Symbole».

x = Symbol('x')
y = Symbol('y')

Plusieurs symboles peuvent être définis à la fois à l'aide de «symboles».

x, y = symbols("x y")

Il peut également être défini en utilisant le module sympy.abc.

from sympy.abc import x, y

Simplification des formules

La fonction la plus pratique lorsque vous la manipulez comme une calculatrice est de simplifier la formule. Si vous pétrissez la formule, vous pouvez créer une formule très longue, mais si vous utilisez Sympy, c'est un seul coup.

Par exemple, supposons que vous ayez la formule suivante: Cette formule est probablement une formule de courbe de Bézier ou quelque chose que j'ai malaxé.

(A-B)*C + B**2 + (-B-A)*C + B**2

Écrit en Sympy, il ressemble à ceci:

from sympy.abc import A, B, C
f = (A-B)*C + B**2 + (-B-A)*C + B**2

2 B^{2} + C \left(- A - B\right) + C \left(A - B\right)

La substitution d'une expression dans Sympy triera les termes pour plus de clarté. Si vous souhaitez simplifier davantage la formule, utilisez simpfly.

simplify(f)

2 B \left(B - C\right)

«A» a disparu et c'est devenu extrêmement simple. Vous pouvez également utiliser ratsimp, qui est souvent utilisé dans Maxima.

ratsimp(f)

2 B^{2} - 2 B C

Il existe de nombreux types de simplifications de formules, voir ci-dessous pour plus de détails.

http://docs.sympy.org/dev/modules/simplify/simplify.html

Résous l'équation

from sympy.abc import A, B, C, D

(A-B)*D + C**2 + (-B-A)*C+B**2

B^{2} + C^{2} + C \left(- A - B\right) + D \left(A - B\right)

Si vous voulez résoudre «A» dans la formule ci-dessus, utilisez «résoudre».

solve((A-B)*D + C**2 + (-B-A)*C+B**2, A)

\left [ \frac{1}{C - D} \left(B^{2} - B C - B D + C^{2}\right)\right ]

Attribuer une valeur à une variable dans une expression

Vous pouvez affecter une valeur à une variable dans une expression avec subs.

f = (A-B)*D + C**2 + (-B-A)*C+B**2

# A,B,Attribuer une valeur à C
f.subs([(A, 10), (B, 20), (C, 30)])

- 10 D + 400

L'argument de subs peut également être passé dans un dictionnaire.

f.subs({A: 10, B: 20, C: 30})

- 10 D + 400

S'il n'y a qu'une seule variable que vous souhaitez affecter, vous pouvez spécifier une variable dans le premier argument et une valeur dans le second argument.

f.subs(A, 10)

B^{2} + C^{2} + C \left(- B - 10\right) + D \left(- B + 10\right)

Différenciation / différenciation partielle

Utilisez diff pour la différenciation / la différenciation partielle.

diff(x**2 + 3*x + 100)

2 x + 3

Pour une différenciation partielle, spécifiez le deuxième argument.

diff(3*x**2 + 3*x*y + y**2, x)

6 x + 3 y

Affacturage / Affacturage Prime

L'affacturage utilise «factor».

factor(x**2-x-6)

\left(x - 3\right) \left(x + 2\right)

Utilisez factor int pour la factorisation des nombres premiers.

factorint(3417)
>>> {3:1,17:1,67:1}

Le dictionnaire est renvoyé, ce qui signifie «3 ^ 1 * 17 ^ 1 * 67 ^ 1 = 3417».

Matrice / vecteur

Utilisez la classe Matrix.

Matrix([[1, 0], [0, 1]])

\left[\begin{matrix}1 & 0\\0 & 1\end{matrix}\right]

Il existe des vecteurs, mais ils sont difficiles à utiliser, ils sont donc traités comme une matrice à une colonne.

θ = Symbol("θ")

P = Matrix([2*cos(θ), 2*sin(θ)])

\left[\begin{matrix}2 \cos{\left (θ \right )}\\2 \sin{\left (θ \right )}\end{matrix}\right]

Si vous voulez calculer un vecteur, utilisez la fonction transpose pour le transposer.

transpose(P) * P

\left[\begin{matrix}4 \sin^{2}{\left (θ \right )} + 4 \cos^{2}{\left (θ \right )}\end{matrix}\right]

Copiez et collez des formules dans Latex

Avec Jupyter et Sympy, vous pouvez facilement copier les formules de sortie dans Qiita. Cliquez avec le bouton droit sur la formule et sélectionnez Afficher les mathématiques comme → Commandes Tex.

Un pop-up comme celui-ci apparaîtra, alors copiez et collez la formule.

Ce Latex est pratique car il peut être collé directement sur Qiita.

Formule de sortie avec AA

Si vous utilisez pprint, est-ce de l'art ASCII? Vous pouvez également générer des formules avec.

pprint(Integral(sqrt(1/x), x), use_unicode=True)
"""
⌠           
⎮     ___   
⎮    ╱ 1    
⎮   ╱  ─  dx
⎮ ╲╱   x    
⌡  
"""

Il est pratique de coller des formules dans le code source.

Ecrire un graphique

Vous pouvez dessiner un graphique avec sympy.plotting.plot. C'est pratique car vous pouvez passer la formule de Sympy telle quelle en argument.

from sympy.plotting import plot

y = -(x+2)*(x+1)*(x-1)

#x est-Tracez un graphique de 4 à 4
plot(y, (x, -4, 4))

Démarrez rapidement avec un modèle .ipynb

Jupyter + Sympy est très pratique, mais vous devez taper «magic» à chaque fois dans la première cellule. C'est étonnamment gênant, n'est-ce pas?

Dans mon article, il y a Generate Jupyter notebook ".ipynb" in Python. En utilisant ceci, écrivons un script qui génère ipynb qui a été entré depuis le début.

Coopération entre Jupyter et PyCharm

PyCharm est un environnement de développement intégré (IDE) Python, qui possède des fonctions complémentaires très puissantes et est l'environnement de développement Python le plus puissant. En fait, PyCharm peut être lié à Jupyter, et le pouvoir expressif de Jupyter + la puissante fonction complémentaire de PyCharm est assez confortable.

Cependant, lorsqu'il s'agit de formules mathématiques, la sortie Jupyter de PyCharm est médiocre, il est donc préférable d'utiliser la version navigateur de Jupyter. Donc je n'utilise pas Jupyter de PyCharm, j'utilise plutôt ʻExtranal Tools`.

Créer un script de génération .ipynb

Créez le script suivant à un endroit facile à consulter.

#!/usr/bin/env python3
# coding:utf-8
import sys
import os
import nbformat

output_dir = sys.argv[1]
output_file = input("input ipynb name:")

nb = nbformat.v4.new_notebook()

title = "#Titre"

code = """
%matplotlib inline
from sympy import *
init_session()
"""

nb["cells"] = [
    nbformat.v4.new_markdown_cell(title),
    nbformat.v4.new_code_cell(code)
]

if not output_file.endswith(".ipynb"):
    output_file += ".ipynb"

with open(os.path.join(output_dir, output_file), "w") as f:
    nbformat.write(nb, f)

print("ok.")

S'inscrire en tant qu'outil externe pour PyCharm

Ouvrez le menu "Fichier (F)" de PyCharm et sélectionnez "Paramètres ...".

Sélectionnez "Outils" -> "Outils externes" dans la boîte de dialogue des paramètres et appuyez sur le bouton "+".

La boîte de dialogue de configuration apparaîtra, alors ajoutez les éléments suivants.

.Ipynb peut maintenant être généré à partir du menu contextuel de PyCharm!

Sélectionnez "External Toos" -> "Registered Tool Name" dans le menu contextuel de PyCharm.

Lorsque vous entrez le nom du fichier dans la console, divers fichiers .ipynb pré-remplis seront générés depuis le début.

Si vous avez un moyen plus pratique de l'utiliser, veuillez le poster.

Épilogue

La sortie de .ipynb était plus longue que Sympy, mais Sympy est très utile.

Idéal pour les programmeurs de jeux et ceux qui utilisent des formules. C'est une bibliothèque que les personnes qui ne sont pas douées en mathématiques devraient absolument utiliser.