ArrayUtils (OpenIMAJ master project 1.3.1 API)

java.lang.Object
- org.openimaj.util.array.ArrayUtils

```
public class ArrayUtils
extends Object
```
Collection of utilities for primitive arrays.

Author:

Jonathan Hare, Sina Samangooei

Method Summary

Methods
Modifier and Type	Method and Description
`static byte[]`	`add(byte[] ds, byte x)` Add a constant to all elements and return the input
`static double[]`	`add(double[] ds, double x)` Add a constant to all elements and return the input
`static float[]`	`add(float[] ds, float x)` Add a constant to all elements and return the input
`static int[]`	`add(int[] ds, int x)` Add a constant to all elements and return the input
`static long[]`	`add(long[] ds, long x)` Add a constant to all elements and return the input
`static short[]`	`add(short[] ds, short x)` Add a constant to all elements and return the input
`static int[]`	`colSum(byte[][] array)` Compute the sum of values in each column of a 2d array
`static double[]`	`colSum(double[][] array)` Compute the sum of values in each column of a 2d array
`static float[]`	`colSum(float[][] array)` Compute the sum of values in each column of a 2d array
`static long[]`	`colSum(int[][] array)` Compute the sum of values in each column of a 2d array
`static long[]`	`colSum(long[][] array)` Compute the sum of values in each column of a 2d array
`static int[]`	`colSum(short[][] array)` Compute the sum of values in each column of a 2d array
`static byte[]`	`concatenate(byte[]... arrays)` Concatenate multiple arrays into a single new array.
`static byte[][]`	`concatenate(byte[][]... arrays)` Concatenate multiple arrays into a single new array.
`static double[]`	`concatenate(double[]... arrays)` Concatenate multiple arrays into a single new array.
`static double[][]`	`concatenate(double[][]... arrays)` Concatenate multiple arrays into a single new array.
`static float[]`	`concatenate(float[]... arrays)` Concatenate multiple arrays into a single new array.
`static float[][]`	`concatenate(float[][]... arrays)` Concatenate multiple arrays into a single new array.
`static int[]`	`concatenate(int[]... arrays)` Concatenate multiple arrays into a single new array.
`static int[][]`	`concatenate(int[][]... arrays)` Concatenate multiple arrays into a single new array.
`static long[]`	`concatenate(long[]... arrays)` Concatenate multiple arrays into a single new array.
`static long[][]`	`concatenate(long[][]... arrays)` Concatenate multiple arrays into a single new array.
`static short[]`	`concatenate(short[]... arrays)` Concatenate multiple arrays into a single new array.
`static short[][]`	`concatenate(short[][]... arrays)` Concatenate multiple arrays into a single new array.
`static <T> T[]`	`concatenate(T[]... arrays)` Concatenate multiple arrays into a single new array.
`Byte[]`	`convert(byte[] array)` Convert from Byte[] to Byte[].
`byte[]`	`convert(Byte[] array)` Convert from Byte[] to byte[].
`Double[]`	`convert(double[] array)` Convert from Double[] to Double[].
`double[]`	`convert(Double[] array)` Convert from Double[] to double[].
`Float[]`	`convert(float[] array)` Convert from Float[] to Float[].
`float[]`	`convert(Float[] array)` Convert from Float[] to float[].
`Integer[]`	`convert(int[] array)` Convert from Int[] to Integer[].
`int[]`	`convert(Integer[] array)` Convert from Integer[] to int[].
`Long[]`	`convert(long[] array)` Convert from Long[] to Long[].
`long[]`	`convert(Long[] array)` Convert from Long[] to long[].
`Short[]`	`convert(short[] array)` Convert from Short[] to Short[].
`short[]`	`convert(Short[] array)` Convert from Short[] to short[].
`static double[]`	`convertToDouble(byte[] array)` Convert a byte array to a double array.
`static double[][]`	`convertToDouble(byte[][] array)` Convert a byte array to a double array.
`static double[]`	`convertToDouble(double[] array)` Convert a double array to a double array.
`static double[][]`	`convertToDouble(double[][] array)` Convert a double array to a double array.
`static double[]`	`convertToDouble(float[] array)` Convert a float array to a double array.
`static double[][]`	`convertToDouble(float[][] array)` Convert a float array to a double array.
`static double[]`	`convertToDouble(int[] array)` Convert a int array to a double array.
`static double[][]`	`convertToDouble(int[][] array)` Convert a int array to a double array.
`static double[]`	`convertToDouble(long[] array)` Convert a long array to a double array.
`static double[][]`	`convertToDouble(long[][] array)` Convert a long array to a double array.
`static double[]`	`convertToDouble(short[] array)` Convert a short array to a double array.
`static double[][]`	`convertToDouble(short[][] array)` Convert a short array to a double array.
`static float[]`	`convertToFloat(byte[] array)` Convert a byte array to a float array.
`static float[][]`	`convertToFloat(byte[][] array)` Convert a byte array to a float array.
`static float[]`	`convertToFloat(double[] array)` Convert a double array to a float array.
`static float[][]`	`convertToFloat(double[][] array)` Convert a double array to a float array.
`static float[]`	`convertToFloat(float[] array)` Convert a float array to a float array.
`static float[][]`	`convertToFloat(float[][] array)` Convert a float array to a float array.
`static float[]`	`convertToFloat(int[] array)` Convert a int array to a float array.
`static float[][]`	`convertToFloat(int[][] array)` Convert a int array to a float array.
`static float[]`	`convertToFloat(long[] array)` Convert a long array to a float array.
`static float[][]`	`convertToFloat(long[][] array)` Convert a long array to a float array.
`static float[]`	`convertToFloat(short[] array)` Convert a short array to a float array.
`static float[][]`	`convertToFloat(short[][] array)` Convert a short array to a float array.
`static int[]`	`cumulativeSum(byte[] vector)` Compute the cumulative sum of values in an array
`static double[]`	`cumulativeSum(double[] vector)` Compute the cumulative sum of values in an array
`static float[]`	`cumulativeSum(float[] vector)` Compute the cumulative sum of values in an array
`static long[]`	`cumulativeSum(int[] vector)` Compute the cumulative sum of values in an array
`static long[]`	`cumulativeSum(long[] vector)` Compute the cumulative sum of values in an array
`static int[]`	`cumulativeSum(short[] vector)` Compute the cumulative sum of values in an array
`static byte[]`	`divide(byte[] fs, byte x)` Divide by a constant, all elements and return the input
`static double[]`	`divide(double[] fs, double x)` Divide by a constant, all elements and return the input
`static float[]`	`divide(float[] fs, float x)` Divide by a constant, all elements and return the input
`static int[]`	`divide(int[] fs, int x)` Divide by a constant, all elements and return the input
`static long[]`	`divide(long[] fs, long x)` Divide by a constant, all elements and return the input
`static short[]`	`divide(short[] fs, short x)` Divide by a constant, all elements and return the input
`static byte[][]`	`fill(byte[][] a1, byte i)` Fill the array with the value
`static byte[]`	`fill(byte[] a1, byte i)` Fill the array with the value
`static byte[]`	`fill(byte[] a1, byte i, int s, int l)` Fill the array with the value from the start index for the length given
`static double[][]`	`fill(double[][] a1, double i)` Fill the array with the value
`static double[]`	`fill(double[] a1, double i)` Fill the array with the value
`static double[]`	`fill(double[] a1, double i, int s, int l)` Fill the array with the value from the start index for the length given
`static float[][]`	`fill(float[][] a1, float i)` Fill the array with the value
`static float[]`	`fill(float[] a1, float i)` Fill the array with the value
`static float[]`	`fill(float[] a1, float i, int s, int l)` Fill the array with the value from the start index for the length given
`static int[]`	`fill(int[] array)` Fills the array with ordinal values
`static int[][]`	`fill(int[][] a1, int i)` Fill the array with the value
`static int[]`	`fill(int[] a1, int i)` Fill the array with the value
`static int[]`	`fill(int[] a1, int i, int s, int l)` Fill the array with the value from the start index for the length given
`static long[][]`	`fill(long[][] a1, long i)` Fill the array with the value
`static long[]`	`fill(long[] a1, long i)` Fill the array with the value
`static long[]`	`fill(long[] a1, long i, int s, int l)` Fill the array with the value from the start index for the length given
`static short[][]`	`fill(short[][] a1, short i)` Fill the array with the value
`static short[]`	`fill(short[] a1, short i)` Fill the array with the value
`static short[]`	`fill(short[] a1, short i, int s, int l)` Fill the array with the value from the start index for the length given
`static <T> T`	`firstNonNull(T[] array)` Return the first non-null item from an array.
`static int[]`	`indexSort(byte[] arr)` Determine the indices of the given array if it were to be sorted into ascending order.
`static int[]`	`indexSort(double[] arr)` Determine the indices of the given array if it were to be sorted into ascending order.
`static int[]`	`indexSort(float[] arr)` Determine the indices of the given array if it were to be sorted into ascending order.
`static int[]`	`indexSort(int[] arr)` Determine the indices of the given array if it were to be sorted into ascending order.
`static int[]`	`indexSort(long[] arr)` Determine the indices of the given array if it were to be sorted into ascending order.
`static int[]`	`indexSort(short[] arr)` Determine the indices of the given array if it were to be sorted into ascending order.
`static int`	`maxIndex(byte[] arr)` Returns the index to the biggest value in the array.
`static int`	`maxIndex(double[] arr)` Returns the index to the biggest value in the array.
`static int`	`maxIndex(float[] arr)` Returns the index to the biggest value in the array.
`static int`	`maxIndex(int[] arr)` Returns the index to the biggest value in the array.
`static int`	`maxIndex(long[] arr)` Returns the index to the biggest value in the array.
`static int`	`maxIndex(short[] arr)` Returns the index to the biggest value in the array.
`static byte`	`maxValue(byte[] arr)` Returns the largest value in the array.
`static double`	`maxValue(double[] arr)` Returns the largest value in the array.
`static float`	`maxValue(float[] arr)` Returns the largest value in the array.
`static int`	`maxValue(int[] arr)` Returns the largest value in the array.
`static long`	`maxValue(long[] arr)` Returns the largest value in the array.
`static short`	`maxValue(short[] arr)` Returns the largest value in the array.
`static int`	`minIndex(byte[] arr)` Returns the index to the smallest value in the array.
`static int`	`minIndex(double[] arr)` Returns the index to the smallest value in the array.
`static int`	`minIndex(float[] arr)` Returns the index to the smallest value in the array.
`static int`	`minIndex(int[] arr)` Returns the index to the smallest value in the array.
`static int`	`minIndex(long[] arr)` Returns the index to the smallest value in the array.
`static int`	`minIndex(short[] arr)` Returns the index to the smallest value in the array.
`static byte`	`minValue(byte[] arr)` Returns the smallest value in the array.
`static double`	`minValue(double[] arr)` Returns the smallest value in the array.
`static float`	`minValue(float[] arr)` Returns the smallest value in the array.
`static int`	`minValue(int[] arr)` Returns the smallest value in the array.
`static long`	`minValue(long[] arr)` Returns the smallest value in the array.
`static short`	`minValue(short[] arr)` Returns the smallest value in the array.
`static byte[][]`	`multiply(byte[][] ds, byte x)` Multiply by a constant all elements and return the input
`static byte[][]`	`multiply(byte[][] a1, byte[][] a2)` Element-wise multiplication, overwriting a1.
`static byte[]`	`multiply(byte[] ds, byte x)` Multiply by a constant all elements and return the input
`static byte[]`	`multiply(byte[] a1, byte[] a2)` Element-wise multiplication, overwriting a1
`static double[][]`	`multiply(double[][] ds, double x)` Multiply by a constant all elements and return the input
`static double[][]`	`multiply(double[][] a1, double[][] a2)` Element-wise multiplication, overwriting a1.
`static double[]`	`multiply(double[] ds, double x)` Multiply by a constant all elements and return the input
`static double[]`	`multiply(double[] a1, double[] a2)` Element-wise multiplication, overwriting a1
`static float[][]`	`multiply(float[][] ds, float x)` Multiply by a constant all elements and return the input
`static float[][]`	`multiply(float[][] a1, float[][] a2)` Element-wise multiplication, overwriting a1.
`static float[]`	`multiply(float[] ds, float x)` Multiply by a constant all elements and return the input
`static float[]`	`multiply(float[] a1, float[] a2)` Element-wise multiplication, overwriting a1
`static int[][]`	`multiply(int[][] ds, int x)` Multiply by a constant all elements and return the input
`static int[][]`	`multiply(int[][] a1, int[][] a2)` Element-wise multiplication, overwriting a1.
`static int[]`	`multiply(int[] ds, int x)` Multiply by a constant all elements and return the input
`static int[]`	`multiply(int[] a1, int[] a2)` Element-wise multiplication, overwriting a1
`static long[][]`	`multiply(long[][] ds, long x)` Multiply by a constant all elements and return the input
`static long[][]`	`multiply(long[][] a1, long[][] a2)` Element-wise multiplication, overwriting a1.
`static long[]`	`multiply(long[] ds, long x)` Multiply by a constant all elements and return the input
`static long[]`	`multiply(long[] a1, long[] a2)` Element-wise multiplication, overwriting a1
`static short[][]`	`multiply(short[][] ds, short x)` Multiply by a constant all elements and return the input
`static short[][]`	`multiply(short[][] a1, short[][] a2)` Element-wise multiplication, overwriting a1.
`static short[]`	`multiply(short[] ds, short x)` Multiply by a constant all elements and return the input
`static short[]`	`multiply(short[] a1, short[] a2)` Element-wise multiplication, overwriting a1
`static double[]`	`normalise(double[] array)` Normalise length of array to 1.0.
`static float[]`	`normalise(float[] array)` Normalise length of array to 1.0.
`static double[]`	`normaliseMax(double[] array)` Normalise and scale the values so that the maximum value in the array is 1.
`static double[]`	`normaliseMax(double[] array, double max)` Normalise and scale the values so that the maximum value in the array is max
`static void`	`parallelQuicksortAscending(byte[] main, byte[] indices)` Sort parallel arrays.
`static void`	`parallelQuicksortAscending(byte[] main, byte[] indices, int left, int right)` Sort parallel arrays.
`static void`	`parallelQuicksortAscending(byte[] main, double[] indices)` Sort parallel arrays.
`static void`	`parallelQuicksortAscending(byte[] main, double[] indices, int left, int right)` Sort parallel arrays.
`static void`	`parallelQuicksortAscending(byte[] main, float[] indices)` Sort parallel arrays.
`static void`	`parallelQuicksortAscending(byte[] main, float[] indices, int left, int right)` Sort parallel arrays.
`static void`	`parallelQuicksortAscending(byte[] main, int[] indices)` Sort parallel arrays.
`static void`	`parallelQuicksortAscending(byte[] main, int[] indices, int left, int right)` Sort parallel arrays.
`static void`	`parallelQuicksortAscending(byte[] main, long[] indices)` Sort parallel arrays.
`static void`	`parallelQuicksortAscending(byte[] main, long[] indices, int left, int right)` Sort parallel arrays.
`static void`	`parallelQuicksortAscending(byte[] main, short[] indices)` Sort parallel arrays.
`static void`	`parallelQuicksortAscending(byte[] main, short[] indices, int left, int right)` Sort parallel arrays.
`static void`	`parallelQuicksortAscending(double[] main, byte[] indices)` Sort parallel arrays.
`static void`	`parallelQuicksortAscending(double[] main, byte[] indices, int left, int right)` Sort parallel arrays.
`static void`	`parallelQuicksortAscending(double[] main, double[] indices)` Sort parallel arrays.
`static void`	`parallelQuicksortAscending(double[] main, double[] indices, int left, int right)` Sort parallel arrays.
`static void`	`parallelQuicksortAscending(double[] main, float[] indices)` Sort parallel arrays.
`static void`	`parallelQuicksortAscending(double[] main, float[] indices, int left, int right)` Sort parallel arrays.
`static void`	`parallelQuicksortAscending(double[] main, int[] indices)` Sort parallel arrays.
`static void`	`parallelQuicksortAscending(double[] main, int[] indices, int left, int right)` Sort parallel arrays.
`static void`	`parallelQuicksortAscending(double[] main, long[] indices)` Sort parallel arrays.
`static void`	`parallelQuicksortAscending(double[] main, long[] indices, int left, int right)` Sort parallel arrays.
`static void`	`parallelQuicksortAscending(double[] main, short[] indices)` Sort parallel arrays.
`static void`	`parallelQuicksortAscending(double[] main, short[] indices, int left, int right)` Sort parallel arrays.
`static void`	`parallelQuicksortAscending(float[] main, byte[] indices)` Sort parallel arrays.
`static void`	`parallelQuicksortAscending(float[] main, byte[] indices, int left, int right)` Sort parallel arrays.
`static void`	`parallelQuicksortAscending(float[] main, double[] indices)` Sort parallel arrays.
`static void`	`parallelQuicksortAscending(float[] main, double[] indices, int left, int right)` Sort parallel arrays.
`static void`	`parallelQuicksortAscending(float[] main, float[] indices)` Sort parallel arrays.
`static void`	`parallelQuicksortAscending(float[] main, float[] indices, int left, int right)` Sort parallel arrays.
`static void`	`parallelQuicksortAscending(float[] main, int[] indices)` Sort parallel arrays.
`static void`	`parallelQuicksortAscending(float[] main, int[] indices, int left, int right)` Sort parallel arrays.
`static void`	`parallelQuicksortAscending(float[] main, long[] indices)` Sort parallel arrays.
`static void`	`parallelQuicksortAscending(float[] main, long[] indices, int left, int right)` Sort parallel arrays.
`static void`	`parallelQuicksortAscending(float[] main, short[] indices)` Sort parallel arrays.
`static void`	`parallelQuicksortAscending(float[] main, short[] indices, int left, int right)` Sort parallel arrays.
`static void`	`parallelQuicksortAscending(int[] main, byte[] indices)` Sort parallel arrays.
`static void`	`parallelQuicksortAscending(int[] main, byte[] indices, int left, int right)` Sort parallel arrays.
`static void`	`parallelQuicksortAscending(int[] main, double[] indices)` Sort parallel arrays.
`static void`	`parallelQuicksortAscending(int[] main, double[] indices, int left, int right)` Sort parallel arrays.
`static void`	`parallelQuicksortAscending(int[] main, float[] indices)` Sort parallel arrays.
`static void`	`parallelQuicksortAscending(int[] main, float[] indices, int left, int right)` Sort parallel arrays.
`static void`	`parallelQuicksortAscending(int[] main, int[] indices)` Sort parallel arrays.
`static void`	`parallelQuicksortAscending(int[] main, int[] indices, int left, int right)` Sort parallel arrays.
`static void`	`parallelQuicksortAscending(int[] main, long[] indices)` Sort parallel arrays.
`static void`	`parallelQuicksortAscending(int[] main, long[] indices, int left, int right)` Sort parallel arrays.
`static void`	`parallelQuicksortAscending(int[] main, short[] indices)` Sort parallel arrays.
`static void`	`parallelQuicksortAscending(int[] main, short[] indices, int left, int right)` Sort parallel arrays.
`static void`	`parallelQuicksortAscending(long[] main, byte[] indices)` Sort parallel arrays.
`static void`	`parallelQuicksortAscending(long[] main, byte[] indices, int left, int right)` Sort parallel arrays.
`static void`	`parallelQuicksortAscending(long[] main, double[] indices)` Sort parallel arrays.
`static void`	`parallelQuicksortAscending(long[] main, double[] indices, int left, int right)` Sort parallel arrays.
`static void`	`parallelQuicksortAscending(long[] main, float[] indices)` Sort parallel arrays.
`static void`	`parallelQuicksortAscending(long[] main, float[] indices, int left, int right)` Sort parallel arrays.
`static void`	`parallelQuicksortAscending(long[] main, int[] indices)` Sort parallel arrays.
`static void`	`parallelQuicksortAscending(long[] main, int[] indices, int left, int right)` Sort parallel arrays.
`static void`	`parallelQuicksortAscending(long[] main, long[] indices)` Sort parallel arrays.
`static void`	`parallelQuicksortAscending(long[] main, long[] indices, int left, int right)` Sort parallel arrays.
`static void`	`parallelQuicksortAscending(long[] main, short[] indices)` Sort parallel arrays.
`static void`	`parallelQuicksortAscending(long[] main, short[] indices, int left, int right)` Sort parallel arrays.
`static void`	`parallelQuicksortAscending(short[] main, byte[] indices)` Sort parallel arrays.
`static void`	`parallelQuicksortAscending(short[] main, byte[] indices, int left, int right)` Sort parallel arrays.
`static void`	`parallelQuicksortAscending(short[] main, double[] indices)` Sort parallel arrays.
`static void`	`parallelQuicksortAscending(short[] main, double[] indices, int left, int right)` Sort parallel arrays.
`static void`	`parallelQuicksortAscending(short[] main, float[] indices)` Sort parallel arrays.
`static void`	`parallelQuicksortAscending(short[] main, float[] indices, int left, int right)` Sort parallel arrays.
`static void`	`parallelQuicksortAscending(short[] main, int[] indices)` Sort parallel arrays.
`static void`	`parallelQuicksortAscending(short[] main, int[] indices, int left, int right)` Sort parallel arrays.
`static void`	`parallelQuicksortAscending(short[] main, long[] indices)` Sort parallel arrays.
`static void`	`parallelQuicksortAscending(short[] main, long[] indices, int left, int right)` Sort parallel arrays.
`static void`	`parallelQuicksortAscending(short[] main, short[] indices)` Sort parallel arrays.
`static void`	`parallelQuicksortAscending(short[] main, short[] indices, int left, int right)` Sort parallel arrays.
`static void`	`parallelQuicksortDescending(byte[] main, byte[] indices)` Sort parallel arrays.
`static void`	`parallelQuicksortDescending(byte[] main, byte[] indices, int left, int right)` Sort parallel arrays.
`static void`	`parallelQuicksortDescending(byte[] main, double[] indices)` Sort parallel arrays.
`static void`	`parallelQuicksortDescending(byte[] main, double[] indices, int left, int right)` Sort parallel arrays.
`static void`	`parallelQuicksortDescending(byte[] main, float[] indices)` Sort parallel arrays.
`static void`	`parallelQuicksortDescending(byte[] main, float[] indices, int left, int right)` Sort parallel arrays.
`static void`	`parallelQuicksortDescending(byte[] main, int[] indices)` Sort parallel arrays.
`static void`	`parallelQuicksortDescending(byte[] main, int[] indices, int left, int right)` Sort parallel arrays.
`static void`	`parallelQuicksortDescending(byte[] main, long[] indices)` Sort parallel arrays.
`static void`	`parallelQuicksortDescending(byte[] main, long[] indices, int left, int right)` Sort parallel arrays.
`static void`	`parallelQuicksortDescending(byte[] main, short[] indices)` Sort parallel arrays.
`static void`	`parallelQuicksortDescending(byte[] main, short[] indices, int left, int right)` Sort parallel arrays.
`static void`	`parallelQuicksortDescending(double[] main, byte[] indices)` Sort parallel arrays.
`static void`	`parallelQuicksortDescending(double[] main, byte[] indices, int left, int right)` Sort parallel arrays.
`static void`	`parallelQuicksortDescending(double[] main, double[] indices)` Sort parallel arrays.
`static void`	`parallelQuicksortDescending(double[] main, double[] indices, int left, int right)` Sort parallel arrays.
`static void`	`parallelQuicksortDescending(double[] main, float[] indices)` Sort parallel arrays.
`static void`	`parallelQuicksortDescending(double[] main, float[] indices, int left, int right)` Sort parallel arrays.
`static void`	`parallelQuicksortDescending(double[] main, int[] indices)` Sort parallel arrays.
`static void`	`parallelQuicksortDescending(double[] main, int[] indices, int left, int right)` Sort parallel arrays.
`static void`	`parallelQuicksortDescending(double[] main, long[] indices)` Sort parallel arrays.
`static void`	`parallelQuicksortDescending(double[] main, long[] indices, int left, int right)` Sort parallel arrays.
`static void`	`parallelQuicksortDescending(double[] main, short[] indices)` Sort parallel arrays.
`static void`	`parallelQuicksortDescending(double[] main, short[] indices, int left, int right)` Sort parallel arrays.
`static void`	`parallelQuicksortDescending(float[] main, byte[] indices)` Sort parallel arrays.
`static void`	`parallelQuicksortDescending(float[] main, byte[] indices, int left, int right)` Sort parallel arrays.
`static void`	`parallelQuicksortDescending(float[] main, double[] indices)` Sort parallel arrays.
`static void`	`parallelQuicksortDescending(float[] main, double[] indices, int left, int right)` Sort parallel arrays.
`static void`	`parallelQuicksortDescending(float[] main, float[] indices)` Sort parallel arrays.
`static void`	`parallelQuicksortDescending(float[] main, float[] indices, int left, int right)` Sort parallel arrays.
`static void`	`parallelQuicksortDescending(float[] main, int[] indices)` Sort parallel arrays.
`static void`	`parallelQuicksortDescending(float[] main, int[] indices, int left, int right)` Sort parallel arrays.
`static void`	`parallelQuicksortDescending(float[] main, long[] indices)` Sort parallel arrays.
`static void`	`parallelQuicksortDescending(float[] main, long[] indices, int left, int right)` Sort parallel arrays.
`static void`	`parallelQuicksortDescending(float[] main, short[] indices)` Sort parallel arrays.
`static void`	`parallelQuicksortDescending(float[] main, short[] indices, int left, int right)` Sort parallel arrays.
`static void`	`parallelQuicksortDescending(int[] main, byte[] indices)` Sort parallel arrays.
`static void`	`parallelQuicksortDescending(int[] main, byte[] indices, int left, int right)` Sort parallel arrays.
`static void`	`parallelQuicksortDescending(int[] main, double[] indices)` Sort parallel arrays.
`static void`	`parallelQuicksortDescending(int[] main, double[] indices, int left, int right)` Sort parallel arrays.
`static void`	`parallelQuicksortDescending(int[] main, float[] indices)` Sort parallel arrays.
`static void`	`parallelQuicksortDescending(int[] main, float[] indices, int left, int right)` Sort parallel arrays.
`static void`	`parallelQuicksortDescending(int[] main, int[] indices)` Sort parallel arrays.
`static void`	`parallelQuicksortDescending(int[] main, int[] indices, int left, int right)` Sort parallel arrays.
`static void`	`parallelQuicksortDescending(int[] main, long[] indices)` Sort parallel arrays.
`static void`	`parallelQuicksortDescending(int[] main, long[] indices, int left, int right)` Sort parallel arrays.
`static void`	`parallelQuicksortDescending(int[] main, short[] indices)` Sort parallel arrays.
`static void`	`parallelQuicksortDescending(int[] main, short[] indices, int left, int right)` Sort parallel arrays.
`static void`	`parallelQuicksortDescending(long[] main, byte[] indices)` Sort parallel arrays.
`static void`	`parallelQuicksortDescending(long[] main, byte[] indices, int left, int right)` Sort parallel arrays.
`static void`	`parallelQuicksortDescending(long[] main, double[] indices)` Sort parallel arrays.
`static void`	`parallelQuicksortDescending(long[] main, double[] indices, int left, int right)` Sort parallel arrays.
`static void`	`parallelQuicksortDescending(long[] main, float[] indices)` Sort parallel arrays.
`static void`	`parallelQuicksortDescending(long[] main, float[] indices, int left, int right)` Sort parallel arrays.
`static void`	`parallelQuicksortDescending(long[] main, int[] indices)` Sort parallel arrays.
`static void`	`parallelQuicksortDescending(long[] main, int[] indices, int left, int right)` Sort parallel arrays.
`static void`	`parallelQuicksortDescending(long[] main, long[] indices)` Sort parallel arrays.
`static void`	`parallelQuicksortDescending(long[] main, long[] indices, int left, int right)` Sort parallel arrays.
`static void`	`parallelQuicksortDescending(long[] main, short[] indices)` Sort parallel arrays.
`static void`	`parallelQuicksortDescending(long[] main, short[] indices, int left, int right)` Sort parallel arrays.
`static void`	`parallelQuicksortDescending(short[] main, byte[] indices)` Sort parallel arrays.
`static void`	`parallelQuicksortDescending(short[] main, byte[] indices, int left, int right)` Sort parallel arrays.
`static void`	`parallelQuicksortDescending(short[] main, double[] indices)` Sort parallel arrays.
`static void`	`parallelQuicksortDescending(short[] main, double[] indices, int left, int right)` Sort parallel arrays.
`static void`	`parallelQuicksortDescending(short[] main, float[] indices)` Sort parallel arrays.
`static void`	`parallelQuicksortDescending(short[] main, float[] indices, int left, int right)` Sort parallel arrays.
`static void`	`parallelQuicksortDescending(short[] main, int[] indices)` Sort parallel arrays.
`static void`	`parallelQuicksortDescending(short[] main, int[] indices, int left, int right)` Sort parallel arrays.
`static void`	`parallelQuicksortDescending(short[] main, long[] indices)` Sort parallel arrays.
`static void`	`parallelQuicksortDescending(short[] main, long[] indices, int left, int right)` Sort parallel arrays.
`static void`	`parallelQuicksortDescending(short[] main, short[] indices)` Sort parallel arrays.
`static void`	`parallelQuicksortDescending(short[] main, short[] indices, int left, int right)` Sort parallel arrays.
`static byte`	`quickSelect(byte[] arr, int n)` Quick Select algorithm for getting the nth item from the array as if it were sorted.
`static byte`	`quickSelect(byte[] arr, int n, int low, int high)` Quick Select algorithm for getting the nth item from a sub-array as if it were sorted.
`static double`	`quickSelect(double[] arr, int n)` Quick Select algorithm for getting the nth item from the array as if it were sorted.
`static double`	`quickSelect(double[] arr, int n, int low, int high)` Quick Select algorithm for getting the nth item from a sub-array as if it were sorted.
`static float`	`quickSelect(float[] arr, int n)` Quick Select algorithm for getting the nth item from the array as if it were sorted.
`static float`	`quickSelect(float[] arr, int n, int low, int high)` Quick Select algorithm for getting the nth item from a sub-array as if it were sorted.
`static int`	`quickSelect(int[] arr, int n)` Quick Select algorithm for getting the nth item from the array as if it were sorted.
`static int`	`quickSelect(int[] arr, int n, int low, int high)` Quick Select algorithm for getting the nth item from a sub-array as if it were sorted.
`static long`	`quickSelect(long[] arr, int n)` Quick Select algorithm for getting the nth item from the array as if it were sorted.
`static long`	`quickSelect(long[] arr, int n, int low, int high)` Quick Select algorithm for getting the nth item from a sub-array as if it were sorted.
`static short`	`quickSelect(short[] arr, int n)` Quick Select algorithm for getting the nth item from the array as if it were sorted.
`static short`	`quickSelect(short[] arr, int n, int low, int high)` Quick Select algorithm for getting the nth item from a sub-array as if it were sorted.
`static int[]`	`range(int start, int length)` Extract a range
`static byte[]`	`reshape(byte[][] a)` Reshape a 2D array into a 1D array
`static byte[][]`	`reshape(byte[] a, byte[][] out)` Reshape a 1D array into a 2D array
`static byte[][]`	`reshape(byte[] a, int width, int height)` Reshape a 1D array into a 2D array
`static double[]`	`reshape(double[][] a)` Reshape a 2D array into a 1D array
`static double[][]`	`reshape(double[] a, double[][] out)` Reshape a 1D array into a 2D array
`static double[][]`	`reshape(double[] a, int width, int height)` Reshape a 1D array into a 2D array
`static float[]`	`reshape(float[][] a)` Reshape a 2D array into a 1D array
`static float[][]`	`reshape(float[] a, float[][] out)` Reshape a 1D array into a 2D array
`static float[][]`	`reshape(float[] a, int width, int height)` Reshape a 1D array into a 2D array
`static int[]`	`reshape(int[][] a)` Reshape a 2D array into a 1D array
`static int[][]`	`reshape(int[] a, int[][] out)` Reshape a 1D array into a 2D array
`static int[][]`	`reshape(int[] a, int width, int height)` Reshape a 1D array into a 2D array
`static long[]`	`reshape(long[][] a)` Reshape a 2D array into a 1D array
`static long[][]`	`reshape(long[] a, int width, int height)` Reshape a 1D array into a 2D array
`static long[][]`	`reshape(long[] a, long[][] out)` Reshape a 1D array into a 2D array
`static short[]`	`reshape(short[][] a)` Reshape a 2D array into a 1D array
`static short[][]`	`reshape(short[] a, int width, int height)` Reshape a 1D array into a 2D array
`static short[][]`	`reshape(short[] a, short[][] out)` Reshape a 1D array into a 2D array
`static double[]`	`reshapeDouble(byte[][] a)` Reshape a 2D array into a 1D array of doubles
`static double[]`	`reshapeDouble(double[][] a)` Reshape a 2D array into a 1D array of doubles
`static double[]`	`reshapeDouble(float[][] a)` Reshape a 2D array into a 1D array of doubles
`static double[]`	`reshapeDouble(int[][] a)` Reshape a 2D array into a 1D array of doubles
`static double[]`	`reshapeDouble(long[][] a)` Reshape a 2D array into a 1D array of doubles
`static double[]`	`reshapeDouble(short[][] a)` Reshape a 2D array into a 1D array of doubles
`static float[][]`	`reshapeFloat(double[] a, float[][] out)` Reshape a 1D array into a 2D array
`static float[][]`	`reshapeFloat(double[] a, int width, int height)` Reshape a 1D array into a 2D array
`static byte[]`	`reverse(byte[] ds)` Reverse the elements in the input and return the input.
`static double[]`	`reverse(double[] ds)` Reverse the elements in the input and return the input.
`static float[]`	`reverse(float[] ds)` Reverse the elements in the input and return the input.
`static int[]`	`reverse(int[] ds)` Reverse the elements in the input and return the input.
`static long[]`	`reverse(long[] ds)` Reverse the elements in the input and return the input.
`static short[]`	`reverse(short[] ds)` Reverse the elements in the input and return the input.
`static int[]`	`rowSum(byte[][] array)` Compute the sum of values in each row of a 2d array
`static double[]`	`rowSum(double[][] array)` Compute the sum of values in each row of a 2d array
`static float[]`	`rowSum(float[][] array)` Compute the sum of values in each row of a 2d array
`static long[]`	`rowSum(int[][] array)` Compute the sum of values in each row of a 2d array
`static long[]`	`rowSum(long[][] array)` Compute the sum of values in each row of a 2d array
`static int[]`	`rowSum(short[][] array)` Compute the sum of values in each row of a 2d array
`static int[]`	`search(byte[] a, byte value)` Find the given value in the array, and return all indices at which it occurs.
`static int[]`	`search(double[] a, double value)` Find the given value in the array, and return all indices at which it occurs.
`static int[]`	`search(float[] a, float value)` Find the given value in the array, and return all indices at which it occurs.
`static int[]`	`search(int[] a, int value)` Find the given value in the array, and return all indices at which it occurs.
`static int[]`	`search(long[] a, long value)` Find the given value in the array, and return all indices at which it occurs.
`static int[]`	`search(short[] a, short value)` Find the given value in the array, and return all indices at which it occurs.
`static byte[][]`	`subtract(byte[][] a1, byte[][] a2)` Element-wise subtraction of two arrays.
`static byte[]`	`subtract(byte[] a1, byte s)` Subtracts `s` from all elements in `a1` overwriting the array.
`static byte[]`	`subtract(byte[] a1, byte[] a2)` Element-wise subtraction of two arrays.
`static double[][]`	`subtract(double[][] a1, double[][] a2)` Element-wise subtraction of two arrays.
`static double[]`	`subtract(double[] a1, double s)` Subtracts `s` from all elements in `a1` overwriting the array.
`static double[]`	`subtract(double[] a1, double[] a2)` Element-wise subtraction of two arrays.
`static float[][]`	`subtract(float[][] a1, float[][] a2)` Element-wise subtraction of two arrays.
`static float[]`	`subtract(float[] a1, float s)` Subtracts `s` from all elements in `a1` overwriting the array.
`static float[]`	`subtract(float[] a1, float[] a2)` Element-wise subtraction of two arrays.
`static int[][]`	`subtract(int[][] a1, int[][] a2)` Element-wise subtraction of two arrays.
`static int[]`	`subtract(int[] a1, int s)` Subtracts `s` from all elements in `a1` overwriting the array.
`static int[]`	`subtract(int[] a1, int[] a2)` Element-wise subtraction of two arrays.
`static long[][]`	`subtract(long[][] a1, long[][] a2)` Element-wise subtraction of two arrays.
`static long[]`	`subtract(long[] a1, long s)` Subtracts `s` from all elements in `a1` overwriting the array.
`static long[]`	`subtract(long[] a1, long[] a2)` Element-wise subtraction of two arrays.
`static short[][]`	`subtract(short[][] a1, short[][] a2)` Element-wise subtraction of two arrays.
`static short[]`	`subtract(short[] a1, short s)` Subtracts `s` from all elements in `a1` overwriting the array.
`static short[]`	`subtract(short[] a1, short[] a2)` Element-wise subtraction of two arrays.
`static byte[][]`	`sum(byte[][] a1, byte[][] a2)` Element-wise summation of two arrays, output writes over first array
`static byte[]`	`sum(byte[] a1, byte[] a2)` Element-wise summation of two arrays, output writes over first array
`static double[][]`	`sum(double[][] a1, double[][] a2)` Element-wise summation of two arrays, output writes over first array
`static double[]`	`sum(double[] a1, double[] a2)` Element-wise summation of two arrays, output writes over first array
`static float[][]`	`sum(float[][] a1, float[][] a2)` Element-wise summation of two arrays, output writes over first array
`static float[]`	`sum(float[] a1, float[] a2)` Element-wise summation of two arrays, output writes over first array
`static int[][]`	`sum(int[][] a1, int[][] a2)` Element-wise summation of two arrays, output writes over first array
`static int[]`	`sum(int[] a1, int[] a2)` Element-wise summation of two arrays, output writes over first array
`static long[][]`	`sum(long[][] a1, long[][] a2)` Element-wise summation of two arrays, output writes over first array
`static long[]`	`sum(long[] a1, long[] a2)` Element-wise summation of two arrays, output writes over first array
`static short[][]`	`sum(short[][] a1, short[][] a2)` Element-wise summation of two arrays, output writes over first array
`static short[]`	`sum(short[] a1, short[] a2)` Element-wise summation of two arrays, output writes over first array
`static int`	`sumValues(byte[] vector)` Compute the sum of values in an array
`static int`	`sumValues(byte[][] array)` Compute the sum of values in a 2d array
`static double`	`sumValues(double[] vector)` Compute the sum of values in an array
`static double`	`sumValues(double[][] array)` Compute the sum of values in a 2d array
`static float`	`sumValues(float[] vector)` Compute the sum of values in an array
`static float`	`sumValues(float[][] array)` Compute the sum of values in a 2d array
`static long`	`sumValues(int[] vector)` Compute the sum of values in an array
`static long`	`sumValues(int[][] array)` Compute the sum of values in a 2d array
`static long`	`sumValues(long[] vector)` Compute the sum of values in an array
`static long`	`sumValues(long[][] array)` Compute the sum of values in a 2d array
`static int`	`sumValues(short[] vector)` Compute the sum of values in an array
`static int`	`sumValues(short[][] array)` Compute the sum of values in a 2d array
`static int`	`sumValuesSquared(byte[] vector)` Compute the sum of values squared in an array
`static double`	`sumValuesSquared(double[] vector)` Compute the sum of values squared in an array
`static float`	`sumValuesSquared(float[] vector)` Compute the sum of values squared in an array
`static long`	`sumValuesSquared(int[] vector)` Compute the sum of values squared in an array
`static long`	`sumValuesSquared(long[] vector)` Compute the sum of values squared in an array
`static int`	`sumValuesSquared(short[] vector)` Compute the sum of values squared in an array
`static String`	`toString(String[] s, String glue)` Convert the array to a `String` by joining the elements with the given glue.
`static byte[][]`	`truncate(byte[][] array, int index)` Truncates every element in the given array to the given size.
`static byte[]`	`truncate(byte[] array, int index)` Truncates the given array to the given size.
`static double[][]`	`truncate(double[][] array, int index)` Truncates every element in the given array to the given size.
`static double[]`	`truncate(double[] array, int index)` Truncates the given array to the given size.
`static float[][]`	`truncate(float[][] array, int index)` Truncates every element in the given array to the given size.
`static float[]`	`truncate(float[] array, int index)` Truncates the given array to the given size.
`static int[][]`	`truncate(int[][] array, int index)` Truncates every element in the given array to the given size.
`static int[]`	`truncate(int[] array, int index)` Truncates the given array to the given size.
`static long[][]`	`truncate(long[][] array, int index)` Truncates every element in the given array to the given size.
`static long[]`	`truncate(long[] array, int index)` Truncates the given array to the given size.
`static short[][]`	`truncate(short[][] array, int index)` Truncates every element in the given array to the given size.
`static short[]`	`truncate(short[] array, int index)` Truncates the given array to the given size.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Method Detail
  - maxValue
```
public static double maxValue(double[] arr)
```
    Returns the largest value in the array.
    
    Parameters:
    arr - array of double
    
    Returns:
    the value
  - maxValue
```
public static float maxValue(float[] arr)
```
    Returns the largest value in the array.
    
    Parameters:
    arr - array of float
    
    Returns:
    the value
  - maxValue
```
public static int maxValue(int[] arr)
```
    Returns the largest value in the array.
    
    Parameters:
    arr - array of int
    
    Returns:
    the value
  - maxValue
```
public static long maxValue(long[] arr)
```
    Returns the largest value in the array.
    
    Parameters:
    arr - array of long
    
    Returns:
    the value
  - maxValue
```
public static byte maxValue(byte[] arr)
```
    Returns the largest value in the array.
    
    Parameters:
    arr - array of byte
    
    Returns:
    the value
  - maxValue
```
public static short maxValue(short[] arr)
```
    Returns the largest value in the array.
    
    Parameters:
    arr - array of short
    
    Returns:
    the value
  - minValue
```
public static double minValue(double[] arr)
```
    Returns the smallest value in the array.
    
    Parameters:
    arr - array of double
    
    Returns:
    the value
  - minValue
```
public static float minValue(float[] arr)
```
    Returns the smallest value in the array.
    
    Parameters:
    arr - array of float
    
    Returns:
    the value
  - minValue
```
public static int minValue(int[] arr)
```
    Returns the smallest value in the array.
    
    Parameters:
    arr - array of int
    
    Returns:
    the value
  - minValue
```
public static long minValue(long[] arr)
```
    Returns the smallest value in the array.
    
    Parameters:
    arr - array of long
    
    Returns:
    the value
  - minValue
```
public static byte minValue(byte[] arr)
```
    Returns the smallest value in the array.
    
    Parameters:
    arr - array of byte
    
    Returns:
    the value
  - minValue
```
public static short minValue(short[] arr)
```
    Returns the smallest value in the array.
    
    Parameters:
    arr - array of short
    
    Returns:
    the value
  - maxIndex
```
public static int maxIndex(double[] arr)
```
    Returns the index to the biggest value in the array.
    
    Parameters:
    arr - array of double
    
    Returns:
    the index
  - maxIndex
```
public static int maxIndex(float[] arr)
```
    Returns the index to the biggest value in the array.
    
    Parameters:
    arr - array of float
    
    Returns:
    the index
  - maxIndex
```
public static int maxIndex(int[] arr)
```
    Returns the index to the biggest value in the array.
    
    Parameters:
    arr - array of int
    
    Returns:
    the index
  - maxIndex
```
public static int maxIndex(long[] arr)
```
    Returns the index to the biggest value in the array.
    
    Parameters:
    arr - array of long
    
    Returns:
    the index
  - maxIndex
```
public static int maxIndex(byte[] arr)
```
    Returns the index to the biggest value in the array.
    
    Parameters:
    arr - array of byte
    
    Returns:
    the index
  - maxIndex
```
public static int maxIndex(short[] arr)
```
    Returns the index to the biggest value in the array.
    
    Parameters:
    arr - array of short
    
    Returns:
    the index
  - minIndex
```
public static int minIndex(double[] arr)
```
    Returns the index to the smallest value in the array.
    
    Parameters:
    arr - array of double
    
    Returns:
    the index
  - minIndex
```
public static int minIndex(float[] arr)
```
    Returns the index to the smallest value in the array.
    
    Parameters:
    arr - array of float
    
    Returns:
    the index
  - minIndex
```
public static int minIndex(int[] arr)
```
    Returns the index to the smallest value in the array.
    
    Parameters:
    arr - array of int
    
    Returns:
    the index
  - minIndex
```
public static int minIndex(long[] arr)
```
    Returns the index to the smallest value in the array.
    
    Parameters:
    arr - array of long
    
    Returns:
    the index
  - minIndex
```
public static int minIndex(byte[] arr)
```
    Returns the index to the smallest value in the array.
    
    Parameters:
    arr - array of byte
    
    Returns:
    the index
  - minIndex
```
public static int minIndex(short[] arr)
```
    Returns the index to the smallest value in the array.
    
    Parameters:
    arr - array of short
    
    Returns:
    the index
  - sum
```
public static double[][] sum(double[][] a1,
             double[][] a2)
```
    Element-wise summation of two arrays, output writes over first array
    
    Parameters:
    a1 - first array
    a2 - second array
    
    Returns:
    the first array
  - sum
```
public static double[] sum(double[] a1,
           double[] a2)
```
    Element-wise summation of two arrays, output writes over first array
    
    Parameters:
    a1 - first array
    a2 - second array
    
    Returns:
    the first array
  - sum
```
public static float[][] sum(float[][] a1,
            float[][] a2)
```
    Element-wise summation of two arrays, output writes over first array
    
    Parameters:
    a1 - first array
    a2 - second array
    
    Returns:
    the first array
  - sum
```
public static float[] sum(float[] a1,
          float[] a2)
```
    Element-wise summation of two arrays, output writes over first array
    
    Parameters:
    a1 - first array
    a2 - second array
    
    Returns:
    the first array
  - sum
```
public static int[][] sum(int[][] a1,
          int[][] a2)
```
    Element-wise summation of two arrays, output writes over first array
    
    Parameters:
    a1 - first array
    a2 - second array
    
    Returns:
    the first array
  - sum
```
public static int[] sum(int[] a1,
        int[] a2)
```
    Element-wise summation of two arrays, output writes over first array
    
    Parameters:
    a1 - first array
    a2 - second array
    
    Returns:
    the first array
  - sum
```
public static long[][] sum(long[][] a1,
           long[][] a2)
```
    Element-wise summation of two arrays, output writes over first array
    
    Parameters:
    a1 - first array
    a2 - second array
    
    Returns:
    the first array
  - sum
```
public static long[] sum(long[] a1,
         long[] a2)
```
    Element-wise summation of two arrays, output writes over first array
    
    Parameters:
    a1 - first array
    a2 - second array
    
    Returns:
    the first array
  - sum
