Index: branches/Parameter-less Population Pyramid/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/EnumerableBoolEqualityComparer.cs
===================================================================
--- branches/Parameter-less Population Pyramid/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/EnumerableBoolEqualityComparer.cs	(revision 11668)
+++ branches/Parameter-less Population Pyramid/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/EnumerableBoolEqualityComparer.cs	(revision 11669)
@@ -23,6 +23,4 @@
 using System.Collections.Generic;
 using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 
 namespace HeuristicLab.Algorithms.ParameterlessPopulationPyramid {
@@ -45,4 +43,8 @@
         }
       }
+      // combine in any remaining content
+      if (word > 1) {
+        hash ^= word;
+      }
       return hash;
     }
Index: branches/Parameter-less Population Pyramid/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/HeuristicLab.Algorithms.ParameterlessPopulationPyramid-3.3.csproj
===================================================================
--- branches/Parameter-less Population Pyramid/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/HeuristicLab.Algorithms.ParameterlessPopulationPyramid-3.3.csproj	(revision 11668)
+++ branches/Parameter-less Population Pyramid/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/HeuristicLab.Algorithms.ParameterlessPopulationPyramid-3.3.csproj	(revision 11669)
@@ -106,5 +106,7 @@
     <Compile Include="EnumerableBoolEqualityComparer.cs" />
     <Compile Include="LinkageCrossover.cs" />
+    <Compile Include="ListExtensions.cs" />
     <Compile Include="Plugin.cs" />
+    <Compile Include="Problems\DeceptiveStepTrapProblem.cs" />
     <Compile Include="Problems\DeceptiveTrapProblem.cs" />
     <Compile Include="HillClimber.cs" />
