Index: branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/Indicators/CrowdingIndicator.cs
===================================================================
--- branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/Indicators/CrowdingIndicator.cs	(revision 15175)
+++ branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/Indicators/CrowdingIndicator.cs	(revision 15176)
@@ -60,9 +60,6 @@
         }
       }
-      //find min
       return pointsums.Select((value, index) => new { value, index }).OrderBy(x => x.value).First().index;
     }
-
-
   }
 }
Index: branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/Indicators/HypervolumeIndicator.cs
===================================================================
--- branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/Indicators/HypervolumeIndicator.cs	(revision 15175)
+++ branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/Indicators/HypervolumeIndicator.cs	(revision 15176)
@@ -55,5 +55,5 @@
       var point = front[idx];
       front.RemoveAt(idx);
-      var contribution = -Hypervolume.Calculate(front, refPoint, maximization);
+      var contribution = -Hypervolume.Calculate(front.ToArray(), refPoint, maximization);
       front.Insert(idx, point);
       return contribution;
Index: branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/Indicators/MinimalDistanceIndicator.cs
===================================================================
--- branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/Indicators/MinimalDistanceIndicator.cs	(revision 15175)
+++ branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/Indicators/MinimalDistanceIndicator.cs	(revision 15176)
@@ -84,5 +84,5 @@
     }
 
-    #region helpers
+    #region Helpers
     private static double[,] CalcDistances(IReadOnlyList<double[]> extracted) {
       var res = new double[extracted.Count, extracted.Count];
@@ -97,5 +97,4 @@
     }
     #endregion
-
   }
 }
Index: branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/Individual.cs
===================================================================
--- branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/Individual.cs	(revision 15175)
+++ branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/Individual.cs	(revision 15176)
@@ -32,8 +32,4 @@
   public class Individual : IDeepCloneable {
 
-    public enum OffspringSuccess {
-      Success, NoSuccess
-    }
-
     #region Properties
     [Storable]
@@ -54,5 +50,4 @@
     private double[,] lowerCholesky;
 
-
     //Phenotype
     [Storable]
@@ -70,12 +65,4 @@
     protected Individual(bool deserializing) { }
 
-    /// <summary>
-    /// 
-    /// </summary>
-    /// <param name="mean">has to be 0-vector with correct lenght</param>
-    /// <param name="pSucc">has to be ptargetsucc</param>
-    /// <param name="sigma">initialSigma</param>
-    /// <param name="pc">has to be 0-vector with correct lenght</param>
-    /// <param name="c">has to be a symmetric positive definit Covariance matrix</param>
     public Individual(RealVector mean, double pSucc, double sigma, RealVector pc, double[,] c, MOCMAEvolutionStrategy strategy) {
       Mean = mean;
@@ -147,7 +134,5 @@
         if (stepNormSqr > 1 && 1 < strategy.CovarianceMatrixUnlearningRate * (2 * stepNormSqr - 1)) rate = 1 / (2 * stepNormSqr - 1);
         CholeskyUpdate(lastStep, 1 + rate, -rate);
-
       } else RoundUpdate();
-
     }
 
@@ -159,7 +144,5 @@
         UpdateEvolutionPath(1 - strategy.EvolutionPathLearningRate, evolutionpathUpdateWeight);
         CholeskyUpdate(evolutionPath, 1 - strategy.CovarianceMatrixLearningRate, strategy.CovarianceMatrixLearningRate);
-      } else {
-        RoundUpdate();
-      }
+      } else RoundUpdate();
     }
 
@@ -172,5 +155,5 @@
     }
 
-    #region helpers
+    #region Helpers
     private void CholeskyDecomposition(double[,] c) {
       if (!alglib.spdmatrixcholesky(ref c, c.GetLength(0), false))
@@ -192,5 +175,5 @@
         var gamma = dj * betaPrime + swj2;
         var x1 = dj + swj2 / betaPrime;
-        if (x1 < 0.0) return;//throw new ArgumentException("Update makes Covariancematrix indefinite");//TODO check wether ignoring this update is valid
+        if (x1 < 0.0) return;
         var nLjj = Math.Sqrt(x1);
         lowerCholesky[j, j] = nLjj;
@@ -202,7 +185,5 @@
         for (var i = j + 1; i < n; i++) lowerCholesky[i, j] *= nLjj / ljj;
         for (var i = j + 1; i < n; i++) lowerCholesky[i, j] += nLjj * beta * wj / gamma * temp[i];
-
       }
