speiger.src.collections.bytes.utils

Class ByteArrays

java.lang.Object

speiger.src.collections.bytes.utils.ByteArrays

public class ByteArrays
extends java.lang.Object

A Helper class for Arrays

Field Summary

Fields

Modifier and Type	Field and Description
static int	BASE_THRESHOLD Default Limit for Insertion/Selection Sort
static byte[]	EMPTY_ARRAY Empty Array Reference used for Uninitialized Collections
static int	PARALLEL_THRESHOLD Default Threshold for Multithreaded Sorting Algorythm options

Constructor Summary

Constructors

Constructor and Description
ByteArrays()

Method Summary

Modifier and Type	Method and Description
static byte[]	heapify(byte[] data, int size, ByteComparator comp) Helper function to create a Heap out of an array.
static void	insertionSort(byte[] array) Sorts an array according to the natural ascending order using InsertionSort,
static void	insertionSort(byte[] array, ByteComparator comp) Sorts the specified range of elements according to the order induced by the specified comparator using Insertion Sort,
static void	insertionSort(byte[] array, int length) Sorts an array according to the natural ascending order using InsertionSort,
static void	insertionSort(byte[] array, int length, ByteComparator comp) Sorts the specified range of elements according to the order induced by the specified comparator using Insertion Sort,
static void	insertionSort(byte[] array, int from, int to) Sorts an array according to the natural ascending order using InsertionSort,
static void	insertionSort(byte[] array, int from, int to, ByteComparator comp) Sorts the specified range of elements according to the order induced by the specified comparator using Insertion Sort,
static void	memFreeMergeSort(byte[] array) Sorts an array according to the natural ascending order using Memory Free Merge Sort, This implementation is inspired by FastUtil original merge sort, but without the need to allocate a copy of the original Array.
static void	memFreeMergeSort(byte[] array, ByteComparator comp) Sorts the specified range of elements according to the order induced by the specified comparator using Memory Free Merge Sort, This implementation is inspired by FastUtil original merge sort, but without the need to allocate a copy of the original Array.
static void	memFreeMergeSort(byte[] array, int length) Sorts an array according to the natural ascending order using Memory Free Merge Sort, This implementation is inspired by FastUtil original merge sort, but without the need to allocate a copy of the original Array.
static void	memFreeMergeSort(byte[] array, int length, ByteComparator comp) Sorts the specified range of elements according to the order induced by the specified comparator using Memory Free Merge Sort, This implementation is inspired by FastUtil original merge sort, but without the need to allocate a copy of the original Array.
static void	memFreeMergeSort(byte[] array, int from, int to) Sorts an array according to the natural ascending order using Memory Free Merge Sort, This implementation is inspired by FastUtil original merge sort, but without the need to allocate a copy of the original Array.
static void	memFreeMergeSort(byte[] array, int from, int to, ByteComparator comp) Sorts the specified range of elements according to the order induced by the specified comparator using Memory Free Merge Sort, This implementation is inspired by FastUtil original merge sort, but without the need to allocate a copy of the original Array.
static void	mergeSort(byte[] array) Sorts an array according to the natural ascending order using Merge Sort, This implementation was copied from FastUtil with a couple custom optimizations
static void	mergeSort(byte[] array, byte[] supp, int from, int to) Sorts an array according to the natural ascending order using Merge Sort, This implementation was copied from FastUtil with a couple custom optimizations
static void	mergeSort(byte[] array, byte[] supp, int from, int to, ByteComparator comp) Sorts the specified range of elements according to the order induced by the specified comparator using Merge Sort, This implementation was copied from FastUtil with a couple custom optimizations
static void	mergeSort(byte[] array, ByteComparator comp) Sorts the specified range of elements according to the order induced by the specified comparator using Merge Sort, This implementation was copied from FastUtil with a couple custom optimizations
static void	mergeSort(byte[] array, int length) Sorts an array according to the natural ascending order using Merge Sort, This implementation was copied from FastUtil with a couple custom optimizations
static void	mergeSort(byte[] array, int length, ByteComparator comp) Sorts the specified range of elements according to the order induced by the specified comparator using Merge Sort, This implementation was copied from FastUtil with a couple custom optimizations
static void	parallelMemFreeMergeSort(byte[] array) Sorts an array according to the natural ascending order using Parallel Memory Free Merge Sort, This implementation is inspired by FastUtil original merge sort, but without the need to allocate a copy of the original Array.
static void	parallelMemFreeMergeSort(byte[] array, ByteComparator comp) Sorts the specified range of elements according to the order induced by the specified comparator using Parallel Memory Free Merge Sort, This implementation is inspired by FastUtil original merge sort, but without the need to allocate a copy of the original Array.
static void	parallelMemFreeMergeSort(byte[] array, int length) Sorts an array according to the natural ascending order using Parallel Memory Free Merge Sort, This implementation is inspired by FastUtil original merge sort, but without the need to allocate a copy of the original Array.
static void	parallelMemFreeMergeSort(byte[] array, int length, ByteComparator comp) Sorts the specified range of elements according to the order induced by the specified comparator using Parallel Memory Free Merge Sort, This implementation is inspired by FastUtil original merge sort, but without the need to allocate a copy of the original Array.
static void	parallelMemFreeMergeSort(byte[] array, int from, int to) Sorts an array according to the natural ascending order using Parallel Memory Free Merge Sort, This implementation is inspired by FastUtil original merge sort, but without the need to allocate a copy of the original Array.
static void	parallelMemFreeMergeSort(byte[] array, int from, int to, ByteComparator comp) Sorts the specified range of elements according to the order induced by the specified comparator using Parallel Memory Free Merge Sort, This implementation is inspired by FastUtil original merge sort, but without the need to allocate a copy of the original Array.
static void	parallelMergeSort(byte[] array) Sorts an array according to the natural ascending order using Parallel Merge Sort, This implementation was copied from FastUtil with a couple custom optimizations
static void	parallelMergeSort(byte[] array, byte[] supp, int from, int to) Sorts an array according to the natural ascending order using Parallel Merge Sort, This implementation was copied from FastUtil with a couple custom optimizations
static void	parallelMergeSort(byte[] array, byte[] supp, int from, int to, ByteComparator comp) Sorts the specified range of elements according to the order induced by the specified comparator using Parallel Merge Sort, This implementation was copied from FastUtil with a couple custom optimizations
static void	parallelMergeSort(byte[] array, ByteComparator comp) Sorts the specified range of elements according to the order induced by the specified comparator using a Parallel Merge Sort, This implementation was copied from FastUtil with a couple custom optimizations
static void	parallelMergeSort(byte[] array, int length) Sorts an array according to the natural ascending order using Parallel Merge Sort, This implementation was copied from FastUtil with a couple custom optimizations
static void	parallelMergeSort(byte[] array, int length, ByteComparator comp) Sorts the specified range of elements according to the order induced by the specified comparator using Parallel Merge Sort, This implementation was copied from FastUtil with a couple custom optimizations
static void	parallelQuickSort(byte[] array) Sorts an array according to the natural ascending order using Parallel Quick Sort, This implementation is a custom of FastUtil quicksort but with a different code structure, and that sorting Algorithm is based on the tuned quicksort adapted from Jon L.
static void	parallelQuickSort(byte[] array, ByteComparator comp) Sorts the specified range of elements according to the order induced by the specified comparator using Parallel Quick Sort, This implementation is a custom of FastUtil quicksort but with a different code structure, and that sorting Algorithm is based on the tuned quicksort adapted from Jon L.
static void	parallelQuickSort(byte[] array, int length) Sorts an array according to the natural ascending order using Parallel Quick Sort, This implementation is a custom of FastUtil quicksort but with a different code structure, and that sorting Algorithm is based on the tuned quicksort adapted from Jon L.
static void	parallelQuickSort(byte[] array, int length, ByteComparator comp) Sorts the specified range of elements according to the order induced by the specified comparator using Parallel Quick Sort, This implementation is a custom of FastUtil quicksort but with a different code structure, and that sorting Algorithm is based on the tuned quicksort adapted from Jon L.
static void	parallelQuickSort(byte[] array, int from, int to) Sorts an array according to the natural ascending order using Parallel Quick Sort, This implementation is a custom of FastUtil quicksort but with a different code structure, and that sorting Algorithm is based on the tuned quicksort adapted from Jon L.
static void	parallelQuickSort(byte[] array, int from, int to, ByteComparator comp) Sorts the specified range of elements according to the order induced by the specified comparator using Parallel Quick Sort, This implementation is a custom of FastUtil quicksort but with a different code structure, and that sorting Algorithm is based on the tuned quicksort adapted from Jon L.
static void	quickSort(byte[] array) Sorts an array according to the natural ascending order using Quick Sort, This implementation is a custom of FastUtil quicksort but with a different code structure, and that sorting Algorithm is based on the tuned quicksort adapted from Jon L.
static void	quickSort(byte[] array, ByteComparator comp) Sorts the specified range of elements according to the order induced by the specified comparator using Quick Sort, This implementation is a custom of FastUtil quicksort but with a different code structure, and that sorting Algorithm is based on the tuned quicksort adapted from Jon L.
static void	quickSort(byte[] array, int length) Sorts an array according to the natural ascending order using Quick Sort, This implementation is a custom of FastUtil quicksort but with a different code structure, and that sorting Algorithm is based on the tuned quicksort adapted from Jon L.
static void	quickSort(byte[] array, int length, ByteComparator comp) Sorts the specified range of elements according to the order induced by the specified comparator using Quick Sort, This implementation is a custom of FastUtil quicksort but with a different code structure, and that sorting Algorithm is based on the tuned quicksort adapted from Jon L.
static void	quickSort(byte[] array, int from, int to) Sorts an array according to the natural ascending order using Quick Sort, This implementation is a custom of FastUtil quicksort but with a different code structure, and that sorting Algorithm is based on the tuned quicksort adapted from Jon L.
static void	quickSort(byte[] array, int from, int to, ByteComparator comp) Sorts the specified range of elements according to the order induced by the specified comparator using Quick Sort, This implementation is a custom of FastUtil quicksort but with a different code structure, and that sorting Algorithm is based on the tuned quicksort adapted from Jon L.
static void	selectionSort(byte[] array) Sorts an array according to the natural ascending order using Selection Sort,
static void	selectionSort(byte[] array, ByteComparator comp) Sorts the specified range of elements according to the order induced by the specified comparator using Selection Sort,
static void	selectionSort(byte[] array, int length) Sorts an array according to the natural ascending order using Selection Sort,
static void	selectionSort(byte[] array, int length, ByteComparator comp) Sorts the specified range of elements according to the order induced by the specified comparator using Selection Sort,
static void	selectionSort(byte[] array, int from, int to) Sorts an array according to the natural ascending order using Selection Sort,
static void	selectionSort(byte[] array, int from, int to, ByteComparator comp) Sorts the specified range of elements according to the order induced by the specified comparator using Selection Sort,
static int	shiftDown(byte[] data, int size, int index, ByteComparator comp) Method to validate if the current value is the lowest value in the heap
static int	shiftUp(byte[] data, int index, ByteComparator comp) Method to sort a specific value into the heap.
static byte[]	shuffle(byte[] array) Simple Shuffle method for Arrays.
static byte[]	shuffle(byte[] array, java.util.Random random) Simple Shuffle method for Arrays.
static void	stableSort(byte[] array) Sorts an array according to the natural ascending order, potentially dynamically choosing an appropriate algorithm given the type and size of the array.
static void	stableSort(byte[] array, ByteComparator comp) Sorts the specified range of elements according to the order induced by the specified comparator, potentially dynamically choosing an appropriate algorithm given the type and size of the array.
static void	stableSort(byte[] array, int length) Sorts an array according to the natural ascending order, potentially dynamically choosing an appropriate algorithm given the type and size of the array.
static void	stableSort(byte[] array, int length, ByteComparator comp) Sorts the specified range of elements according to the order induced by the specified comparator, potentially dynamically choosing an appropriate algorithm given the type and size of the array.
static void	stableSort(byte[] array, int from, int to) Sorts an array according to the natural ascending order, potentially dynamically choosing an appropriate algorithm given the type and size of the array.
static void	stableSort(byte[] array, int from, int to, ByteComparator comp) Sorts the specified range of elements according to the order induced by the specified comparator, potentially dynamically choosing an appropriate algorithm given the type and size of the array.
static void	unstableSort(byte[] array) Sorts an array according to the natural ascending order, potentially dynamically choosing an appropriate algorithm given the type and size of the array.
static void	unstableSort(byte[] array, ByteComparator comp) Sorts the specified range of elements according to the order induced by the specified comparator, potentially dynamically choosing an appropriate algorithm given the type and size of the array.
static void	unstableSort(byte[] array, int length) Sorts an array according to the natural ascending order, potentially dynamically choosing an appropriate algorithm given the type and size of the array.
static void	unstableSort(byte[] array, int length, ByteComparator comp) Sorts the specified range of elements according to the order induced by the specified comparator, potentially dynamically choosing an appropriate algorithm given the type and size of the array.
static void	unstableSort(byte[] array, int from, int to) Sorts an array according to the natural ascending order, potentially dynamically choosing an appropriate algorithm given the type and size of the array.
static void	unstableSort(byte[] array, int from, int to, ByteComparator comp) Sorts the specified range of elements according to the order induced by the specified comparator, potentially dynamically choosing an appropriate algorithm given the type and size of the array.
static byte[]	unwrap(java.lang.Byte[] a) A Helper function to convert a Byte Array to a byte Array.
static byte[]	unwrap(java.lang.Byte[] a, int length) A Helper function to convert a Byte Array to a byte Array.
static byte[]	unwrap(java.lang.Byte[] a, int offset, int length) A Helper function to convert a Byte Array to a byte Array.
static java.lang.Byte[]	wrap(byte[] a) A Helper function to convert a Primitive Array to a Byte Array.
static java.lang.Byte[]	wrap(byte[] a, int length) A Helper function to convert a Primitive Array to a Byte Array.
static java.lang.Byte[]	wrap(byte[] a, int offset, int length) A Helper function to convert a Primitive Array to a Byte Array.

