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

Timestamp:

03/28/08 14:28:10 (17 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/DiscreteMultiCrossover.cs (moved) (moved from trunk/sources/HeuristicLab.RealVector/DiscreteRecombination.cs) (1 diff)

trunk/sources/HeuristicLab.RealVector/DiscreteMultiCrossover.cs

@@ -27 +27 @@
 
 namespace HeuristicLab.RealVector {
-  public class DiscreteRecombination : OperatorBase {
+  public class DiscreteMultiCrossover : RealVectorMultiCrossoverBase {
     public override string Description {
       get {
-        return @"Discrete/dominant recombination creates a new offspring by combining the alleles in the parents such that each allele is randomly selected from one parent";
+        return @"This creates a new offspring by combining the alleles in the parents such that each allele is randomly selected from one parent";
       }
     }
 
-    public DiscreteRecombination()
-      : base() {
-      AddVariableInfo(new VariableInfo("Random", "Pseudo random number generator", typeof(IRandom), VariableKind.In));
-      AddVariableInfo(new VariableInfo("Rho", "Amount of parents to recombine", typeof(IntData), VariableKind.In));
-      AddVariableInfo(new VariableInfo("RealVector", "Parent and child real vector", typeof(DoubleArrayData), VariableKind.In | VariableKind.New));
+    public static double[] Apply(IRandom random, IList<double[]> parents) {
+      int length = parents[0].Length;
+      double[] result = new double[length];
+      try {
+        for (int i = 0; i < length; i++) {
+          result[i] = parents[random.Next(parents.Count)][i];
+        }
+      } catch (IndexOutOfRangeException) {
+        throw new InvalidOperationException("Cannot apply multicrossover to real vectors of different length.");
+      }
+      return result;
     }
 
-    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);
-
-      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();
-        parents.Clear();
-        for (int j = 0; j < rho; j++) {
-          IScope parent = scope.SubScopes[0];
-          parents.Add(parent.GetVariableValue<DoubleArrayData>("RealVector", false).Data);
-          scope.RemoveSubScope(parent);
-        }
-        // actual discrete recombination
-        for (int x = 0; x < childGene.Length; x++) {
-          childGene[x] = parents[random.Next(rho)][x];
-        }
-        childScope.AddVariable(new Variable(scope.SubScopes[0].TranslateName("RealVector"), new DoubleArrayData(childGene)));
-        scope.AddSubScope(childScope);
-      }
-      return null;
+    protected override double[] Cross(IScope scope, IRandom random, IList<double[]> parents) {
+      return Apply(random, parents);
     }
   }