Index: branches/Parameter-less Population Pyramid/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/LinkageTree.cs
===================================================================
--- branches/Parameter-less Population Pyramid/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/LinkageTree.cs	(revision 11668)
+++ branches/Parameter-less Population Pyramid/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/LinkageTree.cs	(revision 11669)
@@ -27,36 +27,5 @@
 
 namespace HeuristicLab.Algorithms.ParameterlessPopulationPyramid {
-  public static class ListExtensions {
-    public static IList<T> Swap<T>(this IList<T> list, int indexA, int indexB) {
-      T tmp = list[indexA];
-      list[indexA] = list[indexB];
-      list[indexB] = tmp;
-      return list;
-    }
-    public static IList<T> ShuffleInPlace<T>(this IList<T> list, IRandom random) {
-      return list.ShuffleInPlace(random, 0, list.Count - 1);
-    }
-    public static IList<T> ShuffleInPlace<T>(this IList<T> list, IRandom random, int maxIndex) {
-      return list.ShuffleInPlace(random, 0, maxIndex);
-    }
-    public static IList<T> ShuffleInPlace<T>(this IList<T> list, IRandom random, int minIndex, int maxIndex) {
-      for (int i = maxIndex; i > minIndex; i--) {
-        int swapIndex = random.Next(minIndex, i + 1);
-        list.Swap(i, swapIndex);
-      }
-      return list;
-    }
-
-    public static IEnumerable<T> ShuffleList<T>(this IList<T> source, IRandom random) {
-      for (int i = source.Count - 1; i > 0; i--) {
-        // Swap element "i" with a random earlier element (including itself)
-        int swapIndex = random.Next(i + 1);
-        source.Swap(i, swapIndex);
-        yield return source[i];
-      }
-      yield return source[0];
-    }
-
-  }
+  
   public class LinkageTree {
 
Index: branches/Parameter-less Population Pyramid/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/ListExtensions.cs
===================================================================
--- branches/Parameter-less Population Pyramid/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/ListExtensions.cs	(revision 11669)
+++ branches/Parameter-less Population Pyramid/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/ListExtensions.cs	(revision 11669)
@@ -0,0 +1,41 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using HeuristicLab.Core;
+
+namespace HeuristicLab.Algorithms.ParameterlessPopulationPyramid {
+  public static class ListExtensions {
+    public static IList<T> Swap<T>(this IList<T> list, int indexA, int indexB) {
+      T tmp = list[indexA];
+      list[indexA] = list[indexB];
+      list[indexB] = tmp;
+      return list;
+    }
+
+    public static IList<T> ShuffleInPlace<T>(this IList<T> list, IRandom random) {
+      return list.ShuffleInPlace(random, 0, list.Count - 1);
+    }
+    public static IList<T> ShuffleInPlace<T>(this IList<T> list, IRandom random, int maxIndex) {
+      return list.ShuffleInPlace(random, 0, maxIndex);
+    }
+    public static IList<T> ShuffleInPlace<T>(this IList<T> list, IRandom random, int minIndex, int maxIndex) {
+      for (int i = maxIndex; i > minIndex; i--) {
+        int swapIndex = random.Next(minIndex, i + 1);
+        list.Swap(i, swapIndex);
+      }
+      return list;
+    }
+
+    public static IEnumerable<T> ShuffleList<T>(this IList<T> source, IRandom random) {
+      for (int i = source.Count - 1; i > 0; i--) {
+        // Swap element "i" with a random earlier element (including itself)
+        int swapIndex = random.Next(i + 1);
+        source.Swap(i, swapIndex);
+        yield return source[i];
+      }
+      yield return source[0];
+    }
+  }
+}
Index: branches/Parameter-less Population Pyramid/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/ParameterlessPopulationPyramid.cs
===================================================================
--- branches/Parameter-less Population Pyramid/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/ParameterlessPopulationPyramid.cs	(revision 11668)
+++ branches/Parameter-less Population Pyramid/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/ParameterlessPopulationPyramid.cs	(revision 11669)
@@ -47,11 +47,28 @@
     // Tracks all solutions in Pyramid for quick membership checks
     private HashSet<bool[]> seen = new HashSet<bool[]>(new EnumerableBoolEqualityComparer());
-
+    
+    #region ParameterNames
     private const string MaximumIterationsParameterName = "Maximum Iterations";
-
+    private const string MaximumEvaluationsParameterName = "Maximum Evaluations";
+    private const string SeedParameterName = "Seed";
+    private const string SetSeedRandomlyParameterName = "SetSeedRandomly";
+    #endregion
+    
+    #region ParameterProperties
     public IFixedValueParameter<IntValue> MaximumIterationsParameter {
       get { return (IFixedValueParameter<IntValue>)Parameters[MaximumIterationsParameterName]; }
     }
-
+    public IFixedValueParameter<IntValue> MaximumEvaluationsParameter {
+      get { return (IFixedValueParameter<IntValue>)Parameters[MaximumEvaluationsParameterName]; }
+    }
+    public IFixedValueParameter<IntValue> SeedParameter {
+      get { return (IFixedValueParameter<IntValue>)Parameters[SeedParameterName]; }
+    }
+    public FixedValueParameter<BoolValue> SetSeedRandomlyParameter {
+      get { return (FixedValueParameter<BoolValue>)Parameters[SetSeedRandomlyParameterName]; }
+    }
+    #endregion
+
+    #region Properties
     public int MaximumIterations {
       get { return MaximumIterationsParameter.Value.Value; }
@@ -59,10 +76,4 @@
     }
 
-    private const string MaximumEvaluationsParameterName = "Maximum Evaluations";
-
-    public IFixedValueParameter<IntValue> MaximumEvaluationsParameter {
-      get { return (IFixedValueParameter<IntValue>)Parameters[MaximumEvaluationsParameterName]; }
-    }
-
     public int MaximumEvaluations {
       get { return MaximumEvaluationsParameter.Value.Value; }
@@ -70,11 +81,4 @@
     }
 
-
-    private const string SeedParameterName = "Seed";
-
-    public IFixedValueParameter<IntValue> SeedParameter {
-      get { return (IFixedValueParameter<IntValue>)Parameters[SeedParameterName]; }
-    }
-
     public int Seed {
       get { return SeedParameter.Value.Value; }
@@ -82,14 +86,9 @@
     }
 
-    private const string SetSeedRandomlyParameterName = "SetSeedRandomly";
-
-    public FixedValueParameter<BoolValue> SetSeedRandomlyParameter {
-      get { return (FixedValueParameter<BoolValue>)Parameters[SetSeedRandomlyParameterName]; }
-    }
-
     public bool SetSeedRandomly {
       get { return SetSeedRandomlyParameter.Value.Value; }
       set { SetSeedRandomlyParameter.Value.Value = value; }
     }
+    #endregion
 
     #region ResultsProperties
@@ -128,5 +127,4 @@
       get { return ResultsQualities.Rows["Iteration Quality"]; }
     }
-
     #endregion
 
@@ -183,4 +181,5 @@
 
     protected override void Run() {
+      // Set up the algorithm
       if (SetSeedRandomly) Seed = new System.Random().Next();
       pyramid = new List<Population>();
@@ -188,4 +187,6 @@
       random.Reset(Seed);
       tracker = new EvaluationTracker(Problem, MaximumEvaluations);
+
+      // Set up the results display
       Results.Add(new Result("Iterations", new IntValue(0)));
       Results.Add(new Result("Evaluations", new IntValue(0)));
@@ -199,4 +200,6 @@
       table.Rows.Add(iterationRows);
       Results.Add(new Result("Qualities", table));
+
+      // Loop until iteration limit reached or canceled.
       for (ResultsIterations = 0; ResultsIterations < MaximumIterations; ResultsIterations++) {
         double fitness = double.NaN;
Index: branches/Parameter-less Population Pyramid/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/Population.cs
===================================================================
--- branches/Parameter-less Population Pyramid/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/Population.cs	(revision 11668)
+++ branches/Parameter-less Population Pyramid/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/Population.cs	(revision 11669)
@@ -20,30 +20,26 @@
 #endregion
 
-using System;
 using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 using HeuristicLab.Core;
 
 namespace HeuristicLab.Algorithms.ParameterlessPopulationPyramid {
   public class Population {
-    private readonly List<bool[]> solutions = new List<bool[]>();
-    private LinkageTree tree;
+    public List<bool[]> Solutions {
+      get;
+      private set;
+    }
 
     public LinkageTree Tree {
-      get { return tree; }
-    }
-
-    public List<bool[]> Solutions {
-      get { return solutions; }
+      get;
+      private set;
     }
 
     public Population(int length, IRandom rand) {
-      tree = new LinkageTree(length, rand);
+      Solutions = new List<bool[]>();
+      Tree = new LinkageTree(length, rand);
     }
     public void Add(bool[] solution) {
-      solutions.Add(solution);
-      tree.Add(solution);
+      Solutions.Add(solution);
+      Tree.Add(solution);
     }
   }
Index: branches/Parameter-less Population Pyramid/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/Problems/DeceptiveStepTrapProblem.cs
===================================================================
--- branches/Parameter-less Population Pyramid/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/Problems/DeceptiveStepTrapProblem.cs	(revision 11669)
+++ branches/Parameter-less Population Pyramid/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/Problems/DeceptiveStepTrapProblem.cs	(revision 11669)
@@ -0,0 +1,73 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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.Collections.Generic;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Algorithms.ParameterlessPopulationPyramid {
+  [Item("Deceptive Step Trap Problem", "Genome encodes completely separable blocks, where each block deceptive with fitness plateaus.")]
+  [StorableClass]
+  [Creatable("Parameterless Population Pyramid")]
+  public class DeceptiveStepTrapProblem : DeceptiveTrapProblem {
+    [StorableConstructor]
+    protected DeceptiveStepTrapProblem(bool deserializing) : base(deserializing) { }
+    protected DeceptiveStepTrapProblem(DeceptiveStepTrapProblem original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new DeceptiveStepTrapProblem(this, cloner);
+    }
+
+    private const string StepSizeParameterName = "Step Size";
+
+    public IFixedValueParameter<IntValue> StepSizeParameter {
+      get { return (IFixedValueParameter<IntValue>)Parameters[StepSizeParameterName]; }
+    }
+
+    public int StepSize {
+      get { return StepSizeParameter.Value.Value; }
+      set { StepSizeParameter.Value.Value = value; }
+    }
+
+    public DeceptiveStepTrapProblem()
+      : base() {
+      Parameters.Add(new FixedValueParameter<IntValue>(StepSizeParameterName, "", new IntValue(2)));
+    }
+
+    private int Offset {
+      get { return (TrapSize - StepSize) % StepSize; }
+    }
+
+    protected override int TrapMaximum {
+      get { return (Offset + TrapSize) / StepSize; }
+    }
+
+    protected override int Score(bool[] individual, int trapIndex) {
+      int partial = base.Score(individual, trapIndex);
+      // introduce plateaus using integer division
+      return (Offset + partial) / StepSize;
+    }
+  }
+}
Index: branches/Parameter-less Population Pyramid/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/Problems/DeceptiveTrapProblem.cs
===================================================================
--- branches/Parameter-less Population Pyramid/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/Problems/DeceptiveTrapProblem.cs	(revision 11668)
+++ branches/Parameter-less Population Pyramid/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/Problems/DeceptiveTrapProblem.cs	(revision 11669)
@@ -22,7 +22,4 @@
 using System;
 using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
@@ -59,7 +56,26 @@
       set { TrapSizeParameter.Value.Value = value; }
     }
+
+    protected virtual int TrapMaximum {
+      get { return TrapSize;  }
+    }
+
     public DeceptiveTrapProblem()
       : base() {
-      Parameters.Add(new FixedValueParameter<IntValue>(TrapSizeParameterName, "", new IntValue(5)));
+      Parameters.Add(new FixedValueParameter<IntValue>(TrapSizeParameterName, "", new IntValue(7)));
+      Length = 49;
+    }
+
+    protected virtual int Score(bool[] individual, int trapIndex) {
+      int result = 0;
+      for (int index = trapIndex; index < trapIndex + TrapSize; index++) {
+        if (individual[index]) result++;
+      }
+
+      // Make it deceptive
+      if (result < TrapSize) {
+        result = TrapSize - result - 1;
+      }
+      return result;
     }
 
@@ -68,16 +84,7 @@
       int total = 0;
       for (int i = 0; i < individual.Length; i += TrapSize) {
-        int partial = 0;
-        for (int index = i; index < i + TrapSize; index++) {
-          if (individual[index]) partial++;
-        }
-
-        // Make it deceptive
-        if (partial < TrapSize) {
-          partial = TrapSize - partial - 1;
-        }
-        total += partial;
+        total += Score(individual, i);
       }
-      return total;
+      return (double)(total * TrapSize) / (TrapMaximum * individual.Length);
     }
   }
Index: branches/Parameter-less Population Pyramid/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/Problems/EvaluationTracker.cs
===================================================================
--- branches/Parameter-less Population Pyramid/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/Problems/EvaluationTracker.cs	(revision 11668)
+++ branches/Parameter-less Population Pyramid/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/Problems/EvaluationTracker.cs	(revision 11669)
@@ -22,31 +22,32 @@
 using System;
 using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 
 namespace HeuristicLab.Algorithms.ParameterlessPopulationPyramid {
   public class EvaluationTracker : IBinaryVectorProblem {
     private readonly IBinaryVectorProblem problem;
+
     private int maxEvaluations;
 
-    private double bestQuality = double.NaN;
+    #region Properties
     public double BestQuality {
-      get { return bestQuality; }
+      get;
+      private set;
     }
 
-    private int evaluations = 0;
     public int Evaluations {
-      get { return evaluations; }
+      get;
+      private set;
     }
 
-    private int bestFoundOnEvaluation = 0;
     public int BestFoundOnEvaluation {
-      get { return bestFoundOnEvaluation; }
+      get;
+      private set;
     }
 
     public bool[] BestSolution {
-      get; private set;
+      get;
+      private set;
     }
+    #endregion
 
     public EvaluationTracker(IBinaryVectorProblem problem, int maxEvaluations) {
@@ -54,19 +55,22 @@
       this.maxEvaluations = maxEvaluations;
       BestSolution = new bool[0];
+      BestQuality = double.NaN;
+      Evaluations = 0;
+      BestFoundOnEvaluation = 0;
     }
 
     public double Evaluate(bool[] individual) {
-      if (evaluations >= maxEvaluations) throw new OperationCanceledException("Maximum Evaluation Limit Reached");
-      evaluations++;
+      if (Evaluations >= maxEvaluations) throw new OperationCanceledException("Maximum Evaluation Limit Reached");
+      Evaluations++;
       double fitness = problem.Evaluate(individual);
-      if (double.IsNaN(bestQuality) || problem.IsBetter(fitness, bestQuality)) {
-        bestQuality = fitness;
+      if (double.IsNaN(BestQuality) || problem.IsBetter(fitness, BestQuality)) {
+        BestQuality = fitness;
         BestSolution = (bool[])individual.Clone();
-        bestFoundOnEvaluation = evaluations;
+        BestFoundOnEvaluation = Evaluations;
       }
       return fitness;
     }
 
-
+    #region ForwardedInteraface
     public int Length {
       get { return problem.Length; }
@@ -77,5 +81,6 @@
     public bool IsBetter(double quality, double bestQuality) {
       return problem.IsBetter(quality, bestQuality);
-    }    
+    }
+    #endregion
   }
 }
Index: branches/Parameter-less Population Pyramid/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/Problems/HIFFProblem.cs
===================================================================
--- branches/Parameter-less Population Pyramid/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/Problems/HIFFProblem.cs	(revision 11668)
+++ branches/Parameter-less Population Pyramid/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/Problems/HIFFProblem.cs	(revision 11669)
@@ -22,7 +22,4 @@
 using System;
 using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
@@ -48,5 +45,5 @@
 
     public HIFFProblem() : base() {
-      Length = 32;
+      Length = 64;
     }
 
Index: branches/Parameter-less Population Pyramid/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/Problems/IBinaryVectorProblem.cs
===================================================================
--- branches/Parameter-less Population Pyramid/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/Problems/IBinaryVectorProblem.cs	(revision 11668)
+++ branches/Parameter-less Population Pyramid/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/Problems/IBinaryVectorProblem.cs	(revision 11669)
@@ -20,10 +20,4 @@
 #endregion
 
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
 namespace HeuristicLab.Algorithms.ParameterlessPopulationPyramid {
   public interface IBinaryVectorProblem {
