ArraysPlume (plume-util 1.0.6 API)

java.lang.Object
- org.plumelib.util.ArraysPlume

```
public final class ArraysPlume
extends java.lang.Object
```
Utilities for manipulating arrays and collections. This complements Arrays and Collections.

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`ArraysPlume.ComparableArrayComparatorLengthFirst<T extends java.lang.Comparable<T>>` Compare two arrays first by length (a shorter array is considered less), and if of equal length compare lexically (element-by-element).
`static class`	`ArraysPlume.ComparableArrayComparatorLexical<T extends java.lang.Comparable<T>>` Compare two arrays lexically (element-by-element).
`static class`	`ArraysPlume.DoubleArrayComparatorLexical` Compare two arrays lexically (element-by-element).
`static class`	`ArraysPlume.IntArrayComparatorLengthFirst` Compare two arrays first by length (a shorter array is considered less), and if of equal length compare lexically (element-by-element).
`static class`	`ArraysPlume.IntArrayComparatorLexical` Compare two arrays lexically (element-by-element).
`static class`	`ArraysPlume.LongArrayComparatorLengthFirst` Compare two arrays first by length (a shorter array is considered less), and if of equal length compare lexically (element-by-element).
`static class`	`ArraysPlume.LongArrayComparatorLexical` Compare two arrays lexically (element-by-element).
`static class`	`ArraysPlume.ObjectArrayComparatorLengthFirst` Compare two arrays first by length (a shorter array is considered less), and if of equal length compare lexically (element-by-element).
`static class`	`ArraysPlume.ObjectArrayComparatorLexical` Compare two arrays lexically (element-by-element).
`static class`	`ArraysPlume.StringArrayComparatorLexical` Compare two arrays lexically (element-by-element).

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static boolean`	`allNull(java.util.List<?> a)` Return true if all elements of a are null.
`static boolean`	`allNull(@PolyAll java.lang.Object[] a)` Return true if all elements of a are null.
`static boolean`	`anyNull(java.util.List<?> a)` Return true if a contains null.
`static boolean`	`anyNull(@PolyAll java.lang.Object[] a)` Return true if a contains null.
`static boolean[]`	`concat(boolean[] a, boolean[] b)` Return an array that contains all the elements of both argument arrays, in order.
`static byte[]`	`concat(byte[] a, byte[] b)` Return an array that contains all the elements of both argument arrays, in order.
`static char[]`	`concat(char[] a, char[] b)` Return an array that contains all the elements of both argument arrays, in order.
`static double[]`	`concat(double[] a, double[] b)` Return an array that contains all the elements of both argument arrays, in order.
`static float[]`	`concat(float[] a, float[] b)` Return an array that contains all the elements of both argument arrays, in order.
`static int[]`	`concat(int[] a, int[] b)` Return an array that contains all the elements of both argument arrays, in order.
`static <T> T[]`	`concat(@Nullable java.util.List<T> a, @Nullable java.util.List<T> b)` Return an array that contains all the elements of both arguments, in order.
`static <T> T[]`	`concat(@Nullable java.util.List<T> a, T[] b)` Return an array that contains all the elements of both arguments, in order.
`static long[]`	`concat(long[] a, long[] b)` Return an array that contains all the elements of both argument arrays, in order.
`static short[]`	`concat(short[] a, short[] b)` Return an array that contains all the elements of both argument arrays, in order.
`static @PolyAll java.lang.String[]`	`concat(@PolyAll java.lang.String[] a, @PolyAll java.lang.String[] b)` Return an array that contains all the elements of both argument arrays, in order.
`static <T> T[]`	`concat(T[] a, @Nullable java.util.List<T> b)` Return an array that contains all the elements of both arguments, in order.
`static <T> T[]`	`concat(T[] a, T[] b)` Return an array that contains all the elements of both arguments, in order.
`static int`	`elementRange(int[] a)` Return the difference between the smallest and largest array elements.
`static long`	`elementRange(long[] a)` Return the difference between the smallest and largest array elements.
`static @PolyAll int[]`	`fnCompose(int[] a, @PolyAll int[] b)` Return the composition of the given two functions, all of which are represented as arrays.
`static int[]`	`fnIdentity(int length)` Return an array [0..length).
`static int[]`	`fnInverse(int[] a, int arange)` Return the inverse of the given function, which is represented as an array.
`static int[]`	`fnInversePermutation(int[] a)` Requires that fnIsPermutation(a) holds.
`static boolean`	`fnIsPermutation(int[] a)` Returns true if the array is a permutation of [0..a.length).
`static boolean`	`fnIsTotal(int[] a)` Return true iff the array does not contain -1.
`static int`	`indexOf(boolean[] a, boolean elt)` Searches for the first occurrence of the given element in the array.
`static int`	`indexOf(boolean[] a, boolean[] sub)` Searches for the first subsequence of the array that matches the given array elementwise.
`static int`	`indexOf(boolean[] a, boolean elt, int minindex, int indexlimit)` Searches for the first occurrence of the given element in the array.
`static int`	`indexOf(double[] a, double elt)` Searches for the first occurrence of the given element in the array.
`static int`	`indexOf(double[] a, double[] sub)` Searches for the first subsequence of the array that matches the given array elementwise.
`static int`	`indexOf(int[] a, int elt)` Searches for the first occurrence of the given element in the array.
`static int`	`indexOf(int[] a, int[] sub)` Searches for the first subsequence of the array that matches the given array elementwise.
`static int`	`indexOf(int[] a, int elt, int minindex, int indexlimit)` Searches for the first occurrence of the given element in the array.
`static int`	`indexOf(java.util.List<?> a, java.util.List<?> sub)` Searches for the first subsequence of the list that matches the given list elementwise, testing for equality using the equals method.
`static int`	`indexOf(java.util.List<?> a, @PolyAll java.lang.Object[] sub)` Searches for the first subsequence of the list that matches the given array elementwise, testing for equality using the equals method.
`static int`	`indexOf(java.util.List<? extends java.lang.Object> a, @Nullable java.lang.Object elt)` Searches for the first occurrence of the given element in the list, testing for equality using the equals method.
`static int`	`indexOf(java.util.List<? extends java.lang.Object> a, @Nullable java.lang.Object elt, int minindex, int indexlimit)` Searches for the first occurrence of the given element in the list, testing for equality using the equals method.
`static int`	`indexOf(long[] a, long elt)` Searches for the first occurrence of the given element in the array.
`static int`	`indexOf(long[] a, long[] sub)` Searches for the first subsequence of the array that matches the given array elementwise.
`static int`	`indexOf(long[] a, long elt, int minindex, int indexlimit)` Searches for the first occurrence of the given element in the array.
`static int`	`indexOf(@PolyAll java.lang.Object[] a, java.util.List<?> sub)` Searches for the first subsequence of the array that matches the given list elementwise, testing for equality using the equals method.
`static int`	`indexOf(@PolyAll java.lang.Object[] a, java.lang.Object[] sub)` Searches for the first subsequence of the array that matches the given array elementwise, testing for equality using the equals method.
`static <T> int`	`indexOf(T[] a, @Nullable java.lang.Object elt)` Searches for the first occurrence of the given element in the array, testing for equality using the equals method.
`static <T> int`	`indexOf(T[] a, @Nullable java.lang.Object elt, int minindex, int indexlimit)` Searches for the first occurrence of the given element in the array, testing for equality using the equals method.
`static int`	`indexOfEq(java.util.List<?> a, java.util.List<?> sub)` Searches for the first subsequence of the list that matches the given list elementwise, testing for equality using == (not the equals method).
`static int`	`indexOfEq(java.util.List<?> a, @PolyAll java.lang.Object[] sub)` Searches for the first subsequence of the list that matches the given array elementwise, testing for equality using == (not the equals method).
`static int`	`indexOfEq(java.util.List<? extends java.lang.Object> a, @Nullable java.lang.Object elt)` Searches for the first occurrence of the given element in the list, testing for equality using == (not the equals method).
`static int`	`indexOfEq(java.util.List<? extends java.lang.Object> a, @Nullable java.lang.Object elt, int minindex, int indexlimit)` Searches for the first occurrence of the given element in the list, testing for equality using == (not the equals method).
`static int`	`indexOfEq(@PolyAll java.lang.Object[] a, java.util.List<?> sub)` Searches for the first subsequence of the array that matches the given list elementwise, testing for equality using == (not the equals method).
`static int`	`indexOfEq(@PolyAll java.lang.Object[] a, @Nullable java.lang.Object elt)` Searches for the first occurrence of the given element in the array, testing for equality using == (not the equals method).
`static int`	`indexOfEq(@PolyAll java.lang.Object[] a, @PolyAll java.lang.Object[] sub)` Searches for the first subsequence of the array that matches the given array elementwise, testing for equality using == (not the equals method).
`static int`	`indexOfEq(@PolyNull java.lang.Object[] a, @Nullable java.lang.Object elt, int minindex, int indexlimit)` Searches for the first occurrence of the given element in the array, testing for equality using == (not the equals method).
`static boolean`	`isSortedDescending(int[] a)` Returns whether the array is sorted in descending order.
`static boolean`	`isSortedDescending(long[] a)` Returns whether the array is sorted in descending order.
`static boolean`	`isSubarray(boolean[] a, boolean[] sub, int aOffset)` Determines whether the second array is a subarray of the first, starting at the specified index of the first.
`static boolean`	`isSubarray(double[] a, double[] sub, int aOffset)` Determines whether the second array is a subarray of the first, starting at the specified index of the first.
`static boolean`	`isSubarray(int[] a, int[] sub, int aOffset)` Determines whether the second array is a subarray of the first, starting at the specified index of the first.
`static boolean`	`isSubarray(java.util.List<?> a, java.util.List<?> sub, int aOffset)` Determines whether the second array is a subarray of the first, starting at the specified index of the first, testing for equality using the equals method.
`static boolean`	`isSubarray(java.util.List<?> a, @PolyAll java.lang.Object[] sub, int aOffset)` Determines whether the second array is a subarray of the first, starting at the specified index of the first, testing for equality using the equals method.
`static boolean`	`isSubarray(long[] a, long[] sub, int aOffset)` Determines whether the second array is a subarray of the first, starting at the specified index of the first.
`static boolean`	`isSubarray(@PolyAll java.lang.Object[] a, java.util.List<?> sub, int aOffset)` Determines whether the second array is a subarray of the first, starting at the specified index of the first, testing for equality using the equals method.
`static boolean`	`isSubarray(@PolyAll java.lang.Object[] a, @PolyNull java.lang.Object[] sub, int aOffset)` Determines whether the second array is a subarray of the first, starting at the specified index of the first, testing for equality using the equals method.
`static boolean`	`isSubarrayEq(java.util.List<?> a, java.util.List<?> sub, int aOffset)` Determines whether the second array is a subarray of the first, starting at the specified index of the first, testing for equality using == (not the equals method).
`static boolean`	`isSubarrayEq(java.util.List<?> a, @PolyAll java.lang.Object[] sub, int aOffset)` Determines whether the second array is a subarray of the first, starting at the specified index of the first, testing for equality using == (not the equals method).
`static boolean`	`isSubarrayEq(@PolyAll java.lang.Object[] a, java.util.List<?> sub, int aOffset)` Determines whether the second array is a subarray of the first, starting at the specified index of the first, testing for equality using == (not the equals method).
`static boolean`	`isSubarrayEq(@PolyAll java.lang.Object[] a, @PolyAll java.lang.Object[] sub, int aOffset)` Determines whether the second array is a subarray of the first, starting at the specified index of the first, testing for equality using == (not the equals method).
`static boolean`	`isSubset(double[] smaller, double[] bigger)` Return whether smaller is a subset of bigger.
`static boolean`	`isSubset(long[] smaller, long[] bigger)` Return whether smaller is a subset of bigger.
`static boolean`	`isSubset(java.lang.String[] smaller, java.lang.String[] bigger)` Return whether smaller is a subset of bigger.
`static int`	`length(java.lang.Object a)` Returns the length of the argument array.
`static double`	`max(double[] a)` Return the largest value in the array.
`static java.lang.Double`	`max(java.lang.Double[] a)` Return the largest value in the array.
`static int`	`max(int[] a)` Return the largest value in the array.
`static java.lang.Integer`	`max(java.lang.Integer[] a)` Return the largest value in the array.
`static long`	`max(long[] a)` Return the largest value in the array.
`static java.lang.Long`	`max(java.lang.Long[] a)` Return the largest value in the array.
`static double`	`min(double[] a)` Return the smallest value in the array.
`static java.lang.Double`	`min(java.lang.Double[] a)` Return the smallest value in the array.
`static int`	`min(int[] a)` Return the smallest value in the array.
`static java.lang.Integer`	`min(java.lang.Integer[] a)` Return the smallest value in the array.
`static long`	`min(long[] a)` Return the smallest value in the array.
`static java.lang.Long`	`min(java.lang.Long[] a)` Return the smallest value in the array.
`static int[]`	`minAndMax(int[] a)` Return a two-element array containing the smallest and largest values in the array.
`static long[]`	`minAndMax(long[] a)` Return a two-element array containing the smallest and largest values in the array.
`static boolean`	`noDuplicates(boolean[] a)` Return true iff a does not contain duplicate elements.
`static boolean`	`noDuplicates(byte[] a)` Return true iff a does not contain duplicate elements.
`static boolean`	`noDuplicates(char[] a)` Return true iff a does not contain duplicate elements.
`static boolean`	`noDuplicates(double[] a)` Return true iff a does not contain duplicate elements.
`static boolean`	`noDuplicates(float[] a)` Return true iff a does not contain duplicate elements.
`static boolean`	`noDuplicates(int[] a)` Return true iff a does not contain duplicate elements.
`static <T> boolean`	`noDuplicates(java.util.List<T> a)` Return true iff a does not contain duplicate elements.
`static boolean`	`noDuplicates(long[] a)` Return true iff a does not contain duplicate elements.
`static boolean`	`noDuplicates(java.lang.Object[] a)` Return true iff a does not contain duplicate elements.
`static boolean`	`noDuplicates(short[] a)` Return true iff a does not contain duplicate elements.
`static boolean`	`noDuplicates(java.lang.String[] a)` Return true iff a does not contain duplicate elements.
`static int[]`	`partialFnCompose(int[] a, int[] b)` Return the composition of the given two (possibly partial) functions, all of which are represented as arrays.
`static <T> java.util.List<org.plumelib.util.ArraysPlume.Partitioning<T>>`	`partitionInto(java.util.Collection<T> elts, int k)` Partition a set of non-null elements into exactly k subsets.
`static <T> java.util.List<org.plumelib.util.ArraysPlume.Partitioning<T>>`	`partitionInto(java.util.Queue<T> elts, int k)` Partition a set of elements into exactly k subsets.
`static <T> java.util.List<org.plumelib.util.ArraysPlume.Partitioning<T>>`	`partitionIntoHelper(java.util.Queue<T> elts, java.util.List<org.plumelib.util.ArraysPlume.Partitioning<T>> resultSoFar, int numEmptyParts, int numNonemptyParts)` Returns a set of partitionings, each of size numEmptyParts + numNonemptyParts.
`static boolean`	`sorted(int[] a)` Returns whether the array is sorted.
`static boolean`	`sorted(long[] a)` Returns whether the array is sorted.
`static boolean[]`	`subarray(boolean[] a, int startindex, int length)` Return a subarray of the given array.
`static byte[]`	`subarray(byte[] a, int startindex, int length)` Return a subarray of the given array.
`static char[]`	`subarray(char[] a, int startindex, int length)` Return a subarray of the given array.
`static double[]`	`subarray(double[] a, int startindex, int length)` Return a subarray of the given array.
`static float[]`	`subarray(float[] a, int startindex, int length)` Return a subarray of the given array.
`static int[]`	`subarray(int[] a, int startindex, int length)` Return a subarray of the given array.
`static <T> java.util.List<T>`	`subarray(java.util.List<T> a, int startindex, int length)` Return a sublist of the given list.
`static long[]`	`subarray(long[] a, int startindex, int length)` Return a subarray of the given array.
`static @PolyAll java.lang.Object[]`	`subarray(@PolyAll java.lang.Object[] a, int startindex, int length)` Return a subarray of the given array.
`static short[]`	`subarray(short[] a, int startindex, int length)` Return a subarray of the given array.
`static @PolyAll java.lang.String[]`	`subarray(@PolyAll java.lang.String[] a, int startindex, int length)` Return a subarray of the given array.
`static double`	`sum(double[] a)` Returns the sum of an array of doubles.
`static double`	`sum(double[][] a)` Returns the sum of all the elements of a 2d array of doubles.
`static int`	`sum(int[] a)` Returns the sum of an array of integers.
`static int`	`sum(int[][] a)` Returns the sum of all the elements of a 2d array of integers.
`static java.lang.String`	`toString(@Nullable java.util.Collection<?> a)` Return a string representation of the collection.
`static java.lang.String`	`toString(@Nullable java.util.Collection<?> a, boolean quoted)` Return a string representation of the collection.
`static java.lang.String`	`toString(java.lang.Object a)` Returns a string representation of the contents of the specified array.
`static java.lang.String`	`toString(@PolyAll java.lang.Object[] a)` Return a string representation of the array.
`static java.lang.String`	`toString(@PolyAll java.lang.Object[] a, boolean quoted)` Return a string representation of the array.
`static java.lang.String`	`toStringQuoted(@Nullable java.util.Collection<?> a)` Return a string representation of the collection.
`static java.lang.String`	`toStringQuoted(@PolyAll java.lang.Object[] a)` Return a string representation of the array.

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

- Method Detail
  - min
```
@Pure
public static int min(int[] a)
```
    Return the smallest value in the array.
    
    Parameters:
    
    a - an array
    
    Returns:
    
    the smallest value in the array
    
    Throws:
    
    java.lang.ArrayIndexOutOfBoundsException - if the array has length 0
  - min
```
@Pure
public static long min(long[] a)
```
    Return the smallest value in the array.
    
    Parameters:
    
    a - an array
    
    Returns:
    
    the smallest value in the array
    
    Throws:
    
    java.lang.ArrayIndexOutOfBoundsException - if the array has length 0
  - min
```
@Pure
public static double min(double[] a)
```
    Return the smallest value in the array.
    
    Parameters:
    
    a - an array
    
    Returns:
    
    the smallest value in the array
    
    Throws:
    
    java.lang.ArrayIndexOutOfBoundsException - if the array has length 0
  - min
```
@Pure
public static java.lang.Integer min(java.lang.Integer[] a)
```
    Return the smallest value in the array.
    
    Parameters:
    
    a - an array
    
    Returns:
    
    the smallest value in the array
    
    Throws:
    
    java.lang.ArrayIndexOutOfBoundsException - if the array has length 0
  - min
```
@Pure
public static java.lang.Long min(java.lang.Long[] a)
```
    Return the smallest value in the array.
    
    Parameters:
    
    a - an array
    
    Returns:
    
    the smallest value in the array
    
    Throws:
    
    java.lang.ArrayIndexOutOfBoundsException - if the array has length 0
  - min
```
@Pure
public static java.lang.Double min(java.lang.Double[] a)
```
    Return the smallest value in the array.
    
    Parameters:
    
    a - an array
    
    Returns:
    
    the smallest value in the array
    
    Throws:
    
    java.lang.ArrayIndexOutOfBoundsException - if the array has length 0
  - max
```
@Pure
public static int max(int[] a)
```
    Return the largest value in the array.
    
    Parameters:
    
    a - an array
    
    Returns:
    
    the largest value in the array
    
    Throws:
    
    java.lang.ArrayIndexOutOfBoundsException - if the array has length 0
  - max
```
@Pure
public static long max(long[] a)
```
    Return the largest value in the array.
    
    Parameters:
    
    a - an array
    
    Returns:
    
    the largest value in the array
    
    Throws:
    
    java.lang.ArrayIndexOutOfBoundsException - if the array has length 0
  - max
```
@Pure
public static double max(double[] a)
```
    Return the largest value in the array.
    
    Parameters:
    
    a - an array
    
    Returns:
    
    the largest value in the array
    
    Throws:
    
    java.lang.ArrayIndexOutOfBoundsException - if the array has length 0
  - max
```
@Pure
public static java.lang.Integer max(java.lang.Integer[] a)
```
    Return the largest value in the array.
    
    Parameters:
    
    a - an array
    
    Returns:
    
    the largest value in the array
    
    Throws:
    
    java.lang.ArrayIndexOutOfBoundsException - if the array has length 0
  - max
```
@Pure
public static java.lang.Long max(java.lang.Long[] a)
```
    Return the largest value in the array.
    
    Parameters:
    
    a - an array
    
    Returns:
    
    the largest value in the array
    
    Throws:
    
    java.lang.ArrayIndexOutOfBoundsException - if the array has length 0
  - max
```
@Pure
public static java.lang.Double max(java.lang.Double[] a)
```
    Return the largest value in the array.
    
    Parameters:
    
    a - an array
    
    Returns:
    
    the largest value in the array
    
    Throws:
    
    java.lang.ArrayIndexOutOfBoundsException - if the array has length 0
  - minAndMax
```
@Pure
public static int[] minAndMax(int[] a)
```
    Return a two-element array containing the smallest and largest values in the array.
    
    Parameters:
    
    a - an array
    
    Returns:
    
    a two-element array containing the smallest and largest values in the array
    
    Throws:
    
    java.lang.ArrayIndexOutOfBoundsException - if the array has length 0
  - minAndMax
```
@Pure
public static long[] minAndMax(long[] a)
```
    Return a two-element array containing the smallest and largest values in the array.
    
    Parameters:
    
    a - an array
    
    Returns:
    
    a two-element array containing the smallest and largest values in the array
    
    Throws:
    
    java.lang.ArrayIndexOutOfBoundsException - if the array has length 0
  - elementRange
```
@Pure
public static int elementRange(int[] a)
```
    Return the difference between the smallest and largest array elements.
    
    Parameters:
    
    a - an array
    
    Returns:
    
    the difference between the smallest and largest array elements
    
    Throws:
    
    java.lang.ArrayIndexOutOfBoundsException - if the array has length 0
  - elementRange
```
@Pure
public static long elementRange(long[] a)
```
    Return the difference between the smallest and largest array elements.
    
    Parameters:
    
    a - an array
    
    Returns:
    
    the difference between the smallest and largest array elements
    
    Throws:
    
    java.lang.ArrayIndexOutOfBoundsException - if the array has length 0
  - sum
```
@Pure
public static int sum(int[] a)
```
    Returns the sum of an array of integers.
    
    Parameters:
    
    a - an array
    
    Returns:
    
    the sum of an array of integers
  - sum
```
@Pure
public static int sum(int[][] a)
```
    Returns the sum of all the elements of a 2d array of integers.
    
    Parameters:
    
    a - a 2d array
    
    Returns:
    
    the sum of all the elements of a 2d array of integers
  - sum
```
@Pure
public static double sum(double[] a)
```
    Returns the sum of an array of doubles.
    
    Parameters:
    
    a - an array
    
    Returns:
    
    the sum of an array of doubles
  - sum
```
@Pure
public static double sum(double[][] a)
```
    Returns the sum of all the elements of a 2d array of doubles.
    
    Parameters:
    
    a - a 2d array
    
    Returns:
    
    the sum of all the elements of a 2d array of doubles
  - indexOf
```
@Pure
public static <T> int indexOf(T[] a,
                                    @Nullable java.lang.Object elt)
