SymPy-クイックガイド

SymPyは、記号計算を実行するためのPythonライブラリです。それはcomputer algebra system（CAS）スタンドアロンアプリケーションとして、または他のアプリケーションへのライブラリとして使用できます。そのライブセッションは、https://live.sympy.org/。純粋なPythonライブラリであるため、インタラクティブモードおよびプログラムアプリケーションとして使用できます。SymPyは現在、科学的なPythonエコシステムの人気のあるシンボリックライブラリになっています。

SymPyには、基本的な記号演算、微積分、代数、離散数学、量子物理学などの分野で適用できる幅広い機能があります。SymPyは、LaTeX、MathMLなどのさまざまな形式で結果をフォーマットできます。SymPyは新しいBSDライセンス。が率いる開発者のチームOndřej Čertík そして Aaron Meurer 2007年にSymPyの最初のバージョンを公開しました。現在のバージョンは1.5.1です。

SymPyのアプリケーションのいくつかの分野は次のとおりです。

• Polynomials
• Calculus
• 離散数学
• Matrices
• Geometry
• Plotting
• Physics
• Statistics
• Combinatorics

SymPyには1つの重要な前提条件ライブラリがあります mpmath。これは、任意精度の実数および複素数の浮動小数点演算用のPythonライブラリです。ただし、PythonのパッケージインストーラーPIPは、SymPyが次のようにインストールされると、自動的にインストールされます。

pip install sympy

Anaconda、Enthought Canopyなどの他のPythonディストリビューションには、SymPyがすでにバンドルされている場合があります。確認するには、Pythonプロンプトに次のように入力します-

>>> import sympy
>>> sympy.__version__

そして、sympyの現在のバージョンとして以下の出力が得られます-

'1.5.1'

SymPyパッケージのソースコードは次のURLで入手できます。 https://github.com/sympy/sympy。

記号計算とは、数式やその他の数学的対象を操作するためのアルゴリズムの開発を指します。記号計算は、数学とコンピュータサイエンスを統合して、数学記号を使用して数式を解きます。SymPyなどの数式処理システム（CAS）は、従来の手動による方法で使用されているのと同じ記号を使用して、代数式を正確に（概算ではなく）評価します。たとえば、Pythonの数学モジュールを使用して数値の平方根を次のように計算します-

>>> import math 
>>> print (math.sqrt(25), math.sqrt(7))

上記のコードスニペットの出力は次のとおりです-

5.0 2.6457513110645907

ご覧のとおり、7の平方根はおおよそ計算されます。しかし、SymPyでは、完全な平方ではない数の平方根は、以下に示すように、デフォルトでは評価されないままになっています。

>>> import sympy 
>>> print (sympy.sqrt(7))

上記のコードスニペットの出力は次のとおりです-

sqrt(7)

以下のコードスニペットを使用して、式の結果を簡略化してシンボリックに表示することができます。

>>> import math
>>> print (math.sqrt(12))

上記のコードスニペットの出力は次のとおりです-

3.4641016151377544

sympy −を使用して同じものを実行するには、以下のコードスニペットを使用する必要があります。

##sympy output 
>>> print (sympy.sqrt(12))

そしてそのための出力は次のとおりです-

2*sqrt(3)

SymPyコードをJupyterノートブックで実行すると、MathJaxライブラリを使用して数学記号をLatEx形式でレンダリングします。以下のコードスニペットに示されています-

>>> from sympy import * 
>>> x=Symbol ('x') 
>>> expr = integrate(x**x, x) 
>>> expr

上記のコマンドをPythonシェルで実行すると、次の出力が生成されます-

Integral(x**x, x)

これは

$\int \mathrm{x}^{x}\,\mathrm{d}x$

不完全な正方形の平方根は、従来の記号を使用して次のようにラテックスで表すことができます-

>>> from sympy import * 
>>> x=7 
>>> sqrt(x)

上記のコードスニペットの出力は次のとおりです-

$\sqrt7$

SymPyなどの記号計算システムは、あらゆる種類の計算（導関数、積分、極限、方程式の解法、行列の操作など）を記号的に実行します。SymPyパッケージには、プロット、印刷（LATEXなど）、物理学、統計、組み合わせ論、数論、幾何学、論理などをサポートするさまざまなモジュールがあります。

SymPyパッケージのコアモジュールには、原子番号を表すNumberクラスが含まれています。このクラスには、FloatクラスとRationalクラスの2つのサブクラスがあります。Rationalクラスは、Integerクラスによってさらに拡張されます。

Floatクラスは、任意精度の浮動小数点数を表します。

>>> from sympy import Float 
>>> Float(6.32)

上記のコードスニペットの出力は次のとおりです-

6.32

SymPyは整数または文字列をfloatに変換できます。

>>> Float(10)

10.0

Float('1.33E5')# scientific notation

133000.0

floatに変換する際に、以下のように精度のために桁数を指定することもできます。

>>> Float(1.33333,2)

上記のコードスニペットの出力は次のとおりです-

1.3

数の表現（p / q）は、qがゼロ以外の数であるRationalクラスのオブジェクトとして表されます。

>>> Rational(3/4)

上記のコードスニペットの出力は次のとおりです-

$\frac{3}{4}$

浮動小数点数がRational（）コンストラクターに渡されると、2進表現の基礎となる値が返されます。

>>> Rational(0.2)

上記のコードスニペットの出力は次のとおりです-

$\frac{3602879701896397}{18014398509481984}$

表現を簡単にするために、分母の制限を指定します。

>>> Rational(0.2).limit_denominator(100)

上記のコードスニペットの出力は次のとおりです-

$\frac{1}{5}$

文字列がRational（）コンストラクターに渡されると、任意精度の有理数が返されます。

>>> Rational("3.65")

上記のコードスニペットの出力は次のとおりです-

$\frac{73}{20}$

2つの数値引数が渡された場合にも有理数オブジェクトを取得できます。分子と分母の部分はプロパティとして利用できます。

>>> a=Rational(3,5) 
>>> print (a) 
>>> print ("numerator:{}, denominator:{}".format(a.p, a.q))

上記のコードスニペットの出力は次のとおりです-

3/5

numerator:3, denominator:5

>>> a

上記のコードスニペットの出力は次のとおりです-

$\frac{3}{5}$

SymPyの整数クラスは、任意のサイズの整数を表します。コンストラクターはFloatまたはRational番号を受け入れることができますが、小数部分は破棄されます

>>> Integer(10)

上記のコードスニペットの出力は次のとおりです-

10

>>> Integer(3.4)

上記のコードスニペットの出力は次のとおりです-

3

>>> Integer(2/7)

上記のコードスニペットの出力は次のとおりです-

0

SymPyには RealNumberFloatのエイリアスとして機能するクラス。SymPyはまた、以下に示すように、ゼロとワンをそれぞれS.ZeroとS.Oneでアクセス可能なシングルトンクラスとして定義します。

>>> S.Zero

出力は次のとおりです-

0

>>> S.One

出力は次のとおりです-

1

その他の事前定義されたシングルトン数オブジェクトは、Half、NaN、Infinity、およびImaginaryUnitです。

>>> from sympy import S 
>>> print (S.Half)

出力は次のとおりです-

½

>>> print (S.NaN)

出力は次のとおりです-

nan

Infinityは、ooシンボルオブジェクトまたはS.Infinityとして使用できます。

>>> from sympy import oo 
>>> oo

上記のコードスニペットの出力は次のとおりです-

$\infty$

>>> S.Infinity

上記のコードスニペットの出力は次のとおりです-

$\infty$

ImaginaryUnit番号は、Iシンボルとしてインポートするか、S.ImaginaryUnitとしてアクセスでき、-1の平方根を表します。

>>> from sympy import I 
>>> I

上記のコードスニペットを実行すると、次の出力が得られます-

i

>>> S.ImaginaryUnit

上記のスニペットの出力は次のとおりです-

i

>>> from sympy import sqrt 
>>> i=sqrt(-1) 
>>> i*i

上記のコードスニペットを実行すると、次の出力が得られます-

-1

SymbolsymPyライブラリで最も重要なクラスです。前述のように、記号計算は記号を使用して行われます。SymPy変数はSymbolsクラスのオブジェクトです。

Symbol（）関数の引数は、変数に割り当てることができるシンボルを含む文字列です。

>>> from sympy import Symbol 
>>> x=Symbol('x') 
>>> y=Symbol('y') 
>>> expr=x**2+y**2 
>>> expr

上記のコードスニペットは、以下の式と同等の出力を提供します-

$x^2 + y^2$

記号は複数のアルファベットで構成されている場合があります。

>>> s=Symbol('side') 
>>> s**3

