Add variable assignment and checking

README.md

@@ -49,6 +49,10 @@ python3 synthesizer.py --domain arithmetic --examples addition
 
 To add additional input-output examples, modify `examples.py`. Add a new key to the dictionary `example_set` and set the value to be a list of tuples.
 
+## 🔎 Abstract Syntax Tree
+
+The most important data structure in this implementation is the abstract syntax tree (AST). The AST is a tree representation of a program, where each node is either a primitive or a compound expression. The AST is represented by the `OperatorNode` class in `abstract_syntax_tree.py`. My AST implementation includes functions to recursively evaluate the operator and its operands, and also to generate a string representation of the program.
+
 ## 🔮 Virtual Environment
 
 To create a virtual environment, run:

abstract_syntax_tree.py

@@ -11,28 +11,40 @@ class OperatorNode:
         operator (object): operator object (e.g., Add, Subtract, etc.)
         children (list): list of children nodes (operands)
     
-    Example of usage:
+    Example:
+        add_node = OperatorNode(Add(), [IntegerConstant(7), IntegerConstant(5)])
+        subtract_node = OperatorNode(Subtract(), [IntegerConstant(3), IntegerConstant(1)])
+        multiply_node = OperatorNode(Multiply(), [add_node, subtract_node])
+        multiply_node.evaluate() # returns 24
+        multiply_node.str() # returns "((7 + 5) * (3 - 1))"
 
-    add_node = OperatorNode(Add(), [IntegerConstant(7), IntegerConstant(5)])
-    subtract_node = OperatorNode(Subtract(), [IntegerConstant(3), IntegerConstant(1)])
-    multiply_node = OperatorNode(Multiply(), [add_node, subtract_node])
+        For variable computation, the input arguments are passed to the evaluate() method.
+        For example, if instead:
+
+        add_node = OperatorNode(Add(), [IntegerVariable(0), IntegerConstant(5)])
+        multiply_node.evaluate([7]) # returns 24
     '''
+    
     def __init__(self, operator, children):
         self.operator = operator  # Operator object (e.g., Add, Subtract, etc.)
         self.children = children  # list of children nodes (operands)
 
-    def evaluate(self):
-        # check arity
+    def evaluate(self, input = None):
+
+        # check arity of operator in AST
         if len(self.children) != self.operator.arity:
             raise ValueError("Invalid number of operands for operator")
+        
         # recursively evaluate the operator and its operands
-        operands = [child.evaluate() for child in self.children]
-        return self.operator.evaluate(*operands)
+        operands = [child.evaluate(input) for child in self.children]
+        return self.operator.evaluate(*operands, input)
 
     def str(self):
-        # check arity
+
+        # check arity of operator in AST
         if len(self.children) != self.operator.arity:
             raise ValueError("Invalid number of operands for operator")
+        
         # recursively generate a string representation of the AST
         operand_strings = [child.str() for child in self.children]
         return self.operator.str(*operand_strings)

arithmetic.py

@@ -13,15 +13,39 @@ class IntegerVariable:
     For example, if the input is [4, 5, 6] and the variable is the third element (i.e., 6), then position = 2.
     '''
     def __init__(self, position):
-        self.value = None           # value of the variable, initially None
-        self.position = position    # position of the variable in the arguments to program
+        # self.value = None           # value of the variable, initially None
+        self.position = position    # zero-indexed position of the variable in the arguments to program
         self.type = int             # type of the variable
 
-    def assign(self, value):
-        self.value = value
+    # def assign(self, value):
+    #     self.value = value
 
-    def evaluate(self):
-        return self.value
+    # def evaluate(self, input = None):
+    #     # check that variable has been assigned a value
+    #     if self.value is None:
+    #         raise ValueError(f"Variable {self.position} has not been assigned a value.")
+
+    #     return self.value
+
+    def evaluate(self, input = None):
+
+        # check that input is not None
+        if input is None:
+            raise ValueError("Input is None.")
+
+        # check that input is a list
+        if type(input) != list:
+            raise ValueError("Input is not a list.")
+
+        # check that input is not empty
+        if len(input) == 0:
+            raise ValueError("Input is empty.")
+
+        # check that position is valid
+        if self.position >= len(input):
+            raise ValueError(f"Position {self.position} is out of range for input of length {len(input)}.")
+
+        return input[self.position]
     
     def str(self):
         return f"x{self.position}"
@@ -34,7 +58,7 @@ class IntegerConstant:
         self.value = value  # value of the constant
         self.type = int     # type of the constant
 
-    def evaluate(self):
+    def evaluate(self, input = None):
         return self.value
     
     def str(self):
@@ -50,7 +74,7 @@ class Add:
         self.return_type = int          # return type
         self.weight = 1                 # weight
 
-    def evaluate(self, x, y):
+    def evaluate(self, x, y, input = None):
         return x + y
     
     def str(self, x, y):
@@ -66,7 +90,7 @@ class Subtract:
         self.return_type = int          # return type
         self.weight = 1                 # weight
 
-    def evaluate(self, x, y):
+    def evaluate(self, x, y, input = None):
         return x - y
     
     def str(self, x, y):
@@ -82,7 +106,7 @@ class Multiply:
         self.return_type = int          # return type
         self.weight = 1                 # weight
 
-    def evaluate(self, x, y):
+    def evaluate(self, x, y, input = None):
         return x * y
     
     def str(self, x, y):
@@ -98,7 +122,7 @@ class Divide:
         self.return_type = int          # return type
         self.weight = 1                 # weight
 
-    def evaluate(self, x, y):
+    def evaluate(self, x, y, input = None):
         try: # check for division by zero error
             return x / y
         except ZeroDivisionError:

demonstration.ipynb

@@ -26,35 +26,12 @@
     "import argparse\n",
     "\n",
     "# import arithmetic module\n",
-    "# from arithmetic import *\n",
-    "# from abstract_syntax_tree import OperatorNode\n",
+    "from arithmetic import *\n",
+    "from abstract_syntax_tree import OperatorNode\n",
     "from examples import example_set, check_examples\n",
     "import config"
    ]
   },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "24"
-      ]
-     },
-     "execution_count": 14,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "add_node = OperatorNode(Add(), [IntegerConstant(7), IntegerConstant(5)])\n",
-    "subtract_node = OperatorNode(Subtract(), [IntegerConstant(3), IntegerConstant(1)])\n",
-    "multiply_node = OperatorNode(Multiply(), [add_node, subtract_node])\n",
-    "multiply_node.evaluate()"
-   ]
-  },
   {
    "cell_type": "markdown",
    "metadata": {},