Fixed that mathematical expressions were not properly type set in feedback messages.

Author: KarlLundengaard

app/evaluation.py

@@ -22,19 +22,24 @@
 def feedback_not_dimensionless(groups):
     groups = list(groups)
     if len(groups) == 1:
-        return f"The group {str(groups[0])} is not dimensionless."
+        return f"The group {convert_to_latex(groups[0])} is not dimensionless."
     else:
-        return "The groups "+", ".join([str(g) for g in groups[0:-1]])+" and "+str(groups[-1])+" are not dimensionless."
+        return "The groups "+", ".join([convert_to_latex(g) for g in groups[0:-1]])+" and "+convert_to_latex(groups[-1])+" are not dimensionless."
 
+def convert_to_latex(expr):
+    if isinstance(expr, str):
+        return expr
+    else:
+        return "$"+latex(expr)+"$"
 
 buckingham_pi_feedback_responses = {
     "VALID_CANDIDATE_SET": "",
     "NOT_DIMENSIONLESS": feedback_not_dimensionless,
     "MORE_GROUPS_THAN_REFERENCE_SET": "Response has more groups than necessary.",
     "CANDIDATE_GROUPS_NOT_INDEPENDENT": lambda r, n: f"Groups in response are not independent. It has {r} independent group(s) and contains {n} groups.",
     "TOO_FEW_INDEPENDENT_GROUPS": lambda name, r, n: f"{name} contains too few independent groups. It has {r} independent group(s) and needs at least {n} independent groups.",
-    "UNKNOWN_SYMBOL": lambda symbols: "Unknown symbol(s): "+", ".join([str(s) for s in symbols])+".",
-    "SUM_WITH_INDEPENDENT_TERMS": lambda s: f"Sum in {s} group contains more independent terms that there are groups in total. Group expressions should ideally be written as a comma-separated list where each item is an entry of the form `q_1**c_1*q_2**c_2*...*q_n**c_n`."
+    "UNKNOWN_SYMBOL": lambda symbols: "Unknown symbol(s): "+", ".join([convert_to_latex(s) for s in symbols])+".",
+    "SUM_WITH_INDEPENDENT_TERMS": lambda s: f"Sum in {convert_to_latex(s)} contains more independent terms that there are groups in total. Group expressions should ideally be written as a comma-separated list where each item is an entry of the form `q_1**c_1*q_2**c_2*...*q_n**c_n`."
 }
 
 feedback_responses_list = [parsing_feedback_responses, buckingham_pi_feedback_responses]
@@ -320,7 +325,7 @@ def wrapped_function(*args):
             # Check that answers are dimensionless
             for k, dimension in enumerate(answer_dimensions):
                 if not dimension.is_constant():
-                    raise Exception(buckingham_pi_feedback_responses["NOT_DIMENSIONLESS"]("$"+latex(answer_groups[k])+"$"))
+                    raise Exception(buckingham_pi_feedback_responses["NOT_DIMENSIONLESS"](answer_groups[k]))
 
             # Check that there is a sufficient number of independent groups in the answer
             answer_matrix = get_exponent_matrix(answer_groups, answer_symbols)

app/evaluation_tests.py

@@ -509,9 +509,9 @@ def test_buckingham_pi_unknown_symbols(self):
         self.assertEqual_input_variations(response, answer, params, False)
         result = evaluation_function(response, answer, params)
         self.assertEqual(
-            buckingham_pi_feedback_responses["UNKNOWN_SYMBOL"](["p", "q"]) in result["feedback"]
+            buckingham_pi_feedback_responses["UNKNOWN_SYMBOL"](["$p$", "$q$"]) in result["feedback"]
             or
-            buckingham_pi_feedback_responses["UNKNOWN_SYMBOL"](["q", "p"]) in result["feedback"],
+            buckingham_pi_feedback_responses["UNKNOWN_SYMBOL"](["$q$", "$p$"]) in result["feedback"],
             True
         )
 
@@ -633,7 +633,7 @@ def test_buckingham_pi_two_groups_with_quantities_not_dimensionless(self):
         answer = "U*L/nu, f*L/U"
         response = "U*L/nu, U*nu/(f*L**2)"
         result = evaluation_function(response, answer, params)
-        self.assertEqual(buckingham_pi_feedback_responses["NOT_DIMENSIONLESS"]({"L*U/nu", }) in result["feedback"], True)
+        self.assertEqual(buckingham_pi_feedback_responses["NOT_DIMENSIONLESS"]({"$\frac{LU}{\nu}", }) in result["feedback"], True)
 
     def test_buckingham_pi_two_groups_with_quantities_too_few_independent_groups_in_answer(self):
         params = {"comparison": "buckinghamPi",
@@ -905,7 +905,7 @@ def test_buckingham_pi_example_in_examples_module(self):
             response = "q*U*L/nu"
             result = evaluation_function(response, answer, params)
             self.assertEqual(result["is_correct"], False)
-            self.assertEqual(buckingham_pi_feedback_responses["UNKNOWN_SYMBOL"]({"q"}) in result["feedback"], True)
+            self.assertEqual(buckingham_pi_feedback_responses["UNKNOWN_SYMBOL"]({"$q$"}) in result["feedback"], True)
             # two dimensionless groups that are not independent
             response = "U*L/nu, nu/U/L"
             result = evaluation_function(response, answer, params)
@@ -916,7 +916,7 @@ def test_buckingham_pi_example_in_examples_module(self):
             response = "U*L"
             result = evaluation_function(response, answer, params)
             self.assertEqual(result["is_correct"], False)
-            self.assertEqual(buckingham_pi_feedback_responses["NOT_DIMENSIONLESS"]({"L*U", }) in result["feedback"], True)
+            self.assertEqual(buckingham_pi_feedback_responses["NOT_DIMENSIONLESS"]({"$L U$", }) in result["feedback"], True)
         with self.subTest(tag="Part b)"):
             params = {
                 "comparison": "buckinghamPi",
@@ -950,14 +950,14 @@ def test_buckingham_pi_example_in_examples_module(self):
             response = "U*L/nu, f/U"
             result = evaluation_function(response, answer, params)
             self.assertEqual(result["is_correct"], False)
-            self.assertEqual(buckingham_pi_feedback_responses["NOT_DIMENSIONLESS"]({"f/U"}) in result["feedback"], True)
+            self.assertEqual(buckingham_pi_feedback_responses["NOT_DIMENSIONLESS"]({r"$\frac{f}{U}$"}) in result["feedback"], True)
             response = "L/nu, f/U"
             result = evaluation_function(response, answer, params)
             self.assertEqual(result["is_correct"], False)
             self.assertEqual(
-                buckingham_pi_feedback_responses["NOT_DIMENSIONLESS"](["L/nu", "f/U"]) in result["feedback"]
+                buckingham_pi_feedback_responses["NOT_DIMENSIONLESS"]([r"$\frac{L}{\nu}$", r"$\frac{f}{U}$"]) in result["feedback"]
                 or
-                buckingham_pi_feedback_responses["NOT_DIMENSIONLESS"](["f/U", "L/nu"]) in result["feedback"],
+                buckingham_pi_feedback_responses["NOT_DIMENSIONLESS"]([r"$\frac{f}{U}$", r"$\frac{L}{\nu}$"]) in result["feedback"],
                 True
             )
         with self.subTest(tag="Part c)"):