DoubleArray

java.lang.Object
- jhplot.math.DoubleArray

Direct Known Subclasses:

LinearAlgebra
```
public class DoubleArray
extends Object
```
A class for dealing with double arrays and matrices. Copyright : BSD License

Constructor Summary

Constructors
Constructor and Description

DoubleArray()

Constructors
Constructor and Description
`DoubleArray()`

Method Summary

All Methods Static Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`static double[][]`	`add(double[][] M, double a)` Adds a single value to a matrix, e.g.
`static double[][]`	`add(double[][] M1, double[][] M2)` Adds a matrix to another matrix, which should be of the same dimension.
`static double[][]`	`buildXY(double[] X, double[] Y)` Join two arrays into a matrix.
`static double[][]`	`buildXY(double Xmin, double Xmax, double[] Y)` Generate a two column matrix.
`static void`	`checkColumnDimension(double[][] M, int n)` Checks to make sure each row of a matrix is of a specified dimension.
`static void`	`checkLength(double[] M, int n)` Checks to make sure an array is of a specified length.
`static void`	`checkRowDimension(double[][] M, int m)` Checks to make sure each column of a matrix is of a specified dimension.
`static double[][]`	`columnVector(double[] x)` Converts an n element array into an n x 1 matrix.
`static double[]`	`copy(double[] M)` Generate a copy of an array
`static double[][]`	`copy(double[][] M)` Generate a copy of a matrix
`static double[]`	`cumProduct(double[] v)` Calculates cumulative product of the values in an array.
`static double[][]`	`cumProduct(double[][] v)` Calculates the cumulative product of each column in a matrix.
`static double[]`	`cumSum(double[] v)` Calculates the cumulative sum of an array.
`static double[][]`	`cumSum(double[][] v)` Calculates the cumulative sum of each column in a matrix.
`static double[]`	`delete(double[] x, int... J)` Delete a list of elements from an array.
`static double[][]`	`deleteColumns(double[][] x, int... J)` Deletes a list of columns from a matrix.
`static double[][]`	`deleteColumnsRange(double[][] x, int J1, int J2)` Deletes a range of columns from a matrix.
`static double[]`	`deleteRange(double[] x, int J1, int J2)` Delete a range of elements from an array.
`static double[][]`	`deleteRows(double[][] x, int... I)` Deletes a list of rows from a matrix.
`static double[][]`	`deleteRowsRange(double[][] x, int I1, int I2)` Deletes a range of rows from a matrix.
`static double[][]`	`diagonal(double... c)` Returns an m x m matrix.
`static double[][]`	`diagonal(int m, double c)` Returns an m x m matrix.
`static double[][]`	`f(double[][] M, Function f)` Apply a scalar function to every element of an array.
`static double[]`	`f(double[] M, Function func)` Apply a scalar function to every element of an array.
`static double[]`	`fill(int m, double c)` Provides an m element array filled with constant c.
`static double[][]`	`fill(int m, int n, double c)` Fills an m x n matrix of doubles with constant c.
`static double[]`	`findex(int m, IndexFunction f)` Provides a sequence of values to which some function has been applied.
`static double[]`	`getColumnCopy(double[][][] M, int j, int k)` Extract one column from a three dimensional array.
`static double[]`	`getColumnCopy(double[][] M, int j)` Extract one column from a matrix.
`static int`	`getColumnDimension(double[][] M, int i)` Get the number of columns in a specified row of a matrix.
`static double[][]`	`getColumnsCopy(double[][] M, int... J)` Extract specific columns from a matrix.
`static double[][]`	`getColumnsRangeCopy(double[][] M, int j1, int j2)` Extract a range of columns from a matrix.
`static double[]`	`getCopy(double[] M, int... I)` Extract specific elements from an array.
`static double[]`	`getDiagonal(double[][] M, int I)` Extract diagonal from a matrix.
`static double[]`	`getRangeCopy(double[] M, int j1, int j2)` Extract a section of an array.
`static double[]`	`getRowCopy(double[][] M, int i)` Extract a row from a matrix.
`static double[][]`	`getRowsCopy(double[][] M, int... I)` Extract specific rows from a matrix.
`static double[][]`	`getRowsRangeCopy(double[][] M, int i1, int i2)` Extract a range of rows from a matrix.
`static double[][]`	`getSubMatrixRangeCopy(double[][] M, int i1, int i2, int j1, int j2)` Carve out a submatrix from the input matrix and return a copy.
`static double[][]`	`identity(int m)` Generates an m x m identity matrix.
`static double[]`	`increment(double begin, double pitch, double end)` Generates an array of successive values from begin to end with step size pitch.
`static double[]`	`increment(int m, double begin, double pitch)` Provides a sequence of successive values in an array.
`static double[][]`	`increment(int m, int n, double[] begin, double[] pitch)` Generates an mxn matrix.
`static double[][]`	`increment(int m, int n, double begin, double pitch)` Provides an mxn matrix.
`static double[]`	`insert(double[] x, int I, double... y)` Insert any number of values, or a single array, between 2 elements of an array.
`static double[][]`	`insertColumns(double[][] x, int J, double[]... y)` Insert any number of arrays between 2 columns of a matrix.
`static double[][]`	`insertRows(double[][] x, int I, double[]... y)` Insert any number of arrays between 2 rows of a matrix.
`static boolean`	`isColumnDimension(double[][] M, int n)` Same as checkColumnDimension() but just returns a boolean value rather than throwing an exception.
`static boolean`	`isLength(double[] M, int n)` Same as checkLength but returns a boolean value rather than throwing an exception.
`static boolean`	`isRowDimension(double[][] M, int m)` Same as checkRowDimension() but just returns a boolean value rather than throwing an exception.
`static void`	`main(String[] args)`
`static double`	`max(double... M)` Finds maximum value in either a list of numbers or a single array.
`static double[]`	`max(double[][] M)` Finds the maximum value in each column of a matrix.
`static int`	`maxIndex(double... M)` Finds the index of the maximum value in a list of values or an array.
`static int[]`	`maxIndex(double[][] M)` Finds the indices of the minimum values in each column of a matrix.
`static double[]`	`merge(double[]... x)` Concatenates arrays.
`static double[][]`	`mergeColumns(double[]... x)` Combine a set of arrays into a matrix.
`static double[][]`	`mergeRows(double[]... x)` Combine a set of arrays into a matrix.
`static double`	`min(double... M)` Finds minimum value in either a list of numbers or a single array.
`static double[]`	`min(double[][] M)` Finds the minimum value in each column of a matrix.
`static int`	`minIndex(double... M)` Finds the index of the minumum value in a list of values or an array.
`static int[]`	`minIndex(double[][] M)` Finds the indices of the minimum values in each column of a matrix.
`static double[]`	`one(int m)` Deprecated. use `fill(int m, double c)` instead.
`static double[]`	`one(int m, double c)` Deprecated. Use `fill(int m, double c)` instead.
`static double[][]`	`one(int m, int n)` Deprecated. use `fill(int m, int n, 1.0)` instead.
`static double[][]`	`one(int m, int n, double c)` Deprecated. use `fill(int m, int n, double c)` instead.
`static double`	`product(double[] v)` Calculates the product of the values in an array.
`static double[]`	`product(double[][] v)` Calculates the product of the values in each column of a matrix.
`static double[]`	`random(int m)` Generates an m element array of random numbers uniformly distributed between 0 and 1.
`static double[]`	`random(int m, double min, double max)` Generates an m element array of random numbers uniformly distributed between min and max.
`static double[][]`	`random(int m, int n)` Generates an m x n matrix of random numbers uniformly distributed between 0 and 1.
`static double[][]`	`random(int m, int n, double[] min, double[] max)` Generates an m x n matrix of random numbers uniformly distributed numbers.
`static double[][]`	`random(int m, int n, double min, double max)` Generates an mxn matrix of random numbers uniformly distributed between min and max.
`static double[][]`	`resize(double[][] M, int m, int n)` Generate a resized copy of a matrix
`static double[][]`	`rowVector(double[] x)` Converts an n element array into an 1 x n matrix.
`static double[]`	`sort(double[] values)` Sorts an array in ascending order.
`static double[][]`	`sort(double[][] values, int column)` Sorts the rows of a matrix using a specified column as the key.
`static double`	`sum(double[] v)` Calculate the sum of the values in an array
`static double[]`	`sum(double[][] v)` Calculates the sum of each column in a matrix.
`static void`	`throwError(String msg)` Throws an error exception if an argument is invalid.
`static String`	`toString(double[]... v)` Generates a string that holds a nicely organized space-seperated version of a matrix or array.
`static String`	`toString(String format, double[]... v)` Generates a string that holds a nicely organized version of a matrix or array.
`static double[][]`	`transpose(double[][] M)` Transposes an mxn matrix into an nxm matrix.

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