```
    Searches for the first occurrence of the given element in the array, testing for equality using the equals method.
    
    Type Parameters:
    
    T - type of the elements of the array
    
    Parameters:
    
    a - an array
    
    elt - the element to search for
    
    Returns:
    
    the first index whose element is equal to the specified element, or -1 if no such element is found in the array
    
    See Also:
    
    List.indexOf(java.lang.Object)
  - indexOf
```
@Pure
public static <T> int indexOf(T[] a,
                                    @Nullable java.lang.Object elt,
                                    int minindex,
                                    int indexlimit)
```
    Searches for the first occurrence of the given element in the array, testing for equality using the equals method.
    
    Type Parameters:
    
    T - the type of the elements
    
    Parameters:
    
    a - an array
    
    elt - the element to search for
    
    minindex - first index at which to search
    
    indexlimit - first index at which not to search
    
    Returns:
    
    the first index i containing the specified element, such that minindex ≤ i < indexlimit, or -1 if the element is not found in that section of the array
    
    See Also:
    
    List.indexOf(java.lang.Object)
  - indexOf
```
@Pure
public static int indexOf(java.util.List<? extends java.lang.Object> a,
                                @Nullable java.lang.Object elt)
```
    Searches for the first occurrence of the given element in the list, testing for equality using the equals method. Identical to List.indexOf, but included for completeness.
    
    Parameters:
    
    a - a list
    
    elt - the element to search for
    
    Returns:
    
    the first index whose element is equal to the specified element, or -1 if no such element is found in the list
    
    See Also:
    
    List.indexOf(java.lang.Object)
  - indexOf
```
@Pure
public static int indexOf(java.util.List<? extends java.lang.Object> a,
                                @Nullable java.lang.Object elt,
                                int minindex,
                                int indexlimit)
