algorithms.statistics.formula.formulae¶
Module: algorithms.statistics.formula.formulae
¶
Inheritance diagram for nipy.algorithms.statistics.formula.formulae
:

Formula objects¶
A formula is basically a sympy expression for the mean of something of the form:
mean = sum([Beta(e)*e for e in expr])
Or, a linear combination of sympy expressions, with each one multiplied by its own “Beta”. The elements of expr can be instances of Term (for a linear regression formula, they would all be instances of Term). But, in general, there might be some other parameters (i.e. sympy.Symbol instances) that are not Terms.
The design matrix is made up of columns that are the derivatives of mean with respect to everything that is not a Term, evaluted at a recarray that has field names given by [str(t) for t in self.terms].
For those familiar with R’s formula syntax, if we wanted a design matrix like the following:
> s.table = read.table("http://www-stat.stanford.edu/~jtaylo/courses/stats191/data/supervisor.table", header=T)
> d = model.matrix(lm(Y ~ X1*X3, s.table)
)
> d
(Intercept) X1 X3 X1:X3
1 1 51 39 1989
2 1 64 54 3456
3 1 70 69 4830
4 1 63 47 2961
5 1 78 66 5148
6 1 55 44 2420
7 1 67 56 3752
8 1 75 55 4125
9 1 82 67 5494
10 1 61 47 2867
11 1 53 58 3074
12 1 60 39 2340
13 1 62 42 2604
14 1 83 45 3735
15 1 77 72 5544
16 1 90 72 6480
17 1 85 69 5865
18 1 60 75 4500
19 1 70 57 3990
20 1 58 54 3132
21 1 40 34 1360
22 1 61 62 3782
23 1 66 50 3300
24 1 37 58 2146
25 1 54 48 2592
26 1 77 63 4851
27 1 75 74 5550
28 1 57 45 2565
29 1 85 71 6035
30 1 82 59 4838
attr(,"assign")
[1] 0 1 2 3
>
With the Formula, it looks like this:
>>> r = np.rec.array([
... (43, 51, 30, 39, 61, 92, 45), (63, 64, 51, 54, 63, 73, 47),
... (71, 70, 68, 69, 76, 86, 48), (61, 63, 45, 47, 54, 84, 35),
... (81, 78, 56, 66, 71, 83, 47), (43, 55, 49, 44, 54, 49, 34),
... (58, 67, 42, 56, 66, 68, 35), (71, 75, 50, 55, 70, 66, 41),
... (72, 82, 72, 67, 71, 83, 31), (67, 61, 45, 47, 62, 80, 41),
... (64, 53, 53, 58, 58, 67, 34), (67, 60, 47, 39, 59, 74, 41),
... (69, 62, 57, 42, 55, 63, 25), (68, 83, 83, 45, 59, 77, 35),
... (77, 77, 54, 72, 79, 77, 46), (81, 90, 50, 72, 60, 54, 36),
... (74, 85, 64, 69, 79, 79, 63), (65, 60, 65, 75, 55, 80, 60),
... (65, 70, 46, 57, 75, 85, 46), (50, 58, 68, 54, 64, 78, 52),
... (50, 40, 33, 34, 43, 64, 33), (64, 61, 52, 62, 66, 80, 41),
... (53, 66, 52, 50, 63, 80, 37), (40, 37, 42, 58, 50, 57, 49),
... (63, 54, 42, 48, 66, 75, 33), (66, 77, 66, 63, 88, 76, 72),
... (78, 75, 58, 74, 80, 78, 49), (48, 57, 44, 45, 51, 83, 38),
... (85, 85, 71, 71, 77, 74, 55), (82, 82, 39, 59, 64, 78, 39)],
... dtype=[('y', '<i8'), ('x1', '<i8'), ('x2', '<i8'),
... ('x3', '<i8'), ('x4', '<i8'), ('x5', '<i8'),
... ('x6', '<i8')])
>>> x1 = Term('x1'); x3 = Term('x3')
>>> f = Formula([x1, x3, x1*x3]) + I
>>> f.mean
_b0*x1 + _b1*x3 + _b2*x1*x3 + _b3
The I is the “intercept” term, I have explicity not used R’s default of adding it to everything.
>>> f.design(r)
array([(51.0, 39.0, 1989.0, 1.0), (64.0, 54.0, 3456.0, 1.0),
(70.0, 69.0, 4830.0, 1.0), (63.0, 47.0, 2961.0, 1.0),
(78.0, 66.0, 5148.0, 1.0), (55.0, 44.0, 2420.0, 1.0),
(67.0, 56.0, 3752.0, 1.0), (75.0, 55.0, 4125.0, 1.0),
(82.0, 67.0, 5494.0, 1.0), (61.0, 47.0, 2867.0, 1.0),
(53.0, 58.0, 3074.0, 1.0), (60.0, 39.0, 2340.0, 1.0),
(62.0, 42.0, 2604.0, 1.0), (83.0, 45.0, 3735.0, 1.0),
(77.0, 72.0, 5544.0, 1.0), (90.0, 72.0, 6480.0, 1.0),
(85.0, 69.0, 5865.0, 1.0), (60.0, 75.0, 4500.0, 1.0),
(70.0, 57.0, 3990.0, 1.0), (58.0, 54.0, 3132.0, 1.0),
(40.0, 34.0, 1360.0, 1.0), (61.0, 62.0, 3782.0, 1.0),
(66.0, 50.0, 3300.0, 1.0), (37.0, 58.0, 2146.0, 1.0),
(54.0, 48.0, 2592.0, 1.0), (77.0, 63.0, 4851.0, 1.0),
(75.0, 74.0, 5550.0, 1.0), (57.0, 45.0, 2565.0, 1.0),
(85.0, 71.0, 6035.0, 1.0), (82.0, 59.0, 4838.0, 1.0)],
dtype=[('x1', '<f8'), ('x3', '<f8'), ('x1*x3', '<f8'), ('1', '<f8')])
Classes¶
Beta
¶
-
class
nipy.algorithms.statistics.formula.formulae.
Beta
¶ Bases:
sympy.core.symbol.Dummy
A symbol tied to a Term term
Methods
__call__
(*args)adjoint
()apart
([x])See the apart function in sympy.polys args_cnc
([cset, warn, split_1])Return [commutative factors, non-commutative factors] of self. as_base_exp
()as_coeff_Add
([rational])Efficiently extract the coefficient of a summation. as_coeff_Mul
([rational])Efficiently extract the coefficient of a product. as_coeff_add
(*deps)Return the tuple (c, args) where self is written as an Add, a
.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
.as_coefficient
(expr)Extracts symbolic coefficient at the given expression. as_coefficients_dict
()Return a dictionary mapping terms to their Rational coefficient. as_content_primitive
([radical, clear])This method should recursively remove a Rational from all arguments and return that (content) and the new self (primitive). as_dummy
()Return a Dummy having the same name and same assumptions as self. as_expr
(*gens)Convert a polynomial to a SymPy expression. as_independent
(*deps, **hint)A mostly naive separation of a Mul or Add into arguments that are not are dependent on deps. as_leading_term
(*args, **kwargs)Returns the leading (nonzero) term of the series expansion of self. as_numer_denom
()expression -> a/b -> a, b as_ordered_factors
([order])Return list of ordered factors (if Mul) else [self]. as_ordered_terms
([order, data])Transform an expression to an ordered list of terms. as_poly
(*gens, **args)Converts self
to a polynomial or returnsNone
.as_powers_dict
()Return self as a dictionary of factors with each factor being treated as a power. as_real_imag
([deep])as_terms
()Transform an expression to a list of terms. atoms
(*types)Returns the atoms that form the current object. cancel
(*gens, **args)See the cancel function in sympy.polys class_key
()coeff
(x[, n, right])Returns the coefficient from the term(s) containing x**n
.collect
(syms[, func, evaluate, exact, …])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. compute_leading_term
(x[, logx])as_leading_term is only allowed for results of .series() conjugate
()copy
()could_extract_minus_sign
()Canonical way to choose an element in the set {e, -e} where e is any expression. count
(query)Count the number of matching subexpressions. count_ops
([visual])wrapper for count_ops that returns the operation count. diff
(*symbols, **assumptions)doit
(**hints)dummy_eq
(other[, symbol])Compare two expressions and handle dummy symbols. equals
(other[, failing_expression])Return True if self == other, False if it doesn’t, or None. evalf
([n, subs, maxn, chop, strict, quad, …])Evaluate the given formula to an accuracy of n digits. expand
(*args, **kwargs)Expand an expression using hints. 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. extract_branch_factor
([allow_half])Try to write self as exp_polar(2*pi*I*n)*z
in a nice way.extract_multiplicatively
(c)Return None if it’s not possible to make self in the form c * something in a nice way, i.e. factor
(*gens, **args)See the factor() function in sympy.polys.polytools find
(query[, group])Find all subexpressions matching a query. fourier_series
([limits])Compute fourier sine/cosine series of self. fps
([x, x0, dir, hyper, order, rational, full])Compute formal power power series of self. fromiter
(args, **assumptions)Create a new object from an iterable. getO
()Returns the additive O(..) symbol if there is one, else None. getn
()Returns the order of the expression. has
(*args, **kwargs)Test whether any subexpression matches any of the patterns. integrate
(*args, **kwargs)See the integrate function in sympy.integrals invert
(g, *gens, **args)Return the multiplicative inverse of self
modg
whereself
(andg
) may be symbolic expressions).is_algebraic_expr
(*syms)This tests whether a given expression is algebraic or not, in the given symbols, syms. is_constant
(*wrt, **flags)is_hypergeometric
(k)is_polynomial
(*syms)Return True if self is a polynomial in syms and False otherwise. is_rational_function
(*syms)Test whether function is a ratio of two polynomials in the given symbols, syms. leadterm
(x)Returns the leading term a*x**b as a tuple (a, b). limit
(x, xlim[, dir])Compute limit x->xlim. lseries
([x, x0, dir, logx])Wrapper for series yielding an iterator of the terms of the series. match
(pattern[, old])Pattern matching. matches
(expr[, repl_dict, old])n
([n, subs, maxn, chop, strict, quad, verbose])Evaluate the given formula to an accuracy of n digits. normal
()nseries
([x, x0, n, dir, logx])Wrapper to _eval_nseries if assumptions allow, else to series. nsimplify
([constants, tolerance, full])See the nsimplify function in sympy.simplify powsimp
(*args, **kwargs)See the powsimp function in sympy.simplify primitive
()Return the positive Rational that can be extracted non-recursively from every term of self (i.e., self is treated like an Add). radsimp
(**kwargs)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. refine
([assumption])See the refine function in sympy.assumptions removeO
()Removes the additive O(..) symbol if there is one replace
(query, value[, map, simultaneous, exact])Replace matching subexpressions of self
withvalue
.rewrite
(*args, **hints)Rewrite functions in terms of other functions. round
([p])Return x rounded to the given decimal place. separate
([deep, force])See the separate function in sympy.simplify series
([x, x0, n, dir, logx])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.simplify
([ratio, measure])See the simplify function in sympy.simplify sort_key
(*args, **kwargs)subs
(*args, **kwargs)Substitutes old for new in an expression after sympifying args. taylor_term
(n, x, *previous_terms)General method for the taylor term. together
(*args, **kwargs)See the together function in sympy.polys transpose
()trigsimp
(**args)See the trigsimp function in sympy.simplify xreplace
(rule[, hack2])-
__init__
()¶ x.__init__(…) initializes x; see help(type(x)) for signature
-
adjoint
()¶
-
apart
(x=None, **args)¶ See the apart function in sympy.polys
-
args
¶ Returns a tuple of arguments of ‘self’.
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).
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
-
args_cnc
(cset=False, warn=True, split_1=True)¶ Return [commutative factors, non-commutative 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 settingwarn
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) [{-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
(rational=False)¶ 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.
- 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 >>> (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 factors of the Mul that are independent of deps.
args should be a tuple of all other factors 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 the product of ‘expr’ and ‘expr’-free coefficient. If such separation is not possible it will return None.
See also
coeff
- return sum of terms have a given factor
as_coeff_Add
- separate the additive constant from an expression
as_coeff_Mul
- separate the multiplicative constant from an expression
as_independent
- separate x-dependent terms/factors from others
sympy.polys.polytools.coeff_monomial
- efficiently find the single coefficient of a monomial in Poly
sympy.polys.polytools.nth
- like coeff_monomial but powers of monomial terms are used
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 thecoeff
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)
-
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_dummy
()¶ Return a Dummy having the same name and same assumptions as self.
-
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 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:
- 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
- otherwise (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
See also
separatevars
,expand
,Add.as_two_terms
,Mul.as_two_terms
,as_coeff_add
,as_coeff_mul
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) >>> ((x-n1)*(x-y)).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)
- – use .as_independent() for true independence testing instead
- of .has(). The former considers only symbols in the free symbols while the latter considers all symbols
>>> 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))
-
as_leading_term
(*args, **kwargs)¶ 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 non-zero 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
- return a/b instead of a, b
-
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 returnsNone
.>>> 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)¶
-
as_terms
()¶ Transform an expression to a list of terms.
-
assumptions0
¶
-
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 Number, NumberSymbol, Symbol >>> (1 + x + 2*sin(y + I*pi)).atoms(Symbol) {x, y}
>>> (1 + x + 2*sin(y + I*pi)).atoms(Number) {1, 2}
>>> (1 + x + 2*sin(y + I*pi)).atoms(Number, NumberSymbol) {1, 2, pi}
>>> (1 + x + 2*sin(y + I*pi)).atoms(Number, NumberSymbol, I) {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 {x, y}
Be careful to check your assumptions when using the implicit option since
S(1).is_Integer = True
buttype(S(1))
isOne
, a special type of sympy atom, whiletype(S(2))
is typeInteger
and will find all integers in an expression:>>> from sympy import S >>> (1 + x + 2*sin(y + I*pi)).atoms(S(1)) {1}
>>> (1 + x + 2*sin(y + I*pi)).atoms(S(2)) {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) {f(x), sin(y + I*pi)} >>> (1 + f(x) + 2*sin(y + I*pi)).atoms(AppliedUndef) {f(x)}
>>> (1 + x + 2*sin(y + I*pi)).atoms(Mul) {I*pi, 2*sin(y + I*pi)}
-
cancel
(*gens, **args)¶ See the cancel function in sympy.polys
-
canonical_variables
¶ Return a dictionary mapping any variable defined in
self.variables
as underscore-suffixed numbers corresponding to their position inself.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
()¶
-
coeff
(x, n=1, right=False)¶ Returns the coefficient from the term(s) containing
x**n
. Ifn
is zero then all terms independent ofx
will be returned.When
x
is noncommutative, the coefficient to the left (default) or right ofx
can be returned. The keyword ‘right’ is ignored whenx
is commutative.See also
as_coefficient
- separate the expression into a coefficient and factor
as_coeff_Add
- separate the additive constant from an expression
as_coeff_Mul
- separate the multiplicative constant from an expression
as_independent
- separate x-dependent terms/factors from others
sympy.polys.polytools.coeff_monomial
- efficiently find the single coefficient of a monomial in Poly
sympy.polys.polytools.nth
- like coeff_monomial but powers of monomial terms are used
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
()¶
-
copy
()¶
-
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
(query)¶ Count the number of matching subexpressions.
-
count_ops
(visual=None)¶ wrapper for count_ops that returns the operation count.
-
default_assumptions
= {}¶
-
diff
(*symbols, **assumptions)¶
-
doit
(**hints)¶
-
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
-
dummy_index
¶
-
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, tanh-sinh quadrature is used. For oscillatory integrals on an infinite interval, try quad=’osc’.
- verbose=<bool>
- Print debug information (default=False)
-
expand
(*args, **kwargs)¶ Expand an expression using hints.
See the docstring of the expand() function in sympy.core.function for more information.
-
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.
See also
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 auto-expansion 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
-
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
¶
-
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 top-level 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.
-
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
(*args, **kwargs)¶ 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
has
is a structural algorithm with no knowledge of mathematics. Consider the following half-open interval:>>> from sympy.sets import Interval >>> i = Interval.Lopen(0, 5); i Interval.Lopen(0, 5) >>> i.args (0, 5, True, False) >>> i.has(4) # there is no "4" in the arguments False >>> i.has(0) # there *is* a "0" in the arguments True
Instead, use
contains
to determine whether a number is in the interval or not:>>> i.contains(4) True >>> i.contains(0) False
Note that
expr.has(*patterns)
is exactly equivalent toany(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
modg
whereself
(andg
) may be symbolic expressions).See also
sympy.core.numbers.mod_inverse
,sympy.polys.polytools.invert
-
is_Add
= False¶
-
is_AlgebraicNumber
= False¶
-
is_Atom
= True¶
-
is_Boolean
= False¶
-
is_Derivative
= False¶
-
is_Dummy
= True¶
-
is_Equality
= False¶
-
is_Float
= False¶
-
is_Function
= False¶
-
is_Indexed
= 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
= True¶
-
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.
See also
References
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
-
is_antihermitian
¶
-
is_commutative
¶
-
is_comparable
= False¶
-
is_complex
¶
-
is_composite
¶
-
is_constant
(*wrt, **flags)¶
-
is_even
¶
-
is_finite
¶
-
is_hermitian
¶
-
is_hypergeometric
(k)¶
-
is_imaginary
¶
-
is_infinite
¶
-
is_integer
¶
-
is_irrational
¶
-
is_negative
¶
-
is_noninteger
¶
-
is_nonnegative
¶
-
is_nonpositive
¶
-
is_nonzero
¶
-
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
¶
-
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
¶
-
is_symbol
= True¶
-
is_transcendental
¶
-
is_zero
¶
-
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 old-style pattern matching where expressions and patterns are essentially solved to give the match. Both of the following give None unlessold=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)¶
-
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, tanh-sinh quadrature is used. For oscillatory integrals on an infinite interval, try quad=’osc’.
- verbose=<bool>
- Print debug information (default=False)
-
name
¶
-
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 “cross-multiplying” 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 sincesin
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
(*args, **kwargs)¶ See the powsimp function in sympy.simplify
-
primitive
()¶ Return the positive Rational that can be extracted non-recursively 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
(**kwargs)¶ 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
-
removeO
()¶ Removes the additive O(..) symbol if there is one
-
replace
(query, value, map=False, simultaneous=True, exact=False)¶ Replace matching subexpressions of
self
withvalue
.If
map = True
then also return the mapping {old: new} whereold
was a sub-expression found with query andnew
is the replacement value for it. If the expression itself doesn’t match the query, then the returned value will beself.xreplace(map)
otherwise it should beself.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 theexact
flag is True, then the match will only succeed if non-zero 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:
See also
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))
- 1.1. type -> type
obj.replace(type, newtype)
When object of type
type
is found, replace it with the result of passing its argument(s) tonewtype
.>>> 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
- 1.2. type -> func
obj.replace(type, func)
When object of type
type
is found, applyfunc
to its argument(s).func
must be written to handle the number of arguments oftype
.>>> 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)
- 2.1. pattern -> expr
obj.replace(pattern(wild), expr(wild))
Replace subexpressions matching
pattern
with the expression written in terms of the Wild symbols inpattern
.>>> 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, non-intuitive 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 non-zero 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
- 2.2. pattern -> func
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))
- 3.1. func -> func
obj.replace(filter, func)
Replace subexpression
e
withfunc(e)
iffilter(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)
-
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.
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
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
-
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 tox
up toO((x - x0)**n, x, x0)
(default n is 6).If
x=None
andself
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 fordir=-
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
(*args, **kwargs)¶
-
subs
(*args, **kwargs)¶ Substitutes old for new in an expression after sympifying args.
- args is either:
- two arguments, e.g. foo.subs(old, new)
- one iterable argument, e.g. foo.subs(iterable). The iterable may be
- o an iterable container with (old, new) pairs. In this case the
- replacements are processed in the order given with successive patterns possibly affecting replacements already made.
- o a dict or set whose key/value items correspond to old/new pairs.
- In this case the old/new pairs will be sorted by op count and in case of a tie, by number of args and the default_sort_key. The resulting sorted list is then processed as an iterable container (see previous).
If the keyword
simultaneous
is True, the subexpressions will not be evaluated until all the substitutions have been made.See also
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.
-
taylor_term
(n, x, *previous_terms)¶ General method for the taylor term.
This method is slow, because it differentiates n-times. 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, hack2=False)¶
-
Factor
¶
-
class
nipy.algorithms.statistics.formula.formulae.
Factor
(name, levels, char='b')¶ Bases:
nipy.algorithms.statistics.formula.formulae.Formula
A qualitative variable in a regression model
A Factor is similar to R’s factor. The levels of the Factor can be either strings or ints.
Methods
design
(input[, param, return_float, contrasts])Construct the design matrix, and optional contrast matrices. fromcol
(col, name)Create a Factor from a column array. fromrec
(rec[, keep, drop])Construct Formula from recarray get_term
(level)Retrieve a term of the Factor… stratify
(variable)Create a new variable, stratified by the levels of a Factor. subs
(old, new)Perform a sympy substitution on all terms in the Formula -
__init__
(name, levels, char='b')¶ Initialize Factor
Parameters: name : str
levels : [str or int]
A sequence of strings or ints.
char : str, optional
prefix character for regression coefficients
-
coefs
¶ Coefficients in the linear regression formula.
-
design
(input, param=None, return_float=False, contrasts=None)¶ Construct the design matrix, and optional contrast matrices.
Parameters: input : np.recarray
Recarray including fields needed to compute the Terms in getparams(self.design_expr).
param : None or np.recarray
Recarray including fields that are not Terms in getparams(self.design_expr)
return_float : bool, optional
If True, return a np.float array rather than a np.recarray
contrasts : None or dict, optional
Contrasts. The items in this dictionary should be (str, Formula) pairs where a contrast matrix is constructed for each Formula by evaluating its design at the same parameters as self.design. If not None, then the return_float is set to True.
Returns: des : 2D array
design matrix
cmatrices : dict, optional
Dictionary with keys from contrasts input, and contrast matrices corresponding to des design matrix. Returned only if contrasts input is not None
-
design_expr
¶
-
dtype
¶ The dtype of the design matrix of the Formula.
-
static
fromcol
(col, name)¶ Create a Factor from a column array.
Parameters: col : ndarray
an array with ndim==1
name : str
name of the Factor
Returns: factor : Factor
Examples
>>> data = np.array([(3,'a'),(4,'a'),(5,'b'),(3,'b')], np.dtype([('x', np.float), ('y', 'S1')])) >>> f1 = Factor.fromcol(data['y'], 'y') >>> f2 = Factor.fromcol(data['x'], 'x') >>> d = f1.design(data) >>> print(d.dtype.descr) [('y_a', '<f8'), ('y_b', '<f8')] >>> d = f2.design(data) >>> print(d.dtype.descr) [('x_3', '<f8'), ('x_4', '<f8'), ('x_5', '<f8')]
-
fromrec
(rec, keep=[], drop=[])¶ Construct Formula from recarray
For fields with a string-dtype, it is assumed that these are qualtiatitve regressors, i.e. Factors.
Parameters: rec: recarray :
Recarray whose field names will be used to create a formula.
keep: [] :
Field names to explicitly keep, dropping all others.
drop: [] :
Field names to drop.
-
get_term
(level)¶ Retrieve a term of the Factor…
-
main_effect
¶
-
mean
¶ Expression for the mean, expressed as a linear combination of terms, each with dummy variables in front.
-
params
¶ The parameters in the Formula.
-
stratify
(variable)¶ Create a new variable, stratified by the levels of a Factor.
Parameters: variable : str or simple sympy expression
If sympy expression, then string representation must be all lower or upper case letters, i.e. it can be interpreted as a name.
Returns: formula : Formula
Formula whose mean has one parameter named variable%d, for each level in self.levels
Examples
>>> f = Factor('a', ['x','y']) >>> sf = f.stratify('theta') >>> sf.mean _theta0*a_x + _theta1*a_y
-
subs
(old, new)¶ Perform a sympy substitution on all terms in the Formula
Returns a new instance of the same class
Parameters: old : sympy.Basic
The expression to be changed
new : sympy.Basic
The value to change it to.
Returns: newf : Formula
Examples
>>> s, t = [Term(l) for l in 'st'] >>> f, g = [sympy.Function(l) for l in 'fg'] >>> form = Formula([f(t),g(s)]) >>> newform = form.subs(g, sympy.Function('h')) >>> newform.terms array([f(t), h(s)], dtype=object) >>> form.terms array([f(t), g(s)], dtype=object)
-
terms
¶ Terms in the linear regression formula.
-
FactorTerm
¶
-
class
nipy.algorithms.statistics.formula.formulae.
FactorTerm
¶ Bases:
nipy.algorithms.statistics.formula.formulae.Term
Boolean Term derived from a Factor.
Its properties are the same as a Term except that its product with itself is itself.
Methods
__call__
(*args)adjoint
()apart
([x])See the apart function in sympy.polys args_cnc
([cset, warn, split_1])Return [commutative factors, non-commutative factors] of self. as_base_exp
()as_coeff_Add
([rational])Efficiently extract the coefficient of a summation. as_coeff_Mul
([rational])Efficiently extract the coefficient of a product. as_coeff_add
(*deps)Return the tuple (c, args) where self is written as an Add, a
.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
.as_coefficient
(expr)Extracts symbolic coefficient at the given expression. as_coefficients_dict
()Return a dictionary mapping terms to their Rational coefficient. as_content_primitive
([radical, clear])This method should recursively remove a Rational from all arguments and return that (content) and the new self (primitive). as_dummy
()Return a Dummy having the same name and same assumptions as self. as_expr
(*gens)Convert a polynomial to a SymPy expression. as_independent
(*deps, **hint)A mostly naive separation of a Mul or Add into arguments that are not are dependent on deps. as_leading_term
(*args, **kwargs)Returns the leading (nonzero) term of the series expansion of self. as_numer_denom
()expression -> a/b -> a, b as_ordered_factors
([order])Return list of ordered factors (if Mul) else [self]. as_ordered_terms
([order, data])Transform an expression to an ordered list of terms. as_poly
(*gens, **args)Converts self
to a polynomial or returnsNone
.as_powers_dict
()Return self as a dictionary of factors with each factor being treated as a power. as_real_imag
([deep])as_terms
()Transform an expression to a list of terms. atoms
(*types)Returns the atoms that form the current object. cancel
(*gens, **args)See the cancel function in sympy.polys class_key
()coeff
(x[, n, right])Returns the coefficient from the term(s) containing x**n
.collect
(syms[, func, evaluate, exact, …])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. compute_leading_term
(x[, logx])as_leading_term is only allowed for results of .series() conjugate
()copy
()could_extract_minus_sign
()Canonical way to choose an element in the set {e, -e} where e is any expression. count
(query)Count the number of matching subexpressions. count_ops
([visual])wrapper for count_ops that returns the operation count. diff
(*symbols, **assumptions)doit
(**hints)dummy_eq
(other[, symbol])Compare two expressions and handle dummy symbols. equals
(other[, failing_expression])Return True if self == other, False if it doesn’t, or None. evalf
([n, subs, maxn, chop, strict, quad, …])Evaluate the given formula to an accuracy of n digits. expand
(*args, **kwargs)Expand an expression using hints. 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. extract_branch_factor
([allow_half])Try to write self as exp_polar(2*pi*I*n)*z
in a nice way.extract_multiplicatively
(c)Return None if it’s not possible to make self in the form c * something in a nice way, i.e. factor
(*gens, **args)See the factor() function in sympy.polys.polytools find
(query[, group])Find all subexpressions matching a query. fourier_series
([limits])Compute fourier sine/cosine series of self. fps
([x, x0, dir, hyper, order, rational, full])Compute formal power power series of self. fromiter
(args, **assumptions)Create a new object from an iterable. getO
()Returns the additive O(..) symbol if there is one, else None. getn
()Returns the order of the expression. has
(*args, **kwargs)Test whether any subexpression matches any of the patterns. integrate
(*args, **kwargs)See the integrate function in sympy.integrals invert
(g, *gens, **args)Return the multiplicative inverse of self
modg
whereself
(andg
) may be symbolic expressions).is_algebraic_expr
(*syms)This tests whether a given expression is algebraic or not, in the given symbols, syms. is_constant
(*wrt, **flags)is_hypergeometric
(k)is_polynomial
(*syms)Return True if self is a polynomial in syms and False otherwise. is_rational_function
(*syms)Test whether function is a ratio of two polynomials in the given symbols, syms. leadterm
(x)Returns the leading term a*x**b as a tuple (a, b). limit
(x, xlim[, dir])Compute limit x->xlim. lseries
([x, x0, dir, logx])Wrapper for series yielding an iterator of the terms of the series. match
(pattern[, old])Pattern matching. matches
(expr[, repl_dict, old])n
([n, subs, maxn, chop, strict, quad, verbose])Evaluate the given formula to an accuracy of n digits. normal
()nseries
([x, x0, n, dir, logx])Wrapper to _eval_nseries if assumptions allow, else to series. nsimplify
([constants, tolerance, full])See the nsimplify function in sympy.simplify powsimp
(*args, **kwargs)See the powsimp function in sympy.simplify primitive
()Return the positive Rational that can be extracted non-recursively from every term of self (i.e., self is treated like an Add). radsimp
(**kwargs)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. refine
([assumption])See the refine function in sympy.assumptions removeO
()Removes the additive O(..) symbol if there is one replace
(query, value[, map, simultaneous, exact])Replace matching subexpressions of self
withvalue
.rewrite
(*args, **hints)Rewrite functions in terms of other functions. round
([p])Return x rounded to the given decimal place. separate
([deep, force])See the separate function in sympy.simplify series
([x, x0, n, dir, logx])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.simplify
([ratio, measure])See the simplify function in sympy.simplify sort_key
(*args, **kwargs)subs
(*args, **kwargs)Substitutes old for new in an expression after sympifying args. taylor_term
(n, x, *previous_terms)General method for the taylor term. together
(*args, **kwargs)See the together function in sympy.polys transpose
()trigsimp
(**args)See the trigsimp function in sympy.simplify xreplace
(rule[, hack2])-
__init__
()¶ x.__init__(…) initializes x; see help(type(x)) for signature
-
adjoint
()¶
-
apart
(x=None, **args)¶ See the apart function in sympy.polys
-
args
¶ Returns a tuple of arguments of ‘self’.
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).
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
-
args_cnc
(cset=False, warn=True, split_1=True)¶ Return [commutative factors, non-commutative 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 settingwarn
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) [{-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
(rational=False)¶ 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.
- 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 >>> (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 factors of the Mul that are independent of deps.
args should be a tuple of all other factors 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 the product of ‘expr’ and ‘expr’-free coefficient. If such separation is not possible it will return None.
See also
coeff
- return sum of terms have a given factor
as_coeff_Add
- separate the additive constant from an expression
as_coeff_Mul
- separate the multiplicative constant from an expression
as_independent
- separate x-dependent terms/factors from others
sympy.polys.polytools.coeff_monomial
- efficiently find the single coefficient of a monomial in Poly
sympy.polys.polytools.nth
- like coeff_monomial but powers of monomial terms are used
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 thecoeff
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)
-
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_dummy
()¶ Return a Dummy having the same name and same assumptions as self.
-
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 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:
- 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
- otherwise (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
See also
separatevars
,expand
,Add.as_two_terms
,Mul.as_two_terms
,as_coeff_add
,as_coeff_mul
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) >>> ((x-n1)*(x-y)).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)
- – use .as_independent() for true independence testing instead
- of .has(). The former considers only symbols in the free symbols while the latter considers all symbols
>>> 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))
-
as_leading_term
(*args, **kwargs)¶ 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 non-zero 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
- return a/b instead of a, b
-
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 returnsNone
.>>> 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)¶
-
as_terms
()¶ Transform an expression to a list of terms.
-
assumptions0
¶
-
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 Number, NumberSymbol, Symbol >>> (1 + x + 2*sin(y + I*pi)).atoms(Symbol) {x, y}
>>> (1 + x + 2*sin(y + I*pi)).atoms(Number) {1, 2}
>>> (1 + x + 2*sin(y + I*pi)).atoms(Number, NumberSymbol) {1, 2, pi}
>>> (1 + x + 2*sin(y + I*pi)).atoms(Number, NumberSymbol, I) {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 {x, y}
Be careful to check your assumptions when using the implicit option since
S(1).is_Integer = True
buttype(S(1))
isOne
, a special type of sympy atom, whiletype(S(2))
is typeInteger
and will find all integers in an expression:>>> from sympy import S >>> (1 + x + 2*sin(y + I*pi)).atoms(S(1)) {1}
>>> (1 + x + 2*sin(y + I*pi)).atoms(S(2)) {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) {f(x), sin(y + I*pi)} >>> (1 + f(x) + 2*sin(y + I*pi)).atoms(AppliedUndef) {f(x)}
>>> (1 + x + 2*sin(y + I*pi)).atoms(Mul) {I*pi, 2*sin(y + I*pi)}
-
cancel
(*gens, **args)¶ See the cancel function in sympy.polys
-
canonical_variables
¶ Return a dictionary mapping any variable defined in
self.variables
as underscore-suffixed numbers corresponding to their position inself.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
()¶
-
coeff
(x, n=1, right=False)¶ Returns the coefficient from the term(s) containing
x**n
. Ifn
is zero then all terms independent ofx
will be returned.When
x
is noncommutative, the coefficient to the left (default) or right ofx
can be returned. The keyword ‘right’ is ignored whenx
is commutative.See also
as_coefficient
- separate the expression into a coefficient and factor
as_coeff_Add
- separate the additive constant from an expression
as_coeff_Mul
- separate the multiplicative constant from an expression
as_independent
- separate x-dependent terms/factors from others
sympy.polys.polytools.coeff_monomial
- efficiently find the single coefficient of a monomial in Poly
sympy.polys.polytools.nth
- like coeff_monomial but powers of monomial terms are used
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
()¶
-
copy
()¶
-
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
(query)¶ Count the number of matching subexpressions.
-
count_ops
(visual=None)¶ wrapper for count_ops that returns the operation count.
-
default_assumptions
= {}¶
-
diff
(*symbols, **assumptions)¶
-
doit
(**hints)¶
-
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, tanh-sinh quadrature is used. For oscillatory integrals on an infinite interval, try quad=’osc’.
- verbose=<bool>
- Print debug information (default=False)
-
expand
(*args, **kwargs)¶ Expand an expression using hints.
See the docstring of the expand() function in sympy.core.function for more information.
-
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.
See also
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 auto-expansion 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
-
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.
-
formula
¶ Return a Formula with only terms=[self].
-
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
¶
-
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 top-level 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.
-
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
(*args, **kwargs)¶ 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
has
is a structural algorithm with no knowledge of mathematics. Consider the following half-open interval:>>> from sympy.sets import Interval >>> i = Interval.Lopen(0, 5); i Interval.Lopen(0, 5) >>> i.args (0, 5, True, False) >>> i.has(4) # there is no "4" in the arguments False >>> i.has(0) # there *is* a "0" in the arguments True
Instead, use
contains
to determine whether a number is in the interval or not:>>> i.contains(4) True >>> i.contains(0) False
Note that
expr.has(*patterns)
is exactly equivalent toany(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
modg
whereself
(andg
) may be symbolic expressions).See also
sympy.core.numbers.mod_inverse
,sympy.polys.polytools.invert
-
is_Add
= False¶
-
is_AlgebraicNumber
= False¶
-
is_Atom
= True¶
-
is_Boolean
= False¶
-
is_Derivative
= False¶
-
is_Dummy
= False¶
-
is_Equality
= False¶
-
is_Float
= False¶
-
is_Function
= False¶
-
is_Indexed
= 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
= True¶
-
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.
See also
References
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
-
is_antihermitian
¶
-
is_commutative
¶
-
is_comparable
= False¶
-
is_complex
¶
-
is_composite
¶
-
is_constant
(*wrt, **flags)¶
-
is_even
¶
-
is_finite
¶
-
is_hermitian
¶
-
is_hypergeometric
(k)¶
-
is_imaginary
¶
-
is_infinite
¶
-
is_integer
¶
-
is_irrational
¶
-
is_negative
¶
-
is_noninteger
¶
-
is_nonnegative
¶
-
is_nonpositive
¶
-
is_nonzero
¶
-
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
¶
-
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
¶
-
is_symbol
= True¶
-
is_transcendental
¶
-
is_zero
¶
-
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 old-style pattern matching where expressions and patterns are essentially solved to give the match. Both of the following give None unlessold=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)¶
-
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, tanh-sinh quadrature is used. For oscillatory integrals on an infinite interval, try quad=’osc’.
- verbose=<bool>
- Print debug information (default=False)
-
name
¶
-
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 “cross-multiplying” 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 sincesin
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
(*args, **kwargs)¶ See the powsimp function in sympy.simplify
-
primitive
()¶ Return the positive Rational that can be extracted non-recursively 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
(**kwargs)¶ 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
-
removeO
()¶ Removes the additive O(..) symbol if there is one
-
replace
(query, value, map=False, simultaneous=True, exact=False)¶ Replace matching subexpressions of
self
withvalue
.If
map = True
then also return the mapping {old: new} whereold
was a sub-expression found with query andnew
is the replacement value for it. If the expression itself doesn’t match the query, then the returned value will beself.xreplace(map)
otherwise it should beself.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 theexact
flag is True, then the match will only succeed if non-zero 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:
See also
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))
- 1.1. type -> type
obj.replace(type, newtype)
When object of type
type
is found, replace it with the result of passing its argument(s) tonewtype
.>>> 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
- 1.2. type -> func
obj.replace(type, func)
When object of type
type
is found, applyfunc
to its argument(s).func
must be written to handle the number of arguments oftype
.>>> 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)
- 2.1. pattern -> expr
obj.replace(pattern(wild), expr(wild))
Replace subexpressions matching
pattern
with the expression written in terms of the Wild symbols inpattern
.>>> 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, non-intuitive 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 non-zero 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
- 2.2. pattern -> func
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))
- 3.1. func -> func
obj.replace(filter, func)
Replace subexpression
e
withfunc(e)
iffilter(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)
-
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.
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
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
-
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 tox
up toO((x - x0)**n, x, x0)
(default n is 6).If
x=None
andself
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 fordir=-
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
(*args, **kwargs)¶
-
subs
(*args, **kwargs)¶ Substitutes old for new in an expression after sympifying args.
- args is either:
- two arguments, e.g. foo.subs(old, new)
- one iterable argument, e.g. foo.subs(iterable). The iterable may be
- o an iterable container with (old, new) pairs. In this case the
- replacements are processed in the order given with successive patterns possibly affecting replacements already made.
- o a dict or set whose key/value items correspond to old/new pairs.
- In this case the old/new pairs will be sorted by op count and in case of a tie, by number of args and the default_sort_key. The resulting sorted list is then processed as an iterable container (see previous).
If the keyword
simultaneous
is True, the subexpressions will not be evaluated until all the substitutions have been made.See also
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.
-
taylor_term
(n, x, *previous_terms)¶ General method for the taylor term.
This method is slow, because it differentiates n-times. 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, hack2=False)¶
-
Formula
¶
-
class
nipy.algorithms.statistics.formula.formulae.
Formula
(seq, char='b')¶ Bases:
object
A Formula is a model for a mean in a regression model.
It is often given by a sequence of sympy expressions, with the mean model being the sum of each term multiplied by a linear regression coefficient.
The expressions may depend on additional Symbol instances, giving a non-linear regression model.
Methods
design
(input[, param, return_float, contrasts])Construct the design matrix, and optional contrast matrices. fromrec
(rec[, keep, drop])Construct Formula from recarray subs
(old, new)Perform a sympy substitution on all terms in the Formula -
__init__
(seq, char='b')¶ Parameters: seq : sequence of
sympy.Basic
char : str, optional
character for regression coefficient
-
coefs
¶ Coefficients in the linear regression formula.
-
design
(input, param=None, return_float=False, contrasts=None)¶ Construct the design matrix, and optional contrast matrices.
Parameters: input : np.recarray
Recarray including fields needed to compute the Terms in getparams(self.design_expr).
param : None or np.recarray
Recarray including fields that are not Terms in getparams(self.design_expr)
return_float : bool, optional
If True, return a np.float array rather than a np.recarray
contrasts : None or dict, optional
Contrasts. The items in this dictionary should be (str, Formula) pairs where a contrast matrix is constructed for each Formula by evaluating its design at the same parameters as self.design. If not None, then the return_float is set to True.
Returns: des : 2D array
design matrix
cmatrices : dict, optional
Dictionary with keys from contrasts input, and contrast matrices corresponding to des design matrix. Returned only if contrasts input is not None
-
design_expr
¶
-
dtype
¶ The dtype of the design matrix of the Formula.
-
static
fromrec
(rec, keep=[], drop=[])¶ Construct Formula from recarray
For fields with a string-dtype, it is assumed that these are qualtiatitve regressors, i.e. Factors.
Parameters: rec: recarray :
Recarray whose field names will be used to create a formula.
keep: [] :
Field names to explicitly keep, dropping all others.
drop: [] :
Field names to drop.
-
mean
¶ Expression for the mean, expressed as a linear combination of terms, each with dummy variables in front.
-
params
¶ The parameters in the Formula.
-
subs
(old, new)¶ Perform a sympy substitution on all terms in the Formula
Returns a new instance of the same class
Parameters: old : sympy.Basic
The expression to be changed
new : sympy.Basic
The value to change it to.
Returns: newf : Formula
Examples
>>> s, t = [Term(l) for l in 'st'] >>> f, g = [sympy.Function(l) for l in 'fg'] >>> form = Formula([f(t),g(s)]) >>> newform = form.subs(g, sympy.Function('h')) >>> newform.terms array([f(t), h(s)], dtype=object) >>> form.terms array([f(t), g(s)], dtype=object)
-
terms
¶ Terms in the linear regression formula.
-
RandomEffects
¶
-
class
nipy.algorithms.statistics.formula.formulae.
RandomEffects
(seq, sigma=None, char='e')¶ Bases:
nipy.algorithms.statistics.formula.formulae.Formula
Covariance matrices for common random effects analyses.
Examples
Two subjects (here named 2 and 3):
>>> subj = make_recarray([2,2,2,3,3], 's') >>> subj_factor = Factor('s', [2,3])
By default the covariance matrix is symbolic. The display differs a little between sympy versions (hence we don’t check it in the doctests):
>>> c = RandomEffects(subj_factor.terms) >>> c.cov(subj) array([[_s2_0, _s2_0, _s2_0, 0, 0], [_s2_0, _s2_0, _s2_0, 0, 0], [_s2_0, _s2_0, _s2_0, 0, 0], [0, 0, 0, _s2_1, _s2_1], [0, 0, 0, _s2_1, _s2_1]], dtype=object)
With a numeric sigma, you get a numeric array:
>>> c = RandomEffects(subj_factor.terms, sigma=np.array([[4,1],[1,6]])) >>> c.cov(subj) array([[ 4., 4., 4., 1., 1.], [ 4., 4., 4., 1., 1.], [ 4., 4., 4., 1., 1.], [ 1., 1., 1., 6., 6.], [ 1., 1., 1., 6., 6.]])
Methods
cov
(term[, param])Compute the covariance matrix for some given data. design
(input[, param, return_float, contrasts])Construct the design matrix, and optional contrast matrices. fromrec
(rec[, keep, drop])Construct Formula from recarray subs
(old, new)Perform a sympy substitution on all terms in the Formula -
__init__
(seq, sigma=None, char='e')¶ Initialize random effects instance
Parameters: seq : [
sympy.Basic
]sigma : ndarray
Covariance of the random effects. Defaults to a diagonal with entries for each random effect.
char : character for regression coefficient
-
coefs
¶ Coefficients in the linear regression formula.
-
cov
(term, param=None)¶ Compute the covariance matrix for some given data.
Parameters: term : np.recarray
Recarray including fields corresponding to the Terms in getparams(self.design_expr).
param : np.recarray
Recarray including fields that are not Terms in getparams(self.design_expr)
Returns: C : ndarray
Covariance matrix implied by design and self.sigma.
-
design
(input, param=None, return_float=False, contrasts=None)¶ Construct the design matrix, and optional contrast matrices.
Parameters: input : np.recarray
Recarray including fields needed to compute the Terms in getparams(self.design_expr).
param : None or np.recarray
Recarray including fields that are not Terms in getparams(self.design_expr)
return_float : bool, optional
If True, return a np.float array rather than a np.recarray
contrasts : None or dict, optional
Contrasts. The items in this dictionary should be (str, Formula) pairs where a contrast matrix is constructed for each Formula by evaluating its design at the same parameters as self.design. If not None, then the return_float is set to True.
Returns: des : 2D array
design matrix
cmatrices : dict, optional
Dictionary with keys from contrasts input, and contrast matrices corresponding to des design matrix. Returned only if contrasts input is not None
-
design_expr
¶
-
dtype
¶ The dtype of the design matrix of the Formula.
-
fromrec
(rec, keep=[], drop=[])¶ Construct Formula from recarray
For fields with a string-dtype, it is assumed that these are qualtiatitve regressors, i.e. Factors.
Parameters: rec: recarray :
Recarray whose field names will be used to create a formula.
keep: [] :
Field names to explicitly keep, dropping all others.
drop: [] :
Field names to drop.
-
mean
¶ Expression for the mean, expressed as a linear combination of terms, each with dummy variables in front.
-
params
¶ The parameters in the Formula.
-
subs
(old, new)¶ Perform a sympy substitution on all terms in the Formula
Returns a new instance of the same class
Parameters: old : sympy.Basic
The expression to be changed
new : sympy.Basic
The value to change it to.
Returns: newf : Formula
Examples
>>> s, t = [Term(l) for l in 'st'] >>> f, g = [sympy.Function(l) for l in 'fg'] >>> form = Formula([f(t),g(s)]) >>> newform = form.subs(g, sympy.Function('h')) >>> newform.terms array([f(t), h(s)], dtype=object) >>> form.terms array([f(t), g(s)], dtype=object)
-
terms
¶ Terms in the linear regression formula.
-
Term
¶
-
class
nipy.algorithms.statistics.formula.formulae.
Term
¶ Bases:
sympy.core.symbol.Symbol
A sympy.Symbol type to represent a term an a regression model
Terms can be added to other sympy expressions with the single convention that a term plus itself returns itself.
It is meant to emulate something on the right hand side of a formula in R. In particular, its name can be the name of a field in a recarray used to create a design matrix.
>>> t = Term('x') >>> xval = np.array([(3,),(4,),(5,)], np.dtype([('x', np.float)])) >>> f = t.formula >>> d = f.design(xval) >>> print(d.dtype.descr) [('x', '<f8')] >>> f.design(xval, return_float=True) array([ 3., 4., 5.])
Methods
__call__
(*args)adjoint
()apart
([x])See the apart function in sympy.polys args_cnc
([cset, warn, split_1])Return [commutative factors, non-commutative factors] of self. as_base_exp
()as_coeff_Add
([rational])Efficiently extract the coefficient of a summation. as_coeff_Mul
([rational])Efficiently extract the coefficient of a product. as_coeff_add
(*deps)Return the tuple (c, args) where self is written as an Add, a
.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
.as_coefficient
(expr)Extracts symbolic coefficient at the given expression. as_coefficients_dict
()Return a dictionary mapping terms to their Rational coefficient. as_content_primitive
([radical, clear])This method should recursively remove a Rational from all arguments and return that (content) and the new self (primitive). as_dummy
()Return a Dummy having the same name and same assumptions as self. as_expr
(*gens)Convert a polynomial to a SymPy expression. as_independent
(*deps, **hint)A mostly naive separation of a Mul or Add into arguments that are not are dependent on deps. as_leading_term
(*args, **kwargs)Returns the leading (nonzero) term of the series expansion of self. as_numer_denom
()expression -> a/b -> a, b as_ordered_factors
([order])Return list of ordered factors (if Mul) else [self]. as_ordered_terms
([order, data])Transform an expression to an ordered list of terms. as_poly
(*gens, **args)Converts self
to a polynomial or returnsNone
.as_powers_dict
()Return self as a dictionary of factors with each factor being treated as a power. as_real_imag
([deep])as_terms
()Transform an expression to a list of terms. atoms
(*types)Returns the atoms that form the current object. cancel
(*gens, **args)See the cancel function in sympy.polys class_key
()coeff
(x[, n, right])Returns the coefficient from the term(s) containing x**n
.collect
(syms[, func, evaluate, exact, …])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. compute_leading_term
(x[, logx])as_leading_term is only allowed for results of .series() conjugate
()copy
()could_extract_minus_sign
()Canonical way to choose an element in the set {e, -e} where e is any expression. count
(query)Count the number of matching subexpressions. count_ops
([visual])wrapper for count_ops that returns the operation count. diff
(*symbols, **assumptions)doit
(**hints)dummy_eq
(other[, symbol])Compare two expressions and handle dummy symbols. equals
(other[, failing_expression])Return True if self == other, False if it doesn’t, or None. evalf
([n, subs, maxn, chop, strict, quad, …])Evaluate the given formula to an accuracy of n digits. expand
(*args, **kwargs)Expand an expression using hints. 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. extract_branch_factor
([allow_half])Try to write self as exp_polar(2*pi*I*n)*z
in a nice way.extract_multiplicatively
(c)Return None if it’s not possible to make self in the form c * something in a nice way, i.e. factor
(*gens, **args)See the factor() function in sympy.polys.polytools find
(query[, group])Find all subexpressions matching a query. fourier_series
([limits])Compute fourier sine/cosine series of self. fps
([x, x0, dir, hyper, order, rational, full])Compute formal power power series of self. fromiter
(args, **assumptions)Create a new object from an iterable. getO
()Returns the additive O(..) symbol if there is one, else None. getn
()Returns the order of the expression. has
(*args, **kwargs)Test whether any subexpression matches any of the patterns. integrate
(*args, **kwargs)See the integrate function in sympy.integrals invert
(g, *gens, **args)Return the multiplicative inverse of self
modg
whereself
(andg
) may be symbolic expressions).is_algebraic_expr
(*syms)This tests whether a given expression is algebraic or not, in the given symbols, syms. is_constant
(*wrt, **flags)is_hypergeometric
(k)is_polynomial
(*syms)Return True if self is a polynomial in syms and False otherwise. is_rational_function
(*syms)Test whether function is a ratio of two polynomials in the given symbols, syms. leadterm
(x)Returns the leading term a*x**b as a tuple (a, b). limit
(x, xlim[, dir])Compute limit x->xlim. lseries
([x, x0, dir, logx])Wrapper for series yielding an iterator of the terms of the series. match
(pattern[, old])Pattern matching. matches
(expr[, repl_dict, old])n
([n, subs, maxn, chop, strict, quad, verbose])Evaluate the given formula to an accuracy of n digits. normal
()nseries
([x, x0, n, dir, logx])Wrapper to _eval_nseries if assumptions allow, else to series. nsimplify
([constants, tolerance, full])See the nsimplify function in sympy.simplify powsimp
(*args, **kwargs)See the powsimp function in sympy.simplify primitive
()Return the positive Rational that can be extracted non-recursively from every term of self (i.e., self is treated like an Add). radsimp
(**kwargs)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. refine
([assumption])See the refine function in sympy.assumptions removeO
()Removes the additive O(..) symbol if there is one replace
(query, value[, map, simultaneous, exact])Replace matching subexpressions of self
withvalue
.rewrite
(*args, **hints)Rewrite functions in terms of other functions. round
([p])Return x rounded to the given decimal place. separate
([deep, force])See the separate function in sympy.simplify series
([x, x0, n, dir, logx])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.simplify
([ratio, measure])See the simplify function in sympy.simplify sort_key
(*args, **kwargs)subs
(*args, **kwargs)Substitutes old for new in an expression after sympifying args. taylor_term
(n, x, *previous_terms)General method for the taylor term. together
(*args, **kwargs)See the together function in sympy.polys transpose
()trigsimp
(**args)See the trigsimp function in sympy.simplify xreplace
(rule[, hack2])-
__init__
()¶ x.__init__(…) initializes x; see help(type(x)) for signature
-
adjoint
()¶
-
apart
(x=None, **args)¶ See the apart function in sympy.polys
-
args
¶ Returns a tuple of arguments of ‘self’.
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).
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
-
args_cnc
(cset=False, warn=True, split_1=True)¶ Return [commutative factors, non-commutative 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 settingwarn
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) [{-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
(rational=False)¶ 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.
- 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 >>> (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 factors of the Mul that are independent of deps.
args should be a tuple of all other factors 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 the product of ‘expr’ and ‘expr’-free coefficient. If such separation is not possible it will return None.
See also
coeff
- return sum of terms have a given factor
as_coeff_Add
- separate the additive constant from an expression
as_coeff_Mul
- separate the multiplicative constant from an expression
as_independent
- separate x-dependent terms/factors from others
sympy.polys.polytools.coeff_monomial
- efficiently find the single coefficient of a monomial in Poly
sympy.polys.polytools.nth
- like coeff_monomial but powers of monomial terms are used
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 thecoeff
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)
-
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_dummy
()¶ Return a Dummy having the same name and same assumptions as self.
-
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 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:
- 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
- otherwise (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
See also
separatevars
,expand
,Add.as_two_terms
,Mul.as_two_terms
,as_coeff_add
,as_coeff_mul
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) >>> ((x-n1)*(x-y)).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)
- – use .as_independent() for true independence testing instead
- of .has(). The former considers only symbols in the free symbols while the latter considers all symbols
>>> 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))
-
as_leading_term
(*args, **kwargs)¶ 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 non-zero 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
- return a/b instead of a, b
-
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 returnsNone
.>>> 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)¶
-
as_terms
()¶ Transform an expression to a list of terms.
-
assumptions0
¶
-
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 Number, NumberSymbol, Symbol >>> (1 + x + 2*sin(y + I*pi)).atoms(Symbol) {x, y}
>>> (1 + x + 2*sin(y + I*pi)).atoms(Number) {1, 2}
>>> (1 + x + 2*sin(y + I*pi)).atoms(Number, NumberSymbol) {1, 2, pi}
>>> (1 + x + 2*sin(y + I*pi)).atoms(Number, NumberSymbol, I) {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 {x, y}
Be careful to check your assumptions when using the implicit option since
S(1).is_Integer = True
buttype(S(1))
isOne
, a special type of sympy atom, whiletype(S(2))
is typeInteger
and will find all integers in an expression:>>> from sympy import S >>> (1 + x + 2*sin(y + I*pi)).atoms(S(1)) {1}
>>> (1 + x + 2*sin(y + I*pi)).atoms(S(2)) {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) {f(x), sin(y + I*pi)} >>> (1 + f(x) + 2*sin(y + I*pi)).atoms(AppliedUndef) {f(x)}
>>> (1 + x + 2*sin(y + I*pi)).atoms(Mul) {I*pi, 2*sin(y + I*pi)}
-
cancel
(*gens, **args)¶ See the cancel function in sympy.polys
-
canonical_variables
¶ Return a dictionary mapping any variable defined in
self.variables
as underscore-suffixed numbers corresponding to their position inself.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
()¶
-
coeff
(x, n=1, right=False)¶ Returns the coefficient from the term(s) containing
x**n
. Ifn
is zero then all terms independent ofx
will be returned.When
x
is noncommutative, the coefficient to the left (default) or right ofx
can be returned. The keyword ‘right’ is ignored whenx
is commutative.See also
as_coefficient
- separate the expression into a coefficient and factor
as_coeff_Add
- separate the additive constant from an expression
as_coeff_Mul
- separate the multiplicative constant from an expression
as_independent
- separate x-dependent terms/factors from others
sympy.polys.polytools.coeff_monomial
- efficiently find the single coefficient of a monomial in Poly
sympy.polys.polytools.nth
- like coeff_monomial but powers of monomial terms are used
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
()¶
-
copy
()¶
-
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
(query)¶ Count the number of matching subexpressions.
-
count_ops
(visual=None)¶ wrapper for count_ops that returns the operation count.
-
default_assumptions
= {}¶
-
diff
(*symbols, **assumptions)¶
-
doit
(**hints)¶
-
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, tanh-sinh quadrature is used. For oscillatory integrals on an infinite interval, try quad=’osc’.
- verbose=<bool>
- Print debug information (default=False)
-
expand
(*args, **kwargs)¶ Expand an expression using hints.
See the docstring of the expand() function in sympy.core.function for more information.
-
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.
See also
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 auto-expansion 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
-
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.
-
formula
¶ Return a Formula with only terms=[self].
-
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
¶
-
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 top-level 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.
-
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
(*args, **kwargs)¶ 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
has
is a structural algorithm with no knowledge of mathematics. Consider the following half-open interval:>>> from sympy.sets import Interval >>> i = Interval.Lopen(0, 5); i Interval.Lopen(0, 5) >>> i.args (0, 5, True, False) >>> i.has(4) # there is no "4" in the arguments False >>> i.has(0) # there *is* a "0" in the arguments True
Instead, use
contains
to determine whether a number is in the interval or not:>>> i.contains(4) True >>> i.contains(0) False
Note that
expr.has(*patterns)
is exactly equivalent toany(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
modg
whereself
(andg
) may be symbolic expressions).See also
sympy.core.numbers.mod_inverse
,sympy.polys.polytools.invert
-
is_Add
= False¶
-
is_AlgebraicNumber
= False¶
-
is_Atom
= True¶
-
is_Boolean
= False¶
-
is_Derivative
= False¶
-
is_Dummy
= False¶
-
is_Equality
= False¶
-
is_Float
= False¶
-
is_Function
= False¶
-
is_Indexed
= 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
= True¶
-
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.
See also
References
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
-
is_antihermitian
¶
-
is_commutative
¶
-
is_comparable
= False¶
-
is_complex
¶
-
is_composite
¶
-
is_constant
(*wrt, **flags)¶
-
is_even
¶
-
is_finite
¶
-
is_hermitian
¶
-
is_hypergeometric
(k)¶
-
is_imaginary
¶
-
is_infinite
¶
-
is_integer
¶
-
is_irrational
¶
-
is_negative
¶
-
is_noninteger
¶
-
is_nonnegative
¶
-
is_nonpositive
¶
-
is_nonzero
¶
-
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
¶
-
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
¶
-
is_symbol
= True¶
-
is_transcendental
¶
-
is_zero
¶
-
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 old-style pattern matching where expressions and patterns are essentially solved to give the match. Both of the following give None unlessold=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)¶
-
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, tanh-sinh quadrature is used. For oscillatory integrals on an infinite interval, try quad=’osc’.
- verbose=<bool>
- Print debug information (default=False)
-
name
¶
-
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 “cross-multiplying” 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 sincesin
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
(*args, **kwargs)¶ See the powsimp function in sympy.simplify
-
primitive
()¶ Return the positive Rational that can be extracted non-recursively 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
(**kwargs)¶ 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
-
removeO
()¶ Removes the additive O(..) symbol if there is one
-
replace
(query, value, map=False, simultaneous=True, exact=False)¶ Replace matching subexpressions of
self
withvalue
.If
map = True
then also return the mapping {old: new} whereold
was a sub-expression found with query andnew
is the replacement value for it. If the expression itself doesn’t match the query, then the returned value will beself.xreplace(map)
otherwise it should beself.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 theexact
flag is True, then the match will only succeed if non-zero 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:
See also
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))
- 1.1. type -> type
obj.replace(type, newtype)
When object of type
type
is found, replace it with the result of passing its argument(s) tonewtype
.>>> 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
- 1.2. type -> func
obj.replace(type, func)
When object of type
type
is found, applyfunc
to its argument(s).func
must be written to handle the number of arguments oftype
.>>> 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)
- 2.1. pattern -> expr
obj.replace(pattern(wild), expr(wild))
Replace subexpressions matching
pattern
with the expression written in terms of the Wild symbols inpattern
.>>> 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, non-intuitive 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 non-zero 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
- 2.2. pattern -> func
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))
- 3.1. func -> func
obj.replace(filter, func)
Replace subexpression
e
withfunc(e)
iffilter(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)
-
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.
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
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
-
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 tox
up toO((x - x0)**n, x, x0)
(default n is 6).If
x=None
andself
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 fordir=-
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
(*args, **kwargs)¶
-
subs
(*args, **kwargs)¶ Substitutes old for new in an expression after sympifying args.
- args is either:
- two arguments, e.g. foo.subs(old, new)
- one iterable argument, e.g. foo.subs(iterable). The iterable may be
- o an iterable container with (old, new) pairs. In this case the
- replacements are processed in the order given with successive patterns possibly affecting replacements already made.
- o a dict or set whose key/value items correspond to old/new pairs.
- In this case the old/new pairs will be sorted by op count and in case of a tie, by number of args and the default_sort_key. The resulting sorted list is then processed as an iterable container (see previous).
If the keyword
simultaneous
is True, the subexpressions will not be evaluated until all the substitutions have been made.See also
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.
-
taylor_term
(n, x, *previous_terms)¶ General method for the taylor term.
This method is slow, because it differentiates n-times. 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, hack2=False)¶
-
Functions¶
-
nipy.algorithms.statistics.formula.formulae.
contrast_from_cols_or_rows
(L, D, pseudo=None)¶ Construct a contrast matrix from a design matrix D
(possibly with its pseudo inverse already computed) and a matrix L that either specifies something in the column space of D or the row space of D.
Parameters: L : ndarray
Matrix used to try and construct a contrast.
D : ndarray
Design matrix used to create the contrast.
pseudo : None or array-like, optional
If not None, gives pseudo-inverse of D. Allows you to pass this if it is already calculated.
Returns: C : ndarray
Matrix with C.shape[1] == D.shape[1] representing an estimable contrast.
Notes
From an n x p design matrix D and a matrix L, tries to determine a p x q contrast matrix C which determines a contrast of full rank, i.e. the n x q matrix
dot(transpose(C), pinv(D))
is full rank.
L must satisfy either L.shape[0] == n or L.shape[1] == p.
If L.shape[0] == n, then L is thought of as representing columns in the column space of D.
If L.shape[1] == p, then L is thought of as what is known as a contrast matrix. In this case, this function returns an estimable contrast corresponding to the dot(D, L.T)
This always produces a meaningful contrast, not always with the intended properties because q is always non-zero unless L is identically 0. That is, it produces a contrast that spans the column space of L (after projection onto the column space of D).
-
nipy.algorithms.statistics.formula.formulae.
define
(*args, **kwargs)¶
-
nipy.algorithms.statistics.formula.formulae.
getparams
(expression)¶ Return the parameters of an expression that are not Term instances but are instances of sympy.Symbol.
Examples
>>> x, y, z = [Term(l) for l in 'xyz'] >>> f = Formula([x,y,z]) >>> getparams(f) [] >>> f.mean _b0*x + _b1*y + _b2*z >>> getparams(f.mean) [_b0, _b1, _b2] >>> th = sympy.Symbol('theta') >>> f.mean*sympy.exp(th) (_b0*x + _b1*y + _b2*z)*exp(theta) >>> getparams(f.mean*sympy.exp(th)) [_b0, _b1, _b2, theta]
-
nipy.algorithms.statistics.formula.formulae.
getterms
(expression)¶ Return the all instances of Term in an expression.
Examples
>>> x, y, z = [Term(l) for l in 'xyz'] >>> f = Formula([x,y,z]) >>> getterms(f) [x, y, z] >>> getterms(f.mean) [x, y, z]
-
nipy.algorithms.statistics.formula.formulae.
is_factor
(obj)¶ Is obj a Factor?
-
nipy.algorithms.statistics.formula.formulae.
is_factor_term
(obj)¶ Is obj a FactorTerm?
-
nipy.algorithms.statistics.formula.formulae.
is_formula
(obj)¶ Is obj a Formula?
-
nipy.algorithms.statistics.formula.formulae.
is_term
(obj)¶ Is obj a Term?
-
nipy.algorithms.statistics.formula.formulae.
make_dummy
(*args, **kwds)¶ make_dummy is deprecated! Please use sympy.Dummy instead of this function
Make dummy variable of given nameParameters: name : str
name of dummy variable
Returns: dum : Dummy instance
Notes
The interface to Dummy changed between 0.6.7 and 0.7.0, and we used this function to keep compatibility. Now we depend on sympy 0.7.0 and this function is obsolete.
-
nipy.algorithms.statistics.formula.formulae.
make_recarray
(rows, names, dtypes=None, drop_name_dim=<class nipy.utils._NoValue>)¶ Create recarray from rows with field names names
Create a recarray with named columns from a list or ndarray of rows and sequence of names for the columns. If rows is an ndarray, dtypes must be None, otherwise we raise a ValueError. Otherwise, if dtypes is None, we cast the data in all columns in rows as np.float. If dtypes is not None, the routine uses dtypes as a dtype specifier for the output structured array.
Parameters: rows: list or array :
Rows that will be turned into an recarray.
names: sequence :
Sequence of strings - names for the columns.
dtypes: None or sequence of str or sequence of np.dtype, optional :
Used to create a np.dtype, can be sequence of np.dtype or string.
drop_name_dim : {_NoValue, False, True}, optional
Flag for compatibility with future default behavior. Current default is False. If True, drops the length 1 dimension corresponding to the axis transformed into fields when converting into a recarray. If _NoValue specified, gives default. Default will change to True in the next version of Nipy.
Returns: v : np.ndarray
Structured array with field names given by names.
Raises: ValueError :
dtypes not None when rows is array.
Examples
The following tests depend on machine byte order for their exact output.
>>> arr = np.array([[3, 4], [4, 6], [6, 8]]) >>> make_recarray(arr, ['x', 'y'], ... drop_name_dim=True) array([(3, 4), (4, 6), (6, 8)], dtype=[('x', '<i8'), ('y', '<i8')]) >>> make_recarray(arr, ['x', 'y'], ... drop_name_dim=False) array([[(3, 4)], [(4, 6)], [(6, 8)]], dtype=[('x', '<i8'), ('y', '<i8')]) >>> r = make_recarray(arr, ['w', 'u'], drop_name_dim=True) >>> make_recarray(r, ['x', 'y'], ... drop_name_dim=True) array([(3, 4), (4, 6), (6, 8)], dtype=[('x', '<i8'), ('y', '<i8')]) >>> make_recarray([[3, 4], [4, 6], [7, 9]], 'wv', ... [np.float, np.int]) array([(3.0, 4), (4.0, 6), (7.0, 9)], dtype=[('w', '<f8'), ('v', '<i8')])
-
nipy.algorithms.statistics.formula.formulae.
natural_spline
(t, knots=None, order=3, intercept=False)¶ Return a Formula containing a natural spline
Spline for a Term with specified knots and order.
Parameters: t :
Term
knots : None or sequence, optional
Sequence of float. Default None (same as empty list)
order : int, optional
Order of the spline. Defaults to a cubic (==3)
intercept : bool, optional
If True, include a constant function in the natural spline. Default is False
Returns: formula : Formula
A Formula with (len(knots) + order) Terms (if intercept=False, otherwise includes one more Term), made up of the natural spline functions.
Examples
>>> x = Term('x') >>> n = natural_spline(x, knots=[1,3,4], order=3) >>> xval = np.array([3,5,7.]).view(np.dtype([('x', np.float)])) >>> n.design(xval, return_float=True) array([[ 3., 9., 27., 8., 0., -0.], [ 5., 25., 125., 64., 8., 1.], [ 7., 49., 343., 216., 64., 27.]]) >>> d = n.design(xval) >>> print(d.dtype.descr) [('ns_1(x)', '<f8'), ('ns_2(x)', '<f8'), ('ns_3(x)', '<f8'), ('ns_4(x)', '<f8'), ('ns_5(x)', '<f8'), ('ns_6(x)', '<f8')]
-
nipy.algorithms.statistics.formula.formulae.
terms
(names, **kwargs)¶ Return list of terms with names given by names
This is just a convenience in defining a set of terms, and is the equivalent of
sympy.symbols
for defining symbols in sympy.We enforce the sympy 0.7.0 behavior of returning symbol “abc” from input “abc”, rthan than 3 symbols “a”, “b”, “c”.
Parameters: names : str or sequence of str
If a single str, can specify multiple ``Term``s with string containing space or ‘,’ as separator.
**kwargs : keyword arguments
keyword arguments as for
sympy.symbols
Returns: ts :
Term
or tupleTerm
instance or list ofTerm
instance objects named from namesExamples
>>> terms(('a', 'b', 'c')) (a, b, c) >>> terms('a, b, c') (a, b, c) >>> terms('abc') abc