# 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, evaluated 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 explicitly 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(name, term)

  Bases: `Dummy`

  A symbol tied to a Term term

  __init__(*args, **kwargs)
  adjoint()
  apart(x=None, **args)

    See the apart function in sympy.polys

  property args: tuple[Basic, ...]

    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. Do not override .args() from Basic (so that it is 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.

    Examples

        >>> 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() → tuple[Expr, Expr]
  as_coeff_Add(rational=False) → tuple['Number', Expr]

    Efficiently extract the coefficient of a summation.

  as_coeff_Mul(rational: bool = False) → tuple['Number', Expr]

    Efficiently extract the coefficient of a product.

  as_coeff_add(*deps) → tuple[Expr, tuple[Expr, ...]]

    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 do not 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 do not 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) → tuple[Expr, Expr]

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

  as_coeff_mul(*deps, **kwargs) → tuple[Expr, tuple[Expr, ...]]

    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 do not 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 do not 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: Expr) → Expr | None

    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.Poly.coeff_monomial`

      efficiently find the single coefficient of a monomial in Poly

    `sympy.polys.polytools.Poly.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 the `coeff` method should be used.)

        >>> (2*E*x + x).as_coefficient(E)
        >>> (2*E*x + x).coeff(E)
        2*x

        >>> (E*(x + 1) + x).as_coefficient(E)

        >>> (2*pi*I).as_coefficient(pi*I)
        2
        >>> (2*I).as_coefficient(pi*I)

  as_coefficients_dict(*syms)

    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 symbols `syms` are provided, any multiplicative terms independent of them will be considered a coefficient and a regular dictionary of syms-dependent generators as keys and their corresponding coefficients as values will be returned.

    Examples

        >>> from sympy.abc import a, x, y
        >>> (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}
        >>> (3*a*x).as_coefficients_dict(x)
        {x: 3*a}
        >>> (3*a*x).as_coefficients_dict(y)
        {1: 3*a*x}

  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 not 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)
        >>> ((x*(1 + y) + 0.4*x*(3 + 3*y))**2).as_content_primitive()
        (1, 4.84*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 the expression with any objects having structurally bound symbols replaced with unique, canonical symbols within the object in which they appear and having only the default assumption for commutativity being True. When applied to a symbol a new symbol having only the same commutativity will be returned.

    Notes

    Any object that has structurally bound variables should have a property, `bound_symbols` that returns those symbols appearing in the object.

    Examples

        >>> from sympy import Integral, Symbol
        >>> from sympy.abc import x
        >>> r = Symbol('r', real=True)
        >>> Integral(r, (r, x)).as_dummy()
        Integral(_0, (_0, x))
        >>> _.variables[0].is_real is None
        True
        >>> r.as_dummy()
        _r

  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) → tuple[Expr, Expr]

    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 either have terms that contain variables that are in deps, or be equal to 0 (when self is an Add) or 1 (when self is a Mul)

    - 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_log`
    `sympy.core.add.Add.as_two_terms`
    `sympy.core.mul.Mul.as_two_terms`
    `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(*symbols, logx=None, cdir=0)

    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() → tuple[Expr, Expr]

    Return the numerator and the denominator of an expression.

    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 returns `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.

    See also

    `as_ordered_factors`

      An alternative for noncommutative applications, returning an ordered list of factors.

    `args_cnc`

      Similar to as_ordered_factors, but guarantees separation of commutative and noncommutative factors.

  as_real_imag(deep=True, **hints)

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

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

        >>> from sympy import symbols, I

        >>> x, y = symbols('x,y', real=True)

        >>> (x + y*I).as_real_imag()
        (x, y)

        >>> from sympy.abc import z, w

        >>> (z + w*I).as_real_imag()
        (re(z) - im(w), re(w) + im(z))

  as_set()

    Rewrites Boolean expression in terms of real sets.

    Examples

        >>> from sympy import Symbol, Eq, Or, And
        >>> x = Symbol('x', real=True)
        >>> Eq(x, 0).as_set()
        {0}
        >>> (x > 0).as_set()
        Interval.open(0, oo)
        >>> And(-2 < x, x < 2).as_set()
        Interval.open(-2, 2)
        >>> Or(x < -2, 2 < x).as_set()
        Union(Interval.open(-oo, -2), Interval.open(2, oo))

  as_terms()

    Transform an expression to a list of terms.

  aseries(x=None, n=6, bound=0, hir=False)

    Asymptotic Series expansion of self. This is equivalent to `self.series(x, oo, n)`.

    Parameters:
      self Expression

        The expression whose series is to be expanded.

      x Symbol

        It is the variable of the expression to be calculated.

      n Value

        The value used to represent the order in terms of `x**n`, up to which the series is to be expanded.

      hir Boolean

        Set this parameter to be True to produce hierarchical series. It stops the recursion at an early level and may provide nicer and more useful results.

      bound Value, Integer

        Use the `bound` parameter to give limit on rewriting coefficients in its normalised form.

    Returns:
      Expr

        Asymptotic series expansion of the expression.

    See also

    `Expr.aseries`

      See the docstring of this function for complete details of this wrapper.

    Notes

    This algorithm is directly induced from the limit computational algorithm provided by Gruntz. It majorly uses the mrv and rewrite sub-routines. The overall idea of this algorithm is first to look for the most rapidly varying subexpression w of a given expression f and then expands f in a series in w. Then same thing is recursively done on the leading coefficient till we get constant coefficients.

    If the most rapidly varying subexpression of a given expression f is f itself, the algorithm tries to find a normalised representation of the mrv set and rewrites f using this normalised representation.

    If the expansion contains an order term, it will be either `O(x ** (-n))` or `O(w ** (-n))` where `w` belongs to the most rapidly varying expression of `self`.

    References

    [1]

    Gruntz, Dominik. A new algorithm for computing asymptotic series. In: Proc. 1993 Int. Symp. Symbolic and Algebraic Computation. 1993. pp. 239-244.

    [2]

    Gruntz thesis - p90

    [3]

    https://en.wikipedia.org/wiki/Asymptotic_expansion

    Examples

        >>> from sympy import sin, exp
        >>> from sympy.abc import x

        >>> e = sin(1/x + exp(-x)) - sin(1/x)

        >>> e.aseries(x)
        (1/(24*x**4) - 1/(2*x**2) + 1 + O(x**(-6), (x, oo)))*exp(-x)

        >>> e.aseries(x, n=3, hir=True)
        -exp(-2*x)*sin(1/x)/2 + exp(-x)*cos(1/x) + O(exp(-3*x), (x, oo))

        >>> e = exp(exp(x)/(1 - 1/x))

        >>> e.aseries(x)
        exp(exp(x)/(1 - 1/x))

        >>> e.aseries(x, bound=3)
        exp(exp(x)/x**2)*exp(exp(x)/x)*exp(-exp(x) + exp(x)/(1 - 1/x) - exp(x)/x - exp(x)/x**2)*exp(exp(x))

    For rational expressions this method may return original expression without the Order term. >>> (1/x).aseries(x, n=8) 1/x

  property assumptions0

    Return object type assumptions.

    For example:

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

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

    Examples

        >>> from sympy import Symbol
        >>> from sympy.abc import x
        >>> x.assumptions0
        {'commutative': True}
        >>> x = Symbol("x", positive=True)
        >>> x.assumptions0
        {'commutative': True, 'complex': True, 'extended_negative': False,
         'extended_nonnegative': True, 'extended_nonpositive': False,
         'extended_nonzero': True, 'extended_positive': True, 'extended_real':
         True, 'finite': True, 'hermitian': True, 'imaginary': False,
         'infinite': False, 'negative': False, 'nonnegative': True,
         'nonpositive': False, 'nonzero': True, 'positive': True, 'real':
         True, 'zero': False}

  atoms(*types: Tbasic | type[Tbasic]) → set[Basic] | set[Tbasic]

    Returns the atoms that form the current object.

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

    Examples

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

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

        >>> 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` but `type(S(1))` is `One`, a special type of SymPy atom, while `type(S(2))` is type `Integer` and will find all integers in an expression:

        >>> from sympy import S
        >>> (1 + x + 2*sin(y + I*pi)).atoms(S(1))
        {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)}

  property binary_symbols
  cancel(*gens, **args)

    See the cancel function in sympy.polys

  property canonical_variables: dict[Basic, Symbol]

    Return a dictionary mapping any variable defined in `self.bound_symbols` to Symbols that do not clash with any free symbols in the expression.

    Examples

        >>> from sympy import Lambda
        >>> from sympy.abc import x
        >>> Lambda(x, 2*x).canonical_variables
        {x: _0}

  classmethod class_key()

    Nice order of classes.

  coeff(x: Expr, n=1, right=False, _first=True)

    Returns the coefficient from the term(s) containing `x**n`. If `n` is zero then all terms independent of `x` will be returned.

    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.Poly.coeff_monomial`

      efficiently find the single coefficient of a monomial in Poly

    `sympy.polys.polytools.Poly.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 less than, equal, or greater than other in a canonical sense. Non-Basic are always greater than Basic. If both names of the classes being compared appear in the ordering_of_classes then the ordering will depend on the appearance of the names there. If either does not appear in that list, then the comparison is based on the class name. If the names are the same then a comparison is made on the length of the hashable content. Items of the equal-lengthed contents are then successively compared using the same rules. If there is never a difference then 0 is returned.

    Examples

        >>> from sympy.abc import x, y
        >>> x.compare(y)
        -1
        >>> x.compare(x)
        0
        >>> y.compare(x)
        1

  conjugate()

    Returns the complex conjugate of ‘self’.

  copy()
  could_extract_minus_sign() → bool

    Return True if self has -1 as a leading factor or has more literal negative signs than positive signs in a sum, otherwise False.

    Examples

        >>> from sympy.abc import x, y
        >>> e = x - y
        >>> {i.could_extract_minus_sign() for i in (e, -e)}
        {False, True}

    Though the `y - x` is considered like `-(x - y)`, since it is in a product without a leading factor of -1, the result is false below:

        >>> (x*(y - x)).could_extract_minus_sign()
        False

    To put something in canonical form wrt to sign, use signsimp:

        >>> from sympy import signsimp
        >>> signsimp(x*(y - x))
        -x*(x - y)
        >>> _.could_extract_minus_sign()
        True

  count(query)

    Count the number of matching subexpressions.

  count_ops(visual=False)

    Wrapper for count_ops that returns the operation count.

  default_assumptions: ClassVar[StdFactKB] = {}
  diff(*symbols, **assumptions)
  dir(x, cdir)
  doit(**hints)

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

        >>> from sympy import Integral
        >>> from sympy.abc import x

        >>> 2*Integral(x, x)
        2*Integral(x, x)

        >>> (2*Integral(x, x)).doit()
        x**2

        >>> (2*Integral(x, x)).doit(deep=False)
        2*Integral(x, x)

  dummy_eq(other, symbol=None)

    Compare two expressions and handle dummy symbols.

    Examples

        >>> from sympy import Dummy
        >>> from sympy.abc import x, y

        >>> u = Dummy('u')

        >>> (u**2 + 1).dummy_eq(x**2 + 1)
        True
        >>> (u**2 + 1) == (x**2 + 1)
        False

        >>> (u**2 + y).dummy_eq(x**2 + y, x)
        True
        >>> (u**2 + y).dummy_eq(x**2 + y, y)
        False

  dummy_index
  equals(other, failing_expression=False)

    Return True if self == other, False if it does not, or None. If failing_expression is True then the expression which did not simplify to a 0 will be returned instead of None.

  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.

    Parameters:
      subs dict, optional

        Substitute numerical values for symbols, e.g. `subs={x:3, y:1+pi}`. The substitutions must be given as a dictionary.

      maxn int, optional

        Allow a maximum temporary working precision of maxn digits.

      chop bool or number, optional

        Specifies how to replace tiny real or imaginary parts in subresults by exact zeros.

        When `True` the chop value defaults to standard precision.

        Otherwise the chop value is used to determine the magnitude of “small” for purposes of chopping.

            >>> from sympy import N
            >>> x = 1e-4
            >>> N(x, chop=True)
            0.000100000000000000
            >>> N(x, chop=1e-5)
            0.000100000000000000
            >>> N(x, chop=1e-4)
            0

      strict bool, optional

        Raise `PrecisionExhausted` if any subresult fails to evaluate to full accuracy, given the available maxprec.

      quad str, optional

        Choose algorithm for numerical quadrature. By default, tanh-sinh quadrature is used. For oscillatory integrals on an infinite interval, try `quad='osc'`.

      verbose bool, optional

        Print debug information.

    Notes

    When Floats are naively substituted into an expression, precision errors may adversely affect the result. For example, adding 1e16 (a Float) to 1 will truncate to 1e16; if 1e16 is then subtracted, the result will be 0. That is exactly what happens in the following:

        >>> from sympy.abc import x, y, z
        >>> values = {x: 1e16, y: 1, z: 1e16}
        >>> (x + y - z).subs(values)
        0

    Using the subs argument for evalf is the accurate way to evaluate such an expression:

        >>> (x + y - z).evalf(subs=values)
        1.00000000000000

  expand(deep=True, modulus=None, power_base=True, power_exp=True, mul=True, log=True, multinomial=True, basic=True, **hints)

    Expand an expression using hints.

    See the docstring of the expand() function in sympy.core.function for more information.

  property expr_free_symbols

    Like `free_symbols`, but returns the free symbols only if they are contained in an expression node.

    Examples

        >>> from sympy.abc import x, y
        >>> (x + y).expr_free_symbols
        {x, y}

    If the expression is contained in a non-expression object, do not return the free symbols. Compare:

        >>> from sympy import Tuple
        >>> t = Tuple(x + y)
        >>> t.expr_free_symbols
        set()
        >>> t.free_symbols
        {x, y}

  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

    `extract_multiplicatively`
    `coeff`
    `as_coefficient`

    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

  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: Expr) → Expr | None

    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.

    Examples

        >>> 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.

  property free_symbols

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

    Not all free symbols are `Symbol` (see examples)

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

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

    Examples

        >>> from sympy import Derivative, Integral, IndexedBase
        >>> from sympy.abc import x, y, n
        >>> (x + 1).free_symbols
        {x}
        >>> Integral(x, y).free_symbols
        {x, y}

    Not all free symbols are actually symbols:

        >>> IndexedBase('F')[0].free_symbols
        {F, F[0]}

    The symbols of differentiation are not included unless they appear in the expression being differentiated.

        >>> Derivative(x + y, y).free_symbols
        {x, y}
        >>> Derivative(x, y).free_symbols
        {x}
        >>> Derivative(x, (y, n)).free_symbols
        {n, x}

    If you want to know if a symbol is in the variables of the Derivative you can do so as follows:

        >>> Derivative(x, y).has_free(y)
        True

  classmethod 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)

  property 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

  gammasimp()

    See the gammasimp function in sympy.simplify

  getO() → Expr | None

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

  getn()

    Returns the order of the expression.

    Examples

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

  has(*patterns)

    Test whether any subexpression matches any of the patterns.

    Examples

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

    Note `has` is a structural algorithm with no knowledge of mathematics. Consider the following half-open interval:

        >>> from sympy 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 to `any(expr.has(p) for p in patterns)`. In particular, `False` is returned when the list of patterns is empty.

        >>> x.has()
        False

  has_free(*patterns)

    Return True if self has object(s) `x` as a free expression else False.

    Examples

        >>> from sympy import Integral, Function
        >>> from sympy.abc import x, y
        >>> f = Function('f')
        >>> g = Function('g')
        >>> expr = Integral(f(x), (f(x), 1, g(y)))
        >>> expr.free_symbols
        {y}
        >>> expr.has_free(g(y))
        True
        >>> expr.has_free(*(x, f(x)))
        False

    This works for subexpressions and types, too:

        >>> expr.has_free(g)
        True
        >>> (x + y + 1).has_free(y + 1)
        True

  has_xfree(s: set[Basic])

    Return True if self has any of the patterns in s as a free argument, else False. This is like Basic.has_free but this will only report exact argument matches.

    Examples

        >>> from sympy import Function
        >>> from sympy.abc import x, y
        >>> f = Function('f')
        >>> f(x).has_xfree({f})
        False
        >>> f(x).has_xfree({f(x)})
        True
        >>> f(x + 1).has_xfree({x})
        True
        >>> f(x + 1).has_xfree({x + 1})
        True
        >>> f(x + y + 1).has_xfree({x + 1})
        False

  integrate(*args, **kwargs)

    See the integrate function in sympy.integrals

  invert(g, *gens, **args)

    Return the multiplicative inverse of `self` mod `g` where `self` (and `g`) may be symbolic expressions).

    See also

    `sympy.core.intfunc.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_MatAdd = False
  is_MatMul = 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
  property 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

    `is_rational_function`

    References

    [1]

    https://en.wikipedia.org/wiki/Algebraic_expression

    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

  property is_antihermitian
  property is_commutative
  is_comparable = False
  property is_complex
  property is_composite
  is_constant(*wrt, **flags)

    Return True if self is constant, False if not, or None if the constancy could not be determined conclusively.

    Examples

        >>> from sympy import cos, sin, Sum, S, pi
        >>> from sympy.abc import a, n, x, y
        >>> x.is_constant()
        False
        >>> S(2).is_constant()
        True
        >>> Sum(x, (x, 1, 10)).is_constant()
        True
        >>> Sum(x, (x, 1, n)).is_constant()
        False
        >>> Sum(x, (x, 1, n)).is_constant(y)
        True
        >>> Sum(x, (x, 1, n)).is_constant(n)
        False
        >>> Sum(x, (x, 1, n)).is_constant(x)
        True
        >>> eq = a*cos(x)**2 + a*sin(x)**2 - a
        >>> eq.is_constant()
        True
        >>> eq.subs({x: pi, a: 2}) == eq.subs({x: pi, a: 3}) == 0
        True

        >>> (0**x).is_constant()
        False
        >>> x.is_constant()
        False
        >>> (x**x).is_constant()
        False
        >>> one = cos(x)**2 + sin(x)**2
        >>> one.is_constant()
        True
        >>> ((one - 1)**(x + 1)).is_constant() in (True, False) # could be 0 or 1
        True

  property is_even
  property is_extended_negative
  property is_extended_nonnegative
  property is_extended_nonpositive
  property is_extended_nonzero
  property is_extended_positive
  property is_extended_real
  property is_finite
  property is_hermitian
  is_hypergeometric(k)
  property is_imaginary
  property is_infinite
  property is_integer
  property is_irrational
  is_meromorphic(x, a)

    This tests whether an expression is meromorphic as a function of the given symbol `x` at the point `a`.

    This method is intended as a quick test that will return None if no decision can be made without simplification or more detailed analysis.

    Examples

        >>> from sympy import zoo, log, sin, sqrt
        >>> from sympy.abc import x

        >>> f = 1/x**2 + 1 - 2*x**3
        >>> f.is_meromorphic(x, 0)
        True
        >>> f.is_meromorphic(x, 1)
        True
        >>> f.is_meromorphic(x, zoo)
        True

        >>> g = x**log(3)
        >>> g.is_meromorphic(x, 0)
        False
        >>> g.is_meromorphic(x, 1)
        True
        >>> g.is_meromorphic(x, zoo)
        False

        >>> h = sin(1/x)*x**2
        >>> h.is_meromorphic(x, 0)
        False
        >>> h.is_meromorphic(x, 1)
        True
        >>> h.is_meromorphic(x, zoo)
        True

    Multivalued functions are considered meromorphic when their branches are meromorphic. Thus most functions are meromorphic everywhere except at essential singularities and branch points. In particular, they will be meromorphic also on branch cuts except at their endpoints.

        >>> log(x).is_meromorphic(x, -1)
        True
        >>> log(x).is_meromorphic(x, 0)
        False
        >>> sqrt(x).is_meromorphic(x, -1)
        True
        >>> sqrt(x).is_meromorphic(x, 0)
        False

  property is_negative
  property is_noninteger
  property is_nonnegative
  property is_nonpositive
  property is_nonzero
  is_number = False
  property is_odd
  property 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, Function
        >>> 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
        >>> (2**x + 1).is_polynomial(2**x)
        True
        >>> f = Function('f')
        >>> (f(x) + 1).is_polynomial(x)
        False
        >>> (f(x) + 1).is_polynomial(f(x))
        True
        >>> (1/f(x) + 1).is_polynomial(f(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()

  property is_positive
  property is_prime
  property 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().

  property is_real
  is_same(b, approx=None)

    Return True if a and b are structurally the same, else False. If approx is supplied, it will be used to test whether two numbers are the same or not. By default, only numbers of the same type will compare equal, so S.Half != Float(0.5).

    Examples

    In SymPy (unlike Python) two numbers do not compare the same if they are not of the same type:

        >>> from sympy import S
        >>> 2.0 == S(2)
        False
        >>> 0.5 == S.Half
        False

    By supplying a function with which to compare two numbers, such differences can be ignored. e.g. equal_valued will return True for decimal numbers having a denominator that is a power of 2, regardless of precision.

        >>> from sympy import Float
        >>> from sympy.core.numbers import equal_valued
        >>> (S.Half/4).is_same(Float(0.125, 1), equal_valued)
        True
        >>> Float(1, 2).is_same(Float(1, 10), equal_valued)
        True

    But decimals without a power of 2 denominator will compare as not being the same.

        >>> Float(0.1, 9).is_same(Float(0.1, 10), equal_valued)
        False

    But arbitrary differences can be ignored by supplying a function to test the equivalence of two numbers:

        >>> import math
        >>> Float(0.1, 9).is_same(Float(0.1, 10), math.isclose)
        True

    Other objects might compare the same even though types are not the same. This routine will only return True if two expressions are identical in terms of class types.

        >>> from sympy import eye, Basic
        >>> eye(1) == S(eye(1))  # mutable vs immutable
        True
        >>> Basic.is_same(eye(1), S(eye(1)))
        False

  is_scalar = True
  is_symbol = True
  property is_transcendental
  property is_zero
  property kind

    Default kind for all SymPy object. If the kind is not defined for the object, or if the object cannot infer the kind from its arguments, this will be returned.

    Examples

        >>> from sympy import Expr
        >>> Expr().kind
        UndefinedKind

  leadterm(x, logx=None, cdir=0)

    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, cdir=0)

    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 do not 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

    See also

    `matches`

      pattern.matches(expr) is the same as expr.match(pattern)

    `xreplace`

      exact structural replacement

    `replace`

      structural replacement with pattern matching

    `Wild`

      symbolic placeholders for expressions in pattern matching

    Examples

        >>> from sympy import Wild, Sum
        >>> 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

    Since match is purely structural expressions that are equivalent up to bound symbols will not match:

        >>> print(Sum(x, (x, 1, 2)).match(Sum(y, (y, 1, p))))
        None

    An expression with bound symbols can be matched if the pattern uses a distinct `Wild` for each bound symbol:

        >>> Sum(x, (x, 1, 2)).match(Sum(q, (q, 1, p)))
        {p_: 2, q_: x}

    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 unless `old=True`:

        >>> (x - 2).match(p - x, old=True)
        {p_: 2*x - 2}
        >>> (2/x).match(p*x, old=True)
        {p_: 2/x**2}

  matches(expr, repl_dict=None, old=False)

    Helper method for match() that looks for a match between Wild symbols in self and expressions in expr.

    Examples

        >>> from sympy import symbols, Wild, Basic
        >>> a, b, c = symbols('a b c')
        >>> x = Wild('x')
        >>> Basic(a + x, x).matches(Basic(a + b, c)) is None
        True
        >>> Basic(a + x, x).matches(Basic(a + b + c, b + c))
        {x_: b + c}

  n(n=15, subs=None, maxn=100, chop=False, strict=False, quad=None, verbose=False)

    Evaluate the given formula to an accuracy of n digits.

    Parameters:
      subs dict, optional

        Substitute numerical values for symbols, e.g. `subs={x:3, y:1+pi}`. The substitutions must be given as a dictionary.

      maxn int, optional

        Allow a maximum temporary working precision of maxn digits.

      chop bool or number, optional

        Specifies how to replace tiny real or imaginary parts in subresults by exact zeros.

        When `True` the chop value defaults to standard precision.

        Otherwise the chop value is used to determine the magnitude of “small” for purposes of chopping.

            >>> from sympy import N
            >>> x = 1e-4
            >>> N(x, chop=True)
            0.000100000000000000
            >>> N(x, chop=1e-5)
            0.000100000000000000
            >>> N(x, chop=1e-4)
            0

      strict bool, optional

        Raise `PrecisionExhausted` if any subresult fails to evaluate to full accuracy, given the available maxprec.

      quad str, optional

        Choose algorithm for numerical quadrature. By default, tanh-sinh quadrature is used. For oscillatory integrals on an infinite interval, try `quad='osc'`.

      verbose bool, optional

        Print debug information.

    Notes

    When Floats are naively substituted into an expression, precision errors may adversely affect the result. For example, adding 1e16 (a Float) to 1 will truncate to 1e16; if 1e16 is then subtracted, the result will be 0. That is exactly what happens in the following:

        >>> from sympy.abc import x, y, z
        >>> values = {x: 1e16, y: 1, z: 1e16}
        >>> (x + y - z).subs(values)
        0

    Using the subs argument for evalf is the accurate way to evaluate such an expression:

        >>> (x + y - z).evalf(subs=values)
        1.00000000000000

  name: str
  normal()

    Return the expression as a fraction.

    expression -> a/b

    See also

    `as_numer_denom`

      return `(a, b)` instead of `a/b`

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

    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 do not have to determine how many terms we need to calculate in advance.

    Disadvantage – you may end up with less terms than you may have expected, but the O(x**n) term appended will always be correct and so the result, though perhaps shorter, will also be correct.

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

    See also lseries().

    Examples

        >>> from sympy import sin, log, Symbol
        >>> from sympy.abc import x, y
        >>> sin(x).nseries(x, 0, 6)
        x - x**3/6 + x**5/120 + O(x**6)
        >>> log(x+1).nseries(x, 0, 5)
        x - x**2/2 + x**3/3 - x**4/4 + O(x**5)

    Handling of the `logx` parameter — in the following example the expansion fails since `sin` does not have an asymptotic expansion at -oo (the limit of log(x) as x approaches 0):

        >>> e = sin(log(x))
        >>> e.nseries(x, 0, 6)
        Traceback (most recent call last):
        ...
        PoleError: ...
        ...
        >>> logx = Symbol('logx')
        >>> e.nseries(x, 0, 6, logx=logx)
        sin(logx)

    In the following example, the expansion works but only returns self unless the `logx` parameter is used:

        >>> e = x**y
        >>> e.nseries(x, 0, 2)
        x**y
        >>> 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() → tuple[Number, Expr]

    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 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() → Expr

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

  replace(query, value, map=False, simultaneous=True, exact=None) → Basic

    Replace matching subexpressions of `self` with `value`.

    If `map = True` then also return the mapping {old: new} where `old` was a sub-expression found with query and `new` is the replacement value for it. If the expression itself does not match the query, then the returned value will be `self.xreplace(map)` otherwise it should be `self.subs(ordered(map.items()))`.

    Traverses an expression tree and performs replacement of matching subexpressions from the bottom to the top of the tree. The default approach is to do the replacement in a simultaneous fashion so changes made are targeted only once. If this is not desired or causes problems, `simultaneous` can be set to False.

    In addition, if an expression containing more than one Wild symbol is being used to match subexpressions and the `exact` flag is None it will be set to True so the match will only succeed if all non-zero values are received for each Wild that appears in the match pattern. Setting this to False accepts a match of 0; while setting it True accepts all matches that have a 0 in them. See example below for cautions.

    The list of possible combinations of queries and replacement values is listed below:

    See also

    `subs`

      substitution of subexpressions as defined by the objects themselves.

    `xreplace`

      exact node replacement in expr tree; also capable of using matching rules

    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) to `newtype`.

          >>> f.replace(sin, cos)
          log(cos(x)) + tan(cos(x**2))
          >>> sin(x).replace(sin, cos, map=True)
          (cos(x), {sin(x): cos(x)})
          >>> (x*y).replace(Mul, Add)
          x + y

    1.2. type -> func

      obj.replace(type, func)

      When object of type `type` is found, apply `func` to its argument(s). `func` must be written to handle the number of arguments of `type`.

          >>> f.replace(sin, lambda arg: sin(2*arg))
          log(sin(2*x)) + tan(sin(2*x**2))
          >>> (x*y).replace(Mul, lambda *args: sin(2*Mul(*args)))
          sin(2*x*y)

    2.1. pattern -> expr

      obj.replace(pattern(wild), expr(wild))

      Replace subexpressions matching `pattern` with the expression written in terms of the Wild symbols in `pattern`.

          >>> a, b = map(Wild, 'ab')
          >>> 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

      Matching is exact by default when more than one Wild symbol is used: matching fails unless the match gives non-zero values for all Wild symbols:

          >>> (2*x + y).replace(a*x + b, b - a)
          y - 2
          >>> (2*x).replace(a*x + b, b - a)
          2*x

      When set to False, the results may be non-intuitive:

          >>> (2*x).replace(a*x + b, b - a, exact=False)
          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` with `func(e)` if `filter(e)` is True.

          >>> g = 2*sin(x**3)
          >>> g.replace(lambda expr: expr.is_Number, lambda expr: expr**2)
          4*sin(x**9)

    The expression itself is also targeted by the query but is done in such a fashion that changes are not made twice.

        >>> e = x*(x*y + 1)
        >>> e.replace(lambda x: x.is_Mul, lambda x: 2*x)
        2*x*(2*x*y + 1)

    When matching a single symbol, exact will default to True, but this may or may not be the behavior that is desired:

    Here, we want exact=False:

        >>> from sympy import Function
        >>> f = Function('f')
        >>> e = f(1) + f(0)
        >>> q = f(a), lambda a: f(a + 1)
        >>> e.replace(*q, exact=False)
        f(1) + f(2)
        >>> e.replace(*q, exact=True)
        f(0) + f(2)

    But here, the nature of matching makes selecting the right setting tricky:

        >>> e = x**(1 + y)
        >>> (x**(1 + y)).replace(x**(1 + a), lambda a: x**-a, exact=False)
        x
        >>> (x**(1 + y)).replace(x**(1 + a), lambda a: x**-a, exact=True)
        x**(-x - y + 1)
        >>> (x**y).replace(x**(1 + a), lambda a: x**-a, exact=False)
        x
        >>> (x**y).replace(x**(1 + a), lambda a: x**-a, exact=True)
        x**(1 - y)

    It is probably better to use a different form of the query that describes the target expression more precisely:

        >>> (1 + x**(1 + y)).replace(
        ... lambda x: x.is_Pow and x.exp.is_Add and x.exp.args[0] == 1,
        ... lambda x: x.base**(1 - (x.exp - 1)))
        ...
        x**(1 - y) + 1

  rewrite(*args, deep=True, **hints)

    Rewrite self using a defined rule.

    Rewriting transforms an expression to another, which is mathematically equivalent but structurally different. For example you can rewrite trigonometric functions as complex exponentials or combinatorial functions as gamma function.

    This method takes a pattern and a rule as positional arguments. pattern is optional parameter which defines the types of expressions that will be transformed. If it is not passed, all possible expressions will be rewritten. rule defines how the expression will be rewritten.

    Parameters:
      args Expr

        A rule, or pattern and rule. - pattern is a type or an iterable of types. - rule can be any object.

      deep bool, optional

        If `True`, subexpressions are recursively transformed. Default is `True`.

    Examples

    If pattern is unspecified, all possible expressions are transformed.

        >>> from sympy import cos, sin, exp, I
        >>> from sympy.abc import x
        >>> expr = cos(x) + I*sin(x)
        >>> expr.rewrite(exp)
        exp(I*x)

    Pattern can be a type or an iterable of types.

        >>> expr.rewrite(sin, exp)
        exp(I*x)/2 + cos(x) - exp(-I*x)/2
        >>> expr.rewrite([cos,], exp)
        exp(I*x)/2 + I*sin(x) + exp(-I*x)/2
        >>> expr.rewrite([cos, sin], exp)
        exp(I*x)

    Rewriting behavior can be implemented by defining `_eval_rewrite()` method.

        >>> from sympy import Expr, sqrt, pi
        >>> class MySin(Expr):
        ...     def _eval_rewrite(self, rule, args, **hints):
        ...         x, = args
        ...         if rule == cos:
        ...             return cos(pi/2 - x, evaluate=False)
        ...         if rule == sqrt:
        ...             return sqrt(1 - cos(x)**2)
        >>> MySin(MySin(x)).rewrite(cos)
        cos(-cos(-x + pi/2) + pi/2)
        >>> MySin(x).rewrite(sqrt)
        sqrt(1 - cos(x)**2)

    Defining `_eval_rewrite_as_[...]()` method is supported for backwards compatibility reason. This may be removed in the future and using it is discouraged.

        >>> class MySin(Expr):
        ...     def _eval_rewrite_as_cos(self, *args, **hints):
        ...         x, = args
        ...         return cos(pi/2 - x, evaluate=False)
        >>> MySin(x).rewrite(cos)
        cos(-x + pi/2)

  round(n=None)

    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

    The Python `round` function uses the SymPy `round` method so it will always return a SymPy number (not a Python float or int):

        >>> isinstance(round(S(123), -2), Number)
        True

    Examples

        >>> from sympy import pi, E, I, S, Number
        >>> 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, cdir=0)

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

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

    If `x=None` and `self` is univariate, the univariate symbol will be supplied, otherwise an error will be raised.

    Parameters:
      expr Expression

        The expression whose series is to be expanded.

      x Symbol

        It is the variable of the expression to be calculated.

      x0 Value

        The value around which `x` is calculated. Can be any value from `-oo` to `oo`.

      n Value

        The value used to represent the order in terms of `x**n`, up to which the series is to be expanded.

      dir String, optional

        The series-expansion can be bi-directional. If `dir="+"`, then (x->x0+). If `dir="-", then (x->x0-). For infinite ``x0` (`oo` or `-oo`), the `dir` argument is determined from the direction of the infinity (i.e., `dir="-"` for `oo`).

      logx optional

        It is used to replace any log(x) in the returned series with a symbolic value rather than evaluating the actual value.

      cdir optional

        It stands for complex direction, and indicates the direction from which the expansion needs to be evaluated.

    Returns:
      Expr Expression

        Series expansion of the expression about x0

    Raises:
      TypeError

        If “n” and “x0” are infinity objects

      PoleError

        If “x0” is an infinity object

    Examples

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

    If `n=None` then a generator of the series terms will be returned.

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

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

        >>> abs(x).series(dir="+")
        x
        >>> abs(x).series(dir="-")
        -x
        >>> f = tan(x)
        >>> f.series(x, 2, 6, "+")
        tan(2) + (1 + tan(2)**2)*(x - 2) + (x - 2)**2*(tan(2)**3 + tan(2)) +
        (x - 2)**3*(1/3 + 4*tan(2)**2/3 + tan(2)**4) + (x - 2)**4*(tan(2)**5 +
        5*tan(2)**3/3 + 2*tan(2)/3) + (x - 2)**5*(2/15 + 17*tan(2)**2/15 +
        2*tan(2)**4 + tan(2)**6) + O((x - 2)**6, (x, 2))

        >>> f.series(x, 2, 3, "-")
        tan(2) + (2 - x)*(-tan(2)**2 - 1) + (2 - x)**2*(tan(2)**3 + tan(2))
        + O((x - 2)**3, (x, 2))

    For rational expressions this method may return original expression without the Order term. >>> (1/x).series(x, n=8) 1/x

  simplify(**kwargs) → Basic

    See the simplify function in sympy.simplify

  sort_key(order=None)

    Return a sort key.

    Examples

        >>> from sympy import S, I

        >>> sorted([S(1)/2, I, -I], key=lambda x: x.sort_key())
        [1/2, -I, I]

        >>> S("[x, 1/x, 1/x**2, x**2, x**(1/2), x**(1/4), x**(3/2)]")
        [x, 1/x, x**(-2), x**2, sqrt(x), x**(1/4), x**(3/2)]
        >>> sorted(_, key=lambda x: x.sort_key())
        [x**(-2), 1/x, x**(1/4), sqrt(x), x, x**(3/2), x**2]

  subs(arg1: Mapping[Basic | complex, Basic | complex] | Iterable[tuple[Basic | complex, Basic | complex]] | Basic | complex, arg2: Basic | complex | None = None, **kwargs: Any) → Basic

    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

    `replace`

      replacement capable of doing wildcard-like matching, parsing of match, and conditional replacements

    `xreplace`

      exact node replacement in expr tree; also capable of using matching rules

    `sympy.core.evalf.EvalfMixin.evalf`

      calculates the given formula to a desired level of precision

    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”.

  to_nnf(simplify=True)
  together(*args, **kwargs)

    See the together function in sympy.polys

  transpose()
  trigsimp(**args)

    See the trigsimp function in sympy.simplify

  xreplace(rule, hack2=False)

    Replace occurrences of objects within the expression.

    Parameters:
      rule dict-like

        Expresses a replacement rule

    Returns:
      xreplace the result of the replacement

    See also

    `replace`

      replacement capable of doing wildcard-like matching, parsing of match, and conditional replacements

    `subs`

      substitution of subexpressions as defined by the objects themselves.

    Examples

        >>> from sympy import symbols, pi, exp
        >>> x, y, z = symbols('x y z')
        >>> (1 + x*y).xreplace({x: pi})
        pi*y + 1
        >>> (1 + x*y).xreplace({x: pi, y: 2})
        1 + 2*pi

    Replacements occur only if an entire node in the expression tree is matched:

        >>> (x*y + z).xreplace({x*y: pi})
        z + pi
        >>> (x*y*z).xreplace({x*y: pi})
        x*y*z
        >>> (2*x).xreplace({2*x: y, x: z})
        y
        >>> (2*2*x).xreplace({2*x: y, x: z})
        4*z
        >>> (x + y + 2).xreplace({x + y: 2})
        x + y + 2
        >>> (x + 2 + exp(x + 2)).xreplace({x + 2: y})
        x + exp(y) + 2

    xreplace does not differentiate between free and bound symbols. In the following, subs(x, y) would not change x since it is a bound symbol, but xreplace does:

        >>> from sympy import Integral
        >>> Integral(x, (x, 1, 2*x)).xreplace({x: y})
        Integral(y, (y, 1, 2*y))

    Trying to replace x with an expression raises an error:

        >>> Integral(x, (x, 1, 2*x)).xreplace({x: 2*y})
        ValueError: Invalid limits given: ((2*y, 1, 4*y),)

