Coverage for sympy/core/basic.py : 54%

"""Base class for all the objects in SymPy""" 

from __future__ import print_function, division 

from collections import Mapping 

from .assumptions import BasicMeta, ManagedProperties 

from .cache import cacheit 

from .sympify import _sympify, sympify, SympifyError 

from .compatibility import (iterable, Iterator, ordered, 

string_types, with_metaclass, zip_longest, range) 

from .singleton import S 

from inspect import getmro 

class Basic(with_metaclass(ManagedProperties)): 

""" 

Base class for all objects in SymPy. 

Conventions: 

1) Always use ``.args``, when accessing parameters of some instance: 

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

2) Never use internal methods or variables (the ones prefixed with ``_``): 

>>> cot(x)._args # do not use this, use cot(x).args instead 

(x,) 

""" 

__slots__ = ['_mhash', # hash value 

'_args', # arguments 

'_assumptions' 

] 

# To be overridden with True in the appropriate subclasses 

is_number = False 

is_Atom = False 

is_Symbol = False 

is_Indexed = 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_AlgebraicNumber = False 

is_Relational = False 

is_Equality = False 

is_Boolean = False 

is_Not = False 

is_Matrix = False 

is_Vector = False 

is_Point = False 

def __new__(cls, *args): 

obj = object.__new__(cls) 

obj._assumptions = cls.default_assumptions 

obj._mhash = None # will be set by __hash__ method. 

obj._args = args # all items in args must be Basic objects 

return obj 

