Data (nshmp-haz)

java.lang.Object
- gov.usgs.earthquake.nshmp.data.Data

```
public final class Data
extends Object
```
Utilities for operating on double-valued data.
Unless otherwise noted, the methods of this class:
- Operate on data in place, returning a reference to the supplied data.
- Are not synchronized.
- Throw a NullPointerException when supplied with null data.
- Return an empty array when attempting to transform each element of a dataset for which no varargs elements have been supplied(e.g. add(double, double...)).
- Throw an IllegalArgumentException if they operate on all elements of a dataset to yield a singular numeric or boolean value, but the supplied dataset is empty, with some documented exceptions.
- Throw an IllegalArguementException if they operate on multiple datasets and the datasets are not the same size.
- Do not check for finiteness (see Doubles.isFinite(double)). For example, any method that operates on data containing Double.NaN or infinite values will likely return NaNs or infinite values as a result. See the Java Math for details on the behavior of individual functions referenced herein.
- Do not check for over/under flow.
Buyer beware.
Many methods in this class are overloaded with Collection<Double> arguments. Those overloaded methods that return a single result or information about a supplied data set typically require a Collection<Double> as an argument, whereas methods that transform data in place require a List<Double> subtype.
For other useful Double utilities, see the Google Guava Doubles class.
Author:

Peter Powers

Method Summary

All Methods Static Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`static double[]`	`abs(double... data)` Set the elements of `data` to their absolute value in place.
`static List<Double>`	`abs(List<Double> data)` Set the elements of `data` to their absolute value in place.
`static double[][][]`	`add(double[][][] data1, double[][][] data2)` Add the values of `data2` to `data1` in place.
`static double[][]`	`add(double[][] data1, double[][] data2)` Add the values of `data2` to `data1` in place.
`static double[]`	`add(double[] data1, double[] data2)` Add the values of `data2` to `data1` in place.
`static double[]`	`add(double term, double... data)` Add a `term` to the elements of `data` in place.
`static double[][]`	`add(double term, double[][] data)` Add a `term` to the elements of `data` in place.
`static double[][][]`	`add(double term, double[][][] data)` Add a `term` to the elements of `data` in place.
`static List<Double>`	`add(double term, List<Double> data)` Add a `term` to the elements of `data` in place.
`static List<Double>`	`add(List<Double> data1, List<Double> data2)` Add the values of `data2` to `data1` in place.
`static <T> Map<T,Double>`	`add(Map<T,Double> map1, Map<T,Double> map2)` Adds the entries of `map2` to `map1` in place.
`static double[]`	`buildCleanSequence(double min, double max, double step, boolean ascending, int scale)` Creates a sequence of evenly spaced values starting at `min` and ending at `max`.
`static double[]`	`buildSequence(double min, double max, double step, boolean ascending)` Creates a sequence of evenly spaced values starting at `min` and ending at `max`.
`static double`	`checkDelta(double min, double max, double Δ)` Ensure validity of sequence discretization parameters.
`static Collection<Double>`	`checkFinite(Collection<Double> data)` Ensure the elements of `data` are finite.
`static double[]`	`checkFinite(double... data)` Ensure the elements of `data` are finite.
`static double`	`checkFinite(String label, double value)` Ensure `value` is finite.
`static Collection<Double>`	`checkInRange(Range<Double> range, Collection<Double> data)` Ensure the elements of `data` fall within the specified `Range` .
`static double[]`	`checkInRange(Range<Double> range, double... data)` Ensure the elements of `data` fall within the specified `Range` .
`static double`	`checkInRange(Range<Double> range, String label, double value)` Ensure `value` falls within the specified `Range`.
`static Collection<Double>`	`checkSize(int min, Collection<Double> data)` Ensure `data.size() ≥ min`.
`static double[]`	`checkSize(int min, double[] data)` Ensure `data.length ≥ min`.
`static void`	`checkSizes(Collection<Double> data1, Collection<Double> data2)` Ensure the supplied datasets are the same size.
`static void`	`checkSizes(double[][][] data1, double[][][] data2)` Ensure the 1^st dimensions of the supplied datasets are the same size.
`static void`	`checkSizes(double[][] data1, double[][] data2)` Ensure the 1^st dimensions of the supplied datasets are the same size.
`static void`	`checkSizes(double[] data1, double[] data2)` Ensure the supplied datasets are the same size.
`static double`	`checkWeight(double weight)` Ensure `0.0 < weight ≤ 1.0`.
`static Collection<Double>`	`checkWeights(Collection<Double> weights)` Ensure each `0.0 ≤ weight ≤ 1.0` and `sum(weights) = 1.0 ± 0.0001`.
`static Collection<Double>`	`checkWeights(Collection<Double> weights, boolean allowZero)` Ensure each `0.0 ≤ weight ≤ 1.0` and `sum(weights) = 1.0 ± 0.0001`, optionally allowing zero-valued weights.
`static double[]`	`checkWeights(double[] weights)` Ensure each `0.0 ≤ weight ≤ 1.0` and `sum(weights) = 1.0 ± 0.0001`.
`static double[]`	`checkWeights(double[] weights, Boolean allowZero)` Ensure each `0.0 ≤ weight ≤ 1.0` and `sum(weights) = 1.0 ± 0.0001`, optionally allowing zero-valued weights.
`static double[]`	`collapse(double[][] data)` Sum the arrays in the 2nd dimension of `data` into a new 1-D array.
`static double[][]`	`collapse(double[][][] data)` Sum the arrays in the 3rd dimension of `data` into the 2nd dimension of a new 2-D array.
`static XySequence`	`combine(Iterable<XySequence> sequences)` Deprecated.
`static double[][]`	`copyOf(double[][] data)` Create a deep copy of a two-dimensional data array.
`static double[][][]`	`copyOf(double[][][] data)` Create a deep copy of a three-dimensional data array.
`static double[]`	`cumulate(double... data)` Cumulate the values of `data` in place.
`static double[]`	`diff(double... data)` Build an array of the differences between the adjacent elements of `data`.
`static double[]`	`divide(double[] data1, double[] data2)` Divide the elements of `data1` by the elements of `data2` in place.
`static List<Double>`	`divide(List<Double> data1, List<Double> data2)` Divide the elements of `data1` by the elements of `data2` in place.
`static double[]`	`exp(double... data)` Raise Euler's number `e` to each of the elements of `data` in place.
`static List<Double>`	`exp(List<Double> data)` Raise Euler's number `e` to each of the elements of `data` in place.
`static double[]`	`flip(double... data)` Flip the sign of the elements of `data` in place.
`static List<Double>`	`flip(List<Double> data)` Flip the sign of the elements of `data` in place.
`static double[]`	`ln(double[] data)` Take the natural logarithm of the elements of `data` in place.
`static List<Double>`	`ln(List<Double> data)` Take the natural logarithm of the elements of `data` in place.
`static double[]`	`log(double... data)` Take the base-10 logarithm of the elements of `data` in place.
`static List<Double>`	`log(List<Double> data)` Take the base-10 logarithm of the elements of `data` in place.
`static double[]`	`multiply(double[] data1, double[] data2)` Multiply the elements of `data1` by the elements of `data2` in place.
`static double[]`	`multiply(double scale, double... data)` Multiply (`scale`) the elements of `data` in place.
`static double[][]`	`multiply(double scale, double[][] data)` Multiply (`scale`) the elements of `data` in place.
`static double[][][]`	`multiply(double scale, double[][][] data)` Multiply (`scale`) the elements of `data` in place.
`static List<Double>`	`multiply(double scale, List<Double> data)` Multiply (`scale`) the elements of `data` in place.
`static List<Double>`	`multiply(List<Double> data1, List<Double> data2)` Multiply the elements of `data1` by the elements of `data2` in place.
`static double[]`	`normalize(double... data)` Normalize the elements of `data` in place such that they sum to 1.
`static List<Double>`	`normalize(List<Double> data)` Normalize the elements of `data` in place such that they sum to 1.
`static double`	`percentDiff(double test, double target)` Compute the difference between `test` and `target`, relative to `target`, as a percent.
`static double[]`	`positivize(double... data)` Ensures positivity of values by adding `Math.abs(min(data))` in place if `min < 0`.
`static double[]`	`pow10(double... data)` Raise the elements of `data` to the power of 10 in place.
`static List<Double>`	`pow10(List<Double> data)` Raise the elements of `data` to the power of 10 in place.
`static double[]`	`round(int scale, double... data)` Round the elements of `data` in place to double values of a specified scale (precision).
`static List<Double>`	`round(int scale, List<Double> data)` Round the elements of `data` in place to double values of a specified scale (precision).
`static double[]`	`subtract(double[] data1, double[] data2)` Subtract the values of `data2` from `data1` in place.
`static List<Double>`	`subtract(List<Double> data1, List<Double> data2)` Subtract the values of `data2` from `data1` in place.
`static double`	`sum(Collection<Double> data)` Sum the elements of `data`.
`static double`	`sum(double... data)` Sum the elements of `data`.
`static String`	`toString(double[][] data)` Format a two-dimensional data array for printing.
`static String`	`toString(double[][][] data)` Format a three-dimensional data array for printing
`static double[]`	`transform(DoubleUnaryOperator function, double... data)` Transform `data` by a `DoubleUnaryOperator` in place.
`static List<Double>`	`transform(DoubleUnaryOperator function, List<Double> data)` Transform `data` by a `DoubleUnaryOperator` in place.
`static double[]`	`transform(Function<Double,Double> function, double... data)` Transform `data` by a `function` in place.
`static double[]`	`transform(int lower, int upper, DoubleUnaryOperator function, double... data)` Transform `data` in a given range, [`minIndex`, `maxIndex`), by a `DoubleUnaryOperator` in place.
`static double[]`	`transform(Range<Integer> range, DoubleUnaryOperator function, double... data)` Transform `data` in a given `Range` by a `DoubleUnaryOperator` in place.
`static double`	`weightedSum(double[] data, double[] weights)` Compute the weighted sum of the supplied data.
`static double`	`weightedSumLn(double[] data, double[] weights)` Compute a weighted sum of the supplied data in linear space, given data that is in natural log space.

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

