def apply(self, z, evaluation):
'%(name)s[z__]'
args = z.get_sequence()
if len(args) != self.nargs:
return
# if no arguments are inexact attempt to use sympy
if all(not x.is_inexact() for x in args):
result = Expression(self.get_name(), *args).to_sympy()
result = self.prepare_mathics(result)
result = from_sympy(result)
# evaluate leaves to convert e.g. Plus[2, I] -> Complex[2, 1]
result = result.evaluate_leaves(evaluation)
else:
prec = min_prec(*args)
with mpmath.workprec(prec):
mpmath_args = [sympy2mpmath(x.to_sympy()) for x in args]
if None in mpmath_args:
return
try:
result = self.eval(*mpmath_args)
result = from_sympy(mpmath2sympy(result, prec))
except ValueError, exc:
text = str(exc)
if text == 'gamma function pole':
return Symbol('ComplexInfinity')
else:
raise
except ZeroDivisionError:
return
except SpecialValueError, exc:
return Symbol(exc.name)
def apply(self, z, evaluation):
'%(name)s[z__]'
args = z.get_sequence()
if len(args) != self.nargs:
return
# if no arguments are inexact attempt to use sympy
if all(not x.is_inexact() for x in args):
result = Expression(self.get_name(), *args).to_sympy()
result = self.prepare_mathics(result)
result = from_sympy(result)
# evaluate leaves to convert e.g. Plus[2, I] -> Complex[2, 1]
result = result.evaluate_leaves(evaluation)
else:
prec = min_prec(*args)
with mpmath.workprec(prec):
mpmath_args = [sympy2mpmath(x.to_sympy()) for x in args]
if None in mpmath_args:
return
try:
result = self.eval(*mpmath_args)
result = from_sympy(mpmath2sympy(result, prec))
except ValueError, exc:
text = str(exc)
if text == 'gamma function pole':
return Symbol('ComplexInfinity')
else:
raise
except ZeroDivisionError:
return
except SpecialValueError, exc:
return Symbol(exc.name)
def apply(self, z, evaluation):
'%(name)s[z__]'
args = z.numerify(evaluation).get_sequence()
mpmath_function = self.get_mpmath_function(args)
result = None
# if no arguments are inexact attempt to use sympy
if all(not x.is_inexact() for x in args):
result = Expression(self.get_name(), *args).to_sympy()
result = self.prepare_mathics(result)
result = from_sympy(result)
# evaluate leaves to convert e.g. Plus[2, I] -> Complex[2, 1]
return result.evaluate_leaves(evaluation)
elif mpmath_function is None:
return
if not all(isinstance(arg, Number) for arg in args):
return
if any(arg.is_machine_precision() for arg in args):
# if any argument has machine precision then the entire calculation
# is done with machine precision.
float_args = [
arg.round().get_float_value(permit_complex=True)
for arg in args
]
if None in float_args:
return
result = self.call_mpmath(mpmath_function, float_args)
if isinstance(result, (mpmath.mpc, mpmath.mpf)):
if mpmath.isinf(result) and isinstance(result, mpmath.mpc):
result = Symbol('ComplexInfinity')
elif mpmath.isinf(result) and result > 0:
result = Expression('DirectedInfinity', Integer(1))
elif mpmath.isinf(result) and result < 0:
result = Expression('DirectedInfinity', Integer(-1))
elif mpmath.isnan(result):
result = Symbol('Indeterminate')
else:
result = Number.from_mpmath(result)
else:
prec = min_prec(*args)
d = dps(prec)
args = [
Expression('N', arg, Integer(d)).evaluate(evaluation)
for arg in args
]
with mpmath.workprec(prec):
mpmath_args = [x.to_mpmath() for x in args]
if None in mpmath_args:
return
result = self.call_mpmath(mpmath_function, mpmath_args)
if isinstance(result, (mpmath.mpc, mpmath.mpf)):
result = Number.from_mpmath(result, d)
return result
def apply(self, z, evaluation):
'%(name)s[z__]'
args = z.numerify(evaluation).get_sequence()
mpmath_function = self.get_mpmath_function(args)
result = None
# if no arguments are inexact attempt to use sympy
if all(not x.is_inexact() for x in args):
result = Expression(self.get_name(), *args).to_sympy()
result = self.prepare_mathics(result)
result = from_sympy(result)
# evaluate leaves to convert e.g. Plus[2, I] -> Complex[2, 1]
return result.evaluate_leaves(evaluation)
elif mpmath_function is None:
return
if not all(isinstance(arg, Number) for arg in args):
return
if any(arg.is_machine_precision() for arg in args):
# if any argument has machine precision then the entire calculation
# is done with machine precision.
float_args = [arg.round().get_float_value(permit_complex=True) for arg in args]
if None in float_args:
return
result = self.call_mpmath(mpmath_function, float_args)
if isinstance(result, (mpmath.mpc, mpmath.mpf)):
if mpmath.isinf(result) and isinstance(result, mpmath.mpc):
result = Symbol('ComplexInfinity')
elif mpmath.isinf(result) and result > 0:
result = Expression('DirectedInfinity', Integer(1))
elif mpmath.isinf(result) and result < 0:
result = Expression('DirectedInfinity', Integer(-1))
elif mpmath.isnan(result):
result = Symbol('Indeterminate')
else:
result = Number.from_mpmath(result)
else:
prec = min_prec(*args)
d = dps(prec)
args = [Expression('N', arg, Integer(d)).evaluate(evaluation) for arg in args]
with mpmath.workprec(prec):
mpmath_args = [x.to_mpmath() for x in args]
if None in mpmath_args:
return
result = self.call_mpmath(mpmath_function, mpmath_args)
if isinstance(result, (mpmath.mpc, mpmath.mpf)):
result = Number.from_mpmath(result, d)
return result
def apply(self, items, evaluation):
'Power[items__]'
items_sequence = items.get_sequence()
if len(items_sequence) == 2:
x, y = items_sequence
else:
return Expression('Power', *items_sequence)
if y.get_int_value() == 1:
return x
elif x.get_int_value() == 1:
return x
elif y.get_int_value() == 0:
if x.get_int_value() == 0:
evaluation.message('Power', 'indet', Expression('Power', x, y))
return Symbol('Indeterminate')
else:
return Integer(1)
elif x.has_form('Power', 2) and isinstance(y, Integer):
return Expression('Power', x.leaves[0],
Expression('Times', x.leaves[1], y))
elif x.has_form('Times', None) and isinstance(y, Integer):
return Expression(
'Times', *[Expression('Power', leaf, y) for leaf in x.leaves])
elif (isinstance(x, Number) and isinstance(y, Number)
and not (x.is_inexact() or y.is_inexact())):
sym_x, sym_y = x.to_sympy(), y.to_sympy()
try:
if sympy.re(sym_y) >= 0:
result = sym_x**sym_y
else:
if sym_x == 0:
evaluation.message('Power', 'infy')
return Symbol('ComplexInfinity')
result = sympy.Integer(1) / (sym_x**(-sym_y))
if isinstance(result, sympy.Pow):
result = result.simplify()
args = [from_sympy(expr) for expr in result.as_base_exp()]
result = Expression('Power', *args)
result = result.evaluate_leaves(evaluation)
return result
return from_sympy(result)
except ValueError:
return Expression('Power', x, y)
except ZeroDivisionError:
evaluation.message('Power', 'infy')
return Symbol('ComplexInfinity')
elif (isinstance(x, Number) and isinstance(y, Number)
and (x.is_inexact() or y.is_inexact())):
try:
prec = min_prec(x, y)
with mpmath.workprec(prec):
mp_x = sympy2mpmath(x.to_sympy())
mp_y = sympy2mpmath(y.to_sympy())
result = mp_x**mp_y
if isinstance(result, mpmath.mpf):
return Real(str(result), prec)
elif isinstance(result, mpmath.mpc):
return Complex(str(result.real), str(result.imag),
prec)
except ZeroDivisionError:
evaluation.message('Power', 'infy')
return Symbol('ComplexInfinity')
else:
numerified_items = items.numerify(evaluation)
return Expression('Power', *numerified_items.get_sequence())
def apply(self, items, evaluation):
"Power[items__]"
items_sequence = items.get_sequence()
if len(items_sequence) == 2:
x, y = items_sequence
else:
return Expression("Power", *items_sequence)
if y.get_int_value() == 1:
return x
elif x.get_int_value() == 1:
return x
elif y.get_int_value() == 0:
if x.get_int_value() == 0:
evaluation.message("Power", "indet", Expression("Power", x, y))
return Symbol("Indeterminate")
else:
return Integer(1)
elif x.has_form("Power", 2) and isinstance(y, Integer):
return Expression("Power", x.leaves[0], Expression("Times", x.leaves[1], y))
elif x.has_form("Times", None) and isinstance(y, Integer):
return Expression("Times", *[Expression("Power", leaf, y) for leaf in x.leaves])
elif isinstance(x, Number) and isinstance(y, Number) and not (x.is_inexact() or y.is_inexact()):
sym_x, sym_y = x.to_sympy(), y.to_sympy()
try:
if sym_y >= 0:
result = sym_x ** sym_y
else:
if sym_x == 0:
evaluation.message("Power", "infy")
return Symbol("ComplexInfinity")
result = sympy.Integer(1) / (sym_x ** (-sym_y))
if isinstance(result, sympy.Pow):
result = result.simplify()
args = [from_sympy(expr) for expr in result.as_base_exp()]
result = Expression("Power", *args)
result = result.evaluate_leaves(evaluation)
return result
return from_sympy(result)
except ValueError:
return Expression("Power", x, y)
except ZeroDivisionError:
evaluation.message("Power", "infy")
return Symbol("ComplexInfinity")
elif isinstance(x, Number) and isinstance(y, Number) and (x.is_inexact() or y.is_inexact()):
try:
prec = min(max(x.get_precision(), 64), max(y.get_precision(), 64))
with mpmath.workprec(prec):
mp_x = sympy2mpmath(x.to_sympy())
mp_y = sympy2mpmath(y.to_sympy())
result = mp_x ** mp_y
if isinstance(result, mpmath.mpf):
return Real(str(result), prec)
elif isinstance(result, mpmath.mpc):
return Complex(str(result.real), str(result.imag), prec)
except ZeroDivisionError:
evaluation.message("Power", "infy")
return Symbol("ComplexInfinity")
else:
numerified_items = items.numerify(evaluation)
return Expression("Power", *numerified_items.get_sequence())
