Index: /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Analyzers/CrowdingAnalyzer.cs
===================================================================
--- /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Analyzers/CrowdingAnalyzer.cs	(revision 14096)
+++ /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Analyzers/CrowdingAnalyzer.cs	(revision 14097)
@@ -37,4 +37,8 @@
     }
 
+    public IResultParameter<DoubleValue> CrowdingResultParameter {
+      get { return (IResultParameter<DoubleValue>)Parameters["Crowding"]; }
+    }
+
     [StorableConstructor]
     protected CrowdingAnalyzer(bool deserializing) : base(deserializing) { }
@@ -49,16 +53,15 @@
       Parameters.Add(new LookupParameter<DoubleMatrix>("Bounds",
         "The bounds of the solution given as either one line for all variables or a line for each variable. The first column specifies lower bound, the second upper bound."));
+      Parameters.Add(new ResultParameter<DoubleValue>("Crowding", "The average corwding value of all points (excluding infinities)"));
+      CrowdingResultParameter.DefaultValue = new DoubleValue(double.NaN);
+
     }
 
     public override IOperation Apply() {
-      var results = ResultsParameter.ActualValue;
       var qualities = QualitiesParameter.ActualValue;
       var bounds = BoundsParameter.ActualValue;
 
-      if (!results.ContainsKey("Crowding")) results.Add(new Result("Crowding", new DoubleValue()));
-      var resultValue = (DoubleValue)results["Crowding"].Value;
-
       var crowdingDistance = Crowding.Calculate(qualities.Select(x => x.ToArray()), bounds.CloneAsMatrix());
-      resultValue.Value = crowdingDistance;
+      CrowdingResultParameter.ActualValue.Value = crowdingDistance;
 
       return base.Apply();
Index: /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Analyzers/GenerationalDistanceAnalyzer.cs
===================================================================
--- /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Analyzers/GenerationalDistanceAnalyzer.cs	(revision 14096)
+++ /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Analyzers/GenerationalDistanceAnalyzer.cs	(revision 14097)
@@ -20,4 +20,5 @@
 #endregion
 
+using System;
 using System.Linq;
 using HeuristicLab.Common;
@@ -43,4 +44,8 @@
     }
 
+    public IResultParameter<DoubleValue> GenerationalDistanceResultParameter {
+      get { return (IResultParameter<DoubleValue>)Parameters["Generational Distance"]; }
+    }
+
     [StorableConstructor]
     protected GenerationalDistanceAnalyzer(bool deserializing) : base(deserializing) { }
@@ -52,8 +57,10 @@
     public GenerationalDistanceAnalyzer() {
       Parameters.Add(new FixedValueParameter<DoubleValue>("Dampening", "", new DoubleValue(1)));
+      Parameters.Add(new ResultParameter<DoubleValue>("Generational Distance", "The genrational distance between the current front and the optimal front"));
+      GenerationalDistanceResultParameter.DefaultValue = new DoubleValue(double.NaN);
+
     }
 
     public override IOperation Apply() {
-      var results = ResultsParameter.ActualValue;
       var qualities = QualitiesParameter.ActualValue;
       int objectives = qualities[0].Length;
@@ -62,9 +69,6 @@
       if (optimalfront == null) return base.Apply();
 
-      if (!results.ContainsKey("GenerationalDistance")) results.Add(new Result("GenerationalDistance", new DoubleValue()));
-      var resultValue = (DoubleValue)results["GenerationalDistance"].Value;
-
       var distance = GenerationalDistance.Calculate(qualities.Select(x => x.CloneAsArray()), optimalfront, Dampening);
-      resultValue.Value = distance;
+      GenerationalDistanceResultParameter.ActualValue.Value = distance;
 
       return base.Apply();
Index: /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Analyzers/HypervolumeAnalyzer.cs
===================================================================
--- /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Analyzers/HypervolumeAnalyzer.cs	(revision 14096)
+++ /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Analyzers/HypervolumeAnalyzer.cs	(revision 14097)
@@ -38,4 +38,14 @@
       get { return (ILookupParameter<DoubleArray>)Parameters["ReferencePoint"]; }
     }
