def testAccuracy(self): self.lex_error('1.5``') self.check('1.0``20', Real('1.0', p=20))
def out(z): return Real(z)
def evaluate(self, evaluation): return Real(-time.timezone / 3600.)
def apply_N(self, prec, evaluation): 'N[MachinePrecision, prec_]' prec = get_precision(prec, evaluation) if prec is not None: return Real(machine_precision).round(prec)
def apply(self, image, x, y, evaluation): 'PixelValue[image_Image, {x_?RealNumberQ, y_?RealNumberQ}]' return Real(image.pixels[int(y.to_python() - 1), int(x.to_python() - 1)])
def apply(self, functions, x, start, stop, evaluation, options): 'Plot[functions_, {x_Symbol, start_, stop_}, OptionsPattern[Plot]]' expr = Expression('Plot', functions, Expression('List', x, start, stop), *options_to_rules(options)) if functions.has_form('List', None): functions = functions.leaves else: functions = [functions] x = x.get_name() try: start = start.to_number(n_evaluation=evaluation) except NumberError: evaluation.message('Plot', 'plln', start, expr) return try: stop = stop.to_number(n_evaluation=evaluation) except NumberError: evaluation.message('Plot', 'plln', stop, expr) return def eval_f(f, x_value): value = dynamic_scoping(f.evaluate, {x: x_value}, evaluation) value = chop(value).get_real_value() return value hue = 0.67 hue_pos = 0.236068 hue_neg = -0.763932 graphics = [] for index, f in enumerate(functions): points = [] continuous = False steps = 50 d = (stop - start) / steps for index in range(steps + 1): x_value = start + index * d y = eval_f(f, Real(x_value)) if y is not None: point = (x_value, y) if continuous: points[-1].append(point) else: points.append([point]) continuous = True else: continuous = False graphics.append(Expression('Hue', hue, 0.6, 0.6)) graphics.append( Expression( 'Line', Expression( 'List', *(Expression( 'List', *(Expression('List', Real(x), Real(y)) for x, y in line)) for line in points)))) if index % 4 == 0: hue += hue_pos else: hue += hue_neg if hue > 1: hue -= 1 if hue < 0: hue += 1 return Expression('Graphics', Expression('List', *graphics), *options_to_rules(options))
def eval_f(self, f, x_name, x_value, evaluation): value = quiet_evaluate(f, {x_name: Real(x_value)}, evaluation, expect_list=True) if value is None or len(value) != 2: return None return value
def apply(self, evaluation): "TimeUsed[]" # time.process_time() is better than # time.clock(). See https://bugs.python.org/issue31803 return Real(time.process_time())
def testReal(self): _test_group(Real(1.17361), Real(-1.42), Real(42.846195714), Real(42.846195714), Real(42.846195713))
def vertices(): for i in range(n): phi = phi0 + pi2 * i / float(n) yield Expression("List", Real(x + r * cos(phi)), Real(y + r * sin(phi)))
def from_sympy(expr): from mathics.builtin import sympy_to_mathics from mathics.core.expression import (Symbol, Integer, Rational, Real, Complex, String, Expression, MachineReal) from mathics.core.numbers import machine_precision from sympy.core import numbers, function, symbol if isinstance(expr, (tuple, list)): return Expression('List', *[from_sympy(item) for item in expr]) if isinstance(expr, int): return Integer(expr) if isinstance(expr, float): return Real(expr) if isinstance(expr, complex): return Complex(Real(expr.real), Real(expr.imag)) if isinstance(expr, six.string_types): return String(expr) if expr is None: return Symbol('Null') if isinstance(expr, sympy.Matrix): if len(expr.shape) == 2 and (expr.shape[1] == 1): # This is a vector (only one column) # Transpose and select first row to get result equivalent to Mathematica return Expression( 'List', *[from_sympy(item) for item in expr.T.tolist()[0]]) else: return Expression( 'List', *[[from_sympy(item) for item in row] for row in expr.tolist()]) if expr.is_Atom: name = None if expr.is_Symbol: name = six.text_type(expr) if isinstance(expr, symbol.Dummy): name = name + ('__Dummy_%d' % expr.dummy_index) return Symbol(name, sympy_dummy=expr) if is_Cn_expr(name): return Expression('C', int(name[1:])) if name.startswith(sympy_symbol_prefix): name = name[len(sympy_symbol_prefix):] if name.startswith(sympy_slot_prefix): index = name[len(sympy_slot_prefix):] return Expression('Slot', int(index)) elif expr.is_NumberSymbol: name = six.text_type(expr) if name is not None: builtin = sympy_to_mathics.get(name) if builtin is not None: name = builtin.get_name() return Symbol(name) elif isinstance(expr, (numbers.Infinity, numbers.ComplexInfinity)): return Symbol(expr.__class__.__name__) elif isinstance(expr, numbers.NegativeInfinity): return Expression('Times', Integer(-1), Symbol('Infinity')) elif isinstance(expr, numbers.ImaginaryUnit): return Complex(Integer(0), Integer(1)) elif isinstance(expr, numbers.Integer): return Integer(expr.p) elif isinstance(expr, numbers.Rational): if expr.q == 0: if expr.p > 0: return Symbol('Infinity') elif expr.p < 0: return Expression('Times', Integer(-1), Symbol('Infinity')) else: assert expr.p == 0 return Symbol('Indeterminate') return Rational(expr.p, expr.q) elif isinstance(expr, numbers.Float): if expr._prec == machine_precision: return MachineReal(float(expr)) return Real(expr) elif isinstance(expr, numbers.NaN): return Symbol('Indeterminate') elif isinstance(expr, function.FunctionClass): return Symbol(six.text_type(expr)) elif expr.is_number and all([x.is_Number for x in expr.as_real_imag()]): # Hack to convert 3 * I to Complex[0, 3] return Complex(*[from_sympy(arg) for arg in expr.as_real_imag()]) elif expr.is_Add: return Expression('Plus', *sorted([from_sympy(arg) for arg in expr.args])) elif expr.is_Mul: return Expression('Times', *sorted([from_sympy(arg) for arg in expr.args])) elif expr.is_Pow: return Expression('Power', *[from_sympy(arg) for arg in expr.args]) elif expr.is_Equality: return Expression('Equal', *[from_sympy(arg) for arg in expr.args]) elif isinstance(expr, SympyExpression): return expr.expr elif isinstance(expr, sympy.Piecewise): args = expr.args default = [] if len(args) > 0: default_case, default_cond = args[-1] if default_cond == sympy.true: args = args[:-1] if isinstance(default_case, sympy.Integer) and int(default_case) == 0: pass # ignore, as 0 default case is always implicit in Piecewise[] else: default = [from_sympy(default_case)] return Expression( 'Piecewise', Expression( 'List', *[ Expression('List', from_sympy(case), from_sympy(cond)) for case, cond in args ]), *default) elif isinstance(expr, sympy.RootSum): return Expression('RootSum', from_sympy(expr.poly), from_sympy(expr.fun)) elif isinstance(expr, sympy.PurePoly): coeffs = expr.coeffs() monoms = expr.monoms() result = [] for coeff, monom in zip(coeffs, monoms): factors = [] if coeff != 1: factors.append(from_sympy(coeff)) for index, exp in enumerate(monom): if exp != 0: slot = Expression('Slot', index + 1) if exp == 1: factors.append(slot) else: factors.append( Expression('Power', slot, from_sympy(exp))) if factors: result.append(Expression('Times', *factors)) else: result.append(Integer(1)) return Expression('Function', Expression('Plus', *result)) elif isinstance(expr, sympy.Lambda): vars = [ sympy.Symbol('%s%d' % (sympy_slot_prefix, index + 1)) for index in range(len(expr.variables)) ] return Expression('Function', from_sympy(expr(*vars))) elif expr.is_Function or isinstance( expr, (sympy.Integral, sympy.Derivative, sympy.Sum, sympy.Product)): if isinstance(expr, sympy.Integral): name = 'Integral' elif isinstance(expr, sympy.Derivative): name = 'Derivative' else: name = expr.func.__name__ if is_Cn_expr(name): return Expression(Expression('C', int(name[1:])), *[from_sympy(arg) for arg in expr.args]) if name.startswith(sympy_symbol_prefix): name = name[len(sympy_symbol_prefix):] args = [from_sympy(arg) for arg in expr.args] builtin = sympy_to_mathics.get(name) if builtin is not None: return builtin.from_sympy(name, args) return Expression(Symbol(name), *args) elif isinstance(expr, sympy.Tuple): return Expression('List', *[from_sympy(arg) for arg in expr.args]) # elif isinstance(expr, sympy.Sum): # return Expression('Sum', ) elif isinstance(expr, sympy.LessThan): return Expression('LessEqual', *[from_sympy(arg) for arg in expr.args]) elif isinstance(expr, sympy.StrictLessThan): return Expression('Less', *[from_sympy(arg) for arg in expr.args]) elif isinstance(expr, sympy.GreaterThan): return Expression('GreaterEqual', *[from_sympy(arg) for arg in expr.args]) elif isinstance(expr, sympy.StrictGreaterThan): return Expression('Greater', *[from_sympy(arg) for arg in expr.args]) elif isinstance(expr, sympy.Unequality): return Expression('Unequal', *[from_sympy(arg) for arg in expr.args]) elif isinstance(expr, sympy.Equality): return Expression('Equal', *[from_sympy(arg) for arg in expr.args]) elif expr is sympy.true: return Symbol('True') elif expr is sympy.false: return Symbol('False') else: raise ValueError("Unknown SymPy expression: %s" % expr)
def testLowPrecision(self): self.check('1.4`1', Real('1', p=1)) self.check('1.4`0', Real(0, p=0)) self.check('1.4`-5', Real(0, p=0))
def testPrecision(self): self.check('1.`20', Real(1, p=20)) self.check('1.00000000000000000000000`', Real(1)) self.check('1.00000000000000000000000`30', Real(1, p=30))
def testLowAccuracy(self): self.check('1.4``0', Real(0)) self.check('1.4``-20', Real(0))
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(), prec) mp_y = sympy2mpmath(y.to_sympy(), prec) 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 testInstances(self): # duplicate instantiations of same content (like Integer 5) to test for potential instantiation randomness. _test_group(list(map(lambda f: (f(), f()), (lambda: Integer(5), lambda: Rational(5, 2), lambda: Real(5.12345678), lambda: Complex(5, 2), lambda: String('xy'), lambda: Symbol('xy')))))
def from_sympy(expr): from mathics.builtin import sympy_to_mathics from mathics.core.expression import (Symbol, Integer, Rational, Real, Complex, String, Expression) from sympy.core import numbers, function, symbol if isinstance(expr, (tuple, list)): return Expression('List', *[from_sympy(item) for item in expr]) if isinstance(expr, int): return Integer(expr) if isinstance(expr, float): return Real(expr) if isinstance(expr, complex): return Complex(expr.real, expr.imag) if isinstance(expr, str): return String(expr) if expr is None: return Symbol('Null') if isinstance(expr, sympy.Matrix): return Expression( 'List', *[ Expression('List', *[from_sympy(item) for item in row]) for row in expr.tolist() ]) if expr.is_Atom: name = None if expr.is_Symbol: name = unicode(expr) if isinstance(expr, symbol.Dummy): name = name + ('__Dummy_%d' % expr.dummy_index) return Symbol(name, sympy_dummy=expr) if (( not name.startswith(sympy_symbol_prefix) or # noqa name.startswith(sympy_slot_prefix)) and name.startswith('C')): return Expression('C', int(name[1:])) if name.startswith(sympy_symbol_prefix): name = name[len(sympy_symbol_prefix):] if name.startswith(sympy_slot_prefix): index = name[len(sympy_slot_prefix):] return Expression('Slot', int(index)) elif expr.is_NumberSymbol: name = unicode(expr) if name is not None: builtin = sympy_to_mathics.get(name) if builtin is not None: name = builtin.get_name() return Symbol(name) elif isinstance(expr, (numbers.Infinity, numbers.ComplexInfinity)): return Symbol(expr.__class__.__name__) elif isinstance(expr, numbers.NegativeInfinity): return Expression('Times', Integer(-1), Symbol('Infinity')) elif isinstance(expr, numbers.ImaginaryUnit): return Complex(0, 1) elif isinstance(expr, numbers.Integer): return Integer(expr.p) elif isinstance(expr, numbers.Rational): if expr.q == 0: if expr.p > 0: return Symbol('Infinity') elif expr.p < 0: return Expression('Times', Integer(-1), Symbol('Infinity')) else: assert expr.p == 0 return Symbol('Indeterminate') return Rational(expr.p, expr.q) elif isinstance(expr, numbers.Float): return Real(expr) elif isinstance(expr, numbers.NaN): return Symbol('Indeterminate') elif isinstance(expr, function.FunctionClass): return Symbol(unicode(expr)) elif expr.is_number and all([x.is_Number for x in expr.as_real_imag()]): # Hack to convert 3 * I to Complex[0, 3] return Complex(*[from_sympy(arg) for arg in expr.as_real_imag()]) elif expr.is_Add: return Expression('Plus', *sorted([from_sympy(arg) for arg in expr.args])) elif expr.is_Mul: return Expression('Times', *sorted([from_sympy(arg) for arg in expr.args])) elif expr.is_Pow: return Expression('Power', *[from_sympy(arg) for arg in expr.args]) elif expr.is_Equality: return Expression('Equal', *[from_sympy(arg) for arg in expr.args]) elif isinstance(expr, SympyExpression): # print "SympyExpression: %s" % expr return expr.expr elif isinstance(expr, sympy.RootSum): return Expression('RootSum', from_sympy(expr.poly), from_sympy(expr.fun)) elif isinstance(expr, sympy.PurePoly): coeffs = expr.coeffs() monoms = expr.monoms() result = [] for coeff, monom in zip(coeffs, monoms): factors = [] if coeff != 1: factors.append(from_sympy(coeff)) for index, exp in enumerate(monom): if exp != 0: slot = Expression('Slot', index + 1) if exp == 1: factors.append(slot) else: factors.append( Expression('Power', slot, from_sympy(exp))) if factors: result.append(Expression('Times', *factors)) else: result.append(Integer(1)) return Expression('Function', Expression('Plus', *result)) elif isinstance(expr, sympy.Lambda): vars = [ sympy.Symbol('%s%d' % (sympy_slot_prefix, index + 1)) for index in range(len(expr.variables)) ] return Expression('Function', from_sympy(expr(*vars))) elif expr.is_Function or isinstance( expr, (sympy.Integral, sympy.Derivative, sympy.Sum, sympy.Product)): if isinstance(expr, sympy.Integral): name = 'Integral' elif isinstance(expr, sympy.Derivative): name = 'Derivative' else: name = expr.func.__name__ if name.startswith(sympy_symbol_prefix): name = name[len(sympy_symbol_prefix):] args = [from_sympy(arg) for arg in expr.args] builtin = sympy_to_mathics.get(name) if builtin is not None: name = builtin.get_name() args = builtin.from_sympy(args) return Expression(Symbol(name), *args) elif isinstance(expr, sympy.Tuple): return Expression('List', *[from_sympy(arg) for arg in expr.args]) # elif isinstance(expr, sympy.Sum): # return Expression('Sum', ) elif isinstance(expr, sympy.LessThan): return Expression('LessEqual', [from_sympy(arg) for arg in expr.args]) elif isinstance(expr, sympy.StrictLessThan): return Expression('Less', [from_sympy(arg) for arg in expr.args]) elif isinstance(expr, sympy.GreaterThan): return Expression('GreaterEqual', [from_sympy(arg) for arg in expr.args]) elif isinstance(expr, sympy.StrictGreaterThan): return Expression('Greater', [from_sympy(arg) for arg in expr.args]) elif isinstance(expr, sympy.Unequality): return Expression('Unequal', [from_sympy(arg) for arg in expr.args]) elif isinstance(expr, sympy.Equality): return Expression('Equal', [from_sympy(arg) for arg in expr.args]) else: raise ValueError("Unknown SymPy expression: %s" % expr)
def evaluate(self, evaluation) -> Real: # Make this be whatever the latest Mathematica release is, # assuming we are trying to be compatible with this. return Real(self.value)
def eval_f(self, f, x_name, x_value, evaluation): value = quiet_evaluate(f, {x_name: Real(x_value)}, evaluation) if value is None: return None return (x_value, value)
def from_sympy(expr): from mathics.builtin import sympy_to_mathics from mathics.core.expression import (Symbol, Integer, Rational, Real, Complex, String, Expression, MachineReal) from mathics.core.numbers import machine_precision if isinstance(expr, (tuple, list)): return Expression('List', *[from_sympy(item) for item in expr]) if isinstance(expr, int): return Integer(expr) if isinstance(expr, float): return Real(expr) if isinstance(expr, complex): return Complex(Real(expr.real), Real(expr.imag)) if isinstance(expr, str): return String(expr) if expr is None: return Symbol('Null') if isinstance(expr, sympy.Matrix) or isinstance(expr, sympy.ImmutableMatrix): if len(expr.shape) == 2 and (expr.shape[1] == 1): # This is a vector (only one column) # Transpose and select first row to get result equivalent to Mathematica return Expression( 'List', *[from_sympy(item) for item in expr.T.tolist()[0]]) else: return Expression( 'List', *[[from_sympy(item) for item in row] for row in expr.tolist()]) if isinstance(expr, sympy.MatPow): return Expression('MatrixPower', from_sympy(expr.base), from_sympy(expr.exp)) if expr.is_Atom: name = None if expr.is_Symbol: name = str(expr) if isinstance(expr, sympy.Dummy): name = name + ('__Dummy_%d' % expr.dummy_index) return Symbol(name, sympy_dummy=expr) if is_Cn_expr(name): return Expression('C', int(name[1:])) if name.startswith(sympy_symbol_prefix): name = name[len(sympy_symbol_prefix):] if name.startswith(sympy_slot_prefix): index = name[len(sympy_slot_prefix):] return Expression('Slot', int(index)) elif expr.is_NumberSymbol: name = str(expr) if name is not None: builtin = sympy_to_mathics.get(name) if builtin is not None: name = builtin.get_name() return Symbol(name) elif isinstance( expr, (sympy.core.numbers.Infinity, sympy.core.numbers.ComplexInfinity)): return Symbol(expr.__class__.__name__) elif isinstance(expr, sympy.core.numbers.NegativeInfinity): return Expression('Times', Integer(-1), Symbol('Infinity')) elif isinstance(expr, sympy.core.numbers.ImaginaryUnit): return Complex(Integer(0), Integer(1)) elif isinstance(expr, sympy.Integer): return Integer(int(expr)) elif isinstance(expr, sympy.Rational): numerator, denominator = map(int, expr.as_numer_denom()) if denominator == 0: if numerator > 0: return Symbol('Infinity') elif numerator < 0: return Expression('Times', Integer(-1), Symbol('Infinity')) else: assert numerator == 0 return Symbol('Indeterminate') return Rational(numerator, denominator) elif isinstance(expr, sympy.Float): if expr._prec == machine_precision: return MachineReal(float(expr)) return Real(expr) elif isinstance(expr, sympy.core.numbers.NaN): return Symbol('Indeterminate') elif isinstance(expr, sympy.core.function.FunctionClass): return Symbol(str(expr)) elif expr is sympy.true: return Symbol('True') elif expr is sympy.false: return Symbol('False') elif expr.is_number and all([x.is_Number for x in expr.as_real_imag()]): # Hack to convert 3 * I to Complex[0, 3] return Complex(*[from_sympy(arg) for arg in expr.as_real_imag()]) elif expr.is_Add: return Expression('Plus', *sorted([from_sympy(arg) for arg in expr.args])) elif expr.is_Mul: return Expression('Times', *sorted([from_sympy(arg) for arg in expr.args])) elif expr.is_Pow: return Expression('Power', *[from_sympy(arg) for arg in expr.args]) elif expr.is_Equality: return Expression('Equal', *[from_sympy(arg) for arg in expr.args]) elif isinstance(expr, SympyExpression): return expr.expr elif isinstance(expr, sympy.Piecewise): args = expr.args return Expression( 'Piecewise', Expression( 'List', *[ Expression('List', from_sympy(case), from_sympy(cond)) for case, cond in args ])) elif isinstance(expr, SympyPrime): return Expression('Prime', from_sympy(expr.args[0])) elif isinstance(expr, sympy.RootSum): return Expression('RootSum', from_sympy(expr.poly), from_sympy(expr.fun)) elif isinstance(expr, sympy.PurePoly): coeffs = expr.coeffs() monoms = expr.monoms() result = [] for coeff, monom in zip(coeffs, monoms): factors = [] if coeff != 1: factors.append(from_sympy(coeff)) for index, exp in enumerate(monom): if exp != 0: slot = Expression('Slot', index + 1) if exp == 1: factors.append(slot) else: factors.append( Expression('Power', slot, from_sympy(exp))) if factors: result.append(Expression('Times', *factors)) else: result.append(Integer(1)) return Expression('Function', Expression('Plus', *result)) elif isinstance(expr, sympy.CRootOf): try: e, i = expr.args except ValueError: return Expression('Null') try: e = sympy.PurePoly(e) except: pass return Expression('Root', from_sympy(e), i + 1) elif isinstance(expr, sympy.Lambda): vars = [ sympy.Symbol('%s%d' % (sympy_slot_prefix, index + 1)) for index in range(len(expr.variables)) ] return Expression('Function', from_sympy(expr(*vars))) elif expr.is_Function or isinstance( expr, (sympy.Integral, sympy.Derivative, sympy.Sum, sympy.Product)): if isinstance(expr, sympy.Integral): name = 'Integral' elif isinstance(expr, sympy.Derivative): name = 'Derivative' margs = [] for arg in expr.args: # parse (x, 1) ==> just x for test_conversion # IMHO this should be removed in future versions if isinstance(arg, sympy.Tuple): if arg[1] == 1: margs.append(from_sympy(arg[0])) else: margs.append(from_sympy(arg)) else: margs.append(from_sympy(arg)) builtin = sympy_to_mathics.get(name) return builtin.from_sympy(name, margs) elif isinstance(expr, sympy.sign): name = 'Sign' else: name = expr.func.__name__ if is_Cn_expr(name): return Expression(Expression('C', int(name[1:])), *[from_sympy(arg) for arg in expr.args]) if name.startswith(sympy_symbol_prefix): name = name[len(sympy_symbol_prefix):] args = [from_sympy(arg) for arg in expr.args] builtin = sympy_to_mathics.get(name) if builtin is not None: return builtin.from_sympy(name, args) return Expression(Symbol(name), *args) elif isinstance(expr, sympy.Tuple): return Expression('List', *[from_sympy(arg) for arg in expr.args]) # elif isinstance(expr, sympy.Sum): # return Expression('Sum', ) elif isinstance(expr, sympy.LessThan): return Expression('LessEqual', *[from_sympy(arg) for arg in expr.args]) elif isinstance(expr, sympy.StrictLessThan): return Expression('Less', *[from_sympy(arg) for arg in expr.args]) elif isinstance(expr, sympy.GreaterThan): return Expression('GreaterEqual', *[from_sympy(arg) for arg in expr.args]) elif isinstance(expr, sympy.StrictGreaterThan): return Expression('Greater', *[from_sympy(arg) for arg in expr.args]) elif isinstance(expr, sympy.Unequality): return Expression('Unequal', *[from_sympy(arg) for arg in expr.args]) elif isinstance(expr, sympy.Equality): return Expression('Equal', *[from_sympy(arg) for arg in expr.args]) elif isinstance(expr, sympy.O): if expr.args[0].func == sympy.core.power.Pow: [var, power] = [from_sympy(arg) for arg in expr.args[0].args] o = Expression('O', var) return Expression('Power', o, power) else: return Expression('O', from_sympy(expr.args[0])) else: raise ValueError( "Unknown SymPy expression: {} (instance of {})".format( expr, str(expr.__class__)))
def t_number(self, t): r''' ( (?# Two possible forms depending on whether base is specified) (\d+\^\^([a-zA-Z0-9]+\.?[a-zA-Z0-9]*|[a-zA-Z0-9]*\.?[a-zA-Z0-9]+)) | (\d+\.?\d*|\d*\.?\d+) ) (``?(\+|-)?(\d+\.?\d*|\d*\.?\d+)|`)? (?# Precision / Accuracy) (\*\^(\+|-)?\d+)? (?# Exponent) ''' s = t.value # Look for base s = s.split('^^') if len(s) == 1: base, s = 10, s[0] else: assert len(s) == 2 base, s = int(s[0]), s[1] assert 2 <= base <= 36 # Look for mantissa s = s.split('*^') if len(s) == 1: n, s = 0, s[0] else: #TODO: modify regex and provide error message if n not an int n, s = int(s[1]), s[0] # Look at precision ` suffix to get precision/accuracy prec, acc = None, None s = s.split('`', 1) if len(s) == 1: suffix, s = None, s[0] else: suffix, s = s[1], s[0] if suffix == '': prec = machine_precision elif suffix.startswith('`'): acc = float(suffix[1:]) else: if re.match('0+$', s) is not None: t.value = Integer(0) return t prec = float(suffix) # Look for decimal point if s.count('.') == 0: if suffix is None: if n < 0: t.value = Rational(int(s, base), base**abs(n)) else: t.value = Integer(int(s, base) * (base**n)) return t else: s = s + '.' if base == 10: if n != 0: s = s + 'E' + str(n) # sympy handles this if acc is not None: if float(s) == 0: prec = 0. else: prec = acc + log10(float(s)) + n #XXX if prec is not None: prec = dps(prec) t.value = Real(s, prec) #t.value = Real(s, prec, acc) else: # Convert the base assert isinstance(base, int) and 2 <= base <= 36 # Put into standard form mantissa * base ^ n s = s.split('.') if len(s) == 1: man = s[0] else: n -= len(s[1]) man = s[0] + s[1] man = int(man, base) if n >= 0: result = Integer(man * base**n) else: result = Rational(man, base**-n) if acc is None and prec is None: acc = len(s[1]) acc10 = acc * log10(base) prec10 = acc10 + log10(result.to_python()) if prec10 < 18: prec10 = None elif acc is not None: acc10 = acc * log10(base) prec10 = acc10 + log10(result.to_python()) elif prec is not None: if prec == machine_precision: prec10 = machine_precision else: prec10 = prec * log10(base) #XXX if prec10 is None: prec10 = machine_precision else: prec10 = dps(prec10) t.value = result.round(prec10) return t
def testReal(self): _test_group(MachineReal(1.17361), MachineReal(-1.42), MachineReal(42.846195714), MachineReal(42.846195714), MachineReal(42.846195713), Real('42.846195713', 18), Real('-1.42', 3))
def apply_real(self, x, evaluation): 'Precision[x_Real]' return Real(dps(x.get_precision()))
def testAcrossTypes(self): _test_group(Integer(1), Rational(1, 1), Real(1), Complex(Integer(1), Integer(1)), String('1'), Symbol('1'))
def apply(self, image, evaluation): 'ImageAspectRatio[image_Image]' dim = image.dimensions() return Real(dim[1] / float(dim[0]))
def apply_N(self, precision, evaluation): 'N[E, precision_]' precision = get_precision(precision, evaluation) if precision is not None: return Real(sympy.E.n(dps(precision)), p=precision)
def out(z): return Real(z, precision)
def apply(self, evaluation): 'SessionTime[]' return Real(time.time() - START_TIME)
def apply(self, evaluation): 'TimeUsed[]' return Real(time.clock()) # TODO: Check this for windows
def find_root_secant(f, x0, x, opts, evaluation) -> (Number, bool): region = opts.get("$$Region", None) if not type(region) is list: if x0.is_zero: region = (Real(-1), Real(1)) else: xmax = 2 * x0.to_python() xmin = -2 * x0.to_python() if xmin > xmax: region = (Real(xmax), Real(xmin)) else: region = (Real(xmin), Real(xmax)) maxit = opts["System`MaxIterations"] x_name = x.get_name() if maxit.sameQ(Symbol("Automatic")): maxit = 100 else: maxit = maxit.evaluate(evaluation).get_int_value() x0 = from_python(region[0]) x1 = from_python(region[1]) f0 = dynamic_scoping(lambda ev: f.evaluate(evaluation), {x_name: x0}, evaluation) f1 = dynamic_scoping(lambda ev: f.evaluate(evaluation), {x_name: x1}, evaluation) if not isinstance(f0, Number): return x0, False if not isinstance(f1, Number): return x0, False f0 = f0.to_python(n_evaluation=True) f1 = f1.to_python(n_evaluation=True) count = 0 while count < maxit: if f0 == f1: x1 = Expression( "Plus", x0, Expression( "Times", Real(0.75), Expression("Plus", x1, Expression("Times", Integer(-1), x0)), ), ) x1 = x1.evaluate(evaluation) f1 = dynamic_scoping(lambda ev: f.evaluate(evaluation), {x_name: x1}, evaluation) if not isinstance(f1, Number): return x0, False f1 = f1.to_python(n_evaluation=True) continue inv_deltaf = from_python(1.0 / (f1 - f0)) num = Expression( "Plus", Expression("Times", x0, f1), Expression("Times", x1, f0, Integer(-1)), ) x2 = Expression("Times", num, inv_deltaf) x2 = x2.evaluate(evaluation) f2 = dynamic_scoping(lambda ev: f.evaluate(evaluation), {x_name: x2}, evaluation) if not isinstance(f2, Number): return x0, False f2 = f2.to_python(n_evaluation=True) f1, f0 = f2, f1 x1, x0 = x2, x1 if x1 == x0 or abs(f2) == 0: break count = count + 1 else: evaluation.message("FindRoot", "maxiter") return x0, False return x0, True