added 'proportional to' criteria

Author: KarlLundengaard

app/context/symbolic.py

@@ -40,6 +40,8 @@ def check_criterion(criterion, parameters_dict, generate_feedback=True):
         result = check_order(criterion, parameters_dict)
     elif label == "CONTAINS":
         result = check_contains_symbol(criterion, parameters_dict)
+    elif label == "PROPORTIONAL_TO":
+        result = check_proportionality(criterion, parameters_dict)
     elif label == "WHERE":
         crit = criterion.children[0]
         subs = criterion.children[1]
@@ -149,6 +151,20 @@ def check_order(criterion, parameters_dict, local_substitutions=[]):
     return result
 
 
+def check_proportionality(criterion, parameters_dict, local_substitutions=[]):
+    lhs_expr, rhs_expr = create_expressions_for_comparison(criterion, parameters_dict, local_substitutions)
+    result = None
+    if lhs_expr.cancel().simplify().simplify() != 0:
+        result = (rhs_expr/lhs_expr).cancel().simplify()
+    elif rhs_expr.cancel().simplify().simplify() != 0:
+        result = (lhs_expr/rhs_expr).cancel().simplify()
+    if result == 0 or result is None:
+        result = False
+    else:
+        result = result.is_constant()
+    return result
+
+
 def check_contains_symbol(criterion, parameters_dict, local_substitutions=[]):
     lhs_expr, rhs_expr = create_expressions_for_comparison(criterion, parameters_dict, local_substitutions)
     result = rhs_expr in lhs_expr.atoms()
@@ -335,7 +351,7 @@ def same_symbols(unused_input):
     ans = parameters_dict["reserved_expressions"]["answer"]
     use_equality_equivalence = isinstance(res, Equality) or isinstance(ans, Equality)
 
-    # TODO: Make checking set quivalence its own context that calls symbolic comparisons instead
+    # TODO: Make checking set equivalence its own context that calls symbolic comparisons instead
     if use_set_equivalence is True:
         graph.add_evaluation_node(
             label,

app/evaluation.py

@@ -55,7 +55,7 @@ def determine_context(parameters):
             input_symbols_reserved_codes.append(input_symbol[0])
             input_symbols_reserved_aliases += [ip for ip in input_symbol[1] if len(ip.strip()) > 0]
 
-    reserved_keywords_codes = {"where", "written as", "contains"}
+    reserved_keywords_codes = {"where", "written as", "contains", "proportional to"}
     reserved_keywords_aliases = {"plus_minus", "minus_plus"}
     for re in parameters["reserved_expressions_strings"].values():
         reserved_keywords_aliases = reserved_keywords_aliases.union(set(re.keys()))

app/feedback/symbolic.py

@@ -69,3 +69,8 @@
     "EXPONENTIAL": "Response and answer are both written on exponential form.",  # None,
     "UNKNOWN": "The response is not written on the expected form.",
 }[tag]
+feedback_generators["PROPORTIONAL_TO"] = lambda tag: lambda inputs: {
+    "TRUE": None,
+    "FALSE": None,
+    "UNKNOWN": None,
+}[tag]

app/tests/example_tests.py

