source: branches/HeuristicLab.Hive_Milestone3/sources/HeuristicLab.ES/3.2/ES.cs @ 4593

#region License Information
/* HeuristicLab
 * Copyright (C) 2002-2009 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.Xml;
using HeuristicLab.Core;
using HeuristicLab.Data;
using HeuristicLab.Operators;
using HeuristicLab.Random;
using HeuristicLab.Logging;
using HeuristicLab.Selection;
using HeuristicLab.RealVector;
using HeuristicLab.Evolutionary;

namespace HeuristicLab.ES {
  /// <summary>
  /// Class for the heuristic optimization technique "evolution strategy".
  /// </summary>
  public class ES : ItemBase, IEditable {

    #region Create Operators
    /// <summary>
    /// Creates a new evolution strategy.
    /// </summary>
    /// <param name="engine">The engine of the ES to create.</param>
    public static void Create(IEngine engine) {
      engine.OperatorGraph.Clear();

      CombinedOperator co = CreateES();
      co.Name = "σSA-ES";
      engine.OperatorGraph.AddOperator(co);
      engine.OperatorGraph.InitialOperator = co;

      engine.Reset();
    }
    private static CombinedOperator CreateES() {
      CombinedOperator op = new CombinedOperator();
      SequentialProcessor sp = new SequentialProcessor();
      op.OperatorGraph.AddOperator(sp);
      op.OperatorGraph.InitialOperator = sp;

      CombinedOperator co1 = CreateVariableInjection();
      co1.Name = "Variable Injection";
      op.OperatorGraph.AddOperator(co1);
      sp.AddSubOperator(co1);

      // place holder for ProblemInjector
      EmptyOperator eo1 = new EmptyOperator();
      eo1.Name = "Empty Problem"; // was ProblemInjector
      op.OperatorGraph.AddOperator(eo1);
      co1.AddSubOperator(eo1);
      co1.AddVariableInfo(new VariableInfo("ProblemInjector", "", typeof(IOperator), VariableKind.In));
      co1.GetVariableInfo("ProblemInjector").ActualName = "Empty Problem";

      CombinedOperator co2 = CreatePopulationInitialization();
      co2.Name = "Population Initialization";
      op.OperatorGraph.AddOperator(co2);
      sp.AddSubOperator(co2);

      // place holder for SolutionGenerator
      EmptyOperator eo2 = new EmptyOperator();
      eo2.Name = "Empty Solution"; // was SolutionGenerator
      op.OperatorGraph.AddOperator(eo2);
      co2.AddSubOperator(eo2);
      co2.AddVariableInfo(new VariableInfo("SolutionGenerator", "", typeof(IOperator), VariableKind.In));
      co2.GetVariableInfo("SolutionGenerator").ActualName = "Empty Solution";

      // place holder for Evaluator
      EmptyOperator eo3 = new EmptyOperator();
      eo3.Name = "Empty Evaluation"; // was Evaluator
      op.OperatorGraph.AddOperator(eo3);
      co2.AddSubOperator(eo3);
      co2.AddVariableInfo(new VariableInfo("Evaluator", "", typeof(IOperator), VariableKind.In));
      co2.GetVariableInfo("Evaluator").ActualName = "Empty Evaluation";

      CombinedOperator co3 = CreateESMain();
      co3.Name = "ES Main";
      op.OperatorGraph.AddOperator(co3);
      sp.AddSubOperator(co3);

      // place holder for Mutator
      EmptyOperator eo4 = new EmptyOperator();
      eo4.Name = "No Mutation"; // was Mutator
      op.OperatorGraph.AddOperator(eo4);
      co3.AddSubOperator(eo4);
      co3.AddVariableInfo(new VariableInfo("Mutator", "", typeof(IOperator), VariableKind.In));
      co3.GetVariableInfo("Mutator").ActualName = "No Mutation";

      // place holder for Evaluator
      co3.AddSubOperator(eo3);
      co3.AddVariableInfo(new VariableInfo("Evaluator", "", typeof(IOperator), VariableKind.In));
      co3.GetVariableInfo("Evaluator").ActualName = "Empty Evaluation";

      // place holder for Recombinator
      EmptyOperator eo5 = new EmptyOperator();
      eo5.Name = "No Recombination"; // was Recombinator
      op.OperatorGraph.AddOperator(eo5);
      co3.AddSubOperator(eo5);
      co3.AddVariableInfo(new VariableInfo("Recombinator", "", typeof(IOperator), VariableKind.In));
      co3.GetVariableInfo("Recombinator").ActualName = "No Recombination";

      return op;
    }
    private static CombinedOperator CreateVariableInjection() {
      CombinedOperator op = new CombinedOperator();
      SequentialProcessor sp = new SequentialProcessor();
      op.OperatorGraph.AddOperator(sp);
      op.OperatorGraph.InitialOperator = sp;

      RandomInjector ri = new RandomInjector();
      op.OperatorGraph.AddOperator(ri);
      sp.AddSubOperator(ri);

      OperatorExtractor oe = new OperatorExtractor();
      oe.Name = "ProblemInjector";
      oe.GetVariableInfo("Operator").ActualName = "ProblemInjector";
      op.OperatorGraph.AddOperator(oe);
      sp.AddSubOperator(oe);

      VariableInjector vi = new VariableInjector();
      vi.AddVariable(new Variable("ESmu", new IntData(1)));
      vi.AddVariable(new Variable("ESrho", new IntData(1)));
      vi.AddVariable(new Variable("ESlambda", new IntData(1)));
      vi.AddVariable(new Variable("EvaluatedSolutions", new IntData()));
      vi.AddVariable(new Variable("PlusNotation", new BoolData(true)));
      vi.AddVariable(new Variable("ProblemDimension", new IntData(1)));
      vi.AddVariable(new Variable("ShakingFactorsMin", new DoubleData(0.1)));
      vi.AddVariable(new Variable("ShakingFactorsMax", new DoubleData(5.0)));
      vi.AddVariable(new Variable("Generations", new IntData()));
      vi.AddVariable(new Variable("MaximumGenerations", new IntData(1000)));
      vi.AddVariable(new Variable("GeneralLearningRate", new DoubleData(1.0 / Math.Sqrt(2))));
      vi.AddVariable(new Variable("LearningRate", new DoubleData(1.0 / Math.Sqrt(2))));
      op.OperatorGraph.AddOperator(vi);
      sp.AddSubOperator(vi);

      return op;
    }
    private static CombinedOperator CreatePopulationInitialization() {
      CombinedOperator op = new CombinedOperator();
      SequentialProcessor sp1 = new SequentialProcessor();
      op.OperatorGraph.AddOperator(sp1);
      op.OperatorGraph.InitialOperator = sp1;

      SubScopesCreater ssc = new SubScopesCreater();
      ssc.GetVariableInfo("SubScopes").ActualName = "ESmu";
      op.OperatorGraph.AddOperator(ssc);
      sp1.AddSubOperator(ssc);

      UniformSequentialSubScopesProcessor ussp = new UniformSequentialSubScopesProcessor();
      op.OperatorGraph.AddOperator(ussp);
      sp1.AddSubOperator(ussp);

      SequentialProcessor sp2 = new SequentialProcessor();
      op.OperatorGraph.AddOperator(sp2);
      ussp.AddSubOperator(sp2);

      OperatorExtractor oe1 = new OperatorExtractor();
      oe1.Name = "SolutionGenerator";
      oe1.GetVariableInfo("Operator").ActualName = "SolutionGenerator";
      op.OperatorGraph.AddOperator(oe1);
      sp2.AddSubOperator(oe1);

      OperatorExtractor oe2 = new OperatorExtractor();
      oe2.Name = "Evaluator";
      oe2.GetVariableInfo("Operator").ActualName = "Evaluator";
      op.OperatorGraph.AddOperator(oe2);
      sp2.AddSubOperator(oe2);

      Counter c = new Counter();
      c.GetVariableInfo("Value").ActualName = "EvaluatedSolutions";
      op.OperatorGraph.AddOperator(c);
      sp2.AddSubOperator(c);

      UniformRandomRealVectorGenerator urrvg = new UniformRandomRealVectorGenerator();
      urrvg.GetVariableInfo("Length").ActualName = "ProblemDimension";
      urrvg.GetVariableInfo("Minimum").ActualName = "ShakingFactorsMin";
      urrvg.GetVariableInfo("Maximum").ActualName = "ShakingFactorsMax";
      urrvg.GetVariableInfo("RealVector").ActualName = "ShakingFactors";
      op.OperatorGraph.AddOperator(urrvg);
      sp2.AddSubOperator(urrvg);

      Sorter s = new Sorter();
      s.GetVariableInfo("Descending").ActualName = "Maximization";
      s.GetVariableInfo("Value").ActualName = "Quality";
      op.OperatorGraph.AddOperator(s);
      sp1.AddSubOperator(s);

      return op;
    }
    private static CombinedOperator CreateESMain() {
      CombinedOperator op = new CombinedOperator();
      SequentialProcessor sp = new SequentialProcessor();
      op.OperatorGraph.AddOperator(sp);
      op.OperatorGraph.InitialOperator = sp;

      ESRandomSelector rs = new ESRandomSelector();
      rs.Name = "Child Selector";
      rs.GetVariableInfo("Lambda").ActualName = "ESlambda";
      rs.GetVariableInfo("Rho").ActualName = "ESrho";
      op.OperatorGraph.AddOperator(rs);
      sp.AddSubOperator(rs);

      SequentialSubScopesProcessor ssp = new SequentialSubScopesProcessor();
      op.OperatorGraph.AddOperator(ssp);
      sp.AddSubOperator(ssp);

      EmptyOperator eo = new EmptyOperator();
      op.OperatorGraph.AddOperator(eo);
      ssp.AddSubOperator(eo);

      CombinedOperator co1 = CreateCreateChildren();
      co1.Name = "Create Children";
      op.OperatorGraph.AddOperator(co1);
      ssp.AddSubOperator(co1);

      ConditionalBranch cb1 = new ConditionalBranch();
      cb1.Name = "Plus or Comma Replacement";
      cb1.GetVariableInfo("Condition").ActualName = "PlusNotation";
      op.OperatorGraph.AddOperator(cb1);
      sp.AddSubOperator(cb1);

      MergingReducer mr = new MergingReducer();
      mr.Name = "Plus Replacement";
      op.OperatorGraph.AddOperator(mr);
      cb1.AddSubOperator(mr);

      RightReducer rr = new RightReducer();
      rr.Name = "Comma Replacement";
      op.OperatorGraph.AddOperator(rr);
      cb1.AddSubOperator(rr);

      CombinedOperator co2 = CreateReplacement();
      co2.Name = "Parents Selection";
      op.OperatorGraph.AddOperator(co2);
      sp.AddSubOperator(co2);

      QualityLogger ql = new QualityLogger();
      op.OperatorGraph.AddOperator(ql);
      sp.AddSubOperator(ql);

      BestAverageWorstQualityCalculator bawqc = new BestAverageWorstQualityCalculator();
      op.OperatorGraph.AddOperator(bawqc);
      sp.AddSubOperator(bawqc);

      DataCollector dc = new DataCollector();
      ItemList<StringData> names = dc.GetVariable("VariableNames").GetValue<ItemList<StringData>>();
      names.Add(new StringData("BestQuality"));
      names.Add(new StringData("AverageQuality"));
      names.Add(new StringData("WorstQuality"));
      op.OperatorGraph.AddOperator(dc);
      sp.AddSubOperator(dc);

      LinechartInjector lci = new LinechartInjector();
      lci.GetVariableInfo("Linechart").ActualName = "Quality Linechart";
      lci.GetVariable("NumberOfLines").GetValue<IntData>().Data = 3;
      op.OperatorGraph.AddOperator(lci);
      sp.AddSubOperator(lci);

      Counter c = new Counter();
      c.GetVariableInfo("Value").ActualName = "Generations";
      op.OperatorGraph.AddOperator(c);
      sp.AddSubOperator(c);

      LessThanComparator ltc = new LessThanComparator();
      ltc.GetVariableInfo("LeftSide").ActualName = "Generations";
      ltc.GetVariableInfo("RightSide").ActualName = "MaximumGenerations";
      ltc.GetVariableInfo("Result").ActualName = "GenerationsCondition";
      op.OperatorGraph.AddOperator(ltc);
      sp.AddSubOperator(ltc);

      ConditionalBranch cb2 = new ConditionalBranch();
      cb2.GetVariableInfo("Condition").ActualName = "GenerationsCondition";
      op.OperatorGraph.AddOperator(cb2);
      sp.AddSubOperator(cb2);

      cb2.AddSubOperator(sp);

      return op;
    }
    private static CombinedOperator CreateCreateChildren() {
      CombinedOperator op = new CombinedOperator();
      SequentialProcessor sp1 = new SequentialProcessor();
      op.OperatorGraph.AddOperator(sp1);
      op.OperatorGraph.InitialOperator = sp1;

      GreaterThanComparator gtc = new GreaterThanComparator();
      gtc.GetVariableInfo("LeftSide").ActualName = "ESrho";
      gtc.GetVariableInfo("RightSide").Local = true;
      gtc.AddVariable(new Variable("RightSide", new IntData(1)));
      gtc.GetVariableInfo("Result").ActualName = "UseRecombination";
      op.OperatorGraph.AddOperator(gtc);
      sp1.AddSubOperator(gtc);

      ConditionalBranch cb = new ConditionalBranch();
      cb.Name = "Use recombination?";
      cb.GetVariableInfo("Condition").ActualName = "UseRecombination";
      op.OperatorGraph.AddOperator(cb);
      sp1.AddSubOperator(cb);

      SequentialProcessor sp2 = new SequentialProcessor();
      op.OperatorGraph.AddOperator(sp2);
      cb.AddSubOperator(sp2);

      ChildrenInitializer ci = new ChildrenInitializer();
      ci.GetVariableInfo("ParentsPerChild").Local = false;
      ci.RemoveVariable("ParentsPerChild");
      ci.GetVariableInfo("ParentsPerChild").ActualName = "ESrho";
      op.OperatorGraph.AddOperator(ci);
      sp2.AddSubOperator(ci);

      UniformSequentialSubScopesProcessor ussp0 = new UniformSequentialSubScopesProcessor();
      op.OperatorGraph.AddOperator(ussp0);
      sp2.AddSubOperator(ussp0);

      SequentialProcessor sp3 = new SequentialProcessor();
      op.OperatorGraph.AddOperator(sp3);
      ussp0.AddSubOperator(sp3);

      OperatorExtractor oe1 = new OperatorExtractor();
      oe1.Name = "Recombinator";
      oe1.GetVariableInfo("Operator").ActualName = "Recombinator";
      op.OperatorGraph.AddOperator(oe1);
      sp3.AddSubOperator(oe1);

      UniformSequentialSubScopesProcessor ussp = new UniformSequentialSubScopesProcessor();
      op.OperatorGraph.AddOperator(ussp);
      cb.AddSubOperator(ussp);

      SequentialProcessor sp4 = new SequentialProcessor();
      op.OperatorGraph.AddOperator(sp4);
      ussp.AddSubOperator(sp4);

      OperatorExtractor oe2 = new OperatorExtractor();
      oe2.Name = "Mutator";
      oe2.GetVariableInfo("Operator").ActualName = "Mutator";
      op.OperatorGraph.AddOperator(oe2);
      sp4.AddSubOperator(oe2);

      OperatorExtractor oe3 = new OperatorExtractor();
      oe3.Name = "Evaluator";
      oe3.GetVariableInfo("Operator").ActualName = "Evaluator";
      op.OperatorGraph.AddOperator(oe3);
      sp4.AddSubOperator(oe3);

      Counter c = new Counter();
      c.GetVariableInfo("Value").ActualName = "EvaluatedSolutions";
      op.OperatorGraph.AddOperator(c);
      sp4.AddSubOperator(c);

      sp3.AddSubOperator(oe2);
      sp3.AddSubOperator(oe3);
      sp3.AddSubOperator(c);

      SubScopesRemover ssr = new SubScopesRemover();
      ssr.GetVariableInfo("SubScopeIndex").Local = true;
      op.OperatorGraph.AddOperator(ssr);
      sp3.AddSubOperator(ssr);

      Sorter s = new Sorter();
      s.GetVariableInfo("Value").ActualName = "Quality";
      s.GetVariableInfo("Descending").ActualName = "Maximization";
      op.OperatorGraph.AddOperator(s);
      sp1.AddSubOperator(s);

      return op;
    }
    private static CombinedOperator CreateReplacement() {
      CombinedOperator op = new CombinedOperator();
      SequentialProcessor sp1 = new SequentialProcessor();
      op.OperatorGraph.AddOperator(sp1);
      op.OperatorGraph.InitialOperator = sp1;

      Sorter s = new Sorter();
      s.GetVariableInfo("Descending").ActualName = "Maximization";
      s.GetVariableInfo("Value").ActualName = "Quality";
      op.OperatorGraph.AddOperator(s);
      sp1.AddSubOperator(s);

      LeftSelector ls = new LeftSelector();
      ls.Name = "Parents Selector";
      ls.GetVariableInfo("Selected").ActualName = "ESmu";
      ls.GetVariable("CopySelected").Value = new BoolData(false);
      op.OperatorGraph.AddOperator(ls);
      sp1.AddSubOperator(ls);

      RightReducer rr = new RightReducer();
      rr.Name = "RightReducer";
      op.OperatorGraph.AddOperator(rr);
      sp1.AddSubOperator(rr);

      return op;
    }
    #endregion

    #region Properties
    private IEngine myEngine;
    /// <summary>
    /// Gets the engine of the current instance.
    /// </summary>
    public IEngine Engine {
      get { return myEngine; }
    }
    private BoolData mySetSeedRandomly;
    /// <summary>
    /// Gets or sets the boolean flag whether to set the seed randomly or not.
    /// </summary>
    public bool SetSeedRandomly {
      get { return mySetSeedRandomly.Data; }
      set { mySetSeedRandomly.Data = value; }
    }
    private IntData mySeed;
    /// <summary>
    /// Gets or sets the seed of the current instance.
    /// </summary>
    /// <remarks>Calls <see cref="ItemBase.OnChanged"/> of base class <see cref="ItemBase"/> 
    /// in the setter.</remarks>
    public int Seed {
      get { return mySeed.Data; }
      set {
        mySeed.Data = value;
        OnChanged();
      }
    }
    private IntData myMu;
    /// <summary>
    /// Gets or sets the µ value of the current instance.
    /// </summary>
    /// <remarks>Sets also the λ and the ρ value if necessary. Using the comma notation it must hold that λ >= µ and generally µ >= ρ must hold as well. Calls <see cref="ItemBase.OnChanged"/> of
    /// base class <see cref="ItemBase"/>.</remarks>
    public int Mu {
      get { return myMu.Data; }
      set {
        if (value > 0) {
          myMu.Data = value;
          if (!PlusNotation && value > Lambda) myLambda.Data = value;
          if (value < Rho) myRho.Data = value;
          OnChanged();
        }
      }
    }
    private IntData myRho;
    /// <summary>
    /// Gets or sets the ρ value of the current instance.
    /// </summary>
    /// <remarks>Sets also the µ value to be as large as the new ρ value if it was smaller before. Calls <see cref="ItemBase.OnChanged"/> of
    /// base class <see cref="ItemBase"/>.</remarks>
    public int Rho {
      get { return myRho.Data; }
      set {
        if (value > 0) {
          myRho.Data = value;
          if (value > Mu) Mu = value;
          OnChanged();
        }
      }
    }
    private IntData myLambda;
    /// <summary>
    /// Gets or sets the λ value of the current instance.
    /// </summary>
    /// <remarks>If the comma notation is used, it also changes the µ value to be as large as the new λ value if it was larger before. Note that in general for good optimization results it needs to be fairly larger than mu.
    /// Calls <see cref="ItemBase.OnChanged"/> of base class <see cref="ItemBase"/>.</remarks>
    public int Lambda {
      get { return myLambda.Data; }
      set {
        if (value > 0) {
          if (PlusNotation) myLambda.Data = value;
          else {
            if (value >= 1 && value < Mu) {
              myLambda.Data = value;
              myMu.Data = value;
            } else if (value >= Mu) {
              myLambda.Data = value;
            }
          }
          OnChanged();
        }
      }
    }
    private BoolData myPlusNotation;
    /// <summary>
    /// Gets or sets the boolean flag whether the plus notation is used (true) or the comma notation (false).
    /// </summary>
    /// <remarks>If set to false (comma notation) it sets λ to be as large as µ if is lower. Note that in general for good optimization results it needs to be fairly larger than µ. 
    /// Calls <see cref="ItemBase.OnChanged"/> of base class <see cref="ItemBase"/>.</remarks>
    public bool PlusNotation {
      get { return myPlusNotation.Data; }
      set {
        if (!value && myPlusNotation.Data) { // from plus to point
          if (Lambda < Mu) {
            myLambda.Data = Mu;
          }
        }
        myPlusNotation.Data = value;
        OnChanged();
      }
    }
    private IntData myProblemDimension;
    /// <summary>
    /// Gets or sets the problem dimension which determines the length of the strategy vector.
    /// </summary>
    /// <remarks>Calls <see cref="ItemBase.OnChanged"/> of base class <see cref="ItemBase"/> 
    /// in the setter.</remarks>
    public int ProblemDimension {
      get { return myProblemDimension.Data; }
      set { myProblemDimension.Data = value; }
    }
    private DoubleData myShakingFactorsMin;
    /// <summary>
    /// Gets or sets the minimal value for each dimension of the strategy vector.
    /// </summary>
    /// <remarks>Calls <see cref="ItemBase.OnChanged"/> of base class <see cref="ItemBase"/> 
    /// in the setter.</remarks>
    public double ShakingFactorsMin {
      get { return myShakingFactorsMin.Data; }
      set {
        myShakingFactorsMin.Data = value;
        OnChanged();
      }
    }
    private DoubleData myShakingFactorsMax;
    /// <summary>
    /// Gets or sets the maximal value for each dimension of the strategy vector.
    /// </summary>
    /// <remarks>Calls <see cref="ItemBase.OnChanged"/> of base class <see cref="ItemBase"/> 
    /// in the setter.</remarks>
    public double ShakingFactorsMax {
      get { return myShakingFactorsMax.Data; }
      set {
        myShakingFactorsMax.Data = value;
        OnChanged();
      }
    }
    private DoubleData myGeneralLearningRate;
    /// <summary>
    /// Gets or sets the general learning rate (tau0).
    /// </summary>
    /// <remarks>Calls <see cref="ItemBase.OnChanged"/> of base class <see cref="ItemBase"/> 
    /// in the setter.</remarks>
    public double GeneralLearningRate {
      get { return myGeneralLearningRate.Data; }
      set {
        if (value > 0.0 && value <= 1.0) {
          myGeneralLearningRate.Data = value;
          OnChanged();
        }
      }
    }
    private DoubleData myLearningRate;
    /// <summary>
    /// Gets or sets the learning rate (tau).
    /// </summary>
    /// <remarks>Calls <see cref="ItemBase.OnChanged"/> of base class <see cref="ItemBase"/> 
    /// in the setter.</remarks>
    public double LearningRate {
      get { return myLearningRate.Data; }
      set {
        if (value > 0.0 && value <= 1.0) {
          myLearningRate.Data = value;
          OnChanged();
        }
      }
    }
    private IntData myMaximumGenerations;
    /// <summary>
    /// Gets or sets the maximum number of generations.
    /// </summary>
    public int MaximumGenerations {
      get { return myMaximumGenerations.Data; }
      set { myMaximumGenerations.Data = value; }
    }
    private CombinedOperator myES;
    private IOperator myESMain;
    private IOperator myVariableInjection;
    /// <summary>
    /// Gets or sets the problem injection operator.
    /// </summary>
    public IOperator ProblemInjector {
      get { return myVariableInjection.SubOperators[0]; }
      set {
        myVariableInjection.GetVariableInfo("ProblemInjector").ActualName = value.Name;
        myES.OperatorGraph.RemoveOperator(ProblemInjector.Guid);
        myES.OperatorGraph.AddOperator(value);
        myVariableInjection.AddSubOperator(value, 0);
      }
    }
    private IOperator myPopulationInitialization;
    /// <summary>
    /// Gets or sets the solution generation operator.
    /// </summary>
    public IOperator SolutionGenerator {
      get { return myPopulationInitialization.SubOperators[0]; }
      set {
        myPopulationInitialization.GetVariableInfo("SolutionGenerator").ActualName = value.Name;
        myES.OperatorGraph.RemoveOperator(SolutionGenerator.Guid);
        myES.OperatorGraph.AddOperator(value);
        myPopulationInitialization.AddSubOperator(value, 0);
      }
    }
    /// <summary>
    /// Gets or sets the evaluation operator.
    /// </summary>
    public IOperator Evaluator {
      get { return myPopulationInitialization.SubOperators[1]; }
      set {
        myPopulationInitialization.GetVariableInfo("Evaluator").ActualName = value.Name;
        myESMain.GetVariableInfo("Evaluator").ActualName = value.Name;
        myES.OperatorGraph.RemoveOperator(Evaluator.Guid);
        myES.OperatorGraph.AddOperator(value);
        myPopulationInitialization.AddSubOperator(value, 1);
        myESMain.AddSubOperator(value, 1);
      }
    }
    /// <summary>
    /// Gets or sets the mutation operator. 
    /// </summary>
    public IOperator Mutator {
      get { return myESMain.SubOperators[0]; }
      set {
        myESMain.GetVariableInfo("Mutator").ActualName = value.Name;
        myES.OperatorGraph.RemoveOperator(Mutator.Guid);
        myES.OperatorGraph.AddOperator(value);
        myESMain.AddSubOperator(value, 0);
      }
    }
    /// <summary>
    /// Gets or sets the recombination operator.
    /// </summary>
    public IOperator Recombinator {
      get { return myESMain.SubOperators[2]; }
      set {
        myESMain.GetVariableInfo("Recombinator").ActualName = value.Name;
        myES.OperatorGraph.RemoveOperator(Recombinator.Guid);
        myES.OperatorGraph.AddOperator(value);
        myESMain.AddSubOperator(value, 2);
      }
    }
    #endregion

    /// <summary>
    /// Initializes a new instance of <see cref="ES"/> having a <see cref="SequentialEngine"/> as engine.
    /// </summary>
    public ES() {
      myEngine = new SequentialEngine.SequentialEngine();
      Create(myEngine);
      SetReferences();
    }

    /// <summary>
    /// Creates a new instance of <see cref="ESEditor"/> to display the current instance.
    /// </summary>
    /// <returns>The created view as <see cref="ESEditor"/>.</returns>
    public override IView CreateView() {
      return new ESEditor(this);
    }
    /// <summary>
    /// Creates a new instance of <see cref="ESEditor"/> to display the current instance.
    /// </summary>
    /// <returns>The created editor as <see cref="ESEditor"/>.</returns>
    public virtual IEditor CreateEditor() {
      return new ESEditor(this);
    }

    /// <summary>
    /// Clones the current instance (deep clone).
    /// </summary>
    /// <remarks>Uses <see cref="Auxiliary.Clone"/> method of the <see cref="Auxiliary"/> class to 
    /// clone the engine.</remarks>
    /// <param name="clonedObjects">A dictionary of all already cloned objects. 
    /// (Needed to avoid cycles.)</param>
    /// <returns>The cloned object as <see cref="ES"/>.</returns>
    public override object Clone(IDictionary<Guid, object> clonedObjects) {
      ES clone = new ES();
      clonedObjects.Add(Guid, clone);
      clone.myEngine = (IEngine)Auxiliary.Clone(Engine, clonedObjects);
      return clone;
    }

    #region SetReferences Method
    private void SetReferences() {
      // ES
      CombinedOperator co1 = (CombinedOperator)Engine.OperatorGraph.InitialOperator;
      myES = co1;
      // SequentialProcessor in ES
      SequentialProcessor sp1 = (SequentialProcessor)co1.OperatorGraph.InitialOperator;
      // Variable Injection
      CombinedOperator co2 = (CombinedOperator)sp1.SubOperators[0];
      myVariableInjection = co2;
      // SequentialProcessor in Variable Injection
      SequentialProcessor sp2 = (SequentialProcessor)co2.OperatorGraph.InitialOperator;
      // RandomInjector
      RandomInjector ri = (RandomInjector)sp2.SubOperators[0];
      mySetSeedRandomly = ri.GetVariable("SetSeedRandomly").GetValue<BoolData>();
      mySeed = ri.GetVariable("Seed").GetValue<IntData>();
      // VariableInjector
      VariableInjector vi = (VariableInjector)sp2.SubOperators[2];
      myMu = vi.GetVariable("ESmu").GetValue<IntData>();
      myRho = vi.GetVariable("ESrho").GetValue<IntData>();
      myLambda = vi.GetVariable("ESlambda").GetValue<IntData>();
      myMaximumGenerations = vi.GetVariable("MaximumGenerations").GetValue<IntData>();
      myPlusNotation = vi.GetVariable("PlusNotation").GetValue<BoolData>();
      myProblemDimension = vi.GetVariable("ProblemDimension").GetValue<IntData>();
      myShakingFactorsMin = vi.GetVariable("ShakingFactorsMin").GetValue<DoubleData>();
      myShakingFactorsMax = vi.GetVariable("ShakingFactorsMax").GetValue<DoubleData>();
      myGeneralLearningRate = vi.GetVariable("GeneralLearningRate").GetValue<DoubleData>();
      myLearningRate = vi.GetVariable("LearningRate").GetValue<DoubleData>();
      // Population Initialization
      CombinedOperator co3 = (CombinedOperator)sp1.SubOperators[1];
      myPopulationInitialization = co3;
      // ES Main
      CombinedOperator co4 = (CombinedOperator)sp1.SubOperators[2];
      myESMain = co4;
    }
    #endregion

    #region Persistence Methods
    /// <summary>
    /// Saves the current instance as <see cref="XmlNode"/> in the specified <paramref name="document"/>.
    /// </summary>
    /// <remarks>Calls <see cref="StorableBase.GetXmlNode"/> of base class <see cref="ItemBase"/>. 
    /// <br/>The engine of the current instance is saved as child node with tag name <c>Engine</c>.</remarks>
    /// <param name="name">The (tag)name of the <see cref="XmlNode"/>.</param>
    /// <param name="document">The <see cref="XmlDocument"/> where to save the data.</param>
    /// <param name="persistedObjects">The dictionary of all already persisted objects. 
    /// (Needed to avoid cycles.)</param>
    /// <returns>The saved <see cref="XmlNode"/>.</returns>
    public override XmlNode GetXmlNode(string name, XmlDocument document, IDictionary<Guid, IStorable> persistedObjects) {
      XmlNode node = base.GetXmlNode(name, document, persistedObjects);
      node.AppendChild(PersistenceManager.Persist("Engine", Engine, document, persistedObjects));
      return node;
    }
    /// <summary>
    /// Loads the persisted ES from the specified <paramref name="node"/>.
    /// </summary>
    /// <remarks>Calls <see cref="StorableBase.Populate"/> of base class <see cref="ItemBase"/>.<br/>
    /// The engine must be saved as child node with tag name <c>Engine</c> (see 
    /// <see cref="GetXmlNode"/>).</remarks>
    /// <param name="node">The <see cref="XmlNode"/> where the value is saved.</param>
    /// <param name="restoredObjects">The dictionary of all already restored objects. 
    /// (Needed to avoid cycles.)</param>
    public override void Populate(XmlNode node, IDictionary<Guid, IStorable> restoredObjects) {
      base.Populate(node, restoredObjects);
      myEngine = (IEngine)PersistenceManager.Restore(node.SelectSingleNode("Engine"), restoredObjects);
      SetReferences();
    }
    #endregion
  }
}