Added changelog entries for min/maxIndex functions

Author: andralex

changelog.dd

@@ -8,12 +8,19 @@ $(BUGSTITLE Library Changes,
     $(LI $(RELATIVE_LINK2 promoted, Added `std.traits.Promoted` to get the result of
         $(LINK2 $(ROOT_DIR)spec/type.html#integer-promotions, scalar type promotion)
         in multi-term arithmetic expressions.))
+    $(LI $(RELATIVE_LINK2 staticIsSorted, Added `std.meta.staticIsSorted` to check if
+        an `AliasSeq` is sorted according to some template predicate.))
+	$(LI $(RELATIVE_LINK2 minIndex, Added `std.algorithm.searching.minIndex`
+		to get the index of the minimum element of a range.))
+	$(LI $(RELATIVE_LINK2 maxIndex, Added `std.algorithm.searching.maxIndex`
+		to get the index of the maximum element of a range.))
+
 )
 
 $(BUGSTITLE Library Changes,
 
 $(LI $(LNAME2 promoted, `std.traits.Promoted` gets the type to which a scalar type will
-    be promoted in multi-term arithmetic expressions)
+    be promoted in multi-term arithmetic expressions.)
 -------
 import std.traits : Promoted;
 static assert(is(typeof(ubyte(3) * ubyte(5)) == Promoted!ubyte));
@@ -23,6 +30,47 @@ static assert(is(Promoted!ubyte == int));
     scalar type promotions) for more information.)
 )
 
+$(LI $(LNAME2 staticIsSorted, `std.meta.staticIsSorted` checks whether an `AliasSeq` is
+    sorted according to some template predicate.)
+------
+enum Comp(T1, T2) = T1.sizeof < T2.sizeof;
+
+import std.meta : staticIsSorted;
+static assert( staticIsSorted!(Comp, byte, uint, double));
+static assert(!staticIsSorted!(Comp, bool, long, dchar));
+------
+    $(P Additionally, the compile-time performance of `std.meta.staticSort` has been
+    greatly improved. Nevertheless, due to compiler limitations it is still an
+    extraordinarily expensive operation to perform on longer sequences; strive to
+    minimize such use.)
+)
+
+$(LI $(LNAME2 minIndex, `std.algorithm.searching.minIndex` gets the index of
+	the minimum element of a range, according to a specified predicate. The
+	default predicate is "a < b")
+-------
+import std.algorithm.searching : minIndex;
+int[] a = [5, 4, 2, 1, 9, 10];
+assert(a.minIndex == 3);
+
+int[] a;
+assert(a.minIndex == -1);
+-------
+)
+
+$(LI $(LNAME2 maxIndex, `std.algorithm.searching.maxIndex` gets the index of
+	the maximum element of a range, according to a specified predicate. The
+	default predicate is "a > b")
+-------
+import std.algorithm.searching : maxIndex;
+int[] a = [5, 4, 2, 1, 9, 10];
+assert(a.minIndex == 5);
+
+int[] a;
+assert(a.minIndex == -1);
+-------
+)
+
 )
 
 Macros:

std/meta.d

@@ -44,10 +44,11 @@
  *           $(LREF anySatisfy)
  *           $(LREF staticIndexOf)
  * ))
