SymPy Core

Basic

class sympy.core.basic.Basic

Base class for all objects in sympy.

Conventions:

1) When you want to access parameters of some instance, always use .args: Example:

>>> from sympy import symbols, cot
>>> x, y = symbols('xy')
>>> cot(x).args
(x,)
>>> cot(x).args[0]
x
>>> (x*y).args
(x, y)
>>> (x*y).args[1]
y

2) Never use internal methods or variables (the ones prefixed with “_”). Example:

>>> cot(x)._args    #don't use this, use cot(x).args instead
(x,)
args

Returns a tuple of arguments of ‘self’.

Example:

>>> from sympy import symbols, cot
>>> x, y = symbols('xy')
>>> cot(x).args
(x,)
>>> cot(x).args[0]
x
>>> (x*y).args
(x, y)
>>> (x*y).args[1]
y

Note for developers: Never use self._args, always use self.args. Only when you are creating your own new function, use _args in the __new__. Don’t override .args() from Basic (so that it’s easy to change the interface in the future if needed).

as_basic()

Converts polynomial to a valid sympy expression.

>>> from sympy import *
>>> x,y = symbols('xy')
>>> p = (x**2 + x*y).as_poly(x, y)
>>> p.as_basic()
x*y + x**2
>>> f = sin(x)
>>> f.as_basic()
sin(x)
as_coeff_exponent(x)
c*x**e -> c,e where x can be any symbolic expression.
as_coefficient(expr)

Extracts symbolic coefficient at the given expression. In other words, this functions separates ‘self’ into product of ‘expr’ and ‘expr’-free coefficient. If such separation is not possible it will return None.

>>> from sympy import *
>>> x, y = symbols('xy')
>>> E.as_coefficient(E)
1
>>> (2*E).as_coefficient(E)
2
>>> (2*E + x).as_coefficient(E)
>>> (2*sin(E)*E).as_coefficient(E)
>>> (2*pi*I).as_coefficient(pi*I)
2
>>> (2*I).as_coefficient(pi*I)
as_independent(*deps)

Returns a pair with separated parts of a given expression independent of specified symbols in the first place and dependent on them in the other. Both parts are valid SymPy expressions.

>>> from sympy import *
>>> x, y = symbols('xy')
>>> (2*x*sin(x)+y+x).as_independent(x)
(y, x + 2*x*sin(x))
>>> (x*sin(x)*cos(y)).as_independent(x)
(cos(y), x*sin(x))

All other expressions are multiplicative:

>>> (sin(x)).as_independent(x)
(1, sin(x))
>>> (sin(x)).as_independent(y)
(sin(x), 1)
as_leading_term(*args, **kw_args)

Returns the leading term.

Example:

>>> x = Symbol("x")
>>> (1+x+x**2).as_leading_term(x)
1
>>> (1/x**2+x+x**2).as_leading_term(x)
1/x**2

Note:

self is assumed to be the result returned by Basic.series().

as_poly(*symbols, **flags)

Converts ‘self’ to a polynomial or returns None.

When constructing a polynomial an exception will be raised in case the input expression is not convertible to a polynomial. There are situations when it is easier (simpler or prettier) to receive None on failure.

If no symbols were given and ‘self’ isn’t already a polynomial then all available symbols will be collected and used to form a new polynomial.

>>> from sympy import *
>>> x,y = symbols('xy')
>>> print (x**2 + x*y).as_poly()
Poly(x**2 + x*y, x, y)
>>> print (x**2 + x*y).as_poly(x, y)
Poly(x**2 + x*y, x, y)
>>> print (x**2 + sin(y)).as_poly(x, y)
None
as_real_imag()

Performs complex expansion on ‘self’ and returns a tuple containing collected both real and imaginary parts. This method can’t be confused with re() and im() functions, which does not perform complex expansion at evaluation.

However it is possible to expand both re() and im() functions and get exactly the same results as with a single call to this function.

>>> from sympy import *
>>> x, y = symbols('xy', real=True)
>>> (x + y*I).as_real_imag()
(x, y)
>>> z, w = symbols('zw')
>>> (z + w*I).as_real_imag()
(-im(w) + re(z), im(z) + re(w))
assumptions0

