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 14084)
+++ branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Analyzers/CrowdingAnalyzer.cs	(revision 14085)
@@ -25,4 +25,5 @@
 using HeuristicLab.Data;
 using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
@@ -31,4 +32,8 @@
   [Item("CrowdingAnalyzer", "The mean crowding distance for each point of the Front (see Multi-Objective Performance Metrics - Shodhganga for more information)")]
   public class CrowdingAnalyzer : MOTFAnalyzer {
+
+    public ILookupParameter<DoubleMatrix> BoundsParameter {
+      get { return (ILookupParameter<DoubleMatrix>)Parameters["Bounds"]; }
+    }
 
     [StorableConstructor]
@@ -41,16 +46,18 @@
     }
 
-    public CrowdingAnalyzer() { }
+    public CrowdingAnalyzer() {
+      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."));
+    }
 
     public override IOperation Apply() {
       var results = ResultsParameter.ActualValue;
       var qualities = QualitiesParameter.ActualValue;
-      var testFunction = TestFunctionParameter.ActualValue;
-      int objectives = qualities[0].Length;
+      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()), testFunction.Bounds(objectives));
+      var crowdingDistance = Crowding.Calculate(qualities.Select(x => x.ToArray()), bounds.CloneAsMatrix());
       resultValue.Value = crowdingDistance;
 
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 14084)
+++ branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Analyzers/GenerationalDistanceAnalyzer.cs	(revision 14085)
@@ -65,5 +65,5 @@
       var resultValue = (DoubleValue)results["GenerationalDistance"].Value;
 
