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 13447)
+++ /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/HeuristicLab.Problems.MultiObjectiveTestFunctions-3.3.csproj	(revision 13448)
@@ -99,5 +99,20 @@
     <Compile Include="Plugin.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="Testfunctions\DTLZ7.cs" />
+    <Compile Include="Testfunctions\DTLZ6.cs" />
+    <Compile Include="Testfunctions\DTLZ5.cs" />
+    <Compile Include="Testfunctions\DTLZ4.cs" />
+    <Compile Include="Testfunctions\DTLZ3.cs" />
+    <Compile Include="Testfunctions\DTLZ2.cs" />
     <Compile Include="Testfunctions\Evaluators.cs" />
+    <Compile Include="Testfunctions\Kursawe.cs" />
+    <Compile Include="Testfunctions\DTLZ1.cs" />
+    <Compile Include="Testfunctions\ZDT6.cs" />
+    <Compile Include="Testfunctions\ZDT4.cs" />
+    <Compile Include="Testfunctions\ZDT3.cs" />
+    <Compile Include="Testfunctions\ZDT2.cs" />
+    <Compile Include="Testfunctions\ZDT1.cs" />
+    <Compile Include="Testfunctions\SchafferN2.cs" />
+    <Compile Include="Testfunctions\SchafferN1.cs" />
     <Compile Include="Testfunctions\Fonseca.cs" />
     <Compile Include="Testfunctions\MultiObjectiveTestFunction.cs" />
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 13447)
+++ /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Interfaces/IMultiObjectiveTestFunction.cs	(revision 13448)
@@ -36,4 +36,5 @@
     int MinimumSolutionSize { get; }
     int MaximumSolutionSize { get; }
+    int ActualSolutionSize { get; set; }
 
     //double Evaluate2D(double x, double y);
Index: /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/MultiObjectiveTestFunctionProblem.cs
===================================================================
--- /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/MultiObjectiveTestFunctionProblem.cs	(revision 13447)
+++ /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/MultiObjectiveTestFunctionProblem.cs	(revision 13448)
@@ -21,8 +21,10 @@
       get {
         return Parameters.ContainsKey("TestFunction") ? TestFunction.Maximization : new bool[2];
-      } //TODO shady
+      }
     }
 
     #region Parameter Properties
+
+
     private IFixedValueParameter<IntValue> ProblemSizeParameter {
       get { return (IFixedValueParameter<IntValue>)Parameters["ProblemSize"]; }
@@ -73,5 +75,5 @@
       Parameters.Add(new FixedValueParameter<IntValue>("ProblemSize", "The dimensionality of the problem instance (number of variables in the function).", new IntValue(2)));
       Parameters.Add(new FixedValueParameter<IntValue>("SolutionSize", "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[,] { { -100, 100 } })));
+      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<IMultiObjectiveTestFunction>("TestFunction", "The function that is to be optimized.", new Fonseca()));
 
@@ -97,13 +99,16 @@
       TestFunctionParameter.ValueChanged += TestFunctionParameterOnValueChanged;
       ProblemSizeParameter.Value.ValueChanged += ProblemSizeOnValueChanged;
+      SolutionSizeParameter.Value.ValueChanged += SolutionSizeOnValueChanged;
       BoundsParameter.ValueChanged += BoundsParameterOnValueChanged;
     }
 
-    public double[] Evaluate(RealVector vector, IRandom random) {
-      return TestFunction.Evaluate(vector);
+    public double[] Evaluate(RealVector individual, IRandom random) {
+      return TestFunction.Evaluate(individual);
     }
-    public sealed override double[] Evaluate(Individual individual, IRandom random) {
+
+    public override double[] Evaluate(Individual individual, IRandom random) {
       return Evaluate(individual.RealVector(), random);
     }
+
 
     #region Events
@@ -114,7 +119,8 @@
     protected override void OnEvaluatorChanged() {
       base.OnEvaluatorChanged();
-     // Evaluator.QualityParameter.ActualNameChanged += Evaluator_QualityParameter_ActualNameChanged;
+      // Evaluator.QualityParameter.ActualNameChanged += Evaluator_QualityParameter_ActualNameChanged;
       Parameterize();
     }
+
     //private void Evaluator_QualityParameter_ActualNameChanged(object sender, EventArgs e) {
     //  Parameterize();
@@ -134,5 +140,4 @@
         ProblemSize = Math.Max(TestFunction.MinimumSolutionSize, Math.Min(SolutionSize, TestFunction.MaximumSolutionSize));
       }
-
       Bounds = (DoubleMatrix)TestFunction.Bounds.Clone();
       OnReset();
@@ -143,10 +148,14 @@
         || ProblemSize > TestFunction.MaximumProblemSize)
         ProblemSize = Math.Min(TestFunction.MaximumProblemSize, Math.Max(TestFunction.MinimumProblemSize, ProblemSize));
+      //TODO problemsize dominates solutionSize 
+      SolutionSizeOnValueChanged(sender, eventArgs);
     }
 
     private void SolutionSizeOnValueChanged(object sender, EventArgs eventArgs) {
       if (SolutionSize < TestFunction.MinimumSolutionSize
-        || ProblemSize > TestFunction.MaximumSolutionSize)
-        ProblemSize = Math.Min(TestFunction.MaximumSolutionSize, Math.Max(TestFunction.MinimumSolutionSize, SolutionSize));
+        || SolutionSize > TestFunction.MaximumSolutionSize)
+        SolutionSize = Math.Min(TestFunction.MaximumSolutionSize, Math.Max(TestFunction.MinimumSolutionSize, SolutionSize));
+      TestFunction.ActualSolutionSize = SolutionSize;
+      OnReset();
     }
 
