Index: /branches/MOCMAEvolutionStrategy/Build.cmd
===================================================================
--- /branches/MOCMAEvolutionStrategy/Build.cmd	(revision 14404)
+++ /branches/MOCMAEvolutionStrategy/Build.cmd	(revision 14404)
@@ -0,0 +1,104 @@
+@ECHO OFF
+
+SET CLEANBEFOREBUILD=
+
+SET SELECTED=
+SET CONFIGURATION=
+SET PLATFORM=
+
+IF "%~1"=="" GOTO :prompt_solution
+
+SET SELECTED=%1
+IF NOT EXIST %SELECTED% (
+  ECHO Solution file %SELECTED% could not be found.
+  GOTO :end
+)
+ECHO Building solution %SELECTED% ...
+GOTO :config_selection
+
+:prompt_solution
+SET /A COUNT=0
+FOR /F "tokens=*" %%A IN ('dir /B *.sln') DO (
+  CALL :forloopbody "%%A"
+)
+
+IF "%COUNT%"=="1" (
+  SET SELECTED=%SOLUTIONS.1%
+  ECHO Building %SOLUTIONS.1% as it is the only solution that was found ...
+  GOTO :config_selection
+)
+
+ECHO Found the following solutions:
+FOR /F "tokens=2* delims=.=" %%A IN ('SET SOLUTIONS.') DO ECHO %%A = %%B
+ECHO.
+SET /P SOLUTIONINDEX=Which solution to build? Type the number: 
+
+SET SELECTED=""
+FOR /F "tokens=2* delims=.=" %%A IN ('SET SOLUTIONS.') DO (
+  IF "%%A"=="%SOLUTIONINDEX%" SET SELECTED=%%B
+)
+
+IF %SELECTED%=="" GOTO :eof
+
+:config_selection
+IF "%~2"==""  GOTO :prompt_config
+
+SET CONFIGURATION=%~2
+ECHO Building configuration %CONFIGURATION% ...
+GOTO :platform_selection
+
+:prompt_config
+SET /P CONFIGURATION=Which configuration to build [Release]: 
+IF "%CONFIGURATION%"=="" SET CONFIGURATION=Release
+
+:platform_selection
+IF "%~3"=="" GOTO :prompt_platform
+  
+SET PLATFORM=%~3
+ECHO Building platform %PLATFORM% ...
+GOTO :clean
+
+:prompt_platform
+SET /P PLATFORM=Which platform to build [Any CPU]: 
+IF "%PLATFORM%"=="" SET PLATFORM=Any CPU
+
+:clean
+IF "%~4"=="" GOTO :prompt_clean
+
+SET CLEANBEFOREBUILD=%~4
+GOTO :main
+
+:prompt_clean
+SET /P CLEANBEFOREBUILD=Would you like to clean before building [n]: 
+IF "%CLEANBEFOREBUILD%"=="" SET CLEANBEFOREBUILD=n
+
+:main
+REM First find the path to the msbuild.exe by performing a registry query
+FOR /F "tokens=1,3 delims=	 " %%A IN ('REG QUERY "HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\MSBuild\ToolsVersions\4.0"') DO (
+  IF "%%A"=="MSBuildToolsPath" SET MSBUILDPATH=%%B)
+
+REM Then execute msbuild to clean and build the solution
+REM Disable that msbuild creates a cache file of the solution
+SET MSBuildUseNoSolutionCache=1
+REM Run msbuild to clean and then build
+IF "%CLEANBEFOREBUILD%" NEQ "n" (
+  ECHO Cleaning ...
+  %MSBUILDPATH%msbuild.exe %SELECTED% /target:Clean /p:Configuration="%CONFIGURATION%",Platform="%PLATFORM%" /m:2 /nologo /verbosity:q /clp:ErrorsOnly
+)
+ECHO Building ...
+%MSBUILDPATH%msbuild.exe %SELECTED% /target:Build /p:Configuration="%CONFIGURATION%",Platform="%PLATFORM%" /m:2 /nologo /verbosity:q /clp:ErrorsOnly
+
+ECHO.
+ECHO DONE.
+
+:end
+
+PAUSE
+
+GOTO :eof
+
+REM This workaround is necessary so that COUNT gets reevaluated
+:forloopbody
+SET /A COUNT+=1
+SET SOLUTIONS.%COUNT%=%1
+GOTO :eof
Index: /branches/MOCMAEvolutionStrategy/Clean.cmd
===================================================================
--- /branches/MOCMAEvolutionStrategy/Clean.cmd	(revision 14404)
+++ /branches/MOCMAEvolutionStrategy/Clean.cmd	(revision 14404)
@@ -0,0 +1,30 @@
+@ECHO OFF
+
+ECHO Clean starting...
+
+FOR /F "tokens=*" %%G IN ('DIR /AD /B') DO (
+  FOR /F "tokens=*" %%T IN ('DIR /AD /B %%G') DO (
+    IF EXIST "%%G\%%T\bin" (
+      ECHO Cleaning "bin" in %%G in version %%T ...
+      RMDIR /S /Q "%%G\%%T\bin"
+    )
+    IF EXIST "%%G\%%T\obj" (
+      ECHO Cleaning "obj" in %%G in version %%T ...
+      RMDIR /S /Q "%%G\%%T\obj"
+    )
+  )
+)
+
+IF EXIST bin (
+  ECHO Cleaning "bin" in current directory ...
+  RMDIR /S /Q bin
+)
+
+IF EXIST TestResults (
+  ECHO Cleaning "TestResults" in current directory ...
+  RMDIR /S /Q TestResults
+)
+
+ECHO Clean finished.
+
+PAUSE
Index: /branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy.sln
===================================================================
--- /branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy.sln	(revision 14404)
+++ /branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy.sln	(revision 14404)
@@ -0,0 +1,27 @@
+﻿
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 14
+VisualStudioVersion = 14.0.25420.1
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{4AE74E16-6C2F-46D4-A3DB-5C073DB7C293}"
+	ProjectSection(SolutionItems) = preProject
+		PreBuildEvent.cmd = PreBuildEvent.cmd
+	EndProjectSection
+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
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{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}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{0E2E224F-E9B2-41F3-B510-09183EEBA2AF}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal
Index: /branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/CrowdingIndicator.cs
===================================================================
--- /branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/CrowdingIndicator.cs	(revision 14404)
+++ /branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/CrowdingIndicator.cs	(revision 14404)
@@ -0,0 +1,63 @@
+﻿#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.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.TestFunctions.MultiObjective;
+
+namespace HeuristicLab.Algorithms.MOCMAEvolutionStrategy {
+  [Item("CrowdingIndicator", "Selection of Offspring based on CrowdingDistance")]
+  [StorableClass]
+  internal class CrowdingIndicator : Item, IIndicator {
+
+    public int LeastContributer<TR>(IEnumerable<TR> front, Func<TR, double[]> extractor, MultiObjectiveTestFunctionProblem problem) {
+      var bounds = problem.Bounds;
+      var extracted = front.Select(extractor.Invoke).ToArray();
+      var pointsums = new double[extracted.Length];
+
+      for (var dim = 0; dim < problem.Objectives; dim++) {
+        var arr = extracted.Select(x => x[dim]).ToArray();
+        Array.Sort(arr);
+        var fmax = problem.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++;
+        }
+      }
+      //find min
+      return pointsums.Where(x => !double.IsInfinity(x)).ArgMin();
+    }
+
+    [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() { }
+  }
+}
Index: /branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/HeuristicLab.Algorithms.MOCMAEvolutionStrategy-3.3.csproj
===================================================================
--- /branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/HeuristicLab.Algorithms.MOCMAEvolutionStrategy-3.3.csproj	(revision 14404)
+++ /branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/HeuristicLab.Algorithms.MOCMAEvolutionStrategy-3.3.csproj	(revision 14404)
@@ -0,0 +1,137 @@
+﻿<?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>..\..\..\..\trunk\sources\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>..\..\..\..\trunk\sources\bin\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <LangVersion>5</LangVersion>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="ALGLIB-3.7.0">
+      <HintPath>..\..\..\trunk\sources\bin\ALGLIB-3.7.0.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Analysis-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Analysis-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Collections-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Collections-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Common-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Common-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Core-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Core-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Core.Views-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Core.Views-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Data-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Data-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Encodings.RealVectorEncoding-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Encodings.RealVectorEncoding-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Operators-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Operators-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Optimization-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Optimization-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Parameters-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Parameters-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Persistence-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Persistence-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.PluginInfrastructure-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.PluginInfrastructure-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Problems.Instances-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Problems.Instances-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Problems.TestFunctions.MultiObjective-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Problems.TestFunctions.MultiObjective-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Random-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Random-3.3.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="CrowdingIndicator.cs" />
+    <Compile Include="HypervolumeIndicator.cs" />
+    <Compile Include="IIndicator.cs" />
+    <Compile Include="MocmaesIndividual.cs" />
+    <Compile Include="MocmaesParameters.cs" />
+    <Compile Include="MOCMASEvolutionStrategy.cs" />
+    <Compile Include="Plugin.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="Utilities.cs" />
+  </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: /branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/HeuristicLab.Algorithms.MOCMAEvolutionStrategy.csproj
===================================================================
--- /branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/HeuristicLab.Algorithms.MOCMAEvolutionStrategy.csproj	(revision 14404)
+++ /branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/HeuristicLab.Algorithms.MOCMAEvolutionStrategy.csproj	(revision 14404)
@@ -0,0 +1,142 @@
+﻿<?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.CMAEvolutionStrategy</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>..\..\..\..\trunk\sources\bin\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>..\..\..\..\trunk\sources\bin\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="ALGLIB-3.7.0">
+      <HintPath>..\..\..\trunk\sources\bin\ALGLIB-3.7.0.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Analysis-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Analysis-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Collections-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Collections-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Common-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Common-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Core-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Core-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Core.Views-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Core.Views-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Data-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Data-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Encodings.RealVectorEncoding-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Encodings.RealVectorEncoding-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Operators-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Operators-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Optimization-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Optimization-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Parameters-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Parameters-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Persistence-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Persistence-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.PluginInfrastructure-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.PluginInfrastructure-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Problems.Instances-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Problems.Instances-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Problems.TestFunctions.MultiObjective-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Problems.TestFunctions.MultiObjective-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Random-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Random-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="System" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Xml.Linq" />
+    <Reference Include="System.Data.DataSetExtensions" />
+    <Reference Include="Microsoft.CSharp" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Net.Http" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="Plugin.cs.frame" />
+    <None Include="Properties\AssemblyInfo.cs.frame" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="CrowdingIndicator.cs" />
+    <Compile Include="HypervolumeIndicator.cs" />
+    <Compile Include="IIndicator.cs" />
+    <Compile Include="MOCMASEvolutionStrategy.cs" />
+    <Compile Include="Plugin.cs" />
+    <Compile Include="Utilities.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <Content Include="HeuristicLab.Algorithms.MOCMAEvolutionStrategy.sln" />
+  </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: /branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/HypervolumeIndicator.cs
===================================================================
--- /branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/HypervolumeIndicator.cs	(revision 14404)
+++ /branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/HypervolumeIndicator.cs	(revision 14404)
@@ -0,0 +1,63 @@
+﻿#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.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 {
+
+    public int LeastContributer<TR>(IEnumerable<TR> front, Func<TR, double[]> extractor, MultiObjectiveTestFunctionProblem problem) {
+      var frontArr = front.Select(extractor.Invoke).ToList();
+      var refPoint = BuildReference(frontArr.Concat(new[] { problem.TestFunction.ReferencePoint(problem.Objectives) }), problem.Maximization);
+      var hv = Hypervolume.Calculate(frontArr, refPoint, problem.Maximization);
+      return Enumerable.Range(0, frontArr.Count).Select(i => Contribution(frontArr, i, problem.Maximization, refPoint, hv)).ArgMin();
+    }
+
+    private static double Contribution(IList<double[]> front, int idx, bool[] maximization, double[] refPoint, double hv) {
+      var point = front[idx];
+      front.RemoveAt(idx);
+      var contribution = hv - Hypervolume.Calculate(front, refPoint, maximization);
+      front.Insert(idx, point);
+      return contribution;
+    }
+    private static double[] BuildReference(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;
+    }
+
+    [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() { }
+  }
+}
Index: /branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/IIndicator.cs
===================================================================
--- /branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/IIndicator.cs	(revision 14404)
+++ /branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/IIndicator.cs	(revision 14404)
@@ -0,0 +1,39 @@
+﻿#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 HeuristicLab.Core;
+using HeuristicLab.Problems.TestFunctions.MultiObjective;
+
+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="extractor">some mapping function to map any R to double[]</param>
+    /// <param name="problem">The problem on which the front is evaluated (!! The function itself will NOT be evluated only bounds referencePoints & other metadate will be used</param>
+    /// <returns>the index of the least contributing point according to any type of quality criteria</returns>
+    int LeastContributer<TR>(IEnumerable<TR> front, Func<TR, double[]> extractor, MultiObjectiveTestFunctionProblem problem);
+  }
+}
Index: /branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/MOCMASEvolutionStrategy.cs
===================================================================
--- /branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/MOCMASEvolutionStrategy.cs	(revision 14404)
+++ /branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/MOCMASEvolutionStrategy.cs	(revision 14404)
@@ -0,0 +1,629 @@
+﻿#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.Algorithms.CMAEvolutionStrategy;
+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("MOCMAS Evolution Strategy (MOCMASES)", "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 MOCMASEvolutionStrategy : BasicAlgorithm {
+    public override Type ProblemType
+    {
+      get { return typeof(MultiObjectiveTestFunctionProblem); }
+    }
+    public new MultiObjectiveTestFunctionProblem Problem
+    {
+      get { return (MultiObjectiveTestFunctionProblem)base.Problem; }
+      set { base.Problem = value; }
+    }
+    #region internal variables
+    private readonly IRandom random = new MersenneTwister();
+    private NormalDistributedRandom gauss;
+    private MOCMAESIndividual[] solutions;
+    private MOCMAESParameters internals;
+    #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 SolutionsResultName = "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]; }
+    }
+    private IFixedValueParameter<IntValue> PopulationSizeParameter
+    {
+      get { return (IFixedValueParameter<IntValue>)Parameters[PopulationSizeName]; }
+    }
+    private IFixedValueParameter<IntValue> MaximumGenerationsParameter
+    {
+      get { return (IFixedValueParameter<IntValue>)Parameters[MaximumGenerationsName]; }
+    }
+    private IFixedValueParameter<IntValue> MaximumEvaluatedSolutionsParameter
+    {
+      get { return (IFixedValueParameter<IntValue>)Parameters[MaximumEvaluatedSolutionsName]; }
+    }
+    private IFixedValueParameter<DoubleValue> InitialSigmaParameter
+    {
+      get { return (IFixedValueParameter<DoubleValue>)Parameters[InitialSigmaName]; }
+    }
+    private 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 double InitialSigma
+    {
+      get { return InitialSigmaParameter.Value.Value; }
+      set { InitialSigmaParameter.Value.Value = value; }
+    }
+    public IIndicator Indicator
+    {
+      get { return IndicatorParameter.Value; }
+      set { IndicatorParameter.Value = value; }
+    }
+
+
+    #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[SolutionsResultName].Value); }
+      set { Results[SolutionsResultName].Value = value; }
+    }
+    private ScatterPlotContent ResultsScatterPlot
+    {
+      get { return ((ScatterPlotContent)Results[ScatterPlotResultName].Value); }
+      set { Results[ScatterPlotResultName].Value = value; }
+    }
+    #endregion
+
+    #region Constructors
+    public MOCMASEvolutionStrategy() {
+      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 FixedValueParameter<DoubleValue>(InitialSigmaName, "The initial sigma is a single value > 0.", new DoubleValue(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() };
+      Parameters.Add(new ConstrainedValueParameter<IIndicator>(IndicatorName, "The selection mechanism on non-dominated solutions", set, set.First()));
+    }
+
+    [StorableConstructor]
+    protected MOCMASEvolutionStrategy(bool deserializing) : base(deserializing) { }
+    protected MOCMASEvolutionStrategy(MOCMASEvolutionStrategy original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) { return new MOCMASEvolutionStrategy(this, cloner); }
+    #endregion
+
+    #region Mainloop
+    protected override void Run(CancellationToken cancellationToken) {
+      // Set up the algorithm
+      if (SetSeedRandomly) Seed = new System.Random().Next();
+      random.Reset(Seed);
+      gauss = new NormalDistributedRandom(random, 0, 1);
+
+      InitResults();
+      InitStrategy();
+      InitSolutions();
+      AnalyzeSolutions();
+
+      // Loop until iteration limit reached or canceled.
+      for (ResultsIterations = 1; ResultsIterations < MaximumGenerations; ResultsIterations++) {
+        try {
+          Iterate();
+          cancellationToken.ThrowIfCancellationRequested();
+        }
+        finally {
+          AnalyzeSolutions();
+        }
+      }
+    }
+    private void Iterate() {
+      var offspring = MutateOffspring();
+      PenalizeEvaluate(offspring);
+      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 Initialization
+    private MOCMAESIndividual InitializeIndividual(RealVector x) {
+      var zeros = new RealVector(x.Length);
+      var identity = new double[x.Length, x.Length];
+      for (var i = 0; i < x.Length; i++) identity[i, i] = 1;
+      return new MOCMAESIndividual(x, internals.TargetSuccessProbability, InitialSigma, zeros, identity, internals);
+    }
+    private void InitSolutions() {
+      solutions = new MOCMAESIndividual[PopulationSize];
+      for (var i = 0; i < PopulationSize; i++) {
+        var x = new RealVector(Problem.ProblemSize); // Uniform distibution in all dimensions assumed.
+                                                     // There is the UniformSolutionCreater associated with the Encoding, but it was considered not usable here
+        var bounds = Problem.Bounds;
+        for (var j = 0; j < Problem.ProblemSize; 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);
+    }
+    private void InitStrategy() {
+      const int lambda = 1;
+      double n = Problem.ProblemSize;
+
+      var targetSuccessProbability = 1.0 / (5.0 + Math.Sqrt(lambda) / 2.0);
+      var stepSizeDampeningFactor = 1.0 + n / (2.0 * lambda);
+      var stepSizeLearningRate = targetSuccessProbability * lambda / (2.0 + targetSuccessProbability * lambda);
+      var evolutionPathLearningRate = 2.0 / (n + 2.0);
+      var covarianceMatrixLearningRate = 2.0 / (n * n + 6.0);
+      var covarianceMatrixUnlearningRate = 0.4 / (Math.Pow(n, 1.6) + 1);
+      var successThreshold = 0.44;
+      internals = new MOCMAESParameters(stepSizeLearningRate, stepSizeDampeningFactor, targetSuccessProbability, evolutionPathLearningRate, covarianceMatrixLearningRate, covarianceMatrixUnlearningRate, successThreshold);
+
+    }
+    private void InitResults() {
+      AddResult(IterationsResultName, "The number of gererations evaluated", new IntValue(0));
+      AddResult(EvaluationsResultName, "The number of function evaltions performed", new IntValue(0));
+      AddResult(HypervolumeResultName, "The hypervolume of the current front considering the Referencepoint defined in the Problem", new DoubleValue(0.0));
+      AddResult(BestHypervolumeResultName, "The best hypervolume of the current run considering the Referencepoint defined in the Problem", new DoubleValue(0.0));
+      AddResult(BestKnownHypervolumeResultName, "The best knwon hypervolume considering the Referencepoint defined in the Problem", new DoubleValue(double.NaN));
+      AddResult(DifferenceToBestKnownHypervolumeResultName, "The difference between the current and the best known hypervolume", new DoubleValue(double.NaN));
+      AddResult(GenerationalDistanceResultName, "The generational distance to an optimal pareto front defined in the Problem", new DoubleValue(double.NaN));
+      AddResult(InvertedGenerationalDistanceResultName, "The inverted generational distance to an optimal pareto front defined in the Problem", new DoubleValue(double.NaN));
+      AddResult(CrowdingResultName, "The average crowding value for the current front (excluding infinities)", new DoubleValue(0.0));
+      AddResult(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));
+      AddResult(TimetableResultName, "Different quality meassures in a timeseries", table);
+      AddResult(SolutionsResultName, "The current front", new DoubleMatrix());
+      AddResult(ScatterPlotResultName, "A scatterplot displaying the evaluated solutions and (if available) the analytically optimal front", new ScatterPlotContent(null, null, null, 2));
+
+      if (Problem.BestKnownFront != null) {
+        ResultsBestKnownHypervolume = Hypervolume.Calculate(Utilities.ToArray(Problem.BestKnownFront), Problem.TestFunction.ReferencePoint(Problem.Objectives), Problem.Maximization);
+        ResultsDifferenceBestKnownHypervolume = ResultsBestKnownHypervolume;
+      }
+      ResultsScatterPlot = new ScatterPlotContent(null, null, Utilities.ToArray(Problem.BestKnownFront), Problem.Objectives);
+    }
+    #endregion
+
+    private MOCMAESIndividual[] MutateOffspring() {
+      var offspring = new MOCMAESIndividual[PopulationSize];
+      for (var i = 0; i < PopulationSize; i++) {
+        offspring[i] = new MOCMAESIndividual(solutions[i]);
+        offspring[i].Mutate(gauss);
+      }
+      return offspring;
+    }
+
+    #region Evaluation
+    private void PenalizeEvaluate(IEnumerable<MOCMAESIndividual> offspring) {
+      foreach (var child in offspring) {
+        if (IsFeasable(child.Mean)) {
+          child.Fitness = Evaluate(child.Mean);
+          child.PenalizedFitness = child.Fitness;
+        } else {
+          var t = ClosestFeasible(child.Mean);
+          child.Fitness = Evaluate(t);
+          child.PenalizedFitness = Penalize(child.Mean, t, child.Fitness);
+        }
+      }
+    }
+    private double[] Evaluate(RealVector x) {
+      var res = Problem.Evaluate(x);
+      ResultsEvaluations++;
+      return res;
+    }
+    private static double[] Penalize(RealVector x, RealVector t, IEnumerable<double> fitness) {
+      var penalty = x.Select((t1, i) => t1 - t[i]).Sum(d => d * d);
+      return fitness.Select(v => v + penalty).ToArray();
+    }
+    private RealVector ClosestFeasible(RealVector x) {
+      var bounds = Problem.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.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<MOCMAESIndividual> parents, int length) {
+      //perform a nondominated sort to assign the rank to every element
+      var fronts = NonDominatedSort(parents);
+
+      //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.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];
+      for (; popSize > length; popSize--) {
+        var lc = Indicator.LeastContributer(front1.ToArray(), x => x.PenalizedFitness, Problem);
+        front1[lc].Selected = false;
+        front1.Swap(lc, front1.Count - 1);
+        front1.RemoveAt(front1.Count - 1);
+      }
+    }
+
+    private void UpdatePopulation(IReadOnlyList<MOCMAESIndividual> parents) {
+      var offspringSucess = new int[solutions.Length];
+      var offspringLength = parents.Count - solutions.Length;
+      for (var i = 0; i < offspringLength; i++) {
+        if (!parents[i + solutions.Length].Selected) continue;
+        parents[i + solutions.Length].UpdateAsOffspring();
+        offspringSucess[i] += MOCMAESIndividual.Success;
+      }
+      for (var i = 0; i < solutions.Length; i++) if (parents[i].Selected) parents[i].UpdateAsParent(offspringSucess[i]);
+      solutions = new MOCMAESIndividual[solutions.Length];
+      var j = 0;
+      foreach (var ind in parents) if (ind.Selected) solutions[j++] = ind;
+    }
+
+    #region Analysis
+    private void AnalyzeSolutions() {
+      ResultsScatterPlot = new ScatterPlotContent(solutions.Select(x => x.Fitness).ToArray(),
+          solutions.Select(x => x.Mean.ToArray()).ToArray(),
+          ResultsScatterPlot.ParetoFront,
+          ResultsScatterPlot.Objectives);
+      ResultsSolutions = ToMatrix(solutions.Select(x => x.Mean.ToArray()));
+      AnalyzeQualityIndicators();
+    }
+    private void AnalyzeQualityIndicators() {
+      var front = NonDominatedSelect.GetDominatingVectors(solutions.Select(x => x.Fitness), Problem.TestFunction.ReferencePoint(Problem.Objectives), Problem.Maximization, true).ToArray();
+      var bounds = Problem.Bounds.CloneAsMatrix();
+      ResultsCrowding = Crowding.Calculate(front, bounds);
+      ResultsSpacing = Spacing.Calculate(front);
+      ResultsGenerationalDistance = Problem.BestKnownFront != null ? GenerationalDistance.Calculate(front, Utilities.ToArray(Problem.BestKnownFront), 1) : double.NaN;
+
+      ResultsInvertedGenerationalDistance = Problem.BestKnownFront != null ? InvertedGenerationalDistance.Calculate(front, Utilities.ToArray(Problem.BestKnownFront), 1) : double.NaN;
+
+      ResultsHypervolume = Hypervolume.Calculate(front, Problem.TestFunction.ReferencePoint(Problem.Objectives), Problem.Maximization);
+      ResultsBestHypervolume = Math.Max(ResultsHypervolume, ResultsBestHypervolume);
+      ResultsDifferenceBestKnownHypervolume = ResultsBestKnownHypervolume - ResultsBestHypervolume;
+
+      //Datalines
+      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);
+
+    }
+    #endregion
+
+
+
+    #region Helpers
+    public DoubleMatrix ToMatrix(IEnumerable<double[]> data) {
+      var d2 = data.ToArray();
+      var mat = new DoubleMatrix(d2.Length, d2[0].Length);
+      for (var i = 0; i < mat.Rows; i++) {
+        for (var j = 0; j < mat.Columns; j++) {
+          mat[i, j] = d2[i][j];
+        }
+      }
+      return mat;
+    }
+    private void AddResult<T>(string name1, string desc, T defaultValue) where T : class, IItem {
+      Results.Add(new Result(name1, desc, defaultValue));
+    }
+    //blatantly stolen form HeuristicLab.Optimization.Operators.FastNonDominatedSort
+    //however: Operators.FastNonDominatedSort does not return ranked fronts => rerank after sorting would not be sensible
+    #region FastNonDominatedSort   
+    private enum DominationResult { Dominates, IsDominated, IsNonDominated };
+    private List<List<MOCMAESIndividual>> NonDominatedSort(IReadOnlyList<MOCMAESIndividual> individuals) {
+      const bool dominateOnEqualQualities = false;
+      var maximization = Problem.Maximization;
+      if (individuals == null) throw new InvalidOperationException(Name + ": No qualities found.");
+      var populationSize = individuals.Count;
+
+      var fronts = new List<List<MOCMAESIndividual>>();
+      var dominatedScopes = new Dictionary<MOCMAESIndividual, List<int>>();
+      var dominationCounter = new int[populationSize];
+
+      for (var pI = 0; pI < populationSize - 1; pI++) {
+        var p = individuals[pI];
+        List<int> dominatedScopesByp;
+        if (!dominatedScopes.TryGetValue(p, out dominatedScopesByp))
+          dominatedScopes[p] = dominatedScopesByp = new List<int>();
+        for (var qI = pI + 1; qI < populationSize; qI++) {
+          var test = Dominates(individuals[pI], individuals[qI], maximization, dominateOnEqualQualities);
+          if (test == DominationResult.Dominates) {
+            dominatedScopesByp.Add(qI);
+            dominationCounter[qI] += 1;
+          } else if (test == DominationResult.IsDominated) {
+            dominationCounter[pI] += 1;
+            if (!dominatedScopes.ContainsKey(individuals[qI]))
+              dominatedScopes.Add(individuals[qI], new List<int>());
+            dominatedScopes[individuals[qI]].Add(pI);
+          }
+          if (pI == populationSize - 2
+            && qI == populationSize - 1
+            && dominationCounter[qI] == 0) {
+            AddToFront(individuals[qI], fronts, 0);
+          }
+        }
+        if (dominationCounter[pI] == 0) {
+          AddToFront(p, fronts, 0);
+        }
+      }
+      var i = 0;
+      while (i < fronts.Count && fronts[i].Count > 0) {
+        var nextFront = new List<MOCMAESIndividual>();
+        foreach (var p in fronts[i]) {
+          List<int> dominatedScopesByp;
+          if (!dominatedScopes.TryGetValue(p, out dominatedScopesByp)) continue;
+          foreach (var dominatedScope in dominatedScopesByp) {
+            dominationCounter[dominatedScope] -= 1;
+            if (dominationCounter[dominatedScope] != 0) continue;
+            nextFront.Add(individuals[dominatedScope]);
+          }
+        }
+        i += 1;
+        fronts.Add(nextFront);
+      }
+
+      for (i = 0; i < fronts.Count; i++) {
+        foreach (var p in fronts[i]) {
+          p.Rank = i;
+        }
+      }
+      return fronts;
+    }
+    private static void AddToFront(MOCMAESIndividual p, IList<List<MOCMAESIndividual>> fronts, int i) {
+      if (i == fronts.Count) fronts.Add(new List<MOCMAESIndividual>());
+      fronts[i].Add(p);
+    }
+    private static DominationResult Dominates(MOCMAESIndividual left, MOCMAESIndividual right, bool[] maximizations, bool dominateOnEqualQualities) {
+      return Dominates(left.PenalizedFitness, right.PenalizedFitness, maximizations, dominateOnEqualQualities);
+    }
+    private static DominationResult Dominates(IReadOnlyList<double> left, IReadOnlyList<double> right, IReadOnlyList<bool> maximizations, bool dominateOnEqualQualities) {
+      //mkommend Caution: do not use LINQ.SequenceEqual for comparing the two quality arrays (left and right) due to performance reasons
+      if (dominateOnEqualQualities) {
+        var equal = true;
+        for (var i = 0; i < left.Count; i++) {
+          if (left[i] != right[i]) {
+            equal = false;
+            break;
+          }
+        }
+        if (equal) return DominationResult.Dominates;
+      }
+
+      bool leftIsBetter = false, rightIsBetter = false;
+      for (var i = 0; i < left.Count; i++) {
+        if (IsDominated(left[i], right[i], maximizations[i])) rightIsBetter = true;
+        else if (IsDominated(right[i], left[i], maximizations[i])) leftIsBetter = true;
+        if (leftIsBetter && rightIsBetter) break;
+      }
+
+      if (leftIsBetter && !rightIsBetter) return DominationResult.Dominates;
+      if (!leftIsBetter && rightIsBetter) return DominationResult.IsDominated;
+      return DominationResult.IsNonDominated;
+    }
+    private static bool IsDominated(double left, double right, bool maximization) {
+      return maximization && left < right
+        || !maximization && left > right;
+    }
+    #endregion
+    #endregion
+  }
+}
Index: /branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/MocmaesIndividual.cs
===================================================================
--- /branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/MocmaesIndividual.cs	(revision 14404)
+++ /branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/MocmaesIndividual.cs	(revision 14404)
@@ -0,0 +1,160 @@
+﻿using System;
+using System.Linq;
+using HeuristicLab.Algorithms.MOCMAEvolutionStrategy;
+using HeuristicLab.Common;
+using HeuristicLab.Encodings.RealVectorEncoding;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Algorithms.CMAEvolutionStrategy {
+  internal class MOCMAESIndividual {
+    public const int Success = 1;
+    public const int NoSuccess = 2;
+    public const int Failure = 3;
+
+    //MOCMAES-Params
+    private readonly MOCMAESParameters strategy;
+
+    //Chromosome
+    public RealVector Mean { get; private set; }
+    private double sigma;//stepsize
+    private RealVector evolutionPath; // pc
+    private RealVector lastStep;
+    private RealVector lastZ;
+    private double[,] lowerCholesky;
+
+
+    //Phenotype
+    public double[] Fitness { get; set; }
+    public double[] PenalizedFitness { get; set; }
+    public bool Selected { get; set; }
+    public double Rank { get; set; }
+    public double SuccessProbability { get; set; }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="mean">has to be 0-vector with correct lenght</param>
+    /// <param name="pSucc">has to be ptargetsucc</param>
+    /// <param name="sigma">initialSigma</param>
+    /// <param name="pc">has to be 0-vector with correct lenght</param>
+    /// <param name="c">has to be a symmetric positive definit Covariance matrix</param>
+    public MOCMAESIndividual(RealVector mean, double pSucc, double sigma, RealVector pc, double[,] c, MOCMAESParameters strategy) {
+      Mean = mean;
+      SuccessProbability = pSucc;
+      this.sigma = sigma;
+      evolutionPath = pc;
+      CholeskyDecomposition(c);
+      Selected = true;
+      this.strategy = strategy;
+    }
+
+    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();
+    }
+
+    public MOCMAESIndividual(MOCMAESIndividual 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 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];
+      }
+    }
+
+    public double GetNormSqr() {
+      return lastZ.Sum(d => d * d);
+    }
+
+    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) throw new ArgumentException("Update makes Covariancematrix indefinite");
+        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];
+
+      }
+
+    }
+
+    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(int v) {
+      SuccessProbability = (1 - strategy.StepSizeLearningRate) * SuccessProbability + strategy.StepSizeLearningRate * (v == Success ? 1 : 0);
+      sigma *= Math.Exp(1 / strategy.StepSizeDampeningFactor * (SuccessProbability - strategy.TargetSuccessProbability) / (1 - strategy.TargetSuccessProbability));
+      if (v != Failure) return;
+      if (SuccessProbability < strategy.SuccessThreshold) {
+        var stepNormSqr = GetNormSqr();
+        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();
+      }
+    }
+
+    private void RoundUpdate() {
+      var evolutionPathUpdateWeight = strategy.EvolutionPathLearningRate * (2.0 - strategy.EvolutionPathLearningRate);
+      UpdateEvolutionPath(1 - strategy.EvolutionPathLearningRate, 0);
+      CholeskyUpdate(evolutionPath, 1 - strategy.CovarianceMatrixLearningRate + evolutionPathUpdateWeight, strategy.CovarianceMatrixLearningRate);
+    }
+
+  }
+
+}
Index: /branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/MocmaesParameters.cs
===================================================================
--- /branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/MocmaesParameters.cs	(revision 14404)
+++ /branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/MocmaesParameters.cs	(revision 14404)
@@ -0,0 +1,22 @@
+﻿
+namespace HeuristicLab.Algorithms.MOCMAEvolutionStrategy {
+  internal class MOCMAESParameters {
+    public readonly double StepSizeLearningRate; //=cp learning rate in [0,1]
+    public readonly double StepSizeDampeningFactor; //d
+    public readonly double TargetSuccessProbability;// p^target_succ
+    public readonly double EvolutionPathLearningRate;//cc
+    public readonly double CovarianceMatrixLearningRate;//ccov
+    public readonly double CovarianceMatrixUnlearningRate;   //from shark
+    public readonly double SuccessThreshold; //ptresh
+
+    public MOCMAESParameters(double stepSizeLearningRate, double stepSizeDampeningFactor, double targetSuccessProbability, double evolutionPathLearningRate, double covarianceMatrixLearningRate, double covarianceMatrixUnlearningRate, double successThreshold) {
+      StepSizeLearningRate = stepSizeLearningRate;
+      StepSizeDampeningFactor = stepSizeDampeningFactor;
+      TargetSuccessProbability = targetSuccessProbability;
+      EvolutionPathLearningRate = evolutionPathLearningRate;
+      CovarianceMatrixLearningRate = covarianceMatrixLearningRate;
+      CovarianceMatrixUnlearningRate = covarianceMatrixUnlearningRate;
+      SuccessThreshold = successThreshold;
+    }
+  }
+}
Index: /branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/Plugin.cs.frame
===================================================================
--- /branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/Plugin.cs.frame	(revision 14404)
+++ /branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/Plugin.cs.frame	(revision 14404)
@@ -0,0 +1,48 @@
+#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.Core.Views", "3.3")]
+  [PluginDependency("HeuristicLab.Data", "3.3")]
+  [PluginDependency("HeuristicLab.Encodings.RealVectorEncoding", "3.3")]
+  [PluginDependency("HeuristicLab.Operators", "3.3")]
+  [PluginDependency("HeuristicLab.Optimization", "3.3")]
+  [PluginDependency("HeuristicLab.Optimization.Operators", "3.3")]
+  [PluginDependency("HeuristicLab.Parameters", "3.3")]
+  [PluginDependency("HeuristicLab.Persistence", "3.3")]
+  [PluginDependency("HeuristicLab.Problems.Instances", "3.3")]
+  [PluginDependency("HeuristicLab.Problems.TestFunctions.MultiObjective", "3.3")]
+  [PluginDependency("HeuristicLab.Random", "3.3")]
+  public class HeuristicLabAlgorithmsMOCMAEvolutionStrategyPlugin : PluginBase {
+  }
+}
Index: /branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/Properties/AssemblyInfo.cs.frame
===================================================================
--- /branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/Properties/AssemblyInfo.cs.frame	(revision 14404)
+++ /branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/Properties/AssemblyInfo.cs.frame	(revision 14404)
@@ -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 MOCMA Evolution Strategy (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$")]
Index: /branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/Utilities.cs
===================================================================
--- /branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/Utilities.cs	(revision 14404)
+++ /branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/Utilities.cs	(revision 14404)
@@ -0,0 +1,56 @@
+﻿using System.Collections.Generic;
+using HeuristicLab.Data;
+
+namespace HeuristicLab.Algorithms.MOCMAEvolutionStrategy {
+  internal static class Utilities {
+    internal static double[][] ToArray(DoubleMatrix m) {
+      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;
+    }
+
+    public static int ArgMin<T>(IEnumerable<T> values, IComparer<T> comparer) {
+      var mindex = 0;
+      var min = default(T);
+      var i = 0;
+      foreach (var v in values) {
+        if (mindex < 0 || comparer.Compare(v, min) < 0) {
+          min = v;
+          mindex = i;
+        }
+        i++;
+      }
+      return mindex;
+
+    }
+    public static int ArgMax<T>(IEnumerable<T> values, IComparer<T> comparer) {
+      var mindex = 0;
+      var min = default(T);
+      var i = 0;
+      foreach (var v in values) {
+        if (mindex < 0 || comparer.Compare(v, min) > 0) {
+          min = v;
+          mindex = i;
+        }
+        i++;
+      }
+      return mindex;
+    }
+    private class DoubleComparer : IComparer<double> {
+      public int Compare(double x, double y) {
+        return x.CompareTo(y);
+      }
+    }
+    public static int ArgMax(this IEnumerable<double> values) {
+      return ArgMax(values, new DoubleComparer());
+    }
+    public static int ArgMin(this IEnumerable<double> values) {
+      return ArgMin(values, new DoubleComparer());
+    }
+  }
+}
Index: /branches/MOCMAEvolutionStrategy/PreBuildEvent.cmd
===================================================================
--- /branches/MOCMAEvolutionStrategy/PreBuildEvent.cmd	(revision 14404)
+++ /branches/MOCMAEvolutionStrategy/PreBuildEvent.cmd	(revision 14404)
@@ -0,0 +1,11 @@
+IF EXIST "%ProjectDir%\Properties\AssemblyInfo.cs.frame" SubWCRev "%ProjectDir%\" "%ProjectDir%\Properties\AssemblyInfo.cs.frame" "%ProjectDir%\Properties\AssemblyInfo.cs"
+IF %ERRORLEVEL% NEQ 0 GOTO Error_Handling
+IF EXIST "%ProjectDir%\Plugin.cs.frame" SubWCRev "%ProjectDir%\" "%ProjectDir%\Plugin.cs.frame" "%ProjectDir%\Plugin.cs"
+IF %ERRORLEVEL% NEQ 0 GOTO Error_Handling
+GOTO Done
+
+:Error_Handling
+ECHO There was an error while running subwcrev. Please verify that the *.cs.frame files have been correctly converted to *.cs files, otherwise HeuristicLab won't build. 
+exit 0
+
+:Done
