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)` Returns the average value of an array.
`static double`	`averageNonZeros(int[] array)` Returns the average value only among non-zero values
`static int[]`	`concatenate(int[]... arrays)` Concatenates a series of arrays.
`static boolean`	`contains(int[] array, int value)` Checks if an input array contains a given value
`static boolean`	`containsAll(int[] array1, int[] array2)` Checks if an array contains all numbers from another.
`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[] array, int value)` Divides all elements in an array by a scalar.
`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)` Returns the position(s) where a given value can be found into an array.
`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)` Returns the position(s) in which the maximum value is found.
`static int[][]`	`maxMinIndexes(int[] array, Constants.SearchType searchType)` Returns the position(s) in which the maximum/minimum values are found.
`static int[]`	`maxMinValues(int[] array)` Returns the maximum/minimum values of an input array.
`static int`	`maxValue(int[] array)` Returns the maximum value in the input array.
`static int`	`maxValue(int[][] array)` Returns the maximum value in the input array.
`static int[]`	`minIndexes(int[] array, Constants.SearchType searchType)` Returns the position(s) in which the minimum value is found.
`static int`	`minValue(int[] array)` Returns the minimum value in the input array.
`static int[]`	`mult(int[] array, int value)` Multiplies all elements in an array by a scalar.
`static int[]`	`mult(int[] array1, int[] array2)` Multiplies two arrays element-to-element.
`static int[]`	`ones(int N)` Returns an array filled with ones.
`static void`	`reverse(int[] array)` Reverses the order of the elements of the input array (it will be overriden).
`static int[]`	`select(int[] array, int[] indexes)` Returns a set of selected elements from an input array.
`static int[]`	`selectColumn(int[][] array, int column)` Returns a column of a bidimensional input array.
`static int[]`	`selectRow(int[][] array, int row)` Returns a row of a bidimensional input array.
`static int[]`	`setdiff(int[]... arrays)` Returns the elements contained in the first array, but not any of the others.
`static void`	`sort(int[] array, Constants.OrderingType orderingType)` Sorts the input array (it will be overriden).
`static int[]`	`sortIndexes(int[] array, Constants.OrderingType orderingType)` Sorts indexes of the `array` into ascending/descending order in a stable way.
`static double`	`std(int[] array)` Returns the standard deviation of an array.
`static int[]`	`substract(int[] array1, int[] array2)` Returns the element-wise substraction of two arrays.
`static double`	`sum(int[] array)` Returns the sum of all elements in the array.
`static int[]`	`sum(int[] array1, int[] array2)` Returns the element-wise sum of two arrays.
`static int[]`	`toArray(Collection<Integer> list)` Converts a collection (`List`, `Set`...) of `Integer` objects to a `int` array.
`static double[]`	`toDoubleArray(int[] array)` Converts an `int` array to a `double` array
`static List<Integer>`	`toList(int[] array)` Converts from a `int` array to a list.
`static int[]`	`union(int[]... arrays)` Returns an array with all elements in input arrays (no repetitions).
`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)
```
    Returns the average value of an array.
    
    Parameters:
    array - Input array
    
    Returns:
    Average value
    Since:
    
    0.2.0
  - averageNonZeros
```
public static double averageNonZeros(int[] array)
```
    Returns the average value only among non-zero values
    
    Parameters:
    array - Input array
    
    Returns:
    Average value among non-zero values
    Since:
    
    0.2.0
  - asObjectArray
```
public static Integer[] asObjectArray(int[] array)
```
    Converts from an int array to an Integer array.
    
    Parameters:
    array - int array
    
    Returns:
    Equivalent Integer array
    Since:
    
    0.2.0
  - asPrimitiveArray
```
public static int[] asPrimitiveArray(Integer[] array)
```
    Converts from an Integer array to an int array.
    
    Parameters:
    array - Integer array
    
    Returns:
    Equivalent int array
    Since:
    
    0.2.0
  - 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
    Since:
    
    0.2.0
  - containsAll
```
public static boolean containsAll(int[] array1,
                  int[] array2)
```
    Checks if an array contains all numbers from another.
    
    Parameters:
    array1 - Container array
    array2 - Array with elements to be checked
    
    Returns:
    true if value is present in array, and false otherwise
    Since:
    
    0.2.0
  - 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 - Container array
    array2 - Array with elements to be checked
    
    Returns:
    true if any number in array1 is present in array2, and false otherwise
    Since:
    
    0.2.0
  - 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)
```
    Returns the position(s) where a given value can be found into an array.
    
    Parameters:
    array - Input array
    value - Value to be searched for
    searchType - Indicates whether the first, the last, or all minimum positions are returned
    
    Returns:
    Position(s) in which the minimum value is found
    Since:
    
    0.2.0
  - 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)
```
    Converts an int array to a double array
    
    Parameters:
    array - Input array
    
    Returns:
    double array
    Since:
    
    0.2.0
  - 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)
```
    Returns the maximum value in the input array.
    
    Parameters:
    array - Input array
    
    Returns:
    Maximum value
    Since:
    
    0.2.0
  - maxValue
```
public static int maxValue(int[][] array)
```
    Returns the maximum value in the input array.
    
    Parameters:
    array - Input array
    
    Returns:
    Maximum value
    Since:
    
    0.2.0
  - maxIndexes
```
public static int[] maxIndexes(int[] array,
               Constants.SearchType searchType)
```
    Returns the position(s) in which the maximum value is found.
    
    Parameters:
    array - Input array
    searchType - Indicates whether the first, the last, or all maximum positions are returned
    
    Returns:
    Position(s) in which the maximum value is found
    Since:
    
    0.2.0
  - maxMinValues
