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

      Methods 
      Modifier and TypeMethod 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 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)
      • 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.

SCaVis 1.7 © jWork.org