Index: /trunk/sources/HeuristicLab 3.3.sln
===================================================================
--- /trunk/sources/HeuristicLab 3.3.sln	(revision 15177)
+++ /trunk/sources/HeuristicLab 3.3.sln	(revision 15178)
@@ -2,5 +2,5 @@
 Microsoft Visual Studio Solution File, Format Version 12.00
 # Visual Studio 15
-VisualStudioVersion = 15.0.26430.6
+VisualStudioVersion = 15.0.26430.15
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{96396439-A764-4022-A8D2-BE021449B8D1}"
@@ -458,4 +458,6 @@
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HeuristicLab.Problems.GraphColoring-3.3", "HeuristicLab.Problems.GraphColoring\3.3\HeuristicLab.Problems.GraphColoring-3.3.csproj", "{4B76E2CB-A990-4959-B080-1D81D418D325}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HeuristicLab.Algorithms.MOCMAEvolutionStrategy-3.3", "HeuristicLab.Algorithms.MOCMAEvolutionStrategy\3.3\HeuristicLab.Algorithms.MOCMAEvolutionStrategy-3.3.csproj", "{0E2E224F-E9B2-41F3-B510-09183EEBA2AF}"
 EndProject
 Global
@@ -2233,4 +2235,16 @@
 		{4B76E2CB-A990-4959-B080-1D81D418D325}.Release|x86.ActiveCfg = Release|x86
 		{4B76E2CB-A990-4959-B080-1D81D418D325}.Release|x86.Build.0 = Release|x86