```
public static int[] maxMinValues(int[] array)
```
    Returns the maximum/minimum values of an input array.
    
    Parameters:
    array - Input array
    
    Returns:
    Maximum/minimum values
    Since:
    
    0.2.0
  - maxMinIndexes
```
public static int[][] maxMinIndexes(int[] array,
                    Constants.SearchType searchType)
```
    Returns the position(s) in which the maximum/minimum values are found.
    
    out[0] are the maximum positions, while out[1] are the minimum positions
    
    Parameters:
    array - Input array
    searchType - Indicates whether the first, the last, or all maximum positions are returned
    
    Returns:
    Position(s) in which the maximum/minimum value are found.
    Since:
    
    0.2.0
  - minValue
```
public static int minValue(int[] array)
```
    Returns the minimum value in the input array.
    
    Parameters:
    array - Input array
    
    Returns:
    Minimum value
    Since:
    
    0.2.0
  - minIndexes
```
public static int[] minIndexes(int[] array,
               Constants.SearchType searchType)
```
    Returns the position(s) in which the minimum value is found.
    
    Parameters:
    array - Input array
    searchType - Indicates whether the first, the last, or all minimum positions are returned
    
    Returns:
    Position(s) in which the minimum value is found
    Since:
    
    0.2.0
  - 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
  - std
```
public static double std(int[] array)
```
    Returns the standard deviation of an array.
    
    Parameters:
    array - Input array
    
    Returns:
    Standard deviation
    Since:
    
    0.2.0
  - reverse
```
public static void reverse(int[] array)
```
    Reverses the order of the elements of the input array (it will be overriden).
    
    Parameters:
    array - Input array
    Since:
    
    0.2.0
  - selectColumn
```
public static int[] selectColumn(int[][] array,
                 int column)
```
    Returns a column of a bidimensional input array.
    
    Parameters:
    array - Input array
    column - Column
    
    Returns:
    Column of an array
    Since:
    
    0.2.0
  - selectRow
```
public static int[] selectRow(int[][] array,
              int row)
```
    Returns a row of a bidimensional input array.
    
    Parameters:
    array - Input array
    row - Row
    
    Returns:
    Row of an array
    Since:
    
    0.2.0
  - select
```
public static int[] select(int[] array,
           int[] indexes)
```
    Returns a set of selected elements from an input array. It is not backed in the input array, thus changes in this array are not reflected in the input array.
    
    Parameters:
    array - Input array
    indexes - Position of elements to be selected.
    
    Returns:
    Set of elements in the order given by indexes
    Since:
    
    0.2.0
  - setdiff
```
public static int[] setdiff(int[]... arrays)
```
    Returns the elements contained in the first array, but not any of the others.
    
    Parameters:
    arrays - Input arrays
    
    Returns:
    Difference set
    Since:
    
    0.2.0
  - sort
```
public static void sort(int[] array,
        Constants.OrderingType orderingType)
```
    Sorts the input array (it will be overriden).
    
    Parameters:
    array - Input array
    orderingType - Ascending or descending
    Since:
    
    0.2.0
  - 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 - Ascending or descending
    
    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)
```
    Concatenates a series of arrays.
    
    Parameters:
    arrays - List of arrays
    
    Returns:
    Concatenated array
    Since:
    
    0.2.0
  - union
```
public static int[] union(int[]... arrays)
```
    Returns an array with all elements in input arrays (no repetitions). There is no order guarantee.
    
    Parameters:
    arrays - Input arrays
    
    Returns:
    A new array with all elements in input arrays
    Since:
    
    0.2.0
  - 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 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)
```
    Returns the sum of all elements in the array.
    
    Parameters:
    array - Input array
    
    Returns:
    Sum of all array elements
    Since:
    
    0.2.0
  - sum
```
public static int[] sum(int[] array1,
        int[] array2)
```
    Returns the element-wise sum of two arrays.
    
    Parameters:
    array1 - Input array 1
    array2 - Input array 2
    
    Returns:
    A new array with the element-wise sum
    Since:
    
    0.2.0
  - mult
```
public static int[] mult(int[] array,
         int value)
```
    Multiplies all elements in an array by a scalar.
    
    Parameters:
    array - Input array
    value - Scalar
    
    Returns:
    A new array containing the input elements multiplied by the scalar
    Since:
    
    0.2.0
  - mult
```
public static int[] mult(int[] array1,
         int[] array2)
```
    Multiplies two arrays element-to-element.
    
    Parameters:
    array1 - Input array 1
    array2 - Input array 2
    
    Returns:
    The element-wise multiplication of the input arrays
    Since:
    
    0.2.0
  - substract
```
public static int[] substract(int[] array1,
              int[] array2)
```
    Returns the element-wise substraction of two arrays.
    
    Parameters:
    array1 - Input array 1
    array2 - Input array 2
    
    Returns:
    A new array with the element-wise subtraction
    Since:
    
    0.2.0
  - divide
```
public static int[] divide(int[] array,
           int value)
```
    Divides all elements in an array by a scalar.
    
    Parameters:
    array - Input array
    value - Scalar
    
    Returns:
    A new array containing the input elements divided by the scalar
    Since:
    
    0.2.0
  - 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
    Since:
    
    0.2.0
  - 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
    Since:
    
    0.2.0

Class IntUtils

Constructor Summary

Method Summary

Methods inherited from class Object

Constructor Detail

IntUtils

Method Detail

average

averageNonZeros

asObjectArray

asPrimitiveArray

contains

containsAll

containsAny

copy

find

gcd

intersect

toDoubleArray

join

maxValue

maxValue

maxIndexes

maxMinValues

maxMinIndexes

minValue

minIndexes

ones

std

reverse

selectColumn

selectRow

select

setdiff

sort

sortIndexes

toArray

toList

concatenate

union

unique

zeros

sum

sum

mult

mult

substract

divide

divide

divideNonSingular