Index: branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/CMAAnalyzer.cs
===================================================================
--- branches/HeuristicLab.Algorithms.CMAEvolutionStrategy/sources/3.3/CMAAnalyzer.cs	(revision 14269)
+++ 	(revision )
@@ -1,153 +1,0 @@
-﻿#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.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-
-namespace HeuristicLab.Algorithms.CMAEvolutionStrategy {
-  [Item("CMAAnalyzer", "Analyzes the development of strategy parameters and visualizes the performance of CMA-ES.")]
-  [StorableClass]
-  public sealed class CMAAnalyzer : SingleSuccessorOperator, IAnalyzer, ISingleObjectiveOperator {
-
-    public bool EnabledByDefault {
-      get { return false; }
-    }
-
-    #region Parameter Properties
-    public ILookupParameter<CMAParameters> StrategyParametersParameter {
-      get { return (ILookupParameter<CMAParameters>)Parameters["StrategyParameters"]; }
-    }
-
-    public ILookupParameter<RealVector> MeanParameter {
-      get { return (ILookupParameter<RealVector>)Parameters["Mean"]; }
-    }
-
-    public IScopeTreeLookupParameter<DoubleValue> QualityParameter {
-      get { return (IScopeTreeLookupParameter<DoubleValue>)Parameters["Quality"]; }
-    }
-
-    public ILookupParameter<ResultCollection> ResultsParameter {
-      get { return (ILookupParameter<ResultCollection>)Parameters["Results"]; }
-    }
-    #endregion
-
-    [StorableConstructor]
-    private CMAAnalyzer(bool deserializing) : base(deserializing) { }
-    private CMAAnalyzer(CMAAnalyzer original, Cloner cloner) : base(original, cloner) { }
-    public CMAAnalyzer()
-      : base() {
-      Parameters.Add(new LookupParameter<CMAParameters>("StrategyParameters", "The CMA strategy parameters to be analyzed."));
-      Parameters.Add(new LookupParameter<RealVector>("Mean", "The mean real vector that is being optimized."));
-      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Quality", "The qualities of the solutions."));
-      Parameters.Add(new LookupParameter<ResultCollection>("Results", "The collection to store the results in."));
-    }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new CMAAnalyzer(this, cloner);
-    }
-
-    public override IOperation Apply() {
-      var sp = StrategyParametersParameter.ActualValue;
-      var vector = MeanParameter.ActualValue;
-      var results = ResultsParameter.ActualValue;
-      var qualities = QualityParameter.ActualValue;
-      double min = qualities[0].Value, max = qualities[0].Value, avg = qualities[0].Value;
-      for (int i = 1; i < qualities.Length; i++) {
-        if (qualities[i].Value < min) min = qualities[i].Value;
-        if (qualities[i].Value > max) max = qualities[i].Value;
-        avg += qualities[i].Value;
-      }
-      avg /= qualities.Length;
-
-      DataTable progress;
-      if (results.ContainsKey("Progress")) {
-        progress = (DataTable)results["Progress"].Value;
-      } else {
-        progress = new DataTable("Progress");
-        progress.Rows.Add(new DataRow("AxisRatio"));
-        progress.Rows.Add(new DataRow("Sigma"));
-        progress.Rows.Add(new DataRow("Min Quality"));
-        progress.Rows.Add(new DataRow("Max Quality"));
-        progress.Rows.Add(new DataRow("Avg Quality"));
-        progress.VisualProperties.YAxisLogScale = true;
-        results.Add(new Result("Progress", progress));
-      }
-      progress.Rows["AxisRatio"].Values.Add(sp.AxisRatio);
-      progress.Rows["Sigma"].Values.Add(sp.Sigma);
-      progress.Rows["Min Quality"].Values.Add(min);
-      progress.Rows["Max Quality"].Values.Add(max);
-      progress.Rows["Avg Quality"].Values.Add(avg);
-
-      DataTable scaling;
-      if (results.ContainsKey("Scaling")) {
-        scaling = (DataTable)results["Scaling"].Value;
-      } else {
-        scaling = new DataTable("Scaling");
-        scaling.VisualProperties.YAxisLogScale = true;
-        for (int i = 0; i < sp.C.GetLength(0); i++)
-          scaling.Rows.Add(new DataRow("Axis" + i.ToString()));
-        results.Add(new Result("Scaling", scaling));
-      }
-      for (int i = 0; i < sp.C.GetLength(0); i++)
-        scaling.Rows["Axis" + i.ToString()].Values.Add(sp.D[i]);
-
-      DataTable realVector;
-      if (results.ContainsKey("Object Variables")) {
-        realVector = (DataTable)results["Object Variables"].Value;
-      } else {
-        realVector = new DataTable("Object Variables");
-        for (int i = 0; i < vector.Length; i++)
-          realVector.Rows.Add(new DataRow("Axis" + i.ToString()));
-        results.Add(new Result("Object Variables", realVector));
-      }
-      for (int i = 0; i < vector.Length; i++)
-        realVector.Rows["Axis" + i.ToString()].Values.Add(vector[i]);
-
-      DataTable stdDevs;
-      if (results.ContainsKey("Standard Deviations")) {
-        stdDevs = (DataTable)results["Standard Deviations"].Value;
-      } else {
-        stdDevs = new DataTable("Standard Deviations");
-        stdDevs.VisualProperties.YAxisLogScale = true;
-        stdDevs.Rows.Add(new DataRow("MinStdDev"));
-        stdDevs.Rows.Add(new DataRow("MaxStdDev"));
-        for (int i = 0; i < vector.Length; i++)
-          stdDevs.Rows.Add(new DataRow("Axis" + i.ToString()));
-        results.Add(new Result("Standard Deviations", stdDevs));
-      }
-      for (int i = 0; i < vector.Length; i++)
-        stdDevs.Rows["Axis" + i.ToString()].Values.Add(Math.Sqrt(sp.C[i, i]));
-      stdDevs.Rows["MinStdDev"].Values.Add(sp.D.Min() * sp.Sigma);
-      stdDevs.Rows["MaxStdDev"].Values.Add(sp.D.Max() * sp.Sigma);
-
-      return base.Apply();
-    }
-  }
-}
Index: branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/CMAEvolutionStrategy - Copy.cs
===================================================================
--- branches/HeuristicLab.Algorithms.CMAEvolutionStrategy/sources/3.3/CMAEvolutionStrategy - Copy.cs	(revision 14269)
+++ 	(revision )
@@ -1,682 +1,0 @@
-﻿#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/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/CMAEvolutionStrategy.cs
===================================================================
--- branches/HeuristicLab.Algorithms.CMAEvolutionStrategy/sources/3.3/CMAEvolutionStrategy.cs	(revision 14269)
+++ 	(revision )
@@ -1,771 +1,0 @@
-﻿#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 Strateg_y", "An evolution strategy based on covariance matrix adaptation.")]
-    [StorableClass]
-    public sealed class CMAEvolutionStrategy : 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 CMAEvolutionStrategy(bool deserializing) : base(deserializing) { }
-        private CMAEvolutionStrategy(CMAEvolutionStrategy 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 CMAEvolutionStrategy()
-          : 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 CMAEvolutionStrategy(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/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/CMAParameters.cs
===================================================================
--- branches/HeuristicLab.Algorithms.CMAEvolutionStrategy/sources/3.3/CMAParameters.cs	(revision 14269)
+++ 	(revision )
@@ -1,116 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2015 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
- *
- * This file is part of HeuristicLab.
- *
- * HeuristicLab is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * HeuristicLab is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
- */
-#endregion
-
-using System.Collections.Generic;
-using System.Linq;
-using HeuristicLab.Common;
-using HeuristicLab.Core;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-
-namespace HeuristicLab.Algorithms.CMAEvolutionStrategy {
-  [Item("CMAParameters", "CMA-ES controls many strategy parameters that guide the search and which are combined in this class.")]
-  [StorableClass]
-  public sealed class CMAParameters : Item {
-
-    [Storable(Name = "axisRatio")]
-    public double AxisRatio { get; set; }
-    [Storable(Name = "sigma")]
-    public double Sigma { get; set; }
-    [Storable(Name = "sigmaBounds")]
-    public double[,] SigmaBounds { get; set; }
-    [Storable(Name = "mu")]
-    public int Mu { get; set; }
-    [Storable(Name = "weights")]
-    public double[] Weights { get; set; }
-    [Storable(Name = "muEff")]
-    public double MuEff { get; set; }
-    [Storable(Name = "cc")]
-    public double CC { get; set; }
-    [Storable(Name = "cs")]
-    public double CS { get; set; }
-    [Storable(Name = "damps")]
-    public double Damps { get; set; }
-    [Storable(Name = "muCov")]
-    public double MuCov { get; set; }
-    [Storable(Name = "cCov")]
-    public double CCov { get; set; }
-    [Storable(Name = "cCovSep")]
-    public double CCovSep { get; set; }
-    [Storable(Name = "pc")]
-    public double[] PC { get; set; }
-    [Storable(Name = "ps")]
-    public double[] PS { get; set; }
-    [Storable(Name = "b")]
-    public double[,] B { get; set; }
-    [Storable(Name = "d")]
-    public double[] D { get; set; }
-    [Storable(Name = "c")]
-    public double[,] C { get; set; }
-    [Storable(Name = "bDz")]
-    public double[] BDz { get; set; }
-    [Storable(Name = "chiN")]
-    public double ChiN { get; set; }
-    [Storable(Name = "initialIterations")]
-    public int InitialIterations { get; set; }
-    [Storable(Name = "qualityHistory")]
-    private IEnumerable<double> StorableQualityHistory {
-      get { return QualityHistory ?? Enumerable.Empty<double>(); }
-      set { if (value != null) QualityHistory = new Queue<double>(value); }
-    }
-    public Queue<double> QualityHistory { get; set; }
-    [Storable(Name = "qualityHistorySize")]
-    public int QualityHistorySize { get; set; }
-
-    [StorableConstructor]
-    private CMAParameters(bool deserializing) : base(deserializing) { }
-    private CMAParameters(CMAParameters original, Cloner cloner)
-      : base(original, cloner) {
-      this.AxisRatio = original.AxisRatio;
-      if (original.B != null) this.B = (double[,])original.B.Clone();
-      if (original.BDz != null) this.BDz = (double[])original.BDz.Clone();
-      if (original.C != null) this.C = (double[,])original.C.Clone();
-      this.CCov = original.CCov;
-      this.CCovSep = original.CCovSep;
-      this.CC = original.CC;
-      this.ChiN = original.ChiN;
-      this.CS = original.CS;
-      if (original.D != null) this.D = (double[])original.D.Clone();
-      this.Damps = original.Damps;
-      this.InitialIterations = original.InitialIterations;
-      this.Mu = original.Mu;
-      this.MuCov = original.MuCov;
-      this.MuEff = original.MuEff;
-      if (original.PC != null) this.PC = (double[])original.PC.Clone();
-      if (original.PS != null) this.PS = (double[])original.PS.Clone();
-      this.Sigma = original.Sigma;
-      if (original.SigmaBounds != null) this.SigmaBounds = (double[,])original.SigmaBounds.Clone();
-      if (original.Weights != null) this.Weights = (double[])original.Weights.Clone();
-
-      if (original.QualityHistory != null) this.QualityHistory = new Queue<double>(original.QualityHistory);
-      this.QualityHistorySize = original.QualityHistorySize;
-    }
-    public CMAParameters() { }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new CMAParameters(this, cloner);
-    }
-  }
-}
Index: branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/CrowdingIndicator.cs
===================================================================
--- branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/CrowdingIndicator.cs	(revision 14404)
+++ branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/CrowdingIndicator.cs	(revision 14404)
@@ -0,0 +1,63 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.TestFunctions.MultiObjective;
+
+namespace HeuristicLab.Algorithms.MOCMAEvolutionStrategy {
+  [Item("CrowdingIndicator", "Selection of Offspring based on CrowdingDistance")]
+  [StorableClass]
+  internal class CrowdingIndicator : Item, IIndicator {
+
+    public int LeastContributer<TR>(IEnumerable<TR> front, Func<TR, double[]> extractor, MultiObjectiveTestFunctionProblem problem) {
+      var bounds = problem.Bounds;
+      var extracted = front.Select(extractor.Invoke).ToArray();
+      var pointsums = new double[extracted.Length];
+
+      for (var dim = 0; dim < problem.Objectives; dim++) {
+        var arr = extracted.Select(x => x[dim]).ToArray();
+        Array.Sort(arr);
+        var fmax = problem.Bounds[dim % bounds.Rows, 1];
+        var fmin = bounds[dim % bounds.Rows, 0];
+        var pointIdx = 0;
+        foreach (var point in extracted) {
+          var pos = Array.BinarySearch(arr, point[dim]);
+          var d = pos != 0 && pos != arr.Length - 1 ? (arr[pos + 1] - arr[pos - 1]) / (fmax - fmin) : double.PositiveInfinity;
+          pointsums[pointIdx] += d;
+          pointIdx++;
+        }
+      }
+      //find min
+      return pointsums.Where(x => !double.IsInfinity(x)).ArgMin();
+    }
+
+    [StorableConstructor]
+    protected CrowdingIndicator(bool deserializing) : base(deserializing) { }
+    protected CrowdingIndicator(CrowdingIndicator original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) { return new CrowdingIndicator(this, cloner); }
+    public CrowdingIndicator() { }
+  }
+}
Index: branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/HeuristicLab.Algorithms.CMAEvolutionStrategy-3.3.csproj
===================================================================
--- branches/HeuristicLab.Algorithms.CMAEvolutionStrategy/sources/3.3/HeuristicLab.Algorithms.CMAEvolutionStrategy-3.3.csproj	(revision 14269)
+++ 	(revision )
@@ -1,226 +1,0 @@
-﻿<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProductVersion>9.0.30729</ProductVersion>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{5E516C4F-9935-437F-8B15-ECEF4451744E}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <RootNamespace>HeuristicLab.Algorithms.CMAEvolutionStrategy</RootNamespace>
-    <AssemblyName>HeuristicLab.Algorithms.CMAEvolutionStrategy-3.3</AssemblyName>
-    <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
-    <TargetFrameworkProfile>
-    </TargetFrameworkProfile>
-    <FileAlignment>512</FileAlignment>
-    <SignAssembly>true</SignAssembly>
-    <AssemblyOriginatorKeyFile>HeuristicLab.snk</AssemblyOriginatorKeyFile>
-    <FileUpgradeFlags>
-    </FileUpgradeFlags>
-    <OldToolsVersion>3.5</OldToolsVersion>
-    <UpgradeBackupLocation />
-    <PublishUrl>publish\</PublishUrl>
-    <Install>true</Install>
-    <InstallFrom>Disk</InstallFrom>
-    <UpdateEnabled>false</UpdateEnabled>
-    <UpdateMode>Foreground</UpdateMode>
-    <UpdateInterval>7</UpdateInterval>
-    <UpdateIntervalUnits>Days</UpdateIntervalUnits>
-    <UpdatePeriodically>false</UpdatePeriodically>
-    <UpdateRequired>false</UpdateRequired>
-    <MapFileExtensions>true</MapFileExtensions>
-    <ApplicationRevision>0</ApplicationRevision>
-    <ApplicationVersion>1.0.0.%2a</ApplicationVersion>
-    <IsWebBootstrapper>false</IsWebBootstrapper>
-    <UseApplicationTrust>false</UseApplicationTrust>
-    <BootstrapperEnabled>true</BootstrapperEnabled>
-  </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>
-    <CodeAnalysisRuleSet>BasicCorrectnessRules.ruleset</CodeAnalysisRuleSet>
-    <Prefer32Bit>false</Prefer32Bit>
-    <RunCodeAnalysis>true</RunCodeAnalysis>
-  </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>
-    <CodeAnalysisRuleSet>BasicCorrectnessRules.ruleset</CodeAnalysisRuleSet>
-    <Prefer32Bit>false</Prefer32Bit>
-    <RunCodeAnalysis>true</RunCodeAnalysis>
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x86' ">
-    <DebugSymbols>true</DebugSymbols>
-    <OutputPath>..\..\..\trunk\sources\bin\</OutputPath>
-    <DefineConstants>DEBUG;TRACE</DefineConstants>
-    <DebugType>full</DebugType>
-    <PlatformTarget>x86</PlatformTarget>
-    <ErrorReport>prompt</ErrorReport>
-    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
-    <Prefer32Bit>false</Prefer32Bit>
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">
-    <OutputPath>..\..\..\trunk\sources\bin\</OutputPath>
-    <DefineConstants>TRACE</DefineConstants>
-    <Optimize>true</Optimize>
-    <DebugType>pdbonly</DebugType>
-    <PlatformTarget>x86</PlatformTarget>
-    <ErrorReport>prompt</ErrorReport>
-    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
-    <Prefer32Bit>false</Prefer32Bit>
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x64' ">
-    <DebugSymbols>true</DebugSymbols>
-    <OutputPath>..\..\..\trunk\sources\bin\</OutputPath>
-    <DefineConstants>DEBUG;TRACE</DefineConstants>
-    <DebugType>full</DebugType>
-    <PlatformTarget>x64</PlatformTarget>
-    <ErrorReport>prompt</ErrorReport>
-    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
-    <Prefer32Bit>false</Prefer32Bit>
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x64' ">
-    <OutputPath>..\..\..\trunk\sources\bin\</OutputPath>
-    <DefineConstants>TRACE</DefineConstants>
-    <Optimize>true</Optimize>
-    <DebugType>pdbonly</DebugType>
-    <PlatformTarget>x64</PlatformTarget>
-    <ErrorReport>prompt</ErrorReport>
-    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
-    <Prefer32Bit>false</Prefer32Bit>
-  </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">
-      <RequiredTargetFramework>3.5</RequiredTargetFramework>
-    </Reference>
-    <Reference Include="System.Drawing" />
-    <Reference Include="System.Xml.Linq">
-      <RequiredTargetFramework>3.5</RequiredTargetFramework>
-    </Reference>
-    <Reference Include="System.Data.DataSetExtensions">
-      <RequiredTargetFramework>3.5</RequiredTargetFramework>
-    </Reference>
-    <Reference Include="System.Data" />
-    <Reference Include="System.Xml" />
-  </ItemGroup>
-  <ItemGroup>
-    <Compile Include="CMAAnalyzer.cs" />
-    <Compile Include="CMAEvolutionStrategy - Copy.cs" />
-    <Compile Include="CMAOperators\CMAInitializer.cs" />
-    <Compile Include="CMAOperators\CMALogweightedRecombinator.cs" />
-    <Compile Include="CMAOperators\CMAMutator.cs" />
-    <Compile Include="CMAOperators\CMALinearweightedRecombinator.cs" />
-    <Compile Include="CMAOperators\CMAEqualweightedRecombinator.cs" />
-    <Compile Include="CMAParameters.cs" />
-    <Compile Include="CMAOperators\CMARecombinator.cs" />
-    <Compile Include="CMAOperators\CMAUpdater.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="Plugin.cs" />
-    <Compile Include="Terminator.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="HeuristicLab.snk" />
-    <None Include="Plugin.cs.frame" />
-    <None Include="Properties\AssemblyInfo.cs.frame" />
-  </ItemGroup>
-  <ItemGroup>
-    <BootstrapperPackage Include="Microsoft.Net.Client.3.5">
-      <Visible>False</Visible>
-      <ProductName>.NET Framework 3.5 SP1 Client Profile</ProductName>
-      <Install>false</Install>
-    </BootstrapperPackage>
-    <BootstrapperPackage Include="Microsoft.Net.Framework.3.5.SP1">
-      <Visible>False</Visible>
-      <ProductName>.NET Framework 3.5 SP1</ProductName>
-      <Install>true</Install>
-    </BootstrapperPackage>
-    <BootstrapperPackage Include="Microsoft.Windows.Installer.3.1">
-      <Visible>False</Visible>
-      <ProductName>Windows Installer 3.1</ProductName>
-      <Install>true</Install>
-    </BootstrapperPackage>
-  </ItemGroup>
-  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
-  <!-- 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>
-  -->
-  <PropertyGroup>
-    <PreBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">set Path=%25Path%25;$(ProjectDir);$(SolutionDir)
-set ProjectDir=$(ProjectDir)
-set SolutionDir=$(SolutionDir)
-set Outdir=$(Outdir)
-
-call PreBuildEvent.cmd
-</PreBuildEvent>
-    <PreBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
-export ProjectDir=$(ProjectDir)
-export SolutionDir=$(SolutionDir)
-
-$SolutionDir/PreBuildEvent.sh
-</PreBuildEvent>
-  </PropertyGroup>
-</Project>
Index: branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/HeuristicLab.Algorithms.MOCMAEvolutionStrategy-3.3.csproj
===================================================================
--- branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/HeuristicLab.Algorithms.MOCMAEvolutionStrategy-3.3.csproj	(revision 14404)
+++ branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/HeuristicLab.Algorithms.MOCMAEvolutionStrategy-3.3.csproj	(revision 14404)
@@ -0,0 +1,137 @@
+﻿<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProjectGuid>{0E2E224F-E9B2-41F3-B510-09183EEBA2AF}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>HeuristicLab.Algorithms.MOCMAEvolutionStrategy</RootNamespace>
+    <AssemblyName>HeuristicLab.Algorithms.MOCMAEvolutionStrategy-3.3</AssemblyName>
+    <TargetFrameworkVersion>v4.5.2</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>..\..\..\..\trunk\sources\bin\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <LangVersion>5</LangVersion>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>..\..\..\..\trunk\sources\bin\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <LangVersion>5</LangVersion>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="ALGLIB-3.7.0">
+      <HintPath>..\..\..\trunk\sources\bin\ALGLIB-3.7.0.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Analysis-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Analysis-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Collections-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Collections-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Common-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Common-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Core-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Core-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Core.Views-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Core.Views-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Data-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Data-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Encodings.RealVectorEncoding-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Encodings.RealVectorEncoding-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Operators-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Operators-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Optimization-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Optimization-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Parameters-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Parameters-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Persistence-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Persistence-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.PluginInfrastructure-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.PluginInfrastructure-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Problems.Instances-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Problems.Instances-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Problems.TestFunctions.MultiObjective-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Problems.TestFunctions.MultiObjective-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Random-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Random-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="System" />
+    <Reference Include="System.Core" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="Plugin.cs.frame" />
+    <None Include="Properties\AssemblyInfo.cs.frame" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="CrowdingIndicator.cs" />
+    <Compile Include="HypervolumeIndicator.cs" />
+    <Compile Include="IIndicator.cs" />
+    <Compile Include="MocmaesIndividual.cs" />
+    <Compile Include="MocmaesParameters.cs" />
+    <Compile Include="MOCMASEvolutionStrategy.cs" />
+    <Compile Include="Plugin.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="Utilities.cs" />
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <PropertyGroup>
+    <PreBuildEvent>set Path=%25Path%25;$(ProjectDir);$(SolutionDir)
+set ProjectDir=$(ProjectDir)
+set SolutionDir=$(SolutionDir)
+set Outdir=$(Outdir)
+
+call PreBuildEvent.cmd
+
+
+</PreBuildEvent>
+  </PropertyGroup>
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+</Project>
Index: branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/HeuristicLab.Algorithms.MOCMAEvolutionStrategy.csproj
===================================================================
--- branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/HeuristicLab.Algorithms.MOCMAEvolutionStrategy.csproj	(revision 14404)
+++ branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/HeuristicLab.Algorithms.MOCMAEvolutionStrategy.csproj	(revision 14404)
@@ -0,0 +1,142 @@
+﻿<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProjectGuid>{0E2E224F-E9B2-41F3-B510-09183EEBA2AF}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>HeuristicLab.Algorithms.CMAEvolutionStrategy</RootNamespace>
+    <AssemblyName>HeuristicLab.Algorithms.MOCMAEvolutionStrategy-3.3</AssemblyName>
+    <TargetFrameworkVersion>v4.5.2</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>..\..\..\..\trunk\sources\bin\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>..\..\..\..\trunk\sources\bin\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="ALGLIB-3.7.0">
+      <HintPath>..\..\..\trunk\sources\bin\ALGLIB-3.7.0.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Analysis-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Analysis-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Collections-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Collections-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Common-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Common-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Core-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Core-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Core.Views-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Core.Views-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Data-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Data-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Encodings.RealVectorEncoding-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Encodings.RealVectorEncoding-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Operators-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Operators-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Optimization-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Optimization-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Parameters-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Parameters-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Persistence-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Persistence-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.PluginInfrastructure-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.PluginInfrastructure-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Problems.Instances-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Problems.Instances-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Problems.TestFunctions.MultiObjective-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Problems.TestFunctions.MultiObjective-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Random-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Random-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="System" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Xml.Linq" />
+    <Reference Include="System.Data.DataSetExtensions" />
+    <Reference Include="Microsoft.CSharp" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Net.Http" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="Plugin.cs.frame" />
+    <None Include="Properties\AssemblyInfo.cs.frame" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="CrowdingIndicator.cs" />
+    <Compile Include="HypervolumeIndicator.cs" />
+    <Compile Include="IIndicator.cs" />
+    <Compile Include="MOCMASEvolutionStrategy.cs" />
+    <Compile Include="Plugin.cs" />
+    <Compile Include="Utilities.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <Content Include="HeuristicLab.Algorithms.MOCMAEvolutionStrategy.sln" />
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <PropertyGroup>
+    <PreBuildEvent>set Path=%25Path%25;$(ProjectDir);$(SolutionDir)
+set ProjectDir=$(ProjectDir)
+set SolutionDir=$(SolutionDir)
+set Outdir=$(Outdir)
+
+call PreBuildEvent.cmd
+
+
+</PreBuildEvent>
+  </PropertyGroup>
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+</Project>
Index: branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/HypervolumeIndicator.cs
===================================================================
--- branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/HypervolumeIndicator.cs	(revision 14404)
+++ branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/HypervolumeIndicator.cs	(revision 14404)
@@ -0,0 +1,63 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.TestFunctions.MultiObjective;
+namespace HeuristicLab.Algorithms.MOCMAEvolutionStrategy {
+  [Item("HypervolumeIndicator", "Selection of Offspring based on contributing Hypervolume")]
+  [StorableClass]
+  internal class HypervolumeIndicator : Item, IIndicator {
+
+    public int LeastContributer<TR>(IEnumerable<TR> front, Func<TR, double[]> extractor, MultiObjectiveTestFunctionProblem problem) {
+      var frontArr = front.Select(extractor.Invoke).ToList();
+      var refPoint = BuildReference(frontArr.Concat(new[] { problem.TestFunction.ReferencePoint(problem.Objectives) }), problem.Maximization);
+      var hv = Hypervolume.Calculate(frontArr, refPoint, problem.Maximization);
+      return Enumerable.Range(0, frontArr.Count).Select(i => Contribution(frontArr, i, problem.Maximization, refPoint, hv)).ArgMin();
+    }
+
+    private static double Contribution(IList<double[]> front, int idx, bool[] maximization, double[] refPoint, double hv) {
+      var point = front[idx];
+      front.RemoveAt(idx);
+      var contribution = hv - Hypervolume.Calculate(front, refPoint, maximization);
+      front.Insert(idx, point);
+      return contribution;
+    }
+    private static double[] BuildReference(IEnumerable<double[]> front, IReadOnlyList<bool> maximization) {
+      var refPoint = new double[maximization.Count];
+      foreach (var point in front)
+        for (var i = 0; i < maximization.Count; i++)
+          refPoint[i] = maximization[i] ? Math.Min(refPoint[i], point[i]) : Math.Max(refPoint[i], point[i]);
+      return refPoint;
+    }
+
+    [StorableConstructor]
+    protected HypervolumeIndicator(bool deserializing) : base(deserializing) { }
+    protected HypervolumeIndicator(HypervolumeIndicator original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) { return new HypervolumeIndicator(this, cloner); }
+    public HypervolumeIndicator() { }
+  }
+}
Index: branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/IIndicator.cs
===================================================================
--- branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/IIndicator.cs	(revision 14404)
+++ branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/IIndicator.cs	(revision 14404)
@@ -0,0 +1,39 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+using System;
+using System.Collections.Generic;
+using HeuristicLab.Core;
+using HeuristicLab.Problems.TestFunctions.MultiObjective;
+
+namespace HeuristicLab.Algorithms.MOCMAEvolutionStrategy {
+  public interface IIndicator : IItem {
+    /// <summary>
+    ///  Selects the least contributing Point of a front. Please keep in mind, that the contribution of a point depends on its value as well as on the other points of a front. 
+    ///  A particularly good point may not be as benefical in another front.
+    /// </summary>
+    /// <typeparam name="TR"></typeparam>
+    /// <param name="front">a front which will be evaluated</param>
+    /// <param name="extractor">some mapping function to map any R to double[]</param>
+    /// <param name="problem">The problem on which the front is evaluated (!! The function itself will NOT be evluated only bounds referencePoints & other metadate will be used</param>
+    /// <returns>the index of the least contributing point according to any type of quality criteria</returns>
+    int LeastContributer<TR>(IEnumerable<TR> front, Func<TR, double[]> extractor, MultiObjectiveTestFunctionProblem problem);
+  }
+}
Index: branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/MOCMASEvolutionStrategy.cs
===================================================================
--- branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/MOCMASEvolutionStrategy.cs	(revision 14404)
+++ branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/MOCMASEvolutionStrategy.cs	(revision 14404)
@@ -0,0 +1,629 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2016 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ * and the BEACON Center for the Study of Evolution in Action.
+ * 
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using HeuristicLab.Algorithms.CMAEvolutionStrategy;
+using HeuristicLab.Analysis;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.RealVectorEncoding;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.TestFunctions.MultiObjective;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Algorithms.MOCMAEvolutionStrategy {
+  [Item("MOCMAS Evolution Strategy (MOCMASES)", "A multi objective evolution strategy based on covariance matrix adaptation. Code is based on 'Covariance Matrix Adaptation for Multi - objective Optimization' by Igel, Hansen and Roth")]
+  [Creatable(CreatableAttribute.Categories.PopulationBasedAlgorithms, Priority = 210)]
+  [StorableClass]
+  public class MOCMASEvolutionStrategy : BasicAlgorithm {
+    public override Type ProblemType
+    {
+      get { return typeof(MultiObjectiveTestFunctionProblem); }
+    }
+    public new MultiObjectiveTestFunctionProblem Problem
+    {
+      get { return (MultiObjectiveTestFunctionProblem)base.Problem; }
+      set { base.Problem = value; }
+    }
+    #region internal variables
+    private readonly IRandom random = new MersenneTwister();
+    private NormalDistributedRandom gauss;
+    private MOCMAESIndividual[] solutions;
+    private MOCMAESParameters internals;
+    #endregion
+
+    #region ParameterNames
+    private const string MaximumRuntimeName = "Maximum Runtime";
+    private const string SeedName = "Seed";
+    private const string SetSeedRandomlyName = "SetSeedRandomly";
+    private const string PopulationSizeName = "PopulationSize";
+    private const string MaximumGenerationsName = "MaximumGenerations";
+    private const string MaximumEvaluatedSolutionsName = "MaximumEvaluatedSolutions";
+    private const string InitialSigmaName = "InitialSigma";
+    private const string IndicatorName = "Indicator";
+
+    private const string EvaluationsResultName = "Evaluations";
+    private const string IterationsResultName = "Generations";
+    private const string TimetableResultName = "Timetable";
+    private const string HypervolumeResultName = "Hypervolume";
+    private const string GenerationalDistanceResultName = "Generational Distance";
+    private const string InvertedGenerationalDistanceResultName = "Inverted Generational Distance";
+    private const string CrowdingResultName = "Crowding";
+    private const string SpacingResultName = "Spacing";
+    private const string SolutionsResultName = "Pareto Front";
+    private const string BestHypervolumeResultName = "Best Hypervolume";
+    private const string BestKnownHypervolumeResultName = "Best known hypervolume";
+    private const string DifferenceToBestKnownHypervolumeResultName = "Absolute Distance to BestKnownHypervolume";
+    private const string ScatterPlotResultName = "ScatterPlot";
+
+    #endregion
+
+    #region ParameterProperties
+    public IFixedValueParameter<IntValue> MaximumRuntimeParameter
+    {
+      get { return (IFixedValueParameter<IntValue>)Parameters[MaximumRuntimeName]; }
+    }
+    public IFixedValueParameter<IntValue> SeedParameter
+    {
+      get { return (IFixedValueParameter<IntValue>)Parameters[SeedName]; }
+    }
+    public FixedValueParameter<BoolValue> SetSeedRandomlyParameter
+    {
+      get { return (FixedValueParameter<BoolValue>)Parameters[SetSeedRandomlyName]; }
+    }
+    private IFixedValueParameter<IntValue> PopulationSizeParameter
+    {
+      get { return (IFixedValueParameter<IntValue>)Parameters[PopulationSizeName]; }
+    }
+    private IFixedValueParameter<IntValue> MaximumGenerationsParameter
+    {
+      get { return (IFixedValueParameter<IntValue>)Parameters[MaximumGenerationsName]; }
+    }
+    private IFixedValueParameter<IntValue> MaximumEvaluatedSolutionsParameter
+    {
+      get { return (IFixedValueParameter<IntValue>)Parameters[MaximumEvaluatedSolutionsName]; }
+    }
+    private IFixedValueParameter<DoubleValue> InitialSigmaParameter
+    {
+      get { return (IFixedValueParameter<DoubleValue>)Parameters[InitialSigmaName]; }
+    }
+    private IConstrainedValueParameter<IIndicator> IndicatorParameter
+    {
+      get { return (IConstrainedValueParameter<IIndicator>)Parameters[IndicatorName]; }
+    }
+    #endregion
+
+    #region Properties
+    public int MaximumRuntime
+    {
+      get { return MaximumRuntimeParameter.Value.Value; }
+      set { MaximumRuntimeParameter.Value.Value = value; }
+    }
+    public int Seed
+    {
+      get { return SeedParameter.Value.Value; }
+      set { SeedParameter.Value.Value = value; }
+    }
+    public bool SetSeedRandomly
+    {
+      get { return SetSeedRandomlyParameter.Value.Value; }
+      set { SetSeedRandomlyParameter.Value.Value = value; }
+    }
+    public int PopulationSize
+    {
+      get { return PopulationSizeParameter.Value.Value; }
+      set { PopulationSizeParameter.Value.Value = value; }
+    }
+    public int MaximumGenerations
+    {
+      get { return MaximumGenerationsParameter.Value.Value; }
+      set { MaximumGenerationsParameter.Value.Value = value; }
+    }
+    public int MaximumEvaluatedSolutions
+    {
+      get { return MaximumEvaluatedSolutionsParameter.Value.Value; }
+      set { MaximumEvaluatedSolutionsParameter.Value.Value = value; }
+    }
+    public double InitialSigma
+    {
+      get { return InitialSigmaParameter.Value.Value; }
+      set { InitialSigmaParameter.Value.Value = value; }
+    }
+    public IIndicator Indicator
+    {
+      get { return IndicatorParameter.Value; }
+      set { IndicatorParameter.Value = value; }
+    }
+
+
+    #endregion
+
+    #region ResultsProperties
+    private int ResultsEvaluations
+    {
+      get { return ((IntValue)Results[EvaluationsResultName].Value).Value; }
+      set { ((IntValue)Results[EvaluationsResultName].Value).Value = value; }
+    }
+    private int ResultsIterations
+    {
+      get { return ((IntValue)Results[IterationsResultName].Value).Value; }
+      set { ((IntValue)Results[IterationsResultName].Value).Value = value; }
+    }
+    #region Datatable
+    private DataTable ResultsQualities
+    {
+      get { return (DataTable)Results[TimetableResultName].Value; }
+    }
+    private DataRow ResultsBestHypervolumeDataLine
+    {
+      get { return ResultsQualities.Rows[BestHypervolumeResultName]; }
+    }
+    private DataRow ResultsHypervolumeDataLine
+    {
+      get { return ResultsQualities.Rows[HypervolumeResultName]; }
+    }
+    private DataRow ResultsGenerationalDistanceDataLine
+    {
+      get { return ResultsQualities.Rows[GenerationalDistanceResultName]; }
+    }
+    private DataRow ResultsInvertedGenerationalDistanceDataLine
+    {
+      get { return ResultsQualities.Rows[InvertedGenerationalDistanceResultName]; }
+    }
+    private DataRow ResultsCrowdingDataLine
+    {
+      get { return ResultsQualities.Rows[CrowdingResultName]; }
+    }
+    private DataRow ResultsSpacingDataLine
+    {
+      get { return ResultsQualities.Rows[SpacingResultName]; }
+    }
+    private DataRow ResultsHypervolumeDifferenceDataLine
+    {
+      get { return ResultsQualities.Rows[DifferenceToBestKnownHypervolumeResultName]; }
+    }
+    #endregion
+    //QualityIndicators
+    private double ResultsHypervolume
+    {
+      get { return ((DoubleValue)Results[HypervolumeResultName].Value).Value; }
+      set { ((DoubleValue)Results[HypervolumeResultName].Value).Value = value; }
+    }
+    private double ResultsGenerationalDistance
+    {
+      get { return ((DoubleValue)Results[GenerationalDistanceResultName].Value).Value; }
+      set { ((DoubleValue)Results[GenerationalDistanceResultName].Value).Value = value; }
+    }
+    private double ResultsInvertedGenerationalDistance
+    {
+      get { return ((DoubleValue)Results[InvertedGenerationalDistanceResultName].Value).Value; }
+      set { ((DoubleValue)Results[InvertedGenerationalDistanceResultName].Value).Value = value; }
+    }
+    private double ResultsCrowding
+    {
+      get { return ((DoubleValue)Results[CrowdingResultName].Value).Value; }
+      set { ((DoubleValue)Results[CrowdingResultName].Value).Value = value; }
+    }
+    private double ResultsSpacing
+    {
+      get { return ((DoubleValue)Results[SpacingResultName].Value).Value; }
+      set { ((DoubleValue)Results[SpacingResultName].Value).Value = value; }
+    }
+    private double ResultsBestHypervolume
+    {
+      get { return ((DoubleValue)Results[BestHypervolumeResultName].Value).Value; }
+      set { ((DoubleValue)Results[BestHypervolumeResultName].Value).Value = value; }
+    }
+    private double ResultsBestKnownHypervolume
+    {
+      get { return ((DoubleValue)Results[BestKnownHypervolumeResultName].Value).Value; }
+      set { ((DoubleValue)Results[BestKnownHypervolumeResultName].Value).Value = value; }
+    }
+    private double ResultsDifferenceBestKnownHypervolume
+    {
+      get { return ((DoubleValue)Results[DifferenceToBestKnownHypervolumeResultName].Value).Value; }
+      set { ((DoubleValue)Results[DifferenceToBestKnownHypervolumeResultName].Value).Value = value; }
+
+    }
+    //Solutions
+    private DoubleMatrix ResultsSolutions
+    {
+      get { return ((DoubleMatrix)Results[SolutionsResultName].Value); }
+      set { Results[SolutionsResultName].Value = value; }
+    }
+    private ScatterPlotContent ResultsScatterPlot
+    {
+      get { return ((ScatterPlotContent)Results[ScatterPlotResultName].Value); }
+      set { Results[ScatterPlotResultName].Value = value; }
+    }
+    #endregion
+
+    #region Constructors
+    public MOCMASEvolutionStrategy() {
+      Parameters.Add(new FixedValueParameter<IntValue>(MaximumRuntimeName, "The maximum runtime in seconds after which the algorithm stops. Use -1 to specify no limit for the runtime", new IntValue(3600)));
+      Parameters.Add(new FixedValueParameter<IntValue>(SeedName, "The random seed used to initialize the new pseudo random number generator.", new IntValue(0)));
+      Parameters.Add(new FixedValueParameter<BoolValue>(SetSeedRandomlyName, "True if the random seed should be set to a random value, otherwise false.", new BoolValue(true)));
+      Parameters.Add(new FixedValueParameter<IntValue>(PopulationSizeName, "λ (lambda) - the size of the offspring population.", new IntValue(20)));
+      Parameters.Add(new FixedValueParameter<DoubleValue>(InitialSigmaName, "The initial sigma is a single value > 0.", new DoubleValue(0.5)));
+      Parameters.Add(new FixedValueParameter<IntValue>(MaximumGenerationsName, "The maximum number of generations which should be processed.", new IntValue(1000)));
+      Parameters.Add(new FixedValueParameter<IntValue>(MaximumEvaluatedSolutionsName, "The maximum number of evaluated solutions that should be computed.", new IntValue(int.MaxValue)));
+      var set = new ItemSet<IIndicator> { new HypervolumeIndicator(), new CrowdingIndicator() };
+      Parameters.Add(new ConstrainedValueParameter<IIndicator>(IndicatorName, "The selection mechanism on non-dominated solutions", set, set.First()));
+    }
+
+    [StorableConstructor]
+    protected MOCMASEvolutionStrategy(bool deserializing) : base(deserializing) { }
+    protected MOCMASEvolutionStrategy(MOCMASEvolutionStrategy original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) { return new MOCMASEvolutionStrategy(this, cloner); }
+    #endregion
+
+    #region Mainloop
+    protected override void Run(CancellationToken cancellationToken) {
+      // Set up the algorithm
+      if (SetSeedRandomly) Seed = new System.Random().Next();
+      random.Reset(Seed);
+      gauss = new NormalDistributedRandom(random, 0, 1);
+
+      InitResults();
+      InitStrategy();
+      InitSolutions();
+      AnalyzeSolutions();
+
+      // Loop until iteration limit reached or canceled.
+      for (ResultsIterations = 1; ResultsIterations < MaximumGenerations; ResultsIterations++) {
+        try {
+          Iterate();
+          cancellationToken.ThrowIfCancellationRequested();
+        }
+        finally {
+          AnalyzeSolutions();
+        }
+      }
+    }
+    private void Iterate() {
+      var offspring = MutateOffspring();
+      PenalizeEvaluate(offspring);
+      var parents = solutions.Concat(offspring).ToArray();
+      SelectParents(parents, solutions.Length);
+      UpdatePopulation(parents);
+    }
+    protected override void OnExecutionTimeChanged() {
+      base.OnExecutionTimeChanged();
+      if (CancellationTokenSource == null) return;
+      if (MaximumRuntime == -1) return;
+      if (ExecutionTime.TotalSeconds > MaximumRuntime) CancellationTokenSource.Cancel();
+    }
+    #endregion
+
+    #region Initialization
+    private MOCMAESIndividual InitializeIndividual(RealVector x) {
+      var zeros = new RealVector(x.Length);
+      var identity = new double[x.Length, x.Length];
+      for (var i = 0; i < x.Length; i++) identity[i, i] = 1;
+      return new MOCMAESIndividual(x, internals.TargetSuccessProbability, InitialSigma, zeros, identity, internals);
+    }
+    private void InitSolutions() {
+      solutions = new MOCMAESIndividual[PopulationSize];
+      for (var i = 0; i < PopulationSize; i++) {
+        var x = new RealVector(Problem.ProblemSize); // Uniform distibution in all dimensions assumed.
+                                                     // There is the UniformSolutionCreater associated with the Encoding, but it was considered not usable here
+        var bounds = Problem.Bounds;
+        for (var j = 0; j < Problem.ProblemSize; j++) {
+          var dim = j % bounds.Rows;
+          x[j] = random.NextDouble() * (bounds[dim, 1] - bounds[dim, 0]) + bounds[dim, 0];
+        }
+        solutions[i] = InitializeIndividual(x);
+      }
+      PenalizeEvaluate(solutions);
+    }
+    private void InitStrategy() {
+      const int lambda = 1;
+      double n = Problem.ProblemSize;
+
+      var targetSuccessProbability = 1.0 / (5.0 + Math.Sqrt(lambda) / 2.0);
+      var stepSizeDampeningFactor = 1.0 + n / (2.0 * lambda);
+      var stepSizeLearningRate = targetSuccessProbability * lambda / (2.0 + targetSuccessProbability * lambda);
+      var evolutionPathLearningRate = 2.0 / (n + 2.0);
+      var covarianceMatrixLearningRate = 2.0 / (n * n + 6.0);
+      var covarianceMatrixUnlearningRate = 0.4 / (Math.Pow(n, 1.6) + 1);
+      var successThreshold = 0.44;
+      internals = new MOCMAESParameters(stepSizeLearningRate, stepSizeDampeningFactor, targetSuccessProbability, evolutionPathLearningRate, covarianceMatrixLearningRate, covarianceMatrixUnlearningRate, successThreshold);
+
+    }
+    private void InitResults() {
+      AddResult(IterationsResultName, "The number of gererations evaluated", new IntValue(0));
+      AddResult(EvaluationsResultName, "The number of function evaltions performed", new IntValue(0));
+      AddResult(HypervolumeResultName, "The hypervolume of the current front considering the Referencepoint defined in the Problem", new DoubleValue(0.0));
+      AddResult(BestHypervolumeResultName, "The best hypervolume of the current run considering the Referencepoint defined in the Problem", new DoubleValue(0.0));
+      AddResult(BestKnownHypervolumeResultName, "The best knwon hypervolume considering the Referencepoint defined in the Problem", new DoubleValue(double.NaN));
+      AddResult(DifferenceToBestKnownHypervolumeResultName, "The difference between the current and the best known hypervolume", new DoubleValue(double.NaN));
+      AddResult(GenerationalDistanceResultName, "The generational distance to an optimal pareto front defined in the Problem", new DoubleValue(double.NaN));
+      AddResult(InvertedGenerationalDistanceResultName, "The inverted generational distance to an optimal pareto front defined in the Problem", new DoubleValue(double.NaN));
+      AddResult(CrowdingResultName, "The average crowding value for the current front (excluding infinities)", new DoubleValue(0.0));
+      AddResult(SpacingResultName, "The spacing for the current front (excluding infinities)", new DoubleValue(0.0));
+
+      var table = new DataTable("QualityIndicators");
+      table.Rows.Add(new DataRow(BestHypervolumeResultName));
+      table.Rows.Add(new DataRow(HypervolumeResultName));
+      table.Rows.Add(new DataRow(CrowdingResultName));
+      table.Rows.Add(new DataRow(GenerationalDistanceResultName));
+      table.Rows.Add(new DataRow(InvertedGenerationalDistanceResultName));
+      table.Rows.Add(new DataRow(DifferenceToBestKnownHypervolumeResultName));
+      table.Rows.Add(new DataRow(SpacingResultName));
+      AddResult(TimetableResultName, "Different quality meassures in a timeseries", table);
+      AddResult(SolutionsResultName, "The current front", new DoubleMatrix());
+      AddResult(ScatterPlotResultName, "A scatterplot displaying the evaluated solutions and (if available) the analytically optimal front", new ScatterPlotContent(null, null, null, 2));
+
+      if (Problem.BestKnownFront != null) {
+        ResultsBestKnownHypervolume = Hypervolume.Calculate(Utilities.ToArray(Problem.BestKnownFront), Problem.TestFunction.ReferencePoint(Problem.Objectives), Problem.Maximization);
+        ResultsDifferenceBestKnownHypervolume = ResultsBestKnownHypervolume;
+      }
+      ResultsScatterPlot = new ScatterPlotContent(null, null, Utilities.ToArray(Problem.BestKnownFront), Problem.Objectives);
+    }
+    #endregion
+
+    private MOCMAESIndividual[] MutateOffspring() {
+      var offspring = new MOCMAESIndividual[PopulationSize];
+      for (var i = 0; i < PopulationSize; i++) {
+        offspring[i] = new MOCMAESIndividual(solutions[i]);
+        offspring[i].Mutate(gauss);
+      }
+      return offspring;
+    }
+
+    #region Evaluation
+    private void PenalizeEvaluate(IEnumerable<MOCMAESIndividual> offspring) {
+      foreach (var child in offspring) {
+        if (IsFeasable(child.Mean)) {
+          child.Fitness = Evaluate(child.Mean);
+          child.PenalizedFitness = child.Fitness;
+        } else {
+          var t = ClosestFeasible(child.Mean);
+          child.Fitness = Evaluate(t);
+          child.PenalizedFitness = Penalize(child.Mean, t, child.Fitness);
+        }
+      }
+    }
+    private double[] Evaluate(RealVector x) {
+      var res = Problem.Evaluate(x);
+      ResultsEvaluations++;
+      return res;
+    }
+    private static double[] Penalize(RealVector x, RealVector t, IEnumerable<double> fitness) {
+      var penalty = x.Select((t1, i) => t1 - t[i]).Sum(d => d * d);
+      return fitness.Select(v => v + penalty).ToArray();
+    }
+    private RealVector ClosestFeasible(RealVector x) {
+      var bounds = Problem.Bounds;
+      var r = new RealVector(x.Length);
+      for (var i = 0; i < x.Length; i++) {
+        var dim = i % bounds.Rows;
+        r[i] = Math.Min(Math.Max(bounds[dim, 0], x[i]), bounds[dim, 1]);
+      }
+      return r;
+    }
+    private bool IsFeasable(RealVector offspring) {
+      var bounds = Problem.Bounds;
+      for (var i = 0; i < offspring.Length; i++) {
+        var dim = i % bounds.Rows;
+        if (bounds[dim, 0] > offspring[i] || offspring[i] > bounds[dim, 1]) return false;
+      }
+      return true;
+    }
+    #endregion
+
+    private void SelectParents(IReadOnlyList<MOCMAESIndividual> parents, int length) {
+      //perform a nondominated sort to assign the rank to every element
+      var fronts = NonDominatedSort(parents);
+
+      //deselect the highest rank fronts until we would end up with less or equal mu elements
+      var rank = fronts.Count - 1;
+      var popSize = parents.Count;
+      while (popSize - fronts[rank].Count >= length) {
+        var front = fronts[rank];
+        foreach (var i in front) i.Selected = false;
+        popSize -= front.Count;
+        rank--;
+      }
+
+      //now use the indicator to deselect the approximatingly worst elements of the last selected front
+      var front1 = fronts[rank];
+      for (; popSize > length; popSize--) {
+        var lc = Indicator.LeastContributer(front1.ToArray(), x => x.PenalizedFitness, Problem);
+        front1[lc].Selected = false;
+        front1.Swap(lc, front1.Count - 1);
+        front1.RemoveAt(front1.Count - 1);
+      }
+    }
+
+    private void UpdatePopulation(IReadOnlyList<MOCMAESIndividual> parents) {
+      var offspringSucess = new int[solutions.Length];
+      var offspringLength = parents.Count - solutions.Length;
+      for (var i = 0; i < offspringLength; i++) {
+        if (!parents[i + solutions.Length].Selected) continue;
+        parents[i + solutions.Length].UpdateAsOffspring();
+        offspringSucess[i] += MOCMAESIndividual.Success;
+      }
+      for (var i = 0; i < solutions.Length; i++) if (parents[i].Selected) parents[i].UpdateAsParent(offspringSucess[i]);
+      solutions = new MOCMAESIndividual[solutions.Length];
+      var j = 0;
+      foreach (var ind in parents) if (ind.Selected) solutions[j++] = ind;
+    }
+
+    #region Analysis
+    private void AnalyzeSolutions() {
+      ResultsScatterPlot = new ScatterPlotContent(solutions.Select(x => x.Fitness).ToArray(),
+          solutions.Select(x => x.Mean.ToArray()).ToArray(),
+          ResultsScatterPlot.ParetoFront,
+          ResultsScatterPlot.Objectives);
+      ResultsSolutions = ToMatrix(solutions.Select(x => x.Mean.ToArray()));
+      AnalyzeQualityIndicators();
+    }
+    private void AnalyzeQualityIndicators() {
+      var front = NonDominatedSelect.GetDominatingVectors(solutions.Select(x => x.Fitness), Problem.TestFunction.ReferencePoint(Problem.Objectives), Problem.Maximization, true).ToArray();
+      var bounds = Problem.Bounds.CloneAsMatrix();
+      ResultsCrowding = Crowding.Calculate(front, bounds);
+      ResultsSpacing = Spacing.Calculate(front);
+      ResultsGenerationalDistance = Problem.BestKnownFront != null ? GenerationalDistance.Calculate(front, Utilities.ToArray(Problem.BestKnownFront), 1) : double.NaN;
+
+      ResultsInvertedGenerationalDistance = Problem.BestKnownFront != null ? InvertedGenerationalDistance.Calculate(front, Utilities.ToArray(Problem.BestKnownFront), 1) : double.NaN;
+
+      ResultsHypervolume = Hypervolume.Calculate(front, Problem.TestFunction.ReferencePoint(Problem.Objectives), Problem.Maximization);
+      ResultsBestHypervolume = Math.Max(ResultsHypervolume, ResultsBestHypervolume);
+      ResultsDifferenceBestKnownHypervolume = ResultsBestKnownHypervolume - ResultsBestHypervolume;
+
+      //Datalines
+      ResultsBestHypervolumeDataLine.Values.Add(ResultsBestHypervolume);
+      ResultsHypervolumeDataLine.Values.Add(ResultsHypervolume);
+      ResultsCrowdingDataLine.Values.Add(ResultsCrowding);
+      ResultsGenerationalDistanceDataLine.Values.Add(ResultsGenerationalDistance);
+      ResultsInvertedGenerationalDistanceDataLine.Values.Add(ResultsInvertedGenerationalDistance);
+      ResultsSpacingDataLine.Values.Add(ResultsSpacing);
+      ResultsHypervolumeDifferenceDataLine.Values.Add(ResultsDifferenceBestKnownHypervolume);
+
+    }
+    #endregion
+
+
+
+    #region Helpers
+    public DoubleMatrix ToMatrix(IEnumerable<double[]> data) {
+      var d2 = data.ToArray();
+      var mat = new DoubleMatrix(d2.Length, d2[0].Length);
+      for (var i = 0; i < mat.Rows; i++) {
+        for (var j = 0; j < mat.Columns; j++) {
+          mat[i, j] = d2[i][j];
+        }
+      }
+      return mat;
+    }
+    private void AddResult<T>(string name1, string desc, T defaultValue) where T : class, IItem {
+      Results.Add(new Result(name1, desc, defaultValue));
+    }
+    //blatantly stolen form HeuristicLab.Optimization.Operators.FastNonDominatedSort
+    //however: Operators.FastNonDominatedSort does not return ranked fronts => rerank after sorting would not be sensible
+    #region FastNonDominatedSort   
+    private enum DominationResult { Dominates, IsDominated, IsNonDominated };
+    private List<List<MOCMAESIndividual>> NonDominatedSort(IReadOnlyList<MOCMAESIndividual> individuals) {
+      const bool dominateOnEqualQualities = false;
+      var maximization = Problem.Maximization;
+      if (individuals == null) throw new InvalidOperationException(Name + ": No qualities found.");
+      var populationSize = individuals.Count;
+
+      var fronts = new List<List<MOCMAESIndividual>>();
+      var dominatedScopes = new Dictionary<MOCMAESIndividual, List<int>>();
+      var dominationCounter = new int[populationSize];
+
+      for (var pI = 0; pI < populationSize - 1; pI++) {
+        var p = individuals[pI];
+        List<int> dominatedScopesByp;
+        if (!dominatedScopes.TryGetValue(p, out dominatedScopesByp))
+          dominatedScopes[p] = dominatedScopesByp = new List<int>();
+        for (var qI = pI + 1; qI < populationSize; qI++) {
+          var test = Dominates(individuals[pI], individuals[qI], maximization, dominateOnEqualQualities);
+          if (test == DominationResult.Dominates) {
+            dominatedScopesByp.Add(qI);
+            dominationCounter[qI] += 1;
+          } else if (test == DominationResult.IsDominated) {
+            dominationCounter[pI] += 1;
+            if (!dominatedScopes.ContainsKey(individuals[qI]))
+              dominatedScopes.Add(individuals[qI], new List<int>());
+            dominatedScopes[individuals[qI]].Add(pI);
+          }
+          if (pI == populationSize - 2
+            && qI == populationSize - 1
+            && dominationCounter[qI] == 0) {
+            AddToFront(individuals[qI], fronts, 0);
+          }
+        }
+        if (dominationCounter[pI] == 0) {
+          AddToFront(p, fronts, 0);
+        }
+      }
+      var i = 0;
+      while (i < fronts.Count && fronts[i].Count > 0) {
+        var nextFront = new List<MOCMAESIndividual>();
+        foreach (var p in fronts[i]) {
+          List<int> dominatedScopesByp;
+          if (!dominatedScopes.TryGetValue(p, out dominatedScopesByp)) continue;
+          foreach (var dominatedScope in dominatedScopesByp) {
+            dominationCounter[dominatedScope] -= 1;
+            if (dominationCounter[dominatedScope] != 0) continue;
+            nextFront.Add(individuals[dominatedScope]);
+          }
+        }
+        i += 1;
+        fronts.Add(nextFront);
+      }
+
+      for (i = 0; i < fronts.Count; i++) {
+        foreach (var p in fronts[i]) {
+          p.Rank = i;
+        }
+      }
+      return fronts;
+    }
+    private static void AddToFront(MOCMAESIndividual p, IList<List<MOCMAESIndividual>> fronts, int i) {
+      if (i == fronts.Count) fronts.Add(new List<MOCMAESIndividual>());
+      fronts[i].Add(p);
+    }
+    private static DominationResult Dominates(MOCMAESIndividual left, MOCMAESIndividual right, bool[] maximizations, bool dominateOnEqualQualities) {
+      return Dominates(left.PenalizedFitness, right.PenalizedFitness, maximizations, dominateOnEqualQualities);
+    }
+    private static DominationResult Dominates(IReadOnlyList<double> left, IReadOnlyList<double> right, IReadOnlyList<bool> maximizations, bool dominateOnEqualQualities) {
+      //mkommend Caution: do not use LINQ.SequenceEqual for comparing the two quality arrays (left and right) due to performance reasons
+      if (dominateOnEqualQualities) {
+        var equal = true;
+        for (var i = 0; i < left.Count; i++) {
+          if (left[i] != right[i]) {
+            equal = false;
+            break;
+          }
+        }
+        if (equal) return DominationResult.Dominates;
+      }
+
+      bool leftIsBetter = false, rightIsBetter = false;
+      for (var i = 0; i < left.Count; i++) {
+        if (IsDominated(left[i], right[i], maximizations[i])) rightIsBetter = true;
+        else if (IsDominated(right[i], left[i], maximizations[i])) leftIsBetter = true;
+        if (leftIsBetter && rightIsBetter) break;
+      }
+
+      if (leftIsBetter && !rightIsBetter) return DominationResult.Dominates;
+      if (!leftIsBetter && rightIsBetter) return DominationResult.IsDominated;
+      return DominationResult.IsNonDominated;
+    }
+    private static bool IsDominated(double left, double right, bool maximization) {
+      return maximization && left < right
+        || !maximization && left > right;
+    }
+    #endregion
+    #endregion
+  }
+}
Index: branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/MocmaesIndividual.cs
===================================================================
--- branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/MocmaesIndividual.cs	(revision 14404)
+++ branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/MocmaesIndividual.cs	(revision 14404)
@@ -0,0 +1,160 @@
+﻿using System;
+using System.Linq;
+using HeuristicLab.Algorithms.MOCMAEvolutionStrategy;
+using HeuristicLab.Common;
+using HeuristicLab.Encodings.RealVectorEncoding;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Algorithms.CMAEvolutionStrategy {
+  internal class MOCMAESIndividual {
+    public const int Success = 1;
+    public const int NoSuccess = 2;
+    public const int Failure = 3;
+
+    //MOCMAES-Params
+    private readonly MOCMAESParameters strategy;
+
+    //Chromosome
+    public RealVector Mean { get; private set; }
+    private double sigma;//stepsize
+    private RealVector evolutionPath; // pc
+    private RealVector lastStep;
+    private RealVector lastZ;
+    private double[,] lowerCholesky;
+
+
+    //Phenotype
+    public double[] Fitness { get; set; }
+    public double[] PenalizedFitness { get; set; }
+    public bool Selected { get; set; }
+    public double Rank { get; set; }
+    public double SuccessProbability { get; set; }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="mean">has to be 0-vector with correct lenght</param>
+    /// <param name="pSucc">has to be ptargetsucc</param>
+    /// <param name="sigma">initialSigma</param>
+    /// <param name="pc">has to be 0-vector with correct lenght</param>
+    /// <param name="c">has to be a symmetric positive definit Covariance matrix</param>
+    public MOCMAESIndividual(RealVector mean, double pSucc, double sigma, RealVector pc, double[,] c, MOCMAESParameters strategy) {
+      Mean = mean;
+      SuccessProbability = pSucc;
+      this.sigma = sigma;
+      evolutionPath = pc;
+      CholeskyDecomposition(c);
+      Selected = true;
+      this.strategy = strategy;
+    }
+
+    private void CholeskyDecomposition(double[,] c) {
+      if (!alglib.spdmatrixcholesky(ref c, c.GetLength(0), false))
+        throw new ArgumentException("Covariancematrix is not symmetric positiv definit");
+      lowerCholesky = (double[,])c.Clone();
+    }
+
+    public MOCMAESIndividual(MOCMAESIndividual other) {
+      SuccessProbability = other.SuccessProbability;
+      sigma = other.sigma;
+      evolutionPath = (RealVector)other.evolutionPath.Clone();
+      Mean = (RealVector)other.Mean.Clone();
+      lowerCholesky = (double[,])other.lowerCholesky.Clone();
+      Selected = true;
+      strategy = other.strategy;
+    }
+
+    public void UpdateEvolutionPath(double learningRate, double updateWeight) {
+      updateWeight = Math.Sqrt(updateWeight);
+      for (var i = 0; i < evolutionPath.Length; i++) {
+        evolutionPath[i] *= learningRate;
+        evolutionPath[i] += updateWeight * lastStep[i];
+      }
+    }
+
+    public double GetNormSqr() {
+      return lastZ.Sum(d => d * d);
+    }
+
+    private void CholeskyUpdate(RealVector v, double alpha, double beta) {
+      var n = v.Length;
+      var temp = new double[n];
+      for (var i = 0; i < n; i++) temp[i] = v[i];
+      double betaPrime = 1;
+      var a = Math.Sqrt(alpha);
+      for (var j = 0; j < n; j++) {
+        var ljj = a * lowerCholesky[j, j];
+        var dj = ljj * ljj;
+        var wj = temp[j];
+        var swj2 = beta * wj * wj;
+        var gamma = dj * betaPrime + swj2;
+        var x1 = dj + swj2 / betaPrime;
+        if (x1 < 0.0) throw new ArgumentException("Update makes Covariancematrix indefinite");
+        var nLjj = Math.Sqrt(x1);
+        lowerCholesky[j, j] = nLjj;
+        betaPrime += swj2 / dj;
+        if (j + 1 >= n) continue;
+        for (var i = j + 1; i < n; i++) lowerCholesky[i, j] *= a;
+        for (var i = j + 1; i < n; i++) temp[i] = wj / ljj * lowerCholesky[i, j];
+        if (gamma.IsAlmost(0)) continue;
+        for (var i = j + 1; i < n; i++) lowerCholesky[i, j] *= nLjj / ljj;
+        for (var i = j + 1; i < n; i++) lowerCholesky[i, j] += nLjj * beta * wj / gamma * temp[i];
+
+      }
+
+    }
+
+    public void Mutate(NormalDistributedRandom gauss) {
+      //sampling a random z from N(0,I) where I is the Identity matrix;
+      lastZ = new RealVector(Mean.Length);
+      var n = lastZ.Length;
+      for (var i = 0; i < n; i++) lastZ[i] = gauss.NextDouble();
+      //Matrixmultiplication: lastStep = lowerCholesky * lastZ;
+      lastStep = new RealVector(Mean.Length);
+      for (var i = 0; i < n; i++) {
+        double sum = 0;
+        for (var j = 0; j <= i; j++) sum += lowerCholesky[i, j] * lastZ[j];
+        lastStep[i] = sum;
+      }
+      //add the step to x weighted by stepsize;
+      for (var i = 0; i < Mean.Length; i++) Mean[i] += sigma * lastStep[i];
+    }
+
+    public void UpdateAsParent(int v) {
+      SuccessProbability = (1 - strategy.StepSizeLearningRate) * SuccessProbability + strategy.StepSizeLearningRate * (v == Success ? 1 : 0);
+      sigma *= Math.Exp(1 / strategy.StepSizeDampeningFactor * (SuccessProbability - strategy.TargetSuccessProbability) / (1 - strategy.TargetSuccessProbability));
+      if (v != Failure) return;
+      if (SuccessProbability < strategy.SuccessThreshold) {
+        var stepNormSqr = GetNormSqr();
+        var rate = strategy.CovarianceMatrixUnlearningRate;
+        if (stepNormSqr > 1 && 1 < strategy.CovarianceMatrixUnlearningRate * (2 * stepNormSqr - 1)) {
+          rate = 1 / (2 * stepNormSqr - 1);
+        }
+        CholeskyUpdate(lastStep, 1 + rate, -rate);
+      } else {
+        RoundUpdate();
+      }
+
+    }
+
+    public void UpdateAsOffspring() {
+      SuccessProbability = (1 - strategy.StepSizeLearningRate) * SuccessProbability + strategy.StepSizeLearningRate;
+      sigma *= Math.Exp(1 / strategy.StepSizeDampeningFactor * (SuccessProbability - strategy.TargetSuccessProbability) / (1 - strategy.TargetSuccessProbability));
+      var evolutionpathUpdateWeight = strategy.EvolutionPathLearningRate * (2.0 - strategy.EvolutionPathLearningRate);
+      if (SuccessProbability < strategy.SuccessThreshold) {
+        UpdateEvolutionPath(1 - strategy.EvolutionPathLearningRate, evolutionpathUpdateWeight);
+        CholeskyUpdate(evolutionPath, 1 - strategy.CovarianceMatrixLearningRate, strategy.CovarianceMatrixLearningRate);
+      } else {
+        RoundUpdate();
+      }
+    }
+
+    private void RoundUpdate() {
+      var evolutionPathUpdateWeight = strategy.EvolutionPathLearningRate * (2.0 - strategy.EvolutionPathLearningRate);
+      UpdateEvolutionPath(1 - strategy.EvolutionPathLearningRate, 0);
+      CholeskyUpdate(evolutionPath, 1 - strategy.CovarianceMatrixLearningRate + evolutionPathUpdateWeight, strategy.CovarianceMatrixLearningRate);
+    }
+
+  }
+
+}
Index: branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/MocmaesParameters.cs
===================================================================
--- branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/MocmaesParameters.cs	(revision 14404)
+++ branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/MocmaesParameters.cs	(revision 14404)
@@ -0,0 +1,22 @@
+﻿
+namespace HeuristicLab.Algorithms.MOCMAEvolutionStrategy {
+  internal class MOCMAESParameters {
+    public readonly double StepSizeLearningRate; //=cp learning rate in [0,1]
+    public readonly double StepSizeDampeningFactor; //d
+    public readonly double TargetSuccessProbability;// p^target_succ
+    public readonly double EvolutionPathLearningRate;//cc
+    public readonly double CovarianceMatrixLearningRate;//ccov
+    public readonly double CovarianceMatrixUnlearningRate;   //from shark
+    public readonly double SuccessThreshold; //ptresh
+
+    public MOCMAESParameters(double stepSizeLearningRate, double stepSizeDampeningFactor, double targetSuccessProbability, double evolutionPathLearningRate, double covarianceMatrixLearningRate, double covarianceMatrixUnlearningRate, double successThreshold) {
+      StepSizeLearningRate = stepSizeLearningRate;
+      StepSizeDampeningFactor = stepSizeDampeningFactor;
+      TargetSuccessProbability = targetSuccessProbability;
+      EvolutionPathLearningRate = evolutionPathLearningRate;
+      CovarianceMatrixLearningRate = covarianceMatrixLearningRate;
+      CovarianceMatrixUnlearningRate = covarianceMatrixUnlearningRate;
+      SuccessThreshold = successThreshold;
+    }
+  }
+}
Index: branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/Plugin.cs.frame
===================================================================
--- branches/HeuristicLab.Algorithms.CMAEvolutionStrategy/sources/3.3/Plugin.cs.frame	(revision 14269)
+++ branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/Plugin.cs.frame	(revision 14404)
@@ -22,14 +22,16 @@
 using HeuristicLab.PluginInfrastructure;
 
-namespace HeuristicLab.Algorithms.CMAEvolutionStrategy {
+namespace HeuristicLab.Algorithms.MOCMAEvolutionStrategy {
   /// <summary>
   /// Plugin class for HeuristicLab.Algorithms.EvolutionStrategy plugin.
   /// </summary>
-  [Plugin("HeuristicLab.Algorithms.CMAEvolutionStrategy", "3.3.13.$WCREV$")]
-  [PluginFile("HeuristicLab.Algorithms.CMAEvolutionStrategy-3.3.dll", PluginFileType.Assembly)]
+  [Plugin("HeuristicLab.Algorithms.MOCMAEvolutionStrategy", "3.3.14.$WCREV$")]
+  [PluginFile("HeuristicLab.Algorithms.MOCMAEvolutionStrategy-3.3.dll", PluginFileType.Assembly)]
+  [PluginDependency("HeuristicLab.ALGLIB", "3.7")]
   [PluginDependency("HeuristicLab.Analysis", "3.3")]
   [PluginDependency("HeuristicLab.Collections", "3.3")]
   [PluginDependency("HeuristicLab.Common", "3.3")]
   [PluginDependency("HeuristicLab.Core", "3.3")]
+  [PluginDependency("HeuristicLab.Core.Views", "3.3")]
   [PluginDependency("HeuristicLab.Data", "3.3")]
   [PluginDependency("HeuristicLab.Encodings.RealVectorEncoding", "3.3")]
@@ -39,6 +41,8 @@
   [PluginDependency("HeuristicLab.Parameters", "3.3")]
   [PluginDependency("HeuristicLab.Persistence", "3.3")]
+  [PluginDependency("HeuristicLab.Problems.Instances", "3.3")]
+  [PluginDependency("HeuristicLab.Problems.TestFunctions.MultiObjective", "3.3")]
   [PluginDependency("HeuristicLab.Random", "3.3")]
-  public class HeuristicLabAlgorithmsCMAEvolutionStrategyPlugin : PluginBase {
+  public class HeuristicLabAlgorithmsMOCMAEvolutionStrategyPlugin : PluginBase {
   }
 }
Index: branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/Properties/AssemblyInfo.cs.frame
===================================================================
--- branches/HeuristicLab.Algorithms.CMAEvolutionStrategy/sources/3.3/Properties/AssemblyInfo.cs.frame	(revision 14269)
+++ branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/Properties/AssemblyInfo.cs.frame	(revision 14404)
@@ -26,6 +26,6 @@
 // set of attributes. Change these attribute values to modify the information
 // associated with an assembly.
-[assembly: AssemblyTitle("HeuristicLab.Algorithms.CMAEvolutionStrategy")]
-[assembly: AssemblyDescription("HeuristicLab implementation of CMA Evolution Strategy (CMA-ES)")]
+[assembly: AssemblyTitle("HeuristicLab.Algorithms.MOCMAEvolutionStrategy")]
+[assembly: AssemblyDescription("HeuristicLab implementation of MOCMA Evolution Strategy (CMA-ES)")]
 [assembly: AssemblyConfiguration("")]
 [assembly: AssemblyCompany("")]
@@ -53,3 +53,3 @@
 // by using the '*' as shown below:
 [assembly: AssemblyVersion("3.3.0.0")]
-[assembly: AssemblyFileVersion("3.3.13.$WCREV$")]
+[assembly: AssemblyFileVersion("3.3.14.$WCREV$")]
Index: branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/Terminator.cs
===================================================================
--- branches/HeuristicLab.Algorithms.CMAEvolutionStrategy/sources/3.3/Terminator.cs	(revision 14269)
+++ 	(revision )
@@ -1,187 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2015 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
- *
- * This file is part of HeuristicLab.
- *
- * HeuristicLab is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * HeuristicLab is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
- */
-#endregion
-
-using HeuristicLab.Common;
-using HeuristicLab.Core;
-using HeuristicLab.Data;
-using HeuristicLab.Operators;
-using HeuristicLab.Optimization;
-using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using System;
-using System.Linq;
-
-namespace HeuristicLab.Algorithms.CMAEvolutionStrategy {
-  [Item("Terminator", "Decides if the algorithm should terminate or not.")]
-  [StorableClass]
-  public class Terminator : Operator, IIterationBasedOperator, ISingleObjectiveOperator {
-
-    protected OperatorParameter ContinueParameter {
-      get { return (OperatorParameter)Parameters["Continue"]; }
-    }
-    protected OperatorParameter TerminateParameter {
-      get { return (OperatorParameter)Parameters["Terminate"]; }
-    }
-
-    public IOperator Continue {
-      get { return ContinueParameter.Value; }
-      set { ContinueParameter.Value = value; }
-    }
-
-    public IOperator Terminate {
-      get { return TerminateParameter.Value; }
-      set { TerminateParameter.Value = value; }
-    }
-
-    public IValueLookupParameter<BoolValue> MaximizationParameter {
-      get { return (IValueLookupParameter<BoolValue>)Parameters["Maximization"]; }
-    }
-
-    public ILookupParameter<CMAParameters> StrategyParametersParameter {
-      get { return (ILookupParameter<CMAParameters>)Parameters["StrategyParameters"]; }
-    }
-
-    public ILookupParameter<IntValue> IterationsParameter {
-      get { return (ILookupParameter<IntValue>)Parameters["Iterations"]; }
-    }
-
-    public IValueLookupParameter<IntValue> MaximumIterationsParameter {
-      get { return (IValueLookupParameter<IntValue>)Parameters["MaximumIterations"]; }
-    }
-
-    public ILookupParameter<IntValue> EvaluatedSolutionsParameter {
-      get { return (ILookupParameter<IntValue>)Parameters["EvaluatedSolutions"]; }
-    }
-
-    public IValueLookupParameter<IntValue> MaximumEvaluatedSolutionsParameter {
-      get { return (IValueLookupParameter<IntValue>)Parameters["MaximumEvaluatedSolutions"]; }
-    }
-
-    public IScopeTreeLookupParameter<DoubleValue> QualityParameter {
-      get { return (IScopeTreeLookupParameter<DoubleValue>)Parameters["Quality"]; }
-    }
-
-    public IValueLookupParameter<DoubleValue> TargetQualityParameter {
-      get { return (IValueLookupParameter<DoubleValue>)Parameters["TargetQuality"]; }
-    }
-
-    public IValueLookupParameter<DoubleValue> MinimumQualityChangeParameter {
-      get { return (IValueLookupParameter<DoubleValue>)Parameters["MinimumQualityChange"]; }
-    }
-
-    public IValueLookupParameter<DoubleValue> MinimumQualityHistoryChangeParameter {
-      get { return (IValueLookupParameter<DoubleValue>)Parameters["MinimumQualityHistoryChange"]; }
-    }
-
-    public IValueLookupParameter<DoubleValue> MinimumStandardDeviationParameter {
-      get { return (IValueLookupParameter<DoubleValue>)Parameters["MinimumStandardDeviation"]; }
-    }
-
-    public ILookupParameter<DoubleArray> InitialSigmaParameter {
-      get { return (ILookupParameter<DoubleArray>)Parameters["InitialSigma"]; }
-    }
-
-    public IValueLookupParameter<DoubleValue> MaximumStandardDeviationChangeParameter {
-      get { return (IValueLookupParameter<DoubleValue>)Parameters["MaximumStandardDeviationChange"]; }
-    }
-
-    public ILookupParameter<BoolValue> DegenerateStateParameter {
-      get { return (ILookupParameter<BoolValue>)Parameters["DegenerateState"]; }
-    }
-
-    [StorableConstructor]
-    protected Terminator(bool deserializing) : base(deserializing) { }
-    protected Terminator(Terminator original, Cloner cloner)
-      : base(original, cloner) { }
-    public Terminator() {
-      Parameters.Add(new OperatorParameter("Continue", "The operator that is executed if the stop conditions have not been met!"));
-      Parameters.Add(new OperatorParameter("Terminate", "The operator that is executed if the stop conditions have been met!"));
-      Parameters.Add(new ValueLookupParameter<BoolValue>("Maximization", "True if the problem is to be maximized and false otherwise."));
-      Parameters.Add(new LookupParameter<CMAParameters>("StrategyParameters", "The CMA-ES strategy parameters."));
-      Parameters.Add(new LookupParameter<IntValue>("Iterations", "The number of iterations passed."));
-      Parameters.Add(new ValueLookupParameter<IntValue>("MaximumIterations", "The maximum number of iterations."));
-      Parameters.Add(new LookupParameter<IntValue>("EvaluatedSolutions", "The number of evaluated solutions."));
-      Parameters.Add(new ValueLookupParameter<IntValue>("MaximumEvaluatedSolutions", "The maximum number of evaluated solutions."));
-      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Quality", "The quality of the offspring."));
-      Parameters.Add(new ValueLookupParameter<DoubleValue>("TargetQuality", "(stopFitness) Surpassing this quality value terminates the algorithm."));
-      Parameters.Add(new ValueLookupParameter<DoubleValue>("MinimumQualityChange", "(stopTolFun) If the range of fitness values is less than a certain value the algorithm terminates (set to 0 or positive value to enable)."));
-      Parameters.Add(new ValueLookupParameter<DoubleValue>("MinimumQualityHistoryChange", "(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)."));
-      Parameters.Add(new ValueLookupParameter<DoubleValue>("MinimumStandardDeviation", "(stopTolXFactor) If the standard deviation falls below a certain value the algorithm terminates (set to 0 or positive to enable)."));
-      Parameters.Add(new LookupParameter<DoubleArray>("InitialSigma", "The initial value for Sigma."));
-      Parameters.Add(new ValueLookupParameter<DoubleValue>("MaximumStandardDeviationChange", "(stopTolUpXFactor) If the standard deviation changes by a value larger than this parameter the algorithm stops (set to a value > 0 to enable)."));
-      Parameters.Add(new LookupParameter<BoolValue>("DegenerateState", "Whether the algorithm state has degenerated and should be terminated."));
-    }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new Terminator(this, cloner);
-    }
-
-    public override IOperation Apply() {
-      var terminateOp = Terminate != null ? ExecutionContext.CreateOperation(Terminate) : null;
-
-      var degenerated = DegenerateStateParameter.ActualValue.Value;
-      if (degenerated) return terminateOp;
-
-      var iterations = IterationsParameter.ActualValue.Value;
-      var maxIterations = MaximumIterationsParameter.ActualValue.Value;
-      if (iterations >= maxIterations) return terminateOp;
-
-      var evals = EvaluatedSolutionsParameter.ActualValue.Value;
-      var maxEvals = MaximumEvaluatedSolutionsParameter.ActualValue.Value;
-      if (evals >= maxEvals) return terminateOp;
-
-      var maximization = MaximizationParameter.ActualValue.Value;
-      var bestQuality = QualityParameter.ActualValue.First().Value;
-      var targetQuality = TargetQualityParameter.ActualValue.Value;
-      if (iterations > 1 && (maximization && bestQuality >= targetQuality
-        || !maximization && bestQuality <= targetQuality)) return terminateOp;
-
-      var sp = StrategyParametersParameter.ActualValue;
-      var worstQuality = QualityParameter.ActualValue.Last().Value;
-      var minHist = sp.QualityHistory.Min();
-      var maxHist = sp.QualityHistory.Max();
-      var change = Math.Max(maxHist, Math.Max(bestQuality, worstQuality))
-                   - Math.Min(minHist, Math.Min(bestQuality, worstQuality));
-      var stopTolFun = MinimumQualityChangeParameter.ActualValue.Value;
-      if (change <= stopTolFun) return terminateOp;
-
-      if (iterations > sp.QualityHistorySize &&
-          maxHist - minHist <= MinimumQualityHistoryChangeParameter.ActualValue.Value)
-        return terminateOp;
-
-      double minSqrtdiagC = int.MaxValue, maxSqrtdiagC = int.MinValue;
-      for (int i = 0; i < sp.C.GetLength(0); i++) {
-        if (Math.Sqrt(sp.C[i, i]) < minSqrtdiagC) minSqrtdiagC = Math.Sqrt(sp.C[i, i]);
-        if (Math.Sqrt(sp.C[i, i]) > maxSqrtdiagC) maxSqrtdiagC = Math.Sqrt(sp.C[i, i]);
-      }
-
-      var tolx = MinimumStandardDeviationParameter.ActualValue.Value;
-      if (sp.Sigma * maxSqrtdiagC < tolx
-          && sp.Sigma * sp.PC.Select(x => Math.Abs(x)).Max() < tolx) return terminateOp;
-
-      var stopTolUpXFactor = MaximumStandardDeviationChangeParameter.ActualValue.Value;
-      if (sp.Sigma * maxSqrtdiagC > stopTolUpXFactor * InitialSigmaParameter.ActualValue.Max())
-        return terminateOp;
-
-      return Continue != null ? ExecutionContext.CreateOperation(Continue) : null;
-    }
-  }
-}
Index: branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/Utilities.cs
===================================================================
--- branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/Utilities.cs	(revision 14404)
+++ branches/MOCMAEvolutionStrategy/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/Utilities.cs	(revision 14404)
@@ -0,0 +1,56 @@
+﻿using System.Collections.Generic;
+using HeuristicLab.Data;
+
+namespace HeuristicLab.Algorithms.MOCMAEvolutionStrategy {
+  internal static class Utilities {
+    internal static double[][] ToArray(DoubleMatrix m) {
+      var i = m.Rows - 1;
+      var a = new double[i][];
+      for (i--; i >= 0; i--) {
+        var j = m.Columns;
+        a[i] = new double[j];
+        for (j--; j >= 0; j--) a[i][j] = m[i, j];
+      }
+      return a;
+    }
+
+    public static int ArgMin<T>(IEnumerable<T> values, IComparer<T> comparer) {
+      var mindex = 0;
+      var min = default(T);
+      var i = 0;
+      foreach (var v in values) {
+        if (mindex < 0 || comparer.Compare(v, min) < 0) {
+          min = v;
+          mindex = i;
+        }
+        i++;
+      }
+      return mindex;
+
+    }
+    public static int ArgMax<T>(IEnumerable<T> values, IComparer<T> comparer) {
+      var mindex = 0;
+      var min = default(T);
+      var i = 0;
+      foreach (var v in values) {
+        if (mindex < 0 || comparer.Compare(v, min) > 0) {
+          min = v;
+          mindex = i;
+        }
+        i++;
+      }
+      return mindex;
+    }
+    private class DoubleComparer : IComparer<double> {
+      public int Compare(double x, double y) {
+        return x.CompareTo(y);
+      }
+    }
+    public static int ArgMax(this IEnumerable<double> values) {
+      return ArgMax(values, new DoubleComparer());
+    }
+    public static int ArgMin(this IEnumerable<double> values) {
+      return ArgMin(values, new DoubleComparer());
+    }
+  }
+}
