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)