public class IntSorting extends PersistentObject
This is another case demonstrating one primary goal of this library: Delivering easy to use, yet very efficient APIs. The sorts return convenient sort views. This enables the usage of algorithms which scale well with the problem size: For example, sorting a 1000000 x 10000 or a 1000000 x 100 x 100 matrix performs just as fast as sorting a 1000000 x 1 matrix. This is so, because internally the algorithms only move around integer indexes, they do not physically move around entire rows or slices. The original matrix is left unaffected.
The quicksort is a derivative of the JDK 1.2 V1.26 algorithms (which are, in turn, based on Bentley's and McIlroy's fine work). The mergesort is a derivative of the JAL algorithms, with optimisations taken from the JDK algorithms. Mergesort is stable (by definition), while quicksort is not. A stable sort is, for example, helpful, if matrices are sorted successively by multiple columns. It preserves the relative position of equal elements.
GenericSorting
,
Sorting
,
Arrays
,
Serialized FormModifier and Type  Field and Description 

static IntSorting 
mergeSort
A prefabricated mergesort.

static IntSorting 
quickSort
A prefabricated quicksort.

Modifier and Type  Method and Description 

IntMatrix1D 
sort(IntMatrix1D vector)
Sorts the vector into ascending order, according to the natural
ordering.

IntMatrix1D 
sort(IntMatrix1D vector,
IntComparator c)
Sorts the vector into ascending order, according to the order induced by
the specified comparator.

IntMatrix2D 
sort(IntMatrix2D matrix,
int column)
Sorts the matrix rows into ascending order, according to the natural
ordering of the matrix values in the given column.

IntMatrix2D 
sort(IntMatrix2D matrix,
int[] aggregates)
Sorts the matrix rows into ascending order, according to the natural
ordering of the matrix values in the virtual column
aggregates; Particularly efficient when comparing expensive
aggregates, because aggregates need not be recomputed time and again, as
is the case for comparator based sorts.

IntMatrix2D 
sort(IntMatrix2D matrix,
IntMatrix1DComparator c)
Sorts the matrix rows according to the order induced by the specified
comparator.

IntMatrix3D 
sort(IntMatrix3D matrix,
int row,
int column)
Sorts the matrix slices into ascending order, according to the natural
ordering of the matrix values in the given [row,column]
position.

IntMatrix3D 
sort(IntMatrix3D matrix,
IntMatrix2DComparator c)
Sorts the matrix slices according to the order induced by the specified
comparator.

int[] 
sortIndex(IntMatrix1D vector)
Sorts indexes of the
vector into ascending order. 
int[] 
sortIndex(IntMatrix1D vector,
IntComparator c)
Sorts indexes of the
vector according to the comparator
c . 
clone
public static final IntSorting quickSort
public static final IntSorting mergeSort
public IntMatrix1D sort(IntMatrix1D vector)
Example:
7, 1, 3, 1 
==> 1, 1, 3, 7 
vector
 the vector to be sorted.public int[] sortIndex(IntMatrix1D vector)
vector
into ascending order.vector
 public IntMatrix1D sort(IntMatrix1D vector, IntComparator c)
Example:
// sort by sinus of cells IntComparator comp = new IntComparator() { public int compare(int a, int b) { int as = Math.sin(a); int bs = Math.sin(b); return as < bs ? 1 : as == bs ? 0 : 1; } }; sorted = quickSort(vector, comp);
vector
 the vector to be sorted.c
 the comparator to determine the order.public int[] sortIndex(IntMatrix1D vector, IntComparator c)
vector
according to the comparator
c
.vector
 c
 public IntMatrix2D sort(IntMatrix2D matrix, int[] aggregates)
The returned view is backed by this matrix, so changes in the returned view are reflected in this matrix, and viceversa. To sort ranges use subranging views. To sort columns by rows, use dice views. To sort descending, use flip views ...
Example: Each aggregate is the sum of a row
4 x 2 matrix: 1, 1 5, 4 3, 0 4, 4 
aggregates= 2 9 3 8 ==> 
4 x 2 matrix: 
// sort 10000 x 1000 matrix by sum of logarithms in a row (i.e. by geometric mean) IntMatrix2D matrix = new DenseIntMatrix2D(10000, 1000); matrix.assign(new cern.jet.random.engine.MersenneTwister()); // initialized randomly cern.jet.math.Functions F = cern.jet.math.Functions.functions; // alias for convenience // THE QUICK VERSION (takes some 3 secs) // aggregates[i] = Sum(log(row)); int[] aggregates = new int[matrix.rows()]; for (int i = matrix.rows(); i >= 0;) aggregates[i] = matrix.viewRow(i).aggregate(F.plus, F.log); IntMatrix2D sorted = quickSort(matrix, aggregates); // THE SLOW VERSION (takes some 90 secs) IntMatrix1DComparator comparator = new IntMatrix1DComparator() { public int compare(IntMatrix1D x, IntMatrix1D y) { int a = x.aggregate(F.plus, F.log); int b = y.aggregate(F.plus, F.log); return a < b ? 1 : a == b ? 0 : 1; } }; IntMatrix2D sorted = quickSort(matrix, comparator); 
matrix
 the matrix to be sorted.aggregates
 the values to sort on. (As a side effect, this array will also
get sorted).IndexOutOfBoundsException
 if aggregates.length != matrix.rows().public IntMatrix2D sort(IntMatrix2D matrix, int column)
Example:
4 x 2 matrix: 7, 6 5, 4 3, 2 1, 0 
column = 0; 
4 x 2 matrix: 
matrix
 the matrix to be sorted.column
 the index of the column inducing the order.IndexOutOfBoundsException
 if column < 0  column >= matrix.columns().public IntMatrix2D sort(IntMatrix2D matrix, IntMatrix1DComparator c)
Example:
// sort by sum of values in a row IntMatrix1DComparator comp = new IntMatrix1DComparator() { public int compare(IntMatrix1D a, IntMatrix1D b) { int as = a.zSum(); int bs = b.zSum(); return as < bs ? 1 : as == bs ? 0 : 1; } }; sorted = quickSort(matrix, comp);
matrix
 the matrix to be sorted.c
 the comparator to determine the order.public IntMatrix3D sort(IntMatrix3D matrix, int row, int column)
The algorithm compares two 2d slices at a time, determinining whether one is smaller, equal or larger than the other. Comparison is based on the cell [row,column] within a slice. Let A and B be two 2d slices. Then we have the following rules
matrix
 the matrix to be sorted.row
 the index of the row inducing the order.column
 the index of the column inducing the order.IndexOutOfBoundsException
 if
row < 0  row >= matrix.rows()  column < 0  column >= matrix.columns()
.public IntMatrix3D sort(IntMatrix3D matrix, IntMatrix2DComparator c)
Example:
// sort by sum of values in a slice IntMatrix2DComparator comp = new IntMatrix2DComparator() { public int compare(IntMatrix2D a, IntMatrix2D b) { int as = a.zSum(); int bs = b.zSum(); return as < bs ? 1 : as == bs ? 0 : 1; } }; sorted = quickSort(matrix, comp);
matrix
 the matrix to be sorted.c
 the comparator to determine the order.Jump to the Parallel Colt Homepage