def test_bad_strings(self):
for s in BAD_STRINGS:
try:
process_sympy(s)
except:
pass
else:
self.fail('No exception raised for bad input %s' % s)
def test_explicit_latex(self):
test_cases = [
('0x', Mul(0, x, evaluate=False)),
('0 = 0', Eq(0, 0)),
('0 = 1', Eq(0, 1)),
('10x = 10x', Eq(10 * x, 10 * x)),
(r'\sin ^ { - 1 } ( x )', asin(x)),
(r'\cos^{-1}x', acos(x)),
(r'\tan^ {-1 }x', atan(x)),
(r'\cot^ {-1 }x', acot(x)),
(r'\sinh^{-1}(x)', asinh(x)),
(r'\sqrt{-1}', I),
(r'\exp{x}', exp(x)),
(r'\exp(x)', exp(x)),
('e^{x}', E**x),
]
failed_tests = []
for s_l_expr, expr in test_cases:
l_expr = process_sympy(s_l_expr)
equiv = equivalent(expr, l_expr)
if not equiv:
print '%s %s' % (s_l_expr, 'PASSED' if equiv else 'FAILED')
failed_tests.append((s_l_expr, l_expr))
print 'sympy: %s\nlatex: %s\n' % (expr, l_expr)
if failed_tests:
print len(failed_tests), 'failed test cases'
assert len(failed_tests) == 0
def test_generated_cases(self):
failed_tests = []
n_tests = 20
print 'Generating', n_tests, 'test_cases\n'
for _ in np.arange(n_tests):
n_terms = np.random.randint(1, high=5)
expr = generate_term()
for _ in np.arange(n_terms - 1):
term = generate_term()
op = np.random.choice(ops)
if op == '+':
expr = expr + term
elif op == '-':
expr = expr - term
elif op == '*':
expr = expr * term
elif op == '/':
expr = expr / term
elif op == '^':
expr = expr**term
else:
assert False
s_l_expr = latex(expr)
try:
l_expr = process_sympy(s_l_expr)
equiv = equivalent(expr, l_expr)
e = None
except Exception as e:
# Parsing failed
l_expr = None
equiv = False
if not equiv:
print '%s %s' % (s_l_expr, 'PASSED' if equiv else 'FAILED')
failed_tests.append((s_l_expr, l_expr))
print 'sympy: %s\nlatex: %s' % (expr, l_expr)
if e is not None:
print e
print
if failed_tests:
print len(failed_tests), 'failed test cases'
assert len(failed_tests) == 0
def test_parsing_failures(self):
test_cases = [
r'\poo', # \poo is not a control sequence
r'\sqrt{\x}', # \x is not a control sequence
# Syntax errors
'(x',
'x)',
'{x',
'}x',
'x}',
'x{',
'{',
'}',
'x^',
'x_',
'x^_',
'x_^',
# Misinterpreted legitimate control sequences do not fail and give incorrect output; treat them as cases that should fail until interpreted
r'\frac{\partial^2U}{\partial y^2}', # partial derivative
r'\cos 90^\circ', # degrees
r'\cfrac{2}{1+\cfrac{2}{1+\cfrac{2}{1+\cfrac{2}{1}}}}', # continued fraction
r'\dfrac{1}{2}', # display mode
r'\binom{9}{3}', # binomial coefficient
]
failed_tests = []
for s_l_expr in test_cases:
try:
l_expr = process_sympy(s_l_expr)
passed = False
except:
passed = True
if not passed:
print '%s %s' % (s_l_expr, 'PASSED' if passed else 'FAILED')
failed_tests.append((s_l_expr, l_expr))
print ' %s\n' % l_expr
if failed_tests:
print len(failed_tests), 'failed test cases'
assert len(failed_tests) == 0
def test_nyi(self):
test_cases = [
r'\int^5_1 2x\,dx = 24', # small space \,
]
failed_tests = []
for s_l_expr in test_cases:
try:
l_expr = process_sympy(s_l_expr)
passed = True
e = None
except Exception as e:
passed = False
l_expr = None
if not passed:
failed_tests.append((s_l_expr, l_expr))
print '%s %s' % (s_l_expr, 'PASSED' if passed else 'FAILED')
if e is not None:
print '%s\n' % e
if failed_tests:
print len(failed_tests), 'failed test cases'
assert len(failed_tests) == 0
'student_answers': ['-3y + 2x']
}, {
'correct_answer':
'x\\times x',
'student_answers': ['x\\times x', 'x\\cdot x', 'x^2', '(\\sqrt{x})^{4}']
}, {
'correct_answer': '23e^{-1\\times \\sqrt{t^2}}',
'student_answers': ['23e^{-t}']
}, {
'correct_answer': 'a=x^2+1',
'student_answers': ['x^2+1=a']
}]
for answer_set in answer_sets:
correct_answer = answer_set['correct_answer']
correct_answer_parsed = process_sympy(answer_set['correct_answer'])
for student_answer in answer_set['student_answers']:
student_answer_parsed = process_sympy(student_answer)
print('correct_answer (c): ', correct_answer, correct_answer_parsed)
print('student_answer (a): ', student_answer, student_answer_parsed)
print('')
print('Expression Tree (srepr(c) == srepr(a)) =>',
srepr(correct_answer_parsed) == srepr(student_answer_parsed))
print('srepr(c) =>', srepr(correct_answer_parsed))
print('srepr(a) =>', srepr(student_answer_parsed))
print('')
# print('Structural (c == a) =>', correct_answer_parsed == student_answer_parsed)
print('Symbolic (simplify(c - s) == 0) =>',
simplify(correct_answer_parsed - student_answer_parsed) == 0)
print('simplified =>',
simplify(correct_answer_parsed - student_answer_parsed))
from latex2sympy import process_sympy
from sympy import *
import sys
sys.path.append("..")
theta = Symbol('theta', real=True)
latex = "\\begin{matrix}1&2\\\\3&4\\end{matrix}"
math = process_sympy(latex)
print("latex: %s to math: %s" % (latex, math))
latex = "\\begin{matrix}1&2\\\\3&4\\\\5&6\\end{matrix}"
math = process_sympy(latex)
print("latex: %s to math: %s" % (latex, math))
latex = "\\begin{matrix}1&2&3\\\\4&5&6\\\\7&8&9\\end{matrix}"
math = process_sympy(latex)
print("latex: %s to math: %s" % (latex, math))
latex = "\\begin{matrix}x^1&x^2&x^3\\\\y^1&y^2&y^3\\\\z^1&z^2&z^3\\end{matrix}"
math = process_sympy(latex)
print("latex: %s to math: %s" % (latex, math))
latex = "\\begin{matrix}x\\\\y\\end{matrix}"
math = process_sympy(latex)
print("latex: %s to math: %s" % (latex, math))
latex = "2\\cdot\\begin{matrix}x\\\\y\\end{matrix}"
math = process_sympy(latex)
print("latex: %s to math: %s" % (latex, math))
v = Matrix([1, 2])
# sub settings
sub_settings_symbols = {}
sub_settings_symbols[Symbol('M' + hashlib.md5('M'.encode()).hexdigest(),
real=True)] = M
sub_settings_symbols[Symbol('v' + hashlib.md5('v'.encode()).hexdigest(),
real=True)] = v
# one parameters
latex = "\\begin{matrix}1&2\\\\3&4\\end{matrix}\\cdot[!v!]"
equation_sympy_check = MatMul(
M, Symbol('v' + hashlib.md5('v'.encode()).hexdigest(), real=True))
equation_sympy_subs_check = MatMul(M, v)
# placeholders
equation_sympy = process_sympy(latex)
print('latex = %s' % latex)
print('equation_sympy = %s' % equation_sympy)
print('equation_sympy_check = %s' % equation_sympy_check)
print('equation_sympy = %s' % (srepr(equation_sympy)))
equation_sympy_subs = equation_sympy.subs(sub_settings_symbols, evaluate=False)
print('equation_sympy_subs = %s' % equation_sympy_subs)
print('equation_sympy_subs_check = %s' % equation_sympy_subs_check)
# two parameters
# sub settings
print('')
print('============== Two Parameters -> M*v = Matrix*Vector =============')
sub_settings_symbols = {}
def test_good_pairs(self):
for s, eq in GOOD_PAIRS:
print 'test_good_pairs:', 'input:', s, 'output:', str(eq)
self.assertEqual(process_sympy(s), eq)
def test_static_cases(self):
test_cases = [
# Linear algebra
1 * x,
Eq(8 * x, 0),
Eq(10 * x, 5),
Eq(x - 4 * x, -21),
Eq(3 * x, 21),
Eq(2 + 5, x),
Eq(3 * (x - 4), x),
Eq(12, 2 * x),
Eq(3 * (x - 4) / x, 1),
Eq(12 / x, 2),
0.5 * x + 0.1,
Rational(1, 10) + Rational(1, 2) * x,
Add(x, 2 * x, -3 * x, evaluate=False),
# Trigonometry
sin(x),
cos(x),
tan(x),
csc(x),
sec(x),
cot(x),
1 - sin(x)**2,
cos(x)**2,
Eq(sin(x)**2, x),
Eq(-x, 1 - cos(x)**2 - 2 * x),
sin(2 * x),
2 * sin(x) * cos(x),
Eq(1 - sin(2 * x), 0),
Eq(sin(x)**2, 2 * sin(x) * cos(x) - cos(x)**2),
cos(x * y),
acos(x),
Pow(cos(x), 1, evaluate=False),
Pow(cos(x), 0, evaluate=False),
# Hyperbolic functions
sinh(x),
cosh(x),
tanh(x),
#csch(x),
#sech(x),
#coth(x),
# Exponential
E,
sqrt(E),
E**x,
exp(x),
exp(ln(x), evaluate=False),
# Imaginary/Complex
I,
3 + 8 * I,
re(x + I * y, evaluate=False),
im(x + y * I, evaluate=False),
re(1 - I, evaluate=False),
im(1 - I, evaluate=False),
E**(I * theta),
# Infinity
oo,
Add(oo, oo, evaluate=False),
Add(oo, Mul(3, oo, evaluate=False), evaluate=False),
-oo,
Add(-oo, -oo, evaluate=False),
Mul(-2, oo, evaluate=False),
Mul(-2, -oo, evaluate=False),
Mul(-2, -oo, -5, evaluate=False),
# Calculus
Limit(x**2, x, theta),
# Miscellaneous
Abs(x),
parse_expr('n!'),
parse_expr('n!!'),
factorial2(2 * x + y),
pi,
Pow(0, 0, evaluate=False),
]
failed_tests = []
for expr in test_cases:
try:
s_l_expr = latex(expr)
l_expr = process_sympy(s_l_expr)
equiv = equivalent(expr, l_expr)
e = None
except Exception as e:
# Parsing failed
l_expr = None
equiv = False
if not equiv:
print '%s %s' % (s_l_expr, 'PASSED' if equiv else 'FAILED')
failed_tests.append((s_l_expr, l_expr))
print 'sympy: %s\nlatex: %s' % (expr, l_expr)
if e is not None:
print e
print
if failed_tests:
print len(failed_tests), 'failed test cases'
assert len(failed_tests) == 0
