Краткое руководство

Введение

SymPy представляет собой открытую библиотеку символьных вычислений на языке Python. Цель SymPy - стать полнофункциональной системой компьютерной алгебры (CAS), при этом сохраняя код максимально понятным и легко расширяемым. SymPy полностью написан на Python и не требует сторонних библиотек.

Данное руководство представляет из себя введение в SymPy. В нем вы узнаете об основных возможностях SymPy и каким образом использовать эту программу. Если же вы желаете прочитать более подробное руководство, то обратитесь к Руководству пользователя SymPy, Описанию модулей SymPy, Можно также обратиться и к исходному коду библиотеки.

Первые шаги с SymPy

Скачать SymPy проще всего с http://code.google.com/p/sympy/. В разделе Featured, Downloads нужно найти и загрузить последнюю версию дистрибутива:

../_images/featured-downloads.png

Для Windows-систем, нужно скачать и запустить установочный .exe файл. В POSIX-совместимых системах нужно скачать .tar.gz файл и распаковать его:

$ tar xzf sympy-0.5.12.tar.gz

и запустить из интерпретатора Python:

$ cd sympy-0.5.12
$ python
Python 2.4.4 (#2, Jan  3 2008, 13:36:28)
[GCC 4.2.3 20071123 (prerelease) (Debian 4.2.2-4)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> from sympy import Symbol, cos
>>> x = Symbol("x")
>>> (1/cos(x)).series(x, 0, 10)
1 + x**2/2 + 5*x**4/24 + 61*x**6/720 + 277*x**8/8064 + O(x**10)

Если вы собираетесь использовать SymPy в вашей программе как модуль, рекомендуется обращаться к нему таким же способом, как показано выше. Установить модуль в систему можно или из скаченных исходников, используя команду ./setup.py install. Или, если вы работаете в Linux, можно установить пакет python-sympy с помощью системы установки программ:

Installing SymPy in Debian

$ sudo apt-get install python-sympy
Reading package lists... Done
Building dependency tree
Reading state information... Done
The following NEW packages will be installed:
  python-sympy
0 upgraded, 1 newly installed, 0 to remove and 18 not upgraded.
Need to get 991kB of archives.
After this operation, 5976kB of additional disk space will be used.
Get:1 http://ftp.cz.debian.org unstable/main python-sympy 0.5.12-1 [991kB]
Fetched 991kB in 2s (361kB/s)
Selecting previously deselected package python-sympy.
(Reading database ... 232619 files and directories currently installed.)
Unpacking python-sympy (from .../python-sympy_0.5.12-1_all.deb) ...
Setting up python-sympy (0.5.12-1) ...

For other means how to install SymPy, consult the wiki page Download and Installation.

Консоль isympy

SymPy можно использовать не только как модуль, но и как отдельную программу isympy, которая расположена в папке bin относительно директории с исходным кодом. Программа удобна для экспериментов с новыми функциями или для обучения SymPy. Она использует стандартный терминал IPython, но с уже включенными в нее важными модулями SymPy и определенными переменными x, y, z:

$ cd sympy
$ ./bin/isympy
IPython console for SymPy 0.7.2-git (Python 2.7.1) (ground types: gmpy)

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)

Documentation can be found at http://www.sympy.org

In [1]: (1/cos(x)).series(x, 0, 10)
Out[1]:
     2      4       6        8
    x    5*x    61*x    277*x     / 10\
1 + -- + ---- + ----- + ------ + O\x  /
    2     24     720     8064

Примечание

Команды введенные вами, обозначены жирным шрифтом. То, что мы делали тремя строчками в стандартном терминале Python, мы можем сделать одной строчкой в isympy. Кроме того программа поддерживает различные способы отображения результатов, в том числе графические.

Использование SymPy в качестве калькулятора

SymPy поддерживает три типа численных данных: Float, Rational и Integer.

Rational представляет собой обыкновенную дробь, которая задается с помощью двух целых чисел: числителя и знаменателя. Например, Rational(1, 2) представляет дробь 1/2, Rational(5, 2) представляет дробь 5/2, и так далее.

>>> from sympy import Rational
>>> a = Rational(1, 2)

>>> a
1/2

>>> a*2
1

>>> Rational(2)**50/Rational(10)**50
1/88817841970012523233890533447265625

Важная особенность Python-интерпретатора, о которой нужно сказать отдельно, связана с делением целых чисел При делении двух питоновских чисел типа int с помощью оператора “/” в старых версиях Python в результате получается число питоновского типа int. В Python 3 этот стандарт изменен на “true division”, и в результате получается питоновский тип float.И этот же стандарт “true division” по умолчанию включен и в isympy:

>>> 1/2 
0.5

В более ранних версиях Python этого не получится, и результатом будет целочисленное деление:

>>> 1/2 
0

Обратите внимание, что и в том и в другом случае вы имеете дело не с объектом Number из библиотеки SymPy, который представляет число в SymPy, а с питоновскими числами, которые создаются самим интерпретатором Python. Скорее всего, вам нужно будете работать с дробными числами из библиотеки SymPy, поэтому для того чтобы получать результат в виде объектов SymPy убедитесь, что вы используете класс Rational. Кому-то может показаться удобным обозначать Rational как R:

>>> R = Rational
>>> R(1, 2)
1/2
>>> R(1)/2 # R(1) is a SymPy Integer and Integer/int gives a Rational
1/2

В модуле Sympy имеются особые константы, такие как e и pi, которые ведут себя как переменные (то есть выражение 1 + pi не преобразуется сразу в число, а так и останется 1 + pi):

>>> from sympy import pi, E
>>> pi**2
pi**2

>>> pi.evalf()
3.14159265358979

>>> (pi + E).evalf()
5.85987448204884

как вы видите, функция evalf переводит исходное выражение в число с плавающей точкой. Вычисления можно проводить с большей точностью. Для этого нужно передать в качестве аргумента этой функции требуемое число десятичных знаков.

Для работы с математической бесконечностью используется символ oo:

>>> from sympy import oo
>>> oo > 99999
True
>>> oo + 1
oo

Переменные

В отличие от многих других систем компьютерной алгебры, вам нужно явно декларировать символьные переменные:

>>> from sympy import Symbol
>>> x = Symbol('x')
>>> y = Symbol('y')

В левой части этого выражения находится переменная Python, которая питоновским присваиванием соотносится с объектом класса Symbol из SymPy.

>>> from sympy.abc import x, theta

Символьные переменные могут также задаваться и с помощью функций symbols или var. Они допускают указание диапазона. Их отличие состоит в том, что var добавляет созданные переменные в текущее пространство имен:

>>> from sympy import symbols, var
>>> a, b, c = symbols('a,b,c')
>>> d, e, f = symbols('d:f')
>>> var('g:h')
(g, h)
>>> var('g:2')
(g0, g1)

Экземпляры класса Symbol взаимодействуют друг с другом. Таким образом, с помощью них конструируются алгебраические выражения:

>>> x + y + x - y
2*x

>>> (x + y)**2
(x + y)**2

>>> ((x + y)**2).expand()
x**2 + 2*x*y + y**2

Переменные могут быть заменены на другие переменные, числа или выражения с помощью функции подстановки subs(old, new):

>>> ((x + y)**2).subs(x, 1)
(y + 1)**2

>>> ((x + y)**2).subs(x, y)
4*y**2

>>> ((x + y)**2).subs(x, 1 - y)
1

Теперь, с этого момента, для всех написанных ниже примеров мы будем предполагать, что запустили следующую команду по настройке системы отображения результатов:

>>> from sympy import init_printing
>>> init_printing(use_unicode=False, wrap_line=False, no_global=True)

Она придаст более качественное отображение выражений. Подробнее по системе отображения и печати написано в разделе Печать. Если же у вас установлен шрифт с юникодом, вы можете использовать опцию use_unicode=True для еще более красивого вывода.

Алгебра

Чтобы разложить выражение на простейшие дроби используется функция apart(expr, x):

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

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

>>> apart(1/( (x + 2)*(x + 1) ), x)
    1       1
- ----- + -----
  x + 2   x + 1

>>> (x + 1)/(x - 1)
x + 1
-----
x - 1

>>> apart((x + 1)/(x - 1), x)
      2
1 + -----
    x - 1

Чтобы снова привести дробь к общему знаменателю используется функция together(expr, x):

>>> from sympy import together
>>> together(1/x + 1/y + 1/z)
x*y + x*z + y*z
---------------
     x*y*z

>>> together(apart((x + 1)/(x - 1), x), x)
x + 1
-----
x - 1

>>> together(apart(1/( (x + 2)*(x + 1) ), x), x)
       1
---------------
(x + 1)*(x + 2)

Вычисления

Пределы

Пределы считаются в SymPy очень легко. Чтобы вычислить предел функции, используйте функцию limit(function, variable, point). Например, чтобы вычислить предел f(x) при x -> 0, вам нужно ввести limit(f, x, 0):

>>> from sympy import limit, Symbol, sin, oo
>>> x = Symbol("x")
>>> limit(sin(x)/x, x, 0)
1

также вы можете вычислять пределы при x, стремящемся к бесконечности:

>>> limit(x, x, oo)
oo

>>> limit(1/x, x, oo)
0

>>> limit(x**x, x, 0)
1

Для более сложных примеров вычисления пределов, вы можете обратится к файлу с тестами test_demidovich.py

Дифференцирование

Продифференцировать любое выражение SymPy, можно используя diff(func, var). Примеры:

>>> from sympy import diff, Symbol, sin, tan
>>> x = Symbol('x')
>>> diff(sin(x), x)
cos(x)
>>> diff(sin(2*x), x)
2*cos(2*x)

>>> diff(tan(x), x)
   2
tan (x) + 1

Можно, кстати, через пределы проверить правильность вычислений производной:

>>> from sympy import limit
>>> from sympy.abc import delta
>>> limit((tan(x + delta) - tan(x))/delta, delta, 0)
   2
tan (x) + 1

Производные более высших порядков можно вычислить, используя дополнительный параметр этой же функции diff(func, var, n):

>>> diff(sin(2*x), x, 1)
2*cos(2*x)

>>> diff(sin(2*x), x, 2)
-4*sin(2*x)

>>> diff(sin(2*x), x, 3)
-8*cos(2*x)

Разложение в ряд

Для разложения в ряд используйте метод .series(var, point, order):

>>> from sympy import Symbol, cos
>>> x = Symbol('x')
>>> cos(x).series(x, 0, 10)
     2    4     6      8
    x    x     x      x      / 10\
1 - -- + -- - --- + ----- + O\x  /
    2    24   720   40320
>>> (1/cos(x)).series(x, 0, 10)
     2      4       6        8
    x    5*x    61*x    277*x     / 10\
1 + -- + ---- + ----- + ------ + O\x  /
    2     24     720     8064

Еще один простой пример:

>>> from sympy import Integral, pprint

>>> y = Symbol("y")
>>> e = 1/(x + y)
>>> s = e.series(x, 0, 5)

>>> print(s)
1/y - x/y**2 + x**2/y**3 - x**3/y**4 + x**4/y**5 + O(x**5)
>>> pprint(s)
          2    3    4
1   x    x    x    x     / 5\
- - -- + -- - -- + -- + O\x /
y    2    3    4    5
    y    y    y    y

Summation

Compute the summation of f with respect to the given summation variable over the given limits.

summation(f, (i, a, b)) computes the sum of f with respect to i from a to b, i.e.,

                            b
                          ____
                          \   `
summation(f, (i, a, b)) =  )    f
                          /___,
                          i = a

If it cannot compute the sum, it prints the corresponding summation formula. Repeated sums can be computed by introducing additional limits:

>>> from sympy import summation, oo, symbols, log
>>> i, n, m = symbols('i n m', integer=True)

>>> summation(2*i - 1, (i, 1, n))
 2
n
>>> summation(1/2**i, (i, 0, oo))
2
>>> summation(1/log(n)**n, (n, 2, oo))
  oo
 ___
 \  `
  \     -n
  /   log (n)
 /__,
n = 2
>>> summation(i, (i, 0, n), (n, 0, m))
      3    2
m    m    m
-- + -- + -
6    2    3
>>> from sympy.abc import x
>>> from sympy import factorial
>>> summation(x**n/factorial(n), (n, 0, oo))
 x
e

Интегрирование

SymPy поддерживает вычисление определенных и неопределенных интегралов с помощью функции integrate(). Она использует расширенный алгоритм Риша-Нормана и некоторые шаблоны и эвристики. Можно вычислять интегралы трансцендентных, простых и специальных функций:

>>> from sympy import integrate, erf, exp, sin, log, oo, pi, sinh, symbols
>>> x, y = symbols('x,y')

Вы можете интегрировать простейшие функции:

>>> integrate(6*x**5, x)
 6
x
>>> integrate(sin(x), x)
-cos(x)
>>> integrate(log(x), x)
x*log(x) - x
>>> integrate(2*x + sinh(x), x)
 2
x  + cosh(x)

Примеры интегрирования некоторых специальных функций:

>>> integrate(exp(-x**2)*erf(x), x)
  ____    2
\/ pi *erf (x)
--------------
      4

Возможно также вычислить определенный интеграл:

>>> integrate(x**3, (x, -1, 1))
0
>>> integrate(sin(x), (x, 0, pi/2))
1
>>> integrate(cos(x), (x, -pi/2, pi/2))
2

Поддерживаются и несобственные интегралы:

>>> integrate(exp(-x), (x, 0, oo))
1
>>> integrate(log(x), (x, 0, 1))
-1

Комплексные числа

Помимо мнимой единицы I, которое является мнимым числом, символы тоже могут иметь специальные атрибуты (real, positive, complex и т.д), которые определяют поведение этих символов при вычислении символьных выражений:

>>> from sympy import Symbol, exp, I
>>> x = Symbol("x") # a plain x with no attributes
>>> exp(I*x).expand()
 I*x
e
>>> exp(I*x).expand(complex=True)
   -im(x)               -im(x)
I*e      *sin(re(x)) + e      *cos(re(x))
>>> x = Symbol("x", real=True)
>>> exp(I*x).expand(complex=True)
I*sin(x) + cos(x)

Функции

тригонометрические

>>> from sympy import asin, asinh, cos, sin, sinh, symbols, I
>>> x, y = symbols('x,y')

>>> sin(x + y).expand(trig=True)
sin(x)*cos(y) + sin(y)*cos(x)

>>> cos(x + y).expand(trig=True)
-sin(x)*sin(y) + cos(x)*cos(y)

>>> sin(I*x)
I*sinh(x)

>>> sinh(I*x)
I*sin(x)

>>> asinh(I)
I*pi
----
 2

>>> asinh(I*x)
I*asin(x)

>>> sin(x).series(x, 0, 10)
     3     5     7       9
    x     x     x       x       / 10\
x - -- + --- - ---- + ------ + O\x  /
    6    120   5040   362880

>>> sinh(x).series(x, 0, 10)
     3     5     7       9
    x     x     x       x       / 10\
x + -- + --- + ---- + ------ + O\x  /
    6    120   5040   362880

>>> asin(x).series(x, 0, 10)
     3      5      7       9
    x    3*x    5*x    35*x     / 10\
x + -- + ---- + ---- + ----- + O\x  /
    6     40    112     1152

>>> asinh(x).series(x, 0, 10)
     3      5      7       9
    x    3*x    5*x    35*x     / 10\
x - -- + ---- - ---- + ----- + O\x  /
    6     40    112     1152

сферические

>>> from sympy import Ylm
>>> from sympy.abc import theta, phi

>>> Ylm(1, 0, theta, phi)
  ___
\/ 3 *cos(theta)
----------------
        ____
    2*\/ pi

>>> Ylm(1, 1, theta, phi)
   ___  I*phi
-\/ 6 *e     *sin(theta)
------------------------
            ____
        4*\/ pi

>>> Ylm(2, 1, theta, phi)
   ____  I*phi
-\/ 30 *e     *sin(theta)*cos(theta)
------------------------------------
                  ____
              4*\/ pi

факториалы и гамма-функции

>>> from sympy import factorial, gamma, Symbol
>>> x = Symbol("x")
>>> n = Symbol("n", integer=True)

>>> factorial(x)
x!

>>> factorial(n)
n!

>>> gamma(x + 1).series(x, 0, 3) # i.e. factorial(x)
                      /          2     2\
                    2 |EulerGamma    pi |    / 3\
1 - EulerGamma*x + x *|----------- + ---| + O\x /
                      \     2         12/

дзета-функции

>>> from sympy import zeta
>>> zeta(4, x)
zeta(4, x)

>>> zeta(4, 1)
  4
pi
---
 90

>>> zeta(4, 2)
       4
     pi
-1 + ---
      90

>>> zeta(4, 3)
         4
  17   pi
- -- + ---
  16    90

многочлены

>>> from sympy import assoc_legendre, chebyshevt, legendre, hermite
>>> chebyshevt(2, x)
   2
2*x  - 1

>>> chebyshevt(4, x)
   4      2
8*x  - 8*x  + 1

>>> legendre(2, x)
   2
3*x    1
---- - -
 2     2

>>> legendre(8, x)
      8         6         4        2
6435*x    3003*x    3465*x    315*x     35
------- - ------- + ------- - ------ + ---
  128        32        64       32     128

>>> assoc_legendre(2, 1, x)
        __________
       /    2
-3*x*\/  - x  + 1

>>> assoc_legendre(2, 2, x)
     2
- 3*x  + 3

>>> hermite(3, x)
   3
8*x  - 12*x

Дифференциальные уравнения

В isympy:

>>> from sympy import Function, Symbol, dsolve
>>> f = Function('f')
>>> x = Symbol('x')
>>> f(x).diff(x, x) + f(x)
        2
       d
f(x) + ---(f(x))
         2
       dx

>>> dsolve(f(x).diff(x, x) + f(x), f(x))
f(x) = C1*sin(x) + C2*cos(x)

Алгебраические уравнения

В isympy:

>>> from sympy import solve, symbols
>>> x, y = symbols('x,y')
>>> solve(x**4 - 1, x)
[-1, 1, -I, I]

>>> solve([x + 5*y - 2, -3*x + 6*y - 15], [x, y])
{x: -3, y: 1}

Линейная алгебра

Матрицы

Матрицы задаются с помощью конструктора Matrix:

>>> from sympy import Matrix, Symbol
>>> Matrix([[1, 0], [0, 1]])
[1  0]
[    ]
[0  1]

В матрицах вы также можете использовать символьные переменные:

>>> x = Symbol('x')
>>> y = Symbol('y')
>>> A = Matrix([[1, x], [y, 1]])
>>> A
[1  x]
[    ]
[y  1]

>>> A**2
[x*y + 1    2*x  ]
[                ]
[  2*y    x*y + 1]

Для того, чтобы узнать о матрицах подробнее, прочитайте, пожалуйста, Руководство по Линейной Алгебре.

Сопоставление с образцом

Чтобы сопоставить выражения с образцами, используйте функцию .match() вместе со вспомогательным классом Wild. Эта функция вернет словарь с необходимыми заменами, например:

>>> from sympy import Symbol, Wild
>>> x = Symbol('x')
>>> p = Wild('p')
>>> (5*x**2).match(p*x**2)
{p: 5}

>>> q = Wild('q')
>>> (x**2).match(p*x**q)
{p: 1, q: 2}

Если же сопоставление не удалось, функция вернет``None``:

>>> print (x + 1).match(p**x)
None

Также можно использовать параметр exclude для исключения некоторых значений из результата:

>>> p = Wild('p', exclude=[1, x])
>>> print (x + 1).match(x + p) # 1 is excluded
None
>>> print (x + 1).match(p + 1) # x is excluded
None
>>> print (x + 1).match(x + 2 + p) # -1 is not excluded
{p_: -1}

Печать

Реализовано несколько способов вывода выражений на экран.

Стандартный

Стандартный способ представлен функцией str(expression), которая работает следующим образом:

>>> from sympy import Integral
>>> from sympy.abc import x
>>> print x**2
x**2
>>> print 1/x
1/x
>>> print Integral(x**2, x)
Integral(x**2, x)

Красивая печать

Этот способ печати выражений основан на ascii-графике и реализован через функцию pprint:

>>> from sympy import Integral, pprint
>>> from sympy.abc import x
>>> pprint(x**2)
 2
x
>>> pprint(1/x)
1
-
x
>>> pprint(Integral(x**2, x))
  /
 |
 |  2
 | x  dx
 |
/

Если у вас установлен шрифт с юникодом, он будет использовать Pretty-print с юникодом по умолчанию. Эту настройку можно отключить, используя use_unicode:

>>> pprint(Integral(x**2, x), use_unicode=True)

⎮  2
⎮ x  dx

Для изучения подробных примеров работы Pretty-print с юникодом вы можете обратится к статье Pretty Printing из нашего Вики.

Совет: Чтобы активировать Pretty-print по умолчанию в интерпретаторе Python, используйте:

$ python
Python 2.5.2 (r252:60911, Jun 25 2008, 17:58:32)
[GCC 4.3.1] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> from sympy import init_printing, var, Integral
>>> init_printing(use_unicode=False, wrap_line=False, no_global=True)
>>> var("x")
x
>>> x**3/3
 3
x
--
3
>>> Integral(x**2, x) #doctest: +NORMALIZE_WHITESPACE
  /
 |
 |  2
 | x  dx
 |
/

Печать объектов Python

>>> from sympy.printing.python import python
>>> from sympy import Integral
>>> from sympy.abc import x
>>> print python(x**2)
x = Symbol('x')
e = x**2
>>> print python(1/x)
x = Symbol('x')
e = 1/x
>>> print python(Integral(x**2, x))
x = Symbol('x')
e = Integral(x**2, x)

Печать в формате LaTeX

>>> from sympy import Integral, latex
>>> from sympy.abc import x
>>> latex(x**2)
x^{2}
>>> latex(x**2, mode='inline')
$x^{2}$
>>> latex(x**2, mode='equation')
\begin{equation}x^{2}\end{equation}
>>> latex(x**2, mode='equation*')
\begin{equation*}x^{2}\end{equation*}
>>> latex(1/x)
\frac{1}{x}
>>> latex(Integral(x**2, x))
\int x^{2}\, dx

MathML

>>> from sympy.printing.mathml import mathml
>>> from sympy import Integral, latex
>>> from sympy.abc import x
>>> print mathml(x**2)
<apply><power/><ci>x</ci><cn>2</cn></apply>
>>> print mathml(1/x)
<apply><power/><ci>x</ci><cn>-1</cn></apply>

Pyglet

>>> from sympy import Integral, preview
>>> from sympy.abc import x
>>> preview(Integral(x**2, x)) 

Появится окно pyglet с отрисованным выражением LaTeX:

../_images/pngview1.png

Примечания

isympy вызывает pprint автоматически, по этой причине Pretty-print будет включен в isympy по умолчанию.

Также доступен модуль печати - sympy.printing. Через этот модуль доступны следующий функции печати:

  • pretty(expr), pretty_print(expr), pprint(expr): Возвращает или выводит на экран, соответственно, “Красивое” представление выражения expr.
  • latex(expr), print_latex(expr): Возвращает или выводит на экран, соответственно, LaTeX -представление expr
  • mathml(expr), print_mathml(expr): Возвращает или выводит на экран, соответственно, MathML -представление expr.
  • print_gtk(expr): Print expr to Gtkmathview, a GTK widget that displays MathML code. The Gtkmathview program is required.

Другие справочники

Чтобы узнать о SymPy подробнее, обратитесь Руководство пользователя SymPy и Описание модулей SymPy.

Также можно обратится на wiki.sympy.org - сайт, который содержит множество полезных примеров, руководств и советов. Они созданны нами и нашим сообществом. Мы будем рады, если и вы внесете в него свой весомый вклад.

Переводы

Этот текст доступен на других языках: