Index: branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis.MultiVariate.Regression/3.3/Symbolic/Evaluators/MultiObjectiveSymbolicVectorRegressionEvaluator.cs
===================================================================
--- branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis.MultiVariate.Regression/3.3/Symbolic/Evaluators/MultiObjectiveSymbolicVectorRegressionEvaluator.cs	(revision 4197)
+++ branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis.MultiVariate.Regression/3.3/Symbolic/Evaluators/MultiObjectiveSymbolicVectorRegressionEvaluator.cs	(revision 4197)
@@ -0,0 +1,75 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
+using HeuristicLab.Operators;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.DataAnalysis.Regression;
+using HeuristicLab.Problems.DataAnalysis.Symbolic;
+using HeuristicLab.Problems.DataAnalysis.MultiVariate.Regression.Symbolic.Interfaces;
+
+namespace HeuristicLab.Problems.DataAnalysis.MultiVariate.Regression.Symbolic.Evaluators {
+  [StorableClass]
+  public abstract class MultiObjectiveSymbolicVectorRegressionEvaluator : SymbolicVectorRegressionEvaluator, IMultiObjectiveSymbolicVectorRegressionEvaluator {
+    private const string QualitiesParameterName = "Qualities";
+    #region parameter properties
+    public ILookupParameter<DoubleArray> QualitiesParameter {
+      get { return (ILookupParameter<DoubleArray>)Parameters[QualitiesParameterName]; }
+    }
+    #endregion
+    public MultiObjectiveSymbolicVectorRegressionEvaluator(bool deserializing) : base(deserializing) { }
+    public MultiObjectiveSymbolicVectorRegressionEvaluator()
+      : base() {
+      Parameters.Add(new LookupParameter<DoubleValue>(QualitiesParameterName, "The qualities of the symbolic vector regression solution."));
+    }
+
+
+    public override IOperation Apply() {
+      var interpreter = SymbolicExpressionTreeInterpreter;
+      var tree = SymbolicExpressionTree;
+      var problemData = MultiVariateDataAnalysisProblemData;
+
+      IEnumerable<string> selectedTargetVariables =
+        problemData.TargetVariables.CheckedItems
+        .Select(x => x.Value.Value);
+
+      // check if there is a vector component for each target variable
+      if (selectedTargetVariables.Count() != tree.Root.SubTrees[0].SubTrees.Count)
+        throw new ArgumentException("The dimension of the output-vector of the tree doesn't match the number of selected target variables.");
+      int start = SamplesStart.Value;
+      int end = SamplesEnd.Value;
+
+      IEnumerable<int> rows = GenerateRowsToEvaluate((uint)Random.Next(), RelativeNumberOfEvaluatedSamples.Value, start, end);
+
+      QualitiesParameter.ActualValue = new DoubleArray(Evaluate(tree, interpreter, problemData, selectedTargetVariables, rows, LowerEstimationLimit, UpperEstimationLimit));
+
+      return base.Apply();
+    }
+
+    public abstract double[] Evaluate(SymbolicExpressionTree tree, ISymbolicExpressionTreeInterpreter interpreter, MultiVariateDataAnalysisProblemData problemData, IEnumerable<string> selectedTargetVariables, IEnumerable<int> rows, DoubleArray LowerEstimationLimit, DoubleArray UpperEstimationLimit);
+  }
+}
Index: branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis.MultiVariate.Regression/3.3/Symbolic/Evaluators/PartialDerivativeEvaluator.cs
===================================================================
--- branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis.MultiVariate.Regression/3.3/Symbolic/Evaluators/PartialDerivativeEvaluator.cs	(revision 4197)
+++ branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis.MultiVariate.Regression/3.3/Symbolic/Evaluators/PartialDerivativeEvaluator.cs	(revision 4197)
@@ -0,0 +1,120 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2008 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using System;
+using HeuristicLab.Common;
+using System.Linq;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.DataAnalysis.Symbolic;
+using System.Collections.Generic;
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
+using HeuristicLab.Problems.DataAnalysis.Regression.Symbolic;
+using HeuristicLab.Problems.DataAnalysis.MultiVariate.Regression.Symbolic.Interfaces;
+using HeuristicLab.Parameters;
+
+
+namespace HeuristicLab.Problems.DataAnalysis.MultiVariate.Regression.Symbolic.Evaluators {
+  [Item("PartialDerivativeEvaluator", "Evaluator for implict equation modelling")]
+  [StorableClass]
+  public class PartialDerivativeEvaluator : SingleObjectiveSymbolicVectorRegressionEvaluator {
+
+    public PartialDerivativeEvaluator(bool deserializing) : base(deserializing) { }
+    public PartialDerivativeEvaluator()
+      : base() {
+    }
+
+    public override double Evaluate(SymbolicExpressionTree tree, ISymbolicExpressionTreeInterpreter interpreter, MultiVariateDataAnalysisProblemData problemData, IEnumerable<string> targetVariables, IEnumerable<int> rows, DoubleArray lowerEstimationBound, DoubleArray upperEstimationBound) {
+
+      Dataset dataset = problemData.Dataset;
+      IEnumerable<double> estimatedValues = interpreter.GetSymbolicExpressionTreeValues(tree, dataset, rows);
+
+      var sortedNames = targetVariables.OrderBy(x => x);
+      var pairs = from v1 in sortedNames
+                  from v2 in sortedNames.Skip(1)
+                  where v1.CompareTo(v2) < 0
+                  select new { x = v1, y = v2 };
+
+      double meanErrorSum = 0;
+      foreach (var pair in pairs) {
+        double errorSum = 0;
+        string variableX = pair.x;
+        string variableY = pair.y;
+
+        var dFdX = new SymbolicExpressionTree(PartialSymbolicDifferential.Apply((SymbolicExpressionTreeNode)tree.Root.Clone(), variableX, variableY));
+        IEnumerable<double> estimatedDfDx = interpreter.GetSymbolicExpressionTreeValues(dFdX, dataset, rows).ToList();
+
+        var dFdY = new SymbolicExpressionTree(PartialSymbolicDifferential.Apply((SymbolicExpressionTreeNode)tree.Root.Clone(), variableY, variableX));
+        IEnumerable<double> estimatedDfDy = interpreter.GetSymbolicExpressionTreeValues(dFdY, dataset, rows).ToList();
+
+        List<int> rowsList = rows.ToList();
+        int n = rowsList.Count;
+        int x = dataset.GetVariableIndex(variableX);
+        int y = dataset.GetVariableIndex(variableY);
+
+        var estimatedDfDxEnumerator = estimatedDfDx.GetEnumerator();
+        var estimatedDfDyEnumerator = estimatedDfDy.GetEnumerator();
+        var rowsEnumerator = rows.GetEnumerator();
+
+        // skip 1
+        estimatedDfDxEnumerator.MoveNext();
+        estimatedDfDyEnumerator.MoveNext();
+        rowsEnumerator.MoveNext();
+
+        for (int i = 1; i < n - 1; i++) {
+          // evaluate next
+          estimatedDfDxEnumerator.MoveNext();
+          estimatedDfDyEnumerator.MoveNext();
+          rowsEnumerator.MoveNext();
+
+          double dFdXValue = estimatedDfDxEnumerator.Current;
+          double dFdYValue = estimatedDfDyEnumerator.Current;
+          double dXdY = GetLocalDifferential(dataset, rowsEnumerator.Current, x, y);
+
+          if ((dFdXValue.IsAlmost(0.0) && dFdYValue.IsAlmost(0.0))) {
+            errorSum += Math.Log(1 + Math.Abs(dXdY));
+          } else if (dFdXValue.IsAlmost(0.0) ||
+            double.IsInfinity(dFdXValue) || double.IsNaN(dFdXValue) ||
+            double.IsInfinity(dFdYValue) || double.IsNaN(dFdYValue)) {
+            errorSum += 1000000;
+          } else {
+            double error = dXdY - dFdYValue / dFdXValue;
+            errorSum += Math.Log(1 + Math.Abs(error));
+            // errorSum += error * error;
+          }
+        }
+
+        meanErrorSum += errorSum / n;
+      }
+      meanErrorSum /= pairs.Count();
+
+      return meanErrorSum;
+    }
+
+    private double GetLocalDifferential(Dataset dataset, int i, int varX, int varY) {
+      return
+        (dataset[i + 1, varX] - dataset[i - 1, varX]) /
+        (dataset[i + 1, varY] - dataset[i - 1, varY]);
+    }
+
+  }
+}
Index: branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis.MultiVariate.Regression/3.3/Symbolic/Evaluators/PartialSymbolicDifferential.cs
===================================================================
--- branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis.MultiVariate.Regression/3.3/Symbolic/Evaluators/PartialSymbolicDifferential.cs	(revision 4197)
+++ branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis.MultiVariate.Regression/3.3/Symbolic/Evaluators/PartialSymbolicDifferential.cs	(revision 4197)
@@ -0,0 +1,256 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2008 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Diagnostics;
+using HeuristicLab.Common;
+using System.Linq;
+
+using System.Collections.Generic;
+using HeuristicLab.Problems.DataAnalysis.Symbolic.Symbols;
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.Symbols;
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding; // double.IsAlmost extension
+
+namespace HeuristicLab.Problems.DataAnalysis.MultiVariate.Regression.Symbolic.Evaluators {
+  public static class PartialSymbolicDifferential {
+    private static readonly DifferentialVariable differential = new DifferentialVariable();
+    private static readonly Constant @const = new Constant();
+    private static readonly ConstantTreeNode const0 = new ConstantTreeNode(@const);
+    private static readonly ConstantTreeNode const1 = new ConstantTreeNode(@const);
+    private static readonly Symbol addition = new Addition();
+    private static readonly Symbol subtraction = new Subtraction();
+    private static readonly Symbol multiplication = new Multiplication();
+    private static readonly Symbol division = new Division();
+    //private static readonly Symbol power = new Power();
+    private static readonly Symbol exp = new Exponential();
+    private static readonly Symbol ln = new Logarithm();
+    private static readonly Symbol cos = new Cosine();
+    private static readonly Symbol sin = new Sine();
+    private static readonly Symbol tan = new Tangent();
+
+    static PartialSymbolicDifferential() {
+      const0.Value = 0.0;
+      const1.Value = 1.0;
+    }
+
+    public static SymbolicExpressionTreeNode Apply(SymbolicExpressionTreeNode expression, string variableName, params string[] interdependentVariable) {
+      Symbol symbol = expression.Symbol;
+      if (symbol is Variable) {
+        var variable = (VariableTreeNode)expression;
+        if (variable.VariableName == variableName) return MakeConstant(variable.Weight);
+        else if (interdependentVariable.Contains(variable.VariableName)) {
+          return MakeProduct(MakeConstant(variable.Weight), MakeDivision(MakeDifferential(1.0, variable.VariableName), MakeDifferential(1.0, variableName)));
+        } else return const0;
+      } else if (symbol is Constant) {
+        return const0;
+      } else if (symbol is Addition) {
+        var sum = addition.CreateTreeNode();
+        foreach (var subExp in expression.SubTrees) {
+          sum.AddSubTree(Apply(subExp, variableName, interdependentVariable));
+        }
+        return sum;
+      } else if (symbol is Subtraction) {
+        var diff = subtraction.CreateTreeNode();
+        foreach (var subExp in expression.SubTrees) {
+          diff.AddSubTree(Apply(subExp, variableName, interdependentVariable));
+        }
+        return diff;
+
+      } else if (symbol is Multiplication) {
+        if (expression.SubTrees.Count() == 1) return Apply(expression.SubTrees[0], variableName, interdependentVariable);
+        SymbolicExpressionTreeNode sum = const0;
+
+        for (int i = 0; i < expression.SubTrees.Count; i++) {
+          SymbolicExpressionTreeNode prod = const1;
+
+          for (int j = 0; j < expression.SubTrees.Count; j++) {
+            if (j != i)
+              prod = MakeProduct(prod, expression.SubTrees[j]);
+            else
+              prod = MakeProduct(prod, Apply(expression.SubTrees[j], variableName, interdependentVariable));
+          }
+          sum = MakeSum(sum, prod);
+        }
+        return sum;
+      } else if (symbol is Division) {
+        // u/v 	(v*du/dx-u*dv/dx)/v^2
+        if (expression.SubTrees.Count == 1) {
+          SymbolicExpressionTreeNode v = expression.SubTrees[0];
+          SymbolicExpressionTreeNode dv = Apply(v, variableName, interdependentVariable);
+          return MakeDifference(const1, MakeDivision(dv, MakeSqr(v)));
+        } else if (expression.SubTrees.Count == 2) {
+          SymbolicExpressionTreeNode u = expression.SubTrees[0];
+          SymbolicExpressionTreeNode v = expression.SubTrees[1];
+          SymbolicExpressionTreeNode du = Apply(u, variableName, interdependentVariable);
+          SymbolicExpressionTreeNode dv = Apply(v, variableName, interdependentVariable);
+          u = MakeDivision(MakeDifference(MakeProduct(v, du), MakeProduct(u, dv)), MakeSqr(v));
+          for (int i = 2; i < expression.SubTrees.Count; i++) {
+            v = expression.SubTrees[i];
+            dv = Apply(v, variableName, interdependentVariable);
+            du = Apply(u, variableName, interdependentVariable);
+            u = MakeDivision(MakeDifference(MakeProduct(v, du), MakeProduct(u, dv)), MakeSqr(v));
+          }
+          return u;
+        } else throw new NotSupportedException("Derivative of division with arity " + expression.SubTrees.Count + " is not supported.");
+      } else if (symbol is Exponential) {
+        // e^u 	e^u*du/dx
+        return MakeProduct(MakeExp(expression.SubTrees[0]), Apply(expression.SubTrees[0], variableName, interdependentVariable));
+      } else if (symbol is Logarithm) {
+        return MakeProduct(MakeDivision(const1, expression.SubTrees[0]), Apply(expression.SubTrees[0], variableName, interdependentVariable));
+      }
+        //case EvaluatorSymbolTable.POWER: {
+        //    var a = expression.SubTrees[0];
+        //    var b = expression.SubTrees[1];
+        //    return Apply(MakeExp(MakeProduct(b, MakeLn(a))), variableName, interdependentVariable);
+        //  }
+        //case EvaluatorSymbolTable.SIGNUM: {
+        //    return const0;
+        //  }
+        else if (symbol is Sine) {
+        return MakeProduct(MakeCos(expression.SubTrees[0]), Apply(expression.SubTrees[0], variableName, interdependentVariable));
+      } else if (symbol is Cosine) {
+        return MakeProduct(MakeNegSin(expression.SubTrees[0]), Apply(expression.SubTrees[0], variableName, interdependentVariable));
+      } else if (symbol is Tangent) {
+        return MakeProduct(MakeSum(const1, MakeTanSqr(expression.SubTrees[0])), Apply(expression.SubTrees[0], variableName, interdependentVariable));
+      }
+        //else if(symbol is Sqrt) {
+        //      var powTree = new FunctionTreeBase(power);
+        //      powTree.AddSubTree(expression.SubTrees[0]);
+        //      powTree.AddSubTree(MakeConstant(0.5));
+        //      return Apply(powTree, variableName, interdependentVariable);
+        //    }
+      else if (symbol is ProgramRootSymbol) {
+        var branch = Apply(expression.SubTrees[0], variableName, interdependentVariable);
+        expression.RemoveSubTree(0);
+        expression.InsertSubTree(0, branch);
+        return expression;
+      } else if (symbol is StartSymbol) {
+        var branch = Apply(expression.SubTrees[0], variableName, interdependentVariable);
+        expression.RemoveSubTree(0);
+        expression.InsertSubTree(0, branch);
+        return expression;
+      } else {
+        throw new NotImplementedException();
+      }
+    }
+
+    private static SymbolicExpressionTreeNode MakeDifferential(double c, string v) {
+      DifferentialVariableTreeNode diffTree = (DifferentialVariableTreeNode)differential.CreateTreeNode();
+      diffTree.VariableName = v;
+      diffTree.Weight = c;
+      return diffTree;
+    }
+
+    private static SymbolicExpressionTreeNode MakeTanSqr(SymbolicExpressionTreeNode expression) {
+      var tanTree1 = tan.CreateTreeNode();
+      var tanTree2 = tan.CreateTreeNode();
+      tanTree2.AddSubTree(expression);
+      tanTree1.AddSubTree(tanTree2);
+      return tanTree1;
+    }
+
+    private static SymbolicExpressionTreeNode MakeNegSin(SymbolicExpressionTreeNode expression) {
+      var sinTree = sin.CreateTreeNode();
+      sinTree.AddSubTree(expression);
+      return MakeDifference(const0, sinTree);
+    }
+
+    private static SymbolicExpressionTreeNode MakeCos(SymbolicExpressionTreeNode expression) {
+      var cosTree = cos.CreateTreeNode();
+      cosTree.AddSubTree(expression);
+      return cosTree;
+    }
+
+    private static SymbolicExpressionTreeNode MakeLn(SymbolicExpressionTreeNode a) {
+      var lnTree = ln.CreateTreeNode();
+      lnTree.AddSubTree(a);
+      return lnTree;
+    }
+
+    private static SymbolicExpressionTreeNode MakeExp(SymbolicExpressionTreeNode expression) {
+      if (IsConstantZero(expression)) return const1;
+      var expTree = exp.CreateTreeNode();
+      expTree.AddSubTree(expression);
+      return expTree;
+    }
+
+    private static SymbolicExpressionTreeNode MakeDivision(SymbolicExpressionTreeNode x, SymbolicExpressionTreeNode y) {
+      if (IsConstantZero(x)) return const0;
+      var div = division.CreateTreeNode();
+      div.AddSubTree(x);
+      div.AddSubTree(y);
+      return div;
+    }
+
+    private static SymbolicExpressionTreeNode MakeSqr(SymbolicExpressionTreeNode x) {
+      var sqr = multiplication.CreateTreeNode();
+      sqr.AddSubTree(x);
+      sqr.AddSubTree((SymbolicExpressionTreeNode)x.Clone());
+      return sqr;
+    }
+
+    private static SymbolicExpressionTreeNode MakeProduct(SymbolicExpressionTreeNode x, SymbolicExpressionTreeNode y) {
+      if (IsConstantZero(x) || IsConstantZero(y)) {
+        return const0;
+      } else if (IsConstantOne(x)) return y;
+      else if (IsConstantOne(y)) return x;
+      var product = multiplication.CreateTreeNode();
+      product.AddSubTree(x);
+      product.AddSubTree(y);
+      return product;
+    }
+
+    private static bool IsConstantOne(SymbolicExpressionTreeNode x) {
+      return x == const1;
+    }
+
+    private static bool IsConstantZero(SymbolicExpressionTreeNode x) {
+      return x == const0;
+    }
+
+    private static SymbolicExpressionTreeNode MakeSum(SymbolicExpressionTreeNode a, SymbolicExpressionTreeNode b) {
+      if (IsConstantZero(a) && IsConstantZero(b)) return const0;
+      else if (IsConstantZero(a)) return b;
+      else if (IsConstantZero(b)) return a;
+      var product = addition.CreateTreeNode();
+      product.AddSubTree(a);
+      product.AddSubTree(b);
+      return product;
+    }
+
+    private static SymbolicExpressionTreeNode MakeDifference(SymbolicExpressionTreeNode a, SymbolicExpressionTreeNode b) {
+      if (IsConstantZero(a) && IsConstantZero(b)) return const0;
+      else if (IsConstantZero(b)) return a;
+      var diff = subtraction.CreateTreeNode();
+      diff.AddSubTree(a);
+      diff.AddSubTree(b);
+      return diff;
+    }
+
+    private static SymbolicExpressionTreeNode MakeConstant(double c) {
+      if (c.IsAlmost(1.0)) return const1;
+      else if (c.IsAlmost(0.0)) return const0;
+      var cExp = new ConstantTreeNode(@const);
+      cExp.Value = c;
+      return cExp;
+    }
+  }
+}
Index: branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis.MultiVariate.Regression/3.3/Symbolic/Evaluators/SingleObjectiveSymbolicVectorRegressionEvaluator.cs
===================================================================
--- branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis.MultiVariate.Regression/3.3/Symbolic/Evaluators/SingleObjectiveSymbolicVectorRegressionEvaluator.cs	(revision 4197)
+++ branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis.MultiVariate.Regression/3.3/Symbolic/Evaluators/SingleObjectiveSymbolicVectorRegressionEvaluator.cs	(revision 4197)
@@ -0,0 +1,75 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
+using HeuristicLab.Operators;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.DataAnalysis.Regression;
+using HeuristicLab.Problems.DataAnalysis.Symbolic;
+using HeuristicLab.Problems.DataAnalysis.MultiVariate.Regression.Symbolic.Interfaces;
+
+namespace HeuristicLab.Problems.DataAnalysis.MultiVariate.Regression.Symbolic.Evaluators {
+  [StorableClass]
+  public abstract class SingleObjectiveSymbolicVectorRegressionEvaluator : SymbolicVectorRegressionEvaluator, ISingleObjectiveSymbolicVectorRegressionEvaluator {
+    private const string QualityParameterName = "Quality";
+    #region parameter properties
+    public ILookupParameter<DoubleValue> QualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters[QualityParameterName]; }
+    }
+    #endregion
+    public SingleObjectiveSymbolicVectorRegressionEvaluator(bool deserializing) : base(deserializing) { }
+    public SingleObjectiveSymbolicVectorRegressionEvaluator()
+      : base() {
+      Parameters.Add(new LookupParameter<DoubleValue>(QualityParameterName, "The quality of the symbolic vector regression solution."));
+    }
+
+
+    public override IOperation Apply() {
+      var interpreter = SymbolicExpressionTreeInterpreter;
+      var tree = SymbolicExpressionTree;
+      var problemData = MultiVariateDataAnalysisProblemData;
+
+      IEnumerable<string> selectedTargetVariables =
+        problemData.TargetVariables.CheckedItems
+        .Select(x => x.Value.Value);
+
+      // check if there is a vector component for each target variable
+      if (selectedTargetVariables.Count() != tree.Root.SubTrees[0].SubTrees.Count)
+        throw new ArgumentException("The dimension of the output-vector of the tree doesn't match the number of selected target variables.");
+      int start = SamplesStart.Value;
+      int end = SamplesEnd.Value;
+
+      IEnumerable<int> rows = GenerateRowsToEvaluate((uint)Random.Next(), RelativeNumberOfEvaluatedSamples.Value, start, end);
+
+      QualityParameter.ActualValue = new DoubleValue(Evaluate(tree, interpreter, problemData, selectedTargetVariables, rows, LowerEstimationLimit, UpperEstimationLimit));
+
+      return base.Apply();
+    }
+
+    public abstract double Evaluate(SymbolicExpressionTree tree, ISymbolicExpressionTreeInterpreter interpreter, MultiVariateDataAnalysisProblemData problemData, IEnumerable<string> selectedTargetVariables, IEnumerable<int> rows, DoubleArray LowerEstimationLimit, DoubleArray UpperEstimationLimit);
+  }
+}
