# 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
>>> from sympy.abc import x, y
```
```>>> 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
>>> from sympy.abc import x, y
```
```>>> 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_poly(*gens, **args)

Converts to a polynomial or returns .

```>>> from sympy import Poly, sin
>>> from sympy.abc import x, y
```
```>>> print (x**2 + x*y).as_poly()
Poly(x**2 + x*y, x, y, domain='ZZ')
```
```>>> print (x**2 + x*y).as_poly(x, y)
Poly(x**2 + x*y, x, y, domain='ZZ')
```
```>>> print (x**2 + sin(y)).as_poly(x, y)
None
```
assumptions0

Return object 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
>>> from sympy.abc import 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.

By default, only objects that are truly atomic and can’t be divided into smaller pieces are returned: symbols, numbers, and number symbols like I and pi. It is possible to request atoms of any type, however, as demonstrated below.

Examples:

```>>> from sympy import I, pi, sin
>>> from sympy.abc import x, y
>>> (1 + x + 2*sin(y + I*pi)).atoms()
```

set([1, 2, I, pi, x, y])

If one or more types are given, the results will contain only those types of atoms:

Examples:

```>>> from sympy import Number, NumberSymbol, Symbol
>>> (1 + x + 2*sin(y + I*pi)).atoms(Symbol)
```

set([x, y])

```>>> (1 + x + 2*sin(y + I*pi)).atoms(Number)
set([1, 2])
```
```>>> (1 + x + 2*sin(y + I*pi)).atoms(Number, NumberSymbol)
set([1, 2, pi])
```
```>>> (1 + x + 2*sin(y + I*pi)).atoms(Number, NumberSymbol, I)
set([1, 2, I, pi])
```

Note that I (imaginary unit) and zoo (complex infinity) are special types of number symbols and are not part of the NumberSymbol class.

The type can be given implicitly, too:

```>>> (1 + x + 2*sin(y + I*pi)).atoms(x) # x is a Symbol
```

set([x, y])

Be careful to check your assumptions when using the implicit option since S(1).is_Integer = True but type(S(1)) is One, a special type of sympy atom, while type(S(2)) is type Integer and will find all integers in an expression:

```>>> from sympy import S
>>> (1 + x + 2*sin(y + I*pi)).atoms(S(1))
```

set([1])

```>>> (1 + x + 2*sin(y + I*pi)).atoms(S(2))
set([1, 2])
```

Finally, arguments to atoms() can select more than atomic atoms: any sympy type (loaded in core/__init__.py) can be listed as an argument and those types of “atoms” as found in scanning the arguments of the expression recursively:

```>>> from sympy import Function, Mul
>>> (1 + x + 2*sin(y + I*pi)).atoms(Function)
```

set([sin(y + I*pi)])

```>>> (1 + x + 2*sin(y + I*pi)).atoms(Mul)
set([I*pi, 2*sin(y + I*pi)])
```
classmethod class_key()

Nice order of classes.

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.abc import 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:

```>>> from sympy.abc import x
>>> from sympy import Basic, Number
>>> Basic._compare_pretty(x, x**2)
-1
>>> Basic._compare_pretty(x**2, x**2)
0
>>> Basic._compare_pretty(x**3, x**2)
1
>>> Basic._compare_pretty(Number(1, 2), Number(1, 3))
1
>>> Basic._compare_pretty(Number(0), Number(-1))
1
```
count(query)

Count the number of matching subexpressions.

count_ops(visual=None)

wrapper for count_ops that returns the operation count.

doit(**hints)

Evaluate objects that are not evaluated by default like limits, integrals, sums and products. All objects of this kind will be evaluated recursively, unless some species were excluded via ‘hints’ or unless the ‘deep’ hint was set to ‘False’.

```>>> from sympy import Integral
>>> from sympy.abc import x, y
```
```>>> 2*Integral(x, x)
2*Integral(x, x)
```
```>>> (2*Integral(x, x)).doit()
x**2
```
```>>> (2*Integral(x, x)).doit(deep = False)
2*Integral(x, x)
```
dummy_eq(other, symbol=None)

Compare two expressions and handle dummy symbols.

Examples

