ArrayMath

java.lang.Object
- icy.math.ArrayMath

```
public class ArrayMath
extends java.lang.Object
```
Class defining basic arithmetic and statistic operations on 1D double arrays.

Author:

Alexandre Dufour & Stephane

Constructor Summary

Constructors
Constructor and Description

ArrayMath()

Constructors
Constructor and Description
`ArrayMath()`

Method Summary

Methods
Modifier and Type	Method and Description
`static byte[]`	`abs(byte[] input, boolean overwrite)` Computes the absolute value of each value of the given byte array
`static double[]`	`abs(double[] input, boolean overwrite)` Computes the absolute value of each value of the given double array
`static float[]`	`abs(float[] input, boolean overwrite)` Computes the absolute value of each value of the given float array
`static int[]`	`abs(int[] input, boolean overwrite)` Computes the absolute value of each value of the given int array
`static long[]`	`abs(long[] input, boolean overwrite)` Computes the absolute value of each value of the given long array
`static java.lang.Object`	`abs(java.lang.Object array, boolean overwrite)` Computes the absolute value of each value of the given array
`static short[]`	`abs(short[] input, boolean overwrite)` Computes the absolute value of each value of the given short array
`static byte[]`	`add(byte[] array, byte value)` Adds a value to all elements of the given byte array
`static byte[]`	`add(byte[] a1, byte[] a2)` Element-wise addition of two byte arrays
`static byte[]`	`add(byte[] a1, byte[] a2, byte[] out)` Element-wise addition of two byte arrays (result in output if defined)
`static byte[]`	`add(byte[] array, byte value, byte[] out)` Adds a value to all elements of the given byte array
`static double[]`	`add(double[] array, double value)` Adds a value to all elements of the given double array
`static double[]`	`add(double[] a1, double[] a2)` Element-wise addition of two double arrays
`static double[]`	`add(double[] a1, double[] a2, double[] out)` Element-wise addition of two double arrays (result in output if defined)
`static double[]`	`add(double[] array, double value, double[] out)` Adds a value to all elements of the given double array
`static double[]`	`add(double value, double[] array, double[] out)` Deprecated. use `add(double[] , double , double[])` instead
`static float[]`	`add(float[] array, float value)` Adds a value to all elements of the float given array
`static float[]`	`add(float[] a1, float[] a2)` Element-wise addition of two float arrays
`static float[]`	`add(float[] a1, float[] a2, float[] out)` Element-wise addition of two float arrays (result in output if defined)
`static float[]`	`add(float[] array, float value, float[] out)` Adds a value to all elements of the given float array
`static int[]`	`add(int[] array, int value)` Adds a value to all elements of the given int array
`static int[]`	`add(int[] a1, int[] a2)` Element-wise addition of two int arrays
`static int[]`	`add(int[] a1, int[] a2, int[] out)` Element-wise addition of two int arrays (result in output if defined)
`static int[]`	`add(int[] array, int value, int[] out)` Adds a value to all elements of the given int array
`static long[]`	`add(long[] array, long value)` Adds a value to all elements of the given long array
`static long[]`	`add(long[] a1, long[] a2)` Element-wise addition of two long arrays
`static long[]`	`add(long[] a1, long[] a2, long[] out)` Element-wise addition of two long arrays (result in output if defined)
`static long[]`	`add(long[] array, long value, long[] out)` Adds a value to all elements of the given long array
`static java.lang.Object`	`add(java.lang.Object array, java.lang.Number value)` Adds a value to all elements of the given array
`static java.lang.Object`	`add(java.lang.Object array, java.lang.Number value, java.lang.Object out)` Adds a value to all elements of the given array
`static java.lang.Object`	`add(java.lang.Object a1, java.lang.Object a2)` Element-wise addition of two arrays
`static java.lang.Object`	`add(java.lang.Object a1, java.lang.Object a2, java.lang.Object out)` Element-wise addition of two arrays
`static short[]`	`add(short[] array, short value)` Adds a value to all elements of the given short array
`static short[]`	`add(short[] a1, short[] a2)` Element-wise addition of two short arrays
`static short[]`	`add(short[] a1, short[] a2, short[] out)` Element-wise addition of two short arrays (result in output if defined)
`static short[]`	`add(short[] array, short value, short[] out)` Adds a value to all elements of the given short array
`static double`	`correlation(double[] a, double[] b)` Computes the classical correlation coefficient between 2 populations.
`static double`	`correlationPearson(double[] a, double[] b)` Computes the Pearson correlation coefficient between two populations of same size N.
`static byte[]`	`divide(byte[] array, byte value)` Divides a value to all elements of the given byte array
`static byte[]`	`divide(byte[] a1, byte[] a2)` Element-wise division of two byte arrays
`static byte[]`	`divide(byte[] a1, byte[] a2, byte[] out)` Element-wise division of two byte arrays (result in output if defined)
`static byte[]`	`divide(byte[] array, byte value, byte[] out)` Divides a value to all elements of the given byte array
`static byte[]`	`divide(byte value, byte[] array)` Divides a value by all elements of the given byte array
`static byte[]`	`divide(byte value, byte[] array, byte[] out)` Divides a value by all elements of the given byte array
`static double[]`	`divide(double[] array, double value)` Divides a value to all elements of the given double array
`static double[]`	`divide(double[] a1, double[] a2)` Element-wise division of two double arrays
`static double[]`	`divide(double[] a1, double[] a2, double[] out)` Element-wise division of two double arrays (result in output if defined)
`static double[]`	`divide(double[] array, double value, double[] out)` Divides a value to all elements of the given double array
`static double[]`	`divide(double value, double[] array)` Divides a value by all elements of the given double array
`static double[]`	`divide(double value, double[] array, double[] out)` Subtracts a value by all elements of the given double array
`static float[]`	`divide(float[] array, float value)` Divides a value to all elements of the float given array
`static float[]`	`divide(float[] a1, float[] a2)` Element-wise division of two float arrays
`static float[]`	`divide(float[] a1, float[] a2, float[] out)` Element-wise division of two float arrays (result in output if defined)
`static float[]`	`divide(float[] array, float value, float[] out)` Divides a value to all elements of the given float array
`static float[]`	`divide(float value, float[] array)` Divides a value by all elements of the float given array
`static float[]`	`divide(float value, float[] array, float[] out)` Divides a value by all elements of the given float array
`static int[]`	`divide(int[] array, int value)` Divides a value to all elements of the given int array
`static int[]`	`divide(int[] a1, int[] a2)` Element-wise division of two int arrays
`static int[]`	`divide(int[] a1, int[] a2, int[] out)` Element-wise division of two int arrays (result in output if defined)
`static int[]`	`divide(int[] array, int value, int[] out)` Divides a value to all elements of the given int array
`static int[]`	`divide(int value, int[] array)` Divides a value by all elements of the given int array
`static int[]`	`divide(int value, int[] array, int[] out)` Divides a value by all elements of the given int array
`static long[]`	`divide(long[] array, long value)` Divides a value to all elements of the given long array
`static long[]`	`divide(long[] a1, long[] a2)` Element-wise division of two long arrays
`static long[]`	`divide(long[] a1, long[] a2, long[] out)` Element-wise division of two long arrays (result in output if defined)
`static long[]`	`divide(long[] array, long value, long[] out)` Divides a value to all elements of the given long array
`static long[]`	`divide(long value, long[] array)` Divides a value by all elements of the given long array
`static long[]`	`divide(long value, long[] array, long[] out)` Divides a value by all elements of the given long array
`static java.lang.Object`	`divide(java.lang.Number value, java.lang.Object array)` Divides a value by all elements of the given array
`static java.lang.Object`	`divide(java.lang.Number value, java.lang.Object array, java.lang.Object out)` Divides a value by all elements of the given array
`static java.lang.Object`	`divide(java.lang.Object array, java.lang.Number value)` Divides a value to all elements of the given array
`static java.lang.Object`	`divide(java.lang.Object array, java.lang.Number value, java.lang.Object out)` Divides a value to all elements of the given array
`static java.lang.Object`	`divide(java.lang.Object a1, java.lang.Object a2)` Element-wise division of two arrays
`static java.lang.Object`	`divide(java.lang.Object a1, java.lang.Object a2, java.lang.Object out)` Element-wise division of two arrays
`static short[]`	`divide(short[] array, short value)` Divides a value to all elements of the given short array
`static short[]`	`divide(short[] a1, short[] a2)` Element-wise division of two short arrays
`static short[]`	`divide(short[] a1, short[] a2, short[] out)` Element-wise division of two short arrays (result in output if defined)
`static short[]`	`divide(short[] array, short value, short[] out)` Divides a value to all elements of the given short array
`static short[]`	`divide(short value, short[] array)` Divides a value by all elements of the given short array
`static short[]`	`divide(short value, short[] array, short[] out)` Divides a value by all elements of the given short array
`static double`	`mad(double[] input, boolean normalPopulation)` Computes the Maximum Absolute Deviation aka MAD of the given array
`static int`	`max(byte[] array, boolean signed)` Find the maximum value of an array
`static double`	`max(double[] array)` Find the maximum value of an array
`static double[]`	`max(double[] a1, double[] a2)` Element-wise maximum of two arrays
`static void`	`max(double[] a1, double[] a2, double[] output)` Element-wise maximum of two arrays
`static float`	`max(float[] array)` Find the maximum value of an array
`static long`	`max(int[] array, boolean signed)` Find the maximum value of an array
`static long`	`max(long[] array, boolean signed)` Find the maximum value of an array
`static double`	`max(java.lang.Object array, boolean signed)` Find the maximum value of a generic array
`static int`	`max(short[] array, boolean signed)` Find the maximum value of an array
`static double`	`mean(double[] input)` Computes the mean value of the given array
`static double`	`median(double[] input, boolean preserveData)` Reorders the given array to compute its median value
`static int`	`min(byte[] array, boolean signed)` Find the minimum value of an array
`static double`	`min(double[] array)` Find the minimum value of an array
`static double[]`	`min(double[] a1, double[] a2)` Element-wise minimum of two arrays
`static void`	`min(double[] a1, double[] a2, double[] output)` Element-wise minimum of two arrays
`static float`	`min(float[] array)` Find the minimum value of an array
`static long`	`min(int[] array, boolean signed)` Find the minimum value of an array
`static long`	`min(long[] array, boolean signed)` Find the minimum value of an array
`static double`	`min(java.lang.Object array, boolean signed)` Find the minimum value of a generic array
`static int`	`min(short[] array, boolean signed)` Find the minimum value of an array
`static byte[]`	`multiply(byte[] array, byte value)` Multiplies a value to all elements of the given byte array
`static byte[]`	`multiply(byte[] a1, byte[] a2)` Element-wise multiplication of two byte arrays
`static byte[]`	`multiply(byte[] a1, byte[] a2, byte[] out)` Element-wise multiplication of two byte arrays (result in output if defined)
`static byte[]`	`multiply(byte[] array, byte value, byte[] out)` Multiplies a value to all elements of the given byte array
`static double[]`	`multiply(double[] array, double value)` Multiplies a value to all elements of the given double array
`static double[]`	`multiply(double[] a1, double[] a2)` Element-wise multiplication of two double arrays
`static double[]`	`multiply(double[] a1, double[] a2, double[] out)` Element-wise multiplication of two double arrays (result in output if defined)
`static double[]`	`multiply(double[] array, double value, double[] out)` Multiplies a value to all elements of the given double array
`static double[]`	`multiply(double value, double[] array, double[] out)` Deprecated. use `multiply(double[] , double , double[])` instead
`static float[]`	`multiply(float[] array, float value)` Multiplies a value to all elements of the float given array
`static float[]`	`multiply(float[] a1, float[] a2)` Element-wise multiplication of two float arrays
`static float[]`	`multiply(float[] a1, float[] a2, float[] out)` Element-wise multiplication of two float arrays (result in output if defined)
`static float[]`	`multiply(float[] array, float value, float[] out)` Multiplies a value to all elements of the given float array
`static int[]`	`multiply(int[] array, int value)` Multiplies a value to all elements of the given int array
`static int[]`	`multiply(int[] a1, int[] a2)` Element-wise multiplication of two int arrays
`static int[]`	`multiply(int[] a1, int[] a2, int[] out)` Element-wise multiplication of two int arrays (result in output if defined)
`static int[]`	`multiply(int[] array, int value, int[] out)` Multiplies a value to all elements of the given int array
`static long[]`	`multiply(long[] array, long value)` Multiplies a value to all elements of the given long array
`static long[]`	`multiply(long[] a1, long[] a2)` Element-wise multiplication of two long arrays
`static long[]`	`multiply(long[] a1, long[] a2, long[] out)` Element-wise multiplication of two long arrays (result in output if defined)
`static long[]`	`multiply(long[] array, long value, long[] out)` Multiplies a value to all elements of the given long array
`static java.lang.Object`	`multiply(java.lang.Object array, java.lang.Number value)` Multiplies a value to all elements of the given array
`static java.lang.Object`	`multiply(java.lang.Object array, java.lang.Number value, java.lang.Object out)` Multiplies a value to all elements of the given array
`static java.lang.Object`	`multiply(java.lang.Object a1, java.lang.Object a2)` Element-wise multiplication of two arrays
`static java.lang.Object`	`multiply(java.lang.Object a1, java.lang.Object a2, java.lang.Object out)` Element-wise multiplication of two arrays
`static short[]`	`multiply(short[] array, short value)` Multiplies a value to all elements of the given short array
`static short[]`	`multiply(short[] a1, short[] a2)` Element-wise multiplication of two short arrays
`static short[]`	`multiply(short[] a1, short[] a2, short[] out)` Element-wise multiplication of two short arrays (result in output if defined)
`static short[]`	`multiply(short[] array, short value, short[] out)` Multiplies a value to all elements of the given short array
`static double[]`	`rescale(double[] input, double newMin, double newMax, boolean overwrite)` Rescales the given array to [newMin,newMax].
`static double`	`select(int k, double[] data)` (routine ported from 'Numerical Recipes in C 2nd ed.')
`static double[]`	`standardize(double[] input, boolean overwrite)` Standardize the input data by subtracting the mean value and dividing by the standard deviation
`static double`	`std(double[] input, boolean unbiased)` Computes the standard deviation of the given array (the variance square root)
`static byte[]`	`subtract(byte[] array, byte value)` Subtracts a value to all elements of the given byte array
`static byte[]`	`subtract(byte[] a1, byte[] a2)` Element-wise subtraction of two byte arrays
`static byte[]`	`subtract(byte[] a1, byte[] a2, byte[] out)` Element-wise subtraction of two byte arrays (result in output if defined)
`static byte[]`	`subtract(byte[] array, byte value, byte[] out)` Subtracts a value to all elements of the given byte array
`static byte[]`	`subtract(byte value, byte[] array)` Subtracts a value by all elements of the given byte array
`static byte[]`	`subtract(byte value, byte[] array, byte[] out)` Subtracts a value by all elements of the given byte array
`static double[]`	`subtract(double[] array, double value)` Subtracts a value to all elements of the given double array
`static double[]`	`subtract(double[] a1, double[] a2)` Element-wise subtraction of two double arrays
`static double[]`	`subtract(double[] a1, double[] a2, double[] out)` Element-wise subtraction of two double arrays (result in output if defined)
`static double[]`	`subtract(double[] array, double value, double[] out)` Subtracts a value to all elements of the given double array
`static double[]`	`subtract(double value, double[] array)` Subtracts a value by all elements of the given double array
`static double[]`	`subtract(double value, double[] array, double[] out)` Subtracts a value by all elements of the given double array
`static float[]`	`subtract(float[] array, float value)` Subtracts a value to all elements of the float given array
`static float[]`	`subtract(float[] a1, float[] a2)` Element-wise subtraction of two float arrays
`static float[]`	`subtract(float[] a1, float[] a2, float[] out)` Element-wise subtraction of two float arrays (result in output if defined)
`static float[]`	`subtract(float[] array, float value, float[] out)` Subtracts a value to all elements of the given float array
`static float[]`	`subtract(float value, float[] array)` Subtracts a value by all elements of the float given array
`static float[]`	`subtract(float value, float[] array, float[] out)` Subtracts a value by all elements of the given float array
`static int[]`	`subtract(int[] array, int value)` Subtracts a value to all elements of the given int array
`static int[]`	`subtract(int[] a1, int[] a2)` Element-wise subtraction of two int arrays
`static int[]`	`subtract(int[] a1, int[] a2, int[] out)` Element-wise subtraction of two int arrays (result in output if defined)
`static int[]`	`subtract(int[] array, int value, int[] out)` Subtracts a value to all elements of the given int array
`static int[]`	`subtract(int value, int[] array)` Subtracts a value by all elements of the given int array
`static int[]`	`subtract(int value, int[] array, int[] out)` Subtracts a value by all elements of the given int array
`static long[]`	`subtract(long[] array, long value)` Subtracts a value to all elements of the given long array
`static long[]`	`subtract(long[] a1, long[] a2)` Element-wise subtraction of two long arrays
`static long[]`	`subtract(long[] a1, long[] a2, long[] out)` Element-wise subtraction of two long arrays (result in output if defined)
`static long[]`	`subtract(long[] array, long value, long[] out)` Subtracts a value to all elements of the given long array
`static long[]`	`subtract(long value, long[] array)` Subtracts a value by all elements of the given long array
`static long[]`	`subtract(long value, long[] array, long[] out)` Subtracts a value by all elements of the given long array
`static java.lang.Object`	`subtract(java.lang.Number value, java.lang.Object array)` Subtracts a value by all elements of the given array
`static java.lang.Object`	`subtract(java.lang.Number value, java.lang.Object array, java.lang.Object out)` Subtracts a value by all elements of the given array
`static java.lang.Object`	`subtract(java.lang.Object array, java.lang.Number value)` Subtracts a value to all elements of the given array
`static java.lang.Object`	`subtract(java.lang.Object array, java.lang.Number value, java.lang.Object out)` Subtracts a value to all elements of the given array
`static java.lang.Object`	`subtract(java.lang.Object a1, java.lang.Object a2)` Element-wise subtraction of two arrays
`static java.lang.Object`	`subtract(java.lang.Object a1, java.lang.Object a2, java.lang.Object out)` Element-wise subtraction of two arrays
`static short[]`	`subtract(short[] array, short value)` Subtracts a value to all elements of the given short array
`static short[]`	`subtract(short[] a1, short[] a2)` Element-wise subtraction of two short arrays
`static short[]`	`subtract(short[] a1, short[] a2, short[] out)` Element-wise subtraction of two short arrays (result in output if defined)
`static short[]`	`subtract(short[] array, short value, short[] out)` Subtracts a value to all elements of the given short array
`static short[]`	`subtract(short value, short[] array)` Subtracts a value by all elements of the given short array
`static short[]`	`subtract(short value, short[] array, short[] out)` Subtracts a value by all elements of the given short array
`static double`	`sum(byte[] input, boolean signed)` Computes the sum of all values in the input array
`static double`	`sum(double[] input)` Computes the sum of all values in the input array
`static double`	`sum(float[] input)` Computes the sum of all values in the input array
`static double`	`sum(int[] input, boolean signed)` Computes the sum of all values in the input array
`static double`	`sum(long[] input, boolean signed)` Computes the sum of all values in the input array
`static double`	`sum(java.lang.Object array, boolean signed)` Computes the sum of all values from the specified input array.
`static double`	`sum(short[] input, boolean signed)` Computes the sum of all values in the input array
`static double`	`var(double[] input, boolean unbiased)` Computes the unbiased variance of the given array

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