-      var distance = GenerationalDistance.Calculate(qualities.Select(x => x.ToArray()), optimalfront, Dampening);
+      var distance = GenerationalDistance.Calculate(qualities.Select(x => x.CloneAsArray()), optimalfront, Dampening);
       resultValue.Value = distance;
 
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 14084)
+++ branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Analyzers/HypervolumeAnalyzer.cs	(revision 14085)
@@ -34,6 +34,6 @@
   public class HypervolumeAnalyzer : MOTFAnalyzer {
 
-    public IValueParameter<DoubleArray> ReferencePointParameter {
-      get { return (IValueParameter<DoubleArray>)Parameters["ReferencePoint"]; }
+    public ILookupParameter<DoubleArray> ReferencePointParameter {
+      get { return (ILookupParameter<DoubleArray>)Parameters["ReferencePoint"]; }
     }
 
@@ -49,12 +49,7 @@
     [StorableConstructor]
     protected HypervolumeAnalyzer(bool deserializing) : base(deserializing) { }
-    [StorableHook(HookType.AfterDeserialization)]
-    private void AfterDeserialization() {
-      RegisterEventHandlers();
-    }
 
     protected HypervolumeAnalyzer(HypervolumeAnalyzer original, Cloner cloner)
       : base(original, cloner) {
-      RegisterEventHandlers();
     }
     public override IDeepCloneable Clone(Cloner cloner) {
@@ -63,12 +58,6 @@
 
     public HypervolumeAnalyzer() {
-      Parameters.Add(new ValueParameter<DoubleArray>("ReferencePoint", "The reference point for hypervolume calculation"));
+      Parameters.Add(new LookupParameter<DoubleArray>("ReferencePoint", "The reference point for hypervolume calculation"));
       Parameters.Add(new FixedValueParameter<DoubleValue>("BestKnownHyperVolume", "The currently best known hypervolume", new DoubleValue(0)));
-
-      RegisterEventHandlers();
-    }
-
-    private void RegisterEventHandlers() {
-      ReferencePointParameter.ValueChanged += (o, e) => BestKnownHyperVolume = 0;
     }
 
@@ -77,5 +66,8 @@
       var qualities = QualitiesParameter.ActualValue;
       var testFunction = TestFunctionParameter.ActualValue;
+      var referencePoint = ReferencePointParameter.ActualValue;
       int objectives = qualities[0].Length;
+
+
 
       if (!results.ContainsKey("Hypervolume")) results.Add(new Result("Hypervolume", typeof(DoubleValue)));
@@ -93,5 +85,5 @@
       IEnumerable<double[]> front = NonDominatedSelect.SelectNonDominatedVectors(qualities.Select(q => q.ToArray()), testFunction.Maximization(objectives), true);
 
-      double hv = front.Any() ? Hypervolume.Calculate(front, testFunction.ReferencePoint(objectives), testFunction.Maximization(objectives)) : 0;
+      double hv = front.Any() ? Hypervolume.Calculate(front, referencePoint.CloneAsArray(), testFunction.Maximization(objectives)) : 0;
 
 
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 14084)
+++ branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Analyzers/InvertedGenerationalDistanceAnalyzer.cs	(revision 14085)
@@ -60,5 +60,5 @@
       int objectives = qualities[0].Length;
 
-      var optimalfront = TestFunctionParameter.ActualValue.OptimalParetoFront(objectives);
+      var optimalfront = testFunction.OptimalParetoFront(objectives);
       if (optimalfront == null) return base.Apply();
 
Index: branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Interfaces/IMultiObjectiveTestFunction.cs
===================================================================
--- branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Interfaces/IMultiObjectiveTestFunction.cs	(revision 14084)
+++ branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Interfaces/IMultiObjectiveTestFunction.cs	(revision 14085)
@@ -31,7 +31,8 @@
     bool[] Maximization(int objectives);
     double[,] Bounds(int objectives);
+
     IEnumerable<double[]> OptimalParetoFront(int objectives);
+    double OptimalHypervolume(int objectives);
     double[] ReferencePoint(int objectives);
-    double BestKnownHypervolume(int objectives);
 
     int MinimumSolutionLength { get; }
Index: branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/MultiObjectiveTestFunctionProblem.cs
===================================================================
--- branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/MultiObjectiveTestFunctionProblem.cs	(revision 14084)
+++ branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/MultiObjectiveTestFunctionProblem.cs	(revision 14085)
@@ -65,7 +65,6 @@
     public override bool[] Maximization {
       get {
-        //necessary because of virtual member call in base ctor to this property
-        if (!Parameters.ContainsKey("TestFunction")) return new bool[2];
-        return TestFunction.Maximization(Objectives);
+        if (!Parameters.ContainsKey("Maximization")) return new bool[2];
+        return MaximizationParameter.Value.ToArray();
       }
     }
@@ -87,6 +86,11 @@
       set { TestFunctionParameter.Value = value; }
     }
-    public IEnumerable<double[]> BestKnownFront {
-      get { return Parameters.ContainsKey("BestKnownFront") ? TestFunction.OptimalParetoFront(Objectives) : null; }
+    public DoubleArray ReferencePoint {
+      get { return ReferencePointParameter.Value; }
+      set { ReferencePointParameter.Value = value; }
+    }
+    public DoubleMatrix BestKnownFront {
+      get { return BestKnownFrontParameter.Value; }
+      set { BestKnownFrontParameter.Value = value; }
     }
     #endregion
@@ -112,4 +116,5 @@
       Parameters.Add(new FixedValueParameter<IntValue>("Objectives", "The dimensionality of the solution vector (number of objectives).", new IntValue(2)));
       Parameters.Add(new ValueParameter<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.", new DoubleMatrix(new double[,] { { -4, 4 } })));
+      Parameters.Add(new ValueParameter<DoubleArray>("ReferencePoint", "The reference point used for hypervolume calculation."));
       Parameters.Add(new ValueParameter<IMultiObjectiveTestFunction>("TestFunction", "The function that is to be optimized.", new Fonseca()));
       Parameters.Add(new ValueParameter<DoubleMatrix>("BestKnownFront", "The currently best known Pareto front"));
@@ -165,8 +170,14 @@
     #region Events
     private void UpdateParameterValues() {
-      MaximizationParameter.ActualValue = (BoolArray)new BoolArray(Maximization).AsReadOnly();
-      var front = BestKnownFront;
-      if (front != null) { BestKnownFrontParameter.Value = (DoubleMatrix)new DoubleMatrix(To2D(front.ToArray())).AsReadOnly(); }
-
+      MaximizationParameter.Value = (BoolArray)new BoolArray(TestFunction.Maximization(Objectives)).AsReadOnly();
+
+      var front = TestFunction.OptimalParetoFront(Objectives);
+      if (front != null) {
+        BestKnownFrontParameter.Value = (DoubleMatrix)new DoubleMatrix(To2D(front.ToArray())).AsReadOnly();
+      } else BestKnownFrontParameter.Value = null;
+
+
+      BoundsParameter.Value = new DoubleMatrix(TestFunction.Bounds(Objectives));
+      ReferencePointParameter.Value = new DoubleArray(TestFunction.ReferencePoint(Objectives));
     }
 
@@ -186,5 +197,4 @@
       Objectives = Math.Max(TestFunction.MinimumObjectives, Math.Min(Objectives, TestFunction.MaximumObjectives));
 
-      Bounds = (DoubleMatrix)new DoubleMatrix(TestFunction.Bounds(Objectives)).Clone();
       ParameterizeAnalyzers();
       UpdateParameterValues();
@@ -228,8 +238,13 @@
         analyzer.BestKnownFrontParameter.ActualName = BestKnownFrontParameter.Name;
 
+        var crowdingAnalyzer = analyzer as CrowdingAnalyzer;
+        if (crowdingAnalyzer != null) {
+          crowdingAnalyzer.BoundsParameter.ActualName = BoundsParameter.Name;
+        }
+
         var hyperVolumeAnalyzer = analyzer as HypervolumeAnalyzer;
         if (hyperVolumeAnalyzer != null) {
-          hyperVolumeAnalyzer.ReferencePointParameter.Value = new DoubleArray(TestFunction.ReferencePoint(Objectives));
-          hyperVolumeAnalyzer.BestKnownHyperVolume = TestFunction.BestKnownHypervolume(Objectives);
+          hyperVolumeAnalyzer.ReferencePointParameter.ActualName = ReferencePointParameter.Name;
+          hyperVolumeAnalyzer.BestKnownHyperVolume = TestFunction.OptimalHypervolume(Objectives);
         }
 
Index: branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/NonDominatedSelect.cs
===================================================================
--- branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/NonDominatedSelect.cs	(revision 14084)
+++ branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/NonDominatedSelect.cs	(revision 14085)
@@ -24,5 +24,5 @@
 namespace HeuristicLab.Problems.MultiObjectiveTestFunctions {
 
-  public class NonDominatedSelect {
+  public static class NonDominatedSelect {
     public enum DominationResult { Dominates, IsDominated, IsNonDominated };
 
Index: branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Testfunctions/MultiObjectiveTestFunction.cs
===================================================================
--- branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Testfunctions/MultiObjectiveTestFunction.cs	(revision 14084)
+++ branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Testfunctions/MultiObjectiveTestFunction.cs	(revision 14085)
@@ -105,5 +105,5 @@
     /// returns the best known Hypervolume for this test function   (default=-1) 
     /// </summary>     
-    public virtual double BestKnownHypervolume(int objectives) {
+    public virtual double OptimalHypervolume(int objectives) {
       CheckObjectives(objectives);
       return GetBestKnownHypervolume(objectives);
