A class that represents a unit symbol.
yt.units.unit_object.
InvalidUnitOperation
[source]¶Bases: Exception
args
¶with_traceback
()¶Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.
yt.units.unit_object.
Unit
[source]¶Bases: sympy.core.expr.Expr
A symbolic unit, using sympy functionality. We only add “dimensions” so that sympy understands relations between different units.
adjoint
()¶apart
(x=None, **args)¶See the apart function in sympy.polys
args
¶Returns a tuple of arguments of ‘self’.
Examples
>>> from sympy import 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
Notes
Never use self._args, always use self.args. Only use _args in __new__ when creating a new function. Don’t override .args() from Basic (so that it’s easy to change the interface in the future if needed).
args_cnc
(cset=False, warn=True, split_1=True)¶Return [commutative factors, noncommutative factors] of self.
self is treated as a Mul and the ordering of the factors is maintained.
If cset
is True the commutative factors will be returned in a set.
If there were repeated factors (as may happen with an unevaluated Mul)
then an error will be raised unless it is explicitly supressed by
setting warn
to False.
Note: 1 is always separated from a Number unless split_1 is False.
>>> from sympy import symbols, oo
>>> A, B = symbols('A B', commutative=0)
>>> x, y = symbols('x y')
>>> (2*x*y).args_cnc()
[[1, 2, x, y], []]
>>> (2.5*x).args_cnc()
[[1, 2.5, x], []]
>>> (2*x*A*B*y).args_cnc()
[[1, 2, x, y], [A, B]]
>>> (2*x*A*B*y).args_cnc(split_1=False)
[[2, x, y], [A, B]]
>>> (2*x*y).args_cnc(cset=True)
[set([1, 2, x, y]), []]
The arg is always treated as a Mul:
>>> (2 + x + A).args_cnc()
[[], [x  2 + A]]
>>> (oo).args_cnc() # oo is a singleton
[[1, oo], []]
as_base_exp
()¶as_coeff_Add
()¶Efficiently extract the coefficient of a summation.
as_coeff_Mul
(rational=False)¶Efficiently extract the coefficient of a product.
as_coeff_add
(*deps)¶Return the tuple (c, args) where self is written as an Add, a
.
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 a
; 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.
self.as_independent(*deps)
>>> from sympy import S
>>> from sympy.abc import x, y
>>> (S(3)).as_coeff_add()
(3, ())
>>> (3 + x).as_coeff_add()
(3, (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, **kwargs)¶Return the tuple (c, args) where self is written as a Mul, m
.
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.
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 the product of ‘expr’ and ‘expr’free coefficient. If such separation is not possible it will return None.
Examples
>>> from sympy import E, pi, sin, I, Poly
>>> from sympy.abc import x
>>> E.as_coefficient(E)
1
>>> (2*E).as_coefficient(E)
2
>>> (2*sin(E)*E).as_coefficient(E)
Two terms have E in them so a sum is returned. (If one were desiring the coefficient of the term exactly matching E then the constant from the returned expression could be selected. Or, for greater precision, a method of Poly can be used to indicate the desired term from which the coefficient is desired.)
>>> (2*E + x*E).as_coefficient(E)
x + 2
>>> _.args[0] # just want the exact match
2
>>> p = Poly(2*E + x*E); p
Poly(x*E + 2*E, x, E, domain='ZZ')
>>> p.coeff_monomial(E)
2
>>> p.nth(0, 1)
2
Since the following cannot be written as a product containing
E as a factor, None is returned. (If the coefficient 2*x
is
desired then the coeff
method should be used.)
>>> (2*E*x + x).as_coefficient(E)
>>> (2*E*x + x).coeff(E)
2*x
>>> (E*(x + 1) + x).as_coefficient(E)
>>> (2*pi*I).as_coefficient(pi*I)
2
>>> (2*I).as_coefficient(pi*I)
See also
coeff()
as_coeff_Add()
as_coeff_Mul()
as_independent()
sympy.polys.polytools.coeff_monomial()
sympy.polys.polytools.nth()
as_coefficients_dict
()¶Return a dictionary mapping terms to their Rational coefficient. Since the dictionary is a defaultdict, inquiries about terms which were not present will return a coefficient of 0. If an expression is not an Add it is considered to have a single term.
Examples
>>> from sympy.abc import a, x
>>> (3*x + a*x + 4).as_coefficients_dict()
{1: 4, x: 3, a*x: 1}
>>> _[a]
0
>>> (3*a*x).as_coefficients_dict()
{a*x: 3}
as_content_primitive
(radical=False, clear=True)¶This method should recursively remove a Rational from all arguments
and return that (content) and the new self (primitive). The content
should always be positive and Mul(*foo.as_content_primitive()) == foo
.
The primitive need no be in canonical form and should try to preserve
the underlying structure if possible (i.e. expand_mul should not be
applied to self).
Examples
>>> from sympy import sqrt
>>> from sympy.abc import x, y, z
>>> eq = 2 + 2*x + 2*y*(3 + 3*y)
The as_content_primitive function is recursive and retains structure:
>>> eq.as_content_primitive()
(2, x + 3*y*(y + 1) + 1)
Integer powers will have Rationals extracted from the base:
>>> ((2 + 6*x)**2).as_content_primitive()
(4, (3*x + 1)**2)
>>> ((2 + 6*x)**(2*y)).as_content_primitive()
(1, (2*(3*x + 1))**(2*y))
Terms may end up joining once their as_content_primitives are added:
>>> ((5*(x*(1 + y)) + 2*x*(3 + 3*y))).as_content_primitive()
(11, x*(y + 1))
>>> ((3*(x*(1 + y)) + 2*x*(3 + 3*y))).as_content_primitive()
(9, x*(y + 1))
>>> ((3*(z*(1 + y)) + 2.0*x*(3 + 3*y))).as_content_primitive()
(1, 6.0*x*(y + 1) + 3*z*(y + 1))
>>> ((5*(x*(1 + y)) + 2*x*(3 + 3*y))**2).as_content_primitive()
(121, x**2*(y + 1)**2)
>>> ((5*(x*(1 + y)) + 2.0*x*(3 + 3*y))**2).as_content_primitive()
(1, 121.0*x**2*(y + 1)**2)
Radical content can also be factored out of the primitive:
>>> (2*sqrt(2) + 4*sqrt(10)).as_content_primitive(radical=True)
(2, sqrt(2)*(1 + 2*sqrt(5)))
If clear=False (default is True) then content will not be removed from an Add if it can be distributed to leave one or more terms with integer coefficients.
>>> (x/2 + y).as_content_primitive()
(1/2, x + 2*y)
>>> (x/2 + y).as_content_primitive(clear=False)
(1, x/2 + y)
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.:
The only nonnaive thing that is done here is to respect noncommutative ordering of variables and to always return (0, 0) for self of zero regardless of hints.
For nonzero self, the returned tuple (i, d) has the following interpretation:
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))
noncommutative 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)
>>> ((xn1)*(xy)).as_independent(x)
(1, (x  y)*(x  n1))
– 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=True)
(0, 3*x)
– force self to be treated as a Mul:
>>> (3+x).as_independent(x, as_Add=False)
(1, x + 3)
>>> (3+x).as_independent(x, as_Add=False)
(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)
>>> from sympy import Integral
>>> I = Integral(x, (x, 1, 2))
>>> I.has(x)
True
>>> x in I.free_symbols
False
>>> I.as_independent(x) == (I, 1)
True
>>> (I + x).as_independent(x) == (I, x)
True
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))
See also
separatevars()
, expand()
, Add.as_two_terms()
, Mul.as_two_terms()
, as_coeff_add()
, as_coeff_mul()
as_leading_term
(*symbols)¶Returns the leading (nonzero) term of the series expansion of self.
The _eval_as_leading_term routines are used to do this, and they must always return a nonzero value.
Examples
>>> from sympy.abc import x
>>> (1 + x + x**2).as_leading_term(x)
1
>>> (1/x**2 + x + x**2).as_leading_term(x)
x**(2)
as_numer_denom
()¶expression > a/b > a, b
This is just a stub that should be defined by an object’s class methods to get anything else.
See also
normal()
as_ordered_factors
(order=None)¶Return list of ordered factors (if Mul) else [self].
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
>>> (sin(x)**2*cos(x) + sin(x)**2 + 1).as_ordered_terms()
[sin(x)**2*cos(x), sin(x)**2, 1]
as_poly
(*gens, **args)¶Converts self
to a polynomial or returns None
.
>>> from sympy import 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
as_powers_dict
()¶Return self as a dictionary of factors with each factor being treated as a power. The keys are the bases of the factors and the values, the corresponding exponents. The resulting dictionary should be used with caution if the expression is a Mul and contains non commutative factors since the order that they appeared will be lost in the dictionary.
as_real_imag
(deep=True, **hints)¶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()
(re(z)  im(w), re(w) + im(z))
as_terms
()¶Transform an expression to a list of terms.
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.
Examples
>>> from sympy import Symbol
>>> from sympy.abc import x
>>> x.assumptions0
{'commutative': True}
>>> x = Symbol("x", positive=True)
>>> x.assumptions0
{'commutative': True, 'complex': True, 'hermitian': 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
>>> from sympy.core.function import AppliedUndef
>>> f = Function('f')
>>> (1 + f(x) + 2*sin(y + I*pi)).atoms(Function)
set([f(x), sin(y + I*pi)])
>>> (1 + f(x) + 2*sin(y + I*pi)).atoms(AppliedUndef)
set([f(x)])
>>> (1 + x + 2*sin(y + I*pi)).atoms(Mul)
set([I*pi, 2*sin(y + I*pi)])
base_offset
¶base_value
¶cancel
(*gens, **args)¶See the cancel function in sympy.polys
canonical_variables
¶Return a dictionary mapping any variable defined in
self.variables
as underscoresuffixed numbers
corresponding to their position in self.variables
. Enough
underscores are added to ensure that there will be no clash with
existing free symbols.
Examples
>>> from sympy import Lambda
>>> from sympy.abc import x
>>> Lambda(x, 2*x).canonical_variables
{x: 0_}
class_key
()¶Nice order of classes.
coeff
(x, n=1, right=False)¶Returns the coefficient from the term(s) containing x**n
or None. If n
is zero then all terms independent of x
will be returned.
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.
See also
as_coefficient()
as_coeff_Add()
as_coeff_Mul()
as_independent()
sympy.polys.polytools.coeff_monomial()
sympy.polys.polytools.nth()
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)
0
You can select terms independent of x by making n=0; in this case expr.as_independent(x)[0] is returned (and 0 will be returned instead of None):
>>> (3 + 2*x + 4*x**2).coeff(x, 0)
3
>>> eq = ((x + 1)**3).expand() + 1
>>> eq
x**3 + 3*x**2 + 3*x + 2
>>> [eq.coeff(x, i) for i in reversed(range(4))]
[1, 3, 3, 2]
>>> eq = 2
>>> [eq.coeff(x, i) for i in reversed(range(4))]
[1, 3, 3, 0]
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)
0
>>> (z*(x + y)**2).coeff((x + y)**2)
z
>>> (z*(x + y)**2).coeff(x + y)
0
In addition, no factoring is done, so 1 + z*(1 + y) is not obtained from the following:
>>> (x + z*(x + x*y)).coeff(x)
1
If such factoring is desired, factor_terms can be used first:
>>> from sympy import factor_terms
>>> factor_terms(x + z*(x + x*y)).coeff(x)
z*(y + 1) + 1
>>> 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 0 is returned:
>>> (n*m + m*n).coeff(n)
0
If there is only one possible coefficient, it is returned:
>>> (n*m + x*m*n).coeff(m*n)
x
>>> (n*m + x*m*n).coeff(m*n, right=1)
1
collect
(syms, func=None, evaluate=True, exact=False, distribute_order_term=True)¶See the collect function in sympy.simplify
combsimp
()¶See the combsimp function in sympy.simplify
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.
Examples
>>> from sympy.abc import x, y
>>> x.compare(y)
1
>>> x.compare(x)
0
>>> y.compare(x)
1
compute_leading_term
(x, logx=None)¶as_leading_term is only allowed for results of .series() This is a wrapper to compute a series first.
conjugate
()¶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
>>> (xy).could_extract_minus_sign() != (yx).could_extract_minus_sign()
True
count
(query)¶Count the number of matching subexpressions.
count_ops
(visual=None)¶wrapper for count_ops that returns the operation count.
default_assumptions
= {'negative': False, 'imaginary': False, 'nonnegative': True, 'positive': True, 'zero': False, 'nonpositive': False, 'hermitian': True, 'real': True, 'nonzero': True, 'complex': True, 'commutative': True}¶diff
(*symbols, **assumptions)¶dimensions
¶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
>>> 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
equals
(other, failing_expression=False)¶Return True if self == other, False if it doesn’t, or None. If failing_expression is True then the expression which did not simplify to a 0 will be returned instead of None.
If self
is a Number (or complex number) that is not zero, then
the result is False.
If self
is a number and has not evaluated to zero, evalf will be
used to test whether the expression evaluates to zero. If it does so
and the result has significance (i.e. the precision is either 1, for
a Rational result, or is greater than 1) then the evalf value will be
used to return True or False.
evalf
(n=15, subs=None, maxn=100, chop=False, strict=False, quad=None, verbose=False)¶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}. The substitutions must be given as a dictionary.
 maxn=<integer>
 Allow a maximum temporary working precision of maxn 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, tanhsinh quadrature is used. For oscillatory integrals on an infinite interval, try quad=’osc’.
 verbose=<bool>
 Print debug information (default=False)
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 of the expand() function in sympy.core.function for more information.
expr
¶extract_additively
(c)¶Return self  c if it’s possible to subtract c from self and make all matching coefficients move towards zero, else return None.
Examples
>>> from sympy.abc import x, y
>>> e = 2*x + 3
>>> e.extract_additively(x + 1)
x + 2
>>> e.extract_additively(3*x)
>>> e.extract_additively(4)
>>> (y*(x + 1)).extract_additively(x + 1)
>>> ((x + 1)*(x + 2*y + 1) + 3).extract_additively(x + 1)
(x + 1)*(x + 2*y) + 3
Sometimes autoexpansion will return a less simplified result than desired; gcd_terms might be used in such cases:
>>> from sympy import gcd_terms
>>> (4*x*(y + 1) + y).extract_additively(x)
4*x*(y + 1) + x*(4*y + 3)  x*(4*y + 4) + y
>>> gcd_terms(_)
x*(4*y + 3) + y
See also
extract_branch_factor
(allow_half=False)¶Try to write self as exp_polar(2*pi*I*n)*z
in a nice way.
Return (z, n).
>>> from sympy import exp_polar, I, pi
>>> from sympy.abc import x, y
>>> exp_polar(I*pi).extract_branch_factor()
(exp_polar(I*pi), 0)
>>> exp_polar(2*I*pi).extract_branch_factor()
(1, 1)
>>> exp_polar(pi*I).extract_branch_factor()
(exp_polar(I*pi), 1)
>>> exp_polar(3*pi*I + x).extract_branch_factor()
(exp_polar(x + I*pi), 1)
>>> (y*exp_polar(5*pi*I)*exp_polar(3*pi*I + 2*pi*x)).extract_branch_factor()
(y*exp_polar(2*pi*x), 1)
>>> exp_polar(I*pi/2).extract_branch_factor()
(exp_polar(I*pi/2), 0)
If allow_half is True, also extract exp_polar(I*pi):
>>> exp_polar(I*pi).extract_branch_factor(allow_half=True)
(1, 1/2)
>>> exp_polar(2*I*pi).extract_branch_factor(allow_half=True)
(1, 1)
>>> exp_polar(3*I*pi).extract_branch_factor(allow_half=True)
(1, 3/2)
>>> exp_polar(I*pi).extract_branch_factor(allow_half=True)
(1, 1/2)
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
find
(query, group=False)¶Find all subexpressions matching a query.
fourier_series
(limits=None)¶Compute fourier sine/cosine series of self.
See the docstring of the fourier_series()
in sympy.series.fourier
for more information.
fps
(x=None, x0=0, dir=1, hyper=True, order=4, rational=True, full=False)¶Compute formal power power series of self.
See the docstring of the fps()
function in sympy.series.formal for
more information.
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 free_symbols method.
Any other method that uses bound variables should implement a free_symbols method.
fromiter
(args, **assumptions)¶Create a new object from an iterable.
This is a convenience function that allows one to create objects from any iterable, without having to convert to a list or tuple first.
Examples
>>> from sympy import Tuple
>>> Tuple.fromiter(i for i in range(5))
(0, 1, 2, 3, 4)
func
¶The toplevel function in an expression.
The following should hold for all objects:
>> x == x.func(*x.args)
Examples
>>> 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
getO
()¶Returns the additive O(..) symbol if there is one, else None.
get_base_equivalent
(unit_system='cgs')[source]¶Create and return dimensionallyequivalent units in a specified base.
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.
Examples
>>> from sympy import O
>>> from sympy.abc import x
>>> (1 + x + O(x**2)).getn()
2
>>> (1 + x).getn()
has
(*patterns)¶Test whether any subexpression matches any of the patterns.
Examples
>>> from sympy import sin
>>> 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
integrate
(*args, **kwargs)¶See the integrate function in sympy.integrals
invert
(g, *gens, **args)¶Return the multiplicative inverse of self
mod g
where self
(and g
) may be symbolic expressions).
See also
sympy.core.numbers.mod_inverse()
, sympy.polys.polytools.invert()
is_Add
= False¶is_AlgebraicNumber
= False¶is_Atom
= False¶is_Boolean
= False¶is_Derivative
= False¶is_Dummy
= False¶is_Equality
= False¶is_Float
= False¶is_Function
= False¶is_Integer
= False¶is_Matrix
= False¶is_Mul
= False¶is_Not
= False¶is_Number
= False¶is_NumberSymbol
= False¶is_Order
= False¶is_Piecewise
= False¶is_Point
= False¶is_Poly
= False¶is_Pow
= False¶is_Rational
= False¶is_Relational
= False¶is_Symbol
= False¶is_Vector
= False¶is_Wild
= False¶is_algebraic
¶is_algebraic_expr
(*syms)¶This tests whether a given expression is algebraic or not, 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 “algebraic expressions” with symbolic exponents. This is a simple extension to the is_rational_function, including rational exponentiation.
Examples
>>> from sympy import Symbol, sqrt
>>> x = Symbol('x', real=True)
>>> sqrt(1 + x).is_rational_function()
False
>>> sqrt(1 + x).is_algebraic_expr()
True
This function does not attempt any nontrivial simplifications that may result in an expression that does not appear to be an algebraic expression to become one.
>>> from sympy import exp, factor
>>> a = sqrt(exp(x)**2 + 2*exp(x) + 1)/(exp(x) + 1)
>>> a.is_algebraic_expr(x)
False
>>> factor(a).is_algebraic_expr()
True
See also
References
is_antihermitian
¶is_atomic
¶is_code_unit
¶is_commutative
= True¶is_comparable
¶Return True if self can be computed to a real number (or already is a real number) with precision, else False.
Examples
>>> from sympy import exp_polar, pi, I
>>> (I*exp_polar(I*pi/2)).is_comparable
True
>>> (I*exp_polar(I*pi*2)).is_comparable
False
A False result does not mean that self cannot be rewritten into a form that would be comparable. For example, the difference computed below is zero but without simplification it does not evaluate to a zero with precision:
>>> e = 2**pi*(1 + 2**pi)
>>> dif = e  e.expand()
>>> dif.is_comparable
False
>>> dif.n(2)._prec
1
is_complex
= True¶is_composite
¶is_constant
(*wrt, **flags)¶Return True if self is constant, False if not, or None if the constancy could not be determined conclusively.
If an expression has no free symbols then it is a constant. If there are free symbols it is possible that the expression is a constant, perhaps (but not necessarily) zero. To test such expressions, two strategies are tried:
1) numerical evaluation at two random points. If two such evaluations
give two different values and the values have a precision greater than
1 then self is not constant. If the evaluations agree or could not be
obtained with any precision, no decision is made. The numerical testing
is done only if wrt
is different than the free symbols.
2) differentiation with respect to variables in ‘wrt’ (or all free symbols if omitted) to see if the expression is constant or not. This will not always lead to an expression that is zero even though an expression is constant (see added test in test_expr.py). If all derivatives are zero then self is constant with respect to the given symbols.
If neither evaluation nor differentiation can prove the expression is
constant, None is returned unless two numerical values happened to be
the same and the flag failing_number
is True – in that case the
numerical value will be returned.
If flag simplify=False is passed, self will not be simplified; the default is True since self should be simplified before testing.
Examples
>>> from sympy import cos, sin, Sum, S, pi
>>> from sympy.abc import a, n, x, y
>>> x.is_constant()
False
>>> S(2).is_constant()
True
>>> Sum(x, (x, 1, 10)).is_constant()
True
>>> Sum(x, (x, 1, n)).is_constant()
False
>>> Sum(x, (x, 1, n)).is_constant(y)
True
>>> Sum(x, (x, 1, n)).is_constant(n)
False
>>> Sum(x, (x, 1, n)).is_constant(x)
True
>>> eq = a*cos(x)**2 + a*sin(x)**2  a
>>> eq.is_constant()
True
>>> eq.subs({x: pi, a: 2}) == eq.subs({x: pi, a: 3}) == 0
True
>>> (0**x).is_constant()
False
>>> x.is_constant()
False
>>> (x**x).is_constant()
False
>>> one = cos(x)**2 + sin(x)**2
>>> one.is_constant()
True
>>> ((one  1)**(x + 1)).is_constant() in (True, False) # could be 0 or 1
True
is_dimensionless
¶is_even
¶is_finite
¶is_hermitian
= True¶is_hypergeometric
(k)¶is_imaginary
= False¶is_infinite
¶is_integer
¶is_irrational
¶is_negative
= False¶is_noninteger
¶is_nonnegative
= True¶is_nonpositive
= False¶is_nonzero
= True¶is_number
= False¶is_odd
¶is_polar
¶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 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
See also .is_rational_function()
is_positive
= True¶is_prime
¶is_rational
¶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).
Examples
>>> 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
>>> 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
See also is_algebraic_expr().
is_real
= True¶is_transcendental
¶is_zero
= False¶latex_repr
¶leadterm
(x)¶Returns the leading term a*x**b as a tuple (a, b).
Examples
>>> from sympy.abc import x
>>> (1+x+x**2).leadterm(x)
(1, 0)
>>> (1/x**2+x+x**2).leadterm(x)
(1, 2)
limit
(x, xlim, dir='+')¶Compute limit x>xlim.
lseries
(x=None, x0=0, dir='+', logx=None)¶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.
See also nseries().
match
(pattern, old=False)¶Pattern matching.
Wild symbols match all.
Return None
when expression (self) does not match
with pattern. Otherwise return a dictionary such that:
pattern.xreplace(self.match(pattern)) == self
Examples
>>> from sympy import 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).xreplace(e.match(p*q**r))
4*x**2
The old
flag will give the oldstyle pattern matching where
expressions and patterns are essentially solved to give the
match. Both of the following give None unless old=True
:
>>> (x  2).match(p  x, old=True)
{p_: 2*x  2}
>>> (2/x).match(p*x, old=True)
{p_: 2/x**2}
matches
(expr, repl_dict={}, old=False)¶Helper method for match() that looks for a match between Wild symbols in self and expressions in expr.
Examples
>>> from sympy import symbols, Wild, Basic
>>> a, b, c = symbols('a b c')
>>> x = Wild('x')
>>> Basic(a + x, x).matches(Basic(a + b, c)) is None
True
>>> Basic(a + x, x).matches(Basic(a + b + c, b + c))
{x_: b + c}
n
(n=15, subs=None, maxn=100, chop=False, strict=False, quad=None, verbose=False)¶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}. The substitutions must be given as a dictionary.
 maxn=<integer>
 Allow a maximum temporary working precision of maxn 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, tanhsinh quadrature is used. For oscillatory integrals on an infinite interval, try quad=’osc’.
 verbose=<bool>
 Print debug information (default=False)
