Changeset 7415 for branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment.Common/3.3

Timestamp:

01/26/12 14:50:56 (13 years ago)

Author:

abeham

Message:

#1614: improved results output of GQAP

File:

• branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment.Common/3.3/ExtensionMethods.cs (modified) (2 diffs)

branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment.Common/3.3/ExtensionMethods.cs

@@ -27 +27 @@
 namespace HeuristicLab.Problems.GeneralizedQuadraticAssignment.Common {
   public static class ExtensionMethods {
-
-    /// <summary>
-    /// Simply enumerates the sequence by moving over all elements.
-    /// </summary>
-    /// <typeparam name="T">The type of the items that are to be enumerated.</typeparam>
-    /// <param name="source">The enumerable that contains the items.</param>
-    public static void Enumerate<T>(this IEnumerable<T> source) {
-      var enumerator = source.GetEnumerator();
-      while (enumerator.MoveNext()) ;
-    }
 
     /// <summary>
@@ -109 +99 @@
 
     /// <summary>
+    /// Selects the first element in the sequence where the selected key is the maximum.
+    /// </summary>
+    /// <remarks>
+    /// Runtime complexity of the operation is O(N).
+    /// </remarks>
+    /// <typeparam name="T">The type of the elements.</typeparam>
+    /// <typeparam name="TComparable">The selected key (needs to be an IComparable).</typeparam>
+    /// <param name="source">The enumeration in which the maximum item should be found.</param>
+    /// <param name="keySelector">The function that selects the key.</param>
+    /// <returns>The element in the enumeration where the selected key is the maximum.</returns>
+    public static T SelectMax<T, TComparable>(this IEnumerable<T> source, Func<T, TComparable> keySelector) where TComparable : IComparable {
+      IEnumerator<T> enumerator = source.GetEnumerator();
+      if (!enumerator.MoveNext()) throw new InvalidOperationException("Sequence is empty!");
+      T result = enumerator.Current;
+      TComparable max = keySelector(result);
+      while (enumerator.MoveNext()) {
+        T item = enumerator.Current;
+        TComparable comparison = keySelector(item);
+        if (comparison.CompareTo(max) > 0) {
+          result = item;
+          max = comparison;
+        }
+      }
+      return result;
+    }
+
+    /// <summary>
+    /// Selects the first element in the sequence where the selected key is the minimum.
+    /// </summary>
+    /// <remarks>
+    /// Runtime complexity of the operation is O(N).
+    /// </remarks>
+    /// <typeparam name="T">The type of the elements.</typeparam>
+    /// <typeparam name="TComparable">The selected key (needs to be an IComparable).</typeparam>
+    /// <param name="source">The enumeration in which the minimum item should be found.</param>
+    /// <param name="keySelector">The function that selects the key.</param>
+    /// <returns>The element in the enumeration where the selected key is the minimum.</returns>
+    public static T SelectMin<T, TComparable>(this IEnumerable<T> source, Func<T, TComparable> keySelector) where TComparable : IComparable {
+      IEnumerator<T> enumerator = source.GetEnumerator();
+      if (!enumerator.MoveNext()) throw new InvalidOperationException("Sequence is empty!");
+      T result = enumerator.Current;
+      TComparable min = keySelector(result);
+      while (enumerator.MoveNext()) {
+        T item = enumerator.Current;
+        TComparable comparison = keySelector(item);
+        if (comparison.CompareTo(min) < 0) {
+          result = item;
+          min = comparison;
+        }
+      }
+      return result;
+    }
+
+    /// <summary>
     /// Walks an operator graph in that it jumps from one operator to all its operator parameters and yields each operator it touches.
     /// Cycles are detected and not walked twice.