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 .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
[docs] def copy(self): """Return swallow copy of self.""" return self.func(*self.args)
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] @classmethod def class_key(cls): """Nice order of classes.""" return 5, 0, cls.__name__
[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, sqrt(x), root(x, 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] """ from .numbers import Integer args = len(self.args), tuple(arg.sort_key(order) for arg in self._sorted_args) return self.class_key(), args, Integer(1).sort_key(), Integer(1)
@_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 ========== * """ 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 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 .numbers import Integer 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] = Integer(1) # 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 # ?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] @classmethod def class_key(cls): """Nice order of classes.""" return 2, 0, cls.__name__
[docs] @cacheit def sort_key(self, order=None): """Return a sort key.""" from . import Integer return self.class_key(), (1, (str(self),)), Integer(1).sort_key(), Integer(1)
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