Index: /trunk/sources/HeuristicLab.Algorithms.EvolutionStrategy/3.3/EvolutionStrategyMainLoop.cs
===================================================================
--- /trunk/sources/HeuristicLab.Algorithms.EvolutionStrategy/3.3/EvolutionStrategyMainLoop.cs	(revision 3182)
+++ /trunk/sources/HeuristicLab.Algorithms.EvolutionStrategy/3.3/EvolutionStrategyMainLoop.cs	(revision 3183)
@@ -28,4 +28,5 @@
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 using HeuristicLab.Selection;
+using HeuristicLab.Encodings.RealVectorEncoding;
 
 namespace HeuristicLab.Algorithms.EvolutionStrategy {
@@ -58,4 +59,7 @@
       get { return (ValueLookupParameter<IntValue>)Parameters["Children"]; }
     }
+    public ValueLookupParameter<RealVector> StrategyVectorParameter {
+      get { return (ValueLookupParameter<RealVector>)Parameters["StrategyVector"]; }
+    }
     public ValueLookupParameter<DoubleMatrix> StrategyVectorBoundsParameter {
       get { return (ValueLookupParameter<DoubleMatrix>)Parameters["StrategyVectorBounds"]; }
@@ -117,4 +121,5 @@
       Parameters.Add(new ValueLookupParameter<IntValue>("Children", "λ (lambda) - the size of the offspring population."));
       Parameters.Add(new ValueLookupParameter<IntValue>("MaximumGenerations", "The maximum number of generations which should be processed."));
+      Parameters.Add(new ValueLookupParameter<RealVector>("StrategyVector", "The strategy vector."));
       Parameters.Add(new LookupParameter<DoubleMatrix>("StrategyVectorBounds", "2 column matrix with one row for each dimension specifying upper and lower bound for the strategy vector. If there are less rows than dimensions, the strategy vector will be read in a cycle."));
       Parameters.Add(new ValueLookupParameter<DoubleValue>("GeneralLearningRate", "τ0 (tau0) - the factor with which adjustments in the strategy vector is dampened over all dimensions. Recommendation is to use 1/Sqrt(2*ProblemDimension)."));
@@ -146,8 +151,10 @@
       UniformSequentialSubScopesProcessor uniformSequentialSubScopesProcessor1 = new UniformSequentialSubScopesProcessor();
       Placeholder recombinator = new Placeholder();
+      StrategyVectorManipulator strategyMutator1 = new StrategyVectorManipulator();
       Placeholder mutator1 = new Placeholder();
       Placeholder evaluator1 = new Placeholder();
       SubScopesRemover subScopesRemover = new SubScopesRemover();
       UniformSequentialSubScopesProcessor uniformSequentialSubScopesProcessor2 = new UniformSequentialSubScopesProcessor();
+      StrategyVectorManipulator strategyMutator2 = new StrategyVectorManipulator();
       Placeholder mutator2 = new Placeholder();
       Placeholder evaluator2 = new Placeholder();
@@ -228,4 +235,9 @@
       recombinator.OperatorParameter.ActualName = RecombinatorParameter.Name;
 
+      strategyMutator1.StrategyVectorParameter.ActualName = StrategyVectorParameter.Name;
+      strategyMutator1.GeneralLearningRateParameter.ActualName = GeneralLearningRateParameter.Name;
+      strategyMutator1.LearningRateParameter.ActualName = LearningRateParameter.Name;
+      strategyMutator1.RandomParameter.ActualName = RandomParameter.Name;
+
       mutator1.Name = "Mutator (placeholder)";
       mutator1.OperatorParameter.ActualName = MutatorParameter.Name;
@@ -235,4 +247,9 @@
 
       subScopesRemover.RemoveAllSubScopes = true;
+
+      strategyMutator2.StrategyVectorParameter.ActualName = StrategyVectorParameter.Name;
+      strategyMutator2.GeneralLearningRateParameter.ActualName = GeneralLearningRateParameter.Name;
+      strategyMutator2.LearningRateParameter.ActualName = LearningRateParameter.Name;
+      strategyMutator2.RandomParameter.ActualName = RandomParameter.Name;
 
       mutator2.Name = "Mutator (placeholder)";
@@ -310,10 +327,12 @@
       uniformSequentialSubScopesProcessor1.Operator = recombinator;
       uniformSequentialSubScopesProcessor1.Successor = null;
-      recombinator.Successor = mutator1;
+      recombinator.Successor = strategyMutator1;
+      strategyMutator1.Successor = mutator1;
       mutator1.Successor = evaluator1;
       evaluator1.Successor = subScopesRemover;
       subScopesRemover.Successor = null;
-      uniformSequentialSubScopesProcessor2.Operator = mutator2;
+      uniformSequentialSubScopesProcessor2.Operator = strategyMutator2;
       uniformSequentialSubScopesProcessor2.Successor = null;
+      strategyMutator2.Successor = mutator2;
       mutator2.Successor = evaluator2;
       plusOrCommaReplacementBranch.TrueBranch = plusReplacement;
Index: /trunk/sources/HeuristicLab.Algorithms.EvolutionStrategy/3.3/HeuristicLab.Algorithms.EvolutionStrategy-3.3.csproj
===================================================================
--- /trunk/sources/HeuristicLab.Algorithms.EvolutionStrategy/3.3/HeuristicLab.Algorithms.EvolutionStrategy-3.3.csproj	(revision 3182)
+++ /trunk/sources/HeuristicLab.Algorithms.EvolutionStrategy/3.3/HeuristicLab.Algorithms.EvolutionStrategy-3.3.csproj	(revision 3183)
@@ -84,5 +84,7 @@
     <Compile Include="EvolutionStrategy.cs" />
     <Compile Include="EvolutionStrategyMainLoop.cs" />
-    <Compile Include="WithoutRepeatingRandomSelector.cs" />
+    <Compile Include="SelfAdaptiveCrossover.cs" />
+    <Compile Include="StrategyVectorManipulator.cs" />
+    <Compile Include="WithoutRepeatingBatchedRandomSelector.cs" />
   </ItemGroup>
   <ItemGroup>
Index: /trunk/sources/HeuristicLab.Algorithms.EvolutionStrategy/3.3/SelfAdaptiveCrossover.cs
===================================================================
--- /trunk/sources/HeuristicLab.Algorithms.EvolutionStrategy/3.3/SelfAdaptiveCrossover.cs	(revision 3183)
+++ /trunk/sources/HeuristicLab.Algorithms.EvolutionStrategy/3.3/SelfAdaptiveCrossover.cs	(revision 3183)
@@ -0,0 +1,68 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 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.Core;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Encodings.RealVectorEncoding;
+
+namespace HeuristicLab.Algorithms.EvolutionStrategy {
+  public class SelfAdaptiveCrossover : SingleSuccessorOperator, ICrossover, IStochasticOperator {
+    public override bool CanChangeName {
+      get { return false; }
+    }
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
+    }
+    public ValueParameter<IRealVectorCrossover> StrategyVectorCrossoverParameter {
+      get { return (ValueParameter<IRealVectorCrossover>)Parameters["StrategyVectorCrossover"]; }
+    }
+    public ConstrainedValueParameter<ICrossover> CrossoverParameter {
+      get { return (ConstrainedValueParameter<ICrossover>)Parameters["Crossover"]; }
+    }
+
+    public IRealVectorCrossover StrategyVectorCrossover {
+      get { return StrategyVectorCrossoverParameter.Value; }
+      set { StrategyVectorCrossoverParameter.Value = value; }
+    }
+    public ICrossover Crossover {
+      get { return CrossoverParameter.Value; }
+      set { CrossoverParameter.Value = value; }
+    }
+
+    public SelfAdaptiveCrossover()
+      : base() {
+      Parameters.Add(new LookupParameter<IRandom>("Random", "The random number generator to use."));
+      Parameters.Add(new ValueParameter<IRealVectorCrossover>("StrategyVectorCrossover", "The crossover operator for the strategy vectors.", new AverageCrossover()));
+      Parameters.Add(new ConstrainedValueParameter<ICrossover>("Crossover", "The solution specific crossover operator."));
+    }
+
+    public override IOperation Apply() {
+      OperationCollection next = new OperationCollection();
+      next.Add(ExecutionContext.CreateOperation(StrategyVectorCrossover));
+      if (Crossover != null)
+        next.Add(ExecutionContext.CreateOperation(Crossover));
+      next.Add(base.Apply());
+      return next;
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.Algorithms.EvolutionStrategy/3.3/StrategyVectorManipulator.cs
===================================================================
--- /trunk/sources/HeuristicLab.Algorithms.EvolutionStrategy/3.3/StrategyVectorManipulator.cs	(revision 3183)
+++ /trunk/sources/HeuristicLab.Algorithms.EvolutionStrategy/3.3/StrategyVectorManipulator.cs	(revision 3183)
@@ -0,0 +1,91 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 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.Core;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Encodings.RealVectorEncoding;
+using HeuristicLab.Data;
+using HeuristicLab.Random;
+using System;
+
+namespace HeuristicLab.Algorithms.EvolutionStrategy {
+  /// <summary>
+  /// Mutates the endogenous strategy parameters.
+  /// </summary>
+  public class StrategyVectorManipulator : SingleSuccessorOperator, IStochasticOperator {
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
+    }
+    public ILookupParameter<RealVector> StrategyVectorParameter {
+      get { return (ILookupParameter<RealVector>)Parameters["StrategyVector"]; }
+    }
+    public IValueLookupParameter<DoubleValue> GeneralLearningRateParameter {
+      get { return (IValueLookupParameter<DoubleValue>)Parameters["GeneralLearningRate"]; }
+    }
+    public IValueLookupParameter<DoubleValue> LearningRateParameter {
+      get { return (IValueLookupParameter<DoubleValue>)Parameters["LearningRate"]; }
+    }
+    /// <summary>
+    /// Initializes a new instance of <see cref="StrategyVectorManipulator"/> with four 
+    /// parameters (<c>Random</c>, <c>StrategyVector</c>, <c>GeneralLearningRate</c> and
+    /// <c>LearningRate</c>).
+    /// </summary>
+    public StrategyVectorManipulator()
+      : base() {
+      Parameters.Add(new LookupParameter<IRandom>("Random", "The random number generator to use."));
+      Parameters.Add(new LookupParameter<RealVector>("StrategyVector", "The strategy vector to manipulate."));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("GeneralLearningRate", "The general learning rate (tau0)."));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("LearningRate", "The learning rate (tau)."));
+    }
+
+    /// <summary>
+    /// Mutates the endogenous strategy parameters.
+    /// </summary>
+    /// <param name="random">The random number generator to use.</param>
+    /// <param name="vector">The strategy vector to manipulate.</param>
+    /// <param name="generalLearningRate">The general learning rate dampens the mutation over all dimensions.</param>
+    /// <param name="learningRate">The learning rate dampens the mutation in each dimension.</param>
+    public static void Apply(IRandom random, RealVector vector, double generalLearningRate, double learningRate) {
+      NormalDistributedRandom N = new NormalDistributedRandom(random, 0.0, 1.0);
+      double generalMultiplier = Math.Exp(generalLearningRate * N.NextDouble());
+      for (int i = 0; i < vector.Length; i++) {
+        vector[i] *= generalMultiplier * Math.Exp(learningRate * N.NextDouble());
+      }
+    }
+    /// <summary>
+    /// Mutates the endogenous strategy parameters.
+    /// </summary>
+    /// <remarks>Calls <see cref="OperatorBase.Apply"/> of base class <see cref="OperatorBase"/>.</remarks>
+    /// <inheritdoc select="returns"/>
+    public override IOperation Apply() {
+      RealVector strategyParams = StrategyVectorParameter.ActualValue;
+      if (strategyParams != null) { // only apply if there is a strategy vector
+        IRandom random = RandomParameter.ActualValue;
+        double tau0 = GeneralLearningRateParameter.ActualValue.Value;
+        double tau = LearningRateParameter.ActualValue.Value;
+        Apply(random, strategyParams, tau0, tau);
+      }
+      return base.Apply();
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.Algorithms.EvolutionStrategy/3.3/WithoutRepeatingBatchedRandomSelector.cs
===================================================================
--- /trunk/sources/HeuristicLab.Algorithms.EvolutionStrategy/3.3/WithoutRepeatingBatchedRandomSelector.cs	(revision 3183)
+++ /trunk/sources/HeuristicLab.Algorithms.EvolutionStrategy/3.3/WithoutRepeatingBatchedRandomSelector.cs	(revision 3183)
@@ -0,0 +1,80 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 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.Data;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Selection;
+
+namespace HeuristicLab.Algorithms.EvolutionStrategy {
+  [Item("WithoutRepeatingBatchedRandomSelector", "Selects m batches of n parents where in each batch the n parents are drawn without repeating.")]
+  [StorableClass]
+  public class WithoutRepeatingBatchedRandomSelector : StochasticSelector {
+    public override bool CanChangeName {
+      get { return true; }
+    }
+    public IValueLookupParameter<IntValue> ChildrenParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters["Children"]; }
+    }
+    public IValueLookupParameter<IntValue> ParentsPerChildParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters["ParentsPerChild"]; }
+    }
+
+    public WithoutRepeatingBatchedRandomSelector()
+      : base() {
+      Parameters.Add(new ValueLookupParameter<IntValue>("Children", "The number of children to select (number of batches)."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("ParentsPerChild", "The number of parents per child (size of each batch)."));
+    }
+
+    protected override IScope[] Select(List<IScope> scopes) {
+      IRandom random = RandomParameter.ActualValue;
+      int children = ChildrenParameter.ActualValue.Value;
+      int parents = ParentsPerChildParameter.ActualValue.Value;
+      int parentsAvailable = scopes.Count;
+
+      if (parents > parentsAvailable)
+        throw new InvalidOperationException("WithoutRepeatingBatchedRandomSelector: Cannot select more parents per child than there are parents available");
+
+      IScope[] result = new IScope[children * parents];
+      int count = 0;
+      HashSet<int> selectedParents = new HashSet<int>();
+      for (int i = 0; i < children; i++) {
+        selectedParents.Clear();
+        for (int j = 0; j < parents; j++) {
+          int nextParent = j; // will be used in case parents == parentsAvailable
+          if (parents < parentsAvailable) {
+            do {
+              nextParent = random.Next(parentsAvailable);
+            } while (selectedParents.Contains(nextParent));
+          }
+
+          result[count++] = (IScope)scopes[nextParent].Clone();
+          selectedParents.Add(nextParent);
+        }
+      }
+
+      return result;
+    }
+  }
+}
Index: unk/sources/HeuristicLab.Algorithms.EvolutionStrategy/3.3/WithoutRepeatingRandomSelector.cs
===================================================================
--- /trunk/sources/HeuristicLab.Algorithms.EvolutionStrategy/3.3/WithoutRepeatingRandomSelector.cs	(revision 3182)
+++ 	(revision )
@@ -1,80 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2010 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.Data;
-using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Selection;
-
-namespace HeuristicLab.Algorithms.EvolutionStrategy {
-  [Item("WithoutRepeatingBatchedRandomSelector", "Selects m batches of n parents where in each batch the n parents are drawn without repeating.")]
-  [StorableClass]
-  public class WithoutRepeatingBatchedRandomSelector : StochasticSelector {
-    public override bool CanChangeName {
-      get { return true; }
-    }
-    public IValueLookupParameter<IntValue> ChildrenParameter {
-      get { return (IValueLookupParameter<IntValue>)Parameters["Children"]; }
-    }
-    public IValueLookupParameter<IntValue> ParentsPerChildParameter {
-      get { return (IValueLookupParameter<IntValue>)Parameters["ParentsPerChild"]; }
-    }
-
-    public WithoutRepeatingBatchedRandomSelector()
-      : base() {
-      Parameters.Add(new ValueLookupParameter<IntValue>("Children", "The number of children to select (number of batches)."));
-      Parameters.Add(new ValueLookupParameter<IntValue>("ParentsPerChild", "The number of parents per child (size of each batch)."));
-    }
-
-    protected override IScope[] Select(List<IScope> scopes) {
-      IRandom random = RandomParameter.ActualValue;
-      int children = ChildrenParameter.ActualValue.Value;
-      int parents = ParentsPerChildParameter.ActualValue.Value;
-      int parentsAvailable = scopes.Count;
-
-      if (parents > parentsAvailable)
-        throw new InvalidOperationException("WithoutRepeatingBatchedRandomSelector: Cannot select more parents per child than there are parents available");
-
-      IScope[] result = new IScope[children * parents];
-      int count = 0;
-      HashSet<int> selectedParents = new HashSet<int>();
-      for (int i = 0; i < children; i++) {
-        selectedParents.Clear();
-        for (int j = 0; j < parents; j++) {
-          int nextParent = j; // will be used in case parents == parentsAvailable
-          if (parents < parentsAvailable) {
-            do {
-              nextParent = random.Next(parentsAvailable);
-            } while (selectedParents.Contains(nextParent));
-          }
-
-          result[count++] = (IScope)scopes[nextParent].Clone();
-          selectedParents.Add(nextParent);
-        }
-      }
-
-      return result;
-    }
-  }
-}
