DoubleUtils (SuanShuExtension API)

java.lang.Object
- com.numericalmethod.suanshu.number.DoubleUtils

```
public class DoubleUtils
extends java.lang.Object
```
These are the utility functions to manipulate double and int.

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class DoubleUtils.RoundingScheme
the schemes available to round a number.

Nested Classes
Modifier and Type	Class and Description
`static class`	`DoubleUtils.RoundingScheme` the schemes available to round a number.

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static double`	`absoluteError(double x1, double x0)` Compute the absolute difference between `x1` and `x0`.
`static double[]`	`collection2DoubleArray(java.util.Collection<? extends java.lang.Number> numbers)` Convert a collection of numbers to a `double` array.
`static int[]`	`collection2IntArray(java.util.Collection<java.lang.Integer> integers)` Convert a collection of `Integer`s to an `int` array.
`static long[]`	`collection2LongArray(java.util.Collection<java.lang.Long> integers)` Convert a collection of `Long`s to a `long` array.
`static int`	`compare(double d1, double d2, double epsilon)` Compares two `double`s up to a precision.
`static double[]`	`concat(double[]... arr)` Concatenate an array of arrays into one array.
`static int[]`	`doubleArray2intArray(double... arr)` Convert a `double` array to an `int` array, rounding down if necessary.
`static java.util.List<java.lang.Double>`	`doubleArray2List(double... arr)` Convert a `double` array to a list.
`static boolean`	`equal(double[][] d1, double[][] d2, double epsilon)` Check if two 2D arrays, `double[][]`, are close enough, hence equal, entry-by-entry.
`static boolean`	`equal(double[] d1, double[] d2, double epsilon)` Check if two `double` arrays are close enough, hence equal, entry-by-entry.
`static boolean`	`equal(double d1, double d2, double epsilon)` Check if two `double`s are close enough, hence equal.
`static boolean`	`equal(int[] d1, int[] d2)` Check if two `int` arrays, `int[]`, are equal, entry-by-entry.
`static double[]`	`foreach(double[] doubles, UnivariateRealFunction f)` Apply a function f to each element in an array.
`static boolean`	`hasDuplicate(double[] arr, double epsilon)` Check if a `double` array contains any duplicates.
`static boolean`	`hasZero(double[] d, double epsilon)` Check if a `double` array has any 0.
`static double[]`	`intArray2doubleArray(int... arr)` Convert an `int` array to a `double` array.
`static java.util.List<java.lang.Integer>`	`intArray2List(int[] ary)` Convert an `int` array to a list.
`static boolean`	`isAllZeros(double[] d, double epsilon)` Check if a `double` array contains only 0s, entry-by-entry.
`static boolean`	`isNegative(double d, double epsilon)` Check if `d` is negative.
`static boolean`	`isNumber(double x)` Check if a `double` is a number, i.e., it is not `∞` or `NaN`.
`static boolean`	`isPositive(double d, double epsilon)` Check if `d` is positive.
`static boolean`	`isPow2(int n)` Check if an integer is a power of 2.
`static boolean`	`isZero(double d, double epsilon)` Check if `d` is zero.
`static int`	`maxIndex(boolean moveOnTies, int from, int to, double... doubles)` Get the index of the maximum of the values.
`static int`	`maxIndex(double... doubles)` Get the index of the maximum of the values.
`static int`	`minIndex(boolean moveOnTies, int from, int to, double... doubles)` Get the index of the minimum of the values.
`static int`	`minIndex(double... doubles)` Get the index of the minimum of the values.
`static double`	`relativeError(double x1, double x0)` Compute the relative error for {x1, x0}.
`static void`	`reverse(double... arr)` Reverse a `double` array.
`static void`	`reverse(int... arr)` Reverse an `int` array.
`static double`	`round(double d, DoubleUtils.RoundingScheme scheme)` Round up or down a number to an integer.
`static double`	`round(double d, int scale)` Round a number to the precision specified.
`static int[]`	`shellsort(double... arr)` Sort an array using Shell sort.
`static java.lang.String`	`toString(double... arr)` Print out numbers to a string.
`static java.lang.String`	`toString(double[][] arr)` Print out a 2D array, `double[][]` to a string.

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

- Method Detail
  - compare
```
public static int compare(double d1,
                          double d2,
                          double epsilon)
```
    Compares two doubles up to a precision. This implementation is preferred to Double.compare(double, double) because our implementation returns 0 (equality), i.e., DoubleUtils.compare(0.0, -0.0) returns 0; Double.compare(0.0, -0.0) returns 1.
    
    Parameters:
    
    d1 - a double
    
    d2 - a double
    
    epsilon - a precision parameter: when a number |x| ≤ ε, it is considered 0
    
    Returns:
    
    0 if d1 is close enough to d2; 1 if d1 > d2; -1 if d1 ≤ d2
  - isZero
```
public static boolean isZero(double d,
                             double epsilon)
```
    Check if d is zero.
    
    Parameters:
    
    d - a double
    
    epsilon - a precision parameter: when a number |x| ≤ ε, it is considered 0
    
    Returns:
    
    true if d is close enough to 0
  - isPositive
```
public static boolean isPositive(double d,
                                 double epsilon)
```
    Check if d is positive.
    
    Parameters:
    
    d - a double
    
    epsilon - a precision parameter: when a number |x| ≤ ε, it is considered 0
    
    Returns:
    
    true if d is bigger than 0 by epsilon
  - isNegative
```
public static boolean isNegative(double d,
                                 double epsilon)
```
    Check if d is negative.
    
    Parameters:
    
    d - a double
    
    epsilon - a precision parameter: when a number |x| ≤ ε, it is considered 0
    
    Returns:
    
    true if d is smaller than 0 by epsilon
  - equal
```
public static boolean equal(double d1,
                            double d2,
                            double epsilon)
```
    Check if two doubles are close enough, hence equal.
    
    Parameters:
    
    d1 - a double
    
    d2 - a double
    
    epsilon - a precision parameter: when a number |x| ≤ ε, it is considered 0
    
    Returns:
    
    true if d1 is close enough to d2, false otherwise
  - equal
```
public static boolean equal(double[] d1,
                            double[] d2,
                            double epsilon)
```
    Check if two double arrays are close enough, hence equal, entry-by-entry.
    
    Parameters:
    
    d1 - a double[]
    
    d2 - a double[]
    
    epsilon - a precision parameter: when a number |x| ≤ ε, it is considered 0
    
    Returns:
    
    true if all entries in d1 are close enough to all entries in d2, false otherwise
  - equal
```
public static boolean equal(double[][] d1,
                            double[][] d2,
                            double epsilon)
```
    Check if two 2D arrays, double[][], are close enough, hence equal, entry-by-entry.
    
    Parameters:
    
    d1 - a double[][]
    
    d2 - a double[][]
    
    epsilon - a precision parameter: when a number |x| ≤ ε, it is considered 0
    
    Returns:
    
    true if all entries in d1 are close enough to all entries in d2, false otherwise
  - equal
```
public static boolean equal(int[] d1,
                            int[] d2)
```
    Check if two int arrays, int[], are equal, entry-by-entry.
    
    Parameters:
    
    d1 - an int array
    
    d2 - an int array
    
    Returns:
    
    true if all entries in d1 are the same as all entries in d2, false otherwise
  - maxIndex
```
public static int maxIndex(boolean moveOnTies,
                           int from,
                           int to,
                           double... doubles)
```
    Get the index of the maximum of the values.
    
    Parameters:
    
    moveOnTies - true if prefer the later one on ties
    
    from - the initial index of the range to be considered
    
    to - 1 after the last index of the range to be considered
    
    doubles - an array, double[]
    
    Returns:
    
    the index of the biggest number
  - maxIndex
```
public static int maxIndex(double... doubles)
```
    Get the index of the maximum of the values.
    
    Parameters:
    
    doubles - an array, double[]
    
    Returns:
    
    the index of the biggest number
  - minIndex
```
public static int minIndex(boolean moveOnTies,
                           int from,
                           int to,
                           double... doubles)
```
    Get the index of the minimum of the values.
    
    Parameters:
    
    moveOnTies - true if prefer the later one on ties
    
    from - the initial index of the range to be considered
    
    to - 1 after the last index of the range to be considered
    
    doubles - an array, double[]
    
    Returns:
    
    the index of the smallest number
  - minIndex
```
public static int minIndex(double... doubles)
```
    Get the index of the minimum of the values.
    
    Parameters:
    
    doubles - an array, double[]
    
    Returns:
    
    the index of the smallest number
  - foreach
```
public static double[] foreach(double[] doubles,
                               UnivariateRealFunction f)
```
    Apply a function f to each element in an array.
    
    Parameters:
    
    doubles - an array, double[]
    
    f - a function to be applied to each element
    
    Returns:
    
    the function outputs
  - concat
```
public static double[] concat(double[]... arr)
```
    Concatenate an array of arrays into one array. The concatenated array is not sorted.
    
    Parameters:
    
    arr - an array, double[]
    
    Returns:
    
    the concatenated array
  - reverse
```
public static void reverse(double... arr)
```
    Reverse a double array.
    
    Parameters:
    
    arr - an array, double[]
  - reverse
```
public static void reverse(int... arr)
```
    Reverse an int array.
    
    Parameters:
    
    arr - an array, int[]
  - shellsort
```
public static int[] shellsort(double... arr)
```
    Sort an array using Shell sort.
    
    Parameters:
    
    arr - an array, double[]
    
    Returns:
    
    a sorted array in ascending order
    
    See Also:
    
    Wikipedia: Shell sort
  - isAllZeros
```
public static boolean isAllZeros(double[] d,
                                 double epsilon)
```
    Check if a double array contains only 0s, entry-by-entry.
    
    Parameters:
    
    d - a double array
    
    epsilon - a precision parameter: when a number |x| ≤ ε, it is considered 0
    
    Returns:
    
    true if all entries in d are close enough to 0, false otherwise
  - hasZero
```
public static boolean hasZero(double[] d,
                              double epsilon)