```
public static byte[][] sum(byte[][] a1,
           byte[][] a2)
```
    Element-wise summation of two arrays, output writes over first array
    
    Parameters:
    a1 - first array
    a2 - second array
    
    Returns:
    the first array
  - sum
```
public static byte[] sum(byte[] a1,
         byte[] a2)
```
    Element-wise summation of two arrays, output writes over first array
    
    Parameters:
    a1 - first array
    a2 - second array
    
    Returns:
    the first array
  - sum
```
public static short[][] sum(short[][] a1,
            short[][] a2)
```
    Element-wise summation of two arrays, output writes over first array
    
    Parameters:
    a1 - first array
    a2 - second array
    
    Returns:
    the first array
  - sum
```
public static short[] sum(short[] a1,
          short[] a2)
```
    Element-wise summation of two arrays, output writes over first array
    
    Parameters:
    a1 - first array
    a2 - second array
    
    Returns:
    the first array
  - subtract
```
public static double[][] subtract(double[][] a1,
                  double[][] a2)
```
    Element-wise subtraction of two arrays. Second array is subtracted from first, overwriting the first array
    
    Parameters:
    a1 - first array
    a2 - second array
    
    Returns:
    the first array
  - subtract
```
public static double[] subtract(double[] a1,
                double[] a2)
```
    Element-wise subtraction of two arrays. Second array is subtracted from first, overwriting the first array
    
    Parameters:
    a1 - first array
    a2 - second array
    
    Returns:
    the first array
  - subtract
```
public static float[][] subtract(float[][] a1,
                 float[][] a2)
```
    Element-wise subtraction of two arrays. Second array is subtracted from first, overwriting the first array
    
    Parameters:
    a1 - first array
    a2 - second array
    
    Returns:
    the first array
  - subtract
```
public static float[] subtract(float[] a1,
               float[] a2)
```
    Element-wise subtraction of two arrays. Second array is subtracted from first, overwriting the first array
    
    Parameters:
    a1 - first array
    a2 - second array
    
    Returns:
    the first array
  - subtract
```
public static int[][] subtract(int[][] a1,
               int[][] a2)
```
    Element-wise subtraction of two arrays. Second array is subtracted from first, overwriting the first array
    
    Parameters:
    a1 - first array
    a2 - second array
    
    Returns:
    the first array
  - subtract
```
public static int[] subtract(int[] a1,
             int[] a2)
```
    Element-wise subtraction of two arrays. Second array is subtracted from first, overwriting the first array
    
    Parameters:
    a1 - first array
    a2 - second array
    
    Returns:
    the first array
  - subtract
```
public static long[][] subtract(long[][] a1,
                long[][] a2)
```
    Element-wise subtraction of two arrays. Second array is subtracted from first, overwriting the first array
    
    Parameters:
    a1 - first array
    a2 - second array
    
    Returns:
    the first array
  - subtract
```
public static long[] subtract(long[] a1,
              long[] a2)
```
    Element-wise subtraction of two arrays. Second array is subtracted from first, overwriting the first array
    
    Parameters:
    a1 - first array
    a2 - second array
    
    Returns:
    the first array
  - subtract
```
public static byte[][] subtract(byte[][] a1,
                byte[][] a2)
```
    Element-wise subtraction of two arrays. Second array is subtracted from first, overwriting the first array
    
    Parameters:
    a1 - first array
    a2 - second array
    
    Returns:
    the first array
  - subtract
```
public static byte[] subtract(byte[] a1,
              byte[] a2)
```
    Element-wise subtraction of two arrays. Second array is subtracted from first, overwriting the first array
    
    Parameters:
    a1 - first array
    a2 - second array
    
    Returns:
    the first array
  - subtract
```
public static short[][] subtract(short[][] a1,
                 short[][] a2)
```
    Element-wise subtraction of two arrays. Second array is subtracted from first, overwriting the first array
    
    Parameters:
    a1 - first array
    a2 - second array
    
    Returns:
    the first array
  - subtract
```
public static short[] subtract(short[] a1,
               short[] a2)
```
    Element-wise subtraction of two arrays. Second array is subtracted from first, overwriting the first array
    
    Parameters:
    a1 - first array
    a2 - second array
    
    Returns:
    the first array
  - subtract
```
public static double[] subtract(double[] a1,
                double s)
```
    Subtracts s from all elements in a1 overwriting the array. This is syntactic sugar for add( a1, -s ).
    
    Parameters:
    a1 - The array
    s - The scalar
    
    Returns:
    the array
  - subtract
```
public static float[] subtract(float[] a1,
               float s)
```
    Subtracts s from all elements in a1 overwriting the array. This is syntactic sugar for add( a1, -s ).
    
    Parameters:
    a1 - The array
    s - The scalar
    
    Returns:
    the array
  - subtract
```
public static int[] subtract(int[] a1,
             int s)
```
    Subtracts s from all elements in a1 overwriting the array. This is syntactic sugar for add( a1, -s ).
    
    Parameters:
    a1 - The array
    s - The scalar
    
    Returns:
    the array
  - subtract
```
public static long[] subtract(long[] a1,
              long s)
```
    Subtracts s from all elements in a1 overwriting the array. This is syntactic sugar for add( a1, -s ).
    
    Parameters:
    a1 - The array
    s - The scalar
    
    Returns:
    the array
  - subtract
```
public static byte[] subtract(byte[] a1,
              byte s)
```
    Subtracts s from all elements in a1 overwriting the array. This is syntactic sugar for add( a1, -s ).
    
    Parameters:
    a1 - The array
    s - The scalar
    
    Returns:
    the array
  - subtract
```
public static short[] subtract(short[] a1,
               short s)
```
    Subtracts s from all elements in a1 overwriting the array. This is syntactic sugar for add( a1, -s ).
    
    Parameters:
    a1 - The array
    s - The scalar
    
    Returns:
    the array
  - add
```
public static double[] add(double[] ds,
           double x)
```
    Add a constant to all elements and return the input
    
    Parameters:
    ds - input array
    x - constant to add
    
    Returns:
    the input array
  - add
```
public static float[] add(float[] ds,
          float x)
```
    Add a constant to all elements and return the input
    
    Parameters:
    ds - input array
    x - constant to add
    
    Returns:
    the input array
  - add
```
public static int[] add(int[] ds,
        int x)
```
    Add a constant to all elements and return the input
    
    Parameters:
    ds - input array
    x - constant to add
    
    Returns:
    the input array
  - add
```
public static long[] add(long[] ds,
         long x)
```
    Add a constant to all elements and return the input
    
    Parameters:
    ds - input array
    x - constant to add
    
    Returns:
    the input array
  - add
```
public static byte[] add(byte[] ds,
         byte x)
```
    Add a constant to all elements and return the input
    
    Parameters:
    ds - input array
    x - constant to add
    
    Returns:
    the input array
  - add
```
public static short[] add(short[] ds,
          short x)
```
    Add a constant to all elements and return the input
    
    Parameters:
    ds - input array
    x - constant to add
    
    Returns:
    the input array
  - multiply
```
public static double[] multiply(double[] ds,
                double x)
```
    Multiply by a constant all elements and return the input
    
    Parameters:
    ds - input array
    x - constant to multiply by
    
    Returns:
    input
  - multiply
```
public static double[][] multiply(double[][] ds,
                  double x)
```
    Multiply by a constant all elements and return the input
    
    Parameters:
    ds - input array
    x - constant to multiply by
    
    Returns:
    input
  - multiply
```
public static float[] multiply(float[] ds,
               float x)
```
    Multiply by a constant all elements and return the input
    
    Parameters:
    ds - input array
    x - constant to multiply by
    
    Returns:
    input
  - multiply
```
public static float[][] multiply(float[][] ds,
                 float x)
```
    Multiply by a constant all elements and return the input
    
    Parameters:
    ds - input array
    x - constant to multiply by
    
    Returns:
    input
  - multiply
```
public static int[] multiply(int[] ds,
             int x)
```
    Multiply by a constant all elements and return the input
    
    Parameters:
    ds - input array
    x - constant to multiply by
    
    Returns:
    input
  - multiply
```
public static int[][] multiply(int[][] ds,
               int x)
```
    Multiply by a constant all elements and return the input
    
    Parameters:
    ds - input array
    x - constant to multiply by
    
    Returns:
    input
  - multiply
```
public static long[] multiply(long[] ds,
              long x)
```
    Multiply by a constant all elements and return the input
    
    Parameters:
    ds - input array
    x - constant to multiply by
    
    Returns:
    input
  - multiply
```
public static long[][] multiply(long[][] ds,
                long x)
```
    Multiply by a constant all elements and return the input
    
    Parameters:
    ds - input array
    x - constant to multiply by
    
    Returns:
    input
  - multiply
```
public static byte[] multiply(byte[] ds,
              byte x)
```
    Multiply by a constant all elements and return the input
    
    Parameters:
    ds - input array
    x - constant to multiply by
    
    Returns:
    input
  - multiply
```
public static byte[][] multiply(byte[][] ds,
                byte x)
```
    Multiply by a constant all elements and return the input
    
    Parameters:
    ds - input array
    x - constant to multiply by
    
    Returns:
    input
  - multiply
```
public static short[] multiply(short[] ds,
               short x)
```
    Multiply by a constant all elements and return the input
    
    Parameters:
    ds - input array
    x - constant to multiply by
    
    Returns:
    input
  - multiply
```
public static short[][] multiply(short[][] ds,
                 short x)
```
    Multiply by a constant all elements and return the input
    
    Parameters:
    ds - input array
    x - constant to multiply by
    
    Returns:
    input
  - multiply
```
public static double[] multiply(double[] a1,
                double[] a2)
```
    Element-wise multiplication, overwriting a1
    
    Parameters:
    a1 - The first array
    a2 - the second array
    
    Returns:
    The first array
  - multiply
```
public static double[][] multiply(double[][] a1,
                  double[][] a2)
```
    Element-wise multiplication, overwriting a1.
    
    Parameters:
    a1 - First array
    a2 - second array
    
    Returns:
    Updated first array
  - multiply
```
public static float[] multiply(float[] a1,
               float[] a2)
```
    Element-wise multiplication, overwriting a1
    
    Parameters:
    a1 - The first array
    a2 - the second array
    
    Returns:
    The first array
  - multiply
```
public static float[][] multiply(float[][] a1,
                 float[][] a2)
```
    Element-wise multiplication, overwriting a1.
    
    Parameters:
    a1 - First array
    a2 - second array
    
    Returns:
    Updated first array
  - multiply
```
public static int[] multiply(int[] a1,
             int[] a2)
```
    Element-wise multiplication, overwriting a1
    
    Parameters:
    a1 - The first array
    a2 - the second array
    
    Returns:
    The first array
  - multiply
```
public static int[][] multiply(int[][] a1,
               int[][] a2)
```
    Element-wise multiplication, overwriting a1.
    
    Parameters:
    a1 - First array
    a2 - second array
    
    Returns:
    Updated first array
  - multiply
```
public static long[] multiply(long[] a1,
              long[] a2)
```
    Element-wise multiplication, overwriting a1
    
    Parameters:
    a1 - The first array
    a2 - the second array
    
    Returns:
    The first array
  - multiply
```
public static long[][] multiply(long[][] a1,
                long[][] a2)
```
    Element-wise multiplication, overwriting a1.
    
    Parameters:
    a1 - First array
    a2 - second array
    
    Returns:
    Updated first array
  - multiply
```
public static byte[] multiply(byte[] a1,
              byte[] a2)
```
    Element-wise multiplication, overwriting a1
    
    Parameters:
    a1 - The first array
    a2 - the second array
    
    Returns:
    The first array
  - multiply
```
public static byte[][] multiply(byte[][] a1,
                byte[][] a2)
```
    Element-wise multiplication, overwriting a1.
    
    Parameters:
    a1 - First array
    a2 - second array
    
    Returns:
    Updated first array
  - multiply
```
public static short[] multiply(short[] a1,
               short[] a2)
```
    Element-wise multiplication, overwriting a1
    
    Parameters:
    a1 - The first array
    a2 - the second array
    
    Returns:
    The first array
  - multiply
```
public static short[][] multiply(short[][] a1,
                 short[][] a2)
```
    Element-wise multiplication, overwriting a1.
    
    Parameters:
    a1 - First array
    a2 - second array
    
    Returns:
    Updated first array
  - divide
```
public static double[] divide(double[] fs,
              double x)
```
    Divide by a constant, all elements and return the input
    
    Parameters:
    fs - The input array
    x - the constant to divide by
    
    Returns:
    THe input
  - divide
```
public static float[] divide(float[] fs,
             float x)
```
    Divide by a constant, all elements and return the input
    
    Parameters:
    fs - The input array
    x - the constant to divide by
    
    Returns:
    THe input
  - divide
```
public static int[] divide(int[] fs,
           int x)
```
    Divide by a constant, all elements and return the input
    
    Parameters:
    fs - The input array
    x - the constant to divide by
    
    Returns:
    THe input
  - divide
```
public static long[] divide(long[] fs,
            long x)
```
    Divide by a constant, all elements and return the input
    
    Parameters:
    fs - The input array
    x - the constant to divide by
    
    Returns:
    THe input
  - divide
```
public static byte[] divide(byte[] fs,
            byte x)
```
    Divide by a constant, all elements and return the input
    
    Parameters:
    fs - The input array
    x - the constant to divide by
    
    Returns:
    THe input
  - divide
```
public static short[] divide(short[] fs,
             short x)
```
    Divide by a constant, all elements and return the input
    
    Parameters:
    fs - The input array
    x - the constant to divide by
    
    Returns:
    THe input
  - normalise
```
public static float[] normalise(float[] array)
```
    Normalise length of array to 1.0. Writes over array. If the array is all zeros, it will be unchanged.
    
    Parameters:
    array - the array
    
    Returns:
    the array
  - normalise
```
public static double[] normalise(double[] array)
```
    Normalise length of array to 1.0. Writes over array. If the array is all zeros, it will be unchanged.
    
    Parameters:
    array - the array
    
    Returns:
    the array
  - reverse
```
public static double[] reverse(double[] ds)
```
    Reverse the elements in the input and return the input.
    
    Parameters:
    ds - input array
    
    Returns:
    input
  - reverse
```
public static float[] reverse(float[] ds)
```
    Reverse the elements in the input and return the input.
    
    Parameters:
    ds - input array
    
    Returns:
    input
  - reverse
```
public static int[] reverse(int[] ds)
```
    Reverse the elements in the input and return the input.
    
    Parameters:
    ds - input array
    
    Returns:
    input
  - reverse
```
public static long[] reverse(long[] ds)
```
    Reverse the elements in the input and return the input.
    
    Parameters:
    ds - input array
    
    Returns:
    input
  - reverse
```
public static byte[] reverse(byte[] ds)
```
    Reverse the elements in the input and return the input.
    
    Parameters:
    ds - input array
    
    Returns:
    input
  - reverse
```
public static short[] reverse(short[] ds)
```
    Reverse the elements in the input and return the input.
    
    Parameters:
    ds - input array
    
    Returns:
    input
  - convertToDouble
```
public static double[] convertToDouble(double[] array)
```
    Convert a double array to a double array.
    
    Parameters:
    array - array of doubles to convert
    
    Returns:
    array of doubles
  - convertToDouble
```
public static double[][] convertToDouble(double[][] array)
```
    Convert a double array to a double array.
    
    Parameters:
    array - array of doubles to convert
    
    Returns:
    array of doubles
  - convertToDouble
```
public static double[] convertToDouble(float[] array)
```
    Convert a float array to a double array.
    
    Parameters:
    array - array of floats to convert
    
    Returns:
    array of doubles
  - convertToDouble
```
public static double[][] convertToDouble(float[][] array)
```
    Convert a float array to a double array.
    
    Parameters:
    array - array of floats to convert
    
    Returns:
    array of doubles
  - convertToDouble
```
public static double[] convertToDouble(int[] array)
```
    Convert a int array to a double array.
    
    Parameters:
    array - array of ints to convert
    
    Returns:
    array of doubles
  - convertToDouble
```
public static double[][] convertToDouble(int[][] array)
```
    Convert a int array to a double array.
    
    Parameters:
    array - array of ints to convert
    
    Returns:
    array of doubles
  - convertToDouble
```
public static double[] convertToDouble(long[] array)
```
    Convert a long array to a double array.
    
    Parameters:
    array - array of longs to convert
    
    Returns:
    array of doubles
  - convertToDouble
```
public static double[][] convertToDouble(long[][] array)
```
    Convert a long array to a double array.
    
    Parameters:
    array - array of longs to convert
    
    Returns:
    array of doubles
  - convertToDouble
```
public static double[] convertToDouble(byte[] array)
```
    Convert a byte array to a double array.
    
    Parameters:
    array - array of bytes to convert
    
    Returns:
    array of doubles
  - convertToDouble
```
public static double[][] convertToDouble(byte[][] array)
```
    Convert a byte array to a double array.
    
    Parameters:
    array - array of bytes to convert
    
    Returns:
    array of doubles
  - convertToDouble
```
public static double[] convertToDouble(short[] array)
```
    Convert a short array to a double array.
    
    Parameters:
    array - array of shorts to convert
    
    Returns:
    array of doubles
  - convertToDouble
```
public static double[][] convertToDouble(short[][] array)
```
    Convert a short array to a double array.
    
    Parameters:
    array - array of shorts to convert
    
    Returns:
    array of doubles
  - convertToFloat
```
public static float[] convertToFloat(double[] array)
```
    Convert a double array to a float array.
    
    Parameters:
    array - array of doubles to convert
    
    Returns:
    array of floats
  - convertToFloat
```
public static float[][] convertToFloat(double[][] array)
```
    Convert a double array to a float array.
    
    Parameters:
    array - array of doubles to convert
    
    Returns:
    array of doubles
  - convertToFloat
```
public static float[] convertToFloat(float[] array)
```
    Convert a float array to a float array.
    
    Parameters:
    array - array of floats to convert
    
    Returns:
    array of floats
  - convertToFloat
```
public static float[][] convertToFloat(float[][] array)
```
    Convert a float array to a float array.
    
    Parameters:
    array - array of floats to convert
    
    Returns:
    array of doubles
  - convertToFloat
```
public static float[] convertToFloat(int[] array)
```
    Convert a int array to a float array.
    
    Parameters:
    array - array of ints to convert
    
    Returns:
    array of floats
  - convertToFloat
```
public static float[][] convertToFloat(int[][] array)
```
    Convert a int array to a float array.
    
    Parameters:
    array - array of ints to convert
    
    Returns:
    array of doubles
  - convertToFloat
```
public static float[] convertToFloat(long[] array)
```
    Convert a long array to a float array.
    
    Parameters:
    array - array of longs to convert
    
    Returns:
    array of floats
  - convertToFloat
```
public static float[][] convertToFloat(long[][] array)
```
    Convert a long array to a float array.
    
    Parameters:
    array - array of longs to convert
    
    Returns:
    array of doubles
  - convertToFloat
```
public static float[] convertToFloat(byte[] array)
```
    Convert a byte array to a float array.
    
    Parameters:
    array - array of bytes to convert
    
    Returns:
    array of floats
  - convertToFloat
```
public static float[][] convertToFloat(byte[][] array)
```
    Convert a byte array to a float array.
    
    Parameters:
    array - array of bytes to convert
    
    Returns:
    array of doubles
  - convertToFloat
```
public static float[] convertToFloat(short[] array)
```
    Convert a short array to a float array.
    
    Parameters:
    array - array of shorts to convert
    
    Returns:
    array of floats
  - convertToFloat
```
public static float[][] convertToFloat(short[][] array)
```
    Convert a short array to a float array.
    
    Parameters:
    array - array of shorts to convert
    
    Returns:
    array of doubles
  - firstNonNull
```
public static <T> T firstNonNull(T[] array)
```
    Return the first non-null item from an array.
    
    Type Parameters:
    T - the type of the elements in the array
    Parameters:
    array - the array
    
    Returns:
    the first non-null object, or null if not found.
  - concatenate
```
public static <T> T[] concatenate(T[]... arrays)
```
    Concatenate multiple arrays into a single new array.
    
    Type Parameters:
    T - Type of elements in the array.
    Parameters:
    arrays - the arrays to concatenate.
    
    Returns:
    the new concatenated array
  - concatenate
```
public static double[] concatenate(double[]... arrays)
```
    Concatenate multiple arrays into a single new array.
    
    Parameters:
    arrays - the arrays to concatenate.
    
    Returns:
    the new concatenated array
  - concatenate
```
public static float[] concatenate(float[]... arrays)
```
    Concatenate multiple arrays into a single new array.
    
    Parameters:
    arrays - the arrays to concatenate.
    
    Returns:
    the new concatenated array
  - concatenate
```
public static int[] concatenate(int[]... arrays)
```
    Concatenate multiple arrays into a single new array.
    
    Parameters:
    arrays - the arrays to concatenate.
    
    Returns:
    the new concatenated array
  - concatenate
```
public static long[] concatenate(long[]... arrays)
```
    Concatenate multiple arrays into a single new array.
    
    Parameters:
    arrays - the arrays to concatenate.
    
    Returns:
    the new concatenated array
  - concatenate
```
public static byte[] concatenate(byte[]... arrays)
```
    Concatenate multiple arrays into a single new array.
    
    Parameters:
    arrays - the arrays to concatenate.
    
    Returns:
    the new concatenated array
  - concatenate
```
public static short[] concatenate(short[]... arrays)
```
    Concatenate multiple arrays into a single new array.
    
    Parameters:
    arrays - the arrays to concatenate.
    
    Returns:
    the new concatenated array
  - concatenate
```
public static double[][] concatenate(double[][]... arrays)
```
    Concatenate multiple arrays into a single new array.
    
    Parameters:
    arrays - the arrays to concatenate.
    
    Returns:
    the new concatenated array
  - concatenate
```
public static float[][] concatenate(float[][]... arrays)
```
    Concatenate multiple arrays into a single new array.
    
    Parameters:
    arrays - the arrays to concatenate.
    
    Returns:
    the new concatenated array
  - concatenate
```
public static int[][] concatenate(int[][]... arrays)
```
    Concatenate multiple arrays into a single new array.
    
    Parameters:
    arrays - the arrays to concatenate.
    
    Returns:
    the new concatenated array
  - concatenate
```
public static long[][] concatenate(long[][]... arrays)
```
    Concatenate multiple arrays into a single new array.
    
    Parameters:
    arrays - the arrays to concatenate.
    
    Returns:
    the new concatenated array
  - concatenate
```
public static byte[][] concatenate(byte[][]... arrays)
```
    Concatenate multiple arrays into a single new array.
    
    Parameters:
    arrays - the arrays to concatenate.
    
    Returns:
    the new concatenated array
  - concatenate
```
public static short[][] concatenate(short[][]... arrays)
```
    Concatenate multiple arrays into a single new array.
    
    Parameters:
    arrays - the arrays to concatenate.
    
    Returns:
    the new concatenated array
  - sumValues
```
public static double sumValues(double[] vector)
```
    Compute the sum of values in an array
    
    Parameters:
    vector -
    
    Returns:
    the sum of all values
  - sumValues
```
public static float sumValues(float[] vector)
```
    Compute the sum of values in an array
    
    Parameters:
    vector -
    
    Returns:
    the sum of all values
  - sumValues
```
public static int sumValues(byte[] vector)
```
    Compute the sum of values in an array
    
    Parameters:
    vector -
    
    Returns:
    the sum of all values
  - sumValues
```
public static int sumValues(short[] vector)
```
    Compute the sum of values in an array
    
    Parameters:
    vector -
    
    Returns:
    the sum of all values
  - sumValues
```
public static long sumValues(int[] vector)
```
    Compute the sum of values in an array
    
    Parameters:
    vector -
    
    Returns:
    the sum of all values
  - sumValues
```
public static long sumValues(long[] vector)
```
    Compute the sum of values in an array
    
    Parameters:
    vector -
    
    Returns:
    the sum of all values
  - sumValues
```
public static double sumValues(double[][] array)
```
    Compute the sum of values in a 2d array
    
    Parameters:
    array -
    
    Returns:
    the sum of all values
  - sumValues
```
public static float sumValues(float[][] array)
```
    Compute the sum of values in a 2d array
    
    Parameters:
    array -
    
    Returns:
    the sum of all values
  - sumValues
```
public static int sumValues(byte[][] array)
```
    Compute the sum of values in a 2d array
    
    Parameters:
    array -
    
    Returns:
    the sum of all values
  - sumValues
```
public static int sumValues(short[][] array)
```
    Compute the sum of values in a 2d array
    
    Parameters:
    array -
    
    Returns:
    the sum of all values
  - sumValues
```
public static long sumValues(int[][] array)
```
    Compute the sum of values in a 2d array
    
    Parameters:
    array -
    
    Returns:
    the sum of all values
  - sumValues
```
public static long sumValues(long[][] array)
```
    Compute the sum of values in a 2d array
    
    Parameters:
    array -
    
    Returns:
    the sum of all values
  - sumValuesSquared
```
public static double sumValuesSquared(double[] vector)
```
    Compute the sum of values squared in an array
    
    Parameters:
    vector -
    
    Returns:
    the sum of all values
  - sumValuesSquared
```
public static float sumValuesSquared(float[] vector)
```
    Compute the sum of values squared in an array
    
    Parameters:
    vector -
    
    Returns:
    the sum of all values
  - sumValuesSquared
```
public static int sumValuesSquared(byte[] vector)
```
    Compute the sum of values squared in an array
    
    Parameters:
    vector -
    
    Returns:
    the sum of all values
  - sumValuesSquared
```
public static int sumValuesSquared(short[] vector)
```
    Compute the sum of values squared in an array
    
    Parameters:
    vector -
    
    Returns:
    the sum of all values
  - sumValuesSquared
```
public static long sumValuesSquared(int[] vector)
```
    Compute the sum of values squared in an array
    
    Parameters:
    vector -
    
    Returns:
    the sum of all values
  - sumValuesSquared
```
public static long sumValuesSquared(long[] vector)
```
    Compute the sum of values squared in an array
    
    Parameters:
    vector -
    
    Returns:
    the sum of all values
  - cumulativeSum
```
public static double[] cumulativeSum(double[] vector)
```
    Compute the cumulative sum of values in an array
    
    Parameters:
    vector -
    
    Returns:
    the sum of all values
  - cumulativeSum
```
public static float[] cumulativeSum(float[] vector)
```
    Compute the cumulative sum of values in an array
    
    Parameters:
    vector -
    
    Returns:
    the sum of all values
  - cumulativeSum
```
public static int[] cumulativeSum(byte[] vector)
```
    Compute the cumulative sum of values in an array
    
    Parameters:
    vector -
    
    Returns:
    the sum of all values
  - cumulativeSum
```
public static int[] cumulativeSum(short[] vector)
```
    Compute the cumulative sum of values in an array
    
    Parameters:
    vector -
    
    Returns:
    the sum of all values
  - cumulativeSum
```
public static long[] cumulativeSum(int[] vector)
```
    Compute the cumulative sum of values in an array
    
    Parameters:
    vector -
    
    Returns:
    the sum of all values
  - cumulativeSum
```
public static long[] cumulativeSum(long[] vector)
```
    Compute the cumulative sum of values in an array
    
    Parameters:
    vector -
    
    Returns:
    the sum of all values
  - rowSum
```
public static double[] rowSum(double[][] array)
```
    Compute the sum of values in each row of a 2d array
    
    Parameters:
    array - the array
    
    Returns:
    the sum of each row
  - rowSum
```
public static float[] rowSum(float[][] array)
```
    Compute the sum of values in each row of a 2d array
    
    Parameters:
    array - the array
    
    Returns:
    the sum of each row
  - rowSum
```
public static int[] rowSum(byte[][] array)
```
    Compute the sum of values in each row of a 2d array
    
    Parameters:
    array - the array
    
    Returns:
    the sum of each row
  - rowSum
```
public static int[] rowSum(short[][] array)
```
    Compute the sum of values in each row of a 2d array
    
    Parameters:
    array - the array
    
    Returns:
    the sum of each row
  - rowSum
```
public static long[] rowSum(int[][] array)
```
    Compute the sum of values in each row of a 2d array
    
    Parameters:
    array - the array
    
    Returns:
    the sum of each row
  - rowSum
```
public static long[] rowSum(long[][] array)
```
    Compute the sum of values in each row of a 2d array
    
    Parameters:
    array - the array
    
    Returns:
    the sum of each row
  - colSum
```
public static double[] colSum(double[][] array)
```
    Compute the sum of values in each column of a 2d array
    
    Parameters:
    array - the array
    
    Returns:
    the sum of each column
  - colSum
```
public static float[] colSum(float[][] array)
```
    Compute the sum of values in each column of a 2d array
    
    Parameters:
    array - the array
    
    Returns:
    the sum of each column
  - colSum
```
public static int[] colSum(byte[][] array)
```
    Compute the sum of values in each column of a 2d array
    
    Parameters:
    array - the array
    
    Returns:
    the sum of each column
  - colSum
```
public static int[] colSum(short[][] array)
```
    Compute the sum of values in each column of a 2d array
    
    Parameters:
    array - the array
    
    Returns:
    the sum of each column
  - colSum
```
public static long[] colSum(int[][] array)
```
    Compute the sum of values in each column of a 2d array
    
    Parameters:
    array - the array
    
    Returns:
    the sum of each column
  - colSum
```
public static long[] colSum(long[][] array)
```
    Compute the sum of values in each column of a 2d array
    
    Parameters:
    array - the array
    
    Returns:
    the sum of each column
  - range
```
public static int[] range(int start,
          int length)
```
    Extract a range
    
    Parameters:
    start -
    length -
    
    Returns:
    [start...length] (inclusive)
  - search
```
public static int[] search(double[] a,
           double value)
```
    Find the given value in the array, and return all indices at which it occurs.
    
    Parameters:
    a - array to search
    value - value to search for
    
    Returns:
    the found values
  - search
```
public static int[] search(float[] a,
           float value)
```
    Find the given value in the array, and return all indices at which it occurs.
    
    Parameters:
    a - array to search
    value - value to search for
    
    Returns:
    the found values
  - search
```
public static int[] search(int[] a,
           int value)
```
    Find the given value in the array, and return all indices at which it occurs.
    
    Parameters:
    a - array to search
    value - value to search for
    
    Returns:
    the found values
  - search
```
public static int[] search(long[] a,
           long value)
```
    Find the given value in the array, and return all indices at which it occurs.
    
    Parameters:
    a - array to search
    value - value to search for
    
    Returns:
    the found values
  - search
```
public static int[] search(byte[] a,
           byte value)
```
    Find the given value in the array, and return all indices at which it occurs.
    
    Parameters:
    a - array to search
    value - value to search for
    
    Returns:
    the found values
  - search
```
public static int[] search(short[] a,
           short value)
```
    Find the given value in the array, and return all indices at which it occurs.
    
    Parameters:
    a - array to search
    value - value to search for
    
    Returns:
    the found values
  - reshape
```
public static double[] reshape(double[][] a)
```
    Reshape a 2D array into a 1D array
    
    Parameters:
    a - array to reshape
    
    Returns:
    the reshaped array
  - reshape
```
public static float[] reshape(float[][] a)
```
    Reshape a 2D array into a 1D array
    
    Parameters:
    a - array to reshape
    
    Returns:
    the reshaped array
  - reshape
```
public static int[] reshape(int[][] a)
```
    Reshape a 2D array into a 1D array
    
    Parameters:
    a - array to reshape
    
    Returns:
    the reshaped array
  - reshape
```
public static long[] reshape(long[][] a)
```
    Reshape a 2D array into a 1D array
    
    Parameters:
    a - array to reshape
    
    Returns:
    the reshaped array
  - reshape
```
public static byte[] reshape(byte[][] a)
```
    Reshape a 2D array into a 1D array
    
    Parameters:
    a - array to reshape
    
    Returns:
    the reshaped array
  - reshape
```
public static short[] reshape(short[][] a)
```
    Reshape a 2D array into a 1D array
    
    Parameters:
    a - array to reshape
    
    Returns:
    the reshaped array
  - reshapeDouble
```
public static double[] reshapeDouble(double[][] a)
```
    Reshape a 2D array into a 1D array of doubles
    
    Parameters:
    a - array to reshape
    
    Returns:
    the reshaped array
  - reshapeDouble
```
public static double[] reshapeDouble(float[][] a)
```
    Reshape a 2D array into a 1D array of doubles
    
    Parameters:
    a - array to reshape
    
    Returns:
    the reshaped array
  - reshapeDouble
```
public static double[] reshapeDouble(int[][] a)
```
    Reshape a 2D array into a 1D array of doubles
    
    Parameters:
    a - array to reshape
    
    Returns:
    the reshaped array
  - reshapeDouble
```
public static double[] reshapeDouble(long[][] a)
```
    Reshape a 2D array into a 1D array of doubles
    
    Parameters:
    a - array to reshape
    
    Returns:
    the reshaped array
  - reshapeDouble
```
public static double[] reshapeDouble(byte[][] a)
```
    Reshape a 2D array into a 1D array of doubles
    
    Parameters:
    a - array to reshape
    
    Returns:
    the reshaped array
  - reshapeDouble
```
public static double[] reshapeDouble(short[][] a)
```
    Reshape a 2D array into a 1D array of doubles
    
    Parameters:
    a - array to reshape
    
    Returns:
    the reshaped array
  - reshape
```
public static double[][] reshape(double[] a,
                 double[][] out)
```
    Reshape a 1D array into a 2D array
    
    Parameters:
    a - array to reshape
    out - the return array, correctly sized
    
    Returns:
    the reshaped array
  - reshape
```
public static double[][] reshape(double[] a,
                 int width,
                 int height)
```
    Reshape a 1D array into a 2D array
    
    Parameters:
    a - array to reshape
    width - the width of the return array
    height - the height of the return array
    
    Returns:
    the reshaped array
  - reshape
```
public static float[][] reshape(float[] a,
                float[][] out)
```
    Reshape a 1D array into a 2D array
    
    Parameters:
    a - array to reshape
    out - the return array, correctly sized
    
    Returns:
    the reshaped array
  - reshape
```
public static float[][] reshape(float[] a,
                int width,
                int height)
```
    Reshape a 1D array into a 2D array
    
    Parameters:
    a - array to reshape
    width - the width of the return array
    height - the height of the return array
    
    Returns:
    the reshaped array
  - reshape
```
public static int[][] reshape(int[] a,
              int[][] out)
```
    Reshape a 1D array into a 2D array
    
    Parameters:
    a - array to reshape
    out - the return array, correctly sized
    
    Returns:
    the reshaped array
  - reshape
```
public static int[][] reshape(int[] a,
              int width,
              int height)
```
    Reshape a 1D array into a 2D array
    
    Parameters:
    a - array to reshape
    width - the width of the return array
    height - the height of the return array
    
    Returns:
    the reshaped array
  - reshape
```
public static long[][] reshape(long[] a,
               long[][] out)
```
    Reshape a 1D array into a 2D array
    
    Parameters:
    a - array to reshape
    out - the return array, correctly sized
    
    Returns:
    the reshaped array
  - reshape
```
public static long[][] reshape(long[] a,
               int width,
               int height)
```
    Reshape a 1D array into a 2D array
    
    Parameters:
    a - array to reshape
    width - the width of the return array
    height - the height of the return array
    
    Returns:
    the reshaped array
  - reshape
```
public static byte[][] reshape(byte[] a,
               byte[][] out)
```
    Reshape a 1D array into a 2D array
    
    Parameters:
    a - array to reshape
    out - the return array, correctly sized
    
    Returns:
    the reshaped array
  - reshape
```
public static byte[][] reshape(byte[] a,
               int width,
               int height)
```
    Reshape a 1D array into a 2D array
    
    Parameters:
    a - array to reshape
    width - the width of the return array
    height - the height of the return array
    
    Returns:
    the reshaped array
  - reshape
```
public static short[][] reshape(short[] a,
                short[][] out)
```
    Reshape a 1D array into a 2D array
    
    Parameters:
    a - array to reshape
    out - the return array, correctly sized
    
    Returns:
    the reshaped array
  - reshape
```
public static short[][] reshape(short[] a,
                int width,
                int height)
```
    Reshape a 1D array into a 2D array
    
    Parameters:
    a - array to reshape
    width - the width of the return array
    height - the height of the return array
    
    Returns:
    the reshaped array
  - reshapeFloat
```
public static float[][] reshapeFloat(double[] a,
                     float[][] out)
```
    Reshape a 1D array into a 2D array
    
    Parameters:
    a - array to reshape
    out - the return array, correctly sized
    
    Returns:
    the reshaped array
  - reshapeFloat
```
public static float[][] reshapeFloat(double[] a,
                     int width,
                     int height)
```
    Reshape a 1D array into a 2D array
    
    Parameters:
    a - array to reshape
    width - the width of the return array
    height - the height of the return array
    
    Returns:
    the reshaped array
  - parallelQuicksortDescending
```
public static void parallelQuicksortDescending(double[] main,
                               double[] indices)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into descending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
  - parallelQuicksortDescending
```
public static void parallelQuicksortDescending(double[] main,
                               double[] indices,
                               int left,
                               int right)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into descending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
    left - the starting index
    right - the ending index
  - parallelQuicksortDescending
```
public static void parallelQuicksortDescending(float[] main,
                               double[] indices)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into descending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
  - parallelQuicksortDescending
```
public static void parallelQuicksortDescending(float[] main,
                               double[] indices,
                               int left,
                               int right)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into descending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
    left - the starting index
    right - the ending index
  - parallelQuicksortDescending
```
public static void parallelQuicksortDescending(int[] main,
                               double[] indices)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into descending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
  - parallelQuicksortDescending
```
public static void parallelQuicksortDescending(int[] main,
                               double[] indices,
                               int left,
                               int right)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into descending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
    left - the starting index
    right - the ending index
  - parallelQuicksortDescending
```
public static void parallelQuicksortDescending(long[] main,
                               double[] indices)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into descending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
  - parallelQuicksortDescending
```
public static void parallelQuicksortDescending(long[] main,
                               double[] indices,
                               int left,
                               int right)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into descending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
    left - the starting index
    right - the ending index
  - parallelQuicksortDescending
```
public static void parallelQuicksortDescending(byte[] main,
                               double[] indices)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into descending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
  - parallelQuicksortDescending
```
public static void parallelQuicksortDescending(byte[] main,
                               double[] indices,
                               int left,
                               int right)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into descending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
    left - the starting index
    right - the ending index
  - parallelQuicksortDescending
```
public static void parallelQuicksortDescending(short[] main,
                               double[] indices)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into descending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
  - parallelQuicksortDescending
```
public static void parallelQuicksortDescending(short[] main,
                               double[] indices,
                               int left,
                               int right)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into descending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
    left - the starting index
    right - the ending index
  - parallelQuicksortDescending
```
public static void parallelQuicksortDescending(double[] main,
                               float[] indices)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into descending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
  - parallelQuicksortDescending
```
public static void parallelQuicksortDescending(double[] main,
                               float[] indices,
                               int left,
                               int right)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into descending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
    left - the starting index
    right - the ending index
  - parallelQuicksortDescending
```
public static void parallelQuicksortDescending(float[] main,
                               float[] indices)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into descending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
  - parallelQuicksortDescending
```
public static void parallelQuicksortDescending(float[] main,
                               float[] indices,
                               int left,
                               int right)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into descending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
    left - the starting index
    right - the ending index
  - parallelQuicksortDescending
```
public static void parallelQuicksortDescending(int[] main,
                               float[] indices)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into descending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
  - parallelQuicksortDescending
```
public static void parallelQuicksortDescending(int[] main,
                               float[] indices,
                               int left,
                               int right)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into descending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
    left - the starting index
    right - the ending index
  - parallelQuicksortDescending
```
public static void parallelQuicksortDescending(long[] main,
                               float[] indices)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into descending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
  - parallelQuicksortDescending
```
public static void parallelQuicksortDescending(long[] main,
                               float[] indices,
                               int left,
                               int right)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into descending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
    left - the starting index
    right - the ending index
  - parallelQuicksortDescending
```
public static void parallelQuicksortDescending(byte[] main,
                               float[] indices)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into descending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
  - parallelQuicksortDescending
```
public static void parallelQuicksortDescending(byte[] main,
                               float[] indices,
                               int left,
                               int right)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into descending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
    left - the starting index
    right - the ending index
  - parallelQuicksortDescending
```
public static void parallelQuicksortDescending(short[] main,
                               float[] indices)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into descending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
  - parallelQuicksortDescending
```
public static void parallelQuicksortDescending(short[] main,
                               float[] indices,
                               int left,
                               int right)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into descending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
    left - the starting index
    right - the ending index
  - parallelQuicksortDescending
```
public static void parallelQuicksortDescending(double[] main,
                               int[] indices)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into descending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
  - parallelQuicksortDescending
```
public static void parallelQuicksortDescending(double[] main,
                               int[] indices,
                               int left,
                               int right)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into descending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
    left - the starting index
    right - the ending index
  - parallelQuicksortDescending
```
public static void parallelQuicksortDescending(float[] main,
                               int[] indices)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into descending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
  - parallelQuicksortDescending
```
public static void parallelQuicksortDescending(float[] main,
                               int[] indices,
                               int left,
                               int right)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into descending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
    left - the starting index
    right - the ending index
  - parallelQuicksortDescending
```
public static void parallelQuicksortDescending(int[] main,
                               int[] indices)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into descending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
  - parallelQuicksortDescending
```
public static void parallelQuicksortDescending(int[] main,
                               int[] indices,
                               int left,
                               int right)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into descending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
    left - the starting index
    right - the ending index
  - parallelQuicksortDescending
```
public static void parallelQuicksortDescending(long[] main,
                               int[] indices)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into descending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
  - parallelQuicksortDescending
```
public static void parallelQuicksortDescending(long[] main,
                               int[] indices,
                               int left,
                               int right)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into descending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
    left - the starting index
    right - the ending index
  - parallelQuicksortDescending
```
public static void parallelQuicksortDescending(byte[] main,
                               int[] indices)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into descending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
  - parallelQuicksortDescending
```
public static void parallelQuicksortDescending(byte[] main,
                               int[] indices,
                               int left,
                               int right)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into descending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
    left - the starting index
    right - the ending index
  - parallelQuicksortDescending
```
public static void parallelQuicksortDescending(short[] main,
                               int[] indices)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into descending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
  - parallelQuicksortDescending
```
public static void parallelQuicksortDescending(short[] main,
                               int[] indices,
                               int left,
                               int right)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into descending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
    left - the starting index
    right - the ending index
  - parallelQuicksortDescending
```
public static void parallelQuicksortDescending(double[] main,
                               long[] indices)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into descending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
  - parallelQuicksortDescending
```
public static void parallelQuicksortDescending(double[] main,
                               long[] indices,
                               int left,
                               int right)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into descending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
    left - the starting index
    right - the ending index
  - parallelQuicksortDescending
```
public static void parallelQuicksortDescending(float[] main,
                               long[] indices)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into descending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
  - parallelQuicksortDescending
```
public static void parallelQuicksortDescending(float[] main,
                               long[] indices,
                               int left,
                               int right)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into descending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
    left - the starting index
    right - the ending index
  - parallelQuicksortDescending
```
public static void parallelQuicksortDescending(int[] main,
                               long[] indices)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into descending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
  - parallelQuicksortDescending
```
public static void parallelQuicksortDescending(int[] main,
                               long[] indices,
                               int left,
                               int right)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into descending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
    left - the starting index
    right - the ending index
  - parallelQuicksortDescending
```
public static void parallelQuicksortDescending(long[] main,
                               long[] indices)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into descending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
  - parallelQuicksortDescending
```
public static void parallelQuicksortDescending(long[] main,
                               long[] indices,
                               int left,
                               int right)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into descending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
    left - the starting index
    right - the ending index
  - parallelQuicksortDescending
```
public static void parallelQuicksortDescending(byte[] main,
                               long[] indices)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into descending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
  - parallelQuicksortDescending
```
public static void parallelQuicksortDescending(byte[] main,
                               long[] indices,
                               int left,
                               int right)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into descending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
    left - the starting index
    right - the ending index
  - parallelQuicksortDescending
```
public static void parallelQuicksortDescending(short[] main,
                               long[] indices)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into descending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
  - parallelQuicksortDescending
```
public static void parallelQuicksortDescending(short[] main,
                               long[] indices,
                               int left,
                               int right)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into descending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
    left - the starting index
    right - the ending index
  - parallelQuicksortDescending
```
public static void parallelQuicksortDescending(double[] main,
                               byte[] indices)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into descending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
  - parallelQuicksortDescending
```
public static void parallelQuicksortDescending(double[] main,
                               byte[] indices,
                               int left,
                               int right)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into descending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
    left - the starting index
    right - the ending index
  - parallelQuicksortDescending
```
public static void parallelQuicksortDescending(float[] main,
                               byte[] indices)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into descending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
  - parallelQuicksortDescending
```
public static void parallelQuicksortDescending(float[] main,
                               byte[] indices,
                               int left,
                               int right)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into descending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
    left - the starting index
    right - the ending index
  - parallelQuicksortDescending
```
public static void parallelQuicksortDescending(int[] main,
                               byte[] indices)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into descending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
  - parallelQuicksortDescending
```
public static void parallelQuicksortDescending(int[] main,
                               byte[] indices,
                               int left,
                               int right)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into descending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
    left - the starting index
    right - the ending index
  - parallelQuicksortDescending
```
public static void parallelQuicksortDescending(long[] main,
                               byte[] indices)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into descending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
  - parallelQuicksortDescending
```
public static void parallelQuicksortDescending(long[] main,
                               byte[] indices,
                               int left,
                               int right)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into descending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
    left - the starting index
    right - the ending index
  - parallelQuicksortDescending
```
public static void parallelQuicksortDescending(byte[] main,
                               byte[] indices)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into descending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
  - parallelQuicksortDescending
```
public static void parallelQuicksortDescending(byte[] main,
                               byte[] indices,
                               int left,
                               int right)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into descending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
    left - the starting index
    right - the ending index
  - parallelQuicksortDescending
```
public static void parallelQuicksortDescending(short[] main,
                               byte[] indices)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into descending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
  - parallelQuicksortDescending
```
public static void parallelQuicksortDescending(short[] main,
                               byte[] indices,
                               int left,
                               int right)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into descending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
    left - the starting index
    right - the ending index
  - parallelQuicksortDescending
```
public static void parallelQuicksortDescending(double[] main,
                               short[] indices)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into descending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
  - parallelQuicksortDescending
```
public static void parallelQuicksortDescending(double[] main,
                               short[] indices,
                               int left,
                               int right)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into descending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
    left - the starting index
    right - the ending index
  - parallelQuicksortDescending
```
public static void parallelQuicksortDescending(float[] main,
                               short[] indices)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into descending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
  - parallelQuicksortDescending
```
public static void parallelQuicksortDescending(float[] main,
                               short[] indices,
                               int left,
                               int right)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into descending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
    left - the starting index
    right - the ending index
  - parallelQuicksortDescending
```
public static void parallelQuicksortDescending(int[] main,
                               short[] indices)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into descending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
  - parallelQuicksortDescending
```
public static void parallelQuicksortDescending(int[] main,
                               short[] indices,
                               int left,
                               int right)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into descending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
    left - the starting index
    right - the ending index
  - parallelQuicksortDescending
```
public static void parallelQuicksortDescending(long[] main,
                               short[] indices)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into descending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
  - parallelQuicksortDescending
```
public static void parallelQuicksortDescending(long[] main,
                               short[] indices,
                               int left,
                               int right)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into descending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
    left - the starting index
    right - the ending index
  - parallelQuicksortDescending
```
public static void parallelQuicksortDescending(byte[] main,
                               short[] indices)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into descending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
  - parallelQuicksortDescending
```
public static void parallelQuicksortDescending(byte[] main,
                               short[] indices,
                               int left,
                               int right)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into descending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
    left - the starting index
    right - the ending index
  - parallelQuicksortDescending
```
public static void parallelQuicksortDescending(short[] main,
                               short[] indices)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into descending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
  - parallelQuicksortDescending
```
public static void parallelQuicksortDescending(short[] main,
                               short[] indices,
                               int left,
                               int right)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into descending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
    left - the starting index
    right - the ending index
  - parallelQuicksortAscending
```
public static void parallelQuicksortAscending(double[] main,
                              double[] indices)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into ascending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
  - parallelQuicksortAscending
```
public static void parallelQuicksortAscending(double[] main,
                              double[] indices,
                              int left,
                              int right)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into ascending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
    left - the starting index
    right - the ending index
  - parallelQuicksortAscending
```
public static void parallelQuicksortAscending(float[] main,
                              double[] indices)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into ascending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
  - parallelQuicksortAscending
```
public static void parallelQuicksortAscending(float[] main,
                              double[] indices,
                              int left,
                              int right)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into ascending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
    left - the starting index
    right - the ending index
  - parallelQuicksortAscending
```
public static void parallelQuicksortAscending(int[] main,
                              double[] indices)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into ascending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
  - parallelQuicksortAscending
```
public static void parallelQuicksortAscending(int[] main,
                              double[] indices,
                              int left,
                              int right)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into ascending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
    left - the starting index
    right - the ending index
  - parallelQuicksortAscending
```
public static void parallelQuicksortAscending(long[] main,
                              double[] indices)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into ascending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
  - parallelQuicksortAscending
```
public static void parallelQuicksortAscending(long[] main,
                              double[] indices,
                              int left,
                              int right)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into ascending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
    left - the starting index
    right - the ending index
  - parallelQuicksortAscending
```
public static void parallelQuicksortAscending(byte[] main,
                              double[] indices)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into ascending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
  - parallelQuicksortAscending
```
public static void parallelQuicksortAscending(byte[] main,
                              double[] indices,
                              int left,
                              int right)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into ascending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
    left - the starting index
    right - the ending index
  - parallelQuicksortAscending
```
public static void parallelQuicksortAscending(short[] main,
                              double[] indices)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into ascending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
  - parallelQuicksortAscending
```
public static void parallelQuicksortAscending(short[] main,
                              double[] indices,
                              int left,
                              int right)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into ascending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
    left - the starting index
    right - the ending index
  - parallelQuicksortAscending
```
public static void parallelQuicksortAscending(double[] main,
                              float[] indices)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into ascending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
  - parallelQuicksortAscending
```
public static void parallelQuicksortAscending(double[] main,
                              float[] indices,
                              int left,
                              int right)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into ascending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
    left - the starting index
    right - the ending index
  - parallelQuicksortAscending
```
public static void parallelQuicksortAscending(float[] main,
                              float[] indices)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into ascending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
  - parallelQuicksortAscending
```
public static void parallelQuicksortAscending(float[] main,
                              float[] indices,
                              int left,
                              int right)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into ascending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
    left - the starting index
    right - the ending index
  - parallelQuicksortAscending
```
public static void parallelQuicksortAscending(int[] main,
                              float[] indices)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into ascending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
  - parallelQuicksortAscending
```
public static void parallelQuicksortAscending(int[] main,
                              float[] indices,
                              int left,
                              int right)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into ascending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
    left - the starting index
    right - the ending index
  - parallelQuicksortAscending
```
public static void parallelQuicksortAscending(long[] main,
                              float[] indices)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into ascending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
  - parallelQuicksortAscending
```
public static void parallelQuicksortAscending(long[] main,
                              float[] indices,
                              int left,
                              int right)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into ascending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
    left - the starting index
    right - the ending index
  - parallelQuicksortAscending
```
public static void parallelQuicksortAscending(byte[] main,
                              float[] indices)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into ascending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
  - parallelQuicksortAscending
```
public static void parallelQuicksortAscending(byte[] main,
                              float[] indices,
                              int left,
                              int right)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into ascending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
    left - the starting index
    right - the ending index
  - parallelQuicksortAscending
```
public static void parallelQuicksortAscending(short[] main,
                              float[] indices)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into ascending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
  - parallelQuicksortAscending
```
public static void parallelQuicksortAscending(short[] main,
                              float[] indices,
                              int left,
                              int right)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into ascending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
    left - the starting index
    right - the ending index
  - parallelQuicksortAscending
```
public static void parallelQuicksortAscending(double[] main,
                              int[] indices)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into ascending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
  - parallelQuicksortAscending
```
public static void parallelQuicksortAscending(double[] main,
                              int[] indices,
                              int left,
                              int right)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into ascending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
    left - the starting index
    right - the ending index
  - parallelQuicksortAscending
```
public static void parallelQuicksortAscending(float[] main,
                              int[] indices)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into ascending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
  - parallelQuicksortAscending
```
public static void parallelQuicksortAscending(float[] main,
                              int[] indices,
                              int left,
                              int right)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into ascending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
    left - the starting index
    right - the ending index
  - parallelQuicksortAscending
```
public static void parallelQuicksortAscending(int[] main,
                              int[] indices)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into ascending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
  - parallelQuicksortAscending
```
public static void parallelQuicksortAscending(int[] main,
                              int[] indices,
                              int left,
                              int right)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into ascending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
    left - the starting index
    right - the ending index
  - parallelQuicksortAscending
```
public static void parallelQuicksortAscending(long[] main,
                              int[] indices)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into ascending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
  - parallelQuicksortAscending
```
public static void parallelQuicksortAscending(long[] main,
                              int[] indices,
                              int left,
                              int right)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into ascending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
    left - the starting index
    right - the ending index
  - parallelQuicksortAscending
```
public static void parallelQuicksortAscending(byte[] main,
                              int[] indices)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into ascending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
  - parallelQuicksortAscending
```
public static void parallelQuicksortAscending(byte[] main,
                              int[] indices,
                              int left,
                              int right)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into ascending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
    left - the starting index
    right - the ending index
  - parallelQuicksortAscending
```
public static void parallelQuicksortAscending(short[] main,
                              int[] indices)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into ascending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
  - parallelQuicksortAscending
```
public static void parallelQuicksortAscending(short[] main,
                              int[] indices,
                              int left,
                              int right)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into ascending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
    left - the starting index
    right - the ending index
  - parallelQuicksortAscending
```
public static void parallelQuicksortAscending(double[] main,
                              long[] indices)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into ascending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
  - parallelQuicksortAscending
```
public static void parallelQuicksortAscending(double[] main,
                              long[] indices,
                              int left,
                              int right)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into ascending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
    left - the starting index
    right - the ending index
  - parallelQuicksortAscending
```
public static void parallelQuicksortAscending(float[] main,
                              long[] indices)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into ascending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
  - parallelQuicksortAscending
```
public static void parallelQuicksortAscending(float[] main,
                              long[] indices,
                              int left,
                              int right)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into ascending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
    left - the starting index
    right - the ending index
  - parallelQuicksortAscending
```
public static void parallelQuicksortAscending(int[] main,
                              long[] indices)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into ascending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
  - parallelQuicksortAscending
```
public static void parallelQuicksortAscending(int[] main,
                              long[] indices,
                              int left,
                              int right)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into ascending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
    left - the starting index
    right - the ending index
  - parallelQuicksortAscending
```
public static void parallelQuicksortAscending(long[] main,
                              long[] indices)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into ascending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
  - parallelQuicksortAscending
```
public static void parallelQuicksortAscending(long[] main,
                              long[] indices,
                              int left,
                              int right)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into ascending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
    left - the starting index
    right - the ending index
  - parallelQuicksortAscending
```
public static void parallelQuicksortAscending(byte[] main,
                              long[] indices)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into ascending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
  - parallelQuicksortAscending
```
public static void parallelQuicksortAscending(byte[] main,
                              long[] indices,
                              int left,
                              int right)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into ascending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
    left - the starting index
    right - the ending index
  - parallelQuicksortAscending
```
public static void parallelQuicksortAscending(short[] main,
                              long[] indices)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into ascending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
  - parallelQuicksortAscending
```
public static void parallelQuicksortAscending(short[] main,
                              long[] indices,
                              int left,
                              int right)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into ascending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
    left - the starting index
    right - the ending index
  - parallelQuicksortAscending
```
public static void parallelQuicksortAscending(double[] main,
                              byte[] indices)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into ascending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
  - parallelQuicksortAscending
```
public static void parallelQuicksortAscending(double[] main,
                              byte[] indices,
                              int left,
                              int right)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into ascending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
    left - the starting index
    right - the ending index
  - parallelQuicksortAscending
```
public static void parallelQuicksortAscending(float[] main,
                              byte[] indices)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into ascending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
  - parallelQuicksortAscending
```
public static void parallelQuicksortAscending(float[] main,
                              byte[] indices,
                              int left,
                              int right)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into ascending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
    left - the starting index
    right - the ending index
  - parallelQuicksortAscending
```
public static void parallelQuicksortAscending(int[] main,
                              byte[] indices)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into ascending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
  - parallelQuicksortAscending
```
public static void parallelQuicksortAscending(int[] main,
                              byte[] indices,
                              int left,
                              int right)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into ascending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
    left - the starting index
    right - the ending index
  - parallelQuicksortAscending
```
public static void parallelQuicksortAscending(long[] main,
                              byte[] indices)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into ascending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
  - parallelQuicksortAscending
```
public static void parallelQuicksortAscending(long[] main,
                              byte[] indices,
                              int left,
                              int right)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into ascending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
    left - the starting index
    right - the ending index
  - parallelQuicksortAscending
```
public static void parallelQuicksortAscending(byte[] main,
                              byte[] indices)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into ascending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
  - parallelQuicksortAscending
```
public static void parallelQuicksortAscending(byte[] main,
                              byte[] indices,
                              int left,
                              int right)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into ascending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
    left - the starting index
    right - the ending index
  - parallelQuicksortAscending
```
public static void parallelQuicksortAscending(short[] main,
                              byte[] indices)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into ascending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
  - parallelQuicksortAscending
```
public static void parallelQuicksortAscending(short[] main,
                              byte[] indices,
                              int left,
                              int right)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into ascending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
    left - the starting index
    right - the ending index
  - parallelQuicksortAscending
```
public static void parallelQuicksortAscending(double[] main,
                              short[] indices)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into ascending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
  - parallelQuicksortAscending
```
public static void parallelQuicksortAscending(double[] main,
                              short[] indices,
                              int left,
                              int right)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into ascending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
    left - the starting index
    right - the ending index
  - parallelQuicksortAscending
```
public static void parallelQuicksortAscending(float[] main,
                              short[] indices)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into ascending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
  - parallelQuicksortAscending
```
public static void parallelQuicksortAscending(float[] main,
                              short[] indices,
                              int left,
                              int right)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into ascending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
    left - the starting index
    right - the ending index
  - parallelQuicksortAscending
```
public static void parallelQuicksortAscending(int[] main,
                              short[] indices)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into ascending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
  - parallelQuicksortAscending
```
public static void parallelQuicksortAscending(int[] main,
                              short[] indices,
                              int left,
                              int right)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into ascending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
    left - the starting index
    right - the ending index
  - parallelQuicksortAscending
```
public static void parallelQuicksortAscending(long[] main,
                              short[] indices)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into ascending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
  - parallelQuicksortAscending
```
public static void parallelQuicksortAscending(long[] main,
                              short[] indices,
                              int left,
                              int right)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into ascending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
    left - the starting index
    right - the ending index
  - parallelQuicksortAscending
```
public static void parallelQuicksortAscending(byte[] main,
                              short[] indices)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into ascending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
  - parallelQuicksortAscending
```
public static void parallelQuicksortAscending(byte[] main,
                              short[] indices,
                              int left,
                              int right)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into ascending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
    left - the starting index
    right - the ending index
  - parallelQuicksortAscending
```
public static void parallelQuicksortAscending(short[] main,
                              short[] indices)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into ascending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
  - parallelQuicksortAscending
```
public static void parallelQuicksortAscending(short[] main,
                              short[] indices,
                              int left,
                              int right)
```
    Sort parallel arrays. Arrays are sorted in-place. The first array determines the order, and is sorted into ascending order.
    Implementation inspired by this stackoverflow page: http://stackoverflow.com/questions/951848/java-array-sort-quick-way-to- get-a-sorted-list-of-indices-of-an-array
    
    Parameters:
    main - the values to use for determining the order
    indices - the second array
    left - the starting index
    right - the ending index
  - indexSort
```
public static int[] indexSort(double[] arr)
```
    Determine the indices of the given array if it were to be sorted into ascending order.
    
    Parameters:
    arr - the array
    
    Returns:
    the sorted indices
  - indexSort
```
public static int[] indexSort(float[] arr)
```
    Determine the indices of the given array if it were to be sorted into ascending order.
    
    Parameters:
    arr - the array
    
    Returns:
    the sorted indices
  - indexSort
```
public static int[] indexSort(int[] arr)
```
    Determine the indices of the given array if it were to be sorted into ascending order.
    
    Parameters:
    arr - the array
    
    Returns:
    the sorted indices
  - indexSort
```
public static int[] indexSort(long[] arr)
```
    Determine the indices of the given array if it were to be sorted into ascending order.
    
    Parameters:
    arr - the array
    
    Returns:
    the sorted indices
  - indexSort
```
public static int[] indexSort(byte[] arr)
```
    Determine the indices of the given array if it were to be sorted into ascending order.
    
    Parameters:
    arr - the array
    
    Returns:
    the sorted indices
  - indexSort
```
public static int[] indexSort(short[] arr)
```
    Determine the indices of the given array if it were to be sorted into ascending order.
    
    Parameters:
    arr - the array
    
    Returns:
    the sorted indices
  - normaliseMax
```
public static double[] normaliseMax(double[] array)
```
    Normalise and scale the values so that the maximum value in the array is 1.
    
    Parameters:
    array - The array to normalise
    
    Returns:
    The array
  - normaliseMax
```
public static double[] normaliseMax(double[] array,
                    double max)
```
    Normalise and scale the values so that the maximum value in the array is max
    
    Parameters:
    array - The array to normalise
    max - The maximum value
    
    Returns:
    The array
  - toString
```
public static String toString(String[] s,
              String glue)
```
    Convert the array to a String by joining the elements with the given glue.
    
    Parameters:
    s - the array
    glue - the glue
    
    Returns:
    the string
  - fill
```
public static double[][] fill(double[][] a1,
              double i)
```
    Fill the array with the value
    
    Parameters:
    a1 - The array
    i - The value
    
    Returns:
    The array
  - fill
```
public static double[] fill(double[] a1,
            double i,
            int s,
            int l)
```
    Fill the array with the value from the start index for the length given
    
    Parameters:
    a1 - The array to fill
    i - The value to fill with
    s - The start index
    l - The length of the fill
    
    Returns:
    The array
  - fill
```
public static double[] fill(double[] a1,
            double i)
```
    Fill the array with the value
    
    Parameters:
    a1 - The array
    i - The value
    
    Returns:
    The array
  - fill
```
public static float[][] fill(float[][] a1,
             float i)
```
    Fill the array with the value
    
    Parameters:
    a1 - The array
    i - The value
    
    Returns:
    The array
  - fill
```
public static float[] fill(float[] a1,
           float i,
           int s,
           int l)
```
    Fill the array with the value from the start index for the length given
    
    Parameters:
    a1 - The array to fill
    i - The value to fill with
    s - The start index
    l - The length of the fill
    
    Returns:
    The array
  - fill
```
public static float[] fill(float[] a1,
           float i)
```
    Fill the array with the value
    
    Parameters:
    a1 - The array
    i - The value
    
    Returns:
    The array
  - fill
```
public static int[][] fill(int[][] a1,
           int i)
```
    Fill the array with the value
    
    Parameters:
    a1 - The array
    i - The value
    
    Returns:
    The array
  - fill
```
public static int[] fill(int[] a1,
         int i,
         int s,
         int l)
```
    Fill the array with the value from the start index for the length given
    
    Parameters:
    a1 - The array to fill
    i - The value to fill with
    s - The start index
    l - The length of the fill
    
    Returns:
    The array
  - fill
```
public static int[] fill(int[] a1,
         int i)
```
    Fill the array with the value
    
    Parameters:
    a1 - The array
    i - The value
    
    Returns:
    The array
  - fill
```
public static long[][] fill(long[][] a1,
            long i)
```
    Fill the array with the value
    
    Parameters:
    a1 - The array
    i - The value
    
    Returns:
    The array
  - fill
```
public static long[] fill(long[] a1,
          long i,
          int s,
          int l)
```
    Fill the array with the value from the start index for the length given
    
    Parameters:
    a1 - The array to fill
    i - The value to fill with
    s - The start index
    l - The length of the fill
    
    Returns:
    The array
  - fill
```
public static long[] fill(long[] a1,
          long i)
```
    Fill the array with the value
    
    Parameters:
    a1 - The array
    i - The value
    
    Returns:
    The array
  - fill
```
public static byte[][] fill(byte[][] a1,
            byte i)
```
    Fill the array with the value
    
    Parameters:
    a1 - The array
    i - The value
    
    Returns:
    The array
  - fill
```
public static byte[] fill(byte[] a1,
          byte i,
          int s,
          int l)
```
    Fill the array with the value from the start index for the length given
    
    Parameters:
    a1 - The array to fill
    i - The value to fill with
    s - The start index
    l - The length of the fill
    
    Returns:
    The array
  - fill
```
public static byte[] fill(byte[] a1,
          byte i)
```
    Fill the array with the value
    
    Parameters:
    a1 - The array
    i - The value
    
    Returns:
    The array
  - fill
```
public static short[][] fill(short[][] a1,
             short i)
```
    Fill the array with the value
    
    Parameters:
    a1 - The array
    i - The value
    
    Returns:
    The array
  - fill
```
public static short[] fill(short[] a1,
           short i,
           int s,
           int l)
```
    Fill the array with the value from the start index for the length given
    
    Parameters:
    a1 - The array to fill
    i - The value to fill with
    s - The start index
    l - The length of the fill
    
    Returns:
    The array
  - fill
```
public static short[] fill(short[] a1,
           short i)
```
    Fill the array with the value
    
    Parameters:
    a1 - The array
    i - The value
    
    Returns:
    The array
  - fill
```
public static int[] fill(int[] array)
```
    Fills the array with ordinal values
    
    Parameters:
    array - The array to fill
    
    Returns:
    the array
  - truncate
```
public static double[] truncate(double[] array,
                int index)
```
    Truncates the given array to the given size.
    
    Parameters:
    array - The array to truncate
    index - The size to truncate it to
    
    Returns:
    The truncated array
  - truncate
```
public static double[][] truncate(double[][] array,
                  int index)
```
    Truncates every element in the given array to the given size.
    
    Parameters:
    array - The array to truncate
    index - The size to truncate it to
    
    Returns:
    The truncated array
  - truncate
```
public static float[] truncate(float[] array,
               int index)
```
    Truncates the given array to the given size.
    
    Parameters:
    array - The array to truncate
    index - The size to truncate it to
    
    Returns:
    The truncated array
  - truncate
```
public static float[][] truncate(float[][] array,
                 int index)
```
    Truncates every element in the given array to the given size.
    
    Parameters:
    array - The array to truncate
    index - The size to truncate it to
    
    Returns:
    The truncated array
  - truncate
```
public static int[] truncate(int[] array,
             int index)
```
    Truncates the given array to the given size.
    
    Parameters:
    array - The array to truncate
    index - The size to truncate it to
    
    Returns:
    The truncated array
  - truncate
```
public static int[][] truncate(int[][] array,
               int index)
```
    Truncates every element in the given array to the given size.
    
    Parameters:
    array - The array to truncate
    index - The size to truncate it to
    
    Returns:
    The truncated array
  - truncate
```
public static long[] truncate(long[] array,
              int index)
```
    Truncates the given array to the given size.
    
    Parameters:
    array - The array to truncate
    index - The size to truncate it to
    
    Returns:
    The truncated array
  - truncate
```
public static long[][] truncate(long[][] array,
                int index)
```
    Truncates every element in the given array to the given size.
    
    Parameters:
    array - The array to truncate
    index - The size to truncate it to
    
    Returns:
    The truncated array
  - truncate
```
public static byte[] truncate(byte[] array,
              int index)
```
    Truncates the given array to the given size.
    
    Parameters:
    array - The array to truncate
    index - The size to truncate it to
    
    Returns:
    The truncated array
  - truncate
```
public static byte[][] truncate(byte[][] array,
                int index)
```
    Truncates every element in the given array to the given size.
    
    Parameters:
    array - The array to truncate
    index - The size to truncate it to
    
    Returns:
    The truncated array
  - truncate
```
public static short[] truncate(short[] array,
               int index)
```
    Truncates the given array to the given size.
    
    Parameters:
    array - The array to truncate
    index - The size to truncate it to
    
    Returns:
    The truncated array
  - truncate
```
public static short[][] truncate(short[][] array,
                 int index)
```
    Truncates every element in the given array to the given size.
    
    Parameters:
    array - The array to truncate
    index - The size to truncate it to
    
    Returns:
    The truncated array
  - quickSelect
```
public static double quickSelect(double[] arr,
                 int n)
```
    Quick Select algorithm for getting the nth item from the array as if it were sorted. Expected complexity is O(N); worst case is O(N^2). The input array will be reordered; clone it first if this is a problem. Implementation based on public domain code from Nicolas Devillard.
    
    Parameters:
    arr - the array to select from
    n - the item to select
    
    Returns:
    the selected item
    See Also:
    "http://ndevilla.free.fr/median/median/src/quickselect.c"
  - quickSelect
```
public static double quickSelect(double[] arr,
                 int n,
                 int low,
                 int high)
```
    Quick Select algorithm for getting the nth item from a sub-array as if it were sorted. Expected complexity is O(N); worst case is O(N^2). The input array will be reordered; clone it first if this is a problem. Implementation based on public domain code from Nicolas Devillard.
    
    Parameters:
    arr - the array to select from
    n - the item to select
    low - the starting position in the array (inclusive)
    high - the ending position in the array (exclusive)
    
    Returns:
    the selected item
    See Also:
    "http://ndevilla.free.fr/median/median/src/quickselect.c"
  - quickSelect
```
public static float quickSelect(float[] arr,
                int n)
```
    Quick Select algorithm for getting the nth item from the array as if it were sorted. Expected complexity is O(N); worst case is O(N^2). The input array will be reordered; clone it first if this is a problem. Implementation based on public domain code from Nicolas Devillard.
    
    Parameters:
    arr - the array to select from
    n - the item to select
    
    Returns:
    the selected item
    See Also:
    "http://ndevilla.free.fr/median/median/src/quickselect.c"
  - quickSelect
```
public static float quickSelect(float[] arr,
                int n,
                int low,
                int high)
```
    Quick Select algorithm for getting the nth item from a sub-array as if it were sorted. Expected complexity is O(N); worst case is O(N^2). The input array will be reordered; clone it first if this is a problem. Implementation based on public domain code from Nicolas Devillard.
    
    Parameters:
    arr - the array to select from
    n - the item to select
    low - the starting position in the array (inclusive)
    high - the ending position in the array (exclusive)
    
    Returns:
    the selected item
    See Also:
    "http://ndevilla.free.fr/median/median/src/quickselect.c"
  - quickSelect
```
public static int quickSelect(int[] arr,
              int n)
```
    Quick Select algorithm for getting the nth item from the array as if it were sorted. Expected complexity is O(N); worst case is O(N^2). The input array will be reordered; clone it first if this is a problem. Implementation based on public domain code from Nicolas Devillard.
    
    Parameters:
    arr - the array to select from
    n - the item to select
    
    Returns:
    the selected item
    See Also:
    "http://ndevilla.free.fr/median/median/src/quickselect.c"
  - quickSelect
```
public static int quickSelect(int[] arr,
              int n,
              int low,
              int high)
```
    Quick Select algorithm for getting the nth item from a sub-array as if it were sorted. Expected complexity is O(N); worst case is O(N^2). The input array will be reordered; clone it first if this is a problem. Implementation based on public domain code from Nicolas Devillard.
    
    Parameters:
    arr - the array to select from
    n - the item to select
    low - the starting position in the array (inclusive)
    high - the ending position in the array (exclusive)
    
    Returns:
    the selected item
    See Also:
    "http://ndevilla.free.fr/median/median/src/quickselect.c"
  - quickSelect
```
public static long quickSelect(long[] arr,
               int n)
```
    Quick Select algorithm for getting the nth item from the array as if it were sorted. Expected complexity is O(N); worst case is O(N^2). The input array will be reordered; clone it first if this is a problem. Implementation based on public domain code from Nicolas Devillard.
    
    Parameters:
    arr - the array to select from
    n - the item to select
    
    Returns:
    the selected item
    See Also:
    "http://ndevilla.free.fr/median/median/src/quickselect.c"
  - quickSelect
```
public static long quickSelect(long[] arr,
               int n,
               int low,
               int high)
```
    Quick Select algorithm for getting the nth item from a sub-array as if it were sorted. Expected complexity is O(N); worst case is O(N^2). The input array will be reordered; clone it first if this is a problem. Implementation based on public domain code from Nicolas Devillard.
    
    Parameters:
    arr - the array to select from
    n - the item to select
    low - the starting position in the array (inclusive)
    high - the ending position in the array (exclusive)
    
    Returns:
    the selected item
    See Also:
    "http://ndevilla.free.fr/median/median/src/quickselect.c"
  - quickSelect
```
public static byte quickSelect(byte[] arr,
               int n)
```
    Quick Select algorithm for getting the nth item from the array as if it were sorted. Expected complexity is O(N); worst case is O(N^2). The input array will be reordered; clone it first if this is a problem. Implementation based on public domain code from Nicolas Devillard.
    
    Parameters:
    arr - the array to select from
    n - the item to select
    
    Returns:
    the selected item
    See Also:
    "http://ndevilla.free.fr/median/median/src/quickselect.c"
  - quickSelect
```
public static byte quickSelect(byte[] arr,
               int n,
               int low,
               int high)
```
    Quick Select algorithm for getting the nth item from a sub-array as if it were sorted. Expected complexity is O(N); worst case is O(N^2). The input array will be reordered; clone it first if this is a problem. Implementation based on public domain code from Nicolas Devillard.
    
    Parameters:
    arr - the array to select from
    n - the item to select
    low - the starting position in the array (inclusive)
    high - the ending position in the array (exclusive)
    
    Returns:
    the selected item
    See Also:
    "http://ndevilla.free.fr/median/median/src/quickselect.c"
  - quickSelect
```
public static short quickSelect(short[] arr,
                int n)
```
    Quick Select algorithm for getting the nth item from the array as if it were sorted. Expected complexity is O(N); worst case is O(N^2). The input array will be reordered; clone it first if this is a problem. Implementation based on public domain code from Nicolas Devillard.
    
    Parameters:
    arr - the array to select from
    n - the item to select
    
    Returns:
    the selected item
    See Also:
    "http://ndevilla.free.fr/median/median/src/quickselect.c"
  - quickSelect
```
public static short quickSelect(short[] arr,
                int n,
                int low,
                int high)
```
    Quick Select algorithm for getting the nth item from a sub-array as if it were sorted. Expected complexity is O(N); worst case is O(N^2). The input array will be reordered; clone it first if this is a problem. Implementation based on public domain code from Nicolas Devillard.
    
    Parameters:
    arr - the array to select from
    n - the item to select
    low - the starting position in the array (inclusive)
    high - the ending position in the array (exclusive)
    
    Returns:
    the selected item
    See Also:
    "http://ndevilla.free.fr/median/median/src/quickselect.c"
  - convert
```
public double[] convert(Double[] array)
```
    Convert from Double[] to double[]. This will create a new array and copy the contents.
    
    Parameters:
    array - input array
    
    Returns:
    the converted array
  - convert
```
public Double[] convert(double[] array)
```
    Convert from Double[] to Double[]. This will create a new array and copy the contents.
    
    Parameters:
    array - input array
    
    Returns:
    the converted array
  - convert
```
public float[] convert(Float[] array)
```
    Convert from Float[] to float[]. This will create a new array and copy the contents.
    
    Parameters:
    array - input array
    
    Returns:
    the converted array
  - convert
```
public Float[] convert(float[] array)
```
    Convert from Float[] to Float[]. This will create a new array and copy the contents.
    
    Parameters:
    array - input array
    
    Returns:
    the converted array
  - convert
```
public int[] convert(Integer[] array)
```
    Convert from Integer[] to int[]. This will create a new array and copy the contents.
    
    Parameters:
    array - input array
    
    Returns:
    the converted array
  - convert
```
public Integer[] convert(int[] array)
```
    Convert from Int[] to Integer[]. This will create a new array and copy the contents.
    
    Parameters:
    array - input array
    
    Returns:
    the converted array
  - convert
```
public long[] convert(Long[] array)
```
    Convert from Long[] to long[]. This will create a new array and copy the contents.
    
    Parameters:
    array - input array
    
    Returns:
    the converted array
  - convert
```
public Long[] convert(long[] array)
```
    Convert from Long[] to Long[]. This will create a new array and copy the contents.
    
    Parameters:
    array - input array
    
    Returns:
    the converted array
  - convert
```
public byte[] convert(Byte[] array)
```
    Convert from Byte[] to byte[]. This will create a new array and copy the contents.
    
    Parameters:
    array - input array
    
    Returns:
    the converted array
  - convert
```
public Byte[] convert(byte[] array)
```
    Convert from Byte[] to Byte[]. This will create a new array and copy the contents.
    
    Parameters:
    array - input array
    
    Returns:
    the converted array
  - convert
```
public short[] convert(Short[] array)
```
    Convert from Short[] to short[]. This will create a new array and copy the contents.
    
    Parameters:
    array - input array
    
    Returns:
    the converted array
  - convert
```
public Short[] convert(short[] array)
```
    Convert from Short[] to Short[]. This will create a new array and copy the contents.
    
    Parameters:
    array - input array
    
    Returns:
    the converted array

Class ArrayUtils

Method Summary

Methods inherited from class java.lang.Object

Method Detail

maxValue

maxValue

maxValue

maxValue

maxValue

maxValue

minValue

minValue

minValue

minValue

minValue

minValue

maxIndex

maxIndex

maxIndex

maxIndex

maxIndex

maxIndex

minIndex

minIndex

minIndex

minIndex

minIndex

minIndex

sum

sum

sum

sum

sum

sum

sum

sum

sum

sum

sum

sum

subtract

subtract

subtract

subtract

subtract

subtract

subtract

subtract

subtract

subtract

subtract

subtract

subtract

subtract

subtract

subtract

subtract

subtract

add

add

add

add

add

add

multiply

multiply

multiply

multiply

multiply

multiply

multiply

multiply

multiply

multiply

multiply

multiply

multiply

multiply

multiply

multiply