Index: /branches/MemPRAlgorithm/HeuristicLab.Algorithms.MemPR/3.3/MemPRAlgorithm.cs
===================================================================
--- /branches/MemPRAlgorithm/HeuristicLab.Algorithms.MemPR/3.3/MemPRAlgorithm.cs	(revision 14679)
+++ /branches/MemPRAlgorithm/HeuristicLab.Algorithms.MemPR/3.3/MemPRAlgorithm.cs	(revision 14680)
@@ -248,5 +248,5 @@
           Context.AddToPopulation(child);
           Context.BestQuality = child.Fitness;
-          Analyze(token);
+          Analyze(CancellationToken.None);
           token.ThrowIfCancellationRequested();
           if (Terminate()) return;
Index: /branches/MemPRAlgorithm/HeuristicLab.Algorithms.MemPR/3.3/MemPRContext.cs
===================================================================
--- /branches/MemPRAlgorithm/HeuristicLab.Algorithms.MemPR/3.3/MemPRContext.cs	(revision 14679)
+++ /branches/MemPRAlgorithm/HeuristicLab.Algorithms.MemPR/3.3/MemPRContext.cs	(revision 14680)
@@ -346,4 +346,5 @@
     #region Breeding Performance
     public void AddBreedingResult(ISingleObjectiveSolutionScope<TSolution> a, ISingleObjectiveSolutionScope<TSolution> b, double parentDist, ISingleObjectiveSolutionScope<TSolution> child) {
+      return;
       if (IsBetter(a, b))
         breedingStat.Add(Tuple.Create(a.Fitness, b.Fitness, parentDist, child.Fitness));
@@ -352,7 +353,9 @@
     }
     public void RelearnBreedingPerformanceModel() {
+      return;
       breedingPerformanceModel = RunRegression(PrepareRegression(ToListRow(breedingStat)), breedingPerformanceModel).Model;
     }
     public bool BreedingSuited(ISingleObjectiveSolutionScope<TSolution> p1, ISingleObjectiveSolutionScope<TSolution> p2, double dist) {
+      return true;
       if (breedingPerformanceModel == null) return true;
       double minI1 = double.MaxValue, minI2 = double.MaxValue, maxI1 = double.MinValue, maxI2 = double.MinValue;
@@ -372,4 +375,5 @@
     #region Relinking Performance
     public void AddRelinkingResult(ISingleObjectiveSolutionScope<TSolution> a, ISingleObjectiveSolutionScope<TSolution> b, double parentDist, ISingleObjectiveSolutionScope<TSolution> child) {
+      return;
       if (IsBetter(a, b))
         relinkingStat.Add(Tuple.Create(a.Fitness, b.Fitness, parentDist, Maximization ? child.Fitness - a.Fitness : a.Fitness - child.Fitness));
@@ -378,7 +382,9 @@
     }
     public void RelearnRelinkingPerformanceModel() {
+      return;
       relinkingPerformanceModel = RunRegression(PrepareRegression(ToListRow(relinkingStat)), relinkingPerformanceModel).Model;
     }
     public bool RelinkSuited(ISingleObjectiveSolutionScope<TSolution> p1, ISingleObjectiveSolutionScope<TSolution> p2, double dist) {
+      return true;
       if (relinkingPerformanceModel == null) return true;
       double minI1 = double.MaxValue, minI2 = double.MaxValue, maxI1 = double.MinValue, maxI2 = double.MinValue;
@@ -401,4 +407,5 @@
     #region Delinking Performance
     public void AddDelinkingResult(ISingleObjectiveSolutionScope<TSolution> a, ISingleObjectiveSolutionScope<TSolution> b, double parentDist, ISingleObjectiveSolutionScope<TSolution> child) {
+      return;
       if (IsBetter(a, b))
         delinkingStat.Add(Tuple.Create(a.Fitness, b.Fitness, parentDist, Maximization ? child.Fitness - a.Fitness : a.Fitness - child.Fitness));
@@ -407,7 +414,9 @@
     }
     public void RelearnDelinkingPerformanceModel() {
+      return;
       delinkingPerformanceModel = RunRegression(PrepareRegression(ToListRow(delinkingStat)), delinkingPerformanceModel).Model;
     }
     public bool DelinkSuited(ISingleObjectiveSolutionScope<TSolution> p1, ISingleObjectiveSolutionScope<TSolution> p2, double dist) {
+      return true;
       if (delinkingPerformanceModel == null) return true;
       double minI1 = double.MaxValue, minI2 = double.MaxValue, maxI1 = double.MinValue, maxI2 = double.MinValue;
@@ -429,11 +438,14 @@
     #region Sampling Performance
     public void AddSamplingResult(ISingleObjectiveSolutionScope<TSolution> sample, double avgDist) {
+      return;
       samplingStat.Add(Tuple.Create(avgDist, sample.Fitness));
       if (samplingStat.Count % 10 == 0) RelearnSamplingPerformanceModel();
     }
     public void RelearnSamplingPerformanceModel() {
+      return;
       samplingPerformanceModel = RunRegression(PrepareRegression(ToListRow(samplingStat)), samplingPerformanceModel).Model;
     }
     public bool SamplingSuited(double avgDist) {
+      return true;
       if (samplingPerformanceModel == null) return true;
       if (avgDist < samplingStat.Min(x => x.Item1) || avgDist > samplingStat.Max(x => x.Item1)) return true;
@@ -444,11 +456,14 @@
     #region Hillclimbing Performance
     public void AddHillclimbingResult(ISingleObjectiveSolutionScope<TSolution> input, ISingleObjectiveSolutionScope<TSolution> outcome) {
+      return;
       hillclimbingStat.Add(Tuple.Create(input.Fitness, Maximization ? outcome.Fitness - input.Fitness : input.Fitness - outcome.Fitness));
       if (hillclimbingStat.Count % 10 == 0) RelearnHillclimbingPerformanceModel();
     }
     public void RelearnHillclimbingPerformanceModel() {
+      return;
       hillclimbingPerformanceModel = RunRegression(PrepareRegression(ToListRow(hillclimbingStat)), hillclimbingPerformanceModel).Model;
     }
     public bool HillclimbingSuited(double startingFitness) {
+      return true;
       if (hillclimbingPerformanceModel == null) return true;
       if (startingFitness < HillclimbingStat.Min(x => x.Item1) || startingFitness > HillclimbingStat.Max(x => x.Item1))
@@ -460,11 +475,14 @@
     #region Adaptivewalking Performance
     public void AddAdaptivewalkingResult(ISingleObjectiveSolutionScope<TSolution> input, ISingleObjectiveSolutionScope<TSolution> outcome) {
+      return;
       adaptivewalkingStat.Add(Tuple.Create(input.Fitness, Maximization ? outcome.Fitness - input.Fitness : input.Fitness - outcome.Fitness));
       if (adaptivewalkingStat.Count % 10 == 0) RelearnAdaptiveWalkPerformanceModel();
     }
     public void RelearnAdaptiveWalkPerformanceModel() {
+      return;
       adaptiveWalkPerformanceModel = RunRegression(PrepareRegression(ToListRow(adaptivewalkingStat)), adaptiveWalkPerformanceModel).Model;
     }
     public bool AdaptivewalkingSuited(double startingFitness) {
+      return true;
       if (adaptiveWalkPerformanceModel == null) return true;
       if (startingFitness < AdaptivewalkingStat.Min(x => x.Item1) || startingFitness > AdaptivewalkingStat.Max(x => x.Item1))
Index: /branches/MemPRAlgorithm/HeuristicLab.Data/3.3/EnumValue.cs
===================================================================
--- /branches/MemPRAlgorithm/HeuristicLab.Data/3.3/EnumValue.cs	(revision 14679)
+++ /branches/MemPRAlgorithm/HeuristicLab.Data/3.3/EnumValue.cs	(revision 14680)
@@ -52,6 +52,4 @@
     private EnumValue(EnumValue<T> original, Cloner cloner)
       : base(original, cloner) {
-      this.value = original.value;
-      this.readOnly = original.readOnly;
     }
 
@@ -64,3 +62,16 @@
     }
   }
+
+  public static class EnumHelper {
+    public static T SetFlag<T>(this Enum value, T flag, bool set) {
+      var baseType = Enum.GetUnderlyingType(value.GetType());
+      dynamic valueAsBase = Convert.ChangeType(value, baseType);
+      dynamic flagAsBase = Convert.ChangeType(flag, baseType);
+      if (set)
+        valueAsBase |= flagAsBase;
+      else
+        valueAsBase &= ~flagAsBase;
+      return (T)valueAsBase;
+    }
+  }
 }
Index: /branches/MemPRAlgorithm/HeuristicLab.Data/3.3/HeuristicLab.Data-3.3.csproj
===================================================================
--- /branches/MemPRAlgorithm/HeuristicLab.Data/3.3/HeuristicLab.Data-3.3.csproj	(revision 14679)
+++ /branches/MemPRAlgorithm/HeuristicLab.Data/3.3/HeuristicLab.Data-3.3.csproj	(revision 14680)
@@ -108,4 +108,5 @@
   </PropertyGroup>
   <ItemGroup>
+    <Reference Include="Microsoft.CSharp" />
     <Reference Include="System" />
     <Reference Include="System.Core">
Index: /branches/MemPRAlgorithm/HeuristicLab.Data/3.3/ValueTypeMatrix.cs
===================================================================
--- /branches/MemPRAlgorithm/HeuristicLab.Data/3.3/ValueTypeMatrix.cs	(revision 14679)
+++ /branches/MemPRAlgorithm/HeuristicLab.Data/3.3/ValueTypeMatrix.cs	(revision 14680)
@@ -201,4 +201,16 @@
     }
 
+    public virtual IEnumerable<T> GetRow(int row) {
+      for (var col = 0; col < Columns; col++) {
+        yield return matrix[row, col];
+      }
+    }
+
+    public virtual IEnumerable<T> GetColumn(int col) {
+      for (var row = 0; row < Rows; row++) {
+        yield return matrix[row, col];
+      }
+    }
+
     public override string ToString() {
       if (matrix.Length == 0) return "[]";
Index: anches/MemPRAlgorithm/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/HammingSimilarityCalculator.cs
===================================================================
--- /branches/MemPRAlgorithm/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/HammingSimilarityCalculator.cs	(revision 14679)
+++ 	(revision )
@@ -1,66 +1,0 @@
-﻿#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 System;
-using HeuristicLab.Common;
-using HeuristicLab.Core;
-using HeuristicLab.Optimization.Operators;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-
-namespace HeuristicLab.Encodings.BinaryVectorEncoding {
-  [Item("Hamming Similarity Calculator for BinaryVector", "Calculates the solution similarity based on the Hamming distance between two binary vectors.")]
-  [StorableClass]
-  public sealed class HammingSimilarityCalculator : SingleObjectiveSolutionSimilarityCalculator {
-    protected override bool IsCommutative {
-      get { return true; }
-    }
-
-    [StorableConstructor]
-    private HammingSimilarityCalculator(bool deserializing) : base(deserializing) { }
-    private HammingSimilarityCalculator(HammingSimilarityCalculator original, Cloner cloner) : base(original, cloner) { }
-    public HammingSimilarityCalculator() { }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new HammingSimilarityCalculator(this, cloner);
-    }
-
-    public static double CalculateSimilarity(BinaryVector left, BinaryVector right) {
-      if (left == null || right == null)
-        throw new ArgumentException("Cannot calculate similarity because one or both of the provided scopes is null.");
-      if (left.Length != right.Length)
-        throw new ArgumentException("Cannot calculate similarity because the provided solutions have different lengths.");
-      if (left == right) return 1.0;
-
-      double similarity = 0.0;
-      for (int i = 0; i < left.Length; i++)
-        if (left[i] == right[i]) similarity++;
-      return similarity / left.Length;
-
-    }
-
-    public override double CalculateSolutionSimilarity(IScope leftSolution, IScope rightSolution) {
-      var left = leftSolution.Variables[SolutionVariableName].Value as BinaryVector;
-      var right = rightSolution.Variables[SolutionVariableName].Value as BinaryVector;
-
-      return CalculateSimilarity(left, right);
-    }
-  }
-}
Index: /branches/MemPRAlgorithm/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/HeuristicLab.Encodings.BinaryVectorEncoding-3.3.csproj
===================================================================
--- /branches/MemPRAlgorithm/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/HeuristicLab.Encodings.BinaryVectorEncoding-3.3.csproj	(revision 14679)
+++ /branches/MemPRAlgorithm/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/HeuristicLab.Encodings.BinaryVectorEncoding-3.3.csproj	(revision 14680)
@@ -127,5 +127,5 @@
     <Compile Include="Crossovers\NPointCrossover.cs" />
     <Compile Include="BinaryVector.cs" />
-    <Compile Include="HammingSimilarityCalculator.cs" />
+    <Compile Include="SimilarityCalculators\HammingSimilarityCalculator.cs" />
     <Compile Include="Interfaces\IBinaryVectorMultiNeighborhoodShakingOperator.cs" />
     <Compile Include="Interfaces\IOneBitflipMoveOperator.cs" />
Index: /branches/MemPRAlgorithm/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/SimilarityCalculators/HammingSimilarityCalculator.cs
===================================================================
--- /branches/MemPRAlgorithm/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/SimilarityCalculators/HammingSimilarityCalculator.cs	(revision 14680)
+++ /branches/MemPRAlgorithm/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/SimilarityCalculators/HammingSimilarityCalculator.cs	(revision 14680)
@@ -0,0 +1,66 @@
+﻿#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 System;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Optimization.Operators;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.BinaryVectorEncoding {
+  [Item("Hamming Similarity Calculator for BinaryVector", "Calculates the solution similarity based on the Hamming distance between two binary vectors.")]
+  [StorableClass]
+  public sealed class HammingSimilarityCalculator : SingleObjectiveSolutionSimilarityCalculator {
+    protected override bool IsCommutative {
+      get { return true; }
+    }
+
+    [StorableConstructor]
+    private HammingSimilarityCalculator(bool deserializing) : base(deserializing) { }
+    private HammingSimilarityCalculator(HammingSimilarityCalculator original, Cloner cloner) : base(original, cloner) { }
+    public HammingSimilarityCalculator() { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new HammingSimilarityCalculator(this, cloner);
+    }
+
+    public static double CalculateSimilarity(BinaryVector left, BinaryVector right) {
+      if (left == null || right == null)
+        throw new ArgumentException("Cannot calculate similarity because one or both of the provided scopes is null.");
+      if (left.Length != right.Length)
+        throw new ArgumentException("Cannot calculate similarity because the provided solutions have different lengths.");
+      if (left == right) return 1.0;
+
+      double similarity = 0.0;
+      for (int i = 0; i < left.Length; i++)
+        if (left[i] == right[i]) similarity++;
+      return similarity / left.Length;
+
+    }
+
+    public override double CalculateSolutionSimilarity(IScope leftSolution, IScope rightSolution) {
+      var left = leftSolution.Variables[SolutionVariableName].Value as BinaryVector;
+      var right = rightSolution.Variables[SolutionVariableName].Value as BinaryVector;
+
+      return CalculateSimilarity(left, right);
+    }
+  }
+}
Index: /branches/MemPRAlgorithm/HeuristicLab.Optimization.Views/3.3/RunCollectionViews/RunCollectionRLDView.cs
===================================================================
--- /branches/MemPRAlgorithm/HeuristicLab.Optimization.Views/3.3/RunCollectionViews/RunCollectionRLDView.cs	(revision 14679)
+++ /branches/MemPRAlgorithm/HeuristicLab.Optimization.Views/3.3/RunCollectionViews/RunCollectionRLDView.cs	(revision 14680)
@@ -30,4 +30,5 @@
 using HeuristicLab.Analysis;
 using HeuristicLab.Collections;
+using HeuristicLab.Common;
 using HeuristicLab.Core.Views;
 using HeuristicLab.Data;
@@ -334,4 +335,5 @@
       // aggregating over multiple problem instances      
       var maxEfforts = new Dictionary<ProblemDescription, double>();
+      var worstKnowns = new Dictionary<ProblemDescription, double>();
       double minEff = double.MaxValue, maxEff = double.MinValue;
       foreach (var group in groupedRuns) {
@@ -343,6 +345,20 @@
           var bestKnownTarget = problem.Value.Item1;
           var max = problem.Key.IsMaximization();
-          var worstTarget = (max ? (1 - targets.Max()) : (1 + targets.Max())) * bestKnownTarget;
-          var bestTarget = (max ? (1 - targets.Min()) : (1 + targets.Min())) * bestKnownTarget;
+          double worstTarget = 0, bestTarget = 0;
+          if (bestKnownTarget > 0) {
+            worstTarget = (max ? (1 - targets.Max()) : (1 + targets.Max())) * bestKnownTarget;
+            bestTarget = (max ? (1 - targets.Min()) : (1 + targets.Min())) * bestKnownTarget;
+          } else if (bestKnownTarget < 0) {
+            worstTarget = (max ? (1 + targets.Max()) : (1 - targets.Max())) * bestKnownTarget;
+            bestTarget = (max ? (1 + targets.Min()) : (1 - targets.Min())) * bestKnownTarget;
+          } else {
+            var initials = problem.Value.Item2.Select(x => ((IndexedDataTable<double>)x.Results[table]).Rows.First().Values.First().Item2);
+            var worstKnown = max ? initials.Min() : initials.Max();
+            if (!worstKnown.IsAlmost(0)) {
+              worstTarget = targets.Max() * worstKnown;
+              bestTarget = targets.Min() * worstKnown;
+              worstKnowns[problem.Key] = worstKnown;
+            }
+          }
           foreach (var run in problem.Value.Item2) {
             var row = ((IndexedDataTable<double>)run.Results[table]).Rows.First().Values;
@@ -389,8 +405,8 @@
 
             if (aggregateTargetsCheckBox.Checked) {
-              var length = CalculateHitsForAllTargets(hits, misses, resultsTable.Rows.First(), problem.Key, group.Key, problem.Value.Item1, maxEff);
+              var length = CalculateHitsForAllTargets(hits, misses, resultsTable.Rows.First(), problem.Key, group.Key, problem.Value.Item1, worstKnowns.ContainsKey(problem.Key) ? worstKnowns[problem.Key] : 0, maxEff);
               maxLength = Math.Max(length, maxLength);
             } else {
-              CalculateHitsForEachTarget(hits, misses, resultsTable.Rows.First(), problem.Key, group.Key, problem.Value.Item1, maxEff);
+              CalculateHitsForEachTarget(hits, misses, resultsTable.Rows.First(), problem.Key, group.Key, problem.Value.Item1, worstKnowns.ContainsKey(problem.Key) ? worstKnowns[problem.Key] : 0, maxEff);
             }
             noRuns++;
@@ -495,6 +511,19 @@
                                             Dictionary<string, SortedList<double, int>> misses,
                                             IndexedDataRow<double> row, ProblemDescription problem,
-                                            string group, double bestTarget, double maxEffort) {
-      foreach (var t in targets.Select(x => Tuple.Create((problem.IsMaximization() ? (1 - x) : (1 + x)) * bestTarget, x))) {
+                                            string group, double bestTarget, double worstKnown, double maxEffort) {
+      var max = problem.IsMaximization();
+      var targetValues = targets.Select(t => {
+        double target = 0;
+        if (bestTarget > 0) {
+          target = (max ? (1 - t) : (1 + t)) * bestTarget;
+        } else if (bestTarget < 0) {
+          target = (max ? (1 + t) : (1 - t)) * bestTarget;
+        } else {
+          if (!worstKnown.IsAlmost(0))
+            target = t * worstKnown;
+        }
+        return Tuple.Create(target, t);
+      });
+      foreach (var t in targetValues) {
         var l = t.Item1;
         var key = group + "_" + (t.Item2 * 100) + "%_" + l;
@@ -515,8 +544,8 @@
         }
         if (!hit) {
-          var max = Math.Min(row.Values.Last().Item1, maxEffort);
-          if (misses[key].ContainsKey(max))
-            misses[key][max]++;
-          else misses[key][max] = 1;
+          var maxEff = Math.Min(row.Values.Last().Item1, maxEffort);
+          if (misses[key].ContainsKey(maxEff))
+            misses[key][maxEff]++;
+          else misses[key][maxEff] = 1;
         }
       }
@@ -526,5 +555,5 @@
                                               Dictionary<string, SortedList<double, int>> misses,
                                               IndexedDataRow<double> row, ProblemDescription problem,
-                                              string group, double bestTarget, double maxEffort) {
+                                              string group, double bestTarget, double worstKnown, double maxEffort) {
       var values = row.Values;
       if (!hits.ContainsKey(group)) {
@@ -536,5 +565,14 @@
       var j = 0;
       while (i < targets.Length && j < values.Count) {
-        var target = (problem.IsMaximization() ? (1 - targets[i]) : (1 + targets[i])) * bestTarget;
+        var max = problem.IsMaximization();
+        double target = 0;
+        if (bestTarget > 0) {
+          target = (max ? (1 - targets[i]) : (1 + targets[i])) * bestTarget;
+        } else if (bestTarget < 0) {
+          target = (max ? (1 + targets[i]) : (1 - targets[i])) * bestTarget;
+        } else {
+          if (!worstKnown.IsAlmost(0))
+            target = targets[i] * worstKnown;
+        }
         var current = values[j];
         if (current.Item1 > maxEffort) break;
