Index: trunk/sources/HeuristicLab.Modeling/3.2/DefaultClassificationOperators.cs
===================================================================
--- trunk/sources/HeuristicLab.Modeling/3.2/DefaultClassificationOperators.cs	(revision 2387)
+++ trunk/sources/HeuristicLab.Modeling/3.2/DefaultClassificationOperators.cs	(revision 2388)
@@ -33,20 +33,5 @@
 
       SequentialProcessor seq = new SequentialProcessor();
-      seq.AddSubOperator(DefaultRegressionOperators.CreatePostProcessingOperator());
-
-      SimpleAccuracyEvaluator trainingAccuracy = new SimpleAccuracyEvaluator();
-      trainingAccuracy.Name = "TrainingAccuracyEvaluator";
-      trainingAccuracy.GetVariableInfo("Accuracy").ActualName = ModelingResult.TrainingAccuracy.ToString();
-      trainingAccuracy.GetVariableInfo("Values").ActualName = "TrainingValues";
-
-      SimpleAccuracyEvaluator validationAccuracy = new SimpleAccuracyEvaluator();
-      validationAccuracy.Name = "ValidationAccuracyEvaluator";
-      validationAccuracy.GetVariableInfo("Accuracy").ActualName = ModelingResult.ValidationAccuracy.ToString();
-      validationAccuracy.GetVariableInfo("Values").ActualName = "ValidationValues";
-
-      SimpleAccuracyEvaluator testAccuracy = new SimpleAccuracyEvaluator();
-      testAccuracy.Name = "TestAccuracyEvaluator";
-      testAccuracy.GetVariableInfo("Accuracy").ActualName = ModelingResult.TestAccuracy.ToString();
-      testAccuracy.GetVariableInfo("Values").ActualName = "TestValues";
+      seq.AddSubOperator(DefaultModelAnalyzerOperators.CreatePostProcessingOperator(ModelType.Classification));
 
       SimpleConfusionMatrixEvaluator trainingConfusionMatrixEvaluator = new SimpleConfusionMatrixEvaluator();
@@ -63,7 +48,4 @@
       testConfusionMatrixEvaluator.GetVariableInfo("ConfusionMatrix").ActualName = "TestConfusionMatrix";
 
-      seq.AddSubOperator(trainingAccuracy);
-      seq.AddSubOperator(validationAccuracy);
-      seq.AddSubOperator(testAccuracy);
       seq.AddSubOperator(trainingConfusionMatrixEvaluator);
       seq.AddSubOperator(validationConfusionMatrixEvaluator);
@@ -81,10 +63,5 @@
 
     public static IAnalyzerModel PopulateAnalyzerModel(IScope modelScope, IAnalyzerModel model) {
-      DefaultRegressionOperators.PopulateAnalyzerModel(modelScope, model);
-      model.ExtractResult(modelScope, ModelingResult.TrainingAccuracy);
-      model.ExtractResult(modelScope, ModelingResult.ValidationAccuracy);
-      model.ExtractResult(modelScope, ModelingResult.TestAccuracy);
-      model.Type = ModelType.Classification;
-      return model;
+      return DefaultModelAnalyzerOperators.PopulateAnalyzerModel(modelScope, model, ModelType.Classification);
     }
   }