- Method Detail
  - add
```
public static List<Double> add(double term,
                               List<Double> data)
```
    Add a term to the elements of data in place.
    
    Parameters:
    
    data - to operate on
    
    term - to add
    
    Returns:
    
    a reference to the supplied data
  - add
```
public static double[] add(double term,
                           double... data)
```
    Add a term to the elements of data in place.
    
    Parameters:
    
    data - to operate on
    
    term - to add
    
    Returns:
    
    a reference to the supplied data
  - add
```
public static double[][] add(double term,
                             double[][] data)
```
    Add a term to the elements of data in place.
    
    Parameters:
    
    data - to operate on
    
    term - to add
    
    Returns:
    
    a reference to the supplied data
  - add
```
public static double[][][] add(double term,
                               double[][][] data)
```
    Add a term to the elements of data in place.
    
    Parameters:
    
    data - to operate on
    
    term - to add
    
    Returns:
    
    a reference to the supplied data
  - add
```
public static List<Double> add(List<Double> data1,
                               List<Double> data2)
```
    Add the values of data2 to data1 in place.
    
    Parameters:
    
    data1 -
    
    data2 -
    
    Returns:
    
    a reference to data1
  - add
```
public static double[] add(double[] data1,
                           double[] data2)
```
    Add the values of data2 to data1 in place.
    
    Parameters:
    
    data1 -
    
    data2 -
    
    Returns:
    
    a reference to data1
  - add
```
public static double[][] add(double[][] data1,
                             double[][] data2)
```
    Add the values of data2 to data1 in place.
    
    Parameters:
    
    data1 -
    
    data2 -
    
    Returns:
    
    a reference to data1
  - add
```
public static double[][][] add(double[][][] data1,
                               double[][][] data2)
```
    Add the values of data2 to data1 in place.
    
    Parameters:
    
    data1 -
    
    data2 -
    
    Returns:
    
    a reference to data1
  - add
```
public static <T> Map<T,Double> add(Map<T,Double> map1,
                                    Map<T,Double> map2)
```
    Adds the entries of map2 to map1 in place. If a key from map2 exists in map1, then the value for that key is added to the corresponding value in map1. If no such key exists in map 1, then the key and value from map2 are transferred as is. Note that this method is not synchronized.
    
    Parameters:
    
    map1 -
    
    map2 -
    
    Returns:
    
    a reference to map1
  - subtract