```
    Searches for the first occurrence of the given element in the list, testing for equality using the equals method.
    
    Parameters:
    
    a - a list
    
    elt - the element to search for
    
    minindex - first index at which to search
    
    indexlimit - first index at which not to search
    
    Returns:
    
    the first index i containing the specified element, such that minindex ≤ i < indexlimit, or -1 if the element is not found in that section of the list
    
    See Also:
    
    List.indexOf(java.lang.Object)
  - indexOfEq
```
@Pure
public static int indexOfEq(@PolyAll java.lang.Object[] a,
                                  @Nullable java.lang.Object elt)
```
    Searches for the first occurrence of the given element in the array, testing for equality using == (not the equals method).
    
    Parameters:
    
    a - an array
    
    elt - the element to search for
    
    Returns:
    
    the first index containing the specified element, or -1 if the element is not found in the array
    
    See Also:
    
    ArrayList.indexOf(java.lang.Object)
  - indexOfEq
```
@Pure
public static int indexOfEq(@PolyNull java.lang.Object[] a,
                                  @Nullable java.lang.Object elt,
                                  int minindex,
                                  int indexlimit)
```
    Searches for the first occurrence of the given element in the array, testing for equality using == (not the equals method).
    
    Parameters:
    
    a - an array
    
    elt - the element to search for
    
    minindex - first index at which to search
    
    indexlimit - first index at which not to search
    
    Returns:
    
    the first index i containing the specified element, such that minindex ≤ i < indexlimit, or -1 if the element is not found in that section of the array
    
    See Also:
    
    ArrayList.indexOf(java.lang.Object)
  - indexOfEq
```
@Pure
public static int indexOfEq(java.util.List<? extends java.lang.Object> a,
                                  @Nullable java.lang.Object elt)
```
    Searches for the first occurrence of the given element in the list, testing for equality using == (not the equals method).
    
    Parameters:
    
    a - a list
    
    elt - the element to search for
    
    Returns:
    
    the first index containing the specified element, or -1 if the element is not found in the list
    
    See Also:
    
    ArrayList.indexOf(java.lang.Object)
  - indexOfEq
```
@Pure
public static int indexOfEq(java.util.List<? extends java.lang.Object> a,
                                  @Nullable java.lang.Object elt,
                                  int minindex,
                                  int indexlimit)
```
    Searches for the first occurrence of the given element in the list, testing for equality using == (not the equals method).
    
    Parameters:
    
    a - a list
    
    elt - the element to search for
    
    minindex - first index at which to search
    
    indexlimit - first index at which not to search
    
    Returns:
    
    the first index i containing the specified element, such that minindex ≤ i < indexlimit, or -1 if the element is not found in that section of the list
    
    See Also:
    
    ArrayList.indexOf(java.lang.Object)
  - indexOf
```
@Pure
public static int indexOf(int[] a,
                                int elt)
```
    Searches for the first occurrence of the given element in the array.
    
    Parameters:
    
    a - an array
    
    elt - the element to search for
    
    Returns:
    
    the first index containing the specified element, or -1 if the element is not found in the array
    
    See Also:
    
    ArrayList.indexOf(java.lang.Object)
  - indexOf
```
@Pure
public static int indexOf(long[] a,
                                long elt)
```
    Searches for the first occurrence of the given element in the array.
    
    Parameters:
    
    a - an array
    
    elt - the element to search for
    
    Returns:
    
    the first index containing the specified element, or -1 if the element is not found in the array
    
    See Also:
    
    ArrayList.indexOf(java.lang.Object)
  - indexOf
```
@Pure
public static int indexOf(int[] a,
                                int elt,
                                int minindex,
                                int indexlimit)
```
    Searches for the first occurrence of the given element in the array.
    
    Parameters:
    
    a - an array
    
    elt - the element to search for
    
    minindex - first index at which to search
    
    indexlimit - first index at which not to search
    
    Returns:
    
    the first index i containing the specified element, such that minindex ≤ i < indexlimit, or -1 if the element is not found in the array
    
    See Also:
    
    ArrayList.indexOf(java.lang.Object)
  - indexOf
```
@Pure
public static int indexOf(long[] a,
                                long elt,
                                int minindex,
                                int indexlimit)
```
    Searches for the first occurrence of the given element in the array.
    
    Parameters:
    
    a - an array
    
    elt - the element to search for
    
    minindex - first index at which to search
    
    indexlimit - first index at which not to search
    
    Returns:
    
    the first index i containing the specified element, such that minindex ≤ i < indexlimit, or -1 if the element is not found in the array
    
    See Also:
    
    ArrayList.indexOf(java.lang.Object)
  - indexOf
```
@Pure
public static int indexOf(boolean[] a,
                                boolean elt)
```
    Searches for the first occurrence of the given element in the array.
    
    Parameters:
    
    a - an array
    
    elt - the element to search for
    
    Returns:
    
    the first index containing the specified element, or -1 if the element is not found in the array
    
    See Also:
    
    ArrayList.indexOf(java.lang.Object)
  - indexOf
```
@Pure
public static int indexOf(double[] a,
                                double elt)
```
    Searches for the first occurrence of the given element in the array.
    
    Parameters:
    
    a - an array
    
    elt - the element to search for
    
    Returns:
    
    the first index containing the specified element, or -1 if the element is not found in the array
    
    See Also:
    
    ArrayList.indexOf(java.lang.Object)
  - indexOf
```
@Pure
public static int indexOf(boolean[] a,
                                boolean elt,
                                int minindex,
                                int indexlimit)
```
    Searches for the first occurrence of the given element in the array.
    
    Parameters:
    
    a - an array
    
    elt - the element to search for
    
    minindex - first index at which to search
    
    indexlimit - first index at which not to search
    
    Returns:
    
    the first index i containing the specified element, such that minindex ≤ i < indexlimit, or -1 if the element is not found in the array
    
    See Also:
    
    ArrayList.indexOf(java.lang.Object)
  - indexOf
```
@Pure
public static int indexOf(@PolyAll java.lang.Object[] a,
                                java.lang.Object[] sub)
```
    Searches for the first subsequence of the array that matches the given array elementwise, testing for equality using the equals method.
    
    Parameters:
    
    a - an array
    
    sub - subsequence to search for
    
    Returns:
    
    the first index at which the second array starts in the first array, or -1 if no such element is found in the array
    
    See Also:
    
    ArrayList.indexOf(java.lang.Object), String.indexOf(java.lang.String)
  - indexOfEq
```
@Pure
public static int indexOfEq(@PolyAll java.lang.Object[] a,
                                  @PolyAll java.lang.Object[] sub)
```
    Searches for the first subsequence of the array that matches the given array elementwise, testing for equality using == (not the equals method).
    
    Parameters:
    
    a - an array
    
    sub - subsequence to search for
    
    Returns:
    
    the first index at which the second array starts in the first array, or -1 if the element is not found in the array
    
    See Also:
    
    ArrayList.indexOf(java.lang.Object), String.indexOf(java.lang.String)
  - indexOf
```
@Pure
public static int indexOf(java.util.List<?> a,
                                @PolyAll java.lang.Object[] sub)
```
    Searches for the first subsequence of the list that matches the given array elementwise, testing for equality using the equals method.
    
    Parameters:
    
    a - a list
    
    sub - subsequence to search for
    
    Returns:
    
    the first index at which the second array starts in the first list, or -1 if no such element is found in the list
    
    See Also:
    
    ArrayList.indexOf(java.lang.Object), String.indexOf(java.lang.String)
  - indexOfEq
```
@Pure
public static int indexOfEq(java.util.List<?> a,
                                  @PolyAll java.lang.Object[] sub)
```
    Searches for the first subsequence of the list that matches the given array elementwise, testing for equality using == (not the equals method).
    
    Parameters:
    
    a - a list
    
    sub - subsequence to search for
    
    Returns:
    
    the first index at which the second array starts in the first list, or -1 if the element is not found in the list
    
    See Also:
    
    ArrayList.indexOf(java.lang.Object), String.indexOf(java.lang.String)
  - indexOf
```
@Pure
public static int indexOf(@PolyAll java.lang.Object[] a,
                                java.util.List<?> sub)
```
    Searches for the first subsequence of the array that matches the given list elementwise, testing for equality using the equals method.
    
    Parameters:
    
    a - a list
    
    sub - subsequence to search for
    
    Returns:
    
    the first index at which the second list starts in the first array, or -1 if no such element is found in the array
    
    See Also:
    
    ArrayList.indexOf(java.lang.Object), String.indexOf(java.lang.String)
  - indexOfEq
```
@Pure
public static int indexOfEq(@PolyAll java.lang.Object[] a,
                                  java.util.List<?> sub)
```
    Searches for the first subsequence of the array that matches the given list elementwise, testing for equality using == (not the equals method).
    
    Parameters:
    
    a - a list
    
    sub - subsequence to search for
    
    Returns:
    
    the first index at which the second list starts in the first array, or -1 if the element is not found in the array
    
    See Also:
    
    ArrayList.indexOf(java.lang.Object), String.indexOf(java.lang.String)
  - indexOf
```
@Pure
public static int indexOf(java.util.List<?> a,
                                java.util.List<?> sub)
```
    Searches for the first subsequence of the list that matches the given list elementwise, testing for equality using the equals method.
    
    Parameters:
    
    a - a list
    
    sub - subsequence to search for
    
    Returns:
    
    the first index at which the second list starts in the first list, or -1 if no such element is found in the list
    
    See Also:
    
    ArrayList.indexOf(java.lang.Object), String.indexOf(java.lang.String)
  - indexOfEq
```
@Pure
public static int indexOfEq(java.util.List<?> a,
                                  java.util.List<?> sub)
```
    Searches for the first subsequence of the list that matches the given list elementwise, testing for equality using == (not the equals method).
    
    Parameters:
    
    a - a list
    
    sub - subsequence to search for
    
    Returns:
    
    the first index at which the second list starts in the first list, or -1 if the element is not found in the list
    
    See Also:
    
    ArrayList.indexOf(java.lang.Object), String.indexOf(java.lang.String)
  - indexOf
```
@Pure
public static int indexOf(int[] a,
                                int[] sub)
```
    Searches for the first subsequence of the array that matches the given array elementwise.
    
    Parameters:
    
    a - an array
    
    sub - subsequence to search for
    
    Returns:
    
    the first index at which the second array starts in the first array, or -1 if the element is not found in the array
    
    See Also:
    
    ArrayList.indexOf(java.lang.Object), String.indexOf(java.lang.String)
  - indexOf
```
@Pure
public static int indexOf(double[] a,
                                double[] sub)
```
    Searches for the first subsequence of the array that matches the given array elementwise.
    
    Parameters:
    
    a - an array
    
    sub - subsequence to search for
    
    Returns:
    
    the first index at which the second array starts in the first array, or -1 if the element is not found in the array
    
    See Also:
    
    ArrayList.indexOf(java.lang.Object), String.indexOf(java.lang.String)
  - indexOf
```
@Pure
public static int indexOf(long[] a,
                                long[] sub)
```
    Searches for the first subsequence of the array that matches the given array elementwise.
    
    Parameters:
    
    a - an array
    
    sub - subsequence to search for
    
    Returns:
    
    the first index at which the second array starts in the first array, or -1 if the element is not found in the array
    
    See Also:
    
    ArrayList.indexOf(java.lang.Object), String.indexOf(java.lang.String)
  - indexOf
```
@Pure
public static int indexOf(boolean[] a,
                                boolean[] sub)
```
    Searches for the first subsequence of the array that matches the given array elementwise.
    
    Parameters:
    
    a - an array
    
    sub - subsequence to search for
    
    Returns:
    
    the first index containing the specified element, or -1 if the element is not found in the array
    
    See Also:
    
    ArrayList.indexOf(java.lang.Object), String.indexOf(java.lang.String)
  - subarray
```
@SideEffectFree
public static @PolyAll java.lang.Object[] subarray(@PolyAll java.lang.Object[] a,
                                                                   int startindex,
                                                                   int length)
```
    Return a subarray of the given array.
    
    Parameters:
    
    a - the original array
    
    startindex - the first index to be included
    
    length - the number of elements to include (not an end index, to avoid confusion over whether it would be the last included index or the first non-included index)
    
    Returns:
    
    a subarray of the given array
  - subarray
```
@SideEffectFree
public static <T> java.util.List<T> subarray(java.util.List<T> a,
                                                             int startindex,
                                                             int length)
```
    Return a sublist of the given list.
    
    Type Parameters:
    
    T - type of the elements
    
    Parameters:
    
    a - the original list
    
    startindex - the first index to be included
    
    length - the number of elements to include (not an end index, to avoid confusion over whether it would be the last included index or the first non-included index)
    
    Returns:
    
    a sublist of the given list
  - subarray
```
@SideEffectFree
public static @PolyAll java.lang.String[] subarray(@PolyAll java.lang.String[] a,
                                                                   int startindex,
                                                                   int length)
```
    Return a subarray of the given array.
    
    Parameters:
    
    a - the original array
    
    startindex - the first index to be included
    
    length - the number of elements to include (not an end index, to avoid confusion over whether it would be the last included index or the first non-included index)
    
    Returns:
    
    a subarray of the given array
  - subarray
```
@SideEffectFree
public static byte[] subarray(byte[] a,
                                              int startindex,
                                              int length)
```
    Return a subarray of the given array.
    
    Parameters:
    
    a - the original array
    
    startindex - the first index to be included
    
    length - the number of elements to include (not an end index, to avoid confusion over whether it would be the last included index or the first non-included index)
    
    Returns:
    
    a subarray of the given array
  - subarray
```
@SideEffectFree
public static boolean[] subarray(boolean[] a,
                                                 int startindex,
                                                 int length)
```
    Return a subarray of the given array.
    
    Parameters:
    
    a - the original array
    
    startindex - the first index to be included
    
    length - the number of elements to include (not an end index, to avoid confusion over whether it would be the last included index or the first non-included index)
    
    Returns:
    
    a subarray of the given array
  - subarray
```
@SideEffectFree
public static char[] subarray(char[] a,
                                              int startindex,
                                              int length)
```
    Return a subarray of the given array.
    
    Parameters:
    
    a - the original array
    
    startindex - the first index to be included
    
    length - the number of elements to include (not an end index, to avoid confusion over whether it would be the last included index or the first non-included index)
    
    Returns:
    
    a subarray of the given array
  - subarray
```
@SideEffectFree
public static double[] subarray(double[] a,
                                                int startindex,
                                                int length)
```
    Return a subarray of the given array.
    
    Parameters:
    
    a - the original array
    
    startindex - the first index to be included
    
    length - the number of elements to include (not an end index, to avoid confusion over whether it would be the last included index or the first non-included index)
    
    Returns:
    
    a subarray of the given array
  - subarray
```
@SideEffectFree
public static float[] subarray(float[] a,
                                               int startindex,
                                               int length)
```
    Return a subarray of the given array.
    
    Parameters:
    
    a - the original array
    
    startindex - the first index to be included
    
    length - the number of elements to include (not an end index, to avoid confusion over whether it would be the last included index or the first non-included index)
    
    Returns:
    
    a subarray of the given array
  - subarray
```
@SideEffectFree
public static int[] subarray(int[] a,
                                             int startindex,
                                             int length)
```
    Return a subarray of the given array.
    
    Parameters:
    
    a - the original array
    
    startindex - the first index to be included
    
    length - the number of elements to include (not an end index, to avoid confusion over whether it would be the last included index or the first non-included index)
    
    Returns:
    
    a subarray of the given array
  - subarray
```
@SideEffectFree
public static long[] subarray(long[] a,
                                              int startindex,
                                              int length)
```
    Return a subarray of the given array.
    
    Parameters:
    
    a - the original array
    
    startindex - the first index to be included
    
    length - the number of elements to include (not an end index, to avoid confusion over whether it would be the last included index or the first non-included index)
    
    Returns:
    
    a subarray of the given array
  - subarray
```
@SideEffectFree
public static short[] subarray(short[] a,
                                               int startindex,
                                               int length)
```
    Return a subarray of the given array.
    
    Parameters:
    
    a - the original array
    
    startindex - the first index to be included
    
    length - the number of elements to include (not an end index, to avoid confusion over whether it would be the last included index or the first non-included index)
    
    Returns:
    
    a subarray of the given array
  - isSubarray
```
@Pure
public static boolean isSubarray(@PolyAll java.lang.Object[] a,
                                       @PolyNull java.lang.Object[] sub,
                                       int aOffset)
```
    Determines whether the second array is a subarray of the first, starting at the specified index of the first, testing for equality using the equals method.
    
    Parameters:
    
    a - an array
    
    sub - subsequence to search for
    
    aOffset - first index in a at which to search. Must be non-negative. The routine returns false if aAffset is too large to be a valid index for a.
    
    Returns:
    
    true iff sub is a contiguous subarray of a
  - isSubarrayEq
```
@Pure
public static boolean isSubarrayEq(@PolyAll java.lang.Object[] a,
                                         @PolyAll java.lang.Object[] sub,
                                         int aOffset)
```
    Determines whether the second array is a subarray of the first, starting at the specified index of the first, testing for equality using == (not the equals method).
    
    Parameters:
    
    a - an array
    
    sub - subsequence to search for
    
    aOffset - first index in a at which to search. Must be non-negative. The routine returns false if aAffset is too large to be a valid index for a.
    
    Returns:
    
    true iff sub is a contiguous subarray of a
  - isSubarray
```
@Pure
public static boolean isSubarray(@PolyAll java.lang.Object[] a,
                                       java.util.List<?> sub,
                                       int aOffset)
```
    Determines whether the second array is a subarray of the first, starting at the specified index of the first, testing for equality using the equals method.
    
    Parameters:
    
    a - an array
    
    sub - subsequence to search for
    
    aOffset - first index in a at which to search. Must be non-negative. The routine returns false if aAffset is too large to be a valid index for a.
    
    Returns:
    
    the first index at which the second array starts in the first array, or -1 if no such element is found in the array
  - isSubarrayEq
```
@Pure
public static boolean isSubarrayEq(@PolyAll java.lang.Object[] a,
                                         java.util.List<?> sub,
                                         int aOffset)
```
    Determines whether the second array is a subarray of the first, starting at the specified index of the first, testing for equality using == (not the equals method).
    
    Parameters:
    
    a - an array
    
    sub - subsequence to search for
    
    aOffset - first index in a at which to search. Must be non-negative. The routine returns false if aAffset is too large to be a valid index for a.
    
    Returns:
    
    true iff sub is a contiguous subarray of a
  - isSubarray
```
@Pure
public static boolean isSubarray(java.util.List<?> a,
                                       @PolyAll java.lang.Object[] sub,
                                       int aOffset)
```
    Determines whether the second array is a subarray of the first, starting at the specified index of the first, testing for equality using the equals method.
    
    Parameters:
    
    a - a list
    
    sub - subsequence to search for
    
    aOffset - first index in a at which to search. Must be non-negative. The routine returns false if aAffset is too large to be a valid index for a.
    
    Returns:
    
    the first index at which the second array starts in the first array, or -1 if no such element is found in the array
  - isSubarrayEq
```
@Pure
public static boolean isSubarrayEq(java.util.List<?> a,
                                         @PolyAll java.lang.Object[] sub,
                                         int aOffset)
```
    Determines whether the second array is a subarray of the first, starting at the specified index of the first, testing for equality using == (not the equals method).
    
    Parameters:
    
    a - a list
    
    sub - subsequence to search for
    
    aOffset - first index in a at which to search. Must be non-negative. The routine returns false if aAffset is too large to be a valid index for a.
    
    Returns:
    
    true iff sub is a contiguous subarray of a
  - isSubarray
```
@Pure
public static boolean isSubarray(java.util.List<?> a,
                                       java.util.List<?> sub,
                                       int aOffset)
```
    Determines whether the second array is a subarray of the first, starting at the specified index of the first, testing for equality using the equals method.
    
    Parameters:
    
    a - a list
    
    sub - subsequence to search for
    
    aOffset - first index in a at which to search. Must be non-negative. The routine returns false if aAffset is too large to be a valid index for a.
    
    Returns:
    
    the first index at which the second array starts in the first array, or -1 if no such element is found in the array
  - isSubarrayEq
```
@Pure
public static boolean isSubarrayEq(java.util.List<?> a,
                                         java.util.List<?> sub,
                                         int aOffset)
```
    Determines whether the second array is a subarray of the first, starting at the specified index of the first, testing for equality using == (not the equals method).
    
    Parameters:
    
    a - a list
    
    sub - subsequence to search for
    
    aOffset - first index in a at which to search. Must be non-negative. The routine returns false if aAffset is too large to be a valid index for a.
    
    Returns:
    
    true iff sub is a contiguous subarray of a
  - isSubarray
```
@Pure
public static boolean isSubarray(int[] a,
                                       int[] sub,
                                       int aOffset)
```
    Determines whether the second array is a subarray of the first, starting at the specified index of the first.
    
    Parameters:
    
    a - an array
    
    sub - subsequence to search for
    
    aOffset - first index in a at which to search. Must be non-negative. The routine returns false if aAffset is too large to be a valid index for a.
    
    Returns:
    
    true iff sub is a contiguous subarray of a
  - isSubarray
```
@Pure
public static boolean isSubarray(long[] a,
                                       long[] sub,
                                       int aOffset)
```
    Determines whether the second array is a subarray of the first, starting at the specified index of the first.
    
    Parameters:
    
    a - an array
    
    sub - subsequence to search for
    
    aOffset - first index in a at which to search. Must be non-negative. The routine returns false if aAffset is too large to be a valid index for a.
    
    Returns:
    
    true iff sub is a contiguous subarray of a
  - isSubarray
```
@Pure
public static boolean isSubarray(double[] a,
                                       double[] sub,
                                       int aOffset)
```
    Determines whether the second array is a subarray of the first, starting at the specified index of the first.
    
    Parameters:
    
    a - an array
    
    sub - subsequence to search for
    
    aOffset - first index in a at which to search. Must be non-negative. The routine returns false if aAffset is too large to be a valid index for a.
    
    Returns:
    
    true iff sub is a contiguous subarray of a
  - isSubarray
```
@Pure
public static boolean isSubarray(boolean[] a,
                                       boolean[] sub,
                                       int aOffset)
```
    Determines whether the second array is a subarray of the first, starting at the specified index of the first.
    
    Parameters:
    
    a - an array
    
    sub - subsequence to search for
    
    aOffset - first index in a at which to search. Must be non-negative. The routine returns false if aAffset is too large to be a valid index for a.
    
    Returns:
    
    true iff sub is a contiguous subarray of a
  - concat
```
public static <T> T[] concat(T[] a,
                             T[] b)
```
    Return an array that contains all the elements of both arguments, in order. Returns an existing array if possible (when one argument is null or empty).
    
    Type Parameters:
    
    T - the type of the sequence elements
    
    Parameters:
    
    a - the first sequence to concatenate
    
    b - the second sequence to concatenate
    
    Returns:
    
    an array that concatenates the arguments
  - concat
```
public static <T> T[] concat(T[] a,
                             @Nullable java.util.List<T> b)
```
    Return an array that contains all the elements of both arguments, in order. Returns an existing array if the list argument is null or empty.
    
    Type Parameters:
    
    T - the type of the sequence elements
    
    Parameters:
    
    a - the first sequence to concatenate
    
    b - the second sequence to concatenate
    
    Returns:
    
    an array that concatenates the arguments
  - concat
```
public static <T> T[] concat(@Nullable java.util.List<T> a,
                             T[] b)
```
    Return an array that contains all the elements of both arguments, in order. Returns an existing array if the list argument is null or empty.
    
    Type Parameters:
    
    T - the type of the sequence elements
    
    Parameters:
    
    a - the first sequence to concatenate
    
    b - the second sequence to concatenate
    
    Returns:
    
    an array that concatenates the arguments
  - concat
```
public static <T> T[] concat(@Nullable java.util.List<T> a,
                             @Nullable java.util.List<T> b)
```
    Return an array that contains all the elements of both arguments, in order.
    
    Type Parameters:
    
    T - the type of the sequence elements
    
    Parameters:
    
    a - the first sequence to concatenate
    
    b - the second sequence to concatenate
    
    Returns:
    
    an array that concatenates the arguments
  - concat
```
public static @PolyAll java.lang.String[] concat(@PolyAll java.lang.String[] a,
                                                 @PolyAll java.lang.String[] b)
```
    Return an array that contains all the elements of both argument arrays, in order. Returns a new array unless one argument is null, in which case it returns the other array.
    
    Parameters:
    
    a - the first array to concatenate
    
    b - the second array to concatenate
    
    Returns:
    
    an array that concatenates the arguments
  - concat
```
public static byte[] concat(byte[] a,
                            byte[] b)
```
    Return an array that contains all the elements of both argument arrays, in order. Returns a new array unless one argument is null, in which case it returns the other array.
    
    Parameters:
    
    a - the first sequence to concatenate
    
    b - the second sequence to concatenate
    
    Returns:
    
    an array that concatenates the arguments
  - concat
```
public static boolean[] concat(boolean[] a,
                               boolean[] b)
```
    Return an array that contains all the elements of both argument arrays, in order. Returns a new array unless one argument is null, in which case it returns the other array.
    
    Parameters:
    
    a - the first sequence to concatenate
    
    b - the second sequence to concatenate
    
    Returns:
    
    an array that concatenates the arguments
  - concat
```
public static char[] concat(char[] a,
                            char[] b)
```
    Return an array that contains all the elements of both argument arrays, in order. Returns a new array unless one argument is null, in which case it returns the other array.
    
    Parameters:
    
    a - the first sequence to concatenate
    
    b - the second sequence to concatenate
    
    Returns:
    
    an array that concatenates the arguments
  - concat
```
public static double[] concat(double[] a,
                              double[] b)
```
    Return an array that contains all the elements of both argument arrays, in order. Returns a new array unless one argument is null, in which case it returns the other array.
    
    Parameters:
    
    a - the first sequence to concatenate
    
    b - the second sequence to concatenate
    
    Returns:
    
    an array that concatenates the arguments
  - concat
```
public static float[] concat(float[] a,
                             float[] b)
```
    Return an array that contains all the elements of both argument arrays, in order. Returns a new array unless one argument is null, in which case it returns the other array.
    
    Parameters:
    
    a - the first sequence to concatenate
    
    b - the second sequence to concatenate
    
    Returns:
    
    an array that concatenates the arguments
  - concat
```
public static int[] concat(int[] a,
                           int[] b)
```
    Return an array that contains all the elements of both argument arrays, in order. Returns a new array unless one argument is null, in which case it returns the other array.
    
    Parameters:
    
    a - the first sequence to concatenate
    
    b - the second sequence to concatenate
    
    Returns:
    
    an array that concatenates the arguments
  - concat
```
public static long[] concat(long[] a,
                            long[] b)
```
    Return an array that contains all the elements of both argument arrays, in order. Returns a new array unless one argument is null, in which case it returns the other array.
    
    Parameters:
    
    a - the first sequence to concatenate
    
    b - the second sequence to concatenate
    
    Returns:
    
    an array that concatenates the arguments
  - concat
```
public static short[] concat(short[] a,
                             short[] b)
```
    Return an array that contains all the elements of both argument arrays, in order. Returns a new array unless one argument is null, in which case it returns the other array.
    
    Parameters:
    
    a - the first sequence to concatenate
    
    b - the second sequence to concatenate
    
    Returns:
    
    an array that concatenates the arguments
  - toString
```
@SideEffectFree
public static java.lang.String toString(java.lang.Object a)
```
    Returns a string representation of the contents of the specified array. The argument must be an array or null. This just dispatches one of the 9 overloaded versions of java.util.Arrays.toString().
    
    Parameters:
    
    a - an array
    
    Returns:
    
    a string representation of the array
    
    Throws:
    
    java.lang.IllegalArgumentException - if a is not an array
  - length
```
@Pure
public static int length(java.lang.Object a)
                        throws java.lang.IllegalArgumentException
```
    Returns the length of the argument array.
    
    Parameters:
    
    a - an array
    
    Returns:
    
    the length of the array
    
    Throws:
    
    java.lang.IllegalArgumentException - if obj is null or is not an array
  - toString
```
@SideEffectFree
public static java.lang.String toString(@PolyAll java.lang.Object[] a)
```
    Return a string representation of the array. The representation is patterned after that of java.util.ArrayList.
    
    Parameters:
    
    a - an array
    
    Returns:
    
    a string representation of the array
    
    See Also:
    
    AbstractCollection.toString()
  - toStringQuoted
```
@SideEffectFree
public static java.lang.String toStringQuoted(@PolyAll java.lang.Object[] a)
```
    Return a string representation of the array. The representation is patterned after that of java.util.ArrayList. Furthermore, each element is quoted like a Java String.
    
    Parameters:
    
    a - an array
    
    Returns:
    
    a string representation of the array, with the elements quoted
    
    See Also:
    
    AbstractCollection.toString()
  - toString
```
@SideEffectFree
public static java.lang.String toString(@PolyAll java.lang.Object[] a,
                                                        boolean quoted)
```
    Return a string representation of the array. The representation is patterned after that of java.util.ArrayList. Furthermore, if quoted is true, then each element is quoted like a Java String.
    
    Parameters:
    
    a - an array
    
    quoted - whether to quote the array elements
    
    Returns:
    
    a string representation of the array
    
    See Also:
    
    AbstractCollection.toString()
  - toString
```
@SideEffectFree
public static java.lang.String toString(@Nullable java.util.Collection<?> a)
```
    Return a string representation of the collection. The representation is patterned after that of java.util.ArrayList.
    
    Parameters:
    
    a - a collection
    
    Returns:
    
    a string representation of the collection
    
    See Also:
    
    AbstractCollection.toString()
  - toStringQuoted
```
@SideEffectFree
public static java.lang.String toStringQuoted(@Nullable java.util.Collection<?> a)
```
    Return a string representation of the collection. The representation is patterned after that of java.util.ArrayList.
    
    Parameters:
    
    a - a collection
    
    Returns:
    
    a string representation of the collection, with the elements quoted
    
    See Also:
    
    AbstractCollection.toString()
  - toString
```
@SideEffectFree
public static java.lang.String toString(@Nullable java.util.Collection<?> a,
                                                        boolean quoted)
```
    Return a string representation of the collection. The representation is patterned after that of java.util.ArrayList. The representation permits quoting (or not) of strings.
    
    Parameters:
    
    a - a collection
    
    quoted - whether to quote the collection elements that are Java strings
    
    Returns:
    
    a string representation of the list
    
    See Also:
    
    AbstractCollection.toString()
  - sorted
```
@Pure
public static boolean sorted(int[] a)
```
    Returns whether the array is sorted.
    
    Parameters:
    
    a - an array
    
    Returns:
    
    true iff the array is sorted
  - sorted
```
@Pure
public static boolean sorted(long[] a)
```
    Returns whether the array is sorted.
    
    Parameters:
    
    a - an array
    
    Returns:
    
    true iff the array is sorted
  - isSortedDescending
```
@Pure
public static boolean isSortedDescending(int[] a)
```
    Returns whether the array is sorted in descending order.
    
    Parameters:
    
    a - an array
    
    Returns:
    
    true iff the array is sorted in descending order
  - isSortedDescending
```
@Pure
public static boolean isSortedDescending(long[] a)
```
    Returns whether the array is sorted in descending order.
    
    Parameters:
    
    a - an array
    
    Returns:
    
    true iff the array is sorted in descending order
  - noDuplicates
```
@Pure
public static boolean noDuplicates(boolean[] a)
```
    Return true iff a does not contain duplicate elements.
    The implementation uses O(n) time and O(n) space.
    
    Parameters:
    
    a - an array
    
    Returns:
    
    true iff a does not contain duplicate elements
  - noDuplicates
```
@Pure
public static boolean noDuplicates(byte[] a)
```
    Return true iff a does not contain duplicate elements.
    The implementation uses O(n) time and O(n) space.
    
    Parameters:
    
    a - an array
    
    Returns:
    
    true iff a does not contain duplicate elements
  - noDuplicates
```
@Pure
public static boolean noDuplicates(char[] a)
```
    Return true iff a does not contain duplicate elements.
    The implementation uses O(n) time and O(n) space.
    
    Parameters:
    
    a - an array
    
    Returns:
    
    true iff a does not contain duplicate elements
  - noDuplicates
```
@Pure
public static boolean noDuplicates(float[] a)
```
    Return true iff a does not contain duplicate elements.
    The implementation uses O(n) time and O(n) space.
    
    Parameters:
    
    a - an array
    
    Returns:
    
    true iff a does not contain duplicate elements
  - noDuplicates
```
@Pure
public static boolean noDuplicates(short[] a)
```
    Return true iff a does not contain duplicate elements.
    The implementation uses O(n) time and O(n) space.
    
    Parameters:
    
    a - an array
    
    Returns:
    
    true iff a does not contain duplicate elements
  - noDuplicates
```
@Pure
public static boolean noDuplicates(int[] a)
```
    Return true iff a does not contain duplicate elements.
    The implementation uses O(n) time and O(n) space.
    
    Parameters:
    
    a - an array
    
    Returns:
    
    true iff a does not contain duplicate elements
  - noDuplicates
```
@Pure
public static boolean noDuplicates(double[] a)
```
    Return true iff a does not contain duplicate elements. Equality checking uses Double.equals(java.lang.Object).
    The implementation uses O(n) time and O(n) space.
    
    Parameters:
    
    a - an array
    
    Returns:
    
    true iff a does not contain duplicate elements
  - noDuplicates
```
@Pure
public static boolean noDuplicates(long[] a)
```
    Return true iff a does not contain duplicate elements.
    The implementation uses O(n) time and O(n) space.
    
    Parameters:
    
    a - an array
    
    Returns:
    
    true iff a does not contain duplicate elements
  - noDuplicates
```
@Pure
public static boolean noDuplicates(java.lang.String[] a)
```
    Return true iff a does not contain duplicate elements.
    The implementation uses O(n) time and O(n) space.
    
    Parameters:
    
    a - an array
    
    Returns:
    
    true iff a does not contain duplicate elements
  - noDuplicates
```
@Pure
public static boolean noDuplicates(java.lang.Object[] a)
```
    Return true iff a does not contain duplicate elements.
    The implementation uses O(n) time and O(n) space.
    
    Parameters:
    
    a - an array
    
    Returns:
    
    true iff a does not contain duplicate elements
  - noDuplicates
```
@Pure
public static <T> boolean noDuplicates(java.util.List<T> a)
```
    Return true iff a does not contain duplicate elements.
    The implementation uses O(n) time and O(n) space.
    
    Type Parameters:
    
    T - the type of the elements
    
    Parameters:
    
    a - a list
    
    Returns:
    
    true iff a does not contain duplicate elements
  - fnIsPermutation
```
@Pure
public static boolean fnIsPermutation(int[] a)
```
    Returns true if the array is a permutation of [0..a.length).
    
    Parameters:
    
    a - an array, representing a function
    
    Returns:
    
    true iff all elements of a are in [0..a.length) and a contains no duplicates.
  - fnIsTotal
```
@Pure
public static boolean fnIsTotal(int[] a)
```
    Return true iff the array does not contain -1.
    
    Parameters:
    
    a - an array, representing a function
    
    Returns:
    
    true iff no element of a maps to -1
  - fnIdentity
```
public static int[] fnIdentity(int length)
```
    Return an array [0..length).
    
    Parameters:
    
    length - the length of the result
    
    Returns:
    
    fresh array that is the identity function of the given length
  - fnInversePermutation
```
public static int[] fnInversePermutation(int[] a)
```
    Requires that fnIsPermutation(a) holds.
    
    Parameters:
    
    a - the input permutation
    
    Returns:
    
    fresh array which is the inverse of the given permutation
    
    See Also:
    
    fnIsPermutation(int[])
  - fnInverse
```
public static int[] fnInverse(int[] a,
                              int arange)