上記のコードスニペットは、以下の式と同等の出力を提供します-

$side^3$

SymPyには Symbols()一度に複数のシンボルを定義できる関数。文字列には、コンマまたはスペースで区切られた変数の名前が含まれます。

>>> from sympy import symbols 
>>> x,y,z=symbols("x,y,z")

SymPyのabcモジュールでは、すべてのラテン語とギリシャ語のアルファベットが記号として定義されています。したがって、Symbolオブジェクトをインスタンス化する代わりに、このメソッドが便利です。

>>> from sympy.abc import x,y,z

しかし、名前は C, O, S, I, N, E そして Q事前定義されたシンボルです。また、複数のアルファベットを含むシンボルはabcモジュールで定義されていないため、上記のようにSymbolオブジェクトを使用する必要があります。abcモジュールは、デフォルトのSymPy名前空間の定義を検出できる特別な名前を定義します。clash1には単一文字が含まれ、clash2には複数文字の衝突記号が含まれます

>>> from sympy.abc import _clash1, _clash2 
>>> _clash1

上記のスニペットの出力は次のとおりです-

{'C': C, 'O': O, 'Q': Q, 'N': N, 'I': I, 'E': E, 'S': S}

>>> _clash2

上記のスニペットの出力は次のとおりです-

{'beta': beta, 'zeta': zeta, 'gamma': gamma, 'pi': pi}

インデックス付きシンボルは、range（）関数と同様の構文を使用して定義できます。範囲はコロンで示されます。範囲のタイプは、コロンの右側の文字によって決まります。itrが数字の場合、左側のすべての連続する数字が非負の開始値と見なされます。右側のすべての連続する数字は、終了値より1大きいものと見なされます。

>>> from sympy import symbols 
>>> symbols('a:5')

上記のスニペットの出力は次のとおりです-

(a0, a1, a2, a3, a4)

>>> symbols('mark(1:4)')

上記のスニペットの出力は次のとおりです-

(mark1, mark2, mark3)

数式に対して実行される最も基本的な操作の1つは、置換です。SymPyのsubs（）関数は、最初のパラメーターのすべての出現箇所を2番目のパラメーターに置き換えます。

>>> from sympy.abc import x,a 
>>> expr=sin(x)*sin(x)+cos(x)*cos(x) 
>>> expr

上記のコードスニペットは、以下の式と同等の出力を提供します-

$\sin^2(x)+\cos^2(x)$

>>> expr.subs(x,a)

上記のコードスニペットは、以下の式と同等の出力を提供します-

$\sin^2(a)+\cos^2(a)$

この関数は、特定の式を評価する場合に役立ちます。たとえば、aを5に置き換えて、次の式の値を計算します。

>>> expr=a*a+2*a+5 
>>> expr

上記のコードスニペットは、以下の式と同等の出力を提供します-

$a^2 + 2a + 5$

expr.subs(a,5)

上記のコードスニペットは、次の出力を提供します-

40

>>> from sympy.abc import x 
>>> from sympy import sin, pi 
>>> expr=sin(x) 
>>> expr1=expr.subs(x,pi) 
>>> expr1

上記のコードスニペットは、次の出力を提供します-

0

この関数は、部分式を別の部分式に置き換えるためにも使用されます。次の例では、bはa + bに置き換えられています。

>>> from sympy.abc import a,b 
>>> expr=(a+b)**2 
>>> expr1=expr.subs(b,a+b) 
>>> expr1

上記のコードスニペットは、以下の式と同等の出力を提供します-

$(2a + b)^2$

sympify（）関数は、SymPy式として使用できるように任意の式を変換するために使用されます。整数オブジェクトなどの通常のPythonオブジェクトはSymPyで変換されます。整数などの文字列もSymPy式に変換されます。

>>> expr="x**2+3*x+2" 
>>> expr1=sympify(expr) 
>>> expr1 
>>> expr1.subs(x,2)

上記のコードスニペットは、次の出力を提供します-

12

すべてのPythonオブジェクトをSymPyオブジェクトに変換できます。ただし、変換では内部的にeval（）関数が使用されるため、サニタイズされていない式は使用しないでください。使用しないと、SympifyErrorが発生します。

>>> sympify("x***2")
---------------------------------------------------------------------------

SympifyError：例外が発生したため、式 'の構文解析ができませんでした' x *** 2 ''が失敗しました。

sympify（）関数は次の引数を取ります：* strict：デフォルトはFalseです。Trueに設定すると、明示的な変換が定義されているタイプのみが変換されます。それ以外の場合、SympifyErrorが発生します。*評価：Falseに設定すると、算術演算子と演算子は、式を評価せずに同等のSymPyに変換されます。

>>> sympify("10/5+4/2")

上記のコードスニペットは、次の出力を提供します-

4

>>> sympify("10/5+4/2", evaluate=False)

上記のコードスニペットは、次の出力を提供します-

$\frac{10}{5}+\frac{4}{2}$

この関数は、100桁までの特定の浮動小数点精度まで、特定の数式を評価します。この関数は、シンボルの数値の辞書オブジェクトであるsubsパラメーターも受け取ります。次の式を検討してください

>>> from sympy.abc import r 
>>> expr=pi*r**2 
>>> expr

上記のコードスニペットは、以下の式と同等の出力を提供します-

$\Pi{r^2}$

rを5に置き換えて、evalf（）関数を使用して上記の式を評価するには

>>> expr.evalf(subs={r:5})

上記のコードスニペットは、次の出力を提供します-

78.5398163397448

デフォルトでは、浮動小数点の精度は最大15桁であり、最大100の任意の数値でオーバーライドできます。次の式は最大20桁の精度で評価されます。

>>> expr=a/b 
>>> expr.evalf(20, subs={a:100, b:3})

上記のコードスニペットは、次の出力を提供します-

33.333333333333333333

lambdify関数は、SymPy式をPython関数に変換します。式を広範囲の値で評価する場合、evalf（）関数は効率的ではありません。lambdifyはラムダ関数のように機能しますが、SymPy名を指定された数値ライブラリ（通常はNumPy）の名前に変換する点が異なります。デフォルトでは、数学標準ライブラリの実装をlambdifyします。

>>> expr=1/sin(x) 
>>> f=lambdify(x, expr) 
>>> f(3.14)

上記のコードスニペットは、次の出力を提供します-

627.8831939138764

式には複数の変数が含まれる場合があります。その場合、lambdify（）関数の最初の引数は変数のリストであり、その後に評価される式が続きます。

>>> expr=a**2+b**2 
>>> f=lambdify([a,b],expr) 
>>> f(2,3)

上記のコードスニペットは、次の出力を提供します-

13

ただし、numpyライブラリを数値バックエンドとして活用するには、lambdify（）関数の引数と同じものを定義する必要があります。

>>> f=lambdify([a,b],expr, "numpy")

上記の関数では、2つの引数aとbに2つのnumpy配列を使用します。numpy配列の場合、実行時間はかなり高速です。

>>> import numpy 
>>> l1=numpy.arange(1,6) 
>>> l2=numpy.arange(6,11) 
>>> f(l1,l2)

上記のコードスニペットは、次の出力を提供します-

array([ 37, 53, 73, 97, 125], dtype=int32)

ブール関数はで定義されています sympy.basic.booleanarg module。標準のPython演算子＆（And）、|を使用してブール式を作成することができます。（または）、〜（ない）および>>と<<。ブール式は、SymPyのコアモジュールで定義されたBasicクラスを継承します。

BooleanTrue関数

この関数は、コアPythonの場合と同様にTrueと同等です。S.trueで取得できるシングルトンを返します。

>>> from sympy import * 
>>> x=sympify(true) 
>>> x, S.true

上記のコードスニペットは、次の出力を提供します-

（True、True）

BooleanFalse関数

同様に、この関数はPythonのブールFalseと同等であり、S.falseからアクセスできます。

>>> from sympy import * 
>>> x=sympify(false) 
>>> x, S.false

上記のコードスニペットは、次の出力を提供します-

（偽、偽）

そして機能

論理AND関数は、その2つの引数を評価し、どちらかがFalseの場合はFalseを返します。この関数は＆演算子をエミュレートします。

>>> from sympy import * 
>>> from sympy.logic.boolalg import And 
>>> x,y=symbols('x y') 
>>> x=True 
>>> y=True 
>>> And(x,y), x"&"y

上記のコードスニペットは、次の出力を提供します-

（True、True）

>>> y=False 
>>> And(x,y), x"&"y

上記のコードスニペットは、次の出力を提供します-

（偽、偽）

または機能

この関数は、2つのブール引数を評価し、どちらかがTrueの場合にTrueを返します。| 演算子は、その動作を便利にエミュレートします。

