def __new__(cls, lhs, rhs, rop=None, **assumptions): lhs = _sympify(lhs) rhs = _sympify(rhs) if cls is not Relational: rop_cls = cls else: try: rop_cls = Relational.ValidRelationOperator[rop] except KeyError: msg = "Invalid relational operator symbol: '%r'" raise ValueError(msg % repr(rop)) if lhs.is_number and rhs.is_number and (rop_cls in (Equality, Unequality) or lhs.is_real and rhs.is_real): diff = lhs - rhs know = diff.equals(0, failing_expression=True) if know is True: # exclude failing expression case Nlhs = S.Zero elif know is False: from sympy import sign Nlhs = sign(diff.n(1)) else: Nlhs = None lhs = know rhs = S.Zero if Nlhs is not None: return rop_cls._eval_relation(Nlhs, S.Zero) obj = Expr.__new__(rop_cls, lhs, rhs, **assumptions) return obj
def __new__(cls, start, end, left_open=False, right_open=False): start = _sympify(start) end = _sympify(end) # Only allow real intervals (use symbols with 'is_real=True'). if not start.is_real or not end.is_real: raise ValueError("Only real intervals are supported") # Make sure that the created interval will be valid. if end.is_comparable and start.is_comparable: if end < start: return S.EmptySet if end == start and (left_open or right_open): return S.EmptySet if end == start and not (left_open or right_open): return FiniteSet(end) # Make sure infinite interval end points are open. if start == S.NegativeInfinity: left_open = True if end == S.Infinity: right_open = True return Basic.__new__(cls, start, end, left_open, right_open)
def __new__(cls, lhs, rhs, rop=None, **assumptions): lhs = _sympify(lhs) rhs = _sympify(rhs) if cls is not Relational: rop_cls = cls else: try: rop_cls = Relational.ValidRelationOperator[rop] except KeyError: msg = "Invalid relational operator symbol: '%r'" raise ValueError(msg % repr(rop)) if (lhs.is_number and rhs.is_number and (rop_cls in (Equality, Unequality) or lhs.is_real and rhs.is_real)): diff = lhs - rhs know = diff.equals(0, failing_expression=True) if know is True: # exclude failing expression case Nlhs = S.Zero elif know is False: from sympy import sign Nlhs = sign(diff.n(2)) else: Nlhs = None lhs = know rhs = S.Zero if Nlhs is not None: return rop_cls._eval_relation(Nlhs, S.Zero) obj = Expr.__new__(rop_cls, lhs, rhs, **assumptions) return obj
def compare_pretty(a, b): """ Is a > b in the sense of ordering in printing? :: yes ..... return 1 no ...... return -1 equal ... return 0 Strategy: It uses Basic.compare as a fallback, but improves it in many cases, like ``x**3``, ``x**4``, ``O(x**3)`` etc. In those simple cases, it just parses the expression and returns the "sane" ordering such as:: 1 < x < x**2 < x**3 < O(x**4) etc. Examples ======== >>> from sympy.abc import x >>> from sympy import Basic, Number >>> Basic._compare_pretty(x, x**2) -1 >>> Basic._compare_pretty(x**2, x**2) 0 >>> Basic._compare_pretty(x**3, x**2) 1 >>> Basic._compare_pretty(Number(1, 2), Number(1, 3)) 1 >>> Basic._compare_pretty(Number(0), Number(-1)) 1 """ try: a = _sympify(a) except SympifyError: pass try: b = _sympify(b) except SympifyError: pass # both objects are non-SymPy if (not isinstance(a, Basic)) and (not isinstance(b, Basic)): return cmp(a, b) if not isinstance(a, Basic): return -1 # other < sympy if not isinstance(b, Basic): return +1 # sympy > other # now both objects are from SymPy, so we can proceed to usual comparison return cmp(a.sort_key(), b.sort_key())
def compare_pretty(a, b): """ Is a > b in the sense of ordering in printing? :: yes ..... return 1 no ...... return -1 equal ... return 0 Strategy: It uses Basic.compare as a fallback, but improves it in many cases, like x**3, x**4, O(x**3) etc. In those simple cases, it just parses the expression and returns the "sane" ordering such as:: 1 < x < x**2 < x**3 < O(x**4) etc. Examples ======== >>> from sympy.abc import x >>> from sympy import Basic, Number >>> Basic._compare_pretty(x, x**2) -1 >>> Basic._compare_pretty(x**2, x**2) 0 >>> Basic._compare_pretty(x**3, x**2) 1 >>> Basic._compare_pretty(Number(1, 2), Number(1, 3)) 1 >>> Basic._compare_pretty(Number(0), Number(-1)) 1 """ try: a = _sympify(a) except SympifyError: pass try: b = _sympify(b) except SympifyError: pass # both objects are non-SymPy if (not isinstance(a, Basic)) and (not isinstance(b, Basic)): return cmp(a,b) if not isinstance(a, Basic): return -1 # other < sympy if not isinstance(b, Basic): return +1 # sympy > other # now both objects are from SymPy, so we can proceed to usual comparison return cmp(a.sort_key(), b.sort_key())
def __new__(cls, lhs, rhs, rop=None, **assumptions): lhs = _sympify(lhs) rhs = _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, lhs, rhs, rop=None, **assumptions): lhs = _sympify(lhs) rhs = _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 if lhs.is_real and lhs.is_number and rhs.is_real and rhs.is_number: return rop_cls._eval_relation(lhs.evalf(), rhs.evalf()) else: obj = Expr.__new__(rop_cls, lhs, rhs, **assumptions) return obj
def __new__(cls, a, b, **assumptions): a = _sympify(a) b = _sympify(b) if assumptions.get("evaluate") is False: return Basic.__new__(cls, a, b, **assumptions) if b is S.Zero: return S.One if b is S.One: return a obj = a._eval_power(b) if obj is None: obj = Basic.__new__(cls, a, b, **assumptions) obj.is_commutative = a.is_commutative and b.is_commutative return obj
def __new__(cls, b, e, **assumptions): b = _sympify(b) e = _sympify(e) if assumptions.get("evaluate") is False: return Basic.__new__(cls, b, e, **assumptions) if e is S.Zero: return S.One if e is S.One: return b obj = b._eval_power(e) if obj is None: obj = Basic.__new__(cls, b, e, **assumptions) obj.is_commutative = b.is_commutative and e.is_commutative return obj
def __new__(cls, a, b, **assumptions): a = _sympify(a) b = _sympify(b) if assumptions.get('evaluate') is False: return Basic.__new__(cls, a, b, **assumptions) if b is S.Zero: return S.One if b is S.One: return a obj = a._eval_power(b) if obj is None: obj = Basic.__new__(cls, a, b, **assumptions) obj.is_commutative = (a.is_commutative and b.is_commutative) return obj
def __new__(cls, b, e, **assumptions): b = _sympify(b) e = _sympify(e) if assumptions.get('evaluate') is False: return Basic.__new__(cls, b, e, **assumptions) if e is S.Zero: return S.One if e is S.One: return b obj = b._eval_power(e) if obj is None: obj = Basic.__new__(cls, b, e, **assumptions) obj.is_commutative = (b.is_commutative and e.is_commutative) return obj
def __new__(cls, b, e, **assumptions): b = _sympify(b) e = _sympify(e) if assumptions.pop('evaluate', True): if e is S.Zero: return S.One elif e is S.One: return b else: obj = b._eval_power(e) if obj is not None: return obj obj = Expr.__new__(cls, b, e, **assumptions) obj.is_commutative = (b.is_commutative and e.is_commutative) return obj
def __new__(cls, b, e, evaluate=True): b = _sympify(b) e = _sympify(e) if evaluate: if e is S.Zero: return S.One elif e is S.One: return b else: obj = b._eval_power(e) if obj is not None: return obj obj = Expr.__new__(cls, b, e) obj.is_commutative = (b.is_commutative and e.is_commutative) return obj
def __new__(cls, lhs, rhs, rop=None, **assumptions): lhs = _sympify(lhs) rhs = _sympify(rhs) if cls is not Relational: rop_cls = cls else: try: rop_cls = Relational.ValidRelationOperator[ rop ] except KeyError: msg = "Invalid relational operator symbol: '%r'" raise ValueError(msg % repr(rop)) diff = S.NaN if isinstance(lhs, Expr) and isinstance(rhs, Expr): diff = lhs - rhs if not (diff is S.NaN or diff.has(Symbol)): know = diff.equals(0, failing_expression=True) if know is True: # exclude failing expression case diff = S.Zero elif know is False: diff = diff.n() if rop_cls is Equality: if (lhs == rhs) is True or (diff == S.Zero) is True: return True elif diff is S.NaN: pass elif diff.is_Number or diff.is_Float: return False elif lhs.is_real is not rhs.is_real and \ lhs.is_real is not None and \ rhs.is_real is not None: return False elif rop_cls is Unequality: if (lhs == rhs) is True or (diff == S.Zero) is True: return False elif diff is S.NaN: pass elif diff.is_Number or diff.is_Float: return True elif lhs.is_real is not rhs.is_real and \ lhs.is_real is not None and \ rhs.is_real is not None: return True elif diff.is_Number and diff.is_real: return rop_cls._eval_relation(diff, S.Zero) obj = Expr.__new__(rop_cls, lhs, rhs, **assumptions) return obj
def __new__(cls, lhs, rhs, rop=None, **assumptions): lhs = _sympify(lhs) rhs = _sympify(rhs) if cls is not Relational: rop_cls = cls else: try: rop_cls = cls.ValidRelationOperator[ rop ] except KeyError: msg = "Invalid relational operator symbol: '%r'" raise ValueError(msg % repr(rop)) diff = S.NaN if isinstance(lhs, Expr) and isinstance(rhs, Expr): diff = lhs - rhs if not (diff is S.NaN or diff.has(Symbol)): know = diff.equals(0, failing_expression=True) if know is True: # exclude failing expression case diff = S.Zero elif know is False: diff = diff.n() if rop_cls is Equality: if (lhs == rhs) is True or (diff == S.Zero) is True: return True elif diff is S.NaN: pass elif diff.is_Number or diff.is_Float: return False elif lhs.is_real is not rhs.is_real and \ lhs.is_real is not None and \ rhs.is_real is not None: return False elif rop_cls is Unequality: if (lhs == rhs) is True or (diff == S.Zero) is True: return False elif diff is S.NaN: pass elif diff.is_Number or diff.is_Float: return True elif lhs.is_real is not rhs.is_real and \ lhs.is_real is not None and \ rhs.is_real is not None: return True elif diff.is_Number and diff.is_real: return rop_cls._eval_relation(diff, S.Zero) obj = Expr.__new__(rop_cls, lhs, rhs, **assumptions) return obj
def __new__(cls, *args, **assumptions): if assumptions.get('evaluate') is False: args = map(_sympify, args) obj = Expr.__new__(cls, *args, **assumptions) obj.is_commutative = all(arg.is_commutative for arg in args) return obj if len(args)==0: return cls.identity if len(args)==1: return _sympify(args[0]) c_part, nc_part, order_symbols = cls.flatten(map(_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: obj = Expr.__new__(cls, *(c_part + nc_part), **assumptions) obj.is_commutative = not nc_part if order_symbols is not None: obj = C.Order(obj, *order_symbols) return obj
def __eq__(self, other): """a == b -> Compare two symbolic trees and see whether they are equal this is the same as: a.compare(b) == 0 but faster """ if type(self) is not type(other): # issue 3001 a**1.0 == a like a**2.0 == a**2 while isinstance(self, C.Pow) and self.exp == 1: self = self.base while isinstance(other, C.Pow) and other.exp == 1: other = other.base try: other = _sympify(other) except SympifyError: return False # sympy != other if type(self) is not type(other): return False # type(self) == type(other) st = self._hashable_content() ot = other._hashable_content() return st == ot and self._assume_type_keys == other._assume_type_keys
def matches(self, expr, repl_dict={}, old=False): expr = _sympify(expr) # special case, pattern = 1 and expr.exp can match to 0 if expr is S.One: d = repl_dict.copy() d = self.exp.matches(S.Zero, d) if d is not None: return d b, e = expr.as_base_exp() # special case number sb, se = self.as_base_exp() if sb.is_Symbol and se.is_Integer and expr: if e.is_rational: return sb.matches(b**(e/se), repl_dict) return sb.matches(expr**(1/se), repl_dict) d = repl_dict.copy() d = self.base.matches(b, d) if d is None: return None d = self.exp.xreplace(d).matches(e, d) if d is None: return Expr.matches(self, expr, repl_dict) return d
def matches(pattern, expr, repl_dict={}, evaluate=False): 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 = _sympify(expr) b, e = expr.as_base_exp() # special case, pattern = 1 and expr.exp can match to 0 if expr is S.One: d = repl_dict.copy() d = pattern.exp.matches(S.Zero, 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 __eq__(self, other): """a == b -> Compare two symbolic trees and see whether they are equal this is the same as: a.compare(b) == 0 but faster """ if type(self) is not type(other): # issue 3001 a**1.0 == a like a**2.0 == a**2 while isinstance(self, C.Pow) and self.exp == 1: self = self.base while isinstance(other, C.Pow) and other.exp == 1: other = other.base try: other = _sympify(other) except SympifyError: return False # sympy != other if type(self) is not type(other): return False return self._hashable_content() == other._hashable_content()
def matches(pattern, expr, repl_dict={}, evaluate=False): 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 = _sympify(expr) b, e = expr.as_base_exp() # special case, pattern = 1 and expr.exp can match to 0 if expr is S.One: d = repl_dict.copy() d = pattern.exp.matches(S.Zero, 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 __ne__(self, other): try: other = _sympify(other) except SympifyError: return True # sympy != other if self is other: return False if isinstance(other, Number) and self.is_irrational: return True return True # NumberSymbol != non(Number|self)
def __mul__(self, other): try: other = _sympify(other) except SympifyError: return NotImplemented if isinstance(other, Number): rhs, prec = other._as_mpf_op(self._prec) return Real._new(mlib.mpf_mul(self._mpf_, rhs, prec, rnd), prec) return Number.__mul__(self, other)
def __new__(cls, lhs, rhs, rop=None, **assumptions): lhs = _sympify(lhs) rhs = _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 if lhs.is_real and lhs.is_number and rhs.is_real and rhs.is_number: # Just becase something is a number, doesn't mean you can evalf it. Nlhs = lhs.evalf() if Nlhs.is_Number: # S.Zero.evalf() returns S.Zero, so test Number instead of Float Nrhs = rhs.evalf() if Nrhs.is_Number: return rop_cls._eval_relation(Nlhs, Nrhs) obj = Expr.__new__(rop_cls, lhs, rhs, **assumptions) return obj
def __new__(cls, lhs, rhs, rop=None, **assumptions): lhs = _sympify(lhs) rhs = _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 if lhs.is_number and rhs.is_number and lhs.is_real and rhs.is_real: # Just becase something is a number, doesn't mean you can evalf it. Nlhs = lhs.evalf() if Nlhs.is_Number: # S.Zero.evalf() returns S.Zero, so test Number instead of Float Nrhs = rhs.evalf() if Nrhs.is_Number: return rop_cls._eval_relation(Nlhs, Nrhs) obj = Expr.__new__(rop_cls, lhs, rhs, **assumptions) return obj
def __le__(self, other): try: other = _sympify(other) except SympifyError: return False # sympy > other --> not <= if self is other: return True if other.is_comparable: other = other.evalf() if isinstance(other, Number): return self.evalf()<=other return Basic.__le__(self, other)
def gcdex(a, b): """Extended Euclidean Algorithm. """ if isinstance(b, (int, long)): return tuple(map(Integer, igcdex(int(a), b))) else: b = _sympify(b) if b.is_Integer: return tuple(map(Integer, igcdex(int(a), int(b)))) else: raise ValueError("expected an integer, got %s" % b)
def lcm(a, b): """Returns least common multiple of input arguments. """ if type(b) is int: return Integer(ilcm(int(a), b)) else: b = _sympify(b) if b.is_Integer: return Integer(ilcm(int(a), int(b))) else: raise ValueError("expected an integer, got %s" % b)
def gcd(a, b): """Returns greates common divisor of input arguments. """ if type(b) is int: return Integer(igcd(int(a), b)) else: b = _sympify(b) if b.is_Integer: return Integer(igcd(int(a), int(b))) else: raise ValueError("expected an integer, got %s" % b)
def gcdex(a, b): """Extended Euclidean Algorithm. """ if type(b) is int: return tuple(map(Integer, igcdex(int(a), b))) else: b = _sympify(b) if b.is_Integer: return tuple(map(Integer, igcdex(int(a), int(b)))) else: raise ValueError("expected an integer, got %s" % b)
def __le__(self, other): try: other = _sympify(other) except SympifyError: return False # sympy > other --> ! <= if isinstance(other, NumberSymbol): return other.__gt__(self) if other.is_comparable: other = other.evalf() if isinstance(other, Number): return bool(mlib.mpf_le(self._mpf_, other._as_mpf_val(self._prec))) return Expr.__le__(self, other)
def gcd(a, b): """Returns greates common divisor of input arguments. """ if isinstance(b, (int, long)): return Integer(igcd(int(a), b)) else: b = _sympify(b) if b.is_Integer: return Integer(igcd(int(a), int(b))) else: raise ValueError("expected an integer, got %s" % b)
def lcm(a, b): """Returns least common multiple of input arguments. """ if isinstance(b, (int, long)): return Integer(ilcm(int(a), b)) else: b = _sympify(b) if b.is_Integer: return Integer(ilcm(int(a), int(b))) else: raise ValueError("expected an integer, got %s" % b)
def __le__(self, other): try: other = _sympify(other) except SympifyError: return False # sympy > other --> ! <= if isinstance(other, NumberSymbol): return other.__gt__(self) if other.is_comparable: other = other.evalf() if isinstance(other, Number): return bool(mlib.mpf_le(self._mpf_, other._as_mpf_val(self._prec))) return Basic.__le__(self, other)
def __add__(self, other): try: other = _sympify(other) except SympifyError: return NotImplemented if (other is S.NaN) or (self is NaN): return S.NaN if isinstance(other, Number): rhs, prec = other._as_mpf_op(self._prec) return Real._new(mlib.mpf_add(self._mpf_, rhs, prec, rnd), prec) return Number.__add__(self, other)
def __ne__(self, other): try: other = _sympify(other) except SympifyError: return True # sympy != 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(not mlib.mpf_eq(self._mpf_, other._as_mpf_val(self._prec))) return True # Real != non-Number
def __new__(cls, b, e, evaluate=True): # don't optimize "if e==0; return 1" here; it's better to handle that # in the calling routine so this doesn't get called b = _sympify(b) e = _sympify(e) if evaluate: if e is S.Zero: return S.One elif e is S.One: return b elif S.NaN in (b, e): if b is S.One: # already handled e == 0 above return S.One return S.NaN else: obj = b._eval_power(e) if obj is not None: return obj obj = Expr.__new__(cls, b, e) obj.is_commutative = (b.is_commutative and e.is_commutative) return obj
def __ne__(self, other): try: other = _sympify(other) except SympifyError: return True # sympy != other if isinstance(other, NumberSymbol): if other.is_irrational: return True return other.__ne__(self) if isinstance(other, FunctionClass): #cos as opposed to cos(x) return True if isinstance(other, Number): return bool(not mlib.mpf_eq(self._mpf_, other._as_mpf_val(self._prec))) return True # Real != non-Number
def cofactors(a, b): """Returns GCD and cofactors of input arguments. """ if type(b) is int: gcd = Integer(igcd(int(a), b)) return gcd, a//gcd, Integer(b)//gcd else: b = _sympify(b) if b.is_Integer: gcd = Integer(igcd(int(a), int(b))) return gcd, a//gcd, b//gcd else: raise ValueError("expected an integer, got %s" % b)
def __new__(cls, lhs, rhs, rop=None, **assumptions): lhs = _sympify(lhs) rhs = _sympify(rhs) if cls is not Relational: rop_cls = cls else: try: rop_cls = Relational.ValidRelationOperator[ rop ] except KeyError: msg = "Invalid relational operator symbol: '%r'" raise ValueError(msg % repr(rop)) if lhs.is_number and rhs.is_number and lhs.is_real and rhs.is_real: # Just becase something is a number, doesn't mean you can evalf it. Nlhs = lhs.evalf() if Nlhs.is_Number: # S.Zero.evalf() returns S.Zero, so test Number instead of Float Nrhs = rhs.evalf() if Nrhs.is_Number: return rop_cls._eval_relation(Nlhs, Nrhs) obj = Expr.__new__(rop_cls, lhs, rhs, **assumptions) return obj
def __le__(self, other): try: other = _sympify(other) except SympifyError: return False # sympy > other --> not <= 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(mlib.mpf_le(self._as_mpf_val(other._prec), other._mpf_)) return bool(self.p * other.q <= self.q * other.p) return Basic.__le__(self, other)
def cofactors(a, b): """Returns GCD and cofactors of input arguments. """ if isinstance(b, (int, long)): gcd = Integer(igcd(int(a), b)) return gcd, a//gcd, Integer(b)//gcd else: b = _sympify(b) if b.is_Integer: gcd = Integer(igcd(int(a), int(b))) return gcd, a//gcd, b//gcd else: raise ValueError("expected an integer, got %s" % b)
def __new__(cls, lhs, rhs, rop=None, **assumptions): lhs = _sympify(lhs) rhs = _sympify(rhs) if cls is not Relational: rop_cls = cls else: try: rop_cls = Relational.ValidRelationOperator[ rop ] except KeyError: msg = "Invalid relational operator symbol: '%r'" raise ValueError(msg % repr(rop)) if lhs.is_number and rhs.is_number and (rop in ('==', '!=' ) or lhs.is_real and rhs.is_real): # Just because something is a number, doesn't mean you can evalf it. Nlhs = lhs.evalf() if not lhs.is_Atom else lhs if Nlhs.is_Atom: Nrhs = rhs.evalf() if not rhs.is_Atom else rhs if Nrhs.is_Atom: return rop_cls._eval_relation(Nlhs, Nrhs) obj = Expr.__new__(rop_cls, lhs, rhs, **assumptions) return obj
def __eq__(self, other): try: other = _sympify(other) except SympifyError: return False # sympy != other --> not == if isinstance(other, NumberSymbol): if other.is_irrational: return False return other.__eq__(self) if isinstance(other, FunctionClass): #cos as opposed to cos(x) return False if other.is_comparable: other = other.evalf() if isinstance(other, Number): return bool(mlib.mpf_eq(self._mpf_, other._as_mpf_val(self._prec))) return False # Real != non-Number
def __new__(cls, b, e, evaluate=True): from sympy.functions.elementary.exponential import exp_polar # don't optimize "if e==0; return 1" here; it's better to handle that # in the calling routine so this doesn't get called b = _sympify(b) e = _sympify(e) if evaluate: if e is S.Zero: return S.One elif e is S.One: return b elif S.NaN in (b, e): if b is S.One: # already handled e == 0 above return S.One return S.NaN else: # recognize base as E if not e.is_Atom and b is not S.Exp1 and b.func is not exp_polar: from sympy import numer, denom, log, sign, im, factor_terms c, ex = factor_terms(e, sign=False).as_coeff_Mul() den = denom(ex) if den.func is log and den.args[0] == b: return S.Exp1**(c * numer(ex)) elif den.is_Add: s = sign(im(b)) if s.is_Number and s and den == \ log(-factor_terms(b, sign=False)) + s*S.ImaginaryUnit*S.Pi: return S.Exp1**(c * numer(ex)) obj = b._eval_power(e) if obj is not None: return obj obj = Expr.__new__(cls, b, e) obj.is_commutative = (b.is_commutative and e.is_commutative) return obj
def __eq__(self, other): try: other = _sympify(other) except SympifyError: return False # sympy != other --> not == if isinstance(other, NumberSymbol): if other.is_irrational: return False return other.__eq__(self) 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(mlib.mpf_eq(self._as_mpf_val(other._prec), other._mpf_)) return bool(self.p==other.p and self.q==other.q) return False # Rational != non-Number
def __lt__(self, other): try: other = _sympify(other) except SympifyError: return False # sympy > other --> not < 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 Basic.__lt__(self, other)