IntegerArray (jmatharray 1.0 API)

java.lang.Object
- org.math.array.IntegerArray

```
public class IntegerArray
extends Object
```
A collection of static methods for generating, modifying, and reading arrays and matrices of integers. BSD License

Author:

Yann RICHET

Constructor Summary

Constructors
Constructor and Description

IntegerArray()

Constructors
Constructor and Description
`IntegerArray()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static int[]`	`copy(int[] M)` Generate a copy of an array
`static int[][]`	`copy(int[][] M)` Generate a copy of a matrix
`static int[]`	`cumProduct(int[] v)` Calculates cumulative product of the values in an array.
`static int[][]`	`cumProduct(int[][] v)` Calculates the cumulative product of each column in a matrix.
`static int[]`	`cumSum(int[] v)` Calculates the cumulative sum of an array.
`static int[][]`	`cumSum(int[][] v)` Calculates the cumulative sum of each column in a matrix.
`static int[]`	`delete(int[] x, int... J)` Delete a list of elements from an array.
`static int[][]`	`deleteColumns(int[][] x, int... J)` Deletes a list of columns from a matrix.
`static int[][]`	`deleteColumnsRange(int[][] x, int J1, int J2)` Deletes a range of columns from a matrix.
`static int[]`	`deleteRange(int[] x, int J1, int J2)` Delete a range of elements from an array.
`static int[][]`	`deleteRows(int[][] x, int... I)` Deletes a list of rows from a matrix.
`static int[][]`	`deleteRowsRange(int[][] x, int I1, int I2)` Deletes a range of rows from a matrix.
`static int[][]`	`diagonal(int m, int c)` Returns an m x m matrix. result has constants along the diagonal and zeros everywhere else.
`static int[]`	`fill(int m, int c)` Generates an m point array of constants
`static int[][]`	`fill(int m, int n, int c)` Returns an mxn matrix of constants
`static int[]`	`floor(double[] v)` Truncates each double value in an array to an integer that is less than or equal to the double.
`static int[][]`	`floor(double[][] v)` Truncates each double value in a matrix to an integer that is less than or equal to the double.
`static int[]`	`getColumnCopy(int[][][] M, int j, int k)` Extract one column from a three dimensional array.
`static int[]`	`getColumnCopy(int[][] M, int j)` Extract one column from a matrix.
`static int`	`getColumnDimension(int[][] M, int i)` Get the number of columns in a specified row of a matrix.
`static int[][]`	`getColumnsCopy(int[][] M, int... J)` Extract specific columns from a matrix.
`static int[][]`	`getColumnsRangeCopy(int[][] M, int j1, int j2)` Extract a range of columns from a matrix.
`static int[]`	`getCopy(int[] M, int... I)` Extract specific elements from an array.
`static int[]`	`getDiagonal(int[][] M, int I)` Extract diagonal from a matrix.
`static int[]`	`getRangeCopy(int[] M, int j1, int j2)` Extract a section of an array.
`static int[]`	`getRowCopy(int[][] M, int i)` Extract a row from a matrix.
`static int[][]`	`getRowsCopy(int[][] M, int... I)` Extract specific rows from a matrix.
`static int[][]`	`getRowsRangeCopy(int[][] M, int i1, int i2)` Extract a range of rows from a matrix.
`static int[][]`	`getSubMatrixRangeCopy(int[][] M, int i1, int i2, int j1, int j2)` Carve out a submatrix from the input matrix and return a copy.
`static int[]`	`insert(int[] x, int I, int... y)` Insert any number of values, or a single array, between 2 elements of an array.
`static int[][]`	`insertColumns(int[][] x, int J, int[]... y)` Insert any number of arrays between 2 columns of a matrix.
`static int[][]`	`insertRows(int[][] x, int I, int[]... y)` Insert any number of arrays between 2 rows of a matrix.
`static double[]`	`int2double(int[] v)` Converts each element in an integer array to a double
`static double[][]`	`int2double(int[][] v)` Converts each element in an integer matrix to a double
`static int`	`max(int... M)` Finds maximum value in either a list of numbers or a single array.
`static int[]`	`max(int[][] M)` Finds the maximum value in each column of a matrix.
`static int`	`maxIndex(int... M)` Finds the index of the maximum value in a list of values or an array.
`static int[]`	`maxIndex(int[][] M)` Finds the indices of the maximum values in each column of a matrix.
`static int[]`	`merge(int[]... x)` Concatenates arrays.
`static int[][]`	`mergeColumns(int[]... x)` Combine a set of arrays into a matrix.
`static int[][]`	`mergeRows(int[]... x)` Combine a set of arrays into a matrix.
`static int`	`min(int... M)` Finds minimum value in either a list of numbers or a single array.
`static int[]`	`min(int[][] M)` Finds the minimum value in each column of a matrix.
`static int`	`minIndex(int... M)` Finds the index of the minumum value in a list of values or an array.
`static int[]`	`minIndex(int[][] M)` Finds the indices of the minimum values in each column of a matrix.
`static int`	`product(int[] v)` Calculates the product of the values in an array.
`static int[]`	`product(int[][] v)` Calculates the product of the values in each column of a matrix.
`static int`	`sum(int[] v)` Calculate the sum of the values in an array
`static int[]`	`sum(int[][] v)` Calculates the sum of each column in a matrix.
`static String`	`toString(int[]... v)` Generates a string that holds a nicely organized version of a matrix or array.
`static String`	`toString(String format, int[]... v)` Generates a string that holds a nicely organized version of a matrix or array.
`static int[][]`	`transpose(int[][] M)` Transposes an mxn matrix into an nxm matrix.

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

