SymPy tutorial
last modified July 6, 2020
SymPy tutorial shows how to do symbolic computation in Python with sympy module. This is a brief introduction to the SymPy.
Computer algebra system (CAS) is a mathematical software with the ability to manipulate mathematical expressions in a way similar to the traditional manual computations of mathematicians and scientists.
Symbolic computation deals with the computation of mathematical objects symbolically. The mathematical objects are represented exactly, not approximately, and mathematical expressions with unevaluated variables are left in symbolic form.
SymPy
SymPy is a Python library for symbolic mathematics. It aims to become a full-featured computer algebra system. SymPy includes features ranging from basic symbolic arithmetic to calculus, algebra, discrete mathematics and quantum physics. It is capable of showing results in LaTeX.
$ pip install sympy
SymPy is installed with pip install sympy
command.
Rational values
SymPy has Rational
for working with rational numbers. A rational
number is any number that can be expressed as the quotient or fraction p/q of
two integers, a numerator p and a non-zero denominator q.
#!/usr/bin/env python from sympy import Rational r1 = Rational(1/10) r2 = Rational(1/10) r3 = Rational(1/10) val = (r1 + r2 + r3) * 3 print(val.evalf()) val2 = (1/10 + 1/10 + 1/10) * 3 print(val2)
The example works with rational numbers.
val = (r1 + r2 + r3) * 3 print(val.evalf())
The expression is in the symbolic form; we evaluate it with
evalf()
method.
$ rational_values.py 0.900000000000000 0.9000000000000001
Notice that there is a small error in the output when not using rational numbers.
SymPy pprint
The pprint()
is used for pretty printing the output on the console.
The best results are achieved with LaTeX e.g. in Jupyter notebook.
#!/usr/bin/env python from sympy import pprint, Symbol, exp, sqrt from sympy import init_printing init_printing(use_unicode=True) x = Symbol('x') a = sqrt(2) pprint(a) print(a) print("------------------------") c = (exp(x) ** 2)/2 pprint(c) print(c)
The program prettifies the output.
init_printing(use_unicode=True)
For some characters we need to enable unicode support.
$ prettify.py √2 sqrt(2) ------------------------ 2⋅x ℯ ──── 2 exp(2*x)/2
This is the output. Note that using Jupyter notebook gives much nicer output.
Square root
Square root is a number which produces a specified quantity when multiplied by itself.
#!/usr/bin/env python from sympy import sqrt, pprint, Mul x = sqrt(2) y = sqrt(2) pprint(Mul(x, y, evaluate=False)) print('equals to ') print(x * y)
The program outputs an expression containing square roots.
pprint(Mul(x, y, evaluate=False))
We postpone the evaluation of the multiplication expression
with evaluate
attribute.
$ square_root.py √2⋅√2 equals to 2
This is the output.
SymPy symbols
Symbolic computation works with symbols, which may be later evaluated. Symbols must be defined in SymPy before using them.
#!/usr/bin/env python # ways to define symbols from sympy import Symbol, symbols from sympy.abc import x, y expr = 2*x + 5*y print(expr) a = Symbol('a') b = Symbol('b') expr2 = a*b + a - b print(expr2) i, j = symbols('i j') expr3 = 2*i*j + i*j print(expr3)
The programs shows three ways to define symbols in SymPy.
from sympy.abc import x, y
Symbols can be imported from the sympy.abc
module.
It exports all latin and greek letters as Symbols, so we can
conveniently use them.
a = Symbol('a') b = Symbol('b')
They can be defined with Symbol
i, j = symbols('i j')
Multiple symbols can be defined with symbols()
method.
SymPy canonical form of expression
An expression is automatically transformed into a canonical form by SymPy. SymPy does only inexpensive operations; thus the expression may not be evaluated into its simplest form.
#!/usr/bin/env python from sympy.abc import a, b expr = b*a + -4*a + b + a*b + 4*a + (a + b)*3 print(expr)
We have an expression with symbols a
and b
.
The expression can be easily simplified.
$ canonical_form.py 2*a*b + 3*a + 4*b
This is the output.
SymPy expanding algebraic expressions
With expand()
, we can expand algebraic expressions;
i.e. the method tries to denest powers and multiplications.
#!/usr/bin/env python from sympy import expand, pprint from sympy.abc import x expr = (x + 1) ** 2 pprint(expr) print('-----------------------') print('-----------------------') expr = expand(expr) pprint(expr)
The program expands a simple expression.
$ expand.py 2 (x + 1) ----------------------- ----------------------- 2 x + 2⋅x + 1
This is the output.
SymPy simplify an expression
An expression can be changed with simplify()
to a
simpler form.
#!/usr/bin/env python from sympy import sin, cos, simplify, pprint from sympy.abc import x expr = sin(x) / cos(x) pprint(expr) print('-----------------------') expr = simplify(expr) pprint(expr)
The exaple simflifies a sin(x)/sin(y)
expression to tan(x)
.
$ simplify.py sin(x) ────── cos(x) ----------------------- tan(x)
This is the output.
SymPy comparig expression
SymPy expressions are compared with equals()
and
not with ==
operator.
#!/usr/bin/env python from sympy import pprint, Symbol, sin, cos x = Symbol('x') a = cos(x)**2 - sin(x)**2 b = cos(2*x) print(a.equals(b)) # we cannot use == operator print(a == b)
The program compares two expressions.
print(a.equals(b))
We compare two expressions with equals()
. Before applying
the method, SymPy tries to simplify the expressions.
$ expr_equality.py True False
This is the output.
SymPy evaluating expression
Expressions can be evaluated by substitution of symbols.
#!/usr/bin/env python from sympy import pi print(pi.evalf(30))
The example evaluates a pi value to thirty places.
$ evaluating.py 3.14159265358979323846264338328
This is the output.
#!/usr/bin/env python from sympy.abc import a, b from sympy import pprint expr = b*a + -4*a + b + a*b + 4*a + (a + b)*3 print(expr.subs([(a, 3), (b, 2)]))
The example evaluates an expression by substituting a
and b
symbols with numbers.
$ evaluating.py 3.14159265358979323846264338328
This is the output.
SymPy solving equations
Equations are solved with solve()
or solveset()
.
#!/usr/bin/env python from sympy import Symbol, solve x = Symbol('x') sol = solve(x**2 - x, x) print(sol)
The example solves a simple equation with solve()
.
sol = solve(x**2 - x, x)
The first parameter of the solve()
is the equation.
The equation is written in a specific form, suitable for SymPy; i.e.
x**2 - x
instead of x**2 = x
. The second
paramter is the symbol for which we need solution.
$ solving.py [0, 1]
The equation has two solutions: 0 and 1.
Alternatively, we can use the Eq
for equation.
#!/usr/bin/env python from sympy import pprint, Symbol, Eq, solve x = Symbol('x') eq1 = Eq(x + 1, 4) pprint(eq1) sol = solve(eq1, x) print(sol)
The example solves a simple x + 1 = 4
equation.
$ solving2.py x + 1 = 4 [3]
This is the output.
#!/usr/bin/env python from sympy.solvers import solveset from sympy import Symbol, Interval, pprint x = Symbol('x') sol = solveset(x**2 - 1, x, Interval(0, 100)) print(sol)
With solveset()
, we find a solution for the
given interval.
$ solving3.py {1}
This is the output.
SymPy sequence
Sequence is an enumerated collection of objects in which repetitions are allowed. A sequence can be finite or infinite. The number of elements is called the length of the sequence. Unlike a set, the same elements can appear multiple times at different positions in a sequence. The order of elements matters.
#!/usr/bin/env python from sympy import summation, sequence, pprint from sympy.abc import x s = sequence(x, (x, 1, 10)) print(s) pprint(s) print(list(s)) print(s.length) print(summation(s.formula, (x, s.start, s.stop))) # print(sum(list(s)))
The example creates a sequence of numbers 1, 2,...,10. We compute the sum of these numbers.
$ sequence.py SeqFormula(x, (x, 1, 10)) [1, 2, 3, 4, …] [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] 10 55
This is the output.
SymPy limit
A limit is the value that a function (or sequence) "approaches" as the input (or index) "approaches" some value.
#!/usr/bin/env python from sympy import sin, limit, oo from sympy.abc import x l1 = limit(1/x, x, oo) print(l1) l2 = limit(1/x, x, 0) print(l2)
In the example, we have the 1/x
function. It has a left-sided and
right-sided limit.
from sympy import sin, limit, sqrt, oo
The oo
denotes infinity.
l1 = limit(1/x, x, oo) print(l1)
We calculate the limit of 1/x
where x approaches positive infinity.
$ limit.py 0 oo
This is the output.
SymPy matrixes
In SymPy, we can work with matrixes. A matrix is a rectangular array of numbers or other mathematical objects for which operations such as addition and multiplication are defined.
Matrixes are used in computing, engineering, or image processing.
#!/usr/bin/env python from sympy import Matrix, pprint M = Matrix([[1, 2], [3, 4], [0, 3]]) print(M) pprint(M) N = Matrix([2, 2]) print("---------------------------") print("M * N") print("---------------------------") pprint(M*N)
The example defines two matrixes and multiplies them.
$ matrix.py Matrix([[1, 2], [3, 4], [0, 3]]) ⎡1 2⎤ ⎢ ⎥ ⎢3 4⎥ ⎢ ⎥ ⎣0 3⎦ --------------------------- M * N --------------------------- ⎡6 ⎤ ⎢ ⎥ ⎢14⎥ ⎢ ⎥ ⎣6 ⎦
This is the output.
SymPy plotting
SymPy contains module for plotting. It is built on Matplotlib.
#!/usr/bin/env python # uses matplotlib import sympy from sympy.abc import x from sympy.plotting import plot plot(1/x)
The example plots a 2d graph of a 1/x
function.
This was SymPy tutorial.
List all Python tutorials.