Util (chocosolver 0.1-SNAPSHOT API)

java.lang.Object
- org.clafer.common.Util

```
public class Util
extends Object
```
Various static utility functions.

Author:

jimmy

Method Summary

Methods
Modifier and Type	Method and Description
`static String`	`commaSeparate(Iterable<?> items)` Concatenate the string representation of the items with a comma separating each item.
`static <T> String`	`commaSeparate(T[] items)` Concatenate the string representation of the items with a comma separating each item.
`static <T> T[]`	`concat(T[][] arrays)` Concatenates all the arrays in the given order into one array.
`static int[]`	`cons(int item, int[] array)` Append the item at the start of the array.
`static <T> List<T>`	`cons(T head, List<? extends T> tail)` Functional-programming cons.
`static <T> T[]`	`cons(T item, T[] array)` Append the item at the start of the array.
`static <T> List<T>`	`dropUntil(T item, List<T> list)` Returns a sublist from the index of the item (inclusive) to the end of the list.
`static <T> boolean`	`endsWith(List<T> string, List<T> suffix)` Checks if the list ends with specific elements.
`static boolean`	`equals(Object a, Object b)` Check equality in a null-friendly fashion.
`static int[]`	`falses(boolean[] array)` Returns the position of all the `false` elements in the array.
`static int[]`	`fromTo(int from, int to)`
`static int`	`hashCode(Object o)` Compute a hash code in a null-friendly fashion.
`static boolean`	`in(int item, int[] array)` Check if the array contains the item at least once.
`static <T> boolean`	`in(T item, T[] array)` Check if the array contains the item at least once.
`static String`	`intercalate(String separator, Iterable<?> items)` Concatenate the string representation of the items with a separator separating each item.
`static <T> String`	`intercalate(String separator, T[] items)` Concatenate the string representation of the items with a separator separating each item.
`static boolean`	`isUnique(int[] array)` Check if every element in the array is unique.
`static <T> boolean`	`isUnique(T[] array)` Check if every element in the array is unique.
`static int[]`	`iterate(util.iterators.IntIterator iter)` Enumerate the iterator and return the values discovered.
`static int`	`max(int... array)`
`static int`	`max(gnu.trove.iterator.TIntIterator iter)`
`static int`	`min(int... array)`
`static int`	`min(gnu.trove.iterator.TIntIterator iter)`
`static int`	`permutation(int n, int r)`
`static <T> T[][]`	`permutations(T[] array, int choose)` Returns all permutations of picking a fixed number of distinct elements in the array.
`static int[]`	`range(int low, int high)`
`static <T> T[]`	`replicate(T item, int times)` Repeat the item.
`static void`	`reverse(int[] array)` Reverse an array in place.
`static void`	`reverse(int[] array, int to)` Reverse part of an array in place.
`static <T> void`	`reverse(T[] array)` Reverse an array in place.
`static <T> void`	`reverse(T[] array, int to)` Reverse part of an array in place.
`static <T> T[][]`	`sequence(T[][] arrays)` Returns all possibilities of picking one element in each array.
`static <T> T[][]`	`sequence(T[] array, int choose)` Returns all possibilities of picking a fixed number of elements in the array.
`static <T> void`	`shuffle(T[] array, Random rand)` Randomly shuffle an array in place.
`static int[]`	`snoc(int[] array, int item)` Append the item at the end of the array.
`static <T> List<T>`	`snoc(List<? extends T> head, T tail)` Functional-programming snoc.
`static <T> T[]`	`snoc(T[] array, T item)` Append the item at the end of the array.
`static <T> boolean`	`startsWith(List<T> string, List<T> prefix)` Checks if the list starts with specific elements.
`static int`	`sum(int... array)`
`static int`	`sum(gnu.trove.iterator.TIntIterator iter)`
`static <T> List<T>`	`takeUntil(T item, List<T> list)` Returns a sublist from index 0 to the index of the item (inclusive).
`static int[]`	`trues(boolean[] array)` Returns the position of all the `true` elements in the array.

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

- Method Detail
  - equals
```
public static boolean equals(Object a,
             Object b)
```
    Check equality in a null-friendly fashion.
    
    Parameters:
    a - an object
    b - an object to compare with a
    
    Returns:
    true if and only if a equals b, false otherwise
  - hashCode
```
public static int hashCode(Object o)
```
    Compute a hash code in a null-friendly fashion.
    
    Parameters:
    o - the object to compute the hash for
    
    Returns:
    the hash code of the object or 0 if null
  - permutation
```
public static int permutation(int n,
              int r)
```
  - range
```
public static int[] range(int low,
          int high)
```
    Parameters:
    low - the lowest integer in the range
    high - the highest integer in the range
    
    Returns:
    an array of all the values between low (inclusive) and high (inclusive) in order
  - fromTo
```
public static int[] fromTo(int from,
           int to)
```
    Parameters:
    from - the lowest integer in the range
    to - the integer after the highest integer in the range
    
    Returns:
    an array of all the values between from (inclusive) and to (exclusive) in order
  - trues
```
public static int[] trues(boolean[] array)
```
    Returns the position of all the true elements in the array. The positions are returned in sorted order.
    
    Parameters:
    array - the array
    
    Returns:
    the position of all the true elements
  - falses
```
public static int[] falses(boolean[] array)
```
    Returns the position of all the false elements in the array. The positions are returned in sorted order.
    
    Parameters:
    array - the array
    
    Returns:
    the position of all the false elements
  - shuffle
```
public static <T> void shuffle(T[] array,
               Random rand)
```
    Randomly shuffle an array in place.
    
    Parameters:
    array - the array to shuffle
    rand - the random number generator
  - reverse
```
public static void reverse(int[] array,
           int to)
```
    Reverse part of an array in place.
    
    Parameters:
    array - the array to reverse
    to - reverse from index 0 to here
  - reverse
```
public static void reverse(int[] array)
```
    Reverse an array in place.
    
    Parameters:
    array - the array to reverse
  - reverse
```
public static <T> void reverse(T[] array,
               int to)
```
    Reverse part of an array in place.
    
    Type Parameters:
    T - the type of the elements
    Parameters:
    array - the array to reverse
    to - reverse from index 0 to here
  - reverse
```
public static <T> void reverse(T[] array)
```
    Reverse an array in place.
    
    Type Parameters:
    T - the type of the elements
    Parameters:
    array - the array to reverse
  - in
```
public static boolean in(int item,
         int[] array)
```
    Check if the array contains the item at least once.
    
    Parameters:
    item - check if this item exists in the array
    array - the array that may contain the item
    
    Returns:
    true if and only if item is in array, false otherwise
  - in
```
public static <T> boolean in(T item,
             T[] array)
```
    Check if the array contains the item at least once.
    
    Type Parameters:
    T - the type of the elements
    Parameters:
    item - check if this item exists in the array
    array - the array that may contain the item
    
    Returns:
    true if and only if item is in array, false otherwise
  - isUnique
```
public static boolean isUnique(int[] array)
```
    Check if every element in the array is unique.
    
    Parameters:
    array - the array
    
    Returns:
    true if and only if the elements in the array never repeat, false otherwise
  - isUnique
```
public static <T> boolean isUnique(T[] array)
```
    Check if every element in the array is unique.
    
    Type Parameters:
    T - the type of the elements
    Parameters:
    array - the array
    
    Returns:
    true if and only if the elements in the array never repeat, false otherwise
  - cons
```
public static <T> List<T> cons(T head,
               List<? extends T> tail)
```
    Functional-programming cons. Nondestructive.
    
    Type Parameters:
    T - the type of the elements
    Parameters:
    head - the beginning of the new list
    tail - the end of the new list
    
    Returns:
    a copy of the original list with head appended at the start
  - snoc
```
public static <T> List<T> snoc(List<? extends T> head,
               T tail)
```
    Functional-programming snoc. Nondestructive.
    
    Type Parameters:
    T - the type of the elements
    Parameters:
    head - the beginning of the new list
    tail - the end of the new list
    
    Returns:
    a copy of the original list with tail appended at the end
  - cons
```
public static <T> T[] cons(T item,
           T[] array)
```
    Append the item at the start of the array. Nondestructive.
    
    Type Parameters:
    T - the type of the elements
    Parameters:
    item - the beginning of the new array
    array - the end of the new array
    
    Returns:
    a copy of the original array with item appended at the start
  - snoc
```
public static <T> T[] snoc(T[] array,
           T item)
```
    Append the item at the end of the array. Nondestructive.
    
    Type Parameters:
    T - the type of the elements
    Parameters:
    array - the beginning of the new array
    item - the end of the new array
    
    Returns:
    a copy of the original array with item appended at the end
  - cons
```
public static int[] cons(int item,
         int[] array)
```
    Append the item at the start of the array. Nondestructive.
    
    Parameters:
    item - the beginning of the new array
    array - the end of the new array
    
    Returns:
    a copy of the original array with item appended at the start
  - snoc
```
public static int[] snoc(int[] array,
         int item)
```
    Append the item at the end of the array. Nondestructive.
    
    Parameters:
    array - the beginning of the new array
    item - the end of the new array
    
    Returns:
    a copy of the original array with item appended at the end
  - concat
```
public static <T> T[] concat(T[][] arrays)
```
    Concatenates all the arrays in the given order into one array. Must be supplied at least one array. Nondestructive.
    
    Type Parameters:
    T - the type of the elements
    Parameters:
    arrays - the array of arrays
    
    Returns:
    the concatenation of all the arrays
  - replicate
```
public static <T> T[] replicate(T item,
                int times)
```
    Repeat the item.
    
    Type Parameters:
    T - the type of the item
    Parameters:
    item - the item
    times - the number of times to repeat
    
    Returns:
    an array containing only the item
  - permutations
```
public static <T> T[][] permutations(T[] array,
                     int choose)
```
    Returns all permutations of picking a fixed number of distinct elements in the array.
    
    Type Parameters:
    T - the type of the elements
    Parameters:
    array - the array
    choose - the number of elements to pick
    
    Returns:
    the permutations
  - sequence
```
public static <T> T[][] sequence(T[] array,
                 int choose)
```
    Returns all possibilities of picking a fixed number of elements in the array.
    
    Type Parameters:
    T - the type of the elements
    Parameters:
    array - the array
    choose - the number of elements to pick
    
    Returns:
    the sequence
  - sequence
```
public static <T> T[][] sequence(T[][] arrays)
```
    Returns all possibilities of picking one element in each array. Similar to Haskell's sequence for lists, except for edge cases.
    
    Type Parameters:
    T - the type of the elements
    Parameters:
    arrays - the arrays
    
    Returns:
    the sequence
  - takeUntil
```
public static <T> List<T> takeUntil(T item,
                    List<T> list)
```
    Returns a sublist from index 0 to the index of the item (inclusive). Equivalent to the Haskell code takeWhile (== item) list
    
    Type Parameters:
    T - the element type
    Parameters:
    item - the item to find
    list - the list of items
    
    Returns:
    a prefix of the list ending at the first item if found, otherwise the entire list
  - dropUntil
```
public static <T> List<T> dropUntil(T item,
                    List<T> list)
```
    Returns a sublist from the index of the item (inclusive) to the end of the list. Equivalent to the Haskell code dropWhile (/= item) list
    
    Type Parameters:
    T - the element type
    Parameters:
    item - the item to find
    list - the list of items
    
    Returns:
    a suffix of the list starting at the first item if found, otherwise the entire list
  - startsWith
```
public static <T> boolean startsWith(List<T> string,
                     List<T> prefix)
```
    Checks if the list starts with specific elements.
    
    Type Parameters:
    T - the element type
    Parameters:
    string - the list
    prefix - the starting elements of the list
    
    Returns:
    true if and only if string starts with prefix, false otherwise
  - endsWith
```
public static <T> boolean endsWith(List<T> string,
                   List<T> suffix)
```
    Checks if the list ends with specific elements.
    
    Type Parameters:
    T - the element type
    Parameters:
    string - the list
    suffix - the ending elements of the list
    
    Returns:
    true if and only if string ends with suffix, false otherwise
  - sum
```
public static int sum(int... array)
```
    Parameters:
    array - an array of integers
    
    Returns:
    the sum of the integers in the array
  - sum
```
public static int sum(gnu.trove.iterator.TIntIterator iter)
```
    Parameters:
    iter - an iterator of integers
    
    Returns:
    the sum of the integers in the iterator
  - min
```
public static int min(int... array)
```
    Parameters:
    array - an array of integers
    
    Returns:
    the minimum integer in the array
  - min
```
public static int min(gnu.trove.iterator.TIntIterator iter)
```
    Parameters:
    iter - an iterator of integers
    
    Returns:
    the minimum integer in the iterator
  - max
```
public static int max(int... array)
```
    Parameters:
    array - an array of integers
    
    Returns:
    the maximum integer in the array
  - max
```
public static int max(gnu.trove.iterator.TIntIterator iter)
```
    Parameters:
    iter - an iterator of integers
    
    Returns:
    the maximum integer in the iterator
  - iterate
```
public static int[] iterate(util.iterators.IntIterator iter)
```
    Enumerate the iterator and return the values discovered. The iterator is exhausted on return.
    
    Parameters:
    iter - an iterator
    
    Returns:
    the values found in the iterator
  - commaSeparate
```
public static <T> String commaSeparate(T[] items)
```
    Concatenate the string representation of the items with a comma separating each item.
    
    Type Parameters:
    T - the type of the elements
    Parameters:
    items - the items to display
    
    Returns:
    the items string form separated by commas
  - commaSeparate
```
public static String commaSeparate(Iterable<?> items)
```
    Concatenate the string representation of the items with a comma separating each item.
    
    Parameters:
    items - the items to display
    
    Returns:
    the items string form separated by commas
  - intercalate
```
public static <T> String intercalate(String separator,
                     T[] items)
```
    Concatenate the string representation of the items with a separator separating each item.
    
    Type Parameters:
    T - the type of the elements
    Parameters:
    separator - the string to separate each item
    items - the items to display
    
    Returns:
    the items string form separated by the separator
  - intercalate
```
public static String intercalate(String separator,
                 Iterable<?> items)
```
    Concatenate the string representation of the items with a separator separating each item.
    
    Parameters:
    separator - the string to separate each item
    items - the items to display
    
    Returns:
    the items string form separated by the separator

Class Util

Method Summary

Methods inherited from class java.lang.Object

Method Detail

equals

hashCode

permutation

range

fromTo

trues

falses

shuffle

reverse

reverse

reverse

reverse

in

in

isUnique

isUnique

cons

snoc

cons

snoc

cons

snoc

concat

replicate

permutations

sequence

sequence

takeUntil

dropUntil

startsWith

endsWith

sum

sum

min

min

max

max

iterate

commaSeparate

commaSeparate

intercalate

intercalate