## Uses of Class
cern.colt.matrix.DoubleMatrix2D

- Packages that use DoubleMatrix2D
  Package | Description
  --- | ---
  cern.colt.matrix | Matrix interfaces and factories; efficient and flexible dense and sparse 1, 2, 3 and d-dimensional matrices holding objects or primitive data types such as `int`, `double`, etc; Templated, fixed sized (not dynamically resizable); Also known as multi-dimensional arrays or Data Cubes.
  cern.colt.matrix.doublealgo | Double matrix algorithms such as print formatting, sorting, partitioning and statistics.
  cern.colt.matrix.impl | Matrix implementations; You normally need not look at this package, because all concrete classes implement the abstract interfaces of `cern.colt.matrix`, without subsetting or supersetting.
  cern.colt.matrix.linalg | Linear Algebraic matrix computations operating on `DoubleMatrix2D` and `DoubleMatrix1D`.

- - ### Uses of DoubleMatrix2D in cern.colt.matrix

    Methods in cern.colt.matrix that return DoubleMatrix2D
    Modifier and Type | Method and Description
    --- | ---
    `DoubleMatrix2D` | DoubleFactory2D.`appendColumns(DoubleMatrix2D A, DoubleMatrix2D B)` C = A||B; Constructs a new matrix which is the column-wise concatenation of two other matrices.
    `DoubleMatrix2D` | DoubleFactory2D.`appendRows(DoubleMatrix2D A, DoubleMatrix2D B)` C = A||B; Constructs a new matrix which is the row-wise concatenation of two other matrices.
    `DoubleMatrix2D` | DoubleFactory2D.`ascending(int rows, int columns)` Constructs a matrix with cells having ascending values.
    `DoubleMatrix2D` | DoubleMatrix2D.`assign(double value)` Sets all cells to the state specified by `value`.
    `DoubleMatrix2D` | DoubleMatrix2D.`assign(double[][] values)` Sets all cells to the state specified by `values`.
    `DoubleMatrix2D` | DoubleMatrix2D.`assign(DoubleFunction function)` Assigns the result of a function to each cell; `x[row,col] = function(x[row,col])`.
    `DoubleMatrix2D` | DoubleMatrix2D.`assign(DoubleMatrix2D other)` Replaces all cell values of the receiver with the values of another matrix.
    `DoubleMatrix2D` | DoubleMatrix2D.`assign(DoubleMatrix2D y, DoubleDoubleFunction function)` Assigns the result of a function to each cell; `x[row,col] = function(x[row,col],y[row,col])`.
    `DoubleMatrix2D` | DoubleFactory2D.`compose(DoubleMatrix2D[][] parts)` Constructs a block matrix made from the given parts.
    `DoubleMatrix2D` | DoubleFactory2D.`composeDiagonal(DoubleMatrix2D A, DoubleMatrix2D B)` Constructs a diagonal block matrix from the given parts (the direct sum of two matrices).
    `DoubleMatrix2D` | DoubleFactory2D.`composeDiagonal(DoubleMatrix2D A, DoubleMatrix2D B, DoubleMatrix2D C)` Constructs a diagonal block matrix from the given parts.
    `DoubleMatrix2D` | DoubleMatrix2D.`copy()` Constructs and returns a deep copy of the receiver.
    `DoubleMatrix2D` | DoubleFactory2D.`descending(int rows, int columns)` Constructs a matrix with cells having descending values.
    `DoubleMatrix2D` | DoubleFactory2D.`diagonal(DoubleMatrix1D vector)` Constructs a new diagonal matrix whose diagonal elements are the elements of `vector`.
    `DoubleMatrix2D` | DoubleMatrix2D.`forEachNonZero(IntIntDoubleFunction function)` Assigns the result of a function to each non-zero cell; `x[row,col] = function(x[row,col])`.
    `DoubleMatrix2D` | DoubleFactory2D.`identity(int rowsAndColumns)` Constructs an identity matrix (having ones on the diagonal and zeros elsewhere).
    `DoubleMatrix2D` | DoubleMatrix2D.`like()` Construct and returns a new empty matrix of the same dynamic type as the receiver, having the same number of rows and columns.
    `abstract DoubleMatrix2D` | DoubleMatrix2D.`like(int rows, int columns)` Construct and returns a new empty matrix of the same dynamic type as the receiver, having the specified number of rows and columns.
    `abstract DoubleMatrix2D` | DoubleMatrix1D.`like2D(int rows, int columns)` Construct and returns a new 2-d matrix of the corresponding dynamic type, entirelly independent of the receiver.
    `DoubleMatrix2D` | DoubleFactory2D.`make(double[][] values)` Constructs a matrix with the given cell values.
    `DoubleMatrix2D` | DoubleFactory2D.`make(double[] values, int rows)` Construct a matrix from a one-dimensional column-major packed array, ala Fortran.
    `DoubleMatrix2D` | DoubleFactory2D.`make(int rows, int columns)` Constructs a matrix with the given shape, each cell initialized with zero.
    `DoubleMatrix2D` | DoubleFactory2D.`make(int rows, int columns, double initialValue)` Constructs a matrix with the given shape, each cell initialized with the given value.
    `DoubleMatrix2D` | DoubleFactory2D.`random(int rows, int columns)` Constructs a matrix with uniformly distributed values in `(0,1)` (exclusive).
    `DoubleMatrix2D` | DoubleFactory2D.`repeat(DoubleMatrix2D A, int rowRepeat, int columnRepeat)` C = A||A||..||A; Constructs a new matrix which is duplicated both along the row and column dimension.
    `DoubleMatrix2D` | DoubleFactory2D.`sample(DoubleMatrix2D matrix, double value, double nonZeroFraction)` Modifies the given matrix to be a randomly sampled matrix.
    `DoubleMatrix2D` | DoubleFactory2D.`sample(int rows, int columns, double value, double nonZeroFraction)` Constructs a randomly sampled matrix with the given shape.
    `DoubleMatrix2D` | DoubleMatrix3D.`viewColumn(int column)` Constructs and returns a new 2-dimensional slice view representing the slices and rows of the given column.
    `DoubleMatrix2D` | DoubleMatrix2D.`viewColumnFlip()` Constructs and returns a new flip view along the column axis.
    `DoubleMatrix2D` | DoubleMatrix2D.`viewDice()` Constructs and returns a new dice (transposition) view; Swaps axes; example: 3 x 4 matrix --> 4 x 3 matrix.
    `DoubleMatrix2D` | DoubleMatrix2D.`viewPart(int row, int column, int height, int width)` Constructs and returns a new sub-range view that is a `height x width` sub matrix starting at `[row,column]`.
    `DoubleMatrix2D` | DoubleMatrix3D.`viewRow(int row)` Constructs and returns a new 2-dimensional slice view representing the slices and columns of the given row.
    `DoubleMatrix2D` | DoubleMatrix2D.`viewRowFlip()` Constructs and returns a new flip view along the row axis.
    `DoubleMatrix2D` | DoubleMatrix2D.`viewSelection(DoubleMatrix1DProcedure condition)` Constructs and returns a new selection view that is a matrix holding all rows matching the given condition.
    `DoubleMatrix2D` | DoubleMatrix2D.`viewSelection(int[] rowIndexes, int[] columnIndexes)` Constructs and returns a new selection view that is a matrix holding the indicated cells.
    `DoubleMatrix2D` | DoubleMatrix3D.`viewSlice(int slice)` Constructs and returns a new 2-dimensional slice view representing the rows and columns of the given slice.
    `DoubleMatrix2D` | DoubleMatrix2D.`viewSorted(int column)` Sorts the matrix rows into ascending order, according to the natural ordering of the matrix values in the given column.
    `DoubleMatrix2D` | DoubleMatrix2D.`viewStrides(int rowStride, int columnStride)` Constructs and returns a new stride view which is a sub matrix consisting of every i-th cell.
    `DoubleMatrix2D` | DoubleMatrix2D.`zMult(DoubleMatrix2D B, DoubleMatrix2D C)` Linear algebraic matrix-matrix multiplication; `C = A x B`; Equivalent to `A.zMult(B,C,1,0,false,false)`.
    `DoubleMatrix2D` | DoubleMatrix2D.`zMult(DoubleMatrix2D B, DoubleMatrix2D C, double alpha, double beta, boolean transposeA, boolean transposeB)` Linear algebraic matrix-matrix multiplication; `C = alpha * A x B + beta*C`.

    Methods in cern.colt.matrix with parameters of type DoubleMatrix2D
    Modifier and Type | Method and Description
    --- | ---
    `double` | DoubleMatrix2D.`aggregate(DoubleMatrix2D other, DoubleDoubleFunction aggr, DoubleDoubleFunction f)` Applies a function to each corresponding cell of two matrices and aggregates the results.
    `DoubleMatrix2D` | DoubleFactory2D.`appendColumns(DoubleMatrix2D A, DoubleMatrix2D B)` C = A||B; Constructs a new matrix which is the column-wise concatenation of two other matrices.
    `DoubleMatrix2D` | DoubleFactory2D.`appendRows(DoubleMatrix2D A, DoubleMatrix2D B)` C = A||B; Constructs a new matrix which is the row-wise concatenation of two other matrices.
    `boolean` | DoubleMatrix2DProcedure.`apply(DoubleMatrix2D element)` Applies a procedure to an argument.
    `DoubleMatrix2D` | DoubleMatrix2D.`assign(DoubleMatrix2D other)` Replaces all cell values of the receiver with the values of another matrix.
    `DoubleMatrix2D` | DoubleMatrix2D.`assign(DoubleMatrix2D y, DoubleDoubleFunction function)` Assigns the result of a function to each cell; `x[row,col] = function(x[row,col],y[row,col])`.
    `DoubleMatrix2D` | DoubleFactory2D.`compose(DoubleMatrix2D[][] parts)` Constructs a block matrix made from the given parts.
    `DoubleMatrix2D` | DoubleFactory2D.`composeDiagonal(DoubleMatrix2D A, DoubleMatrix2D B)` Constructs a diagonal block matrix from the given parts (the direct sum of two matrices).
    `DoubleMatrix2D` | DoubleFactory2D.`composeDiagonal(DoubleMatrix2D A, DoubleMatrix2D B, DoubleMatrix2D C)` Constructs a diagonal block matrix from the given parts.
    `void` | DoubleFactory2D.`decompose(DoubleMatrix2D[][] parts, DoubleMatrix2D matrix)` Splits a block matrix into its constituent blocks; Copies blocks of a matrix into the given parts.
    `void` | DoubleFactory2D.`decompose(DoubleMatrix2D[][] parts, DoubleMatrix2D matrix)` Splits a block matrix into its constituent blocks; Copies blocks of a matrix into the given parts.
    `DoubleMatrix1D` | DoubleFactory2D.`diagonal(DoubleMatrix2D A)` Constructs a new vector consisting of the diagonal elements of `A`.
    `DoubleMatrix2D` | DoubleFactory2D.`repeat(DoubleMatrix2D A, int rowRepeat, int columnRepeat)` C = A||A||..||A; Constructs a new matrix which is duplicated both along the row and column dimension.
    `DoubleMatrix2D` | DoubleFactory2D.`sample(DoubleMatrix2D matrix, double value, double nonZeroFraction)` Modifies the given matrix to be a randomly sampled matrix.
    `void` | DoubleMatrix2D.`zAssign8Neighbors(DoubleMatrix2D B, Double9Function function)` 8 neighbor stencil transformation.
    `DoubleMatrix2D` | DoubleMatrix2D.`zMult(DoubleMatrix2D B, DoubleMatrix2D C)` Linear algebraic matrix-matrix multiplication; `C = A x B`; Equivalent to `A.zMult(B,C,1,0,false,false)`.
    `DoubleMatrix2D` | DoubleMatrix2D.`zMult(DoubleMatrix2D B, DoubleMatrix2D C, double alpha, double beta, boolean transposeA, boolean transposeB)` Linear algebraic matrix-matrix multiplication; `C = alpha * A x B + beta*C`.

  - ### Uses of DoubleMatrix2D in cern.colt.matrix.doublealgo

    Methods in cern.colt.matrix.doublealgo that return DoubleMatrix2D
    Modifier and Type | Method and Description
    --- | ---
    `static DoubleMatrix2D` | Transform.`abs(DoubleMatrix2D A)` Deprecated. `A[row,col] = Math.abs(A[row,col])`.
    `static DoubleMatrix2D` | Statistic.`aggregate(DoubleMatrix2D matrix, BinFunction1D[] aggr, DoubleMatrix2D result)` Applies the given aggregation functions to each column and stores the results in a the result matrix.
    `static DoubleMatrix2D` | Statistic.`correlation(DoubleMatrix2D covariance)` Modifies the given covariance matrix to be a correlation matrix (in-place).
    `static DoubleMatrix2D` | Statistic.`covariance(DoubleMatrix2D matrix)` Constructs and returns the covariance matrix of the given matrix.
    `static DoubleMatrix2D` | Statistic.`distance(DoubleMatrix2D matrix, Statistic.VectorVectorFunction distanceFunction)` Constructs and returns the distance matrix of the given matrix.
    `static DoubleMatrix2D` | Transform.`div(DoubleMatrix2D A, double s)` Deprecated. `A = A / s <=> A[row,col] = A[row,col] / s`.
    `static DoubleMatrix2D` | Transform.`div(DoubleMatrix2D A, DoubleMatrix2D B)` Deprecated. `A = A / B <=> A[row,col] = A[row,col] / B[row,col]`.
    `static DoubleMatrix2D` | Transform.`equals(DoubleMatrix2D A, double s)` Deprecated. `A[row,col] = A[row,col] == s ? 1 : 0`; ignores tolerance.
    `static DoubleMatrix2D` | Transform.`equals(DoubleMatrix2D A, DoubleMatrix2D B)` Deprecated. `A[row,col] = A[row,col] == B[row,col] ? 1 : 0`; ignores tolerance.
    `static DoubleMatrix2D` | Transform.`greater(DoubleMatrix2D A, double s)` Deprecated. `A[row,col] = A[row,col] > s ? 1 : 0`.
    `static DoubleMatrix2D` | Transform.`greater(DoubleMatrix2D A, DoubleMatrix2D B)` Deprecated. `A[row,col] = A[row,col] > B[row,col] ? 1 : 0`.
    `static DoubleMatrix2D` | Transform.`less(DoubleMatrix2D A, double s)` Deprecated. `A[row,col] = A[row,col] < s ? 1 : 0`.
    `static DoubleMatrix2D` | Transform.`less(DoubleMatrix2D A, DoubleMatrix2D B)` Deprecated. `A[row,col] = A[row,col] < B[row,col] ? 1 : 0`.
    `static DoubleMatrix2D` | Transform.`minus(DoubleMatrix2D A, double s)` Deprecated. `A = A - s <=> A[row,col] = A[row,col] - s`.
    `static DoubleMatrix2D` | Transform.`minus(DoubleMatrix2D A, DoubleMatrix2D B)` Deprecated. `A = A - B <=> A[row,col] = A[row,col] - B[row,col]`.
    `static DoubleMatrix2D` | Transform.`minusMult(DoubleMatrix2D A, DoubleMatrix2D B, double s)` Deprecated. `A = A - B*s <=> A[row,col] = A[row,col] - B[row,col]*s`.
    `static DoubleMatrix2D` | Transform.`mult(DoubleMatrix2D A, double s)` Deprecated. `A = A * s <=> A[row,col] = A[row,col] * s`.
    `static DoubleMatrix2D` | Transform.`mult(DoubleMatrix2D A, DoubleMatrix2D B)` Deprecated. `A = A * B <=> A[row,col] = A[row,col] * B[row,col]`.
    `static DoubleMatrix2D` | Transform.`negate(DoubleMatrix2D A)` Deprecated. `A = -A <=> A[row,col] = -A[row,col]`.
    `static DoubleMatrix2D` | Partitioning.`partition(DoubleMatrix2D matrix, int column, double[] splitters, int[] splitIndexes)` Same as `Partitioning.partition(int[],int,int,int[],int,int,int[])` except that it synchronously partitions the rows of the given matrix by the values of the given matrix column; This is essentially the same as partitioning a list of composite objects by some instance variable; In other words, two entire rows of the matrix are swapped, whenever two column values indicate so.
    `static DoubleMatrix2D` | Transform.`plus(DoubleMatrix2D A, double s)` Deprecated. `A = A + s <=> A[row,col] = A[row,col] + s`.
    `static DoubleMatrix2D` | Transform.`plus(DoubleMatrix2D A, DoubleMatrix2D B)` Deprecated. `A = A + B <=> A[row,col] = A[row,col] + B[row,col]`.
    `static DoubleMatrix2D` | Transform.`plusMult(DoubleMatrix2D A, DoubleMatrix2D B, double s)` Deprecated. `A = A + B*s <=> A[row,col] = A[row,col] + B[row,col]*s`.
    `static DoubleMatrix2D` | Transform.`pow(DoubleMatrix2D A, double s)` Deprecated. `A = As <=> A[row,col] = Math.pow(A[row,col], s)`.
    `static DoubleMatrix2D` | Transform.`pow(DoubleMatrix2D A, DoubleMatrix2D B)` Deprecated. `A = AB <=> A[row,col] = Math.pow(A[row,col], B[row,col])`.
    `DoubleMatrix2D` | Sorting.`sort(DoubleMatrix2D matrix, BinFunction1D aggregate)` Sorts the matrix rows into ascending order, according to the natural ordering of the values computed by applying the given aggregation function to each row; Particularly efficient when comparing expensive aggregates, because aggregates need not be recomputed time and again, as is the case for comparator based sorts.
    `DoubleMatrix2D` | Sorting.`sort(DoubleMatrix2D matrix, double[] aggregates)` Sorts the matrix rows into ascending order, according to the natural ordering of the matrix values in the virtual column `aggregates`; Particularly efficient when comparing expensive aggregates, because aggregates need not be recomputed time and again, as is the case for comparator based sorts.
    `DoubleMatrix2D` | Sorting.`sort(DoubleMatrix2D matrix, DoubleMatrix1DComparator c)` Sorts the matrix rows according to the order induced by the specified comparator.
    `DoubleMatrix2D` | Sorting.`sort(DoubleMatrix2D matrix, int column)` Sorts the matrix rows into ascending order, according to the natural ordering of the matrix values in the given column.
    `static DoubleMatrix2D` | Statistic.`viewSample(DoubleMatrix2D matrix, double rowFraction, double columnFraction, RandomEngine randomGenerator)` Constructs and returns a sampling view with `round(matrix.rows() * rowFraction)` rows and `round(matrix.columns() * columnFraction)` columns.

    Methods in cern.colt.matrix.doublealgo with parameters of type DoubleMatrix2D
    Modifier and Type | Method and Description
    --- | ---
    `static DoubleMatrix2D` | Transform.`abs(DoubleMatrix2D A)` Deprecated. `A[row,col] = Math.abs(A[row,col])`.
    `static DoubleMatrix2D` | Statistic.`aggregate(DoubleMatrix2D matrix, BinFunction1D[] aggr, DoubleMatrix2D result)` Applies the given aggregation functions to each column and stores the results in a the result matrix.
    `int` | DoubleMatrix2DComparator.`compare(DoubleMatrix2D o1, DoubleMatrix2D o2)` Compares its two arguments for order.
    `static DoubleMatrix2D` | Statistic.`correlation(DoubleMatrix2D covariance)` Modifies the given covariance matrix to be a correlation matrix (in-place).
    `static DoubleMatrix2D` | Statistic.`covariance(DoubleMatrix2D matrix)` Constructs and returns the covariance matrix of the given matrix.
    `static DoubleMatrix2D` | Statistic.`distance(DoubleMatrix2D matrix, Statistic.VectorVectorFunction distanceFunction)` Constructs and returns the distance matrix of the given matrix.
    `static DoubleMatrix2D` | Transform.`div(DoubleMatrix2D A, double s)` Deprecated. `A = A / s <=> A[row,col] = A[row,col] / s`.
    `static DoubleMatrix2D` | Transform.`div(DoubleMatrix2D A, DoubleMatrix2D B)` Deprecated. `A = A / B <=> A[row,col] = A[row,col] / B[row,col]`.
    `static DoubleMatrix2D` | Transform.`equals(DoubleMatrix2D A, double s)` Deprecated. `A[row,col] = A[row,col] == s ? 1 : 0`; ignores tolerance.
    `static DoubleMatrix2D` | Transform.`equals(DoubleMatrix2D A, DoubleMatrix2D B)` Deprecated. `A[row,col] = A[row,col] == B[row,col] ? 1 : 0`; ignores tolerance.
    `java.lang.String[][]` | Formatter.`format(DoubleMatrix2D matrix)` Returns a string representations of all cells; no alignment considered.
    `static DoubleMatrix2D` | Transform.`greater(DoubleMatrix2D A, double s)` Deprecated. `A[row,col] = A[row,col] > s ? 1 : 0`.
    `static DoubleMatrix2D` | Transform.`greater(DoubleMatrix2D A, DoubleMatrix2D B)` Deprecated. `A[row,col] = A[row,col] > B[row,col] ? 1 : 0`.
    `static DoubleMatrix2D` | Transform.`less(DoubleMatrix2D A, double s)` Deprecated. `A[row,col] = A[row,col] < s ? 1 : 0`.
    `static DoubleMatrix2D` | Transform.`less(DoubleMatrix2D A, DoubleMatrix2D B)` Deprecated. `A[row,col] = A[row,col] < B[row,col] ? 1 : 0`.
    `static DoubleMatrix2D` | Transform.`minus(DoubleMatrix2D A, double s)` Deprecated. `A = A - s <=> A[row,col] = A[row,col] - s`.
    `static DoubleMatrix2D` | Transform.`minus(DoubleMatrix2D A, DoubleMatrix2D B)` Deprecated. `A = A - B <=> A[row,col] = A[row,col] - B[row,col]`.
    `static DoubleMatrix2D` | Transform.`minusMult(DoubleMatrix2D A, DoubleMatrix2D B, double s)` Deprecated. `A = A - B*s <=> A[row,col] = A[row,col] - B[row,col]*s`.
    `static DoubleMatrix2D` | Transform.`mult(DoubleMatrix2D A, double s)` Deprecated. `A = A * s <=> A[row,col] = A[row,col] * s`.
    `static DoubleMatrix2D` | Transform.`mult(DoubleMatrix2D A, DoubleMatrix2D B)` Deprecated. `A = A * B <=> A[row,col] = A[row,col] * B[row,col]`.
    `static DoubleMatrix2D` | Transform.`negate(DoubleMatrix2D A)` Deprecated. `A = -A <=> A[row,col] = -A[row,col]`.
    `static void` | Partitioning.`partition(DoubleMatrix2D matrix, int[] rowIndexes, int rowFrom, int rowTo, int column, double[] splitters, int splitFrom, int splitTo, int[] splitIndexes)` Same as `Partitioning.partition(int[],int,int,int[],int,int,int[])` except that it synchronously partitions the rows of the given matrix by the values of the given matrix column; This is essentially the same as partitioning a list of composite objects by some instance variable; In other words, two entire rows of the matrix are swapped, whenever two column values indicate so.
    `static DoubleMatrix2D` | Partitioning.`partition(DoubleMatrix2D matrix, int column, double[] splitters, int[] splitIndexes)` Same as `Partitioning.partition(int[],int,int,int[],int,int,int[])` except that it synchronously partitions the rows of the given matrix by the values of the given matrix column; This is essentially the same as partitioning a list of composite objects by some instance variable; In other words, two entire rows of the matrix are swapped, whenever two column values indicate so.
    `static DoubleMatrix2D` | Transform.`plus(DoubleMatrix2D A, double s)` Deprecated. `A = A + s <=> A[row,col] = A[row,col] + s`.
    `static DoubleMatrix2D` | Transform.`plus(DoubleMatrix2D A, DoubleMatrix2D B)` Deprecated. `A = A + B <=> A[row,col] = A[row,col] + B[row,col]`.
    `static DoubleMatrix2D` | Transform.`plusMult(DoubleMatrix2D A, DoubleMatrix2D B, double s)` Deprecated. `A = A + B*s <=> A[row,col] = A[row,col] + B[row,col]*s`.
    `static DoubleMatrix2D` | Transform.`pow(DoubleMatrix2D A, double s)` Deprecated. `A = As <=> A[row,col] = Math.pow(A[row,col], s)`.
    `static DoubleMatrix2D` | Transform.`pow(DoubleMatrix2D A, DoubleMatrix2D B)` Deprecated. `A = AB <=> A[row,col] = Math.pow(A[row,col], B[row,col])`.
    `DoubleMatrix2D` | Sorting.`sort(DoubleMatrix2D matrix, BinFunction1D aggregate)` Sorts the matrix rows into ascending order, according to the natural ordering of the values computed by applying the given aggregation function to each row; Particularly efficient when comparing expensive aggregates, because aggregates need not be recomputed time and again, as is the case for comparator based sorts.
    `DoubleMatrix2D` | Sorting.`sort(DoubleMatrix2D matrix, double[] aggregates)` Sorts the matrix rows into ascending order, according to the natural ordering of the matrix values in the virtual column `aggregates`; Particularly efficient when comparing expensive aggregates, because aggregates need not be recomputed time and again, as is the case for comparator based sorts.
    `DoubleMatrix2D` | Sorting.`sort(DoubleMatrix2D matrix, DoubleMatrix1DComparator c)` Sorts the matrix rows according to the order induced by the specified comparator.
    `DoubleMatrix2D` | Sorting.`sort(DoubleMatrix2D matrix, int column)` Sorts the matrix rows into ascending order, according to the natural ordering of the matrix values in the given column.
    `static int` | Stencil.`stencil9(DoubleMatrix2D A, Double9Function function, int maxIterations, DoubleMatrix2DProcedure hasConverged, int convergenceIterations)` 9 point stencil operation.
    `java.lang.String` | Formatter.`toSourceCode(DoubleMatrix2D matrix)` Returns a string `s` such that `Object[] m = s` is a legal Java statement.
    `java.lang.String` | Formatter.`toString(DoubleMatrix2D matrix)` Returns a string representation of the given matrix.
    `java.lang.String` | Formatter.`toTitleString(DoubleMatrix2D matrix, java.lang.String[] rowNames, java.lang.String[] columnNames, java.lang.String rowAxisName, java.lang.String columnAxisName, java.lang.String title, BinFunction1D[] aggr)` Same as `toTitleString` except that additionally statistical aggregates (mean, median, sum, etc.) of rows and columns are printed.
    `static DoubleMatrix2D` | Statistic.`viewSample(DoubleMatrix2D matrix, double rowFraction, double columnFraction, RandomEngine randomGenerator)` Constructs and returns a sampling view with `round(matrix.rows() * rowFraction)` rows and `round(matrix.columns() * columnFraction)` columns.

  - ### Uses of DoubleMatrix2D in cern.colt.matrix.impl

    Subclasses of DoubleMatrix2D in cern.colt.matrix.impl
    Modifier and Type | Class and Description
    --- | ---
    `class` | `DenseDoubleMatrix2D` Dense 2-d matrix holding `double` elements.
    `class` | `RCDoubleMatrix2D` Sparse row-compressed 2-d matrix holding `double` elements.
    `class` | `SparseDoubleMatrix2D` Sparse hashed 2-d matrix holding `double` elements.

    Methods in cern.colt.matrix.impl that return DoubleMatrix2D
    Modifier and Type | Method and Description
    --- | ---
    `DoubleMatrix2D` | SparseDoubleMatrix2D.`assign(double value)` Sets all cells to the state specified by `value`.
    `DoubleMatrix2D` | RCDoubleMatrix2D.`assign(double value)` Sets all cells to the state specified by `value`.
    `DoubleMatrix2D` | DenseDoubleMatrix2D.`assign(double value)` Sets all cells to the state specified by `value`.
    `DoubleMatrix2D` | DenseDoubleMatrix2D.`assign(double[][] values)` Sets all cells to the state specified by `values`.
    `DoubleMatrix2D` | SparseDoubleMatrix2D.`assign(DoubleFunction function)` Assigns the result of a function to each cell; `x[row,col] = function(x[row,col])`.
    `DoubleMatrix2D` | RCDoubleMatrix2D.`assign(DoubleFunction function)`
    `DoubleMatrix2D` | DenseDoubleMatrix2D.`assign(DoubleFunction function)` Assigns the result of a function to each cell; `x[row,col] = function(x[row,col])`.
    `DoubleMatrix2D` | SparseDoubleMatrix2D.`assign(DoubleMatrix2D source)` Replaces all cell values of the receiver with the values of another matrix.
    `DoubleMatrix2D` | RCDoubleMatrix2D.`assign(DoubleMatrix2D source)` Replaces all cell values of the receiver with the values of another matrix.
    `DoubleMatrix2D` | DenseDoubleMatrix2D.`assign(DoubleMatrix2D source)` Replaces all cell values of the receiver with the values of another matrix.
    `DoubleMatrix2D` | SparseDoubleMatrix2D.`assign(DoubleMatrix2D y, DoubleDoubleFunction function)`
    `DoubleMatrix2D` | RCDoubleMatrix2D.`assign(DoubleMatrix2D y, DoubleDoubleFunction function)`
    `DoubleMatrix2D` | DenseDoubleMatrix2D.`assign(DoubleMatrix2D y, DoubleDoubleFunction function)` Assigns the result of a function to each cell; `x[row,col] = function(x[row,col],y[row,col])`.
    `DoubleMatrix2D` | SparseDoubleMatrix2D.`forEachNonZero(IntIntDoubleFunction function)`
    `DoubleMatrix2D` | RCDoubleMatrix2D.`forEachNonZero(IntIntDoubleFunction function)`
    `DoubleMatrix2D` | SparseDoubleMatrix2D.`like(int rows, int columns)` Construct and returns a new empty matrix of the same dynamic type as the receiver, having the specified number of rows and columns.
    `DoubleMatrix2D` | RCDoubleMatrix2D.`like(int rows, int columns)` Construct and returns a new empty matrix of the same dynamic type as the receiver, having the specified number of rows and columns.
    `DoubleMatrix2D` | DenseDoubleMatrix2D.`like(int rows, int columns)` Construct and returns a new empty matrix of the same dynamic type as the receiver, having the specified number of rows and columns.
    `DoubleMatrix2D` | SparseDoubleMatrix1D.`like2D(int rows, int columns)` Construct and returns a new 2-d matrix of the corresponding dynamic type, entirelly independent of the receiver.
    `DoubleMatrix2D` | DenseDoubleMatrix1D.`like2D(int rows, int columns)` Construct and returns a new 2-d matrix of the corresponding dynamic type, entirelly independent of the receiver.
    `DoubleMatrix2D` | SparseDoubleMatrix2D.`zMult(DoubleMatrix2D B, DoubleMatrix2D C, double alpha, double beta, boolean transposeA, boolean transposeB)`
    `DoubleMatrix2D` | RCDoubleMatrix2D.`zMult(DoubleMatrix2D B, DoubleMatrix2D C, double alpha, double beta, boolean transposeA, boolean transposeB)`
    `DoubleMatrix2D` | DenseDoubleMatrix2D.`zMult(DoubleMatrix2D B, DoubleMatrix2D C, double alpha, double beta, boolean transposeA, boolean transposeB)`

    Methods in cern.colt.matrix.impl with parameters of type DoubleMatrix2D
    Modifier and Type | Method and Description
    --- | ---
    `DoubleMatrix2D` | SparseDoubleMatrix2D.`assign(DoubleMatrix2D source)` Replaces all cell values of the receiver with the values of another matrix.
    `DoubleMatrix2D` | RCDoubleMatrix2D.`assign(DoubleMatrix2D source)` Replaces all cell values of the receiver with the values of another matrix.
    `DoubleMatrix2D` | DenseDoubleMatrix2D.`assign(DoubleMatrix2D source)` Replaces all cell values of the receiver with the values of another matrix.
    `DoubleMatrix2D` | SparseDoubleMatrix2D.`assign(DoubleMatrix2D y, DoubleDoubleFunction function)`
    `DoubleMatrix2D` | RCDoubleMatrix2D.`assign(DoubleMatrix2D y, DoubleDoubleFunction function)`
    `DoubleMatrix2D` | DenseDoubleMatrix2D.`assign(DoubleMatrix2D y, DoubleDoubleFunction function)` Assigns the result of a function to each cell; `x[row,col] = function(x[row,col],y[row,col])`.
    `void` | DenseDoubleMatrix2D.`zAssign8Neighbors(DoubleMatrix2D B, Double9Function function)` 8 neighbor stencil transformation.
    `DoubleMatrix2D` | SparseDoubleMatrix2D.`zMult(DoubleMatrix2D B, DoubleMatrix2D C, double alpha, double beta, boolean transposeA, boolean transposeB)`
    `DoubleMatrix2D` | RCDoubleMatrix2D.`zMult(DoubleMatrix2D B, DoubleMatrix2D C, double alpha, double beta, boolean transposeA, boolean transposeB)`
    `DoubleMatrix2D` | DenseDoubleMatrix2D.`zMult(DoubleMatrix2D B, DoubleMatrix2D C, double alpha, double beta, boolean transposeA, boolean transposeB)`

  - ### Uses of DoubleMatrix2D in cern.colt.matrix.linalg

    Methods in cern.colt.matrix.linalg that return DoubleMatrix2D
    Modifier and Type | Method and Description
    --- | ---
    `DoubleMatrix2D` | EigenvalueDecomposition.`getD()` Returns the block diagonal eigenvalue matrix, `D`.
    `DoubleMatrix2D` | QRDecomposition.`getH()` Returns the Householder vectors `H`.
    `DoubleMatrix2D` | LUDecompositionQuick.`getL()` Returns the lower triangular factor, `L`.
    `DoubleMatrix2D` | LUDecomposition.`getL()` Returns the lower triangular factor, `L`.
    `DoubleMatrix2D` | CholeskyDecomposition.`getL()` Returns the triangular factor, `L`.
    `DoubleMatrix2D` | LUDecompositionQuick.`getLU()` Returns a copy of the combined lower and upper triangular factor, `LU`.
    `DoubleMatrix2D` | QRDecomposition.`getQ()` Generates and returns the (economy-sized) orthogonal factor `Q`.
    `DoubleMatrix2D` | QRDecomposition.`getR()` Returns the upper triangular factor, `R`.
    `DoubleMatrix2D` | SingularValueDecomposition.`getS()` Returns the diagonal matrix of singular values.
    `DoubleMatrix2D` | SingularValueDecomposition.`getU()` Returns the left singular vectors `U`.
    `DoubleMatrix2D` | LUDecompositionQuick.`getU()` Returns the upper triangular factor, `U`.
    `DoubleMatrix2D` | LUDecomposition.`getU()` Returns the upper triangular factor, `U`.
    `DoubleMatrix2D` | SingularValueDecomposition.`getV()` Returns the right singular vectors `V`.
    `DoubleMatrix2D` | EigenvalueDecomposition.`getV()` Returns the eigenvector matrix, `V`
    `DoubleMatrix2D` | Algebra.`inverse(DoubleMatrix2D A)` Returns the inverse or pseudo-inverse of matrix `A`.
    `DoubleMatrix2D` | Algebra.`mult(DoubleMatrix2D A, DoubleMatrix2D B)` Linear algebraic matrix-matrix multiplication; `C = A x B`.
    `DoubleMatrix2D` | Algebra.`multOuter(DoubleMatrix1D x, DoubleMatrix1D y, DoubleMatrix2D A)` Outer product of two vectors; Sets `A[i,j] = x[i] * y[j]`.
    `DoubleMatrix2D` | Algebra.`permute(DoubleMatrix2D A, int[] rowIndexes, int[] columnIndexes)` Constructs and returns a new row and column permuted selection view of matrix `A`; equivalent to `viewSelection(int[],int[])`.
    `DoubleMatrix2D` | Algebra.`permuteColumns(DoubleMatrix2D A, int[] indexes, int[] work)` Modifies the given matrix `A` such that it's columns are permuted as specified; Useful for pivoting.
    `DoubleMatrix2D` | Algebra.`permuteRows(DoubleMatrix2D A, int[] indexes, int[] work)` Modifies the given matrix `A` such that it's rows are permuted as specified; Useful for pivoting.
    `DoubleMatrix2D` | Algebra.`pow(DoubleMatrix2D A, int p)` Linear algebraic matrix power; `B = Ak <==> B = A*A*...*A`.
    `DoubleMatrix2D` | QRDecomposition.`solve(DoubleMatrix2D B)` Least squares solution of `A*X = B`; `returns X`.
    `DoubleMatrix2D` | LUDecomposition.`solve(DoubleMatrix2D B)` Solves `A*X = B`.
    `DoubleMatrix2D` | CholeskyDecomposition.`solve(DoubleMatrix2D B)` Solves `A*X = B`; returns `X`.
    `DoubleMatrix2D` | Algebra.`solve(DoubleMatrix2D A, DoubleMatrix2D B)` Solves A*X = B.
    `DoubleMatrix2D` | Algebra.`solveTranspose(DoubleMatrix2D A, DoubleMatrix2D B)` Solves X*A = B, which is also A'*X' = B'.
    `DoubleMatrix2D` | Algebra.`subMatrix(DoubleMatrix2D A, int fromRow, int toRow, int fromColumn, int toColumn)` Constructs and returns a new sub-range view which is the sub matrix `A[fromRow..toRow,fromColumn..toColumn]`.
    `DoubleMatrix2D` | Algebra.`transpose(DoubleMatrix2D A)` Constructs and returns a new view which is the transposition of the given matrix `A`.

    Methods in cern.colt.matrix.linalg with parameters of type DoubleMatrix2D
    Modifier and Type | Method and Description
    --- | ---
    `double` | Matrix2DMatrix2DFunction.`apply(DoubleMatrix2D x, DoubleMatrix2D y)` Applies a function to two arguments.
    `void` | SmpBlas.`assign(DoubleMatrix2D A, DoubleFunction function)`
    `void` | SeqBlas.`assign(DoubleMatrix2D A, DoubleFunction function)`
    `void` | Blas.`assign(DoubleMatrix2D A, DoubleFunction function)` Assigns the result of a function to each cell; `x[row,col] = function(x[row,col])`.
    `void` | SmpBlas.`assign(DoubleMatrix2D A, DoubleMatrix2D B, DoubleDoubleFunction function)`
    `void` | SeqBlas.`assign(DoubleMatrix2D A, DoubleMatrix2D B, DoubleDoubleFunction function)`
    `void` | Blas.`assign(DoubleMatrix2D x, DoubleMatrix2D y, DoubleDoubleFunction function)` Assigns the result of a function to each cell; `x[row,col] = function(x[row,col],y[row,col])`.
    `void` | Property.`checkRectangular(DoubleMatrix2D A)` Checks whether the given matrix `A` is rectangular.
    `void` | Property.`checkSquare(DoubleMatrix2D A)` Checks whether the given matrix `A` is square.
    `double` | Algebra.`cond(DoubleMatrix2D A)` Returns the condition of matrix `A`, which is the ratio of largest to smallest singular value.
    `void` | SmpBlas.`daxpy(double alpha, DoubleMatrix2D A, DoubleMatrix2D B)`
    `void` | SeqBlas.`daxpy(double alpha, DoubleMatrix2D A, DoubleMatrix2D B)`
    `void` | Blas.`daxpy(double alpha, DoubleMatrix2D A, DoubleMatrix2D B)` Combined matrix scaling; `B = B + alpha*A`.
    `void` | SmpBlas.`dcopy(DoubleMatrix2D A, DoubleMatrix2D B)`
    `void` | SeqBlas.`dcopy(DoubleMatrix2D A, DoubleMatrix2D B)`
    `void` | Blas.`dcopy(DoubleMatrix2D A, DoubleMatrix2D B)` Matrix assignment (copying); `B = A`.
    `void` | LUDecompositionQuick.`decompose(DoubleMatrix2D A)` Decomposes matrix `A` into `L` and `U` (in-place).
    `void` | LUDecompositionQuick.`decompose(DoubleMatrix2D A, int semiBandwidth)` Decomposes the banded and square matrix `A` into `L` and `U` (in-place).
    `double` | Property.`density(DoubleMatrix2D A)` Returns the matrix's fraction of non-zero cells; `A.cardinality() / A.size()`.
    `double` | Algebra.`det(DoubleMatrix2D A)` Returns the determinant of matrix `A`.
    `void` | SmpBlas.`dgemm(boolean transposeA, boolean transposeB, double alpha, DoubleMatrix2D A, DoubleMatrix2D B, double beta, DoubleMatrix2D C)`
    `void` | SeqBlas.`dgemm(boolean transposeA, boolean transposeB, double alpha, DoubleMatrix2D A, DoubleMatrix2D B, double beta, DoubleMatrix2D C)`
    `void` | Blas.`dgemm(boolean transposeA, boolean transposeB, double alpha, DoubleMatrix2D A, DoubleMatrix2D B, double beta, DoubleMatrix2D C)` Generalized linear algebraic matrix-matrix multiply; `C = alpha*A*B + beta*C`.
    `void` | SmpBlas.`dgemv(boolean transposeA, double alpha, DoubleMatrix2D A, DoubleMatrix1D x, double beta, DoubleMatrix1D y)`
    `void` | SeqBlas.`dgemv(boolean transposeA, double alpha, DoubleMatrix2D A, DoubleMatrix1D x, double beta, DoubleMatrix1D y)`
    `void` | Blas.`dgemv(boolean transposeA, double alpha, DoubleMatrix2D A, DoubleMatrix1D x, double beta, DoubleMatrix1D y)` Generalized linear algebraic matrix-vector multiply; `y = alpha*A*x + beta*y`.
    `void` | SmpBlas.`dger(double alpha, DoubleMatrix1D x, DoubleMatrix1D y, DoubleMatrix2D A)`
    `void` | SeqBlas.`dger(double alpha, DoubleMatrix1D x, DoubleMatrix1D y, DoubleMatrix2D A)`
    `void` | Blas.`dger(double alpha, DoubleMatrix1D x, DoubleMatrix1D y, DoubleMatrix2D A)` Performs a rank 1 update; `A = A + alpha*x*y'`.
    `void` | SmpBlas.`dscal(double alpha, DoubleMatrix2D A)`
    `void` | SeqBlas.`dscal(double alpha, DoubleMatrix2D A)`
    `void` | Blas.`dscal(double alpha, DoubleMatrix2D A)` Matrix scaling; `A = alpha*A`.
    `void` | SmpBlas.`dswap(DoubleMatrix2D A, DoubleMatrix2D B)`
    `void` | SeqBlas.`dswap(DoubleMatrix2D A, DoubleMatrix2D B)`
    `void` | Blas.`dswap(DoubleMatrix2D x, DoubleMatrix2D y)` Swaps the elements of two matrices; `B <==> A`.
    `void` | SmpBlas.`dsymv(boolean isUpperTriangular, double alpha, DoubleMatrix2D A, DoubleMatrix1D x, double beta, DoubleMatrix1D y)`
    `void` | SeqBlas.`dsymv(boolean isUpperTriangular, double alpha, DoubleMatrix2D A, DoubleMatrix1D x, double beta, DoubleMatrix1D y)`
    `void` | Blas.`dsymv(boolean isUpperTriangular, double alpha, DoubleMatrix2D A, DoubleMatrix1D x, double beta, DoubleMatrix1D y)` Symmetric matrix-vector multiplication; `y = alpha*A*x + beta*y`.
    `void` | SmpBlas.`dtrmv(boolean isUpperTriangular, boolean transposeA, boolean isUnitTriangular, DoubleMatrix2D A, DoubleMatrix1D x)`
    `void` | SeqBlas.`dtrmv(boolean isUpperTriangular, boolean transposeA, boolean isUnitTriangular, DoubleMatrix2D A, DoubleMatrix1D x)`
    `void` | Blas.`dtrmv(boolean isUpperTriangular, boolean transposeA, boolean isUnitTriangular, DoubleMatrix2D A, DoubleMatrix1D x)` Triangular matrix-vector multiplication; `x = A*x` or `x = A'*x`.
    `boolean` | Property.`equals(DoubleMatrix2D A, double value)` Returns whether all cells of the given matrix `A` are equal to the given value.
    `boolean` | Property.`equals(DoubleMatrix2D A, DoubleMatrix2D B)` Returns whether both given matrices `A` and `B` are equal.
    `void` | Property.`generateNonSingular(DoubleMatrix2D A)` Modifies the given matrix square matrix `A` such that it is diagonally dominant by row and column, hence non-singular, hence invertible.
    `DoubleMatrix2D` | Algebra.`inverse(DoubleMatrix2D A)` Returns the inverse or pseudo-inverse of matrix `A`.
    `boolean` | Property.`isDiagonal(DoubleMatrix2D A)` A matrix `A` is diagonal if `A[i,j] == 0` whenever `i != j`.
    `boolean` | Property.`isDiagonallyDominantByColumn(DoubleMatrix2D A)` A matrix `A` is diagonally dominant by column if the absolute value of each diagonal element is larger than the sum of the absolute values of the off-diagonal elements in the corresponding column.
    `boolean` | Property.`isDiagonallyDominantByRow(DoubleMatrix2D A)` A matrix `A` is diagonally dominant by row if the absolute value of each diagonal element is larger than the sum of the absolute values of the off-diagonal elements in the corresponding row.
    `boolean` | Property.`isIdentity(DoubleMatrix2D A)` A matrix `A` is an identity matrix if `A[i,i] == 1` and all other cells are zero.
    `boolean` | Property.`isLowerBidiagonal(DoubleMatrix2D A)` A matrix `A` is lower bidiagonal if `A[i,j]==0` unless `i==j || i==j+1`.
    `boolean` | Property.`isLowerTriangular(DoubleMatrix2D A)` A matrix `A` is lower triangular if `A[i,j]==0` whenever `i < j`.
    `boolean` | Property.`isNonNegative(DoubleMatrix2D A)` A matrix `A` is non-negative if `A[i,j] >= 0` holds for all cells.
    `boolean` | Property.`isOrthogonal(DoubleMatrix2D A)` A square matrix `A` is orthogonal if `A*transpose(A) = I`.
    `boolean` | Property.`isPositive(DoubleMatrix2D A)` A matrix `A` is positive if `A[i,j] > 0` holds for all cells.
    `boolean` | Property.`isSingular(DoubleMatrix2D A)` A matrix `A` is singular if it has no inverse, that is, iff `det(A)==0`.
    `boolean` | Property.`isSkewSymmetric(DoubleMatrix2D A)` A square matrix `A` is skew-symmetric if `A = -transpose(A)`, that is `A[i,j] == -A[j,i]`.
    `boolean` | Property.`isSquare(DoubleMatrix2D A)` A matrix `A` is square if it has the same number of rows and columns.
    `boolean` | Property.`isStrictlyLowerTriangular(DoubleMatrix2D A)` A matrix `A` is strictly lower triangular if `A[i,j]==0` whenever `i <= j`.
    `boolean` | Property.`isStrictlyTriangular(DoubleMatrix2D A)` A matrix `A` is strictly triangular if it is triangular and its diagonal elements all equal 0.
    `boolean` | Property.`isStrictlyUpperTriangular(DoubleMatrix2D A)` A matrix `A` is strictly upper triangular if `A[i,j]==0` whenever `i >= j`.
    `boolean` | Property.`isSymmetric(DoubleMatrix2D A)` A matrix `A` is symmetric if `A = tranpose(A)`, that is `A[i,j] == A[j,i]`.
    `boolean` | Property.`isTriangular(DoubleMatrix2D A)` A matrix `A` is triangular iff it is either upper or lower triangular.
    `boolean` | Property.`isTridiagonal(DoubleMatrix2D A)` A matrix `A` is tridiagonal if `A[i,j]==0` whenever `Math.abs(i-j) > 1`.
    `boolean` | Property.`isUnitTriangular(DoubleMatrix2D A)` A matrix `A` is unit triangular if it is triangular and its diagonal elements all equal 1.
    `boolean` | Property.`isUpperBidiagonal(DoubleMatrix2D A)` A matrix `A` is upper bidiagonal if `A[i,j]==0` unless `i==j || i==j-1`.
    `boolean` | Property.`isUpperTriangular(DoubleMatrix2D A)` A matrix `A` is upper triangular if `A[i,j]==0` whenever `i > j`.
    `boolean` | Property.`isZero(DoubleMatrix2D A)` A matrix `A` is zero if all its cells are zero.
    `int` | Property.`lowerBandwidth(DoubleMatrix2D A)` The lower bandwidth of a square matrix `A` is the maximum `i-j` for which `A[i,j]` is nonzero and `i > j`.
    `DoubleMatrix1D` | Algebra.`mult(DoubleMatrix2D A, DoubleMatrix1D y)` Linear algebraic matrix-vector multiplication; `z = A * y`.
    `DoubleMatrix2D` | Algebra.`mult(DoubleMatrix2D A, DoubleMatrix2D B)` Linear algebraic matrix-matrix multiplication; `C = A x B`.
    `DoubleMatrix2D` | Algebra.`multOuter(DoubleMatrix1D x, DoubleMatrix1D y, DoubleMatrix2D A)` Outer product of two vectors; Sets `A[i,j] = x[i] * y[j]`.
    `double` | Algebra.`norm1(DoubleMatrix2D A)` Returns the one-norm of matrix `A`, which is the maximum absolute column sum.
    `double` | Algebra.`norm2(DoubleMatrix2D A)` Returns the two-norm of matrix `A`, which is the maximum singular value; obtained from SVD.
    `double` | Algebra.`normF(DoubleMatrix2D A)` Returns the Frobenius norm of matrix `A`, which is `Sqrt(Sum(A[i,j]2))`.
    `double` | Algebra.`normInfinity(DoubleMatrix2D A)` Returns the infinity norm of matrix `A`, which is the maximum absolute row sum.
    `DoubleMatrix2D` | Algebra.`permute(DoubleMatrix2D A, int[] rowIndexes, int[] columnIndexes)` Constructs and returns a new row and column permuted selection view of matrix `A`; equivalent to `viewSelection(int[],int[])`.
    `DoubleMatrix2D` | Algebra.`permuteColumns(DoubleMatrix2D A, int[] indexes, int[] work)` Modifies the given matrix `A` such that it's columns are permuted as specified; Useful for pivoting.
    `DoubleMatrix2D` | Algebra.`permuteRows(DoubleMatrix2D A, int[] indexes, int[] work)` Modifies the given matrix `A` such that it's rows are permuted as specified; Useful for pivoting.
    `DoubleMatrix2D` | Algebra.`pow(DoubleMatrix2D A, int p)` Linear algebraic matrix power; `B = Ak <==> B = A*A*...*A`.
    `int` | Algebra.`rank(DoubleMatrix2D A)` Returns the effective numerical rank of matrix `A`, obtained from Singular Value Decomposition.
    `int` | Property.`semiBandwidth(DoubleMatrix2D A)` Returns the semi-bandwidth of the given square matrix `A`.
    `void` | LUDecompositionQuick.`setLU(DoubleMatrix2D LU)` Sets the combined lower and upper triangular factor, `LU`.
    `DoubleMatrix2D` | QRDecomposition.`solve(DoubleMatrix2D B)` Least squares solution of `A*X = B`; `returns X`.
    `void` | LUDecompositionQuick.`solve(DoubleMatrix2D B)` Solves the system of equations `A*X = B` (in-place).
    `DoubleMatrix2D` | LUDecomposition.`solve(DoubleMatrix2D B)` Solves `A*X = B`.
    `DoubleMatrix2D` | CholeskyDecomposition.`solve(DoubleMatrix2D B)` Solves `A*X = B`; returns `X`.
    `DoubleMatrix2D` | Algebra.`solve(DoubleMatrix2D A, DoubleMatrix2D B)` Solves A*X = B.
    `DoubleMatrix2D` | Algebra.`solveTranspose(DoubleMatrix2D A, DoubleMatrix2D B)` Solves X*A = B, which is also A'*X' = B'.
    `DoubleMatrix2D` | Algebra.`subMatrix(DoubleMatrix2D A, int fromRow, int toRow, int fromColumn, int toColumn)` Constructs and returns a new sub-range view which is the sub matrix `A[fromRow..toRow,fromColumn..toColumn]`.
    `java.lang.String` | Property.`toString(DoubleMatrix2D A)` Returns summary information about the given matrix `A`.
    `java.lang.String` | Algebra.`toString(DoubleMatrix2D matrix)` Returns a String with (propertyName, propertyValue) pairs.
    `java.lang.String` | Algebra.`toVerboseString(DoubleMatrix2D matrix)` Returns the results of `toString(A)` and additionally the results of all sorts of decompositions applied to the given matrix.
    `double` | Algebra.`trace(DoubleMatrix2D A)` Returns the sum of the diagonal elements of matrix `A`; `Sum(A[i,i])`.
    `DoubleMatrix2D` | Algebra.`transpose(DoubleMatrix2D A)` Constructs and returns a new view which is the transposition of the given matrix `A`.
    `int` | Property.`upperBandwidth(DoubleMatrix2D A)` The upper bandwidth of a square matrix `A` is the maximum `j-i` for which `A[i,j]` is nonzero and `j > i`.

    Constructors in cern.colt.matrix.linalg with parameters of type DoubleMatrix2D
    Constructor and Description
    `CholeskyDecomposition(DoubleMatrix2D A)` Constructs and returns a new Cholesky decomposition object for a symmetric and positive definite matrix; The decomposed matrices can be retrieved via instance methods of the returned decomposition object.
    `EigenvalueDecomposition(DoubleMatrix2D A)` Constructs and returns a new eigenvalue decomposition object; The decomposed matrices can be retrieved via instance methods of the returned decomposition object.
    `LUDecomposition(DoubleMatrix2D A)` Constructs and returns a new LU Decomposition object; The decomposed matrices can be retrieved via instance methods of the returned decomposition object.
    `QRDecomposition(DoubleMatrix2D A)` Constructs and returns a new QR decomposition object; computed by Householder reflections; The decomposed matrices can be retrieved via instance methods of the returned decomposition object.
    `SingularValueDecomposition(DoubleMatrix2D Arg)` Constructs and returns a new singular value decomposition object; The decomposed matrices can be retrieved via instance methods of the returned decomposition object.

Jump to the Colt Homepage