+    public IResultParameter<DoubleValue> HypervolumeResultParameter {
+      get { return (IResultParameter<DoubleValue>)Parameters["Hypervolume"]; }
+    }
+    public IResultParameter<DoubleValue> BestKnownHypervolumeResultParameter {
+      get { return (IResultParameter<DoubleValue>)Parameters["Best known hypervolume"]; }
+    }
+    public IResultParameter<DoubleValue> HypervolumeDistanceResultParameter {
+      get { return (IResultParameter<DoubleValue>)Parameters["Absolute Distance to BestKnownHypervolume"]; }
+    }
+
 
     [StorableConstructor]
@@ -52,8 +62,15 @@
     public HypervolumeAnalyzer() {
       Parameters.Add(new LookupParameter<DoubleArray>("ReferencePoint", "The reference point for hypervolume calculation"));
+      Parameters.Add(new ResultParameter<DoubleValue>("Hypervolume", "The hypervolume of the current generation"));
+      Parameters.Add(new ResultParameter<DoubleValue>("Best known hypervolume", "The optimal hypervolume"));
+      Parameters.Add(new ResultParameter<DoubleValue>("Absolute Distance to BestKnownHypervolume", "The difference between the best known and the current hypervolume"));
+      HypervolumeResultParameter.DefaultValue = new DoubleValue(0);
+      BestKnownHypervolumeResultParameter.DefaultValue = new DoubleValue(0);
+      HypervolumeDistanceResultParameter.DefaultValue = new DoubleValue(0);
+
+
     }
 
     public override IOperation Apply() {
-      var results = ResultsParameter.ActualValue;
       var qualities = QualitiesParameter.ActualValue;
       var testFunction = TestFunctionParameter.ActualValue;
@@ -61,14 +78,8 @@
       var referencePoint = ReferencePointParameter.ActualValue;
 
-      if (!results.ContainsKey("Hypervolume")) results.Add(new Result("Hypervolume", new DoubleValue(0)));
-      if (!results.ContainsKey("Absolute Distance to BestKnownHypervolume")) results.Add(new Result("Absolute Distance to BestKnownHypervolume", new DoubleValue(0)));
-
-      double best = testFunction.OptimalHypervolume(objectives);
-      if (!results.ContainsKey("BestKnownHypervolume")) {
-        results.Add(new Result("BestKnownHypervolume", new DoubleValue(0)));
-      } else {
-        best = Math.Max(best, ((DoubleValue)(results["BestKnownHypervolume"].Value)).Value);
+      double best = BestKnownHypervolumeResultParameter.ActualValue.Value;
+      if (referencePoint.SequenceEqual(testFunction.ReferencePoint(objectives))) {
+        best = Math.Max(best, testFunction.OptimalHypervolume(objectives));
       }
-
 
       IEnumerable<double[]> front = NonDominatedSelect.SelectNonDominatedVectors(qualities.Select(q => q.ToArray()), testFunction.Maximization(objectives), true);
@@ -76,12 +87,11 @@
       double hv = Hypervolume.Calculate(front, referencePoint.ToArray(), testFunction.Maximization(objectives));
 
-      if (double.IsNaN(best) || best < hv) {
+      if (!double.IsNaN(hv) || best < hv) {
         best = hv;
-        BestKnownFrontParameter.ActualValue = new DoubleMatrix(MultiObjectiveTestFunctionProblem.To2D(qualities.Select(q => q.ToArray()).ToArray()));
       }
 
-      ((DoubleValue)(results["Hypervolume"].Value)).Value = hv;
-      ((DoubleValue)(results["BestKnownHypervolume"].Value)).Value = best;
-      ((DoubleValue)(results["Absolute Distance to BestKnownHypervolume"].Value)).Value = best - hv;
+      HypervolumeResultParameter.ActualValue.Value = hv;
+      BestKnownHypervolumeResultParameter.ActualValue.Value = best;
+      HypervolumeDistanceResultParameter.ActualValue.Value = best - hv;
 
       return base.Apply();
Index: /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Analyzers/InvertedGenerationalDistanceAnalyzer.cs
===================================================================
--- /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Analyzers/InvertedGenerationalDistanceAnalyzer.cs	(revision 14096)
+++ /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Analyzers/InvertedGenerationalDistanceAnalyzer.cs	(revision 14097)
@@ -43,7 +43,15 @@
     }
 
+    public IResultParameter<DoubleValue> InvertedGenerationalDistanceResultParameter {
+      get { return (IResultParameter<DoubleValue>)Parameters["Inverted Generational Distance"]; }
+    }
+
     public InvertedGenerationalDistanceAnalyzer() {
       Parameters.Add(new FixedValueParameter<DoubleValue>("Dampening", "", new DoubleValue(1)));
+      Parameters.Add(new ResultParameter<DoubleValue>("Inverted Generational Distance", "The genrational distance between the current front and the optimal front"));
+      InvertedGenerationalDistanceResultParameter.DefaultValue = new DoubleValue(double.NaN);
+
     }
+
 
     [StorableConstructor]
@@ -55,5 +63,4 @@
 
     public override IOperation Apply() {
-      var results = ResultsParameter.ActualValue;
       var qualities = QualitiesParameter.ActualValue;
       var testFunction = TestFunctionParameter.ActualValue;
@@ -63,9 +70,6 @@
       if (optimalfront == null) return base.Apply();
 
-      if (!results.ContainsKey("InvertedGenerationalDistance")) results.Add(new Result("InvertedGenerationalDistance", new DoubleValue(double.NaN)));
-      var resultValue = (DoubleValue)results["InvertedGenerationalDistance"].Value;
-
       var invertedGenerationalDistance = InvertedGenerationalDistance.Calculate(qualities.Select(q => q.ToArray()), optimalfront, DampeningParameter.Value.Value);
-      resultValue.Value = invertedGenerationalDistance;
+      InvertedGenerationalDistanceResultParameter.ActualValue.Value = invertedGenerationalDistance;
 
       return base.Apply();
Index: /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Analyzers/ScatterPlotAnalyzer.cs
===================================================================
--- /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Analyzers/ScatterPlotAnalyzer.cs	(revision 14096)
+++ /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Analyzers/ScatterPlotAnalyzer.cs	(revision 14097)
@@ -37,4 +37,9 @@
     }
 
+    public IResultParameter<ScatterPlotContent> ScatterPlotResultParameter {
+      get { return (IResultParameter<ScatterPlotContent>)Parameters["Scatterplot"]; }
+    }
+
+
     [StorableConstructor]
     protected ScatterPlotAnalyzer(bool deserializing) : base(deserializing) { }
@@ -46,16 +51,13 @@
     public ScatterPlotAnalyzer() {
       Parameters.Add(new ScopeTreeLookupParameter<RealVector>("Individuals", "The individual solutions to the problem"));
+      Parameters.Add(new ResultParameter<ScatterPlotContent>("Scatterplot", "The scatterplot for the current and optimal (if known front)"));
+
     }
 
     public override IOperation Apply() {
-      var results = ResultsParameter.ActualValue;
       var qualities = QualitiesParameter.ActualValue;
       var testFunction = TestFunctionParameter.ActualValue;
       int objectives = qualities[0].Length;
       var individuals = IndividualsParameter.ActualValue;
-
-      if (!results.ContainsKey("Scatterplot")) {
-        results.Add(new Result("Scatterplot", typeof(ScatterPlotContent)));
-      }
 
       double[][] optimalFront = new double[0][];
@@ -66,5 +68,5 @@
       var solutionClones = individuals.Select(s => s.ToArray()).ToArray();
 
-      results["Scatterplot"].Value = new ScatterPlotContent(qualityClones, solutionClones, optimalFront, objectives);
+      ScatterPlotResultParameter.ActualValue = new ScatterPlotContent(qualityClones, solutionClones, optimalFront, objectives);
 
       return base.Apply();
Index: /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Analyzers/SpacingAnalyzer.cs
===================================================================
--- /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Analyzers/SpacingAnalyzer.cs	(revision 14096)
+++ /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Analyzers/SpacingAnalyzer.cs	(revision 14097)
@@ -31,6 +31,11 @@
   [Item("SpacingAnalyzer", "The spacing of the current front (see Multi-Objective Performance Metrics - Shodhganga for more information)")]
   public class SpacingAnalyzer : MOTFAnalyzer {
+
+    public IResultParameter<DoubleValue> SpacingResultParameter {
+      get { return (IResultParameter<DoubleValue>)Parameters["Spacing"]; }
+    }
     [StorableConstructor]
     protected SpacingAnalyzer(bool deserializing) : base(deserializing) { }
+
 
     protected SpacingAnalyzer(SpacingAnalyzer original, Cloner cloner) : base(original, cloner) { }
@@ -39,15 +44,13 @@
     }
 
-    public SpacingAnalyzer() { }
+    public SpacingAnalyzer() {
+      Parameters.Add(new ResultParameter<DoubleValue>("Spacing", "The spacing of the current front"));
+      SpacingResultParameter.DefaultValue = new DoubleValue(double.NaN);
+    }
 
     public override IOperation Apply() {
-      var results = ResultsParameter.ActualValue;
       var qualities = QualitiesParameter.ActualValue;
-
-      if (!results.ContainsKey("Spacing")) results.Add(new Result("Spacing", new DoubleValue(0)));
-      var resultValue = (DoubleValue)results["Spacing"].Value;
-
       var spacing = Spacing.Calculate(qualities.Select(q => q.ToArray()));
-      resultValue.Value = spacing;
+      SpacingResultParameter.ActualValue.Value = spacing;
 
       return base.Apply();
Index: anches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Calculators/Utilities.cs
===================================================================
--- /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Calculators/Utilities.cs	(revision 14096)
+++ 	(revision )
@@ -1,62 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2016 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;
-
-namespace HeuristicLab.Problems.MultiObjectiveTestFunctions {
-  internal static class Utilities {
-    internal static double MinimumDistance(double[] point, IEnumerable<double[]> points) {
-      if (point == null) throw new ArgumentNullException("Point must not be null.");
-      if (points == null) throw new ArgumentNullException("Points must not be null.");
-      if (!points.Any()) throw new ArgumentException("Points must not be empty.");
-
-      double minDistance = double.MaxValue;
-      foreach (double[] r in points) {
-        if (r.Length != point.Length) throw new ArgumentException("Dimensions of Points and Point do not match.");
-
-        double squaredDistance = 0;
-        for (int i = 0; i < r.Length; i++) {
-          squaredDistance += (point[i] - r[i]) * (point[i] - r[i]);
-        }
-        minDistance = Math.Min(squaredDistance, minDistance);
-      }
-
-      return Math.Sqrt(minDistance);
-    }
-
-    internal class DimensionComparer : IComparer<double[]> {
-      private readonly int dim;
-      private readonly int descending;
-
-      public DimensionComparer(int dimension, bool descending) {
-        this.dim = dimension;
-        this.descending = descending ? -1 : 1;
-      }
-
-      public int Compare(double[] x, double[] y) {
-        if (x[dim] < y[dim]) return -descending;
-        else if (x[dim] > y[dim]) return descending;
-        else return 0;
-      }
-    }
-  }
-}
Index: /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/HeuristicLab.Problems.MultiObjectiveTestFunctions-3.3.csproj
===================================================================
--- /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/HeuristicLab.Problems.MultiObjectiveTestFunctions-3.3.csproj	(revision 14096)
+++ /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/HeuristicLab.Problems.MultiObjectiveTestFunctions-3.3.csproj	(revision 14097)
@@ -161,5 +161,5 @@
     <Compile Include="Calculators\InvertedGenerationalDistance.cs" />
     <Compile Include="Calculators\GenerationalDistance.cs" />
-    <Compile Include="Calculators\Utilities.cs" />
+    <Compile Include="Utilities.cs" />
     <Compile Include="Instances\MISCInstanceProvider.cs" />
     <Compile Include="Instances\ZDTInstanceProvider.cs" />
Index: /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/MultiObjectiveTestFunctionProblem.cs
===================================================================
--- /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/MultiObjectiveTestFunctionProblem.cs	(revision 14096)
+++ /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/MultiObjectiveTestFunctionProblem.cs	(revision 14097)
@@ -174,5 +174,5 @@
       var front = TestFunction.OptimalParetoFront(Objectives);
       if (front != null) {
-        BestKnownFrontParameter.Value = (DoubleMatrix)new DoubleMatrix(To2D(front.ToArray())).AsReadOnly();
+        BestKnownFrontParameter.Value = (DoubleMatrix)Utilities.ToMatrix(front).AsReadOnly();
       } else BestKnownFrontParameter.Value = null;
 
@@ -249,21 +249,4 @@
     }
 
-    public static T[,] To2D<T>(T[][] source) {
-      try {
-        int firstDimension = source.Length;
-        int secondDimension = source.GroupBy(row => row.Length).Single().Key; // throws InvalidOperationException if source is not rectangular
-
-        var result = new T[firstDimension, secondDimension];
-        for (int i = 0; i < firstDimension; ++i)
-          for (int j = 0; j < secondDimension; ++j)
-            result[i, j] = source[i][j];
-
-        return result;
-      }
-      catch (InvalidOperationException) {
-        throw new InvalidOperationException("The given jagged array is not rectangular.");
-      }
-    }
-
     #endregion
   }
Index: /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Utilities.cs
===================================================================
--- /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Utilities.cs	(revision 14097)
+++ /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Utilities.cs	(revision 14097)
@@ -0,0 +1,80 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2016 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.Problems.MultiObjectiveTestFunctions {
+  internal static class Utilities {
+    internal static double MinimumDistance(double[] point, IEnumerable<double[]> points) {
+      if (point == null) throw new ArgumentNullException("Point must not be null.");
+      if (points == null) throw new ArgumentNullException("Points must not be null.");
+      if (!points.Any()) throw new ArgumentException("Points must not be empty.");
+
+      double minDistance = double.MaxValue;
+      foreach (double[] r in points) {
+        if (r.Length != point.Length) throw new ArgumentException("Dimensions of Points and Point do not match.");
+
+        double squaredDistance = 0;
+        for (int i = 0; i < r.Length; i++) {
+          squaredDistance += (point[i] - r[i]) * (point[i] - r[i]);
+        }
+        minDistance = Math.Min(squaredDistance, minDistance);
+      }
+
+      return Math.Sqrt(minDistance);
+    }
+
+    internal static DoubleMatrix ToMatrix(IEnumerable<double[]> source) {
+      try {
+        int firstDimension = source.Count();
+        int secondDimension = source.GroupBy(row => row.Length).Single().Key; // throws InvalidOperationException if source is not rectangular
+
+        var result = new DoubleMatrix(firstDimension, secondDimension);
+        var enumarator = source.GetEnumerator();
+        for (int i = 0; i < firstDimension && enumarator.MoveNext(); ++i)
+          for (int j = 0; j < secondDimension; ++j)
+            result[i, j] = enumarator.Current[j];
+        return result;
+      }
+      catch (InvalidOperationException) {
+        throw new InvalidOperationException("The given jagged array is not rectangular.");
+      }
+    }
+
+    internal class DimensionComparer : IComparer<double[]> {
+      private readonly int dim;
+      private readonly int descending;
+
+      public DimensionComparer(int dimension, bool descending) {
+        this.dim = dimension;
+        this.descending = descending ? -1 : 1;
+      }
+
+      public int Compare(double[] x, double[] y) {
+        if (x[dim] < y[dim]) return -descending;
+        else if (x[dim] > y[dim]) return descending;
+        else return 0;
+      }
+    }
+  }
+}
Index: /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Views/ScatterPlotContent.cs
===================================================================
--- /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Views/ScatterPlotContent.cs	(revision 14096)
+++ /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Views/ScatterPlotContent.cs	(revision 14097)
@@ -28,4 +28,5 @@
 namespace HeuristicLab.Problems.MultiObjectiveTestFunctions {
   [StorableClass]
+  [Item("ScatterPlot", "The optimal front, current front and its associated Points in the searchspace")]
   public class ScatterPlotContent : Item {
 
@@ -37,5 +38,5 @@
       }
 
-      set {
+      private set {
         qualities = value;
       }
@@ -49,5 +50,5 @@
       }
 
-      set {
+      private set {
         objectives = value;
       }
@@ -61,5 +62,5 @@
       }
 
-      set {
+      private set {
         solutions = value;
       }
@@ -73,5 +74,5 @@
       }
 
-      set {
+      private set {
         paretoFront = value;
       }
