added sort measurement

Author: Morfly

src/kotlin/sequential/sorting/_measurement/BUILD

@@ -3,6 +3,6 @@ load("@io_bazel_rules_kotlin//kotlin:kotlin.bzl", "kt_jvm_library")
 package(default_visibility = ["//sequential/sorting:__subpackages__"])
 
 kt_jvm_library(
-    name = "_measurement",
+    name = "measurement",
     srcs = glob(["*.kt"]),
 )

src/kotlin/sequential/sorting/_measurement/MeasuredElements.kt

@@ -0,0 +1,92 @@
+package sequential.sorting._measurement
+
+
+abstract class MeasuredCollection<T : Comparable<T>> {
+
+    private var comparisons: Int = 0
+    private var exchanges: Int = 0
+    private var halfExchanges: Int = 0
+
+
+    fun beginMeasurement() {
+        comparisons = 0
+        exchanges = 0
+        halfExchanges = 0
+    }
+
+    fun <R> endMeasurement(algorithmResult: R) =
+        MeasurementResult(algorithmResult, comparisons, exchanges, halfExchanges)
+
+    fun exch(i: Int, j: Int) {
+        exchanges++
+        this[i] = this[j].also { this[j] = this[i] }
+    }
+    
+    fun onCompare() {
+        comparisons++
+    }
+
+    operator fun set(index: Int, value: MeasuredElement<T>) {
+        halfExchanges++
+        setAt(index, value)
+    }
+
+    operator fun get(index: Int) = getAt(index)
+
+
+    abstract fun setAt(index: Int, value: MeasuredElement<T>)
+
+    abstract fun getAt(index: Int): MeasuredElement<T>
+}
+
+class MeasuredElement<T : Comparable<T>>(
+    private val measurer: MeasuredCollection<T>,
+    val value: T
+) {
+
+    operator fun compareTo(other: MeasuredElement<T>): Int {
+        measurer.onCompare()
+        return value.compareTo(other.value)
+    }
+
+    operator fun compareTo(other: T): Int {
+        measurer.onCompare()
+        return value.compareTo(other)
+    }
+}
+
+data class MeasurementResult<R>(
+    val algorithmOutput: R,
+    val comparisons: Int,
+    val exchanges: Int,
+    val halfExchanges: Int
+) {
+    val totalExchanges = exchanges + halfExchanges / 2.0
+
+    @Suppress("IMPLICIT_CAST_TO_ANY")
+    override fun toString() = """
+            Algorithm output: ${if (algorithmOutput !is Unit) algorithmOutput else "N/A"}
+            Number of comparisons: $comparisons
+            Number of exchanges: $exchanges
+            Number of half-exchanges: $halfExchanges
+            Total number of exchanges: $totalExchanges
+        """.trimIndent()
+}
+
+class MeasuredIntArray(private val array: IntArray) : MeasuredCollection<Int>() {
+
+    override fun getAt(index: Int) = MeasuredElement(this, array[index])
+
+    override fun setAt(index: Int, value: MeasuredElement<Int>) {
+        array[index] = value.value
+    }
+}
+
+
+fun <R> IntArray.measured(algorithm: MeasuredIntArray.() -> R): MeasurementResult<R> {
+    val measuredArray = MeasuredIntArray(array = this)
+    return measuredArray
+        .apply { beginMeasurement() }
+        .run(algorithm)
+        .let { measuredArray.endMeasurement(algorithmResult = it) }
+}

src/kotlin/sequential/sorting/_measurement/SortMeasurement.kt

@@ -0,0 +1,8 @@
+load("@io_bazel_rules_kotlin//kotlin:kotlin.bzl", "kt_jvm_library")
+
+package(default_visibility = ["//sequential/sorting:__subpackages__"])
+
+kt_jvm_library(
+    name = "test_base",
+    srcs = glob(["*.kt"]),
+)

src/kotlin/sequential/sorting/_test/BUILD

@@ -5,9 +5,10 @@ kt_jvm_library(
     srcs = [
         "InsertionSort.kt",
         "RangedInsertionSort.kt",
+        "_measurement/MeasuredInsertionSort.kt"
     ],
     deps = [
-        "//sequential/sorting/_measurement",
+        "//sequential/sorting/_measurement:measurement",
         "//:utils",
     ],
     visibility = ["//visibility:public"],
@@ -23,4 +24,10 @@ java_binary(
     name = "insertion_sort_ranged",
     main_class = "sequential.sorting.insertionsort.RangedInsertionSortKt",
     runtime_deps = [":insertion_sort_lib"],
+)
+
+java_binary(
+    name = "insertion_sort_measured",
+    main_class = "sequential.sorting.insertionsort._measurement.MeasuredInsertionSortKt",
+    runtime_deps = [":insertion_sort_lib"],
 )

src/kotlin/sequential/sorting/insertionsort/BUILD

@@ -0,0 +1,42 @@
+package sequential.sorting.insertionsort._measurement
+
+import sequential.sorting._measurement.*
+import _util.*
+
+
+fun IntArray.insertionSort() = measured {
+
+    // Setting sentinel
+    var exchanges = 0
+    for (i in lastIndex downTo 1) {
+        if (this[i] < this[i - 1]) {
+            exch(i, i - 1)
+            exchanges++
+        }
+    }
+    if (exchanges == 0) return@measured
+
+    // Actual insertion sort
+    for (i in 2..lastIndex) {
+        var j = i
+        val arri = this[i]
+        while (arri < this[j - 1]) {
+            this[j] = this[j - 1]
+            j--
+        }
+        this[j] = arri
+    }
+}
+
+
+fun main() {
+    val array = randomIntArray(size = 20)
+    array.print()
+
+    val measurement = array.insertionSort()
+
+    println("Sorting is successful: ${array.isSorted()}")
+    array.print()
+
+    println("$measurement")
+}

src/kotlin/sequential/sorting/insertionsort/_measurement/MeasuredInsertionSort.kt

@@ -8,8 +8,8 @@ kt_jvm_library(
     ] + glob(["partition/*.kt"]),
     deps = [
         "//sequential/sorting/insertionsort:insertion_sort_lib",
-        "//sequential/sorting/_measurement",
-        "//:utils"
+        "//sequential/sorting/_measurement:measurement",
+        "//:utils",
     ]
 )
 

src/kotlin/sequential/sorting/quicksort/BUILD

@@ -0,0 +1,3 @@
+package sequential.sorting.quicksort._measurement
+
+