Index: stable/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/EvaluationTracker.cs
===================================================================
--- stable/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/EvaluationTracker.cs	(revision 12005)
+++ stable/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/EvaluationTracker.cs	(revision 12005)
@@ -0,0 +1,118 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ * and the BEACON Center for the Study of Evolution in Action.
+ *
+ * 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.Data;
+using HeuristicLab.Encodings.BinaryVectorEncoding;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.Binary;
+
+namespace HeuristicLab.Algorithms.ParameterlessPopulationPyramid {
+  // This code is based off the publication
+  // B. W. Goldman and W. F. Punch, "Parameter-less Population Pyramid," GECCO, pp. 785–792, 2014
+  // and the original source code in C++11 available from: https://github.com/brianwgoldman/Parameter-less_Population_Pyramid
+  internal sealed class EvaluationTracker : BinaryProblem {
+    private readonly BinaryProblem problem;
+
+    private int maxEvaluations;
+
+    #region Properties
+    public double BestQuality {
+      get;
+      private set;
+    }
+
+    public int Evaluations {
+      get;
+      private set;
+    }
+
+    public int BestFoundOnEvaluation {
+      get;
+      private set;
+    }
+
+    public BinaryVector BestSolution {
+      get;
+      private set;
+    }
+    #endregion
+
+    [StorableConstructor]
+    private EvaluationTracker(bool deserializing) : base(deserializing) { }
+    private EvaluationTracker(EvaluationTracker original, Cloner cloner)
+      : base(original, cloner) {
+      problem = cloner.Clone(original.problem);
+      maxEvaluations = original.maxEvaluations;
+      BestQuality = original.BestQuality;
+      Evaluations = original.Evaluations;
+      BestFoundOnEvaluation = original.BestFoundOnEvaluation;
+      BestSolution = cloner.Clone(BestSolution);
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new EvaluationTracker(this, cloner);
+    }
+    public EvaluationTracker(BinaryProblem problem, int maxEvaluations) {
+      this.problem = problem;
+      this.maxEvaluations = maxEvaluations;
+      BestSolution = new BinaryVector(Length);
+      BestQuality = double.NaN;
+      Evaluations = 0;
+      BestFoundOnEvaluation = 0;
+
+      if (Parameters.ContainsKey("Maximization")) Parameters.Remove("Maximization");
+      Parameters.Add(new FixedValueParameter<BoolValue>("Maximization", "Set to false if the problem should be minimized.", (BoolValue)new BoolValue(Maximization).AsReadOnly()) { Hidden = true });
+    }
+
+    public override double Evaluate(BinaryVector vector, IRandom random) {
+      if (Evaluations >= maxEvaluations) throw new OperationCanceledException("Maximum Evaluation Limit Reached");
+      Evaluations++;
+      double fitness = problem.Evaluate(vector, random);
+      if (double.IsNaN(BestQuality) || problem.IsBetter(fitness, BestQuality)) {
+        BestQuality = fitness;
+        BestSolution = (BinaryVector)vector.Clone();
+        BestFoundOnEvaluation = Evaluations;
+      }
+      return fitness;
+    }
+
+    public override int Length {
+      get { return problem.Length; }
+      set { problem.Length = value; }
+    }
+
+    public override bool Maximization {
+      get {
+        if (problem == null) return false;
+        return problem.Maximization;
+      }
+    }
+
+    public bool IsBetter(double quality, double bestQuality) {
+      return problem.IsBetter(quality, bestQuality);
+    }
+
+  }
+}
Index: stable/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/HeuristicLab.Algorithms.ParameterlessPopulationPyramid-3.3.csproj
===================================================================
--- trunk/sources/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/HeuristicLab.Algorithms.ParameterlessPopulationPyramid-3.3.csproj	(revision 11939)
+++ stable/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/HeuristicLab.Algorithms.ParameterlessPopulationPyramid-3.3.csproj	(revision 12005)
@@ -17,5 +17,5 @@
     <DebugType>full</DebugType>
     <Optimize>false</Optimize>
-    <OutputPath>..\..\..\..\trunk\sources\bin\</OutputPath>
+    <OutputPath>$(SolutionDir)\bin\</OutputPath>
     <DefineConstants>DEBUG;TRACE</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
@@ -25,5 +25,5 @@
     <DebugType>pdbonly</DebugType>
     <Optimize>true</Optimize>
-    <OutputPath>..\..\..\..\trunk\sources\bin\</OutputPath>
+    <OutputPath>$(SolutionDir)\bin\</OutputPath>
     <DefineConstants>TRACE</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