```
    Check if a double array has any 0.
    
    Parameters:
    
    d - a double array
    
    epsilon - a precision parameter: when a number |x| ≤ ε, it is considered 0
    
    Returns:
    
    true if an entry in d are close enough to 0, false otherwise
  - isNumber
```
public static boolean isNumber(double x)
```
    Check if a double is a number, i.e., it is not ∞ or NaN.
    
    Parameters:
    
    x - a double
    
    Returns:
    
    true if x is not ∞ or NaN
  - isPow2
```
public static boolean isPow2(int n)
```
    Check if an integer is a power of 2.
    
    Parameters:
    
    n - an integer
    
    Returns:
    
    true if n is a power of 2.
  - hasDuplicate
```
public static boolean hasDuplicate(double[] arr,
                                   double epsilon)
```
    Check if a double array contains any duplicates.
    
    Parameters:
    
    arr - a double array
    
    epsilon - a precision parameter: when a number |x| ≤ ε, it is considered 0
    
    Returns:
    
    true if there is a duplicate
  - doubleArray2intArray
```
public static int[] doubleArray2intArray(double... arr)
```
    Convert a double array to an int array, rounding down if necessary.
    
    Parameters:
    
    arr - a double array
    
    Returns:
    
    an int array
  - intArray2doubleArray
```
public static double[] intArray2doubleArray(int... arr)
```
    Convert an int array to a double array.
    
    Parameters:
    
    arr - an int array
    
    Returns:
    
    a double array
  - collection2DoubleArray
```
public static double[] collection2DoubleArray(java.util.Collection<? extends java.lang.Number> numbers)
```
    Convert a collection of numbers to a double array.
    
    Parameters:
    
    numbers - the collection of numbers
    
    Returns:
    
    a double array containing the numbers in the input collection
  - doubleArray2List
```
public static java.util.List<java.lang.Double> doubleArray2List(double... arr)
```
    Convert a double array to a list.
    
    Parameters:
    
    arr - a double array
    
    Returns:
    
    a list of the numbers
  - collection2IntArray
```
public static int[] collection2IntArray(java.util.Collection<java.lang.Integer> integers)
```
    Convert a collection of Integers to an int array.
    
    Parameters:
    
    integers - a collection of integers
    
    Returns:
    
    an int array of the integers
  - collection2LongArray
```
public static long[] collection2LongArray(java.util.Collection<java.lang.Long> integers)
```
    Convert a collection of Longs to a long array.
    
    Parameters:
    
    integers - a collection of long integers
    
    Returns:
    
    a long array of the long integers
  - intArray2List
```
public static java.util.List<java.lang.Integer> intArray2List(int[] ary)
```
    Convert an int array to a list.
    
    Parameters:
    
    ary - an int array
    
    Returns:
    
    a list of the integers
  - round
```
public static double round(double d,
                           DoubleUtils.RoundingScheme scheme)
```
    Round up or down a number to an integer.
    
    Parameters:
    
    d - a number
    
    scheme - the rounding scheme
    
    Returns:
    
    a near integer in double
  - round
```
public static double round(double d,
                           int scale)
```
    Round a number to the precision specified.
    
    Parameters:
    
    d - a number
    
    scale - the number of decimal points
    
    Returns:
    
    an approximation of the number
  - absoluteError
```
public static double absoluteError(double x1,
                                   double x0)
```
    Compute the absolute difference between x1 and x0. This function is symmetric.
    ε = | x1 - x0 |
    
    Parameters:
    
    x1 - x1
    
    x0 - x0
    
    Returns:
    
    the absolute error
  - relativeError
```
public static double relativeError(double x1,
                                   double x0)
```
    Compute the relative error for {x1, x0}. This function is asymmetric.
    ε = | (x1 - x0) / x0 | = | x1/x0 - 1 |
    
    Parameters:
    
    x1 - x1
    
    x0 - x0
    
    Returns:
    
    the relative error
  - toString
```
public static java.lang.String toString(double... arr)
```
    Print out numbers to a string.
    
    Parameters:
    
    arr - a double array
    
    Returns:
    
    a String representation of the numbers
  - toString
```
public static java.lang.String toString(double[][] arr)
```
    Print out a 2D array, double[][] to a string.
    
    Parameters:
    
    arr - a double[][]
    
    Returns:
    
    the string representation of the array

Class DoubleUtils

Nested Class Summary

Method Summary

Methods inherited from class java.lang.Object

Method Detail

compare

isZero

isPositive

isNegative

equal

equal

equal

equal

maxIndex

maxIndex

minIndex

minIndex

foreach

concat

reverse

reverse

shellsort

isAllZeros

hasZero

isNumber

isPow2

hasDuplicate

doubleArray2intArray

intArray2doubleArray

collection2DoubleArray

doubleArray2List

collection2IntArray

collection2LongArray

intArray2List

round

round

absoluteError

relativeError

toString

toString