DoubleUtils (Net2Plan API)

Object
- com.net2plan.utils.DoubleUtils

```
public class DoubleUtils
extends Object
```
Provides extra functionality for double primitives.

Since:

0.2.0

Author:

Pablo Pavon-Marino, Jose-Luis Izquierdo-Zaragoza

Constructor Summary

Constructors
Constructor and Description

DoubleUtils()

Constructors
Constructor and Description
`DoubleUtils()`

Method Summary

Methods
Modifier and Type	Method and Description
`static Double[]`	`asObjectArray(double[] array)` Converts from a `double` array to a `Double` array.
`static double[]`	`asPrimitiveArray(Double[] array)` Converts from a `Double` array to a `double` array.
`static double`	`average(double[] array)`
`static double`	`averageNonZeros(double[] array)`
`static double[]`	`concatenate(double[]... arrays)`
`static boolean`	`contains(double[] array, double value)` Checks if an input array contains a given value
`static boolean`	`containsAny(double[] array1, double[] array2)` Checks whether any element of an array is present in another.
`static double[]`	`copy(double[] array)` Returns a deep copy of the input `array`.
`static double[]`	`divide(double[] array, double value)`
`static double[]`	`divide(double[] array1, double[] array2)` Divides two arrays element-to-element
`static double[]`	`divideNonSingular(double[] array1, double[] array2)` Divides two arrays element-to-element, but when numerator and denominator = 0, returns 0 instead of a singularity (NaN)
`static int[]`	`find(double[] array, double value, Constants.SearchType searchType)`
`static double`	`gcd(double[] array)` Computes the greatest common divisor of a double array.
`static double[]`	`intersect(double[]... arrays)` Returns the intersection vector of a series of input arrays.
`static boolean`	`isEqualWithinAbsoluteTolerance(double pattern, double value, double tolerance)` Checks if a given value is within a tolerance margin compared to a given pattern.
`static boolean`	`isEqualWithinRelativeTolerance(double pattern, double value, double tolerance)` Checks if the relative difference between a given value and a pattern is within a tolerance margin.
`static String`	`join(double[] array, String separator)` Joins the elements in an input array using a given separator.
`static int[]`	`maxIndexes(double[] array, Constants.SearchType searchType)`
`static int[][]`	`maxMinIndexes(double[] array, Constants.SearchType searchType)`
`static double[]`	`maxMinValues(double[] array)`
`static double`	`maxValue(double[] array)`
`static int[]`	`minIndexes(double[] array, Constants.SearchType searchType)`
`static double`	`minValue(double[] array)`
`static double[]`	`mult(double[] array, double scalar)`
`static double[]`	`mult(double[] array1, double[] array2)`
`static double[]`	`ones(int N)` Returns an array filled with zeros.
`static void`	`reverse(double[] array)`
`static double[]`	`select(double[] array, int[] indexes)`
`static double[]`	`selectColumn(double[][] array, int column)`
`static double[]`	`selectRow(double[][] array, int row)`
`static double[]`	`setdiff(double[]... arrays)`
`static void`	`sort(double[] array, Constants.OrderingType orderingType)`
`static int[]`	`sortIndexes(double[] array, Constants.OrderingType orderingType)` Sorts indexes of the `array` into ascending/descending order in a stable way.
`static double`	`std(double[] array)`
`static double[]`	`substract(double[] array1, double[] array2)`
`static double`	`sum(double[] array)`
`static double[]`	`sum(double[] array1, double[] array2)`
`static double[]`	`toArray(Collection<Double> list)` Converts a collection (`List`, `Set`...) of `Double` objects to a `double` array.
`static int[]`	`toIntArray(double[] array)`
`static List<Double>`	`toList(double[] array)` Converts from a `double` array to a list.
`static double[]`	`union(double[]... arrays)`
`static double[]`	`unique(double[] array)` Returns the same values of the input `array` but with no repetitions.
`static double[]`	`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
  - DoubleUtils
```
public DoubleUtils()
```
- Method Detail
  - concatenate
```
public static double[] concatenate(double[]... arrays)
```
  - std
```
public static double std(double[] array)
```
  - averageNonZeros
```
public static double averageNonZeros(double[] array)
```
  - average
```
public static double average(double[] array)
```
  - asObjectArray
```
public static Double[] asObjectArray(double[] array)
```
    Converts from a double array to a Double array.
    
    Parameters:
    array - double array
    
    Returns:
    Equivalent Double array
  - asPrimitiveArray
```
public static double[] asPrimitiveArray(Double[] array)
```
    Converts from a Double array to a double array.
    
    Parameters:
    array - Double array
    
    Returns:
    Equivalent double array
  - contains
```
public static boolean contains(double[] array,
               double 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
  - containsAny
```
public static boolean containsAny(double[] array1,
                  double[] 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 double[] copy(double[] 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(double[] array,
         double value,
         Constants.SearchType searchType)
```
  - gcd
```
public static double gcd(double[] array)
```
    Computes the greatest common divisor of a double array.
    
    Parameters:
    array - Input array
    
    Returns:
    The greatest common divisor. By convention, gcd(0, 0) is equal to zero and gcd([]) is equal to one
    Since:
    
    0.2.0
  - intersect
```
public static double[] intersect(double[]... 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
  - isEqualWithinAbsoluteTolerance
```
public static boolean isEqualWithinAbsoluteTolerance(double pattern,
                                     double value,
                                     double tolerance)
```
    Checks if a given value is within a tolerance margin compared to a given pattern.
    
    Parameters:
    pattern - Pattern value
    value - Value to compare with pattern
    tolerance - Tolerance margin
    
    Returns:
    true if value is within the tolerance, and false otherwise
    Since:
    
    0.2.0
  - isEqualWithinRelativeTolerance
```
public static boolean isEqualWithinRelativeTolerance(double pattern,
                                     double value,
                                     double tolerance)
```
    Checks if the relative difference between a given value and a pattern is within a tolerance margin.
    
    Parameters:
    pattern - Pattern value
    value - Value to compare with pattern
    tolerance - Tolerance margin
    
    Returns:
    true if value is within the tolerance, and false otherwise
    Since:
    
    0.2.0
  - join
```
public static String join(double[] 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 double maxValue(double[] array)
```
    Parameters:
    array -
    
    Returns:
  - maxIndexes
```
public static int[] maxIndexes(double[] array,
               Constants.SearchType searchType)
```
    Parameters:
    array -
    searchType -
    
    Returns:
  - maxMinValues
```
public static double[] maxMinValues(double[] array)
```
    Parameters:
    array -
    
    Returns:
  - maxMinIndexes
```
public static int[][] maxMinIndexes(double[] array,
                    Constants.SearchType searchType)
```
    Parameters:
    array -
    searchType -
    
    Returns:
  - minValue
```
public static double minValue(double[] array)
```
    Parameters:
    array -
    
    Returns:
  - minIndexes
```
public static int[] minIndexes(double[] array,
               Constants.SearchType searchType)
```
    Parameters:
    array -
    searchType -
    
    Returns:
  - ones
```
public static double[] ones(int N)
```
    Returns an array filled with zeros.
    
    Parameters:
    N - Number of elements
    
    Returns:
    A zero-array of length N
    Since:
    
    0.2.0
  - reverse
```
public static void reverse(double[] array)
```
    Parameters:
    array -
  - select
```
public static double[] select(double[] array,
              int[] indexes)
```
  - selectColumn
```
public static double[] selectColumn(double[][] array,
                    int column)
```
  - selectRow
```
public static double[] selectRow(double[][] array,
                 int row)
```
  - setdiff
```
public static double[] setdiff(double[]... arrays)
```
    Parameters:
    arrays -
    
    Returns:
  - sort
```
public static void sort(double[] array,
        Constants.OrderingType orderingType)
```
    Parameters:
    array -
    orderingType -
  - sortIndexes
```
public static int[] sortIndexes(double[] 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 double[] toArray(Collection<Double> list)
```
    Converts a collection (List, Set...) of Double objects to a double array.
    
    Parameters:
    list - Input list
    
    Returns:
    int array
    Since:
    
    0.2.0
  - toList
```
public static List<Double> toList(double[] array)
```
    Converts from a double array to a list.
    
    Parameters:
    array - Input array
    
    Returns:
    A list of Double objects
    Since:
    
    0.2.0
  - union
```
public static double[] union(double[]... arrays)
```
    Parameters:
    arrays -
    
    Returns:
  - unique
```
public static double[] unique(double[] 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 double[] 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
  - toIntArray
```
public static int[] toIntArray(double[] array)
```
  - sum
```
public static double sum(double[] array)
```
  - sum
```
public static double[] sum(double[] array1,
           double[] array2)
```
  - mult
```
public static double[] mult(double[] array,
            double scalar)
```
  - mult
```
public static double[] mult(double[] array1,
            double[] array2)
```
  - substract
```
public static double[] substract(double[] array1,
                 double[] array2)
```
  - divide
```
public static double[] divide(double[] array1,
              double[] array2)
```
    Divides two arrays element-to-element
    
    Parameters:
    array1 - Numerator
    array2 - Denominator
    
    Returns:
    The element-wise division of the input arrays
  - divide
```
public static double[] divide(double[] array,
              double value)
```
  - divideNonSingular
```
public static double[] divideNonSingular(double[] array1,
                         double[] 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 DoubleUtils

Constructor Summary

Method Summary

Methods inherited from class Object

Constructor Detail

DoubleUtils

Method Detail

concatenate

std

averageNonZeros

average

asObjectArray

asPrimitiveArray

contains

containsAny

copy

find

gcd

intersect

isEqualWithinAbsoluteTolerance

isEqualWithinRelativeTolerance

join

maxValue

maxIndexes

maxMinValues

maxMinIndexes

minValue

minIndexes

ones

reverse

select

selectColumn

selectRow

setdiff

sort

sortIndexes

toArray

toList

union

unique

zeros

toIntArray

sum

sum

mult

mult

substract

divide

divide

divideNonSingular