```
public static List<Double> subtract(List<Double> data1,
                                    List<Double> data2)
```
    Subtract the values of data2 from data1 in place. To subtract a term from every value of a dataset, use add(double, List) with a negative addend.
    
    Parameters:
    
    data1 -
    
    data2 -
    
    Returns:
    
    a reference to data1
  - subtract
```
public static double[] subtract(double[] data1,
                                double[] data2)
```
    Subtract the values of data2 from data1 in place. To subtract a term from every value of a dataset, use add(double, double...) with a negative addend.
    
    Parameters:
    
    data1 -
    
    data2 -
    
    Returns:
    
    a reference to data1
  - multiply
```
public static List<Double> multiply(double scale,
                                    List<Double> data)
```
    Multiply (scale) the elements of data in place.
    
    Parameters:
    
    data - to operate on
    
    scale - factor
    
    Returns:
    
    a reference to the supplied data
  - multiply
```
public static double[] multiply(double scale,
                                double... data)
```
    Multiply (scale) the elements of data in place.
    
    Parameters:
    
    data - to operate on
    
    scale - factor
    
    Returns:
    
    a reference to the supplied data
  - multiply
```
public static double[][] multiply(double scale,
                                  double[][] data)
```
    Multiply (scale) the elements of data in place.
    
    Parameters:
    
    data - to operate on
    
    scale - factor
    
    Returns:
    
    a reference to the supplied data
  - multiply
```
public static double[][][] multiply(double scale,
                                    double[][][] data)
```
    Multiply (scale) the elements of data in place.
    
    Parameters:
    
    data - to operate on
    
    scale - factor
    
    Returns:
    
    a reference to the supplied data
  - multiply
```
public static List<Double> multiply(List<Double> data1,
                                    List<Double> data2)
```
    Multiply the elements of data1 by the elements of data2 in place.
    
    Parameters:
    
    data1 -
    
    data2 -
    
    Returns:
    
    a reference to data1
  - multiply
```
public static double[] multiply(double[] data1,
                                double[] data2)
```
    Multiply the elements of data1 by the elements of data2 in place.
    
    Parameters:
    
    data1 -
    
    data2 -
    
    Returns:
    
    a reference to data1
  - divide
```
public static double[] divide(double[] data1,
                              double[] data2)
```
    Divide the elements of data1 by the elements of data2 in place. To divide every value of a dataset by some term, use multiply(double, double...) with 1/divisor.
    
    Parameters:
    
    data1 -
    
    data2 -
    
    Returns:
    
    a reference to data1
  - divide
```
public static List<Double> divide(List<Double> data1,
                                  List<Double> data2)
```
    Divide the elements of data1 by the elements of data2 in place. To divide every value of a dataset by some term, use multiply(double, List) with 1/divisor.
    
    Parameters:
    
    data1 -
    
    data2 -
    
    Returns:
    
    a reference to data1
  - abs
```
public static List<Double> abs(List<Double> data)
```
    Set the elements of data to their absolute value in place.
    
    Parameters:
    
    data - to operate on
    
    Returns:
    
    a reference to the supplied data
    
    See Also:
    
    Math.abs(double)
  - abs
```
public static double[] abs(double... data)
```
    Set the elements of data to their absolute value in place.
    
    Parameters:
    
    data - to operate on
    
    Returns:
    
    a reference to the supplied data
    
    See Also:
    
    Math.abs(double)
  - exp
```
public static List<Double> exp(List<Double> data)
```
    Raise Euler's number e to each of the elements of data in place.
    
    Parameters:
    
    data - to operate on
    
    Returns:
    
    a reference to the supplied data
    
    See Also:
    
    Math.exp(double)
  - exp
```
public static double[] exp(double... data)
```
    Raise Euler's number e to each of the elements of data in place.
    
    Parameters:
    
    data - to operate on
    
    Returns:
    
    a reference to the supplied data
    
    See Also:
    
    Math.exp(double)
  - ln
```
public static List<Double> ln(List<Double> data)
```
    Take the natural logarithm of the elements of data in place.
    
    Parameters:
    
    data - to operate on
    
    Returns:
    
    a reference to the supplied data
    
    See Also:
    
    Math.log(double)
  - ln
```
public static double[] ln(double[] data)
```
    Take the natural logarithm of the elements of data in place.
    
    Parameters:
    
    data - to operate on
    
    Returns:
    
    a reference to the supplied data
    
    See Also:
    
    Math.log(double)
  - pow10