- Constructor Detail
  - ArrayMath
```
public ArrayMath()
```
- Method Detail
  - add
```
public static java.lang.Object add(java.lang.Object a1,
                   java.lang.Object a2,
                   java.lang.Object out)
```
    Element-wise addition of two arrays
    
    Parameters:
    out - the array receiving the result
  - add
```
public static java.lang.Object add(java.lang.Object a1,
                   java.lang.Object a2)
```
    Element-wise addition of two arrays
  - add
```
public static double[] add(double[] a1,
           double[] a2,
           double[] out)
```
    Element-wise addition of two double arrays (result in output if defined)
    
    Parameters:
    out - the array receiving the result
  - add
```
public static double[] add(double[] a1,
           double[] a2)
```
    Element-wise addition of two double arrays
  - add
```
public static float[] add(float[] a1,
          float[] a2,
          float[] out)
```
    Element-wise addition of two float arrays (result in output if defined)
    
    Parameters:
    out - the array receiving the result
  - add
```
public static float[] add(float[] a1,
          float[] a2)
```
    Element-wise addition of two float arrays
  - add
```
public static long[] add(long[] a1,
         long[] a2,
         long[] out)
```
    Element-wise addition of two long arrays (result in output if defined)
    
    Parameters:
    out - the array receiving the result
  - add
