speiger.src.collections.floats.utils

Class FloatArrays

java.lang.Object

speiger.src.collections.floats.utils.FloatArrays

public class FloatArrays
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 float[]	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
FloatArrays()

Method Summary

Modifier and Type	Method and Description
static float[]	heapify(float[] data, int size, FloatComparator comp) Helper function to create a Heap out of an array.
static void	insertionSort(float[] array) Sorts an array according to the natural ascending order using InsertionSort,
static void	insertionSort(float[] array, FloatComparator comp) Sorts the specified range of elements according to the order induced by the specified comparator using Insertion Sort,
static void	insertionSort(float[] array, int length) Sorts an array according to the natural ascending order using InsertionSort,
static void	insertionSort(float[] array, int length, FloatComparator comp) Sorts the specified range of elements according to the order induced by the specified comparator using Insertion Sort,
static void	insertionSort(float[] array, int from, int to) Sorts an array according to the natural ascending order using InsertionSort,
static void	insertionSort(float[] array, int from, int to, FloatComparator comp) Sorts the specified range of elements according to the order induced by the specified comparator using Insertion Sort,
static void	memFreeMergeSort(float[] 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(float[] array, FloatComparator 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(float[] 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(float[] array, int length, FloatComparator 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(float[] 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(float[] array, int from, int to, FloatComparator 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(float[] 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(float[] array, float[] 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(float[] array, float[] supp, int from, int to, FloatComparator 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(float[] array, FloatComparator 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(float[] 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(float[] array, int length, FloatComparator 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(float[] 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(float[] array, FloatComparator 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(float[] 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(float[] array, int length, FloatComparator 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(float[] 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(float[] array, int from, int to, FloatComparator 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(float[] 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(float[] array, float[] 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(float[] array, float[] supp, int from, int to, FloatComparator 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(float[] array, FloatComparator 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(float[] 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(float[] array, int length, FloatComparator 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(float[] 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(float[] array, FloatComparator 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(float[] 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(float[] array, int length, FloatComparator 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(float[] 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(float[] array, int from, int to, FloatComparator 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(float[] 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(float[] array, FloatComparator 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(float[] 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(float[] array, int length, FloatComparator 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(float[] 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(float[] array, int from, int to, FloatComparator 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(float[] array) Sorts an array according to the natural ascending order using Selection Sort,
static void	selectionSort(float[] array, FloatComparator comp) Sorts the specified range of elements according to the order induced by the specified comparator using Selection Sort,
static void	selectionSort(float[] array, int length) Sorts an array according to the natural ascending order using Selection Sort,
static void	selectionSort(float[] array, int length, FloatComparator comp) Sorts the specified range of elements according to the order induced by the specified comparator using Selection Sort,
static void	selectionSort(float[] array, int from, int to) Sorts an array according to the natural ascending order using Selection Sort,
static void	selectionSort(float[] array, int from, int to, FloatComparator comp) Sorts the specified range of elements according to the order induced by the specified comparator using Selection Sort,
static int	shiftDown(float[] data, int size, int index, FloatComparator comp) Method to validate if the current value is the lowest value in the heap
static int	shiftUp(float[] data, int index, FloatComparator comp) Method to sort a specific value into the heap.
static float[]	shuffle(float[] array) Simple Shuffle method for Arrays.
static float[]	shuffle(float[] array, java.util.Random random) Simple Shuffle method for Arrays.
static void	stableSort(float[] 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(float[] array, FloatComparator 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(float[] 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(float[] array, int length, FloatComparator 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(float[] 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(float[] array, int from, int to, FloatComparator 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(float[] 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(float[] array, FloatComparator 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(float[] 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(float[] array, int length, FloatComparator 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(float[] 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(float[] array, int from, int to, FloatComparator 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 float[]	unwrap(java.lang.Float[] a) A Helper function to convert a Float Array to a float Array.
static float[]	unwrap(java.lang.Float[] a, int length) A Helper function to convert a Float Array to a float Array.
static float[]	unwrap(java.lang.Float[] a, int offset, int length) A Helper function to convert a Float Array to a float Array.
static java.lang.Float[]	wrap(float[] a) A Helper function to convert a Primitive Array to a Float Array.
static java.lang.Float[]	wrap(float[] a, int length) A Helper function to convert a Primitive Array to a Float Array.
static java.lang.Float[]	wrap(float[] a, int offset, int length) A Helper function to convert a Primitive Array to a Float 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 float[] EMPTY_ARRAY

Empty Array Reference used for Uninitialized Collections

Constructor Detail

FloatArrays

public FloatArrays()

Method Detail

wrap

public static java.lang.Float[] wrap(float[] a)

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

Parameters:

a - the array that should be converted

Returns:

a Float Array of the input array.

wrap

public static java.lang.Float[] wrap(float[] a,
                                     int length)

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

Parameters:

a - the array that should be converted

length - the maximum length that should be coverted

Returns:

a Float Array of the input array.

wrap

public static java.lang.Float[] wrap(float[] a,
                                     int offset,
                                     int length)

A Helper function to convert a Primitive Array to a Float 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 Float Array of the input array.

unwrap

public static float[] unwrap(java.lang.Float[] a)

A Helper function to convert a Float Array to a float Array.

Parameters:

a - the array that should be converted

Returns:

a float Array of the input array.

unwrap

public static float[] unwrap(java.lang.Float[] a,
                             int length)

A Helper function to convert a Float Array to a float Array.

Parameters:

a - the array that should be converted

length - the maximum length that should be coverted

Returns:

a float Array of the input array.

unwrap

public static float[] unwrap(java.lang.Float[] a,
                             int offset,
                             int length)

A Helper function to convert a Float Array to a float 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 float Array of the input array.

shiftDown

public static int shiftDown(float[] data,
                            int size,
                            int index,
                            FloatComparator 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(float[] data,
                          int index,
                          FloatComparator 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 float[] heapify(float[] data,
                              int size,
                              FloatComparator 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 float[] shuffle(float[] 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 float[] shuffle(float[] 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(float[] array,
                              FloatComparator 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(float[] array,
                              int length,
                              FloatComparator 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(float[] array,
                              int from,
                              int to,
                              FloatComparator 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(float[] 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(float[] 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(float[] 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(float[] array,
                                FloatComparator 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(float[] array,
                                int length,
                                FloatComparator 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(float[] array,
                                int from,
                                int to,
                                FloatComparator 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(float[] 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(float[] 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(float[] 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(float[] array,
                                 FloatComparator 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(float[] array,
                                 int length,
                                 FloatComparator 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(float[] array,
                                 int from,
                                 int to,
                                 FloatComparator 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(float[] 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(float[] 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(float[] 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(float[] array,
                                 FloatComparator 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(float[] array,
                                 int length,
                                 FloatComparator 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(float[] array,
                                 int from,
                                 int to,
                                 FloatComparator 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(float[] 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(float[] 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(float[] 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(float[] array,
                             FloatComparator 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(float[] array,
                             int length,
                             FloatComparator 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(float[] array,
                             float[] supp,
                             int from,
                             int to,
                             FloatComparator 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(float[] 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(float[] 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(float[] array,
                             float[] 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(float[] array,
                                     FloatComparator 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(float[] array,
                                     int length,
                                     FloatComparator 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(float[] array,
                                     float[] supp,
                                     int from,
                                     int to,
                                     FloatComparator 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(float[] 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(float[] 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(float[] array,
                                     float[] 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(float[] array,
                                    FloatComparator 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(float[] array,
                                    int length,
                                    FloatComparator 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(float[] array,
                                    int from,
                                    int to,
                                    FloatComparator 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(float[] 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(float[] 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(float[] 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(float[] array,
                                            FloatComparator 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(float[] array,
                                            int length,
                                            FloatComparator 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(float[] array,
                                            int from,
                                            int to,
                                            FloatComparator 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(float[] 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(float[] 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(float[] 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(float[] array,
                             FloatComparator 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(float[] array,
                             int length,
                             FloatComparator 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(float[] array,
                             int from,
                             int to,
                             FloatComparator 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(float[] 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(float[] 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(float[] 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(float[] array,
                                     FloatComparator 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(float[] array,
                                     int length,
                                     FloatComparator 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(float[] array,
                                     int from,
                                     int to,
                                     FloatComparator 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(float[] 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(float[] 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(float[] 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