```>>> from sympy import Dummy
>>> from sympy.abc import x, y
```
```>>> u = Dummy('u')
```
```>>> (u**2 + 1).dummy_eq(x**2 + 1)
True
>>> (u**2 + 1) == (x**2 + 1)
False
```
```>>> (u**2 + y).dummy_eq(x**2 + y, x)
True
>>> (u**2 + y).dummy_eq(x**2 + y, y)
False
```
find(query, group=False)

Find all subexpressions matching a query.

free_symbols

Return from the atoms of self those which are free symbols.

For most expressions, all symbols are free symbols. For some classes this is not true. e.g. Integrals use Symbols for the dummy variables which are bound variables, so Integral has a method to return all symbols except those. Derivative keeps track of symbols with respect to which it will perform a derivative; those are bound variables, too, so it has its own symbols method.

Any other method that uses bound variables should implement a symbols method.

func

The top-level function in an expression.

The following should hold for all objects:

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

Example:

```>>> from sympy.abc import 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
```
has(*args, **kw_args)

Test whether any subexpression matches any of the patterns.

Examples: >>> from sympy import sin, S >>> from sympy.abc import x, y, z >>> (x**2 + sin(x*y)).has(z) False >>> (x**2 + sin(x*y)).has(x, y, z) True >>> x.has(x) True

Note that expr.has(*patterns) is exactly equivalent to any(expr.has(p) for p in patterns). In particular, False is returned when the list of patterns is empty. >>> x.has() False

is_Real

Deprecated alias for is_Float

is_number

Returns True if ‘self’ is a number.

```>>> from sympy import log, Integral
>>> from sympy.abc import x, y
```
```>>> x.is_number
False
>>> (2*x).is_number
False
>>> (2 + log(2)).is_number
True
>>> (2 + Integral(2, x)).is_number
False
>>> (2 + Integral(2, (x, 1, 2))).is_number
True
```
iter_basic_args()

Iterates arguments of ‘self’.

Example:

```>>> from sympy.abc import x
>>> a = 2*x
>>> a.iter_basic_args()
<tupleiterator object at 0x...>
>>> list(a.iter_basic_args())
[2, x]
```
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, Wild
>>> from sympy.abc import 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(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}
```
replace(query, value, map=False)

Replace matching subexpressions of self with value.

If map=True then also return the mapping {old: new} where was a sub-expression found with query and new is the replacement value for it.

Traverses an expression tree and performs replacement of matching subexpressions from the bottom to the top of the tree. The list of possible combinations of queries and replacement values is listed below:

1.1. type -> type
obj.replace(sin, tan)
1.2. type -> func
obj.replace(sin, lambda expr, arg: ...)
2.1. expr -> expr
obj.replace(sin(a), tan(a))
2.2. expr -> func
obj.replace(sin(a), lambda a: ...)
3.1. func -> func
obj.replace(lambda expr: ..., lambda expr: ...)

Examples:

```>>> from sympy import log, sin, cos, tan, Wild
>>> from sympy.abc import x
```
```>>> f = log(sin(x)) + tan(sin(x**2))
```
```>>> f.replace(sin, cos)
log(cos(x)) + tan(cos(x**2))
>>> f.replace(sin, lambda arg: sin(2*arg))
log(sin(2*x)) + tan(sin(2*x**2))
```
```>>> sin(x).replace(sin, cos, map=True)
(cos(x), {sin(x): cos(x)})
```
```>>> a = Wild('a')
```
```>>> f.replace(sin(a), cos(a))
log(cos(x)) + tan(cos(x**2))
>>> f.replace(sin(a), lambda a: sin(2*a))
log(sin(2*x)) + tan(sin(2*x**2))
```
```>>> g = 2*sin(x**3)
```
```>>> g.replace(lambda expr: expr.is_Number, lambda expr: expr**2)
4*sin(x**9)
```
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 sin, exp, I
>>> from sympy.abc import x, y
```
```>>> sin(x).rewrite(sin, exp)
-I*(exp(I*x) - exp(-I*x))/2
```
sort_key(order=None)

Return a sort key.

Examples