- Constructor Detail
  - DoubleArray
```
public DoubleArray()
```
- Method Detail
  - main
```
public static void main(String[] args)
```
  - add
```
public static double[][] add(double[][] M,
                             double a)
```
    Adds a single value to a matrix, e.g. adds the constant value a to all element of the matrix M.
    
    Returns:
    
    The resulting matrix.
  - add
```
public static double[][] add(double[][] M1,
                             double[][] M2)
```
    Adds a matrix to another matrix, which should be of the same dimension.
    
    Returns:
    
    The resulting matrix.
  - identity
```
public static double[][] identity(int m)
```
    Generates an m x m identity matrix. Result has ones along the diagonal and zeros everywhere else. Example:
    double[][] id = identity(3); Result is: 1.0 0.0 0.0 0.0 1.0 0.0 0.0 0.0 1.0
    
    Parameters:
    
    m - an integer > 0.
    
    Returns:
    
    m x m two dimensional array of doubles.
  - diagonal
```
public static double[][] diagonal(int m,
                                  double c)
```
    Returns an m x m matrix. result has constants along the diagonal and zeros everywhere else. Example:
    double[][] eig = diagonal(3, 2.1); Result is: 2.1 0.0 0.0 0.0 2.1 0.0 0.0 0.0 2.1
    
    Parameters:
    
    m - an integer > 0.
    
    c - Constant that lies along diagonal. Set c=1 for identity matrix.
    
    Returns:
    
    m x m 2D array of doubles.
  - diagonal
```
public static double[][] diagonal(double... c)
```
    Returns an m x m matrix. result has specified values along the diagonal and zeros everywhere else. Example:
    double[][] eig = diagonal(1.0,2.0,3.0); Result is: 1.0 0.0 0.0 0.0 2.0 0.0 0.0 0.0 3.0
    
    Parameters:
    
    c - Values that lies along diagonal.
    
    Returns:
    
    c.length x c.length 2D array of doubles.
  - one
```
public static double[][] one(int m,
                             int n)
```
    Deprecated. use fill(int m, int n, 1.0) instead.
    
    Provides an m x n matrix filled with ones.
    
    Parameters:
    
    m - Number of rows in returned matrix
    
    n - Number of columns in returned matrix
    
    Returns:
    
    m x n 2D array of ones
  - one
```
public static double[][] one(int m,
                             int n,
                             double c)
```
    Deprecated. use fill(int m, int n, double c) instead.
    
    Provides an mxn matrix filled with constant c
    
    Parameters:
    
    m - Number of rows in returned matrix
    
    n - Number of columns in returned matrix
    
    c - Constant that fills matrix
    
    Returns:
    
    m x n 2D array of constants
  - one
```
public static double[] one(int m)
```
    Deprecated. use fill(int m, double c) instead.
    
    Provides an m element array filled with ones
    
    Parameters:
    
    m - Number of elements in returned array
    
    Returns:
    
    m element array of ones
  - one