```
public static List<Double> pow10(List<Double> data)
```
    Raise the elements of data to the power of 10 in place.
    
    Parameters:
    
    data - to operate on
    
    Returns:
    
    a reference to the supplied data
    
    See Also:
    
    Math.pow(double, double)
  - pow10
```
public static double[] pow10(double... data)
```
    Raise the elements of data to the power of 10 in place.
    
    Parameters:
    
    data - to operate on
    
    Returns:
    
    a reference to the supplied data
    
    See Also:
    
    Math.pow(double, double)
  - log
```
public static List<Double> log(List<Double> data)
```
    Take the base-10 logarithm of the elements of data in place.
    
    Parameters:
    
    data - to operate on
    
    Returns:
    
    a reference to the supplied data
    
    See Also:
    
    Math.log10(double)
  - log
```
public static double[] log(double... data)
```
    Take the base-10 logarithm of the elements of data in place.
    
    Parameters:
    
    data - to operate on
    
    Returns:
    
    a reference to the supplied data
    
    See Also:
    
    Math.log10(double)
  - flip
```
public static List<Double> flip(List<Double> data)
```
    Flip the sign of the elements of data in place.
    
    Parameters:
    
    data - to operate on
    
    Returns:
    
    a reference to the supplied data
  - flip
```
public static double[] flip(double... data)
```
    Flip the sign of the elements of data in place.
    
    Parameters:
    
    data - to operate on
    
    Returns:
    
    a reference to the supplied data
  - sum
```
public static double sum(Collection<Double> data)
```
    Sum the elements of data. Method returns zero for an empty data argument.
    
    Parameters:
    
    data - to sum
    
    Returns:
    
    the sum of the supplied values
  - sum
```
public static double sum(double... data)
```
    Sum the elements of data. Method returns zero for empty data argument or no varargs.
    
    Parameters:
    
    data - to sum
    
    Returns:
    
    the sum of the supplied values
  - weightedSum
```
public static double weightedSum(double[] data,
                                 double[] weights)
```
    Compute the weighted sum of the supplied data. Weights are not constrained to sum to 1.0.
    
    Parameters:
    
    data - to sum
    
    weights - to apply
    
    Returns:
    
    the weighted sum of the supplied values
  - weightedSumLn
```
public static double weightedSumLn(double[] data,
                                   double[] weights)
```
    Compute a weighted sum of the supplied data in linear space, given data that is in natural log space. Returned sum is in natural log space. Weights are not constrained to sum to 1.0.
    
    Parameters:
    
    data - to sum (natural log values)
    
    weights - to apply
    
    Returns:
    
    the weighted sum of the supplied values
  - collapse
```
public static double[] collapse(double[][] data)
```
    Sum the arrays in the 2nd dimension of data into a new 1-D array.
    
    Parameters:
    
    data - to collapse
    
    Returns:
    
    a new array with the sums of the second dimension of data
  - collapse
```
public static double[][] collapse(double[][][] data)
```
    Sum the arrays in the 3rd dimension of data into the 2nd dimension of a new 2-D array.
    
    Parameters:
    
    data - to collapse
    
    Returns:
    
    a new 2-D array with the sums of the third dimension of data
  - cumulate
```
public static double[] cumulate(double... data)
```
    Cumulate the values of data in place.
    
    Parameters:
    
    data - to operate on
    
    Returns:
    
    a reference to the supplied data
  - transform
```
public static double[] transform(DoubleUnaryOperator function,
                                 double... data)
```
    Transform data by a DoubleUnaryOperator in place.
    
    Parameters:
    
    function - to apply to data
    
    data - to operate on
    
    Returns:
    
    a reference to the supplied data
  - transform
```
public static List<Double> transform(DoubleUnaryOperator function,
                                     List<Double> data)
```
    Transform data by a DoubleUnaryOperator in place.
    
    Parameters:
    
    function - to apply
    
    data - to operate on
    
    Returns:
    
    a reference to the supplied data
  - transform
```
public static double[] transform(Function<Double,Double> function,
                                 double... data)
```
    Transform data by a function in place.
    
    Parameters:
    
    function - to apply
    
    data - to operate on
    
    Returns:
    
    a reference to the supplied data
  - transform
