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 17820)
+++ /branches/3076_IA_evaluators_analyzers/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression-3.4.csproj	(revision 17821)
@@ -176,10 +176,7 @@
     <Compile Include="SingleObjective\Evaluators\SymbolicRegressionMeanRelativeErrorEvaluator.cs" />
     <Compile Include="SingleObjective\Evaluators\SymbolicRegressionSingleObjectiveConstraintEvaluator.cs" />
-    <Compile Include="SingleObjective\Evaluators\SymbolicRegressionSingleObjectiveConstraintScalingNmseEvaluator.cs" />
-    <Compile Include="SingleObjective\Evaluators\SymbolicRegressionSingleObjectiveConstraintConstOptNmseEvaluator.cs" />
     <Compile Include="SingleObjective\SymbolicRegressionSolutionsAnalyzer.cs" />
+    <Compile Include="SymbolicRegressionSplittingAnalyzer.cs" />
     <Compile Include="SymbolicRegressionConstraintAnalyzer.cs" />
-    <Compile Include="SymbolicRegressionMetaModelAnalyzer.cs" />
-    <Compile Include="SymbolicRegressionMultiObjectiveMetaModelAnalyzer.cs" />
     <Compile Include="SymbolicRegressionPhenotypicDiversityAnalyzer.cs" />
     <Compile Include="SymbolicRegressionPruningAnalyzer.cs" />
@@ -209,5 +206,4 @@
     <Compile Include="SingleObjective\Evaluators\SymbolicRegressionSingleObjectivePearsonRSquaredEvaluator.cs" />
     <Compile Include="SymbolicRegressionPruningOperator.cs" />
-    <Compile Include="SymbolicRegressionSingleObjectiveMetaModelAnalyzer.cs" />
     <Compile Include="SymbolicRegressionSolution.cs" />
     <Compile Include="SymbolicRegressionSolutionImpactValuesCalculator.cs" />
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 17820)
+++ /branches/3076_IA_evaluators_analyzers/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/SymbolicRegressionMultiObjectiveMultiHardConstraintEvaluator.cs	(revision 17821)
@@ -11,4 +11,13 @@
   [StorableType("9397A63D-0C6B-4733-BD1A-59AAE9A9F006")]
   public class SymbolicRegressionMultiObjectiveMultiHardConstraintEvaluator : SymbolicRegressionMultiObjectiveEvaluator {
+    private const string BoundsEstimatorParameterName = "Bounds estimator";
+    public IValueParameter<IBoundsEstimator> BoundsEstimatorParameter =>
+      (IValueParameter<IBoundsEstimator>)Parameters[BoundsEstimatorParameterName];
+
+    public IBoundsEstimator BoundsEstimator {
+      get => BoundsEstimatorParameter.Value;
+      set => BoundsEstimatorParameter.Value = value;
+    }
+
     #region Constructors
 
@@ -47,5 +56,5 @@
 
       var qualities = Calculate(interpreter, solution, estimationLimits.Lower, estimationLimits.Upper, problemData,
-                                rows, applyLinearScaling, DecimalPlaces);
+                                rows, applyLinearScaling, DecimalPlaces, BoundsEstimator);
       QualitiesParameter.ActualValue = new DoubleArray(qualities);
       return base.InstrumentedApply();
@@ -62,5 +71,5 @@
                               EstimationLimitsParameter.ActualValue.Lower, EstimationLimitsParameter.ActualValue.Upper,
                               problemData, rows,
-                              ApplyLinearScalingParameter.ActualValue.Value, DecimalPlaces);
+                              ApplyLinearScalingParameter.ActualValue.Value, DecimalPlaces, BoundsEstimator);
 
       SymbolicDataAnalysisTreeInterpreterParameter.ExecutionContext = null;
@@ -75,5 +84,5 @@
                                      double upperEstimationLimit,
                                      IRegressionProblemData problemData, IEnumerable<int> rows, bool applyLinearScaling,
-                                     int decimalPlaces) {
+                                     int decimalPlaces, IBoundsEstimator estimator) {
       OnlineCalculatorError errorState;
       var estimatedValues =
@@ -91,10 +100,10 @@
 
       var constraints    = problemData.IntervalConstraints.Constraints.Where(c => c.Enabled);
-      var variableRanges = problemData.VariableRanges.GetReadonlyDictionary();
+      var intervalCollection = problemData.VariableRanges;
 
       var objectives = new List<double> {nmse}; //Add r² to resultlist
       var constraintObjectives = constraints.Select(constraint =>
-                                                      ConstraintExceeded(constraint, new IntervalInterpreter(),
-                                                                         variableRanges, solution));
+        IntervalUtil.IntervalConstraintViolation(constraint, estimator, intervalCollection, solution) > 0 ? 0.0 : 1.0);
+
       objectives.AddRange(constraintObjectives); //Add hardconstraints for each constraint
 
@@ -102,10 +111,4 @@
     }
 