### `Factor`

class nipy.algorithms.statistics.formula.formulae.Factor(name, levels, char='b')

  Bases: `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.

  __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

  property 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.float64 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

  property design_expr
  property 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.float64), ('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')]

  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.

  get_term(level)

    Retrieve a term of the Factor…

  property main_effect
  property mean

    Expression for the mean, expressed as a linear combination of terms, each with dummy variables in front.

  property 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)

  property terms

    Terms in the linear regression formula.

### `FactorTerm`

class nipy.algorithms.statistics.formula.formulae.FactorTerm(name, level)

  Bases: `Term`

  Boolean Term derived from a Factor.

  Its properties are the same as a Term except that its product with itself is itself.

  __init__(*args, **kwargs)
  adjoint()
  apart(x=None, **args)

    See the apart function in sympy.polys

  property args: tuple[Basic, ...]

    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. Do not override .args() from Basic (so that it is 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.

    Examples

        >>> 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() → tuple[Expr, Expr]
  as_coeff_Add(rational=False) → tuple['Number', Expr]

    Efficiently extract the coefficient of a summation.

  as_coeff_Mul(rational: bool = False) → tuple['Number', Expr]

    Efficiently extract the coefficient of a product.

  as_coeff_add(*deps) → tuple[Expr, tuple[Expr, ...]]

    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 do not 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 do not 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) → tuple[Expr, Expr]

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

  as_coeff_mul(*deps, **kwargs) → tuple[Expr, tuple[Expr, ...]]

    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 do not 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 do not 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: Expr) → Expr | None

    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.Poly.coeff_monomial`

      efficiently find the single coefficient of a monomial in Poly

    `sympy.polys.polytools.Poly.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 the `coeff` method should be used.)

        >>> (2*E*x + x).as_coefficient(E)
        >>> (2*E*x + x).coeff(E)
        2*x

        >>> (E*(x + 1) + x).as_coefficient(E)

        >>> (2*pi*I).as_coefficient(pi*I)
        2
        >>> (2*I).as_coefficient(pi*I)

  as_coefficients_dict(*syms)

    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 symbols `syms` are provided, any multiplicative terms independent of them will be considered a coefficient and a regular dictionary of syms-dependent generators as keys and their corresponding coefficients as values will be returned.

    Examples

        >>> from sympy.abc import a, x, y
        >>> (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}
        >>> (3*a*x).as_coefficients_dict(x)
        {x: 3*a}
        >>> (3*a*x).as_coefficients_dict(y)
        {1: 3*a*x}

  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 not 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)
        >>> ((x*(1 + y) + 0.4*x*(3 + 3*y))**2).as_content_primitive()
        (1, 4.84*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 the expression with any objects having structurally bound symbols replaced with unique, canonical symbols within the object in which they appear and having only the default assumption for commutativity being True. When applied to a symbol a new symbol having only the same commutativity will be returned.

    Notes

    Any object that has structurally bound variables should have a property, `bound_symbols` that returns those symbols appearing in the object.

    Examples

        >>> from sympy import Integral, Symbol
        >>> from sympy.abc import x
        >>> r = Symbol('r', real=True)
        >>> Integral(r, (r, x)).as_dummy()
        Integral(_0, (_0, x))
        >>> _.variables[0].is_real is None
        True
        >>> r.as_dummy()
        _r

  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) → tuple[Expr, Expr]

    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 either have terms that contain variables that are in deps, or be equal to 0 (when self is an Add) or 1 (when self is a Mul)

    - 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_log`
    `sympy.core.add.Add.as_two_terms`
    `sympy.core.mul.Mul.as_two_terms`
    `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(*symbols, logx=None, cdir=0)

    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() → tuple[Expr, Expr]

    Return the numerator and the denominator of an expression.

    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 returns `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.

    See also

    `as_ordered_factors`

      An alternative for noncommutative applications, returning an ordered list of factors.

    `args_cnc`

      Similar to as_ordered_factors, but guarantees separation of commutative and noncommutative factors.

  as_real_imag(deep=True, **hints)

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

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

        >>> from sympy import symbols, I

        >>> x, y = symbols('x,y', real=True)

        >>> (x + y*I).as_real_imag()
        (x, y)

        >>> from sympy.abc import z, w

        >>> (z + w*I).as_real_imag()
        (re(z) - im(w), re(w) + im(z))

  as_set()

    Rewrites Boolean expression in terms of real sets.

    Examples

        >>> from sympy import Symbol, Eq, Or, And
        >>> x = Symbol('x', real=True)
        >>> Eq(x, 0).as_set()
        {0}
        >>> (x > 0).as_set()
        Interval.open(0, oo)
        >>> And(-2 < x, x < 2).as_set()
        Interval.open(-2, 2)
        >>> Or(x < -2, 2 < x).as_set()
        Union(Interval.open(-oo, -2), Interval.open(2, oo))

  as_terms()

    Transform an expression to a list of terms.

  aseries(x=None, n=6, bound=0, hir=False)

    Asymptotic Series expansion of self. This is equivalent to `self.series(x, oo, n)`.

    Parameters:
      self Expression

        The expression whose series is to be expanded.

      x Symbol

        It is the variable of the expression to be calculated.

      n Value

        The value used to represent the order in terms of `x**n`, up to which the series is to be expanded.

      hir Boolean

        Set this parameter to be True to produce hierarchical series. It stops the recursion at an early level and may provide nicer and more useful results.

      bound Value, Integer

        Use the `bound` parameter to give limit on rewriting coefficients in its normalised form.

    Returns:
      Expr

        Asymptotic series expansion of the expression.

    See also

    `Expr.aseries`

      See the docstring of this function for complete details of this wrapper.

    Notes

    This algorithm is directly induced from the limit computational algorithm provided by Gruntz. It majorly uses the mrv and rewrite sub-routines. The overall idea of this algorithm is first to look for the most rapidly varying subexpression w of a given expression f and then expands f in a series in w. Then same thing is recursively done on the leading coefficient till we get constant coefficients.

    If the most rapidly varying subexpression of a given expression f is f itself, the algorithm tries to find a normalised representation of the mrv set and rewrites f using this normalised representation.

    If the expansion contains an order term, it will be either `O(x ** (-n))` or `O(w ** (-n))` where `w` belongs to the most rapidly varying expression of `self`.

    References

    [1]

    Gruntz, Dominik. A new algorithm for computing asymptotic series. In: Proc. 1993 Int. Symp. Symbolic and Algebraic Computation. 1993. pp. 239-244.

    [2]

    Gruntz thesis - p90

    [3]

    https://en.wikipedia.org/wiki/Asymptotic_expansion

    Examples

        >>> from sympy import sin, exp
        >>> from sympy.abc import x

        >>> e = sin(1/x + exp(-x)) - sin(1/x)

        >>> e.aseries(x)
        (1/(24*x**4) - 1/(2*x**2) + 1 + O(x**(-6), (x, oo)))*exp(-x)

        >>> e.aseries(x, n=3, hir=True)
        -exp(-2*x)*sin(1/x)/2 + exp(-x)*cos(1/x) + O(exp(-3*x), (x, oo))

        >>> e = exp(exp(x)/(1 - 1/x))

        >>> e.aseries(x)
        exp(exp(x)/(1 - 1/x))

        >>> e.aseries(x, bound=3)
        exp(exp(x)/x**2)*exp(exp(x)/x)*exp(-exp(x) + exp(x)/(1 - 1/x) - exp(x)/x - exp(x)/x**2)*exp(exp(x))

    For rational expressions this method may return original expression without the Order term. >>> (1/x).aseries(x, n=8) 1/x

  property assumptions0

    Return object type assumptions.

    For example:

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

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

    Examples

        >>> from sympy import Symbol
        >>> from sympy.abc import x
        >>> x.assumptions0
        {'commutative': True}
        >>> x = Symbol("x", positive=True)
        >>> x.assumptions0
        {'commutative': True, 'complex': True, 'extended_negative': False,
         'extended_nonnegative': True, 'extended_nonpositive': False,
         'extended_nonzero': True, 'extended_positive': True, 'extended_real':
         True, 'finite': True, 'hermitian': True, 'imaginary': False,
         'infinite': False, 'negative': False, 'nonnegative': True,
         'nonpositive': False, 'nonzero': True, 'positive': True, 'real':
         True, 'zero': False}

  atoms(*types: Tbasic | type[Tbasic]) → set[Basic] | set[Tbasic]

    Returns the atoms that form the current object.

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

    Examples

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

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

        >>> 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` but `type(S(1))` is `One`, a special type of SymPy atom, while `type(S(2))` is type `Integer` and will find all integers in an expression:

        >>> from sympy import S
        >>> (1 + x + 2*sin(y + I*pi)).atoms(S(1))
        {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)}

  property binary_symbols
  cancel(*gens, **args)

    See the cancel function in sympy.polys

  property canonical_variables: dict[Basic, Symbol]

    Return a dictionary mapping any variable defined in `self.bound_symbols` to Symbols that do not clash with any free symbols in the expression.

    Examples

        >>> from sympy import Lambda
        >>> from sympy.abc import x
        >>> Lambda(x, 2*x).canonical_variables
        {x: _0}

  classmethod class_key()

    Nice order of classes.

  coeff(x: Expr, n=1, right=False, _first=True)

    Returns the coefficient from the term(s) containing `x**n`. If `n` is zero then all terms independent of `x` will be returned.

    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.Poly.coeff_monomial`

      efficiently find the single coefficient of a monomial in Poly

    `sympy.polys.polytools.Poly.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 less than, equal, or greater than other in a canonical sense. Non-Basic are always greater than Basic. If both names of the classes being compared appear in the ordering_of_classes then the ordering will depend on the appearance of the names there. If either does not appear in that list, then the comparison is based on the class name. If the names are the same then a comparison is made on the length of the hashable content. Items of the equal-lengthed contents are then successively compared using the same rules. If there is never a difference then 0 is returned.

    Examples

        >>> from sympy.abc import x, y
        >>> x.compare(y)
        -1
        >>> x.compare(x)
        0
        >>> y.compare(x)
        1

  conjugate()

    Returns the complex conjugate of ‘self’.

  copy()
  could_extract_minus_sign() → bool

    Return True if self has -1 as a leading factor or has more literal negative signs than positive signs in a sum, otherwise False.

    Examples

        >>> from sympy.abc import x, y
        >>> e = x - y
        >>> {i.could_extract_minus_sign() for i in (e, -e)}
        {False, True}

    Though the `y - x` is considered like `-(x - y)`, since it is in a product without a leading factor of -1, the result is false below:

        >>> (x*(y - x)).could_extract_minus_sign()
        False

    To put something in canonical form wrt to sign, use signsimp:

        >>> from sympy import signsimp
        >>> signsimp(x*(y - x))
        -x*(x - y)
        >>> _.could_extract_minus_sign()
        True

  count(query)

    Count the number of matching subexpressions.

  count_ops(visual=False)

    Wrapper for count_ops that returns the operation count.

  default_assumptions: ClassVar[StdFactKB] = {}
  diff(*symbols, **assumptions)
  dir(x, cdir)
  doit(**hints)

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

        >>> from sympy import Integral
        >>> from sympy.abc import x

        >>> 2*Integral(x, x)
        2*Integral(x, x)

        >>> (2*Integral(x, x)).doit()
        x**2

        >>> (2*Integral(x, x)).doit(deep=False)
        2*Integral(x, x)

  dummy_eq(other, symbol=None)

    Compare two expressions and handle dummy symbols.

    Examples

        >>> from sympy import Dummy
        >>> from sympy.abc import x, y

        >>> u = Dummy('u')

        >>> (u**2 + 1).dummy_eq(x**2 + 1)
        True
        >>> (u**2 + 1) == (x**2 + 1)
        False

        >>> (u**2 + y).dummy_eq(x**2 + y, x)
        True
        >>> (u**2 + y).dummy_eq(x**2 + y, y)
        False

  equals(other, failing_expression=False)

    Return True if self == other, False if it does not, or None. If failing_expression is True then the expression which did not simplify to a 0 will be returned instead of None.

  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.

    Parameters:
      subs dict, optional

        Substitute numerical values for symbols, e.g. `subs={x:3, y:1+pi}`. The substitutions must be given as a dictionary.

      maxn int, optional

        Allow a maximum temporary working precision of maxn digits.

      chop bool or number, optional

        Specifies how to replace tiny real or imaginary parts in subresults by exact zeros.

        When `True` the chop value defaults to standard precision.

        Otherwise the chop value is used to determine the magnitude of “small” for purposes of chopping.

            >>> from sympy import N
            >>> x = 1e-4
            >>> N(x, chop=True)
            0.000100000000000000
            >>> N(x, chop=1e-5)
            0.000100000000000000
            >>> N(x, chop=1e-4)
            0

      strict bool, optional

        Raise `PrecisionExhausted` if any subresult fails to evaluate to full accuracy, given the available maxprec.

      quad str, optional

        Choose algorithm for numerical quadrature. By default, tanh-sinh quadrature is used. For oscillatory integrals on an infinite interval, try `quad='osc'`.

      verbose bool, optional

        Print debug information.

    Notes

    When Floats are naively substituted into an expression, precision errors may adversely affect the result. For example, adding 1e16 (a Float) to 1 will truncate to 1e16; if 1e16 is then subtracted, the result will be 0. That is exactly what happens in the following:

        >>> from sympy.abc import x, y, z
        >>> values = {x: 1e16, y: 1, z: 1e16}
        >>> (x + y - z).subs(values)
        0

    Using the subs argument for evalf is the accurate way to evaluate such an expression:

        >>> (x + y - z).evalf(subs=values)
        1.00000000000000

  expand(deep=True, modulus=None, power_base=True, power_exp=True, mul=True, log=True, multinomial=True, basic=True, **hints)

    Expand an expression using hints.

    See the docstring of the expand() function in sympy.core.function for more information.

  property expr_free_symbols

    Like `free_symbols`, but returns the free symbols only if they are contained in an expression node.

    Examples

        >>> from sympy.abc import x, y
        >>> (x + y).expr_free_symbols
        {x, y}

    If the expression is contained in a non-expression object, do not return the free symbols. Compare:

        >>> from sympy import Tuple
        >>> t = Tuple(x + y)
        >>> t.expr_free_symbols
        set()
        >>> t.free_symbols
        {x, y}

  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

    `extract_multiplicatively`
    `coeff`
    `as_coefficient`

    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

  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: Expr) → Expr | None

    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.

    Examples

        >>> 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.

  property 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.

  property free_symbols

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

    Not all free symbols are `Symbol` (see examples)

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

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

    Examples

        >>> from sympy import Derivative, Integral, IndexedBase
        >>> from sympy.abc import x, y, n
        >>> (x + 1).free_symbols
        {x}
        >>> Integral(x, y).free_symbols
        {x, y}

    Not all free symbols are actually symbols:

        >>> IndexedBase('F')[0].free_symbols
        {F, F[0]}

    The symbols of differentiation are not included unless they appear in the expression being differentiated.

        >>> Derivative(x + y, y).free_symbols
        {x, y}
        >>> Derivative(x, y).free_symbols
        {x}
        >>> Derivative(x, (y, n)).free_symbols
        {n, x}

    If you want to know if a symbol is in the variables of the Derivative you can do so as follows:

        >>> Derivative(x, y).has_free(y)
        True

  classmethod 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)

  property 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

  gammasimp()

    See the gammasimp function in sympy.simplify

  getO() → Expr | None

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

  getn()

    Returns the order of the expression.

    Examples

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

  has(*patterns)

    Test whether any subexpression matches any of the patterns.

    Examples

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

    Note `has` is a structural algorithm with no knowledge of mathematics. Consider the following half-open interval:

        >>> from sympy 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 to `any(expr.has(p) for p in patterns)`. In particular, `False` is returned when the list of patterns is empty.

        >>> x.has()
        False

  has_free(*patterns)

    Return True if self has object(s) `x` as a free expression else False.

    Examples

        >>> from sympy import Integral, Function
        >>> from sympy.abc import x, y
        >>> f = Function('f')
        >>> g = Function('g')
        >>> expr = Integral(f(x), (f(x), 1, g(y)))
        >>> expr.free_symbols
        {y}
        >>> expr.has_free(g(y))
        True
        >>> expr.has_free(*(x, f(x)))
        False

    This works for subexpressions and types, too:

        >>> expr.has_free(g)
        True
        >>> (x + y + 1).has_free(y + 1)
        True

  has_xfree(s: set[Basic])

    Return True if self has any of the patterns in s as a free argument, else False. This is like Basic.has_free but this will only report exact argument matches.

    Examples

        >>> from sympy import Function
        >>> from sympy.abc import x, y
        >>> f = Function('f')
        >>> f(x).has_xfree({f})
        False
        >>> f(x).has_xfree({f(x)})
        True
        >>> f(x + 1).has_xfree({x})
        True
        >>> f(x + 1).has_xfree({x + 1})
        True
        >>> f(x + y + 1).has_xfree({x + 1})
        False

  integrate(*args, **kwargs)

    See the integrate function in sympy.integrals

  invert(g, *gens, **args)

    Return the multiplicative inverse of `self` mod `g` where `self` (and `g`) may be symbolic expressions).

    See also

    `sympy.core.intfunc.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_MatAdd = False
  is_MatMul = 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
  property 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

    `is_rational_function`

    References

    [1]

    https://en.wikipedia.org/wiki/Algebraic_expression

    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

  property is_antihermitian
  property is_commutative
  is_comparable = False
  property is_complex
  property is_composite
  is_constant(*wrt, **flags)

    Return True if self is constant, False if not, or None if the constancy could not be determined conclusively.

    Examples

        >>> from sympy import cos, sin, Sum, S, pi
        >>> from sympy.abc import a, n, x, y
        >>> x.is_constant()
        False
        >>> S(2).is_constant()
        True
        >>> Sum(x, (x, 1, 10)).is_constant()
        True
        >>> Sum(x, (x, 1, n)).is_constant()
        False
        >>> Sum(x, (x, 1, n)).is_constant(y)
        True
        >>> Sum(x, (x, 1, n)).is_constant(n)
        False
        >>> Sum(x, (x, 1, n)).is_constant(x)
        True
        >>> eq = a*cos(x)**2 + a*sin(x)**2 - a
        >>> eq.is_constant()
        True
        >>> eq.subs({x: pi, a: 2}) == eq.subs({x: pi, a: 3}) == 0
        True

        >>> (0**x).is_constant()
        False
        >>> x.is_constant()
        False
        >>> (x**x).is_constant()
        False
        >>> one = cos(x)**2 + sin(x)**2
        >>> one.is_constant()
        True
        >>> ((one - 1)**(x + 1)).is_constant() in (True, False) # could be 0 or 1
        True

  property is_even
  property is_extended_negative
  property is_extended_nonnegative
  property is_extended_nonpositive
  property is_extended_nonzero
  property is_extended_positive
  property is_extended_real
  property is_finite
  property is_hermitian
  is_hypergeometric(k)
  property is_imaginary
  property is_infinite
  property is_integer
  property is_irrational
  is_meromorphic(x, a)

    This tests whether an expression is meromorphic as a function of the given symbol `x` at the point `a`.

    This method is intended as a quick test that will return None if no decision can be made without simplification or more detailed analysis.

    Examples

        >>> from sympy import zoo, log, sin, sqrt
        >>> from sympy.abc import x

        >>> f = 1/x**2 + 1 - 2*x**3
        >>> f.is_meromorphic(x, 0)
        True
        >>> f.is_meromorphic(x, 1)
        True
        >>> f.is_meromorphic(x, zoo)
        True

        >>> g = x**log(3)
        >>> g.is_meromorphic(x, 0)
        False
        >>> g.is_meromorphic(x, 1)
        True
        >>> g.is_meromorphic(x, zoo)
        False

        >>> h = sin(1/x)*x**2
        >>> h.is_meromorphic(x, 0)
        False
        >>> h.is_meromorphic(x, 1)
        True
        >>> h.is_meromorphic(x, zoo)
        True

    Multivalued functions are considered meromorphic when their branches are meromorphic. Thus most functions are meromorphic everywhere except at essential singularities and branch points. In particular, they will be meromorphic also on branch cuts except at their endpoints.

        >>> log(x).is_meromorphic(x, -1)
        True
        >>> log(x).is_meromorphic(x, 0)
        False
        >>> sqrt(x).is_meromorphic(x, -1)
        True
        >>> sqrt(x).is_meromorphic(x, 0)
        False

  property is_negative
  property is_noninteger
  property is_nonnegative
  property is_nonpositive
  property is_nonzero
  is_number = False
  property is_odd
  property 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, Function
        >>> 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
        >>> (2**x + 1).is_polynomial(2**x)
        True
        >>> f = Function('f')
        >>> (f(x) + 1).is_polynomial(x)
        False
        >>> (f(x) + 1).is_polynomial(f(x))
        True
        >>> (1/f(x) + 1).is_polynomial(f(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()

  property is_positive
  property is_prime
  property 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().

  property is_real
  is_same(b, approx=None)

    Return True if a and b are structurally the same, else False. If approx is supplied, it will be used to test whether two numbers are the same or not. By default, only numbers of the same type will compare equal, so S.Half != Float(0.5).

    Examples

    In SymPy (unlike Python) two numbers do not compare the same if they are not of the same type:

        >>> from sympy import S
        >>> 2.0 == S(2)
        False
        >>> 0.5 == S.Half
        False

    By supplying a function with which to compare two numbers, such differences can be ignored. e.g. equal_valued will return True for decimal numbers having a denominator that is a power of 2, regardless of precision.

        >>> from sympy import Float
        >>> from sympy.core.numbers import equal_valued
        >>> (S.Half/4).is_same(Float(0.125, 1), equal_valued)
        True
        >>> Float(1, 2).is_same(Float(1, 10), equal_valued)
        True

    But decimals without a power of 2 denominator will compare as not being the same.

        >>> Float(0.1, 9).is_same(Float(0.1, 10), equal_valued)
        False

    But arbitrary differences can be ignored by supplying a function to test the equivalence of two numbers:

        >>> import math
        >>> Float(0.1, 9).is_same(Float(0.1, 10), math.isclose)
        True

    Other objects might compare the same even though types are not the same. This routine will only return True if two expressions are identical in terms of class types.

        >>> from sympy import eye, Basic
        >>> eye(1) == S(eye(1))  # mutable vs immutable
        True
        >>> Basic.is_same(eye(1), S(eye(1)))
        False

  is_scalar = True
  is_symbol = True
  property is_transcendental
  property is_zero
  property kind

    Default kind for all SymPy object. If the kind is not defined for the object, or if the object cannot infer the kind from its arguments, this will be returned.

    Examples

        >>> from sympy import Expr
        >>> Expr().kind
        UndefinedKind

  leadterm(x, logx=None, cdir=0)

    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, cdir=0)

    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 do not 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

    See also

    `matches`

      pattern.matches(expr) is the same as expr.match(pattern)

    `xreplace`

      exact structural replacement

    `replace`

      structural replacement with pattern matching

    `Wild`

      symbolic placeholders for expressions in pattern matching

    Examples

        >>> from sympy import Wild, Sum
        >>> 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

    Since match is purely structural expressions that are equivalent up to bound symbols will not match:

        >>> print(Sum(x, (x, 1, 2)).match(Sum(y, (y, 1, p))))
        None

    An expression with bound symbols can be matched if the pattern uses a distinct `Wild` for each bound symbol:

        >>> Sum(x, (x, 1, 2)).match(Sum(q, (q, 1, p)))
        {p_: 2, q_: x}

    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 unless `old=True`:

        >>> (x - 2).match(p - x, old=True)
        {p_: 2*x - 2}
        >>> (2/x).match(p*x, old=True)
        {p_: 2/x**2}

  matches(expr, repl_dict=None, old=False)

    Helper method for match() that looks for a match between Wild symbols in self and expressions in expr.

    Examples

        >>> from sympy import symbols, Wild, Basic
        >>> a, b, c = symbols('a b c')
        >>> x = Wild('x')
        >>> Basic(a + x, x).matches(Basic(a + b, c)) is None
        True
        >>> Basic(a + x, x).matches(Basic(a + b + c, b + c))
        {x_: b + c}

  n(n=15, subs=None, maxn=100, chop=False, strict=False, quad=None, verbose=False)

    Evaluate the given formula to an accuracy of n digits.

    Parameters:
      subs dict, optional

        Substitute numerical values for symbols, e.g. `subs={x:3, y:1+pi}`. The substitutions must be given as a dictionary.

      maxn int, optional

        Allow a maximum temporary working precision of maxn digits.

      chop bool or number, optional

        Specifies how to replace tiny real or imaginary parts in subresults by exact zeros.

        When `True` the chop value defaults to standard precision.

        Otherwise the chop value is used to determine the magnitude of “small” for purposes of chopping.

            >>> from sympy import N
            >>> x = 1e-4
            >>> N(x, chop=True)
            0.000100000000000000
            >>> N(x, chop=1e-5)
            0.000100000000000000
            >>> N(x, chop=1e-4)
            0

      strict bool, optional

        Raise `PrecisionExhausted` if any subresult fails to evaluate to full accuracy, given the available maxprec.

      quad str, optional

        Choose algorithm for numerical quadrature. By default, tanh-sinh quadrature is used. For oscillatory integrals on an infinite interval, try `quad='osc'`.

      verbose bool, optional

        Print debug information.

    Notes

    When Floats are naively substituted into an expression, precision errors may adversely affect the result. For example, adding 1e16 (a Float) to 1 will truncate to 1e16; if 1e16 is then subtracted, the result will be 0. That is exactly what happens in the following:

        >>> from sympy.abc import x, y, z
        >>> values = {x: 1e16, y: 1, z: 1e16}
        >>> (x + y - z).subs(values)
        0

    Using the subs argument for evalf is the accurate way to evaluate such an expression:

        >>> (x + y - z).evalf(subs=values)
        1.00000000000000

  name: str
  normal()

    Return the expression as a fraction.

    expression -> a/b

    See also

    `as_numer_denom`

      return `(a, b)` instead of `a/b`

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

    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 do not have to determine how many terms we need to calculate in advance.

    Disadvantage – you may end up with less terms than you may have expected, but the O(x**n) term appended will always be correct and so the result, though perhaps shorter, will also be correct.

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

    See also lseries().

    Examples

        >>> from sympy import sin, log, Symbol
        >>> from sympy.abc import x, y
        >>> sin(x).nseries(x, 0, 6)
        x - x**3/6 + x**5/120 + O(x**6)
        >>> log(x+1).nseries(x, 0, 5)
        x - x**2/2 + x**3/3 - x**4/4 + O(x**5)

    Handling of the `logx` parameter — in the following example the expansion fails since `sin` does not have an asymptotic expansion at -oo (the limit of log(x) as x approaches 0):

        >>> e = sin(log(x))
        >>> e.nseries(x, 0, 6)
        Traceback (most recent call last):
        ...
        PoleError: ...
        ...
        >>> logx = Symbol('logx')
        >>> e.nseries(x, 0, 6, logx=logx)
        sin(logx)

    In the following example, the expansion works but only returns self unless the `logx` parameter is used:

        >>> e = x**y
        >>> e.nseries(x, 0, 2)
        x**y
        >>> 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() → tuple[Number, Expr]

    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 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() → Expr

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

  replace(query, value, map=False, simultaneous=True, exact=None) → Basic

    Replace matching subexpressions of `self` with `value`.

    If `map = True` then also return the mapping {old: new} where `old` was a sub-expression found with query and `new` is the replacement value for it. If the expression itself does not match the query, then the returned value will be `self.xreplace(map)` otherwise it should be `self.subs(ordered(map.items()))`.

    Traverses an expression tree and performs replacement of matching subexpressions from the bottom to the top of the tree. The default approach is to do the replacement in a simultaneous fashion so changes made are targeted only once. If this is not desired or causes problems, `simultaneous` can be set to False.

    In addition, if an expression containing more than one Wild symbol is being used to match subexpressions and the `exact` flag is None it will be set to True so the match will only succeed if all non-zero values are received for each Wild that appears in the match pattern. Setting this to False accepts a match of 0; while setting it True accepts all matches that have a 0 in them. See example below for cautions.

    The list of possible combinations of queries and replacement values is listed below:

    See also

    `subs`

      substitution of subexpressions as defined by the objects themselves.

    `xreplace`

      exact node replacement in expr tree; also capable of using matching rules

    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) to `newtype`.

          >>> f.replace(sin, cos)
          log(cos(x)) + tan(cos(x**2))
          >>> sin(x).replace(sin, cos, map=True)
          (cos(x), {sin(x): cos(x)})
          >>> (x*y).replace(Mul, Add)
          x + y

    1.2. type -> func

      obj.replace(type, func)

      When object of type `type` is found, apply `func` to its argument(s). `func` must be written to handle the number of arguments of `type`.

          >>> f.replace(sin, lambda arg: sin(2*arg))
          log(sin(2*x)) + tan(sin(2*x**2))
          >>> (x*y).replace(Mul, lambda *args: sin(2*Mul(*args)))
          sin(2*x*y)

    2.1. pattern -> expr

      obj.replace(pattern(wild), expr(wild))

      Replace subexpressions matching `pattern` with the expression written in terms of the Wild symbols in `pattern`.

          >>> a, b = map(Wild, 'ab')
          >>> 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

      Matching is exact by default when more than one Wild symbol is used: matching fails unless the match gives non-zero values for all Wild symbols:

          >>> (2*x + y).replace(a*x + b, b - a)
          y - 2
          >>> (2*x).replace(a*x + b, b - a)
          2*x

      When set to False, the results may be non-intuitive:

          >>> (2*x).replace(a*x + b, b - a, exact=False)
          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` with `func(e)` if `filter(e)` is True.

          >>> g = 2*sin(x**3)
          >>> g.replace(lambda expr: expr.is_Number, lambda expr: expr**2)
          4*sin(x**9)

    The expression itself is also targeted by the query but is done in such a fashion that changes are not made twice.

        >>> e = x*(x*y + 1)
        >>> e.replace(lambda x: x.is_Mul, lambda x: 2*x)
        2*x*(2*x*y + 1)

    When matching a single symbol, exact will default to True, but this may or may not be the behavior that is desired:

    Here, we want exact=False:

        >>> from sympy import Function
        >>> f = Function('f')
        >>> e = f(1) + f(0)
        >>> q = f(a), lambda a: f(a + 1)
        >>> e.replace(*q, exact=False)
        f(1) + f(2)
        >>> e.replace(*q, exact=True)
        f(0) + f(2)

    But here, the nature of matching makes selecting the right setting tricky:

        >>> e = x**(1 + y)
        >>> (x**(1 + y)).replace(x**(1 + a), lambda a: x**-a, exact=False)
        x
        >>> (x**(1 + y)).replace(x**(1 + a), lambda a: x**-a, exact=True)
        x**(-x - y + 1)
        >>> (x**y).replace(x**(1 + a), lambda a: x**-a, exact=False)
        x
        >>> (x**y).replace(x**(1 + a), lambda a: x**-a, exact=True)
        x**(1 - y)

    It is probably better to use a different form of the query that describes the target expression more precisely:

        >>> (1 + x**(1 + y)).replace(
        ... lambda x: x.is_Pow and x.exp.is_Add and x.exp.args[0] == 1,
        ... lambda x: x.base**(1 - (x.exp - 1)))
        ...
        x**(1 - y) + 1

  rewrite(*args, deep=True, **hints)

    Rewrite self using a defined rule.

    Rewriting transforms an expression to another, which is mathematically equivalent but structurally different. For example you can rewrite trigonometric functions as complex exponentials or combinatorial functions as gamma function.

    This method takes a pattern and a rule as positional arguments. pattern is optional parameter which defines the types of expressions that will be transformed. If it is not passed, all possible expressions will be rewritten. rule defines how the expression will be rewritten.

    Parameters:
      args Expr

        A rule, or pattern and rule. - pattern is a type or an iterable of types. - rule can be any object.

      deep bool, optional

        If `True`, subexpressions are recursively transformed. Default is `True`.

    Examples

    If pattern is unspecified, all possible expressions are transformed.

        >>> from sympy import cos, sin, exp, I
        >>> from sympy.abc import x
        >>> expr = cos(x) + I*sin(x)
        >>> expr.rewrite(exp)
        exp(I*x)

    Pattern can be a type or an iterable of types.

        >>> expr.rewrite(sin, exp)
        exp(I*x)/2 + cos(x) - exp(-I*x)/2
        >>> expr.rewrite([cos,], exp)
        exp(I*x)/2 + I*sin(x) + exp(-I*x)/2
        >>> expr.rewrite([cos, sin], exp)
        exp(I*x)

    Rewriting behavior can be implemented by defining `_eval_rewrite()` method.

        >>> from sympy import Expr, sqrt, pi
        >>> class MySin(Expr):
        ...     def _eval_rewrite(self, rule, args, **hints):
        ...         x, = args
        ...         if rule == cos:
        ...             return cos(pi/2 - x, evaluate=False)
        ...         if rule == sqrt:
        ...             return sqrt(1 - cos(x)**2)
        >>> MySin(MySin(x)).rewrite(cos)
        cos(-cos(-x + pi/2) + pi/2)
        >>> MySin(x).rewrite(sqrt)
        sqrt(1 - cos(x)**2)

    Defining `_eval_rewrite_as_[...]()` method is supported for backwards compatibility reason. This may be removed in the future and using it is discouraged.

        >>> class MySin(Expr):
        ...     def _eval_rewrite_as_cos(self, *args, **hints):
        ...         x, = args
        ...         return cos(pi/2 - x, evaluate=False)
        >>> MySin(x).rewrite(cos)
        cos(-x + pi/2)

  round(n=None)

    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

    The Python `round` function uses the SymPy `round` method so it will always return a SymPy number (not a Python float or int):

        >>> isinstance(round(S(123), -2), Number)
        True

    Examples

        >>> from sympy import pi, E, I, S, Number
        >>> 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, cdir=0)

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

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

    If `x=None` and `self` is univariate, the univariate symbol will be supplied, otherwise an error will be raised.

    Parameters:
      expr Expression

        The expression whose series is to be expanded.

      x Symbol

        It is the variable of the expression to be calculated.

      x0 Value

        The value around which `x` is calculated. Can be any value from `-oo` to `oo`.

      n Value

        The value used to represent the order in terms of `x**n`, up to which the series is to be expanded.

      dir String, optional

        The series-expansion can be bi-directional. If `dir="+"`, then (x->x0+). If `dir="-", then (x->x0-). For infinite ``x0` (`oo` or `-oo`), the `dir` argument is determined from the direction of the infinity (i.e., `dir="-"` for `oo`).

      logx optional

        It is used to replace any log(x) in the returned series with a symbolic value rather than evaluating the actual value.

      cdir optional

        It stands for complex direction, and indicates the direction from which the expansion needs to be evaluated.

    Returns:
      Expr Expression

        Series expansion of the expression about x0

    Raises:
      TypeError

        If “n” and “x0” are infinity objects

      PoleError

        If “x0” is an infinity object

    Examples

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

    If `n=None` then a generator of the series terms will be returned.

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

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

        >>> abs(x).series(dir="+")
        x
        >>> abs(x).series(dir="-")
        -x
        >>> f = tan(x)
        >>> f.series(x, 2, 6, "+")
        tan(2) + (1 + tan(2)**2)*(x - 2) + (x - 2)**2*(tan(2)**3 + tan(2)) +
        (x - 2)**3*(1/3 + 4*tan(2)**2/3 + tan(2)**4) + (x - 2)**4*(tan(2)**5 +
        5*tan(2)**3/3 + 2*tan(2)/3) + (x - 2)**5*(2/15 + 17*tan(2)**2/15 +
        2*tan(2)**4 + tan(2)**6) + O((x - 2)**6, (x, 2))

        >>> f.series(x, 2, 3, "-")
        tan(2) + (2 - x)*(-tan(2)**2 - 1) + (2 - x)**2*(tan(2)**3 + tan(2))
        + O((x - 2)**3, (x, 2))

    For rational expressions this method may return original expression without the Order term. >>> (1/x).series(x, n=8) 1/x

  simplify(**kwargs) → Basic

    See the simplify function in sympy.simplify

  sort_key(order=None)

    Return a sort key.

    Examples

        >>> from sympy import S, I

        >>> sorted([S(1)/2, I, -I], key=lambda x: x.sort_key())
        [1/2, -I, I]

        >>> S("[x, 1/x, 1/x**2, x**2, x**(1/2), x**(1/4), x**(3/2)]")
        [x, 1/x, x**(-2), x**2, sqrt(x), x**(1/4), x**(3/2)]
        >>> sorted(_, key=lambda x: x.sort_key())
        [x**(-2), 1/x, x**(1/4), sqrt(x), x, x**(3/2), x**2]

  subs(arg1: Mapping[Basic | complex, Basic | complex] | Iterable[tuple[Basic | complex, Basic | complex]] | Basic | complex, arg2: Basic | complex | None = None, **kwargs: Any) → Basic

    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

    `replace`

      replacement capable of doing wildcard-like matching, parsing of match, and conditional replacements

    `xreplace`

      exact node replacement in expr tree; also capable of using matching rules

    `sympy.core.evalf.EvalfMixin.evalf`

      calculates the given formula to a desired level of precision

    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”.

  to_nnf(simplify=True)
  together(*args, **kwargs)

    See the together function in sympy.polys

  transpose()
  trigsimp(**args)

    See the trigsimp function in sympy.simplify

  xreplace(rule, hack2=False)

    Replace occurrences of objects within the expression.

    Parameters:
      rule dict-like

        Expresses a replacement rule

    Returns:
      xreplace the result of the replacement

    See also

    `replace`

      replacement capable of doing wildcard-like matching, parsing of match, and conditional replacements

    `subs`

      substitution of subexpressions as defined by the objects themselves.

    Examples

        >>> from sympy import symbols, pi, exp
        >>> x, y, z = symbols('x y z')
        >>> (1 + x*y).xreplace({x: pi})
        pi*y + 1
        >>> (1 + x*y).xreplace({x: pi, y: 2})
        1 + 2*pi

    Replacements occur only if an entire node in the expression tree is matched:

        >>> (x*y + z).xreplace({x*y: pi})
        z + pi
        >>> (x*y*z).xreplace({x*y: pi})
        x*y*z
        >>> (2*x).xreplace({2*x: y, x: z})
        y
        >>> (2*2*x).xreplace({2*x: y, x: z})
        4*z
        >>> (x + y + 2).xreplace({x + y: 2})
        x + y + 2
        >>> (x + 2 + exp(x + 2)).xreplace({x + 2: y})
        x + exp(y) + 2

    xreplace does not differentiate between free and bound symbols. In the following, subs(x, y) would not change x since it is a bound symbol, but xreplace does:

        >>> from sympy import Integral
        >>> Integral(x, (x, 1, 2*x)).xreplace({x: y})
        Integral(y, (y, 1, 2*y))

    Trying to replace x with an expression raises an error:

        >>> Integral(x, (x, 1, 2*x)).xreplace({x: 2*y})
        ValueError: Invalid limits given: ((2*y, 1, 4*y),)

### `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.

  __init__(seq, char='b')
    Parameters:
      seq sequence of `sympy.Basic`
      char str, optional

        character for regression coefficient

  property 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.float64 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

  property design_expr
  property 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.

  property mean

    Expression for the mean, expressed as a linear combination of terms, each with dummy variables in front.

  property 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)

  property terms

    Terms in the linear regression formula.

