IntUtils (Net2Plan API)

Object
- com.net2plan.utils.IntUtils

```
public class IntUtils
extends Object
```
Provides extra functionality for int primitives.

Since:

0.2.0

Author:

Pablo Pavon-Marino, Jose-Luis Izquierdo-Zaragoza

Constructor Summary

Constructors
Constructor and Description

IntUtils()

Constructors
Constructor and Description
`IntUtils()`

Method Summary

Methods
Modifier and Type	Method and Description
`static Integer[]`	`asObjectArray(int[] array)` Converts from an `int` array to an `Integer` array.
`static int[]`	`asPrimitiveArray(Integer[] array)` Converts from an `Integer` array to an `int` array.
`static double`	`average(int[] array)`
`static int[]`	`concatenate(int[]... arrays)`
`static boolean`	`contains(int[] array, int value)` Checks if an input array contains a given value
`static boolean`	`containsAll(int[] array1, int[] array2)`
`static boolean`	`containsAny(int[] array1, int[] array2)` Checks whether any element of an array is present in another.
`static int[]`	`copy(int[] array)` Returns a deep copy of the input `array`.
`static int[]`	`divide(int[] array1, int[] array2)` Divides two arrays element-to-element.
`static int[]`	`divideNonSingular(int[] array1, int[] array2)` Divides two arrays element-to-element, but when numerator and denominator = 0, returns 0 instead of a singularity (NaN)
`static int[]`	`find(int[] array, int value, Constants.SearchType searchType)`
`static int`	`gcd(int[] array)` Computes the greatest absolute common divisor of an integer array.
`static int[]`	`intersect(int[]... arrays)` Returns the intersection vector of a series of input arrays.
`static String`	`join(int[] array, String separator)` Joins the elements in an input array using a given separator.
`static int[]`	`maxIndexes(int[] array, Constants.SearchType searchType)`
`static int[][]`	`maxMinIndexes(int[] array, Constants.SearchType searchType)`
`static int[]`	`maxMinValues(int[] array)`
`static int`	`maxValue(int[] array)`
`static int`	`maxValue(int[][] array)`
`static int[]`	`minIndexes(int[] array, Constants.SearchType searchType)`
`static int`	`minValue(int[] array)`
`static int[]`	`mult(int[] array, int scalar)`
`static int[]`	`mult(int[] array1, int[] array2)`
`static int[]`	`ones(int N)` Returns an array filled with ones.
`static void`	`reverse(int[] array)`
`static int[]`	`select(int[] array, int[] indexes)`
`static int[]`	`setdiff(int[]... arrays)`
`static void`	`sort(int[] array, Constants.OrderingType orderingType)`
`static int[]`	`sortIndexes(int[] array, Constants.OrderingType orderingType)` Sorts indexes of the `array` into ascending/descending order in a stable way.
`static int[]`	`substract(int[] array1, int[] array2)`
`static double`	`sum(int[] array)`
`static int[]`	`sum(int[] array1, int[] array2)`
`static int[]`	`toArray(Collection<Integer> list)` Converts a collection (`List`, `Set`...) of `Integer` objects to a `int` array.
`static double[]`	`toDoubleArray(int[] array)`
`static List<Integer>`	`toList(int[] array)` Converts from a `int` array to a list.
`static int[]`	`union(int[]... arrays)`
`static int[]`	`unique(int[] array)` Returns the same values of the input `array` but with no repetitions.
`static int[]`	`zeros(int N)` Returns an array filled with zeros.

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

- Constructor Detail
  - IntUtils
```
public IntUtils()
```
- Method Detail
  - average
```
public static double average(int[] array)
```
  - asObjectArray
```
public static Integer[] asObjectArray(int[] array)
```
    Converts from an int array to an Integer array.
    
    Parameters:
    array - int array
    
    Returns:
    Equivalent Integer array
  - asPrimitiveArray
```
public static int[] asPrimitiveArray(Integer[] array)
```
    Converts from an Integer array to an int array.
    
    Parameters:
    array - Integer array
    
    Returns:
    Equivalent int array
  - contains
```
public static boolean contains(int[] array,
               int value)
```
    Checks if an input array contains a given value
    
    Parameters:
    array - Input array
    value - Value to search
    
    Returns:
    true if value is present in array, and false otherwise
  - containsAll
```
public static boolean containsAll(int[] array1,
                  int[] array2)
```
  - containsAny
```
public static boolean containsAny(int[] array1,
                  int[] array2)
```
    Checks whether any element of an array is present in another. It is equivalent to assert if intersection(array1, array2).length == 0.
    
    Parameters:
    array1 - Input array 1
    array2 - Input array 2
    
    Returns:
    true if any number in array1 is present in array2, and false otherwise
  - copy
```
public static int[] copy(int[] array)
```
    Returns a deep copy of the input array.
    
    Parameters:
    array - Input array
    
    Returns:
    Deep copy of array
    Since:
    
    0.2.0
  - find
```
public static int[] find(int[] array,
         int value,
         Constants.SearchType searchType)
```
  - gcd
```
public static int gcd(int[] array)
```
    Computes the greatest absolute common divisor of an integer array.
    
    Parameters:
    array - Input array
    
    Returns:
    The greatest absolute common divisor. By convention, gcd(0, 0) is equal to zero and gcd([]) is equal to one
    Since:
    
    0.2.0
  - intersect
```
public static int[] intersect(int[]... arrays)
```
    Returns the intersection vector of a series of input arrays. There is no order guarantee.
    
    Parameters:
    arrays - Vector of input arrays
    
    Returns:
    Intersection vector of input arrays
    Since:
    
    0.2.0
  - toDoubleArray
```
public static double[] toDoubleArray(int[] array)
```
  - join
```
public static String join(int[] array,
          String separator)
```
    Joins the elements in an input array using a given separator. It is an improved version of Arrays.toString().
    
    Parameters:
    array - Input array
    separator - Separator
    
    Returns:
    String representation of the input array
    Since:
    
    0.2.0
  - maxValue
```
public static int maxValue(int[] array)
```
    Parameters:
    array -
    
    Returns:
  - maxValue
```
public static int maxValue(int[][] array)
```
  - maxIndexes
```
public static int[] maxIndexes(int[] array,
               Constants.SearchType searchType)
```
    Parameters:
    array -
    searchType -
    
    Returns:
  - maxMinValues
```
public static int[] maxMinValues(int[] array)
```
    Parameters:
    array -
    
    Returns:
  - maxMinIndexes
```
public static int[][] maxMinIndexes(int[] array,
                    Constants.SearchType searchType)
```
    Parameters:
    array -
    searchType -
    
    Returns:
  - minValue
```
public static int minValue(int[] array)
```
    Parameters:
    array -
    
    Returns:
  - minIndexes
```
public static int[] minIndexes(int[] array,
               Constants.SearchType searchType)
```
    Parameters:
    array -
    searchType -
    
    Returns:
  - ones
```
public static int[] ones(int N)
```
    Returns an array filled with ones.
    
    Parameters:
    N - Number of elements
    
    Returns:
    A one-array of length N
    Since:
    
    0.2.0
  - reverse
```
public static void reverse(int[] array)
```
  - select
```
public static int[] select(int[] array,
           int[] indexes)
```
  - setdiff
```
public static int[] setdiff(int[]... arrays)
```
    Parameters:
    arrays -
    
    Returns:
  - sort
```
public static void sort(int[] array,
        Constants.OrderingType orderingType)
```
    Parameters:
    array -
    orderingType -
  - sortIndexes
```
public static int[] sortIndexes(int[] array,
                Constants.OrderingType orderingType)
```
    Sorts indexes of the array into ascending/descending order in a stable way. Stable means that index order doesn't change if values are the same.
    
    Parameters:
    array - Array to be sorted
    orderingType -
    
    Returns:
    Sorted indexes
    Since:
    
    0.2.0
  - toArray
```
public static int[] toArray(Collection<Integer> list)
```
    Converts a collection (List, Set...) of Integer objects to a int array.
    
    Parameters:
    list - Input list
    
    Returns:
    int array
    Since:
    
    0.2.0
  - toList
```
public static List<Integer> toList(int[] array)
```
    Converts from a int array to a list.
    
    Parameters:
    array - Input array
    
    Returns:
    A list of Integer objects
    Since:
    
    0.2.0
  - concatenate
```
public static int[] concatenate(int[]... arrays)
```
  - union
```
public static int[] union(int[]... arrays)
```
    Parameters:
    arrays -
    
    Returns:
  - unique
```
public static int[] unique(int[] array)
```
    Returns the same values of the input array but with no repetitions. There is no order guarantee.
    
    Parameters:
    array - Input double array
    
    Returns:
    Same values as in array but with no repetitions
    Since:
    
    0.2.0
  - zeros
```
public static int[] zeros(int N)
```
    Returns an array filled with zeros.
    
    Parameters:
    N - Number of elements
    
    Returns:
    A zero-array of length N
    Since:
    
    0.2.0
  - sum
```
public static double sum(int[] array)
```
  - sum
```
public static int[] sum(int[] array1,
        int[] array2)
```
  - mult
```
public static int[] mult(int[] array,
         int scalar)
```
  - mult
```
public static int[] mult(int[] array1,
         int[] array2)
```
  - substract
```
public static int[] substract(int[] array1,
              int[] array2)
```
  - divide
```
public static int[] divide(int[] array1,
           int[] array2)
```
    Divides two arrays element-to-element.
    
    Parameters:
    array1 - Numerator
    array2 - Denominator
    
    Returns:
    The element-wise division of the input arrays
  - divideNonSingular
```
public static int[] divideNonSingular(int[] array1,
                      int[] array2)
```
    Divides two arrays element-to-element, but when numerator and denominator = 0, returns 0 instead of a singularity (NaN)
    
    Parameters:
    array1 - Numerator
    array2 - Denominator
    
    Returns:
    The element-wise division of the input arrays

Class IntUtils

Constructor Summary

Method Summary

Methods inherited from class Object

Constructor Detail

IntUtils

Method Detail

average

asObjectArray

asPrimitiveArray

contains

containsAll

containsAny

copy

find

gcd

intersect

toDoubleArray

join

maxValue

maxValue

maxIndexes

maxMinValues

maxMinIndexes

minValue

minIndexes

ones

reverse

select

setdiff

sort

sortIndexes

toArray

toList

concatenate

union

unique

zeros

sum

sum

mult

mult

substract

divide

divideNonSingular