Index: /branches/3076_IA_evaluators_analyzers/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression-3.4.csproj
===================================================================
--- /branches/3076_IA_evaluators_analyzers/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression-3.4.csproj	(revision 17622)
+++ /branches/3076_IA_evaluators_analyzers/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression-3.4.csproj	(revision 17623)
@@ -169,4 +169,7 @@
     <Compile Include="MultiObjective\PearsonRSquaredAverageSimilarityEvaluator.cs" />
     <Compile Include="MultiObjective\PearsonRSquaredTreeComplexityEvaluator.cs" />
+    <Compile Include="MultiObjective\SymbolicRegressionMultiObjectiveConstraintAnalyzer.cs" />
+    <Compile Include="MultiObjective\SymbolicRegressionMultiObjectiveMultiHardConstraintEvaluator.cs" />
+    <Compile Include="MultiObjective\SymbolicRegressionMultiObjectiveMultiSoftConstraintEvaluator.cs" />
     <Compile Include="MultiObjective\SymbolicRegressionMultiObjectiveValidationBestSolutionAnalyzer.cs" />
     <Compile Include="Plugin.cs" />
Index: /branches/3076_IA_evaluators_analyzers/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/SymbolicRegressionMultiObjectiveConstraintAnalyzer.cs
===================================================================
--- /branches/3076_IA_evaluators_analyzers/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/SymbolicRegressionMultiObjectiveConstraintAnalyzer.cs	(revision 17623)
+++ /branches/3076_IA_evaluators_analyzers/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/SymbolicRegressionMultiObjectiveConstraintAnalyzer.cs	(revision 17623)
@@ -0,0 +1,162 @@
+﻿#region License Information
+
+/* HeuristicLab
+ * Copyright (C) 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.Collections.Generic;
+using System.Linq;
+using HEAL.Attic;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+
+namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Regression {
+  [Item("TestAnalyzer",
+    "An operator that analyzes the training best symbolic regression solution for multi objective symbolic regression problems.")]
+  [StorableType("D802BF87-6137-47D6-BC09-A905BBB3534D")]
+  public class SymbolicRegressionMultiObjectiveConstraintAnalyzer :
+    SymbolicDataAnalysisMultiObjectiveTrainingBestSolutionAnalyzer<ISymbolicRegressionSolution>,
+    ISymbolicDataAnalysisInterpreterOperator, ISymbolicDataAnalysisBoundedOperator {
+    private const string SymbolicDataAnalysisTreeInterpreterParameterName = "SymbolicExpressionTreeInterpreter";
+    private const string EstimationLimitsParameterName                    = "EstimationLimits";
+    private const string ProblemDataParameterName                         = "ProblemData";
+
+    private const string SolutionObjectivesName  = "Solution Objectives";
+    private const string SolutionConstraintsName = "Solutions & Constraints";
+
+    #region Constructors
+
+    public ILookupParameter<ISymbolicDataAnalysisExpressionTreeInterpreter>
+      SymbolicDataAnalysisTreeInterpreterParameter =>
+      (ILookupParameter<ISymbolicDataAnalysisExpressionTreeInterpreter>) Parameters
+        [SymbolicDataAnalysisTreeInterpreterParameterName];
+
+    public IValueLookupParameter<DoubleLimit> EstimationLimitsParameter =>
+      (IValueLookupParameter<DoubleLimit>) Parameters[EstimationLimitsParameterName];
+
+    public IValueLookupParameter<IRegressionProblemData> ProblemDataParameter =>
+      (IValueLookupParameter<IRegressionProblemData>) Parameters[ProblemDataParameterName];
+
+    public IResultParameter<DoubleMatrix> SolutionObjectivesParameter =>
+      (IResultParameter<DoubleMatrix>) Parameters[SolutionObjectivesName];
+
+    public IResultParameter<ItemList<ISymbolicRegressionSolution>> SolutionConstraintsParameter =>
+      (IResultParameter<ItemList<ISymbolicRegressionSolution>>) Parameters[SolutionConstraintsName];
+
+    public SymbolicRegressionMultiObjectiveConstraintAnalyzer() {
+      Parameters.Add(new
+                       LookupParameter<ISymbolicDataAnalysisExpressionTreeInterpreter>(SymbolicDataAnalysisTreeInterpreterParameterName,
+                         "The interpreter that should be used to calculate the output values of the symbolic data analysis tree."));
+      Parameters.Add(new ValueLookupParameter<IRegressionProblemData>(ProblemDataParameterName,
+                                                                      "The problem data on which the symbolic data analysis solution should be evaluated."));
+      Parameters.Add(new ValueLookupParameter<DoubleLimit>(EstimationLimitsParameterName,
+                                                           "The upper and lower limit that should be used as cut off value for the output values of symbolic data analysis trees."));
+      Parameters.Add(new ResultParameter<DoubleMatrix>(SolutionObjectivesName,
+                                                       "Shows the constraints violation for each solution"));
+      SolutionObjectivesParameter.DefaultValue = new DoubleMatrix();
+      Parameters.Add(new ResultParameter<ItemList<ISymbolicRegressionSolution>>(SolutionConstraintsName,
+                                                                                "Holds the symbolic regression solutions"));
+      SolutionConstraintsParameter.DefaultValue = new ItemList<ISymbolicRegressionSolution>();
+    }
+
+    [StorableConstructor]
+    protected SymbolicRegressionMultiObjectiveConstraintAnalyzer(StorableConstructorFlag _) : base(_) { }
+
+    protected SymbolicRegressionMultiObjectiveConstraintAnalyzer(
+      SymbolicRegressionMultiObjectiveConstraintAnalyzer original, Cloner cloner) : base(original, cloner) { }
+
+    #endregion
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SymbolicRegressionMultiObjectiveConstraintAnalyzer(this, cloner);
+    }
+
+    public override IOperation Apply() {
+      var results     = ResultCollection;
+      var dataset     = ProblemDataParameter.ActualValue.Dataset;
+      var trees       = SymbolicExpressionTreeParameter.ActualValue;
+      var qualities   = QualitiesParameter.ActualValue;
+      var constraints = ProblemDataParameter.ActualValue.IntervalConstraints.Constraints;
+
+      if (!(qualities.First().Length < constraints.Count())) {
+        //DoubleMatrix
+        var dm = new DoubleMatrix(trees.Length, qualities[0].Length);
+        for (var i = 0; i < qualities.Length; ++i) {
+          for (var j = 0; j < qualities[i].Length; ++j) dm[i, j] = qualities[i][j];
+        }
+
+        dm.RowNames                             = GetRowNames(dm);
+        dm.ColumnNames                          = GetColumnNames(constraints);
+        SolutionObjectivesParameter.ActualValue = dm;
+      }
+
+      //SolutionsList
+      var treeQualities = new[] {new {Tree = default(ISymbolicExpressionTree), Qualities = default(double[])}}.ToList();
+      treeQualities.Clear();
+
+      var q = qualities.Select(x => x.ToArray()).ToList();
+      for (var i = 0; i < trees.Length; ++i) treeQualities.Add(new {Tree = trees[i], Qualities = q[i]});
+
+
+      var count  = 0;
+      var resSol = new ItemList<ISymbolicRegressionSolution>();
+      foreach (var tq in treeQualities) {
+        var model = new SymbolicRegressionModel(ProblemDataParameter.ActualValue.TargetVariable,
+                                                (ISymbolicExpressionTree) tq.Tree.Clone(),
+                                                SymbolicDataAnalysisTreeInterpreterParameter.ActualValue,
+                                                EstimationLimitsParameter.ActualValue.Lower,
+                                                EstimationLimitsParameter.ActualValue.Upper);
+        var sol =
+          new SymbolicRegressionSolution(model, (IRegressionProblemData) ProblemDataParameter.ActualValue.Clone());
+        //var sol = CreateSolution(tq.Tree, tq.Qualities);
+        sol.Name = string.Join(", ", "Solution" + count, tq.Qualities[0], tq.Qualities.Skip(1).Count(x => x > 0));
+        resSol.Add(sol);
+        count++;
+      }
+
+      SolutionConstraintsParameter.ActualValue = resSol;
+      return base.Apply();
+    }
+
+    protected override ISymbolicRegressionSolution CreateSolution(ISymbolicExpressionTree bestTree,
+                                                                  double[] bestQuality) {
+      var model = new SymbolicRegressionModel(ProblemDataParameter.ActualValue.TargetVariable,
+                                              (ISymbolicExpressionTree) bestTree.Clone(),
+                                              SymbolicDataAnalysisTreeInterpreterParameter.ActualValue,
+                                              EstimationLimitsParameter.ActualValue.Lower,
+                                              EstimationLimitsParameter.ActualValue.Upper);
+      if (ApplyLinearScalingParameter.ActualValue.Value) model.Scale(ProblemDataParameter.ActualValue);
+      return new SymbolicRegressionSolution(model, (IRegressionProblemData) ProblemDataParameter.ActualValue.Clone());
+    }
+
+    private static IEnumerable<string> GetColumnNames(IEnumerable<IntervalConstraint> constraints) {
+      yield return "NMSE";
+      foreach (var constraint in constraints) yield return constraint.Expression;
+    }
+
+    private static IEnumerable<string> GetRowNames(DoubleMatrix dm) {
+      for (var i = 0; i < dm.Rows; ++i) yield return "Solution " + i;
+    }
+  }
+}
Index: /branches/3076_IA_evaluators_analyzers/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/SymbolicRegressionMultiObjectiveMultiHardConstraintEvaluator.cs
===================================================================
--- /branches/3076_IA_evaluators_analyzers/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/SymbolicRegressionMultiObjectiveMultiHardConstraintEvaluator.cs	(revision 17623)
+++ /branches/3076_IA_evaluators_analyzers/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/SymbolicRegressionMultiObjectiveMultiHardConstraintEvaluator.cs	(revision 17623)
@@ -0,0 +1,123 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using HEAL.Attic;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
+
+namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Regression.MultiObjective {
+  public class
+    SymbolicRegressionMultiObjectiveMultiHardConstraintEvaluator : SymbolicRegressionMultiObjectiveEvaluator {
+    #region Constructors
+
+    public SymbolicRegressionMultiObjectiveMultiHardConstraintEvaluator() { }
+
+    [StorableConstructor]
+    protected SymbolicRegressionMultiObjectiveMultiHardConstraintEvaluator(StorableConstructorFlag _) : base(_) { }
+
+    protected SymbolicRegressionMultiObjectiveMultiHardConstraintEvaluator(
+      SymbolicRegressionMultiObjectiveMultiHardConstraintEvaluator original, Cloner cloner) :
+      base(original, cloner) { }
+
+    #endregion
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SymbolicRegressionMultiObjectiveMultiHardConstraintEvaluator(this, cloner);
+    }
+
+
+    public override IOperation InstrumentedApply() {
+      var rows               = GenerateRowsToEvaluate();
+      var solution           = SymbolicExpressionTreeParameter.ActualValue;
+      var problemData        = ProblemDataParameter.ActualValue;
+      var interpreter        = SymbolicDataAnalysisTreeInterpreterParameter.ActualValue;
+      var estimationLimits   = EstimationLimitsParameter.ActualValue;
+      var applyLinearScaling = false;
+
+      if (UseConstantOptimization)
+        SymbolicRegressionConstantOptimizationEvaluator.OptimizeConstants(interpreter, solution, problemData, rows,
+                                                                          applyLinearScaling,
+                                                                          ConstantOptimizationIterations,
+                                                                          updateVariableWeights:
+                                                                          ConstantOptimizationUpdateVariableWeights,
+                                                                          lowerEstimationLimit: estimationLimits.Lower,
+                                                                          upperEstimationLimit: estimationLimits.Upper);
+
+      var qualities = Calculate(interpreter, solution, estimationLimits.Lower, estimationLimits.Upper, problemData,
+                                rows, applyLinearScaling, DecimalPlaces);
+      QualitiesParameter.ActualValue = new DoubleArray(qualities);
+      return base.InstrumentedApply();
+    }
+
+    public override double[] Evaluate(IExecutionContext context, ISymbolicExpressionTree tree,
+                                      IRegressionProblemData problemData,
+                                      IEnumerable<int> rows) {
+      SymbolicDataAnalysisTreeInterpreterParameter.ExecutionContext = context;
+      EstimationLimitsParameter.ExecutionContext                    = context;
+      ApplyLinearScalingParameter.ExecutionContext                  = context;
+
+      var quality = Calculate(SymbolicDataAnalysisTreeInterpreterParameter.ActualValue, tree,
+                              EstimationLimitsParameter.ActualValue.Lower, EstimationLimitsParameter.ActualValue.Upper,
+                              problemData, rows,
+                              ApplyLinearScalingParameter.ActualValue.Value, DecimalPlaces);
+
+      SymbolicDataAnalysisTreeInterpreterParameter.ExecutionContext = null;
+      EstimationLimitsParameter.ExecutionContext                    = null;
+      ApplyLinearScalingParameter.ExecutionContext                  = null;
+
+      return quality;
+    }
+
+    public static double[] Calculate(ISymbolicDataAnalysisExpressionTreeInterpreter interpreter,
+                                     ISymbolicExpressionTree solution, double lowerEstimationLimit,
+                                     double upperEstimationLimit,
+                                     IRegressionProblemData problemData, IEnumerable<int> rows, bool applyLinearScaling,
+                                     int decimalPlaces) {
+      OnlineCalculatorError errorState;
+      var estimatedValues =
+        interpreter.GetSymbolicExpressionTreeValues(solution, problemData.Dataset, rows);
+      var targetValues = problemData.Dataset.GetDoubleValues(problemData.TargetVariable, rows);
+
+      double nmse;
+
+      var boundedEstimatedValues = estimatedValues.LimitToRange(lowerEstimationLimit, upperEstimationLimit);
+      nmse = OnlineNormalizedMeanSquaredErrorCalculator.Calculate(targetValues, boundedEstimatedValues, out errorState);
+      if (errorState != OnlineCalculatorError.None) nmse = double.NaN;
+
+      if (nmse > 1)
+        nmse = 1;
+
+      var constraints    = problemData.IntervalConstraints.Constraints.Where(c => c.Enabled);
+      var variableRanges = problemData.VariableRanges.GetReadonlyDictionary();
+
+      var objectives = new List<double> {nmse}; //Add r² to resultlist
+      var constraintObjectives = constraints.Select(constraint =>
+                                                      ConstraintExceeded(constraint, new IntervalInterpreter(),
+                                                                         variableRanges, solution));
+      objectives.AddRange(constraintObjectives); //Add hardconstraints for each constraint
+
+      return objectives.ToArray();
+    }
+
+    private static double ConstraintExceeded(IntervalConstraint constraint, IntervalInterpreter intervalInterpreter,
+                                             IReadOnlyDictionary<string, Interval> variableRanges,
+                                             ISymbolicExpressionTree solution) {
+      return SymbolicRegressionConstraintAnalyzer.ConstraintSatisfied(constraint, new IntervalInterpreter(),
+                                                                      variableRanges, solution) ? 0 : 1;
+    }
+
+    /*
+     * First objective is to maximize the Pearson R² value
+     * All following objectives have to be minimized ==> Constraints
+     */
+    public override IEnumerable<bool> Maximization {
+      get {
+        var objectives = new List<bool> {true};           //Max the pearson r² value
+        objectives.AddRange(Enumerable.Repeat(false, 6)); //Min the constraints
+        return objectives;
+      }
+    }
+  }
+}
Index: /branches/3076_IA_evaluators_analyzers/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/SymbolicRegressionMultiObjectiveMultiSoftConstraintEvaluator.cs
===================================================================
--- /branches/3076_IA_evaluators_analyzers/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/SymbolicRegressionMultiObjectiveMultiSoftConstraintEvaluator.cs	(revision 17623)
+++ /branches/3076_IA_evaluators_analyzers/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/SymbolicRegressionMultiObjectiveMultiSoftConstraintEvaluator.cs	(revision 17623)
@@ -0,0 +1,216 @@
+﻿#region License Information
+
+/* HeuristicLab
+ * Copyright (C) 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 HEAL.Attic;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
+using HeuristicLab.Parameters;
+
+namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Regression.MultiObjective {
+  [Item("Multi Soft Constraints Evaluator",
+    "Calculates the Person R² and the constraints violations of a symbolic regression solution.")]
+  [StorableType("8E9D76B7-ED9C-43E7-9898-01FBD3633880")]
+  public class
+    SymbolicRegressionMultiObjectiveMultiSoftConstraintEvaluator : SymbolicRegressionMultiObjectiveEvaluator {
+    private const string MinIntervalWidthParameterName      = "MinIntervalWidth";
+    private const string MaxIntervalSplitDepthParameterName = "MaxIntervalSplitDepth";
+
+    public IFixedValueParameter<DoubleValue> MinIntervalWidthParameter =>
+      (IFixedValueParameter<DoubleValue>) Parameters[MinIntervalWidthParameterName];
+
+    public IFixedValueParameter<IntValue> MaxIntervalSplitDepthParameter =>
+      (IFixedValueParameter<IntValue>) Parameters[MaxIntervalSplitDepthParameterName];
+
+    public double MinIntervalWidth => MinIntervalWidthParameter.Value.Value;
+
+    public int MaxIntervalSplitDepth => MaxIntervalSplitDepthParameter.Value.Value;
+
+    #region Constructors
+
+    public SymbolicRegressionMultiObjectiveMultiSoftConstraintEvaluator() {
+      Parameters.Add(new FixedValueParameter<DoubleValue>(MinIntervalWidthParameterName, new DoubleValue(1.0)));
+      Parameters.Add(new FixedValueParameter<IntValue>(MaxIntervalSplitDepthParameterName, new IntValue(5)));
+    }
+
+    [StorableConstructor]
+    protected SymbolicRegressionMultiObjectiveMultiSoftConstraintEvaluator(StorableConstructorFlag _) : base(_) { }
+
+    protected SymbolicRegressionMultiObjectiveMultiSoftConstraintEvaluator(
+      SymbolicRegressionMultiObjectiveMultiSoftConstraintEvaluator original, Cloner cloner) : base(original, cloner) { }
+
+    #endregion
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SymbolicRegressionMultiObjectiveMultiSoftConstraintEvaluator(this, cloner);
+    }
+
+
+    public override IOperation InstrumentedApply() {
+      var rows             = GenerateRowsToEvaluate();
+      var solution         = SymbolicExpressionTreeParameter.ActualValue;
+      var problemData      = ProblemDataParameter.ActualValue;
+      var interpreter      = SymbolicDataAnalysisTreeInterpreterParameter.ActualValue;
+      var estimationLimits = EstimationLimitsParameter.ActualValue;
+      //var applyLinearScaling = ApplyLinearScalingParameter.ActualValue.Value;
+      var applyLinearScaling = false;
+
+      if (UseConstantOptimization)
+        SymbolicRegressionConstantOptimizationEvaluator.OptimizeConstants(interpreter, solution, problemData, rows,
+                                                                          applyLinearScaling,
+                                                                          ConstantOptimizationIterations,
+                                                                          ConstantOptimizationUpdateVariableWeights,
+                                                                          estimationLimits.Lower,
+                                                                          estimationLimits.Upper);
+
+      var qualities = Calculate(interpreter, solution, estimationLimits.Lower, estimationLimits.Upper, problemData,
+                                rows, applyLinearScaling, DecimalPlaces, MinIntervalWidth, MaxIntervalSplitDepth);
+      QualitiesParameter.ActualValue = new DoubleArray(qualities);
+      return base.InstrumentedApply();
+    }
+
+    public override double[] Evaluate(IExecutionContext context, ISymbolicExpressionTree tree,
+                                      IRegressionProblemData problemData,
+                                      IEnumerable<int> rows) {
+      SymbolicDataAnalysisTreeInterpreterParameter.ExecutionContext = context;
+      EstimationLimitsParameter.ExecutionContext                    = context;
+      ApplyLinearScalingParameter.ExecutionContext                  = context;
+
+      var quality = Calculate(SymbolicDataAnalysisTreeInterpreterParameter.ActualValue, tree,
+                              EstimationLimitsParameter.ActualValue.Lower, EstimationLimitsParameter.ActualValue.Upper,
+                              problemData, rows,
+                              ApplyLinearScalingParameter.ActualValue.Value, DecimalPlaces, MinIntervalWidth,
+                              MaxIntervalSplitDepth);
+
+      SymbolicDataAnalysisTreeInterpreterParameter.ExecutionContext = null;
+      EstimationLimitsParameter.ExecutionContext                    = null;
+      ApplyLinearScalingParameter.ExecutionContext                  = null;
+
+      return quality;
+    }
+
+
+    public static double[] Calculate(ISymbolicDataAnalysisExpressionTreeInterpreter interpreter,
+                                     ISymbolicExpressionTree solution, double lowerEstimationLimit,
+                                     double upperEstimationLimit,
+                                     IRegressionProblemData problemData, IEnumerable<int> rows, bool applyLinearScaling,
+                                     int decimalPlaces, double minIntervalSplitWidth, int maxIntervalSplitDetph) {
+      OnlineCalculatorError errorState;
+      var estimatedValues =
+        interpreter.GetSymbolicExpressionTreeValues(solution, problemData.Dataset, rows);
+      var targetValues = problemData.Dataset.GetDoubleValues(problemData.TargetVariable, rows);
+
+      double nmse;
+
+      var boundedEstimatedValues = estimatedValues.LimitToRange(lowerEstimationLimit, upperEstimationLimit);
+      nmse = OnlineNormalizedMeanSquaredErrorCalculator.Calculate(targetValues, boundedEstimatedValues, out errorState);
+      if (errorState != OnlineCalculatorError.None) nmse = double.NaN;
+
+      if (nmse > 1)
+        nmse = 1;
+
+      var constraints    = problemData.IntervalConstraints.Constraints.Where(c => c.Enabled);
+      var variableRanges = problemData.VariableRanges.GetReadonlyDictionary();
+
+      var objectives          = new List<double> {nmse};
+      var intervalInterpreter = new IntervalInterpreter();
+      /*{MinIntervalSplitWidth = minIntervalSplitWidth, MaxIntervalSplitDepth = maxIntervalSplitDetph};*/
+
+      var constraintObjectives = new List<double>();
+      foreach (var c in constraints) {
+        var penalty = ConstraintExceeded(c, intervalInterpreter, variableRanges,
+                                         solution /*, problemData.IntervalSplitting*/);
+        var maxP = 0.1;
+
+        if (double.IsNaN(penalty) || double.IsInfinity(penalty) || penalty > maxP)
+          penalty = maxP;
+
+        constraintObjectives.Add(penalty);
+      }
+
+      objectives.AddRange(constraintObjectives);
+
+      return objectives.ToArray();
+    }
+
+    public static double ConstraintExceeded(IntervalConstraint constraint, IntervalInterpreter intervalInterpreter,
+                                            IReadOnlyDictionary<string, Interval> variableRanges,
+                                            ISymbolicExpressionTree solution /*, bool splitting*/) {
+      if (constraint.Variable != null && !variableRanges.ContainsKey(constraint.Variable))
+        throw new ArgumentException(
+                                    $"The given variable {constraint.Variable} in the constraint does not exists in the model.",
+                                    nameof(IntervalConstraintsParser));
+      Interval resultInterval;
+      if (!constraint.IsDerivative) {
+        resultInterval =
+          intervalInterpreter.GetSymbolicExpressionTreeInterval(solution, variableRanges /*, splitting:splitting*/);
+      }
+      else {
+        var tree = solution;
+        for (var i = 0; i < constraint.NumberOfDerivations; ++i)
+          tree = DerivativeCalculator.Derive(tree, constraint.Variable);
+
+        resultInterval =
+          intervalInterpreter.GetSymbolicExpressionTreeInterval(tree, variableRanges /*, splitting: splitting*/);
+      }
+
+      //Calculate soft-constraints for intervals
+      if (constraint.Interval.Contains(resultInterval)) return 0;
+      var pLower = 0.0;
+      var pUpper = 0.0;
+      if (constraint.Interval.Contains(resultInterval.LowerBound))
+        pLower = 0;
+      else
+        pLower = constraint.Interval.LowerBound - resultInterval.LowerBound;
+
+      if (constraint.Interval.Contains(resultInterval.UpperBound))
+        pUpper = 0;
+      else
+        pUpper = resultInterval.UpperBound - constraint.Interval.UpperBound;
+      var penalty = Math.Abs(pLower) + Math.Abs(pUpper);
+
+      return penalty;
+    }
+
+    public static double Normalize(double val, double min = 0, double max = 10e6) {
+      return (val - min) / (max - min);
+    }
+
+    /*
+     * First objective is to maximize the Pearson R² value
+     * All following objectives have to be minimized ==> Constraints
+     */
+    public override IEnumerable<bool> Maximization {
+      get {
+        var objectives = new List<bool> {false}; //First NMSE ==> min
+        objectives.AddRange(Enumerable.Repeat(false, 3)); //Constraints ==> min
+
+        return objectives;
+      }
+    }
+  }
+}
Index: /branches/3076_IA_evaluators_analyzers/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/SymbolicRegressionMultiObjectiveProblem.cs
===================================================================
--- /branches/3076_IA_evaluators_analyzers/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/SymbolicRegressionMultiObjectiveProblem.cs	(revision 17622)
+++ /branches/3076_IA_evaluators_analyzers/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/SymbolicRegressionMultiObjectiveProblem.cs	(revision 17623)
@@ -96,4 +96,5 @@
       Operators.Add(new SymbolicExpressionTreePhenotypicSimilarityCalculator());
       Operators.Add(new SymbolicRegressionPhenotypicDiversityAnalyzer(Operators.OfType<SymbolicExpressionTreePhenotypicSimilarityCalculator>()));
+      Operators.Add(new SymbolicRegressionMultiObjectiveConstraintAnalyzer());
       ParameterizeOperators();
     }