### `RandomEffects`

class nipy.algorithms.statistics.formula.formulae.RandomEffects(seq, sigma=None, char='e')

  Bases: `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.]])

  __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
  property 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.float64 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

  property design_expr
  property 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.

  property mean

    Expression for the mean, expressed as a linear combination of terms, each with dummy variables in front.

  property 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)

  property terms

    Terms in the linear regression formula.

### `Term`

class nipy.algorithms.statistics.formula.formulae.Term(name, **assumptions)

  Bases: `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.float64)]))
      >>> f = t.formula
      >>> d = f.design(xval)
      >>> print(d.dtype.descr)
      [('x', '<f8')]
      >>> f.design(xval, return_float=True)
      array([ 3.,  4.,  5.])

  __init__(*args, **kwargs)
  adjoint()
  apart(x=None, **args)

    See the apart function in sympy.polys

  property args: tuple[Basic, ...]

    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. Do not override .args() from Basic (so that it is 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.

    Examples

        >>> 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() → tuple[Expr, Expr]
  as_coeff_Add(rational=False) → tuple['Number', Expr]

    Efficiently extract the coefficient of a summation.

  as_coeff_Mul(rational: bool = False) → tuple['Number', Expr]

    Efficiently extract the coefficient of a product.

  as_coeff_add(*deps) → tuple[Expr, tuple[Expr, ...]]

    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 do not 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 do not 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) → tuple[Expr, Expr]

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

  as_coeff_mul(*deps, **kwargs) → tuple[Expr, tuple[Expr, ...]]

    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 do not 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 do not 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: Expr) → Expr | None

    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.Poly.coeff_monomial`

      efficiently find the single coefficient of a monomial in Poly

    `sympy.polys.polytools.Poly.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 the `coeff` method should be used.)

        >>> (2*E*x + x).as_coefficient(E)
        >>> (2*E*x + x).coeff(E)
        2*x

        >>> (E*(x + 1) + x).as_coefficient(E)

        >>> (2*pi*I).as_coefficient(pi*I)
        2
        >>> (2*I).as_coefficient(pi*I)

  as_coefficients_dict(*syms)

    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 symbols `syms` are provided, any multiplicative terms independent of them will be considered a coefficient and a regular dictionary of syms-dependent generators as keys and their corresponding coefficients as values will be returned.

    Examples

        >>> from sympy.abc import a, x, y
        >>> (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}
        >>> (3*a*x).as_coefficients_dict(x)
        {x: 3*a}
        >>> (3*a*x).as_coefficients_dict(y)
        {1: 3*a*x}

  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 not 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)
        >>> ((x*(1 + y) + 0.4*x*(3 + 3*y))**2).as_content_primitive()
        (1, 4.84*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 the expression with any objects having structurally bound symbols replaced with unique, canonical symbols within the object in which they appear and having only the default assumption for commutativity being True. When applied to a symbol a new symbol having only the same commutativity will be returned.

    Notes

    Any object that has structurally bound variables should have a property, `bound_symbols` that returns those symbols appearing in the object.

    Examples

        >>> from sympy import Integral, Symbol
        >>> from sympy.abc import x
        >>> r = Symbol('r', real=True)
        >>> Integral(r, (r, x)).as_dummy()
        Integral(_0, (_0, x))
        >>> _.variables[0].is_real is None
        True
        >>> r.as_dummy()
        _r

  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) → tuple[Expr, Expr]

    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 either have terms that contain variables that are in deps, or be equal to 0 (when self is an Add) or 1 (when self is a Mul)

    - 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_log`
    `sympy.core.add.Add.as_two_terms`
    `sympy.core.mul.Mul.as_two_terms`
    `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(*symbols, logx=None, cdir=0)

    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() → tuple[Expr, Expr]

    Return the numerator and the denominator of an expression.

    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 returns `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.

    See also

    `as_ordered_factors`

      An alternative for noncommutative applications, returning an ordered list of factors.

    `args_cnc`

      Similar to as_ordered_factors, but guarantees separation of commutative and noncommutative factors.

  as_real_imag(deep=True, **hints)

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

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

        >>> from sympy import symbols, I

        >>> x, y = symbols('x,y', real=True)

        >>> (x + y*I).as_real_imag()
        (x, y)

        >>> from sympy.abc import z, w

        >>> (z + w*I).as_real_imag()
        (re(z) - im(w), re(w) + im(z))

  as_set()

    Rewrites Boolean expression in terms of real sets.

    Examples

        >>> from sympy import Symbol, Eq, Or, And
        >>> x = Symbol('x', real=True)
        >>> Eq(x, 0).as_set()
        {0}
        >>> (x > 0).as_set()
        Interval.open(0, oo)
        >>> And(-2 < x, x < 2).as_set()
        Interval.open(-2, 2)
        >>> Or(x < -2, 2 < x).as_set()
        Union(Interval.open(-oo, -2), Interval.open(2, oo))

  as_terms()

    Transform an expression to a list of terms.

  aseries(x=None, n=6, bound=0, hir=False)

    Asymptotic Series expansion of self. This is equivalent to `self.series(x, oo, n)`.

    Parameters:
      self Expression

        The expression whose series is to be expanded.

      x Symbol

        It is the variable of the expression to be calculated.

      n Value

        The value used to represent the order in terms of `x**n`, up to which the series is to be expanded.

      hir Boolean

        Set this parameter to be True to produce hierarchical series. It stops the recursion at an early level and may provide nicer and more useful results.

      bound Value, Integer

        Use the `bound` parameter to give limit on rewriting coefficients in its normalised form.

    Returns:
      Expr

        Asymptotic series expansion of the expression.

    See also

    `Expr.aseries`

      See the docstring of this function for complete details of this wrapper.

    Notes

    This algorithm is directly induced from the limit computational algorithm provided by Gruntz. It majorly uses the mrv and rewrite sub-routines. The overall idea of this algorithm is first to look for the most rapidly varying subexpression w of a given expression f and then expands f in a series in w. Then same thing is recursively done on the leading coefficient till we get constant coefficients.

    If the most rapidly varying subexpression of a given expression f is f itself, the algorithm tries to find a normalised representation of the mrv set and rewrites f using this normalised representation.

    If the expansion contains an order term, it will be either `O(x ** (-n))` or `O(w ** (-n))` where `w` belongs to the most rapidly varying expression of `self`.

    References

    [1]

    Gruntz, Dominik. A new algorithm for computing asymptotic series. In: Proc. 1993 Int. Symp. Symbolic and Algebraic Computation. 1993. pp. 239-244.

    [2]

    Gruntz thesis - p90

    [3]

    https://en.wikipedia.org/wiki/Asymptotic_expansion

    Examples

        >>> from sympy import sin, exp
        >>> from sympy.abc import x

        >>> e = sin(1/x + exp(-x)) - sin(1/x)

        >>> e.aseries(x)
        (1/(24*x**4) - 1/(2*x**2) + 1 + O(x**(-6), (x, oo)))*exp(-x)

        >>> e.aseries(x, n=3, hir=True)
        -exp(-2*x)*sin(1/x)/2 + exp(-x)*cos(1/x) + O(exp(-3*x), (x, oo))

        >>> e = exp(exp(x)/(1 - 1/x))

        >>> e.aseries(x)
        exp(exp(x)/(1 - 1/x))

        >>> e.aseries(x, bound=3)
        exp(exp(x)/x**2)*exp(exp(x)/x)*exp(-exp(x) + exp(x)/(1 - 1/x) - exp(x)/x - exp(x)/x**2)*exp(exp(x))

    For rational expressions this method may return original expression without the Order term. >>> (1/x).aseries(x, n=8) 1/x

  property assumptions0

    Return object type assumptions.

    For example:

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

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

    Examples

        >>> from sympy import Symbol
        >>> from sympy.abc import x
        >>> x.assumptions0
        {'commutative': True}
        >>> x = Symbol("x", positive=True)
        >>> x.assumptions0
        {'commutative': True, 'complex': True, 'extended_negative': False,
         'extended_nonnegative': True, 'extended_nonpositive': False,
         'extended_nonzero': True, 'extended_positive': True, 'extended_real':
         True, 'finite': True, 'hermitian': True, 'imaginary': False,
         'infinite': False, 'negative': False, 'nonnegative': True,
         'nonpositive': False, 'nonzero': True, 'positive': True, 'real':
         True, 'zero': False}

  atoms(*types: Tbasic | type[Tbasic]) → set[Basic] | set[Tbasic]

    Returns the atoms that form the current object.

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

    Examples

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

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

        >>> 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` but `type(S(1))` is `One`, a special type of SymPy atom, while `type(S(2))` is type `Integer` and will find all integers in an expression:

        >>> from sympy import S
        >>> (1 + x + 2*sin(y + I*pi)).atoms(S(1))
        {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)}

  property binary_symbols
  cancel(*gens, **args)

    See the cancel function in sympy.polys

  property canonical_variables: dict[Basic, Symbol]

    Return a dictionary mapping any variable defined in `self.bound_symbols` to Symbols that do not clash with any free symbols in the expression.

    Examples

        >>> from sympy import Lambda
        >>> from sympy.abc import x
        >>> Lambda(x, 2*x).canonical_variables
        {x: _0}

  classmethod class_key()

    Nice order of classes.

  coeff(x: Expr, n=1, right=False, _first=True)

    Returns the coefficient from the term(s) containing `x**n`. If `n` is zero then all terms independent of `x` will be returned.

    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.Poly.coeff_monomial`

      efficiently find the single coefficient of a monomial in Poly

    `sympy.polys.polytools.Poly.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 less than, equal, or greater than other in a canonical sense. Non-Basic are always greater than Basic. If both names of the classes being compared appear in the ordering_of_classes then the ordering will depend on the appearance of the names there. If either does not appear in that list, then the comparison is based on the class name. If the names are the same then a comparison is made on the length of the hashable content. Items of the equal-lengthed contents are then successively compared using the same rules. If there is never a difference then 0 is returned.

    Examples

        >>> from sympy.abc import x, y
        >>> x.compare(y)
        -1
        >>> x.compare(x)
        0
        >>> y.compare(x)
        1

  conjugate()

    Returns the complex conjugate of ‘self’.

  copy()
  could_extract_minus_sign() → bool

    Return True if self has -1 as a leading factor or has more literal negative signs than positive signs in a sum, otherwise False.

    Examples

        >>> from sympy.abc import x, y
        >>> e = x - y
        >>> {i.could_extract_minus_sign() for i in (e, -e)}
        {False, True}

    Though the `y - x` is considered like `-(x - y)`, since it is in a product without a leading factor of -1, the result is false below:

        >>> (x*(y - x)).could_extract_minus_sign()
        False

    To put something in canonical form wrt to sign, use signsimp:

        >>> from sympy import signsimp
        >>> signsimp(x*(y - x))
        -x*(x - y)
        >>> _.could_extract_minus_sign()
        True

  count(query)

    Count the number of matching subexpressions.

  count_ops(visual=False)

    Wrapper for count_ops that returns the operation count.

  default_assumptions: ClassVar[StdFactKB] = {}
  diff(*symbols, **assumptions)
  dir(x, cdir)
  doit(**hints)

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

        >>> from sympy import Integral
        >>> from sympy.abc import x

        >>> 2*Integral(x, x)
        2*Integral(x, x)

        >>> (2*Integral(x, x)).doit()
        x**2

        >>> (2*Integral(x, x)).doit(deep=False)
        2*Integral(x, x)

  dummy_eq(other, symbol=None)

    Compare two expressions and handle dummy symbols.

    Examples

        >>> from sympy import Dummy
        >>> from sympy.abc import x, y

        >>> u = Dummy('u')

        >>> (u**2 + 1).dummy_eq(x**2 + 1)
        True
        >>> (u**2 + 1) == (x**2 + 1)
        False

        >>> (u**2 + y).dummy_eq(x**2 + y, x)
        True
        >>> (u**2 + y).dummy_eq(x**2 + y, y)
        False

  equals(other, failing_expression=False)

    Return True if self == other, False if it does not, or None. If failing_expression is True then the expression which did not simplify to a 0 will be returned instead of None.

  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.

    Parameters:
      subs dict, optional

        Substitute numerical values for symbols, e.g. `subs={x:3, y:1+pi}`. The substitutions must be given as a dictionary.

      maxn int, optional

        Allow a maximum temporary working precision of maxn digits.

      chop bool or number, optional

        Specifies how to replace tiny real or imaginary parts in subresults by exact zeros.

        When `True` the chop value defaults to standard precision.

        Otherwise the chop value is used to determine the magnitude of “small” for purposes of chopping.

            >>> from sympy import N
            >>> x = 1e-4
            >>> N(x, chop=True)
            0.000100000000000000
            >>> N(x, chop=1e-5)
            0.000100000000000000
            >>> N(x, chop=1e-4)
            0

      strict bool, optional

        Raise `PrecisionExhausted` if any subresult fails to evaluate to full accuracy, given the available maxprec.

      quad str, optional

        Choose algorithm for numerical quadrature. By default, tanh-sinh quadrature is used. For oscillatory integrals on an infinite interval, try `quad='osc'`.

      verbose bool, optional

        Print debug information.

    Notes

    When Floats are naively substituted into an expression, precision errors may adversely affect the result. For example, adding 1e16 (a Float) to 1 will truncate to 1e16; if 1e16 is then subtracted, the result will be 0. That is exactly what happens in the following:

        >>> from sympy.abc import x, y, z
        >>> values = {x: 1e16, y: 1, z: 1e16}
        >>> (x + y - z).subs(values)
        0

    Using the subs argument for evalf is the accurate way to evaluate such an expression:

        >>> (x + y - z).evalf(subs=values)
        1.00000000000000

  expand(deep=True, modulus=None, power_base=True, power_exp=True, mul=True, log=True, multinomial=True, basic=True, **hints)

    Expand an expression using hints.

    See the docstring of the expand() function in sympy.core.function for more information.

  property expr_free_symbols

    Like `free_symbols`, but returns the free symbols only if they are contained in an expression node.

    Examples

        >>> from sympy.abc import x, y
        >>> (x + y).expr_free_symbols
        {x, y}

    If the expression is contained in a non-expression object, do not return the free symbols. Compare:

        >>> from sympy import Tuple
        >>> t = Tuple(x + y)
        >>> t.expr_free_symbols
        set()
        >>> t.free_symbols
        {x, y}

  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

    `extract_multiplicatively`
    `coeff`
    `as_coefficient`

    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

  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: Expr) → Expr | None

    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.

    Examples

        >>> 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.

  property 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.

  property free_symbols

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

    Not all free symbols are `Symbol` (see examples)

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

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

    Examples

        >>> from sympy import Derivative, Integral, IndexedBase
        >>> from sympy.abc import x, y, n
        >>> (x + 1).free_symbols
        {x}
        >>> Integral(x, y).free_symbols
        {x, y}

    Not all free symbols are actually symbols:

        >>> IndexedBase('F')[0].free_symbols
        {F, F[0]}

    The symbols of differentiation are not included unless they appear in the expression being differentiated.

        >>> Derivative(x + y, y).free_symbols
        {x, y}
        >>> Derivative(x, y).free_symbols
        {x}
        >>> Derivative(x, (y, n)).free_symbols
        {n, x}

    If you want to know if a symbol is in the variables of the Derivative you can do so as follows:

        >>> Derivative(x, y).has_free(y)
        True

  classmethod 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)

  property 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

  gammasimp()

    See the gammasimp function in sympy.simplify

  getO() → Expr | None

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

  getn()

    Returns the order of the expression.

    Examples

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

  has(*patterns)

    Test whether any subexpression matches any of the patterns.

    Examples

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

    Note `has` is a structural algorithm with no knowledge of mathematics. Consider the following half-open interval:

        >>> from sympy 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 to `any(expr.has(p) for p in patterns)`. In particular, `False` is returned when the list of patterns is empty.

        >>> x.has()
        False

  has_free(*patterns)

    Return True if self has object(s) `x` as a free expression else False.

    Examples

        >>> from sympy import Integral, Function
        >>> from sympy.abc import x, y
        >>> f = Function('f')
        >>> g = Function('g')
        >>> expr = Integral(f(x), (f(x), 1, g(y)))
        >>> expr.free_symbols
        {y}
        >>> expr.has_free(g(y))
        True
        >>> expr.has_free(*(x, f(x)))
        False

    This works for subexpressions and types, too:

        >>> expr.has_free(g)
        True
        >>> (x + y + 1).has_free(y + 1)
        True

  has_xfree(s: set[Basic])

    Return True if self has any of the patterns in s as a free argument, else False. This is like Basic.has_free but this will only report exact argument matches.

    Examples

        >>> from sympy import Function
        >>> from sympy.abc import x, y
        >>> f = Function('f')
        >>> f(x).has_xfree({f})
        False
        >>> f(x).has_xfree({f(x)})
        True
        >>> f(x + 1).has_xfree({x})
        True
        >>> f(x + 1).has_xfree({x + 1})
        True
        >>> f(x + y + 1).has_xfree({x + 1})
        False

  integrate(*args, **kwargs)

    See the integrate function in sympy.integrals

  invert(g, *gens, **args)

    Return the multiplicative inverse of `self` mod `g` where `self` (and `g`) may be symbolic expressions).

    See also

    `sympy.core.intfunc.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_MatAdd = False
  is_MatMul = 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
  property 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

    `is_rational_function`

    References

    [1]

    https://en.wikipedia.org/wiki/Algebraic_expression

    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

  property is_antihermitian
  property is_commutative
  is_comparable = False
  property is_complex
  property is_composite
  is_constant(*wrt, **flags)

    Return True if self is constant, False if not, or None if the constancy could not be determined conclusively.

    Examples

        >>> from sympy import cos, sin, Sum, S, pi
        >>> from sympy.abc import a, n, x, y
        >>> x.is_constant()
        False
        >>> S(2).is_constant()
        True
        >>> Sum(x, (x, 1, 10)).is_constant()
        True
        >>> Sum(x, (x, 1, n)).is_constant()
        False
        >>> Sum(x, (x, 1, n)).is_constant(y)
        True
        >>> Sum(x, (x, 1, n)).is_constant(n)
        False
        >>> Sum(x, (x, 1, n)).is_constant(x)
        True
        >>> eq = a*cos(x)**2 + a*sin(x)**2 - a
        >>> eq.is_constant()
        True
        >>> eq.subs({x: pi, a: 2}) == eq.subs({x: pi, a: 3}) == 0
        True

        >>> (0**x).is_constant()
        False
        >>> x.is_constant()
        False
        >>> (x**x).is_constant()
        False
        >>> one = cos(x)**2 + sin(x)**2
        >>> one.is_constant()
        True
        >>> ((one - 1)**(x + 1)).is_constant() in (True, False) # could be 0 or 1
        True

  property is_even
  property is_extended_negative
  property is_extended_nonnegative
  property is_extended_nonpositive
  property is_extended_nonzero
  property is_extended_positive
  property is_extended_real
  property is_finite
  property is_hermitian
  is_hypergeometric(k)
  property is_imaginary
  property is_infinite
  property is_integer
  property is_irrational
  is_meromorphic(x, a)

    This tests whether an expression is meromorphic as a function of the given symbol `x` at the point `a`.

    This method is intended as a quick test that will return None if no decision can be made without simplification or more detailed analysis.

    Examples

        >>> from sympy import zoo, log, sin, sqrt
        >>> from sympy.abc import x

        >>> f = 1/x**2 + 1 - 2*x**3
        >>> f.is_meromorphic(x, 0)
        True
        >>> f.is_meromorphic(x, 1)
        True
        >>> f.is_meromorphic(x, zoo)
        True

        >>> g = x**log(3)
        >>> g.is_meromorphic(x, 0)
        False
        >>> g.is_meromorphic(x, 1)
        True
        >>> g.is_meromorphic(x, zoo)
        False

        >>> h = sin(1/x)*x**2
        >>> h.is_meromorphic(x, 0)
        False
        >>> h.is_meromorphic(x, 1)
        True
        >>> h.is_meromorphic(x, zoo)
        True

    Multivalued functions are considered meromorphic when their branches are meromorphic. Thus most functions are meromorphic everywhere except at essential singularities and branch points. In particular, they will be meromorphic also on branch cuts except at their endpoints.

        >>> log(x).is_meromorphic(x, -1)
        True
        >>> log(x).is_meromorphic(x, 0)
        False
        >>> sqrt(x).is_meromorphic(x, -1)
        True
        >>> sqrt(x).is_meromorphic(x, 0)
        False

  property is_negative
  property is_noninteger
  property is_nonnegative
  property is_nonpositive
  property is_nonzero
  is_number = False
  property is_odd
  property 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, Function
        >>> 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
        >>> (2**x + 1).is_polynomial(2**x)
        True
        >>> f = Function('f')
        >>> (f(x) + 1).is_polynomial(x)
        False
        >>> (f(x) + 1).is_polynomial(f(x))
        True
        >>> (1/f(x) + 1).is_polynomial(f(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()

  property is_positive
  property is_prime
  property 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().

  property is_real
  is_same(b, approx=None)

    Return True if a and b are structurally the same, else False. If approx is supplied, it will be used to test whether two numbers are the same or not. By default, only numbers of the same type will compare equal, so S.Half != Float(0.5).

    Examples

    In SymPy (unlike Python) two numbers do not compare the same if they are not of the same type:

        >>> from sympy import S
        >>> 2.0 == S(2)
        False
        >>> 0.5 == S.Half
        False

    By supplying a function with which to compare two numbers, such differences can be ignored. e.g. equal_valued will return True for decimal numbers having a denominator that is a power of 2, regardless of precision.

        >>> from sympy import Float
        >>> from sympy.core.numbers import equal_valued
        >>> (S.Half/4).is_same(Float(0.125, 1), equal_valued)
        True
        >>> Float(1, 2).is_same(Float(1, 10), equal_valued)
        True

    But decimals without a power of 2 denominator will compare as not being the same.

        >>> Float(0.1, 9).is_same(Float(0.1, 10), equal_valued)
        False

    But arbitrary differences can be ignored by supplying a function to test the equivalence of two numbers:

        >>> import math
        >>> Float(0.1, 9).is_same(Float(0.1, 10), math.isclose)
        True

    Other objects might compare the same even though types are not the same. This routine will only return True if two expressions are identical in terms of class types.

        >>> from sympy import eye, Basic
        >>> eye(1) == S(eye(1))  # mutable vs immutable
        True
        >>> Basic.is_same(eye(1), S(eye(1)))
        False

  is_scalar = True
  is_symbol = True
  property is_transcendental
  property is_zero
  property kind

    Default kind for all SymPy object. If the kind is not defined for the object, or if the object cannot infer the kind from its arguments, this will be returned.

    Examples

        >>> from sympy import Expr
        >>> Expr().kind
        UndefinedKind

  leadterm(x, logx=None, cdir=0)

    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, cdir=0)

    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 do not 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

    See also

    `matches`

      pattern.matches(expr) is the same as expr.match(pattern)

    `xreplace`

      exact structural replacement

    `replace`

      structural replacement with pattern matching

    `Wild`

      symbolic placeholders for expressions in pattern matching

    Examples

        >>> from sympy import Wild, Sum
        >>> 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

    Since match is purely structural expressions that are equivalent up to bound symbols will not match:

        >>> print(Sum(x, (x, 1, 2)).match(Sum(y, (y, 1, p))))
        None

    An expression with bound symbols can be matched if the pattern uses a distinct `Wild` for each bound symbol:

        >>> Sum(x, (x, 1, 2)).match(Sum(q, (q, 1, p)))
        {p_: 2, q_: x}

    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 unless `old=True`:

        >>> (x - 2).match(p - x, old=True)
        {p_: 2*x - 2}
        >>> (2/x).match(p*x, old=True)
        {p_: 2/x**2}

  matches(expr, repl_dict=None, old=False)

    Helper method for match() that looks for a match between Wild symbols in self and expressions in expr.

    Examples

        >>> from sympy import symbols, Wild, Basic
        >>> a, b, c = symbols('a b c')
        >>> x = Wild('x')
        >>> Basic(a + x, x).matches(Basic(a + b, c)) is None
        True
        >>> Basic(a + x, x).matches(Basic(a + b + c, b + c))
        {x_: b + c}

  n(n=15, subs=None, maxn=100, chop=False, strict=False, quad=None, verbose=False)

    Evaluate the given formula to an accuracy of n digits.

    Parameters:
      subs dict, optional

        Substitute numerical values for symbols, e.g. `subs={x:3, y:1+pi}`. The substitutions must be given as a dictionary.

      maxn int, optional

        Allow a maximum temporary working precision of maxn digits.

      chop bool or number, optional

        Specifies how to replace tiny real or imaginary parts in subresults by exact zeros.

        When `True` the chop value defaults to standard precision.

        Otherwise the chop value is used to determine the magnitude of “small” for purposes of chopping.

            >>> from sympy import N
            >>> x = 1e-4
            >>> N(x, chop=True)
            0.000100000000000000
            >>> N(x, chop=1e-5)
            0.000100000000000000
            >>> N(x, chop=1e-4)
            0

      strict bool, optional

        Raise `PrecisionExhausted` if any subresult fails to evaluate to full accuracy, given the available maxprec.

      quad str, optional

        Choose algorithm for numerical quadrature. By default, tanh-sinh quadrature is used. For oscillatory integrals on an infinite interval, try `quad='osc'`.

      verbose bool, optional

        Print debug information.

    Notes

    When Floats are naively substituted into an expression, precision errors may adversely affect the result. For example, adding 1e16 (a Float) to 1 will truncate to 1e16; if 1e16 is then subtracted, the result will be 0. That is exactly what happens in the following:

        >>> from sympy.abc import x, y, z
        >>> values = {x: 1e16, y: 1, z: 1e16}
        >>> (x + y - z).subs(values)
        0

    Using the subs argument for evalf is the accurate way to evaluate such an expression:

        >>> (x + y - z).evalf(subs=values)
        1.00000000000000

  name: str
  normal()

    Return the expression as a fraction.

    expression -> a/b

    See also

    `as_numer_denom`

      return `(a, b)` instead of `a/b`

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

    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 do not have to determine how many terms we need to calculate in advance.

    Disadvantage – you may end up with less terms than you may have expected, but the O(x**n) term appended will always be correct and so the result, though perhaps shorter, will also be correct.

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

    See also lseries().

    Examples

        >>> from sympy import sin, log, Symbol
        >>> from sympy.abc import x, y
        >>> sin(x).nseries(x, 0, 6)
        x - x**3/6 + x**5/120 + O(x**6)
        >>> log(x+1).nseries(x, 0, 5)
        x - x**2/2 + x**3/3 - x**4/4 + O(x**5)

    Handling of the `logx` parameter — in the following example the expansion fails since `sin` does not have an asymptotic expansion at -oo (the limit of log(x) as x approaches 0):

        >>> e = sin(log(x))
        >>> e.nseries(x, 0, 6)
        Traceback (most recent call last):
        ...
        PoleError: ...
        ...
        >>> logx = Symbol('logx')
        >>> e.nseries(x, 0, 6, logx=logx)
        sin(logx)

    In the following example, the expansion works but only returns self unless the `logx` parameter is used:

        >>> e = x**y
        >>> e.nseries(x, 0, 2)
        x**y
        >>> 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() → tuple[Number, Expr]

    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 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() → Expr

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

  replace(query, value, map=False, simultaneous=True, exact=None) → Basic

    Replace matching subexpressions of `self` with `value`.

    If `map = True` then also return the mapping {old: new} where `old` was a sub-expression found with query and `new` is the replacement value for it. If the expression itself does not match the query, then the returned value will be `self.xreplace(map)` otherwise it should be `self.subs(ordered(map.items()))`.

    Traverses an expression tree and performs replacement of matching subexpressions from the bottom to the top of the tree. The default approach is to do the replacement in a simultaneous fashion so changes made are targeted only once. If this is not desired or causes problems, `simultaneous` can be set to False.

    In addition, if an expression containing more than one Wild symbol is being used to match subexpressions and the `exact` flag is None it will be set to True so the match will only succeed if all non-zero values are received for each Wild that appears in the match pattern. Setting this to False accepts a match of 0; while setting it True accepts all matches that have a 0 in them. See example below for cautions.

    The list of possible combinations of queries and replacement values is listed below:

    See also

    `subs`

      substitution of subexpressions as defined by the objects themselves.

    `xreplace`

      exact node replacement in expr tree; also capable of using matching rules

    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) to `newtype`.

          >>> f.replace(sin, cos)
          log(cos(x)) + tan(cos(x**2))
          >>> sin(x).replace(sin, cos, map=True)
          (cos(x), {sin(x): cos(x)})
          >>> (x*y).replace(Mul, Add)
          x + y

    1.2. type -> func

      obj.replace(type, func)

      When object of type `type` is found, apply `func` to its argument(s). `func` must be written to handle the number of arguments of `type`.

          >>> f.replace(sin, lambda arg: sin(2*arg))
          log(sin(2*x)) + tan(sin(2*x**2))
          >>> (x*y).replace(Mul, lambda *args: sin(2*Mul(*args)))
          sin(2*x*y)

    2.1. pattern -> expr

      obj.replace(pattern(wild), expr(wild))

      Replace subexpressions matching `pattern` with the expression written in terms of the Wild symbols in `pattern`.

          >>> a, b = map(Wild, 'ab')
          >>> 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

      Matching is exact by default when more than one Wild symbol is used: matching fails unless the match gives non-zero values for all Wild symbols:

          >>> (2*x + y).replace(a*x + b, b - a)
          y - 2
          >>> (2*x).replace(a*x + b, b - a)
          2*x

      When set to False, the results may be non-intuitive:

          >>> (2*x).replace(a*x + b, b - a, exact=False)
          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` with `func(e)` if `filter(e)` is True.

          >>> g = 2*sin(x**3)
          >>> g.replace(lambda expr: expr.is_Number, lambda expr: expr**2)
          4*sin(x**9)

    The expression itself is also targeted by the query but is done in such a fashion that changes are not made twice.

        >>> e = x*(x*y + 1)
        >>> e.replace(lambda x: x.is_Mul, lambda x: 2*x)
        2*x*(2*x*y + 1)

    When matching a single symbol, exact will default to True, but this may or may not be the behavior that is desired:

    Here, we want exact=False:

        >>> from sympy import Function
        >>> f = Function('f')
        >>> e = f(1) + f(0)
        >>> q = f(a), lambda a: f(a + 1)
        >>> e.replace(*q, exact=False)
        f(1) + f(2)
        >>> e.replace(*q, exact=True)
        f(0) + f(2)

    But here, the nature of matching makes selecting the right setting tricky:

        >>> e = x**(1 + y)
        >>> (x**(1 + y)).replace(x**(1 + a), lambda a: x**-a, exact=False)
        x
        >>> (x**(1 + y)).replace(x**(1 + a), lambda a: x**-a, exact=True)
        x**(-x - y + 1)
        >>> (x**y).replace(x**(1 + a), lambda a: x**-a, exact=False)
        x
        >>> (x**y).replace(x**(1 + a), lambda a: x**-a, exact=True)
        x**(1 - y)

    It is probably better to use a different form of the query that describes the target expression more precisely:

        >>> (1 + x**(1 + y)).replace(
        ... lambda x: x.is_Pow and x.exp.is_Add and x.exp.args[0] == 1,
        ... lambda x: x.base**(1 - (x.exp - 1)))
        ...
        x**(1 - y) + 1

  rewrite(*args, deep=True, **hints)

    Rewrite self using a defined rule.

    Rewriting transforms an expression to another, which is mathematically equivalent but structurally different. For example you can rewrite trigonometric functions as complex exponentials or combinatorial functions as gamma function.

    This method takes a pattern and a rule as positional arguments. pattern is optional parameter which defines the types of expressions that will be transformed. If it is not passed, all possible expressions will be rewritten. rule defines how the expression will be rewritten.

    Parameters:
      args Expr

        A rule, or pattern and rule. - pattern is a type or an iterable of types. - rule can be any object.

      deep bool, optional

        If `True`, subexpressions are recursively transformed. Default is `True`.

    Examples

    If pattern is unspecified, all possible expressions are transformed.

        >>> from sympy import cos, sin, exp, I
        >>> from sympy.abc import x
        >>> expr = cos(x) + I*sin(x)
        >>> expr.rewrite(exp)
        exp(I*x)

    Pattern can be a type or an iterable of types.

        >>> expr.rewrite(sin, exp)
        exp(I*x)/2 + cos(x) - exp(-I*x)/2
        >>> expr.rewrite([cos,], exp)
        exp(I*x)/2 + I*sin(x) + exp(-I*x)/2
        >>> expr.rewrite([cos, sin], exp)
        exp(I*x)

    Rewriting behavior can be implemented by defining `_eval_rewrite()` method.

        >>> from sympy import Expr, sqrt, pi
        >>> class MySin(Expr):
        ...     def _eval_rewrite(self, rule, args, **hints):
        ...         x, = args
        ...         if rule == cos:
        ...             return cos(pi/2 - x, evaluate=False)
        ...         if rule == sqrt:
        ...             return sqrt(1 - cos(x)**2)
        >>> MySin(MySin(x)).rewrite(cos)
        cos(-cos(-x + pi/2) + pi/2)
        >>> MySin(x).rewrite(sqrt)
        sqrt(1 - cos(x)**2)

    Defining `_eval_rewrite_as_[...]()` method is supported for backwards compatibility reason. This may be removed in the future and using it is discouraged.

        >>> class MySin(Expr):
        ...     def _eval_rewrite_as_cos(self, *args, **hints):
        ...         x, = args
        ...         return cos(pi/2 - x, evaluate=False)
        >>> MySin(x).rewrite(cos)
        cos(-x + pi/2)

  round(n=None)

    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

    The Python `round` function uses the SymPy `round` method so it will always return a SymPy number (not a Python float or int):

        >>> isinstance(round(S(123), -2), Number)
        True

    Examples

        >>> from sympy import pi, E, I, S, Number
        >>> 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, cdir=0)

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

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

    If `x=None` and `self` is univariate, the univariate symbol will be supplied, otherwise an error will be raised.

    Parameters:
      expr Expression

        The expression whose series is to be expanded.

      x Symbol

        It is the variable of the expression to be calculated.

      x0 Value

        The value around which `x` is calculated. Can be any value from `-oo` to `oo`.

      n Value

        The value used to represent the order in terms of `x**n`, up to which the series is to be expanded.

      dir String, optional

        The series-expansion can be bi-directional. If `dir="+"`, then (x->x0+). If `dir="-", then (x->x0-). For infinite ``x0` (`oo` or `-oo`), the `dir` argument is determined from the direction of the infinity (i.e., `dir="-"` for `oo`).

      logx optional

        It is used to replace any log(x) in the returned series with a symbolic value rather than evaluating the actual value.

      cdir optional

        It stands for complex direction, and indicates the direction from which the expansion needs to be evaluated.

    Returns:
      Expr Expression

        Series expansion of the expression about x0

    Raises:
      TypeError

        If “n” and “x0” are infinity objects

      PoleError

        If “x0” is an infinity object

    Examples

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

    If `n=None` then a generator of the series terms will be returned.

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

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

        >>> abs(x).series(dir="+")
        x
        >>> abs(x).series(dir="-")
        -x
        >>> f = tan(x)
        >>> f.series(x, 2, 6, "+")
        tan(2) + (1 + tan(2)**2)*(x - 2) + (x - 2)**2*(tan(2)**3 + tan(2)) +
        (x - 2)**3*(1/3 + 4*tan(2)**2/3 + tan(2)**4) + (x - 2)**4*(tan(2)**5 +
        5*tan(2)**3/3 + 2*tan(2)/3) + (x - 2)**5*(2/15 + 17*tan(2)**2/15 +
        2*tan(2)**4 + tan(2)**6) + O((x - 2)**6, (x, 2))

        >>> f.series(x, 2, 3, "-")
        tan(2) + (2 - x)*(-tan(2)**2 - 1) + (2 - x)**2*(tan(2)**3 + tan(2))
        + O((x - 2)**3, (x, 2))

    For rational expressions this method may return original expression without the Order term. >>> (1/x).series(x, n=8) 1/x

  simplify(**kwargs) → Basic

    See the simplify function in sympy.simplify

  sort_key(order=None)

    Return a sort key.

    Examples

        >>> from sympy import S, I

        >>> sorted([S(1)/2, I, -I], key=lambda x: x.sort_key())
        [1/2, -I, I]

        >>> S("[x, 1/x, 1/x**2, x**2, x**(1/2), x**(1/4), x**(3/2)]")
        [x, 1/x, x**(-2), x**2, sqrt(x), x**(1/4), x**(3/2)]
        >>> sorted(_, key=lambda x: x.sort_key())
        [x**(-2), 1/x, x**(1/4), sqrt(x), x, x**(3/2), x**2]

  subs(arg1: Mapping[Basic | complex, Basic | complex] | Iterable[tuple[Basic | complex, Basic | complex]] | Basic | complex, arg2: Basic | complex | None = None, **kwargs: Any) → Basic

    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

    `replace`

      replacement capable of doing wildcard-like matching, parsing of match, and conditional replacements

    `xreplace`

      exact node replacement in expr tree; also capable of using matching rules

    `sympy.core.evalf.EvalfMixin.evalf`

      calculates the given formula to a desired level of precision

    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”.

  to_nnf(simplify=True)
  together(*args, **kwargs)

    See the together function in sympy.polys

  transpose()
  trigsimp(**args)

    See the trigsimp function in sympy.simplify

  xreplace(rule, hack2=False)

    Replace occurrences of objects within the expression.

    Parameters:
      rule dict-like

        Expresses a replacement rule

    Returns:
      xreplace the result of the replacement

    See also

    `replace`

      replacement capable of doing wildcard-like matching, parsing of match, and conditional replacements

    `subs`

      substitution of subexpressions as defined by the objects themselves.

    Examples

        >>> from sympy import symbols, pi, exp
        >>> x, y, z = symbols('x y z')
        >>> (1 + x*y).xreplace({x: pi})
        pi*y + 1
        >>> (1 + x*y).xreplace({x: pi, y: 2})
        1 + 2*pi

    Replacements occur only if an entire node in the expression tree is matched:

        >>> (x*y + z).xreplace({x*y: pi})
        z + pi
        >>> (x*y*z).xreplace({x*y: pi})
        x*y*z
        >>> (2*x).xreplace({2*x: y, x: z})
        y
        >>> (2*2*x).xreplace({2*x: y, x: z})
        4*z
        >>> (x + y + 2).xreplace({x + y: 2})
        x + y + 2
        >>> (x + 2 + exp(x + 2)).xreplace({x + 2: y})
        x + exp(y) + 2

    xreplace does not differentiate between free and bound symbols. In the following, subs(x, y) would not change x since it is a bound symbol, but xreplace does:

        >>> from sympy import Integral
        >>> Integral(x, (x, 1, 2*x)).xreplace({x: y})
        Integral(y, (y, 1, 2*y))

    Trying to replace x with an expression raises an error:

        >>> Integral(x, (x, 1, 2*x)).xreplace({x: 2*y})
        ValueError: Invalid limits given: ((2*y, 1, 4*y),)

## 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(name)

  Make dummy variable of given name

  Parameters:
    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.float64. 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.float64, 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.float64)]))
      >>> 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 tuple

      `Term` instance or list of `Term` instance objects named from names

  Examples

      >>> terms(('a', 'b', 'c'))
      (a, b, c)
      >>> terms('a, b, c')
      (a, b, c)
      >>> terms('abc')
      abc