# Source code for diofant.core.basic

```
"""Base class for all the objects in Diofant."""
from collections import Mapping, defaultdict
from itertools import zip_longest
from .cache import cacheit
from .compatibility import iterable, ordered
from .decorators import _sympifyit
from .singleton import S
from .sympify import SympifyError, sympify
[docs]class Basic:
"""
Base class for all objects in Diofant.
Always use ``args`` property, when accessing parameters of some instance.
"""
# To be overridden with True in the appropriate subclasses
is_number = False
is_Atom = False
is_Symbol = False
is_Dummy = False
is_Wild = False
is_Function = False
is_Add = False
is_Mul = False
is_Pow = False
is_Number = False
is_Float = False
is_Rational = False
is_Integer = False
is_NumberSymbol = False
is_Order = False
is_Derivative = False
is_Piecewise = False
is_Poly = False
is_Relational = False
is_Equality = False
is_Boolean = False
is_Not = False
is_Matrix = False
is_MatMul = False
is_Vector = False
def __new__(cls, *args):
obj = object.__new__(cls)
obj._mhash = None # will be set by __hash__ method.
obj._args = args # all items in args must be Basic objects
return obj
def __reduce_ex__(self, proto):
"""Pickling support."""
return type(self), self.__getnewargs__(), self.__getstate__()
def __getnewargs__(self):
return self.args
def __getstate__(self):
return {}
def __setstate__(self, state):
for k, v in state.items():
setattr(self, k, v)
def __hash__(self):
# hash cannot be cached using cache_it because infinite recurrence
# occurs as hash is needed for setting cache dictionary keys
h = self._mhash
if h is None:
h = hash((type(self).__name__,) + self._hashable_content())
self._mhash = h
return h
def _hashable_content(self):
"""Return a tuple of information about self that can be used to
compute the hash. If a class defines additional attributes,
like ``name`` in Symbol, then this method should be updated
accordingly to return such relevant attributes.
Defining more than _hashable_content is necessary if __eq__ has
been defined by a class. See note about this in Basic.__eq__.
"""
return self._args
[docs] @cacheit
def sort_key(self, order=None):
"""Return a sort key.
Examples
========
>>> sorted([Rational(1, 2), I, -I], key=lambda x: x.sort_key())
[1/2, -I, I]
>>> [x, 1/x, 1/x**2, x**2, x**S.Half, x**Rational(1, 4), x**Rational(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]
"""
args = len(self.args), tuple(arg.sort_key(order)
for arg in self._sorted_args)
return self.class_key(), args, S.One.sort_key(), S.One
@_sympifyit('other', NotImplemented)
def __eq__(self, other):
"""Return a boolean indicating whether a == b on the basis of
their symbolic trees.
Notes
=====
See [1]_. 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
==========
* http://docs.python.org/dev/reference/datamodel.html#object.__hash__
"""
if self is other:
return True
if type(self) != type(other):
return False
return self._hashable_content() == other._hashable_content()
# Note, we always use the default ordering (lex) in __str__ and __repr__,
# regardless of the global setting. See issue sympy/sympy#5487.
def __repr__(self):
from ..printing import srepr
return srepr(self, order=None)
def __str__(self):
from ..printing import sstr
return sstr(self, order=None)
def _repr_pretty_(self, p, cycle):
from ..printing import pretty
p.text(pretty(self))
def _repr_latex_(self):
from ..printing import latex
return latex(self, mode='equation')
[docs] def 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
========
>>> e = 1 + x + 2*sin(y + I*pi)
>>> e.atoms()
{1, 2, I, pi, x, y}
If one or more types are given, the results will contain only
those types of atoms.
>>> e.atoms(Symbol)
{x, y}
>>> e.atoms(Number)
{1, 2}
>>> e.atoms(Number, NumberSymbol)
{1, 2, pi}
>>> e.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:
>>> e.atoms(x)
{x, y}
Be careful to check your assumptions when using the implicit option
since ``Integer(1).is_Integer = True`` but ``type(Integer(1))`` is
``One``, a special type of diofant atom, while ``type(Integer(2))``
is type ``Integer`` and will find all integers in an expression:
>>> e.atoms(Integer(1))
{1}
>>> e.atoms(Integer(2))
{1, 2}
Finally, arguments to atoms() can select more than atomic atoms: any
diofant type can be listed as an argument and those types of "atoms"
as found in scanning the arguments of the expression recursively:
>>> from diofant.core.function import AppliedUndef
>>> (1 + x + 2*sin(y + I*pi)).atoms(Mul)
{I*pi, 2*sin(y + I*pi)}
>>> f = Function('f')
>>> e = 1 + f(x) + 2*sin(y + I*pi)
>>> e.atoms(Function)
{f(x), sin(y + I*pi)}
>>> (1 + f(x) + 2*sin(y + I*pi)).atoms(AppliedUndef)
{f(x)}
"""
if types:
types = tuple(t if isinstance(t, type) else type(t) for t in types)
else:
types = Atom,
return set().union(*[self.find(t) for t in types])
@property
def free_symbols(self):
"""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.
"""
return set().union(*[a.free_symbols for a in self.args])
[docs] def 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 Diofant the the following will not work:
``(x+Lambda(y, 2*y))(z) == x+2*z``,
however you can use
>>> (x + Lambda(y, 2*y)).rcall(z)
x + 2*z
"""
if callable(self) and hasattr(self, '__call__'):
return self(*args)
elif self.args:
newargs = [sub.rcall(*args) for sub in self.args]
return type(self)(*newargs)
else:
return self
@property
def func(self):
"""The top-level function in an expression.
The following should hold for all objects::
x == x.func(*x.args)
Examples
========
>>> a = 2*x
>>> a.func
<class 'diofant.core.mul.Mul'>
>>> a.args
(2, x)
>>> a.func(*a.args)
2*x
>>> a == a.func(*a.args)
True
"""
return self.__class__
@property
def args(self):
"""Returns a tuple of arguments of 'self'.
Examples
========
>>> cot(x).args
(x,)
>>> (x*y).args
(x, y)
"""
return self._args
@property
def _sorted_args(self):
"""
The same as ``args``. Derived classes which don't fix an
order on their arguments should override this method to
produce the sorted representation.
"""
return self.args
[docs] def subs(self, *args, **kwargs):
"""
Substitutes old for new in an expression after sympifying args.
`args` is either:
- 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
========
>>> (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 diofant.abc import e
>>> expr = sqrt(sin(2*x))*sin(exp(x)*x)*cos(2*x) + sin(2*x)
>>> expr.subs({sqrt(sin(2*x)): a, sin(2*x): b,
... cos(2*x): c, x: d, exp(x): 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(21, subs={x: 3.0}, strict=False)
0.333333333333333333333
rather than
>>> (1/x).subs({x: 3.0}).evalf(21, strict=False)
0.333333333333333
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
diofant.core.evalf.EvalfMixin.evalf: calculates the given formula to
a desired level of precision
"""
from ..utilities import default_sort_key
from .symbol import Dummy
unordered = False
if len(args) == 1:
sequence = args[0]
if isinstance(sequence, set):
unordered = True
elif isinstance(sequence, Mapping):
unordered = True
sequence = sequence.items()
elif not iterable(sequence):
raise ValueError("Expected a mapping or iterable "
"of (old, new) tuples.")
sequence = list(sequence)
else:
raise ValueError("subs accepts one argument")
sequence = [_ for _ in sympify(sequence) if not _aresame(*_)]
if unordered:
sequence = dict(sequence)
if not all(k.is_Atom for k in sequence):
d = defaultdict(list)
for o, n in sequence.items():
try:
ops = o.count_ops(), len(o.args)
except TypeError:
ops = (0, 0)
d[ops].append((o, n))
newseq = []
for k in sorted(d, reverse=True):
newseq.extend(sorted((v[0] for v in d[k]),
key=default_sort_key))
sequence = [(k, sequence[k]) for k in newseq]
del newseq, d
else:
sequence = sorted(((k, v) for (k, v) in sequence.items()),
key=default_sort_key)
if kwargs.pop('simultaneous', False): # XXX should this be the default for dict subs?
reps = {}
rv = self
m = Dummy()
for old, new in sequence:
d = Dummy(commutative=new.is_commutative)
# using d*m so Subs will be used on dummy variables
# in things like Derivative(f(x, y), x) in which x
# is both free and bound
rv = rv._subs(old, d*m, **kwargs)
reps[d] = new
reps[m] = S.One # get rid of m
return rv.xreplace(reps)
else:
rv = self
for old, new in sequence:
rv = rv._subs(old, new, **kwargs)
if not isinstance(rv, Basic):
break
return rv
@cacheit
def _subs(self, old, new, **hints):
"""Substitutes an expression old -> new.
If self is not equal to old then _eval_subs is called.
If _eval_subs doesn't want to make any special replacement
then a None is received which indicates that the fallback
should be applied wherein a search for replacements is made
amongst the arguments of self.
Examples
========
Add's _eval_subs knows how to target x + y in the following
so it makes the change:
>>> (x + y + z).subs({x + y: 1})
z + 1
Add's _eval_subs doesn't need to know how to find x + y in
the following:
>>> Add._eval_subs(z*(x + y) + 3, x + y, 1) is None
True
The returned None will cause the fallback routine to traverse the args and
pass the z*(x + y) arg to Mul where the change will take place and the
substitution will succeed:
>>> (z*(x + y) + 3).subs({x + y: 1})
z + 3
** Developers Notes **
An _eval_subs routine for a class should be written if:
1) any arguments are not instances of Basic (e.g. bool, tuple);
2) some arguments should not be targeted (as in integration
variables);
3) if there is something other than a literal replacement
that should be attempted (as in Piecewise where the condition
may be updated without doing a replacement).
If it is overridden, here are some special cases that might arise:
1) If it turns out that no special change was made and all
the original sub-arguments should be checked for
replacements then None should be returned.
2) If it is necessary to do substitutions on a portion of
the expression then _subs should be called. _subs will
handle the case of any sub-expression being equal to old
(which usually would not be the case) while its fallback
will handle the recursion into the sub-arguments. For
example, after Add's _eval_subs removes some matching terms
it must process the remaining terms so it calls _subs
on each of the un-matched terms and then adds them
onto the terms previously obtained.
3) If the initial expression should remain unchanged then
the original expression should be returned. (Whenever an
expression is returned, modified or not, no further
substitution of old -> new is attempted.) Sum's _eval_subs
routine uses this strategy when a substitution is attempted
on any of its summation variables.
"""
def fallback(self, old, new):
"""Try to replace old with new in any of self's arguments."""
hit = False
args = list(self.args)
for i, arg in enumerate(args):
arg = arg._subs(old, new, **hints)
if not _aresame(arg, args[i]):
hit = True
args[i] = arg
if hit:
return self.func(*args)
return self
if _aresame(self, old):
return new
rv = self._eval_subs(old, new)
if rv is None:
rv = fallback(self, old, new)
return rv
def _eval_subs(self, old, new):
"""Override this stub if you want to do anything more than
attempt a replacement of old with new in the arguments of self.
See also
========
_subs
"""
return
[docs] def xreplace(self, rule):
"""
Replace occurrences of objects within the expression.
Parameters
==========
rule : dict-like
Expresses a replacement rule
Returns
=======
xreplace : the result of the replacement
Examples
========
>>> (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})
E**y + x + 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:
>>> 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})
Traceback (most recent call last):
...
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.
"""
if self in rule:
return rule[self]
elif rule and not self.is_Atom:
args = tuple(a.xreplace(rule) for a in self.args)
if not _aresame(args, self.args):
return self.func(*args)
return self
[docs] @cacheit
def has(self, *patterns):
r"""Test if any subexpression matches any of the patterns.
Parameters
==========
\*patterns : tuple of Expr
List of expressions to search for match.
Returns
=======
bool
False if there is no match or patterns list is
empty, else True.
Examples
========
>>> e = x**2 + sin(x*y)
>>> e.has(z)
False
>>> e.has(x, y, z)
True
>>> x.has()
False
"""
from .function import UndefinedFunction, Function
if len(patterns) != 1:
return any(self.has(pattern) for pattern in patterns)
else:
pattern = sympify(patterns[0])
if isinstance(pattern, UndefinedFunction):
return any(pattern in (f, f.func)
for f in self.atoms(Function, UndefinedFunction))
elif isinstance(pattern, type):
return any(isinstance(arg, pattern)
for arg in preorder_traversal(self))
else:
match = pattern._has_matcher()
return any(match(arg) for arg in preorder_traversal(self))
def _has_matcher(self):
"""Helper for .has()."""
return lambda x: self == x
[docs] def replace(self, query, value, exact=False):
"""Replace matching subexpressions of ``self`` with ``value``.
Traverses an expression tree and performs replacement of matching
subexpressions from the bottom to the top of the tree in a simultaneous
fashion so changes made are targeted only once. 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
>>> 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))
>>> (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
"""
from ..simplify.simplify import bottom_up
try:
query = sympify(query)
except SympifyError:
pass
try:
value = sympify(value)
except SympifyError:
pass
if isinstance(query, type):
def _query(expr):
return isinstance(expr, query)
if isinstance(value, type) or callable(value):
def _value(expr, result):
return value(*expr.args)
else:
raise TypeError(
"given a type, replace() expects another "
"type or a callable")
elif isinstance(query, Basic):
def _query(expr):
return expr.match(query)
# XXX remove the exact flag and make multi-symbol
# patterns use exact=True semantics; to do this the query must
# be tested to find out how many Wild symbols are present.
# See https://groups.google.com/forum/
# ?fromgroups=#!topic/sympy/zPzo5FtRiqI
# for a method of inspecting a function to know how many
# parameters it has.
if isinstance(value, Basic):
if exact:
def _value(expr, result):
return (value.subs(result)
if all(val for val in result.values()) else expr)
else:
def _value(expr, result):
return value.subs(result)
elif callable(value):
# match dictionary keys get the trailing underscore stripped
# from them and are then passed as keywords to the callable;
# if ``exact`` is True, only accept match if there are no null
# values amongst those matched.
if exact:
def _value(expr, result):
return (value(**{str(key)[:-1]: val for key, val in result.items()})
if all(val for val in result.values()) else expr)
else:
def _value(expr, result):
return value(**{str(key)[:-1]: val for key, val in result.items()})
else:
raise TypeError(
"given an expression, replace() expects "
"another expression or a callable")
elif callable(query):
_query = query
if callable(value):
def _value(expr, result):
return value(expr)
else:
raise TypeError(
"given a callable, replace() expects "
"another callable")
else:
raise TypeError(
"first argument to replace() must be a "
"type, an expression or a callable")
def rec_replace(expr):
result = _query(expr)
if result or result == {}:
new = _value(expr, result)
if new is not None and new != expr:
expr = new
return expr
return bottom_up(self, rec_replace, atoms=True)
[docs] def find(self, query):
"""Find all subexpressions matching a query."""
try:
query = sympify(query)
except SympifyError:
pass
if isinstance(query, type):
def _query(expr):
return isinstance(expr, query)
elif isinstance(query, Basic):
def _query(expr):
return expr.match(query) is not None
else:
_query = query
groups = defaultdict(int)
for result in filter(_query, preorder_traversal(self)):
groups[result] += 1
return dict(groups)
[docs] def count(self, query):
"""Count the number of matching subexpressions."""
return sum(self.find(query).values())
def _matches(self, expr, repl_dict={}):
"""Helper method for match() that looks for a match between Wild
symbols in self and expressions in expr.
Examples
========
>>> 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}
"""
expr = sympify(expr)
if not isinstance(expr, self.func):
return
if self == expr:
return repl_dict
if self.is_Atom:
return
if len(self.args) != len(expr.args):
return
d = repl_dict.copy()
for arg, other_arg in zip(self.args, expr.args):
if arg == other_arg:
continue
d = arg.xreplace(d)._matches(other_arg, d)
if d is None:
return
return d
[docs] def match(self, pattern):
"""Pattern matching.
Wild symbols match all.
Parameters
==========
pattern : Expr
An expression that may contain Wild symbols.
Returns
=======
dict or None
If pattern match self, return a dictionary of
replacement rules, such that::
pattern.xreplace(self.match(pattern)) == self
Examples
========
>>> p = Wild("p")
>>> q = Wild("q")
>>> e = (x + y)**(x + y)
>>> e.match(p**p)
{p_: x + y}
>>> e.match(p**q)
{p_: x + y, q_: x + y}
>>> (p**q).xreplace(_)
(x + y)**(x + y)
See Also
========
xreplace
diofant.core.symbol.Wild
"""
from ..simplify import signsimp
pattern = sympify(pattern)
s = signsimp(self)
p = signsimp(pattern)
# if we still have the same relationship between the types of
# input, then use the sign simplified forms
if (pattern.func == self.func) and (s.func == p.func):
rv = p._matches(s)
else:
rv = pattern._matches(self)
return rv
[docs] def count_ops(self, visual=None):
"""wrapper for count_ops that returns the operation count."""
from .function import count_ops
return count_ops(self, visual)
[docs] def doit(self, **hints):
"""Evaluate objects that are not evaluated by default.
For example, 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'.
Examples
========
>>> 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)
"""
if hints.get('deep', True):
terms = [term.doit(**hints) if isinstance(term, Basic) else term
for term in self.args]
return self.func(*terms)
else:
return self
def _eval_rewrite(self, pattern, rule, **hints):
if self.is_Atom:
if hasattr(self, rule):
return getattr(self, rule)()
return self
if hints.get('deep', True):
args = [a._eval_rewrite(pattern, rule, **hints)
if isinstance(a, Basic) else a
for a in self.args]
else:
args = self.args
if pattern is None or isinstance(self, pattern):
if hasattr(self, rule):
rewritten = getattr(self, rule)(*args)
if rewritten is not None:
return rewritten
return self.func(*args)
[docs] def 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
========
Unspecified pattern:
>>> sin(x).rewrite(exp)
-I*(E**(I*x) - E**(-I*x))/2
Pattern as a single function:
>>> sin(x).rewrite(sin, exp)
-I*(E**(I*x) - E**(-I*x))/2
Pattern as a list of functions:
>>> sin(x).rewrite([sin], exp)
-I*(E**(I*x) - E**(-I*x))/2
"""
if not args:
return self
else:
pattern = args[:-1]
if isinstance(args[-1], str):
rule = '_eval_rewrite_as_' + args[-1]
else:
rule = '_eval_rewrite_as_' + args[-1].__name__
if not pattern:
return self._eval_rewrite(None, rule, **hints)
else:
if iterable(pattern[0]):
pattern = pattern[0]
pattern = [p for p in pattern if self.has(p)]
if pattern:
return self._eval_rewrite(tuple(pattern), rule, **hints)
else:
return self
[docs]class Atom(Basic):
"""A parent class for atomic things.
An atom is an expression with no subexpressions, for example Symbol,
Number, Rational or Integer, but not Add, Mul, Pow.
"""
is_Atom = True
[docs] def doit(self, **hints):
"""Evaluate objects that are not evaluated by default.
See Also
========
Basic.doit
"""
return self
[docs] @cacheit
def sort_key(self, order=None):
"""Return a sort key."""
from . import S
return self.class_key(), (1, (str(self),)), S.One.sort_key(), S.One
def _eval_simplify(self, ratio, measure):
return self
@property
def _sorted_args(self):
# this is here as a safeguard against accidentally using _sorted_args
# on Atoms -- they cannot be rebuilt as atom.func(*atom._sorted_args)
# since there are no args. So the calling routine should be checking
# to see that this property is not called for Atoms.
raise AttributeError('Atoms have no args. It might be necessary'
' to make a check for Atoms in the calling code.')
def _aresame(a, b):
"""Return True if a and b are structurally the same, else False.
Examples
========
To Diofant, 2.0 == 2:
>>> 2.0 == Integer(2)
True
Since a simple 'same or not' result is sometimes useful, this routine was
written to provide that query:
>>> _aresame(Float(2.0), Integer(2))
False
"""
from .function import AppliedUndef, UndefinedFunction as UndefFunc
for i, j in zip_longest(preorder_traversal(a), preorder_traversal(b)):
if i != j or type(i) != type(j):
if (isinstance(i, (UndefFunc, AppliedUndef)) and
isinstance(j, (UndefFunc, AppliedUndef))):
if i.class_key() != j.class_key():
return False
else:
return False
return True
[docs]class preorder_traversal:
"""Do a pre-order traversal of a tree.
This iterator recursively yields nodes that it has visited in a pre-order
fashion. That is, it yields the current node then descends through the
tree breadth-first to yield all of a node's children's pre-order
traversal.
For an expression, the order of the traversal depends on the order of
.args, which in many cases can be arbitrary.
Parameters
==========
node : diofant expression
The expression to traverse.
keys : (default None) sort key(s)
The key(s) used to sort args of Basic objects. When None, args of Basic
objects are processed in arbitrary order. If key is defined, it will
be passed along to ordered() as the only key(s) to use to sort the
arguments; if ``key`` is simply True then the default keys of ordered
will be used.
Yields
======
subtree : diofant expression
All of the subtrees in the tree.
Examples
========
The nodes are returned in the order that they are encountered unless key
is given; simply passing key=True will guarantee that the traversal is
unique.
>>> list(preorder_traversal((x + y)*z, keys=True))
[z*(x + y), z, x + y, x, y]
"""
def __init__(self, node, keys=None):
self._skip_flag = False
self._pt = self._preorder_traversal(node, keys)
def _preorder_traversal(self, node, keys):
yield node
if self._skip_flag:
self._skip_flag = False
return
if isinstance(node, Basic):
args = node.args
if keys:
args = ordered(args)
for arg in args:
for subtree in self._preorder_traversal(arg, keys):
yield subtree
elif iterable(node):
for item in node:
for subtree in self._preorder_traversal(item, keys):
yield subtree
[docs] def skip(self):
"""
Skip yielding current node's (last yielded node's) subtrees.
Examples
========
>>> pt = preorder_traversal((x+y*z)*z)
>>> for i in pt:
... print(i)
... if i == x + y*z:
... pt.skip()
z*(x + y*z)
z
x + y*z
"""
self._skip_flag = True
def __next__(self):
return next(self._pt)
def __iter__(self):
return self
```