@@ -508,53 +508,105 @@ def test_syntactical_comparison(self, response, answer, criteria, value, feedbac
         assert set(feedback_tags) == set(result["tags"])
 
     @pytest.mark.parametrize(
-        "response, answer, criteria, value, feedback_tags, additional_params",
+        "response, value, tags",
+        [
+            (
+                "2a+2b+2c",
+                True,
+                [
+                    "response proportional to answer_TRUE",
+                ],
+            ),
+            (
+                "a+2b+3c",
+                False,
+                [
+                    "response proportional to answer_FALSE",
+                ],
+            ),
+            (
+                "pi*(a+b+c)",
+                True,
+                [
+                    "response proportional to answer_TRUE",
+                ],
+            ),
+            (
+                "x*(a+b+c)",
+                False,
+                [
+                    "response proportional to answer_FALSE",
+                ],
+            ),
+        ]
+    )
+    def test_custom_comparison_with_criteria_proportional(self, response, value, tags):
+        params = {
+            "strict_syntax": False,
+            "elementary_functions": True,
+            "criteria": "response proportional to answer",
+        }
+        answer = "a+b+c"
+        result = evaluation_function(response, answer, params, include_test_data=True)
+        assert result["is_correct"] is value
+        assert set(tags) == set(result["tags"])
+
+    @pytest.mark.parametrize(
+        "response, value, tags",
         [
             (
                 "2*x^2+0.5+0.25*sin(x)^2",
-                "2*x^2",
-                "answer <= response, 2+answer > response",
                 False,
                 [
                     "answer <= response_TRUE",
                     "2+answer > response_UNKNOWN",
-                ],
-                {
-                    "symbol_assumptions": "('x', 'real')"
-                }
+                ]
             ),
+        ]
+    )
+    def test_custom_comparison_with_criteria_order(self, response, value, tags):
+        params = {
+            "strict_syntax": False,
+            "elementary_functions": True,
+            "criteria": "answer <= response, 2+answer > response",
+            "symbol_assumptions": "('x', 'real')",
+        }
+        answer = "2*x^2"
+        result = evaluation_function(response, answer, params, include_test_data=True)
+        assert result["is_correct"] is value
+        assert set(tags) == set(result["tags"])
+
+    @pytest.mark.parametrize(
+        "response, value, tags",
+        [
             (
                 "pi*n",
-                "0",
-                "sin(response)=0, response contains n",
                 True,
                 [
                     "sin(response)=0_TRUE",
                     "sin(response)=0_SAME_SYMBOLS_TRUE",
                     "response contains n_TRUE",
                 ],
-                {
-                    "symbols": {
-                        "n": {
-                            "latex": r"\(n\)",
-                            "aliases": ["i", "k", "N", "I", "K"],
-                        },
-                    },
-                    "symbol_assumptions": "('n', 'integer')"
-                }
             ),
         ]
     )
-    def test_custom_comparison_with_criteria(self, response, answer, criteria, value, feedback_tags, additional_params):
+    def test_custom_comparison_with_criteria_contains(self, response, value, tags):
         params = {
             "strict_syntax": False,
             "elementary_functions": True,
-            "criteria": criteria,
+            "criteria": "sin(response)=0, response contains n",
+            "symbols": {
+                "n": {
+                    "latex": r"\(n\)",
+                    "aliases": ["i", "k", "N", "I", "K"],
+                },
+            },
+            "symbol_assumptions": "('n', 'integer')"
         }
-        params.update(additional_params)
+        answer = "0"
         result = evaluation_function(response, answer, params, include_test_data=True)
         assert result["is_correct"] is value
-        assert set(feedback_tags) == set(result["tags"])
+        assert set(tags) == set(result["tags"])
 
 if __name__ == "__main__":
     pytest.main(['-sk not slow', "--tb=line", os.path.abspath(__file__)])

app/utility/criteria_parsing.py

@@ -17,6 +17,7 @@
     (" *(>=?|<=?|ORDER) *", "ORDER"),  # less than (or equal), < (<=), greater than (or equal), > (>=)
     (" *where *", "WHERE"),
     (" *written +as *", "WRITTEN_AS"),
+    (" *proportional +to *", "PROPORTIONAL_TO"),
     (" *contains *", "CONTAINS"),
     (" *; *", "SEPARATOR"),
     (" *OTHER *", "OTHER", catch_undefined),
@@ -30,6 +31,10 @@
     ("BOOL", "EQUAL where EQUAL_LIST", infix),
     ("BOOL", "RESERVED written as OTHER", infix),
     ("BOOL", "RESERVED written as RESERVED", infix),
+    ("EQUAL", "OTHER proportional to OTHER", infix),
+    ("EQUAL", "RESERVED proportional to OTHER", infix),
+    ("EQUAL", "OTHER proportional to RESERVED", infix),
+    ("EQUAL", "RESERVED proportional to RESERVED", infix),
     ("BOOL", "RESERVED contains OTHER", infix),
     ("BOOL", "RESERVED contains RESERVED", infix),
     ("EQUAL_LIST", "EQUAL;EQUAL", infix),