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 Static Methods Concrete Methods Deprecated 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 2.2 © jWork.ORG

Warning: You see this message because an access to the SCaVis documentation for third-party Java classes is denied. Guests can only view jhplot Java API. To enable the description of all Java classes of SCaVis, please request the full SCaVis membership.

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