```>>> from sympy.core import Basic, S, I
>>> from sympy.abc import x
```
```>>> sorted([S(1)/2, I, -I], key=lambda x: x.sort_key())
[1/2, -I, I]
```
```>>> S("[x, 1/x, 1/x**2, x**2, x**(1/2), x**(1/4), x**(3/2)]")
[x, 1/x, x**(-2), x**2, x**(1/2), x**(1/4), x**(3/2)]
>>> sorted(_, key=lambda x: x.sort_key())
[x**(-2), 1/x, x**(1/4), x**(1/2), x, x**(3/2), x**2]
```
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 pi
>>> from sympy.abc import x, y
>>> (1 + x*y).subs(x, pi)
pi*y + 1
>>> (1 + x*y).subs({x:pi, y:2})
1 + 2*pi
>>> (1 + x*y).subs([(x,pi), (y,2)])
1 + 2*pi
```
```>>> (x + y).subs([(y,x**2), (x,2)])
6
>>> (x + y).subs([(x,2), (y,x**2)])
x**2 + 2
```

## Expr¶

class sympy.core.expr.Expr
apart(x=None, **args)

See the apart function in sympy.polys

args_cnc()

treat self as Mul and split it into tuple (set, list) where contains the commutative parts and contains the ordered non-commutative args.

A special treatment is that -1 is separated from a Rational:

```>>> from sympy import symbols
>>> A, B = symbols('A B', commutative=0)
>>> x, y = symbols('x y')
>>> (-2*x*y).args_cnc()
[set([-1, 2, x, y]), []]
>>> (-2*x*A*B*y).args_cnc()
[set([-1, 2, x, y]), [A, B]]
```

The arg is treated as a Mul:

```>>> (-2 + x + A).args_cnc()
[set(), [x - 2 + A]]
```
as_coeff_Mul()

Efficiently extract the coefficient of a product.

Return the tuple (c, args) where self is written as an Add, .

c should be a Rational added to any terms of the Add that are independent of deps.

args should be a tuple of all other terms of ; args is empty if self is a Number or if self is independent of deps (when given).

This should be used when you don’t know if self is an Add or not but you want to treat self as an Add or if you want to process the individual arguments of the tail of self as an Add.

• if you know self is an Add and want only the head, use self.args[0];
• if you don’t want to process the arguments of the tail but need the tail then use self.as_two_terms() which gives the head and tail.
• if you want to split self into an independent and dependent parts use self.as_independent(*deps)
```>>> from sympy import S
>>> from sympy.abc import x, y
(3, ())
>>> (3 + x + y).as_coeff_add()
(3, (y, x))
>>> (3 + x +y).as_coeff_add(x)
(y + 3, (x,))
>>> (3 + y).as_coeff_add(x)
(y + 3, ())
```
as_coeff_exponent(x)

c*x**e -> c,e where x can be any symbolic expression.

as_coeff_mul(*deps)

Return the tuple (c, args) where self is written as a Mul, .

c should be a Rational multiplied by any terms of the Mul that are independent of deps.

args should be a tuple of all other terms of m; args is empty if self is a Number or if self is independent of deps (when given).

This should be used when you don’t know if self is a Mul or not but you want to treat self as a Mul or if you want to process the individual arguments of the tail of self as a Mul.

• if you know self is a Mul and want only the head, use self.args[0];
• if you don’t want to process the arguments of the tail but need the tail then use self.as_two_terms() which gives the head and tail;
• if you want to split self into an independent and dependent parts use self.as_independent(*deps)
```>>> from sympy import S
>>> from sympy.abc import x, y
>>> (S(3)).as_coeff_mul()
(3, ())
>>> (3*x*y).as_coeff_mul()
(3, (x, y))
>>> (3*x*y).as_coeff_mul(x)
(3*y, (x,))
>>> (3*y).as_coeff_mul(x)
(3*y, ())
```
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 E, pi, sin, I, symbols
>>> from sympy.abc import x, y
```
```>>> E.as_coefficient(E)
1
>>> (2*E).as_coefficient(E)
2
>>> (2*sin(E)*E).as_coefficient(E)
```
```>>> (2*E + x*E).as_coefficient(E)
x + 2
>>> (2*E*x + x).as_coefficient(E)
```
```>>> (E*(x + 1) + x).as_coefficient(E)
```
```>>> (2*pi*I).as_coefficient(pi*I)
2
>>> (2*I).as_coefficient(pi*I)
```
as_expr(*gens)

Convert a polynomial to a SymPy expression.

Examples

```>>> from sympy import sin
>>> from sympy.abc import x, y
```
```>>> f = (x**2 + x*y).as_poly(x, y)
>>> f.as_expr()
x**2 + x*y
```
```>>> sin(x).as_expr()
sin(x)
```
as_independent(*deps, **hint)

A mostly naive separation of a Mul or Add into arguments that are not/ are dependent on deps. To obtain as complete a separation of variables as possible, use a separation method first, e.g.:

separatevars() to change Mul, Add and Pow (including exp) into Mul .expand(mul=True) to change Add or Mul into Add .expand(log=True) to change log expr into an Add

The only non-naive thing that is done here is to respect noncommutative ordering of variables.

The returned tuple (i, d) has the following interpretation:

• i will has no variable that appears in deps
• d will be 1 or else have terms that contain variables that are in deps
• if self is an Add then self = i + d
• if self is a Mul then self = i*d
• if self is anything else, either tuple (self, S.One) or (S.One, self) is returned.

To force the expression to be treated as an Add, use the hint as_Add=True

Examples:

– self is an Add
```>>> from sympy import sin, cos, exp
>>> from sympy.abc import x, y, z
```
```>>> (x + x*y).as_independent(x)
(0, x*y + x)
>>> (x + x*y).as_independent(y)
(x, x*y)
>>> (2*x*sin(x) + y + x + z).as_independent(x)
(y + z, 2*x*sin(x) + x)
>>> (2*x*sin(x) + y + x + z).as_independent(x, y)
(z, 2*x*sin(x) + x + y)
```

—self is a Mul >>> (x*sin(x)*cos(y)).as_independent(x) (cos(y), x*sin(x))

non-commutative terms cannot always be separated out when self is a Mul
```>>> from sympy import symbols
>>> n1, n2, n3 = symbols('n1 n2 n3', commutative=False)
>>> (n1 + n1*n2).as_independent(n2)
(n1, n1*n2)
>>> (n2*n1 + n1*n2).as_independent(n2)
(0, n1*n2 + n2*n1)
>>> (n1*n2*n3).as_independent(n1)
(1, n1*n2*n3)
>>> (n1*n2*n3).as_independent(n2)
(n1, n2*n3)
```

—self is anything else: >>> (sin(x)).as_independent(x) (1, sin(x)) >>> (sin(x)).as_independent(y) (sin(x), 1) >>> exp(x+y).as_independent(x) (1, exp(x + y))

– force self to be treated as an Add:
```>>> (3*x).as_independent(x, as_Add=1)
(0, 3*x)
```

—force self to be treated as a Mul: >>> (3+x).as_independent(x, as_Add=0) (1, x + 3) >>> (-3+x).as_independent(x, as_Add=0) (1, x - 3)

Note how the below differs from the above in making the constant on the dep term positive. >>> (y*(-3+x)).as_independent(x) (y, x - 3)

Note: when trying to get independent terms, a separation method might need to be used first. In this case, it is important to keep track of what you send to this routine so you know how to interpret the returned values

```>>> from sympy import separatevars, log
>>> separatevars(exp(x+y)).as_independent(x)
(exp(y), exp(x))
>>> (x + x*y).as_independent(y)
(x, x*y)
>>> separatevars(x + x*y).as_independent(y)
(x, y + 1)
>>> (x*(1 + y)).as_independent(y)
(x, y + 1)
>>> (x*(1 + y)).expand(mul=True).as_independent(y)
(x, x*y)
>>> a, b=symbols('a b',positive=True)
>>> (log(a*b).expand(log=True)).as_independent(b)
(log(a), log(b))
```

Returns the leading term.

Example:

```>>> from sympy.abc import x
1
x**(-2)
```

Note:

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

as_numer_denom()

a/b -> a,b

This is just a stub that should be defined by an object’s class methods to get anything else.

as_ordered_factors(order=None)

Transform an expression to an ordered list of factors.

Examples

```>>> from sympy import sin, cos
>>> from sympy.abc import x, y
```
```>>> (2*x*y*sin(x)*cos(x)).as_ordered_factors()
[2, x, y, sin(x), cos(x)]
```
as_ordered_terms(order=None, data=False)

Transform an expression to an ordered list of terms.

Examples

