class Symbol(AtomicExpr, Boolean):
"""
Assumptions:
commutative = True
You can override the default assumptions in the constructor:
>>> from sympy import symbols
>>> A,B = symbols('A,B', commutative = False)
>>> bool(A*B != B*A)
True
>>> bool(A*B*2 == 2*A*B) == True # multiplication by scalars is commutative
True
"""
is_comparable = False
__slots__ = ['name']
is_Symbol = True
@property
def _diff_wrt(self):
"""Allow derivatives wrt Symbols.
Examples
========
>>> from sympy import Symbol
>>> x = Symbol('x')
>>> x._diff_wrt
True
"""
return True
def __new__(cls, name, **assumptions):
"""Symbols are identified by name and assumptions::
>>> from sympy import Symbol
>>> Symbol("x") == Symbol("x")
True
>>> Symbol("x", real=True) == Symbol("x", real=False)
False
"""
if 'dummy' in assumptions:
SymPyDeprecationWarning(
feature="Symbol('x', dummy=True)",
useinstead="Dummy() or symbols(..., cls=Dummy)",
issue=3378, deprecated_since_version="0.7.0",
).warn()
if assumptions.pop('dummy'):
return Dummy(name, **assumptions)
if assumptions.get('zero', False):
return S.Zero
is_commutative = fuzzy_bool(assumptions.get('commutative', True))
if is_commutative is None:
raise ValueError(
'''Symbol commutativity must be True or False.''')
assumptions['commutative'] = is_commutative
return Symbol.__xnew_cached_(cls, name, **assumptions)
def __new_stage2__(cls, name, **assumptions):
assert isinstance(name, str), repr(type(name))
obj = Expr.__new__(cls)
obj.name = name
obj._assumptions = StdFactKB(assumptions)
return obj
__xnew__ = staticmethod(
__new_stage2__) # never cached (e.g. dummy)
__xnew_cached_ = staticmethod(
cacheit(__new_stage2__)) # symbols are always cached
def __getnewargs__(self):
return (self.name,)
def __getstate__(self):
return {'_assumptions': self._assumptions}
def _hashable_content(self):
return (self.name,) + tuple(sorted(self.assumptions0.iteritems()))
@property
def assumptions0(self):
return dict((key, value) for key, value
in self._assumptions.iteritems() if value is not None)
@cacheit
def sort_key(self, order=None):
return self.class_key(), (1, (str(self),)), S.One.sort_key(), S.One
def as_dummy(self):
return Dummy(self.name, **self.assumptions0)
def __call__(self, *args):
from function import Function
return Function(self.name)(*args)
def as_real_imag(self, deep=True, **hints):
if hints.get('ignore') == self:
return None
else:
return (C.re(self), C.im(self))
def _sage_(self):
import sage.all as sage
return sage.var(self.name)
def is_constant(self, *wrt, **flags):
if not wrt:
return False
return not self in wrt
@property
def is_number(self):
return False
@property
def free_symbols(self):
return set([self])
class Symbol(AtomicExpr, Boolean):
"""
Assumptions:
commutative = True
You can override the default assumptions in the constructor:
>>> from sympy import symbols
>>> A,B = symbols('A,B', commutative = False)
>>> bool(A*B != B*A)
True
>>> bool(A*B*2 == 2*A*B) == True # multiplication by scalars is commutative
True
"""
is_comparable = False
__slots__ = ['is_commutative', 'name']
is_Symbol = True
@property
def _diff_wrt(self):
"""Allow derivatives wrt Symbols.
Examples
========
>>> from sympy import Symbol
>>> x = Symbol('x')
>>> x._diff_wrt
True
"""
return True
def __new__(cls, name, commutative=True, **assumptions):
"""Symbols are identified by name and assumptions::
>>> from sympy import Symbol
>>> Symbol("x") == Symbol("x")
True
>>> Symbol("x", real=True) == Symbol("x", real=False)
False
"""
if 'dummy' in assumptions:
warnings.warn(
"\nThe syntax Symbol('x', dummy=True) is deprecated and will"
"\nbe dropped in a future version of Sympy. Please use Dummy()"
"\nor symbols(..., cls=Dummy) to create dummy symbols.",
SymPyDeprecationWarning)
if assumptions.pop('dummy'):
return Dummy(name, commutative, **assumptions)
return Symbol.__xnew_cached_(cls, name, commutative, **assumptions)
def __new_stage2__(cls, name, commutative=True, **assumptions):
assert isinstance(name, str), repr(type(name))
obj = Expr.__new__(cls, **assumptions)
obj.is_commutative = commutative
obj.name = name
return obj
__xnew__ = staticmethod(__new_stage2__) # never cached (e.g. dummy)
__xnew_cached_ = staticmethod(
cacheit(__new_stage2__)) # symbols are always cached
def __getnewargs__(self):
return (self.name, self.is_commutative)
def _hashable_content(self):
return (self.is_commutative, self.name)
@cacheit
def sort_key(self, order=None):
return self.class_key(), (1, (str(self), )), S.One.sort_key(), S.One
def as_dummy(self):
assumptions = self.assumptions0.copy()
assumptions.pop('commutative', None)
return Dummy(self.name, self.is_commutative, **assumptions)
def __call__(self, *args):
from function import Function
return Function(self.name, nargs=len(args))(*args, **self.assumptions0)
def as_real_imag(self, deep=True):
return (C.re(self), C.im(self))
def _eval_expand_complex(self, deep=True, **hints):
re, im = self.as_real_imag()
return re + im * S.ImaginaryUnit
def _sage_(self):
import sage.all as sage
return sage.var(self.name)
def is_constant(self, *wrt):
if not wrt:
return False
return not self in wrt
@property
def is_number(self):
return False
@property
def free_symbols(self):
return set([self])
class Symbol(Atom):
"""
Assumptions::
real = True
commutative = True
You can override the default assumptions in the constructor::
>>> A,B = symbols('AB', commutative = False)
>>> bool(A*B != B*A)
True
>>> bool(A*B*2 == 2*A*B) == True # multiplication by scalars is commutative
True
"""
is_comparable = False
__slots__ = ['is_commutative', 'name']
is_Symbol = True
def __new__(cls, name, commutative=True, dummy=False, **assumptions):
"""if dummy == True, then this Symbol is totally unique, i.e.::
>>> bool(Symbol("x") == Symbol("x")) == True
True
but with the dummy variable ::
>>> bool(Symbol("x", dummy = True) == Symbol("x", dummy = True)) == True
False
"""
# XXX compatibility stuff
if dummy == True:
return Dummy(name, commutative=commutative, **assumptions)
else:
return Symbol.__xnew_cached_(cls, name, commutative, **assumptions)
def __new_stage2__(cls, name, commutative=True, **assumptions):
assert isinstance(name, str), ` type(name) `
obj = Basic.__new__(cls, **assumptions)
obj.is_commutative = commutative
obj.name = name
return obj
__xnew__ = staticmethod(__new_stage2__) # never cached (e.g. dummy)
__xnew_cached_ = staticmethod(
cacheit(__new_stage2__)) # symbols are always cached
def __getnewargs__(self):
return (self.name, self.is_commutative)
def _hashable_content(self):
return (self.is_commutative, self.name)
def as_dummy(self):
return Dummy(self.name, **self.assumptions0)
def __call__(self, *args):
return Function(self.name, nargs=len(args))(*args, **self.assumptions0)
def _eval_expand_complex(self, *args):
return C.re(self) + C.im(self) * S.ImaginaryUnit
def _sage_(self):
import sage.all as sage
return sage.var(self.name)
@property
def is_number(self):
return False
