Upload program_translator.py

program_translator.py

@@ -0,0 +1,104 @@
+
+class ProgramTranslator(object):
+    def __init__(self, programDict, maxArity):
+        self.programDict = programDict
+        self.maxArity = maxArity
+
+        self.maxStack = 0
+
+    def functionToKey(self, function, withValInputs = True):
+        valInputs = ""
+        if withValInputs:
+            valInputs = "_" + ",".join(function["value_inputs"])
+        functionKey = function["function"] if "_" in function["function"] else \
+                      "_".join([function["function"], function["function"]])
+        return str(len(function["inputs"])) + "_" + functionKey + valInputs
+
+    def typeToKey(self, function, withValInputs = True):
+        valInputs = ""
+        if withValInputs:
+            valInputs = "_" + ",".join(function["value_inputs"])
+        functionKey = function["type"] if "_" in function["type"] else \
+                      "_".join([function["type"], function["type"]])
+        return str(len(function["inputs"])) + "_" + functionKey + valInputs
+
+    def keyToFunction(self, key):
+        assert key not in self.programDict.invalidSymbols
+        function = {}
+        parts = key.split("_")
+        arity = int(parts[0])
+        function["function"] = "_".join([parts[1], parts[2]])
+        function["value_inputs"] = []
+        if len(parts) == 4:
+            function["value_inputs"] = parts[3].split(",")
+        function["inputs"] = []
+        return function, arity
+    
+    def keyToArity(self, key):
+        if key in self.programDict.invalidSymbols:
+            return 0
+        return int(key.split("_")[0])
+
+    def keyToType(self, key):
+        if key in self.programDict.invalidSymbols:
+            return ["0", "0", "0"]
+        return ["0:" + key.split("_")[0], "1:" + key.split("_")[1], "2:" + key.split("_")[2]]
+
+    def programToPostfixProgram(self, program):
+        newProgram = []
+        
+        def programToPostfixAux(currIndex = -1):
+            childrenIndices = program[currIndex]["inputs"]
+            #[int(child) for child in program[currIndex]["inputs"]]
+            childrenNewIndices = []
+            for child in childrenIndices:
+                programToPostfixAux(child)
+                childrenNewIndices.append(len(newProgram) - 1)
+            program[currIndex]["inputs"] = childrenNewIndices
+            newProgram.append(program[currIndex])
+        
+        programToPostfixAux()
+        return newProgram
+
+    def programToSeq(self, program):
+        return [self.functionToKey(function) for function in program]
+
+    def pdfProgramToSeq(self, program):
+        return [self.typeToKey(function) for function in program]
+
+    def programToInputs(self, program, offset = 0):
+        inputs = [function["inputs"] for function in program]
+        offsetedInputs = [[FuncInput + offset for FuncInput in FuncInputs] for FuncInputs in inputs]
+        return offsetedInputs
+
+    # def seqToProgram(self, seq, enforceValidPrograms = True):
+    #     program = []
+
+    #     def seqToProgramAux(currIndex = len(seq) - 1):
+    #         if currIndex < 0:
+    #             program = None
+    #             return
+    #         currFunc, arity = self.keyToFunction(seq[currIndex])
+    #         nextIndex = currIndex - 1
+    #         program.append(currFunc)
+    #         for _ in arity:
+    #             currFunc["inputs"].append(nextIndex)
+    #             nextIndex = seqToProgramAux(nextIndex)
+    #         currFunc["inputs"].reverse()
+    #         return nextIndex
+
+    #     if enforceValidPrograms:
+    #         seqToProgramAux()
+    #         if program is not None:
+    #             program.reverse()
+    #     else:
+    #         stack = [0] * self.maxArity
+    #         for i in range(len(seq)):
+    #             func, arity = self.keyToFunction(seq[i])
+    #             func["inputs"] = stack[len(stack) - arity:]
+    #             newLength = max(len(stack) - arity, self.maxArity)
+    #             stack = stack[:newLength] + [i + self.maxArity]
+    #             self.maxStack = max(len(stack), self.maxStack)
+    #             program.append(func)
+
+    #     return program