Return object type assumptions.

For example:

Symbol(‘x’, real=True) Symbol(‘x’, integer=True)

are different objects. In other words, besides Python type (Symbol in this case), the initial assumptions are also forming their typeinfo.

Example:

>>> from sympy import Symbol
>>> x = Symbol("x")
>>> x.assumptions0
{}
>>> x = Symbol("x", positive=True)
>>> x.assumptions0
{'commutative': True, 'complex': True, 'imaginary': False,
'negative': False, 'nonnegative': True, 'nonpositive': False,
'nonzero': True, 'positive': True, 'real': True, 'zero': False}
atoms(*types)

Returns the atoms that form the current object. An atom is the smallest piece in which we can divide an expression.

Examples:

>>> from sympy import *
>>> x,y = symbols('xy')
>>> sorted((x+y**2 + 2*x*y).atoms())
[2, x, y]

You can also filter the results by a given type(s) of object:

>>> sorted((x+y+2+y**2*sin(x)).atoms(Symbol))
[x, y]
>>> sorted((x+y+2+y**3*sin(x)).atoms(Number))
[2, 3]
>>> sorted((x+y+2+y**2*sin(x)).atoms(Symbol, Number))
[2, x, y]

Or by a type of on object in an impliciy way:

>>> sorted((x+y+2+y**2*sin(x)).atoms(x))
[x, y]
coeff(x, expand=True)

Returns the coefficient of the term “x” or None if there is no “x”.

Optional expand keyword argument allows one to control whether the expression is expanded before terms are collected, which can be useful if the term “x” isn’t nested inside of terms and you don’t want the returned coefficient to be expanded.

Example:

>>> from sympy import symbols
>>> x, y, z = symbols('x y z')
>>> (3+2*x+4*x**2).coeff(1)
>>> (3+2*x+4*x**2).coeff(x)
2
>>> (3+2*x+4*x**2).coeff(x**2)
4
>>> (3+2*x+4*x**2).coeff(x**3)
>>> (z*(x+y)**2).coeff(z)
2*x*y + x**2 + y**2
>>> (z*(x+y)**2).coeff(z, expand=False)
(x + y)**2
>>>
compare(other)

Return -1,0,1 if the object is smaller, equal, or greater than other.

Not in the mathematical sense. If the object is of a different type from the “other” then their classes are ordered according to the sorted_classes list.

Example:

>>> from sympy import *
>>> x, y = symbols("x y")
>>> x.compare(y)
-1
>>> x.compare(x)
0
>>> y.compare(x)
1
static compare_pretty(a, b)

Is a>b in the sense of ordering in printing?

yes ..... return 1 no ...... return -1 equal ... return 0

Strategy:

It uses Basic.compare as a fallback, but improves it in many cases, like x**3, x**4, O(x**3) etc. In those simple cases, it just parses the expression and returns the “sane” ordering such as:

1 < x < x**2 < x**3 < O(x**4) etc.

Example:

>>> x = Symbol("x")
>>> Basic.compare_pretty(x, x**2)
-1
>>> Basic.compare_pretty(x**2, x**2)
0
>>> Basic.compare_pretty(x**3, x**2)
1
could_extract_minus_sign()

Canonical way to choose an element in the set {e, -e} where e is any expression. If the canonical element is e, we have e.could_extract_minus_sign() == True, else e.could_extract_minus_sign() == False.

For any expression, the set {e.could_extract_minus_sign(), (-e).could_extract_minus_sign()} must be {True, False}.

>>> from sympy import *
>>> x, y = symbols("xy")
>>> (x-y).could_extract_minus_sign() != (y-x).could_extract_minus_sign()
True
count_ops(*args, **kw_args)

Return the number of operations in expressions.

Examples: >>> (1+a+b**2).count_ops() POW + 2 * ADD >>> (sin(x)*x+sin(x)**2).count_ops() ADD + MUL + POW + 2 * SIN

doit(**hints)

Evaluate objects that are not evaluated by default like limits, integrals, sums and products. All objects of this kind will be evaluated unless some species were excluded via ‘hints’.

>>> from sympy import *
>>> x, y = symbols('xy')
>>> 2*Integral(x, x)
2*Integral(x, x)
>>> (2*Integral(x, x)).doit()
x**2
evalf(x, n=15, **options)

Evaluate the given formula to an accuracy of n digits. Optional keyword arguments:

subs=<dict>
Substitute numerical values for symbols, e.g. subs={x:3, y:1+pi}.
maxprec=N
Allow a maximum temporary working precision of N digits (default=100)
chop=<bool>
Replace tiny real or imaginary parts in subresults by exact zeros (default=False)
strict=<bool>
Raise PrecisionExhausted if any subresult fails to evaluate to full accuracy, given the available maxprec (default=False)
quad=<str>
Choose algorithm for numerical quadrature. By default, tanh-sinh quadrature is used. For oscillatory integrals on an infinite interval, try quad=’osc’.
verbose=<bool>
Print debug information (default=False)
expand(deep=True, power_base=True, power_exp=True, mul=True, log=True, multinomial=True, basic=True, **hints)

Expand an expression using hints.

See the docstring in function.expand for more information.

extract_additively(c)

Return None if it’s not possible to make self in the form something + c in a nice way, i.e. preserving the properties of arguments of self.

>>> from sympy import *
>>> x, y = symbols('xy', real=True)
>>> ((x*y)**3).extract_additively(1)
>>> (x+1).extract_additively(x)
1
>>> (x+1).extract_additively(2*x)
>>> (x+1).extract_additively(-x)
1 + 2*x
>>> (-x+1).extract_additively(2*x)
1 - 3*x
extract_multiplicatively(c)

Return None if it’s not possible to make self in the form c * something in a nice way, i.e. preserving the properties of arguments of self.

>>> from sympy import *
>>> x, y = symbols('xy', real=True)
>>> ((x*y)**3).extract_multiplicatively(x**2 * y)
x*y**2
>>> ((x*y)**3).extract_multiplicatively(x**4 * y)
>>> (2*x).extract_multiplicatively(2)
x
>>> (2*x).extract_multiplicatively(3)
>>> (Rational(1,2)*x).extract_multiplicatively(3)
x/6
func

The top-level function in an expression.

The following should hold for all objects:

>> x == x.func(*x.args)

Example:

>>> x = Symbol("x")
>>> a = 2*x
>>> a.func
<class 'sympy.core.mul.Mul'>
>>> a.args
(2, x)
>>> a.func(*a.args)
2*x
>>> a == a.func(*a.args)
True
getO(e)
Returns the O(..) symbol, or None if there is none.
has(*patterns)

Return True if self has any of the patterns.

Example: >>> x = Symbol(“x”) >>> (2*x).has(x) True >>> (2*x/x).has(x) False

has_all_symbols(*args, **kw_args)

Return True if ‘self’ has all of the symbols.

>>> from sympy import *
>>> x,y,z = symbols('xyz')
>>> (x**2 + sin(x*y)).has_all_symbols(x, y)
True
>>> (x**2 + sin(x*y)).has_all_symbols(x, y, z)
False
has_any_symbols(*args, **kw_args)

Return True if ‘self’ has any of the symbols.

>>> from sympy import *
>>> x,y,z = symbols('xyz')
>>> (x**2 + sin(x*y)).has_any_symbols(z)
False
>>> (x**2 + sin(x*y)).has_any_symbols(x, y)
True
>>> (x**2 + sin(x*y)).has_any_symbols(x, y, z)
True
is_number

Returns True if ‘self’ is a number.

>>> from sympy import *
>>> x,y = symbols('xy')
>>> x.is_number
False
>>> (2*x).is_number
False
>>> (2 + log(2)).is_number
True
is_rational_function(*syms)

Test whether function is rational function - ratio of two polynomials. When no arguments are present, Basic.atoms(Symbol) is used instead.

Example:

>>> from sympy import symbols, sin
>>> x, y = symbols('xy')
>>> (x/y).is_rational_function()
True
>>> (x**2).is_rational_function()
True
>>> (x/sin(y)).is_rational_function(y)
False
iter_basic_args()

Iterates arguments of ‘self’.

