Changeset 12701

Timestamp:

07/09/15 23:11:18 (9 years ago)

Author:

abeham

Message:

#2319:

• Some code cleanup in LinearLinkage and updates to the documentation
• Fixed operator discovery in multi*operators
• Fixed bug in MultiLLEManipulator with respect to successful offspring analysis

Location:

trunk/sources/HeuristicLab.Encodings.LinearLinkageEncoding/3.3

Files:

• Crossovers/MultiLLECrossover.cs (modified) (2 diffs)
• LinearLinkage.cs (modified) (2 diffs)
• Manipulators/MultiLLEManipulator.cs (modified) (3 diffs)

trunk/sources/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Crossovers/MultiLLECrossover.cs

@@ -23 +23 @@
 using System.Collections.Generic;
 using System.Linq;
+using System.Reflection;
 using HeuristicLab.Collections;
 using HeuristicLab.Common;
@@ -61 +62 @@
       ChildParameter.ActualName = "LLE";
 
-      foreach (Type type in ApplicationManager.Manager.GetTypes(typeof(ILinearLinkageCrossover))) {
+      foreach (Type type in ApplicationManager.Manager.GetTypes(typeof(ILinearLinkageCrossover), typeof(LinearLinkageEncoding).Assembly)) {
         if (!typeof(MultiOperator<ILinearLinkageCrossover>).IsAssignableFrom(type))
           Operators.Add((ILinearLinkageCrossover)Activator.CreateInstance(type), true);

trunk/sources/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/LinearLinkage.cs

@@ -77 +77 @@
 
     /// <summary>
-    /// This method parses the encoded array and gathers all items that
-    /// belong to the same group as element <paramref name="index"/>.
-    /// </summary>
-    /// <param name="index">The element whose group should be returned.</param>
+    /// This method parses the encoded array and gathers all elements
+    /// that belong to the same group as element <paramref name="index"/>.
+    /// </summary>
+    /// <param name="index">The element whose group should be returned.
+    /// </param>
     /// <returns>The element at <paramref name="index"/> and all other
     /// elements in the same group.</returns>
     public IEnumerable<int> GetGroup(int index) {
-      // return current element
-      yield return index;
-      var next = array[index];
-      if (next == index) yield break;
-      int prev;
-      // return succeeding elements in group
-      do {
-        yield return next;
-        prev = next;
-        next = array[next];
-      } while (next != prev);
-      next = array[index];
-      // return preceding elements in group
-      for (prev = index - 1; prev >= 0; prev--) {
-        if (array[prev] != next) continue;
-        next = prev;
-        yield return next;
-      }
-    }
-
-    /// <summary>
-    /// This method parses the encoded array and gathers the item itself as
-    /// well as subsequent items that belong to the same group as element
-    /// <paramref name="index"/>.
-    /// </summary>
-    /// <param name="index">The element from which items in the group should
-    /// be returned.</param>
-    /// <returns>The element at <paramref name="index"/> and all subsequent
+      foreach (var n in GetGroupForward(index))
+        yield return n;
+      // the element index has already been yielded
+      foreach (var n in GetGroupBackward(index).Skip(1))
+        yield return n;
+    }
+
+    /// <summary>
+    /// This method parses the encoded array and gathers the element
+    /// <paramref name="index"/> as well as subsequent elements that
+    /// belong to the same group.
+    /// </summary>
+    /// <param name="index">The element from which subsequent (having a
+    /// larger number) elements in the group should be returned.
+    /// </param>
+    /// <returns>The element <paramref name="index"/> and all subsequent
     /// elements in the same group.</returns>
     public IEnumerable<int> GetGroupForward(int index) {
@@ -123 +112 @@
         next = array[next];
       } while (next != prev);
+    }
+
+    /// <summary>
+    /// This method parses the encoded array and gathers the element
+    /// given <paramref name="index"/> as well as preceeding elements that
+    /// belong to the same group.
+    /// </summary>
+    /// <remarks>
+    /// Warning, this code has performance O(index) as the array has to
+    /// be fully traversed backwards from the given index.
+    /// </remarks>
+    /// <param name="index">The element from which preceeding (having a
+    /// smaller number) elements in the group should be returned.
+    /// </param>
+    /// <returns>The element <paramref name="index"/> and all preceeding
+    /// elements in the same group.</returns>
+    public IEnumerable<int> GetGroupBackward(int index) {
+      yield return index;
+      var next = array[index];
+      // return preceding elements in group
+      for (var prev = index - 1; prev >= 0; prev--) {
+        if (array[prev] != next) continue;
+        next = prev;
+        yield return next;
+      }
     }
 

trunk/sources/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Manipulators/MultiLLEManipulator.cs

@@ -23 +23 @@
 using System.Collections.Generic;
 using System.Linq;
+using System.Reflection;
 using HeuristicLab.Collections;
 using HeuristicLab.Common;
@@ -53 +54 @@
       : base() {
       Parameters.Add(new LookupParameter<LinearLinkage>("LLE", "The encoding vector that is to be manipulated."));
-      foreach (Type type in ApplicationManager.Manager.GetTypes(typeof(ILinearLinkageManipulator))) {
+      foreach (Type type in ApplicationManager.Manager.GetTypes(typeof(ILinearLinkageManipulator), typeof(LinearLinkageEncoding).Assembly)) {
         if (!typeof(MultiOperator<ILinearLinkageManipulator>).IsAssignableFrom(type))
           Operators.Add((ILinearLinkageManipulator)Activator.CreateInstance(type), true);
@@ -59 +60 @@
       Operators.SetItemCheckedState(Operators.OfType<SwapItemManipulator>().First(), false);
       Operators.SetItemCheckedState(Operators.OfType<GraftManipulator>().First(), false);
-      SelectedOperatorParameter.ActualName = "SelectedManipulatorOperator";
+      SelectedOperatorParameter.ActualName = "SelectedManipulationOperator";
     }