```
public static double[] transform(Range<Integer> range,
                                 DoubleUnaryOperator function,
                                 double... data)
```
    Transform data in a given Range by a DoubleUnaryOperator in place.
    
    Parameters:
    
    range - to apply the function
    
    function - to apply to the data
    
    data - to operate on
    
    Returns:
    
    a reference to the supplied data
  - transform
```
public static double[] transform(int lower,
                                 int upper,
                                 DoubleUnaryOperator function,
                                 double... data)
```
    Transform data in a given range, [minIndex, maxIndex), by a DoubleUnaryOperator in place.
    
    Parameters:
    
    lower - inclusive index
    
    upper - exclusive index
    
    function - to apply to the data
    
    data - to operate on
    
    Returns:
    
    a reference to the supplied data
  - normalize
```
public static List<Double> normalize(List<Double> data)
```
    Normalize the elements of data in place such that they sum to 1.
    
    Parameters:
    
    data - to normalize
    
    Returns:
    
    a reference to the supplied data
    
    Throws:
    
    IllegalArgumentException - if data is empty or no varargs are supplied, contains values outside the range [0..+Inf), or sums to a value outside the range (0..+Inf)
  - normalize
```
public static double[] normalize(double... data)
```
    Normalize the elements of data in place such that they sum to 1.
    
    Parameters:
    
    data - to normalize
    
    Returns:
    
    a reference to the supplied data
    
    Throws:
    
    IllegalArgumentException - if data is empty or no varargs are supplied, contains values outside the range [0..+Inf), or sums to a value outside the range (0..+Inf)
  - round
```
public static List<Double> round(int scale,
                                 List<Double> data)
```
    Round the elements of data in place to double values of a specified scale (precision). Internally, this method uses the rounding and precision functionality of BigDecimal.
    
    Parameters:
    
    data - to operate on
    
    scale - decimal precision
    
    Returns:
    
    a reference to the supplied data
    
    See Also:
    
    Maths.round(double, int)
  - round
```
public static double[] round(int scale,
                             double... data)
```
    Round the elements of data in place to double values of a specified scale (precision). Internally, this method uses the rounding and precision functionality of BigDecimal.
    
    Parameters:
    
    data - to operate on
    
    scale - decimal precision
    
    Returns:
    
    a reference to the supplied data
    
    See Also:
    
    Maths.round(double, int)
  - positivize
```
public static double[] positivize(double... data)
```
    Ensures positivity of values by adding Math.abs(min(data)) in place if min < 0.
    
    Parameters:
    
    data - to operate on
    
    Returns:
    
    a reference to the supplied data, positivized if necessary
  - diff
```
public static double[] diff(double... data)
```
    Build an array of the differences between the adjacent elements of data. Method returns results in a new array that has data.length - 1 where differences are computed per data[i+1] - data[i].
    
    Parameters:
    
    data - to difference
    
    Returns:
    
    the differences between adjacent values
    
    Throws:
    
    IllegalArgumentException - if data.length < 2
  - percentDiff
```
public static double percentDiff(double test,
                                 double target)
```
    Compute the difference between test and target, relative to target, as a percent. If target == 0, method returns 0 if test == 0, otherwise Double.POSITIVE_INFINITY.
    
    Parameters:
    
    test - value
    
    target - value
    
    Returns:
    
    100 * abs(test - target) / target
    
    Throws:
    
    IllegalArgumentException - if test or target are not finite.
  - checkDelta
```
public static double checkDelta(double min,
                                double max,
                                double Δ)
```
    Ensure validity of sequence discretization parameters. Confirms that for a specified range [min, max] and Δ that:
    - min, max, and Δ are finite
    - max > min
    - Δ ≥ 0
    - Δ > 0 for max > min
    - Δ ≤ max - min
    Parameters:
    
    min - value
    
    max - value
    
    Δ - discretization delta
    
    Returns:
    
    the supplied Δ for use inline
  - checkFinite
```
public static double checkFinite(String label,
                                 double value)
```
    Ensure value is finite.
    
    Parameters:
    
    label - for value if check fails
    
    value - to check
    
    Returns:
    
    the validated value
    
    Throws:
    
    IllegalArgumentException - if value is outside the range (-Inf..+Inf)
    
    See Also:
    
    Doubles.isFinite(double)
  - checkFinite
