# Symbolic Math with Python

Many programming languages include libraries to do more complicated math. You can do statistics, numerical analysis or handle big numbers. One topic many programming languages have difficulty with is symbolic math. If you use Python though, you have access to sympy, the symbolic math library. Sympy is under constant development, and it's aiming to be a full-featured computer algebra system (CAS). It also is written completely in Python, so you won't need to install any extra requirements. You can download a source tarball or a git repository if you want the latest and greatest. Most distributions also provide a package for sympy for those of you less concerned about being bleeding-edge. Once it is installed, you will be able to access the sympy library in two ways. You can access it like any other library with the import statement. But, sympy also provides a binary called isympy that is modeled after ipython.

In its simplest mode, sympy can be used as a calculator. Sympy has built-in support for three numeric types: float, rational and integer. Float and integer are intuitive, but what is a rational? A rational number is made of a numerator and a denominator. So, Rational(5,2) is equivalent to 5/2. There is also support for complex numbers. The imaginary part of a complex number is tagged with the constant I. So, a basic complex number is:

```
a + b*I
```

You can get the imaginary part with "im", and the real part with "re". You need to tell functions explicitly when they need to deal with complex numbers. For example, when doing a basic expansion, you get:

```
exp(I*x).expand() exp(I*x)
```

To get the actual expansion, you need to tell `expand`

that it is dealing
with complex numbers. This would look like:

```
exp(I*x).expand(complex=True)
```

All of the standard arithmetic operators, like addition, multiplication
and power are available. All of the usual functions also are available,
like trigonometric functions, special functions and so on. Special
constants, like e and pi, are treated symbolically in sympy. They
won't actually evaluate to a number, so something like "1+pi" remains
"1+pi". You actually have to use evalf explicitly to get a numeric
value. There is also a class, called `oo`

, which represents the concept
of infinity—a handy extra when doing more complicated mathematics.

Although this is useful, the real power of a CAS is the ability to do symbolic mathematics, like calculus or solving equations. Most other CASes automatically create symbolic variables when you use them. In sympy, these symbolic entities exist as classes, so you need to create them explicitly. You create them by using:

```
x = Symbol('x')
y = Symbol('y')
```

If you have more than one symbol at a time to define, you can use:

```
x,y = symbols('x', 'y')
```

Then, you can use them in other operations, like looking at equations. For example:

```
(x+y)**2
```

You then can apply operations to these equations, like expanding it:

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

You also can substitute these variables for other variables, or even numbers, using the substitution operator. For example:

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

You can decompose or combine more complicated equations too. For example, let's say you have the following:

```
(x+1)/(x-1)
```

Then, you can do a partial fraction decomposition with:

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

You can combine things back together again with:

```
together(1 + 2/(x-1))
(x+1)/(x-1)
```

When dealing with trigonometric functions, you need to tell operators like
`expand`

and `together`

about it. For example, you could use:

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

The really big use case for a CAS is calculus. Calculus is the backbone of
scientific calculations and is used in many situations. One of the
fundamental ideas in calculus is the limit. Sympy provides a function
called `limit`

to handle exactly that. You need to provide a function, a
variable and the value toward which the limit is being calculated. So, if
you wanted to calculate the limit of (sin(x)/x) as x goes to 0, you would
use:

```
limit(sin(x)/x, x, 0)
1
```

Because sympy provides an infinity object, you can calculate limits as they go to infinity. So, you can calculate:

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

Sympy also allows you to do differentiation. It can understand basic polynomials, as well as trigonometric functions. If you wanted to differentiate sin(x), then you could use:

```
x = Symbol('x')
diff(sin(x), x)
cos(x)
```

You can calculate higher derivatives by adding an extra parameter to the
`diff`

function call. So, calculating the first derivative of (x**2) can be
done with:

```
diff(x**2, x, 1)
2*x
```

While the second derivative can be done with:

```
diff(x**2, x, 2)
2
```

Sympy provides for calculating solutions to differential equations. You can
define a differential equation with the `diff`

function. For example:

```
f(x).diff(x,x) + f(x)
```

where `f(x)`

is the function of interest, and
`diff(x,x)`

takes the second
derivative of f(x) with respect to x. To solve this equation, you would use
the function `dsolve`

:

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

This is a very common task in scientific calculations.

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

## Webinar

### Practical Task Scheduling Deployment

July 20, 2016 12:00 pm CDT

One of the best things about the UNIX environment (aside from being stable and efficient) is the vast array of software tools available to help you do your job. Traditionally, a UNIX tool does only one thing, but does that one thing very well. For example, grep is very easy to use and can search vast amounts of data quickly. The find tool can find a particular file or files based on all kinds of criteria. It's pretty easy to string these tools together to build even more powerful tools, such as a tool that finds all of the .log files in the /home directory and searches each one for a particular entry. This erector-set mentality allows UNIX system administrators to seem to always have the right tool for the job.

Cron traditionally has been considered another such a tool for job scheduling, but is it enough? This webinar considers that very question. The first part builds on a previous Geek Guide, Beyond Cron, and briefly describes how to know when it might be time to consider upgrading your job scheduling infrastructure. The second part presents an actual planning and implementation framework.

Join *Linux Journal*'s Mike Diehl and Pat Cameron of Help Systems.

Free to *Linux Journal* readers.

SUSE LLC's SUSE Manager | Jul 21, 2016 |

My +1 Sword of Productivity | Jul 20, 2016 |

Non-Linux FOSS: Caffeine! | Jul 19, 2016 |

Murat Yener and Onur Dundar's Expert Android Studio (Wrox) | Jul 18, 2016 |

Rogue Wave Software's Zend Server | Jul 14, 2016 |

Webinar: Practical Task Scheduling Deployment | Jul 14, 2016 |

- SUSE LLC's SUSE Manager
- My +1 Sword of Productivity
- Non-Linux FOSS: Caffeine!
- Managing Linux Using Puppet
- Control Your Linux Desktop with D-Bus
- Download "Linux Management with Red Hat Satellite: Measuring Business Impact and ROI"
- Doing for User Space What We Did for Kernel Space
- SuperTuxKart 0.9.2 Released
- Google's SwiftShader Released
- Murat Yener and Onur Dundar's Expert Android Studio (Wrox)

## Geek Guides

With all the industry talk about the benefits of Linux on Power and all the performance advantages offered by its open architecture, you may be considering a move in that direction. If you are thinking about analytics, big data and cloud computing, you would be right to evaluate Power. The idea of using commodity x86 hardware and replacing it every three years is an outdated cost model. It doesn’t consider the total cost of ownership, and it doesn’t consider the advantage of real processing power, high-availability and multithreading like a demon.

This ebook takes a look at some of the practical applications of the Linux on Power platform and ways you might bring all the performance power of this open architecture to bear for your organization. There are no smoke and mirrors here—just hard, cold, empirical evidence provided by independent sources. I also consider some innovative ways Linux on Power will be used in the future.

Get the Guide
## 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