@@ -35,4 +35,40 @@
   <PropertyGroup>
     <AssemblyOriginatorKeyFile>HeuristicLab.snk</AssemblyOriginatorKeyFile>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x64'">
+    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>$(SolutionDir)\bin\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <DebugType>full</DebugType>
+    <PlatformTarget>x64</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x64'">
+    <OutputPath>$(SolutionDir)\bin\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+    <PlatformTarget>x64</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x86'">
+    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>$(SolutionDir)\bin\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <DebugType>full</DebugType>
+    <PlatformTarget>x86</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x86'">
+    <OutputPath>$(SolutionDir)\bin\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+    <PlatformTarget>x86</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
   </PropertyGroup>
   <ItemGroup>
@@ -47,17 +83,11 @@
   <ItemGroup>
     <Compile Include="EnumerableBoolEqualityComparer.cs" />
+    <Compile Include="EvaluationTracker.cs" />
     <Compile Include="LinkageCrossover.cs" />
     <Compile Include="Plugin.cs" />
-    <Compile Include="Problems\DeceptiveStepTrapProblem.cs" />
-    <Compile Include="Problems\DeceptiveTrapProblem.cs" />
     <Compile Include="HillClimber.cs" />
     <Compile Include="LinkageTree.cs" />
     <Compile Include="ParameterlessPopulationPyramid.cs" />
     <Compile Include="Population.cs" />
-    <Compile Include="Problems\BinaryVectorProblem.cs" />
-    <Compile Include="Problems\EvaluationTracker.cs" />
-    <Compile Include="Problems\HIFFProblem.cs" />
-    <Compile Include="Problems\IBinaryVectorProblem.cs" />
-    <Compile Include="Problems\OneMaxProblem.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
   </ItemGroup>
@@ -118,4 +148,9 @@
       <Private>False</Private>
     </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Problems.Binary\3.3\HeuristicLab.Problems.Binary-3.3.csproj">
+      <Project>{fc627be5-0f93-47d8-bd2e-530ea2b8aa5f}</Project>
+      <Name>HeuristicLab.Problems.Binary-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
     <ProjectReference Include="..\..\HeuristicLab.Random\3.3\HeuristicLab.Random-3.3.csproj">
       <Project>{f4539fb6-4708-40c9-be64-0a1390aea197}</Project>
@@ -124,12 +159,21 @@
     </ProjectReference>
   </ItemGroup>
+  <ItemGroup />
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <PropertyGroup>
-    <PreBuildEvent>set Path=%25Path%25;$(ProjectDir);$(SolutionDir)
-set ProjectDir=$(ProjectDir)
-set SolutionDir=$(SolutionDir)
-set Outdir=$(Outdir)
+    <PreBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
+      set Path=%25Path%25;$(ProjectDir);$(SolutionDir)
+      set ProjectDir=$(ProjectDir)
+      set SolutionDir=$(SolutionDir)
+      set Outdir=$(Outdir)
 
-call PreBuildEvent.cmd</PreBuildEvent>
+      call PreBuildEvent.cmd
+    </PreBuildEvent>
+    <PreBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
+      export ProjectDir=$(ProjectDir)
+      export SolutionDir=$(SolutionDir)
+
+      $SolutionDir/PreBuildEvent.sh
+    </PreBuildEvent>
   </PropertyGroup>
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
Index: stable/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/HillClimber.cs
===================================================================
--- trunk/sources/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/HillClimber.cs	(revision 11939)
+++ stable/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/HillClimber.cs	(revision 12005)
@@ -28,7 +28,9 @@
 using HeuristicLab.Core;
 using HeuristicLab.Data;
+using HeuristicLab.Encodings.BinaryVectorEncoding;
 using HeuristicLab.Optimization;
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.Binary;
 using HeuristicLab.Random;
 
@@ -38,7 +40,7 @@
   // B. W. Goldman and W. F. Punch, "Parameter-less Population Pyramid," GECCO, pp. 785–792, 2014
   // and the original source code in C++11 available from: https://github.com/brianwgoldman/Parameter-less_Population_Pyramid
-  [Item("Hill Climber", "Test algorithm.")]
+  [Item("Hill Climber", "Binary Hill Climber.")]
   [StorableClass]