>>> from sympy import * 
>>> from sympy.logic.boolalg import Or 
>>> x,y=symbols('x y') 
>>> x=True 
>>> y=False 
>>> Or(x,y), x|y

上記のコードスニペットは、次の出力を提供します-

（True、True）

>>> x=False 
>>> y=False 
>>> Or(x,y), x|y

上記のコードスニペットは、次の出力を提供します-

（偽、偽）

機能しない

論理Not関数を使用すると、ブール引数が否定されます。引数がFalseの場合はTrueを返し、Trueの場合はFalseを返します。〜演算子は、Not関数と同様の操作を実行します。以下の例に示します-

>>> from sympy import * 
>>> from sympy.logic.boolalg import Or, And, Not 
>>> x,y=symbols('x y') 
>>> x=True 
>>> y=False 
>>> Not(x), Not(y)

上記のコードスニペットは、次の出力を提供します-

（真偽）

>>> Not(And(x,y)), Not(Or(x,y))

上記のコードスニペットは、次の出力を提供します-

（真/偽）

Xor関数

論理XOR（排他的論理和）関数は、奇数の引数がTrueで残りがFalseの場合にTrueを返し、偶数の引数がTrueで残りがFalseの場合にFalseを返します。同様の操作は^演算子によって実行されます。

>>> from sympy import * 
>>> from sympy.logic.boolalg import Xor 
>>> x,y=symbols('x y') 
>>> x=True 
>>> y=False

>>> Xor(x,y), x^y

上記のコードスニペットは、次の出力を提供します-

（True、True）

>>> a,b,c,d,e=symbols('a b c d e') 
>>> a,b,c,d,e=(True, False, True, True, False) 
>>> Xor(a,b,c,d,e)

上記のコードスニペットは、次の出力を提供します-

本当

上記の場合、3つの（奇数）引数がTrueであるため、Xorはtrueを返します。ただし、True引数の数が偶数の場合、以下に示すようにFalseになります。

>>> a,b,c,d,e=(True, False, False, True, False) 
>>> Xor(a,b,c,d,e)

上記のコードスニペットは、次の出力を提供します-

誤り

ナンド関数

この関数は論理NAND演算を実行します。引数を評価し、いずれかがFalseの場合はTrueを返し、すべてTrueの場合はFalseを返します。

>>> from sympy import * 
>>> from sympy.logic.boolalg import Nand 
>>> a,b,c=symbols('a b c') 
>>> a,b,c=(True, False, True) 
>>> Nand(a,b,c), Nand(a,c)

上記のコードスニペットは、次の出力を提供します-

（真/偽）

機能も機能も

この関数は論理NOR演算を実行します。引数を評価し、いずれかがTrueの場合はFalseを返し、すべてFalseの場合はTrueを返します。

>>> from sympy import * 
>>> from sympy.logic.boolalg import Nor 
>>> a,b,c=symbols('a b c') 
>>> a,b,c=(True, False, True) 
>>> Nor(a,b,c), Nor(a,c)

上記のコードスニペットは、次の出力を提供します-

（偽、偽）

SymPyはXorに^演算子を提供しますが、Notには〜を提供することに注意してください。便宜上、Orおよび＆for And関数の場合、Pythonでの通常の使用はビット演算子です。したがって、オペランドが整数の場合、結果は異なります。

同等の機能

この関数は、同値関係を返します。Equivalent（A、B）は、AとBが両方ともTrueまたは両方がFalseである場合にのみ、Trueになります。すべての引数が論理的に同等である場合、関数はTrueを返します。それ以外の場合はFalseを返します。

>>> from sympy import * 
>>> from sympy.logic.boolalg import Equivalent 
>>> a,b,c=symbols('a b c') 
>>> a,b,c=(True, False, True) 
>>> Equivalent(a,b), Equivalent(a,c)

上記のコードスニペットは、次の出力を提供します-

（真偽）

ITE機能

この関数は、プログラミング言語のIf then else句として機能します。ITE（A、B、C）は、Aがtrueの場合はBの結果を評価して返し、それ以外の場合はCの結果を返します。すべての引数はブール値である必要があります。

>>> from sympy import * >>> from sympy.logic.boolalg import ITE >>> a,b,c=symbols('a b c') >>> a,b,c=(True, False, True) 
>>> ITE(a,b,c), ITE(a,c,b)

上記のコードスニペットは、次の出力を提供します-

（真偽）

SymPyパッケージの仮定モジュールには、式に関する情報を抽出するためのツールが含まれています。このモジュールは、この目的のためにask（）関数を定義します。

sympy.assumptions.ask(property)

次のプロパティは、式に関する有用な情報を提供します-

algebraic(x)

代数的であるためには、数は有理係数を持つ非ゼロ多項式の根でなければなりません。√2はx2− 2 = 0の解であるため、√2は代数的です。

complex(x)

複素数述語。xが複素数のセットに属している場合にのみ当てはまります。

composite(x)

ask（Q.composite（x））によって返される合成数述語は、xが正の整数であり、1と数自体以外に少なくとも1つの正の約数がある場合にのみ真になります。

even, odd

ask（）は、xが偶数のセットと奇数のセットにそれぞれ含まれている場合にtrueを返します。

imaginary

このプロパティは、虚数述語を表します。xを実数に虚数単位Iを掛けたものとして書くことができれば真実です。

integer

Q.integer（x）によって返されるこのプロパティは、偶数のセットに属するxのtrueを返します。

rational, irrational

Q.irrational（x）は、xが整数の比率として表現できない実数である場合にのみ真になります。たとえば、円周率は無理数です。

positive, negative

数値が正か負かを確認するための述語

zero, nonzero

数値がゼロかどうかを確認するための述語

>>> from sympy import * 
>>> x=Symbol('x') 
>>> x=10 
>>> ask(Q.algebraic(pi))
False
>>> ask(Q.complex(5-4*I)), ask( Q.complex(100))
(True, True)
>>> x,y=symbols("x y") 
>>> x,y=5,10 
>>> ask(Q.composite(x)), ask(Q.composite(y))
(False, True)
>>> ask(Q.even(x)), ask(Q.even(y))
(False, True)
>>> x,y= 2*I, 4+5*I 
>>> ask(Q.imaginary(x)), ask(Q.imaginary(y))
(True, False)
>>> x,y=5,10 
>>> ask(Q.even(x)), ask(Q.even(y)), ask(Q.odd(x)), ask(Q.odd(y))
(False, True, True, False)
>>> x,y=5,-5 
>>> ask(Q.positive(x)), ask(Q.negative(y)), ask(Q.positive(x)), ask(Q.negative(y))
(True, True, True, True)
>>> ask(Q.rational(pi)), ask(Q.irrational(S(2)/3))
(False, False)
>>> ask(Q.zero(oo)), ask(Q.nonzero(I))
(False, False)

Sympyには、数式を単純化する強力な機能があります。SymPyには、さまざまな種類の単純化を実行するための多くの関数があります。simple（）と呼ばれる一般的な関数は、式の最も単純な形式に到達しようとします。

簡略化する

この関数はsympy.simplifyモジュールで定義されています。simple（）は、インテリジェントなヒューリスティックを適用して、入力式を「より単純」にしようとします。次のコードは、式を単純化することを示しています$sin^2(x)+cos^2(x)$。

>>> from sympy import * 
>>> x=Symbol('x')
>>> expr=sin(x)**2 + cos(x)**2 
>>> simplify(expr)

上記のコードスニペットは、次の出力を提供します-

1

展開

expand（）は、SymPyで最も一般的な単純化関数の1つであり、多項式の展開に使用されます。例-

>>> a,b=symbols('a b') 
>>> expand((a+b)**2)

上記のコードスニペットは、以下の式と同等の出力を提供します-

$a^2 + 2ab + b^2$

>>> expand((a+b)*(a-b))

上記のコードスニペットは、以下の式と同等の出力を提供します-

$a^2 - b^2$

expand（）関数は、式を小さくするのではなく大きくします。通常はこれが当てはまりますが、expand（）を呼び出すと、式が小さくなることがよくあります。

>>> expand((x + 1)*(x - 2) - (x - 1)*x)

上記のコードスニペットは、次の出力を提供します-

-2

因子

この関数は多項式を取り、それを有理数の既約因子に因数分解します。

>>> x,y,z=symbols('x y z') 
>>> expr=(x**2*z + 4*x*y*z + 4*y**2*z) 
>>> factor(expr)

上記のコードスニペットは、以下の式と同等の出力を提供します-

$z(x + 2y)^2$

>>> factor(x**2+2*x+1)

上記のコードスニペットは、以下の式と同等の出力を提供します-