def copy(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 

@property 

def assumptions0(self): 

""" 

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} 

""" 

return {} 

def 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 

""" 

# all redefinitions of __cmp__ method should start with the 

# following lines: 

if self is other: 

return 0 

n1 = self.__class__ 

n2 = other.__class__ 

c = (n1 > n2) - (n1 < n2) 

if c: 

return c 

# 

st = self._hashable_content() 

ot = other._hashable_content() 

c = (len(st) > len(ot)) - (len(st) < len(ot)) 

if c: 

return c 

for l, r in zip(st, ot): 

l = Basic(*l) if isinstance(l, frozenset) else l 

r = Basic(*r) if isinstance(r, frozenset) else r 

if isinstance(l, Basic): 

c = l.compare(r) 

else: 

c = (l > r) - (l < r) 

if c: 

return c 

return 0 

@staticmethod 

def _compare_pretty(a, b): 

from sympy.series.order import Order 

if isinstance(a, Order) and not isinstance(b, Order): 

return 1 

if not isinstance(a, Order) and isinstance(b, Order): 

return -1 

if a.is_Rational and b.is_Rational: 

l = a.p * b.q 

r = b.p * a.q 

return (l > r) - (l < r) 

else: 

from sympy.core.symbol import Wild 

p1, p2, p3 = Wild("p1"), Wild("p2"), Wild("p3") 

r_a = a.match(p1 * p2**p3) 

if r_a and p3 in r_a: 

a3 = r_a[p3] 

r_b = b.match(p1 * p2**p3) 

if r_b and p3 in r_b: 

b3 = r_b[p3] 

c = Basic.compare(a3, b3) 

if c != 0: 

return c 

return Basic.compare(a, b) 

@classmethod 

def fromiter(cls, args, **assumptions): 

""" 

Create a new object from an iterable. 

This is a convenience function that allows one to create objects from 

any iterable, without having to convert to a list or tuple first. 

Examples 

======== 

>>> from sympy import Tuple 

>>> Tuple.fromiter(i for i in range(5)) 

(0, 1, 2, 3, 4) 

""" 

return cls(*tuple(args), **assumptions) 

@classmethod 

def class_key(cls): 

"""Nice order of classes. """ 

return 5, 0, cls.__name__ 

@cacheit 

def sort_key(self, order=None): 

""" 

Return a sort key. 

Examples 

======== 

>>> from sympy.core import S, I 

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

[1/2, -I, I] 

>>> S("[x, 1/x, 1/x**2, x**2, x**(1/2), x**(1/4), x**(3/2)]") 

[x, 1/x, x**(-2), x**2, sqrt(x), x**(1/4), x**(3/2)] 

>>> sorted(_, key=lambda x: x.sort_key()) 

[x**(-2), 1/x, x**(1/4), sqrt(x), x, x**(3/2), x**2] 

""" 

# XXX: remove this when issue 5169 is fixed 

def inner_key(arg): 

if isinstance(arg, Basic): 

return arg.sort_key(order) 

else: 

return arg 

args = self._sorted_args 

args = len(args), tuple([inner_key(arg) for arg in args]) 

return self.class_key(), args, S.One.sort_key(), S.One 

def __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__ 

""" 

from sympy import Pow 

if self is other: 

return True 

from .function import AppliedUndef, UndefinedFunction as UndefFunc 

if isinstance(self, UndefFunc) and isinstance(other, UndefFunc): 

if self.class_key() == other.class_key(): 

return True 

else: 

return False 

if type(self) is not type(other): 

# issue 6100 a**1.0 == a like a**2.0 == a**2 

if isinstance(self, Pow) and self.exp == 1: 

return self.base == other 

if isinstance(other, Pow) and other.exp == 1: 

return self == other.base 

try: 

other = _sympify(other) 

except SympifyError: 

return False # sympy != other 

if isinstance(self, AppliedUndef) and isinstance(other, 

AppliedUndef): 

if self.class_key() != other.class_key(): 

return False 

elif type(self) is not type(other): 

return False 

return self._hashable_content() == other._hashable_content() 

def __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 

""" 

return not self.__eq__(other) 

def 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 

""" 

dummy_symbols = [s for s in self.free_symbols if s.is_Dummy] 

if not dummy_symbols: 

return self == other 

elif len(dummy_symbols) == 1: 

dummy = dummy_symbols.pop() 

else: 

raise ValueError( 

"only one dummy symbol allowed on the left-hand side") 

if symbol is None: 

symbols = other.free_symbols 

if not symbols: 

return self == other 

elif len(symbols) == 1: 

symbol = symbols.pop() 

else: 

raise ValueError("specify a symbol in which expressions should be compared") 

tmp = dummy.__class__() 

return self.subs(dummy, tmp) == other.subs(symbol, tmp) 

# Note, we always use the default ordering (lex) in __str__ and __repr__, 

# regardless of the global setting. See issue 5487. 

def __repr__(self): 

from sympy.printing import sstr 

return sstr(self, order=None) 

def __str__(self): 

from sympy.printing import sstr 

return sstr(self, order=None) 

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 

======== 

>>> from sympy import I, pi, sin 

>>> from sympy.abc import x, y 

>>> (1 + x + 2*sin(y + I*pi)).atoms() 

set([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) 

set([x, y]) 

>>> (1 + x + 2*sin(y + I*pi)).atoms(Number) 

set([1, 2]) 

>>> (1 + x + 2*sin(y + I*pi)).atoms(Number, NumberSymbol) 

set([1, 2, pi]) 

>>> (1 + x + 2*sin(y + I*pi)).atoms(Number, NumberSymbol, I) 

set([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 

set([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)) 

set([1]) 

>>> (1 + x + 2*sin(y + I*pi)).atoms(S(2)) 

set([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) 

set([f(x), sin(y + I*pi)]) 

>>> (1 + f(x) + 2*sin(y + I*pi)).atoms(AppliedUndef) 

set([f(x)]) 

>>> (1 + x + 2*sin(y + I*pi)).atoms(Mul) 

set([I*pi, 2*sin(y + I*pi)]) 

""" 

if types: 

types = tuple( 

[t if isinstance(t, type) else type(t) for t in types]) 

else: 

types = (Atom,) 

result = set() 

for expr in preorder_traversal(self): 

if isinstance(expr, types): 

result.add(expr) 

return result 

@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]) 

@property 

def canonical_variables(self): 

"""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_} 

""" 

from sympy import Symbol 

if not hasattr(self, 'variables'): 

return {} 

u = "_" 

while any(s.name.endswith(u) for s in self.free_symbols): 

u += "_" 

name = '%%i%s' % u 

V = self.variables 

return dict(list(zip(V, [Symbol(name % i, **v.assumptions0) 

for i, v in enumerate(V)]))) 

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

""" 

return Basic._recursive_call(self, args) 

@staticmethod 

def _recursive_call(expr_to_call, on_args): 

from sympy import Symbol 

def the_call_method_is_overridden(expr): 

for cls in getmro(type(expr)): 

if '__call__' in cls.__dict__: 

return cls != Basic 

if callable(expr_to_call) and the_call_method_is_overridden(expr_to_call): 

if isinstance(expr_to_call, Symbol): # XXX When you call a Symbol it is 

return expr_to_call # transformed into an UndefFunction 

else: 

return expr_to_call(*on_args) 

elif expr_to_call.args: 

args = [Basic._recursive_call( 

sub, on_args) for sub in expr_to_call.args] 

return type(expr_to_call)(*args) 

else: 

return expr_to_call 

def is_hypergeometric(self, k): 

from sympy.simplify import hypersimp 

return hypersimp(self, k) is not None 

@property 

def is_comparable(self): 

"""Return True if self can be computed to a real number 

(or already is a real number) with precision, else False. 

Examples 

======== 

>>> from sympy import exp_polar, pi, I 

>>> (I*exp_polar(I*pi/2)).is_comparable 

True 

>>> (I*exp_polar(I*pi*2)).is_comparable 

False 

A False result does not mean that `self` cannot be rewritten 

into a form that would be comparable. For example, the 

difference computed below is zero but without simplification 

it does not evaluate to a zero with precision: 

>>> e = 2**pi*(1 + 2**pi) 

>>> dif = e - e.expand() 

>>> dif.is_comparable 

False 

>>> dif.n(2)._prec 

1 

""" 

is_real = self.is_real 

if is_real is False: 

return False 

is_number = self.is_number 

if is_number is False: 

return False 

n, i = [p.evalf(2) if not p.is_Number else p 

for p in self.as_real_imag()] 

if not i.is_Number or not n.is_Number: 

return False 

if i: 

# if _prec = 1 we can't decide and if not, 

# the answer is False because numbers with 

# imaginary parts can't be compared 

# so return False 

return False 

else: 

return n._prec != 1 

@property 

def func(self): 

""" 

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 

""" 

return self.__class__ 

@property 

def args(self): 

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

""" 

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 

def 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 

""" 

from sympy.polys import Poly, PolynomialError 

try: 

poly = Poly(self, *gens, **args) 

if not poly.is_Poly: 

return None 

else: 

return poly 

except PolynomialError: 

return None 

def as_content_primitive(self, radical=False, clear=True): 

"""A stub to allow Basic args (like Tuple) to be skipped when computing 

the content and primitive components of an expression. 

See docstring of Expr.as_content_primitive 

""" 

return S.One, self 

def 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 

""" 

from sympy.core.containers import Dict 

from sympy.utilities import default_sort_key 

from sympy import Dummy, Symbol 

unordered = False 

if len(args) == 1: 

sequence = args[0] 

if isinstance(sequence, set): 

unordered = True 

elif isinstance(sequence, (Dict, Mapping)): 

unordered = True 

sequence = sequence.items() 

elif not iterable(sequence): 

from sympy.utilities.misc import filldedent 

raise ValueError(filldedent(""" 

When a single argument is passed to subs 

it should be a dictionary of old: new pairs or an iterable 

of (old, new) tuples.""")) 

elif len(args) == 2: 

sequence = [args] 

else: 

raise ValueError("subs accepts either 1 or 2 arguments") 

sequence = list(sequence) 

for i in range(len(sequence)): 

s = list(sequence[i]) 

for j, si in enumerate(s): 

try: 

si = sympify(si, strict=True) 

except SympifyError: 

if type(si) is str: 

si = Symbol(si) 

else: 

# if it can't be sympified, skip it 

sequence[i] = None 

break 

s[j] = si 

else: 

sequence[i] = None if _aresame(*s) else tuple(s) 

sequence = list(filter(None, sequence)) 

if unordered: 

sequence = dict(sequence) 

if not all(k.is_Atom for k in sequence): 

d = {} 

for o, n in sequence.items(): 

try: 

ops = o.count_ops(), len(o.args) 

except TypeError: 

ops = (0, 0) 

d.setdefault(ops, []).append((o, n)) 

newseq = [] 

for k in sorted(d.keys(), reverse=True): 

newseq.extend(