Index: trunk/sources/HeuristicLab.Modeling/3.2/DefaultModelAnalyzerOperators.cs
===================================================================
--- trunk/sources/HeuristicLab.Modeling/3.2/DefaultModelAnalyzerOperators.cs	(revision 2388)
+++ trunk/sources/HeuristicLab.Modeling/3.2/DefaultModelAnalyzerOperators.cs	(revision 2388)
@@ -0,0 +1,92 @@
+﻿#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 DefaultModelAnalyzerOperators {
+    public static IOperator CreatePostProcessingOperator(ModelType modelType) {
+      CombinedOperator op = new CombinedOperator();
+      op.Name = modelType + " model analyser";
+      SequentialProcessor seq = new SequentialProcessor();
+      var modelingResults = ModelingResultCalculators.GetModelingResult(modelType);
+      foreach (var r in modelingResults.Keys) {
+        seq.AddSubOperator(ModelingResultCalculators.CreateModelingResultEvaluator(r));
+      }
+
+      #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, ModelType modelType) {
+      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.Type = ModelType.Regression;
+      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;
+
+      var modelingResults = ModelingResultCalculators.GetModelingResult(modelType);
+      foreach (var r in modelingResults.Keys) {
+        model.ExtractResult(modelScope, r);
+      }
+
+      ItemList evaluationImpacts = modelScope.GetVariableValue<ItemList>(ModelingResult.VariableEvaluationImpact.ToString(), false);
+      ItemList qualityImpacts = modelScope.GetVariableValue<ItemList>(ModelingResult.VariableQualityImpact.ToString(), false);
+      foreach (ItemList row in evaluationImpacts) {
+        string variableName = ((StringData)row[0]).Data;
+        double impact = ((DoubleData)row[1]).Data;
+        model.SetVariableResult(ModelingResult.VariableEvaluationImpact, variableName, impact);
+        model.AddInputVariable(variableName);
+      }
+      foreach (ItemList row in qualityImpacts) {
+        string variableName = ((StringData)row[0]).Data;
+        double impact = ((DoubleData)row[1]).Data;
+        model.SetVariableResult(ModelingResult.VariableQualityImpact, variableName, impact);
+        model.AddInputVariable(variableName);
+      }
+
+      return model;
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Modeling/3.2/DefaultRegressionOperators.cs
===================================================================
--- trunk/sources/HeuristicLab.Modeling/3.2/DefaultRegressionOperators.cs	(revision 2387)
+++ trunk/sources/HeuristicLab.Modeling/3.2/DefaultRegressionOperators.cs	(revision 2388)
@@ -44,176 +44,9 @@
 
     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 = ModelingResult.TrainingMeanSquaredError.ToString();
-      trainingMseEvaluator.GetVariableInfo("Values").ActualName = "TrainingValues";
-      SimpleMSEEvaluator validationMseEvaluator = new SimpleMSEEvaluator();
-      validationMseEvaluator.Name = "ValidationMseEvaluator";
-      validationMseEvaluator.GetVariableInfo("MSE").ActualName = ModelingResult.ValidationMeanSquaredError.ToString();
-      validationMseEvaluator.GetVariableInfo("Values").ActualName = "ValidationValues";
-      SimpleMSEEvaluator testMseEvaluator = new SimpleMSEEvaluator();
-      testMseEvaluator.Name = "TestMseEvaluator";
-      testMseEvaluator.GetVariableInfo("MSE").ActualName = ModelingResult.TestMeanSquaredError.ToString();
-      testMseEvaluator.GetVariableInfo("Values").ActualName = "TestValues";
-      #endregion
-      #region NMSE
-      SimpleNMSEEvaluator trainingNmseEvaluator = new SimpleNMSEEvaluator();
-      trainingNmseEvaluator.Name = "TrainingNmseEvaluator";
-      trainingNmseEvaluator.GetVariableInfo("NMSE").ActualName = ModelingResult.TrainingNormalizedMeanSquaredError.ToString();
-      trainingNmseEvaluator.GetVariableInfo("Values").ActualName = "TrainingValues";
-      SimpleNMSEEvaluator validationNmseEvaluator = new SimpleNMSEEvaluator();
-      validationNmseEvaluator.Name = "ValidationMseEvaluator";
-      validationNmseEvaluator.GetVariableInfo("NMSE").ActualName = ModelingResult.ValidationNormalizedMeanSquaredError.ToString();
-      validationNmseEvaluator.GetVariableInfo("Values").ActualName = "ValidationValues";
-      SimpleNMSEEvaluator testNmseEvaluator = new SimpleNMSEEvaluator();
-      testNmseEvaluator.Name = "TestNmseEvaluator";
-      testNmseEvaluator.GetVariableInfo("NMSE").ActualName = ModelingResult.TestNormalizedMeanSquaredError.ToString();
-      testNmseEvaluator.GetVariableInfo("Values").ActualName = "TestValues";
-      #endregion
-      #region MAPE
-      SimpleMeanAbsolutePercentageErrorEvaluator trainingMapeEvaluator = new SimpleMeanAbsolutePercentageErrorEvaluator();
-      trainingMapeEvaluator.Name = "TrainingMapeEvaluator";
-      trainingMapeEvaluator.GetVariableInfo("MAPE").ActualName = ModelingResult.TrainingMeanAbsolutePercentageError.ToString();
-      trainingMapeEvaluator.GetVariableInfo("Values").ActualName = "TrainingValues";
-      SimpleMeanAbsolutePercentageErrorEvaluator validationMapeEvaluator = new SimpleMeanAbsolutePercentageErrorEvaluator();
-      validationMapeEvaluator.Name = "ValidationMapeEvaluator";
-      validationMapeEvaluator.GetVariableInfo("MAPE").ActualName = ModelingResult.ValidationMeanAbsolutePercentageError.ToString();
-      validationMapeEvaluator.GetVariableInfo("Values").ActualName = "ValidationValues";
-      SimpleMeanAbsolutePercentageErrorEvaluator testMapeEvaluator = new SimpleMeanAbsolutePercentageErrorEvaluator();
-      testMapeEvaluator.Name = "TestMapeEvaluator";
-      testMapeEvaluator.GetVariableInfo("MAPE").ActualName = ModelingResult.TestMeanAbsolutePercentageError.ToString();
-      testMapeEvaluator.GetVariableInfo("Values").ActualName = "TestValues";
-      #endregion
-      #region MAPRE
-      SimpleMeanAbsolutePercentageOfRangeErrorEvaluator trainingMapreEvaluator = new SimpleMeanAbsolutePercentageOfRangeErrorEvaluator();
-      trainingMapreEvaluator.Name = "TrainingMapreEvaluator";
-      trainingMapreEvaluator.GetVariableInfo("MAPRE").ActualName = ModelingResult.TrainingMeanAbsolutePercentageOfRangeError.ToString();
-      trainingMapreEvaluator.GetVariableInfo("Values").ActualName = "TrainingValues";
-      SimpleMeanAbsolutePercentageOfRangeErrorEvaluator validationMapreEvaluator = new SimpleMeanAbsolutePercentageOfRangeErrorEvaluator();
-      validationMapreEvaluator.Name = "ValidationMapreEvaluator";
-      validationMapreEvaluator.GetVariableInfo("MAPRE").ActualName = ModelingResult.ValidationMeanAbsolutePercentageOfRangeError.ToString();
-      validationMapreEvaluator.GetVariableInfo("Values").ActualName = "ValidationValues";
-      SimpleMeanAbsolutePercentageOfRangeErrorEvaluator testMapreEvaluator = new SimpleMeanAbsolutePercentageOfRangeErrorEvaluator();
-      testMapreEvaluator.Name = "TestMapreEvaluator";
-      testMapreEvaluator.GetVariableInfo("MAPRE").ActualName = ModelingResult.TestMeanAbsolutePercentageOfRangeError.ToString();
-      testMapreEvaluator.GetVariableInfo("Values").ActualName = "TestValues";
-      #endregion MAPRE
-      #region R2
-      SimpleR2Evaluator trainingR2Evaluator = new SimpleR2Evaluator();
-      trainingR2Evaluator.Name = "TrainingR2Evaluator";
-      trainingR2Evaluator.GetVariableInfo("R2").ActualName = ModelingResult.TrainingCoefficientOfDetermination.ToString();
-      trainingR2Evaluator.GetVariableInfo("Values").ActualName = "TrainingValues";
-      SimpleR2Evaluator validationR2Evaluator = new SimpleR2Evaluator();
-      validationR2Evaluator.Name = "ValidationR2Evaluator";
-      validationR2Evaluator.GetVariableInfo("R2").ActualName = ModelingResult.ValidationCoefficientOfDetermination.ToString();
-      validationR2Evaluator.GetVariableInfo("Values").ActualName = "ValidationValues";
-      SimpleR2Evaluator testR2Evaluator = new SimpleR2Evaluator();
-      testR2Evaluator.Name = "TestR2Evaluator";
-      testR2Evaluator.GetVariableInfo("R2").ActualName = ModelingResult.TestCoefficientOfDetermination.ToString();
-      testR2Evaluator.GetVariableInfo("Values").ActualName = "TestValues";
-      #endregion
-      #region VAF
-      SimpleVarianceAccountedForEvaluator trainingVAFEvaluator = new SimpleVarianceAccountedForEvaluator();
-      trainingVAFEvaluator.Name = "TrainingVAFEvaluator";
-      trainingVAFEvaluator.GetVariableInfo("VAF").ActualName = ModelingResult.TrainingVarianceAccountedFor.ToString();
-      trainingVAFEvaluator.GetVariableInfo("Values").ActualName = "TrainingValues";
-      SimpleVarianceAccountedForEvaluator validationVAFEvaluator = new SimpleVarianceAccountedForEvaluator();
-      validationVAFEvaluator.Name = "ValidationVAFEvaluator";
-      validationVAFEvaluator.GetVariableInfo("VAF").ActualName = ModelingResult.ValidationVarianceAccountedFor.ToString();
-      validationVAFEvaluator.GetVariableInfo("Values").ActualName = "ValidationValues";
-      SimpleVarianceAccountedForEvaluator testVAFEvaluator = new SimpleVarianceAccountedForEvaluator();
-      testVAFEvaluator.Name = "TestVAFEvaluator";
-      testVAFEvaluator.GetVariableInfo("VAF").ActualName = ModelingResult.TestVarianceAccountedFor.ToString();
-      testVAFEvaluator.GetVariableInfo("Values").ActualName = "TestValues";
-      #endregion
-
-      seq.AddSubOperator(trainingMseEvaluator);
-      seq.AddSubOperator(validationMseEvaluator);
-      seq.AddSubOperator(testMseEvaluator);
-      seq.AddSubOperator(trainingNmseEvaluator);
-      seq.AddSubOperator(validationNmseEvaluator);
-      seq.AddSubOperator(testNmseEvaluator);
-      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;
+      return DefaultModelAnalyzerOperators.CreatePostProcessingOperator(ModelType.Regression);
     }
 
     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.Type = ModelType.Regression;
