# 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)
-cos(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))
1
```

Sympy also can handle some improper integrals. For example:

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

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
`Matrix`

class. 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:

```
latex(x**2)
x^{2}
```

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

```
latex(x**2, mode='inline')
$x^{2}$
```

You can generate full LaTeX equation output with:

```
latex(x**2, mode='equation')
\begin{equation}x^{2}\end{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.

## Trending Topics

Smoothwall Express | Feb 24, 2017 |

Machine Learning Everywhere | Feb 23, 2017 |

Ensono M.O. | Feb 22, 2017 |

Understanding OpenStack's Success | Feb 21, 2017 |

Natalie Rusk's Scratch Coding Cards (No Starch Press) | Feb 17, 2017 |

Own Your DNS Data | Feb 16, 2017 |

- Machine Learning Everywhere
- Smoothwall Express
- Bash Shell Script: Building a Better March Madness Bracket
- Own Your DNS Data
- Simple Server Hardening
- From vs. to + for Microsoft and Linux
- Understanding OpenStack's Success
- The Weather Outside Is Frightful (Or Is It?)
- Understanding Firewalld in Multi-Zone Configurations
- Ensono M.O.

## Comments

## It sound that this is a

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

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