Example:

>>> x = Symbol("x")
>>> a = 2*x
>>> a.iter_basic_args()
<tupleiterator object at 0x...>
>>> list(a.iter_basic_args())
[2, x]
leadterm(x)

Returns the leading term a*x**b as a tuple (a, b).

Example:

>>> x = Symbol("x")
>>> (1+x+x**2).leadterm(x)
(1, 0)
>>> (1/x**2+x+x**2).leadterm(x)
(1, -2)

Note:

self is assumed to be the result returned by Basic.series().

limit(x, xlim, direction='+')
Compute limit x->xlim.
lseries(x, x0)

lseries is a generator yielding terms in the series.

Example: if you do:

for term in sin(x).lseries(x, 0):
print term

It will print all terms of the sin(x) series (i.e. it never terminates).

The advantage of lseries() over nseries() is that many times you are just interested in the next term in the series (i.e. the first term for example), but you don’t know how many you should ask for in nseries() using the “n” parameter.

See also nseries().

match(pattern)

Pattern matching.

Wild symbols match all.

Return None when expression (self) does not match with pattern. Otherwise return a dictionary such that

pattern.subs(self.match(pattern)) == self

Example:

>>> from sympy import symbols
>>> x, y = symbols("x y")
>>> p = Wild("p")
>>> q = Wild("q")
>>> r = Wild("r")
>>> e = (x+y)**(x+y)
>>> e.match(p**p)
{p_: x + y}
>>> e.match(p**q)
{p_: x + y, q_: x + y}
>>> e = (2*x)**2
>>> e.match(p*q**r)
{p_: 4, q_: x, r_: 2}
>>> (p*q**r).subs(e.match(p*q**r))
4*x**2
matches(pattern, expr, repl_dict={}, evaluate=False)

Helper method for match() - switches the pattern and expr.

Can be used to solve linear equations:
>>> from sympy import Symbol, Wild, Integer
>>> a,b = map(Symbol, 'ab')
>>> x = Wild('x')
>>> (a+b*x).matches(Integer(0))
{x_: -a/b}
n(x, n=15, **options)

Evaluate the given formula to an accuracy of n digits. Optional keyword arguments:

subs=<dict>
Substitute numerical values for symbols, e.g. subs={x:3, y:1+pi}.
maxprec=N
Allow a maximum temporary working precision of N digits (default=100)
chop=<bool>
Replace tiny real or imaginary parts in subresults by exact zeros (default=False)
strict=<bool>
Raise PrecisionExhausted if any subresult fails to evaluate to full accuracy, given the available maxprec (default=False)
quad=<str>
Choose algorithm for numerical quadrature. By default, tanh-sinh quadrature is used. For oscillatory integrals on an infinite interval, try quad=’osc’.
verbose=<bool>
Print debug information (default=False)
new(*args)

Create new ‘similar’ object.

this is conceptually equivalent to:

type(self) (*args)

but takes type assumptions into account. See also: assumptions0

Example:

>>> x = Symbol("x")
>>> x.new("x")
x
nseries(x, x0, n)

Calculates a generalized series expansion.

nseries calculates “n” terms in the innermost expressions and then builds up the final series just by “cross-mutliplying” everything out.

Advantage – it’s fast, because we don’t have to determine how many terms we need to calculate in advance.

Disadvantage – you may endup with less terms than you may have expected, but the O(x**n) term appended will always be correct, so the result is correct, but maybe shorter.

See also lseries().

removeO()
Removes the O(..) symbol if there is one
rewrite(*args, **hints)

Rewrites expression containing applications of functions of one kind in terms of functions of different kind. For example you can rewrite trigonometric functions as complex exponentials or combinatorial functions as gamma function.

As a pattern this function accepts a list of functions to to rewrite (instances of DefinedFunction class). As rule you can use string or a destination function instance (in this case rewrite() will use the str() function).

There is also possibility to pass hints on how to rewrite the given expressions. For now there is only one such hint defined called ‘deep’. When ‘deep’ is set to False it will forbid functions to rewrite their contents.