- Constructor Detail
  - IntegerArray
```
public IntegerArray()
```
- Method Detail
  - diagonal
```
public static int[][] diagonal(int m,
                               int c)
```
    Returns an m x m matrix. result has constants along the diagonal and zeros everywhere else.
    
    Parameters:
    
    m - an integer > 0.
    
    c - Constant that lies along diagonal. Set c=1 for identity matrix.
    
    Returns:
    
    m x m two dimensional array of integers.
  - fill
```
public static int[][] fill(int m,
                           int n,
                           int c)
```
    Returns an mxn matrix of constants
    
    Parameters:
    
    m - number of rows in matrix
    
    n - number of columns in matrix
    
    c - constant matrix is filled with.
    
    Returns:
    
    mxn two dimensional array of constants
  - fill
```
public static int[] fill(int m,
                         int c)
```
    Generates an m point array of constants
    
    Parameters:
    
    m - Size of array
    
    c - constant array is to be filled with
    
    Returns:
    
    array of constants.
  - floor
```
public static int[][] floor(double[][] v)
```
    Truncates each double value in a matrix to an integer that is less than or equal to the double.
    
    Parameters:
    
    v - The input matrix of doubles
    
    Returns:
    
    The truncated version of the input matrix.
  - floor
```
public static int[] floor(double[] v)
```
    Truncates each double value in an array to an integer that is less than or equal to the double.
    
    Parameters:
    
    v - The input array of doubles
    
    Returns:
    
    The truncated version of the input matrix.
  - int2double
```
public static double[][] int2double(int[][] v)
```
    Converts each element in an integer matrix to a double
    
    Parameters:
    
    v - matrix of integers
    
    Returns:
    
    matrix of doubles
  - int2double
```
public static double[] int2double(int[] v)
```
    Converts each element in an integer array to a double
    
    Parameters:
    
    v - array of integers
    
    Returns:
    
    array of doubles
  - copy
```
public static int[] copy(int[] M)
```
    Generate a copy of an array
    
    Parameters:
    
    M - Input array.
    
    Returns:
    
    A copy of the input array.
  - copy
```
public static int[][] copy(int[][] M)
```
    Generate a copy of a matrix
    
    Parameters:
    
    M - Input matrix.
    
    Returns:
    
    A copy of the input matrix
  - getSubMatrixRangeCopy
```
public static int[][] getSubMatrixRangeCopy(int[][] 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:
    int[][] 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}}; int[][] b = getSubMatrixRangeCopy(a, 2, 3, 1, 3); Result is: 13 14 15 19 20 21
    
    Parameters:
    
    M - Input matrix
    
    i1 - first row in cut
    
    i2 - last row in cut
    
    j1 - first column in cut
    
    j2 - last column in cut
    
    Returns:
    
    submatrix. Input matrix is left unharmed.
  - getColumnsRangeCopy
```
public static int[][] getColumnsRangeCopy(int[][] M,
                                          int j1,
                                          int j2)
