Changeset 17367 for branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter

Timestamp:

11/22/19 16:31:11 (5 years ago)

Author:

pfleck

Message:

#3040

• Added VectorVariable and its corresponding TreeNode.
• Added symbols for basic vector operations and symbols for sum and avg of vectors.
• Added a VectorEvaluate method in the SymbolicDataAnalysisExpressionTreeInterpreter that returns a DoubleVector instead of a double that is also called within the regular Evaluate method.

Location:

branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter

Files:

• OpCodes.cs (modified) (3 diffs)
• SymbolicDataAnalysisExpressionTreeInterpreter.cs (modified) (2 diffs)

branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/OpCodes.cs

@@ -79 +79 @@
     CubeRoot = 51,
     Tanh = 52,
+    VectorVariable = 53,
+    VectorAdd = 54,
+    VectorSub = 55,
+    VectorMul = 56,
+    VectorDiv = 57,
+    VectorSum = 58,
+    VectorAvg = 59
   };
   public static class OpCodes {
     // constants for API compatibility only
     public const byte Add = (byte)OpCode.Add;
-    public const byte Sub =(byte)OpCode.Sub;
-    public const byte Mul =(byte)OpCode.Mul;
-    public const byte Div =(byte)OpCode.Div;
-    public const byte Sin =(byte)OpCode.Sin;
-    public const byte Cos =(byte)OpCode.Cos;
-    public const byte Tan =(byte)OpCode.Tan;
-    public const byte Log =(byte)OpCode.Log;
+    public const byte Sub = (byte)OpCode.Sub;
+    public const byte Mul = (byte)OpCode.Mul;
+    public const byte Div = (byte)OpCode.Div;
+    public const byte Sin = (byte)OpCode.Sin;
+    public const byte Cos = (byte)OpCode.Cos;
+    public const byte Tan = (byte)OpCode.Tan;
+    public const byte Log = (byte)OpCode.Log;
     public const byte Exp = (byte)OpCode.Exp;
     public const byte IfThenElse = (byte)OpCode.IfThenElse;
@@ -134 +141 @@
     public const byte CubeRoot = (byte)OpCode.CubeRoot;
     public const byte Tanh = (byte)OpCode.Tanh;
+    public const byte VectorVariable = (byte)OpCode.VectorVariable;
+    public const byte VectorAdd = (byte)OpCode.VectorAdd;
+    public const byte VectorSub = (byte)OpCode.VectorSub;
+    public const byte VectorMul = (byte)OpCode.VectorMul;
+    public const byte VectorDiv = (byte)OpCode.VectorDiv;
+    public const byte VectorSum = (byte)OpCode.VectorSum;
+    public const byte VectorAvg = (byte)OpCode.VectorAvg;
 
 
     private static Dictionary<Type, byte> symbolToOpcode = new Dictionary<Type, byte>() {
-       { typeof(Addition), OpCodes.Add },
+      { typeof(Addition), OpCodes.Add },
       { typeof(Subtraction), OpCodes.Sub },
       { typeof(Multiplication), OpCodes.Mul },
@@ -189 +203 @@
       { typeof(AnalyticQuotient), OpCodes.AnalyticQuotient },
       { typeof(Cube), OpCodes.Cube },
-      { typeof(CubeRoot), OpCodes.CubeRoot }
+      { typeof(CubeRoot), OpCodes.CubeRoot },
+      { typeof(VectorVariable), OpCodes.VectorVariable },
+      { typeof(VectorAddition), OpCodes.VectorAdd },
+      { typeof(VectorSubtraction), OpCodes.VectorSub },
+      { typeof(VectorMultiplication), OpCodes.VectorMul },
+      { typeof(VectorDivision), OpCodes.VectorDiv },
+      { typeof(VectorSum), OpCodes.VectorSum },
+      { typeof(VectorAverage), OpCodes.VectorAvg }
     };
 

branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeInterpreter.cs

@@ -149 +149 @@
           var factorTreeNode = instr.dynamicNode as BinaryFactorVariableTreeNode;
           instr.data = dataset.GetReadOnlyStringValues(factorTreeNode.VariableName);
+        } else if (instr.opCode == OpCodes.VectorVariable) {
+          var vectorVariableTreeNode = (VectorVariableTreeNode)instr.dynamicNode;
+          instr.data = dataset.GetReadOnlyDoubleVectorValues(vectorVariableTreeNode.VariableName);
         } else if (instr.opCode == OpCodes.LagVariable) {
           var laggedVariableTreeNode = (LaggedVariableTreeNode)instr.dynamicNode;
@@ -528 +531 @@
             }
           }
+
+        case OpCodes.VectorSum: {
+            DoubleVector v = VectorEvaluate(dataset, ref row, state);
+            return v.Sum();
+          }
+        case OpCodes.VectorAvg: {
+            DoubleVector v = VectorEvaluate(dataset, ref row, state);
+            return v.Average();
+          }
+
         default:
           throw new NotSupportedException();
       }
     }
+
+    public virtual DoubleVector VectorEvaluate(IDataset dataset, ref int row, InterpreterState state) {
+      Instruction currentInstr = state.NextInstruction();
+      switch (currentInstr.opCode) {
+        case OpCodes.VectorAdd: {
+            DoubleVector s = VectorEvaluate(dataset, ref row, state);
+            for (int i = 1; i < currentInstr.nArguments; i++) {
+              s += Evaluate(dataset, ref row, state);
+            }
+            return s;
+          }
+        case OpCodes.VectorSub: {
+            DoubleVector s = VectorEvaluate(dataset, ref row, state);
+            for (int i = 1; i < currentInstr.nArguments; i++) {
+              s -= Evaluate(dataset, ref row, state);
+            }
+            return s;
+          }
+        case OpCodes.VectorMul: {
+            DoubleVector s = VectorEvaluate(dataset, ref row, state);
+            for (int i = 1; i < currentInstr.nArguments; i++) {
+              s *= Evaluate(dataset, ref row, state);
+            }
+            return s;
+          }
+        case OpCodes.VectorDiv: {
+            DoubleVector s = VectorEvaluate(dataset, ref row, state);
+            for (int i = 1; i < currentInstr.nArguments; i++) {
+              s /= Evaluate(dataset, ref row, state);
+            }
+            return s;
+          }
+
+        case OpCodes.VectorVariable: {
+            if (row < 0 || row >= dataset.Rows) return new DoubleVector(new[] { double.NaN });
+            var vectorVarTreeNode = currentInstr.dynamicNode as VectorVariableTreeNode;
+            return ((IList<DoubleVector>)currentInstr.data)[row] * vectorVarTreeNode.Weight;
+          }
+        default:
+          throw new NotSupportedException();
+      }
+    }
   }
 }