normal
()¶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 “crossmultiplying” everything out.
The optional logx
parameter can be used to replace any log(x) in the
returned series with a symbolic value to avoid evaluating log(x) at 0. A
symbol to use in place of log(x) should be provided.
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.
See also lseries().
Examples
>>> from sympy import sin, log, Symbol
>>> from sympy.abc import x, y
>>> sin(x).nseries(x, 0, 6)
x  x**3/6 + x**5/120 + O(x**6)
>>> log(x+1).nseries(x, 0, 5)
x  x**2/2 + x**3/3  x**4/4 + O(x**5)
Handling of the logx
parameter — in the following example the
expansion fails since sin
does not have an asymptotic expansion
at oo (the limit of log(x) as x approaches 0):
>>> e = sin(log(x))
>>> e.nseries(x, 0, 6)
Traceback (most recent call last):
...
PoleError: ...
...
>>> logx = Symbol('logx')
>>> e.nseries(x, 0, 6, logx=logx)
sin(logx)
In the following example, the expansion works but gives only an Order term
unless the logx
parameter is used:
>>> e = x**y
>>> e.nseries(x, 0, 2)
O(log(x)**2)
>>> e.nseries(x, 0, 2, logx=logx)
exp(logx*y)
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
primitive
()¶Return the positive Rational that can be extracted nonrecursively from every term of self (i.e., self is treated like an Add). This is like the as_coeff_Mul() method but primitive always extracts a positive Rational (never a negative or a Float).
Examples
>>> from sympy.abc import x
>>> (3*(x + 1)**2).primitive()
(3, (x + 1)**2)
>>> a = (6*x + 2); a.primitive()
(2, 3*x + 1)
>>> b = (x/2 + 3); b.primitive()
(1/2, x + 6)
>>> (a*b).primitive() == (1, a*b)
True
radsimp
()¶See the radsimp function in sympy.simplify
ratsimp
()¶See the ratsimp function in sympy.simplify
rcall
(*args)¶Apply on the argument recursively through the expression tree.
This method is used to simulate a common abuse of notation for operators. For instance in SymPy the the following will not work:
(x+Lambda(y, 2*y))(z) == x+2*z
,
however you can use
>>> from sympy import Lambda
>>> from sympy.abc import x, y, z
>>> (x + Lambda(y, 2*y)).rcall(z)
x + 2*z
refine
(assumption=True)¶See the refine function in sympy.assumptions
registry
¶removeO
()¶Removes the additive O(..) symbol if there is one
replace
(query, value, map=False, simultaneous=True, exact=False)¶Replace matching subexpressions of self
with value
.
If map = True
then also return the mapping {old: new} where old
was a subexpression found with query and new
is the replacement
value for it. If the expression itself doesn’t match the query, then
the returned value will be self.xreplace(map)
otherwise it should
be self.subs(ordered(map.items()))
.
Traverses an expression tree and performs replacement of matching
subexpressions from the bottom to the top of the tree. The default
approach is to do the replacement in a simultaneous fashion so
changes made are targeted only once. If this is not desired or causes
problems, simultaneous
can be set to False. In addition, if an
expression containing more than one Wild symbol is being used to match
subexpressions and the exact
flag is True, then the match will only
succeed if nonzero values are received for each Wild that appears in
the match pattern.
The list of possible combinations of queries and replacement values is listed below:
Examples
Initial setup
>>> from sympy import log, sin, cos, tan, Wild, Mul, Add
>>> from sympy.abc import x, y
>>> f = log(sin(x)) + tan(sin(x**2))
obj.replace(type, newtype)
When object of type type
is found, replace it with the
result of passing its argument(s) to newtype
.
>>> f.replace(sin, cos)
log(cos(x)) + tan(cos(x**2))
>>> sin(x).replace(sin, cos, map=True)
(cos(x), {sin(x): cos(x)})
>>> (x*y).replace(Mul, Add)
x + y
obj.replace(type, func)
When object of type type
is found, apply func
to its
argument(s). func
must be written to handle the number
of arguments of type
.
>>> f.replace(sin, lambda arg: sin(2*arg))
log(sin(2*x)) + tan(sin(2*x**2))
>>> (x*y).replace(Mul, lambda *args: sin(2*Mul(*args)))
sin(2*x*y)
obj.replace(pattern(wild), expr(wild))
Replace subexpressions matching pattern
with the expression
written in terms of the Wild symbols in pattern
.
>>> a = Wild('a')
>>> f.replace(sin(a), tan(a))
log(tan(x)) + tan(tan(x**2))
>>> f.replace(sin(a), tan(a/2))
log(tan(x/2)) + tan(tan(x**2/2))
>>> f.replace(sin(a), a)
log(x) + tan(x**2)
>>> (x*y).replace(a*x, a)
y
When the default value of False is used with patterns that have more than one Wild symbol, nonintuitive results may be obtained:
>>> b = Wild('b')
>>> (2*x).replace(a*x + b, b  a)
2/x
For this reason, the exact
option can be used to make the
replacement only when the match gives nonzero values for all
Wild symbols:
>>> (2*x + y).replace(a*x + b, b  a, exact=True)
y  2
>>> (2*x).replace(a*x + b, b  a, exact=True)
2*x
obj.replace(pattern(wild), lambda wild: expr(wild))
All behavior is the same as in 2.1 but now a function in terms of pattern variables is used rather than an expression:
>>> f.replace(sin(a), lambda a: sin(2*a))
log(sin(2*x)) + tan(sin(2*x**2))
obj.replace(filter, func)
Replace subexpression e
with func(e)
if filter(e)
is True.
>>> g = 2*sin(x**3)
>>> g.replace(lambda expr: expr.is_Number, lambda expr: expr**2)
4*sin(x**9)
The expression itself is also targeted by the query but is done in such a fashion that changes are not made twice.
>>> e = x*(x*y + 1)
>>> e.replace(lambda x: x.is_Mul, lambda x: 2*x)
2*x*(2*x*y + 1)
See also
subs()
xreplace()
rewrite
(*args, **hints)¶Rewrite functions in terms of other functions.
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 the 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.
Examples
>>> from sympy import sin, exp
>>> from sympy.abc import x
Unspecified pattern:
>>> sin(x).rewrite(exp)
I*(exp(I*x)  exp(I*x))/2
Pattern as a single function:
>>> sin(x).rewrite(sin, exp)
I*(exp(I*x)  exp(I*x))/2
Pattern as a list of functions:
>>> sin(x).rewrite([sin, ], exp)
I*(exp(I*x)  exp(I*x))/2
round
(p=0)¶Return x rounded to the given decimal place.
If a complex number would results, apply round to the real and imaginary components of the number.
Examples
>>> from sympy import pi, E, I, S, Add, Mul, Number
>>> S(10.5).round()
11.
>>> pi.round()
3.
>>> pi.round(2)
3.14
>>> (2*pi + E*I).round()
6. + 3.*I
The round method has a chopping effect:
>>> (2*pi + I/10).round()
6.
>>> (pi/10 + 2*I).round()
2.*I
>>> (pi/10 + E*I).round(2)
0.31 + 2.72*I
Notes
Do not confuse the Python builtin function, round, with the SymPy method of the same name. The former always returns a float (or raises an error if applied to a complex value) while the latter returns either a Number or a complex number:
>>> isinstance(round(S(123), 2), Number)
False
>>> isinstance(S(123).round(2), Number)
True
>>> isinstance((3*I).round(), Mul)
True
>>> isinstance((1 + 3*I).round(), Add)
True
separate
(deep=False, force=False)¶See the separate function in sympy.simplify
series
(x=None, x0=0, n=6, dir='+', logx=None)¶Series expansion of “self” around x = x0
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.
Returns the series expansion of “self” around the point x = x0
with respect to x
up to O((x  x0)**n, x, x0)
(default n is 6).
If x=None
and self
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)
>>> cos(x).series(x, x0=1, n=2)
cos(1)  (x  1)*sin(1) + O((x  1)**2, (x, 1))
>>> 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 n=None
then a generator of the series terms will be returned.
>>> term=cos(x).series(n=None)
>>> [next(term) for i in range(2)]
[1, x**2/2]
For dir=+
(default) the series is calculated from the right and
for dir=
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
(ratio=1.7, measure=None)¶See the simplify function in sympy.simplify
sort_key
(order=None)¶subs
(*args, **kwargs)¶Substitutes old for new in an expression after sympifying args.
If the keyword simultaneous
is True, the subexpressions will not be
evaluated until all the substitutions have been made.
Examples
>>> from sympy import pi, exp, limit, oo
>>> 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
>>> reps = [(y, x**2), (x, 2)]
>>> (x + y).subs(reps)
6
>>> (x + y).subs(reversed(reps))
x**2 + 2
>>> (x**2 + x**4).subs(x**2, y)
y**2 + y
To replace only the x**2 but not the x**4, use xreplace:
>>> (x**2 + x**4).xreplace({x**2: y})
x**4 + y
To delay evaluation until all substitutions have been made,
set the keyword simultaneous
to True:
>>> (x/y).subs([(x, 0), (y, 0)])
0
>>> (x/y).subs([(x, 0), (y, 0)], simultaneous=True)
nan
This has the added feature of not allowing subsequent substitutions to affect those already made:
>>> ((x + y)/y).subs({x + y: y, y: x + y})
1
>>> ((x + y)/y).subs({x + y: y, y: x + y}, simultaneous=True)
y/(x + y)
In order to obtain a canonical result, unordered iterables are sorted by count_op length, number of arguments and by the default_sort_key to break any ties. All other iterables are left unsorted.
>>> from sympy import sqrt, sin, cos
>>> from sympy.abc import a, b, c, d, e
>>> A = (sqrt(sin(2*x)), a)
>>> B = (sin(2*x), b)
>>> C = (cos(2*x), c)
>>> D = (x, d)
>>> E = (exp(x), e)
>>> expr = sqrt(sin(2*x))*sin(exp(x)*x)*cos(2*x) + sin(2*x)
>>> expr.subs(dict([A, B, C, D, E]))
a*c*sin(d*e) + b
The resulting expression represents a literal replacement of the old arguments with the new arguments. This may not reflect the limiting behavior of the expression:
>>> (x**3  3*x).subs({x: oo})
nan
>>> limit(x**3  3*x, x, oo)
oo
If the substitution will be followed by numerical evaluation, it is better to pass the substitution to evalf as
>>> (1/x).evalf(subs={x: 3.0}, n=21)
0.333333333333333333333
rather than
>>> (1/x).subs({x: 3.0}).evalf(21)
0.333333333333333314830
as the former will ensure that the desired level of precision is obtained.
See also
replace()
xreplace()
evalf()
taylor_term
(n, x, *previous_terms)¶General method for the taylor term.
This method is slow, because it differentiates ntimes. Subclasses can redefine it to make it faster by using the “previous_terms”.
together
(*args, **kwargs)¶See the together function in sympy.polys
transpose
()¶trigsimp
(**args)¶See the trigsimp function in sympy.simplify
xreplace
(rule)¶Replace occurrences of objects within the expression.
Parameters:  rule (dictlike) – Expresses a replacement rule 