-
     }
 
@@ -213,6 +194,4 @@
     }
     #endregion
-
   }
-
 }
Index: branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/MOCMAEvolutionStrategy.cs
===================================================================
--- branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/MOCMAEvolutionStrategy.cs	(revision 15175)
+++ branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/MOCMAEvolutionStrategy.cs	(revision 15176)
@@ -42,19 +42,16 @@
   [System.Runtime.InteropServices.Guid("5AC20A69-BBBF-4153-B57D-3EAF92DC505E")]
   public class MOCMAEvolutionStrategy : BasicAlgorithm {
-    public override Type ProblemType
-    {
+    public override Type ProblemType {
       get { return typeof(MultiObjectiveBasicProblem<RealVectorEncoding>); }
     }
-    public new MultiObjectiveBasicProblem<RealVectorEncoding> Problem
-    {
+    public new MultiObjectiveBasicProblem<RealVectorEncoding> Problem {
       get { return (MultiObjectiveBasicProblem<RealVectorEncoding>)base.Problem; }
       set { base.Problem = value; }
     }
-    public override bool SupportsPause
-    {
+    public override bool SupportsPause {
       get { return true; }
     }
 
-    #region storable fields
+    #region Storable fields
     [Storable]
     private IRandom random = new MersenneTwister();
@@ -106,34 +103,26 @@
 
     #region ParameterProperties
-    public IFixedValueParameter<IntValue> MaximumRuntimeParameter
-    {
+    public IFixedValueParameter<IntValue> MaximumRuntimeParameter {
       get { return (IFixedValueParameter<IntValue>)Parameters[MaximumRuntimeName]; }
     }
-    public IFixedValueParameter<IntValue> SeedParameter
-    {
+    public IFixedValueParameter<IntValue> SeedParameter {
       get { return (IFixedValueParameter<IntValue>)Parameters[SeedName]; }
     }
-    public FixedValueParameter<BoolValue> SetSeedRandomlyParameter
-    {
+    public FixedValueParameter<BoolValue> SetSeedRandomlyParameter {
       get { return (FixedValueParameter<BoolValue>)Parameters[SetSeedRandomlyName]; }
     }
-    public IFixedValueParameter<IntValue> PopulationSizeParameter
-    {
+    public IFixedValueParameter<IntValue> PopulationSizeParameter {
       get { return (IFixedValueParameter<IntValue>)Parameters[PopulationSizeName]; }
     }
-    public IFixedValueParameter<IntValue> MaximumGenerationsParameter
-    {
+    public IFixedValueParameter<IntValue> MaximumGenerationsParameter {
       get { return (IFixedValueParameter<IntValue>)Parameters[MaximumGenerationsName]; }
     }
-    public IFixedValueParameter<IntValue> MaximumEvaluatedSolutionsParameter
-    {
+    public IFixedValueParameter<IntValue> MaximumEvaluatedSolutionsParameter {
       get { return (IFixedValueParameter<IntValue>)Parameters[MaximumEvaluatedSolutionsName]; }
     }
-    public IValueParameter<DoubleArray> InitialSigmaParameter
-    {
+    public IValueParameter<DoubleArray> InitialSigmaParameter {
       get { return (IValueParameter<DoubleArray>)Parameters[InitialSigmaName]; }
     }
-    public IConstrainedValueParameter<IIndicator> IndicatorParameter
-    {
+    public IConstrainedValueParameter<IIndicator> IndicatorParameter {
       get { return (IConstrainedValueParameter<IIndicator>)Parameters[IndicatorName]; }
     }
@@ -141,41 +130,33 @@
 
     #region Properties
-    public int MaximumRuntime
-    {
+    public int MaximumRuntime {
       get { return MaximumRuntimeParameter.Value.Value; }
       set { MaximumRuntimeParameter.Value.Value = value; }
     }
-    public int Seed
-    {
+    public int Seed {
       get { return SeedParameter.Value.Value; }
       set { SeedParameter.Value.Value = value; }
     }
-    public bool SetSeedRandomly
-    {
+    public bool SetSeedRandomly {
       get { return SetSeedRandomlyParameter.Value.Value; }
       set { SetSeedRandomlyParameter.Value.Value = value; }
     }
-    public int PopulationSize
-    {
+    public int PopulationSize {
       get { return PopulationSizeParameter.Value.Value; }
       set { PopulationSizeParameter.Value.Value = value; }
     }
-    public int MaximumGenerations
-    {
+    public int MaximumGenerations {
       get { return MaximumGenerationsParameter.Value.Value; }
       set { MaximumGenerationsParameter.Value.Value = value; }
     }
-    public int MaximumEvaluatedSolutions
-    {
+    public int MaximumEvaluatedSolutions {
       get { return MaximumEvaluatedSolutionsParameter.Value.Value; }
       set { MaximumEvaluatedSolutionsParameter.Value.Value = value; }
     }
-    public DoubleArray InitialSigma
-    {
+    public DoubleArray InitialSigma {
       get { return InitialSigmaParameter.Value; }
       set { InitialSigmaParameter.Value = value; }
     }
-    public IIndicator Indicator
-    {
+    public IIndicator Indicator {
       get { return IndicatorParameter.Value; }
       set { IndicatorParameter.Value = value; }
@@ -192,86 +173,68 @@
 
     #region ResultsProperties
-    private int ResultsEvaluations
-    {
+    private int ResultsEvaluations {
       get { return ((IntValue)Results[EvaluationsResultName].Value).Value; }
       set { ((IntValue)Results[EvaluationsResultName].Value).Value = value; }
     }
-    private int ResultsIterations
-    {
+    private int ResultsIterations {
       get { return ((IntValue)Results[IterationsResultName].Value).Value; }
       set { ((IntValue)Results[IterationsResultName].Value).Value = value; }
     }
     #region Datatable
-    private DataTable ResultsQualities
-    {
+    private DataTable ResultsQualities {
       get { return (DataTable)Results[TimetableResultName].Value; }
     }
-    private DataRow ResultsBestHypervolumeDataLine
-    {
+    private DataRow ResultsBestHypervolumeDataLine {
       get { return ResultsQualities.Rows[BestHypervolumeResultName]; }
     }
-    private DataRow ResultsHypervolumeDataLine
-    {
+    private DataRow ResultsHypervolumeDataLine {
       get { return ResultsQualities.Rows[HypervolumeResultName]; }
     }
-    private DataRow ResultsGenerationalDistanceDataLine
-    {
+    private DataRow ResultsGenerationalDistanceDataLine {
       get { return ResultsQualities.Rows[GenerationalDistanceResultName]; }
     }
-    private DataRow ResultsInvertedGenerationalDistanceDataLine
-    {
+    private DataRow ResultsInvertedGenerationalDistanceDataLine {
       get { return ResultsQualities.Rows[InvertedGenerationalDistanceResultName]; }
     }
-    private DataRow ResultsCrowdingDataLine
-    {
+    private DataRow ResultsCrowdingDataLine {
       get { return ResultsQualities.Rows[CrowdingResultName]; }
     }
-    private DataRow ResultsSpacingDataLine
-    {
+    private DataRow ResultsSpacingDataLine {
       get { return ResultsQualities.Rows[SpacingResultName]; }
     }
-    private DataRow ResultsHypervolumeDifferenceDataLine
-    {
+    private DataRow ResultsHypervolumeDifferenceDataLine {
       get { return ResultsQualities.Rows[DifferenceToBestKnownHypervolumeResultName]; }
     }
     #endregion
     //QualityIndicators
-    private double ResultsHypervolume
-    {
+    private double ResultsHypervolume {
       get { return ((DoubleValue)Results[HypervolumeResultName].Value).Value; }
       set { ((DoubleValue)Results[HypervolumeResultName].Value).Value = value; }
     }
-    private double ResultsGenerationalDistance
-    {
+    private double ResultsGenerationalDistance {
       get { return ((DoubleValue)Results[GenerationalDistanceResultName].Value).Value; }
       set { ((DoubleValue)Results[GenerationalDistanceResultName].Value).Value = value; }
     }
-    private double ResultsInvertedGenerationalDistance
-    {
+    private double ResultsInvertedGenerationalDistance {
       get { return ((DoubleValue)Results[InvertedGenerationalDistanceResultName].Value).Value; }
       set { ((DoubleValue)Results[InvertedGenerationalDistanceResultName].Value).Value = value; }
     }
-    private double ResultsCrowding
-    {
+    private double ResultsCrowding {
       get { return ((DoubleValue)Results[CrowdingResultName].Value).Value; }
       set { ((DoubleValue)Results[CrowdingResultName].Value).Value = value; }
     }
-    private double ResultsSpacing
-    {
+    private double ResultsSpacing {
       get { return ((DoubleValue)Results[SpacingResultName].Value).Value; }
       set { ((DoubleValue)Results[SpacingResultName].Value).Value = value; }
     }
-    private double ResultsBestHypervolume
-    {
+    private double ResultsBestHypervolume {
       get { return ((DoubleValue)Results[BestHypervolumeResultName].Value).Value; }
       set { ((DoubleValue)Results[BestHypervolumeResultName].Value).Value = value; }
     }
-    private double ResultsBestKnownHypervolume
-    {
+    private double ResultsBestKnownHypervolume {
       get { return ((DoubleValue)Results[BestKnownHypervolumeResultName].Value).Value; }
       set { ((DoubleValue)Results[BestKnownHypervolumeResultName].Value).Value = value; }
     }
-    private double ResultsDifferenceBestKnownHypervolume
-    {
+    private double ResultsDifferenceBestKnownHypervolume {
       get { return ((DoubleValue)Results[DifferenceToBestKnownHypervolumeResultName].Value).Value; }
       set { ((DoubleValue)Results[DifferenceToBestKnownHypervolumeResultName].Value).Value = value; }
@@ -279,11 +242,9 @@
     }
     //Solutions
-    private DoubleMatrix ResultsSolutions
-    {
+    private DoubleMatrix ResultsSolutions {
       get { return (DoubleMatrix)Results[CurrentFrontResultName].Value; }
       set { Results[CurrentFrontResultName].Value = value; }
     }
-    private ScatterPlotContent ResultsScatterPlot
-    {
+    private ScatterPlotContent ResultsScatterPlot {
       get { return (ScatterPlotContent)Results[ScatterPlotResultName].Value; }
       set { Results[ScatterPlotResultName].Value = value; }
@@ -401,5 +362,4 @@
         ResultsDifferenceBestKnownHypervolume = ResultsBestKnownHypervolume;
       }
-      //TODO? move FrontScatterPlotContent partially? to MultiobjectiveTestProblem?
       ResultsScatterPlot = new ScatterPlotContent(new double[0][], new double[0][], problem.BestKnownFront.ToJaggedArray(), problem.Objectives);
     }
@@ -413,11 +373,8 @@
           ResultsIterations++;
           cancellationToken.ThrowIfCancellationRequested();
-        }
-        finally {
+        } finally {
           Analyze();
         }
       }
-
-
     }
     private void Iterate() {
@@ -483,5 +440,4 @@
       int[] ranks;
       var fronts = DominationCalculator<Individual>.CalculateAllParetoFronts(parents.ToArray(), parents.Select(i => i.PenalizedFitness).ToArray(), Problem.Maximization, out ranks);
-      // NonDominatedSort(parents, individual => individual.PenalizedFitness);
 
       //deselect the highest rank fronts until we would end up with less or equal mu elements
@@ -508,16 +464,12 @@
       foreach (var p in parents.Skip(solutions.Length).Where(i => i.Selected))
         p.UpdateAsOffspring();
-
       for (var i = 0; i < solutions.Length; i++)
         if (parents[i].Selected)
           parents[i].UpdateAsParent(parents[i + solutions.Length].Selected);
-
       solutions = parents.Where(p => p.Selected).ToArray();
     }
 
     private void Analyze() {
-      //TODO? move FrontScatterPlotContent partially to MultiobjectiveTestProblem 
       ResultsScatterPlot = new ScatterPlotContent(solutions.Select(x => x.Fitness).ToArray(), solutions.Select(x => x.Mean.ToArray()).ToArray(), ResultsScatterPlot.ParetoFront, ResultsScatterPlot.Objectives);
-
       ResultsSolutions = solutions.Select(x => x.Mean.ToArray()).ToMatrix();
 
@@ -550,5 +502,4 @@
         random);
     }
-
   }
 }