$(x + 1)^2$

factor（）関数はexpand（）の反対です。factor（）によって返される各因子は、既約であることが保証されています。factor_list（）関数は、より構造化された出力を返します。

>>> expr=(x**2*z + 4*x*y*z + 4*y**2*z) 
>>> factor_list(expr)

上記のコードスニペットは、以下の式と同等の出力を提供します-

(1, [(z, 1), (x + 2*y, 2)])

収集する

この関数は、有理指数の累乗までの式のリストに関して、式の追加の項を収集します。

>>> expr=x*y + x - 3 + 2*x**2 - z*x**2 + x**3 
>>> expr

上記のコードスニペットは、以下の式と同等の出力を提供します-

$x^3 + x^2z + 2x^2 + xy + x - 3$

この式のcollect（）関数は、次のようになります。

>>> collect(expr,x)

上記のコードスニペットは、以下の式と同等の出力を提供します-

$x^3 + x^2(2 - z) + x(y + 1) - 3$

>>> expr=y**2*x + 4*x*y*z + 4*y**2*z+y**3+2*x*y 
>>> collect(expr,y)

上記のコードスニペットは、以下の式と同等の出力を提供します-

$Y^3+Y^2(x+4z)+y(4xz+2x)$

キャンセル

cancel（）関数は、任意の有理関数を取り、それを標準の正規形式p / qに入れます。ここで、pとqは、共通因子のない展開された多項式です。pとqの先行係数には分母がありません。つまり、整数です。

>>> expr1=x**2+2*x+1 
>>> expr2=x+1 
>>> cancel(expr1/expr2)

上記のコードスニペットは、以下の式と同等の出力を提供します-

$x+1$

>>> expr = 1/x + (3*x/2 - 2)/(x - 4) 
>>> expr

上記のコードスニペットは、以下の式と同等の出力を提供します-

$\frac{\frac{3x}{2} - 2}{x - 4} + \frac{1}{x}$

>>> cancel(expr)

上記のコードスニペットは、以下の式と同等の出力を提供します-

$\frac{3x^2 - 2x - 8}{2x^2 - 8}$

>>> expr=1/sin(x)**2 
>>> expr1=sin(x) 
>>> cancel(expr1*expr)

上記のコードスニペットは、以下の式と同等の出力を提供します-

$\frac{1}{\sin(x)}$

trigsimp

この関数は、三角関数式のアイデンティティを単純化するために使用されます。逆三角関数の命名規則は、関数の名前の前にaを追加することであることに注意してください。たとえば、逆コサインまたはアークコサインはacos（）と呼ばれます。

>>> from sympy import trigsimp, sin, cos 
>>> from sympy.abc import x, y
>>> expr = 2*sin(x)**2 + 2*cos(x)**2 
>>> trigsimp(expr)

2

trigsimp関数は、ヒューリスティックを使用して、最適な三角関数の恒等式を適用します。

powersimp

この関数は、べき乗を類似の基数および指数と組み合わせることにより、与えられた式を減らします。

>>> expr=x**y*x**z*y**z 
>>> expr

上記のコードスニペットは、以下の式と同等の出力を提供します-

$x^y x^z y^z$

>>> powsimp(expr)

上記のコードスニペットは、以下の式と同等の出力を提供します-

$x^{y+z} y^z$

Combine = 'base'またはcombine = 'exp'を変更することにより、powsimp（）にベースのみを結合するか、指数のみを結合させることができます。デフォルトでは、combine = 'all'であり、両方を実行します。forceがTrueの場合、ベースは仮定をチェックせずに結合されます。

>>> powsimp(expr, combine='base', force=True)

上記のコードスニペットは、以下の式と同等の出力を提供します-

$x^y(xy)^z$

コームシンプ

階乗二項式を含む組み合わせ式は、combsimp（）関数を使用して簡略化できます。SymPyはfactorial（）関数を提供します

>>> expr=factorial(x)/factorial(x - 3) 
>>> expr

上記のコードスニペットは、以下の式と同等の出力を提供します-

$\frac{x!}{(x - 3)!}$

上記の組み合わせ式を単純化するために、combsimp（）関数を次のように使用します。

>>> combsimp(expr)

上記のコードスニペットは、以下の式と同等の出力を提供します-

$x(x-2)(x-1)$

binomial（x、y）は、x個の個別のアイテムのセットからy個のアイテムを選択する方法の数です。また、xCyと書かれることもよくあります。

>>> binomial(x,y)

上記のコードスニペットは、以下の式と同等の出力を提供します-

$(\frac{x}{y})$

>>> combsimp(binomial(x+1, y+1)/binomial(x, y))

上記のコードスニペットは、以下の式と同等の出力を提供します-

$\frac{x + 1}{y + 1}$

logcombine

この関数は対数を取り、次のルールを使用してそれらを結合します-

• log（x）+ log（y）== log（x * y）両方が正の場合
• a * log（x）== log（x ** a）xが正で、aが実数の場合

>>> logcombine(a*log(x) + log(y) - log(z))

上記のコードスニペットは、以下の式と同等の出力を提供します-

$a\log(x) + \log(y) - \log(z)$

この関数の力パラメータがTrueに設定されている場合、数量にまだ仮定がない場合は、上記の仮定が成り立つと見なされます。

>>> logcombine(a*log(x) + log(y) - log(z), force=True)

上記のコードスニペットは、以下の式と同等の出力を提供します-

$\log\frac{x^a y}{z}$

関数の導関数は、その変数の1つに対する瞬間的な変化率です。これは、ある点で関数の接線の傾きを見つけることと同じです。SymPyパッケージのdiff（）関数を使用して、変数の形式で数式の微分を見つけることができます。

diff(expr, variable)
>>> from sympy import diff, sin, exp 
>>> from sympy.abc import x,y 
>>> expr=x*sin(x*x)+1 >>> expr

上記のコードスニペットは、以下の式と同等の出力を提供します-

$x\sin(x^2) + 1$

>>> diff(expr,x)

上記のコードスニペットは、以下の式と同等の出力を提供します-

$2x^2\cos(x^2) + \sin(x^2)$

>>> diff(exp(x**2),x)

上記のコードスニペットは、以下の式と同等の出力を提供します-

2xe^x2

複数の導関数を取得するには、微分したい回数だけ変数を渡すか、変数の後に数値を渡します。

>>> diff(x**4,x,3)

上記のコードスニペットは、以下の式と同等の出力を提供します-

$24x$

>>> for i in range(1,4): print (diff(x**4,x,i))

上記のコードスニペットは、以下の式を示します-

4*x**3

12*x**2

24*x

式のdiff（）メソッドを呼び出すこともできます。diff（）関数と同様に機能します。

>>> expr=x*sin(x*x)+1 
>>> expr.diff(x)

上記のコードスニペットは、以下の式と同等の出力を提供します-

$2x^2\cos(x^2) + \sin(x^2)$

未評価のデリバティブは、Derivativeクラスを使用して作成されます。構文はdiff（）関数と同じです。未評価のデリバティブを評価するには、doitメソッドを使用します。

>>> from sympy import Derivative 
>>> d=Derivative(expr) 
>>> d

上記のコードスニペットは、以下の式と同等の出力を提供します-

$\frac{d}{dx}(x\sin(x^2)+1)$

>>> d.doit()

上記のコードスニペットは、以下の式と同等の出力を提供します-

$2x^2\cos(x^2) + \sin(x^2)$

SymPyパッケージには積分モジュールが含まれています。式の定積分と不定積分を計算するメソッドを実装します。Integrate（）メソッドは、定積分と不定積分の両方を計算するために使用されます。不定積分またはプリミティブ積分を計算するには、式の後に変数を渡すだけです。

例-

integrate(f, x)

定積分を計算するには、次のように引数を渡します。

(integration_variable, lower_limit, upper_limit)

>>> from sympy import * 
>>> x,y = symbols('x y') 
>>> expr=x**2 + x + 1 
>>> integrate(expr, x)

上記のコードスニペットは、以下の式と同等の出力を提供します-

$\frac{x^3}{3} + \frac{x^2}{2} + x$

>>> expr=sin(x)*tan(x) 
>>> expr 
>>> integrate(expr,x)

上記のコードスニペットは、以下の式と同等の出力を提供します-

$-\frac{\log(\sin(x) - 1)}{2} + \frac{\log(\sin(x) + 1)}{2} - \sin(x)$

定積分の例を以下に示します-

>>> expr=exp(-x**2) 
>>> integrate(expr,(x,0,oo) )

上記のコードスニペットは、以下の式と同等の出力を提供します-

$\frac{\sqrt\pi}{2}$