```
    Return the inverse of the given function, which is represented as an array.
    
    Parameters:
    
    a - an array representing a function from [0..a.length) to [0..arange); each element of a is between 0 (inclusive) and arange (exclusive)
    
    arange - length of the argument's range and the result's domain
    
    Returns:
    
    function from [0..arange) to [0..a.length) that is the inverse of a
    
    Throws:
    
    java.lang.IllegalArgumentException - if a value of a is outside of arange
    
    java.lang.UnsupportedOperationException - when the function is not invertible
  - fnCompose
```
public static @PolyAll int[] fnCompose(int[] a,
                                       @PolyAll int[] b)
```
    Return the composition of the given two functions, all of which are represented as arrays.
    
    Parameters:
    
    a - function from [0..a.length) to [0..b.length)
    
    b - function from [0..b.length) to range R
    
    Returns:
    
    function from [0..a.length) to range R that is the composition of a and b
  - partialFnCompose
```
public static int[] partialFnCompose(int[] a,
                                     int[] b)
```
    Return the composition of the given two (possibly partial) functions, all of which are represented as arrays.
    
    Parameters:
    
    a - function from [0..a.length) to [-1..b.length)
    
    b - function from [0..b.length) to range R
    
    Returns:
    
    function from [0..a.length) to {range R} union {-1}, that is the composition of a and b.
  - isSubset
```
@Pure
public static boolean isSubset(long[] smaller,
                                     long[] bigger)
```
    Return whether smaller is a subset of bigger.
    The implementation is to use collections because we want to take advantage of HashSet's constant time membership tests.
    
    Parameters:
    
    smaller - first set to test
    
    bigger - second set to test
    
    Returns:
    
    true iff smaller is a subset of bigger
  - isSubset
```
@Pure
public static boolean isSubset(double[] smaller,
                                     double[] bigger)
```
    Return whether smaller is a subset of bigger.
    The implementation is to use collections because we want to take advantage of HashSet's constant time membership tests.
    
    Parameters:
    
    smaller - first set to test
    
    bigger - second set to test
    
    Returns:
    
    true iff smaller is a subset of bigger
  - isSubset
```
@Pure
public static boolean isSubset(java.lang.String[] smaller,
                                     java.lang.String[] bigger)
```
    Return whether smaller is a subset of bigger.
    The implementation is to use collections because we want to take advantage of HashSet's constant time membership tests.
    
    Parameters:
    
    smaller - first set to test
    
    bigger - second set to test
    
    Returns:
    
    true iff smaller is a subset of bigger
  - anyNull
```
@Pure
public static boolean anyNull(@PolyAll java.lang.Object[] a)
```
    Return true if a contains null.
    
    Parameters:
    
    a - an array
    
    Returns:
    
    true iff some element of a is null (false if a is zero-sized)
  - allNull
```
@Pure
public static boolean allNull(@PolyAll java.lang.Object[] a)
```
    Return true if all elements of a are null.
    
    Parameters:
    
    a - an array
    
    Returns:
    
    true iff all elements of a are null (unspecified result if a is zero-sized)
  - anyNull
```
@Pure
public static boolean anyNull(java.util.List<?> a)
```
    Return true if a contains null.
    
    Parameters:
    
    a - an array
    
    Returns:
    
    true iff some element of a is null (false if a is zero-sized)
  - allNull
```
@Pure
public static boolean allNull(java.util.List<?> a)
```
    Return true if all elements of a are null.
    
    Parameters:
    
    a - an array
    
    Returns:
    
    true iff all elements of a are null (unspecified result if a is zero-sized)
  - partitionInto
```
public static <T> java.util.List<org.plumelib.util.ArraysPlume.Partitioning<T>> partitionInto(java.util.Collection<T> elts,
                                                                                              int k)
```
    Partition a set of non-null elements into exactly k subsets. A partitioning is of type List<List<T>>, where the union of the inner lists is elts. This method returns a list of such partitionings.
    
    Type Parameters:
    
    T - type of items to be partitioned
    
    Parameters:
    
    elts - items to be partitioned
    
    k - number of subsets into which to partition elts
    
    Returns:
    
    a list of partitionings, where each contains exactly k subsets
  - partitionInto
```
public static <T> java.util.List<org.plumelib.util.ArraysPlume.Partitioning<T>> partitionInto(java.util.Queue<T> elts,
                                                                                              int k)
```
    Partition a set of elements into exactly k subsets. A partitioning is of type List<List<T>>, where the union of the inner lists is elts. This method returns a list of such partitionings.
    
    Type Parameters:
    
    T - type of items to be partitioned
    
    Parameters:
    
    elts - items to be partitioned
    
    k - number of subsets into which to partition elts
    
    Returns:
    
    a list of partitionings, where each contains exactly k subsets
  - partitionIntoHelper
```
public static <T> java.util.List<org.plumelib.util.ArraysPlume.Partitioning<T>> partitionIntoHelper(java.util.Queue<T> elts,
                                                                                                    java.util.List<org.plumelib.util.ArraysPlume.Partitioning<T>> resultSoFar,
                                                                                                    int numEmptyParts,
                                                                                                    int numNonemptyParts)
```
    Returns a set of partitionings, each of size numEmptyParts + numNonemptyParts. A helper method for partitionInto(java.util.Collection<T>, int).
    
    Type Parameters:
    
    T - type of items to be partitioned
    
    Parameters:
    
    elts - the elements that remain to be added to the partitionings
    
    resultSoFar - a list of partitionings, each of which has numNonemptyParts parts
    
    numEmptyParts - the number of partitions in the partitioning that are empty so far
    
    numNonemptyParts - the number of partitions in the partitioning that have at least one member so far
    
    Returns:
    
    a list of partitionings, where each contains exactly k subsets

Class ArraysPlume

Nested Class Summary

Method Summary

Methods inherited from class java.lang.Object

Method Detail

min

min

min

min

min

min

max

max

max

max

max

max

minAndMax

minAndMax

elementRange

elementRange

sum

sum

sum

sum

indexOf

indexOf

indexOf

indexOf

indexOfEq

indexOfEq

indexOfEq

indexOfEq

indexOf

indexOf

indexOf

indexOf

indexOf

indexOf

indexOf

indexOf

indexOfEq

indexOf

indexOfEq

indexOf

indexOfEq

indexOf

indexOfEq

indexOf

indexOf

indexOf

indexOf

subarray

subarray

subarray

subarray

subarray

subarray

subarray

subarray

subarray

subarray

subarray

isSubarray

isSubarrayEq

isSubarray

isSubarrayEq

isSubarray

isSubarrayEq

isSubarray

isSubarrayEq

isSubarray

isSubarray

isSubarray

isSubarray

concat

concat

concat

concat

concat