Changeset 17726

Timestamp:

08/26/20 16:43:25 (4 years ago)

Author:

pfleck

Message:

#3040 Added a constant opt evaluator for vectors that uses the existing AutoDiff library by unrolling all vector operations.

Location:

branches/3040_VectorBasedGP

Files:

• HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression-3.4.csproj (modified) (1 diff)
• HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/Evaluators/VectorUnrollingNonlinearLeastSquaresConstantOptimizationEvaluator.cs (copied) (copied from branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/Evaluators/NonlinearLeastSquaresConstantOptimizationEvaluator.cs) (8 diffs)
• HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Converters/VectorUnrollingTreeToAutoDiffTermConverter.cs (copied) (copied from branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Converters/TreeToAutoDiffTermConverter.cs) (15 diffs)
• HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic-3.4.csproj (modified) (2 diffs)
• HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interfaces/IWindowedSymbol.cs (modified) (1 diff)
• HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/OpCodes.cs (modified) (3 diffs)
• HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeVectorInterpreter.cs (modified) (13 diffs)
• HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/SubVector.cs (copied) (copied from branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/Sum.cs) (2 diffs)
• HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/Sum.cs (modified) (1 diff)
• HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/WindowedSymbol.cs (modified) (1 diff)

branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression-3.4.csproj

@@ -141 +141 @@
     <Compile Include="Plugin.cs" />
     <Compile Include="SingleObjective\ConstantOptimizationAnalyzer.cs" />
+    <Compile Include="SingleObjective\Evaluators\VectorUnrollingNonlinearLeastSquaresConstantOptimizationEvaluator.cs" />
     <Compile Include="SingleObjective\Evaluators\NonlinearLeastSquaresConstantOptimizationEvaluator.cs" />
     <Compile Include="SingleObjective\Evaluators\SymbolicRegressionMeanRelativeErrorEvaluator.cs" />

branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/Evaluators/VectorUnrollingNonlinearLeastSquaresConstantOptimizationEvaluator.cs

@@ -30 +30 @@
 using HeuristicLab.Parameters;
 using HEAL.Attic;
