Index: branches/2943_MOBasicProblem_MOCMAES/HeuristicLab.Optimization/3.3/BasicProblems/BasicProblem.cs
===================================================================
--- branches/2943_MOBasicProblem_MOCMAES/HeuristicLab.Optimization/3.3/BasicProblems/BasicProblem.cs	(revision 16123)
+++ branches/2943_MOBasicProblem_MOCMAES/HeuristicLab.Optimization/3.3/BasicProblems/BasicProblem.cs	(revision 16171)
@@ -30,5 +30,5 @@
 namespace HeuristicLab.Optimization {
   [StorableClass]
-  public abstract class BasicProblem<TEncoding, TEvaluator> : HeuristicOptimizationProblem<TEvaluator, ISolutionCreator>, IProblemDefinition, IStorableContent
+  public abstract class BasicProblem<TEncoding, TEvaluator> : HeuristicOptimizationProblem<TEvaluator, ISolutionCreator>, IBasicProblem
     where TEncoding : class, IEncoding
     where TEvaluator : class, IEvaluator {
Index: branches/2943_MOBasicProblem_MOCMAES/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/IBasicProblem.cs
===================================================================
--- branches/2943_MOBasicProblem_MOCMAES/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/IBasicProblem.cs	(revision 16171)
+++ branches/2943_MOBasicProblem_MOCMAES/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/IBasicProblem.cs	(revision 16171)
@@ -0,0 +1,25 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2018 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
+
+namespace HeuristicLab.Optimization {
+  public interface IBasicProblem : IHeuristicOptimizationProblem, IProblemDefinition {
+  }
+}
Index: branches/2943_MOBasicProblem_MOCMAES/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/IMultiObjectiveBasicProblem.cs
===================================================================
--- branches/2943_MOBasicProblem_MOCMAES/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/IMultiObjectiveBasicProblem.cs	(revision 16171)
+++ branches/2943_MOBasicProblem_MOCMAES/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/IMultiObjectiveBasicProblem.cs	(revision 16171)
@@ -0,0 +1,35 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2018 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.Core;
+using HeuristicLab.Data;
+
+namespace HeuristicLab.Optimization {
+  public interface IMultiObjectiveBasicProblem : IBasicProblem, IMultiObjectiveProblemDefinition, IMultiObjectiveHeuristicOptimizationProblem
+  {
+    IValueParameter<DoubleMatrix> BestKnownFrontParameter { get; } 
+    DoubleMatrix BestKnownFront { get; }
+
+    IValueParameter<DoubleArray> ReferencePointParameter { get; }
+    DoubleArray ReferencePoint { get; }
+
+  }
+}
Index: branches/2943_MOBasicProblem_MOCMAES/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/ISingleObjectiveBasicProblem.cs
===================================================================
--- branches/2943_MOBasicProblem_MOCMAES/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/ISingleObjectiveBasicProblem.cs	(revision 16171)
+++ branches/2943_MOBasicProblem_MOCMAES/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/ISingleObjectiveBasicProblem.cs	(revision 16171)
@@ -0,0 +1,30 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2018 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.Core;
+using HeuristicLab.Data;
+
+namespace HeuristicLab.Optimization {
+
+  public interface ISingleObjectiveBasicProblem : IBasicProblem, ISingleObjectiveProblemDefinition, ISingleObjectiveHeuristicOptimizationProblem {
+    double BestKnownQuality { get; }
+  }
+}
Index: branches/2943_MOBasicProblem_MOCMAES/HeuristicLab.Optimization/3.3/BasicProblems/MultiObjectiveBasicProblem.cs
===================================================================
--- branches/2943_MOBasicProblem_MOCMAES/HeuristicLab.Optimization/3.3/BasicProblems/MultiObjectiveBasicProblem.cs	(revision 16123)
+++ branches/2943_MOBasicProblem_MOCMAES/HeuristicLab.Optimization/3.3/BasicProblems/MultiObjectiveBasicProblem.cs	(revision 16171)
@@ -31,6 +31,39 @@
 namespace HeuristicLab.Optimization {
   [StorableClass]
-  public abstract class MultiObjectiveBasicProblem<TEncoding> : BasicProblem<TEncoding, MultiObjectiveEvaluator>, IMultiObjectiveHeuristicOptimizationProblem, IMultiObjectiveProblemDefinition
+  public abstract class MultiObjectiveBasicProblem<TEncoding> : BasicProblem<TEncoding, MultiObjectiveEvaluator>, IMultiObjectiveBasicProblem
   where TEncoding : class, IEncoding {
+
+    #region Parameternames
+    public const string MaximizationParameterName = "Maximization";
+    public const string BestKnownFrontParameterName = "BestKnownFront";
+    public const string ReferencePointParameterName = "ReferencePoint";
+    #endregion
+
+    #region Parameterproperties
+    public IValueParameter<BoolArray> MaximizationParameter {
+      get { return (IValueParameter<BoolArray>) Parameters[MaximizationParameterName]; }
+    }
+    public IValueParameter<DoubleMatrix> BestKnownFrontParameter {
+      get { return (IValueParameter<DoubleMatrix>)Parameters[BestKnownFrontParameterName]; }
+    }
+    public IValueParameter<DoubleArray> ReferencePointParameter {
+      get { return (IValueParameter<DoubleArray>)Parameters[ReferencePointParameterName]; }
+    }
+    #endregion
+
+    #region Properties
+
+    public abstract bool[] Maximization { get; }
+
+    public DoubleMatrix BestKnownFront {
+      get { return Parameters.ContainsKey(BestKnownFrontParameterName) ? BestKnownFrontParameter.Value : null; }
+      set { BestKnownFrontParameter.Value = value; }
+    }
+    public DoubleArray ReferencePoint {
+      get { return Parameters.ContainsKey(ReferencePointParameterName) ? ReferencePointParameter.Value : null; }
+      set { ReferencePointParameter.Value = value; }
+    }
+    #endregion
+
     [StorableConstructor]
     protected MultiObjectiveBasicProblem(bool deserializing) : base(deserializing) { }
@@ -43,6 +76,7 @@
     protected MultiObjectiveBasicProblem()
       : base() {
-      Parameters.Add(new ValueParameter<BoolArray>("Maximization", "Set to false if the problem should be minimized.", (BoolArray)new BoolArray(Maximization).AsReadOnly()));
-
+      Parameters.Add(new ValueParameter<BoolArray>(MaximizationParameterName, "Set to false if the problem should be minimized.", (BoolArray)new BoolArray(Maximization).AsReadOnly()));
+      Parameters.Add(new OptionalValueParameter<DoubleMatrix>(BestKnownFrontParameterName, "A double matrix representing the best known qualites for this problem (aka points on the Pareto front). Points are to be given in a row-wise fashion."));
+      Parameters.Add(new OptionalValueParameter<DoubleArray>(ReferencePointParameterName, "The refrence point for hypervolume calculations on this problem"));
       Operators.Add(Evaluator);
       Operators.Add(new MultiObjectiveAnalyzer());
@@ -56,5 +90,5 @@
     }
 
-    public abstract bool[] Maximization { get; }
+    
     public abstract double[] Evaluate(Individual individual, IRandom random);
     public virtual void Analyze(Individual[] individuals, double[][] qualities, ResultCollection results, IRandom random) { }
@@ -96,8 +130,7 @@
     }
 
-
     #region IMultiObjectiveHeuristicOptimizationProblem Members
     IParameter IMultiObjectiveHeuristicOptimizationProblem.MaximizationParameter {
-      get { return Parameters["Maximization"]; }
+      get { return Parameters[MaximizationParameterName]; }
     }
     IMultiObjectiveEvaluator IMultiObjectiveHeuristicOptimizationProblem.Evaluator {
Index: branches/2943_MOBasicProblem_MOCMAES/HeuristicLab.Optimization/3.3/BasicProblems/SingleObjectiveBasicProblem.cs
===================================================================
--- branches/2943_MOBasicProblem_MOCMAES/HeuristicLab.Optimization/3.3/BasicProblems/SingleObjectiveBasicProblem.cs	(revision 16123)
+++ branches/2943_MOBasicProblem_MOCMAES/HeuristicLab.Optimization/3.3/BasicProblems/SingleObjectiveBasicProblem.cs	(revision 16171)
@@ -31,6 +31,5 @@
 namespace HeuristicLab.Optimization {
   [StorableClass]
-  public abstract class SingleObjectiveBasicProblem<TEncoding> : BasicProblem<TEncoding, SingleObjectiveEvaluator>,
-    ISingleObjectiveProblemDefinition, ISingleObjectiveHeuristicOptimizationProblem
+  public abstract class SingleObjectiveBasicProblem<TEncoding> : BasicProblem<TEncoding, SingleObjectiveEvaluator>, ISingleObjectiveBasicProblem
   where TEncoding : class, IEncoding {
 
Index: branches/2943_MOBasicProblem_MOCMAES/HeuristicLab.Optimization/3.3/HeuristicLab.Optimization-3.3.csproj
===================================================================
--- branches/2943_MOBasicProblem_MOCMAES/HeuristicLab.Optimization/3.3/HeuristicLab.Optimization-3.3.csproj	(revision 16123)
+++ branches/2943_MOBasicProblem_MOCMAES/HeuristicLab.Optimization/3.3/HeuristicLab.Optimization-3.3.csproj	(revision 16171)
@@ -41,5 +41,5 @@
     <DebugType>full</DebugType>
     <Optimize>false</Optimize>
-    <OutputPath>$(SolutionDir)\bin\</OutputPath>
+    <OutputPath>..\..\..\..\trunk\bin\</OutputPath>
     <DefineConstants>DEBUG;TRACE</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
@@ -105,4 +105,12 @@
   </PropertyGroup>
   <ItemGroup>
+    <Reference Include="ALGLIB-3.7.0, Version=3.7.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\..\trunk\bin\ALGLIB-3.7.0.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.ALGLIB-3.7.0, Version=3.7.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\..\trunk\bin\HeuristicLab.ALGLIB-3.7.0.dll</HintPath>
+    </Reference>
     <Reference Include="HeuristicLab.Collections-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
@@ -120,8 +128,4 @@
       <SpecificVersion>False</SpecificVersion>
       <HintPath>..\..\..\..\trunk\bin\HeuristicLab.Core-3.3.dll</HintPath>
-    </Reference>
-    <Reference Include="HeuristicLab.Data-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
-      <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\..\..\..\trunk\bin\HeuristicLab.Data-3.3.dll</HintPath>
     </Reference>
     <Reference Include="HeuristicLab.Operators-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
@@ -162,7 +166,9 @@
     <Compile Include="BasicProblems\Individuals\MultiEncodingIndividual.cs" />
     <Compile Include="BasicProblems\Individuals\SingleEncodingIndividual.cs" />
+    <Compile Include="BasicProblems\Interfaces\IBasicProblem.cs" />
     <Compile Include="BasicProblems\Interfaces\IEncoding.cs" />
     <Compile Include="BasicProblems\Interfaces\IEncodingOperator.cs" />
     <Compile Include="BasicProblems\Interfaces\IMultiEncodingOperator.cs" />
+    <Compile Include="BasicProblems\Interfaces\IMultiObjectiveBasicProblem.cs" />
     <Compile Include="BasicProblems\Interfaces\IMultiObjectiveProblemDefinition.cs" />
     <Compile Include="BasicProblems\Interfaces\internal\IMultiObjectiveAnalysisOperator.cs" />
@@ -172,4 +178,5 @@
     <Compile Include="BasicProblems\Interfaces\internal\ISingleObjectiveEvaluationOperator.cs" />
     <Compile Include="BasicProblems\Interfaces\IProblemDefinition.cs" />
+    <Compile Include="BasicProblems\Interfaces\ISingleObjectiveBasicProblem.cs" />
     <Compile Include="BasicProblems\Interfaces\ISingleObjectiveMoveOperator.cs" />
     <Compile Include="BasicProblems\Interfaces\ISingleObjectiveProblemDefinition.cs" />
@@ -192,5 +199,9 @@
     <Compile Include="Interfaces\ILocalImprovementAlgorithmOperator.cs" />
     <Compile Include="Interfaces\IMultiObjectiveOperator.cs" />
+    <Compile Include="MultiObjective\CrowdingCalculator.cs" />
     <Compile Include="MultiObjective\DominationCalculator.cs" />
+    <Compile Include="MultiObjective\GenerationalDistanceCalculator.cs" />
+    <Compile Include="MultiObjective\HypervolumeCalculator.cs" />
+    <Compile Include="MultiObjective\SpacingCalculator.cs" />
     <Compile Include="Results\IResultParameter.cs" />
     <Compile Include="Interfaces\ISingleObjectiveOperator.cs" />
@@ -319,5 +330,10 @@
     </BootstrapperPackage>
   </ItemGroup>
-  <ItemGroup />
+  <ItemGroup>
+    <ProjectReference Include="..\..\HeuristicLab.Data\3.3\HeuristicLab.Data-3.3.csproj">
+      <Project>{bbab9df5-5ef3-4ba8-ade9-b36e82114937}</Project>
+      <Name>HeuristicLab.Data-3.3</Name>
+    </ProjectReference>
+  </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
Index: branches/2943_MOBasicProblem_MOCMAES/HeuristicLab.Optimization/3.3/MultiObjective/CrowdingCalculator.cs
===================================================================
--- branches/2943_MOBasicProblem_MOCMAES/HeuristicLab.Optimization/3.3/MultiObjective/CrowdingCalculator.cs	(revision 16171)
+++ branches/2943_MOBasicProblem_MOCMAES/HeuristicLab.Optimization/3.3/MultiObjective/CrowdingCalculator.cs	(revision 16171)
@@ -0,0 +1,67 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2018 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 System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Data;
+
+namespace HeuristicLab.Optimization {
+
+  /// <summary>
+  /// CrowdingCalculator distance d(x,A) is usually defined between a point x and a set of points A
+  /// d(x,A) is the sum over all dimensions where for each dimension the next larger and the next smaller Point to x are subtracted
+  /// see in more detail: "A fast elitist non-dominated sorting genetic algorithm for multi-objective optimization: NSGA-II" by K Deb, S Agrawal, A Pratap, T Meyarivan
+  /// CrowdingCalculator as a quality of the complete qualities is defined here as the mean of the crowding distances of every point x in A 
+  /// C(A) = mean(d(x,A)) where x in A  and d(x,A) is not infinite
+  /// Beware that CrowdingCalculator is not normalized for the number of dimensions. A higher number of dimensions normally causes higher CrowdingCalculator values
+  /// </summary>
+  public static class CrowdingCalculator
+  {
+
+    public static double CalculateCrowding<TP>(IEnumerable<TP> qualities) where TP : IReadOnlyList<double> {
+      return CalculateCrowdingDistances(qualities.ToArray()).Where(d => !double.IsPositiveInfinity(d)).DefaultIfEmpty(double.PositiveInfinity).Average();
+    }
+
+    public static IList<double> CalculateCrowdingDistances<TP>(TP[] qualities) where TP : IReadOnlyList<double> {
+      if (qualities == null) throw new ArgumentException("qualities must not be null");
+      if (!qualities.Any()) throw new ArgumentException("qualities must not be empty");
+
+      var lastIndex = qualities.Length-1;
+      int objectiveCount = qualities[0].Count;
+
+      var pointsums = qualities.ToDictionary(x => x, x => 0.0);
+      for (var dim = 0; dim < objectiveCount; dim++) {
+        var arr = qualities.OrderBy(x => x[dim]).ToArray();
+
+        pointsums[arr[0]] = double.PositiveInfinity;
+        pointsums[arr[lastIndex]] = double.PositiveInfinity;
+
+        var d = arr[lastIndex][dim]-arr[0][dim];
+
+        for (var i = 1; i < lastIndex; i++)
+          pointsums[arr[i]] += (arr[i + 1][dim] - arr[i - 1][dim])/d;
+      }
+      return qualities.Select(x=> pointsums[x]).ToList();
+    }
+
+  }
+}
Index: branches/2943_MOBasicProblem_MOCMAES/HeuristicLab.Optimization/3.3/MultiObjective/DominationCalculator.cs
===================================================================
--- branches/2943_MOBasicProblem_MOCMAES/HeuristicLab.Optimization/3.3/MultiObjective/DominationCalculator.cs	(revision 16123)
+++ branches/2943_MOBasicProblem_MOCMAES/HeuristicLab.Optimization/3.3/MultiObjective/DominationCalculator.cs	(revision 16171)
@@ -24,7 +24,8 @@
 
 namespace HeuristicLab.Optimization {
+
   public enum DominationResult { Dominates, IsDominated, IsNonDominated };
 
-  public static class DominationCalculator<T> {
+  public static class DominationCalculator {
     /// <summary>
     /// Calculates the best pareto front only. The fast non-dominated sorting algorithm is used
@@ -43,6 +44,6 @@
     /// <param name="dominateOnEqualQualities">Whether solutions of exactly equal quality should dominate one another.</param>
     /// <returns>The pareto front containing the best solutions and their associated quality resp. fitness.</returns>
-    public static List<Tuple<T, double[]>> CalculateBestParetoFront(T[] solutions, double[][] qualities, bool[] maximization, bool dominateOnEqualQualities = true) {
-      int populationSize = solutions.Length;
+    public static List<Tuple<T, double[]>> CalculateBestParetoFront<T>(T[] solutions, double[][] qualities, bool[] maximization, bool dominateOnEqualQualities = true) {
+      var populationSize = solutions.Length;
 
       Dictionary<T, List<int>> dominatedIndividuals;
@@ -69,6 +70,6 @@
     /// <param name="dominateOnEqualQualities">Whether solutions of exactly equal quality should dominate one another.</param>
     /// <returns>A sorted list of the pareto fronts from best to worst.</returns>
-    public static List<List<Tuple<T, double[]>>> CalculateAllParetoFronts(T[] solutions, double[][] qualities, bool[] maximization, out int[] rank, bool dominateOnEqualQualities = true) {
-      int populationSize = solutions.Length;
+    public static List<List<Tuple<T, double[]>>> CalculateAllParetoFronts<T>(T[] solutions, double[][] qualities, bool[] maximization, out int[] rank, bool dominateOnEqualQualities = true) {
+      var populationSize = solutions.Length;
 
       Dictionary<T, List<int>> dominatedIndividuals;
@@ -76,5 +77,5 @@
       var fronts = new List<List<Tuple<T, double[]>>>();
       fronts.Add(CalculateBestFront(solutions, qualities, maximization, dominateOnEqualQualities, populationSize, out dominatedIndividuals, out dominationCounter, out rank));
-      int i = 0;
+      var i = 0;
       while (i < fronts.Count && fronts[i].Count > 0) {
         var nextFront = new List<Tuple<T, double[]>>();
@@ -82,6 +83,6 @@
           List<int> dominatedIndividualsByp;
           if (dominatedIndividuals.TryGetValue(p.Item1, out dominatedIndividualsByp)) {
-            for (int k = 0; k < dominatedIndividualsByp.Count; k++) {
-              int dominatedIndividual = dominatedIndividualsByp[k];
+            for (var k = 0; k < dominatedIndividualsByp.Count; k++) {
+              var dominatedIndividual = dominatedIndividualsByp[k];
               dominationCounter[dominatedIndividual] -= 1;
               if (dominationCounter[dominatedIndividual] == 0) {
@@ -98,15 +99,15 @@
     }
 
-    private static List<Tuple<T, double[]>> CalculateBestFront(T[] solutions, double[][] qualities, bool[] maximization, bool dominateOnEqualQualities, int populationSize, out Dictionary<T, List<int>> dominatedIndividuals, out int[] dominationCounter, out int[] rank) {
+    private static List<Tuple<T, double[]>> CalculateBestFront<T>(T[] solutions, double[][] qualities, bool[] maximization, bool dominateOnEqualQualities, int populationSize, out Dictionary<T, List<int>> dominatedIndividuals, out int[] dominationCounter, out int[] rank) {
       var front = new List<Tuple<T, double[]>>();
       dominatedIndividuals = new Dictionary<T, List<int>>();
       dominationCounter = new int[populationSize];
       rank = new int[populationSize];
-      for (int pI = 0; pI < populationSize - 1; pI++) {
+      for (var pI = 0; pI < populationSize - 1; pI++) {
         var p = solutions[pI];
         List<int> dominatedIndividualsByp;
         if (!dominatedIndividuals.TryGetValue(p, out dominatedIndividualsByp))
           dominatedIndividuals[p] = dominatedIndividualsByp = new List<int>();
-        for (int qI = pI + 1; qI < populationSize; qI++) {
+        for (var qI = pI + 1; qI < populationSize; qI++) {
           var test = Dominates(qualities[pI], qualities[qI], maximization, dominateOnEqualQualities);
           if (test == DominationResult.Dominates) {
@@ -147,5 +148,5 @@
       if (dominateOnEqualQualities) {
         var equal = true;
-        for (int i = 0; i < left.Length; i++) {
+        for (var i = 0; i < left.Length; i++) {
           if (left[i] != right[i]) {
             equal = false;
@@ -157,5 +158,5 @@
 
       bool leftIsBetter = false, rightIsBetter = false;
-      for (int i = 0; i < left.Length; i++) {
+      for (var i = 0; i < left.Length; i++) {
         if (IsDominated(left[i], right[i], maximizations[i])) rightIsBetter = true;
         else if (IsDominated(right[i], left[i], maximizations[i])) leftIsBetter = true;
Index: branches/2943_MOBasicProblem_MOCMAES/HeuristicLab.Optimization/3.3/MultiObjective/GenerationalDistanceCalculator.cs
===================================================================
--- branches/2943_MOBasicProblem_MOCMAES/HeuristicLab.Optimization/3.3/MultiObjective/GenerationalDistanceCalculator.cs	(revision 16171)
+++ branches/2943_MOBasicProblem_MOCMAES/HeuristicLab.Optimization/3.3/MultiObjective/GenerationalDistanceCalculator.cs	(revision 16171)
@@ -0,0 +1,79 @@
+﻿#region License Information
+
+/* HeuristicLab
+ * Copyright (C) 2002-2018 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
+
+#region
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+
+#endregion
+
+namespace HeuristicLab.Optimization {
+  /// <summary>
+  /// The generational Distance is defined as the pth-root of the sum of all d[i]^(p) divided by the size of the qualities
+  ///  where d[i] is the minimal distance the ith point of the evaluated qualities has to any point in the optimal pareto qualities.   
+  ///  p is a dampening factor and is normally set to 1. 
+  ///  http://shodhganga.inflibnet.ac.in/bitstream/10603/15070/28/28_appendix_h.pdf
+  /// </summary>
+  public static class GenerationalDistanceCalculator {
+    public static double CalculateGenerationalDistance<TP1, TP2>(IEnumerable<TP1> qualities, IEnumerable<TP2> bestKnownFront, double p) where TP1 : IReadOnlyList<double> where TP2 : IReadOnlyList<double> {
+      if (qualities == null || bestKnownFront == null) throw new ArgumentNullException("Fronts must not be null");
+      if (p.IsAlmost(0.0)) throw new ArgumentException("p must not be zero.");
+      var mat = bestKnownFront.ToMatrix();
+      if (mat.GetLength(0) == 0) throw new ArgumentException("Fronts must not be empty.");
+
+      alglib.kdtree tree;
+      alglib.kdtreebuild(mat, mat.GetLength(0), mat.GetLength(1), 0, 2, out tree);
+      var sum = 0.0;
+      var summand = new double[1];
+      var count = 0;
+      foreach(var point in qualities) {
+        alglib.kdtreequeryknn(tree, point.ToArray(), 1, true);
+        alglib.kdtreequeryresultsdistances(tree, ref summand);
+        sum += Math.Pow(summand[0], p);
+        count++;
+      }
+
+      if (count == 0) throw new ArgumentException("Fronts must not be empty.");
+      return Math.Pow(sum, 1 / p) / count;
+    }
+
+    public static double CalculateInverseGenerationalDistance<TP1, TP2>(IEnumerable<TP1> qualities, IEnumerable<TP2> bestKnownFront, double p) where TP1 : IReadOnlyList<double> where TP2 : IReadOnlyList<double> {
+      return CalculateGenerationalDistance(bestKnownFront, qualities, p);
+    }
+
+    internal static double[,] ToMatrix<TP>(this IEnumerable<TP> source) where TP : IReadOnlyList<double> {
+      var l = source.ToArray();
+      var firstDimension = l.Length;
+      var secondDimension = l[0].Count;
+      var result = new double[firstDimension, secondDimension];
+      for (var i = 0; i < firstDimension; ++i)
+        for (var j = 0; j < secondDimension; ++j)
+          result[i, j] = l[i][j];
+
+      return result;
+    }
+  }
+}
Index: branches/2943_MOBasicProblem_MOCMAES/HeuristicLab.Optimization/3.3/MultiObjective/HypervolumeCalculator.cs
===================================================================
--- branches/2943_MOBasicProblem_MOCMAES/HeuristicLab.Optimization/3.3/MultiObjective/HypervolumeCalculator.cs	(revision 16171)
+++ branches/2943_MOBasicProblem_MOCMAES/HeuristicLab.Optimization/3.3/MultiObjective/HypervolumeCalculator.cs	(revision 16171)
@@ -0,0 +1,305 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2018 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 System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Optimization;
+
+namespace HeuristicLab.Optimization {
+
+  public static class HypervolumeCalculator {
+
+    public static double[] CalculateNadirPoint(IEnumerable<double[]> qualities, bool[] maximization){
+      var res = maximization.Select(m => m ? double.MaxValue : double.MinValue).ToArray();
+      foreach (var quality in qualities)
+        for (var i = 0; i < quality.Length; i++)
+          if (maximization[i] == res[i] > quality[i])
+            res[i] = quality[i];
+      return res;
+    }
+
+    /// <summary>
+    /// The Hyprevolume-metric is defined as the HypervolumeCalculator enclosed between a given reference point,
+    /// that is fixed for every evaluation function and the evaluated qualities.
+    /// 
+    /// Example:
+    /// r is the reference point at (1|1) and every point p is part of the evaluated qualities
+    /// The filled area labled HV is the 2 dimensional HypervolumeCalculator enclosed by this qualities. 
+    /// 
+    /// (0|1)                (1|1)
+    ///   +      +-------------r
+    ///   |      |###### HV ###|
+    ///   |      p------+######|
+    ///   |             p+#####|
+    ///   |              |#####|
+    ///   |              p-+###|
+    ///   |                p---+
+    ///   |                 
+    ///   +--------------------1
+    /// (0|0)                (1|0)
+    /// 
+    ///  Please note that in this example both dimensions are minimized. The reference point needs to be dominated by EVERY point in the evaluated qualities 
+    /// 
+    /// </summary>
+    /// 
+    public static double CalculateHypervolume(double[][] qualities, double[] referencePoint, bool[] maximization){
+      qualities = qualities.Where(vec => DominationCalculator.Dominates(vec, referencePoint, maximization, false) == DominationResult.Dominates).ToArray();
+      if (!qualities.Any()) return 0;//TODO replace with negative computation
+      if (maximization.Length == 2)
+        return Calculate2D(qualities, referencePoint, maximization);
+
+      if (Array.TrueForAll(maximization, x => !x))
+        return CalculateMultiDimensional(qualities, referencePoint);
+      throw new NotImplementedException("HypervolumeCalculator calculation for more than two dimensions is supported only with minimization problems.");
+    }
+
+    public static double Calculate2D(double[][] front, double[] referencePoint, bool[] maximization) {
+      if (front == null) throw new ArgumentNullException("Front must not be null.");
+      if (!front.Any()) throw new ArgumentException("Front must not be empty.");
+
+      if (referencePoint == null) throw new ArgumentNullException("ReferencePoint must not be null.");
+      if (referencePoint.Length != 2) throw new ArgumentException("ReferencePoint must have exactly two dimensions.");
+
+      var set = front.ToArray();
+      if (set.Any(s => s.Length != 2)) throw new ArgumentException("Points in qualities must have exactly two dimensions.");
+
+      Array.Sort(set, new DimensionComparer(0, maximization[0]));
+
+      double sum = 0;
+      for (var i = 0; i < set.Length - 1; i++) 
+        sum += Math.Abs((set[i][0] - set[i + 1][0])) * Math.Abs((set[i][1] - referencePoint[1]));
+      
+      var lastPoint = set[set.Length - 1];
+      sum += Math.Abs(lastPoint[0] - referencePoint[0]) * Math.Abs(lastPoint[1] - referencePoint[1]);
+
+      return sum;
+    }
+
+    public static double CalculateMultiDimensional(double[][] front, double[] referencePoint) {
+      if (referencePoint == null || referencePoint.Length < 3) throw new ArgumentException("ReferencePoint unfit for complex HypervolumeCalculator calculation");
+
+      var objectives = referencePoint.Length;
+      var fronList = front.ToList();
+      fronList.StableSort(new DimensionComparer(objectives - 1, false));
+
+      var regLow = Enumerable.Repeat(1E15, objectives).ToArray();
+      foreach (var p in fronList) {
+        for (var i = 0; i < regLow.Length; i++) {
+          if (p[i] < regLow[i]) regLow[i] = p[i];
+        }
+      }
+
+      return Stream(regLow, referencePoint, fronList, 0, referencePoint[objectives - 1], (int)Math.Sqrt(fronList.Count), objectives);
+    }
+
+    private static double Stream(double[] regionLow, double[] regionUp, List<double[]> front, int split, double cover, int sqrtNoPoints, int objectives) {
+      var coverOld = cover;
+      var coverIndex = 0;
+      var coverIndexOld = -1;
+      int c;
+      double result = 0;
+
+      var dMeasure = GetMeasure(regionLow, regionUp, objectives);
+      while (cover == coverOld && coverIndex < front.Count()) {
+        if (coverIndexOld == coverIndex) break;
+        coverIndexOld = coverIndex;
+        if (Covers(front[coverIndex], regionLow, objectives)) {
+          cover = front[coverIndex][objectives - 1];
+          result += dMeasure * (coverOld - cover);
+        } else coverIndex++;
+      }
+
+      for (c = coverIndex; c > 0; c--) if (front[c - 1][objectives - 1] == cover) coverIndex--;
+      if (coverIndex == 0) return result;
+
+      var allPiles = true;
+      var piles = new int[coverIndex];
+      for (var i = 0; i < coverIndex; i++) {
+        piles[i] = IsPile(front[i], regionLow, regionUp, objectives);
+        if (piles[i] == -1) {
+          allPiles = false;
+          break;
+        }
+      }
+
+      if (allPiles) {
+        var trellis = new double[regionUp.Length];
+        for (var j = 0; j < trellis.Length; j++) trellis[j] = regionUp[j];
+        double current = 0;
+        double next = 0;
+        var i = 0;
+        do {
+          current = front[i][objectives - 1];
+          do {
+            if (front[i][piles[i]] < trellis[piles[i]]) trellis[piles[i]] = front[i][piles[i]];
+            i++;
+            if (i < coverIndex) next = front[i][objectives - 1];
+            else { next = cover; break; }
+          } while (next == current);
+          result += ComputeTrellis(regionLow, regionUp, trellis, objectives) * (next - current);
+        } while (next != cover);
+      } else {
+        double bound = -1;
+        var boundaries = new double[coverIndex];
+        var noBoundaries = new double[coverIndex];
+        var boundIdx = 0;
+        var noBoundIdx = 0;
+
+        do {
+          for (var i = 0; i < coverIndex; i++) {
+            var contained = ContainesBoundary(front[i], regionLow, split);
+            if (contained == 0) boundaries[boundIdx++] = front[i][split];
+            else if (contained == 1) noBoundaries[noBoundIdx++] = front[i][split];
+          }
+          if (boundIdx > 0) bound = GetMedian(boundaries, boundIdx);
+          else if (noBoundIdx > sqrtNoPoints) bound = GetMedian(noBoundaries, noBoundIdx);
+          else split++;
+        } while (bound == -1.0);
+
+        List<double[]> pointsChildLow, pointsChildUp;
+        pointsChildLow = new List<double[]>();
+        pointsChildUp = new List<double[]>();
+        var regionUpC = new double[regionUp.Length];
+        for (var j = 0; j < regionUpC.Length; j++) regionUpC[j] = regionUp[j];
+        var regionLowC = new double[regionLow.Length];
+        for (var j = 0; j < regionLowC.Length; j++) regionLowC[j] = regionLow[j];
+
+        for (var i = 0; i < coverIndex; i++) {
+          if (PartCovers(front[i], regionUpC, objectives)) pointsChildUp.Add(front[i]);
+          if (PartCovers(front[i], regionUp, objectives)) pointsChildLow.Add(front[i]);
+        }
+
+        if (pointsChildUp.Count > 0) result += Stream(regionLow, regionUpC, pointsChildUp, split, cover, sqrtNoPoints, objectives);
+        if (pointsChildLow.Count > 0) result += Stream(regionLowC, regionUp, pointsChildLow, split, cover, sqrtNoPoints, objectives);
+      }
+      return result;
+    }
+
+    private static double GetMedian(double[] vector, int length) {
+      return vector.Take(length).Median();
+    }
+
+    private static double ComputeTrellis(double[] regionLow, double[] regionUp, double[] trellis, int objectives) {
+      var bs = new bool[objectives - 1];
+      for (var i = 0; i < bs.Length; i++) bs[i] = true;
+
+      double result = 0;
+      var noSummands = BinarayToInt(bs);
+      int oneCounter; double summand;
+      for (uint i = 1; i <= noSummands; i++) {
+        summand = 1;
+        IntToBinary(i, bs);
+        oneCounter = 0;
+        for (var j = 0; j < objectives - 1; j++) {
+          if (bs[j]) {
+            summand *= regionUp[j] - trellis[j];
+            oneCounter++;
+          } else {
+            summand *= regionUp[j] - regionLow[j];
+          }
+        }
+        if (oneCounter % 2 == 0) result -= summand;
+        else result += summand;
+
+      }
+      return result;
+    }
+
+    private static void IntToBinary(uint i, bool[] bs) {
+      for (var j = 0; j < bs.Length; j++) bs[j] = false;
+      var rest = i;
+      var idx = 0;
+      while (rest != 0) {
+        bs[idx] = rest % 2 == 1;
+        rest = rest / 2;
+        idx++;
+      }
+    }
+
+    private static uint BinarayToInt(bool[] bs) {
+      uint result = 0;
+      for (var i = 0; i < bs.Length; i++) {
+        result += bs[i] ? ((uint)1 << i) : 0;
+      }
+      return result;
+    }
+
+    private static int IsPile(double[] cuboid, double[] regionLow, double[] regionUp, int objectives) {
+      var pile = cuboid.Length;
+      for (var i = 0; i < objectives - 1; i++) {
+        if (cuboid[i] > regionLow[i]) {
+          if (pile != objectives) return 1;
+          pile = i;
+        }
+      }
+      return pile;
+    }
+
+    private static double GetMeasure(double[] regionLow, double[] regionUp, int objectives) {
+      double volume = 1;
+      for (var i = 0; i < objectives - 1; i++) {
+        volume *= (regionUp[i] - regionLow[i]);
+      }
+      return volume;
+    }
+
+    private static int ContainesBoundary(double[] cub, double[] regionLow, int split) {
+      if (regionLow[split] >= cub[split]) return -1;
+      else {
+        for (var j = 0; j < split; j++) {
+          if (regionLow[j] < cub[j]) return 1;
+        }
+      }
+      return 0;
+    }
+
+    private static bool PartCovers(double[] v, double[] regionUp, int objectives) {
+      for (var i = 0; i < objectives - 1; i++) {
+        if (v[i] >= regionUp[i]) return false;
+      }
+      return true;
+    }
+
+    private static bool Covers(double[] v, double[] regionLow, int objectives) {
+      for (var i = 0; i < objectives - 1; i++) {
+        if (v[i] > regionLow[i]) return false;
+      }
+      return true;
+    }
+
+    private class DimensionComparer : IComparer<double[]> {
+      private readonly int dimension;
+      private readonly int descending;
+
+      public DimensionComparer(int dimension, bool descending) {
+        this.dimension = dimension;
+        this.descending = descending ? -1 : 1;
+      }
+
+      public int Compare(double[] x, double[] y){
+        return x[dimension].CompareTo(y[dimension]) * descending;
+      }
+    }
+
+  }
+}
+
Index: branches/2943_MOBasicProblem_MOCMAES/HeuristicLab.Optimization/3.3/MultiObjective/SpacingCalculator.cs
===================================================================
--- branches/2943_MOBasicProblem_MOCMAES/HeuristicLab.Optimization/3.3/MultiObjective/SpacingCalculator.cs	(revision 16171)
+++ branches/2943_MOBasicProblem_MOCMAES/HeuristicLab.Optimization/3.3/MultiObjective/SpacingCalculator.cs	(revision 16171)
@@ -0,0 +1,56 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2018 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 System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+
+namespace HeuristicLab.Optimization {
+
+  /// <summary>
+  /// SpacingCalculator is defined as the standarddeviation of all d[i] 
+  /// where d[i] is the minimum eukildean distance any point i has 
+  /// to all OTHER points in the same front 
+  /// </summary>
+  public static class SpacingCalculator {
+
+    public static double CalculateSpacing<TP>(IEnumerable<TP> qualities) where TP: IReadOnlyList<double> {
+      if (qualities == null) throw new ArgumentException("Front must not be null.");
+      var l = qualities.ToList();
+      if (l.Count == 0) throw new ArgumentException("Front must not be empty.");
+      if (l.Count == 1) return 0;
+
+      var mat = l.ToMatrix();
+      alglib.kdtree tree;
+      alglib.kdtreebuild(mat, mat.GetLength(0), mat.GetLength(1), 0, 2, out tree);
+      var summand = new double[2];
+      var dists = new List<double>();
+      foreach (var point in l) {
+        alglib.kdtreequeryknn(tree, point.ToArray(), 2, true);
+        alglib.kdtreequeryresultsdistances(tree, ref summand);
+        dists.Add(summand[1]);
+      }
+      return dists.StandardDeviationPop();
+    }
+
+    
+  }
+}