-    private static double ConstraintExceeded(IntervalConstraint constraint, IntervalInterpreter intervalInterpreter,
-                                             IReadOnlyDictionary<string, Interval> variableRanges,
-                                             ISymbolicExpressionTree solution) {
-      return SymbolicRegressionConstraintAnalyzer.ConstraintSatisfied(constraint, new IntervalInterpreter(),
-                                                                      variableRanges, solution, out double error) ? 0 : 1;
-    }
 
     /*
Index: anches/3076_IA_evaluators_analyzers/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/Evaluators/SymbolicRegressionSingleObjectiveConstraintConstOptNmseEvaluator.cs
===================================================================
--- /branches/3076_IA_evaluators_analyzers/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/Evaluators/SymbolicRegressionSingleObjectiveConstraintConstOptNmseEvaluator.cs	(revision 17820)
+++ 	(revision )
@@ -1,166 +1,0 @@
-﻿using System;
-using System.Collections.Generic;
-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.SingleObjective.Evaluators {
-  [Item("Constraint ConstOpt NMSE Evaluator", "")]
-  [StorableType("DED36D85-A4BA-4019-B12D-C523F7327899")]
-  public class SymbolicRegressionSingleObjectiveConstraintConstOptNmseEvaluator
-    : SymbolicRegressionSingleObjectiveEvaluator {
-    private const string UseConstOptParameterName = "Use ConstOpt";
-    private const string ConstOptIterationsParameterName = "ConstOpt Iterations";
-    private const string PenalityMultiplierParameterName = "ConstraintsPenalityMultiplier";
-    private const string BoundsEstimatorParameterName = "Bounds estimator";
-
-    public IFixedValueParameter<BoolValue> UseConstOptParamerter =>
-      (IFixedValueParameter<BoolValue>) Parameters[UseConstOptParameterName];
-
-    public IFixedValueParameter<IntValue> ConstOpterIterationsParameter =>
-      (IFixedValueParameter<IntValue>) Parameters[ConstOptIterationsParameterName];
-
-    public ILookupParameter<DoubleValue> PenalityMultiplierParameter =>
-      (ILookupParameter<DoubleValue>)Parameters[PenalityMultiplierParameterName];
-
-    public IValueParameter<IBoundsEstimator> BoundsEstimatorParameter =>
-      (IValueParameter<IBoundsEstimator>) Parameters[BoundsEstimatorParameterName];
-
-    public bool UseConstOpt {
-      get => UseConstOptParamerter.Value.Value;
-      set => UseConstOptParamerter.Value.Value = value;
-    }
-
-    public int ConstOptIterations {
-      get => ConstOpterIterationsParameter.Value.Value;
-      set => ConstOpterIterationsParameter.Value.Value = value;
-    }
-
-    public IBoundsEstimator BoundsEstimator {
-      get => BoundsEstimatorParameter.Value;
-      set => BoundsEstimatorParameter.Value = value;
-    }
-
-    [StorableConstructor]
-    protected SymbolicRegressionSingleObjectiveConstraintConstOptNmseEvaluator(StorableConstructorFlag _) : base(_) {}
-
-    protected SymbolicRegressionSingleObjectiveConstraintConstOptNmseEvaluator(
-      SymbolicRegressionSingleObjectiveConstraintConstOptNmseEvaluator original, Cloner cloner) :
-      base(original, cloner) { }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new SymbolicRegressionSingleObjectiveConstraintConstOptNmseEvaluator(this, cloner);
-    }
-
-    public SymbolicRegressionSingleObjectiveConstraintConstOptNmseEvaluator() {
-      Parameters.Add(new FixedValueParameter<BoolValue>(UseConstOptParameterName,
-        "Define whether constOpt is active or not.", new BoolValue(true)));
-      Parameters.Add(new FixedValueParameter<IntValue>(ConstOptIterationsParameterName,
-        "Define how many constOpt iterations should be performed.", new IntValue(10)));
-      Parameters.Add(new LookupParameter<DoubleValue>(PenalityMultiplierParameterName,
-        "Lookup parameter for the penality multiplier.", "PenalityMultiplier"));
-      Parameters.Add(new ValueParameter<IBoundsEstimator>(BoundsEstimatorParameterName, "Select the Boundsestimator.", new IABoundsEstimator()));
-    }
-
-    public override bool Maximization => false;
-
-    [StorableHook(HookType.AfterDeserialization)]
-    private void AfterDeserialization() {
-      if (!Parameters.ContainsKey(UseConstOptParameterName)) {
-        Parameters.Add(new FixedValueParameter<BoolValue>(UseConstOptParameterName,
-          "Define whether constOpt is active or not.", new BoolValue(true)));
-      }
-
-      if (!Parameters.ContainsKey(ConstOptIterationsParameterName)) {
-        Parameters.Add(new FixedValueParameter<IntValue>(ConstOptIterationsParameterName,
-          "Define how many constOpt iterations should be performed.", new IntValue(10)));
-      }
-
-      if (!Parameters.ContainsKey(PenalityMultiplierParameterName))
-        Parameters.Add(new LookupParameter<DoubleValue>(PenalityMultiplierParameterName,
-          "Lookup parameter for the penality multiplier.", "PenalityMultiplier"));
-
-      if (!Parameters.ContainsKey(BoundsEstimatorParameterName))
-        Parameters.Add(new ValueParameter<IBoundsEstimator>(BoundsEstimatorParameterName, "Select the Boundsestimator.", new IABoundsEstimator()));
-    }
-
-    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;
-      var constantOptimizationIterations         = ConstOptIterations;
-      var constantOptimizationUpdateVariableWeights = true;
-
-      //Use Const Opt
-      if(UseConstOpt)
-        SymbolicRegressionConstantOptimizationEvaluator.OptimizeConstants(interpreter, solution, problemData, rows,
-          applyLinearScaling, constantOptimizationIterations, constantOptimizationUpdateVariableWeights,
-          estimationLimits.Lower, estimationLimits.Upper);
-
-      var penalityMultiplier = PenalityMultiplierParameter.ActualValue?.Value ?? 1.0;
-
-      var quality = Calculate(interpreter, solution, estimationLimits.Lower, estimationLimits.Upper, problemData, rows,
-        applyLinearScaling, penalityMultiplier);
-      QualityParameter.ActualValue = new DoubleValue(quality);
-
-
-      return base.InstrumentedApply();
-    }
-
-    public static double Calculate(
-      ISymbolicDataAnalysisExpressionTreeInterpreter interpreter,
-      ISymbolicExpressionTree solution, double lowerEstimationLimit,
-      double upperEstimationLimit,
-      IRegressionProblemData problemData, IEnumerable<int> rows, bool applyLinearScaling, 
-      double penalityMultiplier) {
-      var estimatedValues =
-        interpreter.GetSymbolicExpressionTreeValues(solution, problemData.Dataset, rows);
-      var targetValues = problemData.Dataset.GetDoubleValues(problemData.TargetVariable, rows);
-      var constraints = problemData.IntervalConstraints.EnabledConstraints;
-      var variableRanges = problemData.VariableRanges.GetReadonlyDictionary();
-
-      var boundedEstimatedValues = estimatedValues.LimitToRange(lowerEstimationLimit, upperEstimationLimit);
-      var nmse = OnlineNormalizedMeanSquaredErrorCalculator.Calculate(targetValues, boundedEstimatedValues, out var errorState);
-      if (!SymbolicRegressionConstraintAnalyzer.ConstraintsSatisfied(constraints, variableRanges, solution, out double error))
-      {
-        if (double.IsNaN(error) || double.IsInfinity(error))
-          nmse += penalityMultiplier * 1.0;
-        else
-          nmse += penalityMultiplier * error;
-        nmse = Math.Min(1.0, nmse);
-      }
-
-      if (errorState != OnlineCalculatorError.None) nmse = 1.0;
-
-      return nmse;
-    }
-    
-    public override double Evaluate(
-      IExecutionContext context, ISymbolicExpressionTree tree, IRegressionProblemData problemData,
-      IEnumerable<int> rows) {
-      SymbolicDataAnalysisTreeInterpreterParameter.ExecutionContext = context;
-      EstimationLimitsParameter.ExecutionContext                    = context;
-      ApplyLinearScalingParameter.ExecutionContext                  = context;
-
-      var penalityMultiplier = PenalityMultiplierParameter.ActualValue?.Value ?? 1.0;
-
-      var nmse = Calculate(SymbolicDataAnalysisTreeInterpreterParameter.ActualValue, tree,
-        EstimationLimitsParameter.ActualValue.Lower, EstimationLimitsParameter.ActualValue.Upper,
-        problemData, rows,
-        ApplyLinearScalingParameter.ActualValue.Value,
-        penalityMultiplier);
-
-      SymbolicDataAnalysisTreeInterpreterParameter.ExecutionContext = null;
-      EstimationLimitsParameter.ExecutionContext                    = null;
-      ApplyLinearScalingParameter.ExecutionContext                  = null;
-
-      return nmse;
-    }
-  }
-}
Index: anches/3076_IA_evaluators_analyzers/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/Evaluators/SymbolicRegressionSingleObjectiveConstraintScalingNmseEvaluator.cs
===================================================================
--- /branches/3076_IA_evaluators_analyzers/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/Evaluators/SymbolicRegressionSingleObjectiveConstraintScalingNmseEvaluator.cs	(revision 17820)
+++ 	(revision )
@@ -1,116 +1,0 @@
-﻿using System.Collections.Generic;
-using HEAL.Attic;
-using HeuristicLab.Common;
-using HeuristicLab.Core;
-using HeuristicLab.Data;
-using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
-
-namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Regression.SingleObjective.Evaluators {
-  [Item("Constraint Scaling NMSE Evaluator", "")]
-  [StorableType("5B69083F-74EE-446C-A7D1-9DEAAA128AC6")]
-  public class SymbolicRegressionSingleObjectiveConstraintScalingNmseEvaluator
-    : SymbolicRegressionSingleObjectiveEvaluator {
-    [StorableConstructor]
-    protected SymbolicRegressionSingleObjectiveConstraintScalingNmseEvaluator(StorableConstructorFlag _) : base(_) { }
-
-    protected SymbolicRegressionSingleObjectiveConstraintScalingNmseEvaluator(
-      SymbolicRegressionSingleObjectiveConstraintScalingNmseEvaluator original, Cloner cloner) :
-      base(original, cloner) { }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new SymbolicRegressionSingleObjectiveConstraintScalingNmseEvaluator(this, cloner);
-    }
-
-    public SymbolicRegressionSingleObjectiveConstraintScalingNmseEvaluator() { }
-
-    public override bool Maximization => false;
-
-
-    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 = true;
-
-      if (applyLinearScaling) {
-        //Check for interval arithmetic grammar
-        //remove scaling nodes for linear scaling evaluation
-        var                    rootNode  = new ProgramRootSymbol().CreateTreeNode();
-        var                    startNode = new StartSymbol().CreateTreeNode();
-        SymbolicExpressionTree newTree   = null;
-        foreach (var node in solution.IterateNodesPrefix())
-          if (node.Symbol.Name == "Scaling") {
-            for (var i = 0; i < node.SubtreeCount; ++i) startNode.AddSubtree(node.GetSubtree(i));
-            rootNode.AddSubtree(startNode);
-            newTree = new SymbolicExpressionTree(rootNode);
-            break;
-          }
-
-        //calculate alpha and beta for scaling
-        var estimatedValues = interpreter.GetSymbolicExpressionTreeValues(newTree, problemData.Dataset, rows);
-        var targetValues    = problemData.Dataset.GetDoubleValues(problemData.TargetVariable, rows);
-        OnlineLinearScalingParameterCalculator.Calculate(estimatedValues, targetValues, out var alpha, out var beta,
-          out var errorState);
-        //Set alpha and beta to the scaling nodes from ia grammar
-        foreach (var node in solution.IterateNodesPrefix())
-          if (node.Symbol.Name == "Offset") {
-            node.RemoveSubtree(1);
-            var alphaNode = new ConstantTreeNode(new Constant()) {Value = alpha};
-            node.AddSubtree(alphaNode);
-          } else if (node.Symbol.Name == "Scaling") {
-            node.RemoveSubtree(1);
-            var betaNode = new ConstantTreeNode(new Constant()) {Value = beta};
-            node.AddSubtree(betaNode);
-          }
-      }
-
-
-      var quality = Calculate(interpreter, solution, estimationLimits.Lower, estimationLimits.Upper, problemData, rows,
-        false);
-      QualityParameter.ActualValue = new DoubleValue(quality);
-      return base.InstrumentedApply();
-    }
-
-    public static double Calculate(
-      ISymbolicDataAnalysisExpressionTreeInterpreter interpreter,
-      ISymbolicExpressionTree solution, double lowerEstimationLimit,
-      double upperEstimationLimit,
-      IRegressionProblemData problemData, IEnumerable<int> rows, bool applyLinearScaling) {
-      var estimatedValues =
-        interpreter.GetSymbolicExpressionTreeValues(solution, problemData.Dataset, rows);
-      var targetValues   = problemData.Dataset.GetDoubleValues(problemData.TargetVariable, rows);
-      var constraints    = problemData.IntervalConstraints.EnabledConstraints;
-      var variableRanges = problemData.VariableRanges.GetReadonlyDictionary();
-
-      if (!SymbolicRegressionConstraintAnalyzer.ConstraintsSatisfied(constraints, variableRanges, solution, out double error))
-        return 1.0;
-
-      var boundedEstimatedValues = estimatedValues.LimitToRange(lowerEstimationLimit, upperEstimationLimit);
-      var nmse = OnlineNormalizedMeanSquaredErrorCalculator.Calculate(targetValues, boundedEstimatedValues,
-        out var errorState);
-      if (errorState != OnlineCalculatorError.None) nmse = 1.0;
-
-      return nmse;
-    }
-
-    public override double Evaluate(
-      IExecutionContext context, ISymbolicExpressionTree tree, IRegressionProblemData problemData,
-      IEnumerable<int> rows) {
-      SymbolicDataAnalysisTreeInterpreterParameter.ExecutionContext = context;
-      EstimationLimitsParameter.ExecutionContext                    = context;
-      ApplyLinearScalingParameter.ExecutionContext                  = context;
-
-      var nmse = Calculate(SymbolicDataAnalysisTreeInterpreterParameter.ActualValue, tree,
-        EstimationLimitsParameter.ActualValue.Lower, EstimationLimitsParameter.ActualValue.Upper,
-        problemData, rows, false);
-
-      SymbolicDataAnalysisTreeInterpreterParameter.ExecutionContext = null;
-      EstimationLimitsParameter.ExecutionContext                    = null;
-      ApplyLinearScalingParameter.ExecutionContext                  = null;
-
-      return nmse;
-    }
-  }
-}
Index: /branches/3076_IA_evaluators_analyzers/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/SymbolicRegressionSingleObjectiveProblem.cs
===================================================================
--- /branches/3076_IA_evaluators_analyzers/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/SymbolicRegressionSingleObjectiveProblem.cs	(revision 17820)
+++ /branches/3076_IA_evaluators_analyzers/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/SymbolicRegressionSingleObjectiveProblem.cs	(revision 17821)
@@ -96,4 +96,9 @@
         changed = true;
       }
+
+      if (!Operators.OfType<SymbolicRegressionSplittingAnalyzer>().Any()) {
+        Operators.Add(new SymbolicRegressionSplittingAnalyzer());
+        changed = true;
+      }
       if (changed) {
         ParameterizeOperators();
@@ -119,4 +124,5 @@
       Operators.Add(new SymbolicExpressionTreePhenotypicSimilarityCalculator());
       Operators.Add(new SymbolicRegressionConstraintAnalyzer());
+      Operators.Add(new SymbolicRegressionSplittingAnalyzer());
       Operators.Add(new SymbolicRegressionPhenotypicDiversityAnalyzer(Operators.OfType<SymbolicExpressionTreePhenotypicSimilarityCalculator>()) { DiversityResultName = "Phenotypic Diversity" });
       ParameterizeOperators();
Index: /branches/3076_IA_evaluators_analyzers/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SymbolicRegressionConstraintAnalyzer.cs
===================================================================
--- /branches/3076_IA_evaluators_analyzers/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SymbolicRegressionConstraintAnalyzer.cs	(revision 17820)
+++ /branches/3076_IA_evaluators_analyzers/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SymbolicRegressionConstraintAnalyzer.cs	(revision 17821)
@@ -17,12 +17,6 @@
   [StorableType("4318C6BD-E0A1-45FE-AC30-96E7F73B51FB")]
   public class SymbolicRegressionConstraintAnalyzer : SymbolicDataAnalysisAnalyzer, ISymbolicExpressionTreeAnalyzer {
-    private const string ConstraintViolationsResultName = "Constraint Violations";
     private const string ProblemDataParameterName = "ProblemData";
     private const string ConstraintViolationParameterName = "ConstraintViolations";
-    private const string PenalityMultiplierParameterName = "ConstraintsPenalityMultiplier";
-    private const string PenalityMultiplierResultParameterName = "PenalityMultiplierResultParameter";
-    private const string StepSizeParameterName = "Step Size";
-    private const string MaximumStepsParameterName = "Maximum Steps";
-    private const string StartPenalityParameterName = "Start Penality";
     private const string ConstraintUnsatisfiedSolutionsParameterName = "Constraint Unsatisfied Solutions";
 
@@ -34,19 +28,4 @@
     public IResultParameter<DataTable> ConstraintViolationParameter =>
       (IResultParameter<DataTable>) Parameters[ConstraintViolationParameterName];
-
-    public ILookupParameter<DoubleValue> PenalityMultiplierParameter =>
-      (ILookupParameter<DoubleValue>) Parameters[PenalityMultiplierParameterName];
-
-    public IValueParameter<IntValue> StepSizeParameter =>
-      (IValueParameter<IntValue>) Parameters[StepSizeParameterName];
-
-    public IValueParameter<IntValue> MaximumStepsParameter =>
-      (IValueParameter<IntValue>) Parameters[MaximumStepsParameterName];
-
-    public IResultParameter<DataTable> PenalityMultiplierResultParameter =>
-      (IResultParameter<DataTable>) Parameters[PenalityMultiplierResultParameterName];
-
-    public IValueParameter<DoubleValue> StartPenalityParameter =>
-      (IValueParameter<DoubleValue>) Parameters[StartPenalityParameterName];
 
     public IResultParameter<DataTable> ConstraintUnsatisfiedSolutionsParameter =>
@@ -75,14 +54,4 @@
       Parameters.Add(new ResultParameter<DataTable>(ConstraintViolationParameterName,
         "Shows the number of constraint violations!"));
-      Parameters.Add(new LookupParameter<DoubleValue>(PenalityMultiplierParameterName,
-        "Lookup parameter for the penality multiplier.", "PenalityMultiplier"));
-      Parameters.Add(new ResultParameter<DataTable>(PenalityMultiplierResultParameterName,
-        "Shows the behavior of the penality multiplier."));
-      Parameters.Add(new ValueParameter<IntValue>(StepSizeParameterName,
-        "Defines the step size for the increasing penality multiplier.", new IntValue(1)));
-      Parameters.Add(new ValueParameter<IntValue>(MaximumStepsParameterName,
-        "Defines maximum steps for the increasing penality multiplier.", new IntValue(1000)));
-      Parameters.Add(new ValueParameter<DoubleValue>(StartPenalityParameterName,
-        "The start value for the penality multiplier.", new DoubleValue(0.5)));
       Parameters.Add(new ResultParameter<DataTable>(ConstraintUnsatisfiedSolutionsParameterName,
         "Shows the number of solutions with unsatisfied constraints."));
@@ -93,11 +62,4 @@
           XAxisTitle = "Generations",
           YAxisTitle = "Constraint Violations"
-        }
-      };
-
-      PenalityMultiplierResultParameter.DefaultValue = new DataTable(PenalityMultiplierResultParameterName) {
-        VisualProperties = {
-          XAxisTitle = "Generations",
-          YAxisTitle = "Penality Multiplier"
         }
       };
@@ -124,59 +86,18 @@
     [StorableHook(HookType.AfterDeserialization)]
     private void AfterDeserialization() {
-      if (!Parameters.ContainsKey(PenalityMultiplierParameterName))
-        Parameters.Add(new LookupParameter<DoubleValue>(PenalityMultiplierParameterName,
-          "Lookup parameter for the penality multiplier.", "PenalityMultiplier"));
+      if (Parameters.ContainsKey(ConstraintUnsatisfiedSolutionsParameterName)) return;
+      Parameters.Add(new ResultParameter<DataTable>(ConstraintUnsatisfiedSolutionsParameterName,
+        "Shows the number of solutions with unsatisfied constraints."));
 
-      if (!Parameters.ContainsKey(PenalityMultiplierResultParameterName)) {
-        Parameters.Add(new ResultParameter<DataTable>(PenalityMultiplierResultParameterName,
-          "Shows the behavior of the penality multiplier."));
-
-        PenalityMultiplierResultParameter.DefaultValue = new DataTable(PenalityMultiplierResultParameterName) {
-          VisualProperties = {
-            XAxisTitle = "Generations",
-            YAxisTitle = "Penality Multiplier"
-          }
-        };
-      }
-
-      if (!Parameters.ContainsKey(StepSizeParameterName))
-        Parameters.Add(new ValueParameter<IntValue>(StepSizeParameterName,
-          "Defines the step size for the increasing penality multiplier.", new IntValue(1)));
-
-      if (!Parameters.ContainsKey(MaximumStepsParameterName))
-        Parameters.Add(new ValueParameter<IntValue>(MaximumStepsParameterName,
-          "Defines maximum steps for the increasing penality multiplier.", new IntValue(1000)));
-
-
-      if (!Parameters.ContainsKey(StartPenalityParameterName))
-        Parameters.Add(new ValueParameter<DoubleValue>(StartPenalityParameterName,
-          "The start value for the penality multiplier.", new DoubleValue(0.5)));
-
-
-      if(!Parameters.ContainsKey(ConstraintUnsatisfiedSolutionsParameterName)) {
-        Parameters.Add(new ResultParameter<DataTable>(ConstraintUnsatisfiedSolutionsParameterName,
-          "Shows the number of solutions with unsatisfied constraints."));
-
-        ConstraintUnsatisfiedSolutionsParameter.DefaultValue = new DataTable(ConstraintUnsatisfiedSolutionsParameterName) {
-            VisualProperties = {
-            XAxisTitle = "Generations",
-            YAxisTitle = "Constraint Unsatisfied Solutions"
-          }
-        };
-      }
+      ConstraintUnsatisfiedSolutionsParameter.DefaultValue = new DataTable(ConstraintUnsatisfiedSolutionsParameterName) {
+        VisualProperties = {
+          XAxisTitle = "Generations",
+          YAxisTitle = "Constraint Unsatisfied Solutions"
+        }
+      };
     }
 
     public override IOperation Apply() {
       Iterations++;
-      var rowName = "GeneralizedExponentialDiscreteDoubleValueModifier";
-      var stepSize = StepSizeParameter?.Value?.Value ?? 1;
-      var startValue = StartPenalityParameter?.Value?.Value ?? 0.5;
-      var maximumSteps = MaximumStepsParameter?.Value?.Value ?? 1000;
-      var penalityMultiplier = new DoubleValue(LinearDiscreteDoubleValueModifier.Apply(0, startValue, 1.0,
-        (int) (Iterations / stepSize) * stepSize, 0, maximumSteps));
-      PenalityMultiplierParameter.ActualValue = penalityMultiplier;
-      //GeneralizedExponentialDiscreteDoubleValueModifier
-      //QuadraticDiscreteDoubleValueModifier
-      //LinearDiscreteDoubleValueModifier
 
       var problemData = RegressionProblemDataParameter.ActualValue;
@@ -194,16 +115,9 @@
           newDataTable.Rows.Add(new DataRow(constraint.Expression));
 
-      var interpreter = new IntervalInterpreter();
       foreach (var constraint in constraints) {
-        var violations = trees.Select(tree =>
-                                 ConstraintSatisfied(constraint, interpreter, variableRanges, tree, out double error))
-                              .Count(satisfied => !satisfied);
+        var violations = trees.Count(tree => IntervalUtil.IntervalConstraintViolation(constraint, BoundsEstimator, intervalCollection, tree) > 0.0);
+
         newDataTable.Rows[constraint.Expression].Values.Add(violations);
       }
-
-      var penalityDataTable = PenalityMultiplierResultParameter.ActualValue;
-      if (penalityDataTable.Rows.Count == 0)
-        penalityDataTable.Rows.Add(new DataRow(rowName));
-      penalityDataTable.Rows[rowName].Values.Add(penalityMultiplier.Value);
 
       var constraintUnsatisfiedSolutionsDataTable = ConstraintUnsatisfiedSolutionsParameter.ActualValue;
@@ -213,93 +127,10 @@
       constraintUnsatisfiedSolutionsDataTable.Rows[ConstraintUnsatisfiedSolutionsParameterName]
         .Values
-        .Add(
-          solutions
-          .Where(s => IntervalUtil.IntervalConstraintsViolation(constraints, BoundsEstimator, intervalCollection, s).Any(x => x != 0.0))
-          .Count());
+        .Add(solutions.Count(s => IntervalUtil.IntervalConstraintsViolation(constraints, BoundsEstimator, intervalCollection, s).Any(x => x != 0.0)));
 
       return base.Apply();
     }
 
-    public static bool ConstraintSatisfied(IntervalConstraint constraint,
-                                           IntervalInterpreter intervalInterpreter,
-                                           IReadOnlyDictionary<string, Interval> variableRanges,
-                                           ISymbolicExpressionTree solution,
-                                           out double error) {
-      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;
-
-      //Create new variable ranges for defined regions
-      var regionRanges = new IntervalCollection();
-      foreach (var kvp in variableRanges) {
-        if (kvp.Key != constraint.Target &&
-            constraint.Regions.GetReadonlyDictionary().TryGetValue(kvp.Key, out Interval val)) {
-          regionRanges.AddInterval(kvp.Key, val);
-        } else {
-          regionRanges.AddInterval(kvp.Key, kvp.Value);
-        }
-      }
-
-      // calculate result interval
-      if (!constraint.IsDerivative) {
-        resultInterval =
-          intervalInterpreter.GetSymbolicExpressionTreeInterval(solution,
-            regionRanges.GetReadonlyDictionary());
-      } else {
-        var tree = solution;
-        for (var i = 0; i < constraint.NumberOfDerivations; ++i) {
-          if (!IntervalInterpreter.IsCompatible(tree) || !DerivativeCalculator.IsCompatible(tree))
-            throw new ArgumentException("Cube, Root, Power Symbols are not supported.");
-          tree = DerivativeCalculator.Derive(tree, constraint.Variable);
-        }
-
-        resultInterval =
-          intervalInterpreter.GetSymbolicExpressionTreeInterval(tree,
-            regionRanges.GetReadonlyDictionary());
-      }
-
-      error = 0.0;
-      bool satisfied = true;
-      if (!constraint.Interval.Contains(resultInterval.LowerBound)) {
-        satisfied = false;
-        error += Math.Abs(resultInterval.LowerBound - constraint.Interval.LowerBound);
-      }
-
-      if (!constraint.Interval.Contains(resultInterval.UpperBound)) {
-        satisfied = false;
-        error += Math.Abs(resultInterval.UpperBound - constraint.Interval.UpperBound);
-      }
-
-      error *= constraint.Weight;
-
-      //var satisfied = constraint.Interval.Contains(resultInterval);
-      return satisfied;
-    }
-
-    public static bool ConstraintsSatisfied(IEnumerable<IntervalConstraint> constraints,
-                                            IReadOnlyDictionary<string, Interval> variableRanges,
-                                            ISymbolicExpressionTree solution,
-                                            out double error) {
-      var intervalInterpreter = new IntervalInterpreter();
-      error = 0.0;
-      var satisfied = true;
-      foreach (var constraint in constraints) {
-        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));
-
-        satisfied = ConstraintSatisfied(constraint, intervalInterpreter, variableRanges, solution, out double e) &&
-                    satisfied;
-        error += e;
-        //if (!satisfied) return false;
-      }
-
-      return satisfied;
-    }
+    
   }
 }
Index: anches/3076_IA_evaluators_analyzers/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SymbolicRegressionMetaModelAnalyzer.cs
===================================================================
--- /branches/3076_IA_evaluators_analyzers/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SymbolicRegressionMetaModelAnalyzer.cs	(revision 17820)
+++ 	(revision )
@@ -1,113 +1,0 @@
-﻿using HEAL.Attic;
-using HeuristicLab.Analysis;
-using HeuristicLab.Common;
-using HeuristicLab.Core;
-using HeuristicLab.Data;
-using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
-using HeuristicLab.Optimization;
-using HeuristicLab.Parameters;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Regression {
-  [StorableType("E5B7E058-E63F-4059-A87F-EA9247592254")]
-  public abstract class SymbolicRegressionMetaModelAnalyzer<T> 
-    : SymbolicDataAnalysisAnalyzer, ISymbolicExpressionTreeAnalyzer where T: class, IRegressionProblem {
-
-    #region constants
-    private const string ProblemsToAnalyzeParameterName = "Problems to Analyze";
-    private const string BaseProblemParameterName = "Base Problem";
-    private const string AnalyzeXIterationParameterName = "Analyze X Iteration";
-    #endregion
-
-    #region parameter properties
-    //IRegressionProblem
-    public IFixedValueParameter<ItemList<T>> ProblemsToAnalyzeParameter =>
-      (IFixedValueParameter<ItemList<T>>)Parameters[ProblemsToAnalyzeParameterName];
-
-    public IValueParameter<T> BaseProblemParameter =>
-      (IValueParameter<T>)Parameters[BaseProblemParameterName];
-
-    public IFixedValueParameter<IntValue> AnalyzeXIterationParameter =>
-      (IFixedValueParameter<IntValue>)Parameters[AnalyzeXIterationParameterName];
-    #endregion
-
-    public static int Iterations { get; set; } = 1;
-
-    #region constructors and cloning
-    protected SymbolicRegressionMetaModelAnalyzer(SymbolicRegressionMetaModelAnalyzer<T> original, Cloner cloner) :
-      base(original, cloner) { }
-
-    [StorableConstructor]
-    protected SymbolicRegressionMetaModelAnalyzer(StorableConstructorFlag _) : base(_) { }
-
-    public SymbolicRegressionMetaModelAnalyzer() {
-      Parameters.Add(new FixedValueParameter<ItemList<T>>(ProblemsToAnalyzeParameterName,
-        "List of datasets, which are used to find a meta model.", new ItemList<T>()));
-      Parameters.Add(new ValueParameter<T>(BaseProblemParameterName,
-        "The problem which uses the algorithm (just drag&drop it)."));
-      Parameters.Add(new FixedValueParameter<IntValue>(AnalyzeXIterationParameterName,
-        "After every X iteration, the analyzer will perform its step.", new IntValue(1)));
-    }
-
-    [StorableHook(HookType.AfterDeserialization)]
-    private void AfterDeserialization() {
-      if (!Parameters.ContainsKey(ProblemsToAnalyzeParameterName))
-        Parameters.Add(new FixedValueParameter<ItemList<T>>(ProblemsToAnalyzeParameterName,
-          "List of datasets, which are used to find a meta model.", new ItemList<T>()));
-
-      if (!Parameters.ContainsKey(BaseProblemParameterName))
-        Parameters.Add(new ValueParameter<T>(BaseProblemParameterName,
-          "The problem which uses the algorithm (just drag&drop it)."));
-
-      if (!Parameters.ContainsKey(AnalyzeXIterationParameterName))
-        Parameters.Add(new FixedValueParameter<IntValue>(AnalyzeXIterationParameterName,
-          "After every X iteration, the analyzer will perform its step.", new IntValue(1)));
-    }
-
-    #endregion
-
-    public override void InitializeState() {
-      Iterations = 1;
-      base.InitializeState();
-    }
-
-    public override void ClearState() {
-      Iterations = 1;
-      base.ClearState();
-    }
-
-    //protected abstract bool TryFittingSolution(ISymbolicExpressionTree tree, T problem, out SymbolicRegressionSolution solution);
-    protected abstract void PerformApply(T baseProblem, IEnumerable<T> problems, string targetVariable);
-
-    public override IOperation Apply() {
-      if (BaseProblemParameter.Value == null)
-        throw new ArgumentNullException("BaseProblemParameter",
-          "Base Problem Parameter is null! Please drag&drop the used problem into the parameter slot.");
-
-      if (Iterations >= AnalyzeXIterationParameter.Value.Value) {
-        Iterations = 1;
-        var baseProblem = BaseProblemParameter.Value;
-        var problems = ProblemsToAnalyzeParameter.Value;
-        var targetVariable = BaseProblemParameter.Value.ProblemData.TargetVariable;
-
-        // error handling
-        var badProblems = problems.Where(x => x.ProblemData.TargetVariable != targetVariable);
-        IList<Exception> errors = new List<Exception>();
-        foreach (var problem in badProblems)
-          errors.Add(new ArgumentException($"The target variable of the problem '{problem.Name}' does not match with the base problem."));
-        if (badProblems.Any())
-          throw new AggregateException(errors);
-
-        // apply
-        PerformApply(baseProblem, problems, targetVariable);
-      } else {
-        Iterations++;
-      }
-      return base.Apply();
-    }
-  }
-}
Index: anches/3076_IA_evaluators_analyzers/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SymbolicRegressionMultiObjectiveMetaModelAnalyzer.cs
===================================================================
--- /branches/3076_IA_evaluators_analyzers/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SymbolicRegressionMultiObjectiveMetaModelAnalyzer.cs	(revision 17820)
+++ 	(revision )
@@ -1,62 +1,0 @@
-﻿using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
-using HEAL.Attic;
-using HeuristicLab.Common;
-using HeuristicLab.Optimization;
-
-namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Regression {
-  [StorableType("30B1B5C6-09D9-44C5-BC56-A57F3186E0D2")]
-  public class SymbolicRegressionMultiObjectiveMetaModelAnalyzer
-      : SymbolicRegressionMetaModelAnalyzer<SymbolicRegressionMultiObjectiveProblem>, ISymbolicExpressionTreeAnalyzer {
-
-    [StorableConstructor]
-    protected SymbolicRegressionMultiObjectiveMetaModelAnalyzer
-    (StorableConstructorFlag _) : base(_) {
-    }
-
-    protected SymbolicRegressionMultiObjectiveMetaModelAnalyzer(SymbolicRegressionMultiObjectiveMetaModelAnalyzer original, Cloner cloner) 
-      : base(original, cloner) { }
-
-    public SymbolicRegressionMultiObjectiveMetaModelAnalyzer() {
-
-    }
-
-    public override IDeepCloneable Clone(Cloner cloner) => 
-      new SymbolicRegressionMultiObjectiveMetaModelAnalyzer(this, cloner);
-
-    protected override void PerformApply(
-      SymbolicRegressionMultiObjectiveProblem baseProblem,
-      IEnumerable<SymbolicRegressionMultiObjectiveProblem> problems,
-      string targetVariable) {
-      
-      //double bestQuality = problem.Maximization.Value ? double.MinValue : double.MaxValue;
-      //var trees = SymbolicExpressionTree.ToArray();
-      //IDataset dataset = problem.ProblemData.Dataset;
-      //IEnumerable<int> rows = Enumerable.Range(0, dataset.Rows);
-      //var paretoFront = DominationCalculator<ISymbolicExpressionTree>.CalculateBestParetoFront(trees,
-      //  trees.Select(x => problem.Evaluator.Evaluate(ExecutionContext, x, problem.ProblemData, rows)).ToArray(), 
-      //  problem.Maximization.ToArray());
-
-      //SymbolicRegressionSolution bestMetaModel = null;
-      //foreach (var tree in this.SymbolicExpressionTree.ToArray()) { // iterate pareto front
-        
-      //  var quality = problem.Evaluator.Evaluate(ExecutionContext, tree, problem.ProblemData, rows);
-      //  /*
-      //  bool isBetter = problem.Maximization.Value ? (bestQuality < quality) : (bestQuality > quality);
-      //  if (isBetter) {
-      //    bestQuality = quality;
-      //    var model = new SymbolicRegressionModel(
-      //      targetVariable,
-      //      (ISymbolicExpressionTree)tree.Clone(),
-      //      new SymbolicDataAnalysisExpressionTreeInterpreter());
-      //    bestMetaModel = new SymbolicRegressionSolution(model, problem.ProblemData);
-      //  }*/
-      //}
-      //BestMetaModelParameter.ActualValue = bestMetaModel;
-    }
-  }
-}
Index: anches/3076_IA_evaluators_analyzers/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SymbolicRegressionSingleObjectiveMetaModelAnalyzer.cs
===================================================================
--- /branches/3076_IA_evaluators_analyzers/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SymbolicRegressionSingleObjectiveMetaModelAnalyzer.cs	(revision 17820)
+++ 	(revision )
@@ -1,138 +1,0 @@
-﻿using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-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 {
-  [StorableType("4B69A82A-265B-46DA-9055-B6E0EB6C3EC8")]
-  public class SymbolicRegressionSingleObjectiveMetaModelAnalyzer 
-    : SymbolicRegressionMetaModelAnalyzer<SymbolicRegressionSingleObjectiveProblem>, ISymbolicExpressionTreeAnalyzer {
-
-    #region constants
-    private const string BestMetaModelParameterName = "Best Meta Model";
-    #endregion
-
-    #region parameter properties
-    public IResultParameter<ItemList<ISymbolicRegressionSolution>> BestMetaModelParameter =>
-      (IResultParameter<ItemList<ISymbolicRegressionSolution>>)Parameters[BestMetaModelParameterName];
-    #endregion
-
-    #region constructors and cloning
-    [StorableConstructor]
-    protected SymbolicRegressionSingleObjectiveMetaModelAnalyzer(StorableConstructorFlag _) : base(_) { }
-
-    protected SymbolicRegressionSingleObjectiveMetaModelAnalyzer(SymbolicRegressionSingleObjectiveMetaModelAnalyzer original, Cloner cloner) : base(original, cloner) { }
-
-    public SymbolicRegressionSingleObjectiveMetaModelAnalyzer() {
-      Parameters.Add(new ResultParameter<ItemList<ISymbolicRegressionSolution>>(BestMetaModelParameterName,
-        "A list with the meta model for all problems."));
-    }
-
-    [StorableHook(HookType.AfterDeserialization)]
-    private void AfterDeserialization() {
-      Parameters.Remove(BestMetaModelParameterName);
-
-      if (!Parameters.ContainsKey(BestMetaModelParameterName))
-        Parameters.Add(new ResultParameter<ItemList<ISymbolicRegressionSolution>>(BestMetaModelParameterName,
-          "A list with all meta models for the problems."));
-    }
-
-    public override IDeepCloneable Clone(Cloner cloner) => new SymbolicRegressionSingleObjectiveMetaModelAnalyzer(this, cloner);
-    #endregion
-
-    protected override void PerformApply(
-      SymbolicRegressionSingleObjectiveProblem baseProblem, 
-      IEnumerable<SymbolicRegressionSingleObjectiveProblem> problems, 
-      string targetVariable) {
-      // init
-      var solutions = this.SymbolicExpressionTree.ToArray();
-      var bestQualityWithConstantOpt = baseProblem.Maximization.Value ? double.MinValue : double.MaxValue;
-      var bestQualityWithoutConstantOpt = baseProblem.Maximization.Value ? double.MinValue : double.MaxValue;
-      var evaluator = baseProblem.Evaluator;
-      var interpreter = baseProblem.SymbolicExpressionTreeInterpreter;
-      ISymbolicExpressionTree bestSolutionWithConstantOpt = null;
-      ISymbolicExpressionTree bestSolutionWithoutConstantOpt = null;
-      var metaModels = new ItemList<ISymbolicRegressionSolution>();
-      // iterate solutions
-      foreach (var solution in solutions) {
-        // calculate with constant optimization
-        var tmpSolution = (ISymbolicExpressionTree) solution.Clone();
-        double qualityAvg = CalculateAverageQuality(tmpSolution, evaluator, problems, interpreter, true);
-        // check if this solution is the best
-        bool isBest = baseProblem.Maximization.Value ? (bestQualityWithConstantOpt < qualityAvg) : (bestQualityWithConstantOpt > qualityAvg);
-        if (isBest) {
-          bestQualityWithConstantOpt = qualityAvg;
-          bestSolutionWithConstantOpt = tmpSolution;
-        }
-
-        // calculate it again without constant optimization to have a comparison
-        tmpSolution = (ISymbolicExpressionTree) solution.Clone();
-        qualityAvg = CalculateAverageQuality(tmpSolution, evaluator, problems, interpreter, false);
-        // check if this solution is the best
-        isBest = baseProblem.Maximization.Value ? (bestQualityWithoutConstantOpt < qualityAvg) : (bestQualityWithoutConstantOpt > qualityAvg);
-        if (isBest) {
-          bestQualityWithoutConstantOpt = qualityAvg;
-          bestSolutionWithoutConstantOpt = tmpSolution;
-        }
-      }
-
-      foreach(var problem in problems) {
-        metaModels.Add(BuildSolution(bestSolutionWithConstantOpt, targetVariable, problem, "withConstantOpt"));
-        metaModels.Add(BuildSolution(bestSolutionWithoutConstantOpt, targetVariable, problem, "withoutConstantOpt"));
-      }
-        
-      BestMetaModelParameter.ActualValue = metaModels;
-    }
-
-    private SymbolicRegressionSolution BuildSolution(
-      ISymbolicExpressionTree solution, 
-      string targetVariable,
-      SymbolicRegressionSingleObjectiveProblem problem,
-      string suffix) {
-      var model = new SymbolicRegressionModel(
-            targetVariable,
-            (ISymbolicExpressionTree)solution.Clone(),
-            new SymbolicDataAnalysisExpressionTreeInterpreter());
-      return new SymbolicRegressionSolution(model, problem.ProblemData) { Name = $"{problem.Name}_solution_{suffix}" };
-    }
-
-    private double CalculateAverageQuality(
-      ISymbolicExpressionTree solution,
-      ISymbolicDataAnalysisSingleObjectiveEvaluator<IRegressionProblemData> evaluator,
-      IEnumerable<SymbolicRegressionSingleObjectiveProblem> problems,
-      ISymbolicDataAnalysisExpressionTreeInterpreter interpreter,
-      bool useConstantOptimization) {
-      double qualitySum = 0.0;
-      // iterate problems
-      foreach (var problem in problems) {
-        var problemData = problem.ProblemData;
-
-        if (useConstantOptimization) {
-          SymbolicRegressionConstantOptimizationEvaluator.OptimizeConstants(
-            interpreter, 
-            solution, 
-            problemData, 
-            problemData.TrainingIndices,
-            false, 10, true);
-        }
-
-        qualitySum += evaluator.Evaluate(
-          ExecutionContext,
-          solution,
-          problemData,
-          problemData.TrainingIndices);
-      }
-        
-      // calculate the average quality
-      return qualitySum / problems.Count();
-    }
-  }
-}
Index: /branches/3076_IA_evaluators_analyzers/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SymbolicRegressionSplittingAnalyzer.cs
===================================================================
--- /branches/3076_IA_evaluators_analyzers/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SymbolicRegressionSplittingAnalyzer.cs	(revision 17821)
+++ /branches/3076_IA_evaluators_analyzers/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SymbolicRegressionSplittingAnalyzer.cs	(revision 17821)
@@ -0,0 +1,197 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.CompilerServices;
+using System.Text;
+using System.Threading.Tasks;
+using HEAL.Attic;
+using HeuristicLab.Analysis;
+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 {
+    [StorableType("7CAE2D30-EDEC-44B6-B772-A2E63E64288F")]
+    public class SymbolicRegressionSplittingAnalyzer : SymbolicDataAnalysisAnalyzer, ISymbolicExpressionTreeAnalyzer {
+      private const string ProblemDataParameterName = "ProblemData";
+      private const string BetterWithSplittingParameterName = "Tighter bounds after splitting";
+      private const string NoSplitAcceptedParameterName = "Accepted without splitting";
+      private const string NoSplitDiscardedParameterName = "Dicarded without splitting";
+      private const string SplitAcceptedParameterName = "Accepted with splitting";
+      private const string SplitDiscardedParameterName = "Discarded with splitting";
+
+
+      #region parameter properties
+
+      public ILookupParameter<IRegressionProblemData> RegressionProblemDataParameter =>
+        (ILookupParameter<IRegressionProblemData>)Parameters[ProblemDataParameterName];
+
+      public IResultParameter<IntValue> BetterWithSplittingParameter =>
+        (IResultParameter<IntValue>) Parameters[BetterWithSplittingParameterName];
+
+      public IResultParameter<IntValue> NoSplitAcceptedParameter =>
+        (IResultParameter<IntValue>) Parameters[NoSplitAcceptedParameterName];
+
+      public IResultParameter<IntValue> NoSplitDiscardedParameter =>
+        (IResultParameter<IntValue>)Parameters[NoSplitDiscardedParameterName];
+
+      public IResultParameter<IntValue> SplitAcceptedParameter =>
+        (IResultParameter<IntValue>)Parameters[SplitAcceptedParameterName];
+
+        public IResultParameter<IntValue> SplitDiscardedParameter =>
+          (IResultParameter<IntValue>)Parameters[SplitDiscardedParameterName];
+
+
+
+      #endregion
+      public override bool EnabledByDefault => false;
+      public static int Iterations { get; set; } = 0;
+
+      public static int BetterWithSplitting { get; set; } = 0;
+
+      public static int AccpetedWithoutSplitting { get; set; } = 0;
+      public static int DiscardedWithoutSplitting { get; set; } = 0;
+      public static int AccptedWithSplitting { get; set; } = 0;
+      public static int DiscardedWithSplitting { get; set; } = 0;
+
+      [StorableConstructor]
+      protected SymbolicRegressionSplittingAnalyzer(StorableConstructorFlag _) : base(_) { }
+
+      private SymbolicRegressionSplittingAnalyzer(SymbolicRegressionSplittingAnalyzer original, Cloner cloner) : base(original, cloner) { }
+
+      public SymbolicRegressionSplittingAnalyzer() {
+        Parameters.Add(new LookupParameter<IRegressionProblemData>(ProblemDataParameterName,
+          "The problem data of the symbolic data analysis problem."));
+
+        if (!Parameters.ContainsKey(BetterWithSplittingParameterName)) {
+          Parameters.Add(new ResultParameter<IntValue>(BetterWithSplittingParameterName, "Shows the number constraints which gets accepted after splitting"));
+        }
+        BetterWithSplittingParameter.DefaultValue = new IntValue(BetterWithSplitting);
+
+        if (!Parameters.ContainsKey(NoSplitAcceptedParameterName)) {
+          Parameters.Add(new ResultParameter<IntValue>(NoSplitAcceptedParameterName, "Shows the number constraints which gets accepted after splitting"));
+        }
+        NoSplitAcceptedParameter.DefaultValue = new IntValue(BetterWithSplitting);
+
+        if (!Parameters.ContainsKey(NoSplitDiscardedParameterName)) {
+          Parameters.Add(new ResultParameter<IntValue>(NoSplitDiscardedParameterName, "Shows the number constraints which gets accepted after splitting"));
+        }
+        BetterWithSplittingParameter.DefaultValue = new IntValue(BetterWithSplitting);
+
+        if (!Parameters.ContainsKey(SplitAcceptedParameterName)) {
+          Parameters.Add(new ResultParameter<IntValue>(SplitAcceptedParameterName, "Shows the number constraints which gets accepted after splitting"));
+        }
+        BetterWithSplittingParameter.DefaultValue = new IntValue(BetterWithSplitting);
+
+        if (!Parameters.ContainsKey(SplitDiscardedParameterName)) {
+          Parameters.Add(new ResultParameter<IntValue>(SplitDiscardedParameterName, "Shows the number constraints which gets accepted after splitting"));
+        }
+        BetterWithSplittingParameter.DefaultValue = new IntValue(BetterWithSplitting);
+        }
+
+
+
+      [StorableHook(HookType.AfterDeserialization)]
+      private void AfterDeserialization() {
+        if (!Parameters.ContainsKey(BetterWithSplittingParameterName)) {
+          Parameters.Add(new ResultParameter<IntValue>(BetterWithSplittingParameterName, "Shows the number constraints which gets accepted after splitting"));
+        }
+
+        BetterWithSplittingParameter.DefaultValue = new IntValue(BetterWithSplitting);
+
+        if (!Parameters.ContainsKey(NoSplitAcceptedParameterName))
+        {
+          Parameters.Add(new ResultParameter<IntValue>(NoSplitAcceptedParameterName, "Shows the number constraints which gets accepted after splitting"));
+        }
+        NoSplitAcceptedParameter.DefaultValue = new IntValue(AccpetedWithoutSplitting);
+
+        if (!Parameters.ContainsKey(NoSplitDiscardedParameterName))
+        {
+          Parameters.Add(new ResultParameter<IntValue>(NoSplitDiscardedParameterName, "Shows the number constraints which gets accepted after splitting"));
+        }
+        NoSplitDiscardedParameter.DefaultValue = new IntValue(DiscardedWithoutSplitting);
+
+        if (!Parameters.ContainsKey(SplitAcceptedParameterName))
+        {
+          Parameters.Add(new ResultParameter<IntValue>(SplitAcceptedParameterName, "Shows the number constraints which gets accepted after splitting"));
+        }
+        SplitAcceptedParameter.DefaultValue = new IntValue(AccptedWithSplitting);
+
+        if (!Parameters.ContainsKey(SplitDiscardedParameterName))
+        {
+          Parameters.Add(new ResultParameter<IntValue>(SplitDiscardedParameterName, "Shows the number constraints which gets accepted after splitting"));
+        }
+        SplitDiscardedParameter.DefaultValue = new IntValue(DiscardedWithSplitting);
+        }
+
+      public override IDeepCloneable Clone(Cloner cloner) {
+        return new SymbolicRegressionSplittingAnalyzer(this, cloner);
+      }
+
+      public override void InitializeState() {
+        Iterations = 0;
+        BetterWithSplitting = 0;
+        AccptedWithSplitting = 0;
+        AccpetedWithoutSplitting = 0;
+        DiscardedWithSplitting = 0;
+        DiscardedWithoutSplitting = 0;
+        base.InitializeState();
+      }
+
+      public override void ClearState() {
+        Iterations = 0;
+        BetterWithSplitting = 0;
+        AccptedWithSplitting = 0;
+        AccpetedWithoutSplitting = 0;
+        DiscardedWithSplitting = 0;
+        DiscardedWithoutSplitting = 0;
+        base.ClearState();
+      }
+
+      public override IOperation Apply() {
+        var problemData = RegressionProblemDataParameter.ActualValue;
+        var trees = SymbolicExpressionTreeParameter.ActualValue;
+        var constraints = problemData.IntervalConstraints.EnabledConstraints;
+        var intervalCollection = problemData.VariableRanges;
+        var estimator = new IABoundsEstimator();
+        var splittingEstimator = new IABoundsEstimator {UseIntervalSplitting = true, SplittingIterations = 12};
+
+        foreach (var solution in trees) {
+          var noSplitting = IntervalUtil.IntervalConstraintsViolation(constraints, estimator, intervalCollection, solution);
+          var splitting = IntervalUtil.IntervalConstraintsViolation(constraints, splittingEstimator, intervalCollection, solution);
+
+          if (noSplitting.Any(x => x != 0)) DiscardedWithoutSplitting++;
+          if (noSplitting.All(x => x == 0)) AccpetedWithoutSplitting++;
+
+          if (splitting.Any(x => x != 0))
+            DiscardedWithSplitting++;
+          else {
+            AccptedWithSplitting++;
+          }
+
+          for (var i = 0; i < noSplitting.Count(); ++i) {
+            if (splitting.ToArray()[i] < noSplitting.ToArray()[i]) {
+              BetterWithSplitting++;
+            }
+            /*if (splitting.ToArray()[i] < noSplitting.ToArray()[i]) {
+              BetterWithSplitting++;
+            } else if (splitting.ToArray()[i] > noSplitting.ToArray()[i] && !splitting.ToArray()[i].IsAlmost(noSplitting.ToArray()[i])) {
+              WorseWithSplitting++;
+              noSplitting = IntervalUtil.IntervalConstraintsViolation(constraints, estimator, intervalCollection, solution);
+              splitting = IntervalUtil.IntervalConstraintsViolation(constraints, splittingEstimator, intervalCollection, solution);
+            }*/
+          }
+        }
+
+        BetterWithSplittingParameter.ActualValue.Value = BetterWithSplitting;
+        NoSplitAcceptedParameter.ActualValue.Value = AccpetedWithoutSplitting;
+        NoSplitDiscardedParameter.ActualValue.Value = DiscardedWithoutSplitting;
+        SplitAcceptedParameter.ActualValue.Value = AccptedWithSplitting;
+        SplitDiscardedParameter.ActualValue.Value = DiscardedWithSplitting;
+        return base.Apply();
+      }
+    }
+}
