Index: /branches/HeuristicLab.Algorithms.CMAEvolutionStrategy/sources/3.3/CMAEvolutionStrategy - Copy.cs
===================================================================
--- /branches/HeuristicLab.Algorithms.CMAEvolutionStrategy/sources/3.3/CMAEvolutionStrategy - Copy.cs	(revision 13793)
+++ /branches/HeuristicLab.Algorithms.CMAEvolutionStrategy/sources/3.3/CMAEvolutionStrategy - Copy.cs	(revision 13793)
@@ -0,0 +1,682 @@
+﻿#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.Linq;
+using HeuristicLab.Analysis;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.RealVectorEncoding;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Optimization.Operators;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.PluginInfrastructure;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Algorithms.CMAEvolutionStrategy {
+  [Item("CMA Evolution StrategyCopy", "An evolution strategy based on covariance matrix adaptation.")]
+  [StorableClass]
+  public sealed class CMAEvolutionStrategyCopy : HeuristicOptimizationEngineAlgorithm, IStorableContent {
+    public string Filename { get; set; }
+    #region Strings
+    private const string SeedName = "Seed";
+    private const string SetSeedRandomlyName = "SetSeedRandomly";
+    private const string PopulationSizeName = "PopulationSize";
+    private const string InitialIterationsName = "InitialIterations";
+    private const string InitialSigmaName = "InitialSigma";
+    private const string MuName = "Mu";
+    private const string CMAInitializerName = "CMAInitializer";
+    private const string CMAMutatorName = "CMAMutator";
+    private const string CMARecombinatorName = "CMARecombinator";
+    private const string CMAUpdaterName = "CMAUpdater";
+    private const string AnalyzerName = "Analyzer";
+    private const string MaximumGenerationsName = "MaximumGenerations";
+    private const string MaximumEvaluatedSolutionsName = "MaximumEvaluatedSolutions";
+    private const string TargetQualityName = "TargetQuality";
+    private const string MinimumQualityChangeName = "MinimumQualityChange";
+    private const string MinimumQualityHistoryChangeName = "MinimumQualityHistoryChange";
+    private const string MinimumStandardDeviationName = "MinimumStandardDeviation";
+    private const string MaximumStandardDeviationChangeName = "MaximumStandardDeviationChange";
+    #endregion
+
+    #region Problem Properties
+    public override Type ProblemType {
+      get { return typeof(ISingleObjectiveHeuristicOptimizationProblem); }
+    }
+    public new ISingleObjectiveHeuristicOptimizationProblem Problem {
+      get { return (ISingleObjectiveHeuristicOptimizationProblem)base.Problem; }
+      set { base.Problem = value; }
+    }
+    #endregion
+
+    #region Parameter Properties
+    public IValueParameter<MultiAnalyzer> AnalyzerParameter {
+      get { return (IValueParameter<MultiAnalyzer>)Parameters[AnalyzerName]; }
+    }
+    private IFixedValueParameter<IntValue> SeedParameter {
+      get { return (IFixedValueParameter<IntValue>)Parameters[SeedName]; }
+    }
+    private IFixedValueParameter<BoolValue> SetSeedRandomlyParameter {
+      get { return (IFixedValueParameter<BoolValue>)Parameters[SetSeedRandomlyName]; }
+    }
+    private IFixedValueParameter<IntValue> PopulationSizeParameter {
+      get { return (IFixedValueParameter<IntValue>)Parameters[PopulationSizeName]; }
+    }
+    private IFixedValueParameter<IntValue> InitialIterationsParameter {
+      get { return (IFixedValueParameter<IntValue>)Parameters[InitialIterationsName]; }
+    }
+    public IValueParameter<DoubleArray> InitialSigmaParameter {
+      get { return (IValueParameter<DoubleArray>)Parameters[InitialSigmaName]; }
+    }
+    private OptionalValueParameter<IntValue> MuParameter {
+      get { return (OptionalValueParameter<IntValue>)Parameters[MuName]; }
+    }
+    public IConstrainedValueParameter<ICMAInitializer> CMAInitializerParameter {
+      get { return (IConstrainedValueParameter<ICMAInitializer>)Parameters[CMAInitializerName]; }
+    }
+    public IConstrainedValueParameter<ICMAManipulator> CMAMutatorParameter {
+      get { return (IConstrainedValueParameter<ICMAManipulator>)Parameters[CMAMutatorName]; }
+    }
+    public IConstrainedValueParameter<ICMARecombinator> CMARecombinatorParameter {
+      get { return (IConstrainedValueParameter<ICMARecombinator>)Parameters[CMARecombinatorName]; }
+    }
+    public IConstrainedValueParameter<ICMAUpdater> CMAUpdaterParameter {
+      get { return (IConstrainedValueParameter<ICMAUpdater>)Parameters[CMAUpdaterName]; }
+    }
+    private IFixedValueParameter<IntValue> MaximumGenerationsParameter {
+      get { return (IFixedValueParameter<IntValue>)Parameters[MaximumGenerationsName]; }
+    }
+    private IFixedValueParameter<IntValue> MaximumEvaluatedSolutionsParameter {
+      get { return (IFixedValueParameter<IntValue>)Parameters[MaximumEvaluatedSolutionsName]; }
+    }
+    private IFixedValueParameter<DoubleValue> TargetQualityParameter {
+      get { return (IFixedValueParameter<DoubleValue>)Parameters[TargetQualityName]; }
+    }
+    private IFixedValueParameter<DoubleValue> MinimumQualityChangeParameter {
+      get { return (IFixedValueParameter<DoubleValue>)Parameters[MinimumQualityChangeName]; }
+    }
+    private IFixedValueParameter<DoubleValue> MinimumQualityHistoryChangeParameter {
+      get { return (IFixedValueParameter<DoubleValue>)Parameters[MinimumQualityHistoryChangeName]; }
+    }
+    private IFixedValueParameter<DoubleValue> MinimumStandardDeviationParameter {
+      get { return (IFixedValueParameter<DoubleValue>)Parameters[MinimumStandardDeviationName]; }
+    }
+    private IFixedValueParameter<DoubleValue> MaximumStandardDeviationChangeParameter {
+      get { return (IFixedValueParameter<DoubleValue>)Parameters[MaximumStandardDeviationChangeName]; }
+    }
+    #endregion
+
+    #region Properties
+    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 InitialIterations {
+      get { return InitialIterationsParameter.Value.Value; }
+      set { InitialIterationsParameter.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 TargetQuality {
+      get { return TargetQualityParameter.Value.Value; }
+      set { TargetQualityParameter.Value.Value = value; }
+    }
+    public double MinimumQualityChange {
+      get { return MinimumQualityChangeParameter.Value.Value; }
+      set { MinimumQualityChangeParameter.Value.Value = value; }
+    }
+    public double MinimumQualityHistoryChange {
+      get { return MinimumQualityHistoryChangeParameter.Value.Value; }
+      set { MinimumQualityHistoryChangeParameter.Value.Value = value; }
+    }
+    public double MinimumStandardDeviation {
+      get { return MinimumStandardDeviationParameter.Value.Value; }
+      set { MinimumStandardDeviationParameter.Value.Value = value; }
+    }
+    public double MaximumStandardDeviationChange {
+      get { return MaximumStandardDeviationChangeParameter.Value.Value; }
+      set { MaximumStandardDeviationChangeParameter.Value.Value = value; }
+    }
+    public DoubleArray InitialSigma {
+      get { return InitialSigmaParameter.Value; }
+      set { InitialSigmaParameter.Value = value; }
+    }
+    public IntValue Mu {
+      get { return MuParameter.Value; }
+      set { MuParameter.Value = value; }
+    }
+    public ICMAInitializer CMAInitializer {
+      get { return CMAInitializerParameter.Value; }
+      set { CMAInitializerParameter.Value = value; }
+    }
+    public ICMAManipulator CMAMutator {
+      get { return CMAMutatorParameter.Value; }
+      set { CMAMutatorParameter.Value = value; }
+    }
+    public ICMARecombinator CMARecombinator {
+      get { return CMARecombinatorParameter.Value; }
+      set { CMARecombinatorParameter.Value = value; }
+    }
+    public MultiAnalyzer Analyzer {
+      get { return AnalyzerParameter.Value; }
+      set { AnalyzerParameter.Value = value; }
+    }
+    public ICMAUpdater CMAUpdater {
+      get { return CMAUpdaterParameter.Value; }
+      set { CMAUpdaterParameter.Value = value; }
+    }
+
+    private RandomCreator RandomCreator {
+      get { return (RandomCreator)OperatorGraph.InitialOperator; }
+    }
+
+    [Storable]
+    private BestAverageWorstQualityAnalyzer qualityAnalyzer;
+    [Storable]
+    private CMAAnalyzer cmaAnalyzer;
+    [Storable]
+    private Placeholder solutionCreator;
+    [Storable]
+    private Placeholder populationSolutionCreator;
+    [Storable]
+    private Placeholder evaluator;
+    [Storable]
+    private SubScopesSorter sorter;
+    [Storable]
+    private Terminator terminator;
+    #endregion
+
+    [StorableConstructor]
+    private CMAEvolutionStrategyCopy(bool deserializing) : base(deserializing) { }
+    private CMAEvolutionStrategyCopy(CMAEvolutionStrategyCopy original, Cloner cloner)
+      : base(original, cloner) {
+      qualityAnalyzer = cloner.Clone(original.qualityAnalyzer);
+      cmaAnalyzer = cloner.Clone(original.cmaAnalyzer);
+      solutionCreator = cloner.Clone(original.solutionCreator);
+      populationSolutionCreator = cloner.Clone(original.populationSolutionCreator);
+      evaluator = cloner.Clone(original.evaluator);
+      sorter = cloner.Clone(original.sorter);
+      terminator = cloner.Clone(original.terminator);
+      RegisterEventHandlers();
+    }
+    public CMAEvolutionStrategyCopy()
+      : base() {
+      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<IntValue>(InitialIterationsName, "The number of iterations that should be performed with only axis parallel mutation.", new IntValue(0)));
+      Parameters.Add(new FixedValueParameter<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 OptionalValueParameter<IntValue>(MuName, "Optional, the mu best offspring that should be considered for update of the new mean and strategy parameters. If not given it will be automatically calculated."));
+      Parameters.Add(new ConstrainedValueParameter<ICMARecombinator>(CMARecombinatorName, "The operator used to calculate the new mean."));
+      Parameters.Add(new ConstrainedValueParameter<ICMAManipulator>(CMAMutatorName, "The operator used to manipulate a point."));
+      Parameters.Add(new ConstrainedValueParameter<ICMAInitializer>(CMAInitializerName, "The operator that initializes the covariance matrix and strategy parameters."));
+      Parameters.Add(new ConstrainedValueParameter<ICMAUpdater>(CMAUpdaterName, "The operator that updates the covariance matrix and strategy parameters."));
+      Parameters.Add(new ValueParameter<MultiAnalyzer>(AnalyzerName, "The operator used to analyze each generation.", new MultiAnalyzer()));
+      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)));
+      Parameters.Add(new FixedValueParameter<DoubleValue>(TargetQualityName, "(stopFitness) Surpassing this quality value terminates the algorithm.", new DoubleValue(double.NaN)));
+      Parameters.Add(new FixedValueParameter<DoubleValue>(MinimumQualityChangeName, "(stopTolFun) If the range of fitness values is less than a certain value the algorithm terminates (set to 0 or positive value to enable).", new DoubleValue(double.NaN)));
+      Parameters.Add(new FixedValueParameter<DoubleValue>(MinimumQualityHistoryChangeName, "(stopTolFunHist) If the range of fitness values is less than a certain value for a certain time the algorithm terminates (set to 0 or positive to enable).", new DoubleValue(double.NaN)));
+      Parameters.Add(new FixedValueParameter<DoubleValue>(MinimumStandardDeviationName, "(stopTolXFactor) If the standard deviation falls below a certain value the algorithm terminates (set to 0 or positive to enable).", new DoubleValue(double.NaN)));
+      Parameters.Add(new FixedValueParameter<DoubleValue>(MaximumStandardDeviationChangeName, "(stopTolUpXFactor) If the standard deviation changes by a value larger than this parameter the algorithm stops (set to a value > 0 to enable).", new DoubleValue(double.NaN)));
+
+      var randomCreator = new RandomCreator();
+      var variableCreator = new VariableCreator();
+      var resultsCollector = new ResultsCollector();
+      var cmaInitializer = new Placeholder();
+      solutionCreator = new Placeholder();
+      var subScopesCreator = new SubScopesCreator();
+      var ussp1 = new UniformSubScopesProcessor();
+      populationSolutionCreator = new Placeholder();
+      var cmaMutator = new Placeholder();
+      var ussp2 = new UniformSubScopesProcessor();
+      evaluator = new Placeholder();
+      var subScopesCounter = new SubScopesCounter();
+      sorter = new SubScopesSorter();
+      var analyzer = new Placeholder();
+      var cmaRecombinator = new Placeholder();
+      var generationsCounter = new IntCounter();
+      var cmaUpdater = new Placeholder();
+      terminator = new Terminator();
+
+      OperatorGraph.InitialOperator = randomCreator;
+
+      randomCreator.RandomParameter.ActualName = "Random";
+      randomCreator.SeedParameter.ActualName = SeedParameter.Name;
+      randomCreator.SeedParameter.Value = null;
+      randomCreator.SetSeedRandomlyParameter.ActualName = SetSeedRandomlyParameter.Name;
+      randomCreator.SetSeedRandomlyParameter.Value = null;
+      randomCreator.Successor = variableCreator;
+
+      variableCreator.Name = "Initialize Variables";
+      variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("EvaluatedSolutions", new IntValue(0)));
+      variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("Generations", new IntValue(0)));
+      variableCreator.Successor = resultsCollector;
+
+      resultsCollector.CollectedValues.Add(new LookupParameter<IntValue>("EvaluatedSolutions"));
+      resultsCollector.CollectedValues.Add(new LookupParameter<IntValue>("Generations"));
+      resultsCollector.ResultsParameter.ActualName = "Results";
+      resultsCollector.Successor = cmaInitializer;
+
+      cmaInitializer.Name = "Initialize Strategy Parameters";
+      cmaInitializer.OperatorParameter.ActualName = CMAInitializerParameter.Name;
+      cmaInitializer.Successor = subScopesCreator;
+
+      subScopesCreator.NumberOfSubScopesParameter.ActualName = PopulationSizeParameter.Name;
+      subScopesCreator.Successor = ussp1;
+
+      ussp1.Name = "Create population";
+      ussp1.Parallel = new BoolValue(false);
+      ussp1.Operator = populationSolutionCreator;
+      ussp1.Successor = solutionCreator;
+
+      populationSolutionCreator.Name = "Initialize arx";
+      // populationSolutionCreator.OperatorParameter will be wired
+      populationSolutionCreator.Successor = null;
+
+      solutionCreator.Name = "Initialize xmean";
+      // solutionCreator.OperatorParameter will be wired
+      solutionCreator.Successor = cmaMutator;
+
+      cmaMutator.Name = "Sample population";
+      cmaMutator.OperatorParameter.ActualName = CMAMutatorParameter.Name;
+      cmaMutator.Successor = ussp2;
+
+      ussp2.Name = "Evaluate offspring";
+      ussp2.Parallel = new BoolValue(true);
+      ussp2.Operator = evaluator;
+      ussp2.Successor = subScopesCounter;
+
+      evaluator.Name = "Evaluator";
+      // evaluator.OperatorParameter will be wired
+      evaluator.Successor = null;
+
+      subScopesCounter.Name = "Count EvaluatedSolutions";
+      subScopesCounter.AccumulateParameter.Value = new BoolValue(true);
+      subScopesCounter.ValueParameter.ActualName = "EvaluatedSolutions";
+      subScopesCounter.Successor = sorter;
+
+      // sorter.ValueParameter will be wired
+      // sorter.DescendingParameter will be wired
+      sorter.Successor = analyzer;
+
+      analyzer.Name = "Analyzer";
+      analyzer.OperatorParameter.ActualName = AnalyzerParameter.Name;
+      analyzer.Successor = cmaRecombinator;
+
+      cmaRecombinator.Name = "Create new xmean";
+      cmaRecombinator.OperatorParameter.ActualName = CMARecombinatorParameter.Name;
+      cmaRecombinator.Successor = generationsCounter;
+
+      generationsCounter.Name = "Generations++";
+      generationsCounter.IncrementParameter.Value = new IntValue(1);
+      generationsCounter.ValueParameter.ActualName = "Generations";
+      generationsCounter.Successor = cmaUpdater;
+
+      cmaUpdater.Name = "Update distributions";
+      cmaUpdater.OperatorParameter.ActualName = CMAUpdaterParameter.Name;
+      cmaUpdater.Successor = terminator;
+
+      terminator.Continue = cmaMutator;
+      terminator.Terminate = null;
+
+      qualityAnalyzer = new BestAverageWorstQualityAnalyzer();
+      cmaAnalyzer = new CMAAnalyzer();
+
+      InitializeOperators();
+      RegisterEventHandlers();
+      Parameterize();
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new CMAEvolutionStrategyCopy(this, cloner);
+    }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      RegisterEventHandlers();
+    }
+
+    public override void Prepare() {
+      if (Problem != null) base.Prepare();
+    }
+
+    protected override void OnStarted() {
+      if (!(Problem.SolutionCreator is IRealVectorCreator))
+        throw new InvalidOperationException("Problems that do not use RealVectorEncoding cannot be solved by CMA-ES.");
+      base.OnStarted();
+    }
+
+    #region Events
+    protected override void OnProblemChanged() {
+      Problem.Evaluator.QualityParameter.ActualNameChanged += Evaluator_QualityParameter_ActualNameChanged;
+      var creator = Problem.SolutionCreator as IRealVectorCreator;
+      if (creator != null) {
+        creator.RealVectorParameter.ActualNameChanged += RealVectorCreator_Changed;
+        creator.LengthParameter.ActualNameChanged += RealVectorCreator_Changed;
+        creator.LengthParameter.ValueChanged += RealVectorCreator_Changed;
+        creator.BoundsParameter.ActualNameChanged += RealVectorCreator_Changed;
+        creator.BoundsParameter.ValueChanged += RealVectorCreator_Changed;
+      }
+      UpdateOperators();
+      UpdateAnalyzers();
+      Parameterize();
+      base.OnProblemChanged();
+    }
+    protected override void Problem_SolutionCreatorChanged(object sender, EventArgs e) {
+      var creator = Problem.SolutionCreator as IRealVectorCreator;
+      if (creator != null) {
+        creator.RealVectorParameter.ActualNameChanged += RealVectorCreator_Changed;
+        creator.LengthParameter.ActualNameChanged += RealVectorCreator_Changed;
+        creator.LengthParameter.ValueChanged += RealVectorCreator_Changed;
+        creator.BoundsParameter.ActualNameChanged += RealVectorCreator_Changed;
+        creator.BoundsParameter.ValueChanged += RealVectorCreator_Changed;
+      }
+      Parameterize();
+      base.Problem_SolutionCreatorChanged(sender, e);
+    }
+    protected override void Problem_EvaluatorChanged(object sender, EventArgs e) {
+      Problem.Evaluator.QualityParameter.ActualNameChanged += Evaluator_QualityParameter_ActualNameChanged;
+      Parameterize();
+      base.Problem_EvaluatorChanged(sender, e);
+    }
+    protected override void Problem_OperatorsChanged(object sender, EventArgs e) {
+      UpdateOperators();
+      UpdateAnalyzers();
+      Parameterize();
+      base.Problem_OperatorsChanged(sender, e);
+    }
+    private void Evaluator_QualityParameter_ActualNameChanged(object sender, EventArgs e) {
+      Parameterize();
+    }
+    private bool cmaesInitializerSync;
+    private void CMAESInitializerParameter_ValueChanged(object sender, EventArgs e) {
+      if (cmaesInitializerSync) return;
+      UpdateOperators();
+      Parameterize();
+    }
+    private void RealVectorCreator_Changed(object sender, EventArgs e) {
+      Parameterize();
+    }
+    #endregion
+
+    #region Helpers
+    private void RegisterEventHandlers() {
+      CMAInitializerParameter.ValueChanged += CMAESInitializerParameter_ValueChanged;
+      if (Problem != null) {
+        Problem.Evaluator.QualityParameter.ActualNameChanged += Evaluator_QualityParameter_ActualNameChanged;
+        var creator = Problem.SolutionCreator as IRealVectorCreator;
+        if (creator != null) {
+          creator.RealVectorParameter.ActualNameChanged += RealVectorCreator_Changed;
+          creator.LengthParameter.ActualNameChanged += RealVectorCreator_Changed;
+          creator.LengthParameter.ValueChanged += RealVectorCreator_Changed;
+          creator.BoundsParameter.ActualNameChanged += RealVectorCreator_Changed;
+          creator.BoundsParameter.ValueChanged += RealVectorCreator_Changed;
+        }
+      }
+    }
+    private void InitializeOperators() {
+      foreach (var op in ApplicationManager.Manager.GetInstances<ICMAInitializer>())
+        CMAInitializerParameter.ValidValues.Add(op);
+      foreach (var op in ApplicationManager.Manager.GetInstances<ICMAManipulator>().Where(x => x.CMAType == CMAInitializer.CMAType))
+        CMAMutatorParameter.ValidValues.Add(op);
+      foreach (var op in ApplicationManager.Manager.GetInstances<ICMARecombinator>().Where(x => x.CMAType == CMAInitializer.CMAType))
+        CMARecombinatorParameter.ValidValues.Add(op);
+      foreach (var op in ApplicationManager.Manager.GetInstances<ICMAUpdater>().Where(x => x.CMAType == CMAInitializer.CMAType))
+        CMAUpdaterParameter.ValidValues.Add(op);
+    }
+    private void UpdateOperators() {
+      cmaesInitializerSync = true;
+      try {
+        var oldMutator = CMAMutator;
+        var oldRecombinator = CMARecombinator;
+        var oldUpdater = CMAUpdater;
+
+        if (CMAInitializer != null && (oldMutator == null || oldMutator.CMAType != CMAInitializer.CMAType)) {
+          CMAMutatorParameter.ValidValues.Clear();
+          foreach (var op in ApplicationManager.Manager.GetInstances<ICMAManipulator>().Where(x => x.CMAType == CMAInitializer.CMAType))
+            CMAMutatorParameter.ValidValues.Add(op);
+          CMAMutator = CMAMutatorParameter.ValidValues.First();
+        }
+
+        if (CMAInitializer != null && (oldRecombinator == null || oldRecombinator.CMAType != CMAInitializer.CMAType)) {
+          CMARecombinatorParameter.ValidValues.Clear();
+          foreach (var op in ApplicationManager.Manager.GetInstances<ICMARecombinator>().Where(x => x.CMAType == CMAInitializer.CMAType))
+            CMARecombinatorParameter.ValidValues.Add(op);
+          CMARecombinator = CMARecombinatorParameter.ValidValues.First();
+        }
+
+        if (CMAInitializer != null && (oldUpdater == null || oldUpdater.CMAType != CMAInitializer.CMAType)) {
+          CMAUpdaterParameter.ValidValues.Clear();
+          foreach (var op in ApplicationManager.Manager.GetInstances<ICMAUpdater>().Where(x => x.CMAType == CMAInitializer.CMAType))
+            CMAUpdaterParameter.ValidValues.Add(op);
+          CMAUpdater = CMAUpdaterParameter.ValidValues.First();
+        }
+      }
+      finally { cmaesInitializerSync = false; }
+    }
+    private void UpdateAnalyzers() {
+      Analyzer.Operators.Clear();
+      if (Problem != null) {
+        foreach (var analyzer in Problem.Operators.OfType<IAnalyzer>()) {
+          foreach (var param in analyzer.Parameters.OfType<IScopeTreeLookupParameter>())
+            param.Depth = 1;
+          Analyzer.Operators.Add(analyzer, analyzer.EnabledByDefault);
+        }
+      }
+      Analyzer.Operators.Add(qualityAnalyzer, qualityAnalyzer.EnabledByDefault);
+      Analyzer.Operators.Add(cmaAnalyzer, cmaAnalyzer.EnabledByDefault);
+    }
+    private void Parameterize() {
+
+      foreach (var op in CMAInitializerParameter.ValidValues) {
+        op.PopulationSizeParameter.ActualName = PopulationSizeParameter.Name;
+        op.PopulationSizeParameter.Hidden = true;
+        op.MuParameter.ActualName = MuParameter.Name;
+        op.MuParameter.Hidden = true;
+        op.InitialIterationsParameter.Value = null;
+        op.InitialIterationsParameter.ActualName = InitialIterationsParameter.Name;
+        op.InitialIterationsParameter.Hidden = true;
+        op.InitialSigmaParameter.Value = null;
+        op.InitialSigmaParameter.ActualName = InitialSigmaParameter.Name;
+        op.InitialSigmaParameter.Hidden = true;
+
+        op.DimensionParameter.Hidden = false;
+
+        ParameterizeStochasticOperator(op);
+        ParameterizeIterationBasedOperator(op);
+      }
+
+      foreach (var op in CMAMutatorParameter.ValidValues) {
+        op.PopulationSizeParameter.ActualName = PopulationSizeParameter.Name;
+        op.PopulationSizeParameter.Hidden = true;
+
+        op.MeanParameter.Hidden = false;
+        op.BoundsParameter.Hidden = false;
+        op.RealVectorParameter.Hidden = false;
+
+        ParameterizeStochasticOperator(op);
+        ParameterizeIterationBasedOperator(op);
+      }
+
+      foreach (var op in CMARecombinatorParameter.ValidValues) {
+        op.OldMeanParameter.ActualName = "XOld";
+        op.OldMeanParameter.Hidden = true;
+
+        op.OffspringParameter.Hidden = false;
+        op.MeanParameter.Hidden = false;
+
+        ParameterizeStochasticOperator(op);
+        ParameterizeIterationBasedOperator(op);
+      }
+
+      foreach (var op in CMAUpdaterParameter.ValidValues) {
+        op.MaximumEvaluatedSolutionsParameter.ActualName = MaximumEvaluatedSolutionsParameter.Name;
+        op.MaximumEvaluatedSolutionsParameter.Hidden = true;
+        op.OldMeanParameter.ActualName = "XOld";
+        op.OldMeanParameter.Hidden = true;
+
+        op.MeanParameter.Hidden = false;
+        op.OffspringParameter.Hidden = false;
+        op.QualityParameter.Hidden = false;
+
+        ParameterizeStochasticOperator(op);
+        ParameterizeIterationBasedOperator(op);
+      }
+
+      terminator.IterationsParameter.ActualName = "Generations";
+      terminator.MaximumIterationsParameter.ActualName = MaximumGenerationsParameter.Name;
+      terminator.EvaluatedSolutionsParameter.ActualName = "EvaluatedSolutions";
+      terminator.InitialSigmaParameter.ActualName = InitialSigmaParameter.Name;
+      terminator.MaximumEvaluatedSolutionsParameter.ActualName = MaximumEvaluatedSolutionsParameter.Name;
+      terminator.MaximumStandardDeviationChangeParameter.ActualName = MaximumStandardDeviationChangeParameter.Name;
+      terminator.MinimumQualityChangeParameter.ActualName = MinimumQualityChangeParameter.Name;
+      terminator.MinimumQualityHistoryChangeParameter.ActualName = MinimumQualityHistoryChangeParameter.Name;
+      terminator.MinimumStandardDeviationParameter.ActualName = MinimumStandardDeviationParameter.Name;
+      terminator.TargetQualityParameter.ActualName = TargetQualityParameter.Name;
+      if (CMAUpdater != null)
+        terminator.DegenerateStateParameter.ActualName = CMAUpdater.DegenerateStateParameter.ActualName;
+
+      var creator = Problem != null ? (Problem.SolutionCreator as IRealVectorCreator) : null;
+      if (Problem != null && creator != null) {
+
+        solutionCreator.OperatorParameter.ActualName = Problem.SolutionCreatorParameter.Name;
+        #region Backwards compatible code, remove with 3.4
+        if (populationSolutionCreator != null) // BackwardsCompatibility3.3
+          // ONLY REMOVE THE CONDITION
+          populationSolutionCreator.OperatorParameter.ActualName = Problem.SolutionCreatorParameter.Name;
+        #endregion
+        evaluator.OperatorParameter.ActualName = Problem.EvaluatorParameter.Name;
+        sorter.DescendingParameter.ActualName = Problem.MaximizationParameter.Name;
+        sorter.ValueParameter.ActualName = Problem.Evaluator.QualityParameter.ActualName;
+        terminator.MaximizationParameter.ActualName = Problem.MaximizationParameter.Name;
+        terminator.QualityParameter.ActualName = Problem.Evaluator.QualityParameter.Name;
+
+        foreach (var op in CMAInitializerParameter.ValidValues) {
+          if (creator.LengthParameter.Value == null) {
+            op.DimensionParameter.ActualName = creator.LengthParameter.ActualName;
+            op.DimensionParameter.Value = null;
+          } else op.DimensionParameter.Value = creator.LengthParameter.Value;
+          op.DimensionParameter.Hidden = true;
+        }
+
+        foreach (var op in CMAMutatorParameter.ValidValues) {
+          op.MeanParameter.ActualName = creator.RealVectorParameter.ActualName;
+          op.MeanParameter.Hidden = true;
+          if (creator.BoundsParameter.Value == null) {
+            op.BoundsParameter.ActualName = creator.BoundsParameter.ActualName;
+            op.BoundsParameter.Value = null;
+          } else op.BoundsParameter.Value = creator.BoundsParameter.Value;
+          op.BoundsParameter.Hidden = true;
+          op.RealVectorParameter.ActualName = creator.RealVectorParameter.ActualName;
+          op.RealVectorParameter.Depth = 1;
+          op.RealVectorParameter.Hidden = true;
+        }
+
+        foreach (var op in CMARecombinatorParameter.ValidValues) {
+          op.MeanParameter.ActualName = creator.RealVectorParameter.ActualName;
+          op.MeanParameter.Hidden = true;
+          op.OffspringParameter.ActualName = creator.RealVectorParameter.ActualName;
+          op.OffspringParameter.Depth = 1;
+          op.OffspringParameter.Hidden = true;
+        }
+
+        foreach (var op in CMAUpdaterParameter.ValidValues) {
+          op.MeanParameter.ActualName = creator.RealVectorParameter.ActualName;
+          op.MeanParameter.Hidden = true;
+          op.OffspringParameter.ActualName = creator.RealVectorParameter.ActualName;
+          op.OffspringParameter.Depth = 1;
+          op.OffspringParameter.Hidden = true;
+          op.QualityParameter.ActualName = Problem.Evaluator.QualityParameter.ActualName;
+          op.QualityParameter.Hidden = true;
+        }
+
+        foreach (var op in Problem.Operators.OfType<IStochasticOperator>()) {
+          op.RandomParameter.ActualName = RandomCreator.RandomParameter.ActualName;
+          op.RandomParameter.Hidden = true;
+        }
+
+        qualityAnalyzer.MaximizationParameter.ActualName = Problem.MaximizationParameter.Name;
+        qualityAnalyzer.MaximizationParameter.Hidden = true;
+        qualityAnalyzer.QualityParameter.ActualName = Problem.Evaluator.QualityParameter.ActualName;
+        qualityAnalyzer.QualityParameter.Depth = 1;
+        qualityAnalyzer.QualityParameter.Hidden = true;
+        qualityAnalyzer.BestKnownQualityParameter.ActualName = Problem.BestKnownQualityParameter.Name;
+        qualityAnalyzer.BestKnownQualityParameter.Hidden = true;
+
+        cmaAnalyzer.QualityParameter.ActualName = Problem.Evaluator.QualityParameter.ActualName;
+        cmaAnalyzer.QualityParameter.Depth = 1;
+        cmaAnalyzer.QualityParameter.Hidden = true;
+        cmaAnalyzer.MeanParameter.ActualName = creator.RealVectorParameter.ActualName;
+        cmaAnalyzer.MeanParameter.Hidden = true;
+
+        foreach (var op in Problem.Operators.OfType<IIterationBasedOperator>()) {
+          op.IterationsParameter.ActualName = "Generations";
+          op.IterationsParameter.Hidden = true;
+          op.MaximumIterationsParameter.ActualName = MaximumGenerationsParameter.Name;
+          op.MaximumIterationsParameter.Hidden = true;
+        }
+      } else {
+        qualityAnalyzer.MaximizationParameter.Hidden = false;
+        qualityAnalyzer.QualityParameter.Hidden = false;
+        qualityAnalyzer.BestKnownQualityParameter.Hidden = false;
+
+        cmaAnalyzer.MeanParameter.Hidden = false;
+      }
+
+      qualityAnalyzer.ResultsParameter.ActualName = "Results";
+      qualityAnalyzer.ResultsParameter.Hidden = true;
+      cmaAnalyzer.ResultsParameter.ActualName = "Results";
+      cmaAnalyzer.ResultsParameter.Hidden = true;
+    }
+
+    private void ParameterizeStochasticOperator(IOperator op) {
+      var sOp = op as IStochasticOperator;
+      if (sOp != null) sOp.RandomParameter.ActualName = RandomCreator.RandomParameter.ActualName;
+    }
+
+    private void ParameterizeIterationBasedOperator(IOperator op) {
+      var iOp = op as IIterationBasedOperator;
+      if (iOp != null) {
+        iOp.IterationsParameter.ActualName = "Generations";
+        iOp.MaximumIterationsParameter.ActualName = MaximumGenerationsParameter.Name;
+      }
+    }
+    #endregion
+  }
+}
Index: /branches/HeuristicLab.Algorithms.CMAEvolutionStrategy/sources/3.3/CMAEvolutionStrategy.cs
===================================================================
--- /branches/HeuristicLab.Algorithms.CMAEvolutionStrategy/sources/3.3/CMAEvolutionStrategy.cs	(revision 13792)
+++ /branches/HeuristicLab.Algorithms.CMAEvolutionStrategy/sources/3.3/CMAEvolutionStrategy.cs	(revision 13793)
@@ -488,5 +488,6 @@
           CMAUpdater = CMAUpdaterParameter.ValidValues.First();
         }
-      } finally { cmaesInitializerSync = false; }
+      }
+      finally { cmaesInitializerSync = false; }
     }
     private void UpdateAnalyzers() {
Index: /branches/HeuristicLab.Algorithms.CMAEvolutionStrategy/sources/3.3/CMAOperators/CMAUpdater.cs
===================================================================
--- /branches/HeuristicLab.Algorithms.CMAEvolutionStrategy/sources/3.3/CMAOperators/CMAUpdater.cs	(revision 13792)
+++ /branches/HeuristicLab.Algorithms.CMAEvolutionStrategy/sources/3.3/CMAOperators/CMAUpdater.cs	(revision 13793)
@@ -20,4 +20,6 @@
 #endregion
 
+using System;
+using System.Linq;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
@@ -28,6 +30,4 @@
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using System;
-using System.Linq;
 
 namespace HeuristicLab.Algorithms.CMAEvolutionStrategy {
@@ -125,6 +125,7 @@
       if (sp.CC == 0) sp.CC = 4.0 / (N + 4);
       if (sp.MuCov == 0) sp.MuCov = sp.MuEff;
-      if (sp.CCov == 0) sp.CCov = 2.0 / ((N + 1.41) * (N + 1.41) * sp.MuCov)
-                             + (1 - (1.0 / sp.MuCov)) * Math.Min(1, (2 * sp.MuEff - 1) / (sp.MuEff + (N + 2) * (N + 2)));
+      if (sp.CCov == 0)
+        sp.CCov = 2.0 / ((N + 1.41) * (N + 1.41) * sp.MuCov)
+             + (1 - (1.0 / sp.MuCov)) * Math.Min(1, (2 * sp.MuEff - 1) / (sp.MuEff + (N + 2) * (N + 2)));
       if (sp.CCovSep == 0) sp.CCovSep = Math.Min(1, sp.CCov * (N + 1.5) / 3);
       #endregion
@@ -269,5 +270,6 @@
         tred2(N, B, diagD, offdiag);
         tql2(N, diagD, offdiag, B);
-      } catch { result = false; }
+      }
+      catch { result = false; }
 
       return result;
Index: /branches/HeuristicLab.Algorithms.CMAEvolutionStrategy/sources/3.3/HeuristicLab.Algorithms.CMAEvolutionStrategy-3.3.csproj
===================================================================
--- /branches/HeuristicLab.Algorithms.CMAEvolutionStrategy/sources/3.3/HeuristicLab.Algorithms.CMAEvolutionStrategy-3.3.csproj	(revision 13792)
+++ /branches/HeuristicLab.Algorithms.CMAEvolutionStrategy/sources/3.3/HeuristicLab.Algorithms.CMAEvolutionStrategy-3.3.csproj	(revision 13793)
@@ -41,24 +41,26 @@
     <DebugType>full</DebugType>
     <Optimize>false</Optimize>
-    <OutputPath>..\..\bin\</OutputPath>
+    <OutputPath>..\..\..\trunk\sources\bin\</OutputPath>
     <DefineConstants>DEBUG;TRACE</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
-    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
-    <Prefer32Bit>false</Prefer32Bit>
+    <CodeAnalysisRuleSet>BasicCorrectnessRules.ruleset</CodeAnalysisRuleSet>
+    <Prefer32Bit>false</Prefer32Bit>
+    <RunCodeAnalysis>true</RunCodeAnalysis>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
     <DebugType>pdbonly</DebugType>
     <Optimize>true</Optimize>
-    <OutputPath>..\..\bin\</OutputPath>
+    <OutputPath>..\..\..\trunk\sources\bin\</OutputPath>
     <DefineConstants>TRACE</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
-    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
-    <Prefer32Bit>false</Prefer32Bit>
+    <CodeAnalysisRuleSet>BasicCorrectnessRules.ruleset</CodeAnalysisRuleSet>
+    <Prefer32Bit>false</Prefer32Bit>
+    <RunCodeAnalysis>true</RunCodeAnalysis>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x86' ">
     <DebugSymbols>true</DebugSymbols>
-    <OutputPath>..\..\bin\</OutputPath>
+    <OutputPath>..\..\..\trunk\sources\bin\</OutputPath>
     <DefineConstants>DEBUG;TRACE</DefineConstants>
     <DebugType>full</DebugType>
@@ -69,5 +71,5 @@
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">
-    <OutputPath>..\..\bin\</OutputPath>
+    <OutputPath>..\..\..\trunk\sources\bin\</OutputPath>
     <DefineConstants>TRACE</DefineConstants>
     <Optimize>true</Optimize>
@@ -80,5 +82,5 @@
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x64' ">
     <DebugSymbols>true</DebugSymbols>
-    <OutputPath>..\..\bin\</OutputPath>
+    <OutputPath>..\..\..\trunk\sources\bin\</OutputPath>
     <DefineConstants>DEBUG;TRACE</DefineConstants>
     <DebugType>full</DebugType>
@@ -89,5 +91,5 @@
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x64' ">
-    <OutputPath>..\..\bin\</OutputPath>
+    <OutputPath>..\..\..\trunk\sources\bin\</OutputPath>
     <DefineConstants>TRACE</DefineConstants>
     <Optimize>true</Optimize>
@@ -99,4 +101,49 @@
   </PropertyGroup>
   <ItemGroup>
+    <Reference Include="HeuristicLab.Analysis-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Analysis-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Collections-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Collections-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Common-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Common-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Core-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Core-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Data-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Data-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Encodings.RealVectorEncoding-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Encodings.RealVectorEncoding-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Operators-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Operators-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Optimization-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Optimization-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Optimization.Operators-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Optimization.Operators-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Parameters-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Parameters-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Persistence-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Persistence-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.PluginInfrastructure-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.PluginInfrastructure-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Problems.Instances-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Problems.Instances-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Problems.MultiObjectiveTestFunctions-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Problems.MultiObjectiveTestFunctions-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Random-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Random-3.3.dll</HintPath>
+    </Reference>
     <Reference Include="System" />
     <Reference Include="System.Core">
@@ -115,4 +162,5 @@
   <ItemGroup>
     <Compile Include="CMAAnalyzer.cs" />
+    <Compile Include="CMAEvolutionStrategy - Copy.cs" />
     <Compile Include="CMAOperators\CMAInitializer.cs" />
     <Compile Include="CMAOperators\CMALogweightedRecombinator.cs" />
@@ -123,11 +171,13 @@
     <Compile Include="CMAOperators\CMARecombinator.cs" />
     <Compile Include="CMAOperators\CMAUpdater.cs" />
+    <Compile Include="MOCMAES\CrowdingIndicator.cs" />
+    <Compile Include="MOCMAES\IIndicator.cs" />
     <Compile Include="Interfaces\ICMAInitializer.cs" />
     <Compile Include="Interfaces\ICMAManipulator.cs" />
     <Compile Include="Interfaces\ICMARecombinator.cs" />
     <Compile Include="Interfaces\ICMAUpdater.cs" />
+    <Compile Include="CMAEvolutionStrategy.cs" />
+    <Compile Include="MOCMAES\MOCMASEvolutionStrategy.cs" />
     <Compile Include="Plugin.cs" />
-    <Compile Include="Properties\AssemblyInfo.cs" />
-    <Compile Include="CMAEvolutionStrategy.cs" />
     <Compile Include="Terminator.cs" />
   </ItemGroup>
@@ -153,76 +203,4 @@
       <Install>true</Install>
     </BootstrapperPackage>