Methods inherited from class java.lang.Object

equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

BASE_THRESHOLD

public static final int BASE_THRESHOLD

Default Limit for Insertion/Selection Sort

See Also:

Constant Field Values

PARALLEL_THRESHOLD

public static final int PARALLEL_THRESHOLD

Default Threshold for Multithreaded Sorting Algorythm options

See Also:

Constant Field Values

EMPTY_ARRAY

public static final byte[] EMPTY_ARRAY

Empty Array Reference used for Uninitialized Collections

Constructor Detail

ByteArrays

public ByteArrays()

Method Detail

wrap

public static java.lang.Byte[] wrap(byte[] a)

A Helper function to convert a Primitive Array to a Byte Array.

Parameters:

a - the array that should be converted

Returns:

a Byte Array of the input array.

wrap

public static java.lang.Byte[] wrap(byte[] a,
                                    int length)

A Helper function to convert a Primitive Array to a Byte Array.

Parameters:

a - the array that should be converted

length - the maximum length that should be coverted

Returns:

a Byte Array of the input array.

wrap

public static java.lang.Byte[] wrap(byte[] a,
                                    int offset,
                                    int length)

A Helper function to convert a Primitive Array to a Byte Array.

Parameters:

a - the array that should be converted

offset - the starting offset of the inputarray

length - the maximum length that should be coverted

Returns:

a Byte Array of the input array.

unwrap

public static byte[] unwrap(java.lang.Byte[] a)

A Helper function to convert a Byte Array to a byte Array.

Parameters:

a - the array that should be converted

Returns:

a byte Array of the input array.

unwrap

public static byte[] unwrap(java.lang.Byte[] a,
                            int length)

A Helper function to convert a Byte Array to a byte Array.

Parameters:

a - the array that should be converted

length - the maximum length that should be coverted

Returns:

a byte Array of the input array.

unwrap

public static byte[] unwrap(java.lang.Byte[] a,
                            int offset,
                            int length)

A Helper function to convert a Byte Array to a byte Array.

Parameters:

a - the array that should be converted

offset - the starting offset of the inputarray

length - the maximum length that should be coverted

Returns:

a byte Array of the input array.

shiftDown

public static int shiftDown(byte[] data,
                            int size,
                            int index,
                            ByteComparator comp)

Method to validate if the current value is the lowest value in the heap

Parameters:

data - the current heap.

size - the size of the heap

index - the index that should be validated

comp - the comparator to sort the heap. Can be null

Returns:

the index the element was shifted to

shiftUp

public static int shiftUp(byte[] data,
                          int index,
                          ByteComparator comp)

Method to sort a specific value into the heap.

Parameters:

data - the heap itself.

index - that should be heapified.

comp - the comparator to sort the heap. Can be null

Returns:

the index the element was shifted to

heapify

public static byte[] heapify(byte[] data,
                             int size,
                             ByteComparator comp)

Helper function to create a Heap out of an array.

Parameters:

data - the array to heapify

size - the current size of elements within the array.

comp - the Comparator to sort the array. Can be null

Returns:

the input array

shuffle

public static byte[] shuffle(byte[] array)

Simple Shuffle method for Arrays.

Parameters:

array - the elements that should be shuffled

Returns:

the provided sorted array

Note:

This uses the SanityChecks#getRandom

shuffle

public static byte[] shuffle(byte[] array,
                             java.util.Random random)

Simple Shuffle method for Arrays.

Parameters:

array - the elements that should be shuffled

random - the Random Number Generator that should be used for the shuffling

Returns:

the provided sorted array

stableSort

public static void stableSort(byte[] array,
                              ByteComparator comp)

Sorts the specified range of elements according to the order induced by the specified comparator, potentially dynamically choosing an appropriate algorithm given the type and size of the array. Stable sort referres to Mergesort or Insertionsort

Parameters:

array - the array that needs to be sorted

comp - the Comparator that decides the sorting order

stableSort

public static void stableSort(byte[] array,
                              int length,
                              ByteComparator comp)

Sorts the specified range of elements according to the order induced by the specified comparator, potentially dynamically choosing an appropriate algorithm given the type and size of the array. Stable sort referres to Mergesort or Insertionsort

Parameters:

array - the array that needs to be sorted

length - the maxmium size of the array to be sorted

comp - the Comparator that decides the sorting order

stableSort

public static void stableSort(byte[] array,
                              int from,
                              int to,
                              ByteComparator comp)

Sorts the specified range of elements according to the order induced by the specified comparator, potentially dynamically choosing an appropriate algorithm given the type and size of the array. Stable sort referres to Mergesort or Insertionsort

Parameters:

array - the array that needs to be sorted

from - where the array should be sorted from

to - where the array should be sorted to

comp - the Comparator that decides the sorting order

stableSort

public static void stableSort(byte[] array)

Sorts an array according to the natural ascending order, potentially dynamically choosing an appropriate algorithm given the type and size of the array. Stable sort referres to Mergesort or Insertionsort

Parameters:

array - the array that needs to be sorted

stableSort

public static void stableSort(byte[] array,
                              int length)

Sorts an array according to the natural ascending order, potentially dynamically choosing an appropriate algorithm given the type and size of the array. Stable sort referres to Mergesort or Insertionsort

Parameters:

array - the array that needs to be sorted

length - the maxmium size of the array to be sorted

stableSort

public static void stableSort(byte[] array,
                              int from,
                              int to)

Sorts an array according to the natural ascending order, potentially dynamically choosing an appropriate algorithm given the type and size of the array. Stable sort referres to Mergesort or Insertionsort

Parameters:

array - the array that needs to be sorted

from - where the array should be sorted from

to - where the array should be sorted to

unstableSort

public static void unstableSort(byte[] array,
                                ByteComparator comp)

Sorts the specified range of elements according to the order induced by the specified comparator, potentially dynamically choosing an appropriate algorithm given the type and size of the array. Unstable sort referres to QuickSort or SelectionSort

Parameters:

array - the array that needs to be sorted

comp - the Comparator that decides the sorting order

unstableSort

public static void unstableSort(byte[] array,
                                int length,
                                ByteComparator comp)

Sorts the specified range of elements according to the order induced by the specified comparator, potentially dynamically choosing an appropriate algorithm given the type and size of the array. Unstable sort referres to QuickSort or SelectionSort

Parameters:

array - the array that needs to be sorted

length - the maxmium size of the array to be sorted

comp - the Comparator that decides the sorting order

unstableSort

public static void unstableSort(byte[] array,
                                int from,
                                int to,
                                ByteComparator comp)

Sorts the specified range of elements according to the order induced by the specified comparator, potentially dynamically choosing an appropriate algorithm given the type and size of the array. Unstable sort referres to QuickSort or SelectionSort

Parameters:

array - the array that needs to be sorted

from - where the array should be sorted from

to - where the array should be sorted to

comp - the Comparator that decides the sorting order

unstableSort

public static void unstableSort(byte[] array)

Sorts an array according to the natural ascending order, potentially dynamically choosing an appropriate algorithm given the type and size of the array. Unstable sort referres to QuickSort or SelectionSort

Parameters:

array - the array that needs to be sorted

unstableSort

public static void unstableSort(byte[] array,
                                int length)

Sorts an array according to the natural ascending order, potentially dynamically choosing an appropriate algorithm given the type and size of the array. Unstable sort referres to QuickSort or SelectionSort

Parameters:

array - the array that needs to be sorted

length - the maxmium size of the array to be sorted

unstableSort

public static void unstableSort(byte[] array,
                                int from,
                                int to)

Sorts an array according to the natural ascending order, potentially dynamically choosing an appropriate algorithm given the type and size of the array. Unstable sort referres to QuickSort or SelectionSort

Parameters:

array - the array that needs to be sorted

from - where the array should be sorted from

to - where the array should be sorted to

insertionSort

public static void insertionSort(byte[] array,
                                 ByteComparator comp)

Sorts the specified range of elements according to the order induced by the specified comparator using Insertion Sort,

Parameters:

array - the array that needs to be sorted

comp - the Comparator that decides the sorting order

insertionSort

public static void insertionSort(byte[] array,
                                 int length,
                                 ByteComparator comp)

Sorts the specified range of elements according to the order induced by the specified comparator using Insertion Sort,

Parameters:

array - the array that needs to be sorted

length - the maxmium size of the array to be sorted

comp - the Comparator that decides the sorting order

insertionSort

public static void insertionSort(byte[] array,
                                 int from,
                                 int to,
                                 ByteComparator comp)

Sorts the specified range of elements according to the order induced by the specified comparator using Insertion Sort,

Parameters:

array - the array that needs to be sorted

from - where the array should be sorted from

to - where the array should be sorted to

comp - the Comparator that decides the sorting order

insertionSort

public static void insertionSort(byte[] array)

Sorts an array according to the natural ascending order using InsertionSort,

Parameters:

array - the array that needs to be sorted

insertionSort

public static void insertionSort(byte[] array,
                                 int length)

Sorts an array according to the natural ascending order using InsertionSort,

Parameters:

array - the array that needs to be sorted

length - the maxmium size of the array to be sorted

insertionSort

public static void insertionSort(byte[] array,
                                 int from,
                                 int to)

Sorts an array according to the natural ascending order using InsertionSort,

Parameters:

array - the array that needs to be sorted

from - where the array should be sorted from

to - where the array should be sorted to

selectionSort

public static void selectionSort(byte[] array,
                                 ByteComparator comp)

Sorts the specified range of elements according to the order induced by the specified comparator using Selection Sort,

Parameters:

array - the array that needs to be sorted

comp - the Comparator that decides the sorting order

selectionSort

public static void selectionSort(byte[] array,
                                 int length,
                                 ByteComparator comp)

Sorts the specified range of elements according to the order induced by the specified comparator using Selection Sort,

Parameters:

array - the array that needs to be sorted

length - the maxmium size of the array to be sorted

comp - the Comparator that decides the sorting order

selectionSort

public static void selectionSort(byte[] array,
                                 int from,
                                 int to,
                                 ByteComparator comp)

Sorts the specified range of elements according to the order induced by the specified comparator using Selection Sort,

Parameters:

array - the array that needs to be sorted

from - where the array should be sorted from

to - where the array should be sorted to

comp - the Comparator that decides the sorting order

selectionSort

public static void selectionSort(byte[] array)

Sorts an array according to the natural ascending order using Selection Sort,

Parameters:

array - the array that needs to be sorted

selectionSort

public static void selectionSort(byte[] array,
                                 int length)

Sorts an array according to the natural ascending order using Selection Sort,

Parameters:

array - the array that needs to be sorted

length - the maxmium size of the array to be sorted

selectionSort

public static void selectionSort(byte[] array,
                                 int from,
                                 int to)

Sorts an array according to the natural ascending order using Selection Sort,

Parameters:

array - the array that needs to be sorted

from - where the array should be sorted from

to - where the array should be sorted to

mergeSort

public static void mergeSort(byte[] array,
                             ByteComparator comp)

Sorts the specified range of elements according to the order induced by the specified comparator using Merge Sort, This implementation was copied from FastUtil with a couple custom optimizations

Parameters:

array - the array that needs to be sorted

comp - the Comparator that decides the sorting order

mergeSort

public static void mergeSort(byte[] array,
                             int length,
                             ByteComparator comp)

Sorts the specified range of elements according to the order induced by the specified comparator using Merge Sort, This implementation was copied from FastUtil with a couple custom optimizations

Parameters:

array - the array that needs to be sorted

length - the maxmium size of the array to be sorted

comp - the Comparator that decides the sorting order

mergeSort

public static void mergeSort(byte[] array,
                             byte[] supp,
                             int from,
                             int to,
                             ByteComparator comp)

Sorts the specified range of elements according to the order induced by the specified comparator using Merge Sort, This implementation was copied from FastUtil with a couple custom optimizations

Parameters:

array - the array that needs to be sorted

supp - the auxillary array that is used to simplify the sorting

from - where the array should be sorted from

to - where the array should be sorted to

comp - the Comparator that decides the sorting order

mergeSort

public static void mergeSort(byte[] array)

Sorts an array according to the natural ascending order using Merge Sort, This implementation was copied from FastUtil with a couple custom optimizations

Parameters:

array - the array that needs to be sorted

mergeSort

public static void mergeSort(byte[] array,
                             int length)

Sorts an array according to the natural ascending order using Merge Sort, This implementation was copied from FastUtil with a couple custom optimizations

Parameters:

array - the array that needs to be sorted

length - the maxmium size of the array to be sorted

mergeSort

public static void mergeSort(byte[] array,
                             byte[] supp,
                             int from,
                             int to)

Sorts an array according to the natural ascending order using Merge Sort, This implementation was copied from FastUtil with a couple custom optimizations

Parameters:

array - the array that needs to be sorted

supp - the auxillary array that is used to simplify the sorting

from - where the array should be sorted from

to - where the array should be sorted to

parallelMergeSort

public static void parallelMergeSort(byte[] array,
                                     ByteComparator comp)

Sorts the specified range of elements according to the order induced by the specified comparator using a Parallel Merge Sort, This implementation was copied from FastUtil with a couple custom optimizations

Parameters:

array - the array that needs to be sorted

comp - the Comparator that decides the sorting order

Note:

This parallelization is invoked through SanityChecks.invokeTask(java.util.concurrent.ForkJoinTask<T>) which the threadpool can be changed as needed

parallelMergeSort

public static void parallelMergeSort(byte[] array,
                                     int length,
                                     ByteComparator comp)

Sorts the specified range of elements according to the order induced by the specified comparator using Parallel Merge Sort, This implementation was copied from FastUtil with a couple custom optimizations

Parameters:

array - the array that needs to be sorted

length - the maxmium size of the array to be sorted

comp - the Comparator that decides the sorting order

Note:

This parallelization is invoked through SanityChecks.invokeTask(java.util.concurrent.ForkJoinTask<T>) which the threadpool can be changed as needed

parallelMergeSort

public static void parallelMergeSort(byte[] array,
                                     byte[] supp,
                                     int from,
                                     int to,
                                     ByteComparator comp)

Sorts the specified range of elements according to the order induced by the specified comparator using Parallel Merge Sort, This implementation was copied from FastUtil with a couple custom optimizations

Parameters:

array - the array that needs to be sorted

supp - the auxillary array that is used to simplify the sorting

from - where the array should be sorted from

to - where the array should be sorted to

comp - the Comparator that decides the sorting order

Note:

This parallelization is invoked through SanityChecks.invokeTask(java.util.concurrent.ForkJoinTask<T>) which the threadpool can be changed as needed

parallelMergeSort

public static void parallelMergeSort(byte[] array)

Sorts an array according to the natural ascending order using Parallel Merge Sort, This implementation was copied from FastUtil with a couple custom optimizations

Parameters:

array - the array that needs to be sorted

Note:

This parallelization is invoked through SanityChecks.invokeTask(java.util.concurrent.ForkJoinTask<T>) which the threadpool can be changed as needed

parallelMergeSort

public static void parallelMergeSort(byte[] array,
                                     int length)

Sorts an array according to the natural ascending order using Parallel Merge Sort, This implementation was copied from FastUtil with a couple custom optimizations

Parameters:

array - the array that needs to be sorted

length - the maxmium size of the array to be sorted

Note:

This parallelization is invoked through SanityChecks.invokeTask(java.util.concurrent.ForkJoinTask<T>) which the threadpool can be changed as needed

parallelMergeSort

public static void parallelMergeSort(byte[] array,
                                     byte[] supp,
                                     int from,
                                     int to)

Sorts an array according to the natural ascending order using Parallel Merge Sort, This implementation was copied from FastUtil with a couple custom optimizations

Parameters:

array - the array that needs to be sorted

supp - the auxillary array that is used to simplify the sorting

from - where the array should be sorted from

to - where the array should be sorted to

Note:

This parallelization is invoked through SanityChecks.invokeTask(java.util.concurrent.ForkJoinTask<T>) which the threadpool can be changed as needed

memFreeMergeSort

public static void memFreeMergeSort(byte[] array,
                                    ByteComparator comp)

Sorts the specified range of elements according to the order induced by the specified comparator using Memory Free Merge Sort, This implementation is inspired by FastUtil original merge sort, but without the need to allocate a copy of the original Array. It is in Very Unsorted Instances 50% slower then Mergesort, otherwise it as fast.

Parameters:

array - the array that needs to be sorted

comp - the Comparator that decides the sorting order

memFreeMergeSort

public static void memFreeMergeSort(byte[] array,
                                    int length,
                                    ByteComparator comp)

Sorts the specified range of elements according to the order induced by the specified comparator using Memory Free Merge Sort, This implementation is inspired by FastUtil original merge sort, but without the need to allocate a copy of the original Array. It is in Very Unsorted Instances 50% slower then Mergesort, otherwise it as fast.

Parameters:

array - the array that needs to be sorted

length - the maxmium size of the array to be sorted

comp - the Comparator that decides the sorting order

memFreeMergeSort

public static void memFreeMergeSort(byte[] array,
                                    int from,
                                    int to,
                                    ByteComparator comp)

Sorts the specified range of elements according to the order induced by the specified comparator using Memory Free Merge Sort, This implementation is inspired by FastUtil original merge sort, but without the need to allocate a copy of the original Array. It is in Very Unsorted Instances 50% slower then Mergesort, otherwise it as fast.

Parameters:

array - the array that needs to be sorted

from - where the array should be sorted from

to - where the array should be sorted to

comp - the Comparator that decides the sorting order

memFreeMergeSort

public static void memFreeMergeSort(byte[] array)

Sorts an array according to the natural ascending order using Memory Free Merge Sort, This implementation is inspired by FastUtil original merge sort, but without the need to allocate a copy of the original Array. It is depending on the size and the unsorted level of the input array slower or almost as fast as normal merge sort. Depending on the test size i can be 0.5x slower (5000 elements) or 4x slower (50000 elements) under the assumtion that the array is in its worst case scenario. It does stack allocate tiny amounts of data for shifting around elements.

Parameters:

array - the array that needs to be sorted

memFreeMergeSort

public static void memFreeMergeSort(byte[] array,
                                    int length)

Sorts an array according to the natural ascending order using Memory Free Merge Sort, This implementation is inspired by FastUtil original merge sort, but without the need to allocate a copy of the original Array. It is depending on the size and the unsorted level of the input array slower or almost as fast as normal merge sort. Depending on the test size i can be 0.5x slower (5000 elements) or 4x slower (50000 elements) under the assumtion that the array is in its worst case scenario. It does stack allocate tiny amounts of data for shifting around elements.

Parameters:

array - the array that needs to be sorted

length - the maxmium size of the array to be sorted

memFreeMergeSort

public static void memFreeMergeSort(byte[] array,
                                    int from,
                                    int to)

Sorts an array according to the natural ascending order using Memory Free Merge Sort, This implementation is inspired by FastUtil original merge sort, but without the need to allocate a copy of the original Array. It is depending on the size and the unsorted level of the input array slower or almost as fast as normal merge sort. Depending on the test size i can be 0.5x slower (5000 elements) or 4x slower (50000 elements) under the assumtion that the array is in its worst case scenario. It does stack allocate tiny amounts of data for shifting around elements.

Parameters:

array - the array that needs to be sorted

from - where the array should be sorted from

to - where the array should be sorted to

parallelMemFreeMergeSort

public static void parallelMemFreeMergeSort(byte[] array,
                                            ByteComparator comp)

Sorts the specified range of elements according to the order induced by the specified comparator using Parallel Memory Free Merge Sort, This implementation is inspired by FastUtil original merge sort, but without the need to allocate a copy of the original Array. It is depending on the size and the unsorted level of the input array slower or almost as fast as normal merge sort. Depending on the test size i can be 0.5x slower (5000 elements) or 4x slower (50000 elements) under the assumtion that the array is in its worst case scenario. It does stack allocate tiny amounts of data for shifting around elements.

Parameters:

array - the array that needs to be sorted

comp - the Comparator that decides the sorting order

Note:

This parallelization is invoked through SanityChecks.invokeTask(java.util.concurrent.ForkJoinTask<T>) which the threadpool can be changed as needed

parallelMemFreeMergeSort

public static void parallelMemFreeMergeSort(byte[] array,
                                            int length,
                                            ByteComparator comp)

Sorts the specified range of elements according to the order induced by the specified comparator using Parallel Memory Free Merge Sort, This implementation is inspired by FastUtil original merge sort, but without the need to allocate a copy of the original Array. It is depending on the size and the unsorted level of the input array slower or almost as fast as normal merge sort. Depending on the test size i can be 0.5x slower (5000 elements) or 4x slower (50000 elements) under the assumtion that the array is in its worst case scenario. It does stack allocate tiny amounts of data for shifting around elements.

Parameters:

array - the array that needs to be sorted

length - the maxmium size of the array to be sorted

comp - the Comparator that decides the sorting order

Note:

This parallelization is invoked through SanityChecks.invokeTask(java.util.concurrent.ForkJoinTask<T>) which the threadpool can be changed as needed

parallelMemFreeMergeSort

public static void parallelMemFreeMergeSort(byte[] array,
                                            int from,
                                            int to,
                                            ByteComparator comp)

Sorts the specified range of elements according to the order induced by the specified comparator using Parallel Memory Free Merge Sort, This implementation is inspired by FastUtil original merge sort, but without the need to allocate a copy of the original Array. It is depending on the size and the unsorted level of the input array slower or almost as fast as normal merge sort. Depending on the test size i can be 0.5x slower (5000 elements) or 4x slower (50000 elements) under the assumtion that the array is in its worst case scenario. It does stack allocate tiny amounts of data for shifting around elements.

Parameters:

array - the array that needs to be sorted

from - where the array should be sorted from

to - where the array should be sorted to

comp - the Comparator that decides the sorting order

Note:

This parallelization is invoked through SanityChecks.invokeTask(java.util.concurrent.ForkJoinTask<T>) which the threadpool can be changed as needed

parallelMemFreeMergeSort

public static void parallelMemFreeMergeSort(byte[] array)

Sorts an array according to the natural ascending order using Parallel Memory Free Merge Sort, This implementation is inspired by FastUtil original merge sort, but without the need to allocate a copy of the original Array. It is depending on the size and the unsorted level of the input array slower or almost as fast as normal merge sort. Depending on the test size i can be 0.5x slower (5000 elements) or 4x slower (50000 elements) under the assumtion that the array is in its worst case scenario. It does stack allocate tiny amounts of data for shifting around elements.

Parameters:

array - the array that needs to be sorted

Note:

This parallelization is invoked through SanityChecks.invokeTask(java.util.concurrent.ForkJoinTask<T>) which the threadpool can be changed as needed

parallelMemFreeMergeSort

public static void parallelMemFreeMergeSort(byte[] array,
                                            int length)

Sorts an array according to the natural ascending order using Parallel Memory Free Merge Sort, This implementation is inspired by FastUtil original merge sort, but without the need to allocate a copy of the original Array. It is depending on the size and the unsorted level of the input array slower or almost as fast as normal merge sort. Depending on the test size i can be 0.5x slower (5000 elements) or 4x slower (50000 elements) under the assumtion that the array is in its worst case scenario. It does stack allocate tiny amounts of data for shifting around elements.

Parameters:

array - the array that needs to be sorted

length - the maxmium size of the array to be sorted

Note:

This parallelization is invoked through SanityChecks.invokeTask(java.util.concurrent.ForkJoinTask<T>) which the threadpool can be changed as needed

parallelMemFreeMergeSort

public static void parallelMemFreeMergeSort(byte[] array,
                                            int from,
                                            int to)

Sorts an array according to the natural ascending order using Parallel Memory Free Merge Sort, This implementation is inspired by FastUtil original merge sort, but without the need to allocate a copy of the original Array. It is depending on the size and the unsorted level of the input array slower or almost as fast as normal merge sort. Depending on the test size i can be 0.5x slower (5000 elements) or 4x slower (50000 elements) under the assumtion that the array is in its worst case scenario. It does stack allocate tiny amounts of data for shifting around elements.

Parameters:

array - the array that needs to be sorted

from - where the array should be sorted from

to - where the array should be sorted to

Note:

This parallelization is invoked through SanityChecks.invokeTask(java.util.concurrent.ForkJoinTask<T>) which the threadpool can be changed as needed

quickSort

public static void quickSort(byte[] array,
                             ByteComparator comp)

Sorts the specified range of elements according to the order induced by the specified comparator using Quick Sort, This implementation is a custom of FastUtil quicksort but with a different code structure, and that sorting Algorithm is based on the tuned quicksort adapted from Jon L. Bentley and M. DouglasMcIlroy, "Engineering a Sort Function", Software: Practice and Experience, 23(11), pages1249−1265, 1993.

Parameters:

array - the array that needs to be sorted

comp - the Comparator that decides the sorting order

quickSort

public static void quickSort(byte[] array,
                             int length,
                             ByteComparator comp)

Sorts the specified range of elements according to the order induced by the specified comparator using Quick Sort, This implementation is a custom of FastUtil quicksort but with a different code structure, and that sorting Algorithm is based on the tuned quicksort adapted from Jon L. Bentley and M. DouglasMcIlroy, "Engineering a Sort Function", Software: Practice and Experience, 23(11), pages1249−1265, 1993.

Parameters:

array - the array that needs to be sorted

length - the maxmium size of the array to be sorted

comp - the Comparator that decides the sorting order

quickSort

public static void quickSort(byte[] array,
                             int from,
                             int to,
                             ByteComparator comp)

Sorts the specified range of elements according to the order induced by the specified comparator using Quick Sort, This implementation is a custom of FastUtil quicksort but with a different code structure, and that sorting Algorithm is based on the tuned quicksort adapted from Jon L. Bentley and M. DouglasMcIlroy, "Engineering a Sort Function", Software: Practice and Experience, 23(11), pages1249−1265, 1993.

Parameters:

array - the array that needs to be sorted

from - where the array should be sorted from

to - where the array should be sorted to

comp - the Comparator that decides the sorting order

