Change calc module

- Create a method called `parse_algebra`. It takes a string of math and returns with a `pyparsing.ParseResults` object representing it.
- `evaluator` takes this tree and applies the old "parse actions" to it to get the same number as it used to.
- Change calc's API: `evaluator` to use `case_sensitive` rather than `cs`
- Add most of the capability for latex rendering

common/lib/calc/tests/test_preview.py

+# -*- coding: utf-8 -*-
+"""
+Unit tests for preview.py
+"""
+
+import unittest
+import preview
+import pyparsing
+
+
+class LatexRenderedTest(unittest.TestCase):
+    """
+    Test the initializing code for LatexRendered.
+
+    Specifically that it stores the correct data and handles parens well.
+    """
+    def test_simple(self):
+        """
+        Test that the data values are stored without changing.
+        """
+        math = 'x^2'
+        obj = preview.LatexRendered(math, tall=True)
+        self.assertEquals(obj.latex, math)
+        self.assertEquals(obj.sans_parens, math)
+        self.assertEquals(obj.tall, True)
+
+    def _each_parens(self, with_parens, math, parens, tall=False):
+        """
+        Helper method to test the way parens are wrapped.
+        """
+        obj = preview.LatexRendered(math, parens=parens, tall=tall)
+        self.assertEquals(obj.latex, with_parens)
+        self.assertEquals(obj.sans_parens, math)
+        self.assertEquals(obj.tall, tall)
+
+    def test_parens(self):
+        """ Test curvy parens. """
+        self._each_parens('(x+y)', 'x+y', '(')
+
+    def test_brackets(self):
+        """ Test brackets. """
+        self._each_parens('[x+y]', 'x+y', '[')
+
+    def test_squiggles(self):
+        """ Test curly braces. """
+        self._each_parens(r'\{x+y\}', 'x+y', '{')
+
+    def test_parens_tall(self):
+        """ Test curvy parens with the tall parameter. """
+        self._each_parens(r'\left(x^y\right)', 'x^y', '(', tall=True)
+
+    def test_brackets_tall(self):
+        """ Test brackets, also tall. """
+        self._each_parens(r'\left[x^y\right]', 'x^y', '[', tall=True)
+
+    def test_squiggles_tall(self):
+        """ Test tall curly braces. """
+        self._each_parens(r'\left\{x^y\right\}', 'x^y', '{', tall=True)
+
+    def test_bad_parens(self):
+        """ Check that we get an error with invalid parens. """
+        with self.assertRaisesRegexp(Exception, 'Unknown parenthesis'):
+            preview.LatexRendered('x^2', parens='not parens')
+
+
+class LatexPreviewTest(unittest.TestCase):
+    """
+    Run integrative tests for `latex_preview`.
+
+    All functionality was tested `RenderMethodsTest`, but see if it combines
+    all together correctly.
+    """
+    def test_no_input(self):
+        """
+        With no input (including just whitespace), see that no error is thrown.
+        """
+        self.assertEquals('', preview.latex_preview(''))
+        self.assertEquals('', preview.latex_preview('  '))
+        self.assertEquals('', preview.latex_preview(' \t '))
+
+    def test_number_simple(self):
+        """ Simple numbers should pass through. """
+        self.assertEquals(preview.latex_preview('3.1415'), '3.1415')
+
+    def test_number_suffix(self):
+        """ Suffixes should be escaped. """
+        self.assertEquals(preview.latex_preview('1.618k'), r'1.618\text{k}')
+
+    def test_number_sci_notation(self):
+        """ Numbers with scientific notation should display nicely """
+        self.assertEquals(
+            preview.latex_preview('6.0221413E+23'),
+            r'6.0221413\!\times\!10^{+23}'
+        )
+        self.assertEquals(
+            preview.latex_preview('-6.0221413E+23'),
+            r'-6.0221413\!\times\!10^{+23}'
+        )
+
+    def test_number_sci_notation_suffix(self):
+        """ Test numbers with both of these. """
+        self.assertEquals(
+            preview.latex_preview('6.0221413E+23k'),
+            r'6.0221413\!\times\!10^{+23}\text{k}'
+        )
+        self.assertEquals(
+            preview.latex_preview('-6.0221413E+23k'),
+            r'-6.0221413\!\times\!10^{+23}\text{k}'
+        )
+
+    def test_variable_simple(self):
+        """ Simple valid variables should pass through. """
+        self.assertEquals(preview.latex_preview('x', variables=['x']), 'x')
+
+    def test_greek(self):
+        """ Variable names that are greek should be formatted accordingly. """
+        self.assertEquals(preview.latex_preview('pi'), r'\pi')
+
+    def test_variable_subscript(self):
+        """ Things like 'epsilon_max' should display nicely """
+        self.assertEquals(
+            preview.latex_preview('epsilon_max', variables=['epsilon_max']),
+            r'\epsilon_{max}'
+        )
+
+    def test_function_simple(self):
+        """ Valid function names should be escaped. """
+        self.assertEquals(
+            preview.latex_preview('f(3)', functions=['f']),
+            r'\text{f}(3)'
+        )
+
+    def test_function_tall(self):
+        r""" Functions surrounding a tall element should have \left, \right """
+        self.assertEquals(
+            preview.latex_preview('f(3^2)', functions=['f']),
+            r'\text{f}\left(3^{2}\right)'
+        )
+
+    def test_function_sqrt(self):
+        """ Sqrt function should be handled specially. """
+        self.assertEquals(preview.latex_preview('sqrt(3)'), r'\sqrt{3}')
+
+    def test_function_log10(self):
+        """ log10 function should be handled specially. """
+        self.assertEquals(preview.latex_preview('log10(3)'), r'\log_{10}(3)')
+
+    def test_function_log2(self):
+        """ log2 function should be handled specially. """
+        self.assertEquals(preview.latex_preview('log2(3)'), r'\log_2(3)')
+
+    def test_power_simple(self):
+        """ Powers should wrap the elements with braces correctly. """
+        self.assertEquals(preview.latex_preview('2^3^4'), '2^{3^{4}}')
+
+    def test_power_parens(self):
+        """ Powers should ignore the parenthesis of the last math. """
+        self.assertEquals(preview.latex_preview('2^3^(4+5)'), '2^{3^{4+5}}')
+
+    def test_parallel(self):
+        r""" Parallel items should combine with '\|'. """
+        self.assertEquals(preview.latex_preview('2||3'), r'2\|3')
+
+    def test_product_mult_only(self):
+        r""" Simple products should combine with a '\cdot'. """
+        self.assertEquals(preview.latex_preview('2*3'), r'2\cdot 3')
+
+    def test_product_big_frac(self):
+        """ Division should combine with '\frac'. """
+        self.assertEquals(
+            preview.latex_preview('2*3/4/5'),
+            r'\frac{2\cdot 3}{4\cdot 5}'
+        )
+
+    def test_product_single_frac(self):
+        """ Division should ignore parens if they are extraneous. """
+        self.assertEquals(
+            preview.latex_preview('(2+3)/(4+5)'),
+            r'\frac{2+3}{4+5}'
+        )
+
+    def test_product_keep_going(self):
+        """
+        Complex products/quotients should split into many '\frac's when needed.
+        """
+        self.assertEquals(
+            preview.latex_preview('2/3*4/5*6'),
+            r'\frac{2}{3}\cdot \frac{4}{5}\cdot 6'
+        )
+
+    def test_sum(self):
+        """ Sums should combine its elements. """
+        # Use 'x' as the first term (instead of, say, '1'), so it can't be
+        # interpreted as a negative number.
+        self.assertEquals(
+            preview.latex_preview('-x+2-3+4', variables=['x']),
+            '-x+2-3+4'
+        )
+
+    def test_sum_tall(self):
+        """ A complicated expression should not hide the tallness. """
+        self.assertEquals(
+            preview.latex_preview('(2+3^2)'),
+            r'\left(2+3^{2}\right)'
+        )
+
+    def test_complicated(self):
+        """
+        Given complicated input, ensure that exactly the correct string is made.
+        """
+        self.assertEquals(
+            preview.latex_preview('11*f(x)+x^2*(3||4)/sqrt(pi)'),
+            r'11\cdot \text{f}(x)+\frac{x^{2}\cdot (3\|4)}{\sqrt{\pi}}'
+        )
+
+        self.assertEquals(
+            preview.latex_preview('log10(1+3/4/Cos(x^2)*(x+1))',
+                                  case_sensitive=True),
+            (r'\log_{10}\left(1+\frac{3}{4\cdot \text{Cos}\left(x^{2}\right)}'
+             r'\cdot (x+1)\right)')
+        )
+
+    def test_syntax_errors(self):
+        """
+        Test a lot of math strings that give syntax errors
+
+        Rather than have a lot of self.assertRaises, make a loop and keep track
+        of those that do not throw a `ParseException`, and assert at the end.
+        """
+        bad_math_list = [
+            '11+',
+            '11*',
+            'f((x)',
+            'sqrt(x^)',
+            '3f(x)',  # Not 3*f(x)
+            '3|4',
+            '3|||4'
+        ]
+        bad_exceptions = {}
+        for math in bad_math_list:
+            try:
+                preview.latex_preview(math)
+            except pyparsing.ParseException:
+                pass  # This is what we were expecting. (not excepting :P)
+            except Exception as error:  # pragma: no cover
+                bad_exceptions[math] = error
+            else:  # pragma: no cover
+                # If there is no exception thrown, this is a problem
+                bad_exceptions[math] = None
+
+        self.assertEquals({}, bad_exceptions)