-  [Creatable("Parameterless Population Pyramid")]
+  [Creatable("Algorithms")]
   public class HillClimber : BasicAlgorithm {
     [Storable]
@@ -48,8 +50,8 @@
 
     public override Type ProblemType {
-      get { return typeof(BinaryVectorProblem); }
+      get { return typeof(BinaryProblem); }
     }
-    public new BinaryVectorProblem Problem {
-      get { return (BinaryVectorProblem)base.Problem; }
+    public new BinaryProblem Problem {
+      get { return (BinaryProblem)base.Problem; }
       set { base.Problem = value; }
     }
@@ -82,10 +84,10 @@
       Results.Add(new Result("Best quality", BestQuality));
       for (int iteration = 0; iteration < Iterations; iteration++) {
-        bool[] solution = new bool[Problem.Length];
+        var solution = new BinaryVector(Problem.Length);
         for (int i = 0; i < solution.Length; i++) {
           solution[i] = random.Next(2) == 1;
         }
 
-        var fitness = Problem.Evaluate(solution);
+        var fitness = Problem.Evaluate(solution, random);
 
         fitness = ImproveToLocalOptimum(Problem, solution, fitness, random);
@@ -96,5 +98,5 @@
     }
     // In the GECCO paper, Section 2.1
-    public static double ImproveToLocalOptimum(IBinaryVectorProblem problem, bool[] solution, double fitness, IRandom rand) {
+    public static double ImproveToLocalOptimum(BinaryProblem problem, BinaryVector solution, double fitness, IRandom rand) {
       var tried = new HashSet<int>();
       do {
@@ -103,5 +105,5 @@
           if (tried.Contains(option)) continue;
           solution[option] = !solution[option];
-          double newFitness = problem.Evaluate(solution);
+          double newFitness = problem.Evaluate(solution, rand);
           if (problem.IsBetter(newFitness, fitness)) {
             fitness = newFitness;
Index: stable/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/LinkageCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/LinkageCrossover.cs	(revision 11939)
+++ stable/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/LinkageCrossover.cs	(revision 12005)
@@ -20,10 +20,9 @@
  */
 #endregion
-using System;
 using System.Collections.Generic;
 using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 using HeuristicLab.Core;
+using HeuristicLab.Encodings.BinaryVectorEncoding;
+using HeuristicLab.Problems.Binary;
 using HeuristicLab.Random;
 
@@ -34,5 +33,5 @@
   public static class LinkageCrossover {
     // In the GECCO paper, Figure 3
-    public static double ImproveUsingTree(LinkageTree tree, IList<bool[]> donors, bool[] solution, double fitness, IBinaryVectorProblem problem, IRandom rand) {
+    public static double ImproveUsingTree(LinkageTree tree, IList<BinaryVector> donors, BinaryVector solution, double fitness, BinaryProblem problem, IRandom rand) {
       var options = Enumerable.Range(0, donors.Count).ToArray();
       foreach (var cluster in tree.Clusters) {
@@ -42,5 +41,5 @@
         foreach (var donorIndex in options.ShuffleList(rand)) {
           // Attempt the donation
-          fitness = Donate(solution, fitness, donors[donorIndex], cluster, problem, out donorFound);
+          fitness = Donate(solution, fitness, donors[donorIndex], cluster, problem, rand, out donorFound);
           if (donorFound) break;
         }
@@ -49,5 +48,5 @@
     }
 
-    private static double Donate(bool[] solution, double fitness, bool[] source, IEnumerable<int> cluster, IBinaryVectorProblem problem, out bool changed) {
+    private static double Donate(BinaryVector solution, double fitness, BinaryVector source, IEnumerable<int> cluster, BinaryProblem problem, IRandom rand, out bool changed) {
       // keep track of which bits flipped to make the donation
       List<int> flipped = new List<int>();
@@ -60,5 +59,5 @@
       changed = flipped.Count > 0;
       if (changed) {
-        double newFitness = problem.Evaluate(solution);
+        double newFitness = problem.Evaluate(solution, rand);
         // if the original is strictly better, revert the change
         if (problem.IsBetter(fitness, newFitness)) {
Index: stable/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/LinkageTree.cs
===================================================================
--- trunk/sources/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/LinkageTree.cs	(revision 11939)
+++ stable/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/LinkageTree.cs	(revision 12005)
@@ -26,4 +26,5 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
+using HeuristicLab.Encodings.BinaryVectorEncoding;
 using HeuristicLab.Random;
 
@@ -64,5 +65,5 @@
     }
 
-    public void Add(bool[] solution) {
+    public void Add(BinaryVector solution) {
       if (solution.Length != length) throw new ArgumentException("The individual has not the correct length.");
       for (int i = 1; i < solution.Length; i++) {
Index: stable/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/ParameterlessPopulationPyramid.cs
===================================================================
--- trunk/sources/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/ParameterlessPopulationPyramid.cs	(revision 11939)
+++ stable/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/ParameterlessPopulationPyramid.cs	(revision 12005)
@@ -32,4 +32,5 @@
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.Binary;
 using HeuristicLab.Random;
 
@@ -38,13 +39,13 @@
   // B. W. Goldman and W. F. Punch, "Parameter-less Population Pyramid," GECCO, pp. 785–792, 2014
   // and the original source code in C++11 available from: https://github.com/brianwgoldman/Parameter-less_Population_Pyramid
-  [Item("Parameter-less Population Pyramid", "Binary value optimization algorithm which requires no configuration.")]
+  [Item("Parameter-less Population Pyramid", "Binary value optimization algorithm which requires no configuration. B. W. Goldman and W. F. Punch, Parameter-less Population Pyramid, GECCO, pp. 785–792, 2014")]
   [StorableClass]
-  [Creatable("Parameterless Population Pyramid")]
+  [Creatable("Algorithms")]
   public class ParameterlessPopulationPyramid : BasicAlgorithm {
     public override Type ProblemType {
-      get { return typeof(BinaryVectorProblem); }
-    }
-    public new BinaryVectorProblem Problem {
-      get { return (BinaryVectorProblem)base.Problem; }
+      get { return typeof(BinaryProblem); }
+    }
+    public new BinaryProblem Problem {
+      get { return (BinaryProblem)base.Problem; }
       set { base.Problem = value; }
     }
@@ -55,5 +56,5 @@
 
     // Tracks all solutions in Pyramid for quick membership checks
-    private HashSet<bool[]> seen = new HashSet<bool[]>(new EnumerableBoolEqualityComparer());
+    private HashSet<BinaryVector> seen = new HashSet<BinaryVector>(new EnumerableBoolEqualityComparer());
 
     #region ParameterNames
@@ -178,5 +179,5 @@
     }
 
-    private void AddIfUnique(bool[] solution, int level) {
+    private void AddIfUnique(BinaryVector solution, int level) {
       // Don't add things you have seen
       if (seen.Contains(solution)) return;
@@ -184,5 +185,5 @@
         pyramid.Add(new Population(tracker.Length, random));
       }
-      var copied = (bool[])solution.Clone();
+      var copied = (BinaryVector)solution.Clone();
       pyramid[level].Add(copied);
       seen.Add(copied);
@@ -192,9 +193,9 @@
     private double iterate() {
       // Create a random solution
-      bool[] solution = new bool[tracker.Length];
+      BinaryVector solution = new BinaryVector(tracker.Length);
       for (int i = 0; i < solution.Length; i++) {
         solution[i] = random.Next(2) == 1;
       }
-      double fitness = tracker.Evaluate(solution);
+      double fitness = tracker.Evaluate(solution, random);
       fitness = HillClimber.ImproveToLocalOptimum(tracker, solution, fitness, random);
       AddIfUnique(solution, 0);
@@ -248,6 +249,5 @@
           fitness = iterate();
           cancellationToken.ThrowIfCancellationRequested();
-        }
-        finally {
+        } finally {
           ResultsEvaluations = tracker.Evaluations;
           ResultsBestSolution = new BinaryVector(tracker.BestSolution);
Index: stable/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/Plugin.cs.frame
===================================================================
--- trunk/sources/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/Plugin.cs.frame	(revision 11939)
+++ stable/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/Plugin.cs.frame	(revision 12005)
@@ -40,4 +40,5 @@
   [PluginDependency("HeuristicLab.Parameters", "3.3")]
   [PluginDependency("HeuristicLab.Persistence", "3.3")]
+  [PluginDependency("HeuristicLab.Problems.Binary", "3.3")]
   [PluginDependency("HeuristicLab.Random", "3.3")]
   public class Plugin : PluginBase {
Index: stable/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/Population.cs
===================================================================
--- trunk/sources/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/Population.cs	(revision 11939)
+++ stable/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/Population.cs	(revision 12005)
@@ -23,4 +23,5 @@
 using System.Collections.Generic;
 using HeuristicLab.Core;
+using HeuristicLab.Encodings.BinaryVectorEncoding;
 
 namespace HeuristicLab.Algorithms.ParameterlessPopulationPyramid {
@@ -29,5 +30,5 @@
   // and the original source code in C++11 available from: https://github.com/brianwgoldman/Parameter-less_Population_Pyramid
   public class Population {
-    public List<bool[]> Solutions {
+    public List<BinaryVector> Solutions {
       get;
       private set;
@@ -40,8 +41,8 @@
 
     public Population(int length, IRandom rand) {
-      Solutions = new List<bool[]>();
+      Solutions = new List<BinaryVector>();
       Tree = new LinkageTree(length, rand);
     }
-    public void Add(bool[] solution) {
+    public void Add(BinaryVector solution) {
       Solutions.Add(solution);
       Tree.Add(solution);
