Fixed bug with latex input that contained \pm or \mp

Author: KarlLundengaard

app/evaluation_tests.py

@@ -42,6 +42,17 @@ def test_eval_function_can_handle_latex_input(self):
         result = evaluation_function(response, answer, params)
         assert result["is_correct"] is True
 
+    def test_eval_function_preserves_order_in_latex_input(self):
+        response = r"c + a + b"
+        answer = "c + a + b"
+        params = {
+            "strict_syntax": False,
+            "elementary_functions": True,
+            "is_latex": True
+        }
+        result = evaluation_function(response, answer, params)
+        assert result["is_correct"] is True
+
     def test_AERO40007_1_6_instance_2024_25(self):
         params = {
             "strict_syntax": False,

app/tests/symbolic_preview_tests.py

@@ -77,6 +77,44 @@ def test_sympy_with_equality_symbol(self):
         preview = result["preview"]
         assert preview.get("latex") == "\\frac{x^{2} + x + x}{x} = 1"
 
+    def test_latex_with_plus_minus(self):
+        response = r"\pm \frac{3}{\sqrt{5}} i"
+        params = Params(
+            is_latex=True,
+            simplify=False,
+            complexNumbers=True,
+            symbols={
+                "I": {
+                    "latex": "$i$",
+                    "aliases": ["i"],
+                },
+                "plus_minus": {
+                    "latex": "$\\pm$",
+                    "aliases": ["pm", "+-"],
+                },
+            }
+        )
+        result = preview_function(response, params)
+        preview = result["preview"]
+        assert preview.get("sympy") in {'{3*(sqrt(5)/5)*I, -3*sqrt(5)/5*I}', '{-3*sqrt(5)/5*I, 3*(sqrt(5)/5)*I}'}
+        assert preview.get("latex") == r'\pm \frac{3}{\sqrt{5}} i'
+        response = r"4 \pm \sqrt{6}}"
+        params = Params(
+            is_latex=True,
+            simplify=False,
+            complexNumbers=True,
+            symbols={
+                "plus_minus": {
+                    "latex": "$\\pm$",
+                    "aliases": ["pm", "+-"],
+                },
+            }
+        )
+        result = preview_function(response, params)
+        preview = result["preview"]
+        assert preview.get("sympy") in {'{sqrt(6) + 4, 4 - sqrt(6)}', '{4 - sqrt(6), sqrt(6) + 4}'}
+        assert preview.get("latex") == r'4 \pm \sqrt{6}}'
+
     def test_latex_conversion_preserves_default_symbols(self):
         response = "\\mu + x + 1"
         params = Params(is_latex=True, simplify=False)

app/utility/expression_utilities.py

@@ -72,18 +72,25 @@ def _print_log(self, expr, exp=None):
 # -------- String Manipulation Utilities
 def create_expression_set(exprs, params):
     if isinstance(exprs, str):
-        exprs = [exprs]
+        if exprs.startswith('{') and exprs.endswith('}'):
+            exprs = [expr.strip() for expr in exprs[1:-1].split(',')]
+        else:
+            exprs = [exprs]
     expr_set = set()
-
     for expr in exprs:
         expr = substitute_input_symbols(expr, params)[0]
         if "plus_minus" in params.keys():
             expr = expr.replace(params["plus_minus"], "plus_minus")
+    
         if "minus_plus" in params.keys():
             expr = expr.replace(params["minus_plus"], "minus_plus")
+    
         if ("plus_minus" in expr) or ("minus_plus" in expr):
-            expr_set.add(expr.replace("plus_minus", "+").replace("minus_plus", "-"))
-            expr_set.add(expr.replace("plus_minus", "-").replace("minus_plus", "+"))
+            for pm_mp_ops in [("+","-"),("-","+")]:
+                expr_string = expr.replace("plus_minus", pm_mp_ops[0]).replace("minus_plus", pm_mp_ops[1]).strip()
+                while expr_string[0] == "+":
+                    expr_string = expr_string[1:]
+                expr_set.add(expr_string.strip())
         else:
             expr_set.add(expr)
 

app/utility/preview_utilities.py

@@ -1,13 +1,14 @@
 from typing import TypedDict
 from typing_extensions import NotRequired
 
-import sympy
+from sympy import Symbol
 from latex2sympy2 import latex2sympy
 
 from .expression_utilities import (
     extract_latex,
     SymbolDict,
     find_matching_parenthesis,
+    create_expression_set,
 )
 
 
@@ -27,38 +28,50 @@ class Result(TypedDict):
     preview: Preview
 
 
-def parse_latex(response: str, symbols: SymbolDict, simplify: bool) -> str:
+def parse_latex(response: str, symbols: SymbolDict, simplify: bool, parameters=None) -> str:
     """Parse a LaTeX string to a sympy string while preserving custom symbols.
 
     Args:
         response (str): The LaTeX expression to parse.
         symbols (SymbolDict): A mapping of sympy symbol strings and LaTeX
-        symbol strings.
+            symbol strings.
+        simplify (bool): If set to false the preview will attempt to preserve
+            the way that the response was written as much as possible. If set
+            to True the response will be simplified before the preview string
+            is generated.
+        parameters (dict): parameters used when generating sympy output when
+            the response is written in LaTeX
 
     Raises:
         ValueError: If the LaTeX string or symbol couldn't be parsed.
 
     Returns:
         str: The expression in sympy syntax.
     """
+    if parameters is None:
+        parameters = dict()
+
     substitutions = {}
 
     pm_placeholder = None
     mp_placeholder = None
 
     if r"\pm " in response or r"\mp " in response:
+        response_set = set()
         for char in 'abcdefghjkoqrtvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ':
             if char not in response and pm_placeholder is None:
                 pm_placeholder = char
+                substitutions[pm_placeholder] = Symbol(pm_placeholder, commutative=False)
             elif char not in response and mp_placeholder is None:
                 mp_placeholder = char
+                substitutions[mp_placeholder] = Symbol(mp_placeholder, commutative=False)
             if pm_placeholder is not None and mp_placeholder is not None:
                 break
-
-    if pm_placeholder is not None:
-        response = response.replace(r"\pm ", pm_placeholder)
-    if mp_placeholder is not None:
-        response = response.replace(r"\mp ", mp_placeholder)
+        for expr in create_expression_set(response.replace(r"\pm ",'plus_minus').replace(r"\mp ",'minus_plus'), parameters):
+            response_set.add(expr)
+        response = response_set
+    else:
+        response_set = {response}
 
     for sympy_symbol_str in symbols:
         symbol_str = symbols[sympy_symbol_str]["latex"]
@@ -72,28 +85,25 @@ def parse_latex(response: str, symbols: SymbolDict, simplify: bool) -> str:
                     f"Couldn't parse latex symbol {latex_symbol_str} "
                     f"to sympy symbol."
                 )