```
    Extract a range of columns from a matrix. Example:
    int[][] 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}}; int[][] 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 int[][] getColumnsCopy(int[][] M,
                                     int... J)
```
    Extract specific columns from a matrix. Example:
    int[][] 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}}; int[][] 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 int[] getColumnCopy(int[][] M,
                                  int j)
```
    Extract one column from a matrix.
    Example:
    int[][] 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}}; int[][] 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 int[] getColumnCopy(int[][][] 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 int[][] getRowsCopy(int[][] M,
                                  int... I)
```
    Extract specific rows from a matrix. Example:
    int[][] 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}}; int[][] 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. There can be as many indices listed as there are rows in M.
    
    Returns:
    
    An mxn matrix where m=number of indices listed and n=number of columns in m
  - getRowCopy
```
public static int[] getRowCopy(int[][] M,
                               int i)
```
    Extract a row from a matrix. Example:
    int[][] 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}}; int[] 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 int[][] getRowsRangeCopy(int[][] M,
                                       int i1,
                                       int i2)
```
    Extract a range of rows from a matrix. Example:
    int[][] 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}}; int[][] 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 int[] getRangeCopy(int[] M,
                                 int j1,
                                 int j2)
```
    Extract a section of an array. Example:
    int[] a = {00,11,22,33,44,55,66,77,88,99}; int[] 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 int[] getCopy(int[] M,
                            int... I)
```
    Extract specific elements from an array. Example:
    int[] a = {00,11,22,33,44,55,66,77,88,99}; int[] 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(int[][] 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 int[] getDiagonal(int[][] M,
                                int I)
```
    Extract diagonal from a matrix. Example:
    int[][] 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}}; int[] 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 int[][] mergeRows(int[]... x)
```
    Combine a set of arrays into a matrix. Each array becomes a row. Example:
    int[] a = {0,11,22,33,44}, b = {55,66,77,88}; int[][] z = mergeRows(a, b); result is: 0 11 22 33 44 55 66 77 88
    
    Parameters:
    
    x - Input arrays
    
    Returns:
    
    A matrix. May non-rectangular if arrays are not all the same length.
  - mergeColumns
```
public static int[][] mergeColumns(int[]... x)
```
    Combine a set of arrays into a matrix. Each array becomes a column. Arrays must all be of same length. Example:
    int[] a = {00,11,22,33,44}, b = {55,66,77,88,99}; int[][] 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.
  - merge
```
public static int[] merge(int[]... x)
```
    Concatenates arrays.
    Example:
    int[] a = {00,11,22,33,44}, b = {55,66,77,88,99}; int[] 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 int[][] insertColumns(int[][] x,
                                    int J,
                                    int[]... 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:
    int[][] 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}}; int[] b = {00,11,22,33,44}, c = {55,66,77,88,99}; int[][] 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 int[][] insertRows(int[][] x,
                                 int I,
                                 int[]... 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:
    int[][] a = {{0,1,2,3,4},{1,7,8,9,10},{2,13,14,15,16},{3,19,20,21,22}}; int[] b = {0,11,22,33,44}, c = {55,66,77,88,99}; int[][] 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 int[] insert(int[] x,
                           int I,
                           int... y)
```
    Insert any number of values, or a single array, between 2 elements of an array. Example:
    int[] b = {00,11,22,33,44}, c = {55,66,77,88,99}; int[] z = insert(b, 2, 333, 444); result is: 0 11 333 444 22 33 44 int[] 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 int[][] deleteColumnsRange(int[][] x,
                                         int J1,
                                         int J2)
```
    Deletes a range of columns from a matrix. Example:
    int[][] 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}}; int[][] 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 int[][] deleteColumns(int[][] x,
                                    int... J)
```
    Deletes a list of columns from a matrix. Example:
    int[][] 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}}; int[][] 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 int[][] deleteRowsRange(int[][] x,
                                      int I1,
                                      int I2)
```
    Deletes a range of rows from a matrix. Example:
    int[][] 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}}; int[][] 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 int[][] deleteRows(int[][] x,
                                 int... I)
```
    Deletes a list of rows from a matrix. Example:
    int[][] 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}}; int[][] 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 int[] deleteRange(int[] x,
                                int J1,
                                int J2)
