parse_quantity

Makefile

@@ -22,11 +22,7 @@ DEPFILE := $(OBJDIR)/$(TARGETNAME).d
 
 DFLAGS := $(DFLAGS) -preview=bitfields -preview=rvaluerefparam -preview=nosharedaccess -preview=in
 
-ifeq ($(OS),windows)
-SOURCES := $(shell dir /s /b $(SRCDIR)\\*.d)
-else
 SOURCES := $(shell find "$(SRCDIR)" -type f -name '*.d')
-endif
 
 # Set target file based on build type and OS
 ifeq ($(BUILD_TYPE),exe)
@@ -93,30 +89,19 @@ else
 endif
 
 ifeq ($(CONFIG),unittest)
-    DFLAGS := $(DFLAGS) -unittest
+    DFLAGS := $(DFLAGS) -unittest -main
 endif
 
 -include $(DEPFILE)
 
 $(TARGET):
-ifeq ($(OS),windows)
-	@if not exist "obj" mkdir "obj" > nul 2>&1
-	@if not exist "$(subst /,\,$(OBJDIR))" mkdir "$(subst /,\,$(OBJDIR))" > nul 2>&1
-	@if not exist "bin" mkdir "bin" > nul 2>&1
-	@if not exist "$(subst /,\,$(TARGETDIR))" mkdir "$(subst /,\,$(TARGETDIR))" > nul 2>&1
-else
 	mkdir -p $(OBJDIR) $(TARGETDIR)
-endif
 ifeq ($(D_COMPILER),ldc)
 	"$(DC)" $(DFLAGS) $(BUILD_CMD_FLAGS) -of$(TARGET) -od$(OBJDIR) -deps=$(DEPFILE) $(SOURCES)
 else ifeq ($(D_COMPILER),dmd)
 ifeq ($(BUILD_TYPE),lib)
-	"$(DC)" $(DFLAGS) $(BUILD_CMD_FLAGS) -of$(notdir $(TARGET)) -od$(OBJDIR) -makedeps $(SOURCES) > $(DEPFILE)
-ifeq ($(OS),windows)
-	move "$(subst /,\,$(OBJDIR))\\$(notdir $(TARGET))" "$(subst /,\,$(TARGETDIR))" > nul
-else
+	"$(DC)" $(DFLAGS) $(BUILD_CMD_FLAGS) -of$(OBJDIR)/$(notdir $(TARGET)) -od$(OBJDIR) -makedeps $(SOURCES) > $(DEPFILE)
 	mv "$(OBJDIR)/$(notdir $(TARGET))" "$(TARGETDIR)"
-endif
 else # exe
 	"$(DC)" $(DFLAGS) $(BUILD_CMD_FLAGS) -of$(TARGET) -od$(OBJDIR) -makedeps $(SOURCES) > $(DEPFILE)
 endif

src/urt/algorithm.d

@@ -1,6 +1,7 @@
 module urt.algorithm;
 
-import urt.traits : lvalueOf;
+import urt.meta : AliasSeq;
+import urt.traits : is_some_function, lvalue_of, Parameters, ReturnType, Unqual;
 import urt.util : swap;
 
 version = SmallSize;