@@ -163,9 +172,8 @@
 
     private void Parameterize() {
-      //empty for now
     }
+
+    
     #endregion
-
-
   }
 }
Index: /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Testfunctions/DTLZ1.cs
===================================================================
--- /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Testfunctions/DTLZ1.cs	(revision 13448)
+++ /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Testfunctions/DTLZ1.cs	(revision 13448)
@@ -0,0 +1,109 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.RealVectorEncoding;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.MultiObjectiveTestFunction;
+
+namespace HeuristicLab.Problems.TestFunctions {
+  [Item("DTLZ1", " http://repository.ias.ac.in/81671/ [30.11.15]")]
+  [StorableClass]
+  public class DTLZ1 : MultiObjectiveTestFunction {
+
+    private int actualSolutionSize=2;
+    public override int ActualSolutionSize {
+      get {
+        return actualSolutionSize;
+      }
+
+      set {
+        actualSolutionSize = value;
+      }
+    }
+
+    public override DoubleMatrix Bounds {
+      get {
+        return new DoubleMatrix(new double[,] { { 0, 1 } });
+      }
+    }
+
+    public override bool[] Maximization {
+      get {
+        bool[] res = new bool[actualSolutionSize];
+        for(int i =0; i < res.Length; i++)  res[i] = false; //TODO: diligent initialzation
+        return res;
+      }
+    }
+
+    public override int MaximumProblemSize {
+      get {
+        return int.MaxValue;
+      }
+    }
+
+    public override int MaximumSolutionSize {
+      get {
+         
+        return int.MaxValue;
+      }
+    }
+
+    public override int MinimumProblemSize {
+      get {
+        return Math.Max(2, ActualSolutionSize+1);
+      }
+    }
+
+    public override int MinimumSolutionSize {
+      get {
+        return 2;
+      }
+    }
+
+    [StorableConstructor]
+    protected DTLZ1(bool deserializing) : base(deserializing) { }
+    protected DTLZ1(DTLZ1 original, Cloner cloner) : base(original, cloner) {}
+    public DTLZ1() : base() {
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new DTLZ1(this, cloner);
+    }
+
+
+
+    public override double[] Evaluate(RealVector r) {
+      return Evaluate(r, actualSolutionSize);
+    }
+
+    private double[] Evaluate(RealVector r, int objectives) {
+      double[] res = new double[objectives];
+
+      //calculate g(Xm)
+      double sum = 0, length = 0;
+      for (int i = objectives; i < r.Length; i++) {
+        double d = r[i] - 0.5;
+        sum += d * d - Math.Cos(20 * Math.PI * d);
+        length += r[i] * r[i];
+      }
+      length = Math.Sqrt(length);
+      double g = 100 * (length + sum);
+
+      //calculating f0...fM-1
+      for (int i = 0; i < objectives; i++) {
+        double f = 0.5 * i == 0 ? 1 : (1 - r[objectives - i - 1]) * (1 + g);
+        for (int j = 0; j < objectives - i - 1; j++) {
+          f *= r[j];
+        }
+        res[i] = f;
+      }
+      return res;
+    }
+  }
+}
Index: /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Testfunctions/DTLZ2.cs
===================================================================
--- /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Testfunctions/DTLZ2.cs	(revision 13448)
+++ /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Testfunctions/DTLZ2.cs	(revision 13448)
@@ -0,0 +1,104 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.RealVectorEncoding;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.MultiObjectiveTestFunction;
+
+namespace HeuristicLab.Problems.TestFunctions {
+  [Item("DTLZ2", " http://repository.ias.ac.in/81671/ [30.11.15]")]
+  [StorableClass]
+  public class DTLZ2 : MultiObjectiveTestFunction {
+
+    private int actualSolutionSize = 2;
+    public override int ActualSolutionSize {
+      get {
+        return actualSolutionSize;
+      }
+
+      set {
+        actualSolutionSize = value;
+      }
+    }
+
+    public override DoubleMatrix Bounds {
+      get {
+        return new DoubleMatrix(new double[,] { { 0, 1 } });
+      }
+    }
+
+    public override bool[] Maximization {
+      get {
+        bool[] res = new bool[actualSolutionSize];
+        for(int i =0; i < res.Length; i++)  res[i] = false; //TODO: diligent initialzation
+        return res;
+      }
+    }
+
+    public override int MaximumProblemSize {
+      get {
+        return int.MaxValue;
+      }
+    }
+
+    public override int MaximumSolutionSize { //TODO ask Michael
+      get {
+        return int.MaxValue;
+      }
+    }
+
+    public override int MinimumProblemSize {
+      get {
+        return Math.Max(2,actualSolutionSize);
+      }
+    }
+
+    public override int MinimumSolutionSize {
+      get {
+        return 2;
+      }
+    }
+
+    [StorableConstructor]
+    protected DTLZ2(bool deserializing) : base(deserializing) { }
+    protected DTLZ2(DTLZ2 original, Cloner cloner) : base(original, cloner) { }
+    public DTLZ2() : base() { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new DTLZ2(this, cloner);
+    }
+
+
+
+    public override double[] Evaluate(RealVector r) {
+      return Evaluate(r, actualSolutionSize);
+    }
+
+    private double[] Evaluate(RealVector r, int objectives) {
+      double[] res = new double[objectives];
+
+      //calculate g(Xm)
+      double g = 0;
+      for (int i = objectives; i < r.Length; i++) {
+        double d = r[i] - 0.5;
+        g += d * d;
+      }
+
+      //calculating f0...fM-1
+      for (int i = 0; i < objectives; i++) {
+        double f = i == 0 ? 1 : (Math.Sin(r[objectives - i - 1] * Math.PI / 2)) * (1 + g);
+        for (int j = 0; j < objectives - i - 1; j++) {
+          f *= Math.Cos(r[j] * Math.PI / 2);
+        }
+        res[i] = f;
+      }
+      return res;
+    }
+  }
+}
Index: /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Testfunctions/DTLZ3.cs
===================================================================
--- /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Testfunctions/DTLZ3.cs	(revision 13448)
+++ /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Testfunctions/DTLZ3.cs	(revision 13448)
@@ -0,0 +1,106 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.RealVectorEncoding;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.MultiObjectiveTestFunction;
+
+namespace HeuristicLab.Problems.TestFunctions {
+  [Item("DTLZ3", " http://repository.ias.ac.in/81671/ [30.11.15]")]
+  [StorableClass]
+  public class DTLZ3 : MultiObjectiveTestFunction {
+
+    public override DoubleMatrix Bounds {
+      get {
+        return new DoubleMatrix(new double[,] { { 0, 1 } });
+      }
+    }
+
+    public override bool[] Maximization {
+      get {
+        bool[] res = new bool[((ValueParameter<IntValue>)Parameters["SolutionSize"]).Value.Value];
+        for(int i =0; i < res.Length; i++)  res[i] = false; //TODO: diligent initialzation
+        return res;
+      }
+    }
+
+    public override int MaximumProblemSize {
+      get {
+        return int.MaxValue;
+      }
+    }
+
+    public override int MaximumSolutionSize { //TODO ask Michael
+      get {
+        return ((ValueParameter<IntValue>)Parameters["ProblemSize"]).Value.Value;
+      }
+    }
+
+    public override int MinimumProblemSize {
+      get {
+        return 2;
+      }
+    }
+
+    public override int MinimumSolutionSize {
+      get {
+        return 2;
+      }
+    }
+
+    public override int ActualSolutionSize {
+      get {
+        throw new NotImplementedException();
+      }
+
+      set {
+        throw new NotImplementedException();
+      }
+    }
+
+    [StorableConstructor]
+    protected DTLZ3(bool deserializing) : base(deserializing) { }
+    protected DTLZ3(DTLZ3 original, Cloner cloner) : base(original, cloner) { }
+    public DTLZ3() : base() { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new DTLZ3(this, cloner);
+    }
+
+
+
+    public override double[] Evaluate(RealVector r) {
+      return Evaluate(r, ((ValueParameter<IntValue>)Parameters["SolutionSize"]).Value.Value);
+    }
+
+    private double[] Evaluate(RealVector r, int objectives) {
+      double[] res = new double[objectives];
+
+      //calculate g(Xm)
+      double sum = 0, length = 0;
+      for (int i = objectives; i < r.Length; i++) {
+        double d = r[i] - 0.5;
+        sum += d * d - Math.Cos(20 * Math.PI * d);
+        length += r[i] * r[i];
+      }
+      length = Math.Sqrt(length);
+      double g = 100 * (length + sum);
+
+      //calculating f0...fM-1
+      for (int i = 0; i < objectives; i++) {
+        double f = i == 0 ? 1 : (Math.Sin(r[objectives - i - 1] * Math.PI / 2)) * (1 + g);
+        for (int j = 0; j < objectives - i - 1; j++) {
+          f *= Math.Cos(r[j] * Math.PI / 2);
+        }
+        res[i] = f;
+      }
+      return res;
+    }
+  }
+}
Index: /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Testfunctions/DTLZ4.cs
===================================================================
--- /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Testfunctions/DTLZ4.cs	(revision 13448)
+++ /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Testfunctions/DTLZ4.cs	(revision 13448)
@@ -0,0 +1,103 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.RealVectorEncoding;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.MultiObjectiveTestFunction;
+
+namespace HeuristicLab.Problems.TestFunctions {
+  [Item("DTLZ4", " http://repository.ias.ac.in/81671/ [30.11.15]")]
+  [StorableClass]
+  public class DTLZ4 : MultiObjectiveTestFunction {
+
+    public override DoubleMatrix Bounds {
+      get {
+        return new DoubleMatrix(new double[,] { { 0, 1 } });
+      }
+    }
+
+    public override bool[] Maximization {
+      get {
+        bool[] res = new bool[((ValueParameter<IntValue>)Parameters["SolutionSize"]).Value.Value];
+        for(int i =0; i < res.Length; i++)  res[i] = false; //TODO: diligent initialzation
+        return res;
+      }
+    }
+
+    public override int MaximumProblemSize {
+      get {
+        return int.MaxValue;
+      }
+    }
+
+    public override int MaximumSolutionSize { //TODO ask Michael
+      get {
+        return ((ValueParameter<IntValue>)Parameters["ProblemSize"]).Value.Value;
+      }
+    }
+
+    public override int MinimumProblemSize {
+      get {
+        return 2;
+      }
+    }
+
+    public override int MinimumSolutionSize {
+      get {
+        return 2;
+      }
+    }
+
+    public override int ActualSolutionSize {
+      get {
+        throw new NotImplementedException();
+      }
+
+      set {
+        throw new NotImplementedException();
+      }
+    }
+
+    [StorableConstructor]
+    protected DTLZ4(bool deserializing) : base(deserializing) { }
+    protected DTLZ4(DTLZ4 original, Cloner cloner) : base(original, cloner) { }
+    public DTLZ4() : base() { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new DTLZ4(this, cloner);
+    }
+
+
+
+    public override double[] Evaluate(RealVector r) {
+      return Evaluate(r, ((ValueParameter<IntValue>)Parameters["SolutionSize"]).Value.Value);
+    }
+
+    private double[] Evaluate(RealVector r, int objectives) {
+      double[] res = new double[objectives];
+
+      //calculate g(Xm)
+      double g = 0;
+      for (int i = objectives; i < r.Length; i++) {
+        double d = r[i] - 0.5;
+        g += d * d;
+      }
+
+      //calculating f0...fM-1
+      for (int i = 0; i < objectives; i++) {
+        double f = i == 0 ? 1 : (Math.Sin(Math.Pow(r[objectives - i - 1], 100) * Math.PI / 2)) * (1 + g);
+        for (int j = 0; j < objectives - i - 1; j++) {
+          f *= Math.Cos(Math.Pow(r[j], 100) * Math.PI / 2);
+        }
+        res[i] = f;
+      }
+      return res;
+    }
+  }
+}
Index: /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Testfunctions/DTLZ5.cs
===================================================================
--- /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Testfunctions/DTLZ5.cs	(revision 13448)
+++ /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Testfunctions/DTLZ5.cs	(revision 13448)
@@ -0,0 +1,106 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.RealVectorEncoding;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.MultiObjectiveTestFunction;
+
+namespace HeuristicLab.Problems.TestFunctions {
+  [Item("DTLZ5", " http://repository.ias.ac.in/81671/ [30.11.15]")]
+  [StorableClass]
+  public class DTLZ5 : MultiObjectiveTestFunction {
+
+    public override DoubleMatrix Bounds {
+      get {
+        return new DoubleMatrix(new double[,] { { 0, 1 } });
+      }
+    }
+
+    public override bool[] Maximization {
+      get {
+        bool[] res = new bool[((ValueParameter<IntValue>)Parameters["SolutionSize"]).Value.Value];
+        for(int i =0; i < res.Length; i++)  res[i] = false; //TODO: diligent initialzation
+        return res;
+      }
+    }
+
+    public override int MaximumProblemSize {
+      get {
+        return int.MaxValue;
+      }
+    }
+
+    public override int MaximumSolutionSize { //TODO ask Michael
+      get {
+        return ((ValueParameter<IntValue>)Parameters["ProblemSize"]).Value.Value;
+      }
+    }
+
+    public override int MinimumProblemSize {
+      get {
+        return 2;
+      }
+    }
+
+    public override int MinimumSolutionSize {
+      get {
+        return 2;
+      }
+    }
+
+    public override int ActualSolutionSize {
+      get {
+        throw new NotImplementedException();
+      }
+
+      set {
+        throw new NotImplementedException();
+      }
+    }
+
+    [StorableConstructor]
+    protected DTLZ5(bool deserializing) : base(deserializing) { }
+    protected DTLZ5(DTLZ5 original, Cloner cloner) : base(original, cloner) { }
+    public DTLZ5() : base() { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new DTLZ5(this, cloner);
+    }
+
+
+
+    public override double[] Evaluate(RealVector r) {
+      return Evaluate(r, ((ValueParameter<IntValue>)Parameters["SolutionSize"]).Value.Value);
+    }
+
+    private double[] Evaluate(RealVector r, int objectives) {
+      double[] res = new double[objectives];
+
+      //calculate g(Xm)
+      double g = 0;
+      for (int i = objectives; i < r.Length; i++) {
+        g += Math.Pow(r[i], 0.1);
+      }
+
+      //phi definition
+      Func<double, double> phi;
+      phi = (double x) => { return Math.PI / (4 * 1 + g) * (1 + 2 * g * x); };
+
+      //calculating f0...fM-1
+      for (int i = 0; i < objectives; i++) {
+        double f = i == 0 ? 1 : (Math.Sin(phi(r[objectives - i - 1]) * Math.PI / 2)) * (1 + g);
+        for (int j = 0; j < objectives - i - 1; j++) {
+          f *= Math.Cos(phi(r[j]) * Math.PI / 2);
+        }
+        res[i] = f;
+      }
+      return res;
+    }
+  }
+}
Index: /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Testfunctions/DTLZ6.cs
===================================================================
--- /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Testfunctions/DTLZ6.cs	(revision 13448)
+++ /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Testfunctions/DTLZ6.cs	(revision 13448)
@@ -0,0 +1,108 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.RealVectorEncoding;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.MultiObjectiveTestFunction;
+
+namespace HeuristicLab.Problems.TestFunctions {
+  [Item("DTLZ6", " http://repository.ias.ac.in/81671/ [30.11.15]")]
+  [StorableClass]
+  public class DTLZ6 : MultiObjectiveTestFunction {
+
+    public override DoubleMatrix Bounds {
+      get {
+        return new DoubleMatrix(new double[,] { { 0, 1 } });
+      }
+    }
+
+    public override bool[] Maximization {
+      get {
+        bool[] res = new bool[((ValueParameter<IntValue>)Parameters["SolutionSize"]).Value.Value];
+        for(int i =0; i < res.Length; i++)  res[i] = false; //TODO: diligent initialzation
+        return res;
+      }
+    }
+
+    public override int MaximumProblemSize {
+      get {
+        return int.MaxValue;
+      }
+    }
+
+    public override int MaximumSolutionSize { //TODO ask Michael
+      get {
+        return ((ValueParameter<IntValue>)Parameters["ProblemSize"]).Value.Value;
+      }
+    }
+
+    public override int MinimumProblemSize {
+      get {
+        return 2;
+      }
+    }
+
+    public override int MinimumSolutionSize {
+      get {
+        return 2;
+      }
+    }
+
+    public override int ActualSolutionSize {
+      get {
+        throw new NotImplementedException();
+      }
+
+      set {
+        throw new NotImplementedException();
+      }
+    }
+
+    [StorableConstructor]
+    protected DTLZ6(bool deserializing) : base(deserializing) { }
+    protected DTLZ6(DTLZ6 original, Cloner cloner) : base(original, cloner) { }
+    public DTLZ6() : base() { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new DTLZ6(this, cloner);
+    }
+
+
+
+    public override double[] Evaluate(RealVector r) {
+      return Evaluate(r, ((ValueParameter<IntValue>)Parameters["SolutionSize"]).Value.Value);
+    }
+
+    private double[] Evaluate(RealVector r, int objectives) {
+      double[] res = new double[objectives];
+
+      //calculate g(Xm)
+      double g = 0, length = 0;
+      for (int i = objectives; i < r.Length; i++) {
+        g += r[i];
+        length += r[i] * r[i];
+      }
+      length = Math.Sqrt(length);
+      g = 1.0 + 9.0 / length * g;
+
+      //calculating f0...fM-2
+      for (int i = 0; i < objectives - 1; i++) {
+        res[i] = r[i];
+      }
+      //calculate fM-1
+      double h = objectives;
+      for (int i = 0; i < objectives - 1; i++) {
+        h -= res[i] / (1 + g) * (1 + Math.Sin(3 * Math.PI * res[i]));
+      }
+      res[objectives - 1] = (1 + g) * h;
+
+      return res;
+    }
+  }
+}
Index: /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Testfunctions/DTLZ7.cs
===================================================================
--- /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Testfunctions/DTLZ7.cs	(revision 13448)
+++ /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Testfunctions/DTLZ7.cs	(revision 13448)
@@ -0,0 +1,110 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.RealVectorEncoding;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.MultiObjectiveTestFunction;
+
+namespace HeuristicLab.Problems.TestFunctions {
+  [Item("DTLZ7", " http://repository.ias.ac.in/81671/ [30.11.15]")]
+  [StorableClass]
+  public class DTLZ7 : MultiObjectiveTestFunction {
+
+    public override DoubleMatrix Bounds {
+      get {
+        return new DoubleMatrix(new double[,] { { 0, 1 } });
+      }
+    }
+
+    public override bool[] Maximization {
+      get {
+        bool[] res = new bool[((ValueParameter<IntValue>)Parameters["SolutionSize"]).Value.Value];
+        for(int i =0; i < res.Length; i++)  res[i] = false; //TODO: diligent initialzation
+        return res;
+      }
+    }
+
+    public override int MaximumProblemSize {
+      get {
+        return int.MaxValue;
+      }
+    }
+
+    public override int MaximumSolutionSize { //TODO ask Michael
+      get {
+        return ((ValueParameter<IntValue>)Parameters["ProblemSize"]).Value.Value;
+      }
+    }
+
+    public override int MinimumProblemSize {
+      get {
+        return 2;
+      }
+    }
+
+    public override int MinimumSolutionSize {
+      get {
+        return 2;
+      }
+    }
+
+    public override int ActualSolutionSize {
+      get {
+        throw new NotImplementedException();
+      }
+
+      set {
+        throw new NotImplementedException();
+      }
+    }
+
+    [StorableConstructor]
+    protected DTLZ7(bool deserializing) : base(deserializing) { }
+    protected DTLZ7(DTLZ7 original, Cloner cloner) : base(original, cloner) { }
+    public DTLZ7() : base() { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new DTLZ7(this, cloner);
+    }
+
+
+
+    public override double[] Evaluate(RealVector r) {
+      return Evaluate(r, ((ValueParameter<IntValue>)Parameters["SolutionSize"]).Value.Value);
+    }
+
+    private double[] Evaluate(RealVector r, int objectives) {
+      double[] res = new double[objectives];
+
+      //calculate f0...fM-1;
+      double n = 10 * objectives;
+      for (int i = 0; i < objectives; i++) {
+        double d = 0;
+        for (int j = (int)Math.Floor((i - 1) * n / objectives); j < (int)Math.Floor(i * n / objectives); j++) {
+          d += r[j];
+        }
+        d *= 1 / Math.Floor(n / objectives);
+        res[i] = d;
+      }
+
+      //evaluate constraints g0...gM-2
+      for (int i = 0; i < objectives - 1; i++) {
+        if (res[objectives - 1] + 4 * res[i] - 1 < 0) return null; //TODO null is not the way to go
+      }
+      //evaluate gM-1
+      double min = Double.PositiveInfinity;
+      for (int i = 0; i < objectives - 1; i++) {
+        for (int j = 0; j < i; j++) min = Math.Min(min, res[i] + res[j]);
+      };
+      if (2 * res[objectives - 1] + min - 1 < 0) return null;  //TODO null is not the way to go
+
+      return res;
+    }
+  }
+}
Index: /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Testfunctions/Evaluators.cs
===================================================================
--- /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Testfunctions/Evaluators.cs	(revision 13447)
+++ /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Testfunctions/Evaluators.cs	(revision 13448)
@@ -226,5 +226,5 @@
     //original paper not accessible + wikipedia definition works only with fixed (3) dimensions
     //http://darwin.di.uminho.pt/jecoli/index.php/Multiobjective_example [30.11.2015]
