Index: trunk/sources/HeuristicLab.GP.StructureIdentification.Classification/3.3/AccuracyEvaluator.cs
===================================================================
--- trunk/sources/HeuristicLab.GP.StructureIdentification.Classification/3.3/AccuracyEvaluator.cs	(revision 2350)
+++ 	(revision )
@@ -1,72 +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 System;
-using HeuristicLab.Core;
-using HeuristicLab.Data;
-using HeuristicLab.DataAnalysis;
-
-namespace HeuristicLab.GP.StructureIdentification.Classification {
-  public class AccuracyEvaluator : GPClassificationEvaluatorBase {
-    private const double EPSILON = 1.0E-6;
-    public override string Description {
-      get {
-        return @"Calculates the total accuracy of the model (ratio of correctly classified instances to total number of instances) given a model and the list of possible target class values.";
-      }
-    }
-
-    public AccuracyEvaluator()
-      : base() {
-      AddVariableInfo(new VariableInfo("Accuracy", "The total accuracy of the model (ratio of correctly classified instances to total number of instances)", typeof(DoubleData), VariableKind.New));
-    }
-
-    public override void Evaluate(IScope scope, ITreeEvaluator evaluator, Dataset dataset, int targetVariable, double[] classes, double[] thresholds, int start, int end) {
-      DoubleData accuracy = GetVariableValue<DoubleData>("Accuracy", scope, false, false);
-      if (accuracy == null) {
-        accuracy = new DoubleData();
-        scope.AddVariable(new HeuristicLab.Core.Variable(scope.TranslateName("Accuracy"), accuracy));
-      }
-
-      int nSamples = end - start;
-      int nCorrect = 0;
-      for (int sample = start; sample < end; sample++) {
-        double est = evaluator.Evaluate(sample);
-        double origClass = dataset.GetValue(sample, targetVariable);
-        double estClass = double.NaN;
-        // if estimation is lower than the smallest threshold value -> estimated class is the lower class
-        if (est < thresholds[0]) estClass = classes[0];
-        // if estimation is larger (or equal) than the largest threshold value -> estimated class is the upper class
-        else if (est >= thresholds[thresholds.Length - 1]) estClass = classes[classes.Length - 1];
-        else {
-          // otherwise the estimated class is the class which upper threshold is larger than the estimated value
-          for (int k = 0; k < thresholds.Length; k++) {
-            if (thresholds[k] > est) {
-              estClass = classes[k];
-              break;
-            }
-          }
-        }
-        if (Math.Abs(estClass - origClass) < EPSILON) nCorrect++;
-      }
-      accuracy.Data = nCorrect / (double)nSamples;
-    }
-  }
-}
Index: trunk/sources/HeuristicLab.GP.StructureIdentification.Classification/3.3/ConfusionMatrixEvaluator.cs
===================================================================
--- trunk/sources/HeuristicLab.GP.StructureIdentification.Classification/3.3/ConfusionMatrixEvaluator.cs	(revision 2350)
+++ 	(revision )
@@ -1,76 +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.Data;
-
-namespace HeuristicLab.GP.StructureIdentification.Classification {
-  public class ConfusionMatrixEvaluator : GPClassificationEvaluatorBase {
-    public override string Description {
-      get {
-        return @"Calculates the classifcation matrix of the model.";
-      }
-    }
-
-    public ConfusionMatrixEvaluator()
-      : base() {
-      AddVariableInfo(new VariableInfo("ConfusionMatrix", "The confusion matrix of the model", typeof(IntMatrixData), VariableKind.New));
-    }
-
-    public override void Evaluate(IScope scope, ITreeEvaluator evaluator, HeuristicLab.DataAnalysis.Dataset dataset, int targetVariable, double[] classes, double[] thresholds, int start, int end) {
-      IntMatrixData matrix = GetVariableValue<IntMatrixData>("ConfusionMatrix", scope, false, false);
-      if (matrix == null) {
-        matrix = new IntMatrixData(new int[classes.Length, classes.Length]);
-        scope.AddVariable(new HeuristicLab.Core.Variable(scope.TranslateName("ConfusionMatrix"), matrix));
-      }
-
-      int nSamples = end - start;
-      for (int sample = start; sample < end; sample++) {
-        double est = evaluator.Evaluate(sample);
-        double origClass = dataset.GetValue(sample, targetVariable);
-        int estClassIndex = -1;
-        // if estimation is lower than the smallest threshold value -> estimated class is the lower class
-        if (est < thresholds[0]) estClassIndex = 0;
-        // if estimation is larger (or equal) than the largest threshold value -> estimated class is the upper class
-        else if (est >= thresholds[thresholds.Length - 1]) estClassIndex = classes.Length - 1;
-        else {
-          // otherwise the estimated class is the class which upper threshold is larger than the estimated value
-          for (int k = 0; k < thresholds.Length; k++) {
-            if (thresholds[k] > est) {
-              estClassIndex = k;
-              break;
-            }
-          }
-        }
-
-        // find the first threshold index that is larger to the original value
-        int origClassIndex = classes.Length - 1;
-        for (int i = 0; i < thresholds.Length; i++) {
-          if (origClass < thresholds[i]) {
-            origClassIndex = i;
-            break;
-          }
-        }
-        matrix.Data[origClassIndex, estClassIndex]++;
-      }
-    }
-  }
-}
Index: trunk/sources/HeuristicLab.GP.StructureIdentification.Classification/3.3/DefaultClassificationAlgorithmOperators.cs
===================================================================
--- trunk/sources/HeuristicLab.GP.StructureIdentification.Classification/3.3/DefaultClassificationAlgorithmOperators.cs	(revision 2350)
+++ trunk/sources/HeuristicLab.GP.StructureIdentification.Classification/3.3/DefaultClassificationAlgorithmOperators.cs	(revision 2351)
@@ -37,21 +37,18 @@
       subScopesProc.AddSubOperator(individualProc);
       seq.AddSubOperator(subScopesProc);
-      AccuracyEvaluator trainingAccuracy = new AccuracyEvaluator();
+      SimpleAccuracyEvaluator trainingAccuracy = new SimpleAccuracyEvaluator();
       trainingAccuracy.Name = "TrainingAccuracyEvaluator";
       trainingAccuracy.GetVariableInfo("Accuracy").ActualName = "TrainingAccuracy";
-      trainingAccuracy.GetVariableInfo("SamplesStart").ActualName = "TrainingSamplesStart";
-      trainingAccuracy.GetVariableInfo("SamplesEnd").ActualName = "TrainingSamplesEnd";
+      trainingAccuracy.GetVariableInfo("Values").ActualName = "TrainingValues";
 
-      AccuracyEvaluator validationAccuracy = new AccuracyEvaluator();
+      SimpleAccuracyEvaluator validationAccuracy = new SimpleAccuracyEvaluator();
       validationAccuracy.Name = "ValidationAccuracyEvaluator";
       validationAccuracy.GetVariableInfo("Accuracy").ActualName = "ValidationAccuracy";
-      validationAccuracy.GetVariableInfo("SamplesStart").ActualName = "ValidationSamplesStart";
-      validationAccuracy.GetVariableInfo("SamplesEnd").ActualName = "ValidationSamplesEnd";
+      validationAccuracy.GetVariableInfo("Values").ActualName = "ValidationValues";
 
-      AccuracyEvaluator testAccuracy = new AccuracyEvaluator();
+      SimpleAccuracyEvaluator testAccuracy = new SimpleAccuracyEvaluator();
       testAccuracy.Name = "TestAccuracyEvaluator";
       testAccuracy.GetVariableInfo("Accuracy").ActualName = "TestAccuracy";
-      testAccuracy.GetVariableInfo("SamplesStart").ActualName = "TestSamplesStart";
-      testAccuracy.GetVariableInfo("SamplesEnd").ActualName = "TestSamplesEnd";
+      testAccuracy.GetVariableInfo("Values").ActualName = "TestValues";
 
       individualProc.AddSubOperator(trainingAccuracy);
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 2350)
+++ trunk/sources/HeuristicLab.GP.StructureIdentification.Classification/3.3/HeuristicLab.GP.StructureIdentification.Classification-3.3.csproj	(revision 2351)
@@ -80,8 +80,5 @@
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="AccuracyEvaluator.cs" />
     <Compile Include="ClassificationMeanSquaredErrorEvaluator.cs" />
-    <Compile Include="ConfusionMatrixEvaluator.cs" />
-    <Compile Include="TargetClassesCalculator.cs" />
     <Compile Include="DefaultClassificationAlgorithmOperators.cs" />
     <Compile Include="GPClassificationEvaluatorBase.cs" />
Index: trunk/sources/HeuristicLab.GP.StructureIdentification.Classification/3.3/TargetClassesCalculator.cs
===================================================================
--- trunk/sources/HeuristicLab.GP.StructureIdentification.Classification/3.3/TargetClassesCalculator.cs	(revision 2350)
+++ 	(revision )
@@ -1,51 +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 System;
-using HeuristicLab.Core;
-using HeuristicLab.Data;
-using HeuristicLab.DataAnalysis;
-using System.Linq;
-
-namespace HeuristicLab.GP.StructureIdentification.Classification {
-  public class TargetClassesCalculator : OperatorBase {
-
-    public TargetClassesCalculator()
-      : base() {
-      AddVariableInfo(new VariableInfo("Dataset", "The dataset", typeof(Dataset), VariableKind.In));
-      AddVariableInfo(new VariableInfo("TargetVariable", "Index of the target variable", typeof(IntData), VariableKind.In));
-      AddVariableInfo(new VariableInfo("TargetClassValues", "The original class values of target variable (for instance negative=0 and positive=1).", typeof(ItemList<DoubleData>), VariableKind.New));
-    }
-
-    public override IOperation Apply(IScope scope) {
-      Dataset dataset = GetVariableValue<Dataset>("Dataset", scope, true);
-      int targetVariable = GetVariableValue<IntData>("TargetVariable", scope, true).Data;
-
-      ItemList<DoubleData> classes = new ItemList<DoubleData>();
-      foreach(double x in dataset.GetVariableValues(targetVariable).Distinct().OrderBy(v=>v)) {
-        classes.Add(new DoubleData(x));
-      }
-
-      scope.AddVariable(new HeuristicLab.Core.Variable(scope.TranslateName("TargetClassValues"), classes));
-      return null;
-    }
-  }
-}
Index: trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/DefaultStructureIdentificationOperators.cs
===================================================================
--- trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/DefaultStructureIdentificationOperators.cs	(revision 2350)
+++ trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/DefaultStructureIdentificationOperators.cs	(revision 2351)
@@ -126,106 +126,99 @@
       evaluatorInjector.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
 
+      #region simple evaluators
+      SimpleEvaluator trainingEvaluator = new SimpleEvaluator();
+      trainingEvaluator.Name = "TrainingEvaluator";
+      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("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("SamplesStart").ActualName = "TestSamplesStart";
+      testEvaluator.GetVariableInfo("SamplesEnd").ActualName = "TestSamplesEnd";
+      testEvaluator.GetVariableInfo("Values").ActualName = "TestValues";
+      testEvaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
+      #endregion
       #region MSE
-      MeanSquaredErrorEvaluator trainingMseEvaluator = new MeanSquaredErrorEvaluator();
+      SimpleMSEEvaluator trainingMseEvaluator = new SimpleMSEEvaluator();
       trainingMseEvaluator.Name = "TrainingMseEvaluator";
-      trainingMseEvaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
       trainingMseEvaluator.GetVariableInfo("MSE").ActualName = "TrainingMSE";
-      trainingMseEvaluator.GetVariableInfo("SamplesStart").ActualName = "TrainingSamplesStart";
-      trainingMseEvaluator.GetVariableInfo("SamplesEnd").ActualName = "TrainingSamplesEnd";
-      MeanSquaredErrorEvaluator validationMseEvaluator = new MeanSquaredErrorEvaluator();
+      trainingMseEvaluator.GetVariableInfo("Values").ActualName = "TrainingValues";
+      SimpleMSEEvaluator validationMseEvaluator = new SimpleMSEEvaluator();
       validationMseEvaluator.Name = "ValidationMseEvaluator";
-      validationMseEvaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
       validationMseEvaluator.GetVariableInfo("MSE").ActualName = "ValidationMSE";
-      validationMseEvaluator.GetVariableInfo("SamplesStart").ActualName = "ValidationSamplesStart";
-      validationMseEvaluator.GetVariableInfo("SamplesEnd").ActualName = "ValidationSamplesEnd";
-      MeanSquaredErrorEvaluator testMseEvaluator = new MeanSquaredErrorEvaluator();
-      testMseEvaluator.Name = "TestMeanSquaredErrorEvaluator";
-      testMseEvaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
+      validationMseEvaluator.GetVariableInfo("Values").ActualName = "ValidationValues";
+      SimpleMSEEvaluator testMseEvaluator = new SimpleMSEEvaluator();
+      testMseEvaluator.Name = "TestMseEvaluator";
       testMseEvaluator.GetVariableInfo("MSE").ActualName = "TestMSE";
-      testMseEvaluator.GetVariableInfo("SamplesStart").ActualName = "TestSamplesStart";
-      testMseEvaluator.GetVariableInfo("SamplesEnd").ActualName = "TestSamplesEnd";
+      testMseEvaluator.GetVariableInfo("Values").ActualName = "TestValues";
       #endregion
       #region MAPE
-      MeanAbsolutePercentageErrorEvaluator trainingMapeEvaluator = new MeanAbsolutePercentageErrorEvaluator();
+      SimpleMeanAbsolutePercentageErrorEvaluator trainingMapeEvaluator = new SimpleMeanAbsolutePercentageErrorEvaluator();
       trainingMapeEvaluator.Name = "TrainingMapeEvaluator";
-      trainingMapeEvaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
       trainingMapeEvaluator.GetVariableInfo("MAPE").ActualName = "TrainingMAPE";
-      trainingMapeEvaluator.GetVariableInfo("SamplesStart").ActualName = "TrainingSamplesStart";
-      trainingMapeEvaluator.GetVariableInfo("SamplesEnd").ActualName = "TrainingSamplesEnd";
-      MeanAbsolutePercentageErrorEvaluator validationMapeEvaluator = new MeanAbsolutePercentageErrorEvaluator();
-      validationMapeEvaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
+      trainingMapeEvaluator.GetVariableInfo("Values").ActualName = "TrainingValues";
+      SimpleMeanAbsolutePercentageErrorEvaluator validationMapeEvaluator = new SimpleMeanAbsolutePercentageErrorEvaluator();
       validationMapeEvaluator.Name = "ValidationMapeEvaluator";
       validationMapeEvaluator.GetVariableInfo("MAPE").ActualName = "ValidationMAPE";
-      validationMapeEvaluator.GetVariableInfo("SamplesStart").ActualName = "ValidationSamplesStart";
-      validationMapeEvaluator.GetVariableInfo("SamplesEnd").ActualName = "ValidationSamplesEnd";
-      MeanAbsolutePercentageErrorEvaluator testMapeEvaluator = new MeanAbsolutePercentageErrorEvaluator();
-      testMapeEvaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
+      validationMapeEvaluator.GetVariableInfo("Values").ActualName = "ValidationValues";
+      SimpleMeanAbsolutePercentageErrorEvaluator testMapeEvaluator = new SimpleMeanAbsolutePercentageErrorEvaluator();
       testMapeEvaluator.Name = "TestMapeEvaluator";
       testMapeEvaluator.GetVariableInfo("MAPE").ActualName = "TestMAPE";
-      testMapeEvaluator.GetVariableInfo("SamplesStart").ActualName = "TestSamplesStart";
-      testMapeEvaluator.GetVariableInfo("SamplesEnd").ActualName = "TestSamplesEnd";
+      testMapeEvaluator.GetVariableInfo("Values").ActualName = "TestValues";
       #endregion
       #region MAPRE
-      MeanAbsolutePercentageOfRangeErrorEvaluator trainingMapreEvaluator = new MeanAbsolutePercentageOfRangeErrorEvaluator();
-      trainingMapreEvaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
+      SimpleMeanAbsolutePercentageOfRangeErrorEvaluator trainingMapreEvaluator = new SimpleMeanAbsolutePercentageOfRangeErrorEvaluator();
       trainingMapreEvaluator.Name = "TrainingMapreEvaluator";
       trainingMapreEvaluator.GetVariableInfo("MAPRE").ActualName = "TrainingMAPRE";
-      trainingMapreEvaluator.GetVariableInfo("SamplesStart").ActualName = "TrainingSamplesStart";
-      trainingMapreEvaluator.GetVariableInfo("SamplesEnd").ActualName = "TrainingSamplesEnd";
-      MeanAbsolutePercentageOfRangeErrorEvaluator validationMapreEvaluator = new MeanAbsolutePercentageOfRangeErrorEvaluator();
-      validationMapreEvaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
+      trainingMapreEvaluator.GetVariableInfo("Values").ActualName = "TrainingValues";
+      SimpleMeanAbsolutePercentageOfRangeErrorEvaluator validationMapreEvaluator = new SimpleMeanAbsolutePercentageOfRangeErrorEvaluator();
       validationMapreEvaluator.Name = "ValidationMapreEvaluator";
       validationMapreEvaluator.GetVariableInfo("MAPRE").ActualName = "ValidationMAPRE";
-      validationMapreEvaluator.GetVariableInfo("SamplesStart").ActualName = "ValidationSamplesStart";
-      validationMapreEvaluator.GetVariableInfo("SamplesEnd").ActualName = "ValidationSamplesEnd";
-      MeanAbsolutePercentageOfRangeErrorEvaluator testMapreEvaluator = new MeanAbsolutePercentageOfRangeErrorEvaluator();
-      testMapreEvaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
+      validationMapreEvaluator.GetVariableInfo("Values").ActualName = "ValidationValues";
+      SimpleMeanAbsolutePercentageOfRangeErrorEvaluator testMapreEvaluator = new SimpleMeanAbsolutePercentageOfRangeErrorEvaluator();
       testMapreEvaluator.Name = "TestMapreEvaluator";
       testMapreEvaluator.GetVariableInfo("MAPRE").ActualName = "TestMAPRE";
-      testMapreEvaluator.GetVariableInfo("SamplesStart").ActualName = "TestSamplesStart";
-      testMapreEvaluator.GetVariableInfo("SamplesEnd").ActualName = "TestSamplesEnd";
+      testMapreEvaluator.GetVariableInfo("Values").ActualName = "TestValues";
       #endregion MAPRE
       #region R2
-      CoefficientOfDeterminationEvaluator trainingR2Evaluator = new CoefficientOfDeterminationEvaluator();
-      trainingR2Evaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
+      SimpleR2Evaluator trainingR2Evaluator = new SimpleR2Evaluator();
       trainingR2Evaluator.Name = "TrainingR2Evaluator";
       trainingR2Evaluator.GetVariableInfo("R2").ActualName = "TrainingR2";
-      trainingR2Evaluator.GetVariableInfo("SamplesStart").ActualName = "TrainingSamplesStart";
-      trainingR2Evaluator.GetVariableInfo("SamplesEnd").ActualName = "TrainingSamplesEnd";
-      CoefficientOfDeterminationEvaluator validationR2Evaluator = new CoefficientOfDeterminationEvaluator();
-      validationR2Evaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
+      trainingR2Evaluator.GetVariableInfo("Values").ActualName = "TrainingValues";
+      SimpleR2Evaluator validationR2Evaluator = new SimpleR2Evaluator();
       validationR2Evaluator.Name = "ValidationR2Evaluator";
       validationR2Evaluator.GetVariableInfo("R2").ActualName = "ValidationR2";
-      validationR2Evaluator.GetVariableInfo("SamplesStart").ActualName = "ValidationSamplesStart";
-      validationR2Evaluator.GetVariableInfo("SamplesEnd").ActualName = "ValidationSamplesEnd";
-      CoefficientOfDeterminationEvaluator testR2Evaluator = new CoefficientOfDeterminationEvaluator();
-      testR2Evaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
+      validationR2Evaluator.GetVariableInfo("Values").ActualName = "ValidationValues";
+      SimpleR2Evaluator testR2Evaluator = new SimpleR2Evaluator();
       testR2Evaluator.Name = "TestR2Evaluator";
       testR2Evaluator.GetVariableInfo("R2").ActualName = "TestR2";
-      testR2Evaluator.GetVariableInfo("SamplesStart").ActualName = "TestSamplesStart";
-      testR2Evaluator.GetVariableInfo("SamplesEnd").ActualName = "TestSamplesEnd";
+      testR2Evaluator.GetVariableInfo("Values").ActualName = "TestValues";
       #endregion
       #region VAF
-      VarianceAccountedForEvaluator trainingVAFEvaluator = new VarianceAccountedForEvaluator();
-      trainingVAFEvaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
+      SimpleVarianceAccountedForEvaluator trainingVAFEvaluator = new SimpleVarianceAccountedForEvaluator();
       trainingVAFEvaluator.Name = "TrainingVAFEvaluator";
       trainingVAFEvaluator.GetVariableInfo("VAF").ActualName = "TrainingVAF";
-      trainingVAFEvaluator.GetVariableInfo("SamplesStart").ActualName = "TrainingSamplesStart";
-      trainingVAFEvaluator.GetVariableInfo("SamplesEnd").ActualName = "TrainingSamplesEnd";
-      VarianceAccountedForEvaluator validationVAFEvaluator = new VarianceAccountedForEvaluator();
-      validationVAFEvaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
+      trainingVAFEvaluator.GetVariableInfo("Values").ActualName = "TrainingValues";
+      SimpleVarianceAccountedForEvaluator validationVAFEvaluator = new SimpleVarianceAccountedForEvaluator();
       validationVAFEvaluator.Name = "ValidationVAFEvaluator";
       validationVAFEvaluator.GetVariableInfo("VAF").ActualName = "ValidationVAF";
-      validationVAFEvaluator.GetVariableInfo("SamplesStart").ActualName = "ValidationSamplesStart";
-      validationVAFEvaluator.GetVariableInfo("SamplesEnd").ActualName = "ValidationSamplesEnd";
-      VarianceAccountedForEvaluator testVAFEvaluator = new VarianceAccountedForEvaluator();
-      testVAFEvaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
+      validationVAFEvaluator.GetVariableInfo("Values").ActualName = "ValidationValues";
+      SimpleVarianceAccountedForEvaluator testVAFEvaluator = new SimpleVarianceAccountedForEvaluator();
       testVAFEvaluator.Name = "TestVAFEvaluator";
       testVAFEvaluator.GetVariableInfo("VAF").ActualName = "TestVAF";
-      testVAFEvaluator.GetVariableInfo("SamplesStart").ActualName = "TestSamplesStart";
-      testVAFEvaluator.GetVariableInfo("SamplesEnd").ActualName = "TestSamplesEnd";
+      testVAFEvaluator.GetVariableInfo("Values").ActualName = "TestValues";
       #endregion
 
       solutionProc.AddSubOperator(evaluatorInjector);
+      solutionProc.AddSubOperator(trainingEvaluator);
+      solutionProc.AddSubOperator(validationEvaluator);
+      solutionProc.AddSubOperator(testEvaluator);
       solutionProc.AddSubOperator(trainingMseEvaluator);
       solutionProc.AddSubOperator(validationMseEvaluator);
Index: trunk/sources/HeuristicLab.Modeling/3.2/ClassificationProblemInjector.cs
===================================================================
--- trunk/sources/HeuristicLab.Modeling/3.2/ClassificationProblemInjector.cs	(revision 2350)
+++ 	(revision )
@@ -1,45 +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 System;
-using System.Collections.Generic;
-using System.Text;
-using System.Xml;
-using HeuristicLab.Core;
-using HeuristicLab.Data;
-
-namespace HeuristicLab.Modeling {
-  public class ClassificationProblemInjector : ProblemInjector {
-
-    public override string Description {
-      get {
-        return "Problem injector for classification problems.";
-      }
-    }
-
-    public ClassificationProblemInjector()
-      : base() {
-      AddVariableInfo(new Core.VariableInfo("TargetClassValues", "TargetClassValues", typeof(ItemList<DoubleData>), Core.VariableKind.New));
-      GetVariableInfo("TargetClassValues").Local = true;
-      AddVariable(new Core.Variable("TargetClassValues", new ItemList<DoubleData>()));
-    }
-  }
-}
Index: trunk/sources/HeuristicLab.Modeling/3.2/HeuristicLab.Modeling-3.2.csproj
===================================================================
--- trunk/sources/HeuristicLab.Modeling/3.2/HeuristicLab.Modeling-3.2.csproj	(revision 2350)
+++ trunk/sources/HeuristicLab.Modeling/3.2/HeuristicLab.Modeling-3.2.csproj	(revision 2351)
@@ -84,5 +84,6 @@
     <Compile Include="AnalyzerModel.cs" />
     <Compile Include="BestSolutionStorer.cs" />
-    <Compile Include="ClassificationProblemInjector.cs" />
+    <Compile Include="SimpleAccuracyEvaluator.cs" />
+    <Compile Include="SimpleConfusionMatrixEvaluator.cs" />
     <Compile Include="SimpleTheilInequalityCoefficientEvaluator.cs" />
     <Compile Include="SolutionExtractor.cs" />
@@ -90,4 +91,5 @@
     <Compile Include="IAnalyzerModel.cs" />
     <Compile Include="MatrixCreator.cs" />
+    <Compile Include="TargetClassesCalculator.cs" />
     <Compile Include="VariableEvaluationImpactCalculator.cs" />
     <Compile Include="IPredictor.cs" />
Index: trunk/sources/HeuristicLab.Modeling/3.2/SimpleAccuracyEvaluator.cs
===================================================================
--- trunk/sources/HeuristicLab.Modeling/3.2/SimpleAccuracyEvaluator.cs	(revision 2351)
+++ trunk/sources/HeuristicLab.Modeling/3.2/SimpleAccuracyEvaluator.cs	(revision 2351)
@@ -0,0 +1,89 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2008 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.DataAnalysis;
+using System.Linq;
+using HeuristicLab.Common;
+
+namespace HeuristicLab.Modeling {
+  public class SimpleAccuracyEvaluator : SimpleEvaluatorBase {
+    public override string OutputVariableName {
+      get {
+        return "Accuracy";
+      }
+    }
+    public override string Description {
+      get {
+        return @"Calculates the total accuracy of the model (ratio of correctly classified instances to total number of instances) given a model and the list of possible target class values.";
+      }
+    }
+
+    public override double Evaluate(double[,] values) {
+      return Calculate(values);
+    }
+
+    public static double Calculate(double[,] values) {
+      int nSamples = values.GetLength(0);
+      int nCorrect = 0;
+      double[] classes = CalculateTargetClasses(values);
+      double[] thresholds = CalculateThresholds(classes);
+
+      for (int sample = 0; sample < nSamples; sample++) {
+        double est = values[sample, 0];
+        double origClass = values[sample, 1];
+        double estClass = double.NaN;
+        // if estimation is lower than the smallest threshold value -> estimated class is the lower class
+        if (est < thresholds[0]) estClass = classes[0];
+        // if estimation is larger (or equal) than the largest threshold value -> estimated class is the upper class
+        else if (est >= thresholds[thresholds.Length - 1]) estClass = classes[classes.Length - 1];
+        else {
+          // otherwise the estimated class is the class which upper threshold is larger than the estimated value
+          for (int k = 0; k < thresholds.Length; k++) {
+            if (thresholds[k] > est) {
+              estClass = classes[k];
+              break;
+            }
+          }
+        }
+        if (estClass.IsAlmost(origClass)) nCorrect++;
+      }
+      return nCorrect / (double)nSamples;
+    }
+
+    public static double[] CalculateTargetClasses(double[,] values) {
+      int n = values.GetLength(0);
+      double[] original = new double[n];
+      for (int i = 0; i < n; i++) original[i] = values[i, 1];
+      return original.OrderBy(x => x).Distinct().ToArray();
+    }
+
+    public static double[] CalculateThresholds(double[] targetClasses) {
+      double[] thresholds = new double[targetClasses.Length - 1];
+      for (int i = 1; i < targetClasses.Length; i++) {
+        thresholds[i - 1] = (targetClasses[i - 1] + targetClasses[i]) / 2.0;
+      }
+      return thresholds;
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Modeling/3.2/SimpleConfusionMatrixEvaluator.cs
===================================================================
--- trunk/sources/HeuristicLab.Modeling/3.2/SimpleConfusionMatrixEvaluator.cs	(revision 2351)
+++ trunk/sources/HeuristicLab.Modeling/3.2/SimpleConfusionMatrixEvaluator.cs	(revision 2351)
@@ -0,0 +1,87 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2008 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+
+namespace HeuristicLab.Modeling {
+  public class SimpleConfusionMatrixEvaluator : OperatorBase {
+    public override string Description {
+      get {
+        return @"Calculates the classifcation matrix of the model.";
+      }
+    }
+
+    public SimpleConfusionMatrixEvaluator()
+      : base() {
+      AddVariableInfo(new VariableInfo("Values", "Original and predicted target values generated by a model", typeof(DoubleMatrixData), VariableKind.In));
+      AddVariableInfo(new VariableInfo("ConfusionMatrix", "The confusion matrix of the model", typeof(IntMatrixData), VariableKind.New));
+    }
+
+    public override IOperation Apply(IScope scope) {
+      double[,] values = GetVariableValue<DoubleMatrixData>("Values", scope, true).Data;
+      int[,] confusionMatrix = Calculate(values);
+      IntMatrixData matrix = GetVariableValue<IntMatrixData>("ConfusionMatrix", scope, false, false);
+      if (matrix == null) {
+        matrix = new IntMatrixData(confusionMatrix);
+        scope.AddVariable(new HeuristicLab.Core.Variable(scope.TranslateName("ConfusionMatrix"), matrix));
+      }
+
+      return null;
+    }
+
+    public static int[,] Calculate(double[,] values) {
+      double[] classes = SimpleAccuracyEvaluator.CalculateTargetClasses(values);
+      double[] thresholds = SimpleAccuracyEvaluator.CalculateThresholds(classes);
+      int nSamples = values.GetLength(0);
+      int[,] confusionMatrix = new int[classes.Length, classes.Length];
+      for (int sample = 0; sample < nSamples; sample++) {
+        double est = values[sample, 0];
+        double origClass = values[sample, 1];
+        int estClassIndex = -1;
+        // if estimation is lower than the smallest threshold value -> estimated class is the lower class
+        if (est < thresholds[0]) estClassIndex = 0;
+        // if estimation is larger (or equal) than the largest threshold value -> estimated class is the upper class
+        else if (est >= thresholds[thresholds.Length - 1]) estClassIndex = classes.Length - 1;
+        else {
+          // otherwise the estimated class is the class which upper threshold is larger than the estimated value
+          for (int k = 0; k < thresholds.Length; k++) {
+            if (thresholds[k] > est) {
+              estClassIndex = k;
+              break;
+            }
+          }
+        }
+
+        // find the first threshold index that is larger to the original value
+        int origClassIndex = classes.Length - 1;
+        for (int i = 0; i < thresholds.Length; i++) {
+          if (origClass < thresholds[i]) {
+            origClassIndex = i;
+            break;
+          }
+        }
+        confusionMatrix[origClassIndex, estClassIndex]++;
+      }
+      return confusionMatrix;
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Modeling/3.2/TargetClassesCalculator.cs
===================================================================
--- trunk/sources/HeuristicLab.Modeling/3.2/TargetClassesCalculator.cs	(revision 2351)
+++ trunk/sources/HeuristicLab.Modeling/3.2/TargetClassesCalculator.cs	(revision 2351)
@@ -0,0 +1,51 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2008 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.DataAnalysis;
+using System.Linq;
+
+namespace HeuristicLab.Modeling {
+  public class TargetClassesCalculator : OperatorBase {
+
+    public TargetClassesCalculator()
+      : base() {
+      AddVariableInfo(new VariableInfo("Dataset", "The dataset", typeof(Dataset), VariableKind.In));
+      AddVariableInfo(new VariableInfo("TargetVariable", "Index of the target variable", typeof(IntData), VariableKind.In));
+      AddVariableInfo(new VariableInfo("TargetClassValues", "The original class values of target variable (for instance negative=0 and positive=1).", typeof(ItemList<DoubleData>), VariableKind.New));
+    }
+
+    public override IOperation Apply(IScope scope) {
+      Dataset dataset = GetVariableValue<Dataset>("Dataset", scope, true);
+      int targetVariable = GetVariableValue<IntData>("TargetVariable", scope, true).Data;
+
+      ItemList<DoubleData> classes = new ItemList<DoubleData>();
+      foreach (double x in dataset.GetVariableValues(targetVariable).Distinct().OrderBy(v => v)) {
+        classes.Add(new DoubleData(x));
+      }
+
+      scope.AddVariable(new HeuristicLab.Core.Variable(scope.TranslateName("TargetClassValues"), classes));
+      return null;
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.SupportVectorMachines/3.2/HeuristicLab.SupportVectorMachines-3.2.csproj
===================================================================
--- trunk/sources/HeuristicLab.SupportVectorMachines/3.2/HeuristicLab.SupportVectorMachines-3.2.csproj	(revision 2350)
+++ trunk/sources/HeuristicLab.SupportVectorMachines/3.2/HeuristicLab.SupportVectorMachines-3.2.csproj	(revision 2351)
@@ -83,4 +83,5 @@
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="SupportVectorClassification.cs" />
     <Compile Include="TimeSeriesSupportVectorRegression.cs" />
     <Compile Include="PredictorView.cs">
Index: trunk/sources/HeuristicLab.SupportVectorMachines/3.2/SupportVectorClassification.cs
===================================================================
--- trunk/sources/HeuristicLab.SupportVectorMachines/3.2/SupportVectorClassification.cs	(revision 2351)
+++ trunk/sources/HeuristicLab.SupportVectorMachines/3.2/SupportVectorClassification.cs	(revision 2351)
@@ -0,0 +1,117 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2008 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using HeuristicLab.Core;
+using System.Xml;
+using System.Diagnostics;
+using HeuristicLab.DataAnalysis;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Logging;
+using HeuristicLab.Operators.Programmable;
+using HeuristicLab.Modeling;
+using HeuristicLab.Random;
+using HeuristicLab.Selection;
+
+namespace HeuristicLab.SupportVectorMachines {
+  public class SupportVectorClassification : SupportVectorRegression {
+
+    public override string Name { get { return "SupportVectorClassification"; } }
+
+    public SupportVectorClassification()
+      : base() {
+      SvmType = "NU_SVC";
+      CostList = new DoubleArrayData(new double[] { 1.0 });
+      MaxCostIndex = 1;
+    }
+
+    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 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);
+
+      return model;
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.SupportVectorMachines/3.2/SupportVectorRegression.cs
===================================================================
--- trunk/sources/HeuristicLab.SupportVectorMachines/3.2/SupportVectorRegression.cs	(revision 2350)
+++ trunk/sources/HeuristicLab.SupportVectorMachines/3.2/SupportVectorRegression.cs	(revision 2351)
@@ -105,4 +105,9 @@
       get { return GetVariableInjector().GetVariable("MaxGammaIndex").GetValue<IntData>().Data; }
       set { GetVariableInjector().GetVariable("MaxGammaIndex").GetValue<IntData>().Data = value; }
+    }
+
+    public string SvmType {
+      get { return GetVariableInjector().GetVariable("Type").GetValue<StringData>().Data; }
+      set { GetVariableInjector().GetVariable("Type").GetValue<StringData>().Data = value; }
     }
 
