stdlib: Add sort functions for primitive arrays

runtime/src/main/kotlin/kotlin/util/Sort.kt

@@ -18,7 +18,10 @@ package kotlin.util
 
 import kotlin.comparisons.*
 
+// TODO: Implement sort for primitives with a custom comparator.
+
 // Yes, rather naive qsort for now.
+// Array<T>     =============================================================================
 private fun <T> partition(array: Array<T>, left: Int, right: Int): Int {
     var i = left
     var j = right
@@ -80,6 +83,255 @@ private fun <T> quickSort(
         quickSort(array, index, right, comparator)
 }
 
+// ByteArray    =============================================================================
+private fun partition(
+        array: ByteArray, left: Int, right: Int): Int {
+    var i = left
+    var j = right
+    val pivot = array[(left + right) / 2]
+    while (i <= j) {
+        while (array[i] < pivot)
+            i++
+        while (array[j] > pivot)
+            j--
+        if (i <= j) {
+            val tmp = array[i]
+            array[i] = array[j]
+            array[j] = tmp
+            i++
+            j--
+        }
+    }
+    return i
+}
+
+private fun quickSort(
+        array: ByteArray, left: Int, right: Int) {
+    val index = partition(array, left, right)
+    if (left < index - 1)
+        quickSort(array, left, index - 1)
+    if (index < right)
+        quickSort(array, index, right)
+}
+
+// ShortArray   =============================================================================
+private fun partition(
+        array: ShortArray, left: Int, right: Int): Int {
+    var i = left
+    var j = right
+    val pivot = array[(left + right) / 2]
+    while (i <= j) {
+        while (array[i] < pivot)
+            i++
+        while (array[j] > pivot)
+            j--
+        if (i <= j) {
+            val tmp = array[i]
+            array[i] = array[j]
+            array[j] = tmp
+            i++
+            j--
+        }
+    }
+    return i
+}
+
+private fun quickSort(
+        array: ShortArray, left: Int, right: Int) {
+    val index = partition(array, left, right)
+    if (left < index - 1)
+        quickSort(array, left, index - 1)
+    if (index < right)
+        quickSort(array, index, right)
+}
+
+// IntArray     =============================================================================
+private fun partition(
+        array: IntArray, left: Int, right: Int): Int {
+    var i = left
+    var j = right
+    val pivot = array[(left + right) / 2]
+    while (i <= j) {
+        while (array[i] < pivot)
+            i++
+        while (array[j] > pivot)
+            j--
+        if (i <= j) {
+            val tmp = array[i]
+            array[i] = array[j]
+            array[j] = tmp
+            i++
+            j--
+        }
+    }
+    return i
+}
+
+private fun quickSort(
+        array: IntArray, left: Int, right: Int) {
+    val index = partition(array, left, right)
+    if (left < index - 1)
+        quickSort(array, left, index - 1)
+    if (index < right)
+        quickSort(array, index, right)
+}
+
+// LongArray    =============================================================================
+private fun partition(
+        array: LongArray, left: Int, right: Int): Int {
+    var i = left
+    var j = right
+    val pivot = array[(left + right) / 2]
+    while (i <= j) {
+        while (array[i] < pivot)
+            i++
+        while (array[j] > pivot)
+            j--
+        if (i <= j) {
+            val tmp = array[i]
+            array[i] = array[j]
+            array[j] = tmp
+            i++
+            j--
+        }
+    }
+    return i
+}
+
+private fun quickSort(
+        array: LongArray, left: Int, right: Int) {
+    val index = partition(array, left, right)
+    if (left < index - 1)
+        quickSort(array, left, index - 1)
+    if (index < right)
+        quickSort(array, index, right)
+}
+
+// CharArray    =============================================================================
+private fun partition(
+        array: CharArray, left: Int, right: Int): Int {
+    var i = left
+    var j = right
+    val pivot = array[(left + right) / 2]
+    while (i <= j) {
+        while (array[i] < pivot)
+            i++
+        while (array[j] > pivot)
+            j--
+        if (i <= j) {
+            val tmp = array[i]
+            array[i] = array[j]
+            array[j] = tmp
+            i++
+            j--
+        }
+    }
+    return i
+}
+
+private fun quickSort(
+        array: CharArray, left: Int, right: Int) {
+    val index = partition(array, left, right)
+    if (left < index - 1)
+        quickSort(array, left, index - 1)
+    if (index < right)
+        quickSort(array, index, right)
+}
+
+// FloatArray   =============================================================================
+private fun partition(
+        array: FloatArray, left: Int, right: Int): Int {
+    var i = left
+    var j = right
+    val pivot = array[(left + right) / 2]
+    while (i <= j) {
+        while (array[i] < pivot)
+            i++
+        while (array[j] > pivot)
+            j--
+        if (i <= j) {
+            val tmp = array[i]
+            array[i] = array[j]
+            array[j] = tmp
+            i++
+            j--
+        }
+    }
+    return i
+}
+
+private fun quickSort(
+        array: FloatArray, left: Int, right: Int) {
+    val index = partition(array, left, right)
+    if (left < index - 1)
+        quickSort(array, left, index - 1)
+    if (index < right)
+        quickSort(array, index, right)
+}
+
+// DoubleArray  =============================================================================
+private fun partition(
+        array: DoubleArray, left: Int, right: Int): Int {
+    var i = left
+    var j = right
+    val pivot = array[(left + right) / 2]
+    while (i <= j) {
+        while (array[i] < pivot)
+            i++
+        while (array[j] > pivot)
+            j--
+        if (i <= j) {
+            val tmp = array[i]
+            array[i] = array[j]
+            array[j] = tmp
+            i++
+            j--
+        }
+    }
+    return i
+}
+
+private fun quickSort(
+        array: DoubleArray, left: Int, right: Int) {
+    val index = partition(array, left, right)
+    if (left < index - 1)
+        quickSort(array, left, index - 1)
+    if (index < right)
+        quickSort(array, index, right)
+}
+
+// BooleanArray =============================================================================
+private fun partition(
+        array: BooleanArray, left: Int, right: Int): Int {
+    var i = left
+    var j = right
+    val pivot = array[(left + right) / 2]
+    while (i <= j) {
+        while (array[i] < pivot)
+            i++
+        while (array[j] > pivot)
+            j--
+        if (i <= j) {
+            val tmp = array[i]
+            array[i] = array[j]
+            array[j] = tmp
+            i++
+            j--
+        }
+    }
+    return i
+}
+
+private fun quickSort(
+        array: BooleanArray, left: Int, right: Int) {
+    val index = partition(array, left, right)
+    if (left < index - 1)
+        quickSort(array, left, index - 1)
+    if (index < right)
+        quickSort(array, index, right)
+}
+
+// Interfaces   =============================================================================
 internal fun <T> sortArrayWith(
         array: Array<out T>, fromIndex: Int, toIndex: Int, comparator: Comparator<T>) {
     @Suppress("UNCHECKED_CAST")
@@ -89,4 +341,13 @@ internal fun <T> sortArrayWith(
 internal fun <T> sortArrayComparable(array: Array<out T>) {
     @Suppress("UNCHECKED_CAST")
     quickSort(array as Array<T>, 0, array.size - 1)
-}
+}
+
+internal fun sortArray(array: ByteArray)    = quickSort(array, 0, array.size - 1)
+internal fun sortArray(array: ShortArray)   = quickSort(array, 0, array.size - 1)
+internal fun sortArray(array: IntArray)     = quickSort(array, 0, array.size - 1)
+internal fun sortArray(array: LongArray)    = quickSort(array, 0, array.size - 1)
+internal fun sortArray(array: CharArray)    = quickSort(array, 0, array.size - 1)
+internal fun sortArray(array: FloatArray)   = quickSort(array, 0, array.size - 1)
+internal fun sortArray(array: DoubleArray)  = quickSort(array, 0, array.size - 1)
+internal fun sortArray(array: BooleanArray) = quickSort(array, 0, array.size - 1)