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 from_sympy(expr):
from mathics.builtin import sympy_to_mathics
from mathics.core.expression import Symbol, Integer, Rational, Real, Expression
from sympy.core import numbers, function, symbol
if isinstance(expr, (tuple, list)):
return Expression('List', *[from_sympy(item) for item in 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 name.startswith(sage_symbol_prefix):
name = name[len(sage_symbol_prefix):]
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 Symbol('I')
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.num)
elif isinstance(expr, function.FunctionClass):
return Symbol(unicode(expr))
elif expr.is_Add:
return Expression('Plus', *[from_sympy(arg) for arg in expr.args])
elif expr.is_Mul:
return Expression('Times', *[from_sympy(arg) for arg in expr.args])
elif expr.is_Pow:
return Expression('Power', *[from_sympy(arg) for arg in expr.args])
elif isinstance(expr, SympyExpression):
#print "SympyExpression: %s" % expr
return expr.expr
elif expr.is_Function or isinstance(expr, (sympy.Integral, sympy.Derivative)):
if isinstance(expr, sympy.Integral):
name = 'Integral'
elif isinstance(expr, sympy.Derivative):
name = 'Derivative'
else:
name = expr.func.__name__
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)
else:
if name.startswith(sage_symbol_prefix):
name = name[len(sage_symbol_prefix):]
return Expression(Symbol(name), *args)
elif isinstance(expr, sympy.Tuple):
return Expression('List', *[from_sympy(arg) for arg in expr.args])
else:
raise ValueError("Unknown SymPy expression: %s" % expr)
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 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 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 from_sympy(expr):
from mathics.builtin import sympy_to_mathics
from mathics.core.expression import Symbol, Integer, Rational, Real, Expression, Number
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, float)):
return Number.from_mp(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 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 Symbol("I")
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.num)
elif isinstance(expr, function.FunctionClass):
return Symbol(unicode(expr))
elif expr.is_Add:
return Expression("Plus", *[from_sympy(arg) for arg in expr.args])
elif expr.is_Mul:
return Expression("Times", *[from_sympy(arg) for arg in expr.args])
elif expr.is_Pow:
return Expression("Power", *[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__
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)
else:
if name.startswith(sage_symbol_prefix):
name = name[len(sage_symbol_prefix) :]
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', )
else:
raise ValueError("Unknown SymPy expression: %s" % expr)
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'
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 expr is sympy.true:
return Symbol('True')
elif expr is sympy.false:
return Symbol('False')
else:
raise ValueError("Unknown SymPy expression: %s" % expr)
