Index: /branches/HeuristicLab.OSGAEvaluator/HeuristicLab.OSGAEvaluator.sln
===================================================================
--- /branches/HeuristicLab.OSGAEvaluator/HeuristicLab.OSGAEvaluator.sln	(revision 14427)
+++ /branches/HeuristicLab.OSGAEvaluator/HeuristicLab.OSGAEvaluator.sln	(revision 14428)
@@ -2,9 +2,12 @@
 Microsoft Visual Studio Solution File, Format Version 12.00
 # Visual Studio 14
-VisualStudioVersion = 14.0.25123.0
+VisualStudioVersion = 14.0.25420.1
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HeuristicLab.OSGAEvaluator", "HeuristicLab.OSGAEvaluator\HeuristicLab.OSGAEvaluator.csproj", "{4148A27C-C6F5-44BA-9A57-1460F3758A24}"
 EndProject
 Global
+	GlobalSection(Performance) = preSolution
+		HasPerformanceSessions = true
+	EndGlobalSection
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
Index: /branches/HeuristicLab.OSGAEvaluator/HeuristicLab.OSGAEvaluator/AdjustedEvaluatedSolutionsAnalyzer.cs
===================================================================
--- /branches/HeuristicLab.OSGAEvaluator/HeuristicLab.OSGAEvaluator/AdjustedEvaluatedSolutionsAnalyzer.cs	(revision 14428)
+++ /branches/HeuristicLab.OSGAEvaluator/HeuristicLab.OSGAEvaluator/AdjustedEvaluatedSolutionsAnalyzer.cs	(revision 14428)
@@ -0,0 +1,76 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2016 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.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.DataAnalysis.Symbolic;
+using HeuristicLab.Problems.DataAnalysis.Symbolic.Regression;
+
+namespace HeuristicLab.OSGAEvaluator {
+  [Item("AdjustedEvaluatedSolutionsAnalyzer", "Analyzer which aggregates the adjusted evaluated solutions count from the predictive evaluator.")]
+  [StorableClass]
+  public class AdjustedEvaluatedSolutionsAnalyzer : SymbolicDataAnalysisSingleObjectiveAnalyzer {
+    private const string EvaluatorParameterName = "Evaluator";
+    private const string AdjustedEvaluatedSolutionsResultName = "AdjustedEvaluatedSolutions";
+
+    public ILookupParameter<SymbolicRegressionSingleObjectiveEvaluator> EvaluatorParameter {
+      get { return (ILookupParameter<SymbolicRegressionSingleObjectiveEvaluator>)Parameters[EvaluatorParameterName]; }
+    }
+
+    public SymbolicRegressionSingleObjectiveEvaluator Evaluator {
+      get { return EvaluatorParameter.ActualValue; }
+    }
+
+    public AdjustedEvaluatedSolutionsAnalyzer() {
+      Parameters.Add(new LookupParameter<SymbolicRegressionSingleObjectiveEvaluator>(EvaluatorParameterName));
+    }
+
+    [StorableConstructor]
+    protected AdjustedEvaluatedSolutionsAnalyzer(bool deserializing) : base(deserializing) { }
+
+    protected AdjustedEvaluatedSolutionsAnalyzer(AdjustedEvaluatedSolutionsAnalyzer original, Cloner cloner) : base(original, cloner) { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new AdjustedEvaluatedSolutionsAnalyzer(this, cloner);
+    }
+
+    public override IOperation Apply() {
+      var evaluator = Evaluator as SymbolicRegressionSingleObjectiveOsgaEvaluator;
+
+      if (evaluator == null)
+        return base.Apply();
+
+      var results = ResultCollectionParameter.ActualValue;
+      if (!results.ContainsKey(AdjustedEvaluatedSolutionsResultName)) {
+        results.Add(new Result(AdjustedEvaluatedSolutionsResultName, new DoubleValue(0)));
+      }
+      var adjustedEvaluatedSolutions = (DoubleValue)results[AdjustedEvaluatedSolutionsResultName].Value;
+      adjustedEvaluatedSolutions.Value += evaluator.AdjustedEvaluatedSolutions;
+      evaluator.AdjustedEvaluatedSolutions = 0;
+
+      return base.Apply();
+    }
+  }
+}
Index: /branches/HeuristicLab.OSGAEvaluator/HeuristicLab.OSGAEvaluator/HeuristicLab.OSGAEvaluator.csproj
===================================================================
--- /branches/HeuristicLab.OSGAEvaluator/HeuristicLab.OSGAEvaluator/HeuristicLab.OSGAEvaluator.csproj	(revision 14427)
+++ /branches/HeuristicLab.OSGAEvaluator/HeuristicLab.OSGAEvaluator/HeuristicLab.OSGAEvaluator.csproj	(revision 14428)
@@ -117,4 +117,5 @@
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="AdjustedEvaluatedSolutionsAnalyzer.cs" />
     <Compile Include="OSGAPredictionCountsAnalyzer.cs" />
     <Compile Include="Plugin.cs" />
