updated evaluation to accept new data structure from front end

HarrySu123 · HarrySu123 · commit f6e60eb8097e · 2026-02-08T22:54:14.000Z
diff --git a/docs/dev.md b/docs/dev.md
@@ -12,13 +12,18 @@ Select the sort of evlauation you want to using the check box. Make sure to only
   "response":"<str>",
   "answer":"<str>",
   "params": {
+    "truthTable": "<bool>",
     "equivalence": "<bool>",
     "tautology": "<bool>",
     "satisfiability": "<bool>",
   }
 }
 ```
 
+### `truthTable`
+
+uses the evaluation for truth tables
+
 ### `equivalence`
 
 checks if response formula and answer formula are equivalent
diff --git a/evaluation_function/evaluation.py b/evaluation_function/evaluation.py
@@ -5,10 +5,10 @@
 from evaluation_function.domain.formula import *
 
 from evaluation_function.parsing.parser import formula_parser
-
-
 from evaluation_function.parsing.tree_builder_error import BuildError
 
+from evaluation_function.truth_table.evaluate import evaluate_truth_table
+
 
 def evaluation_function(
     response: Any,
@@ -39,16 +39,70 @@ def evaluation_function(
     """
 
 
-    # if not isinstance(answer, str):
-    #     raise Exception("Answer must be a string/text.")
-    
+    if not isinstance(answer, str):
+        raise Exception("Answer must be a string/text.")
 
-    if not isinstance(response, str):
+        
+    response_formula = response.get("formula", None)
+    if not isinstance(response_formula, str):
         return Result(
             is_correct=False,
             feedback_items=[("incorrect input", "response must be type String")]
         )
 
+    # parse response_formula into Formula
+    try:
+        formula = formula_parser(response_formula)
+    
+    except BuildError as e:
+        return Result(
+            is_correct=False,
+            feedback_items=[(BuildError, str(e))]
+        )
+    except ValueError as e:
+        return Result(
+            is_correct=False,
+            feedback_items=[(ValueError, str(e))]
+        )
+
+
+
+    # check if input is a truth table
+    truth_table = response.get("truthTable", None)
+    if truth_table is not None and isinstance(truth_table, dict):
+
+        variables = truth_table.get("variables", [])
+        cells = truth_table.get("cells", [])
+        
+        if not isinstance(variables, list) or not isinstance(cells, list):
+            return Result(
+                is_correct=False,
+                feedback_items=[("incorrect input", "truthTable must contain 'variables' and 'cells' arrays")]
+            )
+
+        # tokenise answer 
+        try:
+            answer_formula = formula_parser(answer)
+        
+        except BuildError as e:
+            return Result(
+                is_correct=False,
+                feedback_items=[("BuildError", str(e))]
+            )
+        except ValueError as e:
+            return Result(
+                is_correct=False,
+                feedback_items=[("ValueError", str(e))]
+            )
+
+        num_atoms = len(_extract_atoms(answer_formula))
+        
+        # Evaluate the truth table
+        truth_table_result = evaluate_truth_table(variables, cells, num_atoms)
+        if not truth_table_result.is_correct:
+            return truth_table_result
+
+
     
     # check only one of "equivilance", "tautology", "satisfiability" is selected
     
@@ -71,28 +125,11 @@ def evaluation_function(
             feedback_items=[("invalid param", "please only select 1 param")]
         )
 
-
     
     feedback   = None
     is_correct = False
 
 
-    # parse response into Formula
-    try:
-        formula = formula_parser(response)
-    
-    except BuildError as e:
-        return Result(
-            is_correct=False,
-            feedback_items=[(BuildError, str(e))]
-        )
-    except ValueError as e:
-        return Result(
-            is_correct=False,
-            feedback_items=[(ValueError, str(e))]
-        )
-
-
     if equivalence:
 
         # tokenise answer 
diff --git a/evaluation_function/truth_table/evaluate.py b/evaluation_function/truth_table/evaluate.py
@@ -14,32 +14,32 @@
 from evaluation_function.parsing.tree_builder_error import BuildError
 
 
-# assume table sent through is of type list[list[str]]
-def evaluate_truth_table(input: list[list[str]], num_atoms) -> Result:
+def evaluate_truth_table(variables: list[str], cells: list[list[str]], num_atoms) -> Result:
     """
     Function used to evaluate truth table response
     ---
     
-    - `input` the 2D array containing the formuals and the cells of the truth table
+    - `variables` array of formula strings (columns of the truth table)
+    - `cells` the 2D array containing only the truth/false values
     - `num_atoms` the number of atoms in the truth table
 
     returns True if truth table is valid
     """
 
-    if len(input) == 0:
+    if len(variables) == 0:
         return Result(
             is_correct=False,
-            feedback_items=[(Exception, "no input was given")]
+            feedback_items=[(Exception, "no variables provided")]
         )
-        
-    elif len(input) == 1:
+    
+    if len(cells) == 0:
         return Result(
             is_correct=False,
-            feedback_items=[(Exception, "Must provide names and its truth values")]
+            feedback_items=[(Exception, "no cells provided")]
         )
 
     # find the atoms of the formula
-    formulas = input[0]
+    formulas = variables
     existing_atoms = {}
 
     for i in range(len(formulas)):
@@ -87,12 +87,12 @@ def evaluate_truth_table(input: list[list[str]], num_atoms) -> Result:
 
     # check all the cells are valid:
 
-    for i in range(1, len(input)):
-        for j in range(len(input[i])):
-            if input[i][j] == "tt":
-                input[i][j] = True
-            elif input[i][j] == "ff":
-                input[i][j] = False
+    for i in range(len(cells)):
+        for j in range(len(cells[i])):
+            if cells[i][j] == "tt":
+                cells[i][j] = True
+            elif cells[i][j] == "ff":
+                cells[i][j] = False
             else:
                 return Result(
                     is_correct=False,
@@ -107,19 +107,19 @@ def evaluate_truth_table(input: list[list[str]], num_atoms) -> Result:
             is_correct=False,
             feedback_items=[(Exception, f"missing combinations in truth table")]
         )
-    if len(input) - 1 < 2 ** num_atoms:
+    if len(cells) < 2 ** num_atoms:
         return Result(
             is_correct=False,
             feedback_items=[(Exception, f"missing combinations in truth table")]
         )
-    if len(input) - 1 > 2 ** num_atoms:
+    if len(cells) > 2 ** num_atoms:
         return Result(
             is_correct=False,
             feedback_items=[(Exception, f"excessive combinations in truth table")]
         )
 
 
-    unique_rows = set(tuple(row[cell] for cell in existing_atoms.values()) for row in input[1:])
+    unique_rows = set(tuple(row[cell] for cell in existing_atoms.values()) for row in cells)
     if len(unique_rows) != 2 ** num_atoms:
         return Result(
             is_correct=False,
@@ -129,17 +129,17 @@ def evaluate_truth_table(input: list[list[str]], num_atoms) -> Result:
     
     # evaluate truth table row by row
 
-    for i in range(1, len(input)):
+    for i in range(len(cells)):
         atoms_mapping = {}
-        for j in range(len(input[i])):
+        for j in range(len(cells[i])):
             formula = formulas[j]
 
             if isinstance(formula, Atom):
-                atoms_mapping[formula] = input[i][j]
+                atoms_mapping[formula] = cells[i][j]
                 continue
 
             assignment = Assignment(atoms_mapping)
-            if FormulaEvaluator(formula, assignment).evaluate() != input[i][j]:
+            if FormulaEvaluator(formula, assignment).evaluate() != cells[i][j]:
                 return Result(
                     is_correct=False,
                     feedback_items=[(Exception, "incorrect cell value")]
diff --git a/evaluation_function/truth_table/truth_table_evaluate_tests.py b/evaluation_function/truth_table/truth_table_evaluate_tests.py