Returns:  xreplace 
Return type:  the result of the replacement 
Examples
>>> from sympy import symbols, pi, exp
>>> x, y, z = symbols('x y z')
>>> (1 + x*y).xreplace({x: pi})
pi*y + 1
>>> (1 + x*y).xreplace({x: pi, y: 2})
1 + 2*pi
Replacements occur only if an entire node in the expression tree is matched:
>>> (x*y + z).xreplace({x*y: pi})
z + pi
>>> (x*y*z).xreplace({x*y: pi})
x*y*z
>>> (2*x).xreplace({2*x: y, x: z})
y
>>> (2*2*x).xreplace({2*x: y, x: z})
4*z
>>> (x + y + 2).xreplace({x + y: 2})
x + y + 2
>>> (x + 2 + exp(x + 2)).xreplace({x + 2: y})
x + exp(y) + 2
xreplace doesn’t differentiate between free and bound symbols. In the following, subs(x, y) would not change x since it is a bound symbol, but xreplace does:
>>> from sympy import Integral
>>> Integral(x, (x, 1, 2*x)).xreplace({x: y})
Integral(y, (y, 1, 2*y))
Trying to replace x with an expression raises an error:
>>> Integral(x, (x, 1, 2*x)).xreplace({x: 2*y})
ValueError: Invalid limits given: ((2*y, 1, 4*y),)
yt.units.unit_object.
auto_positive_symbol
(tokens, local_dict, global_dict)[source]¶Inserts calls to Symbol
for undefined variables.
Passes in positive=True as a keyword argument.
Adapted from sympy.sympy.parsing.sympy_parser.auto_symbol
yt.units.unit_object.
define_unit
(symbol, value, tex_repr=None, offset=None, prefixable=False)[source]¶Define a new unit and add it to the default unit registry.
Parameters: 


Examples
>>> yt.define_unit("mph", (1.0, "mile/hr"))
>>> two_weeks = YTQuantity(14.0, "days")
>>> yt.define_unit("fortnight", two_weeks)
yt.units.unit_object.
get_conversion_factor
(old_units, new_units)[source]¶Get the conversion factor between two units of equivalent dimensions. This is the number you multiply data by to convert from values in old_units to values in new_units.
Parameters:  

Returns: 

yt.units.unit_object.
iskeyword
()¶x.__contains__(y) <==> y in x.