Fixed E being parsed as Eulers in preview (#235)

* Fixed E being parsed as Eulers in preview

* Removed E from the list of potentially placeholders

* Added note to dev.md for `E` parsing and added more tests for Euler preview

* Added link to PR

Author: m-messer

app/docs/dev.md

@@ -209,5 +209,7 @@ When the evaluation function preview is called the code in `preview.py` will be
 
 **Remark**: Since it is likely that there will be significant overlap between the response preview and the response evaluation (e.g. code for parsing and interpreting the response), it is good practice if they can share as much code as possible to ensure consistency. For this reason it might be better to move the preview functions fully inside the context (either by making a `preview` subfolder in the `context` folder, or by moving the implementation of the preview function inside the context files themselves). In this case the `preview.py` and `evaluation.py` could also share the same code for determining the right context to use.
 
+`E` is treated as `E` in when `is_latex` is enabled. As latex2sympy2 does not parse E correctly. More details can be found ont the PR: https://github.com/lambda-feedback/compareExpressions/pull/235
+
 # Tests
 There are two main groups of tests, evaluation tests and preview tests. The evaluation test can be run by calling `evaluation_tests.py`

app/evaluation_tests.py

@@ -1,6 +1,8 @@
 import pytest
 import os
 
+from app.preview import preview_function
+from app.utility.preview_utilities import Params
 from .evaluation import evaluation_function
 
 
@@ -92,5 +94,29 @@ def test_physical_qualities_no_tolerance(self):
         result = evaluation_function(response, answer, params)
         assert result["is_correct"] is False
 
+    def test_euler_preview_evaluate(self):
+        response = "ER_2"
+        params = Params(is_latex=True, elementary_functions=False, strict_syntax=False)
+        result = preview_function(response, params)
+        assert "preview" in result.keys()
+
+        preview = result["preview"]
+        assert preview["latex"] == "ER_2"
+        assert preview["sympy"] == "E*R_2"
+
+        params = {
+            "atol": 0.0,
+            "rtol": 0.0,
+            "strict_syntax": False,
+            "physical_quantity": False,
+            "elementary_functions": False,
+        }
+
+        response = preview["sympy"]
+        answer = "E*R_2"
+        result = evaluation_function(response, answer, params)
+        assert result["is_correct"] is True
+
+
 if __name__ == "__main__":
     pytest.main(['-xk not slow', '--tb=short', '--durations=10', os.path.abspath(__file__)])

app/preview_tests.py

@@ -77,15 +77,39 @@ def test_natural_logarithm_notation(self):
         assert preview["latex"] == r"\ln{\left(x \right)}"
 
     @pytest.mark.parametrize(
-        "response, response_latex, response_sympy", [
-            ("e", "e", "E",),
-            ("oo", "\\infty", "oo"),
-            ("ex", "e \\cdot x", "Ex"),
-            ("e * x", "e \\cdot x", "E * x")
+        "response, is_latex, elementary_functions,  response_latex, response_sympy", [
+            ("e", False, True, "e", "E",),
+            ("oo", False, True, "\\infty", "oo"),
+            ("ex", False, True, "e \\cdot x", "Ex"),
+            ("e * x", False, True,  "e \\cdot x", "E * x"),
+            ("E", False, True, "e", "E", ),
+            ("e", False, False, "e", "e",),
+            ("ex", False, False, "e \\cdot x", "ex"),
+            ("e * x", False, False, "e \\cdot x", "e * x"),
+            ("E", False, False, "E", "E",),
+            ("E", True, True, "E", "E",),
+            ("e", True, False, "e", "E",),
+            ("ex", True, False, "ex", "E*x"),
+            ("e * x", True, False, "e * x", "E*x"),
+            ("E", True, False, "E", "E",),
+            ("ER_2", True, False, "ER_2", "E*R_2",),
+            # TODO: add exp (0), (1), (2) and (x)
+            ("exp(1)", False, True, "e^{1}", "exp(1)"),
+            ("e**1", False, True, "e^{1}", "E**1"),
+            ("e^{1}", True, True, "e^{1}", "E"),
+            ("exp(0)", False, True, "e^{0}", "exp(0)"),
+            ("e**0", False, True, "e^{0}", "E**0"),
+            ("e^{0}", True, True, "e^{0}", "1"),
+            ("exp(2)", False, True, "e^{2}", "exp(2)"),
+            ("e**2", False, True, "e^{2}", "E**2"),
+            ("e^{2}", True, True, "e^{2}", "exp(2)"),
+            ("exp(x)", False, True, "e^{x}", "exp(x)"),
+            ("e**x", False, True, "e^{x}", "E**x"),
+            ("e^{x}", True, True, "e^{x}", "exp(x)")
         ]
     )
-    def test_eulers_number_notation(self, response, response_latex, response_sympy):
-        params = Params(is_latex=False, elementary_functions=True, strict_syntax=False)
+    def test_eulers_number_notation(self, response, is_latex, elementary_functions, response_latex, response_sympy):
+        params = Params(is_latex=is_latex, elementary_functions=elementary_functions, strict_syntax=False)
         result = preview_function(response, params)
         assert "preview" in result.keys()
 

app/utility/preview_utilities.py

@@ -1,3 +1,4 @@
+import re
 from typing import TypedDict
 from typing_extensions import NotRequired
 
@@ -31,6 +32,40 @@ class Result(TypedDict):
     preview: Preview
 
 
+def find_placeholder(exp):
+    for char in 'abcdfghjkoqrtvwxyzABCDFGHIJKLMNOPQRSTUVWXYZ':
+        if char not in exp:
+            return char
+
+def preprocess_E(latex_str: str, placeholder: str) -> str:
+    """
+    Replace all symbols starting with 'E' (including plain 'E') with a
+    placeholder, so latex2sympy does not interpret 'E' as Euler's number.
+    """
+    # Replace E, E_x, ER_2, Efield, etc.
+    def repl(match):
+        token = match.group(0)
+        return placeholder + token[1:]
+
+    # Match E followed by optional subscript or alphanumeric/underscore
+    pattern = re.compile(r'(?<![\\a-zA-Z])E([A-Za-z0-9_]*(?:_\{[^}]*\})?)')
+    return pattern.sub(repl, latex_str)
+
+
+def postprocess_E(expr, placeholder):
+    """
+    Replace all placeholder symbols back to symbols starting with E.
+    """
+    subs = {}
+    for s in expr.free_symbols:
+        name = str(s)
+        if name.startswith(placeholder):
+            new_name = "E" + name[len(placeholder):]
+            subs[s] = Symbol(new_name)
+    return expr.xreplace(subs)
+
+
+
 def parse_latex(response: str, symbols: SymbolDict, simplify: bool, parameters=None) -> str:
     """Parse a LaTeX string to a sympy string while preserving custom symbols.
 
@@ -97,15 +132,20 @@ def parse_latex(response: str, symbols: SymbolDict, simplify: bool, parameters=N
     parsed_responses = set()
     for expression in response_set:
         try:
-            expression = latex2sympy(expression, substitutions)
-            if isinstance(expression, list):
-                expression = expression.pop()
+            e_placeholder = find_placeholder(expression)
+
+            expression_preprocessed = preprocess_E(expression, e_placeholder)
+            expression_parsed = latex2sympy(expression_preprocessed, substitutions)
+            if isinstance(expression_parsed, list):
+                expression_parsed = expression_parsed.pop()
+
+            expression_postprocess = postprocess_E(expression_parsed, e_placeholder)
             if simplify is True:
-                expression = expression.simplify()
+                expression_postprocess = expression_postprocess.simplify()
         except Exception as e:
             raise ValueError(str(e))
 
-        parsed_responses.add(str(expression.xreplace(substitutions)))
+        parsed_responses.add(str(expression_postprocess.xreplace(substitutions)))
 
     if len(parsed_responses) < 2:
         return parsed_responses.pop()