Working AST representation

abstract_syntax_tree.py

@@ -0,0 +1,38 @@
+'''
+ABSTRACT SYNTAX TREE
+This file contains the Python class that defines the abstract syntax tree (AST) representation.
+'''
+
+class OperatorNode:
+    '''
+    Class to represent operator nodes (i.e., an operator and its operands) as an AST.
+
+    Args:
+        operator (object): operator object (e.g., Add, Subtract, etc.)
+        children (list): list of children nodes (operands)
+    
+    Example of usage:
+
+    add_node = OperatorNode(Add(), [IntegerConstant(7), IntegerConstant(5)])
+    subtract_node = OperatorNode(Subtract(), [IntegerConstant(3), IntegerConstant(1)])
+    multiply_node = OperatorNode(Multiply(), [add_node, subtract_node])
+    '''
+    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
+        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)
+
+    def str(self):
+        # check arity
+        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)

abstract_syntax_trees.py

@@ -1,5 +0,0 @@
-'''
-ABSTRACT SYNTAX TREES
-This file contains Python classes that define the abstract syntax tree (AST) for program synthesis.
-'''
-

arithmetic.py

@@ -20,6 +20,12 @@ class IntegerVariable:
     def assign(self, value):
         self.value = value
 
+    def evaluate(self):
+        return self.value
+    
+    def str(self):
+        return f"x{self.position}"
+
 class IntegerConstant:
     '''
     Class to represent an integer constant.
@@ -28,6 +34,12 @@ class IntegerConstant:
         self.value = value  # value of the constant
         self.type = int     # type of the constant
 
+    def evaluate(self):
+        return self.value
+    
+    def str(self):
+        return str(self.value)
+
 class Add:
     '''
     Operator to add two numerical values.
@@ -38,11 +50,11 @@ class Add:
         self.return_type = int          # return type
         self.weight = 1                 # weight
 
-    def __call__(self, x, y):
+    def evaluate(self, x, y):
         return x + y
     
-    def str(x, y):
-        return f"{x} + {y}"
+    def str(self, x, y):
+        return f"({x} + {y})"
 
 class Subtract:
     '''
@@ -54,11 +66,11 @@ class Subtract:
         self.return_type = int          # return type
         self.weight = 1                 # weight
 
-    def __call__(self, x, y):
+    def evaluate(self, x, y):
         return x - y
     
-    def str(x, y):
-        return f"{x} - {y}"
+    def str(self, x, y):
+        return f"({x} - {y})"
     
 class Multiply:
     '''
@@ -70,11 +82,11 @@ class Multiply:
         self.return_type = int          # return type
         self.weight = 1                 # weight
 
-    def __call__(self, x, y):
+    def evaluate(self, x, y):
         return x * y
     
-    def str(x, y):
-        return f"{x} * {y}" 
+    def str(self, x, y):
+        return f"({x} * {y})" 
 
 class Divide:
     '''
@@ -86,14 +98,14 @@ class Divide:
         self.return_type = int          # return type
         self.weight = 1                 # weight
 
-    def __call__(self, x, y):
+    def evaluate(self, x, y):
         try: # check for division by zero error
             return x / y
         except ZeroDivisionError:
             return None
     
-    def str(x, y):
-        return f"{x} / {y}"
+    def str(self, x, y):
+        return f"({x} / {y})"
 
 
 '''

demonstration.ipynb

@@ -27,10 +27,34 @@
     "\n",
     "# import arithmetic module\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": {},
@@ -40,7 +64,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -66,7 +90,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -176,7 +200,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -229,7 +253,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -267,7 +291,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [