Documentation API of the 'jhplot.math.DoubleArray' Java class
DoubleArray
jhplot.math

## Class DoubleArray

• Direct Known Subclasses:
LinearAlgebra

public class DoubleArrayextends Object
A class for dealing with double arrays and matrices. Copyright : BSD License
• ### Constructor Summary

Constructors
Constructor and Description
DoubleArray()
• ### Method Summary

All Methods
Modifier and TypeMethod and Description
Adds a single value to a matrix, e.g.
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 voidcheckColumnDimension(double[][] M, int n)
Checks to make sure each row of a matrix is of a specified dimension.
static voidcheckLength(double[] M, int n)
Checks to make sure an array is of a specified length.
static voidcheckRowDimension(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 intgetColumnDimension(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 booleanisColumnDimension(double[][] M, int n)
Same as checkColumnDimension() but just returns a boolean value rather than throwing an exception.
static booleanisLength(double[] M, int n)
Same as checkLength but returns a boolean value rather than throwing an exception.
static booleanisRowDimension(double[][] M, int m)
Same as checkRowDimension() but just returns a boolean value rather than throwing an exception.
static voidmain(String[] args)
static doublemax(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 intmaxIndex(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 doublemin(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 intminIndex(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 doubleproduct(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 doublesum(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 voidthrowError(String msg)
Throws an error exception if an argument is invalid.
static StringtoString(double[]... v)
Generates a string that holds a nicely organized space-seperated version of a matrix or array.
static StringtoString(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.
• ### Constructor Detail

• #### DoubleArray

public DoubleArray()
• ### Method Detail

• #### main

public static void main(String[] args)

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.

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:
• #### 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:
• #### 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
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.
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.
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.

DMelt 1.2 © DataMelt by jWork.ORG

DoubleArray
jhplot.math

## Class DoubleArray

• Direct Known Subclasses:
LinearAlgebra

public class DoubleArrayextends Object
A class for dealing with double arrays and matrices. Copyright : BSD License

Warning: You cannot see the full API documentation of this class since the access to the DatMelt documentation for third-party Java classes is denied. Guests can only view jhplot Java API. To view the complete description of this class and its methods, please request the full DataMelt membership.

If you are already a full member, please login to the DataMelt member area before visiting this documentation.