```
public static double[] one(int m,
                           double c)
```
    Deprecated. Use fill(int m, double c) instead.
    
    Provides an m element array filled with constant c
    
    Parameters:
    
    m - Number of elements in returned array
    
    c - Constant that fills array
    
    Returns:
    
    m element array of constants
  - fill
```
public static double[][] fill(int m,
                              int n,
                              double c)
```
    Fills an m x n matrix of doubles with constant c. Example:
    double[][] u = fill(2, 3, 1.0); Result is: 1.0 1.0 1.0 1.0 1.0 1.0
    
    Parameters:
    
    m - Number of rows in matrix
    
    n - Number of columns in matrix
    
    c - constant that fills matrix
    
    Returns:
    
    m x n 2D array of constants c
  - fill
```
public static double[] fill(int m,
                            double c)
```
    Provides an m element array filled with constant c. Example:
    double[] u = fill(3, 1.0); Result is: 1.0 1.0 1.0
    
    Parameters:
    
    m - Number of elements in returned array
    
    c - Constant that fills array
    
    Returns:
    
    m element array of constants
  - random
```
public static double[][] random(int m,
                                int n)
```
    Generates an m x n matrix of random numbers uniformly distributed between 0 and 1.
    
    Parameters:
    
    m - Number of rows in matrix
    
    n - Number of columns in matrix
    
    Returns:
    
    2D array of random numbers.
  - random
```
public static double[] random(int m)
```
    Generates an m element array of random numbers uniformly distributed between 0 and 1.
    
    Parameters:
    
    m - Size of array
    
    Returns:
    
    Array of random numbers.
  - random
```
public static double[][] random(int m,
                                int n,
                                double min,
                                double max)
```
    Generates an mxn matrix of random numbers uniformly distributed between min and max.
    
    Parameters:
    
    m - Number of rows in matrix
    
    n - Number of columns in matrix
    
    min - minimum value of the random numbers
    
    max - maximum value of the random numbers
    
    Returns:
    
    2D array of random numbers.
  - random
```
public static double[] random(int m,
                              double min,
                              double max)
```
    Generates an m element array of random numbers uniformly distributed between min and max.
    
    Parameters:
    
    m - Size of array
    
    min - minimum value of the random numbers
    
    max - maximum value of the random numbers
    
    Returns:
    
    Array of random numbers.
  - random
```
public static double[][] random(int m,
                                int n,
                                double[] min,
                                double[] max)
```
    Generates an m x n matrix of random numbers uniformly distributed numbers. The bounds of the random numbers each column are in the arrays min and max. So the values in column j are uniformly distributed random numbers between min[j] and max[j]
    
    Parameters:
    
    m - Number of rows in matrix
    
    n - Number of columns in matrix
    
    min - minimum value of the random numbers in a column
    
    max - maximum value of the random numbers in a column
    
    Returns:
    
    2D array of random numbers.
  - increment
```
public static double[][] increment(int m,
                                   int n,
                                   double begin,
                                   double pitch)
```
    Provides an mxn matrix. Each column is a sequence of successive values of stepsize pitch and starts at begin. The columns are all identical.
    
    Parameters:
    
    m - Number of rows in matrix
    
    n - Number of columns in matrix
    
    begin - First value in sequence
    
    pitch - Step size of sequence
    
    Returns:
    
    m x n 2D array
  - increment
```
public static double[] increment(int m,
                                 double begin,
                                 double pitch)
```
    Provides a sequence of successive values in an array. e.g. increment(4, 3, 2) = {3,5,7,9}
    
    Parameters:
    
    m - Size of array
    
    begin - Starting value
    
    pitch - Step size
    
    Returns:
    
    m point array. Sequence of values from begin to begin + (m-1)*pitch
  - increment
```
public static double[][] increment(int m,
                                   int n,
                                   double[] begin,
                                   double[] pitch)
```
    Generates an mxn matrix. Each column is a sequence of succesive values. Each column has it's own starting value and step size.
    
    Parameters:
    
    m - Number of rows in matrix
    
    n - Number of columns in matrix
    
    begin - Array of starting values for each column. length must = n.
    
    pitch - Array of step sizes for each column. length must = n.
    
    Returns:
    
    2D array
  - increment
```
public static double[] increment(double begin,
                                 double pitch,
                                 double end)
```
    Generates an array of successive values from begin to end with step size pitch.
    
    Parameters:
    
    begin - First value in sequence
    
    pitch - Step size of sequence
    
    end - Last value of sequence
    
    Returns:
    
    Array of successive values
  - copy
```
public static double[] copy(double[] M)
```
    Generate a copy of an array
    
    Parameters:
    
    M - Input array.
    
    Returns:
    
    A copy of the input array.
  - copy
```
public static double[][] copy(double[][] M)
```
    Generate a copy of a matrix
    
    Parameters:
    
    M - Input matrix.
    
    Returns:
    
    A copy of the input matrix
  - resize
```
public static double[][] resize(double[][] M,
                                int m,
                                int n)
```
    Generate a resized copy of a matrix
    
    Parameters:
    
    M - Input matrix.
    
    m - number of rows of new matrix.
    
    n - number of columns of new matrix.
    
    Returns:
    
    A resized copy of the input matrix
  - getSubMatrixRangeCopy
```
public static double[][] getSubMatrixRangeCopy(double[][] M,
                                               int i1,
                                               int i2,
                                               int j1,
                                               int j2)
```
    Carve out a submatrix from the input matrix and return a copy. Result is the intersection of rows i1 through i2 and columns j1 through j2 inclusive. Example:
    double[][] a = {{0,1,2,3,4},{1,7,8,9,10},{2,13,14,15,16},{3,19,20,21,22},{4,25,26,27,28}}; double[][] b = getSubMatrixRangeCopy(a, 2, 3, 1, 3); input is: 0 1 2 3 4 1 7 8 9 10 2 13 14 15 16 3 19 20 21 22 4 25 26 27 28 result is: 13 14 15 19 20 21
    
    Parameters:
    
    M - Input matrix
    
    i1 - Index of first row in cut
    
    i2 - Index of last row in cut
    
    j1 - Index of first column in cut
    
    j2 - Index of last column in cut
    
    Returns:
    
    submatrix. Input matrix is left unharmed.
  - getColumnsRangeCopy
