def apply(self, expr, evaluation):
'Dimensions[expr_]'
return Expression('List',
*[Integer(dim) for dim in get_dimensions(expr)])
def apply(self, command, evaluation):
"Run[command_?StringQ]"
command_str = command.to_python()
return Integer(subprocess.call(command_str, shell=True))
def apply(self, evaluation) -> Integer:
"""MemoryAvailable[]"""
totalmem = psutil.virtual_memory().available
return Integer(totalmem)
def p_Slash(self, args):
'''expr : expr RawSlash expr
| expr Divide expr'''
args[0] = Expression('Times', args[1], Expression('Power', args[3], Integer(-1)))
def apply_single(self, m, evaluation):
'Norm[m_]'
return self.apply(m, Integer(2), evaluation)
def p_slotseq(self, args):
'expr : slotseq'
args[0] = Expression('SlotSequence', Integer(args[1]))
def p_Apply2(self, args):
'expr : expr Apply2 expr'
assert args[2] == '@@@'
args[0] = Expression('Apply', args[1], args[3], Expression('List', Integer(1)))
def testSpan(self):
self.check('1;;2;;3',
Expression('Span', Integer(1), Integer(2), Integer(3)))
self.check('1;; ;;3',
Expression('Span', Integer(1), Symbol('All'), Integer(3)))
self.check('1;;;;3',
Expression('Span', Integer(1), Symbol('All'), Integer(3)))
self.check(' ;;2;;3',
Expression('Span', Integer(1), Integer(2), Integer(3)))
self.check(' ;;2', Expression('Span', Integer(1), Integer(2)))
self.check('1;; ', Expression('Span', Integer(1), Symbol('All')))
self.check(' ;; ', Expression('Span', Integer(1), Symbol('All')))
def testBinOp(self):
self.check('1 <> 2 ', Expression('StringJoin', Integer(1), Integer(2)))
self.check(
'1 <> 2 <> 3',
Expression('StringJoin', Integer(1), Integer(2), Integer(3)))
self.check('1 ^ 2', Expression('Power', Integer(1), Integer(2)))
self.check('1 . 2', Expression('Dot', Integer(1), Integer(2)))
self.check('1 && 2', Expression('And', Integer(1), Integer(2)))
self.check('1 || 2', Expression('Or', Integer(1), Integer(2)))
self.check(
'x /; y',
Expression('Condition', Symbol('Global`x'), Symbol('Global`y')))
self.check('x -> y',
Expression('Rule', Symbol('Global`x'), Symbol('Global`y')))
self.check(
'x :> y',
Expression('RuleDelayed', Symbol('Global`x'), Symbol('Global`y')))
self.check(
'x /. y',
Expression('ReplaceAll', Symbol('Global`x'), Symbol('Global`y')))
self.check(
'x //. y',
Expression('ReplaceRepeated', Symbol('Global`x'),
Symbol('Global`y')))
self.check('x += y',
Expression('AddTo', Symbol('Global`x'), Symbol('Global`y')))
self.check(
'x -= y',
Expression('SubtractFrom', Symbol('Global`x'), Symbol('Global`y')))
self.check(
'x *= y',
Expression('TimesBy', Symbol('Global`x'), Symbol('Global`y')))
self.check(
'x /= y',
Expression('DivideBy', Symbol('Global`x'), Symbol('Global`y')))
self.check('x &', Expression('Function', Symbol('Global`x')))
self.check('x // y', Expression('Global`y', Symbol('Global`x')))
self.check('1 ^ 2 ^ 3', 'Power[1, Power[2, 3]]')
self.check(
'3/2',
Expression('Times', Integer(3),
Expression('Power', Integer(2), Integer(-1))))
self.check(
'x ~~ y',
Expression('StringExpression', Symbol('Global`x'),
Symbol('Global`y')))
self.check(
'x ~~ y ~~ z',
Expression('StringExpression', Symbol('Global`x'),
Symbol('Global`y'), Symbol('Global`z')))
def testMessage(self):
self.check('1 :: "abc"',
Expression('MessageName', Integer(1), String("abc")))
def testTimes(self):
self.check('1 2', Expression('Times', Integer(1), Integer(2)))
self.check('1*2', Expression('Times', Integer(1), Integer(2)))
self.check('1 2 3',
Expression('Times', Integer(1), Integer(2), Integer(3)))
self.check('1*2*3',
Expression('Times', Integer(1), Integer(2), Integer(3)))
self.check(
'x ^ 2 y',
Expression('Times',
Expression('Power', Symbol('Global`x'), Integer(2)),
Symbol('Global`y')))
def testComment(self):
self.check('145 (* abf *) 345',
Expression('Times', Integer(145), Integer(345)))
def apply_empty(self, evaluation):
'ToExpression[]'
evaluation.message('ToExpression', 'argb', 'ToExpression', Integer(0),
Integer(1), Integer(3))
return
def apply_strse2(self, x, y, evaluation):
'StringSplit[x_/;Not[StringQ[x]], y_]'
evaluation.message('StringSplit', 'strse', Integer(1),
Expression('StringSplit', x))
return
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):
return Integer(expr)
if isinstance(expr, float):
return Real(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 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 Expression('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 Expression('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', )
else:
raise ValueError("Unknown SymPy expression: %s" % expr)
def testCompare(self):
self.check('1 == 2', Expression('Equal', Integer(1), Integer(2)))
self.check('1 != 2', Expression('Unequal', Integer(1), Integer(2)))
self.check('1 == 2 == 3',
Expression('Equal', Integer(1), Integer(2), Integer(3)))
self.check('1 != 2 != 3',
Expression('Unequal', Integer(1), Integer(2), Integer(3)))
self.check('1 > 2', Expression('Greater', Integer(1), Integer(2)))
self.check('1 >= 2', Expression('GreaterEqual', Integer(1),
Integer(2)))
self.check('1 < 2', Expression('Less', Integer(1), Integer(2)))
self.check('1 <= 2', Expression('LessEqual', Integer(1), Integer(2)))
self.check('1 > 2 > 3',
Expression('Greater', Integer(1), Integer(2), Integer(3)))
self.check(
'1 >= 2 >= 3',
Expression('GreaterEqual', Integer(1), Integer(2), Integer(3)))
self.check('1 < 2 < 3',
Expression('Less', Integer(1), Integer(2), Integer(3)))
self.check('1 <= 2 <= 3',
Expression('LessEqual', Integer(1), Integer(2), Integer(3)))
self.check('1 === 2', Expression('SameQ', Integer(1), Integer(2)))
self.check('1 =!= 2', Expression('UnsameQ', Integer(1), Integer(2)))
self.check('1 === 2 === 3',
Expression('SameQ', Integer(1), Integer(2), Integer(3)))
self.check('1 =!= 2 =!= 3',
Expression('UnsameQ', Integer(1), Integer(2), Integer(3)))
def p_slot(self, args):
'expr : slot'
args[0] = Expression('Slot', Integer(args[1]))
def testRepeated(self):
self.check('1..', Expression('Repeated', Integer(1)))
self.check('1...', Expression('RepeatedNull', Integer(1)))
def p_out(self, args):
'expr : out'
if args[1] == -1:
args[0] = Expression('Out')
else:
args[0] = Expression('Out', Integer(args[1]))
def testAlternatives(self):
self.check('1 | 2', Expression('Alternatives', Integer(1), Integer(2)))
self.check(
'1 | 2 | 3',
Expression('Alternatives', Integer(1), Integer(2), Integer(3)))
def p_Minus(self, args):
'expr : expr Minus expr'
args[0] = Expression('Plus', args[1], Expression('Times', Integer(-1), args[3]))
def testPart(self):
self.check('a[[1]]', Expression('Part', Symbol('Global`a'),
Integer(1)))
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 testSlot(self):
self.check('#2', Expression('Slot', Integer(2)))
self.check('#', Expression('Slot', Integer(1)))
self.check('##2', Expression('SlotSequence', Integer(2)))
self.check('##', Expression('SlotSequence', Integer(1)))
self.check('%2', Expression('Out', Integer(2)))
def evaluate(self, evaluation) -> Integer:
return Integer(os.getpid())
def testOut(self):
self.check('%%', Expression('Out', Integer(-2)))
self.check('%%%%', Expression('Out', Integer(-4)))
self.check('%', Expression('Out'))
def evaluate(self, evaluation) -> Integer:
totalmem = psutil.virtual_memory().total
return Integer(totalmem)
def testNonAscii(self):
self.check('z \\[Conjugate]',
Expression('Conjugate', Symbol('Global`z')))
self.check('z \\[Transpose]',
Expression('Transpose', Symbol('Global`z')))
self.check('z \\[ConjugateTranspose]',
Expression('ConjugateTranspose', Symbol('Global`z')))
self.check(u'z \uf3c7 ', Expression('Transpose', Symbol('Global`z')))
self.check(u'z \uf3c8 ', Expression('Conjugate', Symbol('Global`z')))
self.check(u'z \uf3c9 ',
Expression('ConjugateTranspose', Symbol('Global`z')))
self.check(
'\\[Integral] x \\[DifferentialD] x',
Expression('Integrate', Symbol('Global`x'), Symbol('Global`x')))
self.check('\\[Del] x', Expression('Del', Symbol('Global`x')))
self.check('\\[Square] x', Expression('Square', Symbol('Global`x')))
self.check('1 \\[SmallCircle] 2',
Expression('SmallCircle', Integer(1), Integer(2)))
self.check(
'1 \\[SmallCircle] 2 \\[SmallCircle] 3',
Expression('SmallCircle', Integer(1), Integer(2), Integer(3)))
self.check(u'1 \u2218 2',
Expression('SmallCircle', Integer(1), Integer(2)))
self.check('1 \\[CircleDot] 2',
Expression('CircleDot', Integer(1), Integer(2)))
self.check(u'1 \u2299 2',
Expression('CircleDot', Integer(1), Integer(2)))
self.check('1 \\[Diamond] 2',
Expression('Diamond', Integer(1), Integer(2)))
self.check('1 \\[Wedge] 2', Expression('Wedge', Integer(1),
Integer(2)))
self.check('1 \\[Vee] 2', Expression('Vee', Integer(1), Integer(2)))
self.check('1 \\[CircleTimes] 2',
Expression('CircleTimes', Integer(1), Integer(2)))
self.check('1 \\[CenterDot] 2',
Expression('CenterDot', Integer(1), Integer(2)))
self.check('1 \\[Star] 2', Expression('Star', Integer(1), Integer(2)))
self.check('a \\[Cap] b', 'Cap[a,b]')
self.check('a \\[Cup] b \\[Cup] c', 'Cup[a,b,c]')
self.check(u'a \u2322 b \u2322 c', 'Cap[a,b,c]')
self.check(u'a \u2323 b', 'Cup[a, b]')
self.check(u'1 \u22C4 2', Expression('Diamond', Integer(1),
Integer(2)))
self.check(u'1 \u22C0 2', Expression('Wedge', Integer(1), Integer(2)))
self.check(u'1 \u22c1 2', Expression('Vee', Integer(1), Integer(2)))
self.check(u'1 \u2297 2',
Expression('CircleTimes', Integer(1), Integer(2)))
self.check(u'1 \u00B7 2',
Expression('CenterDot', Integer(1), Integer(2)))
self.check(u'1 \u22C6 2', Expression('Star', Integer(1), Integer(2)))
self.check(
'expr1 ** expr2',
Expression('NonCommutativeMultiply', Symbol('Global`expr1'),
Symbol('Global`expr2')))
self.check(
'expr1 ** expr2 ** expr3',
Expression('NonCommutativeMultiply', Symbol('Global`expr1'),
Symbol('Global`expr2'), Symbol('Global`expr3')))
self.check('1 \\[Cross] 2', Expression('Cross', Integer(1),
Integer(2)))
self.check(u'1 \uf4a0 2', Expression('Cross', Integer(1), Integer(2)))
self.check(
'3\\[Divide]2',
Expression('Times', Integer(3),
Expression('Power', Integer(2), Integer(-1))))
self.check(
u'3 \u00f7 2',
Expression('Times', Integer(3),
Expression('Power', Integer(2), Integer(-1))))
self.check('3\\2', Expression('Backslash', Integer(3), Integer(2)))
self.check('1 \\[Times] 2', Expression('Times', Integer(1),
Integer(2)))
self.check(u'1 \u00d7 2', Expression('Times', Integer(1), Integer(2)))
self.check('1 \[PlusMinus] 2',
Expression('PlusMinus', Integer(1), Integer(2)))
self.check('1 \[MinusPlus] 2',
Expression('MinusPlus', Integer(1), Integer(2)))
self.check('\[PlusMinus] 1', Expression('PlusMinus', Integer(1)))
self.check('\[MinusPlus] 1', Expression('MinusPlus', Integer(1)))
self.check(u'\u00b1 1', Expression('PlusMinus', Integer(1)))
self.check(u'\u2213 1', Expression('MinusPlus', Integer(1)))
self.check('1 \\[And] 2', Expression('And', Integer(1), Integer(2)))
self.check(u'1 \u2227 2', Expression('And', Integer(1), Integer(2)))
self.check('1 \\[Or] 2', Expression('Or', Integer(1), Integer(2)))
self.check(u'1 \u2228 2', Expression('Or', Integer(1), Integer(2)))
self.check('a \\[Colon] b',
Expression('Colon', Symbol('Global`a'), Symbol('Global`b')))
self.check(u'a \u2236 b',
Expression('Colon', Symbol('Global`a'), Symbol('Global`b')))
self.check('x \\[Function] y', 'Function[{x}, y]')
self.check(u'x \uf4a1 y', 'Function[{x}, y]')
self.check('x1 \\[RightTee] x2', 'RightTee[x1, x2]')
self.check('x1 \\[DoubleRightTee] x2', 'DoubleRightTee[x1, x2]')
self.check('x1 \\[LeftTee] x2', 'LeftTee[x1, x2]')
self.check('x1 \\[DoubleLeftTee] x2', 'DoubleLeftTee[x1, x2]')
def evaluate(self, evaluation) -> Integer:
return Integer(-1)
def testInteger(self):
_test_group(Integer(5), Integer(3242), Integer(-1372))
