```python
from symfit import variables, Parameter, ODEModel, D, Fit, parameters
import numpy as np
import matplotlib.pyplot as plt
from time import time
from scipy.optimize import curve_fit
from scipy.integrate import odeint
from symfit.contrib.interactive_guess import InteractiveGuess2D

from time import time as start_time

%matplotlib tk
```

```python
file = 'kineticfile.txt'
data = np.genfromtxt(file)
time = data[:, 0][1:]/1000
cd = data[:, 1][1:]
cdHe = data[:, 3][1:]
cdHe2 = data[:, 4][1:]
cdHe3 = data[:, 5][1:]
cdHe4 = data[:, 6][1:]
He = 1.768e14

total = cd+cdHe+cdHe2+cdHe3+cdHe4

```

```python
fig, ax = plt.subplots(figsize = (14, 5), dpi = 150)

ax.plot(time, total,'k', label = 'Total')
ax.plot(time, cd, lw=1, label = 'CD+')
ax.plot(time, cdHe, lw=1, label = 'CDHe+')
ax.plot(time, cdHe2, lw=1, label = 'CDHe2+')
ax.plot(time, cdHe3, lw=1, label = 'CDHe3+')
ax.plot(time, cdHe4, lw=1, label = 'CDHe4+')

ax.set_xlim(left = 0)
ax.set_yscale('log')
ax.legend()
ax.grid()

plt.show()
plt.close()
```

# Rate Equations

$$\frac{d(CD^+)}{dt} = -[(k31) * CD^+ * He^2] + [(kCID1) * CDHe^+ * He] $$
$$\frac{d(CDHe^+)}{dt} = -[(k32) * CDHe^+ * He^2] + [(kCID2) * CDHe2^+ * He] + [(k31) * CD^+ * He^2] - [(kCID1) * CDHe^+ * He] $$
$$\frac{d(CDHe2^+)}{dt} = -[(k33) * CDHe2^+ * He^2] + [(kCID3) * CDHe3^+ * He] + [(k32) * CDHe^+ * He^2] - [(kCID2) * CDHe2^+ * He] $$
$$\frac{d(CDHe3^+)}{dt} = -[(k34) * CDHe3^+ * He^2] + [(kCID4) * CDHe4^+ * He] + [(k33) * CDHe2^+ * He^2] - [(kCID3) * CDHe3^+ * He] $$
$$\frac{d(CDHe4^+)}{dt} = [(k34) * CD^+ * He^2] - [(kCID4) * CDHe^+ * He] $$

### Rate Constants to fit K31, K32, K33, K34, KCID1, KCID2, KCID3, KCID4

```python
CD, CDHe, CDHe2, CDHe3, CDHe4, t = variables('CD, CDHe, CDHe2, CDHe3, CDHe4, t')
#k31, k32, k33, k34, kCID1, kCID2, kCID3, kCID4 = parameters('k31, k32, k33, k34, kCID1, kCID2, kCID3, kCID4')

kmin, kcid_min = 1e-30, 1e-15
kmax, kcid_max = 1e-29, 1e-14

print(f'kmin: {kmin} kmax: {kmax}\nkcid_min: {kcid_min} kcid_max: {kcid_max}')

k31 = Parameter('k31', min=kmin, max=kmax)
k32 = Parameter('k32', min=kmin, max=kmax)
k33 = Parameter('k33', min=kmin, max=kmax)
k34 = Parameter('k34', min=kmin, max=kmax)

kCID1 = Parameter('kCID1', min=kcid_min, max=kcid_max)
kCID2 = Parameter('kCID2', min=kcid_min, max=kcid_max)
kCID3 = Parameter('kCID3', min=kcid_min, max=kcid_max)
kCID4 = Parameter('kCID4', min=kcid_min, max=kcid_max)

initial_cond = {
    t: 0,
    CD: cd[0],
    CDHe: 0,
    CDHe2: 0,
    CDHe3: 0,
    CDHe4: 0
}

r31 = k31*CD*He**2
rcid1 = kCID1*CDHe*He

r32 = k32*CDHe*He**2
rcid2 = kCID2*CDHe2*He

r33 = k33*CDHe2*He**2
rcid3 = kCID3*CDHe3*He

r34 = k34*CDHe3*He**2
rcid4 = kCID4*CDHe4*He

rate_model = {
    D(CD, t): -r31+rcid1,
    D(CDHe, t): -r32+rcid2+r31-rcid1,
    D(CDHe2, t): -r33+rcid3+r32-rcid2,
    D(CDHe3, t): -r34+rcid4+r33-rcid3,
    D(CDHe4, t): +r34-rcid4
}

ode_model = ODEModel(rate_model, initial=initial_cond)

# Generate some data
tdata = np.linspace(0, 3, 1000)
```

    kmin: 1e-30 kmax: 1e-29
    kcid_min: 1e-15 kcid_max: 1e-14

```python
guess = InteractiveGuess2D(ode_model, t=time, CD=cd, CDHe=cdHe, CDHe2=cdHe2, CDHe3=cdHe3, CDHe4=cdHe4)
guess.execute()
```

```python
# with Fit
t0 = start_time()

fit = Fit(ode_model, t=time, CD=cd, CDHe=cdHe, CDHe2=cdHe2, CDHe3=cdHe3, CDHe4=cdHe4)
fit_result = fit.execute()

t1 = start_time()
print(f'Time taken: {t1-t0} s')

CD, CDHe, CDHe2, CDHe3, CDHe4 = ode_model(t=tdata, **fit_result.params)

print(fit_result)
print(f'Parameters: {fit_result.params}' )
```

```python
print(f'Parameters: {fit_result.params}' )
print(fit_result)
fit_result.model
```

    Parameters: OrderedDict([('k31', 1.0000000012308992), ('k32', 0.9999999778438152), ('k33', 1.0000000061544958), ('k34', 0.9999999901528068), ('kCID1', 1.0), ('kCID2', 0.9999999950764034), ('kCID3', 0.9999999876910085), ('kCID4', 0.9999999901528068)])

    Parameter Value        Standard Deviation
    k31       1.000000e+00 9.028050e+07
    k32       1.000000e+00 5.430212e+07
    k33       1.000000e+00 4.463294e+07
    k34       1.000000e+00 5.271634e+07
    kCID1     1.000000e+00 1.208968e+08
    kCID2     1.000000e+00 3.967016e+07
    kCID3     1.000000e+00 5.626132e+07
    kCID4     1.000000e+00 1.001997e+08
    Fitting status message: Desired error not necessarily achieved due to precision loss.
    Number of iterations:   721
    Regression Coefficient: -1450.011948091635

    <symfit.core.fit.ODEModel at 0x2a7dbd467b8>

```python
# Eval the normal way. (without fit)
CD, CDHe, CDHe2, CDHe3, CDHe4 = ode_model(t=tdata, k31=2.7e-30, k32=6e-30, k33=32e-30, k34=15e-28, kCID1=1.9e-15, kCID2=4e-15, kCID3=24e-15, kCID4=15e-14)

# with Fit
#ode_model = ODEModel(rate_model, initial=initial_cond)

#fit = Fit(ode_model, t=time, CD=cd, CDHe-cdHe, CDHe2=cdHe2, CDHe3=cdHe3, CDHe4=cdHe4)
#fit_result = fit.execute()

#CD, CDHe, CDHe2, CDHe3, CDHe4 = ode_model(t=tdata, **fit_result.params)

######################################################################################################################################################################

fig2, ax2 = plt.subplots(figsize = (14, 5), dpi = 150)

ax2.plot(tdata, CD, label = 'CD+')
ax2.plot(time, cd, '.', label = 'CD+_exp')

ax2.plot(tdata, CDHe, label = 'CDHe+')
ax2.plot(time, cdHe, '.', label = 'CDHe+_exp')

ax2.plot(tdata, CDHe2, label = 'CDHe2+')
ax2.plot(time, cdHe2, '.', label = 'CDHe2+_exp')

ax2.plot(tdata, CDHe3, label = 'CDHe3+')
ax2.plot(time, cdHe3, '.', label = 'CDHe3+_exp')

ax2.plot(tdata, CDHe4, label = 'CDHe4+')
ax2.plot(time, cdHe4, '.', label = 'CDHe4+_exp')

ax2.set_yscale('log')
ax2.set_xlabel('Time (s)')
ax2.set_ylabel('Counts')
ax2.set_title('Ternary Reactions rate')
ax2.legend()
ax2.grid()

plt.show()
plt.close()
```

```python

```

```python
help(Fit)
```

```python
import time
t0 = time.time()
time.sleep(1)
t1 = time.time()
t1-t0
```

    1.0153584480285645

```python
time()
```

    1556023399.318374