+using DoubleVector = MathNet.Numerics.LinearAlgebra.Vector<double>;
 
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Regression {
-  [StorableType("24B68851-036D-4446-BD6F-3823E9028FF4")]
-  [Item("NonlinearLeastSquaresOptimizer", "")]
-  public class NonlinearLeastSquaresConstantOptimizationEvaluator : SymbolicRegressionConstantOptimizationEvaluator {
+  [StorableType("5F8DB251-C6F7-40AC-BC30-3C55AF655A2F")]
+  [Item("VectorUnrollingNonlinearLeastSquaresConstantOptimizationEvaluator", "")]
+  public class VectorUnrollingNonlinearLeastSquaresConstantOptimizationEvaluator : SymbolicRegressionConstantOptimizationEvaluator {
 
     private const string ConstantOptimizationIterationsName = "ConstantOptimizationIterations";
@@ -51 +52 @@
     #endregion
 
-    public NonlinearLeastSquaresConstantOptimizationEvaluator()
+    public VectorUnrollingNonlinearLeastSquaresConstantOptimizationEvaluator()
       : base() {
       Parameters.Add(new FixedValueParameter<IntValue>(ConstantOptimizationIterationsName, "Determines how many iterations should be calculated while optimizing the constant of a symbolic expression tree(0 indicates other or default stopping criterion).", new IntValue(10)));
     }
 
-    protected NonlinearLeastSquaresConstantOptimizationEvaluator(NonlinearLeastSquaresConstantOptimizationEvaluator original, Cloner cloner)
+    protected VectorUnrollingNonlinearLeastSquaresConstantOptimizationEvaluator(VectorUnrollingNonlinearLeastSquaresConstantOptimizationEvaluator original, Cloner cloner)
       : base(original, cloner) {
     }
     public override IDeepCloneable Clone(Cloner cloner) {
-      return new NonlinearLeastSquaresConstantOptimizationEvaluator(this, cloner);
+      return new VectorUnrollingNonlinearLeastSquaresConstantOptimizationEvaluator(this, cloner);
     }
     [StorableConstructor]
-    protected NonlinearLeastSquaresConstantOptimizationEvaluator(StorableConstructorFlag _) : base(_) { }
+    protected VectorUnrollingNonlinearLeastSquaresConstantOptimizationEvaluator(StorableConstructorFlag _) : base(_) { }
 
     protected override ISymbolicExpressionTree OptimizeConstants(
       ISymbolicExpressionTree tree, IRegressionProblemData problemData, IEnumerable<int> rows,
       CancellationToken cancellationToken = default(CancellationToken), EvaluationsCounter counter = null) {
-      return OptimizeTree(tree,
+      return OptimizeTree(tree, (SymbolicDataAnalysisExpressionTreeVectorInterpreter)SymbolicDataAnalysisTreeInterpreterParameter.ActualValue,
         problemData, rows,
         ApplyLinearScalingParameter.ActualValue.Value, ConstantOptimizationIterations, UpdateVariableWeights,
@@ -76 +77 @@
     public static ISymbolicExpressionTree OptimizeTree(
       ISymbolicExpressionTree tree,
+      SymbolicDataAnalysisExpressionTreeVectorInterpreter interpreter,
       IRegressionProblemData problemData, IEnumerable<int> rows,
       bool applyLinearScaling, int maxIterations, bool updateVariableWeights,
       CancellationToken cancellationToken = default(CancellationToken), EvaluationsCounter counter = null, Action<double[], double, object> iterationCallback = null) {
+
+      var vectorLengths = problemData.Dataset.DoubleVectorVariables
+        .SelectMany(var => problemData.Dataset.GetDoubleVectorValues(var, rows))
+        .Select(v => v.Count);
+      var vectorlength = vectorLengths.First();
+      if (vectorLengths.Any(l => l != vectorlength))
+        throw new InvalidOperationException("All vectors must be of same length.");
+      var evaluationTraces = interpreter.GetIntermediateNodeValues(tree, problemData.Dataset, rows);
+      var evaluationTrace = evaluationTraces.First(); // assume all vector lengths are the same
+
 
       // numeric constants in the tree become variables for constant opt
@@ -85 +97 @@
       // variable name, variable value (for factor vars) and lag as a DataForVariable object.
       // A dictionary is used to find parameters
-      bool success = TreeToAutoDiffTermConverter.TryConvertToAutoDiff(
-        tree, updateVariableWeights, applyLinearScaling,
+      bool success = VectorUnrollingTreeToAutoDiffTermConverter.TryConvertToAutoDiff(
+        tree, evaluationTrace,
+        updateVariableWeights, applyLinearScaling,
         out var parameters, out var initialConstants, out var func, out var func_grad);
       if (!success)
@@ -114 +127 @@
           } else if (ds.VariableHasType<string>(info.variableName)) {
             x[row, col] = ds.GetStringValue(info.variableName, r) == info.variableValue ? 1 : 0;
+          } else if (ds.VariableHasType<DoubleVector>(info.variableName)) {
+            x[row, col] = ds.GetDoubleVectorValue(info.variableName, r)[info.index];
           } else throw new InvalidProgramException("found a variable of unknown type");
           col++;
@@ -182 +197 @@
     }
 
-    private static alglib.ndimensional_pfunc CreatePFunc(TreeToAutoDiffTermConverter.ParametricFunction func) {
+    private static alglib.ndimensional_pfunc CreatePFunc(VectorUnrollingTreeToAutoDiffTermConverter.ParametricFunction func) {
       return (double[] c, double[] x, ref double fx, object o) => {
         fx = func(c, x);
@@ -190 +205 @@
     }
 
-    private static alglib.ndimensional_pgrad CreatePGrad(TreeToAutoDiffTermConverter.ParametricFunctionGradient func_grad) {
+    private static alglib.ndimensional_pgrad CreatePGrad(VectorUnrollingTreeToAutoDiffTermConverter.ParametricFunctionGradient func_grad) {
       return (double[] c, double[] x, ref double fx, double[] grad, object o) => {
         var tuple = func_grad(c, x);
@@ -201 +216 @@
 
     public static bool CanOptimizeConstants(ISymbolicExpressionTree tree) {
-      return TreeToAutoDiffTermConverter.IsCompatible(tree);
+      return VectorUnrollingTreeToAutoDiffTermConverter.IsCompatible(tree);
     }
   }

branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Converters/VectorUnrollingTreeToAutoDiffTermConverter.cs

@@ -25 +25 @@
 using System.Runtime.Serialization;
 using AutoDiff;
+using HeuristicLab.Common;
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
 
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
-  public class TreeToAutoDiffTermConverter {
+  public class VectorUnrollingTreeToAutoDiffTermConverter {
     public delegate double ParametricFunction(double[] vars, double[] @params);
 
@@ -38 +39 @@
       public readonly string variableValue; // for factor vars
       public readonly int lag;
-
-      public DataForVariable(string varName, string varValue, int lag) {
+      public readonly int index; // for vectors
+
+      public DataForVariable(string varName, string varValue, int lag, int index) {
         this.variableName = varName;
         this.variableValue = varValue;
         this.lag = lag;
+        this.index = index;
       }
 
@@ -50 +53 @@
         return other.variableName.Equals(this.variableName) &&
                other.variableValue.Equals(this.variableValue) &&
-               other.lag == this.lag;
+               other.lag == this.lag &&
+               other.index == this.index;
       }
 
       public override int GetHashCode() {
-        return variableName.GetHashCode() ^ variableValue.GetHashCode() ^ lag;
+        return variableName.GetHashCode() ^ variableValue.GetHashCode() ^ lag ^ index;
       }
     }
@@ -101 +105 @@
     #endregion
 
-    public static bool TryConvertToAutoDiff(ISymbolicExpressionTree tree, bool makeVariableWeightsVariable, bool addLinearScalingTerms,
+    public static bool TryConvertToAutoDiff(ISymbolicExpressionTree tree,
+      IDictionary<ISymbolicExpressionTreeNode, SymbolicDataAnalysisExpressionTreeVectorInterpreter.EvaluationResult> evaluationTrace,
+      bool makeVariableWeightsVariable, bool addLinearScalingTerms,
       out List<DataForVariable> parameters, out double[] initialConstants,
       out ParametricFunction func,
@@ -107 +113 @@
 
       // use a transformator object which holds the state (variable list, parameter list, ...) for recursive transformation of the tree
-      var transformator = new TreeToAutoDiffTermConverter(makeVariableWeightsVariable, addLinearScalingTerms);
-      AutoDiff.Term term;
+      var transformator = new VectorUnrollingTreeToAutoDiffTermConverter(evaluationTrace,
+        makeVariableWeightsVariable, addLinearScalingTerms);
+      Term term;
       try {
-        term = transformator.ConvertToAutoDiff(tree.Root.GetSubtree(0));
+        term = transformator.ConvertToAutoDiff(tree.Root.GetSubtree(0)).Single();
         var parameterEntries = transformator.parameters.ToArray(); // guarantee same order for keys and values
         var compiledTerm = term.Compile(transformator.variables.ToArray(),
@@ -128 +135 @@
     }
 
+    private readonly IDictionary<ISymbolicExpressionTreeNode, SymbolicDataAnalysisExpressionTreeVectorInterpreter.EvaluationResult> evaluationTrace;
     // state for recursive transformation of trees 
-    private readonly
-    List<double> initialConstants;
+    private readonly List<double> initialConstants;
     private readonly Dictionary<DataForVariable, AutoDiff.Variable> parameters;
     private readonly List<AutoDiff.Variable> variables;
@@ -136 +143 @@
     private readonly bool addLinearScalingTerms;
 
-    private TreeToAutoDiffTermConverter(bool makeVariableWeightsVariable, bool addLinearScalingTerms) {
+    private VectorUnrollingTreeToAutoDiffTermConverter(IDictionary<ISymbolicExpressionTreeNode, SymbolicDataAnalysisExpressionTreeVectorInterpreter.EvaluationResult> evaluationTrace,
+      bool makeVariableWeightsVariable, bool addLinearScalingTerms) {
+      this.evaluationTrace = evaluationTrace;
       this.makeVariableWeightsVariable = makeVariableWeightsVariable;
       this.addLinearScalingTerms = addLinearScalingTerms;
@@ -144 +153 @@
     }
 
-    private AutoDiff.Term ConvertToAutoDiff(ISymbolicExpressionTreeNode node) {
-      if (node.Symbol is Constant) {
+    private IList<AutoDiff.Term> ConvertToAutoDiff(ISymbolicExpressionTreeNode node) {
+      IList<Term> BinaryOp(Func<Term, Term, Term> binaryOp, Func<Term, Term> singleElementOp, params IList<Term>[] terms) {
+        if (terms.Length == 1) return terms[0].Select(singleElementOp).ToList();
+        return terms.Aggregate((acc, vectorizedTerm) => acc.Zip(vectorizedTerm, binaryOp).ToList());
+      }
+      IList<Term> BinaryOp2(Func<Term, Term, Term> binaryOp, params IList<Term>[] terms) {
+        return terms.Aggregate((acc, vectorizedTerm) => acc.Zip(vectorizedTerm, binaryOp).ToList());
+      }
+      IList<Term> UnaryOp(Func<Term, Term> unaryOp, IList<Term> term) {
+        return term.Select(unaryOp).ToList();
+      }
+
+      var evaluationResult = evaluationTrace[node];
+
+      if (node.Symbol is Constant) { // assume scalar constant
         initialConstants.Add(((ConstantTreeNode)node).Value);
         var var = new AutoDiff.Variable();
         variables.Add(var);
-        return var;
+        return new Term[] { var };
       }
       if (node.Symbol is Variable || node.Symbol is BinaryFactorVariable) {
@@ -156 +178 @@
         // factor variable values are only 0 or 1 and set in x accordingly
         var varValue = factorVarNode != null ? factorVarNode.VariableValue : string.Empty;
-        var par = FindOrCreateParameter(parameters, varNode.VariableName, varValue);
+        var pars = evaluationResult.IsVector
+          ? Enumerable.Range(0, evaluationResult.Vector.Count).Select(i => FindOrCreateParameter(parameters, varNode.VariableName, varValue, index: i))
+          : FindOrCreateParameter(parameters, varNode.VariableName, varValue).ToEnumerable();
 
         if (makeVariableWeightsVariable) {
@@ -162 +186 @@
           var w = new AutoDiff.Variable();
           variables.Add(w);
-          return AutoDiff.TermBuilder.Product(w, par);
+          return pars.Select(par => AutoDiff.TermBuilder.Product(w, par)).ToList();
         } else {
-          return varNode.Weight * par;
+          return pars.Select(par => varNode.Weight * par).ToList();
         }
       }
@@ -179 +203 @@
           products.Add(AutoDiff.TermBuilder.Product(wVar, par));
         }
-        return AutoDiff.TermBuilder.Sum(products);
-      }
-      if (node.Symbol is LaggedVariable) {
-        var varNode = node as LaggedVariableTreeNode;
-        var par = FindOrCreateParameter(parameters, varNode.VariableName, string.Empty, varNode.Lag);
-
-        if (makeVariableWeightsVariable) {
-          initialConstants.Add(varNode.Weight);
-          var w = new AutoDiff.Variable();
-          variables.Add(w);
-          return AutoDiff.TermBuilder.Product(w, par);
-        } else {
-          return varNode.Weight * par;
-        }
-      }
+        return new[] { AutoDiff.TermBuilder.Sum(products) };
+      }
+      //if (node.Symbol is LaggedVariable) {
+      //  var varNode = node as LaggedVariableTreeNode;
+      //  var par = FindOrCreateParameter(parameters, varNode.VariableName, string.Empty, varNode.Lag);
+
+      //  if (makeVariableWeightsVariable) {
+      //    initialConstants.Add(varNode.Weight);
+      //    var w = new AutoDiff.Variable();
+      //    variables.Add(w);
+      //    return AutoDiff.TermBuilder.Product(w, par);
+      //  } else {
+      //    return varNode.Weight * par;
+      //  }
+      //}
       if (node.Symbol is Addition) {
-        List<AutoDiff.Term> terms = new List<Term>();
-        foreach (var subTree in node.Subtrees) {
-          terms.Add(ConvertToAutoDiff(subTree));
-        }
-        return AutoDiff.TermBuilder.Sum(terms);
+        var terms = node.Subtrees.Select(ConvertToAutoDiff).ToArray();
+        return BinaryOp((a, b) => a + b, a => a, terms);
       }
       if (node.Symbol is Subtraction) {
-        List<AutoDiff.Term> terms = new List<Term>();
-        for (int i = 0; i < node.SubtreeCount; i++) {
-          AutoDiff.Term t = ConvertToAutoDiff(node.GetSubtree(i));
-          if (i > 0) t = -t;
-          terms.Add(t);
-        }
-        if (terms.Count == 1) return -terms[0];
-        else return AutoDiff.TermBuilder.Sum(terms);
+        var terms = node.Subtrees.Select(ConvertToAutoDiff).ToArray();
+        return BinaryOp((a, b) => a - b, a => -a, terms);
       }
       if (node.Symbol is Multiplication) {
-        List<AutoDiff.Term> terms = new List<Term>();
-        foreach (var subTree in node.Subtrees) {
-          terms.Add(ConvertToAutoDiff(subTree));
-        }
-        if (terms.Count == 1) return terms[0];
-        else return terms.Aggregate((a, b) => new AutoDiff.Product(a, b));
+        var terms = node.Subtrees.Select(ConvertToAutoDiff).ToArray();
+        return BinaryOp((a, b) => a * b, a => a, terms);
       }
       if (node.Symbol is Division) {
-        List<AutoDiff.Term> terms = new List<Term>();
-        foreach (var subTree in node.Subtrees) {
-          terms.Add(ConvertToAutoDiff(subTree));
-        }
-        if (terms.Count == 1) return 1.0 / terms[0];
-        else return terms.Aggregate((a, b) => new AutoDiff.Product(a, 1.0 / b));
+        var terms = node.Subtrees.Select(ConvertToAutoDiff).ToArray();
+        return BinaryOp((a, b) => a / b, a => 1.0 / a, terms);
       }
       if (node.Symbol is Absolute) {
-        var x1 = ConvertToAutoDiff(node.GetSubtree(0));
-        return abs(x1);
-      }
-      if (node.Symbol is AnalyticQuotient) {
-        var x1 = ConvertToAutoDiff(node.GetSubtree(0));
-        var x2 = ConvertToAutoDiff(node.GetSubtree(1));
-        return x1 / (TermBuilder.Power(1 + x2 * x2, 0.5));
-      }
+        var term = node.Subtrees.Select(ConvertToAutoDiff).Single();
+        return UnaryOp(abs, term);
+      }
+      //if (node.Symbol is AnalyticQuotient) {
+      //  var x1 = ConvertToAutoDiff(node.GetSubtree(0));
+      //  var x2 = ConvertToAutoDiff(node.GetSubtree(1));
+      //  return x1 / (TermBuilder.Power(1 + x2 * x2, 0.5));
+      //}
       if (node.Symbol is Logarithm) {
-        return AutoDiff.TermBuilder.Log(
-          ConvertToAutoDiff(node.GetSubtree(0)));
+        var term = node.Subtrees.Select(ConvertToAutoDiff).Single();
+        return UnaryOp(TermBuilder.Log, term);
       }
       if (node.Symbol is Exponential) {
-        return AutoDiff.TermBuilder.Exp(
-          ConvertToAutoDiff(node.GetSubtree(0)));
+        var term = node.Subtrees.Select(ConvertToAutoDiff).Single();
+        return UnaryOp(TermBuilder.Exp, term);
       }
       if (node.Symbol is Square) {
-        return AutoDiff.TermBuilder.Power(
-          ConvertToAutoDiff(node.GetSubtree(0)), 2.0);
+        var term = node.Subtrees.Select(ConvertToAutoDiff).Single();
+        return UnaryOp(t => TermBuilder.Power(t, 2.0), term);
       }
       if (node.Symbol is SquareRoot) {
-        return AutoDiff.TermBuilder.Power(
-          ConvertToAutoDiff(node.GetSubtree(0)), 0.5);
+        var term = node.Subtrees.Select(ConvertToAutoDiff).Single();
+        return UnaryOp(t => TermBuilder.Power(t, 0.5), term);
       }
       if (node.Symbol is Cube) {
-        return AutoDiff.TermBuilder.Power(
-          ConvertToAutoDiff(node.GetSubtree(0)), 3.0);
+        var term = node.Subtrees.Select(ConvertToAutoDiff).Single();
+        return UnaryOp(t => TermBuilder.Power(t, 3.0), term);
       }
       if (node.Symbol is CubeRoot) {
-        return cbrt(ConvertToAutoDiff(node.GetSubtree(0)));
+        var term = node.Subtrees.Select(ConvertToAutoDiff).Single();
+        return UnaryOp(cbrt, term);
       }
       if (node.Symbol is Sine) {
-        return sin(
-          ConvertToAutoDiff(node.GetSubtree(0)));
+        var term = node.Subtrees.Select(ConvertToAutoDiff).Single();
+        return UnaryOp(sin, term);
       }
       if (node.Symbol is Cosine) {
-        return cos(
-          ConvertToAutoDiff(node.GetSubtree(0)));
+        var term = node.Subtrees.Select(ConvertToAutoDiff).Single();
+        return UnaryOp(cos, term);
       }
       if (node.Symbol is Tangent) {
-        return tan(
-          ConvertToAutoDiff(node.GetSubtree(0)));
+        var term = node.Subtrees.Select(ConvertToAutoDiff).Single();
+        return UnaryOp(tan, term);
       }
       if (node.Symbol is HyperbolicTangent) {
-        return tanh(
-          ConvertToAutoDiff(node.GetSubtree(0)));
+        var term = node.Subtrees.Select(ConvertToAutoDiff).Single();
+        return UnaryOp(tanh, term);
       }
       if (node.Symbol is Erf) {
-        return erf(
-          ConvertToAutoDiff(node.GetSubtree(0)));
+        var term = node.Subtrees.Select(ConvertToAutoDiff).Single();
+        return UnaryOp(erf, term);
       }
       if (node.Symbol is Norm) {
-        return norm(
-          ConvertToAutoDiff(node.GetSubtree(0)));
+        var term = node.Subtrees.Select(ConvertToAutoDiff).Single();
+        return UnaryOp(norm, term);
       }
       if (node.Symbol is StartSymbol) {
@@ -291 +299 @@
           variables.Add(alpha);
           var t = ConvertToAutoDiff(node.GetSubtree(0));
-          return t * alpha + beta;
+          if (t.Count > 1) throw new InvalidOperationException("Tree Result must be scalar value");
+          return new[] { t[0] * alpha + beta };
         } else return ConvertToAutoDiff(node.GetSubtree(0));
       }
+      if (node.Symbol is Sum) {
+        var term = node.Subtrees.Select(ConvertToAutoDiff).Single();
+        return new[] { TermBuilder.Sum(term) };
+      }
+      if (node.Symbol is Mean) {
+        var term = node.Subtrees.Select(ConvertToAutoDiff).Single();
+        return new[] { TermBuilder.Sum(term) / term.Count };
+      }
+      if (node.Symbol is StandardDeviation) {
+        var term = node.Subtrees.Select(ConvertToAutoDiff).Single();
+        var mean = TermBuilder.Sum(term) / term.Count;
+        var ssd = TermBuilder.Sum(term.Select(t => TermBuilder.Power(t - mean, 2.0)));
+        return new[] { TermBuilder.Power(ssd / term.Count, 0.5) };
+      }
+      if (node.Symbol is Length) {
+        var term = node.Subtrees.Select(ConvertToAutoDiff).Single();
+        return new[] { TermBuilder.Constant(term.Count) };
+      }
+      //if (node.Symbol is Min) {
+      //}
+      //if (node.Symbol is Max) {
+      //}
+      if (node.Symbol is Variance) {
+        var term = node.Subtrees.Select(ConvertToAutoDiff).Single();
+        var mean = TermBuilder.Sum(term) / term.Count;
+        var ssd = TermBuilder.Sum(term.Select(t => TermBuilder.Power(t - mean, 2.0)));
+        return new[] { ssd / term.Count };
+      }
+      //if (node.Symbol is Skewness) {
+      //}
+      //if (node.Symbol is Kurtosis) {
+      //}
+      //if (node.Symbol is EuclideanDistance) {
+      //}
+      //if (node.Symbol is Covariance) {
+      //}
+
+
       throw new ConversionException();
     }
@@ -301 +348 @@
     // each binary indicator is only necessary once. So we only create a parameter if this combination is not yet available
     private static Term FindOrCreateParameter(Dictionary<DataForVariable, AutoDiff.Variable> parameters,
-      string varName, string varValue = "", int lag = 0) {
-      var data = new DataForVariable(varName, varValue, lag);
+      string varName, string varValue = "", int lag = 0, int index = -1) {
+      var data = new DataForVariable(varName, varValue, lag, index);
 
       AutoDiff.Variable par = null;
@@ -319 +366 @@
           !(n.Symbol is Variable) &&
           !(n.Symbol is BinaryFactorVariable) &&
-          !(n.Symbol is FactorVariable) &&
-          !(n.Symbol is LaggedVariable) &&
+          //!(n.Symbol is FactorVariable) &&
+          //!(n.Symbol is LaggedVariable) &&
           !(n.Symbol is Constant) &&
           !(n.Symbol is Addition) &&
@@ -338 +385 @@
           !(n.Symbol is StartSymbol) &&
           !(n.Symbol is Absolute) &&
-          !(n.Symbol is AnalyticQuotient) &&
+          //!(n.Symbol is AnalyticQuotient) &&
           !(n.Symbol is Cube) &&
-          !(n.Symbol is CubeRoot)
+          !(n.Symbol is CubeRoot) &&
+          !(n.Symbol is Sum) &&
+          !(n.Symbol is Mean) &&
+          !(n.Symbol is StandardDeviation) &&
+          !(n.Symbol is Length) &&
+          //!(n.Symbol is Min) &&
+          //!(n.Symbol is Max) &&
+          !(n.Symbol is Variance)
+        //!(n.Symbol is Skewness) &&
+        //!(n.Symbol is Kurtosis) &&
+        //!(n.Symbol is EuclideanDistance) &&
+        //!(n.Symbol is Covariance)
         select n).Any();
       return !containsUnknownSymbol;

branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic-3.4.csproj

@@ -161 +161 @@
     </Compile>
     <Compile Include="Converters\LinearModelToTreeConverter.cs" />
+    <Compile Include="Converters\VectorUnrollingTreeToAutoDiffTermConverter.cs" />
     <Compile Include="Converters\VectorTreeSimplifier.cs" />
     <Compile Include="Converters\TreeSimplifier.cs" />
@@ -253 +254 @@
     <Compile Include="Symbols\Kurtosis.cs" />
     <Compile Include="Symbols\Skewness.cs" />
+    <Compile Include="Symbols\SubVector.cs" />
     <Compile Include="Symbols\WindowedSymbolTreeNode.cs" />
     <Compile Include="Symbols\WindowedSymbol.cs" />

branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interfaces/IWindowedSymbol.cs

@@ -24 +24 @@
 
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
-  [StorableType("BB96C8EF-4DB8-4892-B3A3-358F34C06AD6")]
   /// <summary>
   /// Any symbol that can use a window (e.g. partial aggregation of a vector)
   /// </summary>
+  [StorableType("BB96C8EF-4DB8-4892-B3A3-358F34C06AD6")]
   public interface IWindowedSymbol : ISymbol {
   }

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

@@ -87 +87 @@
     Skewness = 60,
     Kurtosis = 61,
-    EuclideanDistance = 62 ,
+    EuclideanDistance = 62,
     Covariance = 63,
+    SubVector = 64,
 
   }
@@ -156 +157 @@
     public const byte EuclideanDistance = (byte)OpCode.EuclideanDistance;
     public const byte Covariance = (byte)OpCode.Covariance;
+    public const byte SubVector = (byte)OpCode.SubVector;
 
 
@@ -223 +225 @@
       { typeof(EuclideanDistance), OpCodes.EuclideanDistance },
       { typeof(Covariance), OpCodes.Covariance },
+      { typeof(SubVector), OpCodes.SubVector },
     };
 

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

@@ -253 +253 @@
         } else
           yield return double.NaN;
+        state.Reset();
+      }
+    }
+
+    public IEnumerable<Dictionary<ISymbolicExpressionTreeNode, EvaluationResult>> GetIntermediateNodeValues(ISymbolicExpressionTree tree, IDataset dataset, IEnumerable<int> rows) {
+      var state = PrepareInterpreterState(tree, dataset);
+
+      foreach (var rowEnum in rows) {
+        int row = rowEnum;
+        var traceDict = new Dictionary<ISymbolicExpressionTreeNode, EvaluationResult>();
+        var result = Evaluate(dataset, ref row, state, traceDict);
+        traceDict.Add(tree.Root.GetSubtree(0), result); // Add StartSymbol
+        yield return traceDict;
         state.Reset();
       }
@@ -353 +366 @@
     }
 
-    private static EvaluationResult AggregateApply(EvaluationResult val, WindowedSymbolTreeNode node,
+    private static EvaluationResult WindowedAggregateApply(EvaluationResult val, WindowedSymbolTreeNode node,
       Func<double, double> sFunc = null,
       Func<DoubleVector, double> vFunc = null) {
@@ -370 +383 @@
       return EvaluationResult.NaN;
     }
+    private static EvaluationResult WindowedFunctionApply(EvaluationResult val, IWindowedSymbolTreeNode node,
+      Func<double, double> sFunc = null,
+      Func<DoubleVector, DoubleVector> vFunc = null) {
+      var offset = node.Offset;
+      var length = node.Length;
+
+      DoubleVector SubVector(DoubleVector v) {
+        int index = (int)(offset * v.Count);
+        int count = (int)(length * (v.Count - index));
+        return v.SubVector(index, count);
+      };
+
+      if (val.IsScalar && sFunc != null) return new EvaluationResult(sFunc(val.Scalar));
+      if (val.IsVector && vFunc != null) return new EvaluationResult(vFunc(SubVector(val.Vector)));
+      return EvaluationResult.NaN;
+    }
+
     private static EvaluationResult AggregateMultipleApply(EvaluationResult lhs, EvaluationResult rhs,
       Func<DoubleVector, DoubleVector, (DoubleVector, DoubleVector)> lengthStrategy,
@@ -404 +434 @@
     }
 
-    public virtual EvaluationResult Evaluate(IDataset dataset, ref int row, InterpreterState state) {
+
+    public virtual EvaluationResult Evaluate(IDataset dataset, ref int row, InterpreterState state,
+      IDictionary<ISymbolicExpressionTreeNode, EvaluationResult> traceDict = null) {
+
+      void TraceEvaluation(Instruction instr, EvaluationResult result) {
+        traceDict?.Add(instr.dynamicNode, result);
+      }
+
       Instruction currentInstr = state.NextInstruction();
       switch (currentInstr.opCode) {
         case OpCodes.Add: {
-            var cur = Evaluate(dataset, ref row, state);
+            var cur = Evaluate(dataset, ref row, state, traceDict);
             for (int i = 1; i < currentInstr.nArguments; i++) {
-              var op = Evaluate(dataset, ref row, state);
+              var op = Evaluate(dataset, ref row, state, traceDict);
               cur = ArithmeticApply(cur, op,
                 (lhs, rhs) => ApplyVectorLengthStrategy(DifferentVectorLengthStrategy, lhs, rhs, 0.0),
@@ -418 +455 @@
                 (v1, v2) => v1 + v2);
             }
+            TraceEvaluation(currentInstr, cur);
             return cur;
           }
         case OpCodes.Sub: {
-            var cur = Evaluate(dataset, ref row, state);
+            var cur = Evaluate(dataset, ref row, state, traceDict);
             for (int i = 1; i < currentInstr.nArguments; i++) {
-              var op = Evaluate(dataset, ref row, state);
+              var op = Evaluate(dataset, ref row, state, traceDict);
               cur = ArithmeticApply(cur, op,
                 (lhs, rhs) => ApplyVectorLengthStrategy(DifferentVectorLengthStrategy, lhs, rhs, 0.0),
@@ -431 +469 @@
                 (v1, v2) => v1 - v2);
             }
+            TraceEvaluation(currentInstr, cur);
             return cur;
           }
         case OpCodes.Mul: {
-            var cur = Evaluate(dataset, ref row, state);
+            var cur = Evaluate(dataset, ref row, state, traceDict);
             for (int i = 1; i < currentInstr.nArguments; i++) {
-              var op = Evaluate(dataset, ref row, state);
+              var op = Evaluate(dataset, ref row, state, traceDict);
               cur = ArithmeticApply(cur, op,
                 (lhs, rhs) => ApplyVectorLengthStrategy(DifferentVectorLengthStrategy, lhs, rhs, 1.0),
@@ -444 +483 @@
                 (v1, v2) => v1.PointwiseMultiply(v2));
             }
+            TraceEvaluation(currentInstr, cur);
             return cur;
           }
         case OpCodes.Div: {
-            var cur = Evaluate(dataset, ref row, state);
+            var cur = Evaluate(dataset, ref row, state, traceDict);
             for (int i = 1; i < currentInstr.nArguments; i++) {
-              var op = Evaluate(dataset, ref row, state);
+              var op = Evaluate(dataset, ref row, state, traceDict);
               cur = ArithmeticApply(cur, op,
                 (lhs, rhs) => ApplyVectorLengthStrategy(DifferentVectorLengthStrategy, lhs, rhs, 1.0),
@@ -457 +497 @@
                 (v1, v2) => v1 / v2);
             }
+            TraceEvaluation(currentInstr, cur);
             return cur;
           }
         case OpCodes.Absolute: {
-            var cur = Evaluate(dataset, ref row, state);
-            return FunctionApply(cur, Math.Abs, DoubleVector.Abs);
+            var cur = Evaluate(dataset, ref row, state, traceDict);
+            cur = FunctionApply(cur, Math.Abs, DoubleVector.Abs);
+            TraceEvaluation(currentInstr, cur);
+            return cur;
           }
         case OpCodes.Tanh: {
-            var cur = Evaluate(dataset, ref row, state);
-            return FunctionApply(cur, Math.Tanh, DoubleVector.Tanh);
+            var cur = Evaluate(dataset, ref row, state, traceDict);
+            cur = FunctionApply(cur, Math.Tanh, DoubleVector.Tanh);
+            TraceEvaluation(currentInstr, cur);
+            return cur;
           }
         case OpCodes.Cos: {
-            var cur = Evaluate(dataset, ref row, state);
-            return FunctionApply(cur, Math.Cos, DoubleVector.Cos);
+            var cur = Evaluate(dataset, ref row, state, traceDict);
+            cur = FunctionApply(cur, Math.Cos, DoubleVector.Cos);
+            TraceEvaluation(currentInstr, cur);
+            return cur;
           }
         case OpCodes.Sin: {
-            var cur = Evaluate(dataset, ref row, state);
-            return FunctionApply(cur, Math.Sin, DoubleVector.Sin);
+            var cur = Evaluate(dataset, ref row, state, traceDict);
+            cur = FunctionApply(cur, Math.Sin, DoubleVector.Sin);
+            TraceEvaluation(currentInstr, cur);
+            return cur;
           }
         case OpCodes.Tan: {
-            var cur = Evaluate(dataset, ref row, state);
-            return FunctionApply(cur, Math.Tan, DoubleVector.Tan);
+            var cur = Evaluate(dataset, ref row, state, traceDict);
+            cur = FunctionApply(cur, Math.Tan, DoubleVector.Tan);
+            TraceEvaluation(currentInstr, cur);
+            return cur;
           }
         case OpCodes.Square: {
-            var cur = Evaluate(dataset, ref row, state);
-            return FunctionApply(cur,
+            var cur = Evaluate(dataset, ref row, state, traceDict);
+            cur = FunctionApply(cur,
               s => Math.Pow(s, 2),
               v => v.PointwisePower(2));
+            TraceEvaluation(currentInstr, cur);
+            return cur;
           }
         case OpCodes.Cube: {
-            var cur = Evaluate(dataset, ref row, state);
-            return FunctionApply(cur,
+            var cur = Evaluate(dataset, ref row, state, traceDict);
+            cur = FunctionApply(cur,
               s => Math.Pow(s, 3),
               v => v.PointwisePower(3));
+            TraceEvaluation(currentInstr, cur);
+            return cur;
           }
         case OpCodes.Power: {
-            var x = Evaluate(dataset, ref row, state);
-            var y = Evaluate(dataset, ref row, state);
-            return ArithmeticApply(x, y,
+            var x = Evaluate(dataset, ref row, state, traceDict);
+            var y = Evaluate(dataset, ref row, state, traceDict);
+            var cur = ArithmeticApply(x, y,
               (lhs, rhs) => lhs.Count < rhs.Count
                 ? CutLonger(lhs, rhs)
@@ -502 +557 @@
               (v1, s2) => v1.PointwisePower(Math.Round(s2)),
               (v1, v2) => v1.PointwisePower(DoubleVector.Round(v2)));
+            TraceEvaluation(currentInstr, cur);
+            return cur;
           }
         case OpCodes.SquareRoot: {
-            var cur = Evaluate(dataset, ref row, state);
-            return FunctionApply(cur,
+            var cur = Evaluate(dataset, ref row, state, traceDict);
+            cur = FunctionApply(cur,
               s => Math.Sqrt(s),
               v => DoubleVector.Sqrt(v));
+            TraceEvaluation(currentInstr, cur);
+            return cur;
           }
         case OpCodes.CubeRoot: {
-            var cur = Evaluate(dataset, ref row, state);
-            return FunctionApply(cur,
+            var cur = Evaluate(dataset, ref row, state, traceDict);
+            cur = FunctionApply(cur,
               s => s < 0 ? -Math.Pow(-s, 1.0 / 3.0) : Math.Pow(s, 1.0 / 3.0),
               v => v.Map(s => s < 0 ? -Math.Pow(-s, 1.0 / 3.0) : Math.Pow(s, 1.0 / 3.0)));
+            TraceEvaluation(currentInstr, cur);
+            return cur;
           }
         case OpCodes.Root: {
-            var x = Evaluate(dataset, ref row, state);
-            var y = Evaluate(dataset, ref row, state);
-            return ArithmeticApply(x, y,
+            var x = Evaluate(dataset, ref row, state, traceDict);
+            var y = Evaluate(dataset, ref row, state, traceDict);
+            var cur = ArithmeticApply(x, y,
               (lhs, rhs) => lhs.Count < rhs.Count
                 ? CutLonger(lhs, rhs)
@@ -526 +587 @@
               (v1, s2) => v1.PointwisePower(1.0 / Math.Round(s2)),
               (v1, v2) => v1.PointwisePower(1.0 / DoubleVector.Round(v2)));
+            TraceEvaluation(currentInstr, cur);
+            return cur;
           }
         case OpCodes.Exp: {
-            var cur = Evaluate(dataset, ref row, state);
-            return FunctionApply(cur,
+            var cur = Evaluate(dataset, ref row, state, traceDict);
+            cur = FunctionApply(cur,
               s => Math.Exp(s),
               v => DoubleVector.Exp(v));
+            TraceEvaluation(currentInstr, cur);
+            return cur;
           }
         case OpCodes.Log: {
-            var cur = Evaluate(dataset, ref row, state);
-            return FunctionApply(cur,
+            var cur = Evaluate(dataset, ref row, state, traceDict);
+            cur = FunctionApply(cur,
               s => Math.Log(s),
               v => DoubleVector.Log(v));
+            TraceEvaluation(currentInstr, cur);
+            return cur;
           }
         case OpCodes.Sum: {
-            var cur = Evaluate(dataset, ref row, state);
-            return AggregateApply(cur, (WindowedSymbolTreeNode)currentInstr.dynamicNode,
+            var cur = Evaluate(dataset, ref row, state, traceDict);
+            cur = AggregateApply(cur,
               s => s,
               v => v.Sum());
+            TraceEvaluation(currentInstr, cur);
+            return cur;
           }
         case OpCodes.Mean: {
-            var cur = Evaluate(dataset, ref row, state);
-            return AggregateApply(cur,
+            var cur = Evaluate(dataset, ref row, state, traceDict);
+            cur = AggregateApply(cur,
               s => s,
               v => Statistics.Mean(v));
+            TraceEvaluation(currentInstr, cur);
+            return cur;
           }
         case OpCodes.StandardDeviation: {
-            var cur = Evaluate(dataset, ref row, state);
-            return AggregateApply(cur,
+            var cur = Evaluate(dataset, ref row, state, traceDict);
+            cur = AggregateApply(cur,
               s => 0,
               v => Statistics.PopulationStandardDeviation(v));
+            TraceEvaluation(currentInstr, cur);
+            return cur;
           }
         case OpCodes.Length: {
-            var cur = Evaluate(dataset, ref row, state);
-            return AggregateApply(cur,
+            var cur = Evaluate(dataset, ref row, state, traceDict);
+            cur = AggregateApply(cur,
               s => 1,
               v => v.Count);
+            TraceEvaluation(currentInstr, cur);
+            return cur;
           }
         case OpCodes.Min: {
-            var cur = Evaluate(dataset, ref row, state);
-            return AggregateApply(cur,
+            var cur = Evaluate(dataset, ref row, state, traceDict);
+            cur = AggregateApply(cur,
               s => s,
               v => Statistics.Minimum(v));
+            TraceEvaluation(currentInstr, cur);
+            return cur;
           }
         case OpCodes.Max: {
-            var cur = Evaluate(dataset, ref row, state);
-            return AggregateApply(cur,
+            var cur = Evaluate(dataset, ref row, state, traceDict);
+            cur = AggregateApply(cur,
               s => s,
               v => Statistics.Maximum(v));
+            TraceEvaluation(currentInstr, cur);
+            return cur;
           }
         case OpCodes.Variance: {
-            var cur = Evaluate(dataset, ref row, state);
-            return AggregateApply(cur,
+            var cur = Evaluate(dataset, ref row, state, traceDict);
+            cur = AggregateApply(cur,
               s => 0,
               v => Statistics.PopulationVariance(v));
+            TraceEvaluation(currentInstr, cur);
+            return cur;
           }
         case OpCodes.Skewness: {
-            var cur = Evaluate(dataset, ref row, state);
-            return AggregateApply(cur,
+            var cur = Evaluate(dataset, ref row, state, traceDict);
+            cur = AggregateApply(cur,
               s => double.NaN,
               v => Statistics.PopulationSkewness(v));
+            TraceEvaluation(currentInstr, cur);
+            return cur;
           }
         case OpCodes.Kurtosis: {
-            var cur = Evaluate(dataset, ref row, state);
-            return AggregateApply(cur,
+            var cur = Evaluate(dataset, ref row, state, traceDict);
+            cur = AggregateApply(cur,
               s => double.NaN,
               v => Statistics.PopulationKurtosis(v));
+            TraceEvaluation(currentInstr, cur);
+            return cur;
           }
         case OpCodes.EuclideanDistance: {
-            var x1 = Evaluate(dataset, ref row, state);
-            var x2 = Evaluate(dataset, ref row, state);
-            return AggregateMultipleApply(x1, x2,
+            var x1 = Evaluate(dataset, ref row, state, traceDict);
+            var x2 = Evaluate(dataset, ref row, state, traceDict);
+            var cur = AggregateMultipleApply(x1, x2,
               (lhs, rhs) => ApplyVectorLengthStrategy(DifferentVectorLengthStrategy, lhs, rhs, 0.0),
               (s1, s2) => s1 - s2,
@@ -602 +687 @@
               (v1, s2) => Math.Sqrt((v1 - s2).PointwisePower(2).Sum()),
               (v1, v2) => Math.Sqrt((v1 - v2).PointwisePower(2).Sum()));
+            TraceEvaluation(currentInstr, cur);
+            return cur;
           }
         case OpCodes.Covariance: {
-            var x1 = Evaluate(dataset, ref row, state);
-            var x2 = Evaluate(dataset, ref row, state);
-            return AggregateMultipleApply(x1, x2,
+            var x1 = Evaluate(dataset, ref row, state, traceDict);
+            var x2 = Evaluate(dataset, ref row, state, traceDict);
+            var cur = AggregateMultipleApply(x1, x2,
               (lhs, rhs) => ApplyVectorLengthStrategy(DifferentVectorLengthStrategy, lhs, rhs, 0.0),
               (s1, s2) => 0,
@@ -612 +699 @@
               (v1, s2) => 0,
               (v1, v2) => Statistics.PopulationCovariance(v1, v2));
+            TraceEvaluation(currentInstr, cur);
+            return cur;
+          }
+        case OpCodes.SubVector: {
+            var cur = Evaluate(dataset, ref row, state, traceDict);
+            return WindowedFunctionApply(cur, (WindowedSymbolTreeNode)currentInstr.dynamicNode,
+              s => s,
+              v => v);
           }
         case OpCodes.Variable: {
             if (row < 0 || row >= dataset.Rows) return EvaluationResult.NaN;
             var variableTreeNode = (VariableTreeNode)currentInstr.dynamicNode;
-            if (currentInstr.data is IList<double> doubleList)
-              return new EvaluationResult(doubleList[row] * variableTreeNode.Weight);
-            if (currentInstr.data is IList<DoubleVector> doubleVectorList)
-              return new EvaluationResult(doubleVectorList[row] * variableTreeNode.Weight);
+            if (currentInstr.data is IList<double> doubleList) {
+              var cur = new EvaluationResult(doubleList[row] * variableTreeNode.Weight);
+              TraceEvaluation(currentInstr, cur);
+              return cur;
+            }
+            if (currentInstr.data is IList<DoubleVector> doubleVectorList) {
+              var cur = new EvaluationResult(doubleVectorList[row] * variableTreeNode.Weight);
+              TraceEvaluation(currentInstr, cur);
+              return cur;
+            }
             throw new NotSupportedException($"Unsupported type of variable: {currentInstr.data.GetType().GetPrettyName()}");
           }
@@ -625 +726 @@
             if (row < 0 || row >= dataset.Rows) return EvaluationResult.NaN;
             var factorVarTreeNode = currentInstr.dynamicNode as BinaryFactorVariableTreeNode;
-            return new EvaluationResult(((IList<string>)currentInstr.data)[row] == factorVarTreeNode.VariableValue ? factorVarTreeNode.Weight : 0);
+            var cur = new EvaluationResult(((IList<string>)currentInstr.data)[row] == factorVarTreeNode.VariableValue ? factorVarTreeNode.Weight : 0);
+            TraceEvaluation(currentInstr, cur);
+            return cur;
           }
         case OpCodes.FactorVariable: {
             if (row < 0 || row >= dataset.Rows) return EvaluationResult.NaN;
             var factorVarTreeNode = currentInstr.dynamicNode as FactorVariableTreeNode;
-            return new EvaluationResult(factorVarTreeNode.GetValue(((IList<string>)currentInstr.data)[row]));
+            var cur = new EvaluationResult(factorVarTreeNode.GetValue(((IList<string>)currentInstr.data)[row]));
+            TraceEvaluation(currentInstr, cur);
+            return cur;
           }
         case OpCodes.Constant: {
             var constTreeNode = (ConstantTreeNode)currentInstr.dynamicNode;
-            return new EvaluationResult(constTreeNode.Value);
+            var cur = new EvaluationResult(constTreeNode.Value);
+            TraceEvaluation(currentInstr, cur);
+            return cur;
           }
 

branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/SubVector.cs

@@ -22 +22 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
 using HEAL.Attic;
 
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
-  [StorableType("C6C245BF-C44A-4207-A268-55641483F27F")]
-  [Item("Sum", "Symbol that represents the sum function.")]
-  public sealed class Sum : WindowedSymbol {
+  [StorableType("4E9511C6-0FA4-496D-9610-35D9F779F899")]
+  [Item("SubVector", "Symbol that represents SubVector sum function.")]
+  public sealed class SubVector : WindowedSymbol {
     private const int minimumArity = 1;
     private const int maximumArity = 1;
@@ -40 +39 @@
 
     [StorableConstructor]
-    private Sum(StorableConstructorFlag _) : base(_) { }
-    private Sum(Sum original, Cloner cloner) : base(original, cloner) { }
+    private SubVector(StorableConstructorFlag _) : base(_) { }
+    private SubVector(SubVector original, Cloner cloner) : base(original, cloner) { }
     public override IDeepCloneable Clone(Cloner cloner) {
-      return new Sum(this, cloner);
+      return new SubVector(this, cloner);
     }
-    public Sum() : base("Sum", "Symbol that represents the sum function.") { }
+    public SubVector() : base("SubVector", "Symbol that represents the SubVector function.") { }
   }
 }

branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/Sum.cs

@@ -28 +28 @@
   [StorableType("C6C245BF-C44A-4207-A268-55641483F27F")]
   [Item("Sum", "Symbol that represents the sum function.")]
-  public sealed class Sum : WindowedSymbol {
+  public sealed class Sum : Symbol {
     private const int minimumArity = 1;
     private const int maximumArity = 1;

branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/WindowedSymbol.cs

@@ -130 +130 @@
         if (value != manipulatorLengthSigma) {
           manipulatorLengthSigma = value;
-          OnChanged(EventArgs.Empty);;
+          OnChanged(EventArgs.Empty);
         }
       }