>>> from sympy import *
>>> x, y = symbols('xy')
>>> sin(x).rewrite(sin, exp)
-I*(exp(I*x) - exp(-I*x))/2
series(x, point=0, n=6, dir='+')

Series expansion of “self” around “point”.

Usage:

Returns the Taylor (Laurent or generalized) series of “self” around the point “point” (default 0) with respect to “x” until the n-th term (default n is 6).

For dir=”+” (default) it calculates the series from the right and for dir=”-” the series from the left. For smooth functions this argument doesn’t matter.

Notes:

This method is the most high level method and it returns the series including the O(x**n) term.

Internally, it executes a method nseries(), see nseries() docstring for more information.

solve4linearsymbol(eqn, rhs, symbols=None)

Solve equation “eqn == rhs” with respect to some linear symbol in eqn.

Returns (symbol, solution). If eqn is nonlinear with respect to all symbols, then return trivial solution (eqn, rhs).

subs(*args)

Substitutes an expression.

Calls either _subs_old_new, _subs_dict or _subs_list depending if you give it two arguments (old, new), a dictionary or a list.

Examples:

>>> from sympy import *
>>> x,y = symbols('xy')
>>> (1+x*y).subs(x, pi)
1 + pi*y
>>> (1+x*y).subs({x:pi, y:2})
1 + 2*pi
>>> (1+x*y).subs([(x,pi), (y,2)])
1 + 2*pi

Symbol

class sympy.core.symbol.Symbol
Assumptions::
real = True commutative = True
You can override the default assumptions in the constructor::
>>> A,B = symbols('AB', commutative = False)
>>> bool(A*B != B*A)
True
>>> bool(A*B*2 == 2*A*B) == True # multiplication by scalars is commutative
True

Add

class sympy.core.add.Add
extract_leading_order(*args, **kw_args)

Returns the leading term and it’s order.

Examples:

>>> (x+1+1/x**5).extract_leading_order(x)
((1/x**5, O(1/x**5)),)
>>> (1+x).extract_leading_order(x)
((1, O(1, x)),)
>>> (x+x**2).extract_leading_order(x)
((x, O(x)),)
classmethod flatten(seq)

Takes the sequence “seq” of nested Adds and returns a flatten list.

Returns: (commutative_part, noncommutative_part, order_symbols)

Applies associativity, all terms are commutable with respect to addition.

matches(pattern, expr, repl_dict={}, evaluate=False)

Matches Add/Mul “pattern” to an expression “expr”.

repl_dict ... a dictionary of (wild: expression) pairs, that get
returned with the results
evaluate .... if True, then repl_dict is first substituted into the
pattern, and then _matches_commutative is run

This function is the main workhorse for Add/Mul.

For instance:

>> from sympy import symbols, Wild, sin >> a = Wild(“a”) >> b = Wild(“b”) >> c = Wild(“c”) >> x, y, z = symbols(“x y z”) >> (a+b*c)._matches_commutative(x+y*z) {a_: x, b_: y, c_: z}

In the example above, “a+b*c” is the pattern, and “x+y*z” is the expression. Some more examples:

>> (a+b*c)._matches_commutative(sin(x)+y*z) {a_: sin(x), b_: y, c_: z} >> (a+sin(b)*c)._matches_commutative(x+sin(y)*z) {a_: x, b_: y, c_: z}

The repl_dict contains parts, that were already matched, and the “evaluate=True” kwarg tells _matches_commutative to substitute this repl_dict into pattern. For example here:

>> (a+b*c)._matches_commutative(x+y*z, repl_dict={a: x}, evaluate=True) {a_: x, b_: y, c_: z}

_matches_commutative substitutes “x” for “a” in the pattern and calls itself again with the new pattern “x+b*c” and evaluate=False (default):

>> (x+b*c)._matches_commutative(x+y*z, repl_dict={a: x}) {a_: x, b_: y, c_: z}

the only function of the repl_dict now is just to return it in the result, e.g. if you omit it:

>> (x+b*c)._matches_commutative(x+y*z) {b_: y, c_: z}

the “a: x” is not returned in the result, but otherwise it is equivalent.

Table Of Contents

Previous topic

SymPy Modules Reference

Next topic

Concrete Mathematics

This Page