Mirror/powersort
1
0
Fork 0
mirror of https://gitlab.uni-marburg.de/langbeid/powersort.git synced 2025-01-21 19:50:35 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'origin/main'

Browse Source
This commit is contained in:
finnm 2024-12-16 22:31:53 +01:00
commit fa70412791
16 changed files with 138 additions and 55 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
README.md
View File

@ -56,9 +56,3 @@ Run the task "test":
```shell
./gradlew test
```
## TimSort
Imported from
- src/java.base/share/classes/java/util/TimSort.java
- src/java.base/share/classes/java/util/ComparableTimSort.java

5
app/src/main/java/de/uni_marburg/powersort/benchmark/Educational.java → app/src/main/java/de/uni_marburg/powersort/Educational.java
View File

@ -1,4 +1,7 @@
package de.uni_marburg.powersort.benchmark;
package de.uni_marburg.powersort;
import de.uni_marburg.powersort.benchmark.DummyComparable1;
import de.uni_marburg.powersort.benchmark.NaturalOrder;
import java.util.Arrays;

2
app/src/main/java/de/uni_marburg/powersort/benchmark/DummyComparable1.java
View File

@ -3,7 +3,7 @@ package de.uni_marburg.powersort.benchmark;
/**
* A class for tiny, comparable objects.
*/
record DummyComparable1(int id) implements Comparable<DummyComparable1> {
public record DummyComparable1(int id) implements Comparable<DummyComparable1> {
@Override
public int compareTo(DummyComparable1 other) {
return id - other.id;

6
app/src/main/java/de/uni_marburg/powersort/data/AscendingIntegers.java
View File

@ -3,11 +3,9 @@ package de.uni_marburg.powersort.data;
import de.uni_marburg.powersort.benchmark.IntegerArray;
import de.uni_marburg.powersort.benchmark.LongFormatter;
import static de.uni_marburg.powersort.data.DataArraySizes.SIZE_ASC;
public class AscendingIntegers extends IntegerSupplier {
public AscendingIntegers() {
super(IntegerArray.ascending( 1, SIZE_ASC));
public AscendingIntegers(int size) {
super(IntegerArray.ascending( 1, size));
}
@Override

7
app/src/main/java/de/uni_marburg/powersort/data/DataArraySizes.java
View File

@ -1,7 +0,0 @@
package de.uni_marburg.powersort.data;
public interface DataArraySizes {
int SIZE_RAND = 50_000_000;
int SIZE_ASC = 50_000_000;
int SIZE_DESC = 50_000_000;
}

15
app/src/main/java/de/uni_marburg/powersort/data/DataEnum.java
View File

@ -4,18 +4,23 @@ public enum DataEnum {
RANDOM_INTEGERS,
ASCENDING_INTEGERS,
DESCENDING_INTEGERS,
ASCENDING_RUNS;
ASCENDING_RUNS,
ASCENDING_RUNS_WITH_OVERLAP;
public ObjectSupplier get() {
// We use a seed to get the same random list every time -> Repeatable benchmarks on same input data!
// final long seed = 3651660232967549736L; // System.nanoTime() ++ Math.random()
final long seed = 140506881906827520L; // (long) 'P' * (long) 'O' *(long) 'W' * (long) 'E' * (long) 'R' * (long) 'S' * (long) 'O' * (long) 'R' * (long) 'T';
int longListSize = 50_000_000;
return switch (this) {
case RANDOM_INTEGERS -> new RandomIntegers(seed);
case ASCENDING_INTEGERS -> new AscendingIntegers();
case DESCENDING_INTEGERS -> new DescendingIntegers();
case ASCENDING_RUNS -> AscendingRuns.newAscendingRuns(10000, 10000, -10000);
case RANDOM_INTEGERS -> new RandomIntegers(longListSize, seed);
case ASCENDING_INTEGERS -> new AscendingIntegers(longListSize);
case DESCENDING_INTEGERS -> new DescendingIntegers(longListSize);
case ASCENDING_RUNS -> AscendingRuns.newAscendingRuns(10_000, 10_000, -10_000);
case ASCENDING_RUNS_WITH_OVERLAP -> AscendingRuns.newAscendingRuns(10_000, 10_000, -5_000);
};
}
}

6
app/src/main/java/de/uni_marburg/powersort/data/DescendingIntegers.java
View File

@ -3,11 +3,9 @@ package de.uni_marburg.powersort.data;
import de.uni_marburg.powersort.benchmark.IntegerArray;
import de.uni_marburg.powersort.benchmark.LongFormatter;
import static de.uni_marburg.powersort.data.DataArraySizes.SIZE_DESC;
public class DescendingIntegers extends IntegerSupplier {
public DescendingIntegers() {
super(IntegerArray.descending(SIZE_DESC, 1));
public DescendingIntegers(int size) {
super(IntegerArray.descending(size, 1));
}
@Override

6
app/src/main/java/de/uni_marburg/powersort/data/RandomIntegers.java
View File

@ -3,11 +3,9 @@ package de.uni_marburg.powersort.data;
import de.uni_marburg.powersort.benchmark.IntegerArray;
import de.uni_marburg.powersort.benchmark.LongFormatter;
import static de.uni_marburg.powersort.data.DataArraySizes.SIZE_RAND;
public class RandomIntegers extends IntegerSupplier {
public RandomIntegers(final long seed) {
super(IntegerArray.random(SIZE_RAND, seed));
public RandomIntegers(final int size, final long seed) {
super(IntegerArray.random(size, seed));
}
@Override

4
app/src/main/java/de/uni_marburg/powersort/sort/ComparableTimSort.java
View File

@ -24,6 +24,10 @@
* questions.
*/
/*
* Imported from OpenJDK git repo ComparableTimSort.java
*/
package de.uni_marburg.powersort.sort;
/**

7
app/src/main/java/de/uni_marburg/powersort/sort/SortEnum.java
View File

@ -1,17 +1,22 @@
package de.uni_marburg.powersort.sort;
import de.uni_marburg.powersort.FinnSort.FinnSort;
import de.uni_marburg.powersort.benchmark.NaturalOrder;
public enum SortEnum {
// BUBBLE_SORT,
MERGE_SORT,
TIM_SORT;
TIM_SORT,
FIN_SORT,
ASORT;
public SimpleSort get() {
return switch (this) {
// case BUBBLE_SORT -> array -> BubbleSort.sort(array, NaturalOrder.INSTANCE);
case MERGE_SORT -> array -> MergeSort.legacyMergeSort(array, NaturalOrder.INSTANCE);
case TIM_SORT -> array -> TimSort.sort(array, 0, array.length, NaturalOrder.INSTANCE, null, 0, 0);
case FIN_SORT -> array -> FinnSort.sort(array, NaturalOrder.INSTANCE);
case ASORT -> array -> ASort.sort(array, NaturalOrder.INSTANCE);
};
}
}

4
app/src/main/java/de/uni_marburg/powersort/sort/TimSort.java
View File

@ -24,6 +24,10 @@
* questions.
*/
/*
* Imported from OpenJDK git repo TimSort.java
*/
package de.uni_marburg.powersort.sort;
import java.util.Comparator;

41
app/src/test/java/de/uni_marburg/powersort/JUnitUtil.java Normal file
View File

@ -0,0 +1,41 @@
package de.uni_marburg.powersort;
import org.junit.jupiter.params.converter.SimpleArgumentConverter;
import java.util.Arrays;
public class JUnitUtil {
/**
* https://stackoverflow.com/a/46850299/6334421
*/
public static class IntArrayConverter extends SimpleArgumentConverter {
@Override
protected int[] convert(Object source, Class<?> targetType) {
if (source instanceof String s && int[].class.isAssignableFrom(targetType)) {
if (s.isEmpty()) {
return new int[0];
}
String[] strings = s.split("\\s*\\|\\s*");
return Arrays.stream(strings).mapToInt(Integer::valueOf).toArray();
} else {
throw new IllegalArgumentException("Conversion from " + source.getClass()
+ " to " + targetType + " not supported.");
}
}
}
public static class IntegerArrayConverter extends SimpleArgumentConverter {
@Override
protected Integer[] convert(Object source, Class<?> targetType) {
if (source instanceof String s && Integer[].class.isAssignableFrom(targetType)) {
if (s.isEmpty()) {
return new Integer[0];
}
String[] strings = s.split("\\s*\\|\\s*");
return Arrays.stream(strings).map(Integer::valueOf).toArray(Integer[]::new);
} else {
throw new IllegalArgumentException("Conversion from " + source.getClass()
+ " to " + targetType + " not supported.");
}
}
}
}

24
app/src/test/java/de/uni_marburg/powersort/data/AscendingRunsTest.java
View File

@ -1,8 +1,8 @@
package de.uni_marburg.powersort.data;
import de.uni_marburg.powersort.JUnitUtil;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.converter.ConvertWith;
import org.junit.jupiter.params.converter.SimpleArgumentConverter;
import org.junit.jupiter.params.provider.CsvSource;
import java.util.Arrays;
@ -10,26 +10,6 @@ import java.util.Arrays;
import static org.junit.jupiter.api.Assertions.*;
class AscendingRunsTest {
/**
* https://stackoverflow.com/a/46850299/6334421
*/
private static class IntArrayConverter extends SimpleArgumentConverter {
@Override
protected Object convert(Object source, Class<?> targetType) {
if (source instanceof String s && int[].class.isAssignableFrom(targetType)) {
if (s.isEmpty()) {
return new int[0];
}
String[] strings = s.split("\\s*\\|\\s*");
return Arrays.stream(strings).mapToInt(Integer::valueOf).toArray();
} else {
throw new IllegalArgumentException("Conversion from " + source.getClass()
+ " to " + targetType + " not supported.");
}
}
}
@ParameterizedTest
@CsvSource({
"0,1,-1,''",
@ -38,7 +18,7 @@ class AscendingRunsTest {
"2,2,-2,0|1|-2|-1",
"2,4,-2,0|1|2|3|-2|-1|0|1",
})
void testAscendingRuns1(int numOfRuns, int runLength, int decreaseBetweenRuns, @ConvertWith(IntArrayConverter.class) int[] expected) {
void testAscendingRuns1(int numOfRuns, int runLength, int decreaseBetweenRuns, @ConvertWith(JUnitUtil.IntArrayConverter.class) int[] expected) {
Integer[] actualIntegers = AscendingRuns.newAscendingRuns(numOfRuns, runLength, decreaseBetweenRuns).getCopy();
int[] actual = Arrays.stream(actualIntegers).mapToInt(Integer::valueOf).toArray();
assertArrayEquals(expected, actual);

7
app/src/test/java/de/uni_marburg/powersort/sort/ASortTest.java Normal file
View File

@ -0,0 +1,7 @@
package de.uni_marburg.powersort.sort;
public class ASortTest extends AbstractSortTest {
ASortTest() {
sortAlg = SortEnum.ASORT;
}
}

46
app/src/test/java/de/uni_marburg/powersort/sort/AbstractSortTest.java Normal file
View File

@ -0,0 +1,46 @@
package de.uni_marburg.powersort.sort;
import de.uni_marburg.powersort.JUnitUtil;
import de.uni_marburg.powersort.data.AscendingRuns;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.converter.ConvertWith;
import org.junit.jupiter.params.provider.CsvSource;
import java.util.Arrays;
import static org.junit.jupiter.api.Assertions.assertArrayEquals;
public abstract class AbstractSortTest {
SortEnum sortAlg;
@ParameterizedTest
@CsvSource({
"''",
"1337",
"3|2|1",
"1|1",
"2|1",
"2|1|2",
})
void test1(@ConvertWith(JUnitUtil.IntegerArrayConverter.class) Integer[] array) {
sortAndCheckResult(array);
}
@ParameterizedTest
@CsvSource({
"3,7,-13",
"3,7,-3",
})
void test2(int numOfRuns, int runLength, int decreaseBetweenRuns) {
Integer[] array = AscendingRuns.newAscendingRuns(numOfRuns, runLength, decreaseBetweenRuns).getCopy();
sortAndCheckResult(array);
}
void sortAndCheckResult(Integer[] array){
Integer[] expected = Arrays.copyOf(array, array.length);
Arrays.sort(expected);
sortAlg.get().sort(array);
assertArrayEquals(expected, array);
}
}

7
app/src/test/java/de/uni_marburg/powersort/sort/FinnSortTest.java Normal file
View File

@ -0,0 +1,7 @@
package de.uni_marburg.powersort.sort;
public class FinnSortTest extends AbstractSortTest {
FinnSortTest() {
sortAlg = SortEnum.FIN_SORT;
}
}