複数の制限タプルを渡して、多重積分を実行できます。例を以下に示します-

>>> expr=exp(-x**2 - y**2)
>>> integrate(expr,(x,0,oo),(y,0,oo))

上記のコードスニペットは、以下の式と同等の出力を提供します-

$\frac{\pi}{4}$

積分オブジェクトを使用して未評価の積分を作成できます。これは、doit（）メソッドを呼び出すことで評価できます。

>>> expr = Integral(log(x)**2, x) 
>>> expr

上記のコードスニペットは、以下の式と同等の出力を提供します-

$\int \mathrm\log(x)^2 \mathrm{d}x$

>>> expr.doit()

上記のコードスニペットは、以下の式と同等の出力を提供します-

$x\log(x)^2 - 2xlog(x) + 2x$

積分変換

SymPyは、次のようにさまざまなタイプの積分変換をサポートしています。

• laplace_transform
• fourier_transform
• sine_transform
• cosine_transform
• hankel_transform

これらの関数はsympy.integrals.transformsモジュールで定義されています。次の例では、フーリエ変換とラプラス変換をそれぞれ計算します。

Example 1

>>> from sympy import fourier_transform, exp 
>>> from sympy.abc import x, k 
>>> expr=exp(-x**2) 
>>> fourier_transform(expr, x, k)

上記のコマンドをPythonシェルで実行すると、次の出力が生成されます-

sqrt(pi)*exp(-pi**2*k**2)

これは−と同等です

$\sqrt\pi * e^{\pi^2k^2}$

Example 2

>>> from sympy.integrals import laplace_transform 
>>> from sympy.abc import t, s, a 
>>> laplace_transform(t**a, t, s)

上記のコマンドをPythonシェルで実行すると、次の出力が生成されます-

(s**(-a)*gamma(a + 1)/s, 0, re(a) > -1)

数学では、行列は数値、記号、または式の2次元配列です。行列操作の理論は、特定の規則に従って、行列オブジェクトに対して算術演算を実行することを扱います。

線形変換は、行列の重要なアプリケーションの1つです。特に物理学に関連する多くの科学分野は、マトリックス関連のアプリケーションを使用しています。

SymPyパッケージには、マトリックス処理を処理するマトリックスモジュールがあります。これには、オブジェクトが行列を表すMatrixクラスが含まれます。

Note: If you want to execute all the snippets in this chapter individually, you need to import the matrix module as shown below −

>>> from sympy.matrices import Matrix

Example

>>> from sympy.matrices import Matrix 
>>> m=Matrix([[1,2,3],[2,3,1]]) 
>>> m
$\displaystyle \left[\begin{matrix}1 & 2 & 3\\2 & 3 & 1\end{matrix}\right]$

上記のコマンドをPythonシェルで実行すると、次の出力が生成されます-

[1 2 3 2 3 1]

マトリックスは、適切なサイズのリストオブジェクトから作成されます。リストアイテムを指定された行数と列数に分散してマトリックスを取得することもできます。

>>> M=Matrix(2,3,[10,40,30,2,6,9]) 
>>> M
$\displaystyle \left[\begin{matrix}10 & 40 & 30\\2 & 6 & 9\end{matrix}\right]$

上記のコマンドをPythonシェルで実行すると、次の出力が生成されます-

[10 40 30 2 6 9]

マトリックスは可変オブジェクトです。行列モジュールは、不変行列を取得するためのImmutableMatrixクラスも提供します。

基本的な操作

ザ・ shape Matrixオブジェクトのプロパティはそのサイズを返します。

>>> M.shape

上記のコードの出力は次のとおりです-

(2,3)

row（）メソッドとcol（）メソッドは、それぞれ指定された数の行または列を返します。

>>> M.row(0)
$\displaystyle \left[\begin{matrix}10 & 40 & 30\end{matrix}\right]$

上記のコードの出力は次のとおりです-

[10 40 30]

>>> M.col(1)
$\displaystyle \left[\begin{matrix}40\\6\end{matrix}\right]$

上記のコードの出力は次のとおりです-

[40 6]

Pythonのスライス演算子を使用して、行または列に属する1つ以上のアイテムをフェッチします。

>>> M.row(1)[1:3]
[6, 9]

行列クラスには、指定された行列から指定された行/列を削除するrow_del（）メソッドとcol_del（）メソッドがあります-

>>> M=Matrix(2,3,[10,40,30,2,6,9]) 
>>> M.col_del(1) 
>>> M

上記のコマンドをPythonシェルで実行すると、次の出力が生成されます-

Matrix([[10, 30],[ 2, 9]])

次のコマンドを使用して、出力にスタイルを適用できます。

$\displaystyle \left[\begin{matrix}10 & 30\\2 & 9\end{matrix}\right]$

上記のコードスニペットを実行すると、次の出力が得られます-

[10 30 2 9]

>>> M.row_del(0) 
>>> M

$\displaystyle \left[\begin{matrix}2 & 9\end{matrix}\right]$

上記のコードスニペットを実行すると、次の出力が得られます-

[2 9]

同様に、row_insert（）メソッドとcol_insert（）メソッドは、指定された行または列のインデックスに行または列を追加します

>>> M1=Matrix([[10,30]]) 
>>> M=M.row_insert(0,M1)
>>> M

$\displaystyle \left[\begin{matrix}10 & 30\\2 & 9\end{matrix}\right]$

上記のコードスニペットを実行すると、次の出力が得られます-

[10 40 30 2 9]

>>> M2=Matrix([40,6]) 
>>> M=M.col_insert(1,M2) 
>>> M

$\displaystyle \left[\begin{matrix}10 & 40 & 30\\2 & 6 & 9\end{matrix}\right]$

上記のコードスニペットを実行すると、次の出力が得られます-

[10 40 30 6 9]

算術演算

通常の演算子+、-、および*は、加算、減算、および乗算を実行するために定義されています。

>>> M1=Matrix([[1,2,3],[3,2,1]]) 
>>> M2=Matrix([[4,5,6],[6,5,4]]) 
>>> M1+M2

$\displaystyle \left[\begin{matrix}5 & 7 & 9\\9 & 7 & 5\end{matrix}\right]$

上記のコードスニペットを実行すると、次の出力が得られます-

[5 7 9 9 7 5]

>>> M1-M2
$\displaystyle \left[\begin{matrix}-3 & -3 & -3\\-3 & -3 & -3\end{matrix}\right]$

上記のコードスニペットを実行すると、次の出力が得られます-

[- 3 -3 -3 -3 -3 -3]

行列の乗算は、次の場合にのみ可能です。-1番目の行列の列数が2番目の行列の行数と等しくなければなりません。-結果は、1番目の行列と同じ行数、2番目の行列と同じ列数になります。

>>> M1=Matrix([[1,2,3],[3,2,1]]) 
>>> M2=Matrix([[4,5],[6,6],[5,4]]) 
>>> M1*M2
$\displaystyle \left[\begin{matrix}31 & 29\\29 & 31\end{matrix}\right]$

上記のコードの出力は次のとおりです-

[31 29 29 31]

>>> M1.T
$\displaystyle \left[\begin{matrix}1 & 3\\2 & 2\\3 & 1\end{matrix}\right]$

コードを実行すると、次の出力が得られます。

[1 3 2 2 3 1]

行列式を計算するには、det（）メソッドを使用します。行列式は、正方行列の要素から計算できるスカラー値です。0

>>> M=Matrix(3,3,[10,20,30,5,8,12,9,6,15])
>>> M
$\displaystyle \left[\begin{matrix}10 & 20 & 30\\5 & 8 & 12\\9 & 6 & 15\end{matrix}\right]$

上記のコードの出力は次のとおりです-

[10 20 30 5 8 12 9 6 15]

>>> M.det()

上記のコードの出力は次のとおりです-

-120

行列コンストラクター

SymPyは多くの特別なタイプの行列クラスを提供します。たとえば、単位行列、すべての0と1の行列などです。これらのクラスには、それぞれeye、0、1という名前が付けられています。単位行列は、対角線上にある要素が1に設定され、残りの要素が0である正方行列です。

Example

from sympy.matrices import eye eye(3)

Output

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

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

上記のコードの出力は次のとおりです-

[1 0 0 0 1 0 0 0 1]

対角行列では、対角上の要素は、指定された引数に従って初期化されます。

>>> from sympy.matrices import diag 
>>> diag(1,2,3)

$\displaystyle \left[\begin{matrix}1 & 0 & 0\\0 & 2 & 0\\0 & 0 & 3\end{matrix}\right]$

上記のコードの出力は次のとおりです-

[1 0 0 0 2 0 0 0 3]

ゼロ行列のすべての要素は0に初期化されます。