```
public static long[] add(long[] a1,
         long[] a2)
```
    Element-wise addition of two long arrays
  - add
```
public static int[] add(int[] a1,
        int[] a2,
        int[] out)
```
    Element-wise addition of two int arrays (result in output if defined)
    
    Parameters:
    out - the array receiving the result
  - add
```
public static int[] add(int[] a1,
        int[] a2)
```
    Element-wise addition of two int arrays
  - add
```
public static short[] add(short[] a1,
          short[] a2,
          short[] out)
```
    Element-wise addition of two short arrays (result in output if defined)
    
    Parameters:
    out - the array receiving the result
  - add
```
public static short[] add(short[] a1,
          short[] a2)
```
    Element-wise addition of two short arrays
  - add
```
public static byte[] add(byte[] a1,
         byte[] a2,
         byte[] out)
```
    Element-wise addition of two byte arrays (result in output if defined)
    
    Parameters:
    out - the array receiving the result
  - add
```
public static byte[] add(byte[] a1,
         byte[] a2)
```
    Element-wise addition of two byte arrays
  - add
```
public static java.lang.Object add(java.lang.Object array,
                   java.lang.Number value,
                   java.lang.Object out)
```
    Adds a value to all elements of the given array
    
    Parameters:
    out - the array receiving the result
  - add
```
public static java.lang.Object add(java.lang.Object array,
                   java.lang.Number value)
```
    Adds a value to all elements of the given array
  - add
```
public static double[] add(double[] array,
           double value,
           double[] out)
```
    Adds a value to all elements of the given double array
    
    Parameters:
    out - the array receiving the result
  - add
```
@Deprecated
public static double[] add(double value,
                      double[] array,
                      double[] out)
```
    Deprecated. use add(double[] , double , double[]) instead
  - add
```
public static double[] add(double[] array,
           double value)
```
    Adds a value to all elements of the given double array
  - add
```
public static float[] add(float[] array,
          float value,
          float[] out)
```
    Adds a value to all elements of the given float array
    
    Parameters:
    out - the array receiving the result
  - add
```
public static float[] add(float[] array,
          float value)
```
    Adds a value to all elements of the float given array
  - add
```
public static long[] add(long[] array,
         long value,
         long[] out)
```
    Adds a value to all elements of the given long array
    
    Parameters:
    out - the array receiving the result
  - add
```
public static long[] add(long[] array,
         long value)
```
    Adds a value to all elements of the given long array
  - add
```
public static int[] add(int[] array,
        int value,
        int[] out)
```
    Adds a value to all elements of the given int array
    
    Parameters:
    out - the array receiving the result
  - add
```
public static int[] add(int[] array,
        int value)
```
    Adds a value to all elements of the given int array
  - add
```
public static short[] add(short[] array,
          short value,
          short[] out)
```
    Adds a value to all elements of the given short array
    
    Parameters:
    out - the array receiving the result
  - add
```
public static short[] add(short[] array,
          short value)
```
    Adds a value to all elements of the given short array
  - add
```
public static byte[] add(byte[] array,
         byte value,
         byte[] out)
```
    Adds a value to all elements of the given byte array
    
    Parameters:
    out - the array receiving the result
  - add
```
public static byte[] add(byte[] array,
         byte value)
```
    Adds a value to all elements of the given byte array
  - subtract
```
public static java.lang.Object subtract(java.lang.Object a1,
                        java.lang.Object a2,
                        java.lang.Object out)
```
    Element-wise subtraction of two arrays
    
    Parameters:
    out - the array receiving the result
  - subtract
```
public static java.lang.Object subtract(java.lang.Object a1,
                        java.lang.Object a2)
```
    Element-wise subtraction of two arrays
  - subtract
```
public static double[] subtract(double[] a1,
                double[] a2,
                double[] out)
```
    Element-wise subtraction of two double arrays (result in output if defined)
    
    Parameters:
    out - the array receiving the result
  - subtract
```
public static double[] subtract(double[] a1,
                double[] a2)
```
    Element-wise subtraction of two double arrays
  - subtract
```
public static float[] subtract(float[] a1,
               float[] a2,
               float[] out)
```
    Element-wise subtraction of two float arrays (result in output if defined)
    
    Parameters:
    out - the array receiving the result
  - subtract
```
public static float[] subtract(float[] a1,
               float[] a2)
```
    Element-wise subtraction of two float arrays
  - subtract
```
public static long[] subtract(long[] a1,
              long[] a2,
              long[] out)
```
    Element-wise subtraction of two long arrays (result in output if defined)
    
    Parameters:
    out - the array receiving the result
  - subtract
```
public static long[] subtract(long[] a1,
              long[] a2)
```
    Element-wise subtraction of two long arrays
  - subtract
```
public static int[] subtract(int[] a1,
             int[] a2,
             int[] out)
```
    Element-wise subtraction of two int arrays (result in output if defined)
    
    Parameters:
    out - the array receiving the result
  - subtract
```
public static int[] subtract(int[] a1,
             int[] a2)
```
    Element-wise subtraction of two int arrays
  - subtract
```
public static short[] subtract(short[] a1,
               short[] a2,
               short[] out)
```
    Element-wise subtraction of two short arrays (result in output if defined)
    
    Parameters:
    out - the array receiving the result
  - subtract
```
public static short[] subtract(short[] a1,
               short[] a2)
```
    Element-wise subtraction of two short arrays
  - subtract
```
public static byte[] subtract(byte[] a1,
              byte[] a2,
              byte[] out)
```
    Element-wise subtraction of two byte arrays (result in output if defined)
    
    Parameters:
    out - the array receiving the result
  - subtract
```
public static byte[] subtract(byte[] a1,
              byte[] a2)
```
    Element-wise subtraction of two byte arrays
  - subtract
```
public static java.lang.Object subtract(java.lang.Object array,
                        java.lang.Number value,
                        java.lang.Object out)
```
    Subtracts a value to all elements of the given array
    
    Parameters:
    out - the array receiving the result
  - subtract
```
public static java.lang.Object subtract(java.lang.Object array,
                        java.lang.Number value)
```
    Subtracts a value to all elements of the given array
  - subtract
```
public static double[] subtract(double[] array,
                double value,
                double[] out)
```
    Subtracts a value to all elements of the given double array
    
    Parameters:
    out - the array receiving the result
  - subtract
```
public static double[] subtract(double[] array,
                double value)
```
    Subtracts a value to all elements of the given double array
  - subtract
```
public static float[] subtract(float[] array,
               float value,
               float[] out)
```
    Subtracts a value to all elements of the given float array
    
    Parameters:
    out - the array receiving the result
  - subtract
```
public static float[] subtract(float[] array,
               float value)
```
    Subtracts a value to all elements of the float given array
  - subtract
```
public static long[] subtract(long[] array,
              long value,
              long[] out)
```
    Subtracts a value to all elements of the given long array
    
    Parameters:
    out - the array receiving the result
  - subtract
```
public static long[] subtract(long[] array,
              long value)
```
    Subtracts a value to all elements of the given long array
  - subtract
```
public static int[] subtract(int[] array,
             int value,
             int[] out)
```
    Subtracts a value to all elements of the given int array
    
    Parameters:
    out - the array receiving the result
  - subtract
```
public static int[] subtract(int[] array,
             int value)
```
    Subtracts a value to all elements of the given int array
  - subtract
```
public static short[] subtract(short[] array,
               short value,
               short[] out)
```
    Subtracts a value to all elements of the given short array
    
    Parameters:
    out - the array receiving the result
  - subtract
```
public static short[] subtract(short[] array,
               short value)
```
    Subtracts a value to all elements of the given short array
  - subtract
```
public static byte[] subtract(byte[] array,
              byte value,
              byte[] out)
```
    Subtracts a value to all elements of the given byte array
    
    Parameters:
    out - the array receiving the result
  - subtract
```
public static byte[] subtract(byte[] array,
              byte value)
```
    Subtracts a value to all elements of the given byte array
  - subtract
```
public static java.lang.Object subtract(java.lang.Number value,
                        java.lang.Object array,
                        java.lang.Object out)
```
    Subtracts a value by all elements of the given array
    
    Parameters:
    out - the array receiving the result
  - subtract
```
public static java.lang.Object subtract(java.lang.Number value,
                        java.lang.Object array)
```
    Subtracts a value by all elements of the given array
  - subtract
```
public static double[] subtract(double value,
                double[] array,
                double[] out)
```
    Subtracts a value by all elements of the given double array
    
    Parameters:
    out - the array receiving the result
  - subtract
```
public static double[] subtract(double value,
                double[] array)
```
    Subtracts a value by all elements of the given double array
  - subtract
```
public static float[] subtract(float value,
               float[] array,
               float[] out)
```
    Subtracts a value by all elements of the given float array
    
    Parameters:
    out - the array receiving the result
  - subtract
```
public static float[] subtract(float value,
               float[] array)
```
    Subtracts a value by all elements of the float given array
  - subtract
```
public static long[] subtract(long value,
              long[] array,
              long[] out)
```
    Subtracts a value by all elements of the given long array
    
    Parameters:
    out - the array receiving the result
  - subtract
```
public static long[] subtract(long value,
              long[] array)
```
    Subtracts a value by all elements of the given long array
  - subtract
```
public static int[] subtract(int value,
             int[] array,
             int[] out)
```
    Subtracts a value by all elements of the given int array
    
    Parameters:
    out - the array receiving the result
  - subtract
```
public static int[] subtract(int value,
             int[] array)
```
    Subtracts a value by all elements of the given int array
  - subtract
```
public static short[] subtract(short value,
               short[] array,
               short[] out)
```
    Subtracts a value by all elements of the given short array
    
    Parameters:
    out - the array receiving the result
  - subtract
```
public static short[] subtract(short value,
               short[] array)
```
    Subtracts a value by all elements of the given short array
  - subtract
```
public static byte[] subtract(byte value,
              byte[] array,
              byte[] out)
```
    Subtracts a value by all elements of the given byte array
    
    Parameters:
    out - the array receiving the result
  - subtract
```
public static byte[] subtract(byte value,
              byte[] array)
```
    Subtracts a value by all elements of the given byte array
  - multiply
```
public static java.lang.Object multiply(java.lang.Object a1,
                        java.lang.Object a2,
                        java.lang.Object out)
```
    Element-wise multiplication of two arrays
    
    Parameters:
    out - the array receiving the result
  - multiply
```
public static java.lang.Object multiply(java.lang.Object a1,
                        java.lang.Object a2)
```
    Element-wise multiplication of two arrays
  - multiply
```
public static double[] multiply(double[] a1,
                double[] a2,
                double[] out)
```
    Element-wise multiplication of two double arrays (result in output if defined)
    
    Parameters:
    out - the array receiving the result
  - multiply
```
public static double[] multiply(double[] a1,
                double[] a2)
```
    Element-wise multiplication of two double arrays
  - multiply
```
public static float[] multiply(float[] a1,
               float[] a2,
               float[] out)
```
    Element-wise multiplication of two float arrays (result in output if defined)
    
    Parameters:
    out - the array receiving the result
  - multiply
```
public static float[] multiply(float[] a1,
               float[] a2)
```
    Element-wise multiplication of two float arrays
  - multiply
```
public static long[] multiply(long[] a1,
              long[] a2,
              long[] out)
```
    Element-wise multiplication of two long arrays (result in output if defined)
    
    Parameters:
    out - the array receiving the result
  - multiply
```
public static long[] multiply(long[] a1,
              long[] a2)
```
    Element-wise multiplication of two long arrays
  - multiply
```
public static int[] multiply(int[] a1,
             int[] a2,
             int[] out)
```
    Element-wise multiplication of two int arrays (result in output if defined)
    
    Parameters:
    out - the array receiving the result
  - multiply
```
public static int[] multiply(int[] a1,
             int[] a2)
```
    Element-wise multiplication of two int arrays
  - multiply
```
public static short[] multiply(short[] a1,
               short[] a2,
               short[] out)
```
    Element-wise multiplication of two short arrays (result in output if defined)
    
    Parameters:
    out - the array receiving the result
  - multiply
```
public static short[] multiply(short[] a1,
               short[] a2)
```
    Element-wise multiplication of two short arrays
  - multiply
```
public static byte[] multiply(byte[] a1,
              byte[] a2,
              byte[] out)
```
    Element-wise multiplication of two byte arrays (result in output if defined)
    
    Parameters:
    out - the array receiving the result
  - multiply
```
public static byte[] multiply(byte[] a1,
              byte[] a2)
```
    Element-wise multiplication of two byte arrays
  - multiply
```
public static java.lang.Object multiply(java.lang.Object array,
                        java.lang.Number value,
                        java.lang.Object out)
```
    Multiplies a value to all elements of the given array
    
    Parameters:
    out - the array receiving the result
  - multiply
```
public static java.lang.Object multiply(java.lang.Object array,
                        java.lang.Number value)
```
    Multiplies a value to all elements of the given array
  - multiply
```
public static double[] multiply(double[] array,
                double value,
                double[] out)
```
    Multiplies a value to all elements of the given double array
    
    Parameters:
    out - the array receiving the result
  - multiply
```
@Deprecated
public static double[] multiply(double value,
                           double[] array,
                           double[] out)
```
    Deprecated. use multiply(double[] , double , double[]) instead
  - multiply
```
public static double[] multiply(double[] array,
                double value)
```
    Multiplies a value to all elements of the given double array
  - multiply
```
public static float[] multiply(float[] array,
               float value,
               float[] out)
```
    Multiplies a value to all elements of the given float array
    
    Parameters:
    out - the array receiving the result
  - multiply
```
public static float[] multiply(float[] array,
               float value)
```
    Multiplies a value to all elements of the float given array
  - multiply
```
public static long[] multiply(long[] array,
              long value,
              long[] out)
```
    Multiplies a value to all elements of the given long array
    
    Parameters:
    out - the array receiving the result
  - multiply
```
public static long[] multiply(long[] array,
              long value)
```
    Multiplies a value to all elements of the given long array
  - multiply
```
public static int[] multiply(int[] array,
             int value,
             int[] out)
```
    Multiplies a value to all elements of the given int array
    
    Parameters:
    out - the array receiving the result
  - multiply
```
public static int[] multiply(int[] array,
             int value)
```
    Multiplies a value to all elements of the given int array
  - multiply
```
public static short[] multiply(short[] array,
               short value,
               short[] out)
```
    Multiplies a value to all elements of the given short array
    
    Parameters:
    out - the array receiving the result
  - multiply
```
public static short[] multiply(short[] array,
               short value)
```
    Multiplies a value to all elements of the given short array
  - multiply
```
public static byte[] multiply(byte[] array,
              byte value,
              byte[] out)
```
    Multiplies a value to all elements of the given byte array
    
    Parameters:
    out - the array receiving the result
  - multiply
```
public static byte[] multiply(byte[] array,
              byte value)
```
    Multiplies a value to all elements of the given byte array
  - divide
```
public static java.lang.Object divide(java.lang.Object a1,
                      java.lang.Object a2,
                      java.lang.Object out)
```
    Element-wise division of two arrays
    
    Parameters:
    out - the array receiving the result
  - divide
```
public static java.lang.Object divide(java.lang.Object a1,
                      java.lang.Object a2)
```
    Element-wise division of two arrays
  - divide
```
public static double[] divide(double[] a1,
              double[] a2,
              double[] out)
```
    Element-wise division of two double arrays (result in output if defined)
    
    Parameters:
    out - the array receiving the result
  - divide
```
public static double[] divide(double[] a1,
              double[] a2)
```
    Element-wise division of two double arrays
  - divide
```
public static float[] divide(float[] a1,
             float[] a2,
             float[] out)
```
    Element-wise division of two float arrays (result in output if defined)
    
    Parameters:
    out - the array receiving the result
  - divide
```
public static float[] divide(float[] a1,
             float[] a2)
```
    Element-wise division of two float arrays
  - divide
```
public static long[] divide(long[] a1,
            long[] a2,
            long[] out)
```
    Element-wise division of two long arrays (result in output if defined)
    
    Parameters:
    out - the array receiving the result
  - divide
```
public static long[] divide(long[] a1,
            long[] a2)
```
    Element-wise division of two long arrays
  - divide
```
public static int[] divide(int[] a1,
           int[] a2,
           int[] out)
```
    Element-wise division of two int arrays (result in output if defined)
    
    Parameters:
    out - the array receiving the result
  - divide
```
public static int[] divide(int[] a1,
           int[] a2)
```
    Element-wise division of two int arrays
  - divide
```
public static short[] divide(short[] a1,
             short[] a2,
             short[] out)
```
    Element-wise division of two short arrays (result in output if defined)
    
    Parameters:
    out - the array receiving the result
  - divide
```
public static short[] divide(short[] a1,
             short[] a2)
```
    Element-wise division of two short arrays
  - divide
```
public static byte[] divide(byte[] a1,
            byte[] a2,
            byte[] out)
```
    Element-wise division of two byte arrays (result in output if defined)
    
    Parameters:
    out - the array receiving the result
  - divide
```
public static byte[] divide(byte[] a1,
            byte[] a2)
```
    Element-wise division of two byte arrays
  - divide
```
public static java.lang.Object divide(java.lang.Object array,
                      java.lang.Number value,
                      java.lang.Object out)
```
    Divides a value to all elements of the given array
    
    Parameters:
    out - the array receiving the result
  - divide
```
public static java.lang.Object divide(java.lang.Object array,
                      java.lang.Number value)
```
    Divides a value to all elements of the given array
  - divide
```
public static double[] divide(double[] array,
              double value,
              double[] out)
```
    Divides a value to all elements of the given double array
    
    Parameters:
    out - the array receiving the result
  - divide
```
public static double[] divide(double[] array,
              double value)
```
    Divides a value to all elements of the given double array
  - divide
```
public static float[] divide(float[] array,
             float value,
             float[] out)
```
    Divides a value to all elements of the given float array
    
    Parameters:
    out - the array receiving the result
  - divide
```
public static float[] divide(float[] array,
             float value)
```
    Divides a value to all elements of the float given array
  - divide
```
public static long[] divide(long[] array,
            long value,
            long[] out)
```
    Divides a value to all elements of the given long array
    
    Parameters:
    out - the array receiving the result
  - divide
```
public static long[] divide(long[] array,
            long value)
```
    Divides a value to all elements of the given long array
  - divide
```
public static int[] divide(int[] array,
           int value,
           int[] out)
```
    Divides a value to all elements of the given int array
    
    Parameters:
    out - the array receiving the result
  - divide
```
public static int[] divide(int[] array,
           int value)
```
    Divides a value to all elements of the given int array
  - divide
```
public static short[] divide(short[] array,
             short value,
             short[] out)
```
    Divides a value to all elements of the given short array
    
    Parameters:
    out - the array receiving the result
  - divide
```
public static short[] divide(short[] array,
             short value)
```
    Divides a value to all elements of the given short array
  - divide
```
public static byte[] divide(byte[] array,
            byte value,
            byte[] out)
```
    Divides a value to all elements of the given byte array
    
    Parameters:
    out - the array receiving the result
  - divide
```
public static byte[] divide(byte[] array,
            byte value)
```
    Divides a value to all elements of the given byte array
  - divide
```
public static java.lang.Object divide(java.lang.Number value,
                      java.lang.Object array,
                      java.lang.Object out)
```
    Divides a value by all elements of the given array
    
    Parameters:
    out - the array receiving the result
  - divide
```
public static java.lang.Object divide(java.lang.Number value,
                      java.lang.Object array)
```
    Divides a value by all elements of the given array
  - divide
```
public static double[] divide(double value,
              double[] array,
              double[] out)
```
    Subtracts a value by all elements of the given double array
    
    Parameters:
    out - the array receiving the result
  - divide
```
public static double[] divide(double value,
              double[] array)
```
    Divides a value by all elements of the given double array
  - divide
```
public static float[] divide(float value,
             float[] array,
             float[] out)
```
    Divides a value by all elements of the given float array
    
    Parameters:
    out - the array receiving the result
  - divide
```
public static float[] divide(float value,
             float[] array)
```
    Divides a value by all elements of the float given array
  - divide
```
public static long[] divide(long value,
            long[] array,
            long[] out)
```
    Divides a value by all elements of the given long array
    
    Parameters:
    out - the array receiving the result
  - divide
```
public static long[] divide(long value,
            long[] array)
```
    Divides a value by all elements of the given long array
  - divide
```
public static int[] divide(int value,
           int[] array,
           int[] out)
```
    Divides a value by all elements of the given int array
    
    Parameters:
    out - the array receiving the result
  - divide
```
public static int[] divide(int value,
           int[] array)
```
    Divides a value by all elements of the given int array
  - divide
```
public static short[] divide(short value,
             short[] array,
             short[] out)
```
    Divides a value by all elements of the given short array
    
    Parameters:
    out - the array receiving the result
  - divide
```
public static short[] divide(short value,
             short[] array)
```
    Divides a value by all elements of the given short array
  - divide
```
public static byte[] divide(byte value,
            byte[] array,
            byte[] out)
```
    Divides a value by all elements of the given byte array
    
    Parameters:
    out - the array receiving the result
  - divide
```
public static byte[] divide(byte value,
            byte[] array)
```
    Divides a value by all elements of the given byte array
  - abs
```
public static java.lang.Object abs(java.lang.Object array,
                   boolean overwrite)
```
    Computes the absolute value of each value of the given array
    
    Parameters:
    overwrite - true : overwrites the input data
    false: returns the result in a new array
  - abs
```
public static double[] abs(double[] input,
           boolean overwrite)
```
    Computes the absolute value of each value of the given double array
    
    Parameters:
    overwrite - true overwrites the input data, false returns the result in a new structure
  - abs
```
public static float[] abs(float[] input,
          boolean overwrite)
```
    Computes the absolute value of each value of the given float array
    
    Parameters:
    overwrite - true overwrites the input data, false returns the result in a new structure
  - abs
```
public static long[] abs(long[] input,
         boolean overwrite)
```
    Computes the absolute value of each value of the given long array
    
    Parameters:
    overwrite - true overwrites the input data, false returns the result in a new structure
  - abs
```
public static int[] abs(int[] input,
        boolean overwrite)
```
    Computes the absolute value of each value of the given int array
    
    Parameters:
    overwrite - true overwrites the input data, false returns the result in a new structure
  - abs
```
public static short[] abs(short[] input,
          boolean overwrite)
```
    Computes the absolute value of each value of the given short array
    
    Parameters:
    overwrite - true overwrites the input data, false returns the result in a new structure
  - abs
```
public static byte[] abs(byte[] input,
         boolean overwrite)
```
    Computes the absolute value of each value of the given byte array
    
    Parameters:
    overwrite - true overwrites the input data, false returns the result in a new structure
  - min
```
public static double min(java.lang.Object array,
         boolean signed)
```
    Find the minimum value of a generic array
    
    Parameters:
    array - an array
    signed - signed / unsigned flag
    
    Returns:
    the min value of the array
  - min
```
public static int min(byte[] array,
      boolean signed)
```
    Find the minimum value of an array
    
    Parameters:
    array - an array
    signed - signed / unsigned flag
    
    Returns:
    the min value of the array
  - min
```
public static int min(short[] array,
      boolean signed)
```
    Find the minimum value of an array
    
    Parameters:
    array - an array
    signed - signed / unsigned flag
    
    Returns:
    the min value of the array
  - min
```
public static long min(int[] array,
       boolean signed)
```
    Find the minimum value of an array
    
    Parameters:
    array - an array
    signed - signed / unsigned flag
    
    Returns:
    the min value of the array
  - min
```
public static long min(long[] array,
       boolean signed)
```
    Find the minimum value of an array
    
    Parameters:
    array - an array
    signed - signed / unsigned flag
    
    Returns:
    the min value of the array
  - min
```
public static float min(float[] array)
```
    Find the minimum value of an array
    
    Parameters:
    array - an array
    
    Returns:
    the min value of the array
  - min
```
public static double min(double[] array)
```
    Find the minimum value of an array
    
    Parameters:
    array - an array
    
    Returns:
    the min value of the array
  - max
```
public static double max(java.lang.Object array,
         boolean signed)
```
    Find the maximum value of a generic array
    
    Parameters:
    array - an array
    signed - signed / unsigned flag
    
    Returns:
    the max value of the array
  - max
```
public static int max(byte[] array,
      boolean signed)
```
    Find the maximum value of an array
    
    Parameters:
    array - an array
    signed - signed / unsigned flag
    
    Returns:
    the max value of the array
  - max
```
public static int max(short[] array,
      boolean signed)
```
    Find the maximum value of an array
    
    Parameters:
    array - an array
    signed - signed / unsigned flag
    
    Returns:
    the max value of the array
  - max
```
public static long max(int[] array,
       boolean signed)
```
    Find the maximum value of an array
    
    Parameters:
    array - an array
    signed - signed / unsigned flag
    
    Returns:
    the max value of the array
  - max