```
public static double[][] getColumnsRangeCopy(double[][] M,
                                             int j1,
                                             int j2)
```
    Extract a range of columns from a matrix. Example:
    double[][] a = {{0,1,2,3,4},{1,7,8,9,10},{2,13,14,15,16},{3,19,20,21,22},{4,25,26,27,28}}; double[][] z = getColumnsRangeCopy(a, 2, 4); input is: 0 1 2 3 4 1 7 8 9 10 2 13 14 15 16 3 19 20 21 22 4 25 26 27 28 result is: 2 3 4 8 9 10 14 15 16 20 21 22 26 27 28
    
    Parameters:
    
    M - Input matrix
    
    j1 - Index of first column to be extracted.
    
    j2 - Index of last column to be extracted.
    
    Returns:
    
    An mxn matrix where m=number of rows in M and n=j2-j1+1
  - getColumnsCopy
```
public static double[][] getColumnsCopy(double[][] M,
                                        int... J)
```
    Extract specific columns from a matrix. Example:
    double[][] a = {{0,1,2,3,4},{1,7,8,9,10},{2,13,14,15,16},{3,19,20,21,22},{4,25,26,27,28}}; double[][] z = getColumnsCopy(a, 2, 4); input is: 0 1 2 3 4 1 7 8 9 10 2 13 14 15 16 3 19 20 21 22 4 25 26 27 28 result is: 0 2 4 1 8 10 2 14 16 3 20 22 4 26 28
    
    Parameters:
    
    M - Input matrix
    
    J - Each is the index of a column. There can be as many indices listed as there are columns in M.
    
    Returns:
    
    An mxn matrix where m=number of rows in M and n=number of indices listed
  - getColumnCopy
```
public static double[] getColumnCopy(double[][] M,
                                     int j)
```
    Extract one column from a matrix. Example:
    double[][] a = {{0,1,2,3,4},{1,7,8,9,10},{2,13,14,15,16},{3,19,20,21,22},{4,25,26,27,28}}; double[][] z = getColumnCopy(a, 2); input is: 0 1 2 3 4 1 7 8 9 10 2 13 14 15 16 3 19 20 21 22 4 25 26 27 28 Result is: 2 8 14 20 26
    
    Parameters:
    
    M - Input matrix
    
    j - Index of desired column
    
    Returns:
    
    Array of values from extracted column.
  - getColumnCopy
```
public static double[] getColumnCopy(double[][][] M,
                                     int j,
                                     int k)
```
    Extract one column from a three dimensional array. The result is an array of the values in the first dimension.
    
    Parameters:
    
    M - Input 3D array
    
    j - The index of the second dimension.
    
    k - The index of the third dimension
    
    Returns:
    
    An array
  - getRowsCopy
```
public static double[][] getRowsCopy(double[][] M,
                                     int... I)
```
    Extract specific rows from a matrix. Example:
    double[][] a = {{0,1,2,3,4},{1,7,8,9,10},{2,13,14,15,16},{3,19,20,21,22},{4,25,26,27,28}}; double[][] z = getRowsCopy(a, 2, 4); input is: 0 1 2 3 4 1 7 8 9 10 2 13 14 15 16 3 19 20 21 22 4 25 26 27 28 result is: 2 13 14 15 16 4 25 26 27 28
    
    Parameters:
    
    M - Input matrix
    
    I - Each is the index of a column.
    
    Returns:
    
    An mxn matrix where m=number of indices listed and n=number of columns in m
  - getRowCopy
```
public static double[] getRowCopy(double[][] M,
                                  int i)
```
    Extract a row from a matrix. Example:
    double[][] a = {{0,1,2,3,4},{1,7,8,9,10},{2,13,14,15,16},{3,19,20,21,22},{4,25,26,27,28}}; double[] z = getRowCopy(a, 2); input is: 0 1 2 3 4 1 7 8 9 10 2 13 14 15 16 3 19 20 21 22 4 25 26 27 28 result is: 2 13 14 15 16
    
    Parameters:
    
    M - Input matrix
    
    i - index of row to copy
    
    Returns:
    
    An array of n values where n = number of columns in M
  - getRowsRangeCopy
```
public static double[][] getRowsRangeCopy(double[][] M,
                                          int i1,
                                          int i2)
```
    Extract a range of rows from a matrix. Example:
    double[][] a = {{0,1,2,3,4},{1,7,8,9,10},{2,13,14,15,16},{3,19,20,21,22},{4,25,26,27,28}}; double[][] z = getRowsRangeCopy(a, 2, 4); input is: 0 1 2 3 4 1 7 8 9 10 2 13 14 15 16 3 19 20 21 22 4 25 26 27 28 result is: 2 13 14 15 16 3 19 20 21 22 4 25 26 27 28
    
    Parameters:
    
    M - Input matrix
    
    i1 - Index of first row to be extracted.
    
    i2 - Index of last row to be extracted.
    
    Returns:
    
    An mxn matrix where m=j2-j1+1 and n=number of columns in M
  - getRangeCopy
```
public static double[] getRangeCopy(double[] M,
                                    int j1,
                                    int j2)
```
    Extract a section of an array. Example:
    double[] a = {00,11,22,33,44,55,66,77,88,99}; double[] z = getRangeCopy(a, 2, 5); result is: 22 33 44 55
    
    Parameters:
    
    M - Input array
    
    j1 - Index of first term to get
    
    j2 - Index of last term to get
    
    Returns:
    
    An array with j2-j1+1 elements
  - getCopy
```
public static double[] getCopy(double[] M,
                               int... I)
```
    Extract specific elements from an array. Example:
    double[] a = {00,11,22,33,44,55,66,77,88,99}; double[] z = getCopy(a, 2, 5); result is: 22 55
    
    Parameters:
    
    M - The input array.
    
    I - the indices of the elements to extract
    
    Returns:
    
    The output array of n elements where n=number of indices listed.
  - getColumnDimension
```
public static int getColumnDimension(double[][] M,
                                     int i)
```
    Get the number of columns in a specified row of a matrix. Used for oddly sized matrices.
    
    Parameters:
    
    M - Input matrix
    
    i - Index of row whose column length will be returned
    
    Returns:
    
    The number of columns in row i
  - getDiagonal
```
public static double[] getDiagonal(double[][] M,
                                   int I)
```
    Extract diagonal from a matrix. Example:
    double[][] a = {{0,1,2,3,4},{1,7,8,9,10},{2,13,14,15,16},{3,19,20,21,22},{4,25,26,27,28}}; double[] z = getDiagonal(a, 1); input is: 0 1 2 3 4 1 7 8 9 10 2 13 14 15 16 3 19 20 21 22 4 25 26 27 28 result is: 1 8 15 22
    
    Parameters:
    
    M - Input matrix
    
    I - index of diagonal to copy
    
    Returns:
    
    An array
  - mergeRows
```
public static double[][] mergeRows(double[]... x)
```
    Combine a set of arrays into a matrix. Each array becomes a row. Rows may be of different lengths. Example:
    double[] a = {00,11,22,33,44}, b = {55,66,77,88}; double[][] z = mergeRows(a, b); result is: 0 11 22 33 44 55 66 77 88
    
    Parameters:
    
    x - Input arrays
    
    Returns:
    
    A matrix. Will be non-rectangular if arrays are not all the same length.
  - mergeColumns
```
public static double[][] mergeColumns(double[]... x)
```
    Combine a set of arrays into a matrix. Each array becomes a column. Arrays must all be of same length. Example:
    double[] a = {00,11,22,33,44}, b = {55,66,77,88,99}; double[][] z = mergeColumns(a, b); result is: 0 55 11 66 22 77 33 88 44 99
    
    Parameters:
    
    x - Input arrays
    
    Returns:
    
    An mxn matrix where m=size of any input array and n is the number of arrays.
  - columnVector
```
public static double[][] columnVector(double[] x)
```
    Converts an n element array into an n x 1 matrix. Handy for matrix math.
    
    Parameters:
    
    x - n element array
    
    Returns:
    
    n x 1 matrix
  - rowVector
```
public static double[][] rowVector(double[] x)
```
    Converts an n element array into an 1 x n matrix. Handy for matrix math.
    
    Parameters:
    
    x - n element array
    
    Returns:
    
    1 x n matrix
  - merge
```
public static double[] merge(double[]... x)
```
    Concatenates arrays. Example:
    double[] a = {00,11,22,33,44}, b = {55,66,77,88,99}; double[] z = merge(a, b, a); result is: 0 11 22 33 44 55 66 77 88 99 0 11 22 33 44
    
    Parameters:
    
    x - Input arrays
    
    Returns:
    
    Output array.
  - insertColumns
```
public static double[][] insertColumns(double[][] x,
                                       int J,
                                       double[]... y)
```
    Insert any number of arrays between 2 columns of a matrix. Size of the arrays must equal number of rows in the matrix. Example:
    double[][] a = {{0,1,2,3,4},{1,7,8,9,10},{2,13,14,15,16},{3,19,20,21,22},{4,23,24,25,26}}; double[] b = {00,11,22,33,44}, c = {55,66,77,88,99}; double[][] z = insertColumns(a, 2, b, c); input matrix is: 0 1 2 3 4 1 7 8 9 10 2 13 14 15 16 3 19 20 21 22 4 23 24 25 26 result is: 0 1 0 55 2 3 4 1 7 11 66 8 9 10 2 13 22 77 14 15 16 3 19 33 88 20 21 22 4 23 44 99 24 25 26
    
    Parameters:
    
    x - Input m x n matrix.
    
    J - Index of column before which the new columns will be inserted.
    
    y - The arrays to be inserted
    
    Returns:
    
    New matrix with added columns.
  - insertRows
```
public static double[][] insertRows(double[][] x,
                                    int I,
                                    double[]... y)
```
    Insert any number of arrays between 2 rows of a matrix. Size of the arrays must equal number of columns in the matrix. Example:
    double[][] a = {{0,1,2,3,4},{1,7,8,9,10},{2,13,14,15,16},{3,19,20,21,22}}; double[] b = {0,11,22,33,44}, c = {55,66,77,88,99}; double[][] z = insertRows(a, 1, b, c); result is: 0 1 2 3 4 0 11 22 33 44 55 66 77 88 99 1 7 8 9 10 2 13 14 15 16 3 19 20 21 22
    
    Parameters:
    
    x - Input m x n matrix.
    
    I - Index of row before which the new rows will be inserted.
    
    y - The arrays to be inserted
    
    Returns:
    
    New matrix with added rows.
  - insert
```
public static double[] insert(double[] x,
                              int I,
                              double... y)
```
    Insert any number of values, or a single array, between 2 elements of an array. Example:
    double[] b = {00,11,22,33,44}, c = {55,66,77,88,99}; double[] z = insert(b, 2, 333, 444); result is: 0 11 333 444 22 33 44 double[] z = insert(b, 2, c); result is: 0 11 55 66 77 88 99 22 33 44
    
    Parameters:
    
    x - Input array.
    
    I - Index of element before which the values will be inserted.
    
    y - Values to be inserted. Can also be a single array.
    
    Returns:
    
    Expanded array.
  - deleteColumnsRange
```
public static double[][] deleteColumnsRange(double[][] x,
                                            int J1,
                                            int J2)
```
    Deletes a range of columns from a matrix. Example:
    double[][] a = {{0,1,2,3,4},{1,7,8,9,10},{2,13,14,15,16},{3,19,20,21,22},{4,23,24,25,26}}; double[][] z = deleteColumnsRange(a, 1, 3); result is: 0 4 1 10 2 16 3 22 4 26
    
    Parameters:
    
    x - The input matrix
    
    J1 - The Index of the first column to delete.
    
    J2 - The index of the last column to delete.
    
    Returns:
    
    The reduced matrix.
  - deleteColumns
```
public static double[][] deleteColumns(double[][] x,
                                       int... J)
```
    Deletes a list of columns from a matrix. Example:
    double[][] a = {{0,1,2,3,4},{1,7,8,9,10},{2,13,14,15,16},{3,19,20,21,22},{4,23,24,25,26}}; double[][] z = deleteColumns(a, 1, 3); result is: 0 2 4 1 8 10 2 14 16 3 20 22 4 24 26
    
    Parameters:
    
    x - The input matrix
    
    J - The indices of the columns to be deleted. There must be no more indices listed than there are columns in the input matrix.
    
    Returns:
    
    The reduced matrix.
  - deleteRowsRange
```
public static double[][] deleteRowsRange(double[][] x,
                                         int I1,
                                         int I2)
```
    Deletes a range of rows from a matrix. Example:
    double[][] a = {{0,1,2,3,4},{1,7,8,9,10},{2,13,14,15,16},{3,19,20,21,22},{4,23,24,25,26}}; double[][] z = deleteRowsRange(a, 1, 3); result is: 0 1 2 3 4 4 23 24 25 26
    
    Parameters:
    
    x - The input matrix
    
    I1 - The Index of the first row to delete.
    
    I2 - The index of the last row to delete.
    
    Returns:
    
    The reduced matrix.
  - deleteRows
```
public static double[][] deleteRows(double[][] x,
                                    int... I)
```
    Deletes a list of rows from a matrix. Example:
    double[][] a = {{0,1,2,3,4},{1,7,8,9,10},{2,13,14,15,16},{3,19,20,21,22},{4,23,24,25,26}}; double[][] z = deleteRows(a, 1, 3); result is: 0 1 2 3 4 2 13 14 15 16 4 23 24 25 26
    
    Parameters:
    
    x - The input matrix
    
    I - The indices of the rows to delete.
    
    Returns:
    
    The reduced matrix.
  - deleteRange
```
public static double[] deleteRange(double[] x,
                                   int J1,
                                   int J2)
```
    Delete a range of elements from an array. Example:
    double[] b = {00,11,22,33,44}; double[] z = deleteRange(b, 1, 3); Result is: 0 44
    
    Parameters:
    
    x - Input array
    
    J1 - Index of first element to delete. Must be >= 0 and <= x.length
    
    J2 - Index of last element to delete. Must be >= J1 and <= x.length
    
    Returns:
    
    Reduced array.
  - delete
```
public static double[] delete(double[] x,
                              int... J)
```
    Delete a list of elements from an array. Example:
    double[] b = {00,11,22,33,44}; double[] z = deleteRange(b, 1, 3); Result is: 0 22 44
    
    Parameters:
    
    x - Input array
    
    J - Index of elements to delete. Each must be >= 0 and <= x.length
    
    Returns:
    
    Reduced array.
  - buildXY
```
public static double[][] buildXY(double Xmin,
                                 double Xmax,
                                 double[] Y)
```
    Generate a two column matrix. Second column is just the values in Y The first column is a uniform sequence of values from Xmin to Xmax. Step size is automatic. Useful for generating values for an x axis when y is already defined and bundling the pairs into a matrix. Example:
    double[] y = {0.0, 1.0, 4.0, 9.0, 16.0}; double[][] xy = buildXY(0.0, 4.0, y); result: 0.0 0.0 1.0 1.0 2.0 4.0 3.0 9.0 4.0 16.0
    
    Parameters:
    
    Xmin - The first value in the first column
    
    Xmax - The last value in the first column
    
    Y - An array that will fill the second column.
    
    Returns:
    
    nx2 array of values where n = length of y.
    
    Throws:
    
    IllegalArgumentException
  - buildXY
```
public static double[][] buildXY(double[] X,
                                 double[] Y)
```
    Join two arrays into a matrix. Each array becomes a column in the matrix. Example:
    double[] x = {0,1,2}; double[] y = {1,7,8}; double[][] z = buildXY(x, y); result is: 0 1 1 7 2 8
    
    See Also:
    
    mergeColumns(double[][])
  - min
```
public static double[] min(double[][] M)
```
    Finds the minimum value in each column of a matrix. Example:
    double[][] a = {{0, 1, 2, 3, 4}, {1, .7, 8, 9, 10}, {2, 13, 1.4, 1.5, 16}, {3, 19, 20, 21, 22}, {4, 23, 24, 25, 2.6}}; double[] z = min(a); Result is: 0.0 0.7 1.4 1.5 2.6
    
    Parameters:
    
    M - The input matrix
    
    Returns:
    
    Array of minimums from each column of M.
  - min
```
public static double min(double... M)
```
    Finds minimum value in either a list of numbers or a single array.
    
    Parameters:
    
    M - Can be a list of values e.g. min(1,22,333,.4) or an array.
    
    Returns:
    
    The minimum value.
  - max
```
public static double[] max(double[][] M)
```
    Finds the maximum value in each column of a matrix. Example:
    double[][] a = {{0, 1, 2, 3, 4}, {1, 7, 88, 9, 10}, {2, 13, 14, 15, 16}, {3, 19, 20, 201, 22}, {4, 23, 24, 25, 26}}; double[] z = max(a); Result is: 4 23 88 201 26
    
    Parameters:
    
    M - The input matrix
    
    Returns:
    
    Array of maximums from each column of M.
  - max
```
public static double max(double... M)
```
    Finds maximum value in either a list of numbers or a single array.
    
    Parameters:
    
    M - Can be a list of values e.g. min(1,22,333,.4) or an array.
    
    Returns:
    
    The maximum value.
  - minIndex
```
public static int[] minIndex(double[][] M)
```
    Finds the indices of the minimum values in each column of a matrix. Example:
    double[][] a = {{0, 1, 2, 3, 4}, {1, .7, 8, 9, 10}, {2, 13, 1.4, 1.5, 16}, {3, 19, 20, 21, 22}, {4, 23, 24, 25, 2.6}}; int[] z = minIndex(a); Result is: 0 1 2 2 4
    
    Parameters:
    
    M - Input matrix.
    
    Returns:
    
    Array of indices of the minimums from each column of M.
  - minIndex
```
public static int minIndex(double... M)
```
    Finds the index of the minumum value in a list of values or an array.
    
    Parameters:
    
    M - Can be a list of values e.g. minIndex(11,22,44,2) or an array
    
    Returns:
    
    index of minimum value in M
  - maxIndex
```
public static int[] maxIndex(double[][] M)
```
    Finds the indices of the minimum values in each column of a matrix. Example:
    double[][] a = {{0, 1, 2, 3, 4}, {1, 7, 88, 9, 10}, {2, 13, 14, 15, 16}, {3, 19, 20, 201, 22}, {4, 23, 24, 25, 26}}; int[] z = maxIndex(a); Result is: 4 4 1 3 4
    
    Parameters:
    
    M - Input matrix.
    
    Returns:
    
    Array of indices of the maximums from each column of M.
  - maxIndex
```
public static int maxIndex(double... M)
```
    Finds the index of the maximum value in a list of values or an array.
    
    Parameters:
    
    M - Can be a list of values e.g. maxIndex(11,22,44,2) or an array
    
    Returns:
    
    index of maximum value in M
  - sum
```
public static double sum(double[] v)
```
    Calculate the sum of the values in an array
    
    Parameters:
    
    v - input array
    
    Returns:
    
    sum of values in v
  - sum
```
public static double[] sum(double[][] v)
```
    Calculates the sum of each column in a matrix.
    
    Parameters:
    
    v -
    
    Returns:
    
    Array. value of i'th element is sum of values in column(i)
  - cumSum
```
public static double[] cumSum(double[] v)
```
    Calculates the cumulative sum of an array. Think of it as an integral. Example:
    double[] b = {0,1,2,3,4}; double[] z = cumSum(b); result is: 0 1 3 6 10
    
    Parameters:
    
    v - Input array.
    
    Returns:
    
    Output array of same length as v.
  - cumSum
```
public static double[][] cumSum(double[][] v)
```
    Calculates the cumulative sum of each column in a matrix. Example:
    double[][] a = {{0, 1, 2, 3, 4}, {1, 7, 8, 9, 10}, {2, 13, 14, 15, 16}, {3, 19, 20, 21, 22}, {4, 23, 24, 25, 26}}; double[][] z = cumSum(a); result is: 0 1 2 3 4 1 8 10 12 14 3 21 24 27 30 6 40 44 48 52 10 63 68 73 78
    
    Parameters:
    
    v -
    
    Returns:
    
    Output matrix. Each column is the cumulative sum of each column in v.
  - product
```
public static double product(double[] v)
```
    Calculates the product of the values in an array.
    
    Parameters:
    
    v - Input array.
    
    Returns:
    
    The product of the values in v.
  - product
```
public static double[] product(double[][] v)
```
    Calculates the product of the values in each column of a matrix.
    
    Parameters:
    
    v - Input matrix.
    
    Returns:
    
    An array of n values where n=number of columns in v. The i'th element is product of the values in the i'th column of v.
  - cumProduct
```
public static double[] cumProduct(double[] v)
```
    Calculates cumulative product of the values in an array. Example:
    double[] b = {1,2,3,4}; double[] z = cumProduct(b); Result is: 1 2 6 24
    
    Parameters:
    
    v - Input array
    
    Returns:
    
    Out put array of same size as v.
  - cumProduct
```
public static double[][] cumProduct(double[][] v)
```
    Calculates the cumulative product of each column in a matrix. Example:
    double[][] a = {{0, 1, 2, 3, 4}, {1, 7, 8, 9, 10}, {2, 13, 14, 15, 16}, {3, 19, 20, 21, 22}, {4, 23, 24, 25, 26}}; result is: 0 1 2 3 4 0 7 16 27 40 0 91 224 405 640 0 1729 4480 8505 14080 0 39767 107520 212625 366080
    
    Parameters:
    
    v -
    
    Returns:
    
    Output matrix. Each column is the cumulative product of each column in v.
  - toString
```
public static String toString(double[]... v)
```
    Generates a string that holds a nicely organized space-seperated version of a matrix or array. An extra space is automatically included. Note the lower case S. It's tostring() not toString(). Example:
    double[][] a = {{1.234, 4.5, 6.78},{1.2, 3.45, 6.789}}; System.out.println(tostring(a)); result is: 1.234 4.5 6.78 1.2 3.45 6.789
    
    Parameters:
    
    v - Matrix or array
    
    Returns:
    
    A string of a nicely organized version of the matrix or array.
  - toString
```
public static String toString(String format,
                              double[]... v)
```
    Generates a string that holds a nicely organized version of a matrix or array. Uses format specifier, e.g. "%5.3f", "%11.1E", ... An extra space is automatically included. Note the lower case S. It's tostring() not toString(). Example:
    double[][] a = random(2, 3); System.out.println(tostring("%7.3f", a)); result is: 0.654 0.115 0.422 0.560 0.839 0.280
    
    Parameters:
    
    format - A standard format specifier for one value
    
    v - Matrix or array
    
    Returns:
    
    A string of a nicely organized version of the matrix or array.
  - throwError
```
public static void throwError(String msg)
```
    Throws an error exception if an argument is invalid. Handy to make sure the right number of values is passed around.
    
    Parameters:
    
    msg - Message to be printed if the error occurs.
    
    Throws:
    
    IllegalArgumentException
  - checkColumnDimension