+		{0E2E224F-E9B2-41F3-B510-09183EEBA2AF}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{0E2E224F-E9B2-41F3-B510-09183EEBA2AF}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{0E2E224F-E9B2-41F3-B510-09183EEBA2AF}.Debug|x64.ActiveCfg = Debug|x64
+		{0E2E224F-E9B2-41F3-B510-09183EEBA2AF}.Debug|x64.Build.0 = Debug|x64
+		{0E2E224F-E9B2-41F3-B510-09183EEBA2AF}.Debug|x86.ActiveCfg = Debug|x86
+		{0E2E224F-E9B2-41F3-B510-09183EEBA2AF}.Debug|x86.Build.0 = Debug|x86
+		{0E2E224F-E9B2-41F3-B510-09183EEBA2AF}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{0E2E224F-E9B2-41F3-B510-09183EEBA2AF}.Release|Any CPU.Build.0 = Release|Any CPU
+		{0E2E224F-E9B2-41F3-B510-09183EEBA2AF}.Release|x64.ActiveCfg = Release|x64
+		{0E2E224F-E9B2-41F3-B510-09183EEBA2AF}.Release|x64.Build.0 = Release|x64
+		{0E2E224F-E9B2-41F3-B510-09183EEBA2AF}.Release|x86.ActiveCfg = Release|x86
+		{0E2E224F-E9B2-41F3-B510-09183EEBA2AF}.Release|x86.Build.0 = Release|x86
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
Index: /trunk/sources/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/DoubleMatrixHelper.cs
===================================================================
--- /trunk/sources/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/DoubleMatrixHelper.cs	(revision 15178)
+++ /trunk/sources/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/DoubleMatrixHelper.cs	(revision 15178)
@@ -0,0 +1,50 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2016 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ * and the BEACON Center for the Study of Evolution in Action.
+ * 
+ * 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.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Data;
+
+namespace HeuristicLab.Algorithms.MOCMAEvolutionStrategy {
+  internal static class DoubleMatrixHelper {
+    internal static double[][] ToJaggedArray(this DoubleMatrix m) {
+      if (m == null) return null;
+      var i = m.Rows - 1;
+      var a = new double[i][];
+      for (i--; i >= 0; i--) {
+        var j = m.Columns;
+        a[i] = new double[j];
+        for (j--; j >= 0; j--) a[i][j] = m[i, j];
+      }
+      return a;
+    }
+
+    internal static DoubleMatrix ToMatrix(this IEnumerable<IReadOnlyList<double>> data) {
+      var d2 = data.ToArray();
+      var mat = new DoubleMatrix(d2.Length, d2[0].Count);
+      for (var i = 0; i < mat.Rows; i++)
+        for (var j = 0; j < mat.Columns; j++)
+          mat[i, j] = d2[i][j];
+      return mat;
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/HeuristicLab.Algorithms.MOCMAEvolutionStrategy-3.3.csproj
===================================================================
--- /trunk/sources/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/HeuristicLab.Algorithms.MOCMAEvolutionStrategy-3.3.csproj	(revision 15178)
+++ /trunk/sources/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/HeuristicLab.Algorithms.MOCMAEvolutionStrategy-3.3.csproj	(revision 15178)
@@ -0,0 +1,183 @@
+﻿<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProjectGuid>{0E2E224F-E9B2-41F3-B510-09183EEBA2AF}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>HeuristicLab.Algorithms.MOCMAEvolutionStrategy</RootNamespace>
+    <AssemblyName>HeuristicLab.Algorithms.MOCMAEvolutionStrategy-3.3</AssemblyName>
+    <TargetFrameworkVersion>v4.5.2</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>$(SolutionDir)\bin\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <LangVersion>5</LangVersion>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>$(SolutionDir)\bin\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <LangVersion>5</LangVersion>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x64'">
+    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>$(SolutionDir)\bin\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <DebugType>full</DebugType>
+    <PlatformTarget>x64</PlatformTarget>
+    <LangVersion>5</LangVersion>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x64'">
+    <OutputPath>$(SolutionDir)\bin\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+    <PlatformTarget>x64</PlatformTarget>
+    <LangVersion>5</LangVersion>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x86'">
+    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>$(SolutionDir)\bin\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <DebugType>full</DebugType>
+    <PlatformTarget>x86</PlatformTarget>
+    <LangVersion>5</LangVersion>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x86'">
+    <OutputPath>$(SolutionDir)\bin\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+    <PlatformTarget>x86</PlatformTarget>
+    <LangVersion>5</LangVersion>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="ALGLIB-3.7.0">
+      <HintPath>..\..\bin\ALGLIB-3.7.0.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="System" />
+    <Reference Include="System.Core" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="Plugin.cs.frame" />
+    <None Include="Properties\AssemblyInfo.cs.frame" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="Indicators\MinimalDistanceIndicator.cs" />
+    <Compile Include="Indicators\CrowdingIndicator.cs" />
+    <Compile Include="Indicators\HypervolumeIndicator.cs" />
+    <Compile Include="IIndicator.cs" />
+    <Compile Include="Individual.cs" />
+    <Compile Include="MOCMAEvolutionStrategy.cs" />
+    <Compile Include="Plugin.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="DoubleMatrixHelper.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\HeuristicLab.Analysis\3.3\HeuristicLab.Analysis-3.3.csproj">
+      <Project>{887425B4-4348-49ED-A457-B7D2C26DDBF9}</Project>
+      <Name>HeuristicLab.Analysis-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Collections\3.3\HeuristicLab.Collections-3.3.csproj">
+      <Project>{958B43BC-CC5C-4FA2-8628-2B3B01D890B6}</Project>
+      <Name>HeuristicLab.Collections-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Common\3.3\HeuristicLab.Common-3.3.csproj">
+      <Project>{A9AD58B9-3EF9-4CC1-97E5-8D909039FF5C}</Project>
+      <Name>HeuristicLab.Common-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Core\3.3\HeuristicLab.Core-3.3.csproj">
+      <Project>{C36BD924-A541-4A00-AFA8-41701378DDC5}</Project>
+      <Name>HeuristicLab.Core-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Data\3.3\HeuristicLab.Data-3.3.csproj">
+      <Project>{BBAB9DF5-5EF3-4BA8-ADE9-B36E82114937}</Project>
+      <Name>HeuristicLab.Data-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Encodings.RealVectorEncoding\3.3\HeuristicLab.Encodings.RealVectorEncoding-3.3.csproj">
+      <Project>{BB6D334A-4BB6-4674-9883-31A6EBB32CAB}</Project>
+      <Name>HeuristicLab.Encodings.RealVectorEncoding-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Optimization\3.3\HeuristicLab.Optimization-3.3.csproj">
+      <Project>{14AB8D24-25BC-400C-A846-4627AA945192}</Project>
+      <Name>HeuristicLab.Optimization-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Parameters\3.3\HeuristicLab.Parameters-3.3.csproj">
+      <Project>{56F9106A-079F-4C61-92F6-86A84C2D84B7}</Project>
+      <Name>HeuristicLab.Parameters-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Persistence\3.3\HeuristicLab.Persistence-3.3.csproj">
+      <Project>{102BC7D3-0EF9-439C-8F6D-96FF0FDB8E1B}</Project>
+      <Name>HeuristicLab.Persistence-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.PluginInfrastructure\3.3\HeuristicLab.PluginInfrastructure-3.3.csproj">
+      <Project>{94186a6a-5176-4402-ae83-886557b53cca}</Project>
+      <Name>HeuristicLab.PluginInfrastructure-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Problems.Instances\3.3\HeuristicLab.Problems.Instances-3.3.csproj">
+      <Project>{3540e29e-4793-49e7-8ee2-fea7f61c3994}</Project>
+      <Name>HeuristicLab.Problems.Instances-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Problems.TestFunctions.MultiObjective\3.3\HeuristicLab.Problems.TestFunctions.MultiObjective-3.3.csproj">
+      <Project>{D53E8E48-CFAA-4F57-AC35-63BEF4476159}</Project>
+      <Name>HeuristicLab.Problems.TestFunctions.MultiObjective-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Random\3.3\HeuristicLab.Random-3.3.csproj">
+      <Project>{F4539FB6-4708-40C9-BE64-0A1390AEA197}</Project>
+      <Name>HeuristicLab.Random-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <PropertyGroup>
+    <PreBuildEvent>set Path=%25Path%25;$(ProjectDir);$(SolutionDir)
+set ProjectDir=$(ProjectDir)
+set SolutionDir=$(SolutionDir)
+set Outdir=$(Outdir)
+
+call PreBuildEvent.cmd
+
+
+</PreBuildEvent>
+  </PropertyGroup>
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+</Project>
Index: /trunk/sources/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/IIndicator.cs
===================================================================
--- /trunk/sources/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/IIndicator.cs	(revision 15178)
+++ /trunk/sources/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/IIndicator.cs	(revision 15178)
@@ -0,0 +1,38 @@
+﻿#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.Collections.Generic;
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.RealVectorEncoding;
+using HeuristicLab.Optimization;
+
+namespace HeuristicLab.Algorithms.MOCMAEvolutionStrategy {
+  public interface IIndicator : IItem {
+    /// <summary>
+    ///  Selects the least contributing Point of a front. Please keep in mind, that the contribution of a point depends on its value as well as on the other points of a front. 
+    ///  A particularly good point may not be as benefical in another front.
+    /// </summary>
+    /// <typeparam name="TR"></typeparam>
+    /// <param name="front">a front which will be evaluated</param>
+    /// <param name="problem">The problem on which the front is evaluated (!! The function itself will NOT be evluated only bounds referencePoints & other metadata will be used</param>
+    /// <returns>the index of the least contributing point according to any type of quality criteria</returns>
+    int LeastContributer(IReadOnlyList<Individual> front, MultiObjectiveBasicProblem<RealVectorEncoding> problem);
+  }
+}
Index: /trunk/sources/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/Indicators/CrowdingIndicator.cs
===================================================================
--- /trunk/sources/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/Indicators/CrowdingIndicator.cs	(revision 15178)
+++ /trunk/sources/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/Indicators/CrowdingIndicator.cs	(revision 15178)
@@ -0,0 +1,65 @@
+﻿#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 System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.RealVectorEncoding;
+using HeuristicLab.Optimization;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Algorithms.MOCMAEvolutionStrategy {
+  [Item("CrowdingIndicator", "Selection of Offspring based on CrowdingDistance")]
+  [StorableClass]
+  internal class CrowdingIndicator : Item, IIndicator {
+    #region Constructors and Cloning
+    [StorableConstructor]
+    protected CrowdingIndicator(bool deserializing) : base(deserializing) { }
+    protected CrowdingIndicator(CrowdingIndicator original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) { return new CrowdingIndicator(this, cloner); }
+    public CrowdingIndicator() { }
+    #endregion
+
+    public int LeastContributer(IReadOnlyList<Individual> front, MultiObjectiveBasicProblem<RealVectorEncoding> problem) {
+      var bounds = problem.Encoding.Bounds;
+      var extracted = front.Select(x => x.PenalizedFitness).ToArray();
+      if (extracted.Length <= 2) return 0;
+      var pointsums = new double[extracted.Length];
+
+      for (var dim = 0; dim < problem.Maximization.Length; dim++) {
+        var arr = extracted.Select(x => x[dim]).ToArray();
+        Array.Sort(arr);
+        var fmax = problem.Encoding.Bounds[dim % bounds.Rows, 1];
+        var fmin = bounds[dim % bounds.Rows, 0];
+        var pointIdx = 0;
+        foreach (var point in extracted) {
+          var pos = Array.BinarySearch(arr, point[dim]);
+          var d = pos != 0 && pos != arr.Length - 1 ? (arr[pos + 1] - arr[pos - 1]) / (fmax - fmin) : double.PositiveInfinity;
+          pointsums[pointIdx] += d;
+          pointIdx++;
+        }
+      }
+      return pointsums.Select((value, index) => new { value, index }).OrderBy(x => x.value).First().index;
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/Indicators/HypervolumeIndicator.cs
===================================================================
--- /trunk/sources/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/Indicators/HypervolumeIndicator.cs	(revision 15178)
+++ /trunk/sources/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/Indicators/HypervolumeIndicator.cs	(revision 15178)
@@ -0,0 +1,69 @@
+﻿#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 System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.RealVectorEncoding;
+using HeuristicLab.Optimization;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.TestFunctions.MultiObjective;
+namespace HeuristicLab.Algorithms.MOCMAEvolutionStrategy {
+  [Item("HypervolumeIndicator", "Selection of Offspring based on contributing Hypervolume")]
+  [StorableClass]
+  internal class HypervolumeIndicator : Item, IIndicator {
+    #region Constructors and Cloning
+    [StorableConstructor]
+    protected HypervolumeIndicator(bool deserializing) : base(deserializing) { }
+    protected HypervolumeIndicator(HypervolumeIndicator original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) { return new HypervolumeIndicator(this, cloner); }
+    public HypervolumeIndicator() { }
+    #endregion
+
+    public int LeastContributer(IReadOnlyList<Individual> front, MultiObjectiveBasicProblem<RealVectorEncoding> problem) {
+      var frontCopy = front.Select(x => x.PenalizedFitness).ToList();
+      if (frontCopy.Count <= 1) return 0;
+      var p = problem as MultiObjectiveTestFunctionProblem;
+      var refPoint = BuildReferencePoint(p != null ? frontCopy.Concat(new[] { p.ReferencePoint.CloneAsArray() }) : frontCopy, problem.Maximization);
+      var contributions = Enumerable.Range(0, frontCopy.Count).Select(i => Contribution(frontCopy, i, problem.Maximization, refPoint));
+      return contributions.Select((value, index) => new { value, index }).OrderBy(x => x.value).First().index;
+    }
+
+    #region Helpers
+    private static double Contribution(IList<double[]> front, int idx, bool[] maximization, double[] refPoint) {
+      var point = front[idx];
+      front.RemoveAt(idx);
+      var contribution = -Hypervolume.Calculate(front.ToArray(), refPoint, maximization);
+      front.Insert(idx, point);
+      return contribution;
+    }
+    private static double[] BuildReferencePoint(IEnumerable<double[]> front, IReadOnlyList<bool> maximization) {
+      var refPoint = new double[maximization.Count];
+      foreach (var point in front)
+        for (var i = 0; i < maximization.Count; i++)
+          refPoint[i] = maximization[i] ? Math.Min(refPoint[i], point[i]) : Math.Max(refPoint[i], point[i]);
+      return refPoint;
+    }
+    #endregion
+  }
+}
Index: /trunk/sources/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/Indicators/MinimalDistanceIndicator.cs
===================================================================
--- /trunk/sources/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/Indicators/MinimalDistanceIndicator.cs	(revision 15178)
+++ /trunk/sources/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/Indicators/MinimalDistanceIndicator.cs	(revision 15178)
@@ -0,0 +1,100 @@
+﻿#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 System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.RealVectorEncoding;
+using HeuristicLab.Optimization;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Algorithms.MOCMAEvolutionStrategy {
+  [Item("MinimalDistanceIndicator", "Selection of Offspring based on distance to nearest neighbour")]
+  [StorableClass]
+  internal class MinimalDistanceIndicator : Item, IIndicator {
+
+    #region Constructor and Cloning
+    [StorableConstructor]
+    protected MinimalDistanceIndicator(bool deserializing) : base(deserializing) { }
+    protected MinimalDistanceIndicator(MinimalDistanceIndicator original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) { return new MinimalDistanceIndicator(this, cloner); }
+    public MinimalDistanceIndicator() { }
+    #endregion
+
+    public int LeastContributer(IReadOnlyList<Individual> front, MultiObjectiveBasicProblem<RealVectorEncoding> problem) {
+      var extracted = front.Select(x => x.PenalizedFitness).ToArray();
+      if (extracted.Length <= 2) return 0;
+      var distances = CalcDistances(extracted);
+      var mindexI = 0;
+      var mindexJ = 0;
+      var min = double.MaxValue;
+      for (var i = 0; i < extracted.Length; i++) {
+        var d = double.MaxValue;
+        var minj = 0;
+        for (var j = 0; j < extracted.Length; j++) {
+          if (i == j) continue;
+          var d1 = distances[i, j];
+          if (!(d1 < d)) continue;
+          minj = j;
+          d = d1;
+        }
+        if (!(d < min)) continue;
+        min = d;
+        mindexI = i;
+        mindexJ = minj;
+      }
+
+      //break tie with distance to second nearest
+      var minI = double.MaxValue;
+      var minJ = double.MaxValue;
+
+      for (var i = 0; i < extracted.Length; i++) {
+        double d;
+        if (mindexI != i) {
+          d = distances[mindexI, i];
+          if (!d.IsAlmost(min)) minI = Math.Min(minI, d);
+        }
+        if (mindexJ == i) continue;
+        d = distances[mindexJ, i];
+        if (!d.IsAlmost(min)) minJ = Math.Min(minJ, d);
+      }
+
+      //find min
+      return minI < minJ ? mindexI : mindexJ;
+    }
+
+    #region Helpers
+    private static double[,] CalcDistances(IReadOnlyList<double[]> extracted) {
+      var res = new double[extracted.Count, extracted.Count];
+      for (var i = 0; i < extracted.Count; i++)
+        for (var j = 0; j < i; j++)
+          res[i, j] = res[j, i] = Dist(extracted[i], extracted[j]);
+      return res;
+    }
+
+    private static double Dist(IEnumerable<double> a, IEnumerable<double> b) {
+      return Math.Sqrt(a.Zip(b, (x, y) => (x - y) * (x - y)).Sum());
+    }
+    #endregion
+  }
+}
Index: /trunk/sources/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/Individual.cs
===================================================================
--- /trunk/sources/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/Individual.cs	(revision 15178)
+++ /trunk/sources/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/Individual.cs	(revision 15178)
@@ -0,0 +1,197 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2016 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ * and the BEACON Center for the Study of Evolution in Action.
+ * 
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Encodings.RealVectorEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Algorithms.MOCMAEvolutionStrategy {
+  [StorableClass]
+  public class Individual : IDeepCloneable {
+
+    #region Properties
+    [Storable]
+    private MOCMAEvolutionStrategy strategy;
+
+    //Chromosome
+    [Storable]
+    public RealVector Mean { get; private set; }
+    [Storable]
+    private double sigma;//stepsize
+    [Storable]
+    private RealVector evolutionPath; // pc
+    [Storable]
+    private RealVector lastStep;
+    [Storable]
+    private RealVector lastZ;
+    [Storable]
+    private double[,] lowerCholesky;
+
+    //Phenotype
+    [Storable]
+    public double[] Fitness { get; set; }
+    [Storable]
+    public double[] PenalizedFitness { get; set; }
+    [Storable]
+    public bool Selected { get; set; }
+    [Storable]
+    public double SuccessProbability { get; set; }
+    #endregion
+
+    #region Constructors and Cloning
+    [StorableConstructor]
+    protected Individual(bool deserializing) { }
+
+    public Individual(RealVector mean, double pSucc, double sigma, RealVector pc, double[,] c, MOCMAEvolutionStrategy strategy) {
+      Mean = mean;
+      lastStep = new RealVector(mean.Length);
+      SuccessProbability = pSucc;
+      this.sigma = sigma;
+      evolutionPath = pc;
+      CholeskyDecomposition(c);
+      Selected = true;
+      this.strategy = strategy;
+    }
+
+    public Individual(Individual other) {
+      SuccessProbability = other.SuccessProbability;
+      sigma = other.sigma;
+      evolutionPath = (RealVector)other.evolutionPath.Clone();
+      Mean = (RealVector)other.Mean.Clone();
+      lowerCholesky = (double[,])other.lowerCholesky.Clone();
+      Selected = true;
+      strategy = other.strategy;
+    }
+
+    public Individual(Individual other, Cloner cloner) {
+      strategy = cloner.Clone(other.strategy);
+      Mean = cloner.Clone(other.Mean);
+      sigma = other.sigma;
+      evolutionPath = cloner.Clone(other.evolutionPath);
+      lastStep = cloner.Clone(other.evolutionPath);
+      lastZ = cloner.Clone(other.lastZ);
+      lowerCholesky = other.lowerCholesky != null ? other.lowerCholesky.Clone() as double[,] : null;
+      Fitness = other.Fitness != null ? other.Fitness.Select(x => x).ToArray() : null;
+      PenalizedFitness = other.PenalizedFitness != null ? other.PenalizedFitness.Select(x => x).ToArray() : null;
+      Selected = other.Selected;
+      SuccessProbability = other.SuccessProbability;
+    }
+
+    public object Clone() {
+      return new Cloner().Clone(this);
+    }
+
+    public IDeepCloneable Clone(Cloner cloner) {
+      return new Individual(this, cloner);
+    }
+    #endregion
+
+    public void Mutate(NormalDistributedRandom gauss) {
+      //sampling a random z from N(0,I) where I is the Identity matrix;
+      lastZ = new RealVector(Mean.Length);
+      var n = lastZ.Length;
+      for (var i = 0; i < n; i++) lastZ[i] = gauss.NextDouble();
+      //Matrixmultiplication: lastStep = lowerCholesky * lastZ;
+      lastStep = new RealVector(Mean.Length);
+      for (var i = 0; i < n; i++) {
+        double sum = 0;
+        for (var j = 0; j <= i; j++) sum += lowerCholesky[i, j] * lastZ[j];
+        lastStep[i] = sum;
+      }
+      //add the step to x weighted by stepsize;
+      for (var i = 0; i < Mean.Length; i++) Mean[i] += sigma * lastStep[i];
+    }
+
+    public void UpdateAsParent(bool offspringSuccessful) {
+      SuccessProbability = (1 - strategy.StepSizeLearningRate) * SuccessProbability + strategy.StepSizeLearningRate * (offspringSuccessful ? 1 : 0);
+      sigma *= Math.Exp(1 / strategy.StepSizeDampeningFactor * (SuccessProbability - strategy.TargetSuccessProbability) / (1 - strategy.TargetSuccessProbability));
+      if (!offspringSuccessful) return;
+      if (SuccessProbability < strategy.SuccessThreshold && lastZ != null) {
+        var stepNormSqr = lastZ.Sum(d => d * d);
+        var rate = strategy.CovarianceMatrixUnlearningRate;
+        if (stepNormSqr > 1 && 1 < strategy.CovarianceMatrixUnlearningRate * (2 * stepNormSqr - 1)) rate = 1 / (2 * stepNormSqr - 1);
+        CholeskyUpdate(lastStep, 1 + rate, -rate);
+      } else RoundUpdate();
+    }
+
+    public void UpdateAsOffspring() {
+      SuccessProbability = (1 - strategy.StepSizeLearningRate) * SuccessProbability + strategy.StepSizeLearningRate;
+      sigma *= Math.Exp(1 / strategy.StepSizeDampeningFactor * (SuccessProbability - strategy.TargetSuccessProbability) / (1 - strategy.TargetSuccessProbability));
+      var evolutionpathUpdateWeight = strategy.EvolutionPathLearningRate * (2.0 - strategy.EvolutionPathLearningRate);
+      if (SuccessProbability < strategy.SuccessThreshold) {
+        UpdateEvolutionPath(1 - strategy.EvolutionPathLearningRate, evolutionpathUpdateWeight);
+        CholeskyUpdate(evolutionPath, 1 - strategy.CovarianceMatrixLearningRate, strategy.CovarianceMatrixLearningRate);
+      } else RoundUpdate();
+    }
+
+    public void UpdateEvolutionPath(double learningRate, double updateWeight) {
+      updateWeight = Math.Sqrt(updateWeight);
+      for (var i = 0; i < evolutionPath.Length; i++) {
+        evolutionPath[i] *= learningRate;
+        evolutionPath[i] += updateWeight * lastStep[i];
+      }
+    }
+
+    #region Helpers
+    private void CholeskyDecomposition(double[,] c) {
+      if (!alglib.spdmatrixcholesky(ref c, c.GetLength(0), false))
+        throw new ArgumentException("Covariancematrix is not symmetric positiv definit");
+      lowerCholesky = (double[,])c.Clone();
+    }
+
+    private void CholeskyUpdate(RealVector v, double alpha, double beta) {
+      var n = v.Length;
+      var temp = new double[n];
+      for (var i = 0; i < n; i++) temp[i] = v[i];
+      double betaPrime = 1;
+      var a = Math.Sqrt(alpha);
+      for (var j = 0; j < n; j++) {
+        var ljj = a * lowerCholesky[j, j];
+        var dj = ljj * ljj;
+        var wj = temp[j];
+        var swj2 = beta * wj * wj;
+        var gamma = dj * betaPrime + swj2;
+        var x1 = dj + swj2 / betaPrime;
+        if (x1 < 0.0) return;
+        var nLjj = Math.Sqrt(x1);
+        lowerCholesky[j, j] = nLjj;
+        betaPrime += swj2 / dj;
+        if (j + 1 >= n) continue;
+        for (var i = j + 1; i < n; i++) lowerCholesky[i, j] *= a;
+        for (var i = j + 1; i < n; i++) temp[i] = wj / ljj * lowerCholesky[i, j];
+        if (gamma.IsAlmost(0)) continue;
+        for (var i = j + 1; i < n; i++) lowerCholesky[i, j] *= nLjj / ljj;
+        for (var i = j + 1; i < n; i++) lowerCholesky[i, j] += nLjj * beta * wj / gamma * temp[i];
+      }
+    }
+
+    private void RoundUpdate() {
+      var evolutionPathUpdateWeight = strategy.EvolutionPathLearningRate * (2.0 - strategy.EvolutionPathLearningRate);
+      UpdateEvolutionPath(1 - strategy.EvolutionPathLearningRate, 0);
+      CholeskyUpdate(evolutionPath, 1 - strategy.CovarianceMatrixLearningRate + evolutionPathUpdateWeight, strategy.CovarianceMatrixLearningRate);
+    }
+    #endregion
+  }
+}
Index: /trunk/sources/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/MOCMAEvolutionStrategy.cs
===================================================================
--- /trunk/sources/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/MOCMAEvolutionStrategy.cs	(revision 15178)
+++ /trunk/sources/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/MOCMAEvolutionStrategy.cs	(revision 15178)
@@ -0,0 +1,504 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2016 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ * and the BEACON Center for the Study of Evolution in Action.
+ * 
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using HeuristicLab.Analysis;
+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.TestFunctions.MultiObjective;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Algorithms.MOCMAEvolutionStrategy {
+  [Item("MOCMA Evolution Strategy (MOCMAES)", "A multi objective evolution strategy based on covariance matrix adaptation. Code is based on 'Covariance Matrix Adaptation for Multi - objective Optimization' by Igel, Hansen and Roth")]
+  [Creatable(CreatableAttribute.Categories.PopulationBasedAlgorithms, Priority = 210)]
+  [StorableClass]
+  public class MOCMAEvolutionStrategy : BasicAlgorithm {
+    public override Type ProblemType {
+      get { return typeof(MultiObjectiveBasicProblem<RealVectorEncoding>); }
+    }
+    public new MultiObjectiveBasicProblem<RealVectorEncoding> Problem {
+      get { return (MultiObjectiveBasicProblem<RealVectorEncoding>)base.Problem; }
+      set { base.Problem = value; }
+    }
+    public override bool SupportsPause {
+      get { return true; }
+    }
+
+    #region Storable fields
+    [Storable]
+    private IRandom random = new MersenneTwister();
+    [Storable]
+    private NormalDistributedRandom gauss;
+    [Storable]
+    private Individual[] solutions;
+    [Storable]
+    private double stepSizeLearningRate; //=cp learning rate in [0,1]
+    [Storable]
+    private double stepSizeDampeningFactor; //d
+    [Storable]
+    private double targetSuccessProbability;// p^target_succ
+    [Storable]
+    private double evolutionPathLearningRate;//cc
+    [Storable]
+    private double covarianceMatrixLearningRate;//ccov
+    [Storable]
+    private double covarianceMatrixUnlearningRate;
+    [Storable]
+    private double successThreshold; //ptresh
+
+    #endregion
+
+    #region ParameterNames
+    private const string MaximumRuntimeName = "Maximum Runtime";
+    private const string SeedName = "Seed";
+    private const string SetSeedRandomlyName = "SetSeedRandomly";
+    private const string PopulationSizeName = "PopulationSize";
+    private const string MaximumGenerationsName = "MaximumGenerations";
+    private const string MaximumEvaluatedSolutionsName = "MaximumEvaluatedSolutions";
+    private const string InitialSigmaName = "InitialSigma";
+    private const string IndicatorName = "Indicator";
+
+    private const string EvaluationsResultName = "Evaluations";
+    private const string IterationsResultName = "Generations";
+    private const string TimetableResultName = "Timetable";
+    private const string HypervolumeResultName = "Hypervolume";
+    private const string GenerationalDistanceResultName = "Generational Distance";
+    private const string InvertedGenerationalDistanceResultName = "Inverted Generational Distance";
+    private const string CrowdingResultName = "Crowding";
+    private const string SpacingResultName = "Spacing";
+    private const string CurrentFrontResultName = "Pareto Front";
+    private const string BestHypervolumeResultName = "Best Hypervolume";
+    private const string BestKnownHypervolumeResultName = "Best known hypervolume";
+    private const string DifferenceToBestKnownHypervolumeResultName = "Absolute Distance to BestKnownHypervolume";
+    private const string ScatterPlotResultName = "ScatterPlot";
+    #endregion
+
+    #region ParameterProperties
+    public IFixedValueParameter<IntValue> MaximumRuntimeParameter {
+      get { return (IFixedValueParameter<IntValue>)Parameters[MaximumRuntimeName]; }
+    }
+    public IFixedValueParameter<IntValue> SeedParameter {
+      get { return (IFixedValueParameter<IntValue>)Parameters[SeedName]; }
+    }
+    public FixedValueParameter<BoolValue> SetSeedRandomlyParameter {
+      get { return (FixedValueParameter<BoolValue>)Parameters[SetSeedRandomlyName]; }
+    }
+    public IFixedValueParameter<IntValue> PopulationSizeParameter {
+      get { return (IFixedValueParameter<IntValue>)Parameters[PopulationSizeName]; }
+    }
+    public IFixedValueParameter<IntValue> MaximumGenerationsParameter {
+      get { return (IFixedValueParameter<IntValue>)Parameters[MaximumGenerationsName]; }
+    }
+    public IFixedValueParameter<IntValue> MaximumEvaluatedSolutionsParameter {
+      get { return (IFixedValueParameter<IntValue>)Parameters[MaximumEvaluatedSolutionsName]; }
+    }
+    public IValueParameter<DoubleArray> InitialSigmaParameter {
+      get { return (IValueParameter<DoubleArray>)Parameters[InitialSigmaName]; }
+    }
+    public IConstrainedValueParameter<IIndicator> IndicatorParameter {
+      get { return (IConstrainedValueParameter<IIndicator>)Parameters[IndicatorName]; }
+    }
+    #endregion
+
+    #region Properties
+    public int MaximumRuntime {
+      get { return MaximumRuntimeParameter.Value.Value; }
+      set { MaximumRuntimeParameter.Value.Value = value; }
+    }
+    public int Seed {
+      get { return SeedParameter.Value.Value; }
+      set { SeedParameter.Value.Value = value; }
+    }
+    public bool SetSeedRandomly {
+      get { return SetSeedRandomlyParameter.Value.Value; }
+      set { SetSeedRandomlyParameter.Value.Value = value; }
+    }
+    public int PopulationSize {
+      get { return PopulationSizeParameter.Value.Value; }
+      set { PopulationSizeParameter.Value.Value = value; }
+    }
+    public int MaximumGenerations {
+      get { return MaximumGenerationsParameter.Value.Value; }
+      set { MaximumGenerationsParameter.Value.Value = value; }
+    }
+    public int MaximumEvaluatedSolutions {
+      get { return MaximumEvaluatedSolutionsParameter.Value.Value; }
+      set { MaximumEvaluatedSolutionsParameter.Value.Value = value; }
+    }
+    public DoubleArray InitialSigma {
+      get { return InitialSigmaParameter.Value; }
+      set { InitialSigmaParameter.Value = value; }
+    }
+    public IIndicator Indicator {
+      get { return IndicatorParameter.Value; }
+      set { IndicatorParameter.Value = value; }
+    }
+
+    public double StepSizeLearningRate { get { return stepSizeLearningRate; } }
+    public double StepSizeDampeningFactor { get { return stepSizeDampeningFactor; } }
+    public double TargetSuccessProbability { get { return targetSuccessProbability; } }
+    public double EvolutionPathLearningRate { get { return evolutionPathLearningRate; } }
+    public double CovarianceMatrixLearningRate { get { return covarianceMatrixLearningRate; } }
+    public double CovarianceMatrixUnlearningRate { get { return covarianceMatrixUnlearningRate; } }
+    public double SuccessThreshold { get { return successThreshold; } }
+    #endregion
+
+    #region ResultsProperties
+    private int ResultsEvaluations {
+      get { return ((IntValue)Results[EvaluationsResultName].Value).Value; }
+      set { ((IntValue)Results[EvaluationsResultName].Value).Value = value; }
+    }
+    private int ResultsIterations {
+      get { return ((IntValue)Results[IterationsResultName].Value).Value; }
+      set { ((IntValue)Results[IterationsResultName].Value).Value = value; }
+    }
+    #region Datatable
+    private DataTable ResultsQualities {
+      get { return (DataTable)Results[TimetableResultName].Value; }
+    }
+    private DataRow ResultsBestHypervolumeDataLine {
+      get { return ResultsQualities.Rows[BestHypervolumeResultName]; }
+    }
+    private DataRow ResultsHypervolumeDataLine {
+      get { return ResultsQualities.Rows[HypervolumeResultName]; }
+    }
+    private DataRow ResultsGenerationalDistanceDataLine {
+      get { return ResultsQualities.Rows[GenerationalDistanceResultName]; }
+    }
+    private DataRow ResultsInvertedGenerationalDistanceDataLine {
+      get { return ResultsQualities.Rows[InvertedGenerationalDistanceResultName]; }
+    }
+    private DataRow ResultsCrowdingDataLine {
+      get { return ResultsQualities.Rows[CrowdingResultName]; }
+    }
+    private DataRow ResultsSpacingDataLine {
+      get { return ResultsQualities.Rows[SpacingResultName]; }
+    }
+    private DataRow ResultsHypervolumeDifferenceDataLine {
+      get { return ResultsQualities.Rows[DifferenceToBestKnownHypervolumeResultName]; }
+    }
+    #endregion
+    //QualityIndicators
+    private double ResultsHypervolume {
+      get { return ((DoubleValue)Results[HypervolumeResultName].Value).Value; }
+      set { ((DoubleValue)Results[HypervolumeResultName].Value).Value = value; }
+    }
+    private double ResultsGenerationalDistance {
+      get { return ((DoubleValue)Results[GenerationalDistanceResultName].Value).Value; }
+      set { ((DoubleValue)Results[GenerationalDistanceResultName].Value).Value = value; }
+    }
+    private double ResultsInvertedGenerationalDistance {
+      get { return ((DoubleValue)Results[InvertedGenerationalDistanceResultName].Value).Value; }
+      set { ((DoubleValue)Results[InvertedGenerationalDistanceResultName].Value).Value = value; }
+    }
+    private double ResultsCrowding {
+      get { return ((DoubleValue)Results[CrowdingResultName].Value).Value; }
+      set { ((DoubleValue)Results[CrowdingResultName].Value).Value = value; }
+    }
+    private double ResultsSpacing {
+      get { return ((DoubleValue)Results[SpacingResultName].Value).Value; }
+      set { ((DoubleValue)Results[SpacingResultName].Value).Value = value; }
+    }
+    private double ResultsBestHypervolume {
+      get { return ((DoubleValue)Results[BestHypervolumeResultName].Value).Value; }
+      set { ((DoubleValue)Results[BestHypervolumeResultName].Value).Value = value; }
+    }
+    private double ResultsBestKnownHypervolume {
+      get { return ((DoubleValue)Results[BestKnownHypervolumeResultName].Value).Value; }
+      set { ((DoubleValue)Results[BestKnownHypervolumeResultName].Value).Value = value; }
+    }
+    private double ResultsDifferenceBestKnownHypervolume {
+      get { return ((DoubleValue)Results[DifferenceToBestKnownHypervolumeResultName].Value).Value; }
+      set { ((DoubleValue)Results[DifferenceToBestKnownHypervolumeResultName].Value).Value = value; }
+
+    }
+    //Solutions
+    private DoubleMatrix ResultsSolutions {
+      get { return (DoubleMatrix)Results[CurrentFrontResultName].Value; }
+      set { Results[CurrentFrontResultName].Value = value; }
+    }
+    private ScatterPlotContent ResultsScatterPlot {
+      get { return (ScatterPlotContent)Results[ScatterPlotResultName].Value; }
+      set { Results[ScatterPlotResultName].Value = value; }
+    }
+    #endregion
+
+    #region Constructors
+    public MOCMAEvolutionStrategy() {
+      Parameters.Add(new FixedValueParameter<IntValue>(MaximumRuntimeName, "The maximum runtime in seconds after which the algorithm stops. Use -1 to specify no limit for the runtime", new IntValue(3600)));
+      Parameters.Add(new FixedValueParameter<IntValue>(SeedName, "The random seed used to initialize the new pseudo random number generator.", new IntValue(0)));
+      Parameters.Add(new FixedValueParameter<BoolValue>(SetSeedRandomlyName, "True if the random seed should be set to a random value, otherwise false.", new BoolValue(true)));
+      Parameters.Add(new FixedValueParameter<IntValue>(PopulationSizeName, "λ (lambda) - the size of the offspring population.", new IntValue(20)));
+      Parameters.Add(new ValueParameter<DoubleArray>(InitialSigmaName, "The initial sigma can be a single value or a value for each dimension. All values need to be > 0.", new DoubleArray(new[] { 0.5 })));
+      Parameters.Add(new FixedValueParameter<IntValue>(MaximumGenerationsName, "The maximum number of generations which should be processed.", new IntValue(1000)));
+      Parameters.Add(new FixedValueParameter<IntValue>(MaximumEvaluatedSolutionsName, "The maximum number of evaluated solutions that should be computed.", new IntValue(int.MaxValue)));
+      var set = new ItemSet<IIndicator> { new HypervolumeIndicator(), new CrowdingIndicator(), new MinimalDistanceIndicator() };
+      Parameters.Add(new ConstrainedValueParameter<IIndicator>(IndicatorName, "The selection mechanism on non-dominated solutions", set, set.First()));
+    }
+
+    [StorableConstructor]
+    protected MOCMAEvolutionStrategy(bool deserializing) : base(deserializing) { }
+
+    protected MOCMAEvolutionStrategy(MOCMAEvolutionStrategy original, Cloner cloner) : base(original, cloner) {
+      random = cloner.Clone(original.random);
+      gauss = cloner.Clone(original.gauss);
+      solutions = original.solutions != null ? original.solutions.Select(cloner.Clone).ToArray() : null;
+      stepSizeLearningRate = original.stepSizeLearningRate;
+      stepSizeDampeningFactor = original.stepSizeDampeningFactor;
+      targetSuccessProbability = original.targetSuccessProbability;
+      evolutionPathLearningRate = original.evolutionPathLearningRate;
+      covarianceMatrixLearningRate = original.covarianceMatrixLearningRate;
+      covarianceMatrixUnlearningRate = original.covarianceMatrixUnlearningRate;
+      successThreshold = original.successThreshold;
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) { return new MOCMAEvolutionStrategy(this, cloner); }
+    #endregion
+
+    #region Initialization
+    protected override void Initialize(CancellationToken cancellationToken) {
+      if (SetSeedRandomly) Seed = new System.Random().Next();
+      random.Reset(Seed);
+      gauss = new NormalDistributedRandom(random, 0, 1);
+
+      InitResults();
+      InitStrategy();
+      InitSolutions();
+      Analyze();
+
+      ResultsIterations = 1;
+      cancellationToken.ThrowIfCancellationRequested();
+    }
+    private Individual InitializeIndividual(RealVector x) {
+      var zeros = new RealVector(x.Length);
+      var c = new double[x.Length, x.Length];
+      var sigma = InitialSigma.Max();
+      for (var i = 0; i < x.Length; i++) {
+        var d = InitialSigma[i % InitialSigma.Length] / sigma;
+        c[i, i] = d * d;
+      }
+      return new Individual(x, targetSuccessProbability, sigma, zeros, c, this);
+    }
+    private void InitSolutions() {
+      solutions = new Individual[PopulationSize];
+      for (var i = 0; i < PopulationSize; i++) {
+        var x = new RealVector(Problem.Encoding.Length); // Uniform distibution in all dimensions assumed.
+        var bounds = Problem.Encoding.Bounds;
+        for (var j = 0; j < Problem.Encoding.Length; j++) {
+          var dim = j % bounds.Rows;
+          x[j] = random.NextDouble() * (bounds[dim, 1] - bounds[dim, 0]) + bounds[dim, 0];
+        }
+        solutions[i] = InitializeIndividual(x);
+        PenalizeEvaluate(solutions[i]);
+      }
+    }
+    private void InitStrategy() {
+      const int lambda = 1;
+      double n = Problem.Encoding.Length;
+      targetSuccessProbability = 1.0 / (5.0 + Math.Sqrt(lambda) / 2.0);
+      stepSizeDampeningFactor = 1.0 + n / (2.0 * lambda);
+      stepSizeLearningRate = targetSuccessProbability * lambda / (2.0 + targetSuccessProbability * lambda);
+      evolutionPathLearningRate = 2.0 / (n + 2.0);
+      covarianceMatrixLearningRate = 2.0 / (n * n + 6.0);
+      covarianceMatrixUnlearningRate = 0.4 / (Math.Pow(n, 1.6) + 1);
+      successThreshold = 0.44;
+    }
+    private void InitResults() {
+      Results.Add(new Result(IterationsResultName, "The number of gererations evaluated", new IntValue(0)));
+      Results.Add(new Result(EvaluationsResultName, "The number of function evaltions performed", new IntValue(0)));
+      Results.Add(new Result(HypervolumeResultName, "The hypervolume of the current front considering the Referencepoint defined in the Problem", new DoubleValue(0.0)));
+      Results.Add(new Result(BestHypervolumeResultName, "The best hypervolume of the current run considering the Referencepoint defined in the Problem", new DoubleValue(0.0)));
+      Results.Add(new Result(BestKnownHypervolumeResultName, "The best knwon hypervolume considering the Referencepoint defined in the Problem", new DoubleValue(double.NaN)));
+      Results.Add(new Result(DifferenceToBestKnownHypervolumeResultName, "The difference between the current and the best known hypervolume", new DoubleValue(double.NaN)));
+      Results.Add(new Result(GenerationalDistanceResultName, "The generational distance to an optimal pareto front defined in the Problem", new DoubleValue(double.NaN)));
+      Results.Add(new Result(InvertedGenerationalDistanceResultName, "The inverted generational distance to an optimal pareto front defined in the Problem", new DoubleValue(double.NaN)));
+      Results.Add(new Result(CrowdingResultName, "The average crowding value for the current front (excluding infinities)", new DoubleValue(0.0)));
+      Results.Add(new Result(SpacingResultName, "The spacing for the current front (excluding infinities)", new DoubleValue(0.0)));
+
+      var table = new DataTable("QualityIndicators");
+      table.Rows.Add(new DataRow(BestHypervolumeResultName));
+      table.Rows.Add(new DataRow(HypervolumeResultName));
+      table.Rows.Add(new DataRow(CrowdingResultName));
+      table.Rows.Add(new DataRow(GenerationalDistanceResultName));
+      table.Rows.Add(new DataRow(InvertedGenerationalDistanceResultName));
+      table.Rows.Add(new DataRow(DifferenceToBestKnownHypervolumeResultName));
+      table.Rows.Add(new DataRow(SpacingResultName));
+      Results.Add(new Result(TimetableResultName, "Different quality meassures in a timeseries", table));
+      Results.Add(new Result(CurrentFrontResultName, "The current front", new DoubleMatrix()));
+      Results.Add(new Result(ScatterPlotResultName, "A scatterplot displaying the evaluated solutions and (if available) the analytically optimal front", new ScatterPlotContent(null, null, null, 2)));
+
+      var problem = Problem as MultiObjectiveTestFunctionProblem;
+      if (problem == null) return;
+      if (problem.BestKnownFront != null) {
+        ResultsBestKnownHypervolume = Hypervolume.Calculate(problem.BestKnownFront.ToJaggedArray(), problem.TestFunction.ReferencePoint(problem.Objectives), Problem.Maximization);
+        ResultsDifferenceBestKnownHypervolume = ResultsBestKnownHypervolume;
+      }
+      ResultsScatterPlot = new ScatterPlotContent(new double[0][], new double[0][], problem.BestKnownFront.ToJaggedArray(), problem.Objectives);
+    }
+    #endregion
+
+    #region Mainloop
+    protected override void Run(CancellationToken cancellationToken) {
+      while (ResultsIterations < MaximumGenerations) {
+        try {
+          Iterate();
+          ResultsIterations++;
+          cancellationToken.ThrowIfCancellationRequested();
+        } finally {
+          Analyze();
+        }
+      }
+    }
+    private void Iterate() {
+      var offspring = solutions.Select(i => {
+        var o = new Individual(i);
+        o.Mutate(gauss);
+        PenalizeEvaluate(o);
+        return o;
+      });
+      var parents = solutions.Concat(offspring).ToArray();
+      SelectParents(parents, solutions.Length);
+      UpdatePopulation(parents);
+    }
+    protected override void OnExecutionTimeChanged() {
+      base.OnExecutionTimeChanged();
+      if (CancellationTokenSource == null) return;
+      if (MaximumRuntime == -1) return;
+      if (ExecutionTime.TotalSeconds > MaximumRuntime) CancellationTokenSource.Cancel();
+    }
+    #endregion
+
+    #region Evaluation
+    private void PenalizeEvaluate(Individual individual) {
+      if (IsFeasable(individual.Mean)) {
+        individual.Fitness = Evaluate(individual.Mean);
+        individual.PenalizedFitness = individual.Fitness;
+      } else {
+        var t = ClosestFeasible(individual.Mean);
+        individual.Fitness = Evaluate(t);
+        individual.PenalizedFitness = Penalize(individual.Mean, t, individual.Fitness);
+      }
+    }
+    private double[] Evaluate(RealVector x) {
+      var res = Problem.Evaluate(new SingleEncodingIndividual(Problem.Encoding, new Scope { Variables = { new Variable(Problem.Encoding.Name, x) } }), random);
+      ResultsEvaluations++;
+      return res;
+    }
+    private double[] Penalize(RealVector x, RealVector t, IEnumerable<double> fitness) {
+      var penalty = x.Zip(t, (a, b) => (a - b) * (a - b)).Sum() * 1E-6;
+      return fitness.Select((v, i) => Problem.Maximization[i] ? v - penalty : v + penalty).ToArray();
+    }
+    private RealVector ClosestFeasible(RealVector x) {
+      var bounds = Problem.Encoding.Bounds;
+      var r = new RealVector(x.Length);
+      for (var i = 0; i < x.Length; i++) {
+        var dim = i % bounds.Rows;
+        r[i] = Math.Min(Math.Max(bounds[dim, 0], x[i]), bounds[dim, 1]);
+      }
+      return r;
+    }
+    private bool IsFeasable(RealVector offspring) {
+      var bounds = Problem.Encoding.Bounds;
+      for (var i = 0; i < offspring.Length; i++) {
+        var dim = i % bounds.Rows;
+        if (bounds[dim, 0] > offspring[i] || offspring[i] > bounds[dim, 1]) return false;
+      }
+      return true;
+    }
+    #endregion
+
+    private void SelectParents(IReadOnlyList<Individual> parents, int length) {
+      //perform a nondominated sort to assign the rank to every element
+      int[] ranks;
+      var fronts = DominationCalculator<Individual>.CalculateAllParetoFronts(parents.ToArray(), parents.Select(i => i.PenalizedFitness).ToArray(), Problem.Maximization, out ranks);
+
+      //deselect the highest rank fronts until we would end up with less or equal mu elements
+      var rank = fronts.Count - 1;
+      var popSize = parents.Count;
+      while (popSize - fronts[rank].Count >= length) {
+        var front = fronts[rank];
+        foreach (var i in front) i.Item1.Selected = false;
+        popSize -= front.Count;
+        rank--;
+      }
+
+      //now use the indicator to deselect the approximatingly worst elements of the last selected front
+      var front1 = fronts[rank].OrderBy(x => x.Item1.PenalizedFitness[0]).ToList();
+      for (; popSize > length; popSize--) {
+        var lc = Indicator.LeastContributer(front1.Select(i => i.Item1).ToArray(), Problem);
+        front1[lc].Item1.Selected = false;
+        front1.Swap(lc, front1.Count - 1);
+        front1.RemoveAt(front1.Count - 1);
+      }
+    }
+
+    private void UpdatePopulation(IReadOnlyList<Individual> parents) {
+      foreach (var p in parents.Skip(solutions.Length).Where(i => i.Selected))
+        p.UpdateAsOffspring();
+      for (var i = 0; i < solutions.Length; i++)
+        if (parents[i].Selected)
+          parents[i].UpdateAsParent(parents[i + solutions.Length].Selected);
+      solutions = parents.Where(p => p.Selected).ToArray();
+    }
+
+    private void Analyze() {
+      ResultsScatterPlot = new ScatterPlotContent(solutions.Select(x => x.Fitness).ToArray(), solutions.Select(x => x.Mean.ToArray()).ToArray(), ResultsScatterPlot.ParetoFront, ResultsScatterPlot.Objectives);
+      ResultsSolutions = solutions.Select(x => x.Mean.ToArray()).ToMatrix();
+
+      var problem = Problem as MultiObjectiveTestFunctionProblem;
+      if (problem == null) return;
+
+      var front = NonDominatedSelect.GetDominatingVectors(solutions.Select(x => x.Fitness), problem.ReferencePoint.CloneAsArray(), Problem.Maximization, true).ToArray();
+      if (front.Length == 0) return;
+      var bounds = problem.Bounds.CloneAsMatrix();
+      ResultsCrowding = Crowding.Calculate(front, bounds);
+      ResultsSpacing = Spacing.Calculate(front);
+      ResultsGenerationalDistance = problem.BestKnownFront != null ? GenerationalDistance.Calculate(front, problem.BestKnownFront.ToJaggedArray(), 1) : double.NaN;
+      ResultsInvertedGenerationalDistance = problem.BestKnownFront != null ? InvertedGenerationalDistance.Calculate(front, problem.BestKnownFront.ToJaggedArray(), 1) : double.NaN;
+      ResultsHypervolume = Hypervolume.Calculate(front, problem.ReferencePoint.CloneAsArray(), Problem.Maximization);
+      ResultsBestHypervolume = Math.Max(ResultsHypervolume, ResultsBestHypervolume);
+      ResultsDifferenceBestKnownHypervolume = ResultsBestKnownHypervolume - ResultsBestHypervolume;
+
+      ResultsBestHypervolumeDataLine.Values.Add(ResultsBestHypervolume);
+      ResultsHypervolumeDataLine.Values.Add(ResultsHypervolume);
+      ResultsCrowdingDataLine.Values.Add(ResultsCrowding);
+      ResultsGenerationalDistanceDataLine.Values.Add(ResultsGenerationalDistance);
+      ResultsInvertedGenerationalDistanceDataLine.Values.Add(ResultsInvertedGenerationalDistance);
+      ResultsSpacingDataLine.Values.Add(ResultsSpacing);
+      ResultsHypervolumeDifferenceDataLine.Values.Add(ResultsDifferenceBestKnownHypervolume);
+
+      Problem.Analyze(
+        solutions.Select(x => (Optimization.Individual)new SingleEncodingIndividual(Problem.Encoding, new Scope { Variables = { new Variable(Problem.Encoding.Name, x.Mean) } })).ToArray(),
+        solutions.Select(x => x.Fitness).ToArray(),
+        Results,
+        random);
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/Plugin.cs.frame
===================================================================
--- /trunk/sources/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/Plugin.cs.frame	(revision 15178)
+++ /trunk/sources/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/Plugin.cs.frame	(revision 15178)
@@ -0,0 +1,44 @@
+#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.PluginInfrastructure;
+
+namespace HeuristicLab.Algorithms.MOCMAEvolutionStrategy {
+  /// <summary>
+  /// Plugin class for HeuristicLab.Algorithms.EvolutionStrategy plugin.
+  /// </summary>
+  [Plugin("HeuristicLab.Algorithms.MOCMAEvolutionStrategy", "3.3.14.$WCREV$")]
+  [PluginFile("HeuristicLab.Algorithms.MOCMAEvolutionStrategy-3.3.dll", PluginFileType.Assembly)]
+  [PluginDependency("HeuristicLab.ALGLIB", "3.7")]
+  [PluginDependency("HeuristicLab.Analysis", "3.3")]
+  [PluginDependency("HeuristicLab.Collections", "3.3")]
+  [PluginDependency("HeuristicLab.Common", "3.3")]
+  [PluginDependency("HeuristicLab.Core", "3.3")]
+  [PluginDependency("HeuristicLab.Data", "3.3")]
+  [PluginDependency("HeuristicLab.Encodings.RealVectorEncoding", "3.3")]
+  [PluginDependency("HeuristicLab.Optimization", "3.3")]
+  [PluginDependency("HeuristicLab.Parameters", "3.3")]
+  [PluginDependency("HeuristicLab.Persistence", "3.3")]
+  [PluginDependency("HeuristicLab.Problems.TestFunctions.MultiObjective", "3.3")]
+  [PluginDependency("HeuristicLab.Random", "3.3")]
+  public class HeuristicLabAlgorithmsMOCMAEvolutionStrategyPlugin : PluginBase {
+  }
+}
Index: /trunk/sources/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/Properties/AssemblyInfo.cs.frame
===================================================================
--- /trunk/sources/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/Properties/AssemblyInfo.cs.frame	(revision 15178)
+++ /trunk/sources/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/Properties/AssemblyInfo.cs.frame	(revision 15178)
@@ -0,0 +1,55 @@
+#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.Reflection;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("HeuristicLab.Algorithms.MOCMAEvolutionStrategy")]
+[assembly: AssemblyDescription("HeuristicLab implementation of Multi-Objective CMA Evolution Strategy (MO-CMA-ES)")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("HeuristicLab")]
+[assembly: AssemblyCopyright("(c) 2002-2015 HEAL")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("c27ab3d3-44d4-44e8-a3cd-3cea09d19a8f")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Revision and Build Numbers 
+// by using the '*' as shown below:
+[assembly: AssemblyVersion("3.3.0.0")]
+[assembly: AssemblyFileVersion("3.3.14.$WCREV$")]
