Symbols
To make symbolic variables in SymPy you have to declare the variable explicitly:
Code Block | ||
---|---|---|
| ||
>>> from sympy import * >>> x = Symbol('x') >>> y = Symbol('y') |
You may then manipulate them as you want:
Code Block | ||
---|---|---|
| ||
>>> x + y + x - y 2*x >>> (x + y)**2 (x + y)**2 >>> ((x + y)**2).expand() x**2 + 2*x*y + y**2 |
You can also substitute variables for numbers or other symbolic variables with subs(var, substitution).
Code Block | ||
---|---|---|
| ||
>>> ((x + y)**2).subs(x, 1) (y + 1)**2 >>> ((x + y)**2).subs(x, y) 4*y**2 |
Some regular constants are already included in SymPy as symbols, like e, pi and infinite. evalf() evaluates the symbols as floation-point numbers.
Code Block | ||
---|---|---|
| ||
>>> pi**2 pi**2 >>> pi.evalf() 3.141592653589793238462643383 <<< E**2 exp(2) >>> oo > 99999 True >>> oo + 1 oo |
Differentiation
You can differentiate any SymPy expression using diff(func, var). Higher derivatives can be solved using diff(func, var, n).
Code Block | ||
---|---|---|
| ||
>>> from sympy import * >>> x = Symbol('x') >>> diff(sin(x), x) cos(x) >>> diff(sin(2*x), x, 1) 2*cos(2*x) >>> diff(sin(2*x), x, 2) -4*sin(2*x) |
Integration
SymPy has support for both indefinite and definite integration.
Code Block | ||
---|---|---|
| ||
>>> from sympy import * >>> x, y = symbols('x y') |
Indefinite integration of some elementary functions:
Code Block | ||
---|---|---|
| ||
>>> integrate(6*x**5, x) x**6 >>> integrate(log(x), x) x*log(x) - x >>> integrate(2*x + sinh(x), x) x**2 + cosh(x) |
Definite integration:
Code Block | ||
---|---|---|
| ||
>>> integrate(x**3, (x, -1, 1)) 0 >>> integrate(sin(x), (x, 0, pi/2)) 1 |
Some special integrals:
Code Block | ||
---|---|---|
| ||
>>> integrate(exp(-x), (x, 0, oo)) 1 >>> integrate(log(x), (x, 0, 1)) -1 |
Algebraic equations
SymPy is able to solve algebraic equations with one or several variables. solve(equation, variable) takes as first argument an equation that is supposed to be equaled to 0, and as second argument the variable to solve for. In case of multiple equations and variables, solve returns a dictonary containing the results. Note that SymPy also handles complex numbers using the symbol I.
Code Block | ||
---|---|---|
| ||
>>> from sympy import * >>> x = Symbol('x') >>> solve(x**2 - 1, x) [-1, 1] >>> solve([x + 5*y - 2, -3*x + 6*y - 15], [x, y]) {x: -3, y: 1} >>> solve(Eq(x**4, 1), x) [-1, 1, -I, I] |
nsolve(function, [variables], x0) is a useful tool to solve nonlinear equation systems numerically, where x0 is a starting vector close to the solution. If there is only one variable, the second argument may be left out.
Code Block | ||
---|---|---|
| ||
>>> nsolve(sin(x), x, 2) 3.14159265358979 >>> nsolve(sin(x), 2) 3.14159265358979 >>> nsolve(sin(x**2)/(pi - x), x, pi.evalf()/2) 1.77245385090552 |
However, if you would like to compute all solutions to a problem, solvset is the way to go. Considering the difficulty of some of the return values computed by solveset, we highly recommend you to read the official documentation. We will only cover the function brifely, although some more advanced examples will be added to the Exercises and solutions, symbolic mathematics.
Code Block | ||
---|---|---|
| ||
>>> solveset(x - x, x) # The function x = x S.Complexes |
The return value in the example above is a Set, more specific the set class Complexes, which represents the set of all complex numbers,
Exercises and solutions
If you want have a look at some exercises and solutions regarding SymPy and sybolic mathematics in Python, check out Exercises and solutions, symbolic mathematics.
Info |
---|
The exercises provided will have a varying degree of difficulty, thus including more advanced and detailed methods than described here. |