Changeset 111 for trunk/sources/HeuristicLab.RealVector/SelfAdaptiveIntermediateMultiCrossover.cs

Timestamp:

03/28/08 14:28:10 (16 years ago)

Author:

abeham

Message:

Renamed Recombination operators to MultCrossover operators and added the necessary base classes (ticket #89)
Created a static Apply method that encapsulates the functionality of the operators (ticket #88)

File:

• trunk/sources/HeuristicLab.RealVector/SelfAdaptiveIntermediateMultiCrossover.cs (moved) (moved from trunk/sources/HeuristicLab.RealVector/SelfAdaptiveIntermediateRecombination.cs) (1 diff)

trunk/sources/HeuristicLab.RealVector/SelfAdaptiveIntermediateMultiCrossover.cs

@@ -27 +27 @@
 
 namespace HeuristicLab.RealVector {
-  public class SelfAdaptiveIntermediateRecombination : DiscreteRecombination {
+  public class SelfAdaptiveIntermediateMultiCrossover : RealVectorSelfAdaptiveMultiCrossoverBase {
     public override string Description {
       get {
-        return @"Self adaptive intermediate recombination creates a new offspring by computing the centroid of the parents. It will also use the same strategy to combine the endogenous strategy parameter vector.";
+        return @"This creates a new offspring by computing the centroid of the parents. It will also use the same strategy to combine the endogenous strategy parameter vector.";
       }
     }
 
-    public SelfAdaptiveIntermediateRecombination()
-      : base() {
-      AddVariableInfo(new VariableInfo("StrategyVector", "Vector containing the endogenous strategy parameters", typeof(DoubleArrayData), VariableKind.In));
+    public static void Apply(IList<double[]> parents, IList<double[]> strategyParametersList, out double[] childIndividual, out double[] strategyParameters) {
+      childIndividual = IntermediateMultiCrossover.Apply(parents);
+      strategyParameters = IntermediateMultiCrossover.Apply(strategyParametersList);
     }
 
-    public override IOperation Apply(IScope scope) {
-      int rho = GetVariableValue<IntData>("Rho", scope, true).Data;
-      // with just 1 parent no recombination is necessary/possible
-      if (rho == 1) return null;
-      IRandom random = GetVariableValue<IRandom>("Random", scope, true);
-
-      if (scope.SubScopes.Count % rho != 0)
-        throw new InvalidOperationException("Number of parents is not a multiple of rho");
-      int lambda = scope.SubScopes.Count / rho;
-      IList<double[]> parents = new List<double[]>(rho);
-      IList<double[]> parentsStrategy = new List<double[]>(rho);
-
-      for (int i = 0; i < lambda; i++) {
-        IScope childScope = new Scope(i.ToString());
-        double[] childGene = (double[])scope.SubScopes[0].GetVariableValue<DoubleArrayData>("RealVector", false).Data.Clone();
-        double[] strategyParams = (double[])scope.SubScopes[0].GetVariableValue<DoubleArrayData>("StrategyVector", false).Data.Clone();
-        parents.Clear();
-        for (int j = 0; j < rho; j++) {
-          IScope parent = scope.SubScopes[0];
-          parents.Add(parent.GetVariableValue<DoubleArrayData>("RealVector", false).Data);
-          parentsStrategy.Add(parent.GetVariableValue<DoubleArrayData>("StrategyVector", false).Data);
-          scope.RemoveSubScope(parent);
-        }
-        // actual discrete recombination
-        if (childGene.Length != strategyParams.Length)
-          throw new InvalidOperationException("ERROR: strategy vector must be as long as there are dimensions");
-
-        for (int x = 0; x < childGene.Length; x++) {
-          double sum = 0.0, sumStrategy = 0.0;
-          for (int y = 0; y < rho; y++) {
-            sum += parents[y][x];
-            sumStrategy += parentsStrategy[y][x];
-          }
-          childGene[x] = sum / rho;
-          strategyParams[x] = sumStrategy / rho;
-        }
-        childScope.AddVariable(new Variable(scope.SubScopes[0].TranslateName("RealVector"), new DoubleArrayData(childGene)));
-        childScope.AddVariable(new Variable(scope.SubScopes[0].TranslateName("StrategyVector"), new DoubleArrayData(strategyParams)));
-        scope.AddSubScope(childScope);
-      }
-      return null;
+    protected override void Cross(IScope scope, IRandom random, IList<double[]> parents, IList<double[]> strategyParametersList, out double[] childIndividual, out double[] strategyParameters) {
+      Apply(parents, strategyParametersList, out childIndividual, out strategyParameters);
     }
   }