```
public static Collection<Double> checkFinite(Collection<Double> data)
```
    Ensure the elements of data are finite.
    
    Parameters:
    
    data - to validate
    
    Returns:
    
    a reference to the supplied data
    
    Throws:
    
    IllegalArgumentException - if data is empty, or any elements of data are outside the range (-Inf..+Inf)
    
    See Also:
    
    Doubles.isFinite(double)
  - checkFinite
```
public static double[] checkFinite(double... data)
```
    Ensure the elements of data are finite.
    
    Parameters:
    
    data - to validate
    
    Returns:
    
    a reference to the supplied data
    
    Throws:
    
    IllegalArgumentException - if data is empty or no varargs are supplied, or any elements of data are outside the range (-Inf..+Inf)
    
    See Also:
    
    Doubles.isFinite(double)
  - checkInRange
```
public static double checkInRange(Range<Double> range,
                                  String label,
                                  double value)
```
    Ensure value falls within the specified Range.
    
    Parameters:
    
    range - of allowable values
    
    label - for value if check fails
    
    value - to validate
    
    Returns:
    
    the supplied value
    
    Throws:
    
    IllegalArgumentException - if either range endpoint is NaN. A range where both enpoints are NaN and at least one enpoint is closed is permitted; only when both endpoints are closed is the value NaN permitted to the exclusion of all other values.
  - checkInRange
```
public static Collection<Double> checkInRange(Range<Double> range,
                                              Collection<Double> data)
```
    Ensure the elements of data fall within the specified Range .
    
    Parameters:
    
    range - of allowable values
    
    data - to validate
    
    Returns:
    
    a reference to the supplied data
    
    See Also:
    
    for exception notes
  - checkInRange
```
public static double[] checkInRange(Range<Double> range,
                                    double... data)
```
    Ensure the elements of data fall within the specified Range .
    
    Parameters:
    
    range - of allowable values
    
    data - to validate
    
    Returns:
    
    a reference to the supplied data
    
    See Also:
    
    for exception notes
  - checkSize
```
public static Collection<Double> checkSize(int min,
                                           Collection<Double> data)
```
    Ensure data.size() ≥ min.
    
    Returns:
    
    a reference to the supplied data
  - checkSize
```
public static double[] checkSize(int min,
                                 double[] data)
```
    Ensure data.length ≥ min.
    
    Returns:
    
    a reference to the supplied data
  - checkSizes
```
public static void checkSizes(Collection<Double> data1,
                              Collection<Double> data2)
```
    Ensure the supplied datasets are the same size.
  - checkSizes
```
public static void checkSizes(double[] data1,
                              double[] data2)
```
    Ensure the supplied datasets are the same size.
  - checkSizes
```
public static void checkSizes(double[][] data1,
                              double[][] data2)
```
    Ensure the 1^st dimensions of the supplied datasets are the same size.
  - checkSizes
```
public static void checkSizes(double[][][] data1,
                              double[][][] data2)
```
    Ensure the 1^st dimensions of the supplied datasets are the same size.
  - checkWeight
```
public static double checkWeight(double weight)
```
    Ensure 0.0 < weight ≤ 1.0. This method does not permit zero-valued weights.
    
    Returns:
    
    the supplied weight
  - checkWeights
```
public static Collection<Double> checkWeights(Collection<Double> weights)
```
    Ensure each 0.0 ≤ weight ≤ 1.0 and sum(weights) = 1.0 ± 0.0001. This method permits zero-valued weights.
    
    Parameters:
    
    weights - to validate
    
    Returns:
    
    a reference to the supplied weights
  - checkWeights
```
public static Collection<Double> checkWeights(Collection<Double> weights,
                                              boolean allowZero)
```
    Ensure each 0.0 ≤ weight ≤ 1.0 and sum(weights) = 1.0 ± 0.0001, optionally allowing zero-valued weights.
    
    Parameters:
    
    weights - to validate
    
    Returns:
    
    a reference to the supplied weights
  - checkWeights
```
public static double[] checkWeights(double[] weights,
                                    Boolean allowZero)
```
    Ensure each 0.0 ≤ weight ≤ 1.0 and sum(weights) = 1.0 ± 0.0001, optionally allowing zero-valued weights.
    
    Parameters:
    
    weights - to validate
    
    Returns:
    
    a reference to the supplied weights
  - checkWeights
