Source code for sympy.core.containers

"""Module for Sympy containers

    (Sympy objects that store other Sympy objects)

    The containers implemented in this module are subclassed to Basic.
    They are supposed to work seamlessly within the Sympy framework.
"""

from basic import Basic
from sympify import sympify

[docs]class Tuple(Basic): """ Wrapper around the builtin tuple object The Tuple is a subclass of Basic, so that it works well in the Sympy framework. The wrapped tuple is available as self.args, but you can also access elements or slices with [:] syntax. >>> from sympy import symbols >>> from sympy.core.containers import Tuple >>> a, b, c, d = symbols('a b c d') >>> Tuple(a, b, c)[1:] (b, c) >>> Tuple(a, b, c).subs(a, d) (d, b, c) """ def __new__(cls, *args, **assumptions): args = [ sympify(arg) for arg in args ] obj = Basic.__new__(cls, *args, **assumptions) return obj def __getitem__(self,i): if isinstance(i,slice): indices = i.indices(len(self)) return Tuple(*[self.args[i] for i in range(*indices)]) return self.args[i] def __len__(self): return len(self.args) def __contains__(self, item): return item in self.args def __iter__(self): return iter(self.args) def __add__(self, other): if isinstance(other, Tuple): return Tuple(*(self.args + other.args)) elif isinstance(other, tuple): return Tuple(*(self.args + other)) else: return NotImplemented def __radd__(self, other): if isinstance(other, Tuple): return Tuple(*(other.args + self.args)) elif isinstance(other, tuple): return Tuple(*(other + self.args)) else: return NotImplemented def __eq__(self, other): if isinstance(other, Basic): return super(Tuple, self).__eq__(other) return self.args == other def __ne__(self, other): if isinstance(other, Basic): return super(Tuple, self).__ne__(other) return self.args != other def __hash__(self): return hash(self.args) def _to_mpmath(self, prec): return tuple([a._to_mpmath(prec) for a in self.args])
def tuple_wrapper(method): """ Decorator that converts any tuple in the function arguments into a Tuple. The motivation for this is to provide simple user interfaces. The user can call a function with regular tuples in the argument, and the wrapper will convert them to Tuples before handing them to the function. >>> from sympy.core.containers import tuple_wrapper, Tuple >>> def f(*args): ... return args >>> g = tuple_wrapper(f) The decorated function g sees only the Tuple argument: >>> g(0, (1, 2), 3) (0, (1, 2), 3) """ def wrap_tuples(*args, **kw_args): newargs=[] for arg in args: if type(arg) is tuple: newargs.append(Tuple(*arg)) else: newargs.append(arg) return method(*newargs, **kw_args) return wrap_tuples