-      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.ExtractResult(modelScope, ModelingResult.TrainingMeanSquaredError);
-      model.ExtractResult(modelScope, ModelingResult.ValidationMeanSquaredError);
-      model.ExtractResult(modelScope, ModelingResult.TestMeanSquaredError);
-      model.ExtractResult(modelScope, ModelingResult.TrainingNormalizedMeanSquaredError);
-      model.ExtractResult(modelScope, ModelingResult.ValidationNormalizedMeanSquaredError);
-      model.ExtractResult(modelScope, ModelingResult.TestNormalizedMeanSquaredError);
-      model.ExtractResult(modelScope, ModelingResult.TrainingMeanAbsolutePercentageError);
-      model.ExtractResult(modelScope, ModelingResult.ValidationMeanAbsolutePercentageError);
-      model.ExtractResult(modelScope, ModelingResult.TestMeanAbsolutePercentageError);
-      model.ExtractResult(modelScope, ModelingResult.TrainingMeanAbsolutePercentageOfRangeError);
-      model.ExtractResult(modelScope, ModelingResult.ValidationMeanAbsolutePercentageOfRangeError);
-      model.ExtractResult(modelScope, ModelingResult.TestMeanAbsolutePercentageOfRangeError);
-      model.ExtractResult(modelScope, ModelingResult.TrainingCoefficientOfDetermination);
-      model.ExtractResult(modelScope, ModelingResult.ValidationCoefficientOfDetermination);
-      model.ExtractResult(modelScope, ModelingResult.TestCoefficientOfDetermination);
-      model.ExtractResult(modelScope, ModelingResult.TrainingVarianceAccountedFor);
-      model.ExtractResult(modelScope, ModelingResult.ValidationVarianceAccountedFor);
-      model.ExtractResult(modelScope, ModelingResult.TestVarianceAccountedFor);
-
-      ItemList evaluationImpacts = modelScope.GetVariableValue<ItemList>(ModelingResult.VariableEvaluationImpact.ToString(), false);
-      ItemList qualityImpacts = modelScope.GetVariableValue<ItemList>(ModelingResult.VariableQualityImpact.ToString(), false);
-      foreach (ItemList row in evaluationImpacts) {
-        string variableName = ((StringData)row[0]).Data;
-        double impact = ((DoubleData)row[1]).Data;
-        model.SetVariableResult(ModelingResult.VariableEvaluationImpact, variableName, impact);
-        model.AddInputVariable(variableName);
-      }
-      foreach (ItemList row in qualityImpacts) {
-        string variableName = ((StringData)row[0]).Data;
-        double impact = ((DoubleData)row[1]).Data;
-        model.SetVariableResult(ModelingResult.VariableQualityImpact, variableName, impact);
-        model.AddInputVariable(variableName);
-      }
-
-      return model;
+      return DefaultModelAnalyzerOperators.PopulateAnalyzerModel(modelScope, model, ModelType.Regression);
     }
   }