-    private double[] Kursawe(RealVector r) { //no Bounds??
+    private double[] Kursawe(RealVector r) { //-5,5
       //objective 1
       double f0 = 0.0;
@@ -241,5 +241,4 @@
       return res;
     }
-
     //http://www.eng.buffalo.edu/Research/MODEL/mdo.test.orig/class2prob4/descr.html
     //TODO this is not multi-objective
@@ -305,5 +304,5 @@
       return res;
     }
-    private double[] Schaffer1(RealVector r) { //-5,10??
+    private double[] Schaffer1(RealVector r) { //-A,A
       if (r.Length != 1) return null;
       double x = r[0];
Index: /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Testfunctions/Fonseca.cs
===================================================================
--- /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Testfunctions/Fonseca.cs	(revision 13447)
+++ /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Testfunctions/Fonseca.cs	(revision 13448)
@@ -13,5 +13,4 @@
 namespace HeuristicLab.Problems.TestFunctions {
   [Item("Fonseca", "from // https://en.wikipedia.org/wiki/Test_functions_for_optimization [30.11.2015]")]
-  [Creatable(CreatableAttribute.Categories.CombinatorialProblems, Priority = 210)]
   [StorableClass]
   public class Fonseca : MultiObjectiveTestFunction {
@@ -53,4 +52,13 @@
     }
 
+    public override int ActualSolutionSize {
+      get {
+        return 2;
+      }
+
+      set {
+      }
+    }
+
     [StorableConstructor]
     protected Fonseca(bool deserializing) : base(deserializing) { }
Index: /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Testfunctions/Kursawe.cs
===================================================================
--- /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Testfunctions/Kursawe.cs	(revision 13448)
+++ /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Testfunctions/Kursawe.cs	(revision 13448)
@@ -0,0 +1,89 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.RealVectorEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.MultiObjectiveTestFunction;
+
+namespace HeuristicLab.Problems.TestFunctions {
+  [Item("Kursawe", "from // http://darwin.di.uminho.pt/jecoli/index.php/Multiobjective_example [30.11.2015]")]
+  [StorableClass]
+  public class Kursawe : MultiObjectiveTestFunction {
+
+    public override DoubleMatrix Bounds {
+      get {
+        return new DoubleMatrix(new double[,] { { -5, 5 } });
+      }
+    }
+
+    public override bool[] Maximization {
+      get {
+        return new bool[] { false, false };
+      }
+    }
+
+    public override int MaximumProblemSize {
+      get {
+        return int.MaxValue;
+      }
+    }
+
+    public override int MaximumSolutionSize {
+      get {
+        return 2;
+      }
+    }
+
+    public override int MinimumProblemSize {
+      get {
+        return 2;
+      }
+    }
+
+    public override int MinimumSolutionSize {
+      get {
+        return 2;
+      }
+    }
+
+    public override int ActualSolutionSize {
+      get {
+        return 2;
+      }
+
+      set {
+      }
+    }
+
+    [StorableConstructor]
+    protected Kursawe(bool deserializing) : base(deserializing) { }
+    protected Kursawe(Kursawe original, Cloner cloner) : base(original, cloner) { }
+    public Kursawe() : base() { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new Kursawe(this, cloner);
+    }
+
+
+
+    public override double[] Evaluate(RealVector r) {
+      //objective 1
+      double f0 = 0.0;
+      for (int i = 0; i < r.Length - 1; i++) {
+        f0 += -10 * Math.Exp(-0.2 * Math.Sqrt(r[i] * r[i] + r[i + 1] * r[i + 1]));
+      }
+      //objective2
+      double f1 = 0.0;
+      for (int i = 0; i < r.Length; i++) {
+        f1 += Math.Pow(Math.Abs(r[i]), 0.2) + 5 * Math.Sin(Math.Pow(r[i], 3));
+      }
+
+      return new double[] { f0, f1 };
+    }
+  }
+}
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 13447)
+++ /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Testfunctions/MultiObjectiveTestFunction.cs	(revision 13448)
@@ -57,9 +57,13 @@
     public abstract int MaximumProblemSize { get; }
     /// <summary>
-    /// Gets the minimum problem size.
+    /// Gets and sets the actual solution size.
+    /// </summary>
+    public abstract int ActualSolutionSize { get; set; }
+    /// <summary>
+    /// Gets the minimum solution size.
     /// </summary>
     public abstract int MinimumSolutionSize { get; }
     /// <summary>
-    /// Gets the maximum problem size.
+    /// Gets the maximum solution size.
     /// </summary>
     public abstract int MaximumSolutionSize { get; }
Index: /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Testfunctions/SchafferN1.cs
===================================================================
--- /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Testfunctions/SchafferN1.cs	(revision 13447)
+++ /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Testfunctions/SchafferN1.cs	(revision 13448)
@@ -13,5 +13,4 @@
 namespace HeuristicLab.Problems.TestFunctions {
   [Item("SchafferN1", "from // https://en.wikipedia.org/wiki/Test_functions_for_optimization [30.11.2015]")]
-  [Creatable(CreatableAttribute.Categories.CombinatorialProblems, Priority = 210)]
   [StorableClass]
   public class SchafferN1 : MultiObjectiveTestFunction {
@@ -53,4 +52,13 @@
     }
 
+    public override int ActualSolutionSize {
+      get {
+        return 2;
+      }
+
+      set {
+      }
+    }
+
     [StorableConstructor]
     protected SchafferN1(bool deserializing) : base(deserializing) { }
Index: /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Testfunctions/SchafferN2.cs
===================================================================
--- /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Testfunctions/SchafferN2.cs	(revision 13447)
+++ /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Testfunctions/SchafferN2.cs	(revision 13448)
@@ -13,5 +13,4 @@
 namespace HeuristicLab.Problems.TestFunctions {
   [Item("SchafferN2", "from // https://en.wikipedia.org/wiki/Test_functions_for_optimization [30.11.2015]")]
-  [Creatable(CreatableAttribute.Categories.CombinatorialProblems, Priority = 210)]
   [StorableClass]
   public class SchafferN2 : MultiObjectiveTestFunction {
@@ -53,4 +52,13 @@
     }
 
+    public override int ActualSolutionSize {
+      get {
+        return 2;
+      }
+
+      set {
+      }
+    }
+
     [StorableConstructor]
     protected SchafferN2(bool deserializing) : base(deserializing) { }
Index: /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Testfunctions/ZDT1.cs
===================================================================
--- /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Testfunctions/ZDT1.cs	(revision 13448)
+++ /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Testfunctions/ZDT1.cs	(revision 13448)
@@ -0,0 +1,81 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.RealVectorEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.MultiObjectiveTestFunction;
+
+namespace HeuristicLab.Problems.TestFunctions {
+  [Item("ZDT1", "//http://www.tik.ee.ethz.ch/sop/download/supplementary/testproblems/ [30.11.2015]")]
+  [StorableClass]
+  public class ZDT1 : MultiObjectiveTestFunction {
+
+    public override DoubleMatrix Bounds {
+      get {
+        return new DoubleMatrix(new double[,] { { 0, 1 } });
+      }
+    }
+
+    public override bool[] Maximization {
+      get {
+        return new bool[] { false, false };
+      }
+    }
+
+    public override int MaximumProblemSize {
+      get {
+        return int.MaxValue;
+      }
+    }
+
+    public override int MaximumSolutionSize {
+      get {
+        return 2;
+      }
+    }
+
+    public override int MinimumProblemSize {
+      get {
+        return 1;
+      }
+    }
+
+    public override int MinimumSolutionSize {
+      get {
+        return 2;
+      }
+    }
+
+    public override int ActualSolutionSize {
+      get {
+        return 2;
+      }
+
+      set {
+      }
+    }
+
+    [StorableConstructor]
+    protected ZDT1(bool deserializing) : base(deserializing) { }
+    protected ZDT1(ZDT1 original, Cloner cloner) : base(original, cloner) { }
+    public ZDT1() : base() { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ZDT1(this, cloner);
+    }
+
+
+
+    public override double[] Evaluate(RealVector r) {
+      double g = 0;
+      for (int i = 1; i < r.Length; i++) g += r[i];
+      g = 1.0 + 9.0 * g / (r.Length - 1);
+      return new double[] { r[0], g * (1.0 - Math.Sqrt(r[0] / g)) };
+    }
+  }
+}
Index: /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Testfunctions/ZDT2.cs
===================================================================
--- /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Testfunctions/ZDT2.cs	(revision 13448)
+++ /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Testfunctions/ZDT2.cs	(revision 13448)
@@ -0,0 +1,81 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.RealVectorEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.MultiObjectiveTestFunction;
+
+namespace HeuristicLab.Problems.TestFunctions {
+  [Item("ZDT2", "//http://www.tik.ee.ethz.ch/sop/download/supplementary/testproblems/ [30.11.2015]")]
+  [StorableClass]
+  public class ZDT2 : MultiObjectiveTestFunction {
+
+    public override DoubleMatrix Bounds {
+      get {
+        return new DoubleMatrix(new double[,] { { 0, 1 } });
+      }
+    }
+
+    public override bool[] Maximization {
+      get {
+        return new bool[] { false, false };
+      }
+    }
+
+    public override int MaximumProblemSize {
+      get {
+        return int.MaxValue;
+      }
+    }
+
+    public override int MaximumSolutionSize {
+      get {
+        return 2;
+      }
+    }
+
+    public override int MinimumProblemSize {
+      get {
+        return 1;
+      }
+    }
+
+    public override int MinimumSolutionSize {
+      get {
+        return 2;
+      }
+    }
+    public override int ActualSolutionSize {
+      get {
+        return 2;
+      }
+
+      set {
+      }
+    }
+
+    [StorableConstructor]
+    protected ZDT2(bool deserializing) : base(deserializing) { }
+    protected ZDT2(ZDT2 original, Cloner cloner) : base(original, cloner) { }
+    public ZDT2() : base() { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ZDT2(this, cloner);
+    }
+
+
+
+    public override double[] Evaluate(RealVector r) {
+      double g = 0;
+      for (int i = 1; i < r.Length; i++) g += r[i];
+      g = 1.0 + 9.0 * g / (r.Length - 1);
+      double d = r[0] / g;
+      return new double[] { r[0], g * (1.0 - d * d) };
+    }
+  }
+}
Index: /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Testfunctions/ZDT3.cs
===================================================================
--- /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Testfunctions/ZDT3.cs	(revision 13448)
+++ /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Testfunctions/ZDT3.cs	(revision 13448)
@@ -0,0 +1,82 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.RealVectorEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.MultiObjectiveTestFunction;
+
+namespace HeuristicLab.Problems.TestFunctions {
+  [Item("ZDT3", "//http://www.tik.ee.ethz.ch/sop/download/supplementary/testproblems/ [30.11.2015]")]
+  [StorableClass]
+  public class ZDT3 : MultiObjectiveTestFunction {
+
+    public override DoubleMatrix Bounds {
+      get {
+        return new DoubleMatrix(new double[,] { { 0, 1 } });
+      }
+    }
+
+    public override bool[] Maximization {
+      get {
+        return new bool[] { false, false };
+      }
+    }
+
+    public override int MaximumProblemSize {
+      get {
+        return int.MaxValue;
+      }
+    }
+
+    public override int MaximumSolutionSize {
+      get {
+        return 2;
+      }
+    }
+
+    public override int MinimumProblemSize {
+      get {
+        return 1;
+      }
+    }
+
+    public override int MinimumSolutionSize {
+      get {
+        return 2;
+      }
+    }
+
+    public override int ActualSolutionSize {
+      get {
+        return 2;
+      }
+
+      set {
+      }
+    }
+
+    [StorableConstructor]
+    protected ZDT3(bool deserializing) : base(deserializing) { }
+    protected ZDT3(ZDT3 original, Cloner cloner) : base(original, cloner) { }
+    public ZDT3() : base() { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ZDT3(this, cloner);
+    }
+
+
+
+    public override double[] Evaluate(RealVector r) {
+      double g = 0;
+      for (int i = 1; i < r.Length; i++) g += r[i];
+      g = 1.0 + 9.0 * g / (r.Length - 1);
+      double d = r[0] / g;
+      return new double[] { r[0], g * (1.0 - Math.Sqrt(d) - d * Math.Sin(10 * Math.PI * r[0])) };
+    }
+  }
+}
Index: /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Testfunctions/ZDT4.cs
===================================================================
--- /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Testfunctions/ZDT4.cs	(revision 13448)
+++ /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Testfunctions/ZDT4.cs	(revision 13448)
@@ -0,0 +1,85 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.RealVectorEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.MultiObjectiveTestFunction;
+
+namespace HeuristicLab.Problems.TestFunctions {
+  [Item("ZDT4", "//http://www.tik.ee.ethz.ch/sop/download/supplementary/testproblems/ [30.11.2015]")]
+  [StorableClass]
+  public class ZDT4 : MultiObjectiveTestFunction {
+
+    public override DoubleMatrix Bounds {
+      get {
+        return new DoubleMatrix(new double[,] { { -5, 5 } });   //TODO definition in the source is contradicting itself
+      }
+    }
+
+    public override bool[] Maximization {
+      get {
+        return new bool[] { false, false };
+      }
+    }
+
+    public override int MaximumProblemSize {
+      get {
+        return int.MaxValue;
+      }
+    }
+
+    public override int MaximumSolutionSize {
+      get {
+        return 2;
+      }
+    }
+
+    public override int MinimumProblemSize {
+      get {
+        return 1;
+      }
+    }
+
+    public override int MinimumSolutionSize {
+      get {
+        return 2;
+      }
+    }
+
+    public override int ActualSolutionSize {
+      get {
+        return 2;
+      }
+
+      set {
+      }
+    }
+
+    [StorableConstructor]
+    protected ZDT4(bool deserializing) : base(deserializing) { }
+    protected ZDT4(ZDT4 original, Cloner cloner) : base(original, cloner) { }
+    public ZDT4() : base() { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ZDT4(this, cloner);
+    }
+
+
+
+    public override double[] Evaluate(RealVector r) {
+      double g = 0;
+      for (int i = 1; i < r.Length; i++) {
+        double v = r[i];
+        g += v * v - 10 * Math.Cos(4 * Math.PI * v);
+      }
+      g = 1.0 + 10.0 * (r.Length - 1) + g;
+      double d = r[0] / g;
+      return new double[] { r[0], g * (1.0 - d * d) };
+    }
+  }
+}
Index: /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Testfunctions/ZDT6.cs
===================================================================
--- /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Testfunctions/ZDT6.cs	(revision 13448)
+++ /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Testfunctions/ZDT6.cs	(revision 13448)
@@ -0,0 +1,82 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.RealVectorEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.MultiObjectiveTestFunction;
+
+namespace HeuristicLab.Problems.TestFunctions {
+  [Item("ZDT6", "//http://www.tik.ee.ethz.ch/sop/download/supplementary/testproblems/ [30.11.2015]")]
+  [StorableClass]
+  public class ZDT6 : MultiObjectiveTestFunction {
+
+    public override DoubleMatrix Bounds {
+      get {
+        return new DoubleMatrix(new double[,] { { 0, 1 } });
+      }
+    }
+
+    public override bool[] Maximization {
+      get {
+        return new bool[] { false, false };
+      }
+    }
+
+    public override int MaximumProblemSize {
+      get {
+        return int.MaxValue;
+      }
+    }
+
+    public override int MaximumSolutionSize {
+      get {
+        return 2;
+      }
+    }
+
+    public override int MinimumProblemSize {
+      get {
+        return 1;
+      }
+    }
+
+    public override int MinimumSolutionSize {
+      get {
+        return 2;
+      }
+    }
+
+    public override int ActualSolutionSize {
+      get {
+        return 2;
+      }
+
+      set {
+      }
+    }
+
+    [StorableConstructor]
+    protected ZDT6(bool deserializing) : base(deserializing) { }
+    protected ZDT6(ZDT6 original, Cloner cloner) : base(original, cloner) { }
+    public ZDT6() : base() { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ZDT6(this, cloner);
+    }
+
+
+
+    public override double[] Evaluate(RealVector r) {
+      double g = 0;
+      for (int i = 1; i < r.Length; i++) g += r[i];
+      g = g = 1.0 + 9.0 * Math.Pow(g / (r.Length - 1), 0.25);
+      double d = r[0] / g;
+      return new double[] { 1 - Math.Exp(-4 * r[0]) * Math.Pow(Math.Sin(6 * Math.PI * r[0]), 6), g * (1.0 - d * d) };
+    }
+  }
+}