@@ -10,36 +11,44 @@ nothrow @nogc:
 
 auto compare(T, U)(auto ref T a, auto ref U b)
 {
-    static if (__traits(compiles, lvalueOf!T.opCmp(lvalueOf!U)))
+    static if (__traits(compiles, a.opCmp(b)))
         return a.opCmp(b);
-    else static if (__traits(compiles, lvalueOf!U.opCmp(lvalueOf!T)))
+    else static if (__traits(compiles, b.opCmp(a)))
         return -b.opCmp(a);
-    else static if (is(T : A[], A))
+    else static if (is(T : A[], A) || is(U : B[], B))
     {
-        import urt.traits : isPrimitive;
+        import urt.traits : is_primitive;
+
+        static assert(is(T : A[], A) && is(U : B[], B), "TODO: compare an array with a not-array?");
 
         auto ai = a.ptr;
         auto bi = b.ptr;
-        size_t len = a.length < b.length ? a.length : b.length;
-        static if (isPrimitive!A)
+
+        // first compere the pointers...
+        if (ai !is bi)
         {
-            // compare strings
-            foreach (i; 0 .. len)
+            size_t len = a.length < b.length ? a.length : b.length;
+            static if (is_primitive!A)
             {
-                if (ai[i] != bi[i])
-                    return ai[i] < bi[i] ? -1 : 1;
+                // compare strings
+                foreach (i; 0 .. len)
+                {
+                    if (ai[i] != bi[i])
+                        return ai[i] < bi[i] ? -1 : 1;
+                }
             }
-        }
-        else
-        {
-            // compare arrays
-            foreach (i; 0 .. len)
+            else
             {
-                auto cmp = compare(ai[i], bi[i]);
-                if (cmp != 0)
-                    return cmp;
+                // compare arrays
+                foreach (i; 0 .. len)
+                {
+                    if (auto cmp = compare(ai[i], bi[i]))
+                        return cmp;
+                }
             }
         }
+
+        // finally, compare the lengths
         if (a.length == b.length)
             return 0;
         return a.length < b.length ? -1 : 1;
@@ -48,8 +57,39 @@ auto compare(T, U)(auto ref T a, auto ref U b)
         return a < b ? -1 : (a > b ? 1 : 0);
 }
 
-size_t binarySearch(alias pred = void, T, Cmp...)(T[] arr, auto ref Cmp cmpArgs)
+size_t binary_search(Pred)(const void[] arr, size_t stride, const void* value, auto ref Pred pred)
+    if (is_some_function!Pred && is(ReturnType!Pred == int) && is(Parameters!Pred == AliasSeq!(const void*, const void*)))
 {
+    debug assert(arr.length % stride == 0, "array length must be a multiple of stride");
+    const count = arr.length / stride;
+
+    const void* p = arr.ptr;
+    size_t low = 0;
+    size_t high = count;
+    while (low < high)
+    {
+        size_t mid = low + (high - low) / 2;
+
+        // should we chase the first in a sequence of same values?
+        int cmp = pred(p + mid*stride, value);
+        if (cmp < 0)
+            low = mid + 1;
+        else
+            high = mid;
+    }
+    if (low == count)
+        return count;
+    if (pred(p + low*stride, value) == 0)
+        return low;
+    return count;
+}
+
+size_t binary_search(alias pred = void, T, Cmp...)(T[] arr, auto ref Cmp cmp_args)
+    if (!is(Unqual!T == void))
+{
+    static if (is(pred == void))
+        static assert (cmp_args.length == 1, "binary_search without a predicate requires exactly one comparison argument");
+
     T* p = arr.ptr;
     size_t low = 0;
     size_t high = arr.length;
@@ -59,90 +99,105 @@ size_t binarySearch(alias pred = void, T, Cmp...)(T[] arr, auto ref Cmp cmpArgs)
         static if (is(pred == void))
         {
             // should we chase the first in a sequence of same values?
-            if (p[mid] < cmpArgs[0])
+            if (p[mid] < cmp_args[0])
                 low = mid + 1;
             else
                 high = mid;
         }
         else
         {
             // should we chase the first in a sequence of same values?
-            int cmp = pred(p[mid], cmpArgs);
+            int cmp = pred(p[mid], cmp_args);
             if (cmp < 0)
                 low = mid + 1;
             else
                 high = mid;
         }
     }
+    if (low == arr.length)
+        return arr.length;
     static if (is(pred == void))
     {
-        if (p[low] == cmpArgs[0])
+        if (p[low] == cmp_args[0])
             return low;
     }
     else
     {
-        if (pred(p[low], cmpArgs) == 0)
+        if (pred(p[low], cmp_args) == 0)
             return low;
     }
     return arr.length;
 }
 
 
