Index: /branches/SensitivityEvaluator/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/SingleObjective/SymbolicClassificationSingleObjectiveWeightedResidualsMeanSquaredErrorEvaluator.cs
===================================================================
--- /branches/SensitivityEvaluator/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/SingleObjective/SymbolicClassificationSingleObjectiveWeightedResidualsMeanSquaredErrorEvaluator.cs	(revision 12447)
+++ /branches/SensitivityEvaluator/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/SingleObjective/SymbolicClassificationSingleObjectiveWeightedResidualsMeanSquaredErrorEvaluator.cs	(revision 12448)
@@ -32,13 +32,13 @@
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Classification {
   [Item("Weighted Residuals Mean Squared Error Evaluator", @"A modified mean squared error evaluator that enables the possibility to weight residuals differently.
-The first residual category belongs to estimated values which obviously belong to a specific class because the estimated value is located above the maximum or below the minimum of all the class values (ObviousResidualsWeight).
+The first residual category belongs to estimated values which definitely belong to a specific class because the estimated value is located above the maximum or below the minimum of all the class values (DefiniteResidualsWeight).
 The second residual category represents residuals which belong to the positive class whereby the estimated value is located between the positive and a negative class (PositiveClassResidualsWeight).
-All other cases are represented by the third category (NegativeClassResidualsWeight).
+All other cases are represented by the third category (NegativeClassesResidualsWeight).
 The weight is multiplied to the error before squaring which means that the Evaluator acts like a normal MSE-Evaluator if all the weights are set to 1.")]
   [StorableClass]
   public class SymbolicClassificationSingleObjectiveWeightedResidualsMeanSquaredErrorEvaluator : SymbolicClassificationSingleObjectiveEvaluator {
-    private const string ObviousResidualsWeightParameterName = "ObviousResidualsWeight";
+    private const string DefiniteResidualsWeightParameterName = "DefiniteResidualsWeight";
     private const string PositiveClassResidualsWeightParameterName = "PositiveClassResidualsWeight";
-    private const string NegativeClassResidualsWeightParameterName = "NegativeClassResidualsWeight";
+    private const string NegativeClassesResidualsWeightParameterName = "NegativeClassesResidualsWeight";
     [StorableConstructor]
     protected SymbolicClassificationSingleObjectiveWeightedResidualsMeanSquaredErrorEvaluator(bool deserializing) : base(deserializing) { }
@@ -52,18 +52,18 @@
     public SymbolicClassificationSingleObjectiveWeightedResidualsMeanSquaredErrorEvaluator()
       : base() {
-      Parameters.Add(new FixedValueParameter<DoubleValue>(ObviousResidualsWeightParameterName, "Weight of residuals which obviously belong to a specific class because the estimated values is located above the maximum or below the minimum of all the class values.", new DoubleValue(1)));
+      Parameters.Add(new FixedValueParameter<DoubleValue>(DefiniteResidualsWeightParameterName, "Weight of residuals which definitely belong to a specific class because the estimated values is located above the maximum or below the minimum of all the class values.", new DoubleValue(1)));
       Parameters.Add(new FixedValueParameter<DoubleValue>(PositiveClassResidualsWeightParameterName, "Weight of residuals which belong to the positive class whereby the estimated value is located between the positive and a negative class.", new DoubleValue(1)));
-      Parameters.Add(new FixedValueParameter<DoubleValue>(NegativeClassResidualsWeightParameterName, "Weight of residuals which are not covered by the ObviousResidualsWeight or the PositiveClassResidualsWeight.", new DoubleValue(1)));
+      Parameters.Add(new FixedValueParameter<DoubleValue>(NegativeClassesResidualsWeightParameterName, "Weight of residuals which are not covered by the DefiniteResidualsWeight or the PositiveClassResidualsWeight.", new DoubleValue(1)));
     }
 
     #region parameter properties
-    public IFixedValueParameter<DoubleValue> ObviousResidualsWeightParameter {
-      get { return (IFixedValueParameter<DoubleValue>)Parameters[ObviousResidualsWeightParameterName]; }
+    public IFixedValueParameter<DoubleValue> DefiniteResidualsWeightParameter {
+      get { return (IFixedValueParameter<DoubleValue>)Parameters[DefiniteResidualsWeightParameterName]; }
     }
     public IFixedValueParameter<DoubleValue> PositiveClassResidualsWeightParameter {
       get { return (IFixedValueParameter<DoubleValue>)Parameters[PositiveClassResidualsWeightParameterName]; }
     }
-    public IFixedValueParameter<DoubleValue> NegativeClassResidualsWeightParameter {
-      get { return (IFixedValueParameter<DoubleValue>)Parameters[NegativeClassResidualsWeightParameterName]; }
+    public IFixedValueParameter<DoubleValue> NegativeClassesResidualsWeightParameter {
+      get { return (IFixedValueParameter<DoubleValue>)Parameters[NegativeClassesResidualsWeightParameterName]; }
     }
     #endregion
@@ -72,7 +72,7 @@
     public override bool Maximization { get { return false; } }
 
-    public double ObviousResidualsWeight {
+    public double DefiniteResidualsWeight {
       get {
-        return ObviousResidualsWeightParameter.Value.Value;
+        return DefiniteResidualsWeightParameter.Value.Value;
       }
     }
@@ -82,7 +82,7 @@
       }
     }
-    public double NegativeClassResidualsWeight {
+    public double NegativeClassesResidualsWeight {
       get {
-        return NegativeClassResidualsWeightParameter.Value.Value;
+        return NegativeClassesResidualsWeightParameter.Value.Value;
       }
     }
@@ -93,5 +93,5 @@
       var solution = SymbolicExpressionTreeParameter.ActualValue;
       double quality = Calculate(SymbolicDataAnalysisTreeInterpreterParameter.ActualValue, solution, EstimationLimitsParameter.ActualValue.Lower, EstimationLimitsParameter.ActualValue.Upper, ProblemDataParameter.ActualValue, rows, ApplyLinearScalingParameter.ActualValue.Value,
-        ObviousResidualsWeight, PositiveClassResidualsWeight, NegativeClassResidualsWeight);
+        DefiniteResidualsWeight, PositiveClassResidualsWeight, NegativeClassesResidualsWeight);
       QualityParameter.ActualValue = new DoubleValue(quality);
       return base.InstrumentedApply();
@@ -99,5 +99,5 @@
 
     public static double Calculate(ISymbolicDataAnalysisExpressionTreeInterpreter interpreter, ISymbolicExpressionTree solution, double lowerEstimationLimit, double upperEstimationLimit, IClassificationProblemData problemData, IEnumerable<int> rows, bool applyLinearScaling,
-      double obviousResidualsWeight, double positiveClassResidualsWeight, double negativeClassResidualsWeight) {
+      double definiteResidualsWeight, double positiveClassResidualsWeight, double negativeClassesResidualsWeight) {
       IEnumerable<double> estimatedValues = interpreter.GetSymbolicExpressionTreeValues(solution, problemData.Dataset, rows);
       IEnumerable<double> targetValues = problemData.Dataset.GetDoubleValues(problemData.TargetVariable, rows);
@@ -116,5 +116,5 @@
       if (applyLinearScaling) {
         var calculator = new OnlineWeightedResidualsMeanSquaredErrorCalculator(positiveClassValue, classValuesMax, classValuesMin,
-          obviousResidualsWeight, positiveClassResidualsWeight, negativeClassResidualsWeight);
+          definiteResidualsWeight, positiveClassResidualsWeight, negativeClassesResidualsWeight);
         CalculateWithScaling(targetValues, estimatedValues, lowerEstimationLimit, upperEstimationLimit, calculator, problemData.Dataset.Rows);
         errorState = calculator.ErrorState;
@@ -123,5 +123,5 @@
         IEnumerable<double> boundedEstimatedValues = estimatedValues.LimitToRange(lowerEstimationLimit, upperEstimationLimit);
         quality = OnlineWeightedResidualsMeanSquaredErrorCalculator.Calculate(targetValues, boundedEstimatedValues, positiveClassValue, classValuesMax,
-          classValuesMin, obviousResidualsWeight, positiveClassResidualsWeight, negativeClassResidualsWeight, out errorState);
+          classValuesMin, definiteResidualsWeight, positiveClassResidualsWeight, negativeClassesResidualsWeight, out errorState);
       }
       if (errorState != OnlineCalculatorError.None) return Double.NaN;
@@ -134,5 +134,5 @@
       ApplyLinearScalingParameter.ExecutionContext = context;
 
-      double quality = Calculate(SymbolicDataAnalysisTreeInterpreterParameter.ActualValue, tree, EstimationLimitsParameter.ActualValue.Lower, EstimationLimitsParameter.ActualValue.Upper, problemData, rows, ApplyLinearScalingParameter.ActualValue.Value, ObviousResidualsWeight, PositiveClassResidualsWeight, NegativeClassResidualsWeight);
+      double quality = Calculate(SymbolicDataAnalysisTreeInterpreterParameter.ActualValue, tree, EstimationLimitsParameter.ActualValue.Lower, EstimationLimitsParameter.ActualValue.Upper, problemData, rows, ApplyLinearScalingParameter.ActualValue.Value, DefiniteResidualsWeight, PositiveClassResidualsWeight, NegativeClassesResidualsWeight);
 
       SymbolicDataAnalysisTreeInterpreterParameter.ExecutionContext = null;
Index: /branches/SensitivityEvaluator/HeuristicLab.Problems.DataAnalysis/3.4/OnlineCalculators/OnlineWeightedResidualsMeanSquaredErrorCalculator.cs
===================================================================
--- /branches/SensitivityEvaluator/HeuristicLab.Problems.DataAnalysis/3.4/OnlineCalculators/OnlineWeightedResidualsMeanSquaredErrorCalculator.cs	(revision 12447)
+++ /branches/SensitivityEvaluator/HeuristicLab.Problems.DataAnalysis/3.4/OnlineCalculators/OnlineWeightedResidualsMeanSquaredErrorCalculator.cs	(revision 12448)
@@ -36,18 +36,18 @@
 
     public double PositiveClassValue { get; private set; }
-    public double ClassValueMax { get; private set; }
-    public double ClassValueMin { get; private set; }
-    public double ObviousResidualsWeight { get; private set; }
+    public double ClassValuesMax { get; private set; }
+    public double ClassValuesMin { get; private set; }
+    public double DefiniteResidualsWeight { get; private set; }
     public double PositiveClassResidualsWeight { get; private set; }
-    public double NegativeClassResidualsWeight { get; private set; }
+    public double NegativeClassesResidualsWeight { get; private set; }
 
-    public OnlineWeightedResidualsMeanSquaredErrorCalculator(double positiveClassValue, double classValueMax, double classValueMin,
-                                                                double obviousResidualsWeight, double positiveClassResidualsWeight, double negativeClassResidualsWeight) {
+    public OnlineWeightedResidualsMeanSquaredErrorCalculator(double positiveClassValue, double classValuesMax, double classValuesMin,
+                                                                double definiteResidualsWeight, double positiveClassResidualsWeight, double negativeClassesResidualsWeight) {
       PositiveClassValue = positiveClassValue;
-      ClassValueMax = classValueMax;
-      ClassValueMin = classValueMin;
-      ObviousResidualsWeight = obviousResidualsWeight;
+      ClassValuesMax = classValuesMax;
+      ClassValuesMin = classValuesMin;
+      DefiniteResidualsWeight = definiteResidualsWeight;
       PositiveClassResidualsWeight = positiveClassResidualsWeight;
-      NegativeClassResidualsWeight = negativeClassResidualsWeight;
+      NegativeClassesResidualsWeight = negativeClassesResidualsWeight;
       Reset();
     }
@@ -75,12 +75,10 @@
         double weight;
         //apply weight
-        if (estimated > ClassValueMax || estimated < ClassValueMin) {
-          weight = ObviousResidualsWeight;
-        } else if (original.IsAlmost(PositiveClassValue))
-        {
+        if (estimated > ClassValuesMax || estimated < ClassValuesMin) {
+          weight = DefiniteResidualsWeight;
+        } else if (original.IsAlmost(PositiveClassValue)) {
           weight = PositiveClassResidualsWeight;
-        } else
-        {
-          weight = NegativeClassResidualsWeight;
+        } else {
+          weight = NegativeClassesResidualsWeight;
         }
         error *= weight;
@@ -92,9 +90,9 @@
     #endregion
 
-    public static double Calculate(IEnumerable<double> originalValues, IEnumerable<double> estimatedValues, double positiveClassValue, double classValueMax, double classValueMin,
-                                                                double obviousValuesWeight, double positiveClassValuesWeight, double negativeClassValuesWeight, out OnlineCalculatorError errorState) {
+    public static double Calculate(IEnumerable<double> originalValues, IEnumerable<double> estimatedValues, double positiveClassValue, double classValuesMax, double classValuesMin,
+                                                                double definiteResidualsWeight, double positiveClassResidualsWeight, double negativeClassesResidualsWeight, out OnlineCalculatorError errorState) {
       IEnumerator<double> originalEnumerator = originalValues.GetEnumerator();
       IEnumerator<double> estimatedEnumerator = estimatedValues.GetEnumerator();
-      OnlineWeightedResidualsMeanSquaredErrorCalculator calculator = new OnlineWeightedResidualsMeanSquaredErrorCalculator(positiveClassValue, classValueMax, classValueMin, obviousValuesWeight, positiveClassValuesWeight, negativeClassValuesWeight);
+      OnlineWeightedResidualsMeanSquaredErrorCalculator calculator = new OnlineWeightedResidualsMeanSquaredErrorCalculator(positiveClassValue, classValuesMax, classValuesMin, definiteResidualsWeight, positiveClassResidualsWeight, negativeClassesResidualsWeight);
 
       // always move forward both enumerators (do not use short-circuit evaluation!)