Index: trunk/sources/HeuristicLab.Modeling/3.2/DefaultTimeSeriesOperators.cs
===================================================================
--- trunk/sources/HeuristicLab.Modeling/3.2/DefaultTimeSeriesOperators.cs	(revision 2387)
+++ trunk/sources/HeuristicLab.Modeling/3.2/DefaultTimeSeriesOperators.cs	(revision 2388)
@@ -39,85 +39,9 @@
 
     public static IOperator CreatePostProcessingOperator() {
-      CombinedOperator op = new CombinedOperator();
-      op.Name = "Time series prognosis model analyzer";
-
-      SequentialProcessor seq = new SequentialProcessor();
-      seq.AddSubOperator(DefaultRegressionOperators.CreatePostProcessingOperator());
-
-      #region theil inequality
-      SimpleTheilInequalityCoefficientEvaluator trainingTheil = new SimpleTheilInequalityCoefficientEvaluator();
-      trainingTheil.Name = "TrainingTheilInequalityEvaluator";
-      trainingTheil.GetVariableInfo("Values").ActualName = "TrainingValues";
-      trainingTheil.GetVariableInfo("TheilInequalityCoefficient").ActualName = ModelingResult.TrainingTheilInequality.ToString();
-      SimpleTheilInequalityCoefficientEvaluator validationTheil = new SimpleTheilInequalityCoefficientEvaluator();
-      validationTheil.Name = "ValidationTheilInequalityEvaluator";
-      validationTheil.GetVariableInfo("Values").ActualName = "ValidationValues";
-      validationTheil.GetVariableInfo("TheilInequalityCoefficient").ActualName = ModelingResult.ValidationTheilInequality.ToString();
-      SimpleTheilInequalityCoefficientEvaluator testTheil = new SimpleTheilInequalityCoefficientEvaluator();
-      testTheil.Name = "TestTheilInequalityEvaluator";
-      testTheil.GetVariableInfo("Values").ActualName = "TestValues";
-      testTheil.GetVariableInfo("TheilInequalityCoefficient").ActualName = ModelingResult.TestTheilInequality.ToString();
-
-      seq.AddSubOperator(trainingTheil);
-      seq.AddSubOperator(validationTheil);
-      seq.AddSubOperator(testTheil);
-      #endregion
-
-      #region directional symmetry
-      SimpleDirectionalSymmetryEvaluator trainingDS = new SimpleDirectionalSymmetryEvaluator();
-      trainingDS.Name = "TrainingDirectionalSymmetryEvaluator";
-      trainingDS.GetVariableInfo("Values").ActualName = "TrainingValues";
-      trainingDS.GetVariableInfo("DirectionalSymmetry").ActualName = ModelingResult.TrainingDirectionalSymmetry.ToString();
-      SimpleDirectionalSymmetryEvaluator validationDS = new SimpleDirectionalSymmetryEvaluator();
-      validationDS.Name = "ValidationDirectionalSymmetryEvaluator";
-      validationDS.GetVariableInfo("Values").ActualName = "ValidationValues";
-      validationDS.GetVariableInfo("DirectionalSymmetry").ActualName = ModelingResult.ValidationDirectionalSymmetry.ToString();
-      SimpleDirectionalSymmetryEvaluator testDS = new SimpleDirectionalSymmetryEvaluator();
-      testDS.Name = "TestDirectionalSymmetryEvaluator";
-      testDS.GetVariableInfo("Values").ActualName = "TestValues";
-      testDS.GetVariableInfo("DirectionalSymmetry").ActualName = ModelingResult.TestDirectionalSymmetry.ToString();
-
-      seq.AddSubOperator(trainingDS);
-      seq.AddSubOperator(validationDS);
-      seq.AddSubOperator(testDS);
-      #endregion
-
-      #region weighted directional symmetry
-      SimpleWeightedDirectionalSymmetryEvaluator trainingWDS = new SimpleWeightedDirectionalSymmetryEvaluator();
-      trainingWDS.Name = "TrainingWeightedDirectionalSymmetryEvaluator";
-      trainingWDS.GetVariableInfo("Values").ActualName = "TrainingValues";
-      trainingWDS.GetVariableInfo("WeightedDirectionalSymmetry").ActualName = ModelingResult.TrainingWeightedDirectionalSymmetry.ToString();
-      SimpleWeightedDirectionalSymmetryEvaluator validationWDS = new SimpleWeightedDirectionalSymmetryEvaluator();
-      validationWDS.Name = "ValidationWeightedDirectionalSymmetryEvaluator";
-      validationWDS.GetVariableInfo("Values").ActualName = "ValidationValues";
-      validationWDS.GetVariableInfo("WeightedDirectionalSymmetry").ActualName = ModelingResult.ValidationWeightedDirectionalSymmetry.ToString();
-      SimpleWeightedDirectionalSymmetryEvaluator testWDS = new SimpleWeightedDirectionalSymmetryEvaluator();
-      testWDS.Name = "TestWeightedDirectionalSymmetryEvaluator";
-      testWDS.GetVariableInfo("Values").ActualName = "TestValues";
-      testWDS.GetVariableInfo("WeightedDirectionalSymmetry").ActualName = ModelingResult.TestWeightedDirectionalSymmetry.ToString();
-
-      seq.AddSubOperator(trainingWDS);
-      seq.AddSubOperator(validationWDS);
-      seq.AddSubOperator(testWDS);
-      #endregion
-
-      op.OperatorGraph.AddOperator(seq);
-      op.OperatorGraph.InitialOperator = seq;
-      return op;
+      return DefaultModelAnalyzerOperators.CreatePostProcessingOperator(ModelType.TimeSeriesPrognosis);
     }
 
     public static IAnalyzerModel PopulateAnalyzerModel(IScope modelScope, IAnalyzerModel model) {
-      DefaultRegressionOperators.PopulateAnalyzerModel(modelScope, model);
-      model.ExtractResult(modelScope, ModelingResult.TrainingTheilInequality);
-      model.ExtractResult(modelScope, ModelingResult.ValidationTheilInequality);
-      model.ExtractResult(modelScope, ModelingResult.TestTheilInequality);
-      model.ExtractResult(modelScope, ModelingResult.TrainingDirectionalSymmetry);
-      model.ExtractResult(modelScope, ModelingResult.ValidationDirectionalSymmetry);
-      model.ExtractResult(modelScope, ModelingResult.TestDirectionalSymmetry);
-      model.ExtractResult(modelScope, ModelingResult.TrainingWeightedDirectionalSymmetry);
-      model.ExtractResult(modelScope, ModelingResult.ValidationWeightedDirectionalSymmetry);
-      model.ExtractResult(modelScope, ModelingResult.TestWeightedDirectionalSymmetry);
-      model.Type = ModelType.TimeSeriesPrognosis;
-      return model;
+      return DefaultModelAnalyzerOperators.PopulateAnalyzerModel(modelScope, model, ModelType.TimeSeriesPrognosis);
     }
   }