-  </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.Operators\3.3\HeuristicLab.Operators-3.3.csproj">
-      <Project>{23da7ff4-d5b8-41b6-aa96-f0561d24f3ee}</Project>
-      <Name>HeuristicLab.Operators-3.3</Name>
-      <Private>False</Private>
-    </ProjectReference>
-    <ProjectReference Include="..\..\HeuristicLab.Optimization.Operators\3.3\HeuristicLab.Optimization.Operators-3.3.csproj">
-      <Project>{25087811-f74c-4128-bc86-8324271da13e}</Project>
-      <Name>HeuristicLab.Optimization.Operators-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.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>
-    <ProjectReference Include="..\..\HeuristicLab.Selection\3.3\HeuristicLab.Selection-3.3.csproj">
-      <Project>{2c36cd4f-e5f5-43a4-801a-201ea895fe17}</Project>
-      <Name>HeuristicLab.Selection-3.3</Name>
-      <Private>False</Private>
-    </ProjectReference>
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
Index: /branches/HeuristicLab.Algorithms.CMAEvolutionStrategy/sources/3.3/MOCMAES/CrowdingIndicator.cs
===================================================================
--- /branches/HeuristicLab.Algorithms.CMAEvolutionStrategy/sources/3.3/MOCMAES/CrowdingIndicator.cs	(revision 13793)
+++ /branches/HeuristicLab.Algorithms.CMAEvolutionStrategy/sources/3.3/MOCMAES/CrowdingIndicator.cs	(revision 13793)
@@ -0,0 +1,10 @@
+﻿using System;
+
+namespace HeuristicLab.Algorithms.CMAEvolutionStrategy {
+  class CrowdingIndicator : IIndicator {
+    int IIndicator.leastContributer<R>(R[] front, Func<R, double[]> extractor) {
+
+      throw new NotImplementedException();
+    }
+  }
+}
Index: /branches/HeuristicLab.Algorithms.CMAEvolutionStrategy/sources/3.3/MOCMAES/IIndicator.cs
===================================================================
--- /branches/HeuristicLab.Algorithms.CMAEvolutionStrategy/sources/3.3/MOCMAES/IIndicator.cs	(revision 13793)
+++ /branches/HeuristicLab.Algorithms.CMAEvolutionStrategy/sources/3.3/MOCMAES/IIndicator.cs	(revision 13793)
@@ -0,0 +1,7 @@
+﻿using System;
+
+namespace HeuristicLab.Algorithms.CMAEvolutionStrategy {
+  public interface IIndicator {
+    int leastContributer<R>(R[] front_, Func<R, double[]> extractor);
+  }
+}
Index: /branches/HeuristicLab.Algorithms.CMAEvolutionStrategy/sources/3.3/MOCMAES/MOCMASEvolutionStrategy.cs
===================================================================
--- /branches/HeuristicLab.Algorithms.CMAEvolutionStrategy/sources/3.3/MOCMAES/MOCMASEvolutionStrategy.cs	(revision 13793)
+++ /branches/HeuristicLab.Algorithms.CMAEvolutionStrategy/sources/3.3/MOCMAES/MOCMASEvolutionStrategy.cs	(revision 13793)
@@ -0,0 +1,853 @@
+﻿#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.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.MultiObjectiveTestFunctions;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Algorithms.CMAEvolutionStrategy {
+  [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; }
+    }
+
+    private readonly IRandom random = new MersenneTwister();
+
+
+    #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 InitialIterationsName = "InitialIterations";
+    private const string InitialSigmaName = "InitialSigma";
+    private const string MuName = "Mu";
+    private const string CMAInitializerName = "CMAInitializer";
+    private const string CMAMutatorName = "CMAMutator";
+    private const string CMARecombinatorName = "CMARecombinator";
+    private const string CMAUpdaterName = "CMAUpdater";
+    private const string AnalyzerName = "Analyzer";
+    private const string MaximumGenerationsName = "MaximumGenerations";
+    private const string MaximumEvaluatedSolutionsName = "MaximumEvaluatedSolutions";
+    private const string TargetQualityName = "TargetQuality";
+    private const string MinimumQualityChangeName = "MinimumQualityChange";
+    private const string MinimumQualityHistoryChangeName = "MinimumQualityHistoryChange";
+    private const string MinimumStandardDeviationName = "MinimumStandardDeviation";
+    private const string MaximumStandardDeviationChangeName = "MaximumStandardDeviationChange";
+    #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]; }
+    }
+    public IValueParameter<MultiAnalyzer> AnalyzerParameter {
+      get { return (IValueParameter<MultiAnalyzer>)Parameters[AnalyzerName]; }
+    }
+    private IFixedValueParameter<IntValue> InitialIterationsParameter {
+      get { return (IFixedValueParameter<IntValue>)Parameters[InitialIterationsName]; }
+    }
+    public IValueParameter<DoubleValue> InitialSigmaParameter {
+      get { return (IValueParameter<DoubleValue>)Parameters[InitialSigmaName]; }
+    }
+    private OptionalValueParameter<IntValue> MuParameter {
+      get { return (OptionalValueParameter<IntValue>)Parameters[MuName]; }
+    }
+    public IConstrainedValueParameter<ICMAInitializer> CMAInitializerParameter {
+      get { return (IConstrainedValueParameter<ICMAInitializer>)Parameters[CMAInitializerName]; }
+    }
+    public IConstrainedValueParameter<ICMAManipulator> CMAMutatorParameter {
+      get { return (IConstrainedValueParameter<ICMAManipulator>)Parameters[CMAMutatorName]; }
+    }
+    public IConstrainedValueParameter<ICMARecombinator> CMARecombinatorParameter {
+      get { return (IConstrainedValueParameter<ICMARecombinator>)Parameters[CMARecombinatorName]; }
+    }
+    public IConstrainedValueParameter<ICMAUpdater> CMAUpdaterParameter {
+      get { return (IConstrainedValueParameter<ICMAUpdater>)Parameters[CMAUpdaterName]; }
+    }
+    private IFixedValueParameter<IntValue> MaximumGenerationsParameter {
+      get { return (IFixedValueParameter<IntValue>)Parameters[MaximumGenerationsName]; }
+    }
+    private IFixedValueParameter<IntValue> MaximumEvaluatedSolutionsParameter {
+      get { return (IFixedValueParameter<IntValue>)Parameters[MaximumEvaluatedSolutionsName]; }
+    }
+    private IFixedValueParameter<DoubleValue> TargetQualityParameter {
+      get { return (IFixedValueParameter<DoubleValue>)Parameters[TargetQualityName]; }
+    }
+    private IFixedValueParameter<DoubleValue> MinimumQualityChangeParameter {
+      get { return (IFixedValueParameter<DoubleValue>)Parameters[MinimumQualityChangeName]; }
+    }
+    private IFixedValueParameter<DoubleValue> MinimumQualityHistoryChangeParameter {
+      get { return (IFixedValueParameter<DoubleValue>)Parameters[MinimumQualityHistoryChangeName]; }
+    }
+    private IFixedValueParameter<DoubleValue> MinimumStandardDeviationParameter {
+      get { return (IFixedValueParameter<DoubleValue>)Parameters[MinimumStandardDeviationName]; }
+    }
+    private IFixedValueParameter<DoubleValue> MaximumStandardDeviationChangeParameter {
+      get { return (IFixedValueParameter<DoubleValue>)Parameters[MaximumStandardDeviationChangeName]; }
+    }
+    #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 InitialIterations {
+      get { return InitialIterationsParameter.Value.Value; }
+      set { InitialIterationsParameter.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 TargetQuality {
+      get { return TargetQualityParameter.Value.Value; }
+      set { TargetQualityParameter.Value.Value = value; }
+    }
+    public double MinimumQualityChange {
+      get { return MinimumQualityChangeParameter.Value.Value; }
+      set { MinimumQualityChangeParameter.Value.Value = value; }
+    }
+    public double MinimumQualityHistoryChange {
+      get { return MinimumQualityHistoryChangeParameter.Value.Value; }
+      set { MinimumQualityHistoryChangeParameter.Value.Value = value; }
+    }
+    public double MinimumStandardDeviation {
+      get { return MinimumStandardDeviationParameter.Value.Value; }
+      set { MinimumStandardDeviationParameter.Value.Value = value; }
+    }
+    public double MaximumStandardDeviationChange {
+      get { return MaximumStandardDeviationChangeParameter.Value.Value; }
+      set { MaximumStandardDeviationChangeParameter.Value.Value = value; }
+    }
+    public DoubleValue InitialSigma {
+      get { return InitialSigmaParameter.Value; }
+      set { InitialSigmaParameter.Value = value; }
+    }
+    public IntValue Mu {
+      get { return MuParameter.Value; }
+      set { MuParameter.Value = value; }
+    }
+    public ICMAInitializer CMAInitializer {
+      get { return CMAInitializerParameter.Value; }
+      set { CMAInitializerParameter.Value = value; }
+    }
+    public ICMAManipulator CMAMutator {
+      get { return CMAMutatorParameter.Value; }
+      set { CMAMutatorParameter.Value = value; }
+    }
+    public ICMARecombinator CMARecombinator {
+      get { return CMARecombinatorParameter.Value; }
+      set { CMARecombinatorParameter.Value = value; }
+    }
+    public MultiAnalyzer Analyzer {
+      get { return AnalyzerParameter.Value; }
+      set { AnalyzerParameter.Value = value; }
+    }
+    public ICMAUpdater CMAUpdater {
+      get { return CMAUpdaterParameter.Value; }
+      set { CMAUpdaterParameter.Value = value; }
+    }
+
+    #endregion
+
+    #region ResultsProperties
+    private double ResultsBestQuality {
+      get { return ((DoubleValue)Results["Best Quality"].Value).Value; }
+      set { ((DoubleValue)Results["Best Quality"].Value).Value = value; }
+    }
+
+    private RealVector ResultsBestSolution {
+      get { return (RealVector)Results["Best Solution"].Value; }
+      set { Results["Best Solution"].Value = value; }
+    }
+
+    private int ResultsBestFoundOnEvaluation {
+      get { return ((IntValue)Results["Evaluation Best Solution Was Found"].Value).Value; }
+      set { ((IntValue)Results["Evaluation Best Solution Was Found"].Value).Value = value; }
+    }
+
+    private int ResultsEvaluations {
+      get { return ((IntValue)Results["Evaluations"].Value).Value; }
+      set { ((IntValue)Results["Evaluations"].Value).Value = value; }
+    }
+    private int ResultsIterations {
+      get { return ((IntValue)Results["Iterations"].Value).Value; }
+      set { ((IntValue)Results["Iterations"].Value).Value = value; }
+    }
+
+    private DataTable ResultsQualities {
+      get { return ((DataTable)Results["Qualities"].Value); }
+    }
+    private DataRow ResultsQualitiesBest {
+      get { return ResultsQualities.Rows["Best Quality"]; }
+    }
+
+    private DataRow ResultsQualitiesIteration {
+      get { return ResultsQualities.Rows["Iteration Quality"]; }
+    }
+
+    #endregion
+
+    #region constructors and hlBoilerPlate-code
+    [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);
+    }
+
+    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<IntValue>(InitialIterationsName, "The number of iterations that should be performed with only axis parallel mutation.", new IntValue(0)));
+      Parameters.Add(new FixedValueParameter<DoubleValue>(InitialSigmaName, "The initial sigma can be a single value or a value for each dimension. All values need to be > 0.", new DoubleValue(0.5)));
+      Parameters.Add(new OptionalValueParameter<IntValue>(MuName, "Optional, the mu best offspring that should be considered for update of the new mean and strategy parameters. If not given it will be automatically calculated."));
+      Parameters.Add(new ConstrainedValueParameter<ICMARecombinator>(CMARecombinatorName, "The operator used to calculate the new mean."));
+      Parameters.Add(new ConstrainedValueParameter<ICMAManipulator>(CMAMutatorName, "The operator used to manipulate a point."));
+      Parameters.Add(new ConstrainedValueParameter<ICMAInitializer>(CMAInitializerName, "The operator that initializes the covariance matrix and strategy parameters."));
+      Parameters.Add(new ConstrainedValueParameter<ICMAUpdater>(CMAUpdaterName, "The operator that updates the covariance matrix and strategy parameters."));
+      Parameters.Add(new ValueParameter<MultiAnalyzer>(AnalyzerName, "The operator used to analyze each generation.", new MultiAnalyzer()));
+      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)));
+      Parameters.Add(new FixedValueParameter<DoubleValue>(TargetQualityName, "(stopFitness) Surpassing this quality value terminates the algorithm.", new DoubleValue(double.NaN)));
+      Parameters.Add(new FixedValueParameter<DoubleValue>(MinimumQualityChangeName, "(stopTolFun) If the range of fitness values is less than a certain value the algorithm terminates (set to 0 or positive value to enable).", new DoubleValue(double.NaN)));
+      Parameters.Add(new FixedValueParameter<DoubleValue>(MinimumQualityHistoryChangeName, "(stopTolFunHist) If the range of fitness values is less than a certain value for a certain time the algorithm terminates (set to 0 or positive to enable).", new DoubleValue(double.NaN)));
+      Parameters.Add(new FixedValueParameter<DoubleValue>(MinimumStandardDeviationName, "(stopTolXFactor) If the standard deviation falls below a certain value the algorithm terminates (set to 0 or positive to enable).", new DoubleValue(double.NaN)));
+      Parameters.Add(new FixedValueParameter<DoubleValue>(MaximumStandardDeviationChangeName, "(stopTolUpXFactor) If the standard deviation changes by a value larger than this parameter the algorithm stops (set to a value > 0 to enable).", new DoubleValue(double.NaN)));
+
+    }
+    #endregion
+
+    #region updates 
+    private void updatePopulation(CMAHansenIndividual[] parents) {
+      int[] offspringSucess = new int[solutions.Length];
+      int offspringLength = parents.Length - solutions.Length;
+
+      for (int i = 0; i < offspringLength; i++) {
+        if (parents[i + solutions.Length].selected) {
+          updateAsOffspring(parents[i + solutions.Length]);
+
+          //TODO this may change if more offspring per parent is allowed 
+          offspringSucess[i] += CMAHansenIndividual.success;
+        }
+      }
+      for (int i = 0; i < solutions.Length; i++) {
+        if (parents[i].selected) {
+          updateAsParent(parents[i], offspringSucess[i]);
+        }
+      }
+
+      solutions = new CMAHansenIndividual[solutions.Length];
+      int j = 0;
+      foreach (CMAHansenIndividual ind in parents) {
+        if (ind.selected) {
+          solutions[j++] = ind;
+        }
+      }
+
+    }
+
+    private void updateAsParent(CMAHansenIndividual c, int v) {
+      c.successProbability = (1 - stepSizeLearningRate) * c.successProbability + stepSizeLearningRate * (v == CMAHansenIndividual.success ? 1 : 0);
+      c.sigma *= Math.Exp(1 / stepSizeDampeningFactor * (c.successProbability - targetSuccessProbability) / (1 - targetSuccessProbability));
+      if (v != CMAHansenIndividual.failure) return;
+      if (c.successProbability < successThreshold) {
+        double stepNormSqr = c.getSetpNormSqr();
+        double rate = covarianceMatrixUnlearningRate;
+        if (stepNormSqr > 1 && 1 < covarianceMatrixUnlearningRate * (2 * stepNormSqr - 1)) {
+          rate = 1 / (2 * stepNormSqr - 1);
+        }
+        rankOneUpdate(c, 1 + rate, -rate, c.lastStep);
+
+      } else {
+        roundUpdate(c);
+      }
+
+    }
+
+    private void updateAsOffspring(CMAHansenIndividual c) {
+      c.successProbability = (1 - stepSizeLearningRate) * c.successProbability + stepSizeLearningRate;
+      c.sigma *= Math.Exp(1 / stepSizeDampeningFactor * (c.successProbability - targetSuccessProbability) / (1 - targetSuccessProbability));
+      double evolutionpathUpdateWeight = evolutionPathLearningRate * (2.0 - evolutionPathLearningRate);
+      if (c.successProbability < successThreshold) {
+        c.updateEvolutionPath(1 - evolutionPathLearningRate, evolutionpathUpdateWeight);
+        rankOneUpdate(c, 1 - covarianceMatrixLearningRate, covarianceMatrixLearningRate, c.evolutionPath);
+      } else {
+        roundUpdate(c);
+      }
+    }
+
+    private void rankOneUpdate(CMAHansenIndividual c, double v1, double v2, RealVector lastStep) {
+      c.choleskyUpdate(lastStep, v1, v2);
+    }
+
+    private void roundUpdate(CMAHansenIndividual c) {
+      double evolutionPathUpdateWeight = evolutionPathLearningRate * (2.0 - evolutionPathLearningRate);
+      c.updateEvolutionPath(1 - evolutionPathLearningRate, 0);
+      rankOneUpdate(c, 1 - covarianceMatrixLearningRate + evolutionPathUpdateWeight,
+        covarianceMatrixLearningRate, c.evolutionPath);
+    }
+    #endregion
+
+    #region selection
+
+    private T[] merge<T>(T[] parents, T[] offspring) {
+      T[] merged = new T[parents.Length + offspring.Length];
+      for (int i = 0; i < parents.Length; i++) {
+        merged[i] = parents[i];
+      }
+      for (int i = 0; i < offspring.Length; i++) {
+        merged[i + parents.Length] = offspring[i];
+      }
+      return merged;
+    }
+
+    private void selection(CMAHansenIndividual[] 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
+      int rank = fronts.Count - 1;
+      int popSize = parents.Length;
+      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 worst approximating elements of the last selected front
+      var front_ = fronts[rank];
+      for (; popSize > length; popSize--) {
+        int lc = indicator.leastContributer<CMAHansenIndividual>(front_.ToArray(), x => x.penalizedFitness);   //TODO: This is a battel in its own right to be fought another day
+        front_[lc].selected = false;
+        front_.Swap(lc, front_.Count - 1);
+        fronts.RemoveAt(front_.Count - 1);
+      }
+    }
+    #endregion
+
+    #region penalize Box-Constraints
+    private void penalizeEvaluate(IEnumerable<CMAHansenIndividual> offspring) {
+      foreach (CMAHansenIndividual child in offspring) {
+        penalizeEvaluate(child);
+      }
+    }
+
+    private void penalizeEvaluate(CMAHansenIndividual offspring) {
+      if (isFeasable(offspring.x)) {
+        offspring.fitness = Problem.Evaluate(offspring.x, random);
+        offspring.penalizedFitness = offspring.fitness;
+      } else {
+        RealVector t = closestFeasible(offspring.x);
+        offspring.fitness = Problem.Evaluate(t, random);
+        offspring.penalizedFitness = penalize(offspring.x, t, offspring.fitness);
+      }
+    }
+
+    private double[] penalize(RealVector x, RealVector t, double[] fitness) {
+      double[] d = new double[fitness.Length];
+      double penality = penalize(x, t);
+      for (int i = 0; i < fitness.Length; i++) {
+        d[i] = fitness[i] + penality;
+      }
+      return d;
+    }
+
+    private double penalize(RealVector x, RealVector t) {
+      double sum = 0;
+      for (int i = 0; i < x.Length; i++) {
+        double d = x[i] - t[i];
+        sum += d * d;
+      }
+      return sum;
+    }
+
+    private RealVector closestFeasible(RealVector x) {
+      DoubleMatrix bounds = Problem.Bounds;
+      RealVector r = new RealVector(x.Length);
+      for (int i = 0; i < x.Length; i++) {
+        r[i] = Math.Min(Math.Max(bounds[i, 0], x[i]), bounds[i, 1]);
+      }
+      return r;
+    }
+
+    private bool isFeasable(RealVector offspring) {
+      DoubleMatrix bounds = Problem.Bounds;
+      for (int i = 0; i < offspring.Length; i++) {
+        if (bounds[i, 0] > offspring[i] || offspring[i] > bounds[i, 1]) return false;
+      }
+      return true;
+    }
+
+    #endregion
+
+    #region mutation
+    private CMAHansenIndividual[] generateOffspring() {
+      CMAHansenIndividual[] offspring = new CMAHansenIndividual[PopulationSize];  //TODO this changes if 1,1-ES is replaced with 1,n-ES
+      for (int i = 0; i < offspring.Length; i++) {
+        offspring[i] = new CMAHansenIndividual(solutions[i]);
+        offspring[i].mutate(gauss);
+      }
+      return offspring;
+    }
+    #endregion
+
+    #region initialization
+    private CMAHansenIndividual initializeIndividual(RealVector x) {
+      var zeros = new RealVector(x.Length);
+      var identity = new double[x.Length, x.Length];
+      for (int i = 0; i < x.Length; i++) {
+        identity[i, i] = 1;
+      }
+      return new CMAHansenIndividual(x, targetSuccessProbability, InitialSigma.Value, zeros, identity);
+    }
+
+    private void initSolutions() {
+      for (int i = 0; i < PopulationSize; i++) {
+        RealVector x = null; //TODO get those with magic 
+        solutions[i] = initializeIndividual(x);
+      }
+      penalizeEvaluate(solutions);
+    }
+
+    private void initStrategy() {
+      int lambda = 1;
+      double n = Problem.ProblemSize;
+      indicator = new CrowdingIndicator();
+      gauss = new NormalDistributedRandom(random, 0, 1);
+      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;
+
+    }
+
+    #endregion
+
+    #region analyze
+    private void analyzeSolutions() {
+      //TODO give HyperVolume stuff
+      //Problem.Analyze();   
+
+    }
+
+    #endregion
+
+
+    //MU = populationSize
+    #region mainloop
+    protected override void Run(CancellationToken cancellationToken) {
+      // Set up the algorithm
+      if (SetSeedRandomly) Seed = new System.Random().Next();
+      random.Reset(Seed);
+
+
+      // Set up the results display
+      Results.Add(new Result("Iterations", new IntValue(0)));
+      Results.Add(new Result("Evaluations", new IntValue(0)));
+      var table = new DataTable("Hypervolumes");
+      table.Rows.Add(new DataRow("Best Hypervolumes"));
+      var iterationRows = new DataRow("Iteration Hypervolumes");
+      iterationRows.VisualProperties.LineStyle = DataRowVisualProperties.DataRowLineStyle.Dot;
+      table.Rows.Add(iterationRows);
+      Results.Add(new Result("Hypervolumes", table));
+
+
+      initStrategy();
+      initSolutions();
+
+
+
+      // Loop until iteration limit reached or canceled.
+      for (ResultsIterations = 0; ResultsIterations < MaximumGenerations; ResultsIterations++) {
+
+        try {
+          iterate();
+          cancellationToken.ThrowIfCancellationRequested();
+        }
+        finally {
+        }
+      }
+    }
+
+    protected override void OnExecutionTimeChanged() {
+      base.OnExecutionTimeChanged();
+      if (CancellationTokenSource == null) return;
+      if (MaximumRuntime == -1) return;
+      if (ExecutionTime.TotalSeconds > MaximumRuntime) CancellationTokenSource.Cancel();
+    }
+
+    private void iterate() {
+      CMAHansenIndividual[] offspring = generateOffspring();
+      penalizeEvaluate(offspring);
+      selection(merge(solutions, offspring), solutions.Length);
+      updatePopulation(offspring);
+
+    }
+    #endregion
+
+    #region bernhard properties
+    private NormalDistributedRandom gauss;
+    private CMAHansenIndividual[] solutions;
+    private const double penalizeFactor = 1e-6;
+    private IIndicator indicator;
+
+    private double stepSizeLearningRate; //=cp learning rate in [0,1]
+    private double stepSizeDampeningFactor; //d
+    private double targetSuccessProbability;// p^target_succ
+    private double evolutionPathLearningRate;//cc
+    private double covarianceMatrixLearningRate;//ccov
+    private double covarianceMatrixUnlearningRate;   //from shark
+    private double successThreshold; //ptresh
+    #endregion
+
+    private class CMAHansenIndividual {
+      public static readonly int success = 1;
+      public static readonly int noSuccess = 2;
+      public static readonly int failure = 3;
+
+
+      //Chromosome
+      public RealVector x;
+      public double successProbability;
+      public double sigma;//stepsize
+      public RealVector evolutionPath; // pc
+      public RealVector lastStep;
+      public RealVector lastZ;
+      private double[,] lowerCholesky;
+
+
+      //Phenotype
+      public double[] fitness;
+      public double[] penalizedFitness;
+      public bool selected = true;
+
+      internal double rank;
+
+
+
+      /// <summary>
+      /// 
+      /// </summary>
+      /// <param name="x">has to be 0-vector with correct lenght</param>
+      /// <param name="p_succ">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 CMAHansenIndividual(RealVector x, double p_succ, double sigma, RealVector pc, double[,] C) {
+        this.x = x;
+        this.successProbability = p_succ;
+        this.sigma = sigma;
+        this.evolutionPath = pc;
+        choleskyDecomposition(C);
+      }
+
+      private void choleskyDecomposition(double[,] C) {
+        if (C.GetLength(0) != C.GetLength(1)) throw new ArgumentException("Covariancematrix is not quadratic");
+        int n = C.GetLength(0);
+        lowerCholesky = new double[n, n];
+        double[,] A = lowerCholesky;
+        for (int i = 0; i < n; i++) {
+          for (int j = 0; j <= i; j++) {
+            A[i, j] = C[i, j];   //simulate inplace transform
+            double sum = A[i, j];
+            for (int k = 0; k < j; k++) {
+              sum = sum - A[i, k] * A[j, k];
+              if (i > j) { A[i, j] = sum / A[j, j]; } else if (sum > 0) {
+                A[i, i] = Math.Sqrt(sum);
+              } else {
+                throw new ArgumentException("Covariancematrix is not symetric positiv definit");
+              }
+            }
+          }
+
+        }
+      }
+
+      public CMAHansenIndividual(CMAHansenIndividual other) {
+
+
+        this.successProbability = other.successProbability;
+        this.sigma = other.sigma;
+
+        // no no no make DEEP copies
+        this.x = (RealVector)other.x.Clone();    //This may be ommited
+        this.evolutionPath = (RealVector)other.evolutionPath.Clone();
+        this.lastStep = (RealVector)lastStep.Clone();  //This may be ommited
+        this.lastZ = (RealVector)lastZ.Clone();  //This may be ommited
+
+
+        this.lowerCholesky = (double[,])other.lowerCholesky.Clone();
+      }
+
+      public void updateEvolutionPath(double learningRate, double updateWeight) {
+        updateWeight = Math.Sqrt(updateWeight);
+        for (int i = 0; i < evolutionPath.Length; i++) {
+          evolutionPath[i] *= learningRate;
+          evolutionPath[i] += updateWeight * lastStep[i];
+        }
+      }
+
+      public double getSetpNormSqr() {
+        double sum = 0;
+        foreach (double d in lastZ) {
+          sum += d * d;
+        }
+        return sum;
+      }
+
+      public void choleskyUpdate(RealVector v, double alpha, double beta) {
+        int n = v.Length;
+        double[] temp = new double[n];
+        for (int i = 0; i < n; i++) temp[i] = v[i];
+        double betaPrime = 1;
+        double a = Math.Sqrt(alpha);
+        for (int j = 0; j < n; j++) {
+          double Ljj = a * lowerCholesky[j, j];
+          double dj = Ljj * Ljj;
+          double wj = temp[j];
+          double swj2 = beta * wj * wj;
+          double gamma = dj * betaPrime + swj2;
+          double x = dj + swj2 / betaPrime;
+          if (x < 0.0) throw new ArgumentException("Update makes Covariancematrix indefinite");
+          double nLjj = Math.Sqrt(x);
+          lowerCholesky[j, j] = nLjj;
+          betaPrime += swj2 / dj;
+          if (j + 1 < n) {
+            for (int i = j + 1; i < n; i++) {
+              lowerCholesky[i, j] *= a;
+            }
+            for (int i = j + 1; i < n; i++) {
+              temp[i] = wj / Ljj * lowerCholesky[i, j];
+            }
+            if (gamma == 0) continue;
+            for (int i = j + 1; i < n; i++) {
+              lowerCholesky[i, j] *= nLjj / Ljj;
+            }
+            for (int 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;
+        int n = lastZ.Length;
+        for (int i = 0; i < n; i++) {
+          lastZ[i] = gauss.NextDouble();
+        }
+        //Matrixmultiplication: lastStep = lowerCholesky * lastZ;
+        for (int i = 0; i < n; i++) {
+          double sum = 0;
+          for (int j = 0; j <= i; j++) {
+            sum += lowerCholesky[i, j] * lastZ[j];
+          }
+          lastStep[i] = sum;
+        }
+
+        //add the step to x weighted by stepsize;
+        for (int i = 0; i < x.Length; i++) {
+          x[i] += sigma * lastStep[i];
+        }
+
+      }
+
+    }
+
+    //blatantly stolen form HeuristicLab.Optimization.Operators.FastNonDominatedSort
+    #region FastNonDominatedSort   
+    private enum DominationResult { Dominates, IsDominated, IsNonDominated };
+
+    private List<List<CMAHansenIndividual>> NonDominatedSort(CMAHansenIndividual[] individuals) {
+      bool dominateOnEqualQualities = false;
+      bool[] maximization = Problem.Maximization;
+      if (individuals == null) throw new InvalidOperationException(Name + ": No qualities found.");
+      int populationSize = individuals.Length;
+
+      List<List<CMAHansenIndividual>> fronts = new List<List<CMAHansenIndividual>>();
+      Dictionary<CMAHansenIndividual, List<int>> dominatedScopes = new Dictionary<CMAHansenIndividual, List<int>>();
+      int[] dominationCounter = new int[populationSize];
+      //ItemArray<IntValue> rank = new ItemArray<IntValue>(populationSize);
+
+      for (int pI = 0; pI < populationSize - 1; pI++) {
+        CMAHansenIndividual p = individuals[pI];
+        List<int> dominatedScopesByp;
+        if (!dominatedScopes.TryGetValue(p, out dominatedScopesByp))
+          dominatedScopes[p] = dominatedScopesByp = new List<int>();
+        for (int qI = pI + 1; qI < populationSize; qI++) {
+          DominationResult 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) {
+            //rank[qI] = new IntValue(0);
+            AddToFront(individuals[qI], fronts, 0);
+          }
+        }
+        if (dominationCounter[pI] == 0) {
+          //rank[pI] = new IntValue(0);
+          AddToFront(p, fronts, 0);
+        }
+      }
+      int i = 0;
+      while (i < fronts.Count && fronts[i].Count > 0) {
+        List<CMAHansenIndividual> nextFront = new List<CMAHansenIndividual>();
+        foreach (CMAHansenIndividual p in fronts[i]) {
+          List<int> dominatedScopesByp;
+          if (dominatedScopes.TryGetValue(p, out dominatedScopesByp)) {
+            for (int k = 0; k < dominatedScopesByp.Count; k++) {
+              int dominatedScope = dominatedScopesByp[k];
+              dominationCounter[dominatedScope] -= 1;
+              if (dominationCounter[dominatedScope] == 0) {
+                //rank[dominatedScope] = new IntValue(i + 1);
+                nextFront.Add(individuals[dominatedScope]);
+              }
+            }
+          }
+        }
+        i += 1;
+        fronts.Add(nextFront);
+      }
+
+      //RankParameter.ActualValue = rank;
+
+      //scope.SubScopes.Clear();
+
+      CMAHansenIndividual[] result = new CMAHansenIndividual[individuals.Length];
+      int j = 0;
+
+      for (i = 0; i < fronts.Count; i++) {
+        foreach (var p in fronts[i]) {
+          p.rank = i;
+        }
+      }
+      return fronts;
+    }
+
+
+    private static void AddToFront(CMAHansenIndividual p, List<List<CMAHansenIndividual>> fronts, int i) {
+      if (i == fronts.Count) fronts.Add(new List<CMAHansenIndividual>());
+      fronts[i].Add(p);
+    }
+
+    private static DominationResult Dominates(CMAHansenIndividual left, CMAHansenIndividual right, bool[] maximizations, bool dominateOnEqualQualities) {
+      return Dominates(left.penalizedFitness, right.penalizedFitness, maximizations, dominateOnEqualQualities);
+    }
+
+    private static DominationResult Dominates(double[] left, double[] right, bool[] maximizations, bool dominateOnEqualQualities) {
+      //mkommend Caution: do not use LINQ.SequenceEqual for comparing the two quality arrays (left and right) due to performance reasons
+      if (dominateOnEqualQualities) {
+        var equal = true;
+        for (int i = 0; i < left.Length; i++) {
+          if (left[i] != right[i]) {
+            equal = false;
+            break;
+          }
+        }
+        if (equal) return DominationResult.Dominates;
+      }
+
+      bool leftIsBetter = false, rightIsBetter = false;
+      for (int i = 0; i < left.Length; 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
+  }
+}
Index: /branches/HeuristicLab.Algorithms.CMAEvolutionStrategy/sources/3.4/HeuristicLab.Algorithms.CMAEvolutionStrategy-3.4.csproj
===================================================================
--- /branches/HeuristicLab.Algorithms.CMAEvolutionStrategy/sources/3.4/HeuristicLab.Algorithms.CMAEvolutionStrategy-3.4.csproj	(revision 13792)
+++ /branches/HeuristicLab.Algorithms.CMAEvolutionStrategy/sources/3.4/HeuristicLab.Algorithms.CMAEvolutionStrategy-3.4.csproj	(revision 13793)
@@ -99,8 +99,45 @@
   </PropertyGroup>
   <ItemGroup>
-    <Reference Include="ALGLIB-3.7.0, Version=3.7.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
-      <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\..\bin\ALGLIB-3.7.0.dll</HintPath>
-      <Private>False</Private>
+    <Reference Include="ALGLIB-3.7.0">
+      <HintPath>..\..\..\trunk\sources\bin\ALGLIB-3.7.0.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Analysis-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Analysis-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Collections-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Collections-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Common-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Common-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Core-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Core-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Data-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Data-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Encodings.RealVectorEncoding-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Encodings.RealVectorEncoding-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Operators-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Operators-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Optimization-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Optimization-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Optimization.Operators-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Optimization.Operators-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Parameters-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Parameters-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Persistence-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Persistence-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.PluginInfrastructure-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.PluginInfrastructure-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Random-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Random-3.3.dll</HintPath>
     </Reference>
     <Reference Include="System" />
@@ -132,6 +169,4 @@
     <Compile Include="Interfaces\ICMARecombinator.cs" />
     <Compile Include="Interfaces\ICMAUpdater.cs" />
-    <Compile Include="Plugin.cs" />
-    <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="CMAEvolutionStrategy.cs" />
     <Compile Include="Terminator.cs" />
@@ -158,76 +193,4 @@
       <Install>true</Install>
     </BootstrapperPackage>
-  </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.Operators\3.3\HeuristicLab.Operators-3.3.csproj">
-      <Project>{23da7ff4-d5b8-41b6-aa96-f0561d24f3ee}</Project>
-      <Name>HeuristicLab.Operators-3.3</Name>
-      <Private>False</Private>
-    </ProjectReference>
-    <ProjectReference Include="..\..\HeuristicLab.Optimization.Operators\3.3\HeuristicLab.Optimization.Operators-3.3.csproj">
-      <Project>{25087811-f74c-4128-bc86-8324271da13e}</Project>
-      <Name>HeuristicLab.Optimization.Operators-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.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>
-    <ProjectReference Include="..\..\HeuristicLab.Selection\3.3\HeuristicLab.Selection-3.3.csproj">
-      <Project>{2c36cd4f-e5f5-43a4-801a-201ea895fe17}</Project>
-      <Name>HeuristicLab.Selection-3.3</Name>
-      <Private>False</Private>
-    </ProjectReference>
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
Index: /branches/HeuristicLab.Algorithms.CMAEvolutionStrategy/sources/BernhardCMAES_Soultion/HeuristicLab.Algorithms.MOCMAEvolutionStrategy.csproj
===================================================================
--- /branches/HeuristicLab.Algorithms.CMAEvolutionStrategy/sources/BernhardCMAES_Soultion/HeuristicLab.Algorithms.MOCMAEvolutionStrategy.csproj	(revision 13793)
+++ /branches/HeuristicLab.Algorithms.CMAEvolutionStrategy/sources/BernhardCMAES_Soultion/HeuristicLab.Algorithms.MOCMAEvolutionStrategy.csproj	(revision 13793)
@@ -0,0 +1,112 @@
+﻿<?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>
+    </Reference>
+    <Reference Include="HeuristicLab.Analysis-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Analysis-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Collections-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Collections-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Common-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Common-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Core-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Core-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Core.Views-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Core.Views-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Data-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Data-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Encodings.RealVectorEncoding-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Encodings.RealVectorEncoding-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Operators-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Operators-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Optimization-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Optimization-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Parameters-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Parameters-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Persistence-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Persistence-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.PluginInfrastructure-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.PluginInfrastructure-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Problems.Instances-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Problems.Instances-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Problems.MultiObjectiveTestFunctions-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Problems.MultiObjectiveTestFunctions-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Random-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Random-3.3.dll</HintPath>
+    </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>
+    <Compile Include="Properties\AssemblyInfo.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>
