Index: unk/sources/HeuristicLab.GP.StructureIdentification.Classification/3.3/DefaultClassificationAlgorithmOperators.cs
===================================================================
--- /trunk/sources/HeuristicLab.GP.StructureIdentification.Classification/3.3/DefaultClassificationAlgorithmOperators.cs	(revision 2355)
+++ 	(revision )
@@ -1,77 +1,0 @@
-﻿#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.DataAnalysis;
-using HeuristicLab.GP.Interfaces;
-using HeuristicLab.Operators;
-using HeuristicLab.Modeling;
-using HeuristicLab.Data;
-
-namespace HeuristicLab.GP.StructureIdentification.Classification {
-  public static class DefaultClassificationAlgorithmOperators {
-    public static IOperator CreatePostProcessingOperator() {
-      SequentialProcessor seq = new SequentialProcessor();
-      seq.AddSubOperator(DefaultStructureIdentificationAlgorithmOperators.CreatePostProcessingOperator());
-
-      UniformSequentialSubScopesProcessor subScopesProc = new UniformSequentialSubScopesProcessor();
-      SequentialProcessor individualProc = new SequentialProcessor();
-      subScopesProc.AddSubOperator(individualProc);
-      seq.AddSubOperator(subScopesProc);
-      SimpleAccuracyEvaluator trainingAccuracy = new SimpleAccuracyEvaluator();
-      trainingAccuracy.Name = "TrainingAccuracyEvaluator";
-      trainingAccuracy.GetVariableInfo("Accuracy").ActualName = "TrainingAccuracy";
-      trainingAccuracy.GetVariableInfo("Values").ActualName = "TrainingValues";
-
-      SimpleAccuracyEvaluator validationAccuracy = new SimpleAccuracyEvaluator();
-      validationAccuracy.Name = "ValidationAccuracyEvaluator";
-      validationAccuracy.GetVariableInfo("Accuracy").ActualName = "ValidationAccuracy";
-      validationAccuracy.GetVariableInfo("Values").ActualName = "ValidationValues";
-
-      SimpleAccuracyEvaluator testAccuracy = new SimpleAccuracyEvaluator();
-      testAccuracy.Name = "TestAccuracyEvaluator";
-      testAccuracy.GetVariableInfo("Accuracy").ActualName = "TestAccuracy";
-      testAccuracy.GetVariableInfo("Values").ActualName = "TestValues";
-
-      individualProc.AddSubOperator(trainingAccuracy);
-      individualProc.AddSubOperator(validationAccuracy);
-      individualProc.AddSubOperator(testAccuracy);
-      return seq;
-    }
-
-    public static IOperator CreateProblemInjector() {
-      CombinedOperator op = new CombinedOperator();
-      op.Name = "ProblemInjector";
-      SequentialProcessor seq = new SequentialProcessor();
-      seq.AddSubOperator(new ProblemInjector());
-      seq.AddSubOperator(new TargetClassesCalculator());
-      op.OperatorGraph.AddOperator(seq);
-      op.OperatorGraph.InitialOperator = seq;
-      return op;
-    }
-
-    public static void SetModelData(IAnalyzerModel model, IScope scope) {
-      model.SetResult("TrainingAccuracy", scope.GetVariableValue<DoubleData>("TrainingAccuracy", true).Data);
-      model.SetResult("ValidationAccuracy", scope.GetVariableValue<DoubleData>("ValidationAccuracy", true).Data);
-      model.SetResult("TestAccuracy", scope.GetVariableValue<DoubleData>("TestAccuracy", true).Data);
-    }
-  }
-}
Index: /trunk/sources/HeuristicLab.GP.StructureIdentification.Classification/3.3/HeuristicLab.GP.StructureIdentification.Classification-3.3.csproj
===================================================================
--- /trunk/sources/HeuristicLab.GP.StructureIdentification.Classification/3.3/HeuristicLab.GP.StructureIdentification.Classification-3.3.csproj	(revision 2355)
+++ /trunk/sources/HeuristicLab.GP.StructureIdentification.Classification/3.3/HeuristicLab.GP.StructureIdentification.Classification-3.3.csproj	(revision 2356)
@@ -81,5 +81,4 @@
   <ItemGroup>
     <Compile Include="ClassificationMeanSquaredErrorEvaluator.cs" />
-    <Compile Include="DefaultClassificationAlgorithmOperators.cs" />
     <Compile Include="GPClassificationEvaluatorBase.cs" />
     <Compile Include="CrossValidation.cs" />
Index: /trunk/sources/HeuristicLab.GP.StructureIdentification.Classification/3.3/OffspringSelectionGP.cs
===================================================================
--- /trunk/sources/HeuristicLab.GP.StructureIdentification.Classification/3.3/OffspringSelectionGP.cs	(revision 2355)
+++ /trunk/sources/HeuristicLab.GP.StructureIdentification.Classification/3.3/OffspringSelectionGP.cs	(revision 2356)
@@ -23,19 +23,31 @@
 using HeuristicLab.Modeling;
 using HeuristicLab.Operators;
