Improved syntax check to make it easier to check for variations of expressions using cases

If the use the criteria "response written as answer" it only checks the syntax, unlike the built in check from "syntactical_comparison". The generated feedback is worse though.

Author: KarlLundengaard

app/symbolic_comparison_evaluation.py

@@ -26,6 +26,7 @@
 from .syntactical_comparison_utilities import is_number as syntactical_is_number
 from .syntactical_comparison_utilities import response_and_answer_on_same_form
 from .syntactical_comparison_utilities import written_as_answer
+from .syntactical_comparison_utilities import written_as
 from .syntactical_comparison_utilities import attach_form_criteria
 
 from .criteria_graph_utilities import CriteriaGraph
@@ -54,6 +55,7 @@ def generate_criteria_parser():
         (" *; *",        "SEPARATOR"),
         ("response",     "EXPR"),
         (" *where *",    "WHERE"),
+        (" *written +as *","WRITTENAS"),
         ("answer",       "EXPR"),
         ("EQUAL",        "EQUAL"),
         ("EQUALS",       "EQUALS"),
@@ -69,6 +71,7 @@ def generate_criteria_parser():
         ("EQUAL",  "EQUAL where EQUALS", infix),
         ("EQUALS", "EQUAL;EQUAL", infix),
         ("EQUALS", "EQUALS;EQUAL", append_last),
+        ("BOOL", "EXPR written as EXPR", infix),
         ("EQUAL", "EXPR=EXPR", infix),
         ("EXPR",  "-EXPR", join),
         ("EXPR",  "EXPR-EXPR", infix),
@@ -116,12 +119,13 @@ def check_criterion(criterion, parameters_dict, generate_feedback=True):
             expr = parse_expression(sub.children[1].content_string(), parsing_params)
             local_subs.append((name, expr))
         result = check_criterion(crit, {**parameters_dict, **{"local_substitutions": local_subs}}, generate_feedback)
+    elif label == "WRITTENAS":
+        result = written_as(criterion.children[0].content, criterion.children[1].content, parameters_dict)
     elif label in criteria_operations.keys():
         result = criteria_operations[label](criterion.children, parameters_dict)
     return result
 
 def check_equality(criterion, parameters_dict):
-    
     reserved_expressions = list(parameters_dict["reserved_expressions"].items())
     local_substitutions = parameters_dict.get("local_substitutions",[])
     parsing_params = {key: value for (key,value) in parameters_dict["parsing_params"].items()}
@@ -842,7 +846,9 @@ def symbolic_comparison(response, answer, params, eval_response) -> dict:
 
     # Parse criteria
     criteria_parser = generate_criteria_parser()
-    parsing_params["unsplittable_symbols"] += ("response", "answer", "where")
+    reserved_keywords = ("response", "answer", "where", "written as")
+    parsing_params["unsplittable_symbols"] += reserved_keywords
+    params["reserved_keywords"] += reserved_keywords
     reserved_expressions = {
         "response": res,
         "answer": ans,

app/symbolic_comparison_evaluation_tests.py

@@ -1234,9 +1234,15 @@ def test_disabled_evaluation_nodes(self, response, answer, criteria, value, disa
             ("2*e**(2*I)", "2*e^(2*I)", "answer=response", True, ["answer=response_TRUE", "answer=response_SAME_SYMBOLS_TRUE", "answer=response_SYNTACTICAL_EQUIVALENCE_FALSE", "answer=response_SAME_FORM_EXPONENTIAL"], {}),
             ("e**(2*I)", "1*e^(2*I)", "answer=response", True, ["answer=response_TRUE", "answer=response_SAME_SYMBOLS_TRUE", "answer=response_SYNTACTICAL_EQUIVALENCE_FALSE", "answer=response_SAME_FORM_EXPONENTIAL"], {}),
             ("0.48+0.88*I", "1*e^(0.5*I)", "answer=response", False, ["answer=response_FALSE", "answer=response_SAME_FORM_UNKNOWN"], {}),
+            ("(x-4)^2-5", "(x-4)^2-5", "response written as answer", True, ["response written as answer_TRUE"], {"detailed_feedback": True}),
+            ("(x-5)^2-6", "(x-4)^2-5", "response written as answer", True, ["response written as answer_TRUE"], {"detailed_feedback": True}),
             ("(x-4)^2-5", "(x-4)^2-5", "answer=response", True, ["answer=response_TRUE", "answer=response_SAME_SYMBOLS_TRUE", "answer=response_WRITTEN_AS_ANSWER_TRUE"], {"detailed_feedback": True}),
+            ("(x-4)^2 - 5", "(x-4)^2-5", "answer=response", True, ["answer=response_TRUE", "answer=response_SAME_SYMBOLS_TRUE", "answer=response_WRITTEN_AS_ANSWER_TRUE"], {"detailed_feedback": True}),
             ("x^2-8x+11", "(x-4)^2-5", "answer=response", False, ["answer=response_TRUE", "answer=response_SAME_SYMBOLS_TRUE", "answer=response_WRITTEN_AS_ANSWER_FALSE"], {"detailed_feedback": True}),
             ("(x-3)^2-3", "(x-4)^2-5", "answer=response", False, ["answer=response_FALSE", "answer=response_WRITTEN_AS_ANSWER_TRUE"], {"detailed_feedback": True}),
+            ("(x+4)^2-5", "(x+(-4))^2-5", "response written as answer", True, ["response written as answer_TRUE"], {"detailed_feedback": True}),
+            ("(x-4)^2+5", "(x-4)^2+(-5)", "response written as answer", True, ["response written as answer_TRUE"], {"detailed_feedback": True}),
+            ("(x+4)^2+5", "(x+(-4))^2+(-5)", "response written as answer", True, ["response written as answer_TRUE"], {"detailed_feedback": True}),
         ]
     )
     def test_syntactical_comparison(self, response, answer, criteria, value, feedback_tags, additional_params):

app/syntactical_comparison_utilities.py

@@ -2,6 +2,7 @@
 from .feedback.symbolic_comparison import feedback_generators as symbolic_feedback_generators
 from .criteria_graph_utilities import CriteriaGraph
 
+is_nonnegative_number_regex = '((0|[1-9]\d*)?(\.\d+)?(?<=\d)(e-?(0|[1-9]\d*))?)'
 is_number_regex = '(-?(0|[1-9]\d*)?(\.\d+)?(?<=\d)(e-?(0|[1-9]\d*))?)'
 
 def is_number(string):
@@ -25,22 +26,67 @@ def escape_regex_reserved_characters(string):
         string = string.replace(s,'\\'+s)
     return string
 
+#def generate_arbitrary_number_pattern_matcher(string):
+#    non_numbers = []
+#    number = re.search(is_number_regex, string)
+#    start = 0
+#    end = 0
+#    offset = 0
+#    while number is not None:
+#        start, end = number.span()
+#        start += offset
+#        end += offset
+#        non_number = escape_regex_reserved_characters(string[offset:start])
+#        non_number = ''.join(non_number.split())
+#        non_numbers.append(non_number)
+#        offset = end
+#        number = re.search(is_number_regex, string[offset:])
+#    non_numbers.append(string[offset:])
+#    pattern = is_number_regex.join(non_numbers)
+#    def matcher(comp_string):
+#        comp_string = ''.join(comp_string.split())
+#        result = re.fullmatch(pattern, comp_string)
+#        return result is not None
+#    return matcher
+
 def generate_arbitrary_number_pattern_matcher(string):
     non_numbers = []
-    number = re.search(is_number_regex, string)
+    number_pattern = '(\\('+is_number_regex+'\\))'
+    nonneg_number_pattern = is_nonnegative_number_regex
+    #number_pattern = '('+'(\\\\('+is_number_regex+'\\\\))'+'|'+is_nonnegative_number_regex+')'
+    full_pattern = '('+number_pattern+'|'+nonneg_number_pattern+')'
+    number = re.search(number_pattern, string)
+    nonneg_number = re.search(nonneg_number_pattern, string)
     start = 0
     end = 0
     offset = 0
-    while number is not None:
-        start, end = number.span()
+    while (number is not None) or (nonneg_number is not None):
+        start_number = len(string)
+        end_number = len(string)
+        start_nonneg_number = len(string)
+        end_nonneg_number = len(string)
+        if number is not None:
+            start_number, end_number = number.span()
+        if nonneg_number is not None:
+            start_nonneg_number, end_nonneg_number = nonneg_number.span()
+        if start_number < start_nonneg_number:
+            start, end = number.span()
+        else:
+            start, end = nonneg_number.span()
         start += offset
         end += offset
-        non_numbers.append(escape_regex_reserved_characters(string[offset:start]))
+        non_number = escape_regex_reserved_characters(string[offset:start])
+        if len(non_number) > 0:
+            non_number = '('+non_number+')'
+        non_number = ''.join(non_number.split())
+        non_numbers.append(non_number)
         offset = end
-        number = re.search(is_number_regex, string[offset:])
+        number = re.search(number_pattern, string[offset:])
+        nonneg_number = re.search(nonneg_number_pattern, string[offset:])
     non_numbers.append(string[offset:])
-    pattern = is_number_regex.join(non_numbers)
+    pattern = full_pattern.join(non_numbers)
     def matcher(comp_string):
+        comp_string = ''.join(comp_string.split())
         result = re.fullmatch(pattern, comp_string)
         return result is not None
     return matcher
@@ -97,4 +143,16 @@ def inner(unused_input):
         else:
             matches_found.add(label+"_FALSE")
         return matches_found
-    return inner
+    return inner
+
+def written_as(comp, ref, parameters_dict):
+    if ref == "answer":
+        ref = parameters_dict["original_input"]["answer"]
+    elif ref == "response":
+        ref = parameters_dict["original_input"]["response"]
+    if comp == "answer":
+        comp = parameters_dict["original_input"]["answer"]
+    elif comp == "response":
+        comp = parameters_dict["original_input"]["response"]
+    matcher = generate_arbitrary_number_pattern_matcher(ref)
+    return matcher(comp)