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