Index: trunk/sources/HeuristicLab.Modeling/3.2/HeuristicLab.Modeling-3.2.csproj
===================================================================
--- trunk/sources/HeuristicLab.Modeling/3.2/HeuristicLab.Modeling-3.2.csproj	(revision 2387)
+++ trunk/sources/HeuristicLab.Modeling/3.2/HeuristicLab.Modeling-3.2.csproj	(revision 2388)
@@ -84,4 +84,5 @@
     <Compile Include="AnalyzerModel.cs" />
     <Compile Include="BestSolutionStorer.cs" />
+    <Compile Include="DefaultModelAnalyzerOperators.cs" />
     <Compile Include="Matrix.cs" />
     <Compile Include="ModelingResultCalculators.cs" />
Index: trunk/sources/HeuristicLab.Modeling/3.2/ModelingResultCalculators.cs
===================================================================
--- trunk/sources/HeuristicLab.Modeling/3.2/ModelingResultCalculators.cs	(revision 2387)
+++ trunk/sources/HeuristicLab.Modeling/3.2/ModelingResultCalculators.cs	(revision 2388)
@@ -24,13 +24,103 @@
 using System.Linq;
 using System.Text;
+using HeuristicLab.Core;
 
 namespace HeuristicLab.Modeling {
   public abstract class ModelingResultCalculators {
+    private enum DatasetPart { Training, Validation, Test };
+
     private static readonly Dictionary<ModelingResult, Func<double[,], double>> ClassificationModelingResults;
     private static readonly Dictionary<ModelingResult, Func<double[,], double>> RegressionModelingResults;
     private static readonly Dictionary<ModelingResult, Func<double[,], double>> TimeSeriesPrognosisModelingResults;
+    private static readonly Dictionary<ModelingResult, IOperator> ClassificationModelingResultEvaluators;
+    private static readonly Dictionary<ModelingResult, IOperator> RegressionModelingResultEvaluators;
+    private static readonly Dictionary<ModelingResult, IOperator> TimeSeriesPrognosisModelingResultEvaluators;
+
+    private static readonly Dictionary<Type, IEnumerable<ModelingResult>> regressionResults =
+      new Dictionary<Type, IEnumerable<ModelingResult>>() {
+        { typeof(SimpleMSEEvaluator), 
+          new ModelingResult[] { 
+            ModelingResult.TrainingMeanSquaredError, 
+            ModelingResult.ValidationMeanSquaredError,
+            ModelingResult.TestMeanSquaredError
+          }},
+        { typeof(SimpleNMSEEvaluator), 
+          new ModelingResult[] {
+            ModelingResult.TrainingNormalizedMeanSquaredError,
+            ModelingResult.ValidationNormalizedMeanSquaredError,
+            ModelingResult.TestNormalizedMeanSquaredError
+          }
+        },
+        { typeof(SimpleR2Evaluator),
+          new ModelingResult[] {
+            ModelingResult.TrainingCoefficientOfDetermination,
+            ModelingResult.ValidationCoefficientOfDetermination,
+            ModelingResult.TestCoefficientOfDetermination
+          }
+        },
+        { typeof(SimpleVarianceAccountedForEvaluator),
+          new ModelingResult[] {
+            ModelingResult.TrainingVarianceAccountedFor,
+            ModelingResult.ValidationVarianceAccountedFor,
+            ModelingResult.TestVarianceAccountedFor
+          }
+        },
+        { typeof(SimpleMeanAbsolutePercentageErrorEvaluator),
+          new ModelingResult[] {
+            ModelingResult.TrainingMeanAbsolutePercentageError,
+            ModelingResult.ValidationMeanAbsolutePercentageError,
+            ModelingResult.TestMeanAbsolutePercentageError
+          }
+        },
+        { typeof(SimpleMeanAbsolutePercentageOfRangeErrorEvaluator),
+          new ModelingResult[] {
+            ModelingResult.TrainingMeanAbsolutePercentageOfRangeError,
+            ModelingResult.ValidationMeanAbsolutePercentageOfRangeError,
+            ModelingResult.TestMeanAbsolutePercentageOfRangeError
+          }
+        }
+      };
+
+    private static readonly Dictionary<Type, IEnumerable<ModelingResult>> timeSeriesResults =
+      new Dictionary<Type, IEnumerable<ModelingResult>>() {
+        { typeof(SimpleTheilInequalityCoefficientEvaluator),
+          new ModelingResult[] {
+            ModelingResult.TrainingTheilInequality,
+            ModelingResult.ValidationTheilInequality,
+            ModelingResult.TestTheilInequality
+          }
+        },
+        { typeof(SimpleDirectionalSymmetryEvaluator),
+          new ModelingResult[] {
+            ModelingResult.TrainingDirectionalSymmetry,
+            ModelingResult.ValidationDirectionalSymmetry,
+            ModelingResult.TestDirectionalSymmetry
+          }
+        },
+        { typeof(SimpleWeightedDirectionalSymmetryEvaluator),
+          new ModelingResult[] {
+            ModelingResult.TrainingWeightedDirectionalSymmetry,
+            ModelingResult.ValidationWeightedDirectionalSymmetry,
+            ModelingResult.TestWeightedDirectionalSymmetry
+          }
+        }
+      };
+
+    private static readonly Dictionary<Type, IEnumerable<ModelingResult>> classificationResults =
+      new Dictionary<Type, IEnumerable<ModelingResult>>() {
+        { typeof(SimpleAccuracyEvaluator),
+          new ModelingResult[] {
+            ModelingResult.TrainingAccuracy,
+            ModelingResult.ValidationAccuracy,
+            ModelingResult.TestAccuracy
+          }
+        }
+      };
+
 
     static ModelingResultCalculators() {
       RegressionModelingResults = new Dictionary<ModelingResult, Func<double[,], double>>();
+      ClassificationModelingResults = new Dictionary<ModelingResult, Func<double[,], double>>();
+      TimeSeriesPrognosisModelingResults = new Dictionary<ModelingResult, Func<double[,], double>>();
 
       //Mean squared errors
@@ -83,24 +173,44 @@
       TimeSeriesPrognosisModelingResults[ModelingResult.ValidationWeightedDirectionalSymmetry] = SimpleWeightedDirectionalSymmetryEvaluator.Calculate;
       TimeSeriesPrognosisModelingResults[ModelingResult.TestWeightedDirectionalSymmetry] = SimpleWeightedDirectionalSymmetryEvaluator.Calculate;
+
+      #region result evaluators
+
+      RegressionModelingResultEvaluators = new Dictionary<ModelingResult, IOperator>();
+      foreach (Type evaluatorT in regressionResults.Keys) {
+        foreach (ModelingResult r in regressionResults[evaluatorT]) {
+          RegressionModelingResultEvaluators[r] = CreateEvaluator(evaluatorT, r);
+        }
+      }
+
+      timeSeriesResults = CombineDictionaries(regressionResults, timeSeriesResults);
+      TimeSeriesPrognosisModelingResultEvaluators = new Dictionary<ModelingResult, IOperator>();
+      foreach (Type evaluatorT in timeSeriesResults.Keys) {
+        foreach (ModelingResult r in timeSeriesResults[evaluatorT]) {
+          TimeSeriesPrognosisModelingResultEvaluators[r] = CreateEvaluator(evaluatorT, r);
+        }
+      }
+
+      classificationResults = CombineDictionaries(regressionResults, classificationResults);
+      ClassificationModelingResultEvaluators = new Dictionary<ModelingResult, IOperator>();
+      foreach (Type evaluatorT in classificationResults.Keys) {
+        foreach (ModelingResult r in classificationResults[evaluatorT]) {
+          ClassificationModelingResultEvaluators[r] = CreateEvaluator(evaluatorT, r);
+        }
+      }
+
+      #endregion
     }
 
     public static Dictionary<ModelingResult, Func<double[,], double>> GetModelingResult(ModelType modelType) {
-      IEnumerable<KeyValuePair<ModelingResult,Func<double[,],double>>> ret = new Dictionary<ModelingResult,Func<double[,],double>>();
       switch (modelType) {
         case ModelType.Regression:
-          ret = ret.Union( RegressionModelingResults);
-          break;
+          return CombineDictionaries(RegressionModelingResults, new Dictionary<ModelingResult, Func<double[,], double>>());
         case ModelType.Classification:
-          ret = ret.Union(RegressionModelingResults);
-          ret = ret.Union(ClassificationModelingResults);
-          break;
+          return CombineDictionaries(RegressionModelingResults, ClassificationModelingResults);
         case ModelType.TimeSeriesPrognosis:
-          ret = ret.Union(RegressionModelingResults);
-          ret = ret.Union(TimeSeriesPrognosisModelingResults);
-          break;
+          return CombineDictionaries(RegressionModelingResults, ClassificationModelingResults);
         default:
-          throw new ArgumentException("Modeling result mapping for ModelType " + modelType + " not defined.");          
-      }
-      return ret.ToDictionary<KeyValuePair<ModelingResult, Func<double[,], double>>, ModelingResult, Func<double[,], double>>(x => x.Key, x => x.Value);
+          throw new ArgumentException("Modeling result mapping for ModelType " + modelType + " not defined.");
+      }
     }
 
@@ -113,5 +223,39 @@
         return TimeSeriesPrognosisModelingResults[modelingResult];
       else
-        throw new ArgumentException("Calculator for modeling reuslt " + modelingResult + " not defined.");
+        throw new ArgumentException("Calculator for modeling result " + modelingResult + " not defined.");
+    }
+
+    public static IOperator CreateModelingResultEvaluator(ModelingResult modelingResult) {
+      IOperator opTemplate = null;
+      if (RegressionModelingResultEvaluators.ContainsKey(modelingResult))
+        opTemplate = RegressionModelingResultEvaluators[modelingResult];
+      else if (ClassificationModelingResultEvaluators.ContainsKey(modelingResult))
+        opTemplate = ClassificationModelingResultEvaluators[modelingResult];
+      else if (TimeSeriesPrognosisModelingResultEvaluators.ContainsKey(modelingResult))
+        opTemplate = TimeSeriesPrognosisModelingResultEvaluators[modelingResult];
+      else
+        throw new ArgumentException("Evaluator for modeling result " + modelingResult + " not defined.");
+      return (IOperator)opTemplate.Clone();
+    }
+
+    private static IOperator CreateEvaluator(Type evaluatorType, ModelingResult result) {
+      SimpleEvaluatorBase evaluator = (SimpleEvaluatorBase)Activator.CreateInstance(evaluatorType);
+      evaluator.GetVariableInfo("Values").ActualName = GetDatasetPart(result) + "Values";
+      evaluator.GetVariableInfo(evaluator.OutputVariableName).ActualName = result.ToString();
+      return evaluator;
+    }
+
+    private static DatasetPart GetDatasetPart(ModelingResult result) {
+      if (result.ToString().StartsWith("Training")) return DatasetPart.Training;
+      else if (result.ToString().StartsWith("Validation")) return DatasetPart.Validation;
+      else if (result.ToString().StartsWith("Test")) return DatasetPart.Test;
+      else throw new ArgumentException("Can't determine dataset part of modeling result " + result + ".");
+    }
+
+    private static Dictionary<T1, T2> CombineDictionaries<T1, T2>(
+      Dictionary<T1, T2> x,
+      Dictionary<T1, T2> y) {
+      Dictionary<T1, T2> result = new Dictionary<T1, T2>(x);
+      return x.Union(y).ToDictionary<KeyValuePair<T1, T2>, T1, T2>(p => p.Key, p => p.Value);
     }
   }
