forked from kscience/kmath
commit
4691caaa7f
@ -0,0 +1,55 @@
|
||||
/*
|
||||
* Copyright 2018-2021 KMath contributors.
|
||||
* Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
|
||||
*/
|
||||
|
||||
package space.kscience.kmath.misc
|
||||
|
||||
import kotlin.comparisons.*
|
||||
import space.kscience.kmath.structures.Buffer
|
||||
|
||||
/**
|
||||
* Return a new list filled with buffer indices. Indice order is defined by sorting associated buffer value.
|
||||
* This feature allows to sort buffer values without reordering its content.
|
||||
*
|
||||
* @return List of buffer indices, sorted by associated value.
|
||||
*/
|
||||
@PerformancePitfall
|
||||
@UnstableKMathAPI
|
||||
public fun <V: Comparable<V>> Buffer<V>.permSort() : IntArray = _permSortWith(compareBy<Int> { get(it) })
|
||||
|
||||
@PerformancePitfall
|
||||
@UnstableKMathAPI
|
||||
public fun <V: Comparable<V>> Buffer<V>.permSortDescending() : IntArray = _permSortWith(compareByDescending<Int> { get(it) })
|
||||
|
||||
@PerformancePitfall
|
||||
@UnstableKMathAPI
|
||||
public fun <V, C: Comparable<C>> Buffer<V>.permSortBy(selector: (V) -> C) : IntArray = _permSortWith(compareBy<Int> { selector(get(it)) })
|
||||
|
||||
@PerformancePitfall
|
||||
@UnstableKMathAPI
|
||||
public fun <V, C: Comparable<C>> Buffer<V>.permSortByDescending(selector: (V) -> C) : IntArray = _permSortWith(compareByDescending<Int> { selector(get(it)) })
|
||||
|
||||
@PerformancePitfall
|
||||
@UnstableKMathAPI
|
||||
public fun <V> Buffer<V>.permSortWith(comparator : Comparator<V>) : IntArray = _permSortWith { i1, i2 -> comparator.compare(get(i1), get(i2)) }
|
||||
|
||||
@PerformancePitfall
|
||||
@UnstableKMathAPI
|
||||
private fun <V> Buffer<V>._permSortWith(comparator : Comparator<Int>) : IntArray {
|
||||
if (size < 2) return IntArray(size)
|
||||
|
||||
/* TODO: optimisation : keep a constant big array of indices (Ex: from 0 to 4096), then create indice
|
||||
* arrays more efficiently by copying subpart of cached one. For bigger needs, we could copy entire
|
||||
* cached array, then fill remaining indices manually. Not done for now, because:
|
||||
* 1. doing it right would require some statistics about common used buffer sizes.
|
||||
* 2. Some benchmark would be needed to ensure it would really provide better performance
|
||||
*/
|
||||
val packedIndices = IntArray(size) { idx -> idx }
|
||||
|
||||
/* TODO: find an efficient way to sort in-place instead, and return directly the IntArray.
|
||||
* Not done for now, because no standard utility is provided yet. An open issue exists for this.
|
||||
* See: https://youtrack.jetbrains.com/issue/KT-37860
|
||||
*/
|
||||
return packedIndices.sortedWith(comparator).toIntArray()
|
||||
}
|
@ -0,0 +1,103 @@
|
||||
/*
|
||||
* Copyright 2018-2021 KMath contributors.
|
||||
* Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
|
||||
*/
|
||||
|
||||
package space.kscience.kmath.misc
|
||||
|
||||
import space.kscience.kmath.misc.PermSortTest.Platform.*
|
||||
import kotlin.random.Random
|
||||
import kotlin.test.Test
|
||||
import kotlin.test.assertEquals
|
||||
import kotlin.test.assertTrue
|
||||
|
||||
import space.kscience.kmath.structures.IntBuffer
|
||||
import space.kscience.kmath.structures.asBuffer
|
||||
import kotlin.test.assertContentEquals
|
||||
|
||||
class PermSortTest {
|
||||
|
||||
private enum class Platform {
|
||||
ANDROID, JVM, JS, NATIVE, WASM
|
||||
}
|
||||
|
||||
private val platforms = Platform.values().asBuffer()
|
||||
|
||||
/**
|
||||
* Permutation on empty buffer should immediately return an empty array.
|
||||
*/
|
||||
@Test
|
||||
fun testOnEmptyBuffer() {
|
||||
val emptyBuffer = IntBuffer(0) {it}
|
||||
var permutations = emptyBuffer.permSort()
|
||||
assertTrue(permutations.isEmpty(), "permutation on an empty buffer should return an empty result")
|
||||
permutations = emptyBuffer.permSortDescending()
|
||||
assertTrue(permutations.isEmpty(), "permutation on an empty buffer should return an empty result")
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testOnSingleValueBuffer() {
|
||||
testPermutation(1)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testOnSomeValues() {
|
||||
testPermutation(10)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testPermSortBy() {
|
||||
val permutations = platforms.permSortBy { it.name }
|
||||
val expected = listOf(ANDROID, JS, JVM, NATIVE, WASM)
|
||||
assertContentEquals(expected, permutations.map { platforms[it] }, "Ascending PermSort by name")
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testPermSortByDescending() {
|
||||
val permutations = platforms.permSortByDescending { it.name }
|
||||
val expected = listOf(WASM, NATIVE, JVM, JS, ANDROID)
|
||||
assertContentEquals(expected, permutations.map { platforms[it] }, "Descending PermSort by name")
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testPermSortWith() {
|
||||
var permutations = platforms.permSortWith { p1, p2 -> p1.name.length.compareTo(p2.name.length) }
|
||||
val expected = listOf(JS, JVM, WASM, NATIVE, ANDROID)
|
||||
assertContentEquals(expected, permutations.map { platforms[it] }, "PermSort using custom ascending comparator")
|
||||
|
||||
permutations = platforms.permSortWith(compareByDescending { it.name.length })
|
||||
assertContentEquals(expected.reversed(), permutations.map { platforms[it] }, "PermSort using custom descending comparator")
|
||||
}
|
||||
|
||||
private fun testPermutation(bufferSize: Int) {
|
||||
|
||||
val seed = Random.nextLong()
|
||||
println("Test randomization seed: $seed")
|
||||
|
||||
val buffer = Random(seed).buffer(bufferSize)
|
||||
val indices = buffer.permSort()
|
||||
|
||||
assertEquals(bufferSize, indices.size)
|
||||
// Ensure no doublon is present in indices
|
||||
assertEquals(indices.toSet().size, indices.size)
|
||||
|
||||
for (i in 0 until (bufferSize-1)) {
|
||||
val current = buffer[indices[i]]
|
||||
val next = buffer[indices[i+1]]
|
||||
assertTrue(current <= next, "Permutation indices not properly sorted")
|
||||
}
|
||||
|
||||
val descIndices = buffer.permSortDescending()
|
||||
assertEquals(bufferSize, descIndices.size)
|
||||
// Ensure no doublon is present in indices
|
||||
assertEquals(descIndices.toSet().size, descIndices.size)
|
||||
|
||||
for (i in 0 until (bufferSize-1)) {
|
||||
val current = buffer[descIndices[i]]
|
||||
val next = buffer[descIndices[i+1]]
|
||||
assertTrue(current >= next, "Permutation indices not properly sorted in descending order")
|
||||
}
|
||||
}
|
||||
|
||||
private fun Random.buffer(size : Int) = IntBuffer(size) { nextInt() }
|
||||
}
|
Loading…
Reference in New Issue
Block a user