def derivative(self, ex, operator): params = operator.parameter_set() counts = {} for param in params: if param in counts: counts[param] += 1 else: counts[param] = 1 new_params = [] for index, count in counts.items(): if len(new_params) <= index: new_params.extend([0] * (index - len(new_params) + 1)) new_params[index] = count f = self.create_symbol(repr(operator.function())) return expression.Expression(expression.Expression('Derivative', *(expression.Integer(count) for count in new_params)), f)
def pyobject(self, ex, obj): from mathics.core import expression from mathics.core.expression import Number if obj is None: return expression.Symbol('Null') elif isinstance(obj, (list, tuple)) or is_Vector(obj): return expression.Expression('List', *(from_sage(item, self.subs) for item in obj)) elif isinstance(obj, Constant): return expression.Symbol(obj._conversions.get('mathematica', obj._name)) elif is_Integer(obj): return expression.Integer(str(obj)) elif isinstance(obj, sage.Rational): rational = expression.Rational(str(obj)) if rational.value.denom() == 1: return expression.Integer(rational.value.numer()) else: return rational elif isinstance(obj, sage.RealDoubleElement) or is_RealNumber(obj): return expression.Real(str(obj)) elif is_ComplexNumber(obj): real = Number.from_string(str(obj.real())).value imag = Number.from_string(str(obj.imag())).value return expression.Complex(real, imag) elif isinstance(obj, NumberFieldElement_quadratic): # TODO: this need not be a complex number, but we assume so! real = Number.from_string(str(obj.real())).value imag = Number.from_string(str(obj.imag())).value return expression.Complex(real, imag) else: return expression.from_python(obj)
def substitute(self, expr): from mathics.core import expression index = len(self.subs) self.subs.append(expr) return expression.Expression(self.head_name, expression.Integer(index), *expr.get_atoms())
def do_convert(self, node): if isinstance(node, Symbol): return self.convert_Symbol(node) elif isinstance(node, String): return self.convert_String(node) elif isinstance(node, Number): return self.convert_Number(node) elif isinstance(node, Filename): return self.convert_Filename(node) else: head = self.do_convert(node.head) children = [self.do_convert(child) for child in node.children] return ma.Expression(head, *children)
def arithmetic(self, ex, op): from mathics.core import expression if op == operator.add: head = 'Plus' elif op == operator.mul: head = 'Times' elif op == operator.pow: head = 'Power' else: head = 'UNKNOWN' operands = map(self, ex.operands()) if head in ['Plus', 'Times']: # normalize arguments so that expressions don't change # when Sage does not change them operands.sort() return expression.Expression(head, *operands)
def composition(self, ex, operator): from mathics.core import expression from mathics.builtin import sage_to_mathics func_name = repr(operator) builtin = sage_to_mathics.get(func_name) leaves = map(self, ex.operands()) if builtin is not None: head = expression.Symbol(builtin.get_name()) leaves = builtin.from_sage(leaves) else: head = self.create_symbol(func_name) result = expression.Expression(head, *leaves) if self.subs is not None and result.has_form(ConvertSubstitutions.head_name, 1, None): index = result.leaves[0] return self.subs.subs[index.value] else: return result
def _make_Expression(self, head, children): return ma.Expression(head, *children)