Symbolic Math with Python

The opposite of differentiation is integration. Sympy provides support for both indefinite and definite integrals. You can integrate elementary functions with:

integrate(sin(x), x)

You can integrate special functions too. For example:

integrate(exp(-x**2)*erf(x), x)

Definite integrals can be calculated by adding limits to the integration. If you integrate sin(x) from 0 to pi/2, you would use:

integrate(sin(x), (x, 0, pi/2))

Sympy also can handle some improper integrals. For example:

integrate(exp(x), (x, 0, oo))

Sometimes, equations are too complex to deal with analytically. In those cases, you need to generate a series expansion and calculate an approximation. Sympy provides the operator series to do this. For example, if you wanted a fourth-order series expansion of cos(x) about 0, you would use:

cos(x).series(x, 0, 4)
1 - (x**2)/2 + (x**4)/24

Sympy handles linear algebra through the use of the Matrixclass. If you are dealing with just numbers, you can use:

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

If you want to, you can define the dimensions of your matrix explicitly. This would look like:

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

You also can use symbolic variables in your matrices:

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

Once a matrix is created, you can operate on it. There are functions to do dot products, cross products or calculate determinants. Vectors are simply matrices made of either one row or one column.

Doing all of these calculations is a bit of a waste if you can't print out what you are doing in a form you can use. The most basic output is generated with the print command. If you want to dress it up some, you can use the pprint command. This command does some ASCII pretty-printing, using ASCII characters to display things like integral signs. If you want to generate output that you can use in a published article, you can make sympy generate LaTeX output. This is done with the latex function. Simply using the plain function will generate generic LaTeX output. For example:


You can hand in modes, however, for special cases. If you wanted to generate inline LaTeX, you could use:

latex(x**2, mode='inline')

You can generate full LaTeX equation output with:

latex(x**2, mode='equation')

To end, let's look at some gotchas that may crop up. The first thing to consider is the equal sign. A single equal sign is the assignment operator, while two equal signs are used for equality testing. Equality testing applies only to actual equality, not symbolic. So, testing the following will return false:

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

If you want to test whether two equations are equal, you need to subtract one from the other, and through careful use of expand, simplify and trigsimp, see whether you end up with 0. Sympy doesn't use the default Python int and float, because it provides more control. If you have an expression that contains only numbers, the default Python types are used. If you want to use the sympy data types, you can use the function sympify(), or S(). So, using Python data types, you get:

6.2 -> 6.2000000000000002

Whereas the sympy data types give:

S(6.2) -> 6.20000000000000

Expressions are immutable in sympy. Any functions applied to them do not change the expressions themselves, but instead return new expressions.

This article touched on only the most basic elements of sympy. But, I hope you have seen that it can be very useful in doing scientific calculations. And by using the isympy console, you have the flexibility to do interactive scientific analysis and work. If some functionality isn't there yet, remember that it is under active development, and also remember that you always can chip in and offer to help out.


Joey Bernard has a background in both physics and computer science. This serves him well in his day job as a computational research consultant at the University of New Brunswick. He also teaches computational physics and parallel programming.


Comment viewing options

Select your preferred way to display the comments and click "Save settings" to activate your changes.

It sound that this is a

billwu's picture

It sound that this is a perfect combination between mobile phones and automotive, no doubt, android industries have begun to enter our life, and I have been thinking recently, if Obd2 auto diagnostic software can be integrated into mobile applications, it will greatly change our lives, and even bring about a revolution again. Now many shop began selling android Obd2 auto diagnostic software product, I was no exception, welcome to my shop to see what the latest android Obd2 auto diagnostic software products. car diagnostic tool

Formula correction

OliverW.'s picture

Liked the article: short, to the point and offering a useful introduction. A worthy mention regarding the pretty printing options is that there is also the MathML output option, for those wanting to publish online. But you could also load the sympy environment in the IPython notebook then and have IPython render your formulas with Mathjax.

Just wanted to point out a small typo for the integration of exp(x) too:

In [3]: integrate(exp(x), (x, 0, oo))
Out[3]: ∞

In [4]: integrate(exp(-x), (x, 0, oo))
Out[4]: 1