>>> from sympy.matrices import zeros 
>>> zeros(2,3)

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

上記のコードの出力は次のとおりです-

[0 0 0 0 0 0]

同様に、1は、すべての要素が1に設定された行列です。

>>> from sympy.matrices import ones
>>> ones(2,3)

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

上記のコードの出力は次のとおりです-

[1 1 1 1 1 1]

Sympyパッケージには、sympy.core.functionモジュールで定義されているFunctionクラスがあります。これは、適用されるすべての数学関数の基本クラスであり、未定義の関数クラスのコンストラクターでもあります。

以下のカテゴリの関数は、関数クラスから継承されます-

• 複素数の関数
• 三角関数
• 整数の関数
• 組み合わせ関数
• その他のその他の機能

複素数の関数

この関数のセットはで定義されています sympy.functions.elementary.complexes モジュール。

re

この関数は式の実数部を返します-

>>> from sympy import * 
>>> re(5+3*I)

上記のコードスニペットの出力を以下に示します-

5

>>> re(I)

上記のコードスニペットの出力は次のとおりです。

0

Im

この関数は、式の虚数部を返します-

>>> im(5+3*I)

上記のコードスニペットの出力を以下に示します-

3

>>> im(I)

上記のコードスニペットの出力を以下に示します-

1

sign

この関数は、式の複素数記号を返します。

実際の表現の場合、符号は次のようになります。

• 式が正の場合は1
• 式がゼロに等しい場合は0
• -式が負の場合は-1

式が架空の場合、返される符号は−です。

• im（expression）が正の場合
• -im（expression）が負の場合はI

>>> sign(1.55), sign(-1), sign(S.Zero)

上記のコードスニペットの出力を以下に示します-

(1, -1, 0)

>>> sign (-3*I), sign(I*2)

上記のコードスニペットの出力を以下に示します-

(-I, I)

Abs

この関数は、複素数の絶対値を返します。これは、複素平面内の原点（0,0）と点（a、b）の間の距離として定義されます。この関数は、シンボリック値を受け入れるための組み込み関数abs（）の拡張です。

>>> Abs(2+3*I)

上記のコードスニペットの出力を以下に示します-

$\sqrt13$

conjugate

この関数は、複素数の共役を返します。複素共役を見つけるために、虚数部の符号を変更します。

>>> conjugate(4+7*I)

上記のコードスニペットを実行すると、次の出力が得られます-

4 - 7i

三角関数

SymPyには、sin cos、tanなどのすべての三角関数の比率と、asin、acos、atanなどの逆の対応物の定義があります。これらの関数は、ラジアンで表された特定の角度のそれぞれの値を計算します。

>>> sin(pi/2), cos(pi/4), tan(pi/6)

上記のコードスニペットの出力を以下に示します-

(1, sqrt(2)/2, sqrt(3)/3)

>>> asin(1), acos(sqrt(2)/2), atan(sqrt(3)/3)

上記のコードスニペットの出力を以下に示します-

(pi/2, pi/4, pi/6)

整数の関数

これは、整数に対してさまざまな操作を実行するための関数のセットです。

ceiling

これは、引数以上の最小の整数値を返す単変量関数です。複素数の場合、実数部と虚数部の上限を別々に設定します。

>>> ceiling(pi), ceiling(Rational(20,3)), ceiling(2.6+3.3*I)

上記のコードスニペットの出力を以下に示します-

(4, 7, 3 + 4*I)

floor

この関数は、引数以下の最大の整数値を返します。複素数の場合、この関数も実数部と虚数部のフロアを別々に取ります。

>>> floor(pi), floor(Rational(100,6)), floor(6.3-5.9*I)

上記のコードスニペットの出力を以下に示します-

(3, 16, 6 - 6*I)

frac

この関数は、xの小数部分を表します。

>>> frac(3.99), frac(Rational(10,3)), frac(10)

上記のコードスニペットの出力を以下に示します-

(0.990000000000000, 1/3, 0)

組み合わせ関数

組み合わせ論は、有限または離散システム内での選択、配置、および操作の問題に関係する数学の分野です。

factorial

階乗は、n個のオブジェクトを並べ替えることができる方法の数を与える組み合わせ論において非常に重要です。象徴的にð?? '¥！この関数は、非負の整数に対する階乗関数の実装です。負の整数の階乗は複素数の無限大です。

>>> x=Symbol('x') 
>>> factorial(x)

上記のコードスニペットの出力を以下に示します-

x!

>>> factorial(5)

上記のコードスニペットの出力を以下に示します-

120

>>> factorial(-1)

上記のコードスニペットの出力を以下に示します-

$\infty\backsim$

二項式

この関数は、n個の要素のセットからk個の要素を選択できる方法の数です。

>>> x,y=symbols('x y') 
>>> binomial(x,y)

上記のコードスニペットの出力を以下に示します-

$(\frac{x}{y})$

>>> binomial(4,2)

上記のコードスニペットの出力を以下に示します-

6

パスカルの三角形の行は、二項関数を使用して生成できます。

>>> for i in range(5): print ([binomial(i,j) for j in range(i+1)])

上記のコードスニペットを実行すると、次の出力が得られます-

[1]

[1, 1]

[1, 2, 1]

[1, 3, 3, 1]

[1, 4, 6, 4, 1]

fibonacci

フィボナッチ数は、初期項F0 = 0、F1 = 1および2項漸化式Fn = Fn-1 + Fn-2によって定義される整数列です。

>>> [fibonacci(x) for x in range(10)]

上記のコードスニペットを実行すると、次の出力が得られます。

