Index: /branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/CrowdingIndicator.cs
===================================================================
--- /branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/CrowdingIndicator.cs	(revision 14576)
+++ /branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/CrowdingIndicator.cs	(revision 14577)
@@ -25,6 +25,7 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
+using HeuristicLab.Encodings.RealVectorEncoding;
+using HeuristicLab.Optimization;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Problems.TestFunctions.MultiObjective;
 
 namespace HeuristicLab.Algorithms.MOCMAEvolutionStrategy {
@@ -33,13 +34,14 @@
   internal class CrowdingIndicator : Item, IIndicator {
 
-    public int LeastContributer<TR>(IEnumerable<TR> front, Func<TR, double[]> extractor, MultiObjectiveTestFunctionProblem problem) {
-      var bounds = problem.Bounds;
+    public int LeastContributer<TR>(IEnumerable<TR> front, Func<TR, double[]> extractor, MultiObjectiveBasicProblem<RealVectorEncoding> problem) {
+      var bounds = problem.Encoding.Bounds;
       var extracted = front.Select(extractor.Invoke).ToArray();
+      if (extracted.Length <= 2) return 0;
       var pointsums = new double[extracted.Length];
 
-      for (var dim = 0; dim < problem.Objectives; dim++) {
+      for (var dim = 0; dim < problem.Maximization.Length; dim++) {
         var arr = extracted.Select(x => x[dim]).ToArray();
         Array.Sort(arr);
-        var fmax = problem.Bounds[dim % bounds.Rows, 1];
+        var fmax = problem.Encoding.Bounds[dim % bounds.Rows, 1];
         var fmin = bounds[dim % bounds.Rows, 0];
         var pointIdx = 0;
@@ -52,5 +54,5 @@
       }
       //find min
-      return pointsums.Where(x => !double.IsInfinity(x)).ArgMin();
+      return pointsums.ArgMin();
     }
 
Index: /branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/HeuristicLab.Algorithms.MOCMAEvolutionStrategy-3.3.csproj
===================================================================
--- /branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/HeuristicLab.Algorithms.MOCMAEvolutionStrategy-3.3.csproj	(revision 14576)
+++ /branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/HeuristicLab.Algorithms.MOCMAEvolutionStrategy-3.3.csproj	(revision 14577)
@@ -106,4 +106,5 @@
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="MinimalDistanceIndicator.cs" />
     <Compile Include="CrowdingIndicator.cs" />
     <Compile Include="HypervolumeIndicator.cs" />
Index: /branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/HypervolumeIndicator.cs
===================================================================
--- /branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/HypervolumeIndicator.cs	(revision 14576)
+++ /branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/HypervolumeIndicator.cs	(revision 14577)
@@ -26,4 +26,6 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
+using HeuristicLab.Encodings.RealVectorEncoding;
+using HeuristicLab.Optimization;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 using HeuristicLab.Problems.TestFunctions.MultiObjective;
@@ -33,9 +35,12 @@
   internal class HypervolumeIndicator : Item, IIndicator {
 
-    public int LeastContributer<TR>(IEnumerable<TR> front, Func<TR, double[]> extractor, MultiObjectiveTestFunctionProblem problem) {
+    public int LeastContributer<TR>(IEnumerable<TR> front, Func<TR, double[]> extractor, MultiObjectiveBasicProblem<RealVectorEncoding> problem) {
       var frontArr = front.Select(extractor.Invoke).ToList();
-      var refPoint = BuildReference(frontArr.Concat(new[] { problem.TestFunction.ReferencePoint(problem.Objectives) }), problem.Maximization);
+      if (frontArr.Count <= 1) return 0;
+      var p = problem as MultiObjectiveTestFunctionProblem;
+      var refPoint = BuildReference(p != null ? frontArr.Concat(new[] { p.TestFunction.ReferencePoint(p.Objectives) }) : frontArr, problem.Maximization);
       var hv = Hypervolume.Calculate(frontArr, refPoint, problem.Maximization);
-      return Enumerable.Range(0, frontArr.Count).Select(i => Contribution(frontArr, i, problem.Maximization, refPoint, hv)).ArgMin();
+      var contributions = Enumerable.Range(0, frontArr.Count).Select(i => Contribution(frontArr, i, problem.Maximization, refPoint, hv));
+      return contributions.ArgMin();
     }
 
Index: /branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/IIndicator.cs
===================================================================
--- /branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/IIndicator.cs	(revision 14576)
+++ /branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/IIndicator.cs	(revision 14577)
@@ -22,5 +22,6 @@
 using System.Collections.Generic;
 using HeuristicLab.Core;
-using HeuristicLab.Problems.TestFunctions.MultiObjective;
+using HeuristicLab.Encodings.RealVectorEncoding;
+using HeuristicLab.Optimization;
 
 namespace HeuristicLab.Algorithms.MOCMAEvolutionStrategy {
@@ -35,5 +36,5 @@
     /// <param name="problem">The problem on which the front is evaluated (!! The function itself will NOT be evluated only bounds referencePoints & other metadate will be used</param>
     /// <returns>the index of the least contributing point according to any type of quality criteria</returns>
-    int LeastContributer<TR>(IEnumerable<TR> front, Func<TR, double[]> extractor, MultiObjectiveTestFunctionProblem problem);
+    int LeastContributer<TR>(IEnumerable<TR> front, Func<TR, double[]> extractor, MultiObjectiveBasicProblem<RealVectorEncoding> problem);
   }
 }
Index: /branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/MOCMASEvolutionStrategy.cs
===================================================================
--- /branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/MOCMASEvolutionStrategy.cs	(revision 14576)
+++ /branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/MOCMASEvolutionStrategy.cs	(revision 14577)
@@ -44,11 +44,16 @@
     public override Type ProblemType
     {
-      get { return typeof(MultiObjectiveTestFunctionProblem); }
-    }
-    public new MultiObjectiveTestFunctionProblem Problem
-    {
-      get { return (MultiObjectiveTestFunctionProblem)base.Problem; }
+      get { return typeof(MultiObjectiveBasicProblem<RealVectorEncoding>); }
+    }
+    public new MultiObjectiveBasicProblem<RealVectorEncoding> Problem
+    {
+      get { return (MultiObjectiveBasicProblem<RealVectorEncoding>)base.Problem; }
       set { base.Problem = value; }
     }
+    public override bool SupportsPause
+    {
+      get { return false; }
+    }
+
     #region internal variables
     private readonly IRandom random = new MersenneTwister();
@@ -76,5 +81,5 @@
     private const string CrowdingResultName = "Crowding";
     private const string SpacingResultName = "Spacing";
-    private const string SolutionsResultName = "Pareto Front";
+    private const string CurrentFrontResultName = "Pareto Front";
     private const string BestHypervolumeResultName = "Best Hypervolume";
     private const string BestKnownHypervolumeResultName = "Best known hypervolume";
@@ -97,21 +102,21 @@
       get { return (FixedValueParameter<BoolValue>)Parameters[SetSeedRandomlyName]; }
     }
-    private IFixedValueParameter<IntValue> PopulationSizeParameter
+    public IFixedValueParameter<IntValue> PopulationSizeParameter
     {
       get { return (IFixedValueParameter<IntValue>)Parameters[PopulationSizeName]; }
     }
-    private IFixedValueParameter<IntValue> MaximumGenerationsParameter
+    public IFixedValueParameter<IntValue> MaximumGenerationsParameter
     {
       get { return (IFixedValueParameter<IntValue>)Parameters[MaximumGenerationsName]; }
     }
-    private IFixedValueParameter<IntValue> MaximumEvaluatedSolutionsParameter
+    public IFixedValueParameter<IntValue> MaximumEvaluatedSolutionsParameter
     {
       get { return (IFixedValueParameter<IntValue>)Parameters[MaximumEvaluatedSolutionsName]; }
     }
-    private IFixedValueParameter<DoubleValue> InitialSigmaParameter
+    public IFixedValueParameter<DoubleValue> InitialSigmaParameter
     {
       get { return (IFixedValueParameter<DoubleValue>)Parameters[InitialSigmaName]; }
     }
-    private IConstrainedValueParameter<IIndicator> IndicatorParameter
+    public IConstrainedValueParameter<IIndicator> IndicatorParameter
     {
       get { return (IConstrainedValueParameter<IIndicator>)Parameters[IndicatorName]; }
@@ -254,6 +259,6 @@
     private DoubleMatrix ResultsSolutions
     {
-      get { return ((DoubleMatrix)Results[SolutionsResultName].Value); }
-      set { Results[SolutionsResultName].Value = value; }
+      get { return ((DoubleMatrix)Results[CurrentFrontResultName].Value); }
+      set { Results[CurrentFrontResultName].Value = value; }
     }
     private ScatterPlotContent ResultsScatterPlot
@@ -273,5 +278,5 @@
       Parameters.Add(new FixedValueParameter<IntValue>(MaximumGenerationsName, "The maximum number of generations which should be processed.", new IntValue(1000)));
       Parameters.Add(new FixedValueParameter<IntValue>(MaximumEvaluatedSolutionsName, "The maximum number of evaluated solutions that should be computed.", new IntValue(int.MaxValue)));
-      var set = new ItemSet<IIndicator> { new HypervolumeIndicator(), new CrowdingIndicator() };
+      var set = new ItemSet<IIndicator> { new HypervolumeIndicator(), new CrowdingIndicator(), new MinimalDistanceIndicator() };
       Parameters.Add(new ConstrainedValueParameter<IIndicator>(IndicatorName, "The selection mechanism on non-dominated solutions", set, set.First()));
     }
@@ -331,8 +336,8 @@
       solutions = new MOCMAESIndividual[PopulationSize];
       for (var i = 0; i < PopulationSize; i++) {
-        var x = new RealVector(Problem.ProblemSize); // Uniform distibution in all dimensions assumed.
-                                                     // There is the UniformSolutionCreater associated with the Encoding, but it was considered not usable here
-        var bounds = Problem.Bounds;
-        for (var j = 0; j < Problem.ProblemSize; j++) {
+        var x = new RealVector(Problem.Encoding.Length); // Uniform distibution in all dimensions assumed.
+                                                         // There is the UniformSolutionCreater associated with the Encoding, but it was considered not usable here
+        var bounds = Problem.Encoding.Bounds;
+        for (var j = 0; j < Problem.Encoding.Length; j++) {
           var dim = j % bounds.Rows;
           x[j] = random.NextDouble() * (bounds[dim, 1] - bounds[dim, 0]) + bounds[dim, 0];
@@ -344,5 +349,5 @@
     private void InitStrategy() {
       const int lambda = 1;
-      double n = Problem.ProblemSize;
+      double n = Problem.Encoding.Length;
 
       var targetSuccessProbability = 1.0 / (5.0 + Math.Sqrt(lambda) / 2.0);
@@ -377,12 +382,14 @@
       table.Rows.Add(new DataRow(SpacingResultName));
       AddResult(TimetableResultName, "Different quality meassures in a timeseries", table);
-      AddResult(SolutionsResultName, "The current front", new DoubleMatrix());
+      AddResult(CurrentFrontResultName, "The current front", new DoubleMatrix());
       AddResult(ScatterPlotResultName, "A scatterplot displaying the evaluated solutions and (if available) the analytically optimal front", new ScatterPlotContent(null, null, null, 2));
 
-      if (Problem.BestKnownFront != null) {
-        ResultsBestKnownHypervolume = Hypervolume.Calculate(Utilities.ToArray(Problem.BestKnownFront), Problem.TestFunction.ReferencePoint(Problem.Objectives), Problem.Maximization);
+      var problem = Problem as MultiObjectiveTestFunctionProblem;
+      if (problem == null) return;
+      if (problem.BestKnownFront != null) {
+        ResultsBestKnownHypervolume = Hypervolume.Calculate(Utilities.ToArray(problem.BestKnownFront), problem.TestFunction.ReferencePoint(problem.Objectives), Problem.Maximization);
         ResultsDifferenceBestKnownHypervolume = ResultsBestKnownHypervolume;
       }
-      ResultsScatterPlot = new ScatterPlotContent(null, null, Utilities.ToArray(Problem.BestKnownFront), Problem.Objectives);
+      ResultsScatterPlot = new ScatterPlotContent(new double[0][], new double[0][], Utilities.ToArray(problem.BestKnownFront), problem.Objectives);
     }
     #endregion
@@ -411,14 +418,17 @@
     }
     private double[] Evaluate(RealVector x) {
-      var res = Problem.Evaluate(x);
+      var s = new Scope();
+      s.Variables.Add(new Variable(Problem.Encoding.Name, x));
+      var ind = new SingleEncodingIndividual(Problem.Encoding, s);
+      var res = Problem.Evaluate(ind, random);
       ResultsEvaluations++;
       return res;
     }
-    private static double[] Penalize(RealVector x, RealVector t, IEnumerable<double> fitness) {
-      var penalty = x.Select((t1, i) => t1 - t[i]).Sum(d => d * d);
-      return fitness.Select(v => v + penalty).ToArray();
+    private double[] Penalize(RealVector x, RealVector t, IEnumerable<double> fitness) {
+      var penalty = x.Zip(t, (a, b) => (a - b) * (a - b)).Sum() * 1E-6;
+      return fitness.Select((v, i) => Problem.Maximization[i] ? v - penalty : v + penalty).ToArray();
     }
     private RealVector ClosestFeasible(RealVector x) {
-      var bounds = Problem.Bounds;
+      var bounds = Problem.Encoding.Bounds;
       var r = new RealVector(x.Length);
       for (var i = 0; i < x.Length; i++) {
@@ -429,5 +439,5 @@
     }
     private bool IsFeasable(RealVector offspring) {
-      var bounds = Problem.Bounds;
+      var bounds = Problem.Encoding.Bounds;
       for (var i = 0; i < offspring.Length; i++) {
         var dim = i % bounds.Rows;
@@ -452,6 +462,8 @@
       }
 
+
       //now use the indicator to deselect the approximatingly worst elements of the last selected front
       var front1 = fronts[rank];
+      front1.Sort(new HelpComparer());
       for (; popSize > length; popSize--) {
         var lc = Indicator.LeastContributer(front1.ToArray(), x => x.PenalizedFitness, Problem);
@@ -486,13 +498,17 @@
     }
     private void AnalyzeQualityIndicators() {
-      var front = NonDominatedSelect.GetDominatingVectors(solutions.Select(x => x.Fitness), Problem.TestFunction.ReferencePoint(Problem.Objectives), Problem.Maximization, true).ToArray();
-      var bounds = Problem.Bounds.CloneAsMatrix();
+      var problem = Problem as MultiObjectiveTestFunctionProblem;
+      if (problem == null) return;
+
+      var front = NonDominatedSelect.GetDominatingVectors(solutions.Select(x => x.Fitness), problem.TestFunction.ReferencePoint(problem.Objectives), Problem.Maximization, true).ToArray();
+      if (front.Length == 0) return;
+      var bounds = problem.Bounds.CloneAsMatrix();
       ResultsCrowding = Crowding.Calculate(front, bounds);
       ResultsSpacing = Spacing.Calculate(front);
-      ResultsGenerationalDistance = Problem.BestKnownFront != null ? GenerationalDistance.Calculate(front, Utilities.ToArray(Problem.BestKnownFront), 1) : double.NaN;
-
-      ResultsInvertedGenerationalDistance = Problem.BestKnownFront != null ? InvertedGenerationalDistance.Calculate(front, Utilities.ToArray(Problem.BestKnownFront), 1) : double.NaN;
-
-      ResultsHypervolume = Hypervolume.Calculate(front, Problem.TestFunction.ReferencePoint(Problem.Objectives), Problem.Maximization);
+      ResultsGenerationalDistance = problem.BestKnownFront != null ? GenerationalDistance.Calculate(front, Utilities.ToArray(problem.BestKnownFront), 1) : double.NaN;
+
+      ResultsInvertedGenerationalDistance = problem.BestKnownFront != null ? InvertedGenerationalDistance.Calculate(front, Utilities.ToArray(problem.BestKnownFront), 1) : double.NaN;
+
+      ResultsHypervolume = Hypervolume.Calculate(front, problem.TestFunction.ReferencePoint(problem.Objectives), Problem.Maximization);
       ResultsBestHypervolume = Math.Max(ResultsHypervolume, ResultsBestHypervolume);
       ResultsDifferenceBestKnownHypervolume = ResultsBestKnownHypervolume - ResultsBestHypervolume;
@@ -510,5 +526,9 @@
     #endregion
 
-
+    private class HelpComparer : IComparer<MOCMAESIndividual> {
+      public int Compare(MOCMAESIndividual x, MOCMAESIndividual y) {
+        return x.PenalizedFitness[0].CompareTo(y.PenalizedFitness[0]);
+      }
+    }
 
     #region Helpers
Index: /branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/MinimalDistanceIndicator.cs
===================================================================
--- /branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/MinimalDistanceIndicator.cs	(revision 14577)
+++ /branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/MinimalDistanceIndicator.cs	(revision 14577)
@@ -0,0 +1,96 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 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.Core;
+using HeuristicLab.Encodings.RealVectorEncoding;
+using HeuristicLab.Optimization;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Algorithms.MOCMAEvolutionStrategy {
+  [Item("MinimalDistanceIndicator", "Selection of Offspring based on distance to nearest neighbour")]
+  [StorableClass]
+  internal class MinimalDistanceIndicator : Item, IIndicator {
+
+    public int LeastContributer<TR>(IEnumerable<TR> front, Func<TR, double[]> extractor, MultiObjectiveBasicProblem<RealVectorEncoding> problem) {
+      var extracted = front.Select(extractor.Invoke).ToArray();
+      if (extracted.Length <= 2) return 0;
+      var distances = CalcDistances(extracted);
+      var mindexI = 0;
+      var mindexJ = 0;
+      var min = double.MaxValue;
+      for (var i = 0; i < extracted.Length; i++) {
+        var d = double.MaxValue;
+        var minj = 0;
+        for (var j = 0; j < extracted.Length; j++) {
+          if (i == j) continue;
+          var d1 = distances[i, j];
+          if (!(d1 < d)) continue;
+          minj = j;
+          d = d1;
+        }
+        if (!(d < min)) continue;
+        min = d;
+        mindexI = i;
+        mindexJ = minj;
+      }
+
+      //break tie with distance to second nearest
+      var minI = double.MaxValue;
+      var minJ = double.MaxValue;
+
+      for (var i = 0; i < extracted.Length; i++) {
+        double d;
+        if (mindexI != i) {
+          d = distances[mindexI, i];
+          if (!d.IsAlmost(min)) minI = Math.Min(minI, d);
+        }
+        if (mindexJ == i) continue;
+        d = distances[mindexJ, i];
+        if (!d.IsAlmost(min)) minJ = Math.Min(minJ, d);
+      }
+
+      //find min
+      return minI < minJ ? mindexI : mindexJ;
+    }
+
+    private static double[,] CalcDistances(IReadOnlyList<double[]> extracted) {
+      var res = new double[extracted.Count, extracted.Count];
+      for (var i = 0; i < extracted.Count; i++)
+        for (var j = 0; j < i; j++)
+          res[i, j] = res[j, i] = Dist(extracted[i], extracted[j]);
+      return res;
+    }
+
+
+    private static double Dist(IEnumerable<double> a, IEnumerable<double> b) {
+      return Math.Sqrt(a.Zip(b, (x, y) => (x - y) * (x - y)).Sum());
+    }
+    [StorableConstructor]
+    protected MinimalDistanceIndicator(bool deserializing) : base(deserializing) { }
+    protected MinimalDistanceIndicator(MinimalDistanceIndicator original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) { return new MinimalDistanceIndicator(this, cloner); }
+    public MinimalDistanceIndicator() { }
+  }
+}
Index: /branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/Plugin.cs.frame
===================================================================
--- /branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/Plugin.cs.frame	(revision 14576)
+++ /branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/Plugin.cs.frame	(revision 14577)
@@ -33,13 +33,9 @@
   [PluginDependency("HeuristicLab.Common", "3.3")]
   [PluginDependency("HeuristicLab.Core", "3.3")]
-  [PluginDependency("HeuristicLab.Core.Views", "3.3")]
   [PluginDependency("HeuristicLab.Data", "3.3")]
   [PluginDependency("HeuristicLab.Encodings.RealVectorEncoding", "3.3")]
-  [PluginDependency("HeuristicLab.Operators", "3.3")]
   [PluginDependency("HeuristicLab.Optimization", "3.3")]
-  [PluginDependency("HeuristicLab.Optimization.Operators", "3.3")]
   [PluginDependency("HeuristicLab.Parameters", "3.3")]
   [PluginDependency("HeuristicLab.Persistence", "3.3")]
-  [PluginDependency("HeuristicLab.Problems.Instances", "3.3")]
   [PluginDependency("HeuristicLab.Problems.TestFunctions.MultiObjective", "3.3")]
   [PluginDependency("HeuristicLab.Random", "3.3")]
Index: /branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/Utilities.cs
===================================================================
--- /branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/Utilities.cs	(revision 14576)
+++ /branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/Utilities.cs	(revision 14577)
@@ -5,4 +5,5 @@
   internal static class Utilities {
     internal static double[][] ToArray(DoubleMatrix m) {
+      if (m == null) return null;
       var i = m.Rows - 1;
       var a = new double[i][];
@@ -16,5 +17,5 @@
 
     public static int ArgMin<T>(IEnumerable<T> values, IComparer<T> comparer) {
-      var mindex = 0;
+      var mindex = -1;
       var min = default(T);
       var i = 0;
@@ -30,5 +31,5 @@
     }
     public static int ArgMax<T>(IEnumerable<T> values, IComparer<T> comparer) {
-      var mindex = 0;
+      var mindex = -1;
       var min = default(T);
       var i = 0;