common/lib/capa/capa/responsetypes.py

@@ -1748,15 +1748,23 @@ class FormulaResponse(LoncapaResponse):
                 student_variables[str(var)] = value
             # log.debug('formula: instructor_vars=%s, expected=%s' %
             # (instructor_variables,expected))
-            instructor_result = evaluator(instructor_variables, dict(),
-                                          expected, cs=self.case_sensitive)
+
+            # Call `evaluator` on the instructor's answer and get a number
+            instructor_result = evaluator(
+                instructor_variables, dict(),
+                expected, case_sensitive=self.case_sensitive
+            )
             try:
                 # log.debug('formula: student_vars=%s, given=%s' %
                 # (student_variables,given))
-                student_result = evaluator(student_variables,
-                                           dict(),
-                                           given,
-                                           cs=self.case_sensitive)
+
+                # Call `evaluator` on the student's answer; look for exceptions
+                student_result = evaluator(
+                    student_variables,
+                    dict(),
+                    given,
+                    case_sensitive=self.case_sensitive
+                )
             except UndefinedVariable as uv:
                 log.debug(
                     'formularesponse: undefined variable in given=%s' % given)

common/lib/xmodule/xmodule/tests/__init__.py

@@ -71,51 +71,6 @@ class ModelsTest(unittest.TestCase):
         vc_str = "<class 'xmodule.video_module.VideoDescriptor'>"
         self.assertEqual(str(vc), vc_str)
 
-    def test_calc(self):
-        variables = {'R1': 2.0, 'R3': 4.0}
-        functions = {'sin': numpy.sin, 'cos': numpy.cos}
-
-        self.assertTrue(abs(calc.evaluator(variables, functions, "10000||sin(7+5)+0.5356")) < 0.01)
-        self.assertEqual(calc.evaluator({'R1': 2.0, 'R3': 4.0}, {}, "13"), 13)
-        self.assertEqual(calc.evaluator(variables, functions, "13"), 13)
-        self.assertEqual(calc.evaluator({'a': 2.2997471478310274, 'k': 9, 'm': 8, 'x': 0.66009498411213041}, {}, "5"), 5)
-        self.assertEqual(calc.evaluator({}, {}, "-1"), -1)
-        self.assertEqual(calc.evaluator({}, {}, "-0.33"), -.33)
-        self.assertEqual(calc.evaluator({}, {}, "-.33"), -.33)
-        self.assertEqual(calc.evaluator(variables, functions, "R1*R3"), 8.0)
-        self.assertTrue(abs(calc.evaluator(variables, functions, "sin(e)-0.41")) < 0.01)
-        self.assertTrue(abs(calc.evaluator(variables, functions, "k*T/q-0.025")) < 0.001)
-        self.assertTrue(abs(calc.evaluator(variables, functions, "e^(j*pi)") + 1) < 0.00001)
-        self.assertTrue(abs(calc.evaluator(variables, functions, "j||1") - 0.5 - 0.5j) < 0.00001)
-        variables['t'] = 1.0
-        # Use self.assertAlmostEqual here...
-        self.assertTrue(abs(calc.evaluator(variables, functions, "t") - 1.0) < 0.00001)
-        self.assertTrue(abs(calc.evaluator(variables, functions, "T") - 1.0) < 0.00001)
-        self.assertTrue(abs(calc.evaluator(variables, functions, "t", cs=True) - 1.0) < 0.00001)
-        self.assertTrue(abs(calc.evaluator(variables, functions, "T", cs=True) - 298) < 0.2)
-        # Use self.assertRaises here...
-        exception_happened = False
-        try:
-            calc.evaluator({}, {}, "5+7 QWSEKO")
-        except:
-            exception_happened = True
-        self.assertTrue(exception_happened)
-
-        try:
-            calc.evaluator({'r1': 5}, {}, "r1+r2")
-        except calc.UndefinedVariable:
-            pass
-
-        self.assertEqual(calc.evaluator(variables, functions, "r1*r3"), 8.0)
-
-        exception_happened = False
-        try:
-            calc.evaluator(variables, functions, "r1*r3", cs=True)
-        except:
-            exception_happened = True
-        self.assertTrue(exception_happened)
-
-
 class PostData(object):
     """Class which emulate postdata."""
     def __init__(self, dict_data):