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 13420)
+++ /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/HeuristicLab.Problems.MultiObjectiveTestFunctions-3.3.csproj	(revision 13421)
@@ -62,4 +62,8 @@
       <Private>False</Private>
     </Reference>
+    <Reference Include="HeuristicLab.Operators-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Operators-3.3.dll</HintPath>
+    </Reference>
     <Reference Include="HeuristicLab.Optimization-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
@@ -91,6 +95,11 @@
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="Interfaces\IMultiObjectiveTestFunction.cs" />
+    <Compile Include="MultiObjectiveTestFunctionProblem.cs" />
     <Compile Include="Plugin.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="Testfunctions\Evaluators.cs" />
+    <Compile Include="Testfunctions\Fonseca.cs" />
+    <Compile Include="Testfunctions\MultiObjectiveTestFunction.cs" />
   </ItemGroup>
   <ItemGroup>
@@ -99,4 +108,5 @@
     <None Include="Properties\AssemblyInfo.cs.frame" />
   </ItemGroup>
+  <ItemGroup />
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <PropertyGroup>
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 13421)
+++ /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Interfaces/IMultiObjectiveTestFunction.cs	(revision 13421)
@@ -0,0 +1,43 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.RealVectorEncoding;
+
+namespace HeuristicLab.Problems.TestFunctions {
+  /// <summary>
+  /// An interface which represents an evaluation operator for multi objective test functions.
+  /// </summary>
+  public interface IMultiObjectiveTestFunction : INamedItem {
+    bool[] Maximization { get; }
+    DoubleMatrix Bounds { get; }
+    //double BestKnownQuality { get; }
+    int MinimumProblemSize { get; }
+    int MaximumProblemSize { get; }
+    int MinimumSolutionSize { get; }
+    int MaximumSolutionSize { get; }
+
+    //double Evaluate2D(double x, double y);
+    double[] Evaluate(RealVector point);
+    //RealVector GetBestKnownSolution(int dimension);
+  }
+}
Index: /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/MultiObjectiveTestFunctionProblem.cs
===================================================================
--- /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/MultiObjectiveTestFunctionProblem.cs	(revision 13421)
+++ /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/MultiObjectiveTestFunctionProblem.cs	(revision 13421)
@@ -0,0 +1,173 @@
+﻿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.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.MultiObjectiveTestFunctions.Testfunctions;
+using HeuristicLab.Problems.TestFunctions;
+
+namespace HeuristicLab.Problems.MultiObjectiveTestFunction {
+  [StorableClass]
+  public class MultiObjectiveTestFunctionProblem : MultiObjectiveBasicProblem<RealVectorEncoding> {
+
+    public override bool[] Maximization {
+      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"]; }
+    }
+    private IFixedValueParameter<IntValue> SolutionSizeParameter {
+      get { return (IFixedValueParameter<IntValue>)Parameters["SolutionSize"]; }
+    }
+    private IValueParameter<DoubleMatrix> BoundsParameter {
+      get { return (IValueParameter<DoubleMatrix>)Parameters["Bounds"]; }
+    }
+    public OptionalValueParameter<RealVector> BestKnownSolutionParameter {
+      get { return (OptionalValueParameter<RealVector>)Parameters["BestKnownSolution"]; }
+    }
+    public IValueParameter<IMultiObjectiveTestFunction> TestFunctionParameter {
+      get { return (IValueParameter<IMultiObjectiveTestFunction>)Parameters["TestFunction"]; }
+    }
+    #endregion
+
+    #region Properties
+    public int ProblemSize {
+      get { return ProblemSizeParameter.Value.Value; }
+      set { ProblemSizeParameter.Value.Value = value; }
+    }
+    public int SolutionSize {
+      get { return SolutionSizeParameter.Value.Value; }
+      set { SolutionSizeParameter.Value.Value = value; }
+    }
+    public DoubleMatrix Bounds {
+      get { return BoundsParameter.Value; }
+      set { BoundsParameter.Value = value; }
+    }
+    public IMultiObjectiveTestFunction TestFunction {
+      get { return TestFunctionParameter.Value; }
+      set { TestFunctionParameter.Value = value; }
+    }
+    #endregion
+
+
+
+    [StorableConstructor]
+    private MultiObjectiveTestFunctionProblem(bool deserializing) : base(deserializing) { }
+    private MultiObjectiveTestFunctionProblem(MultiObjectiveTestFunctionProblem original, Cloner cloner)
+      : base(original, cloner) {
+      RegisterEventHandlers();
+    }
+    public MultiObjectiveTestFunctionProblem()
+      : base() { //former: base(new RealVectorEncoding("Point"))
+      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<IMultiObjectiveTestFunction>("TestFunction", "The function that is to be optimized.", new Fonseca()));
+
+      Encoding.LengthParameter = ProblemSizeParameter;
+      Encoding.BoundsParameter = BoundsParameter;
+      //BestKnownQuality = TestFunction.BestKnownQuality;
+
+      InitializeOperators();
+      RegisterEventHandlers();
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new MultiObjectiveTestFunctionProblem(this, cloner);
+    }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      RegisterEventHandlers();
+    }
+
+    private void RegisterEventHandlers() {
+      //Evaluator.QualityParameter.ActualNameChanged += Evaluator_QualityParameter_ActualNameChanged;
+      TestFunctionParameter.ValueChanged += TestFunctionParameterOnValueChanged;
+      ProblemSizeParameter.Value.ValueChanged += ProblemSizeOnValueChanged;
+      BoundsParameter.ValueChanged += BoundsParameterOnValueChanged;
+    }
+
+    public double[] Evaluate(RealVector vector, IRandom random) {
+      return TestFunction.Evaluate(vector);
+    }
+    public sealed override double[] Evaluate(Individual individual, IRandom random) {
+      return Evaluate(individual.RealVector(), random);
+    }
+
+    #region Events
+    protected override void OnEncodingChanged() {
+      base.OnEncodingChanged();
+      Parameterize();
+    }
+    protected override void OnEvaluatorChanged() {
+      base.OnEvaluatorChanged();
+     // Evaluator.QualityParameter.ActualNameChanged += Evaluator_QualityParameter_ActualNameChanged;
+      Parameterize();
+    }
+    //private void Evaluator_QualityParameter_ActualNameChanged(object sender, EventArgs e) {
+    //  Parameterize();
+    //}
+
+
+    private void TestFunctionParameterOnValueChanged(object sender, EventArgs eventArgs) {
+      var problemSizeChange = ProblemSize < TestFunction.MinimumProblemSize
+                              || ProblemSize > TestFunction.MaximumProblemSize;
+      if (problemSizeChange) {
+        ProblemSize = Math.Max(TestFunction.MinimumProblemSize, Math.Min(ProblemSize, TestFunction.MaximumProblemSize));
+      }
+
+      var solutionSizeChange = SolutionSize < TestFunction.MinimumSolutionSize
+                              || SolutionSize > TestFunction.MaximumSolutionSize;
+      if (solutionSizeChange) {
+        ProblemSize = Math.Max(TestFunction.MinimumSolutionSize, Math.Min(SolutionSize, TestFunction.MaximumSolutionSize));
+      }
+
+      Bounds = (DoubleMatrix)TestFunction.Bounds.Clone();
+      OnReset();
+    }
+
+    private void ProblemSizeOnValueChanged(object sender, EventArgs eventArgs) {
+      if (ProblemSize < TestFunction.MinimumProblemSize
+        || ProblemSize > TestFunction.MaximumProblemSize)
+        ProblemSize = Math.Min(TestFunction.MaximumProblemSize, Math.Max(TestFunction.MinimumProblemSize, ProblemSize));
+    }
+
+    private void SolutionSizeOnValueChanged(object sender, EventArgs eventArgs) {
+      if (SolutionSize < TestFunction.MinimumSolutionSize
+        || ProblemSize > TestFunction.MaximumSolutionSize)
+        ProblemSize = Math.Min(TestFunction.MaximumSolutionSize, Math.Max(TestFunction.MinimumSolutionSize, SolutionSize));
+    }
+
+    private void BoundsParameterOnValueChanged(object sender, EventArgs eventArgs) {
+      Parameterize();
+    }
+    #endregion
+
+    #region Helpers
+    private void InitializeOperators() {
+      //empty for now
+      Parameterize();
+    }
+
+    private void Parameterize() {
+      //empty for now
+    }
+    #endregion
+
+
+  }
+}
+
+   
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 13421)
+++ /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Testfunctions/Evaluators.cs	(revision 13421)
@@ -0,0 +1,341 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using HeuristicLab.Encodings.RealVectorEncoding;
+
+namespace HeuristicLab.Problems.MultiObjectiveTestFunctions.Testfunctions {
+  class Evaluators {
+
+    //http://www.tik.ee.ethz.ch/sop/download/supplementary/testproblems/ [30.11.2015]
+    private double[] ZDT1(RealVector r) {  //0,1
+      double g = 0;
+      for (int i = 1; i < r.Length; i++) g += r[i];
+      g = 1.0 + 9.0 * g / (r.Length - 1);
+      double[] res = { r[0], g * (1.0 - Math.Sqrt(r[0] / g)) };
+      return res;
+    }
+    private double[] ZDT2(RealVector r) { //0,1
+      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;
+      double[] res = { r[0], g * (1.0 - d * d) };
+      return res;
+    }
+    private double[] ZDT3(RealVector r) { //0,1
+      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;
+      double[] res = { r[0], g * (1.0 - Math.Sqrt(d) - d * Math.Sin(10 * Math.PI * r[0])) };
+      return res;
+    }
+    private double[] ZDT4(RealVector r) {  //-5,5
+      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;
+      double[] res = { r[0], g * (1.0 - d * d) };
+      return res;
+    }
+    private double[] ZDT6(RealVector r) { //0,1
+      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;
+      double[] res = { 1 - Math.Exp(-4 * r[0]) * Math.Pow(Math.Sin(6 * Math.PI * r[0]), 6), g * (1.0 - d * d) };
+      return res;
+    }
+
+
+    //IMPOTANT There is often confusion about the numbering and the function definitions
+    //eg.: in EALib only the first 4 functions are the same although the other 3 share resemblances
+    //even on  http://www.tik.ee.ethz.ch/ where the original paper is referenced DTLZ7 on the page is DTLZ6 in the paper 
+    /*Deb, K., Thiele, L., Laumanns, M., & Zitzler, E. (2002, May).
+    Scalable multi-objective optimization test problems. 
+    In Proceedings of the Congress on Evolutionary Computation (CEC-2002),(Honolulu, USA) (pp. 825-830). 
+    http://repository.ias.ac.in/81671/ [30.11.15]
+      */
+    private double[] DTLZ1(RealVector r, int objectives) { //0,1
+      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;
+    }
+    private double[] DTLZ2(RealVector r, int objectives) { //0,1
+      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;
+    }
+    private double[] DTLZ3(RealVector r, int objectives) {  //0,1
+      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;
+    }
+    private double[] DTLZ4(RealVector r, int objectives) { //0,1
+      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;
+    }
+    private double[] DTLZ5(RealVector r, int objectives) {  //0,1
+      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;
+    }
+    private double[] DTLZ6(RealVector r, int objectives) { //0,1
+      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;
+    }
+    private double[] DTLZ7(RealVector r, int objectives) { //0,1
+      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;
+    }
+
+    //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??
+      //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));
+      }
+
+      double[] res = { f0, f1 };
+      return res;
+    }
+
+    //http://www.eng.buffalo.edu/Research/MODEL/mdo.test.orig/class2prob4/descr.html
+    //TODO this is not multi-objective
+    private double[] Golinski(RealVector r) { //bounds {{2.6,3.6}, {0.7,0.8}, {17,28}, {7.3, 8.3}, {7.3,8.3}, {2.9,3.9}, {5.0,5.5}}
+      if (r.Length != 7) return null;
+
+      double[] Cf = { 0.7854, 3.3333, 14.9334, 43.0934, 1.5079, 7.477 };
+      double f = Cf[0] * r[0] * r[1] * r[1];
+      f*= Cf[1] * r[2] * r[2] + Cf[2] * r[2] - Cf[3];
+      f -= Cf[4] * (r[5] * r[5] + r[6] * r[6]);
+      f += Cf[5] * (r[5] * r[5] * r[5] + r[6] * r[6] * r[6]);
+      f += Cf[0] * (r[3] * r[5] * r[5] + r[4] * r[6] * r[6]);
+
+      double Ca12s = 745.0*745.0; 
+      //Constraints x[0],x[1],x[2],x[5],x[6]
+      List<GoldinskiConstraint> constraints = new List<GoldinskiConstraint>();
+      constraints.Add(new GoldinskiConstraint(x => 27.0/(x[0]*x[1]*x[1]*x[2])));
+      constraints.Add(new GoldinskiConstraint(x => 397.5 / (x[0] * x[1] * x[1] * x[2]*x[2])));
+      constraints.Add(new GoldinskiConstraint(x => 1.93*Math.Pow(x[3],3) / (x[1] * x[2] * Math.Pow(x[5],4))));
+      constraints.Add(new GoldinskiConstraint(x => 1.93 * Math.Pow(x[4], 3) / (x[1] * x[2] * Math.Pow(x[6], 4))));
+      constraints.Add(new GoldinskiConstraint(x => Math.Sqrt(Ca12s*x[3]*x[3]/(x[1]*x[1]*x[2]*x[2])+0.169e8)/(1100*0.1*Math.Pow(x[5],3))));
+      constraints.Add(new GoldinskiConstraint(x => Math.Sqrt(Ca12s * x[4] * x[4] / (x[1] * x[1] * x[2] * x[2]) + 0.169e8) / (859 * 0.1 * Math.Pow(x[6], 3))));
+      constraints.Add(new GoldinskiConstraint(x => x[1]*x[2]/40.0));
+      constraints.Add(new GoldinskiConstraint(x => 5.0 * x[1] / x[0]));
+      constraints.Add(new GoldinskiConstraint(x => x[0] / 12 * x[1]));
+      constraints.Add(new GoldinskiConstraint(x => 2.6/x[0])); //g10
+      constraints.Add(new GoldinskiConstraint(x => x[0]/3.6));
+      constraints.Add(new GoldinskiConstraint(x => 0.7 / x[1]));
+      constraints.Add(new GoldinskiConstraint(x => x[1] / 0.8));
+      return null;
+    }
+    private class GoldinskiConstraint {
+      private Func<RealVector, double> phi;
+      public GoldinskiConstraint(Func<RealVector, double> phi) {
+        this.phi = phi;
+      }
+      public bool eval(RealVector r) {
+        return phi(r) <= 1.0;
+      }
+    } 
+
+
+    // https://en.wikipedia.org/wiki/Test_functions_for_optimization [30.11.2015]
+    private double[] Fonseca(RealVector r) {  //-4,4
+      double f0 = 0.0, aux = 1.0 / Math.Sqrt(r.Length);
+
+      //objective1
+      for (int i = 0; i < r.Length; i++) {
+        double d = r[i] - aux;
+        f0 += d * d;
+      }
+      f0 = 1 - Math.Exp(-f0);
+
+      //objective2
+      double f1 = 0.0;
+      for (int i = 0; i < r.Length; i++) {
+        double d = r[i] + aux;
+        f1 += d * d;
+      }
+      f1 = 1 - Math.Exp(-f1);
+
+      double[] res = { f0, f1 };
+      return res;
+    }
+    private double[] Schaffer1(RealVector r) { //-5,10??
+      if (r.Length != 1) return null;
+      double x = r[0];
+
+      //objective1
+      double f0=x*x;
+
+      //objective0
+      double f1 = x - 2;
+      f1 *= f1;
+
+      double[] res = { f0, f1 };
+      return res;
+    }
+    private double[] Schaffer2(RealVector r) { //-5,10
+      if (r.Length != 1) return null;
+      double x = r[0];
+
+      //objective1
+      double f0;
+      if (x <= 11) f0 = -x;
+      else if (x <= 3) f0 = x - 2;
+      else if (x <= 4) f0 = 4 - x;
+      else f0 = x - 4;
+
+      //objective0
+      double f1 = x - 5;
+      f1 *= f1;
+
+      double[] res = { f0, f1 };
+      return res;
+    }
+
+  }
+}
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 13421)
+++ /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Testfunctions/Fonseca.cs	(revision 13421)
@@ -0,0 +1,88 @@
+﻿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("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 {
+
+    public override DoubleMatrix Bounds {
+      get {
+        return new DoubleMatrix(new double[,] { { -4, 4 } });
+      }
+    }
+
+    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;
+      }
+    }
+
+    [StorableConstructor]
+    protected Fonseca(bool deserializing) : base(deserializing) { }
+    protected Fonseca(Fonseca original, Cloner cloner) : base(original, cloner) { }
+    public Fonseca() : base() { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new Fonseca(this, cloner);
+    }
+
+
+
+    public override double[] Evaluate(RealVector r) {
+      double f0 = 0.0, aux = 1.0 / Math.Sqrt(r.Length);
+
+      //objective1
+      for (int i = 0; i < r.Length; i++) {
+        double d = r[i] - aux;
+        f0 += d * d;
+      }
+      f0 = 1 - Math.Exp(-f0);
+
+      //objective2
+      double f1 = 0.0;
+      for (int i = 0; i < r.Length; i++) {
+        double d = r[i] + aux;
+        f1 += d * d;
+      }
+      f1 = 1 - Math.Exp(-f1);
+
+      double[] res = { f0, f1 };
+      return res;
+    }
+  }
+}
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 13421)
+++ /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Testfunctions/MultiObjectiveTestFunction.cs	(revision 13421)
@@ -0,0 +1,81 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.RealVectorEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.TestFunctions {
+  /// <summary>
+  /// Base class for a test function evaluator.
+  /// </summary>
+  [Item("Single-Objective Function", "Base class for single objective functions.")]
+  [StorableClass]
+  public abstract class MultiObjectiveTestFunction : ParameterizedNamedItem, IMultiObjectiveTestFunction {
+    /// <summary>
+    /// These operators should not change their name through the GUI
+    /// </summary>
+    public override bool CanChangeName {
+      get { return false; }
+    }
+    /// <summary>
+    /// Returns whether the actual function constitutes a maximization or minimization problem.
+    /// </summary>
+    public abstract bool[] Maximization { get; }
+    /// <summary>
+    /// Gets the lower and upper bound of the function.
+    /// </summary>
+    public abstract DoubleMatrix Bounds { get; }
+    /// <summary>
+    /// Gets the minimum problem size.
+    /// </summary>
+    public abstract int MinimumProblemSize { get; }
+    /// <summary>
+    /// Gets the maximum problem size.
+    /// </summary>
+    public abstract int MaximumProblemSize { get; }
+    /// <summary>
+    /// Gets the minimum problem size.
+    /// </summary>
+    public abstract int MinimumSolutionSize { get; }
+    /// <summary>
+    /// Gets the maximum problem size.
+    /// </summary>
+    public abstract int MaximumSolutionSize { get; }
+
+    [StorableConstructor]
+    protected MultiObjectiveTestFunction(bool deserializing) : base(deserializing) { }
+    protected MultiObjectiveTestFunction(MultiObjectiveTestFunction original, Cloner cloner) : base(original, cloner) { }
+    protected MultiObjectiveTestFunction() : base() { }
+
+
+    /// <summary>
+    /// Evaluates the test function for a specific <paramref name="point"/>.
+    /// </summary>
+    /// <param name="point">N-dimensional point for which the test function should be evaluated.</param>
+    /// <returns>The result values of the function at the given point.</returns>
+    public abstract double[] Evaluate(RealVector point);
+
+  }
+}
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 13421)
+++ /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Testfunctions/SchafferN1.cs	(revision 13421)
@@ -0,0 +1,80 @@
+﻿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("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 {
+
+    public override DoubleMatrix Bounds {
+      get {
+        return new DoubleMatrix(new double[,] { { -1e5, 1e5 } });
+      }
+    }
+
+    public override bool[] Maximization {
+      get {
+        return new bool[] { false, false };
+      }
+    }
+
+    public override int MaximumProblemSize {
+      get {
+        return 1;
+      }
+    }
+
+    public override int MaximumSolutionSize {
+      get {
+        return 2;
+      }
+    }
+
+    public override int MinimumProblemSize {
+      get {
+        return 1;
+      }
+    }
+
+    public override int MinimumSolutionSize {
+      get {
+        return 2;
+      }
+    }
+
+    [StorableConstructor]
+    protected SchafferN1(bool deserializing) : base(deserializing) { }
+    protected SchafferN1(SchafferN1 original, Cloner cloner) : base(original, cloner) { }
+    public SchafferN1() : base() { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SchafferN1(this, cloner);
+    }
+
+
+
+    public override double[] Evaluate(RealVector r) {
+      if (r.Length != 1) return null;
+      double x = r[0];
+
+      //objective1
+      double f0 = x * x;
+
+      //objective0
+      double f1 = x - 2;
+      f1 *= f1;
+
+     return new double[] { f0, f1 };
+    }
+  }
+}
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 13421)
+++ /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Testfunctions/SchafferN2.cs	(revision 13421)
@@ -0,0 +1,83 @@
+﻿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("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 {
+
+    public override DoubleMatrix Bounds {
+      get {
+        return new DoubleMatrix(new double[,] { { -5, 10 } });
+      }
+    }
+
+    public override bool[] Maximization {
+      get {
+        return new bool[] { false, false };
+      }
+    }
+
+    public override int MaximumProblemSize {
+      get {
+        return 1;
+      }
+    }
+
+    public override int MaximumSolutionSize {
+      get {
+        return 2;
+      }
+    }
+
+    public override int MinimumProblemSize {
+      get {
+        return 1;
+      }
+    }
+
+    public override int MinimumSolutionSize {
+      get {
+        return 2;
+      }
+    }
+
+    [StorableConstructor]
+    protected SchafferN2(bool deserializing) : base(deserializing) { }
+    protected SchafferN2(SchafferN2 original, Cloner cloner) : base(original, cloner) { }
+    public SchafferN2() : base() { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SchafferN2(this, cloner);
+    }
+
+
+
+    public override double[] Evaluate(RealVector r) {
+      double x = r[0];
+
+      //objective1
+      double f0;
+      if (x <= 11) f0 = -x;
+      else if (x <= 3) f0 = x - 2;
+      else if (x <= 4) f0 = 4 - x;
+      else f0 = x - 4;
+
+      //objective0
+      double f1 = x - 5;
+      f1 *= f1;
+
+      return new double[] { f0, f1 };
+    }
+  }
+}
Index: /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/MultiObjectiveTestFunctions.sln
===================================================================
--- /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/MultiObjectiveTestFunctions.sln	(revision 13420)
+++ /branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/MultiObjectiveTestFunctions.sln	(revision 13421)
@@ -1,6 +1,6 @@
 ﻿
 Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio 2013
-VisualStudioVersion = 12.0.31101.0
+# Visual Studio 14
+VisualStudioVersion = 14.0.23107.0
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HeuristicLab.Problems.MultiObjectiveTestFunctions-3.3", "HeuristicLab.Problems.MultiObjectiveTestFunctions\3.3\HeuristicLab.Problems.MultiObjectiveTestFunctions-3.3.csproj", "{D53E8E48-CFAA-4F57-AC35-63BEF4476159}"