Index: /branches/HeuristicLab.OSGAEvaluator/HeuristicLab.OSGAEvaluator/OSGAPredictionCountsAnalyzer.cs
===================================================================
--- /branches/HeuristicLab.OSGAEvaluator/HeuristicLab.OSGAEvaluator/OSGAPredictionCountsAnalyzer.cs	(revision 14427)
+++ /branches/HeuristicLab.OSGAEvaluator/HeuristicLab.OSGAEvaluator/OSGAPredictionCountsAnalyzer.cs	(revision 14428)
@@ -17,10 +17,10 @@
     private const string ResultCollectionParameterName = "Results";
 
-    public ILookupParameter<SymbolicRegressionSingleObjectiveOsgaEvaluator> EvaluatorParameter {
-      get { return (ILookupParameter<SymbolicRegressionSingleObjectiveOsgaEvaluator>)Parameters[EvaluatorParameterName]; }
+    public ILookupParameter<SymbolicRegressionSingleObjectiveEvaluator> EvaluatorParameter {
+      get { return (ILookupParameter<SymbolicRegressionSingleObjectiveEvaluator>)Parameters[EvaluatorParameterName]; }
     }
 
     public OSGAPredictionCountsAnalyzer() {
-      Parameters.Add(new LookupParameter<SymbolicRegressionSingleObjectiveOsgaEvaluator>(EvaluatorParameterName));
+      Parameters.Add(new LookupParameter<SymbolicRegressionSingleObjectiveEvaluator>(EvaluatorParameterName));
     }
 
@@ -33,5 +33,5 @@
 
     public override IOperation Apply() {
-      var evaluator = EvaluatorParameter.ActualValue;
+      var evaluator = EvaluatorParameter.ActualValue as SymbolicRegressionSingleObjectiveOsgaEvaluator;
       if (evaluator == null)
         return base.Apply();
Index: /branches/HeuristicLab.OSGAEvaluator/HeuristicLab.OSGAEvaluator/SymbolicRegressionSingleObjectiveOSGAEvaluator.cs
===================================================================
--- /branches/HeuristicLab.OSGAEvaluator/HeuristicLab.OSGAEvaluator/SymbolicRegressionSingleObjectiveOSGAEvaluator.cs	(revision 14427)
+++ /branches/HeuristicLab.OSGAEvaluator/HeuristicLab.OSGAEvaluator/SymbolicRegressionSingleObjectiveOSGAEvaluator.cs	(revision 14428)
@@ -22,5 +22,4 @@
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.Linq;
 using HeuristicLab.Common;
@@ -43,6 +42,10 @@
     private const string UseAdaptiveQualityThresholdParameterName = "UseAdaptiveQualityThreshold";
     private const string UseFixedEvaluationIntervalsParameterName = "UseFixedEvaluationIntervals";
+    private const string PreserveResultCompatibilityParameterName = "PreserveEvaluationResultCompatibility";
 
     #region parameters
+    public IFixedValueParameter<BoolValue> PreserveResultCompatibilityParameter {
+      get { return (IFixedValueParameter<BoolValue>)Parameters[PreserveResultCompatibilityParameterName]; }
+    }
     public IFixedValueParameter<BoolValue> UseFixedEvaluationIntervalsParameter {
       get { return (IFixedValueParameter<BoolValue>)Parameters[UseFixedEvaluationIntervalsParameterName]; }
@@ -79,4 +82,12 @@
 
     #region parameter properties
+    public bool AggregateStatistics {
+      get { return AggregateStatisticsParameter.Value.Value; }
+      set { AggregateStatisticsParameter.Value.Value = value; }
+    }
+    public bool PreserveResultCompatibility {
+      get { return PreserveResultCompatibilityParameter.Value.Value; }
+      set { PreserveResultCompatibilityParameter.Value.Value = value; }
+    }
     public bool UseFixedEvaluationIntervals {
       get { return UseFixedEvaluationIntervalsParameter.Value.Value; }
@@ -91,15 +102,12 @@
       set { RelativeParentChildQualityThresholdParameter.Value.Value = value; }
     }
-
     public double RelativeFitnessEvaluationIntervalSize {
       get { return RelativeFitnessEvaluationIntervalSizeParameter.Value.Value; }
       set { RelativeFitnessEvaluationIntervalSizeParameter.Value.Value = value; }
     }
-
     public IntMatrix RejectedStats {
       get { return RejectedStatsParameter.Value; }
       set { RejectedStatsParameter.Value = value; }
     }
-
     public IntMatrix TotalStats {
       get { return NotRejectedStatsParameter.Value; }
@@ -111,4 +119,6 @@
       get { return true; }
     }
+
+    public double AdjustedEvaluatedSolutions { get; set; }
 
     public SymbolicRegressionSingleObjectiveOsgaEvaluator() {
@@ -124,4 +134,5 @@
       Parameters.Add(new FixedValueParameter<BoolValue>(UseAdaptiveQualityThresholdParameterName, new BoolValue(false)));
       Parameters.Add(new FixedValueParameter<BoolValue>(UseFixedEvaluationIntervalsParameterName, new BoolValue(false)));
+      Parameters.Add(new FixedValueParameter<BoolValue>(PreserveResultCompatibilityParameterName, new BoolValue(false)));
     }
 
@@ -136,4 +147,7 @@
       if (!Parameters.ContainsKey(UseFixedEvaluationIntervalsParameterName))
         Parameters.Add(new FixedValueParameter<BoolValue>(UseFixedEvaluationIntervalsParameterName, new BoolValue(false)));
+
+      if (!Parameters.ContainsKey(PreserveResultCompatibilityParameterName))
+        Parameters.Add(new FixedValueParameter<BoolValue>(PreserveResultCompatibilityParameterName, new BoolValue(false)));
     }
 
@@ -151,4 +165,5 @@
       RejectedStats = new IntMatrix();
       TotalStats = new IntMatrix();
+      AdjustedEvaluatedSolutions = 0;
     }
 
@@ -198,16 +213,18 @@
       var estimatedValues = interpreter.GetSymbolicExpressionTreeValues(solution, problemData.Dataset, rows);
       var targetValues = problemData.Dataset.GetDoubleValues(problemData.TargetVariable, rows).ToList();
-
       var parentQualities = ParentQualitiesParameter.ActualValue.Select(x => x.Value);
-      var minQuality = parentQualities.Min();
-      var maxQuality = parentQualities.Max();
+      var minQuality = double.MaxValue;
+      var maxQuality = double.MinValue;
+
+      foreach (var quality in parentQualities) {
+        if (minQuality > quality) minQuality = quality;
+        if (maxQuality < quality) maxQuality = quality;
+      }
+
       var comparisonFactor = ComparisonFactorParameter.ActualValue.Value;
       var parentQuality = minQuality + (maxQuality - minQuality) * comparisonFactor;
 
-
-
       #region fixed intervals
       if (UseFixedEvaluationIntervals) {
-        var e = estimatedValues.GetEnumerator();
         double threshold = parentQuality * RelativeParentChildQualityThreshold;
         if (UseAdaptiveQualityThreshold) {
@@ -216,129 +233,154 @@
             threshold = parentQuality * (1 - actualSelectionPressure.Value / 100.0);
         }
-
-        var pearsonRCalculator = new OnlinePearsonsRCalculator();
-        var targetValuesEnumerator = targetValues.GetEnumerator();
+        var estimatedEnumerator = estimatedValues.GetEnumerator();
+        var targetEnumerator = targetValues.GetEnumerator();
+
+        var rcalc = new OnlinePearsonsRCalculator();
         var trainingPartitionSize = problemData.TrainingPartition.Size;
         var interval = (int)Math.Floor(trainingPartitionSize * RelativeFitnessEvaluationIntervalSize);
 
-        var aggregateStatistics = AggregateStatisticsParameter.Value.Value;
-        var i = 0;
-        if (aggregateStatistics) {
+        var calculatedRows = 0;
+        #region aggregate statistics
+        if (AggregateStatistics) {
           var trainingEnd = problemData.TrainingPartition.End;
           var qualityPerInterval = new List<double>();
-          while (targetValuesEnumerator.MoveNext() && e.MoveNext()) {
-            pearsonRCalculator.Add(targetValuesEnumerator.Current, e.Current);
-            ++i;
-            if (i % interval == 0 || i == trainingPartitionSize) {
-              var q = pearsonRCalculator.ErrorState != OnlineCalculatorError.None ? double.NaN : pearsonRCalculator.R;
-              qualityPerInterval.Add(q * q);
-            }
-          }
-          var r = pearsonRCalculator.ErrorState != OnlineCalculatorError.None ? double.NaN : pearsonRCalculator.R;
+          while (estimatedEnumerator.MoveNext() & targetEnumerator.MoveNext()) {
+            var estimated = estimatedEnumerator.Current;
+            var target = targetEnumerator.Current;
+            rcalc.Add(estimated, target);
+            ++calculatedRows;
+            if (calculatedRows % interval == 0 || calculatedRows == trainingPartitionSize) {
+              var r = rcalc.ErrorState == OnlineCalculatorError.None ? rcalc.R : 0d;
+              qualityPerInterval.Add(r * r);
+            }
+          }
+          double quality;
+          {
+            var r = rcalc.ErrorState != OnlineCalculatorError.None ? 0d : rcalc.R;
+            var actualQuality = r * r;
+            quality = actualQuality;
+            bool predictedRejected = false;
+
+            calculatedRows = 0;
+            foreach (var q in qualityPerInterval) {
+              if (double.IsNaN(q) || !(q > threshold)) {
+                predictedRejected = true;
+                quality = q;
+                break;
+              }
+              ++calculatedRows;
+            }
+
+            var actuallyRejected = !(actualQuality > parentQuality);
+
+            if (RejectedStats.Rows == 0 || TotalStats.Rows == 0) {
+              RejectedStats = new IntMatrix(2, qualityPerInterval.Count);
+              RejectedStats.RowNames = new[] { "Predicted", "Actual" };
+              RejectedStats.ColumnNames = Enumerable.Range(1, RejectedStats.Columns).Select(x => string.Format("0-{0}", Math.Min(trainingEnd, x * interval)));
+              TotalStats = new IntMatrix(2, 2);
+              TotalStats.RowNames = new[] { "Predicted", "Actual" };
+              TotalStats.ColumnNames = new[] { "Rejected", "Not Rejected" };
+            }
+            // gather some statistics
+            if (predictedRejected) {
+              RejectedStats[0, calculatedRows]++;
+              TotalStats[0, 0]++;
+            } else {
+              TotalStats[0, 1]++;
+            }
+            if (actuallyRejected) {
+              TotalStats[1, 0]++;
+            } else {
+              TotalStats[1, 1]++;
+            }
+            if (predictedRejected && actuallyRejected) {
+              RejectedStats[1, calculatedRows]++;
+            }
+          }
+          return quality;
+        }
+        #endregion
+        else {
+          while (estimatedEnumerator.MoveNext() & targetEnumerator.MoveNext()) {
+            rcalc.Add(targetEnumerator.Current, estimatedEnumerator.Current);
+            ++calculatedRows;
+            if (calculatedRows % interval == 0 || calculatedRows == trainingPartitionSize) {
+              var q = rcalc.ErrorState != OnlineCalculatorError.None ? double.NaN : rcalc.R;
+              var quality = q * q;
+              if (!(quality > threshold)) {
+                AdjustedEvaluatedSolutions += (double)calculatedRows / problemData.TrainingPartition.Size;
+                return quality;
+              }
+            }
+          }
+          var r = rcalc.ErrorState != OnlineCalculatorError.None ? double.NaN : rcalc.R;
           var actualQuality = r * r;
-
-          bool predictedRejected = false;
-
-          i = 0;
-          double quality = actualQuality;
-          foreach (var q in qualityPerInterval) {
-            if (double.IsNaN(q) || !(q > threshold)) {
-              predictedRejected = true;
-              quality = q;
-              break;
-            }
-            ++i;
-          }
-
-          var actuallyRejected = !(actualQuality > parentQuality);
-
-          if (RejectedStats.Rows == 0 || TotalStats.Rows == 0) {
-            RejectedStats = new IntMatrix(2, qualityPerInterval.Count);
-            RejectedStats.RowNames = new[] { "Predicted", "Actual" };
-            RejectedStats.ColumnNames = Enumerable.Range(1, RejectedStats.Columns).Select(x => string.Format("0-{0}", Math.Min(trainingEnd, x * interval)));
-            TotalStats = new IntMatrix(2, 2);
-            TotalStats.RowNames = new[] { "Predicted", "Actual" };
-            TotalStats.ColumnNames = new[] { "Rejected", "Not Rejected" };
-          }
-          // gather some statistics
-          if (predictedRejected) {
-            RejectedStats[0, i]++;
-            TotalStats[0, 0]++;
-          } else {
-            TotalStats[0, 1]++;
-          }
-          if (actuallyRejected) {
-            TotalStats[1, 0]++;
-          } else {
-            TotalStats[1, 1]++;
-          }
-          if (predictedRejected && actuallyRejected) {
-            RejectedStats[1, i]++;
-          }
-          return quality;
-        } else {
-          while (targetValuesEnumerator.MoveNext() && e.MoveNext()) {
-            pearsonRCalculator.Add(targetValuesEnumerator.Current, e.Current);
-            ++i;
-            if (i % interval == 0 || i == trainingPartitionSize) {
-              var q = pearsonRCalculator.ErrorState != OnlineCalculatorError.None ? double.NaN : pearsonRCalculator.R;
-              var quality = q * q;
-              if (!(quality > threshold))
-                return quality;
-            }
-          }
-          var r = pearsonRCalculator.ErrorState != OnlineCalculatorError.None ? double.NaN : pearsonRCalculator.R;
-          var actualQuality = r * r;
+          AdjustedEvaluatedSolutions += 1d;
           return actualQuality;
         }
-      #endregion
+        #endregion
       } else {
         var lsc = new OnlineLinearScalingParameterCalculator();
         var rcalc = new OnlinePearsonsRCalculator();
-        var actualQuality = SymbolicRegressionSingleObjectivePearsonRSquaredEvaluator.Calculate(SymbolicDataAnalysisTreeInterpreterParameter.ActualValue, SymbolicExpressionTreeParameter.ActualValue, estimationLimits.Lower, estimationLimits.Upper, problemData, rows, true);
-
-        var values = estimatedValues.Zip(targetValues, (es, t) => new { Estimated = es, Target = t });
-        int calculatedRows = 0;
-        double quality = 0.0;
-
-        foreach (var value in values) {
-          lsc.Add(value.Estimated, value.Target);
-          rcalc.Add(value.Estimated, value.Target);
+        var interval = (int)Math.Round(RelativeFitnessEvaluationIntervalSize * problemData.TrainingPartition.Size);
+        var quality = 0d;
+        var calculatedRows = 0;
+
+        var cache = PreserveResultCompatibility ? new List<double>(problemData.TrainingPartition.Size) : null;
+        foreach (var target in estimatedValues.Zip(targetValues, (e, t) => new { EstimatedValue = e, ActualValue = t })) {
+          if (cache != null)
+            cache.Add(target.EstimatedValue);
+
+          lsc.Add(target.EstimatedValue, target.ActualValue);
+          rcalc.Add(target.EstimatedValue, target.ActualValue);
+
           calculatedRows++;
 
-          if (calculatedRows % 5 == 0) {
+          if (calculatedRows % interval != 0) continue;
+
+          var alpha = lsc.Alpha;
+          var beta = lsc.Beta;
+          if (lsc.ErrorState != OnlineCalculatorError.None) {
+            alpha = 0;
+            beta = 1;
+          }
+
+          var calc = (OnlinePearsonsRCalculator)rcalc.Clone();
+          foreach (var t in targetValues.Skip(calculatedRows)) {
+            var s = (t - alpha) / beta; // scaled target
+            calc.Add(s, t); // add pair (scaled, target) to the calculator
+          }
+          var r = calc.ErrorState == OnlineCalculatorError.None ? calc.R : 0d;
+          quality = r * r;
+
+          if (!(quality > parentQuality)) {
+            AdjustedEvaluatedSolutions += (double)calculatedRows / problemData.TrainingPartition.Size;
+            return quality;
+          }
+        }
+        if (PreserveResultCompatibility) {
+          // get quality for all the rows. to ensure reproducibility of results between this evaluator
+          // and the standard one, we calculate the quality in an identical way (otherwise the returned 
+          // quality could be slightly off due to rounding errors (in the range 1e-15 to 1e-16)
+          var applyLinearScaling = ApplyLinearScalingParameter.ActualValue.Value;
+          double r;
+          OnlineCalculatorError calculatorError;
+
+          if (applyLinearScaling) {
             var alpha = lsc.Alpha;
             var beta = lsc.Beta;
-
-            OnlinePearsonsRCalculator calc = (OnlinePearsonsRCalculator)rcalc.Clone();
-            foreach (var t in targetValues.Skip(calculatedRows)) {
-              var scaledTarget = (t - alpha) / beta;
-              calc.Add(scaledTarget, t);
-            }
-
-            var r = calc.ErrorState == OnlineCalculatorError.None ? calc.R : double.NaN;
-            quality = r * r;
-
-            if (quality < parentQuality && actualQuality > parentQuality) {
-              Debugger.Break();
-            }
-            if (quality < parentQuality) return quality;
-          }
+            if (lsc.ErrorState != OnlineCalculatorError.None) {
+              alpha = 0;
+              beta = 1;
+            }
+            var boundedEstimatedValues = cache.Select(x => x * beta + alpha).LimitToRange(estimationLimits.Lower, estimationLimits.Upper);
+            r = OnlinePearsonsRCalculator.Calculate(boundedEstimatedValues, targetValues, out calculatorError);
+          } else {
+            var boundedEstimatedValues = cache.LimitToRange(estimationLimits.Lower, estimationLimits.Upper);
+            r = OnlinePearsonsRCalculator.Calculate(boundedEstimatedValues, targetValues, out calculatorError);
+          }
+          quality = calculatorError == OnlineCalculatorError.None ? r * r : 0d;
         }
-
-        //calculate quality for all rows
-        {
-          var r = rcalc.ErrorState == OnlineCalculatorError.None ? rcalc.R : double.NaN;
-          quality = r * r;
-          if (quality < parentQuality && actualQuality > parentQuality) {
-            Debugger.Break();
-          }
-          if (double.IsNaN(quality)) quality = 0.0;
-          if (quality != actualQuality) Debugger.Break();
-
-          //necessary due to rounding errors and diff in the range of 10E-8
-          quality = actualQuality;
-        }
-
+        AdjustedEvaluatedSolutions += 1d;
         return quality;
       }