```python
help(Parameter)
k31 = Parameter('k31', min=1e-16)
```

    Help on class Parameter in module symfit.core.argument:

    class Parameter(Argument)
     |  Parameter(name=None, *args, **kwargs)
     |
     |  Parameter objects are used to facilitate bounds on function parameters.
     |  Important change from `symfit>0.4.1`: the name needs to be the first keyword,
     |  followed by the guess value. If no name is provided, the initial value can
     |  be passed as a keyword argument, e.g.: `value=0.1`. A generic name will then
     |  be generated.
     |
     |  Method resolution order:
     |      Parameter
     |      Argument
     |      sympy.core.symbol.Symbol
     |      sympy.core.expr.AtomicExpr
     |      sympy.core.basic.Atom
     |      sympy.core.expr.Expr
     |      sympy.logic.boolalg.Boolean
     |      sympy.core.basic.Basic
     |      sympy.core.evalf.EvalfMixin
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __call__ = call(self, *values, **named_values)
     |      Call an expression to evaluate it at the given point.
     |
     |      Future improvements: I would like if func and signature could be buffered after the
     |      first call so they don't have to be recalculated for every call. However, nothing
     |      can be stored on self as sympy uses __slots__ for efficiency. This means there is no
     |      instance dict to put stuff in! And I'm pretty sure it's ill advised to hack into the
     |      __slots__ of Expr.
     |
     |      However, for the moment I don't really notice a performance penalty in running tests.
     |
     |      p.s. In the current setup signature is not even needed since no introspection is possible
     |      on the Expr before calling it anyway, which makes calculating the signature absolutely useless.
     |      However, I hope that someday some monkey patching expert in shining armour comes by and finds
     |      a way to store it in __signature__ upon __init__ of any ``symfit`` expr such that calling
     |      inspect_sig.signature on a symbolic expression will tell you which arguments to provide.
     |
     |      :param self: Any subclass of sympy.Expr
     |      :param values: Values for the Parameters and Variables of the Expr.
     |      :param named_values: Values for the vars and params by name. ``named_values`` is
     |          allowed to contain too many values, as this sometimes happens when using
     |          \*\*fit_result.params on a submodel. The irrelevant params are simply ignored.
     |      :return: The function evaluated at ``values``. The type depends entirely on the input.
     |          Typically an array or a float but nothing is enforced.
     |
     |  __init__(self, name=None, value=1.0, min=None, max=None, fixed=False, **assumptions)
     |      :param name: Name of the Parameter.
     |      :param value: Initial guess value.
     |      :param min: Lower bound on the parameter value.
     |      :param max: Upper bound on the parameter value.
     |      :param fixed: Fix the parameter to ``value`` during fitting.
     |      :type fixed: bool
     |      :param assumptions: assumptions to pass to ``sympy``.
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __new__(cls, name=None, *args, **kwargs)
     |      Create a new ``Argument``. See :class:`~sympy.core.symbol.Symbol`
     |      for more information.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  fixed
     |
     |  max
     |
     |  min
     |
     |  value
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  default_assumptions = {}
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Argument:
     |
     |  __getstate__(self)
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from sympy.core.symbol.Symbol:
     |
     |  __getnewargs__(self)
     |
     |  __new_stage2__(cls, name, **assumptions)
     |
     |  as_dummy(self)
     |      Return a Dummy having the same name and same assumptions as self.
     |
     |  as_real_imag(self, deep=True, **hints)
     |      Performs complex expansion on 'self' and returns a tuple
     |      containing collected both real and imaginary parts. This
     |      method can't be confused with re() and im() functions,
     |      which does not perform complex expansion at evaluation.
     |
     |      However it is possible to expand both re() and im()
     |      functions and get exactly the same results as with
     |      a single call to this function.
     |
     |      >>> from sympy import symbols, I
     |
     |      >>> x, y = symbols('x,y', real=True)
     |
     |      >>> (x + y*I).as_real_imag()
     |      (x, y)
     |
     |      >>> from sympy.abc import z, w
     |
     |      >>> (z + w*I).as_real_imag()
     |      (re(z) - im(w), re(w) + im(z))
     |
     |  is_constant(self, *wrt, **flags)
     |      Return True if self is constant, False if not, or None if
     |      the constancy could not be determined conclusively.
     |
     |      If an expression has no free symbols then it is a constant. If
     |      there are free symbols it is possible that the expression is a
     |      constant, perhaps (but not necessarily) zero. To test such
     |      expressions, two strategies are tried:
     |
     |      1) numerical evaluation at two random points. If two such evaluations
     |      give two different values and the values have a precision greater than
     |      1 then self is not constant. If the evaluations agree or could not be
     |      obtained with any precision, no decision is made. The numerical testing
     |      is done only if ``wrt`` is different than the free symbols.
     |
     |      2) differentiation with respect to variables in 'wrt' (or all free
     |      symbols if omitted) to see if the expression is constant or not. This
     |      will not always lead to an expression that is zero even though an
     |      expression is constant (see added test in test_expr.py). If
     |      all derivatives are zero then self is constant with respect to the
     |      given symbols.
     |
     |      If neither evaluation nor differentiation can prove the expression is
     |      constant, None is returned unless two numerical values happened to be
     |      the same and the flag ``failing_number`` is True -- in that case the
     |      numerical value will be returned.
     |
     |      If flag simplify=False is passed, self will not be simplified;
     |      the default is True since self should be simplified before testing.
     |
     |      Examples
     |      ========
     |
     |      >>> from sympy import cos, sin, Sum, S, pi
     |      >>> from sympy.abc import a, n, x, y
     |      >>> x.is_constant()
     |      False
     |      >>> S(2).is_constant()
     |      True
     |      >>> Sum(x, (x, 1, 10)).is_constant()
     |      True
     |      >>> Sum(x, (x, 1, n)).is_constant()
     |      False
     |      >>> Sum(x, (x, 1, n)).is_constant(y)
     |      True
     |      >>> Sum(x, (x, 1, n)).is_constant(n)
     |      False
     |      >>> Sum(x, (x, 1, n)).is_constant(x)
     |      True
     |      >>> eq = a*cos(x)**2 + a*sin(x)**2 - a
     |      >>> eq.is_constant()
     |      True
     |      >>> eq.subs({x: pi, a: 2}) == eq.subs({x: pi, a: 3}) == 0
     |      True
     |
     |      >>> (0**x).is_constant()
     |      False
     |      >>> x.is_constant()
     |      False
     |      >>> (x**x).is_constant()
     |      False
     |      >>> one = cos(x)**2 + sin(x)**2
     |      >>> one.is_constant()
     |      True
     |      >>> ((one - 1)**(x + 1)).is_constant() in (True, False) # could be 0 or 1
     |      True
     |
     |  sort_key(self, order=None)
     |
     |  ----------------------------------------------------------------------
     |  Static methods inherited from sympy.core.symbol.Symbol:
     |
     |  __xnew__ = __new_stage2__(cls, name, **assumptions)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from sympy.core.symbol.Symbol:
     |
     |  assumptions0
     |      Return object `type` assumptions.
     |
     |      For example:
     |
     |        Symbol('x', real=True)
     |        Symbol('x', integer=True)
     |
     |      are different objects. In other words, besides Python type (Symbol in
     |      this case), the initial assumptions are also forming their typeinfo.
     |
     |      Examples
     |      ========
     |
     |      >>> from sympy import Symbol
     |      >>> from sympy.abc import x
     |      >>> x.assumptions0
     |      {'commutative': True}
     |      >>> x = Symbol("x", positive=True)
     |      >>> x.assumptions0
     |      {'commutative': True, 'complex': True, 'hermitian': True,
     |      'imaginary': False, 'negative': False, 'nonnegative': True,
     |      'nonpositive': False, 'nonzero': True, 'positive': True, 'real': True,
     |      'zero': False}
     |
     |  free_symbols
     |      Return from the atoms of self those which are free symbols.
     |
     |      For most expressions, all symbols are free symbols. For some classes
     |      this is not true. e.g. Integrals use Symbols for the dummy variables
     |      which are bound variables, so Integral has a method to return all
     |      symbols except those. Derivative keeps track of symbols with respect
     |      to which it will perform a derivative; those are
     |      bound variables, too, so it has its own free_symbols method.
     |
     |      Any other method that uses bound variables should implement a
     |      free_symbols method.
     |
     |  name
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from sympy.core.symbol.Symbol:
     |
     |  is_Symbol = True
     |
     |  is_comparable = False
     |
     |  is_symbol = True
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from sympy.core.expr.AtomicExpr:
     |
     |  is_Atom = True
     |
     |  is_number = False
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from sympy.core.basic.Atom:
     |
     |  doit(self, **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)
     |
     |  matches(self, expr, repl_dict={}, old=False)
     |      Helper method for match() that looks for a match between Wild symbols
     |      in self and expressions in expr.
     |
     |      Examples
     |      ========
     |
     |      >>> from sympy import symbols, Wild, Basic
     |      >>> a, b, c = symbols('a b c')
     |      >>> x = Wild('x')
     |      >>> Basic(a + x, x).matches(Basic(a + b, c)) is None
     |      True
     |      >>> Basic(a + x, x).matches(Basic(a + b + c, b + c))
     |      {x_: b + c}
     |
     |  xreplace(self, 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
     |
     |      Examples
     |      ========
     |
     |      >>> from sympy import symbols, pi, exp
     |      >>> x, y, z = symbols('x y z')
     |      >>> (1 + x*y).xreplace({x: pi})
     |      pi*y + 1
     |      >>> (1 + x*y).xreplace({x: pi, y: 2})
     |      1 + 2*pi
     |
     |      Replacements occur only if an entire node in the expression tree is
     |      matched:
     |
     |      >>> (x*y + z).xreplace({x*y: pi})
     |      z + pi
     |      >>> (x*y*z).xreplace({x*y: pi})
     |      x*y*z
     |      >>> (2*x).xreplace({2*x: y, x: z})
     |      y
     |      >>> (2*2*x).xreplace({2*x: y, x: z})
     |      4*z
     |      >>> (x + y + 2).xreplace({x + y: 2})
     |      x + y + 2
     |      >>> (x + 2 + exp(x + 2)).xreplace({x + 2: y})
     |      x + exp(y) + 2
     |
     |      xreplace doesn't differentiate between free and bound symbols. In the
     |      following, subs(x, y) would not change x since it is a bound symbol,
     |      but xreplace does:
     |
     |      >>> from sympy import Integral
     |      >>> Integral(x, (x, 1, 2*x)).xreplace({x: y})
     |      Integral(y, (y, 1, 2*y))
     |
     |      Trying to replace x with an expression raises an error:
     |
     |      >>> Integral(x, (x, 1, 2*x)).xreplace({x: 2*y}) # doctest: +SKIP
     |      ValueError: Invalid limits given: ((2*y, 1, 4*y),)
     |
     |      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.
     |
     |  ----------------------------------------------------------------------
     |  Class methods inherited from sympy.core.basic.Atom:
     |
     |  class_key() from sympy.core.assumptions.ManagedProperties
     |      Nice order of classes.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from sympy.core.expr.Expr:
     |
     |  __abs__(self)
     |
     |  __add__(self, other)
     |
     |  __complex__(self)
     |
     |  __div__(self, other)
     |
     |  __float__(self)
     |
     |  __floordiv__(self, other)
     |
     |  __ge__(self, other)
     |      Return self>=value.
     |
     |  __gt__(self, other)
     |      Return self>value.
     |
     |  __int__(self)
     |
     |  __le__(self, other)
     |      Return self<=value.
     |
     |  __long__ = __int__(self)
     |
     |  __lt__(self, other)
     |      Return self<value.
     |
     |  __mod__(self, other)
     |
     |  __mul__(self, other)
     |
     |  __neg__(self)
     |
     |  __pos__(self)
     |
     |  __pow__(self, other)
     |
     |  __radd__(self, other)
     |
     |  __rdiv__(self, other)
     |
     |  __rfloordiv__(self, other)
     |
     |  __rmod__(self, other)
     |
     |  __rmul__(self, other)
     |
     |  __rpow__(self, other)
     |
     |  __rsub__(self, other)
     |
     |  __rtruediv__ = __rdiv__(self, other)
     |
     |  __sub__(self, other)
     |
     |  __truediv__ = __div__(self, other)
     |
     |  adjoint(self)
     |
     |  apart(self, x=None, **args)
     |      See the apart function in sympy.polys
     |
     |  args_cnc(self, cset=False, warn=True, split_1=True)
     |      Return [commutative factors, non-commutative factors] of self.
     |
     |      self is treated as a Mul and the ordering of the factors is maintained.
     |      If ``cset`` is True the commutative factors will be returned in a set.
     |      If there were repeated factors (as may happen with an unevaluated Mul)
     |      then an error will be raised unless it is explicitly supressed by
     |      setting ``warn`` to False.
     |
     |      Note: -1 is always separated from a Number unless split_1 is False.
     |
     |      >>> from sympy import symbols, oo
     |      >>> A, B = symbols('A B', commutative=0)
     |      >>> x, y = symbols('x y')
     |      >>> (-2*x*y).args_cnc()
     |      [[-1, 2, x, y], []]
     |      >>> (-2.5*x).args_cnc()
     |      [[-1, 2.5, x], []]
     |      >>> (-2*x*A*B*y).args_cnc()
     |      [[-1, 2, x, y], [A, B]]
     |      >>> (-2*x*A*B*y).args_cnc(split_1=False)
     |      [[-2, x, y], [A, B]]
     |      >>> (-2*x*y).args_cnc(cset=True)
     |      [{-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(self)
     |
     |  as_coeff_Add(self, rational=False)
     |      Efficiently extract the coefficient of a summation.
     |
     |  as_coeff_Mul(self, rational=False)
     |      Efficiently extract the coefficient of a product.
     |
     |  as_coeff_add(self, *deps)
     |      Return the tuple (c, args) where self is written as an Add, ``a``.
     |
     |      c should be a Rational added to any terms of the Add that are
     |      independent of deps.
     |
     |      args should be a tuple of all other terms of ``a``; args is empty
     |      if self is a Number or if self is independent of deps (when given).
     |
     |      This should be used when you don't know if self is an Add or not but
     |      you want to treat self as an Add or if you want to process the
     |      individual arguments of the tail of self as an Add.
     |
     |      - if you know self is an Add and want only the head, use self.args[0];
     |      - if you don't want to process the arguments of the tail but need the
     |        tail then use self.as_two_terms() which gives the head and tail.
     |      - if you want to split self into an independent and dependent parts
     |        use ``self.as_independent(*deps)``
     |
     |      >>> from sympy import S
     |      >>> from sympy.abc import x, y
     |      >>> (S(3)).as_coeff_add()
     |      (3, ())
     |      >>> (3 + x).as_coeff_add()
     |      (3, (x,))
     |      >>> (3 + x + y).as_coeff_add(x)
     |      (y + 3, (x,))
     |      >>> (3 + y).as_coeff_add(x)
     |      (y + 3, ())
     |
     |  as_coeff_exponent(self, x)
     |      ``c*x**e -> c,e`` where x can be any symbolic expression.
     |
     |  as_coeff_mul(self, *deps, **kwargs)
     |      Return the tuple (c, args) where self is written as a Mul, ``m``.
     |
     |      c should be a Rational multiplied by any factors of the Mul that are
     |      independent of deps.
     |
     |      args should be a tuple of all other factors of m; args is empty
     |      if self is a Number or if self is independent of deps (when given).
     |
     |      This should be used when you don't know if self is a Mul or not but
     |      you want to treat self as a Mul or if you want to process the
     |      individual arguments of the tail of self as a Mul.
     |
     |      - if you know self is a Mul and want only the head, use self.args[0];
     |      - if you don't want to process the arguments of the tail but need the
     |        tail then use self.as_two_terms() which gives the head and tail;
     |      - if you want to split self into an independent and dependent parts
     |        use ``self.as_independent(*deps)``
     |
     |      >>> from sympy import S
     |      >>> from sympy.abc import x, y
     |      >>> (S(3)).as_coeff_mul()
     |      (3, ())
     |      >>> (3*x*y).as_coeff_mul()
     |      (3, (x, y))
     |      >>> (3*x*y).as_coeff_mul(x)
     |      (3*y, (x,))
     |      >>> (3*y).as_coeff_mul(x)
     |      (3*y, ())
     |
     |  as_coefficient(self, expr)
     |      Extracts symbolic coefficient at the given expression. In
     |      other words, this functions separates 'self' into the product
     |      of 'expr' and 'expr'-free coefficient. If such separation
     |      is not possible it will return None.
     |
     |      Examples
     |      ========
     |
     |      >>> from sympy import E, pi, sin, I, Poly
     |      >>> from sympy.abc import x
     |
     |      >>> E.as_coefficient(E)
     |      1
     |      >>> (2*E).as_coefficient(E)
     |      2
     |      >>> (2*sin(E)*E).as_coefficient(E)
     |
     |      Two terms have E in them so a sum is returned. (If one were
     |      desiring the coefficient of the term exactly matching E then
     |      the constant from the returned expression could be selected.
     |      Or, for greater precision, a method of Poly can be used to
     |      indicate the desired term from which the coefficient is
     |      desired.)
     |
     |      >>> (2*E + x*E).as_coefficient(E)
     |      x + 2
     |      >>> _.args[0]  # just want the exact match
     |      2
     |      >>> p = Poly(2*E + x*E); p
     |      Poly(x*E + 2*E, x, E, domain='ZZ')
     |      >>> p.coeff_monomial(E)
     |      2
     |      >>> p.nth(0, 1)
     |      2
     |
     |      Since the following cannot be written as a product containing
     |      E as a factor, None is returned. (If the coefficient ``2*x`` is
     |      desired then the ``coeff`` method should be used.)
     |
     |      >>> (2*E*x + x).as_coefficient(E)
     |      >>> (2*E*x + x).coeff(E)
     |      2*x
     |
     |      >>> (E*(x + 1) + x).as_coefficient(E)
     |
     |      >>> (2*pi*I).as_coefficient(pi*I)
     |      2
     |      >>> (2*I).as_coefficient(pi*I)
     |
     |      See Also
     |      ========
     |
     |      coeff: return sum of terms have a given factor
     |      as_coeff_Add: separate the additive constant from an expression
     |      as_coeff_Mul: separate the multiplicative constant from an expression
     |      as_independent: separate x-dependent terms/factors from others
     |      sympy.polys.polytools.coeff_monomial: efficiently find the single coefficient of a monomial in Poly
     |      sympy.polys.polytools.nth: like coeff_monomial but powers of monomial terms are used
     |
     |  as_coefficients_dict(self)
     |      Return a dictionary mapping terms to their Rational coefficient.
     |      Since the dictionary is a defaultdict, inquiries about terms which
     |      were not present will return a coefficient of 0. If an expression is
     |      not an Add it is considered to have a single term.
     |
     |      Examples
     |      ========
     |
     |      >>> from sympy.abc import a, x
     |      >>> (3*x + a*x + 4).as_coefficients_dict()
     |      {1: 4, x: 3, a*x: 1}
     |      >>> _[a]
     |      0
     |      >>> (3*a*x).as_coefficients_dict()
     |      {a*x: 3}
     |
     |  as_content_primitive(self, radical=False, clear=True)
     |      This method should recursively remove a Rational from all arguments
     |      and return that (content) and the new self (primitive). The content
     |      should always be positive and ``Mul(*foo.as_content_primitive()) == foo``.
     |      The primitive need no be in canonical form and should try to preserve
     |      the underlying structure if possible (i.e. expand_mul should not be
     |      applied to self).
     |
     |      Examples
     |      ========
     |
     |      >>> from sympy import sqrt
     |      >>> from sympy.abc import x, y, z
     |
     |      >>> eq = 2 + 2*x + 2*y*(3 + 3*y)
     |
     |      The as_content_primitive function is recursive and retains structure:
     |
     |      >>> eq.as_content_primitive()
     |      (2, x + 3*y*(y + 1) + 1)
     |
     |      Integer powers will have Rationals extracted from the base:
     |
     |      >>> ((2 + 6*x)**2).as_content_primitive()
     |      (4, (3*x + 1)**2)
     |      >>> ((2 + 6*x)**(2*y)).as_content_primitive()
     |      (1, (2*(3*x + 1))**(2*y))
     |
     |      Terms may end up joining once their as_content_primitives are added:
     |
     |      >>> ((5*(x*(1 + y)) + 2*x*(3 + 3*y))).as_content_primitive()
     |      (11, x*(y + 1))
     |      >>> ((3*(x*(1 + y)) + 2*x*(3 + 3*y))).as_content_primitive()
     |      (9, x*(y + 1))
     |      >>> ((3*(z*(1 + y)) + 2.0*x*(3 + 3*y))).as_content_primitive()
     |      (1, 6.0*x*(y + 1) + 3*z*(y + 1))
     |      >>> ((5*(x*(1 + y)) + 2*x*(3 + 3*y))**2).as_content_primitive()
     |      (121, x**2*(y + 1)**2)
     |      >>> ((5*(x*(1 + y)) + 2.0*x*(3 + 3*y))**2).as_content_primitive()
     |      (1, 121.0*x**2*(y + 1)**2)
     |
     |      Radical content can also be factored out of the primitive:
     |
     |      >>> (2*sqrt(2) + 4*sqrt(10)).as_content_primitive(radical=True)
     |      (2, sqrt(2)*(1 + 2*sqrt(5)))
     |
     |      If clear=False (default is True) then content will not be removed
     |      from an Add if it can be distributed to leave one or more
     |      terms with integer coefficients.
     |
     |      >>> (x/2 + y).as_content_primitive()
     |      (1/2, x + 2*y)
     |      >>> (x/2 + y).as_content_primitive(clear=False)
     |      (1, x/2 + y)
     |
     |  as_expr(self, *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(self, *deps, **hint)
     |      A mostly naive separation of a Mul or Add into arguments that are not
     |      are dependent on deps. To obtain as complete a separation of variables
     |      as possible, use a separation method first, e.g.:
     |
     |      * separatevars() to change Mul, Add and Pow (including exp) into Mul
     |      * .expand(mul=True) to change Add or Mul into Add
     |      * .expand(log=True) to change log expr into an Add
     |
     |      The only non-naive thing that is done here is to respect noncommutative
     |      ordering of variables and to always return (0, 0) for `self` of zero
     |      regardless of hints.
     |
     |      For nonzero `self`, the returned tuple (i, d) has the
     |      following interpretation:
     |
     |      * i will has no variable that appears in deps
     |      * d will be 1 or else have terms that contain variables that are in deps
     |      * if self is an Add then self = i + d
     |      * if self is a Mul then self = i*d
     |      * otherwise (self, S.One) or (S.One, self) is returned.
     |
     |      To force the expression to be treated as an Add, use the hint as_Add=True
     |
     |      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))
     |
     |      See Also
     |      ========
     |      .separatevars(), .expand(log=True), Add.as_two_terms(),
     |      Mul.as_two_terms(), .as_coeff_add(), .as_coeff_mul()
     |
     |  as_leading_term(self, *symbols)
     |      Returns the leading (nonzero) term of the series expansion of self.
     |
     |      The _eval_as_leading_term routines are used to do this, and they must
     |      always return a 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(self)
     |      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(self, order=None)
     |      Return list of ordered factors (if Mul) else [self].
     |
     |  as_ordered_terms(self, 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_powers_dict(self)
     |      Return self as a dictionary of factors with each factor being
     |      treated as a power. The keys are the bases of the factors and the
     |      values, the corresponding exponents. The resulting dictionary should
     |      be used with caution if the expression is a Mul and contains non-
     |      commutative factors since the order that they appeared will be lost in
     |      the dictionary.
     |
     |  as_terms(self)
     |      Transform an expression to a list of terms.
     |
     |  cancel(self, *gens, **args)
     |      See the cancel function in sympy.polys
     |
     |  coeff(self, x, n=1, right=False)
     |      Returns the coefficient from the term(s) containing ``x**n``. If ``n``
     |      is zero then all terms independent of ``x`` will be returned.
     |
     |      When ``x`` is noncommutative, the coefficient to the left (default) or
     |      right of ``x`` can be returned. The keyword 'right' is ignored when
     |      ``x`` is commutative.
     |
     |      See Also
     |      ========
     |
     |      as_coefficient: separate the expression into a coefficient and factor
     |      as_coeff_Add: separate the additive constant from an expression
     |      as_coeff_Mul: separate the multiplicative constant from an expression
     |      as_independent: separate x-dependent terms/factors from others
     |      sympy.polys.polytools.coeff_monomial: efficiently find the single coefficient of a monomial in Poly
     |      sympy.polys.polytools.nth: like coeff_monomial but powers of monomial terms are used
     |
     |      Examples
     |      ========
     |
     |      >>> from sympy import symbols
     |      >>> from sympy.abc import x, y, z
     |
     |      You can select terms that have an explicit negative in front of them:
     |
     |      >>> (-x + 2*y).coeff(-1)
     |      x
     |      >>> (x - 2*y).coeff(-1)
     |      2*y
     |
     |      You can select terms with no Rational coefficient:
     |
     |      >>> (x + 2*y).coeff(1)
     |      x
     |      >>> (3 + 2*x + 4*x**2).coeff(1)
     |      0
     |
     |      You can select terms independent of x by making n=0; in this case
     |      expr.as_independent(x)[0] is returned (and 0 will be returned instead
     |      of None):
     |
     |      >>> (3 + 2*x + 4*x**2).coeff(x, 0)
     |      3
     |      >>> eq = ((x + 1)**3).expand() + 1
     |      >>> eq
     |      x**3 + 3*x**2 + 3*x + 2
     |      >>> [eq.coeff(x, i) for i in reversed(range(4))]
     |      [1, 3, 3, 2]
     |      >>> eq -= 2
     |      >>> [eq.coeff(x, i) for i in reversed(range(4))]
     |      [1, 3, 3, 0]
     |
     |      You can select terms that have a numerical term in front of them:
     |
     |      >>> (-x - 2*y).coeff(2)
     |      -y
     |      >>> from sympy import sqrt
     |      >>> (x + sqrt(2)*x).coeff(sqrt(2))
     |      x
     |
     |      The matching is exact:
     |
     |      >>> (3 + 2*x + 4*x**2).coeff(x)
     |      2
     |      >>> (3 + 2*x + 4*x**2).coeff(x**2)
     |      4
     |      >>> (3 + 2*x + 4*x**2).coeff(x**3)
     |      0
     |      >>> (z*(x + y)**2).coeff((x + y)**2)
     |      z
     |      >>> (z*(x + y)**2).coeff(x + y)
     |      0
     |
     |      In addition, no factoring is done, so 1 + z*(1 + y) is not obtained
     |      from the following:
     |
     |      >>> (x + z*(x + x*y)).coeff(x)
     |      1
     |
     |      If such factoring is desired, factor_terms can be used first:
     |
     |      >>> from sympy import factor_terms
     |      >>> factor_terms(x + z*(x + x*y)).coeff(x)
     |      z*(y + 1) + 1
     |
     |      >>> n, m, o = symbols('n m o', commutative=False)
     |      >>> n.coeff(n)
     |      1
     |      >>> (3*n).coeff(n)
     |      3
     |      >>> (n*m + m*n*m).coeff(n) # = (1 + m)*n*m
     |      1 + m
     |      >>> (n*m + m*n*m).coeff(n, right=True) # = (1 + m)*n*m
     |      m
     |
     |      If there is more than one possible coefficient 0 is returned:
     |
     |      >>> (n*m + m*n).coeff(n)
     |      0
     |
     |      If there is only one possible coefficient, it is returned:
     |
     |      >>> (n*m + x*m*n).coeff(m*n)
     |      x
     |      >>> (n*m + x*m*n).coeff(m*n, right=1)
     |      1
     |
     |  collect(self, syms, func=None, evaluate=True, exact=False, distribute_order_term=True)
     |      See the collect function in sympy.simplify
     |
     |  combsimp(self)
     |      See the combsimp function in sympy.simplify
     |
     |  compute_leading_term(self, x, logx=None)
     |      as_leading_term is only allowed for results of .series()
     |      This is a wrapper to compute a series first.
     |
     |  conjugate(self)
     |
     |  could_extract_minus_sign(self)
     |      Canonical way to choose an element in the set {e, -e} where
     |      e is any expression. If the canonical element is e, we have
     |      e.could_extract_minus_sign() == True, else
     |      e.could_extract_minus_sign() == False.
     |
     |      For any expression, the set ``{e.could_extract_minus_sign(),
     |      (-e).could_extract_minus_sign()}`` must be ``{True, False}``.
     |
     |      >>> from sympy.abc import x, y
     |      >>> (x-y).could_extract_minus_sign() != (y-x).could_extract_minus_sign()
     |      True
     |
     |  count_ops(self, visual=None)
     |      wrapper for count_ops that returns the operation count.
     |
     |  diff(self, *symbols, **assumptions)
     |
     |  equals(self, other, failing_expression=False)
     |      Return True if self == other, False if it doesn't, or None. If
     |      failing_expression is True then the expression which did not simplify
     |      to a 0 will be returned instead of None.
     |
     |      If ``self`` is a Number (or complex number) that is not zero, then
     |      the result is False.
     |
     |      If ``self`` is a number and has not evaluated to zero, evalf will be
     |      used to test whether the expression evaluates to zero. If it does so
     |      and the result has significance (i.e. the precision is either -1, for
     |      a Rational result, or is greater than 1) then the evalf value will be
     |      used to return True or False.
     |
     |  expand(self, 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.
     |
     |  extract_additively(self, c)
     |      Return self - c if it's possible to subtract c from self and
     |      make all matching coefficients move towards zero, else return None.
     |
     |      Examples
     |      ========
     |
     |      >>> from sympy.abc import x, y
     |      >>> e = 2*x + 3
     |      >>> e.extract_additively(x + 1)
     |      x + 2
     |      >>> e.extract_additively(3*x)
     |      >>> e.extract_additively(4)
     |      >>> (y*(x + 1)).extract_additively(x + 1)
     |      >>> ((x + 1)*(x + 2*y + 1) + 3).extract_additively(x + 1)
     |      (x + 1)*(x + 2*y) + 3
     |
     |      Sometimes auto-expansion will return a less simplified result
     |      than desired; gcd_terms might be used in such cases:
     |
     |      >>> from sympy import gcd_terms
     |      >>> (4*x*(y + 1) + y).extract_additively(x)
     |      4*x*(y + 1) + x*(4*y + 3) - x*(4*y + 4) + y
     |      >>> gcd_terms(_)
     |      x*(4*y + 3) + y
     |
     |      See Also
     |      ========
     |      extract_multiplicatively
     |      coeff
     |      as_coefficient
     |
     |  extract_branch_factor(self, 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(self, c)
     |      Return None if it's not possible to make self in the form
     |      c * something in a nice way, i.e. preserving the properties
     |      of arguments of self.
     |
     |      >>> from sympy import symbols, Rational
     |
     |      >>> x, y = symbols('x,y', real=True)
     |
     |      >>> ((x*y)**3).extract_multiplicatively(x**2 * y)
     |      x*y**2
     |
     |      >>> ((x*y)**3).extract_multiplicatively(x**4 * y)
     |
     |      >>> (2*x).extract_multiplicatively(2)
     |      x
     |
     |      >>> (2*x).extract_multiplicatively(3)
     |
     |      >>> (Rational(1, 2)*x).extract_multiplicatively(3)
     |      x/6
     |
     |  factor(self, *gens, **args)
     |      See the factor() function in sympy.polys.polytools
     |
     |  fourier_series(self, limits=None)
     |      Compute fourier sine/cosine series of self.
     |
     |      See the docstring of the :func:`fourier_series` in sympy.series.fourier
     |      for more information.
     |
     |  fps(self, 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 :func:`fps` function in sympy.series.formal for
     |      more information.
     |
     |  getO(self)
     |      Returns the additive O(..) symbol if there is one, else None.
     |
     |  getn(self)
     |      Returns the order of the expression.
     |
     |      The order is determined either from the O(...) term. If there
     |      is no O(...) term, it returns None.
     |
     |      Examples
     |      ========
     |
     |      >>> from sympy import O
     |      >>> from sympy.abc import x
     |      >>> (1 + x + O(x**2)).getn()
     |      2
     |      >>> (1 + x).getn()
     |
     |  integrate(self, *args, **kwargs)
     |      See the integrate function in sympy.integrals
     |
     |  invert(self, g, *gens, **args)
     |      Return the multiplicative inverse of ``self`` mod ``g``
     |      where ``self`` (and ``g``) may be symbolic expressions).
     |
     |      See Also
     |      ========
     |      sympy.core.numbers.mod_inverse, sympy.polys.polytools.invert
     |
     |  is_algebraic_expr(self, *syms)
     |      This tests whether a given expression is algebraic or not, in the
     |      given symbols, syms. When syms is not given, all free symbols
     |      will be used. The rational function does not have to be in expanded
     |      or in any kind of canonical form.
     |
     |      This function returns False for expressions that are "algebraic
     |      expressions" with symbolic exponents. This is a simple extension to the
     |      is_rational_function, including rational exponentiation.
     |
     |      Examples
     |      ========
     |
     |      >>> from sympy import Symbol, sqrt
     |      >>> x = Symbol('x', real=True)
     |      >>> sqrt(1 + x).is_rational_function()
     |      False
     |      >>> sqrt(1 + x).is_algebraic_expr()
     |      True
     |
     |      This function does not attempt any nontrivial simplifications that may
     |      result in an expression that does not appear to be an algebraic
     |      expression to become one.
     |
     |      >>> from sympy import exp, factor
     |      >>> a = sqrt(exp(x)**2 + 2*exp(x) + 1)/(exp(x) + 1)
     |      >>> a.is_algebraic_expr(x)
     |      False
     |      >>> factor(a).is_algebraic_expr()
     |      True
     |
     |      See Also
     |      ========
     |      is_rational_function()
     |
     |      References
     |      ==========
     |
     |      - http://en.wikipedia.org/wiki/Algebraic_expression
     |
     |  is_polynomial(self, *syms)
     |      Return True if self is a polynomial in syms and False otherwise.
     |
     |      This checks if self is an exact polynomial in syms.  This function
     |      returns False for expressions that are "polynomials" with symbolic
     |      exponents.  Thus, you should be able to apply polynomial algorithms to
     |      expressions for which this returns True, and Poly(expr, \*syms) should
     |      work if and only if expr.is_polynomial(\*syms) returns True. The
     |      polynomial does not have to be in expanded form.  If no symbols are
     |      given, all free symbols in the expression will be used.
     |
     |      This is not part of the assumptions system.  You cannot do
     |      Symbol('z', polynomial=True).
     |
     |      Examples
     |      ========
     |
     |      >>> from sympy import Symbol
     |      >>> x = Symbol('x')
     |      >>> ((x**2 + 1)**4).is_polynomial(x)
     |      True
     |      >>> ((x**2 + 1)**4).is_polynomial()
     |      True
     |      >>> (2**x + 1).is_polynomial(x)
     |      False
     |
     |
     |      >>> n = Symbol('n', nonnegative=True, integer=True)
     |      >>> (x**n + 1).is_polynomial(x)
     |      False
     |
     |      This function does not attempt any nontrivial simplifications that may
     |      result in an expression that does not appear to be a polynomial to
     |      become one.
     |
     |      >>> from sympy import sqrt, factor, cancel
     |      >>> y = Symbol('y', positive=True)
     |      >>> a = sqrt(y**2 + 2*y + 1)
     |      >>> a.is_polynomial(y)
     |      False
     |      >>> factor(a)
     |      y + 1
     |      >>> factor(a).is_polynomial(y)
     |      True
     |
     |      >>> b = (y**2 + 2*y + 1)/(y + 1)
     |      >>> b.is_polynomial(y)
     |      False
     |      >>> cancel(b)
     |      y + 1
     |      >>> cancel(b).is_polynomial(y)
     |      True
     |
     |      See also .is_rational_function()
     |
     |  is_rational_function(self, *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().
     |
     |  leadterm(self, x)
     |      Returns the leading term a*x**b as a tuple (a, b).
     |
     |      Examples
     |      ========
     |
     |      >>> from sympy.abc import x
     |      >>> (1+x+x**2).leadterm(x)
     |      (1, 0)
     |      >>> (1/x**2+x+x**2).leadterm(x)
     |      (1, -2)
     |
     |  limit(self, x, xlim, dir='+')
     |      Compute limit x->xlim.
     |
     |  lseries(self, x=None, x0=0, dir='+', logx=None)
     |      Wrapper for series yielding an iterator of the terms of the series.
     |
     |      Note: an infinite series will yield an infinite iterator. The following,
     |      for exaxmple, will never terminate. It will just keep printing terms
     |      of the sin(x) series::
     |
     |        for term in sin(x).lseries(x):
     |            print term
     |
     |      The advantage of lseries() over nseries() is that many times you are
     |      just interested in the next term in the series (i.e. the first term for
     |      example), but you don't know how many you should ask for in nseries()
     |      using the "n" parameter.
     |
     |      See also nseries().
     |
     |  normal(self)
     |
     |  nseries(self, x=None, x0=0, n=6, dir='+', logx=None)
     |      Wrapper to _eval_nseries if assumptions allow, else to series.
     |
     |      If x is given, x0 is 0, dir='+', and self has x, then _eval_nseries is
     |      called. This calculates "n" terms in the innermost expressions and
     |      then builds up the final series just by "cross-multiplying" everything
     |      out.
     |
     |      The optional ``logx`` parameter can be used to replace any log(x) in the
     |      returned series with a symbolic value to avoid evaluating log(x) at 0. A
     |      symbol to use in place of log(x) should be provided.
     |
     |      Advantage -- it's fast, because we don't have to determine how many
     |      terms we need to calculate in advance.
     |
     |      Disadvantage -- you may end up with less terms than you may have
     |      expected, but the O(x**n) term appended will always be correct and
     |      so the result, though perhaps shorter, will also be correct.
     |
     |      If any of those assumptions is not met, this is treated like a
     |      wrapper to series which will try harder to return the correct
     |      number of terms.
     |
     |      See also lseries().
     |
     |      Examples
     |      ========
     |
     |      >>> from sympy import sin, log, Symbol
     |      >>> from sympy.abc import x, y
     |      >>> sin(x).nseries(x, 0, 6)
     |      x - x**3/6 + x**5/120 + O(x**6)
     |      >>> log(x+1).nseries(x, 0, 5)
     |      x - x**2/2 + x**3/3 - x**4/4 + O(x**5)
     |
     |      Handling of the ``logx`` parameter --- in the following example the
     |      expansion fails since ``sin`` does not have an asymptotic expansion
     |      at -oo (the limit of log(x) as x approaches 0):
     |
     |      >>> e = sin(log(x))
     |      >>> e.nseries(x, 0, 6)
     |      Traceback (most recent call last):
     |      ...
     |      PoleError: ...
     |      ...
     |      >>> logx = Symbol('logx')
     |      >>> e.nseries(x, 0, 6, logx=logx)
     |      sin(logx)
     |
     |      In the following example, the expansion works but gives only an Order term
     |      unless the ``logx`` parameter is used:
     |
     |      >>> e = x**y
     |      >>> e.nseries(x, 0, 2)
     |      O(log(x)**2)
     |      >>> e.nseries(x, 0, 2, logx=logx)
     |      exp(logx*y)
     |
     |  nsimplify(self, constants=[], tolerance=None, full=False)
     |      See the nsimplify function in sympy.simplify
     |
     |  powsimp(self, *args, **kwargs)
     |      See the powsimp function in sympy.simplify
     |
     |  primitive(self)
     |      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(self, **kwargs)
     |      See the radsimp function in sympy.simplify
     |
     |  ratsimp(self)
     |      See the ratsimp function in sympy.simplify
     |
     |  refine(self, assumption=True)
     |      See the refine function in sympy.assumptions
     |
     |  removeO(self)
     |      Removes the additive O(..) symbol if there is one
     |
     |  round(self, p=0)
     |      Return x rounded to the given decimal place.
     |
     |      If a complex number would results, apply round to the real
     |      and imaginary components of the number.
     |
     |      Examples
     |      ========
     |
     |      >>> from sympy import pi, E, I, S, Add, Mul, Number
     |      >>> S(10.5).round()
     |      11.
     |      >>> pi.round()
     |      3.
     |      >>> pi.round(2)
     |      3.14
     |      >>> (2*pi + E*I).round()
     |      6. + 3.*I
     |
     |      The round method has a chopping effect:
     |
     |      >>> (2*pi + I/10).round()
     |      6.
     |      >>> (pi/10 + 2*I).round()
     |      2.*I
     |      >>> (pi/10 + E*I).round(2)
     |      0.31 + 2.72*I
     |
     |      Notes
     |      =====
     |
     |      Do not confuse the Python builtin function, round, with the
     |      SymPy method of the same name. The former always returns a float
     |      (or raises an error if applied to a complex value) while the
     |      latter returns either a Number or a complex number:
     |
     |      >>> isinstance(round(S(123), -2), Number)
     |      False
     |      >>> isinstance(S(123).round(-2), Number)
     |      True
     |      >>> isinstance((3*I).round(), Mul)
     |      True
     |      >>> isinstance((1 + 3*I).round(), Add)
     |      True
     |
     |  separate(self, deep=False, force=False)
     |      See the separate function in sympy.simplify
     |
     |  series(self, x=None, x0=0, n=6, dir='+', logx=None)
     |      Series expansion of "self" around ``x = x0`` yielding either terms of
     |      the series one by one (the lazy series given when n=None), else
     |      all the terms at once when n != None.
     |
     |      Returns the series expansion of "self" around the point ``x = x0``
     |      with respect to ``x`` up to ``O((x - x0)**n, x, x0)`` (default n is 6).
     |
     |      If ``x=None`` and ``self`` is univariate, the univariate symbol will
     |      be supplied, otherwise an error will be raised.
     |
     |      >>> from sympy import cos, exp
     |      >>> from sympy.abc import x, y
     |      >>> cos(x).series()
     |      1 - x**2/2 + x**4/24 + O(x**6)
     |      >>> cos(x).series(n=4)
     |      1 - x**2/2 + O(x**4)
     |      >>> cos(x).series(x, x0=1, n=2)
     |      cos(1) - (x - 1)*sin(1) + O((x - 1)**2, (x, 1))
     |      >>> e = cos(x + exp(y))
     |      >>> e.series(y, n=2)
     |      cos(x + 1) - y*sin(x + 1) + O(y**2)
     |      >>> e.series(x, n=2)
     |      cos(exp(y)) - x*sin(exp(y)) + O(x**2)
     |
     |      If ``n=None`` then a generator of the series terms will be returned.
     |
     |      >>> term=cos(x).series(n=None)
     |      >>> [next(term) for i in range(2)]
     |      [1, -x**2/2]
     |
     |      For ``dir=+`` (default) the series is calculated from the right and
     |      for ``dir=-`` the series from the left. For smooth functions this
     |      flag will not alter the results.
     |
     |      >>> abs(x).series(dir="+")
     |      x
     |      >>> abs(x).series(dir="-")
     |      -x
     |
     |  simplify(self, ratio=1.7, measure=None)
     |      See the simplify function in sympy.simplify
     |
     |  taylor_term(self, n, x, *previous_terms)
     |      General method for the taylor term.
     |
     |      This method is slow, because it differentiates n-times. Subclasses can
     |      redefine it to make it faster by using the "previous_terms".
     |
     |  together(self, *args, **kwargs)
     |      See the together function in sympy.polys
     |
     |  transpose(self)
     |
     |  trigsimp(self, **args)
     |      See the trigsimp function in sympy.simplify
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from sympy.logic.boolalg.Boolean:
     |
     |  __and__(self, other)
     |      Overloading for & operator
     |
     |  __invert__(self)
     |      Overloading for ~
     |
     |  __lshift__(self, other)
     |      Overloading for <<
     |
     |  __or__(self, other)
     |      Overloading for |
     |
     |  __rand__ = __and__(self, other)
     |      Overloading for & operator
     |
     |  __rlshift__ = __rshift__(self, other)
     |      Overloading for >>
     |
     |  __ror__ = __or__(self, other)
     |      Overloading for |
     |
     |  __rrshift__ = __lshift__(self, other)
     |      Overloading for <<
     |
     |  __rshift__(self, other)
     |      Overloading for >>
     |
     |  __rxor__ = __xor__(self, other)
     |
     |  __xor__(self, other)
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from sympy.core.basic.Basic:
     |
     |  __eq__(self, other)
     |      Return a boolean indicating whether a == b on the basis of
     |      their symbolic trees.
     |
     |      This is the same as a.compare(b) == 0 but faster.
     |
     |      Notes
     |      =====
     |
     |      If a class that overrides __eq__() needs to retain the
     |      implementation of __hash__() from a parent class, the
     |      interpreter must be told this explicitly by setting __hash__ =
     |      <ParentClass>.__hash__. Otherwise the inheritance of __hash__()
     |      will be blocked, just as if __hash__ had been explicitly set to
     |      None.
     |
     |      References
     |      ==========
     |
     |      from http://docs.python.org/dev/reference/datamodel.html#object.__hash__
     |
     |  __hash__(self)
     |      Return hash(self).
     |
     |  __ne__(self, other)
     |      a != b  -> Compare two symbolic trees and see whether they are different
     |
     |      this is the same as:
     |
     |        a.compare(b) != 0
     |
     |      but faster
     |
     |  __reduce_ex__(self, proto)
     |      Pickling support.
     |
     |  __repr__(self)
     |      Method to return the string representation.
     |      Return the expression as a string.
     |
     |  __setstate__(self, state)
     |
     |  __str__(self)
     |      Return str(self).
     |
     |  as_poly(self, *gens, **args)
     |      Converts ``self`` to a polynomial or returns ``None``.
     |
     |      >>> from sympy import sin
     |      >>> from sympy.abc import x, y
     |
     |      >>> print((x**2 + x*y).as_poly())
     |      Poly(x**2 + x*y, x, y, domain='ZZ')
     |
     |      >>> print((x**2 + x*y).as_poly(x, y))
     |      Poly(x**2 + x*y, x, y, domain='ZZ')
     |
     |      >>> print((x**2 + sin(y)).as_poly(x, y))
     |      None
     |
     |  atoms(self, *types)
     |      Returns the atoms that form the current object.
     |
     |      By default, only objects that are truly atomic and can't
     |      be divided into smaller pieces are returned: symbols, numbers,
     |      and number symbols like I and pi. It is possible to request
     |      atoms of any type, however, as demonstrated below.
     |
     |      Examples
     |      ========
     |
     |      >>> from sympy import I, pi, sin
     |      >>> from sympy.abc import x, y
     |      >>> (1 + x + 2*sin(y + I*pi)).atoms()
     |      {1, 2, I, pi, x, y}
     |
     |      If one or more types are given, the results will contain only
     |      those types of atoms.
     |
     |      Examples
     |      ========
     |
     |      >>> from sympy import Number, NumberSymbol, Symbol
     |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Symbol)
     |      {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)}
     |
     |  compare(self, other)
     |      Return -1, 0, 1 if the object is smaller, equal, or greater than other.
     |
     |      Not in the mathematical sense. If the object is of a different type
     |      from the "other" then their classes are ordered according to
     |      the sorted_classes list.
     |
     |      Examples
     |      ========
     |
     |      >>> from sympy.abc import x, y
     |      >>> x.compare(y)
     |      -1
     |      >>> x.compare(x)
     |      0
     |      >>> y.compare(x)
     |      1
     |
     |  copy(self)
     |
     |  count(self, query)
     |      Count the number of matching subexpressions.
     |
     |  dummy_eq(self, other, symbol=None)
     |      Compare two expressions and handle dummy symbols.
     |
     |      Examples
     |      ========
     |
     |      >>> from sympy import Dummy
     |      >>> from sympy.abc import x, y
     |
     |      >>> u = Dummy('u')
     |
     |      >>> (u**2 + 1).dummy_eq(x**2 + 1)
     |      True
     |      >>> (u**2 + 1) == (x**2 + 1)
     |      False
     |
     |      >>> (u**2 + y).dummy_eq(x**2 + y, x)
     |      True
     |      >>> (u**2 + y).dummy_eq(x**2 + y, y)
     |      False
     |
     |  find(self, query, group=False)
     |      Find all subexpressions matching a query.
     |
     |  has(self, *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.sets import Interval
     |      >>> i = Interval.Lopen(0, 5); i
     |      Interval.Lopen(0, 5)
     |      >>> i.args
     |      (0, 5, True, False)
     |      >>> i.has(4)  # there is no "4" in the arguments
     |      False
     |      >>> i.has(0)  # there *is* a "0" in the arguments
     |      True
     |
     |      Instead, use ``contains`` to determine whether a number is in the
     |      interval or not:
     |
     |      >>> i.contains(4)
     |      True
     |      >>> i.contains(0)
     |      False
     |
     |
     |      Note that ``expr.has(*patterns)`` is exactly equivalent to
     |      ``any(expr.has(p) for p in patterns)``. In particular, ``False`` is
     |      returned when the list of patterns is empty.
     |
     |      >>> x.has()
     |      False
     |
     |  is_hypergeometric(self, k)
     |
     |  match(self, pattern, old=False)
     |      Pattern matching.
     |
     |      Wild symbols match all.
     |
     |      Return ``None`` when expression (self) does not match
     |      with pattern. Otherwise return a dictionary such that::
     |
     |        pattern.xreplace(self.match(pattern)) == self
     |
     |      Examples
     |      ========
     |
     |      >>> from sympy import Wild
     |      >>> from sympy.abc import x, y
     |      >>> p = Wild("p")
     |      >>> q = Wild("q")
     |      >>> r = Wild("r")
     |      >>> e = (x+y)**(x+y)
     |      >>> e.match(p**p)
     |      {p_: x + y}
     |      >>> e.match(p**q)
     |      {p_: x + y, q_: x + y}
     |      >>> e = (2*x)**2
     |      >>> e.match(p*q**r)
     |      {p_: 4, q_: x, r_: 2}
     |      >>> (p*q**r).xreplace(e.match(p*q**r))
     |      4*x**2
     |
     |      The ``old`` flag will give the old-style pattern matching where
     |      expressions and patterns are essentially solved to give the
     |      match. Both of the following give None 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}
     |
     |  rcall(self, *args)
     |      Apply on the argument recursively through the expression tree.
     |
     |      This method is used to simulate a common abuse of notation for
     |      operators. For instance in SymPy the the following will not work:
     |
     |      ``(x+Lambda(y, 2*y))(z) == x+2*z``,
     |
     |      however you can use
     |
     |      >>> from sympy import Lambda
     |      >>> from sympy.abc import x, y, z
     |      >>> (x + Lambda(y, 2*y)).rcall(z)
     |      x + 2*z
     |
     |  replace(self, query, value, map=False, simultaneous=True, exact=False)
     |      Replace matching subexpressions of ``self`` with ``value``.
     |
     |      If ``map = True`` then also return the mapping {old: new} where ``old``
     |      was a sub-expression found with query and ``new`` is the replacement
     |      value for it. If the expression itself doesn't match the query, then
     |      the returned value will be ``self.xreplace(map)`` otherwise it should
     |      be ``self.subs(ordered(map.items()))``.
     |
     |      Traverses an expression tree and performs replacement of matching
     |      subexpressions from the bottom to the top of the tree. The default
     |      approach is to do the replacement in a simultaneous fashion so
     |      changes made are targeted only once. If this is not desired or causes
     |      problems, ``simultaneous`` can be set to False. In addition, if an
     |      expression containing more than one Wild symbol is being used to match
     |      subexpressions and  the ``exact`` flag is True, then the match will only
     |      succeed if non-zero values are received for each Wild that appears in
     |      the match pattern.
     |
     |      The list of possible combinations of queries and replacement values
     |      is listed below:
     |
     |      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 = Wild('a')
     |          >>> f.replace(sin(a), tan(a))
     |          log(tan(x)) + tan(tan(x**2))
     |          >>> f.replace(sin(a), tan(a/2))
     |          log(tan(x/2)) + tan(tan(x**2/2))
     |          >>> f.replace(sin(a), a)
     |          log(x) + tan(x**2)
     |          >>> (x*y).replace(a*x, a)
     |          y
     |
     |          When the default value of False is used with patterns that have
     |          more than one Wild symbol, non-intuitive results may be obtained:
     |
     |          >>> b = Wild('b')
     |          >>> (2*x).replace(a*x + b, b - a)
     |          2/x
     |
     |          For this reason, the ``exact`` option can be used to make the
     |          replacement only when the match gives non-zero values for all
     |          Wild symbols:
     |
     |          >>> (2*x + y).replace(a*x + b, b - a, exact=True)
     |          y - 2
     |          >>> (2*x).replace(a*x + b, b - a, exact=True)
     |          2*x
     |
     |      2.2. pattern -> func
     |          obj.replace(pattern(wild), lambda wild: expr(wild))
     |
     |          All behavior is the same as in 2.1 but now a function in terms of
     |          pattern variables is used rather than an expression:
     |
     |          >>> f.replace(sin(a), lambda a: sin(2*a))
     |          log(sin(2*x)) + tan(sin(2*x**2))
     |
     |      3.1. func -> func
     |          obj.replace(filter, func)
     |
     |          Replace subexpression ``e`` with ``func(e)`` if ``filter(e)``
     |          is True.
     |
     |          >>> g = 2*sin(x**3)
     |          >>> g.replace(lambda expr: expr.is_Number, lambda expr: expr**2)
     |          4*sin(x**9)
     |
     |      The expression itself is also targeted by the query but is done in
     |      such a fashion that changes are not made twice.
     |
     |          >>> e = x*(x*y + 1)
     |          >>> e.replace(lambda x: x.is_Mul, lambda x: 2*x)
     |          2*x*(2*x*y + 1)
     |
     |      See Also
     |      ========
     |      subs: substitution of subexpressions as defined by the objects
     |            themselves.
     |      xreplace: exact node replacement in expr tree; also capable of
     |                using matching rules
     |
     |  rewrite(self, *args, **hints)
     |      Rewrite functions in terms of other functions.
     |
     |      Rewrites expression containing applications of functions
     |      of one kind in terms of functions of different kind. For
     |      example you can rewrite trigonometric functions as complex
     |      exponentials or combinatorial functions as gamma function.
     |
     |      As a pattern this function accepts a list of functions to
     |      to rewrite (instances of DefinedFunction class). As rule
     |      you can use string or a destination function instance (in
     |      this case rewrite() will use the str() function).
     |
     |      There is also the possibility to pass hints on how to rewrite
     |      the given expressions. For now there is only one such hint
     |      defined called 'deep'. When 'deep' is set to False it will
     |      forbid functions to rewrite their contents.
     |
     |      Examples
     |      ========
     |
     |      >>> from sympy import sin, exp
     |      >>> from sympy.abc import x
     |
     |      Unspecified pattern:
     |
     |      >>> sin(x).rewrite(exp)
     |      -I*(exp(I*x) - exp(-I*x))/2
     |
     |      Pattern as a single function:
     |
     |      >>> sin(x).rewrite(sin, exp)
     |      -I*(exp(I*x) - exp(-I*x))/2
     |
     |      Pattern as a list of functions:
     |
     |      >>> sin(x).rewrite([sin, ], exp)
     |      -I*(exp(I*x) - exp(-I*x))/2
     |
     |  subs(self, *args, **kwargs)
     |      Substitutes old for new in an expression after sympifying args.
     |
     |      `args` is either:
     |        - two arguments, e.g. foo.subs(old, new)
     |        - one iterable argument, e.g. foo.subs(iterable). The iterable may be
     |           o an iterable container with (old, new) pairs. In this case the
     |             replacements are processed in the order given with successive
     |             patterns possibly affecting replacements already made.
     |           o a dict or set whose key/value items correspond to old/new pairs.
     |             In this case the old/new pairs will be sorted by op count and in
     |             case of a tie, by number of args and the default_sort_key. The
     |             resulting sorted list is then processed as an iterable container
     |             (see previous).
     |
     |      If the keyword ``simultaneous`` is True, the subexpressions will not be
     |      evaluated until all the substitutions have been made.
     |
     |      Examples
     |      ========
     |
     |      >>> from sympy import pi, exp, limit, oo
     |      >>> from sympy.abc import x, y
     |      >>> (1 + x*y).subs(x, pi)
     |      pi*y + 1
     |      >>> (1 + x*y).subs({x:pi, y:2})
     |      1 + 2*pi
     |      >>> (1 + x*y).subs([(x, pi), (y, 2)])
     |      1 + 2*pi
     |      >>> reps = [(y, x**2), (x, 2)]
     |      >>> (x + y).subs(reps)
     |      6
     |      >>> (x + y).subs(reversed(reps))
     |      x**2 + 2
     |
     |      >>> (x**2 + x**4).subs(x**2, y)
     |      y**2 + y
     |
     |      To replace only the x**2 but not the x**4, use xreplace:
     |
     |      >>> (x**2 + x**4).xreplace({x**2: y})
     |      x**4 + y
     |
     |      To delay evaluation until all substitutions have been made,
     |      set the keyword ``simultaneous`` to True:
     |
     |      >>> (x/y).subs([(x, 0), (y, 0)])
     |      0
     |      >>> (x/y).subs([(x, 0), (y, 0)], simultaneous=True)
     |      nan
     |
     |      This has the added feature of not allowing subsequent substitutions
     |      to affect those already made:
     |
     |      >>> ((x + y)/y).subs({x + y: y, y: x + y})
     |      1
     |      >>> ((x + y)/y).subs({x + y: y, y: x + y}, simultaneous=True)
     |      y/(x + y)
     |
     |      In order to obtain a canonical result, unordered iterables are
     |      sorted by count_op length, number of arguments and by the
     |      default_sort_key to break any ties. All other iterables are left
     |      unsorted.
     |
     |      >>> from sympy import sqrt, sin, cos
     |      >>> from sympy.abc import a, b, c, d, e
     |
     |      >>> A = (sqrt(sin(2*x)), a)
     |      >>> B = (sin(2*x), b)
     |      >>> C = (cos(2*x), c)
     |      >>> D = (x, d)
     |      >>> E = (exp(x), e)
     |
     |      >>> expr = sqrt(sin(2*x))*sin(exp(x)*x)*cos(2*x) + sin(2*x)
     |
     |      >>> expr.subs(dict([A, B, C, D, E]))
     |      a*c*sin(d*e) + b
     |
     |      The resulting expression represents a literal replacement of the
     |      old arguments with the new arguments. This may not reflect the
     |      limiting behavior of the expression:
     |
     |      >>> (x**3 - 3*x).subs({x: oo})
     |      nan
     |
     |      >>> limit(x**3 - 3*x, x, oo)
     |      oo
     |
     |      If the substitution will be followed by numerical
     |      evaluation, it is better to pass the substitution to
     |      evalf as
     |
     |      >>> (1/x).evalf(subs={x: 3.0}, n=21)
     |      0.333333333333333333333
     |
     |      rather than
     |
     |      >>> (1/x).subs({x: 3.0}).evalf(21)
     |      0.333333333333333314830
     |
     |      as the former will ensure that the desired level of precision is
     |      obtained.
     |
     |      See Also
     |      ========
     |      replace: 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
     |      evalf: calculates the given formula to a desired level of precision
     |
     |  ----------------------------------------------------------------------
     |  Class methods inherited from sympy.core.basic.Basic:
     |
     |  fromiter(args, **assumptions) from sympy.core.assumptions.ManagedProperties
     |      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)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from sympy.core.basic.Basic:
     |
     |  args
     |      Returns a tuple of arguments of 'self'.
     |
     |      Examples
     |      ========
     |
     |      >>> from sympy import cot
     |      >>> from sympy.abc import x, y
     |
     |      >>> cot(x).args
     |      (x,)
     |
     |      >>> cot(x).args[0]
     |      x
     |
     |      >>> (x*y).args
     |      (x, y)
     |
     |      >>> (x*y).args[1]
     |      y
     |
     |      Notes
     |      =====
     |
     |      Never use self._args, always use self.args.
     |      Only use _args in __new__ when creating a new function.
     |      Don't override .args() from Basic (so that it's easy to
     |      change the interface in the future if needed).
     |
     |  canonical_variables
     |      Return a dictionary mapping any variable defined in
     |      ``self.variables`` as underscore-suffixed numbers
     |      corresponding to their position in ``self.variables``. Enough
     |      underscores are added to ensure that there will be no clash with
     |      existing free symbols.
     |
     |      Examples
     |      ========
     |
     |      >>> from sympy import Lambda
     |      >>> from sympy.abc import x
     |      >>> Lambda(x, 2*x).canonical_variables
     |      {x: 0_}
     |
     |  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
     |
     |  is_algebraic
     |
     |  is_antihermitian
     |
     |  is_commutative
     |
     |  is_complex
     |
     |  is_composite
     |
     |  is_even
     |
     |  is_finite
     |
     |  is_hermitian
     |
     |  is_imaginary
     |
     |  is_infinite
     |
     |  is_integer
     |
     |  is_irrational
     |
     |  is_negative
     |
     |  is_noninteger
     |
     |  is_nonnegative
     |
     |  is_nonpositive
     |
     |  is_nonzero
     |
     |  is_odd
     |
     |  is_polar
     |
     |  is_positive
     |
     |  is_prime
     |
     |  is_rational
     |
     |  is_real
     |
     |  is_transcendental
     |
     |  is_zero
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from sympy.core.basic.Basic:
     |
     |  is_Add = False
     |
     |  is_AlgebraicNumber = False
     |
     |  is_Boolean = False
     |
     |  is_Derivative = False
     |
     |  is_Dummy = False
     |
     |  is_Equality = False
     |
     |  is_Float = False
     |
     |  is_Function = False
     |
     |  is_Indexed = False
     |
     |  is_Integer = False
     |
     |  is_Matrix = False
     |
     |  is_Mul = False
     |
     |  is_Not = False
     |
     |  is_Number = False
     |
     |  is_NumberSymbol = False
     |
     |  is_Order = False
     |
     |  is_Piecewise = False
     |
     |  is_Point = False
     |
     |  is_Poly = False
     |
     |  is_Pow = False
     |
     |  is_Rational = False
     |
     |  is_Relational = False
     |
     |  is_Vector = False
     |
     |  is_Wild = False
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from sympy.core.evalf.EvalfMixin:
     |
     |  evalf(self, n=15, subs=None, maxn=100, chop=False, strict=False, quad=None, verbose=False)
     |      Evaluate the given formula to an accuracy of n digits.
     |      Optional keyword arguments:
     |
     |          subs=<dict>
     |              Substitute numerical values for symbols, e.g.
     |              subs={x:3, y:1+pi}. The substitutions must be given as a
     |              dictionary.
     |
     |          maxn=<integer>
     |              Allow a maximum temporary working precision of maxn digits
     |              (default=100)
     |
     |          chop=<bool>
     |              Replace tiny real or imaginary parts in subresults
     |              by exact zeros (default=False)
     |
     |          strict=<bool>
     |              Raise PrecisionExhausted if any subresult fails to evaluate
     |              to full accuracy, given the available maxprec
     |              (default=False)
     |
     |          quad=<str>
     |              Choose algorithm for numerical quadrature. By default,
     |              tanh-sinh quadrature is used. For oscillatory
     |              integrals on an infinite interval, try quad='osc'.
     |
     |          verbose=<bool>
     |              Print debug information (default=False)
     |
     |  n = evalf(self, n=15, subs=None, maxn=100, chop=False, strict=False, quad=None, verbose=False)
     |      Evaluate the given formula to an accuracy of n digits.
     |      Optional keyword arguments:
     |
     |          subs=<dict>
     |              Substitute numerical values for symbols, e.g.
     |              subs={x:3, y:1+pi}. The substitutions must be given as a
     |              dictionary.
     |
     |          maxn=<integer>
     |              Allow a maximum temporary working precision of maxn digits
     |              (default=100)
     |
     |          chop=<bool>
     |              Replace tiny real or imaginary parts in subresults
     |              by exact zeros (default=False)
     |
     |          strict=<bool>
     |              Raise PrecisionExhausted if any subresult fails to evaluate
     |              to full accuracy, given the available maxprec
     |              (default=False)
     |
     |          quad=<str>
     |              Choose algorithm for numerical quadrature. By default,
     |              tanh-sinh quadrature is used. For oscillatory
     |              integrals on an infinite interval, try quad='osc'.
     |
     |          verbose=<bool>
     |              Print debug information (default=False)

```python

```

```python

```

```python

```

```python

```

```python

```

```python

```

```python

```

```python

```

```python

```

```python

```

```python

```

```python

```

```python

```