```
public static long max(long[] array,
       boolean signed)
```
    Find the maximum value of an array
    
    Parameters:
    array - an array
    signed - signed / unsigned flag
    
    Returns:
    the max value of the array
  - max
```
public static float max(float[] array)
```
    Find the maximum value of an array
    
    Parameters:
    array - an array
    
    Returns:
    the max value of the array
  - max
```
public static double max(double[] array)
```
    Find the maximum value of an array
    
    Parameters:
    array - an array
    
    Returns:
    the max value of the array
  - min
```
public static void min(double[] a1,
       double[] a2,
       double[] output)
```
    Element-wise minimum of two arrays
    
    Parameters:
    a1 - =input1
    a2 - =input2
    output - - the array of min values
  - min
```
public static double[] min(double[] a1,
           double[] a2)
```
    Element-wise minimum of two arrays
    
    Parameters:
    a1 - =input1
    a2 - =input2
    
    Returns:
    the array of min values
  - max
```
public static void max(double[] a1,
       double[] a2,
       double[] output)
```
    Element-wise maximum of two arrays
    
    Parameters:
    a1 - =input1
    a2 - =input2
    output - - the array of max values
  - max
```
public static double[] max(double[] a1,
           double[] a2)
```
    Element-wise maximum of two arrays
    
    Parameters:
    a1 - =input1
    a2 - =input2
    
    Returns:
    the array of max values
  - median
```
public static double median(double[] input,
            boolean preserveData)
```
    Reorders the given array to compute its median value
    
    Parameters:
    input -
    preserveData - set to true if the given array should not be changed (a copy will be made)
  - mad
```
public static double mad(double[] input,
         boolean normalPopulation)
```
    Computes the Maximum Absolute Deviation aka MAD of the given array
    
    Parameters:
    input -
    normalPopulation - normalizes the population by 1.4826
  - select
```
public static double select(int k,
            double[] data)
```
    (routine ported from 'Numerical Recipes in C 2nd ed.')
    Computes the k-th smallest value in the input array and rearranges the array such that the wanted value is located at data[k-1], Lower values are stored in arbitrary order in data[0 .. k-2] Higher values will be stored in arbitrary order in data[k .. end]
    
    Parameters:
    k -
    data -
    
    Returns:
    the k-th smallest value in the array
  - sum
```
public static double sum(java.lang.Object array,
         boolean signed)
```
    Computes the sum of all values from the specified input array.
    
    Parameters:
    array - an array
    signed - signed / unsigned flag
    
    Returns:
    the sum of all values from the array
  - sum
```
public static double sum(byte[] input,
         boolean signed)
```
    Computes the sum of all values in the input array
    
    Parameters:
    input - the array to sum up
    signed - signed / unsigned flag
  - sum
```
public static double sum(short[] input,
         boolean signed)
```
    Computes the sum of all values in the input array
    
    Parameters:
    input - the array to sum up
    signed - signed / unsigned flag
  - sum
```
public static double sum(int[] input,
         boolean signed)
```
    Computes the sum of all values in the input array
    
    Parameters:
    input - the array to sum up
    signed - signed / unsigned flag
  - sum
```
public static double sum(long[] input,
         boolean signed)
```
    Computes the sum of all values in the input array
    
    Parameters:
    input - the array to sum up
    signed - signed / unsigned flag
  - sum
```
public static double sum(float[] input)
```
    Computes the sum of all values in the input array
    
    Parameters:
    input - the array to sum up
  - sum
```
public static double sum(double[] input)
```
    Computes the sum of all values in the input array
    
    Parameters:
    input - the array to sum up
  - mean
```
public static double mean(double[] input)
```
    Computes the mean value of the given array
    
    Parameters:
    input -
  - var
```
public static double var(double[] input,
         boolean unbiased)
```
    Computes the unbiased variance of the given array
    
    Parameters:
    input -
    unbiased - set to true if the result should be normalized by the population size minus 1
  - std
```
public static double std(double[] input,
         boolean unbiased)
```
    Computes the standard deviation of the given array (the variance square root)
    
    Parameters:
    input -
    unbiased - set to true if the variance should be unbiased
    
    Returns:
    the square root of the variance
  - rescale
```
public static double[] rescale(double[] input,
               double newMin,
               double newMax,
               boolean overwrite)
```
    Rescales the given array to [newMin,newMax]. Nothing is done if the input is constant or if the new bounds equal the old ones.
    
    Parameters:
    input - the input array
    newMin - the new min bound
    newMax - the new max bound
    overwrite - true overwrites the input data, false returns the result in a new structure
  - standardize
```
public static double[] standardize(double[] input,
                   boolean overwrite)
```
    Standardize the input data by subtracting the mean value and dividing by the standard deviation
    
    Parameters:
    input - the data to standardize
    overwrite - true if the output should overwrite the input, false if a new array should be returned
    
    Returns:
    the standardized data
  - correlation
```
public static double correlation(double[] a,
                 double[] b)
                          throws java.lang.IllegalArgumentException
```
    Computes the classical correlation coefficient between 2 populations.
    This coefficient is given by:
```
                       sum(a[i] * b[i])
 r(a,b) = -------------------------------------------
          sqrt( sum(a[i] * a[i]) * sum(b[i] * b[i]) )
 
```
    Parameters:
    a - a population
    b - a population
    
    Returns:
    the correlation coefficient between a and b.
    
    Throws:
    
    java.lang.IllegalArgumentException - if the two input population have different sizes
  - correlationPearson
```
public static double correlationPearson(double[] a,
                        double[] b)
                                 throws java.lang.IllegalArgumentException
```
    Computes the Pearson correlation coefficient between two populations of same size N.
    This coefficient is computed by:
```
          sum(a[i] * b[i]) - N * mean(a) * mean(b)
 r(a,b) = ----------------------------------------
                  (N-1) * std(a) * std(b)
 
```
    Parameters:
    a - a population
    b - a population
    
    Returns:
    the Pearson correlation measure between a and b.
    
    Throws:
    
    java.lang.IllegalArgumentException - if the two input population have different sizes

Icy Developer Documentation

Class ArrayMath

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

ArrayMath

Method Detail

add

add

add

add

add

add

add

add

add

add

add

add

add

add

add

add

add

add

add

add

add

add

add

add

add

add

add

add

add

subtract

subtract

subtract

subtract

subtract

subtract

subtract

subtract

subtract

subtract

subtract

subtract

subtract

subtract

subtract

subtract

subtract

subtract

subtract

subtract

subtract

subtract

subtract

subtract

subtract

subtract

subtract

subtract

subtract

subtract

subtract

subtract

subtract

subtract

subtract

subtract

subtract

subtract

subtract

subtract

subtract

subtract

multiply