```
public static double[] checkWeights(double[] weights)
```
    Ensure each 0.0 ≤ weight ≤ 1.0 and sum(weights) = 1.0 ± 0.0001. This method permits zero-valued weights.
    
    Parameters:
    
    weights - to validate
    
    Returns:
    
    a reference to the supplied weights
  - copyOf
```
public static double[][] copyOf(double[][] data)
```
    Create a deep copy of a two-dimensional data array.
    
    Parameters:
    
    data - to copy
    
    Returns:
    
    a new two-dimensional array populated with the values of data
  - copyOf
```
public static double[][][] copyOf(double[][][] data)
```
    Create a deep copy of a three-dimensional data array.
    
    Parameters:
    
    data - to copy
    
    Returns:
    
    a new three-dimensional array populated with the values of data
  - toString
```
public static String toString(double[][] data)
```
    Format a two-dimensional data array for printing.
    
    Parameters:
    
    data - to format
    
    Returns:
    
    a string representation of the supplied data
  - toString
```
public static String toString(double[][][] data)
```
    Format a three-dimensional data array for printing
    
    Parameters:
    
    data - to format
    
    Returns:
    
    a string representation of the supplied data
  - buildCleanSequence
```
public static double[] buildCleanSequence(double min,
                                          double max,
                                          double step,
                                          boolean ascending,
                                          int scale)
```
    Creates a sequence of evenly spaced values starting at min and ending at max. If (max - min) / step is not equivalent to an integer, the last step in the sequence will be <step. Unlike buildSequence(double, double, double, boolean), this method returns a sequence where any 'odd' values due to rounding errors have been removed, at least within the range of the specified scale (precision or number of decimal places).
    
    Parameters:
    
    min - sequence value
    
    max - sequence value
    
    step - sequence spacing
    
    ascending - if true, descending if false
    
    scale - the number of decimal places to preserve
    
    Returns:
    
    a monotonically increasing or decreasing sequence of values
    
    Throws:
    
    IllegalArgumentException - if min >= max, step <= 0 , or any arguments are Double.NaN, Double.POSITIVE_INFINITY, or Double.NEGATIVE_INFINITY
  - buildSequence
```
public static double[] buildSequence(double min,
                                     double max,
                                     double step,
                                     boolean ascending)
```
    Creates a sequence of evenly spaced values starting at min and ending at max. If (max - min) / step is not integer valued, the last step in the sequence will be <step. If min == max, then an array containing a single value is returned.
    
    Parameters:
    
    min - sequence value
    
    max - sequence value
    
    step - sequence spacing
    
    ascending - if true, descending if false
    
    Returns:
    
    a monotonically increasing or decreasing sequence of values
    
    Throws:
    
    IllegalArgumentException - if min >= max, step <= 0 , or any arguments are Double.NaN, Double.POSITIVE_INFINITY, or Double.NEGATIVE_INFINITY
  - combine
```
@Deprecated
public static XySequence combine(Iterable<XySequence> sequences)
```
    Deprecated.
    
    Combine the supplied sequences. The y-values returned are the set of all supplied y-values. The x-values returned are the sum of the supplied x-values. When summing, x-values for points outside the original domain of a sequence are set to 0, while those inside the original domain are sampled via linear interpolation.
    
    Parameters:
    
    sequences - to combine
    
    Returns:
    
    a combined sequence

Class Data

Method Summary

Methods inherited from class java.lang.Object

Method Detail

add

add

add

add

add

add

add

add

add

subtract

subtract

multiply

multiply

multiply

multiply

multiply

multiply

divide

divide

abs

abs

exp

exp

ln

ln

pow10

pow10

log

log

flip

flip

sum

sum

weightedSum

weightedSumLn

collapse

collapse

cumulate

transform

transform

transform

transform

transform

normalize

normalize

round

round

positivize

diff

percentDiff

checkDelta

checkFinite

checkFinite

checkFinite

checkInRange

checkInRange

checkInRange

checkSize

checkSize

checkSizes

checkSizes

checkSizes

checkSizes

checkWeight

checkWeights

checkWeights

checkWeights

checkWeights

copyOf

copyOf

toString

toString

buildCleanSequence

buildSequence

combine