[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

tribonacci

フィボナッチ数は、初期項F0 = 0、F1 = 1、F2 = 1および3項漸化式Fn = Fn-1 + Fn-2 + Fn-3によって定義される整数列です。

>>> tribonacci(5, Symbol('x'))

上記のコードスニペットは、以下の式と同等の出力を提供します-

$x^8 + 3x^5 + 3x^2$

>>> [tribonacci(x) for x in range(10)]

上記のコードスニペットを実行すると、次の出力が得られます。

[0, 1, 1, 2, 4, 7, 13, 24, 44, 81]

その他の機能

以下は、よく使用される機能のリストです。

Min−リストの最小値を返します。組み込み関数minとの競合を避けるために、Minという名前が付けられています。

Max−リストの最大値を返します。組み込み関数maxとの競合を避けるために、Maxという名前が付けられています。

root −xのn乗根を返します。

sqrt −xの主平方根を返します。

cbrt −この関数は、xの主立方根を計算します（x ++ Rational（1,3）のショートカット）。

以下は、上記のその他の関数とそれぞれの出力の例です。

>>> Min(pi,E)

e

>>> Max(5, Rational(11,2))

$\frac{11}{2}$

>>> root(7,Rational(1,2))

49

>>> sqrt(2)

$\sqrt2$

>>> cbrt(1000)

10

数学では、クォータニオン数体系は複素数の拡張です。各Quaternionオブジェクトには、4つのスカラー変数と4つの次元、1つの実次元と3つの虚次元が含まれています。

クォータニオンは次の式で表されます-

q = a + bi + cj + dk

どこ a, b, c およびdは実数であり、 i, j, k は、i2 == j2 == k2 == ijkのようなクォータニオン単位です。

ザ・ sympy.algebras.quaternion モジュールにはQuaternionクラスがあります。

>>> from sympy.algebras.quaternion import Quaternion 
>>> q=Quaternion(2,3,1,4) 
>>> q

上記のコードスニペットは、以下の式と同等の出力を提供します-

$2 + 3i + 1j + 4k$

クォータニオンは、純粋数学だけでなく、応用数学、コンピューターグラフィックス、コンピュータービジョンなどでも使用されます。

>>> from sympy import * 
>>> x=Symbol('x') 
>>> q1=Quaternion(x**2, x**3, x) >>> q1

上記のコードスニペットは、以下の式と同等の出力を提供します-

$x^2 + x^3i + xj + 0k$

クォータニオンオブジェクトは、架空の係数を持つこともできます

>>> q2=Quaternion(2,(3+2*I), x**2, 3.5*I) 
>>> q2

上記のコードスニペットは、以下の式と同等の出力を提供します-

$2 + (3 + 2i)i + x2j + 3.5ik$

追加（）

Quaternionクラスで使用可能なこのメソッドは、2つのQuaternionオブジェクトの追加を実行します。

>>> q1=Quaternion(1,2,3,4) 
>>> q2=Quaternion(4,3,2,1) 
>>> q1.add(q2)

上記のコードスニペットは、以下の式と同等の出力を提供します-

$5 + 5i + 5j + 5k$

Quaternionオブジェクトに数値または記号を追加することができます。

>>> q1+2

上記のコードスニペットを実行すると、次の出力が得られます。

$3 + 2i + 3j + 4k$

>>> q1+x

上記のコードスニペットを実行すると、次の出力が得られます。

$(x + 1) + 2i + 3j + 4k$

mul（）

このメソッドは、2つのクォータニオンオブジェクトの乗算を実行します。

>>> q1=Quaternion(1,2,1,2) 
>>> q2=Quaternion(2,4,3,1) 
>>> q1.mul(q2)

上記のコードスニペットは、以下の式と同等の出力を提供します-

$(-11) + 3i + 11j + 7k$

reverse（）

このメソッドは、クォータニオンオブジェクトの逆を返します。

>>> q1.inverse()

上記のコードスニペットは、以下の式と同等の出力を提供します-

$\frac{1}{10} + (-\frac{1}{5})i + (-\frac{1}{10})j + (-\frac{1}{5})k$

捕虜（）

このメソッドは、クォータニオンオブジェクトのパワーを返します。

>>> q1.pow(2)

上記のコードスニペットを実行すると、次の出力が得られます。

$(-8) + 4i + 2j + 4k$

exp（）

このメソッドは、Quaternionオブジェクトの指数を計算します。

>>> q=Quaternion(1,2,4,3) 
>>> q.exp()

上記のコードスニペットを実行すると、次の出力が得られます。

$e\cos(\sqrt29) + \frac{2\sqrt29e\sin(\sqrt29)}{29}i + \frac{4\sqrt29e\sin(\sqrt29)}{29}j + \frac{3\sqrt29e\sin}{29}k$

シンボル=と==はPythonで代入演算子と等式演算子として定義されているため、シンボリック方程式の作成には使用できません。SymPyは、方程式を設定するためのEq（）関数を提供します。

>>> from sympy import * 
>>> x,y=symbols('x y') 
>>> Eq(x,y)

上記のコードスニペットは、以下の式と同等の出力を提供します-

x = y

x = yは、xy = 0の場合にのみ可能であるため、上記の式は次のように記述できます。

>>> Eq(x-y,0)

上記のコードスニペットは、以下の式と同等の出力を提供します-

x − y = 0

SymPyのソルバーモジュールは、プロトタイプが次のようなsoveset（）関数を提供します。

solveset(equation, variable, domain)

ドメインはデフォルトでS.Complexesです。resolveset（）関数を使用すると、次のように代数式を解くことができます。

>>> solveset(Eq(x**2-9,0), x)

次の出力が得られます-

{−3, 3}

>>> solveset(Eq(x**2-3*x, -2),x)

上記のコードスニペットを実行すると、次の出力が得られます。

{1,2}

ソルブセットの出力は、ソリューションの有限集合です。解決策がない場合は、EmptySetが返されます

>>> solveset(exp(x),x)

上記のコードスニペットを実行すると、次の出力が得られます。

$\varnothing$

一次方程式

線形方程式を解くには、linsolve（）関数を使用する必要があります。

たとえば、方程式は次のとおりです。

xy = 4

x + y = 1

>>> from sympy import * 
>>> x,y=symbols('x y') 
>>> linsolve([Eq(x-y,4),Eq( x + y ,1) ], (x, y))

上記のコードスニペットを実行すると、次の出力が得られます。

$\lbrace(\frac{5}{2},-\frac{3}{2})\rbrace$

linsolve（）関数は、行列形式で表現された線形方程式を解くこともできます。

>>> a,b=symbols('a b') 
>>> a=Matrix([[1,-1],[1,1]]) 
>>> b=Matrix([4,1]) 
>>> linsolve([a,b], (x,y))

上記のコードスニペットを実行すると、次の出力が得られます-

$\lbrace(\frac{5}{2},-\frac{3}{2})\rbrace$

非線形方程式

この目的のために、nonlinsolve（）関数を使用します。この例の方程式-

a ² + a = 0 ab = 0

>>> a,b=symbols('a b') 
>>> nonlinsolve([a**2 + a, a - b], [a, b])

上記のコードスニペットを実行すると、次の出力が得られます-

$\lbrace(-1, -1),(0,0)\rbrace$

微分方程式

まず、cls = Functionをsymbols関数に渡して、未定義の関数を作成します。微分方程式を解くには、dsolveを使用します。

>>> x=Symbol('x') 
>>> f=symbols('f', cls=Function) 
>>> f(x)

上記のコードスニペットを実行すると、次の出力が得られます。

f(x)

ここで、f（x）は未評価の関数です。その導関数は次のとおりです-

>>> f(x).diff(x)

上記のコードスニペットは、以下の式と同等の出力を提供します-

$\frac{d}{dx}f(x)$

まず、次の微分方程式に対応するEqオブジェクトを作成します

>>> eqn=Eq(f(x).diff(x)-f(x), sin(x)) 
>>> eqn

上記のコードスニペットは、以下の式と同等の出力を提供します-

$-f(x) + \frac{d}{dx}f(x)= \sin(x)$

>>> dsolve(eqn, f(x))

上記のコードスニペットは、以下の式と同等の出力を提供します-

$f(x)=(c^1-\frac{e^-xsin(x)}{2}-\frac{e^-xcos(x)}{2})e^x$

SymPyは、Matplotlibライブラリをバックエンドとして使用して、数学関数の2次元および3次元プロットをレンダリングします。Matplotlibが現在のPythonインストールで利用可能であることを確認してください。そうでない場合は、次のコマンドを使用して同じものをインストールします-

pip install matplotlib

プロットのサポートはsympy.pttingモジュールで定義されています。プロットモジュールには次の機能があります-

• plot −2Dラインプロット

• plot3d −3Dラインプロット

• plot_parametric −2Dパラメトリックプロット

• plot3d_parametric −3Dパラメトリックプロット

plot（）関数は、Plotクラスのインスタンスを返します。プロット図には、1つ以上のSymPy式が含まれる場合があります。Matplotlibをバックエンドとして使用できますが、texplot、pyglet、Google ChartsAPIなどの他のバックエンドも使用できます。

plot(expr, range, kwargs)

ここで、exprは有効なsymPy式です。言及されていない場合、範囲はデフォルトを（-10、10）として使用します。

次の例では、range（-10,10）−の各値に対してx2の値をプロットします。

>>> from sympy.plotting import plot 
>>> from sympy import * 
>>> x=Symbol('x') 
>>> plot(x**2, line_color='red')

同じ範囲に対して複数のプロットを描画するには、範囲タプルの前に複数の式を指定します。

>>> plot( sin(x),cos(x), (x, -pi, pi))

式ごとに個別の範囲を指定することもできます。

plot((expr1, range1), (expr2, range2))

次の図は、さまざまな範囲でsin（x）とcos（x）をプロットしています。

>>> plot( (sin(x),(x, -2*pi, 2*pi)),(cos(x), (x, -pi, pi)))

次のオプションのキーワード引数は、plot（）関数で指定できます。

• line_color −プロットラインの色を指定します。

• title −タイトルとして表示される文字列

• xlabel −X軸のラベルとして表示される文字列

• ylabel −y軸のラベルとして表示される文字列

>>> plot( (sin(x),(x, -2*pi, 2*pi)),(cos(x), (x, -pi, pi)), line_color='red', title='SymPy plot example')

plot3d（）関数は、3次元プロットをレンダリングします。

plot3d(expr, xrange, yrange, kwargs)

次の例では、3D表面プロットを描画します-

>>> from sympy.plotting import plot3d 
>>> x,y=symbols('x y') 
>>> plot3d(x*y, (x, -10,10), (y, -10,10))

2Dプロットと同様に、3次元プロットにも、それぞれ範囲が異なる複数のプロットを含めることができます。

>>> plot3d(x*y, x/y, (x, -5, 5), (y, -5, 5))

plot3d_parametric_line（）関数は、3次元のパラメトリック折れ線グラフをレンダリングします。

>>> from sympy.plotting import plot3d_parametric_line 
>>> plot3d_parametric_line(cos(x), sin(x), x, (x, -5, 5))

パラメトリック曲面プロットを描画するには、plot3d_parametric_surface（）関数を使用します。

plot3d_parametric_surface(xexpr, yexpr, zexpr, rangex, rangey, kwargs)

>>> from sympy.plotting import plot3d_parametric_surface 
>>> plot3d_parametric_surface(cos(x+y), sin(x-y), x-y, (x, -5, 5), (y, -5, 5))

SymPyのジオメトリモジュールを使用すると、線、円などの2次元エンティティを作成できます。その後、共線性の確認や交点の検索など、それらに関する情報を取得できます。

ポイント

ポイントクラスは、ユークリッド空間のポイントを表します。次の例では、点の共線性をチェックします-

>>> from sympy.geometry import Point 
>>> from sympy import * 
>>> x=Point(0,0) 
>>> y=Point(2,2) 
>>> z=Point(4,4) 
>>> Point.is_collinear(x,y,z)

Output

True

>>> a=Point(2,3) 
>>> Point.is_collinear(x,y,a)

Output

False

Pointクラスのdistance（）メソッドは、2点間の距離を計算します

>>> x.distance(y)

Output

$2\sqrt2$

距離は、記号で表すこともできます。

ライン

ラインエンティティは、2つのポイントオブジェクトから取得されます。2つの線が互いに交差する場合、intersection（）メソッドは交点を返します。

>>> from sympy.geometry import Point, Line 
>>> p1, p2=Point(0,5), Point(5,0) 
>>> l1=Line(p1,p2)
>>> l2=Line(Point(0,0), Point(5,5)) 
>>> l1.intersection(l2)

Output

[Point2D(5/2, 5/2)]

>>> l1.intersection(Line(Point(0,0), Point(2,2)))

Output

[Point2D(5/2, 5/2)]

>>> x,y=symbols('x y') 
>>> p=Point(x,y) 
>>> p.distance(Point(0,0))

Output

$\sqrt{x^2 + y^2}$

三角形

この関数は、3つのポイントオブジェクトから三角形エンティティを作成します。

Triangle(a,b,c)

>>> t=Triangle(Point(0,0),Point(0,5), Point(5,0)) 
>>> t.area

Output

$-\frac{25}{2}$

楕円

楕円幾何学エンティティは、中心に対応するPointオブジェクトと、水平半径と垂直半径にそれぞれ2つの数値を渡すことによって構築されます。

ellipse(center, hradius, vradius)

>>> from sympy.geometry import Ellipse, Line 
>>> e=Ellipse(Point(0,0),8,3) 
>>> e.area

Output

$24\pi$

離心率パラメータを使用して、vradiusを間接的に提供できます。

>>> e1=Ellipse(Point(2,2), hradius=5, eccentricity=Rational(3,4)) 
>>> e1.vradius

Output

$\frac{5\sqrt7}{4}$

ザ・ apoapsis 楕円のは、焦点と輪郭の間の最大距離です。

>>> e1.apoapsis

Output

$\frac{35}{4}$

次のステートメントは、楕円の円周を計算します-

>>> e1.circumference

Output

$20E(\frac{9}{16})$

ザ・ equation 楕円のメソッドは、楕円の方程式を返します。

>>> e1.equation(x,y)

Output

$(\frac{x}{5}-\frac{2}{5})^2 + \frac{16(y-2)2}{175} - 1$

数学では、セットは、数字、人、アルファベットの文字、またはその他のセットなど、明確に定義された個別のオブジェクトのコレクションです。Setは、Pythonの組み込み型の1つでもあります。SymPyはsetsモジュールを提供します。さまざまなタイプのセットの定義が含まれており、交差、和集合などのセット操作を実行する機能があります。

Setは、SymPyの他のタイプのセットの基本クラスです。Pythonの組み込みセットデータ型とは異なることに注意してください。インターバルクラスは実際のインターバルを表し、その境界プロパティはFiniteSet オブジェクト。

>>> from sympy import Interval 
>>> s=Interval(1,10).boundary 
>>> type(s)

sympy.sets.sets.FiniteSet

FiniteSetは、離散数のコレクションです。これは、リストや文字列などの任意のシーケンスオブジェクトから取得できます。

>>> from sympy import FiniteSet 
>>> FiniteSet(range(5))

Output

$\lbrace\lbrace0,1,...,4\rbrace\rbrace$

>>> numbers=[1,3,5,2,8] 
>>> FiniteSet(*numbers)

Output

$\lbrace1,2,3,5,8\rbrace$

>>> s="HelloWorld" 
>>> FiniteSet(*s)

Output

{H,W,d,e,l,o,r}

組み込みセットと同様に、SymPyのセットも個別のオブジェクトのコレクションであることに注意してください。

ConditionSet 与えられた条件を満たす要素のセットです

>>> from sympy import ConditionSet, Eq, Symbol 
>>> x=Symbol('x') 
>>> s=ConditionSet(x, Eq(x**2-2*x,0), Interval(1,10)) >>> s

Output

$\lbrace x\mid x\in[1,10]∧x^2 - 2x =0\rbrace$

Union複合セットです。2つのセットのすべての要素が含まれています。両方にある要素は、ユニオンに1回だけ表示されることに注意してください。

>>> from sympy import Union 
>>> l1=[3,1,5,7] 
>>> l2=[9,7,2,1] 
>>> a=FiniteSet(*l1) 
>>> b=FiniteSet(*l2) 
>>> Union(a,b)

Intersection 一方、両方に存在する要素のみが含まれています。

>>> from sympy import Intersection 
>>> Intersection(a,b)

ProductSet オブジェクトは、両方のセットの要素のデカルト積を表します。

>>> from sympy import ProductSet 
>>> l1=[1,2] 
>>> l2=[2,3] 
>>> a=FiniteSet(*l1) 
>>> b=FiniteSet(*l2) 
>>> set(ProductSet(a,b))

Complement(a,b) bセットと共通の除外要素の要素を保持します。

>>> from sympy import Complement 
>>> l1=[3,1,5,7] 
>>> l2=[9,7,2,1] 
>>> a=FiniteSet(*l1) 
>>> b=FiniteSet(*l2) 
>>> Complement(a,b), Complement(b,a)

SymmetricDifference セットには、両方のセットで一般的でない要素のみが含まれています。

>>> from sympy import SymmetricDifference 
>>> l1=[3,1,5,7] 
>>> l2=[9,7,2,1] 
>>> a=FiniteSet(*l1) 
>>> b=FiniteSet(*l2) 
>>> SymmetricDifference(a,b)

Output

{2,3,5,9}

SymPyにはいくつかのプリンターがあります。以下は部分的なリストです-

• str
• srepr
• ASCIIプリティプリンター
• Unicodeプリティプリンター
• LaTeX
• MathML
• Dot

SymPyオブジェクトは、C、Fortran、Javascript、Theano、Pythonなどのさまざまな言語のコードへの出力として送信することもできます。

SymPyはUnicode文字を使用して、出力をプリティプリントの形式でレンダリングします。SymPyセッションの実行にPythonコンソールを使用している場合は、init_session（）関数を呼び出すことで最適な印刷環境がアクティブ化されます。

>>> from sympy import init_session 
>>> init_session()

SymPy 1.5.1（Python 3.7.4-64ビット）用のIPythonコンソール（グラウンドタイプ：python）。

これらのコマンドが実行されました-

>>> 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()

ドキュメントはで見つけることができます https://docs.sympy.org/1.5.1/.

>>> Integral(sqrt(1/x),x)

$\int \sqrt\frac{1}{x} dx$

LATEXがインストールされていないが、Matplotlibがインストールされている場合は、Matplotlibレンダリングエンジンが使用されます。Matplotlibがインストールされていない場合は、Unicodeプリティプリンターを使用します。ただし、JupyterノートブックはMathJaxを使用してLATEXをレンダリングします。

Unicodeをサポートしていない端末では、ASCIIプリティプリンターが使用されます。

ASCIIプリンターを使用するには、use_unicodeプロパティをFalseに設定してpprint（）関数を使用します

>>> pprint(Integral(sqrt(1/x),x),use_unicode=False)

Unicodeプリティプリンターは、pprint（）およびpretty（）からもアクセスできます。端末がUnicodeをサポートしている場合は、自動的に使用されます。pprint（）が端末がUnicodeをサポートしていることを検出できない場合は、use_unicode = Trueを渡して、Unicodeを使用するように強制できます。

式のLATEX形式を取得するには、latex（）関数を使用します。

>>> print(latex(Integral(sqrt(1/x),x)))

\int \sqrt{\frac{1}{x}}\, dx

mathmlプリンターを使用することもできます。そのために、print_mathml関数をインポートします。文字列バージョンはmathml（）関数によって取得されます。

>>> from sympy.printing.mathml import print_mathml 
>>> print_mathml(Integral(sqrt(1/x),x))

<apply>

<int/>

<bvar>

<ci>x</ci>

</bvar>

<apply>

<root/>

<apply>

<power/>

<ci>x</ci>

<cn>-1</cn>

</apply>

</apply>

</apply>

>>>mathml(Integral(sqrt(1/x),x))

'<apply><int/><bvar><ci>x</ci></bvar><apply><root/><apply><power/><ci>x</ci><cn>-1</cn></apply></apply></apply>'