def __new__(cls, lhs, rhs, rop=None, **assumptions): lhs = Basic.sympify(lhs) rhs = Basic.sympify(rhs) if cls is not Relational: rop_cls = cls else: rop_cls, swap = Relational.get_relational_class(rop) if swap: lhs, rhs = rhs, lhs obj = Basic.__new__(rop_cls, lhs, rhs, **assumptions) return obj
def __new__(cls, a, b, **assumptions): a = Basic.sympify(a) b = Basic.sympify(b) if isinstance(b, Basic.Zero): return S.One if isinstance(b, Basic.One): return a obj = a._eval_power(b) if obj is None: obj = Basic.__new__(cls, a, b, **assumptions) return obj
def __add__(self, other): other = Basic.sympify(other) if isinstance(other, NaN) or isinstance(self, NaN): return S.NaN if isinstance(other, Number): return Real(self.num + other._as_decimal()) return Number.__add__(self, other)
def __le__(self, other): other = Basic.sympify(other) if self is other: return True if other.is_comparable: other = other.evalf() if isinstance(other, Number): return self.evalf()<=other return RelMeths.__le__(self, other)
def __new__(cls, expr, *symbols, **assumptions): expr = Basic.sympify(expr) if not symbols: return expr symbols = map(Basic.sympify, symbols) if not assumptions.get("evaluate", True): obj = Basic.__new__(cls, expr, *symbols) return obj for s in symbols: assert isinstance(s, Basic.Symbol),`s` if not expr.has(s): return Basic.Zero() unevaluated_symbols = [] for s in symbols: obj = expr._eval_derivative(s) if obj is None: unevaluated_symbols.append(s) else: expr = obj if not unevaluated_symbols: return expr return Basic.__new__(cls, expr, *unevaluated_symbols)
def matches(pattern, expr, repl_dict={}, evaluate=False): Basic.matches.__doc__ if evaluate: pat = pattern for old,new in repl_dict.items(): pat = pat.subs(old, new) if pat!=pattern: return pat.matches(expr, repl_dict) expr = Basic.sympify(expr) b, e = expr.as_base_exp() # special case, pattern = 1 and expr.exp can match to 0 if isinstance(expr, Basic.One): d = repl_dict.copy() d = pattern.exp.matches(Basic.Integer(0), d, evaluate=False) if d is not None: return d d = repl_dict.copy() d = pattern.base.matches(b, d, evaluate=False) if d is None: return None d = pattern.exp.matches(e, d, evaluate=True) if d is None: return Basic.matches(pattern, expr, repl_dict, evaluate) return d
def __le__(self, other): other = Basic.sympify(other) if isinstance(other, NumberSymbol): return other.__gt__(self) if other.is_comparable: other = other.evalf() if isinstance(other, Number): return bool(self._as_decimal()<=other._as_decimal()) return RelMeths.__le__(self, other)
def __ne__(self, other): other = Basic.sympify(other) if isinstance(other, NumberSymbol): if other.is_irrational: return True return other.__ne__(self) if other.is_comparable: other = other.evalf() if isinstance(other, Number): return bool(self._as_decimal()!=other._as_decimal()) return RelMeths.__ne__(self, other)
def __mul__(self, other): other = Basic.sympify(other) if isinstance(other, NaN) or isinstance(self, NaN): return S.NaN if isinstance(other, Real): return Real(self._as_decimal() * other.num) if isinstance(other, Rational): return Rational(self.p * other.p, self.q * other.q) return Number.__mul__(self, other)
def __new__(cls, name=None, exclude=None, **assumptions): assumptions["dummy"] = True if name is None: name = "W%s" % (Symbol.dummycount + 1) obj = Symbol.__new__(cls, name, **assumptions) if exclude is None: obj.exclude = None else: obj.exclude = [Basic.sympify(x) for x in exclude] return obj
def __le__(self, other): other = Basic.sympify(other) if isinstance(other, NumberSymbol): return other.__gt__(self) if other.is_comparable and not isinstance(other, Rational): other = other.evalf() if isinstance(other, Number): if isinstance(other, Real): return bool(self._as_decimal()<=other._as_decimal()) return bool(self.p * other.q <= self.q * other.p) return RelMeths.__le__(self, other)
def __eq__(self, other): other = Basic.sympify(other) if isinstance(other, NumberSymbol): if other.is_irrational: return False return other.__eq__(self) from sympy.core.function import FunctionClass if isinstance(self, Number) and isinstance(other, FunctionClass): return False if other.is_comparable and not isinstance(other, Rational): other = other.evalf() if isinstance(other, Number): if isinstance(other, Real): return bool(self._as_decimal()==other._as_decimal()) return bool(self.p==other.p and self.q==other.q) return RelMeths.__eq__(self, other)
def __lt__(self, other): other = Basic.sympify(other) if self is other: return False if isinstance(other, Number): approx = self.approximation_interval(other.__class__) if approx is not None: l,u = approx if other < l: return False if other > u: return True return self.evalf()<other if other.is_comparable: other = other.evalf() return self.evalf()<other return RelMeths.__lt__(self, other)
def diff(f, x, times = 1, evaluate=True): """Differentiate f with respect to x It's just a wrapper to unify .diff() and the Derivative class, it's interface is similar to that of integrate() see http://documents.wolfram.com/v5/Built-inFunctions/AlgebraicComputation/Calculus/D.html """ f = Basic.sympify(f) if evaluate == True: for i in range(0,times): f = f.diff(x) return f else: return Derivative(f, x, evaluate=evaluate)
def __new__(cls, expr, *args): expr = Basic.sympify(expr) args = tuple(map(Basic.sympify, args)) #if isinstance(expr, Apply): # if expr[:]==args: # return expr.func dummy_args = [] for a in args: if not isinstance(a, Basic.Symbol): raise TypeError("%s %s-th argument must be Symbol instance (got %r)" \ % (cls.__name__, len(dummy_args)+1,a)) d = a.as_dummy() expr = expr.subs(a, d) dummy_args.append(d) obj = Basic.__new__(cls, expr, *dummy_args, **expr._assumptions) return obj
def __add__(self, other): other = Basic.sympify(other) if isinstance(other, NaN) or isinstance(self, NaN): return S.NaN if isinstance(other, Real): return Real(self._as_decimal() + other.num) if isinstance(other, Rational): if self.is_unbounded: if other.is_bounded: return self elif self==other: return self else: if other.is_unbounded: return other return Rational(self.p * other.q + self.q * other.p, self.q * other.q) return Number.__add__(self, other)
def __new__(cls, *args, **assumptions): if len(args)==0: return cls.identity() if len(args)==1: return Basic.sympify(args[0]) c_part, nc_part, lambda_args, order_symbols = cls.flatten(map(Basic.sympify, args)) if len(c_part) + len(nc_part) <= 1: if c_part: obj = c_part[0] elif nc_part: obj = nc_part[0] else: obj = cls.identity() else: assumptions['commutative'] = not nc_part obj = Basic.__new__(cls, *(c_part + nc_part), **assumptions) if order_symbols is not None: obj = Basic.Order(obj, *order_symbols) if lambda_args is not None: obj = Basic.Lambda(obj, *lambda_args) return obj
def matches(pattern, expr, repl_dict={}, evaluate=False): expr = Basic.sympify(expr) if pattern.is_commutative and expr.is_commutative: return AssocOp._matches_commutative(pattern, expr, repl_dict, evaluate) # todo for commutative parts, until then use the default matches method for non-commutative products return Basic.matches(pattern, expr, repl_dict, evaluate)
def __rsub__(self, other): return Basic.sympify(other).__sub__(self)
def taylor_term(self, n, x, *previous_terms): # of (1+x)**e if n<0: return S.Zero x = Basic.sympify(x) return Basic.Binomial(self.exp, n) * x**n
def __rmul__(self, other): return Basic.sympify(other).__mul__(self)
def __rpow__(self, other): return Basic.sympify(other).__pow__(self)
def __div__(self, other): return self * (Basic.sympify(other) ** Basic.Integer(-1))
def __rdiv__(self, other): return Basic.sympify(other).__div__(self)
def __ne__(self, other): other = Basic.sympify(other) if self is other: return False if isinstance(other, Number) and self.is_irrational: return True return RelMeths.__ne__(self, other)
def __sub__(self, other): return self + (-Basic.sympify(other))
def __ge__(self, other): return Basic.sympify(other).__le__(self)
def __mul__(self, other): other = Basic.sympify(other) if isinstance(other, Number): return Real(self.num * other._as_decimal()) return Number.__mul__(self, other)
def __new__(cls, start, end, **assumptions): start = Basic.sympify(start) end = Basic.sympify(end) return Basic.__new__(cls, start, end, **assumptions)
def __radd__(self, other): return Basic.sympify(other).__add__(self)