```
public static void checkColumnDimension(double[][] M,
                                        int n)
```
    Checks to make sure each row of a matrix is of a specified dimension. Handy for making sure matrices are rectangular.
    
    Parameters:
    
    M - Input matrix
    
    n - Number of elements that should be in each row of M
    
    Throws:
    
    IllegalArgumentException
  - isColumnDimension
```
public static boolean isColumnDimension(double[][] M,
                                        int n)
```
    Same as checkColumnDimension() but just returns a boolean value rather than throwing an exception.
    
    Parameters:
    
    M - Input matrix
    
    n - Number of elements that should be in each row of M
    
    Returns:
    
    true if each row of M has n values. false otherwise.
    
    See Also:
    
    checkColumnDimension(double[][], int)
  - checkRowDimension
```
public static void checkRowDimension(double[][] M,
                                     int m)
```
    Checks to make sure each column of a matrix is of a specified dimension. Handy for making sure matrices are rectangular.
    
    Parameters:
    
    M - Input matrix
    
    m - Number of elements that should be in each column of M.
    
    Throws:
    
    IllegalArgumentException
  - isRowDimension
```
public static boolean isRowDimension(double[][] M,
                                     int m)
```
    Same as checkRowDimension() but just returns a boolean value rather than throwing an exception.
    
    Parameters:
    
    M - Input matrix
    
    m - Number of elements that should be in each column of M
    
    Returns:
    
    true if each column of M has n values. false otherwise.
    
    See Also:
    
    checkRowDimension(double[][], int)
  - checkLength
```
public static void checkLength(double[] M,
                               int n)
```
    Checks to make sure an array is of a specified length.
    
    Parameters:
    
    M - Input array.
    
    n - Required number of elements in M
    
    Throws:
    
    IllegalArgumentException
  - isLength
```
public static boolean isLength(double[] M,
                               int n)
```
    Same as checkLength but returns a boolean value rather than throwing an exception.
    
    Parameters:
    
    M - Input array.
    
    n - Required number of elements in M.
    
    Returns:
    
    true if M.length==n. false otherwise.
  - f
```
public static double[][] f(double[][] M,
                           Function f)
```
    Apply a scalar function to every element of an array. Must import org.math.array.util.*; to get Function interface. The function named f in Function must be overridden. Be careful not to define any other functions named f in your code. Example:
    double[] b = {{1,2,3,4},{5,6,7,8}}; Function inverse = new Function() { public double f(double x) { return 1/x; }}; double[] z = f(b, inverse); Result is: 1.00 0.50 0.333 0.25 0.20 0.167 0.143 0.125
    
    Parameters:
    
    M - The input array
    
    f - Function object
    
    Returns:
    
    array of same size as M.
  - f
```
public static double[] f(double[] M,
                         Function func)
```
    Apply a scalar function to every element of an array. Must import org.math.array.util.*; to get Function interface. Example:
    double[] b = {1,2,3,4}; Function inverse = new Function() { public double f(double x) { return 1/x; }}; double[] z = f(b, inverse); Result is: 1.00 0.50 0.33 0.25
    
    Parameters:
    
    M - The input array
    
    func - Function object whose sole method f(double) has already been overridden.
    
    Returns:
    
    array of same size as M.
  - findex
```
public static double[] findex(int m,
                              IndexFunction f)
```
    Provides a sequence of values to which some function has been applied. Sort of a mutant version of increment(). Example:
    IndexFunction square = new IndexFunction() { public double fi(int x) { return x*x; }}; double[] z = findex(5, square); Result is: 0 1 4 9 16
    
    Parameters:
    
    m - Number of terms in the output array. The values 0..m-1 will be fed to the function
    
    f - An IndexFunction object whose method fi(int) has already been overridden.
    
    Returns:
    
    An array of m elements. fi(0), fi(1), ... fi(m-1)
  - sort
```
public static double[] sort(double[] values)
```
    Sorts an array in ascending order.
    
    Parameters:
    
    values - Input array
    
    Returns:
    
    Sorted version of input array.
  - sort
```
public static double[][] sort(double[][] values,
                              int column)
```
    Sorts the rows of a matrix using a specified column as the key. Example:
    double[][] a = {{3, 5, 2, 1, 2}, {1, 3, 8, 9, 0}, {2, 4, 2, 5, 6}, {0, 1, 2, 3, 4}, {4, 2, 1, 5, 2}}; double[][] z = sort(a,1); Result is: 0 1 2 3 4 4 2 1 5 2 1 3 8 9 0 2 4 2 5 6 3 5 2 1 2 Fixed (I hope) 3/28/06.
    
    Parameters:
    
    values - Input matrix
    
    column - Index of column to be used as the sorting key.
    
    Returns:
    
    Matrix whose rows have been shuffled around.
  - transpose
```
public static double[][] transpose(double[][] M)
```
    Transposes an mxn matrix into an nxm matrix. Each row of the input matrix becomes a column in the output matrix.
    
    Parameters:
    
    M - Input matrix.
    
    Returns:
    
    Transposed version of M.

Class DoubleArray

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

DoubleArray

Method Detail

main

add

add

identity

diagonal

diagonal

one

one

one

one

fill

fill

random

random

random

random

random

increment

increment

increment

increment

copy

copy

resize

getSubMatrixRangeCopy

getColumnsRangeCopy

getColumnsCopy

getColumnCopy

getColumnCopy

getRowsCopy

getRowCopy

getRowsRangeCopy

getRangeCopy

getCopy

getColumnDimension

getDiagonal

mergeRows

mergeColumns

columnVector

rowVector

merge

insertColumns

insertRows

insert

deleteColumnsRange

deleteColumns

deleteRowsRange

deleteRows

deleteRange

delete

buildXY

buildXY

min

min

max

max

minIndex

minIndex

maxIndex

maxIndex

sum

sum

cumSum

cumSum

product

product

cumProduct

cumProduct

toString

toString

throwError

checkColumnDimension

isColumnDimension