-void qsort(alias pred = void, T)(T[] arr)
+void qsort(alias pred = void, T)(T[] arr) pure
 {
+    if (arr.length <= 1)
+        return;
+
     version (SmallSize)
+        enum use_small_size_impl = true;
+    else
+        enum use_small_size_impl = false;
+
+    if (!__ctfe && use_small_size_impl)
     {
         static if (is(pred == void))
-            static if (__traits(compiles, lvalueOf!T.opCmp(lvalueOf!T)))
-                static int compare(const void* a, const void* b) nothrow @nogc
+            static if (__traits(compiles, lvalue_of!T.opCmp(lvalue_of!T)))
+                static int compare(const void* a, const void* b) pure nothrow @nogc
                     => (*cast(const T*)a).opCmp(*cast(const T*)b);
             else
-                static int compare(const void* a, const void* b) nothrow @nogc
+                static int compare(const void* a, const void* b) pure nothrow @nogc
                     => *cast(const T*)a < *cast(const T*)b ? -1 : *cast(const T*)a > *cast(const T*)b ? 1 : 0;
         else
-            static int compare(const void* a, const void* b) nothrow @nogc
+            static int compare(const void* a, const void* b) pure nothrow @nogc
                 => pred(*cast(T*)a, *cast(T*)b);
 
-        qsort(arr[], T.sizeof, &compare, (void* a, void* b) nothrow @nogc {
+        qsort(arr[], T.sizeof, &compare, (void* a, void* b) pure nothrow @nogc {
                   swap(*cast(T*)a, *cast(T*)b);
               });
     }
     else
     {
         T* p = arr.ptr;
-        if (arr.length > 1)
-        {
-            size_t pivotIndex = arr.length / 2;
-            T* pivot = &p[pivotIndex];
+        const n = cast(ptrdiff_t)arr.length;
+
+        size_t pivotIndex = n / 2;
+        T* pivot = p + pivotIndex;
 
-            size_t i = 0;
-            size_t j = arr.length - 1;
+        size_t i = 0;
+        ptrdiff_t j = n - 1;
 
-            while (i <= j)
+        while (i <= j)
+        {
+            static if (is(pred == void))
             {
-                static if (is(pred == void))
-                {
-                    while (p[i] < *pivot) i++;
-                    while (p[j] > *pivot) j--;
-                }
-                else
-                {
-                    while (pred(*cast(T*)&p[i], *cast(T*)pivot) < 0) i++;
-                    while (pred(*cast(T*)&p[j], *cast(T*)pivot) > 0) j--;
-                }
-                if (i <= j)
-                {
-                    swap(p[i], p[j]);
-                    i++;
-                    j--;
-                }
+                while (p[i] < *pivot) ++i;
+                while (p[j] > *pivot) --j;
             }
+            else
+            {
+                while (pred(p[i], *pivot) < 0) ++i;
+                while (pred(p[j], *pivot) > 0) --j;
+            }
+            if (i <= j)
+            {
+                // track pivot value across swaps
+                if (p + i == pivot)
+                    pivot = p + j;
+                else if (p + j == pivot)
+                    pivot = p + i;
 
-            if (j > 0)
-                qsort(p[0 .. j + 1]);
-            if (i < arr.length)
-                qsort(p[i .. arr.length]);
+                swap(p[i], p[j]);
+                ++i;
+                --j;
+            }
         }
+
+        if (j >= 0)
+            qsort!pred(p[0 .. j + 1]);
+        if (i < n)
+            qsort!pred(p[i .. n]);
     }
 }
 
@@ -151,26 +206,26 @@ unittest
     struct S
     {
         int x;
-        int opCmp(ref const S rh) const nothrow @nogc
+        int opCmp(ref const S rh) pure const nothrow @nogc
             => x < rh.x ? -1 : x > rh.x ? 1 : 0;
     }
 
     int[5] arr = [3, 100, -1, 17, 30];
     qsort(arr);
     assert(arr == [-1, 3, 17, 30, 100]);
 
-    S[5] arr2 = [ S(3), S(100), S(-1), S(17), S(30)];
+    S[5] arr2 = [ S(3), S(100), S(-1), S(17), S(30) ];
     qsort(arr2);
     foreach (i, ref s; arr2)
         assert(s.x == arr[i]);
 
     // test binary search, not that they're sorted...
-    assert(binarySearch(arr, -1) == 0);
-    assert(binarySearch!(s => s.x < 30 ? -1 : s.x > 30 ? 1 : 0)(arr2) == 3);
-    assert(binarySearch(arr, 0) == arr.length);
+    assert(binary_search(arr, -1) == 0);
+    assert(binary_search!(s => s.x < 30 ? -1 : s.x > 30 ? 1 : 0)(arr2) == 3);
+    assert(binary_search(arr, 0) == arr.length);
 
     int[10] rep = [1, 10, 10, 10, 10, 10, 10, 10, 10, 100];
-    assert(binarySearch(rep, 10) == 1);
+    assert(binary_search(rep, 10) == 1);
 }
 
 
@@ -181,34 +236,36 @@ version (SmallSize)
     // just one generic implementation to minimise the code...
     // kinda slow though... look at all those multiplies!
     // maybe there's some way to make this faster :/
-    void qsort(void[] arr, size_t elementSize, int function(const void* a, const void* b) nothrow @nogc compare, void function(void* a, void* b) nothrow @nogc swap)
+    void qsort(void[] arr, size_t element_size, int function(const void* a, const void* b) pure nothrow @nogc compare, void function(void* a, void* b) pure nothrow @nogc swap) pure
     {
         void* p = arr.ptr;
-        size_t length = arr.length / elementSize;
-        if (length > 1)
-        {
-            size_t pivotIndex = length / 2;
-            void* pivot = p + pivotIndex*elementSize;
+        size_t length = arr.length / element_size;
+        if (length <= 1)
+            return;
+
+        size_t pivot_index = length / 2;
+        size_t last = length - 1;
+        swap(p + pivot_index*element_size, p + last*element_size);
 
-            size_t i = 0;
-            size_t j = length - 1;
+        void* pivot = p + last*element_size;
 
-            while (i <= j)
+        size_t partition = 0;
+        for (size_t k = 0; k < last; ++k)
+        {
+            void* elem = p + k*element_size;
+            if (compare(elem, pivot) < 0)
             {
-                while (compare(p + i*elementSize, pivot) < 0) i++;
-                while (compare(p + j*elementSize, pivot) > 0) j--;
-                if (i <= j)
-                {
-                    swap(p + i*elementSize, p + j*elementSize);
-                    i++;
-                    j--;
-                }
+                if (k != partition)
+                    swap(elem, p + partition*element_size);
+                ++partition;
             }
-
-            if (j > 0)
-                qsort(p[0 .. (j + 1)*elementSize], elementSize, compare, swap);
-            if (i < length)
-                qsort(p[i*elementSize .. length*elementSize], elementSize, compare, swap);
         }
+
+        swap(p + partition*element_size, p + last*element_size);
+
+        if (partition > 1)
+            qsort(p[0 .. partition*element_size], element_size, compare, swap);
+        if (partition + 1 < length)
+            qsort(p[(partition + 1)*element_size .. length*element_size], element_size, compare, swap);
     }
 }