quickSort

public static void quickSort(byte[] array)

Sorts an array according to the natural ascending order using Quick Sort, This implementation is a custom of FastUtil quicksort but with a different code structure, and that sorting Algorithm is based on the tuned quicksort adapted from Jon L. Bentley and M. DouglasMcIlroy, "Engineering a Sort Function", Software: Practice and Experience, 23(11), pages1249−1265, 1993.

Parameters:

array - the array that needs to be sorted

quickSort

public static void quickSort(byte[] array,
                             int length)

Sorts an array according to the natural ascending order using Quick Sort, This implementation is a custom of FastUtil quicksort but with a different code structure, and that sorting Algorithm is based on the tuned quicksort adapted from Jon L. Bentley and M. DouglasMcIlroy, "Engineering a Sort Function", Software: Practice and Experience, 23(11), pages1249−1265, 1993.

Parameters:

array - the array that needs to be sorted

length - the maxmium size of the array to be sorted

quickSort

public static void quickSort(byte[] array,
                             int from,
                             int to)

Sorts an array according to the natural ascending order using Quick Sort, This implementation is a custom of FastUtil quicksort but with a different code structure, and that sorting Algorithm is based on the tuned quicksort adapted from Jon L. Bentley and M. DouglasMcIlroy, "Engineering a Sort Function", Software: Practice and Experience, 23(11), pages1249−1265, 1993.

Parameters:

array - the array that needs to be sorted

from - where the array should be sorted from

to - where the array should be sorted to

parallelQuickSort

public static void parallelQuickSort(byte[] array,
                                     ByteComparator comp)

Sorts the specified range of elements according to the order induced by the specified comparator using Parallel Quick Sort, This implementation is a custom of FastUtil quicksort but with a different code structure, and that sorting Algorithm is based on the tuned quicksort adapted from Jon L. Bentley and M. DouglasMcIlroy, "Engineering a Sort Function", Software: Practice and Experience, 23(11), pages1249−1265, 1993.

Parameters:

array - the array that needs to be sorted

comp - the Comparator that decides the sorting order

Note:

This parallelization is invoked through SanityChecks.invokeTask(java.util.concurrent.ForkJoinTask<T>) which the threadpool can be changed as needed

parallelQuickSort

public static void parallelQuickSort(byte[] array,
                                     int length,
                                     ByteComparator comp)

Sorts the specified range of elements according to the order induced by the specified comparator using Parallel Quick Sort, This implementation is a custom of FastUtil quicksort but with a different code structure, and that sorting Algorithm is based on the tuned quicksort adapted from Jon L. Bentley and M. DouglasMcIlroy, "Engineering a Sort Function", Software: Practice and Experience, 23(11), pages1249−1265, 1993.

Parameters:

array - the array that needs to be sorted

length - the maxmium size of the array to be sorted

comp - the Comparator that decides the sorting order

Note:

This parallelization is invoked through SanityChecks.invokeTask(java.util.concurrent.ForkJoinTask<T>) which the threadpool can be changed as needed

parallelQuickSort

public static void parallelQuickSort(byte[] array,
                                     int from,
                                     int to,
                                     ByteComparator comp)

Sorts the specified range of elements according to the order induced by the specified comparator using Parallel Quick Sort, This implementation is a custom of FastUtil quicksort but with a different code structure, and that sorting Algorithm is based on the tuned quicksort adapted from Jon L. Bentley and M. DouglasMcIlroy, "Engineering a Sort Function", Software: Practice and Experience, 23(11), pages1249−1265, 1993.

Parameters:

array - the array that needs to be sorted

from - where the array should be sorted from

to - where the array should be sorted to

comp - the Comparator that decides the sorting order

Note:

This parallelization is invoked through SanityChecks.invokeTask(java.util.concurrent.ForkJoinTask<T>) which the threadpool can be changed as needed

parallelQuickSort

public static void parallelQuickSort(byte[] array)

Sorts an array according to the natural ascending order using Parallel Quick Sort, This implementation is a custom of FastUtil quicksort but with a different code structure, and that sorting Algorithm is based on the tuned quicksort adapted from Jon L. Bentley and M. DouglasMcIlroy, "Engineering a Sort Function", Software: Practice and Experience, 23(11), pages1249−1265, 1993.

Parameters:

array - the array that needs to be sorted

Note:

This parallelization is invoked through SanityChecks.invokeTask(java.util.concurrent.ForkJoinTask<T>) which the threadpool can be changed as needed

parallelQuickSort

public static void parallelQuickSort(byte[] array,
                                     int length)

Sorts an array according to the natural ascending order using Parallel Quick Sort, This implementation is a custom of FastUtil quicksort but with a different code structure, and that sorting Algorithm is based on the tuned quicksort adapted from Jon L. Bentley and M. DouglasMcIlroy, "Engineering a Sort Function", Software: Practice and Experience, 23(11), pages1249−1265, 1993.

Parameters:

array - the array that needs to be sorted

length - the maxmium size of the array to be sorted

Note:

This parallelization is invoked through SanityChecks.invokeTask(java.util.concurrent.ForkJoinTask<T>) which the threadpool can be changed as needed

parallelQuickSort

public static void parallelQuickSort(byte[] array,
                                     int from,
                                     int to)

Sorts an array according to the natural ascending order using Parallel Quick Sort, This implementation is a custom of FastUtil quicksort but with a different code structure, and that sorting Algorithm is based on the tuned quicksort adapted from Jon L. Bentley and M. DouglasMcIlroy, "Engineering a Sort Function", Software: Practice and Experience, 23(11), pages1249−1265, 1993.

Parameters:

array - the array that needs to be sorted

from - where the array should be sorted from

to - where the array should be sorted to

Note:

This parallelization is invoked through SanityChecks.invokeTask(java.util.concurrent.ForkJoinTask<T>) which the threadpool can be changed as needed