-            substitutions[latex_symbol] = sympy.Symbol(sympy_symbol_str)
-
-    substitutions.update({r"\pm ": pm_placeholder, r"\mp ": mp_placeholder})
-
-    try:
-        expression = latex2sympy(response, substitutions)
-        if isinstance(expression, list):
-            expression = expression.pop()
-        if simplify is True:
-            expression = expression.simplify()
-    except Exception as e:
-        raise ValueError(str(e))
-
-    result_str = str(expression.xreplace(substitutions))
-    for ph in [(pm_placeholder, "plus_minus"), (mp_placeholder, "minus_plus")]:
-        if ph[0] is not None:
-            result_str = result_str.replace("*"+ph[0]+"*", " "+ph[1]+" ")
-            result_str = result_str.replace(ph[0]+"*", " "+ph[1]+" ")
-            result_str = result_str.replace("*"+ph[0], " "+ph[1]+" ")
-            result_str = result_str.replace(ph[0], " "+ph[1]+" ")
-
-    return result_str
+            substitutions[latex_symbol] = Symbol(sympy_symbol_str)
+
+    parsed_responses = set()
+    for expression in response_set:
+        try:
+            expression = latex2sympy(expression, substitutions)
+            if isinstance(expression, list):
+                expression = expression.pop()
+            if simplify is True:
+                expression = expression.simplify()
+        except Exception as e:
+            raise ValueError(str(e))
+
+        parsed_responses.add(str(expression.xreplace(substitutions)))
+
+    if len(parsed_responses) < 2:
+        return parsed_responses.pop()
+    else:
+        return '{'+', '.join(parsed_responses)+'}'
 
 
 def sanitise_latex(response):