```
    Delete a range of elements from an array. Example:
    int[] b = {00,11,22,33,44}; int[] 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 int[] delete(int[] x,
                           int... J)
```
    Delete a list of elements from an array. Example:
    int[] b = {00,11,22,33,44}; int[] 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.
  - min
```
public static int[] min(int[][] M)
```
    Finds the minimum value in each column of a matrix. Example:
    int[][] a = {{0, 13, 22, 3, 44}, {1, 7, 28, 9, 10}, {2, 1, 14, 15, 6}, {3, 19, 20, 21, 2}, {4, 23, 24, 25, 6}}; int[] z = min(a); Result is: 0 1 14 3 2
    
    Parameters:
    
    M - The input matrix
    
    Returns:
    
    Array of minimums from each column of M.
  - min
```
public static int min(int... 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 int[] max(int[][] M)
```
    Finds the maximum value in each column of a matrix. Example:
    int[][] 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 = 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 int max(int... 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(int[][] M)
```
    Finds the indices of the minimum values in each column of a matrix. Example:
    int[][] a = {{0, 13, 22, 3, 44}, {1, 7, 28, 9, 10}, {2, 1, 14, 15, 6}, {3, 19, 20, 21, 2}, {4, 23, 24, 25, 6}}; int[] z = minIndex(a); Result is: 0 2 2 0 3
    
    Parameters:
    
    M - Input matrix.
    
    Returns:
    
    Array of indices of the minimums from each column of M.
  - minIndex
```
public static int minIndex(int... 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(int[][] M)
```
    Finds the indices of the maximum values in each column of a matrix. Example:
    int[][] 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(int... 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 int sum(int[] v)
```
    Calculate the sum of the values in an array
    
    Parameters:
    
    v - input array
    
    Returns:
    
    sum of values in v
  - sum
```
public static int[] sum(int[][] 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 int[] cumSum(int[] v)
```
    Calculates the cumulative sum of an array. Think of it as an integral. Example:
    int[] b = {0,1,2,3,4}; int[] 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 int[][] cumSum(int[][] v)
```
    Calculates the cumulative sum of each column in a matrix. Example:
    int[][] 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}}; int[][] 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 int product(int[] 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 int[] product(int[][] 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 int[] cumProduct(int[] v)
```
    Calculates cumulative product of the values in an array. Example:
    int[] b = {1,2,3,4}; int[] 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 int[][] cumProduct(int[][] v)
```
    Calculates the cumulative product of each column in a matrix. Example:
    int[][] 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(int[]... v)
```
    Generates a string that holds a nicely organized version of a matrix or array. Note the lower case S. It's tostring() not toString(). Example:
    int[][] a = {{1,22,333},{4444,555,7}}; System.out.println(tostring(a)); result is: 1 22 333 4444 555 7
    
    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,
                              int[]... v)
```
    Generates a string that holds a nicely organized version of a matrix or array. Uses format specifier, e.g. "%5d" An extra space is automatically included. Note the lower case S. It's tostring() not toString(). Example:
    int[][] a = fill(2, 3, 555); System.out.println(tostring("%11d", a)); result is: 555 555 555 555 555 555
    
    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.
  - transpose
```
public static int[][] transpose(int[][] M)
```
    Transposes an mxn matrix into an nxm matrix. Each row of the input matrix becomes a column in the output matrix.
    
    Parameters:
    
    M - Input matrix.
    
    Returns:
    
    Transposed version of M.

Class IntegerArray

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

IntegerArray

Method Detail

diagonal

fill

fill

floor

floor

int2double

int2double

copy

copy

getSubMatrixRangeCopy

getColumnsRangeCopy

getColumnsCopy

getColumnCopy

getColumnCopy

getRowsCopy

getRowCopy

getRowsRangeCopy

getRangeCopy

getCopy

getColumnDimension

getDiagonal

mergeRows

mergeColumns

merge

insertColumns

insertRows

insert

deleteColumnsRange

deleteColumns

deleteRowsRange

deleteRows

deleteRange

delete

min

min

max

max

minIndex

minIndex

maxIndex

maxIndex

sum

sum

cumSum

cumSum

product

product

cumProduct

cumProduct

toString

toString

transpose