- * $(TR $(TD Boolean template predicate operators) $(TD
+ * $(TR $(TD Template predicates) $(TD
  *           $(LREF templateAnd)
  *           $(LREF templateNot)
  *           $(LREF templateOr)
+ *           $(LREF staticIsSorted)
  * ))
  * $(TR $(TD Template instantiation) $(TD
  *           $(LREF ApplyLeft)
@@ -1393,9 +1394,15 @@ template staticSort(alias cmp, Seq...)
     }
     else
     {
-        private alias bottom = staticSort!(cmp, Seq[0 .. $ / 2]);
+        private alias btm = staticSort!(cmp, Seq[0 .. $ / 2]);
         private alias top = staticSort!(cmp, Seq[$ / 2 .. $]);
-        alias staticSort = staticMerge!(cmp, Seq.length / 2, bottom, top);
+
+        static if (isLessEq!(cmp, btm[$ - 1], top[0]))
+            alias staticSort = AliasSeq!(btm, top); // already ascending
+        else static if (isLessEq!(cmp, top[$ - 1], btm[0]))
+            alias staticSort = AliasSeq!(top, btm); // already descending
+        else
+            alias staticSort = staticMerge!(cmp, Seq.length / 2, btm, top);
     }
 }
 
@@ -1424,31 +1431,74 @@ private template staticMerge(alias cmp, int half, Seq...)
     }
     else
     {
-        private enum Result = cmp!(Seq[0], Seq[half]);
-        static if (is(typeof(Result) == bool))
-        {
-            private enum Check = Result;
-        }
-        else static if (is(typeof(Result) : int))
-        {
-            private enum Check = Result <= 0;
-        }
-        else
+        static if (isLessEq!(cmp, Seq[0], Seq[half]))
         {
-            static assert(0, typeof(Result).stringof ~ " is not a value comparison type");
-        }
-        static if (Check)
-        {
-            alias staticMerge = AliasSeq!(Seq[0], staticMerge!(cmp, half - 1, Seq[1 .. $]));
+            alias staticMerge = AliasSeq!(Seq[0],
+                staticMerge!(cmp, half - 1, Seq[1 .. $]));
         }
         else
         {
-            alias staticMerge = AliasSeq!(Seq[half], staticMerge!(cmp, half,
-                Seq[0 .. half], Seq[half + 1 .. $]));
+            alias staticMerge = AliasSeq!(Seq[half],
+                staticMerge!(cmp, half, Seq[0 .. half], Seq[half + 1 .. $]));
         }
     }
 }
 
+private template isLessEq(alias cmp, Seq...)
+    if (Seq.length == 2)
+{
+    private enum Result = cmp!(Seq[1], Seq[0]);
+    static if (is(typeof(Result) == bool))
+        enum isLessEq = !Result;
+    else static if (is(typeof(Result) : int))
+        enum isLessEq = Result >= 0;
+    else
+        static assert(0, typeof(Result).stringof ~ " is not a value comparison type");
+}
+
+/**
+ * Checks if an $(LREF AliasSeq) is sorted according to $(D cmp).
+ *
+ * Parameters:
+ *     cmp = A template that returns a $(D bool) (if its first argument is less than the second one)
+ *         or an $(D int) (-1 means less than, 0 means equal, 1 means greater than)
+ *
+ *     Seq = The  $(LREF AliasSeq) to check
+ *
+ * Returns: `true` if `Seq` is sorted; otherwise `false`
+ */
+template staticIsSorted(alias cmp, Seq...)
+{
+    static if (Seq.length <= 1)
+        enum staticIsSorted = true;
+    else static if (Seq.length == 2)
+        enum staticIsSorted = isLessEq!(cmp, Seq[0], Seq[1]);
+    else
+    {
+        enum staticIsSorted =
+            isLessEq!(cmp, Seq[($ / 2) - 1], Seq[$ / 2]) &&
+            staticIsSorted!(cmp, Seq[0 .. $ / 2]) &&
+            staticIsSorted!(cmp, Seq[$ / 2 .. $]);
+    }
+}
+
+///
+unittest
+{
+    enum Comp(int N1, int N2) = N1 < N2;
+    static assert( staticIsSorted!(Comp, 2, 2));
+    static assert( staticIsSorted!(Comp, 2, 3, 7, 23));
+    static assert(!staticIsSorted!(Comp, 7, 2, 3, 23));
+}
+
+///
+unittest
+{
+    enum Comp(T1, T2) = __traits(isUnsigned, T2) - __traits(isUnsigned, T1);
+    static assert( staticIsSorted!(Comp, uint, ubyte, ulong, short, long));
+    static assert(!staticIsSorted!(Comp, uint, short, ubyte, long, ulong));
+}
+
 // : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : //
 private: