Index: branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/IMultiObjectiveProblemDefinition.cs
===================================================================
--- branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/IMultiObjectiveProblemDefinition.cs	(revision 17309)
+++ branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/IMultiObjectiveProblemDefinition.cs	(revision 17315)
@@ -28,5 +28,5 @@
   public interface IMultiObjectiveProblemDefinition {
     int Objectives { get; }
-    IReadOnlyList<bool> Maximization { get; }
+    bool[] Maximization { get; }
     IReadOnlyList<double[]> BestKnownFront { get; }
     double[] ReferencePoint { get; }
Index: branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/MultiObjectiveProblem.cs
===================================================================
--- branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/MultiObjectiveProblem.cs	(revision 17309)
+++ branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/MultiObjectiveProblem.cs	(revision 17315)
@@ -37,4 +37,5 @@
     where TEncodedSolution : class, IEncodedSolution {
     #region Parameternames
+    public const string MaximizationParameterName = "Maximization";
     public const string BestKnownFrontParameterName = "BestKnownFront";
     public const string ReferencePointParameterName = "ReferencePoint";
@@ -42,5 +43,7 @@
 
     #region Parameterproperties
-    [Storable] protected IValueParameter<BoolArray> MaximizationParameter { get; }
+    public IValueParameter<BoolArray> MaximizationParameter {
+      get { return (IValueParameter<BoolArray>)Parameters[MaximizationParameterName]; }
+    }
     public IValueParameter<DoubleMatrix> BestKnownFrontParameter {
       get { return (IValueParameter<DoubleMatrix>)Parameters[BestKnownFrontParameterName]; }
@@ -57,11 +60,9 @@
     protected MultiObjectiveProblem(MultiObjectiveProblem<TEncoding, TEncodedSolution> original, Cloner cloner)
       : base(original, cloner) {
-      MaximizationParameter = cloner.Clone(original.MaximizationParameter);
       ParameterizeOperators();
     }
 
     protected MultiObjectiveProblem() : base() {
-      MaximizationParameter = new ValueParameter<BoolArray>("Maximization", "Set to false if the problem should be minimized.", new BoolArray(new[] { false, false }).AsReadOnly()) { Hidden = true, ReadOnly = true };
-      Parameters.Add(MaximizationParameter);
+      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"));
@@ -72,6 +73,5 @@
 
     protected MultiObjectiveProblem(TEncoding encoding) : base(encoding) {
-      MaximizationParameter = new ValueParameter<BoolArray>("Maximization", "Set to false if the problem should be minimized.", new BoolArray(new[] { false, false }).AsReadOnly()) { Hidden = true, ReadOnly = true };
-      Parameters.Add(MaximizationParameter);
+      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"));
@@ -89,16 +89,5 @@
       get { return Maximization.Length; }
     }
-    IReadOnlyList<bool> IMultiObjectiveProblemDefinition.Maximization {
-      get { return Maximization.CloneAsArray(); }
-    }
-    public BoolArray Maximization {
-      get { return MaximizationParameter.Value; }
-      set {
-        if (Maximization == value) return;
-        MaximizationParameter.ReadOnly = false;
-        MaximizationParameter.Value = value.AsReadOnly();
-        MaximizationParameter.ReadOnly = true;
-      }
-    }
+    public abstract bool[] Maximization { get; }
 
     public virtual IReadOnlyList<double[]> BestKnownFront {
@@ -179,5 +168,5 @@
     #region IMultiObjectiveHeuristicOptimizationProblem Members
     IParameter IMultiObjectiveHeuristicOptimizationProblem.MaximizationParameter {
-      get { return MaximizationParameter; }
+      get { return Parameters[MaximizationParameterName]; }
     }
     IMultiObjectiveEvaluator IMultiObjectiveHeuristicOptimizationProblem.Evaluator {
Index: branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/MultiObjective/DominationCalculator.cs
===================================================================
--- branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/MultiObjective/DominationCalculator.cs	(revision 17309)
+++ branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/MultiObjective/DominationCalculator.cs	(revision 17315)
@@ -47,5 +47,5 @@
     /// <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>(T[] solutions, double[][] qualities, IReadOnlyList<bool> maximization, bool dominateOnEqualQualities = true) {
+    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;
@@ -72,5 +72,5 @@
     /// <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>(T[] solutions, double[][] qualities, IReadOnlyList<bool> maximization, out int[] rank, bool dominateOnEqualQualities = true) {
+    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;
 
@@ -101,5 +101,5 @@
     }
 
-    private static List<Tuple<T, double[]>> CalculateBestFront<T>(T[] solutions, double[][] qualities, IReadOnlyList<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>>();
@@ -155,5 +155,5 @@
     /// <param name="dominateOnEqualQualities">Whether solutions of exactly equal quality should dominate one another.</param>
     /// <returns>A sorted list of the pareto fronts where each front contains the indices of the <paramref name="solutions"/> and <paramref name="qualities"/>.</returns>
-    public static List<List<int>> CalculateAllParetoFrontsIndices<T>(T[] solutions, double[][] qualities, IReadOnlyList<bool> maximization, bool dominateOnEqualQualities = true) {
+    public static List<List<int>> CalculateAllParetoFrontsIndices<T>(T[] solutions, double[][] qualities, bool[] maximization, bool dominateOnEqualQualities = true) {
       return CalculateAllParetoFrontsIndices(solutions, qualities, maximization, out var rank, dominateOnEqualQualities);
     }
@@ -178,5 +178,5 @@
     /// <param name="dominateOnEqualQualities">Whether solutions of exactly equal quality should dominate one another.</param>
     /// <returns>A sorted list of the pareto fronts where each front contains the indices of the <paramref name="solutions"/> and <paramref name="qualities"/>.</returns>
-    public static List<List<int>> CalculateAllParetoFrontsIndices<T>(T[] solutions, double[][] qualities, IReadOnlyList<bool> maximization, out int[] rank, bool dominateOnEqualQualities = true) {
+    public static List<List<int>> CalculateAllParetoFrontsIndices<T>(T[] solutions, double[][] qualities, bool[] maximization, out int[] rank, bool dominateOnEqualQualities = true) {
       var populationSize = solutions.Length;
 
@@ -207,5 +207,5 @@
     }
 
-    private static List<int> CalculateBestFrontIndices<T>(T[] solutions, double[][] qualities, IReadOnlyList<bool> maximization, bool dominateOnEqualQualities, int populationSize, List<int>[] dominatedIndividuals, int[] dominationCounter, int[] rank) {
+    private static List<int> CalculateBestFrontIndices<T>(T[] solutions, double[][] qualities, bool[] maximization, bool dominateOnEqualQualities, int populationSize, List<int>[] dominatedIndividuals, int[] dominationCounter, int[] rank) {
       var front = new List<int>();
       for (var pI = 0; pI < populationSize - 1; pI++) {
@@ -244,5 +244,5 @@
     /// <param name="dominateOnEqualQualities">Whether the result should be Dominates in case both fitness vectors are exactly equal</param>
     /// <returns>Dominates if left dominates right, IsDominated if right dominates left and IsNonDominated otherwise.</returns>
-    public static DominationResult Dominates(double[] left, double[] right, IReadOnlyList<bool> maximizations, bool dominateOnEqualQualities) {
+    public static DominationResult Dominates(double[] left, double[] right, bool[] maximizations, bool dominateOnEqualQualities) {
       //mkommend Caution: do not use LINQ.SequenceEqual for comparing the two quality arrays (left and right) due to performance reasons
       if (dominateOnEqualQualities) {
Index: branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/MultiObjective/HypervolumeCalculator.cs
===================================================================
--- branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/MultiObjective/HypervolumeCalculator.cs	(revision 17309)
+++ branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/MultiObjective/HypervolumeCalculator.cs	(revision 17315)
@@ -26,5 +26,5 @@
 namespace HeuristicLab.Optimization {
   public static class HypervolumeCalculator {
-    public static double[] CalculateNadirPoint(IEnumerable<double[]> qualities, IReadOnlyList<bool> maximization) {
+    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)
@@ -59,11 +59,11 @@
     /// </summary>
     /// 
-    public static double CalculateHypervolume(IList<double[]> qualities, double[] referencePoint, IReadOnlyList<bool> maximization) {
+    public static double CalculateHypervolume(IList<double[]> qualities, double[] referencePoint, bool[] maximization) {
       qualities = qualities.Where(vec => DominationCalculator.Dominates(vec, referencePoint, maximization, false) == DominationResult.Dominates).ToArray();
       if (qualities.Count== 0) return 0; //TODO computation for negative hypervolume?
-      if (maximization.Count == 2)
+      if (maximization.Length == 2)
         return Calculate2D(qualities, referencePoint, maximization);
 
-      if (maximization.All(x => !x))
+      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.");
@@ -78,5 +78,5 @@
     /// <param name="maximization"></param>
     /// <returns></returns>
-    public static double Calculate2D(IList<double[]> front, double[] referencePoint, IReadOnlyList<bool> maximization) {
+    public static double Calculate2D(IList<double[]> front, double[] referencePoint, bool[] maximization) {
       if (front == null) throw new ArgumentNullException("front");
       if (referencePoint == null) throw new ArgumentNullException("referencePoint");