```>>> from sympy import sin, cos
>>> from sympy.abc import x, y
```
```>>> (sin(x)**2*cos(x) + sin(x)**2 + 1).as_ordered_terms()
[sin(x)**2*cos(x), sin(x)**2, 1]
```
as_real_imag(deep=True)

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 symbols, I
```
```>>> x, y = symbols('x,y', real=True)
```
```>>> (x + y*I).as_real_imag()
(x, y)
```
```>>> from sympy.abc import z, w
```
```>>> (z + w*I).as_real_imag()
(-im(w) + re(z), im(z) + re(w))
```
as_terms()

Transform an expression to a list of terms.

cancel(*gens, **args)

See the cancel function in sympy.polys

coeff(x, right=False)

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

When x is noncommutative, the coeff to the left (default) or right of x can be returned. The keyword ‘right’ is ignored when x is commutative.

Examples:

```>>> from sympy import symbols
>>> from sympy.abc import x, y, z
```

You can select terms that have an explicit negative in front of them:

```>>> (-x+2*y).coeff(-1)
x
>>> (x-2*y).coeff(-1)
2*y
```

You can select terms with no rational coefficient:

```>>> (x+2*y).coeff(1)
x
>>> (3+2*x+4*x**2).coeff(1)
```

You can select terms that have a numerical term in front of them:

```>>> (-x-2*y).coeff(2)
-y
>>> from sympy import sqrt
>>> (x+sqrt(2)*x).coeff(sqrt(2))
x
```

The matching is exact:

```>>> (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((x+y)**2)
z
>>> (z*(x+y)**2).coeff(x+y)
```

In addition, no factoring is done, so 2 + y is not obtained from the following:

```>>> (2*x+2+(x+1)*y).coeff(x+1)
y
```
```>>> n, m, o = symbols('n m o', commutative=False)
>>> n.coeff(n)
1
>>> (3*n).coeff(n)
3
>>> (n*m + m*n*m).coeff(n) # = (1 + m)*n*m
1 + m
>>> (n*m + m*n*m).coeff(n, right=True) # = (1 + m)*n*m
m
```

If there is more than one possible coefficient None is returned:

```>>> (n*m + m*n).coeff(n)
```

If there is only one possible coefficient, it is returned:

```>>> (n*m + o*m*n).coeff(m*n)
o
>>> (n*m + o*m*n).coeff(m*n, right=1)
1
```
collect(syms, evaluate=True, exact=False)

See the collect function in sympy.simplify

combsimp()

See the combsimp function in sympy.simplify

as_leading_term is only allowed for results of .series() This is a wrapper to compute a series first. If skip_abs is true, the absolute term is assumed to be zero. (This is necessary because sometimes it cannot be simplified

to zero without a lot of work, but is still known to be zero. See log._eval_nseries for an example.)

If skip_log is true, log(x) is treated as an independent symbol. (This is needed for the gruntz algorithm.)

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.abc import x, y
>>> (x-y).could_extract_minus_sign() != (y-x).could_extract_minus_sign()
True
```
count_ops(visual=None)

wrapper for count_ops that returns the operation count.

expand(deep=True, modulus=None, 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.

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 symbols
```
```>>> x, y = symbols('x,y', 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)
2*x + 1
```
```>>> (-x+1).extract_additively(2*x)
-3*x + 1
```
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 symbols, Rational
```
```>>> x, y = symbols('x,y', 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
```
factor(*gens, **args)

See the factor() function in sympy.polys.polytools

getO()

Returns the additive O(..) symbol if there is one, else None.

getn()

Returns the order of the expression.

The order is determined either from the O(...) term. If there is no O(...) term, it returns None.

Example: >>> from sympy import O >>> from sympy.abc import x >>> (1 + x + O(x**2)).getn() 2 >>> (1 + x).getn() >>>

integrate(*args, **kwargs)

See the integrate function in sympy.integrals

invert(g)

See the invert function in sympy.polys

is_number

Returns True if ‘self’ is a number.

```>>> from sympy import log, Integral
>>> from sympy.abc import x, y
```
```>>> x.is_number
False
>>> (2*x).is_number
False
>>> (2 + log(2)).is_number
True
>>> (2 + Integral(2, x)).is_number
False
>>> (2 + Integral(2, (x, 1, 2))).is_number
True
```
is_polynomial(*syms)

Return True if self is a polynomial in syms and False otherwise.

This checks if self is an exact polynomial in syms. This function returns False for expressions that are “polynomials” with symbolic exponents. Thus, you should be able to apply polynomial algorithms to expressions for which this returns True, and Poly(expr, *syms) should work only if and only if expr.is_polynomial(*syms) returns True. The polynomial does not have to be in expanded form. If no symbols are given, all free symbols in the expression will be used.

This is not part of the assumptions system. You cannot do Symbol(‘z’, polynomial=True).

Examples >>> from sympy import Symbol >>> x = Symbol(‘x’) >>> ((x**2 + 1)**4).is_polynomial(x) True >>> ((x**2 + 1)**4).is_polynomial() True >>> (2**x + 1).is_polynomial(x) False

```>>> n = Symbol('n', nonnegative=True, integer=True)
>>> (x**n + 1).is_polynomial(x)
False
```

This function does not attempt any nontrivial simplifications that may result in an expression that does not appear to be a polynomial to become one.

```>>> from sympy import sqrt, factor, cancel
>>> y = Symbol('y', positive=True)
>>> a = sqrt(y**2 + 2*y + 1)
>>> a.is_polynomial(y)
False
>>> factor(a)
y + 1
>>> factor(a).is_polynomial(y)
True
```
```>>> b = (y**2 + 2*y + 1)/(y + 1)
>>> b.is_polynomial(y)
False
>>> cancel(b)
y + 1
>>> cancel(b).is_polynomial(y)
True
```

is_rational_function(*syms)

Test whether function is a ratio of two polynomials in the given symbols, syms. When syms is not given, all free symbols will be used. The rational function does not have to be in expanded or in any kind of canonical form.

This function returns False for expressions that are “rational functions” with symbolic exponents. Thus, you should be able to call .as_numer_denom() and apply polynomial algorithms to the result for expressions for which this returns True.

This is not part of the assumptions system. You cannot do Symbol(‘z’, rational_function=True).

Example:

```>>> from sympy import Symbol, sin
>>> from sympy.abc import x, y
```
```>>> (x/y).is_rational_function()
True
```
```>>> (x**2).is_rational_function()
True
```
```>>> (x/sin(y)).is_rational_function(y)
False
```
```>>> n = Symbol('n', integer=True)
>>> (x**n + 1).is_rational_function(x)
False
```

This function does not attempt any nontrivial simplifications that may result in an expression that does not appear to be a rational function to become one.

```>>> from sympy import sqrt, factor, cancel
>>> y = Symbol('y', positive=True)
>>> a = sqrt(y**2 + 2*y + 1)/y
>>> a.is_rational_function(y)
False
>>> factor(a)
(y + 1)/y
>>> factor(a).is_rational_function(y)
True
```

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

Example:

```>>> from sympy.abc import x
(1, 0)
(1, -2)
```

Note:

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

limit(x, xlim, dir='+')

Compute limit x->xlim.

lseries(x=None, x0=0, dir='+')

Wrapper for series yielding an iterator of the terms of the series.

Note: an infinite series will yield an infinite iterator. The following, for exaxmple, will never terminate. It will just keep printing terms of the sin(x) series:

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

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.

nseries(x=None, x0=0, n=6, dir='+', logx=None)

Wrapper to _eval_nseries if assumptions allow, else to series.

If x is given, x0 is 0, dir=’+’, and self has x, then _eval_nseries is called. This calculates “n” terms in the innermost expressions and then builds up the final series just by “cross-multiplying” 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 end up with less terms than you may have expected, but the O(x**n) term appended will always be correct and so the result, though perhaps shorter, will also be correct.

If any of those assumptions is not met, this is treated like a wrapper to series which will try harder to return the correct number of terms.

nsimplify(constants=[], tolerance=None, full=False)

See the nsimplify function in sympy.simplify

powsimp(deep=False, combine='all')

See the powsimp function in sympy.simplify

See the radsimp function in sympy.simplify

ratsimp()

See the ratsimp function in sympy.simplify

refine(assumption=True)

See the refine function in sympy.assumptions

removeO()

Removes the additive O(..) symbol if there is one

separate(deep=False, force=False)

See the separate function in sympy.simplify

series(x=None, x0=0, n=6, dir='+')

Series expansion of “self” around yielding either terms of the series one by one (the lazy series given when n=None), else all the terms at once when n != None.

Note: when n != None, if an O() term is returned then the x in the in it and the entire expression represents x - x0, the displacement from x0. (If there is no O() term then the series was exact and x has it’s normal meaning.) This is currently necessary since sympy’s O() can only represent terms at x0=0. So instead of

>> cos(x).series(x0=1, n=2) (1 - x)*sin(1) + cos(1) + O((x - 1)**2)

which graphically looks like this:

.|. . .

. | . .

—+———————-
. . . .
x=0

the following is returned instead

-x*sin(1) + cos(1) + O(x**2)

whose graph is this

|

. .| . .

. . .

—–+——————.
. . . .
x=0

which is identical to cos(x + 1).series(n=2).

Usage:

Returns the series expansion of “self” around the point with respect to up to O(x**n) (default n is 6).

If and is univariate, the univariate symbol will be supplied, otherwise an error will be raised.

```>>> from sympy import cos, exp
>>> from sympy.abc import x, y
>>> cos(x).series()
1 - x**2/2 + x**4/24 + O(x**6)
>>> cos(x).series(n=4)
1 - x**2/2 + O(x**4)
>>> e = cos(x + exp(y))
>>> e.series(y, n=2)
cos(x + 1) - y*sin(x + 1) + O(y**2)
>>> e.series(x, n=2)
cos(exp(y)) - x*sin(exp(y)) + O(x**2)
```

If then an iterator of the series terms will be returned.

```>>> term=cos(x).series(n=None)
>>> [term.next() for i in range(2)]
[1, -x**2/2]
```

For (default) the series is calculated from the right and for the series from the left. For smooth functions this flag will not alter the results.

```>>> abs(x).series(dir="+")
x
>>> abs(x).series(dir="-")
-x
```
simplify()

See the simplify function in sympy.simplify

together(*args, **kwargs)

See the together function in sympy.polys

trigsimp(deep=False, recursive=False)

See the trigsimp function in sympy.simplify

## Symbol¶

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

as_two_terms(*args, **kw_args)

Return head and tail of self.

This is the most efficient way to get the head and tail of an expression.

• if you want only the head, use self.args[0];
• if you want to process the arguments of the tail then use self.as_coef_add() which gives the head and a tuple containing the arguments of the tail when treated as an Add.
• if you want the coefficient when self is treated as a Mul then use self.as_coeff_mul()[0]
```>>> from sympy.abc import x, y
>>> (3*x*y).as_two_terms()
(3, x*y)
```

Returns the leading term and it’s order.

Examples:

```>>> from sympy.abc import x
((x**(-5), O(x**(-5))),)
((1, O(1)),)
((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(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+sin(b)*c)._matches_commutative(x+sin(y)*z)
{a_: x, b_: y, c_: z}
```

In the example above, “a+sin(b)*c” is the pattern, and “x+sin(y)*z” is the expression.

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+sin(b)*c)._matches_commutative(x+sin(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+sin(b)*c)._matches_commutative(x+sin(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+sin(b)*c)._matches_commutative(x+sin(y)*z)
{b_: y, c_: z}
```

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

primitive()

Divide self by the GCD of coefficients of self.

```>>> from sympy.abc import x, y
```
```>>> (2*x + 4*y).primitive()
(2, x + 2*y)
```
```>>> (2*x/3 + 4*y/9).primitive()
(2/9, 3*x + 2*y)
```
```>>> (2*x/3 + 4.1*y).primitive()
(1, 2*x/3 + 4.1*y)
```

## Set¶

class sympy.core.sets.Set

Represents any kind of set.

Real intervals are represented by the Interval class and unions of sets by the Union class. The empty set is represented by the EmptySet class and available as a singleton as S.EmptySet.

complement

The complement of ‘self’.

As a shortcut it is possible to use the ‘~’ or ‘-‘ operators:

```>>> from sympy import Interval
```
```>>> Interval(0, 1).complement
Union((-oo, 0), (1, oo))
>>> ~Interval(0, 1)
Union((-oo, 0), (1, oo))
>>> -Interval(0, 1)
Union((-oo, 0), (1, oo))
```
contains(other)

Returns True if ‘other’ is contained in ‘self’ as an element.

As a shortcut it is possible to use the ‘in’ operator:

```>>> from sympy import Interval
```
```>>> Interval(0, 1).contains(0.5)
True
>>> 0.5 in Interval(0, 1)
True
```
inf

The infimum of ‘self’.

```>>> from sympy import Interval, Union
```
```>>> Interval(0, 1).inf
0
>>> Union(Interval(0, 1), Interval(2, 3)).inf
0
```
intersect(other)

Returns the intersection of ‘self’ and ‘other’.

```>>> from sympy import Interval
```
```>>> Interval(1, 3).intersect(Interval(1, 2))
[1, 2]
```
measure

The (Lebesgue) measure of ‘self’.

```>>> from sympy import Interval, Union
```
```>>> Interval(0, 1).measure
1
>>> Union(Interval(0, 1), Interval(2, 3)).measure
2
```
subset(other)

Returns True if ‘other’ is a subset of ‘self’.

```>>> from sympy import Interval
```
```>>> Interval(0, 1).contains(0)
True
>>> Interval(0, 1, left_open=True).contains(0)
False
```
sup

The supremum of ‘self’.

```>>> from sympy import Interval, Union
```
```>>> Interval(0, 1).sup
1
>>> Union(Interval(0, 1), Interval(2, 3)).sup
3
```
union(other)

Returns the union of ‘self’ and ‘other’. As a shortcut it is possible to use the ‘+’ operator:

```>>> from sympy import Interval
```
```>>> Interval(0, 1).union(Interval(2, 3))
Union([0, 1], [2, 3])
>>> Interval(0, 1) + Interval(2, 3)
Union([0, 1], [2, 3])
```

Similarly it is possible to use the ‘-‘ operator for set differences:

```>>> Interval(0, 2) - Interval(0, 1)
(1, 2]
```

## Interval¶

class sympy.core.sets.Interval

Represents a real interval as a Set.

Usage:

Returns an interval with end points “start” and “end”.

For left_open=True (default left_open is False) the interval will be open on the left. Similarly, for right_open=True the interval will be open on the right.

Examples:
```>>> from sympy import Symbol, Interval, sets
```
```>>> Interval(0, 1)
[0, 1]
>>> Interval(0, 1, False, True)
[0, 1)
```
```>>> a = Symbol('a', real=True)
>>> Interval(0, a)
[0, a]
```
Notes:
• Only real end points are supported
• Interval(a, b) with a > b will return the empty set
• Use the evalf() method to turn an Interval into an mpmath ‘mpi’ interval instance
as_relational(symbol)

Rewrite an interval in terms of inequalities and logic operators.

end

The right end point of ‘self’. This property takes the same value as the ‘sup’ property.

```>>> from sympy import Interval
```
```>>> Interval(0, 1).end
1
```
is_left_unbounded

Return True if the left endpoint is negative infinity.

is_point

Return True if the left endpoint equals the right endpoint.

is_right_unbounded

Return True if the right endpoint is positive infinity.

left

The left end point of ‘self’. This property takes the same value as the ‘inf’ property.

```>>> from sympy import Interval
```
```>>> Interval(0, 1).start
0
```
left_open

True if ‘self’ is left-open.

```>>> from sympy import Interval
```
```>>> Interval(0, 1, left_open=True).left_open
True
>>> Interval(0, 1, left_open=False).left_open
False
```
right

The right end point of ‘self’. This property takes the same value as the ‘sup’ property.

```>>> from sympy import Interval
```
```>>> Interval(0, 1).end
1
```
right_open

True if ‘self’ is right-open.

```>>> from sympy import Interval
```
```>>> Interval(0, 1, right_open=True).right_open
True
>>> Interval(0, 1, right_open=False).right_open
False
```
start

The left end point of ‘self’. This property takes the same value as the ‘inf’ property.

```>>> from sympy import Interval
```
```>>> Interval(0, 1).start
0
```

## Union¶

class sympy.core.sets.Union

Represents a union of sets as a Set.

Examples:
```>>> from sympy import Union, Interval
```
```>>> Union(Interval(1, 2), Interval(3, 4))
Union([1, 2], [3, 4])
```

The Union constructor will always try to merge overlapping intervals, if possible. For example:

```>>> Union(Interval(1, 2), Interval(2, 3))
[1, 3]
```