Merge pull request #203 from lambda-feedback/tr170-basic-generic-syntactical-comparison

Improved syntax check to make it easier to check for variations of ex…

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)