+using HeuristicLab.Data;
 
 namespace HeuristicLab.GP.StructureIdentification.Classification {
   public class OffspringSelectionGP : HeuristicLab.GP.StructureIdentification.OffspringSelectionGP, IClassificationAlgorithm {
 
-    protected override IOperator CreateProblemInjector() {
-      return DefaultClassificationAlgorithmOperators.CreateProblemInjector();
+    public override string Name {
+      get {
+        return base.Name + " - Classification";
+      }
     }
 
-    protected override IOperator CreatePostProcessingOperator() {
-      return DefaultClassificationAlgorithmOperators.CreatePostProcessingOperator();
+    protected override IOperator CreateProblemInjector() {
+      return DefaultClassificationOperators.CreateProblemInjector();
     }
 
-    protected override IAnalyzerModel CreateGPModel() {
-      IAnalyzerModel model = base.CreateGPModel();
-      DefaultClassificationAlgorithmOperators.SetModelData(model, Engine.GlobalScope.SubScopes[0]);
+    protected override IOperator CreateModelAnalyzerOperator() {
+      return DefaultClassificationOperators.CreatePostProcessingOperator();
+    }
+
+    protected virtual IAnalyzerModel CreateGPModel() {
+      IScope bestModelScope = Engine.GlobalScope.SubScopes[0];
+      var model = new AnalyzerModel();
+
+      model.SetMetaData("SelectionPressure", bestModelScope.GetVariableValue<DoubleData>("SelectionPressure", false).Data);
+      DefaultStructureIdentificationOperators.PopulateAnalyzerModel(bestModelScope, model);
+      DefaultClassificationOperators.PopulateAnalyzerModel(bestModelScope, model);
+
       return model;
     }
Index: /trunk/sources/HeuristicLab.GP.StructureIdentification.Classification/3.3/StandardGP.cs
===================================================================
--- /trunk/sources/HeuristicLab.GP.StructureIdentification.Classification/3.3/StandardGP.cs	(revision 2355)
+++ /trunk/sources/HeuristicLab.GP.StructureIdentification.Classification/3.3/StandardGP.cs	(revision 2356)
@@ -27,15 +27,23 @@
 namespace HeuristicLab.GP.StructureIdentification.Classification {
   public class StandardGP : HeuristicLab.GP.StructureIdentification.StandardGP, IClassificationAlgorithm {
+    public override string Name {
+      get {
+        return base.Name + " - Classification";
+      }
+    }
+
     protected override IOperator CreateProblemInjector() {
-      return DefaultClassificationAlgorithmOperators.CreateProblemInjector();
+      return DefaultClassificationOperators.CreateProblemInjector();
     }
-    
-    protected override IOperator CreatePostProcessingOperator() {
-      return DefaultClassificationAlgorithmOperators.CreatePostProcessingOperator();
+
+    protected override IOperator CreateModelAnalyzerOperator() {
+      return DefaultClassificationOperators.CreatePostProcessingOperator();
     }
 
     protected override IAnalyzerModel CreateGPModel() {
-      IAnalyzerModel model = base.CreateGPModel();
-      DefaultClassificationAlgorithmOperators.SetModelData(model, Engine.GlobalScope.SubScopes[0]);
+      var model = new AnalyzerModel();
+      var bestModelScope = Engine.GlobalScope.SubScopes[0];
+      DefaultStructureIdentificationOperators.PopulateAnalyzerModel(bestModelScope, model);
+      DefaultClassificationOperators.PopulateAnalyzerModel(bestModelScope, model);
       return model;
     }
Index: unk/sources/HeuristicLab.GP.StructureIdentification.TimeSeries/3.3/DefaultTimeSeriesOperators.cs
===================================================================
--- /trunk/sources/HeuristicLab.GP.StructureIdentification.TimeSeries/3.3/DefaultTimeSeriesOperators.cs	(revision 2355)
+++ 	(revision )
@@ -1,89 +1,0 @@
-﻿#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.DataAnalysis;
-using HeuristicLab.GP.Interfaces;
-using HeuristicLab.Operators;
-using HeuristicLab.Modeling;
-using HeuristicLab.Logging;
-using HeuristicLab.Data;
-
-namespace HeuristicLab.GP.StructureIdentification.TimeSeries {
-  internal static class DefaultTimeSeriesOperators {
-    internal static IOperator CreateFunctionLibraryInjector() {
-      CombinedOperator op = new CombinedOperator();
-      op.Name = "FunctionLibraryInjector";
-      SequentialProcessor seq = new SequentialProcessor();
-      FunctionLibraryInjector funLibInjector = new FunctionLibraryInjector();
-      funLibInjector.GetVariable("Differentials").Value = new BoolData(true);
-      seq.AddSubOperator(funLibInjector);
-      seq.AddSubOperator(new HL3TreeEvaluatorInjector());
-      op.OperatorGraph.AddOperator(seq);
-      op.OperatorGraph.InitialOperator = seq;
-      return op;
-    }
-
-    internal static IOperator CreateProblemInjector() {
-      CombinedOperator op = new CombinedOperator();
-      op.Name = "ProblemInjector";
-      SequentialProcessor seq = new SequentialProcessor();
-      seq.AddSubOperator(new ProblemInjector());
-      op.OperatorGraph.AddOperator(seq);
-      op.OperatorGraph.InitialOperator = seq;
-      return op;
-    }
-
-    internal static IOperator CreatePostProcessingOperator() {
-      SequentialProcessor seq = new SequentialProcessor();
-      seq.AddSubOperator(DefaultStructureIdentificationAlgorithmOperators.CreatePostProcessingOperator());
-
-      UniformSequentialSubScopesProcessor subScopesProc = new UniformSequentialSubScopesProcessor();
-      SequentialProcessor individualProc = new SequentialProcessor();
-      subScopesProc.AddSubOperator(individualProc);
-      seq.AddSubOperator(subScopesProc);
-
-      SimpleTheilInequalityCoefficientEvaluator trainingTheil = new SimpleTheilInequalityCoefficientEvaluator();
-      trainingTheil.Name = "TrainingTheilInequalityEvaluator";
-      trainingTheil.GetVariableInfo("Values").ActualName = "TrainingValues";
-      trainingTheil.GetVariableInfo("TheilInequalityCoefficient").ActualName = "TrainingTheilInequalityCoefficient";
-      SimpleTheilInequalityCoefficientEvaluator validationTheil = new SimpleTheilInequalityCoefficientEvaluator();
-      validationTheil.Name = "ValidationTheilInequalityEvaluator";
-      validationTheil.GetVariableInfo("Values").ActualName = "ValidationValues";
-      validationTheil.GetVariableInfo("TheilInequalityCoefficient").ActualName = "ValidationTheilInequalityCoefficient";
-      SimpleTheilInequalityCoefficientEvaluator testTheil = new SimpleTheilInequalityCoefficientEvaluator();
-      testTheil.Name = "TestTheilInequalityEvaluator";
-      testTheil.GetVariableInfo("Values").ActualName = "TestValues";
-      testTheil.GetVariableInfo("TheilInequalityCoefficient").ActualName = "TestTheilInequalityCoefficient";
-
-      individualProc.AddSubOperator(trainingTheil);
-      individualProc.AddSubOperator(validationTheil);
-      individualProc.AddSubOperator(testTheil);
-      return seq;
-    }
-
-    internal static void SetModelData(IAnalyzerModel model, IScope scope) {
-      model.SetResult("TrainingTheilInequalityCoefficient", scope.GetVariableValue<DoubleData>("TrainingTheilInequalityCoefficient", true).Data);
-      model.SetResult("ValidationTheilInequalityCoefficient", scope.GetVariableValue<DoubleData>("ValidationTheilInequalityCoefficient", true).Data);
-      model.SetResult("TestTheilInequalityCoefficient", scope.GetVariableValue<DoubleData>("TestTheilInequalityCoefficient", true).Data);
-    }
-  }
-}
Index: /trunk/sources/HeuristicLab.GP.StructureIdentification.TimeSeries/3.3/HeuristicLab.GP.StructureIdentification.TimeSeries-3.3.csproj
===================================================================
--- /trunk/sources/HeuristicLab.GP.StructureIdentification.TimeSeries/3.3/HeuristicLab.GP.StructureIdentification.TimeSeries-3.3.csproj	(revision 2355)
+++ /trunk/sources/HeuristicLab.GP.StructureIdentification.TimeSeries/3.3/HeuristicLab.GP.StructureIdentification.TimeSeries-3.3.csproj	(revision 2356)
@@ -83,5 +83,4 @@
   <ItemGroup>
     <Compile Include="AveragePercentageChangeEvaluator.cs" />
-    <Compile Include="DefaultTimeSeriesOperators.cs" />
     <Compile Include="HeuristicLabGPTimeSeriesPlugin.cs" />
     <Compile Include="OffspringSelectionGP.cs" />
Index: /trunk/sources/HeuristicLab.GP.StructureIdentification.TimeSeries/3.3/OffspringSelectionGP.cs
===================================================================
--- /trunk/sources/HeuristicLab.GP.StructureIdentification.TimeSeries/3.3/OffspringSelectionGP.cs	(revision 2355)
+++ /trunk/sources/HeuristicLab.GP.StructureIdentification.TimeSeries/3.3/OffspringSelectionGP.cs	(revision 2356)
@@ -29,4 +29,9 @@
 namespace HeuristicLab.GP.StructureIdentification.TimeSeries {
   public class OffspringSelectionGP : HeuristicLab.GP.StructureIdentification.OffspringSelectionGP, ITimeSeriesAlgorithm {
+    public override string Name {
+      get {
+        return base.Name + " - time series prognosis";
+      }
+    }
 
     public int MinTimeOffset {
@@ -50,9 +55,14 @@
 
     protected override IOperator CreateFunctionLibraryInjector() {
-      return DefaultTimeSeriesOperators.CreateFunctionLibraryInjector();
-    }
-
-    protected override IOperator CreatePostProcessingOperator() {
-      return DefaultTimeSeriesOperators.CreatePostProcessingOperator();
+      CombinedOperator op = new CombinedOperator();
+      op.Name = "FunctionLibraryInjector";
+      SequentialProcessor seq = new SequentialProcessor();
+      FunctionLibraryInjector funLibInjector = new FunctionLibraryInjector();
+      funLibInjector.GetVariable("Differentials").Value = new BoolData(true);
+      seq.AddSubOperator(funLibInjector);
+      seq.AddSubOperator(new HL3TreeEvaluatorInjector());
+      op.OperatorGraph.AddOperator(seq);
+      op.OperatorGraph.InitialOperator = seq;
+      return op;
     }
 
@@ -65,7 +75,14 @@
     }
 
+    protected override IOperator CreateModelAnalyzerOperator() {
+      return DefaultTimeSeriesOperators.CreatePostProcessingOperator();
+    }
+
     protected override IAnalyzerModel CreateGPModel() {
-      IAnalyzerModel model = base.CreateGPModel();
-      DefaultTimeSeriesOperators.SetModelData(model, Engine.GlobalScope.SubScopes[0]);
+      var model = new AnalyzerModel();
+      var bestModelScope = Engine.GlobalScope.SubScopes[0];
+      model.SetMetaData("SelectionPressure", bestModelScope.GetVariableValue<DoubleData>("SelectionPressure", false).Data);
+      DefaultStructureIdentificationOperators.PopulateAnalyzerModel(bestModelScope, model);
+      DefaultTimeSeriesOperators.PopulateAnalyzerModel(bestModelScope, model);
       return model;
     }
Index: /trunk/sources/HeuristicLab.GP.StructureIdentification.TimeSeries/3.3/StandardGP.cs
===================================================================
--- /trunk/sources/HeuristicLab.GP.StructureIdentification.TimeSeries/3.3/StandardGP.cs	(revision 2355)
+++ /trunk/sources/HeuristicLab.GP.StructureIdentification.TimeSeries/3.3/StandardGP.cs	(revision 2356)
@@ -29,4 +29,10 @@
 namespace HeuristicLab.GP.StructureIdentification.TimeSeries {
   public class StandardGP : HeuristicLab.GP.StructureIdentification.StandardGP, ITimeSeriesAlgorithm {
+    public override string Name {
+      get {
+        return base.Name + " - time series prognosis";
+      }
+    }
+
     public int MinTimeOffset {
       get { return GetVariableInjector().GetVariable("MinTimeOffset").GetValue<IntData>().Data; }
@@ -49,8 +55,17 @@
 
     protected override IOperator CreateFunctionLibraryInjector() {
-      return DefaultTimeSeriesOperators.CreateFunctionLibraryInjector();
+      CombinedOperator op = new CombinedOperator();
+      op.Name = "FunctionLibraryInjector";
+      SequentialProcessor seq = new SequentialProcessor();
+      FunctionLibraryInjector funLibInjector = new FunctionLibraryInjector();
+      funLibInjector.GetVariable("Differentials").Value = new BoolData(true);
+      seq.AddSubOperator(funLibInjector);
+      seq.AddSubOperator(new HL3TreeEvaluatorInjector());
+      op.OperatorGraph.AddOperator(seq);
+      op.OperatorGraph.InitialOperator = seq;
+      return op;
     }
 
-    protected override IOperator CreatePostProcessingOperator() {
+    protected override IOperator CreateModelAnalyzerOperator() {
       return DefaultTimeSeriesOperators.CreatePostProcessingOperator();
     }
@@ -65,6 +80,8 @@
 
     protected override IAnalyzerModel CreateGPModel() {
-      IAnalyzerModel model = base.CreateGPModel();
-      DefaultTimeSeriesOperators.SetModelData(model, Engine.GlobalScope.SubScopes[0]);
+      var model = new AnalyzerModel();
+      var bestModelScope = Engine.GlobalScope.SubScopes[0];
+      DefaultStructureIdentificationOperators.PopulateAnalyzerModel(bestModelScope, model);
+      DefaultTimeSeriesOperators.PopulateAnalyzerModel(bestModelScope, model);
       return model;
     }
Index: /trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/DefaultStructureIdentificationOperators.cs
===================================================================
--- /trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/DefaultStructureIdentificationOperators.cs	(revision 2355)
+++ /trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/DefaultStructureIdentificationOperators.cs	(revision 2356)
@@ -30,5 +30,5 @@
 
 namespace HeuristicLab.GP.StructureIdentification {
-  public static class DefaultStructureIdentificationAlgorithmOperators {
+  public static class DefaultStructureIdentificationOperators {
     public static IOperator CreateFunctionLibraryInjector() {
       CombinedOperator op = new CombinedOperator();
@@ -37,19 +37,4 @@
       seq.AddSubOperator(new FunctionLibraryInjector());
       seq.AddSubOperator(new HL3TreeEvaluatorInjector());
-      op.OperatorGraph.AddOperator(seq);
-      op.OperatorGraph.InitialOperator = seq;
-      return op;
-    }
-
-    public static IOperator CreateProblemInjector() {
-      CombinedOperator op = new CombinedOperator();
-      op.Name = "ProblemInjector";
-      SequentialProcessor seq = new SequentialProcessor();
-
-      seq.AddSubOperator(new ProblemInjector());
-      DatasetShuffler shuffler = new DatasetShuffler();
-      shuffler.GetVariableInfo("ShuffleStart").ActualName = "TrainingSamplesStart";
-      shuffler.GetVariableInfo("ShuffleEnd").ActualName = "TrainingSamplesEnd";
-      seq.AddSubOperator(shuffler);
       op.OperatorGraph.AddOperator(seq);
       op.OperatorGraph.InitialOperator = seq;
@@ -105,7 +90,6 @@
     }
 
-    public static IOperator CreatePostProcessingOperator() {
-      CombinedOperator op = new CombinedOperator();
-      op.Name = "ModelAnalyser";
+
+    public static IOperator CreatePreparationForPostProcessingOperator() {
       SequentialProcessor seq = new SequentialProcessor();
       LeftReducer cleanUp = new LeftReducer();
@@ -145,95 +129,9 @@
       testEvaluator.GetVariableInfo("Values").ActualName = "TestValues";
       testEvaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
-      #endregion
-      #region MSE
-      SimpleMSEEvaluator trainingMseEvaluator = new SimpleMSEEvaluator();
-      trainingMseEvaluator.Name = "TrainingMseEvaluator";
-      trainingMseEvaluator.GetVariableInfo("MSE").ActualName = "TrainingMSE";
-      trainingMseEvaluator.GetVariableInfo("Values").ActualName = "TrainingValues";
-      SimpleMSEEvaluator validationMseEvaluator = new SimpleMSEEvaluator();
-      validationMseEvaluator.Name = "ValidationMseEvaluator";
-      validationMseEvaluator.GetVariableInfo("MSE").ActualName = "ValidationMSE";
-      validationMseEvaluator.GetVariableInfo("Values").ActualName = "ValidationValues";
-      SimpleMSEEvaluator testMseEvaluator = new SimpleMSEEvaluator();
-      testMseEvaluator.Name = "TestMseEvaluator";
-      testMseEvaluator.GetVariableInfo("MSE").ActualName = "TestMSE";
-      testMseEvaluator.GetVariableInfo("Values").ActualName = "TestValues";
-      #endregion
-      #region MAPE
-      SimpleMeanAbsolutePercentageErrorEvaluator trainingMapeEvaluator = new SimpleMeanAbsolutePercentageErrorEvaluator();
-      trainingMapeEvaluator.Name = "TrainingMapeEvaluator";
-      trainingMapeEvaluator.GetVariableInfo("MAPE").ActualName = "TrainingMAPE";
-      trainingMapeEvaluator.GetVariableInfo("Values").ActualName = "TrainingValues";
-      SimpleMeanAbsolutePercentageErrorEvaluator validationMapeEvaluator = new SimpleMeanAbsolutePercentageErrorEvaluator();
-      validationMapeEvaluator.Name = "ValidationMapeEvaluator";
-      validationMapeEvaluator.GetVariableInfo("MAPE").ActualName = "ValidationMAPE";
-      validationMapeEvaluator.GetVariableInfo("Values").ActualName = "ValidationValues";
-      SimpleMeanAbsolutePercentageErrorEvaluator testMapeEvaluator = new SimpleMeanAbsolutePercentageErrorEvaluator();
-      testMapeEvaluator.Name = "TestMapeEvaluator";
-      testMapeEvaluator.GetVariableInfo("MAPE").ActualName = "TestMAPE";
-      testMapeEvaluator.GetVariableInfo("Values").ActualName = "TestValues";
-      #endregion
-      #region MAPRE
-      SimpleMeanAbsolutePercentageOfRangeErrorEvaluator trainingMapreEvaluator = new SimpleMeanAbsolutePercentageOfRangeErrorEvaluator();
-      trainingMapreEvaluator.Name = "TrainingMapreEvaluator";
-      trainingMapreEvaluator.GetVariableInfo("MAPRE").ActualName = "TrainingMAPRE";
-      trainingMapreEvaluator.GetVariableInfo("Values").ActualName = "TrainingValues";
-      SimpleMeanAbsolutePercentageOfRangeErrorEvaluator validationMapreEvaluator = new SimpleMeanAbsolutePercentageOfRangeErrorEvaluator();
-      validationMapreEvaluator.Name = "ValidationMapreEvaluator";
-      validationMapreEvaluator.GetVariableInfo("MAPRE").ActualName = "ValidationMAPRE";
-      validationMapreEvaluator.GetVariableInfo("Values").ActualName = "ValidationValues";
-      SimpleMeanAbsolutePercentageOfRangeErrorEvaluator testMapreEvaluator = new SimpleMeanAbsolutePercentageOfRangeErrorEvaluator();
-      testMapreEvaluator.Name = "TestMapreEvaluator";
-      testMapreEvaluator.GetVariableInfo("MAPRE").ActualName = "TestMAPRE";
-      testMapreEvaluator.GetVariableInfo("Values").ActualName = "TestValues";
-      #endregion MAPRE
-      #region R2
-      SimpleR2Evaluator trainingR2Evaluator = new SimpleR2Evaluator();
-      trainingR2Evaluator.Name = "TrainingR2Evaluator";
-      trainingR2Evaluator.GetVariableInfo("R2").ActualName = "TrainingR2";
-      trainingR2Evaluator.GetVariableInfo("Values").ActualName = "TrainingValues";
-      SimpleR2Evaluator validationR2Evaluator = new SimpleR2Evaluator();
-      validationR2Evaluator.Name = "ValidationR2Evaluator";
-      validationR2Evaluator.GetVariableInfo("R2").ActualName = "ValidationR2";
-      validationR2Evaluator.GetVariableInfo("Values").ActualName = "ValidationValues";
-      SimpleR2Evaluator testR2Evaluator = new SimpleR2Evaluator();
-      testR2Evaluator.Name = "TestR2Evaluator";
-      testR2Evaluator.GetVariableInfo("R2").ActualName = "TestR2";
-      testR2Evaluator.GetVariableInfo("Values").ActualName = "TestValues";
-      #endregion
-      #region VAF
-      SimpleVarianceAccountedForEvaluator trainingVAFEvaluator = new SimpleVarianceAccountedForEvaluator();
-      trainingVAFEvaluator.Name = "TrainingVAFEvaluator";
-      trainingVAFEvaluator.GetVariableInfo("VAF").ActualName = "TrainingVAF";
-      trainingVAFEvaluator.GetVariableInfo("Values").ActualName = "TrainingValues";
-      SimpleVarianceAccountedForEvaluator validationVAFEvaluator = new SimpleVarianceAccountedForEvaluator();
-      validationVAFEvaluator.Name = "ValidationVAFEvaluator";
-      validationVAFEvaluator.GetVariableInfo("VAF").ActualName = "ValidationVAF";
-      validationVAFEvaluator.GetVariableInfo("Values").ActualName = "ValidationValues";
-      SimpleVarianceAccountedForEvaluator testVAFEvaluator = new SimpleVarianceAccountedForEvaluator();
-      testVAFEvaluator.Name = "TestVAFEvaluator";
-      testVAFEvaluator.GetVariableInfo("VAF").ActualName = "TestVAF";
-      testVAFEvaluator.GetVariableInfo("Values").ActualName = "TestValues";
-      #endregion
-
       solutionProc.AddSubOperator(evaluatorInjector);
       solutionProc.AddSubOperator(trainingEvaluator);
       solutionProc.AddSubOperator(validationEvaluator);
       solutionProc.AddSubOperator(testEvaluator);
-      solutionProc.AddSubOperator(trainingMseEvaluator);
-      solutionProc.AddSubOperator(validationMseEvaluator);
-      solutionProc.AddSubOperator(testMseEvaluator);
-      solutionProc.AddSubOperator(trainingMapeEvaluator);
-      solutionProc.AddSubOperator(validationMapeEvaluator);
-      solutionProc.AddSubOperator(testMapeEvaluator);
-      solutionProc.AddSubOperator(trainingMapreEvaluator);
-      solutionProc.AddSubOperator(validationMapreEvaluator);
-      solutionProc.AddSubOperator(testMapreEvaluator);
-      solutionProc.AddSubOperator(trainingR2Evaluator);
-      solutionProc.AddSubOperator(validationR2Evaluator);
-      solutionProc.AddSubOperator(testR2Evaluator);
-      solutionProc.AddSubOperator(trainingVAFEvaluator);
-      solutionProc.AddSubOperator(validationVAFEvaluator);
-      solutionProc.AddSubOperator(testVAFEvaluator);
+      #endregion
 
       #region variable impacts
@@ -244,72 +142,16 @@
       predictorBuilder.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
 
-      VariableEvaluationImpactCalculator evaluationImpactCalculator = new VariableEvaluationImpactCalculator();
-      evaluationImpactCalculator.GetVariableInfo("SamplesStart").ActualName = "TrainingSamplesStart";
-      evaluationImpactCalculator.GetVariableInfo("SamplesEnd").ActualName = "TrainingSamplesEnd";
-      VariableQualityImpactCalculator qualityImpactCalculator = new VariableQualityImpactCalculator();
-      qualityImpactCalculator.GetVariableInfo("SamplesStart").ActualName = "TrainingSamplesStart";
-      qualityImpactCalculator.GetVariableInfo("SamplesEnd").ActualName = "TrainingSamplesEnd";
-
       solutionProc.AddSubOperator(namesExtractor);
       solutionProc.AddSubOperator(predictorBuilder);
-      solutionProc.AddSubOperator(evaluationImpactCalculator);
-      solutionProc.AddSubOperator(qualityImpactCalculator);
       #endregion
 
-      op.OperatorGraph.AddOperator(seq);
-      op.OperatorGraph.InitialOperator = seq;
-      return op;
+      return seq;
     }
 
-    public static IAnalyzerModel CreateGPModel(IScope bestModelScope) {
-      IAnalyzerModel model = new AnalyzerModel();
-      model.Predictor = bestModelScope.GetVariableValue<IPredictor>("Predictor", true);
-      Dataset ds = bestModelScope.GetVariableValue<Dataset>("Dataset", true);
-      model.Dataset = ds;
-      model.TargetVariable = ds.GetVariableName(bestModelScope.GetVariableValue<IntData>("TargetVariable", true).Data);
-      model.TrainingSamplesStart = bestModelScope.GetVariableValue<IntData>("TrainingSamplesStart", true).Data;
-      model.TrainingSamplesEnd = bestModelScope.GetVariableValue<IntData>("TrainingSamplesEnd", true).Data;
-      model.ValidationSamplesStart = bestModelScope.GetVariableValue<IntData>("ValidationSamplesStart", true).Data;
-      model.ValidationSamplesEnd = bestModelScope.GetVariableValue<IntData>("ValidationSamplesEnd", true).Data;
-      model.TestSamplesStart = bestModelScope.GetVariableValue<IntData>("TestSamplesStart", true).Data;
-      model.TestSamplesEnd = bestModelScope.GetVariableValue<IntData>("TestSamplesEnd", true).Data;
-
-      model.SetResult("TrainingMeanSquaredError", bestModelScope.GetVariableValue<DoubleData>("TrainingMSE", false).Data);
-      model.SetResult("ValidationMeanSquaredError", bestModelScope.GetVariableValue<DoubleData>("ValidationMSE", false).Data);
-      model.SetResult("TestMeanSquaredError", bestModelScope.GetVariableValue<DoubleData>("TestMSE", false).Data);
-      model.SetResult("TrainingCoefficientOfDetermination", bestModelScope.GetVariableValue<DoubleData>("TrainingR2", false).Data);
-      model.SetResult("ValidationCoefficientOfDetermination", bestModelScope.GetVariableValue<DoubleData>("ValidationR2", false).Data);
-      model.SetResult("TestCoefficientOfDetermination", bestModelScope.GetVariableValue<DoubleData>("TestR2", false).Data);
-      model.SetResult("TrainingMeanAbsolutePercentageError", bestModelScope.GetVariableValue<DoubleData>("TrainingMAPE", false).Data);
-      model.SetResult("ValidationMeanAbsolutePercentageError", bestModelScope.GetVariableValue<DoubleData>("ValidationMAPE", false).Data);
-      model.SetResult("TestMeanAbsolutePercentageError", bestModelScope.GetVariableValue<DoubleData>("TestMAPE", false).Data);
-      model.SetResult("TrainingMeanAbsolutePercentageOfRangeError", bestModelScope.GetVariableValue<DoubleData>("TrainingMAPRE", false).Data);
-      model.SetResult("ValidationMeanAbsolutePercentageOfRangeError", bestModelScope.GetVariableValue<DoubleData>("ValidationMAPRE", false).Data);
-      model.SetResult("TestMeanAbsolutePercentageOfRangeError", bestModelScope.GetVariableValue<DoubleData>("TestMAPRE", false).Data);
-      model.SetResult("TrainingVarianceAccountedFor", bestModelScope.GetVariableValue<DoubleData>("TrainingVAF", false).Data);
-      model.SetResult("ValidationVarianceAccountedFor", bestModelScope.GetVariableValue<DoubleData>("ValidationVAF", false).Data);
-      model.SetResult("TestVarianceAccountedFor", bestModelScope.GetVariableValue<DoubleData>("TestVAF", false).Data);
-
-      model.SetMetaData("EvaluatedSolutions", bestModelScope.GetVariableValue<DoubleData>("EvaluatedSolutions", true).Data);
-      IGeneticProgrammingModel gpModel = bestModelScope.GetVariableValue<IGeneticProgrammingModel>("FunctionTree", true);
+    public static void PopulateAnalyzerModel(IScope bestModelScope, IAnalyzerModel model) {
+      model.SetMetaData("EvaluatedSolutions", bestModelScope.GetVariableValue<DoubleData>("EvaluatedSolutions", false).Data);
+      IGeneticProgrammingModel gpModel = bestModelScope.GetVariableValue<IGeneticProgrammingModel>("FunctionTree", false);
       model.SetMetaData("TreeSize", gpModel.Size);
       model.SetMetaData("TreeHeight", gpModel.Height);
-
-      ItemList evaluationImpacts = bestModelScope.GetVariableValue<ItemList>("VariableEvaluationImpacts", false);
-      ItemList qualityImpacts = bestModelScope.GetVariableValue<ItemList>("VariableQualityImpacts", false);
-      foreach (ItemList row in evaluationImpacts) {
-        string variableName = ((StringData)row[0]).Data;
-        double impact = ((DoubleData)row[1]).Data;
-        model.SetVariableEvaluationImpact(variableName, impact);
-        model.AddInputVariable(variableName);
-      }
-      foreach (ItemList row in qualityImpacts) {
-        string variableName = ((StringData)row[0]).Data;
-        double impact = ((DoubleData)row[1]).Data;
-        model.SetVariableQualityImpact(variableName, impact);
-        model.AddInputVariable(variableName);
-      }
-
-      return model;
     }
   }
Index: /trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/OffspringSelectionGP.cs
===================================================================
--- /trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/OffspringSelectionGP.cs	(revision 2355)
+++ /trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/OffspringSelectionGP.cs	(revision 2356)
@@ -77,22 +77,22 @@
 
     protected override IOperator CreateFunctionLibraryInjector() {
-      return DefaultStructureIdentificationAlgorithmOperators.CreateFunctionLibraryInjector();
+      return DefaultStructureIdentificationOperators.CreateFunctionLibraryInjector();
     }
 
     protected override IOperator CreateProblemInjector() {
-      return DefaultStructureIdentificationAlgorithmOperators.CreateProblemInjector();
+      return DefaultRegressionOperators.CreateProblemInjector();
     }
 
     protected override IOperator CreateInitialPopulationEvaluator() {
-      return DefaultStructureIdentificationAlgorithmOperators.CreateInitialPopulationEvaluator();
+      return DefaultStructureIdentificationOperators.CreateInitialPopulationEvaluator();
     }
 
     protected override IOperator CreateEvaluationOperator() {
-      return DefaultStructureIdentificationAlgorithmOperators.CreateEvaluator();
+      return DefaultStructureIdentificationOperators.CreateEvaluator();
     }
 
 
     protected override IOperator CreateGenerationStepHook() {
-      return DefaultStructureIdentificationAlgorithmOperators.CreateGenerationStepHook();
+      return DefaultStructureIdentificationOperators.CreateGenerationStepHook();
     }
 
@@ -133,5 +133,23 @@
 
     protected override IOperator CreatePostProcessingOperator() {
-      return DefaultStructureIdentificationAlgorithmOperators.CreatePostProcessingOperator();
+      CombinedOperator op = new CombinedOperator();
+      op.Name = "ModelAnalyser";
+      SequentialProcessor seq = new SequentialProcessor();
+      seq.AddSubOperator(DefaultStructureIdentificationOperators.CreatePreparationForPostProcessingOperator());
+
+      UniformSequentialSubScopesProcessor subScopesProc = new UniformSequentialSubScopesProcessor();
+      SequentialProcessor solutionProc = new SequentialProcessor();
+      solutionProc.AddSubOperator(CreateModelAnalyzerOperator());
+
+      subScopesProc.AddSubOperator(solutionProc);
+      seq.AddSubOperator(subScopesProc);
+
+      op.OperatorGraph.AddOperator(seq);
+      op.OperatorGraph.InitialOperator = seq;
+      return op;
+    }
+
+    protected virtual IOperator CreateModelAnalyzerOperator() {
+      return DefaultRegressionOperators.CreatePostProcessingOperator();
     }
 
@@ -148,6 +166,10 @@
     protected virtual IAnalyzerModel CreateGPModel() {
       IScope bestModelScope = Engine.GlobalScope.SubScopes[0];
-      IAnalyzerModel model = DefaultStructureIdentificationAlgorithmOperators.CreateGPModel(bestModelScope);
-      model.SetMetaData("SelectionPressure", bestModelScope.GetVariableValue<DoubleData>("SelectionPressure", true).Data);
+      var model = new AnalyzerModel();
+
+      model.SetMetaData("SelectionPressure", bestModelScope.GetVariableValue<DoubleData>("SelectionPressure", false).Data);
+      DefaultStructureIdentificationOperators.PopulateAnalyzerModel(bestModelScope, model);
+      DefaultRegressionOperators.PopulateAnalyzerModel(bestModelScope, model);
+
       return model;
     }
Index: /trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/StandardGP.cs
===================================================================
--- /trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/StandardGP.cs	(revision 2355)
+++ /trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/StandardGP.cs	(revision 2356)
@@ -78,22 +78,22 @@
 
     protected override IOperator CreateFunctionLibraryInjector() {
-      return DefaultStructureIdentificationAlgorithmOperators.CreateFunctionLibraryInjector();
+      return DefaultStructureIdentificationOperators.CreateFunctionLibraryInjector();
     }
 
     protected override IOperator CreateProblemInjector() {
-      return DefaultStructureIdentificationAlgorithmOperators.CreateProblemInjector();
+      return DefaultRegressionOperators.CreateProblemInjector();
     }
 
     protected override IOperator CreateInitialPopulationEvaluator() {
-      return DefaultStructureIdentificationAlgorithmOperators.CreateInitialPopulationEvaluator();
+      return DefaultStructureIdentificationOperators.CreateInitialPopulationEvaluator();
     }
 
     protected override IOperator CreateEvaluationOperator() {
-      return DefaultStructureIdentificationAlgorithmOperators.CreateEvaluator();
+      return DefaultStructureIdentificationOperators.CreateEvaluator();
     }
 
 
     protected override IOperator CreateGenerationStepHook() {
-      return DefaultStructureIdentificationAlgorithmOperators.CreateGenerationStepHook();
+      return DefaultStructureIdentificationOperators.CreateGenerationStepHook();
     }
 
@@ -132,5 +132,23 @@
 
     protected override IOperator CreatePostProcessingOperator() {
-      return DefaultStructureIdentificationAlgorithmOperators.CreatePostProcessingOperator();
+      CombinedOperator op = new CombinedOperator();
+      op.Name = "ModelAnalyser";
+      SequentialProcessor seq = new SequentialProcessor();
+      seq.AddSubOperator(DefaultStructureIdentificationOperators.CreatePreparationForPostProcessingOperator());
+
+      UniformSequentialSubScopesProcessor subScopesProc = new UniformSequentialSubScopesProcessor();
+      SequentialProcessor solutionProc = new SequentialProcessor();
+      solutionProc.AddSubOperator(CreateModelAnalyzerOperator());
+
+      subScopesProc.AddSubOperator(solutionProc);
+      seq.AddSubOperator(subScopesProc);
+
+      op.OperatorGraph.AddOperator(seq);
+      op.OperatorGraph.InitialOperator = seq;
+      return op;
+    }
+
+    protected virtual IOperator CreateModelAnalyzerOperator() {
+      return DefaultRegressionOperators.CreatePostProcessingOperator();
     }
 
@@ -147,5 +165,7 @@
     protected virtual IAnalyzerModel CreateGPModel() {
       IScope bestModelScope = Engine.GlobalScope.SubScopes[0];
-      IAnalyzerModel model = DefaultStructureIdentificationAlgorithmOperators.CreateGPModel(bestModelScope);
+      IAnalyzerModel model = new AnalyzerModel();
+      DefaultStructureIdentificationOperators.PopulateAnalyzerModel(bestModelScope, model);
+      DefaultRegressionOperators.PopulateAnalyzerModel(bestModelScope, model);
       return model;
     }
Index: /trunk/sources/HeuristicLab.LinearRegression/3.2/LinearClassification.cs
===================================================================
--- /trunk/sources/HeuristicLab.LinearRegression/3.2/LinearClassification.cs	(revision 2355)
+++ /trunk/sources/HeuristicLab.LinearRegression/3.2/LinearClassification.cs	(revision 2356)
@@ -38,5 +38,5 @@
 
 namespace HeuristicLab.LinearRegression {
-  public class LinearClassification : LinearRegression {
+  public class LinearClassification : LinearRegression, IClassificationAlgorithm {
 
     public override string Name { get { return "LinearClassification"; } }
@@ -46,11 +46,15 @@
     }
 
-    protected override IOperator CreateModelAnalyser() {
-      return DefaultClassificationAlgorithmOperators.CreatePostProcessingOperator();
+    protected override IOperator CreateProblemInjector() {
+      return DefaultClassificationOperators.CreateProblemInjector();
+    }
+
+    protected override IOperator CreateModelAnalyzerOperator() {
+      return DefaultClassificationOperators.CreatePostProcessingOperator();
     }
 
     protected internal virtual IAnalyzerModel CreateLRModel(IScope bestModelScope) {
-      IAnalyzerModel model = base.CreateLRModel(bestModelScope);
-      DefaultClassificationAlgorithmOperators.SetModelData(model, bestModelScope);
+      var model = new AnalyzerModel();
+      DefaultClassificationOperators.PopulateAnalyzerModel(bestModelScope, model);
       return model;
     }
Index: /trunk/sources/HeuristicLab.LinearRegression/3.2/LinearRegression.cs
===================================================================
--- /trunk/sources/HeuristicLab.LinearRegression/3.2/LinearRegression.cs	(revision 2355)
+++ /trunk/sources/HeuristicLab.LinearRegression/3.2/LinearRegression.cs	(revision 2356)
@@ -87,19 +87,11 @@
       CombinedOperator algo = new CombinedOperator();
       SequentialProcessor seq = new SequentialProcessor();
-      algo.Name = "LinearRegression";
-      seq.Name = "LinearRegression";
-
-      var randomInjector = new RandomInjector();
-      randomInjector.Name = "Random Injector";
+      algo.Name = Name;
+      seq.Name = Name;
+
       IOperator globalInjector = CreateGlobalInjector();
-      ProblemInjector problemInjector = new ProblemInjector();
-      problemInjector.GetVariableInfo("MaxNumberOfTrainingSamples").Local = true;
-      problemInjector.AddVariable(new HeuristicLab.Core.Variable("MaxNumberOfTrainingSamples", new IntData(5000)));
-
-      HL2TreeEvaluatorInjector treeEvaluatorInjector = new HL2TreeEvaluatorInjector();
-
-      IOperator shuffler = new DatasetShuffler();
-      shuffler.GetVariableInfo("ShuffleStart").ActualName = "TrainingSamplesStart";
-      shuffler.GetVariableInfo("ShuffleEnd").ActualName = "TrainingSamplesEnd";
+
+      HL3TreeEvaluatorInjector treeEvaluatorInjector = new HL3TreeEvaluatorInjector();
+
 
       LinearRegressionOperator lrOperator = new LinearRegressionOperator();
@@ -107,11 +99,10 @@
       lrOperator.GetVariableInfo("SamplesEnd").ActualName = "ActualTrainingSamplesEnd";
 
-      seq.AddSubOperator(randomInjector);
-      seq.AddSubOperator(problemInjector);
       seq.AddSubOperator(globalInjector);
+      seq.AddSubOperator(new RandomInjector());
+      seq.AddSubOperator(CreateProblemInjector());
       seq.AddSubOperator(treeEvaluatorInjector);
-      seq.AddSubOperator(shuffler);
       seq.AddSubOperator(lrOperator);
-      seq.AddSubOperator(CreateModelAnalyser());
+      seq.AddSubOperator(CreatePostProcessingOperator());
 
       algo.OperatorGraph.InitialOperator = seq;
@@ -119,4 +110,8 @@
 
       return algo;
+    }
+
+    protected virtual IOperator CreateProblemInjector() {
+      return DefaultRegressionOperators.CreateProblemInjector();
     }
 
@@ -129,18 +124,70 @@
     }
 
-    protected virtual IOperator CreateModelAnalyser() {
+    protected virtual IOperator CreatePostProcessingOperator() {
       CombinedOperator op = new CombinedOperator();
-      op.AddVariableInfo(new VariableInfo("FunctionTree", "The model to analyze", typeof(IGeneticProgrammingModel), VariableKind.In));
       op.Name = "Model Analyzer";
-      op.GetVariableInfo("FunctionTree").ActualName = "LinearRegressionModel";
-
-      IOperator maOp = DefaultStructureIdentificationAlgorithmOperators.CreatePostProcessingOperator();
-      op.OperatorGraph.AddOperator(maOp);
-      op.OperatorGraph.InitialOperator = maOp;
+
+      SequentialProcessor seq = new SequentialProcessor();
+      HL3TreeEvaluatorInjector evaluatorInjector = new HL3TreeEvaluatorInjector();
+      evaluatorInjector.AddVariable(new HeuristicLab.Core.Variable("PunishmentFactor", new DoubleData(1000.0)));
+      evaluatorInjector.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
+
+      #region simple evaluators
+      SimpleEvaluator trainingEvaluator = new SimpleEvaluator();
+      trainingEvaluator.Name = "TrainingEvaluator";
+      trainingEvaluator.GetVariableInfo("FunctionTree").ActualName = "LinearRegressionModel";
+      trainingEvaluator.GetVariableInfo("SamplesStart").ActualName = "TrainingSamplesStart";
+      trainingEvaluator.GetVariableInfo("SamplesEnd").ActualName = "TrainingSamplesEnd";
+      trainingEvaluator.GetVariableInfo("Values").ActualName = "TrainingValues";
+      trainingEvaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
+      SimpleEvaluator validationEvaluator = new SimpleEvaluator();
+      validationEvaluator.Name = "ValidationEvaluator";
+      validationEvaluator.GetVariableInfo("FunctionTree").ActualName = "LinearRegressionModel";
+      validationEvaluator.GetVariableInfo("SamplesStart").ActualName = "ValidationSamplesStart";
+      validationEvaluator.GetVariableInfo("SamplesEnd").ActualName = "ValidationSamplesEnd";
+      validationEvaluator.GetVariableInfo("Values").ActualName = "ValidationValues";
+      validationEvaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
+      SimpleEvaluator testEvaluator = new SimpleEvaluator();
+      testEvaluator.Name = "TestEvaluator";
+      testEvaluator.GetVariableInfo("FunctionTree").ActualName = "LinearRegressionModel";
+      testEvaluator.GetVariableInfo("SamplesStart").ActualName = "TestSamplesStart";
+      testEvaluator.GetVariableInfo("SamplesEnd").ActualName = "TestSamplesEnd";
+      testEvaluator.GetVariableInfo("Values").ActualName = "TestValues";
+      testEvaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
+      seq.AddSubOperator(evaluatorInjector);
+      seq.AddSubOperator(trainingEvaluator);
+      seq.AddSubOperator(validationEvaluator);
+      seq.AddSubOperator(testEvaluator);
+      #endregion
+
+      #region variable impacts
+      // calculate and set variable impacts
+      VariableNamesExtractor namesExtractor = new VariableNamesExtractor();
+      namesExtractor.GetVariableInfo("VariableNames").ActualName = "InputVariableNames";
+      namesExtractor.GetVariableInfo("FunctionTree").ActualName = "LinearRegressionModel";
+
+      PredictorBuilder predictorBuilder = new PredictorBuilder();
+      predictorBuilder.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
+      predictorBuilder.GetVariableInfo("FunctionTree").ActualName = "LinearRegressionModel";
+
+      seq.AddSubOperator(namesExtractor);
+      seq.AddSubOperator(predictorBuilder);
+      #endregion
+
+      seq.AddSubOperator(CreateModelAnalyzerOperator());
+
+      op.OperatorGraph.AddOperator(seq);
+      op.OperatorGraph.InitialOperator = seq;
       return op;
     }
 
+    protected virtual IOperator CreateModelAnalyzerOperator() {
+      return DefaultRegressionOperators.CreatePostProcessingOperator();
+    }
+
     protected virtual IAnalyzerModel CreateLRModel(IScope bestModelScope) {
-      return DefaultStructureIdentificationAlgorithmOperators.CreateGPModel(bestModelScope);
+      var model = new AnalyzerModel();
+      DefaultRegressionOperators.PopulateAnalyzerModel(bestModelScope, model);
+      return model;
     }
 
Index: /trunk/sources/HeuristicLab.Modeling/3.2/DefaultClassificationOperators.cs
===================================================================
--- /trunk/sources/HeuristicLab.Modeling/3.2/DefaultClassificationOperators.cs	(revision 2356)
+++ /trunk/sources/HeuristicLab.Modeling/3.2/DefaultClassificationOperators.cs	(revision 2356)
@@ -0,0 +1,90 @@
+﻿#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.DataAnalysis;
+using HeuristicLab.Operators;
+using HeuristicLab.Modeling;
+using HeuristicLab.Data;
+
+namespace HeuristicLab.Modeling {
+  public static class DefaultClassificationOperators {
+    public static IOperator CreatePostProcessingOperator() {
+      CombinedOperator op = new CombinedOperator();
+      op.Name = "Classification model analyzer";
+
+      SequentialProcessor seq = new SequentialProcessor();
+      seq.AddSubOperator(DefaultRegressionOperators.CreatePostProcessingOperator());
+
+      SimpleAccuracyEvaluator trainingAccuracy = new SimpleAccuracyEvaluator();
+      trainingAccuracy.Name = "TrainingAccuracyEvaluator";
+      trainingAccuracy.GetVariableInfo("Accuracy").ActualName = "TrainingAccuracy";
+      trainingAccuracy.GetVariableInfo("Values").ActualName = "TrainingValues";
+
+      SimpleAccuracyEvaluator validationAccuracy = new SimpleAccuracyEvaluator();
+      validationAccuracy.Name = "ValidationAccuracyEvaluator";
+      validationAccuracy.GetVariableInfo("Accuracy").ActualName = "ValidationAccuracy";
+      validationAccuracy.GetVariableInfo("Values").ActualName = "ValidationValues";
+
+      SimpleAccuracyEvaluator testAccuracy = new SimpleAccuracyEvaluator();
+      testAccuracy.Name = "TestAccuracyEvaluator";
+      testAccuracy.GetVariableInfo("Accuracy").ActualName = "TestAccuracy";
+      testAccuracy.GetVariableInfo("Values").ActualName = "TestValues";
+
+      SimpleConfusionMatrixEvaluator trainingConfusionMatrixEvaluator = new SimpleConfusionMatrixEvaluator();
+      trainingConfusionMatrixEvaluator.Name = "TrainingConfusionMatrixEvaluator";
+      trainingConfusionMatrixEvaluator.GetVariableInfo("Values").ActualName = "TrainingValues";
+      trainingConfusionMatrixEvaluator.GetVariableInfo("ConfusionMatrix").ActualName = "TrainingConfusionMatrix";
+      SimpleConfusionMatrixEvaluator validationConfusionMatrixEvaluator = new SimpleConfusionMatrixEvaluator();
+      validationConfusionMatrixEvaluator.Name = "ValidationConfusionMatrixEvaluator";
+      validationConfusionMatrixEvaluator.GetVariableInfo("Values").ActualName = "ValidationValues";
+      validationConfusionMatrixEvaluator.GetVariableInfo("ConfusionMatrix").ActualName = "ValidationConfusionMatrix";
+      SimpleConfusionMatrixEvaluator testConfusionMatrixEvaluator = new SimpleConfusionMatrixEvaluator();
+      testConfusionMatrixEvaluator.Name = "TestConfusionMatrixEvaluator";
+      testConfusionMatrixEvaluator.GetVariableInfo("Values").ActualName = "TestValues";
+      testConfusionMatrixEvaluator.GetVariableInfo("ConfusionMatrix").ActualName = "TestConfusionMatrix";
+
+      seq.AddSubOperator(trainingAccuracy);
+      seq.AddSubOperator(validationAccuracy);
+      seq.AddSubOperator(testAccuracy);
+      seq.AddSubOperator(trainingConfusionMatrixEvaluator);
+      seq.AddSubOperator(validationConfusionMatrixEvaluator);
+      seq.AddSubOperator(testConfusionMatrixEvaluator);
+
+      op.OperatorGraph.AddOperator(seq);
+      op.OperatorGraph.InitialOperator = seq;
+
+      return op;
+    }
+
+    public static IOperator CreateProblemInjector() {
+      return DefaultRegressionOperators.CreateProblemInjector();
+    }
+
+    public static IAnalyzerModel PopulateAnalyzerModel(IScope modelScope, IAnalyzerModel model) {
+      DefaultRegressionOperators.PopulateAnalyzerModel(modelScope, model);
+      model.SetResult("TrainingAccuracy", modelScope.GetVariableValue<DoubleData>("TrainingAccuracy", false).Data);
+      model.SetResult("ValidationAccuracy", modelScope.GetVariableValue<DoubleData>("ValidationAccuracy", false).Data);
+      model.SetResult("TestAccuracy", modelScope.GetVariableValue<DoubleData>("TestAccuracy", false).Data);
+      return model;
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.Modeling/3.2/DefaultRegressionOperators.cs
===================================================================
--- /trunk/sources/HeuristicLab.Modeling/3.2/DefaultRegressionOperators.cs	(revision 2356)
+++ /trunk/sources/HeuristicLab.Modeling/3.2/DefaultRegressionOperators.cs	(revision 2356)
@@ -0,0 +1,199 @@
+﻿#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.DataAnalysis;
+using HeuristicLab.Operators;
+using HeuristicLab.Modeling;
+using HeuristicLab.Data;
+
+namespace HeuristicLab.Modeling {
+  public static class DefaultRegressionOperators {
+    public static IOperator CreateProblemInjector() {
+      CombinedOperator op = new CombinedOperator();
+      op.Name = "ProblemInjector";
+      SequentialProcessor seq = new SequentialProcessor();
+
+      seq.AddSubOperator(new ProblemInjector());
+      DatasetShuffler shuffler = new DatasetShuffler();
+      shuffler.GetVariableInfo("ShuffleStart").ActualName = "TrainingSamplesStart";
+      shuffler.GetVariableInfo("ShuffleEnd").ActualName = "TrainingSamplesEnd";
+      seq.AddSubOperator(shuffler);
+      op.OperatorGraph.AddOperator(seq);
+      op.OperatorGraph.InitialOperator = seq;
+      return op;
+    }
+
+    public static IOperator CreatePostProcessingOperator() {
+      CombinedOperator op = new CombinedOperator();
+      op.Name = "Regression model analyser";
+      SequentialProcessor seq = new SequentialProcessor();
+      #region MSE
+      SimpleMSEEvaluator trainingMseEvaluator = new SimpleMSEEvaluator();
+      trainingMseEvaluator.Name = "TrainingMseEvaluator";
+      trainingMseEvaluator.GetVariableInfo("MSE").ActualName = "TrainingMSE";
+      trainingMseEvaluator.GetVariableInfo("Values").ActualName = "TrainingValues";
+      SimpleMSEEvaluator validationMseEvaluator = new SimpleMSEEvaluator();
+      validationMseEvaluator.Name = "ValidationMseEvaluator";
+      validationMseEvaluator.GetVariableInfo("MSE").ActualName = "ValidationMSE";
+      validationMseEvaluator.GetVariableInfo("Values").ActualName = "ValidationValues";
+      SimpleMSEEvaluator testMseEvaluator = new SimpleMSEEvaluator();
+      testMseEvaluator.Name = "TestMseEvaluator";
+      testMseEvaluator.GetVariableInfo("MSE").ActualName = "TestMSE";
+      testMseEvaluator.GetVariableInfo("Values").ActualName = "TestValues";
+      #endregion
+      #region MAPE
+      SimpleMeanAbsolutePercentageErrorEvaluator trainingMapeEvaluator = new SimpleMeanAbsolutePercentageErrorEvaluator();
+      trainingMapeEvaluator.Name = "TrainingMapeEvaluator";
+      trainingMapeEvaluator.GetVariableInfo("MAPE").ActualName = "TrainingMAPE";
+      trainingMapeEvaluator.GetVariableInfo("Values").ActualName = "TrainingValues";
+      SimpleMeanAbsolutePercentageErrorEvaluator validationMapeEvaluator = new SimpleMeanAbsolutePercentageErrorEvaluator();
+      validationMapeEvaluator.Name = "ValidationMapeEvaluator";
+      validationMapeEvaluator.GetVariableInfo("MAPE").ActualName = "ValidationMAPE";
+      validationMapeEvaluator.GetVariableInfo("Values").ActualName = "ValidationValues";
+      SimpleMeanAbsolutePercentageErrorEvaluator testMapeEvaluator = new SimpleMeanAbsolutePercentageErrorEvaluator();
+      testMapeEvaluator.Name = "TestMapeEvaluator";
+      testMapeEvaluator.GetVariableInfo("MAPE").ActualName = "TestMAPE";
+      testMapeEvaluator.GetVariableInfo("Values").ActualName = "TestValues";
+      #endregion
+      #region MAPRE
+      SimpleMeanAbsolutePercentageOfRangeErrorEvaluator trainingMapreEvaluator = new SimpleMeanAbsolutePercentageOfRangeErrorEvaluator();
+      trainingMapreEvaluator.Name = "TrainingMapreEvaluator";
+      trainingMapreEvaluator.GetVariableInfo("MAPRE").ActualName = "TrainingMAPRE";
+      trainingMapreEvaluator.GetVariableInfo("Values").ActualName = "TrainingValues";
+      SimpleMeanAbsolutePercentageOfRangeErrorEvaluator validationMapreEvaluator = new SimpleMeanAbsolutePercentageOfRangeErrorEvaluator();
+      validationMapreEvaluator.Name = "ValidationMapreEvaluator";
+      validationMapreEvaluator.GetVariableInfo("MAPRE").ActualName = "ValidationMAPRE";
+      validationMapreEvaluator.GetVariableInfo("Values").ActualName = "ValidationValues";
+      SimpleMeanAbsolutePercentageOfRangeErrorEvaluator testMapreEvaluator = new SimpleMeanAbsolutePercentageOfRangeErrorEvaluator();
+      testMapreEvaluator.Name = "TestMapreEvaluator";
+      testMapreEvaluator.GetVariableInfo("MAPRE").ActualName = "TestMAPRE";
+      testMapreEvaluator.GetVariableInfo("Values").ActualName = "TestValues";
+      #endregion MAPRE
+      #region R2
+      SimpleR2Evaluator trainingR2Evaluator = new SimpleR2Evaluator();
+      trainingR2Evaluator.Name = "TrainingR2Evaluator";
+      trainingR2Evaluator.GetVariableInfo("R2").ActualName = "TrainingR2";
+      trainingR2Evaluator.GetVariableInfo("Values").ActualName = "TrainingValues";
+      SimpleR2Evaluator validationR2Evaluator = new SimpleR2Evaluator();
+      validationR2Evaluator.Name = "ValidationR2Evaluator";
+      validationR2Evaluator.GetVariableInfo("R2").ActualName = "ValidationR2";
+      validationR2Evaluator.GetVariableInfo("Values").ActualName = "ValidationValues";
+      SimpleR2Evaluator testR2Evaluator = new SimpleR2Evaluator();
+      testR2Evaluator.Name = "TestR2Evaluator";
+      testR2Evaluator.GetVariableInfo("R2").ActualName = "TestR2";
+      testR2Evaluator.GetVariableInfo("Values").ActualName = "TestValues";
+      #endregion
+      #region VAF
+      SimpleVarianceAccountedForEvaluator trainingVAFEvaluator = new SimpleVarianceAccountedForEvaluator();
+      trainingVAFEvaluator.Name = "TrainingVAFEvaluator";
+      trainingVAFEvaluator.GetVariableInfo("VAF").ActualName = "TrainingVAF";
+      trainingVAFEvaluator.GetVariableInfo("Values").ActualName = "TrainingValues";
+      SimpleVarianceAccountedForEvaluator validationVAFEvaluator = new SimpleVarianceAccountedForEvaluator();
+      validationVAFEvaluator.Name = "ValidationVAFEvaluator";
+      validationVAFEvaluator.GetVariableInfo("VAF").ActualName = "ValidationVAF";
+      validationVAFEvaluator.GetVariableInfo("Values").ActualName = "ValidationValues";
+      SimpleVarianceAccountedForEvaluator testVAFEvaluator = new SimpleVarianceAccountedForEvaluator();
+      testVAFEvaluator.Name = "TestVAFEvaluator";
+      testVAFEvaluator.GetVariableInfo("VAF").ActualName = "TestVAF";
+      testVAFEvaluator.GetVariableInfo("Values").ActualName = "TestValues";
+      #endregion
+
+      seq.AddSubOperator(trainingMseEvaluator);
+      seq.AddSubOperator(validationMseEvaluator);
+      seq.AddSubOperator(testMseEvaluator);
+      seq.AddSubOperator(trainingMapeEvaluator);
+      seq.AddSubOperator(validationMapeEvaluator);
+      seq.AddSubOperator(testMapeEvaluator);
+      seq.AddSubOperator(trainingMapreEvaluator);
+      seq.AddSubOperator(validationMapreEvaluator);
+      seq.AddSubOperator(testMapreEvaluator);
+      seq.AddSubOperator(trainingR2Evaluator);
+      seq.AddSubOperator(validationR2Evaluator);
+      seq.AddSubOperator(testR2Evaluator);
+      seq.AddSubOperator(trainingVAFEvaluator);
+      seq.AddSubOperator(validationVAFEvaluator);
+      seq.AddSubOperator(testVAFEvaluator);
+
+      #region variable impacts
+      VariableEvaluationImpactCalculator evaluationImpactCalculator = new VariableEvaluationImpactCalculator();
+      evaluationImpactCalculator.GetVariableInfo("SamplesStart").ActualName = "TrainingSamplesStart";
+      evaluationImpactCalculator.GetVariableInfo("SamplesEnd").ActualName = "TrainingSamplesEnd";
+      VariableQualityImpactCalculator qualityImpactCalculator = new VariableQualityImpactCalculator();
+      qualityImpactCalculator.GetVariableInfo("SamplesStart").ActualName = "TrainingSamplesStart";
+      qualityImpactCalculator.GetVariableInfo("SamplesEnd").ActualName = "TrainingSamplesEnd";
+
+      seq.AddSubOperator(evaluationImpactCalculator);
+      seq.AddSubOperator(qualityImpactCalculator);
+      #endregion
+
+      op.OperatorGraph.AddOperator(seq);
+      op.OperatorGraph.InitialOperator = seq;
+      return op;
+    }
+
+    public static IAnalyzerModel PopulateAnalyzerModel(IScope modelScope, IAnalyzerModel model) {
+      model.Predictor = modelScope.GetVariableValue<IPredictor>("Predictor", false);
+      Dataset ds = modelScope.GetVariableValue<Dataset>("Dataset", true);
+      model.Dataset = ds;
+      model.TargetVariable = ds.GetVariableName(modelScope.GetVariableValue<IntData>("TargetVariable", true).Data);
+      model.TrainingSamplesStart = modelScope.GetVariableValue<IntData>("TrainingSamplesStart", true).Data;
+      model.TrainingSamplesEnd = modelScope.GetVariableValue<IntData>("TrainingSamplesEnd", true).Data;
+      model.ValidationSamplesStart = modelScope.GetVariableValue<IntData>("ValidationSamplesStart", true).Data;
+      model.ValidationSamplesEnd = modelScope.GetVariableValue<IntData>("ValidationSamplesEnd", true).Data;
+      model.TestSamplesStart = modelScope.GetVariableValue<IntData>("TestSamplesStart", true).Data;
+      model.TestSamplesEnd = modelScope.GetVariableValue<IntData>("TestSamplesEnd", true).Data;
+
+      model.SetResult("TrainingMeanSquaredError", modelScope.GetVariableValue<DoubleData>("TrainingMSE", false).Data);
+      model.SetResult("ValidationMeanSquaredError", modelScope.GetVariableValue<DoubleData>("ValidationMSE", false).Data);
+      model.SetResult("TestMeanSquaredError", modelScope.GetVariableValue<DoubleData>("TestMSE", false).Data);
+      model.SetResult("TrainingCoefficientOfDetermination", modelScope.GetVariableValue<DoubleData>("TrainingR2", false).Data);
+      model.SetResult("ValidationCoefficientOfDetermination", modelScope.GetVariableValue<DoubleData>("ValidationR2", false).Data);
+      model.SetResult("TestCoefficientOfDetermination", modelScope.GetVariableValue<DoubleData>("TestR2", false).Data);
+      model.SetResult("TrainingMeanAbsolutePercentageError", modelScope.GetVariableValue<DoubleData>("TrainingMAPE", false).Data);
+      model.SetResult("ValidationMeanAbsolutePercentageError", modelScope.GetVariableValue<DoubleData>("ValidationMAPE", false).Data);
+      model.SetResult("TestMeanAbsolutePercentageError", modelScope.GetVariableValue<DoubleData>("TestMAPE", false).Data);
+      model.SetResult("TrainingMeanAbsolutePercentageOfRangeError", modelScope.GetVariableValue<DoubleData>("TrainingMAPRE", false).Data);
+      model.SetResult("ValidationMeanAbsolutePercentageOfRangeError", modelScope.GetVariableValue<DoubleData>("ValidationMAPRE", false).Data);
+      model.SetResult("TestMeanAbsolutePercentageOfRangeError", modelScope.GetVariableValue<DoubleData>("TestMAPRE", false).Data);
+      model.SetResult("TrainingVarianceAccountedFor", modelScope.GetVariableValue<DoubleData>("TrainingVAF", false).Data);
+      model.SetResult("ValidationVarianceAccountedFor", modelScope.GetVariableValue<DoubleData>("ValidationVAF", false).Data);
+      model.SetResult("TestVarianceAccountedFor", modelScope.GetVariableValue<DoubleData>("TestVAF", false).Data);
+
+      ItemList evaluationImpacts = modelScope.GetVariableValue<ItemList>("VariableEvaluationImpacts", false);
+      ItemList qualityImpacts = modelScope.GetVariableValue<ItemList>("VariableQualityImpacts", false);
+      foreach (ItemList row in evaluationImpacts) {
+        string variableName = ((StringData)row[0]).Data;
+        double impact = ((DoubleData)row[1]).Data;
+        model.SetVariableEvaluationImpact(variableName, impact);
+        model.AddInputVariable(variableName);
+      }
+      foreach (ItemList row in qualityImpacts) {
+        string variableName = ((StringData)row[0]).Data;
+        double impact = ((DoubleData)row[1]).Data;
+        model.SetVariableQualityImpact(variableName, impact);
+        model.AddInputVariable(variableName);
+      }
+
+      return model;
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.Modeling/3.2/DefaultTimeSeriesOperators.cs
===================================================================
--- /trunk/sources/HeuristicLab.Modeling/3.2/DefaultTimeSeriesOperators.cs	(revision 2356)
+++ /trunk/sources/HeuristicLab.Modeling/3.2/DefaultTimeSeriesOperators.cs	(revision 2356)
@@ -0,0 +1,78 @@
+﻿#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.DataAnalysis;
+using HeuristicLab.Operators;
+using HeuristicLab.Modeling;
+using HeuristicLab.Data;
+
+namespace HeuristicLab.Modeling {
+  public static class DefaultTimeSeriesOperators {
+    public static IOperator CreateProblemInjector() {
+      CombinedOperator op = new CombinedOperator();
+      op.Name = "ProblemInjector";
+      SequentialProcessor seq = new SequentialProcessor();
+      seq.AddSubOperator(new ProblemInjector());
+      op.OperatorGraph.AddOperator(seq);
+      op.OperatorGraph.InitialOperator = seq;
+      return op;
+    }
+
+    public static IOperator CreatePostProcessingOperator() {
+      CombinedOperator op = new CombinedOperator();
+      op.Name = "Time series prognosis model analyzer";
+
+      SequentialProcessor seq = new SequentialProcessor();
+      seq.AddSubOperator(DefaultRegressionOperators.CreatePostProcessingOperator());
+
+      SimpleTheilInequalityCoefficientEvaluator trainingTheil = new SimpleTheilInequalityCoefficientEvaluator();
+      trainingTheil.Name = "TrainingTheilInequalityEvaluator";
+      trainingTheil.GetVariableInfo("Values").ActualName = "TrainingValues";
+      trainingTheil.GetVariableInfo("TheilInequalityCoefficient").ActualName = "TrainingTheilInequalityCoefficient";
+      SimpleTheilInequalityCoefficientEvaluator validationTheil = new SimpleTheilInequalityCoefficientEvaluator();
+      validationTheil.Name = "ValidationTheilInequalityEvaluator";
+      validationTheil.GetVariableInfo("Values").ActualName = "ValidationValues";
+      validationTheil.GetVariableInfo("TheilInequalityCoefficient").ActualName = "ValidationTheilInequalityCoefficient";
+      SimpleTheilInequalityCoefficientEvaluator testTheil = new SimpleTheilInequalityCoefficientEvaluator();
+      testTheil.Name = "TestTheilInequalityEvaluator";
+      testTheil.GetVariableInfo("Values").ActualName = "TestValues";
+      testTheil.GetVariableInfo("TheilInequalityCoefficient").ActualName = "TestTheilInequalityCoefficient";
+
+      seq.AddSubOperator(trainingTheil);
+      seq.AddSubOperator(validationTheil);
+      seq.AddSubOperator(testTheil);
+
+      op.OperatorGraph.AddOperator(seq);
+      op.OperatorGraph.InitialOperator = seq;
+      return op;
+    }
+
+    public static IAnalyzerModel PopulateAnalyzerModel(IScope modelScope, IAnalyzerModel model) {
+      DefaultRegressionOperators.PopulateAnalyzerModel(modelScope, model);
+      model.SetResult("TrainingTheilInequalityCoefficient", modelScope.GetVariableValue<DoubleData>("TrainingTheilInequalityCoefficient", true).Data);
+      model.SetResult("ValidationTheilInequalityCoefficient", modelScope.GetVariableValue<DoubleData>("ValidationTheilInequalityCoefficient", true).Data);
+      model.SetResult("TestTheilInequalityCoefficient", modelScope.GetVariableValue<DoubleData>("TestTheilInequalityCoefficient", true).Data);
+
+      return model;
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.Modeling/3.2/HeuristicLab.Modeling-3.2.csproj
===================================================================
--- /trunk/sources/HeuristicLab.Modeling/3.2/HeuristicLab.Modeling-3.2.csproj	(revision 2355)
+++ /trunk/sources/HeuristicLab.Modeling/3.2/HeuristicLab.Modeling-3.2.csproj	(revision 2356)
@@ -84,4 +84,7 @@
     <Compile Include="AnalyzerModel.cs" />
     <Compile Include="BestSolutionStorer.cs" />
+    <Compile Include="DefaultClassificationOperators.cs" />
+    <Compile Include="DefaultRegressionOperators.cs" />
+    <Compile Include="DefaultTimeSeriesOperators.cs" />
     <Compile Include="SimpleAccuracyEvaluator.cs" />
     <Compile Include="SimpleConfusionMatrixEvaluator.cs" />
@@ -133,4 +136,8 @@
       <Name>HeuristicLab.Data-3.2</Name>
     </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Operators\3.2\HeuristicLab.Operators-3.2.csproj">
+      <Project>{A9983BA2-B3B2-475E-8E2C-62050B71D1C5}</Project>
+      <Name>HeuristicLab.Operators-3.2</Name>
+    </ProjectReference>
     <ProjectReference Include="..\..\HeuristicLab.PluginInfrastructure\HeuristicLab.PluginInfrastructure.csproj">
       <Project>{94186A6A-5176-4402-AE83-886557B53CCA}</Project>
Index: /trunk/sources/HeuristicLab.SupportVectorMachines/3.2/SupportVectorClassification.cs
===================================================================
--- /trunk/sources/HeuristicLab.SupportVectorMachines/3.2/SupportVectorClassification.cs	(revision 2355)
+++ /trunk/sources/HeuristicLab.SupportVectorMachines/3.2/SupportVectorClassification.cs	(revision 2356)
@@ -1,3 +1,4 @@
-﻿#region License Information
+﻿
+#region License Information
 /* HeuristicLab
  * Copyright (C) 2002-2008 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
@@ -37,5 +38,5 @@
 
 namespace HeuristicLab.SupportVectorMachines {
-  public class SupportVectorClassification : SupportVectorRegression {
+  public class SupportVectorClassification : SupportVectorRegression, IClassificationAlgorithm {
 
     public override string Name { get { return "SupportVectorClassification"; } }
@@ -48,68 +49,14 @@
     }
 
-    protected override IOperator CreateModelAnalyser() {
-      CombinedOperator op = new CombinedOperator();
-      op.Name = "Model Analyzer";
-      SequentialProcessor seq = new SequentialProcessor();
-      seq.AddSubOperator(base.CreateModelAnalyser());
-      SequentialSubScopesProcessor seqSubScopeProc = new SequentialSubScopesProcessor();
-      SequentialProcessor seqProc = new SequentialProcessor();
-
-      SupportVectorEvaluator trainingEvaluator = new SupportVectorEvaluator();
-      trainingEvaluator.Name = "TrainingSimpleEvaluator";
-      trainingEvaluator.GetVariableInfo("SamplesStart").ActualName = "TrainingSamplesStart";
-      trainingEvaluator.GetVariableInfo("SamplesEnd").ActualName = "TrainingSamplesEnd";
-      trainingEvaluator.GetVariableInfo("Values").ActualName = "TrainingValues";
-
-      SimpleAccuracyEvaluator trainingAccuracyEvaluator = new SimpleAccuracyEvaluator();
-      trainingAccuracyEvaluator.Name = "TrainingAccuracyEvaluator";
-      trainingAccuracyEvaluator.GetVariableInfo("Values").ActualName = "TrainingValues";
-      trainingAccuracyEvaluator.GetVariableInfo("Accuracy").ActualName = "TrainingAccuracy";
-      SimpleAccuracyEvaluator validationAccuracyEvaluator = new SimpleAccuracyEvaluator();
-      validationAccuracyEvaluator.Name = "ValidationAccuracyEvaluator";
-      validationAccuracyEvaluator.GetVariableInfo("Values").ActualName = "ValidationValues";
-      validationAccuracyEvaluator.GetVariableInfo("Accuracy").ActualName = "ValidationAccuracy";
-      SimpleAccuracyEvaluator testAccuracyEvaluator = new SimpleAccuracyEvaluator();
-      testAccuracyEvaluator.Name = "TestAccuracyEvaluator";
-      testAccuracyEvaluator.GetVariableInfo("Values").ActualName = "TestValues";
-      testAccuracyEvaluator.GetVariableInfo("Accuracy").ActualName = "TestAccuracy";
-
-      SimpleConfusionMatrixEvaluator trainingConfusionMatrixEvaluator = new SimpleConfusionMatrixEvaluator();
-      trainingConfusionMatrixEvaluator.Name = "TrainingConfusionMatrixEvaluator";
-      trainingConfusionMatrixEvaluator.GetVariableInfo("Values").ActualName = "TrainingValues";
-      trainingConfusionMatrixEvaluator.GetVariableInfo("ConfusionMatrix").ActualName = "TrainingConfusionMatrix";
-      SimpleConfusionMatrixEvaluator validationConfusionMatrixEvaluator = new SimpleConfusionMatrixEvaluator();
-      validationConfusionMatrixEvaluator.Name = "ValidationConfusionMatrixEvaluator";
-      validationConfusionMatrixEvaluator.GetVariableInfo("Values").ActualName = "ValidationValues";
-      validationConfusionMatrixEvaluator.GetVariableInfo("ConfusionMatrix").ActualName = "ValidationConfusionMatrix";
-      SimpleConfusionMatrixEvaluator testConfusionMatrixEvaluator = new SimpleConfusionMatrixEvaluator();
-      testConfusionMatrixEvaluator.Name = "TestConfusionMatrixEvaluator";
-      testConfusionMatrixEvaluator.GetVariableInfo("Values").ActualName = "TestValues";
-      testConfusionMatrixEvaluator.GetVariableInfo("ConfusionMatrix").ActualName = "TestConfusionMatrix";
-
-      seqProc.AddSubOperator(trainingEvaluator);
-      seqProc.AddSubOperator(trainingAccuracyEvaluator);
-      seqProc.AddSubOperator(validationAccuracyEvaluator);
-      seqProc.AddSubOperator(testAccuracyEvaluator);
-      seqProc.AddSubOperator(trainingConfusionMatrixEvaluator);
-      seqProc.AddSubOperator(validationConfusionMatrixEvaluator);
-      seqProc.AddSubOperator(testConfusionMatrixEvaluator);
-
-      seq.AddSubOperator(seqSubScopeProc);
-      seqSubScopeProc.AddSubOperator(seqProc);
-
-      op.OperatorGraph.AddOperator(seq);
-      op.OperatorGraph.InitialOperator = seq;
-      return op;
+    protected override IOperator CreateModelAnalyzerOperator() {
+      return DefaultClassificationOperators.CreatePostProcessingOperator();
     }
 
 
     protected override IAnalyzerModel CreateSVMModel(IScope bestModelScope) {
-      IAnalyzerModel model = base.CreateSVMModel(bestModelScope);
-
-      model.SetResult("TrainingAccuracy", bestModelScope.GetVariableValue<DoubleData>("TrainingAccuracy", false).Data);
-      model.SetResult("ValidationAccuracy", bestModelScope.GetVariableValue<DoubleData>("ValidationAccuracy", false).Data);
-      model.SetResult("TestAccuracy", bestModelScope.GetVariableValue<DoubleData>("TestAccuracy", false).Data);
-
+      IAnalyzerModel model = new AnalyzerModel();
+      model.SetMetaData("Cost", bestModelScope.GetVariableValue<DoubleData>("Cost", false).Data);
+      model.SetMetaData("Nu", bestModelScope.GetVariableValue<DoubleData>("Nu", false).Data);
+      DefaultClassificationOperators.PopulateAnalyzerModel(bestModelScope, model);
       return model;
     }
Index: /trunk/sources/HeuristicLab.SupportVectorMachines/3.2/SupportVectorRegression.cs
===================================================================
--- /trunk/sources/HeuristicLab.SupportVectorMachines/3.2/SupportVectorRegression.cs	(revision 2355)
+++ /trunk/sources/HeuristicLab.SupportVectorMachines/3.2/SupportVectorRegression.cs	(revision 2356)
@@ -125,10 +125,10 @@
       CombinedOperator algo = new CombinedOperator();
       SequentialProcessor seq = new SequentialProcessor();
-      algo.Name = "SupportVectorRegression";
-      seq.Name = "SupportVectorRegression";
+      algo.Name = Name;
+      seq.Name = Name;
 
       IOperator initialization = CreateInitialization();
       IOperator main = CreateMainLoop();
-      IOperator postProc = CreateModelAnalyser();
+      IOperator postProc = CreatePostProcessingOperator();
 
       seq.AddSubOperator(initialization);
@@ -145,16 +145,12 @@
       SequentialProcessor seq = new SequentialProcessor();
       seq.Name = "Initialization";
+      seq.AddSubOperator(new RandomInjector());
       seq.AddSubOperator(CreateGlobalInjector());
-      ProblemInjector probInjector = new ProblemInjector();
-      probInjector.GetVariableInfo("MaxNumberOfTrainingSamples").Local = true;
-      probInjector.AddVariable(new Variable("MaxNumberOfTrainingSamples", new IntData(1000)));
-      seq.AddSubOperator(probInjector);
-      seq.AddSubOperator(new RandomInjector());
-
-      DatasetShuffler shuffler = new DatasetShuffler();
-      shuffler.GetVariableInfo("ShuffleStart").ActualName = "TrainingSamplesStart";
-      shuffler.GetVariableInfo("ShuffleEnd").ActualName = "TrainingSamplesEnd";
-      seq.AddSubOperator(shuffler);
+      seq.AddSubOperator(CreateProblemInjector());
       return seq;
+    }
+
+    protected virtual IOperator CreateProblemInjector() {
+      return DefaultRegressionOperators.CreateProblemInjector();
     }
 
@@ -402,5 +398,5 @@
     }
 
-    protected virtual IOperator CreateModelAnalyser() {
+    protected virtual IOperator CreatePostProcessingOperator() {
       CombinedOperator modelAnalyser = new CombinedOperator();
       modelAnalyser.Name = "Model Analyzer";
@@ -410,15 +406,10 @@
       PredictorBuilder predictorBuilder = new PredictorBuilder();
       predictorBuilder.GetVariableInfo("SVMModel").ActualName = "Model";
-      VariableEvaluationImpactCalculator evalImpactCalc = new VariableEvaluationImpactCalculator();
-      evalImpactCalc.GetVariableInfo("SamplesStart").ActualName = "ActualTrainingSamplesStart";
-      evalImpactCalc.GetVariableInfo("SamplesEnd").ActualName = "ActualTrainingSamplesEnd";
-      VariableQualityImpactCalculator qualImpactCalc = new VariableQualityImpactCalculator();
-      qualImpactCalc.GetVariableInfo("SamplesStart").ActualName = "ActualTrainingSamplesStart";
-      qualImpactCalc.GetVariableInfo("SamplesEnd").ActualName = "ActualTrainingSamplesEnd";
 
       seqProc.AddSubOperator(CreateEvaluator("Test"));
+      seqProc.AddSubOperator(CreateEvaluator("Training"));
       seqProc.AddSubOperator(predictorBuilder);
-      seqProc.AddSubOperator(evalImpactCalc);
-      seqProc.AddSubOperator(qualImpactCalc);
+      seqProc.AddSubOperator(CreateModelAnalyzerOperator());
+
       seqSubScopeProc.AddSubOperator(seqProc);
       modelAnalyser.OperatorGraph.InitialOperator = seqSubScopeProc;
@@ -427,51 +418,14 @@
     }
 
+    protected virtual IOperator CreateModelAnalyzerOperator() {
+      return DefaultRegressionOperators.CreatePostProcessingOperator();
+    }
+
 
     protected virtual IAnalyzerModel CreateSVMModel(IScope bestModelScope) {
       AnalyzerModel model = new AnalyzerModel();
-      model.SetResult("TrainingMeanSquaredError", bestModelScope.GetVariableValue<DoubleData>("Quality", false).Data);
-      model.SetResult("ValidationMeanSquaredError", bestModelScope.GetVariableValue<DoubleData>("ValidationQuality", false).Data);
-      model.SetResult("TestMeanSquaredError", bestModelScope.GetVariableValue<DoubleData>("TestQuality", false).Data);
-      model.SetResult("TrainingCoefficientOfDetermination", bestModelScope.GetVariableValue<DoubleData>("ActualTrainingR2", false).Data);
-      model.SetResult("ValidationCoefficientOfDetermination", bestModelScope.GetVariableValue<DoubleData>("ValidationR2", false).Data);
-      model.SetResult("TestCoefficientOfDetermination", bestModelScope.GetVariableValue<DoubleData>("TestR2", false).Data);
-      model.SetResult("TrainingMeanAbsolutePercentageError", bestModelScope.GetVariableValue<DoubleData>("ActualTrainingMAPE", false).Data);
-      model.SetResult("ValidationMeanAbsolutePercentageError", bestModelScope.GetVariableValue<DoubleData>("ValidationMAPE", false).Data);
-      model.SetResult("TestMeanAbsolutePercentageError", bestModelScope.GetVariableValue<DoubleData>("TestMAPE", false).Data);
-      model.SetResult("TrainingMeanAbsolutePercentageOfRangeError", bestModelScope.GetVariableValue<DoubleData>("ActualTrainingMAPRE", false).Data);
-      model.SetResult("ValidationMeanAbsolutePercentageOfRangeError", bestModelScope.GetVariableValue<DoubleData>("ValidationMAPRE", false).Data);
-      model.SetResult("TestMeanAbsolutePercentageOfRangeError", bestModelScope.GetVariableValue<DoubleData>("TestMAPRE", false).Data);
-      model.SetResult("TrainingVarianceAccountedFor", bestModelScope.GetVariableValue<DoubleData>("ActualTrainingVAF", false).Data);
-      model.SetResult("ValidationVarianceAccountedFor", bestModelScope.GetVariableValue<DoubleData>("ValidationVAF", false).Data);
-      model.SetResult("TestVarianceAccountedFor", bestModelScope.GetVariableValue<DoubleData>("TestVAF", false).Data);
-
       model.SetMetaData("Cost", bestModelScope.GetVariableValue<DoubleData>("Cost", false).Data);
       model.SetMetaData("Nu", bestModelScope.GetVariableValue<DoubleData>("Nu", false).Data);
-
-      HeuristicLab.DataAnalysis.Dataset ds = bestModelScope.GetVariableValue<Dataset>("Dataset", true);
-      model.Dataset = ds;
-      model.TargetVariable = ds.GetVariableName(bestModelScope.GetVariableValue<IntData>("TargetVariable", true).Data);
-      model.TrainingSamplesStart = bestModelScope.GetVariableValue<IntData>("TrainingSamplesStart", true).Data;
-      model.TrainingSamplesEnd = bestModelScope.GetVariableValue<IntData>("TrainingSamplesEnd", true).Data;
-      model.ValidationSamplesStart = bestModelScope.GetVariableValue<IntData>("ValidationSamplesStart", true).Data;
-      model.ValidationSamplesEnd = bestModelScope.GetVariableValue<IntData>("ValidationSamplesEnd", true).Data;
-      model.TestSamplesStart = bestModelScope.GetVariableValue<IntData>("TestSamplesStart", true).Data;
-      model.TestSamplesEnd = bestModelScope.GetVariableValue<IntData>("TestSamplesEnd", true).Data;
-      model.Predictor = bestModelScope.GetVariableValue<IPredictor>("Predictor", true);
-
-      ItemList evaluationImpacts = bestModelScope.GetVariableValue<ItemList>("VariableEvaluationImpacts", false);
-      ItemList qualityImpacts = bestModelScope.GetVariableValue<ItemList>("VariableQualityImpacts", false);
-      foreach (ItemList row in evaluationImpacts) {
-        string variableName = ((StringData)row[0]).Data;
-        double impact = ((DoubleData)row[1]).Data;
-        model.SetVariableEvaluationImpact(variableName, impact);
-        model.AddInputVariable(variableName);
-      }
-      foreach (ItemList row in qualityImpacts) {
-        string variableName = ((StringData)row[0]).Data;
-        double impact = ((DoubleData)row[1]).Data;
-        model.SetVariableQualityImpact(variableName, impact);
-        model.AddInputVariable(variableName);
-      }
+      DefaultRegressionOperators.PopulateAnalyzerModel(bestModelScope, model);
 
       return model;
@@ -479,5 +433,5 @@
 
     protected IOperator GetVariableInjector() {
-      return GetMainOperator().SubOperators[0].SubOperators[0];
+      return GetMainOperator().SubOperators[0].SubOperators[1];
     }
 
Index: /trunk/sources/HeuristicLab.SupportVectorMachines/3.2/TimeSeriesSupportVectorRegression.cs
===================================================================
--- /trunk/sources/HeuristicLab.SupportVectorMachines/3.2/TimeSeriesSupportVectorRegression.cs	(revision 2355)
+++ /trunk/sources/HeuristicLab.SupportVectorMachines/3.2/TimeSeriesSupportVectorRegression.cs	(revision 2356)
@@ -57,12 +57,6 @@
     }
 
-    protected override IOperator CreateInitialization() {
-      SequentialProcessor seq = new SequentialProcessor();
-      seq.Name = "Initialization";
-      seq.AddSubOperator(CreateGlobalInjector());
-      ProblemInjector probInjector = new ProblemInjector();
-      seq.AddSubOperator(probInjector);
-      seq.AddSubOperator(new RandomInjector());
-      return seq;
+    protected override IOperator CreateProblemInjector() {
+      return DefaultTimeSeriesOperators.CreateProblemInjector();
     }
 
@@ -74,53 +68,13 @@
     }
 
-    protected override IOperator CreateModelAnalyser() {
-      CombinedOperator op = new CombinedOperator();
-      op.Name = "Model Analyzer";
-      SequentialProcessor seq = new SequentialProcessor();
-      seq.AddSubOperator(base.CreateModelAnalyser());
-      SequentialSubScopesProcessor seqSubScopeProc = new SequentialSubScopesProcessor();
-      SequentialProcessor seqProc = new SequentialProcessor();
-
-      SupportVectorEvaluator trainingEvaluator = new SupportVectorEvaluator();
-      trainingEvaluator.Name = "TrainingEvaluator";
-      trainingEvaluator.GetVariableInfo("SVMModel").ActualName = "Model";
-      trainingEvaluator.GetVariableInfo("SamplesStart").ActualName = "TrainingSamplesStart";
-      trainingEvaluator.GetVariableInfo("SamplesEnd").ActualName = "TrainingSamplesEnd";
-      trainingEvaluator.GetVariableInfo("Values").ActualName = "TrainingValues";
-
-      SimpleTheilInequalityCoefficientEvaluator trainingTheilUCalculator = new SimpleTheilInequalityCoefficientEvaluator();
-      trainingTheilUCalculator.Name = "TrainingTheilInequalityEvaluator";
-      trainingTheilUCalculator.GetVariableInfo("Values").ActualName = "TrainingValues";
-      trainingTheilUCalculator.GetVariableInfo("TheilInequalityCoefficient").ActualName = "TrainingTheilInequalityCoefficient";
-      SimpleTheilInequalityCoefficientEvaluator validationTheilUCalculator = new SimpleTheilInequalityCoefficientEvaluator();
-      validationTheilUCalculator.Name = "ValidationTheilInequalityEvaluator";
-      validationTheilUCalculator.GetVariableInfo("Values").ActualName = "ValidationValues";
-      validationTheilUCalculator.GetVariableInfo("TheilInequalityCoefficient").ActualName = "ValidationTheilInequalityCoefficient";
-      SimpleTheilInequalityCoefficientEvaluator testTheilUCalculator = new SimpleTheilInequalityCoefficientEvaluator();
-      testTheilUCalculator.Name = "TestTheilInequalityEvaluator";
-      testTheilUCalculator.GetVariableInfo("Values").ActualName = "TestValues";
-      testTheilUCalculator.GetVariableInfo("TheilInequalityCoefficient").ActualName = "TestTheilInequalityCoefficient";
-
-      seqProc.AddSubOperator(trainingEvaluator);
-      seqProc.AddSubOperator(trainingTheilUCalculator);
-      seqProc.AddSubOperator(validationTheilUCalculator);
-      seqProc.AddSubOperator(testTheilUCalculator);
-
-      seq.AddSubOperator(seqSubScopeProc);
-      seqSubScopeProc.AddSubOperator(seqProc);
-
-      op.OperatorGraph.AddOperator(seq);
-      op.OperatorGraph.InitialOperator = seq;
-      return op;
+    protected override IOperator CreateModelAnalyzerOperator() {
+      return DefaultTimeSeriesOperators.CreatePostProcessingOperator();
     }
 
-
     protected override IAnalyzerModel CreateSVMModel(IScope bestModelScope) {
-      IAnalyzerModel model = base.CreateSVMModel(bestModelScope);
-
-      model.SetResult("TrainingTheilInequalityCoefficient", bestModelScope.GetVariableValue<DoubleData>("TrainingTheilInequalityCoefficient", false).Data);
-      model.SetResult("ValidationTheilInequalityCoefficient", bestModelScope.GetVariableValue<DoubleData>("ValidationTheilInequalityCoefficient", false).Data);
-      model.SetResult("TestTheilInequalityCoefficient", bestModelScope.GetVariableValue<DoubleData>("TestTheilInequalityCoefficient", false).Data);
-
+      var model = new AnalyzerModel();
+      model.SetMetaData("Cost", bestModelScope.GetVariableValue<DoubleData>("Cost", false).Data);
+      model.SetMetaData("Nu", bestModelScope.GetVariableValue<DoubleData>("Nu", false).Data);
+      DefaultTimeSeriesOperators.PopulateAnalyzerModel(bestModelScope, model);
       return model;
     }
