Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| Colt 1.2.0
PREV NEXT | FRAMES NO FRAMES

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

Packages that use DoubleMatrix2D
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
`DoubleMatrix2D` | `DoubleMatrix3D.viewColumn(int column)` Constructs and returns a new 2-dimensional slice view representing the slices and rows of the given 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` | `DoubleMatrix3D.viewSlice(int slice)` Constructs and returns a new 2-dimensional slice view representing the rows and columns of the given slice.
`DoubleMatrix2D` | `DoubleMatrix2D.assign(double[][] values)` Sets all cells to the state specified by `values`.
`DoubleMatrix2D` | `DoubleMatrix2D.assign(double value)` Sets all cells to the state specified by `value`.
`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` | `DoubleMatrix2D.copy()` Constructs and returns a deep copy of the receiver.
`DoubleMatrix2D` | `DoubleMatrix2D.forEachNonZero(IntIntDoubleFunction function)` Assigns the result of a function to each non-zero cell; `x[row,col] = function(x[row,col])`.
`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.
`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` | `DoubleMatrix2D.viewRowFlip()` Constructs and returns a new flip view along the row axis.
`DoubleMatrix2D` | `DoubleMatrix2D.viewSelection(int[] rowIndexes, int[] columnIndexes)` Constructs and returns a new selection view that is a matrix holding the indicated cells.
`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.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`.
`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.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` | `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` | `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` | `DoubleFactory2D.identity(int rowsAndColumns)` Constructs an identity matrix (having ones on the diagonal and zeros elsewhere).
`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(int rows, int columns, double value, double nonZeroFraction)` Constructs a randomly sampled matrix with the given shape.
`DoubleMatrix2D` | `DoubleFactory2D.sample(DoubleMatrix2D matrix, double value, double nonZeroFraction)` Modifies the given matrix to be a randomly sampled matrix.

Methods in cern.colt.matrix with parameters of type DoubleMatrix2D
`boolean` | `DoubleMatrix2DProcedure.apply(DoubleMatrix2D element)` Applies a procedure to an argument.
`double` | `DoubleMatrix2D.aggregate(DoubleMatrix2D other, DoubleDoubleFunction aggr, DoubleDoubleFunction f)` Applies a function to each corresponding cell of two matrices and aggregates the results.
`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])`.
`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`.
`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.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.
`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.

Uses of DoubleMatrix2D in cern.colt.matrix.doublealgo

Methods in cern.colt.matrix.doublealgo that return DoubleMatrix2D
`static DoubleMatrix2D` | `Transform.abs(DoubleMatrix2D A)` Deprecated. `A[row,col] = Math.abs(A[row,col])`.
`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` | `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])`.
`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` | `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.
`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, int column)` Sorts the matrix rows into ascending order, according to the natural ordering of the matrix values in the given column.
`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, 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.
`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.

Methods in cern.colt.matrix.doublealgo with parameters of type DoubleMatrix2D
`static DoubleMatrix2D` | `Transform.abs(DoubleMatrix2D A)` Deprecated. `A[row,col] = Math.abs(A[row,col])`.
`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` | `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])`.
`static int` | `Stencil.stencil9(DoubleMatrix2D A, Double9Function function, int maxIterations, DoubleMatrix2DProcedure hasConverged, int convergenceIterations)` 9 point stencil operation.
`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` | `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.
`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, int column)` Sorts the matrix rows into ascending order, according to the natural ordering of the matrix values in the given column.
`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, 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.
`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.
`String[][]` | `Formatter.format(DoubleMatrix2D matrix)` Returns a string representations of all cells; no alignment considered.
`String` | `Formatter.toSourceCode(DoubleMatrix2D matrix)` Returns a string `s` such that `Object[] m = s` is a legal Java statement.
`String` | `Formatter.toString(DoubleMatrix2D matrix)` Returns a string representation of the given matrix.
`String` | `Formatter.toTitleString(DoubleMatrix2D matrix, String[] rowNames, String[] columnNames, String rowAxisName, String columnAxisName, String title, BinFunction1D[] aggr)` Same as `toTitleString` except that additionally statistical aggregates (mean, median, sum, etc.) of rows and columns are printed.
`int` | `DoubleMatrix2DComparator.compare(DoubleMatrix2D o1, DoubleMatrix2D o2)` Compares its two arguments for order.

Uses of DoubleMatrix2D in cern.colt.matrix.impl

Subclasses of DoubleMatrix2D in cern.colt.matrix.impl
`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.
`(package private) class` | `cern.colt.matrix.impl.WrapperDoubleMatrix2D` 2-d matrix holding `double` elements; either a view wrapping another matrix or a matrix whose views are wrappers.

Methods in cern.colt.matrix.impl that return DoubleMatrix2D
`DoubleMatrix2D` | `SparseDoubleMatrix2D.assign(double value)` Sets all cells to the state specified by `value`.
`DoubleMatrix2D` | `SparseDoubleMatrix2D.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` | `SparseDoubleMatrix2D.assign(DoubleMatrix2D y, DoubleDoubleFunction function)`
`DoubleMatrix2D` | `SparseDoubleMatrix2D.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` | `SparseDoubleMatrix2D.zMult(DoubleMatrix2D B, DoubleMatrix2D C, double alpha, double beta, boolean transposeA, boolean transposeB)`
`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` | `RCDoubleMatrix2D.assign(double value)` Sets all cells to the state specified by `value`.
`DoubleMatrix2D` | `RCDoubleMatrix2D.assign(DoubleFunction function)`
`DoubleMatrix2D` | `RCDoubleMatrix2D.assign(DoubleMatrix2D source)` Replaces all cell values of the receiver with the values of another matrix.
`DoubleMatrix2D` | `RCDoubleMatrix2D.assign(DoubleMatrix2D y, DoubleDoubleFunction function)`
`DoubleMatrix2D` | `RCDoubleMatrix2D.forEachNonZero(IntIntDoubleFunction function)`
`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` | `RCDoubleMatrix2D.zMult(DoubleMatrix2D B, DoubleMatrix2D C, double alpha, double beta, boolean transposeA, boolean transposeB)`
`DoubleMatrix2D` | `DenseDoubleMatrix2D.assign(double[][] values)` Sets all cells to the state specified by `values`.
`DoubleMatrix2D` | `DenseDoubleMatrix2D.assign(double value)` Sets all cells to the state specified by `value`.
`DoubleMatrix2D` | `DenseDoubleMatrix2D.assign(DoubleFunction function)` Assigns the result of a function to each cell; `x[row,col] = function(x[row,col])`.
`DoubleMatrix2D` | `DenseDoubleMatrix2D.assign(DoubleMatrix2D source)` Replaces all cell values of the receiver with the values of another matrix.
`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` | `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` | `DenseDoubleMatrix2D.zMult(DoubleMatrix2D B, DoubleMatrix2D C, double alpha, double beta, boolean transposeA, boolean transposeB)`
`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.

Methods in cern.colt.matrix.impl with parameters of type DoubleMatrix2D
`DoubleMatrix2D` | `SparseDoubleMatrix2D.assign(DoubleMatrix2D source)` Replaces all cell values of the receiver with the values of another matrix.
`DoubleMatrix2D` | `SparseDoubleMatrix2D.assign(DoubleMatrix2D y, DoubleDoubleFunction function)`
`DoubleMatrix2D` | `SparseDoubleMatrix2D.zMult(DoubleMatrix2D B, DoubleMatrix2D C, double alpha, double beta, boolean transposeA, boolean transposeB)`
`DoubleMatrix2D` | `RCDoubleMatrix2D.assign(DoubleMatrix2D source)` Replaces all cell values of the receiver with the values of another matrix.
`DoubleMatrix2D` | `RCDoubleMatrix2D.assign(DoubleMatrix2D y, DoubleDoubleFunction function)`
`DoubleMatrix2D` | `RCDoubleMatrix2D.zMult(DoubleMatrix2D B, DoubleMatrix2D C, double alpha, double beta, boolean transposeA, boolean transposeB)`
`DoubleMatrix2D` | `DenseDoubleMatrix2D.assign(DoubleMatrix2D source)` Replaces all cell values of the receiver with the values of another matrix.
`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` | `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
`DoubleMatrix2D` | `SingularValueDecomposition.getS()` Returns the diagonal matrix of singular values.
`DoubleMatrix2D` | `SingularValueDecomposition.getU()` Returns the left singular vectors `U`.
`DoubleMatrix2D` | `SingularValueDecomposition.getV()` Returns the right singular vectors `V`.
`DoubleMatrix2D` | `QRDecomposition.getH()` Returns the Householder vectors `H`.
`DoubleMatrix2D` | `QRDecomposition.getQ()` Generates and returns the (economy-sized) orthogonal factor `Q`.
`DoubleMatrix2D` | `QRDecomposition.getR()` Returns the upper triangular factor, `R`.
`DoubleMatrix2D` | `QRDecomposition.solve(DoubleMatrix2D B)` Least squares solution of `A*X = B`; `returns X`.
`DoubleMatrix2D` | `LUDecompositionQuick.getL()` Returns the lower triangular factor, `L`.
`DoubleMatrix2D` | `LUDecompositionQuick.getLU()` Returns a copy of the combined lower and upper triangular factor, `LU`.
`DoubleMatrix2D` | `LUDecompositionQuick.getU()` Returns the upper triangular factor, `U`.
`DoubleMatrix2D` | `LUDecomposition.getL()` Returns the lower triangular factor, `L`.
`DoubleMatrix2D` | `LUDecomposition.getU()` Returns the upper triangular factor, `U`.
`DoubleMatrix2D` | `LUDecomposition.solve(DoubleMatrix2D B)` Solves `A*X = B`.
`DoubleMatrix2D` | `EigenvalueDecomposition.getD()` Returns the block diagonal eigenvalue matrix, `D`.
`DoubleMatrix2D` | `EigenvalueDecomposition.getV()` Returns the eigenvector matrix, `V`
`DoubleMatrix2D` | `CholeskyDecomposition.getL()` Returns the triangular factor, `L`.
`DoubleMatrix2D` | `CholeskyDecomposition.solve(DoubleMatrix2D B)` Solves `A*X = B`; returns `X`.
`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` | `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
`void` | `SmpBlas.assign(DoubleMatrix2D A, DoubleFunction function)`
`void` | `SmpBlas.assign(DoubleMatrix2D A, DoubleMatrix2D B, DoubleDoubleFunction function)`
`void` | `SmpBlas.daxpy(double alpha, DoubleMatrix2D A, DoubleMatrix2D B)`
`void` | `SmpBlas.dcopy(DoubleMatrix2D A, DoubleMatrix2D B)`
`void` | `SmpBlas.dgemm(boolean transposeA, boolean transposeB, double alpha, DoubleMatrix2D A, DoubleMatrix2D B, double beta, DoubleMatrix2D C)`
`void` | `SmpBlas.dgemv(boolean transposeA, double alpha, DoubleMatrix2D A, DoubleMatrix1D x, double beta, DoubleMatrix1D y)`
`void` | `SmpBlas.dger(double alpha, DoubleMatrix1D x, DoubleMatrix1D y, DoubleMatrix2D A)`
`void` | `SmpBlas.dscal(double alpha, DoubleMatrix2D A)`
`void` | `SmpBlas.dswap(DoubleMatrix2D A, DoubleMatrix2D B)`
`void` | `SmpBlas.dsymv(boolean isUpperTriangular, double alpha, DoubleMatrix2D A, DoubleMatrix1D x, double beta, DoubleMatrix1D y)`
`void` | `SmpBlas.dtrmv(boolean isUpperTriangular, boolean transposeA, boolean isUnitTriangular, DoubleMatrix2D A, DoubleMatrix1D x)`
`void` | `SeqBlas.assign(DoubleMatrix2D A, DoubleFunction function)`
`void` | `SeqBlas.assign(DoubleMatrix2D A, DoubleMatrix2D B, DoubleDoubleFunction function)`
`void` | `SeqBlas.daxpy(double alpha, DoubleMatrix2D A, DoubleMatrix2D B)`
`void` | `SeqBlas.dcopy(DoubleMatrix2D A, DoubleMatrix2D B)`
`void` | `SeqBlas.dgemm(boolean transposeA, boolean transposeB, double alpha, DoubleMatrix2D A, DoubleMatrix2D B, double beta, DoubleMatrix2D C)`
`void` | `SeqBlas.dgemv(boolean transposeA, double alpha, DoubleMatrix2D A, DoubleMatrix1D x, double beta, DoubleMatrix1D y)`
`void` | `SeqBlas.dger(double alpha, DoubleMatrix1D x, DoubleMatrix1D y, DoubleMatrix2D A)`
`void` | `SeqBlas.dscal(double alpha, DoubleMatrix2D A)`
`void` | `SeqBlas.dswap(DoubleMatrix2D A, DoubleMatrix2D B)`
`void` | `SeqBlas.dsymv(boolean isUpperTriangular, double alpha, DoubleMatrix2D A, DoubleMatrix1D x, double beta, DoubleMatrix1D y)`
`void` | `SeqBlas.dtrmv(boolean isUpperTriangular, boolean transposeA, boolean isUnitTriangular, DoubleMatrix2D A, DoubleMatrix1D x)`
`DoubleMatrix2D` | `QRDecomposition.solve(DoubleMatrix2D B)` Least squares solution of `A*X = B`; `returns X`.
`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` | `Property.density(DoubleMatrix2D A)` Returns the matrix's fraction of non-zero cells; `A.cardinality() / A.size()`.
`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.
`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`.
`int` | `Property.semiBandwidth(DoubleMatrix2D A)` Returns the semi-bandwidth of the given square matrix `A`.
`String` | `Property.toString(DoubleMatrix2D A)` Returns summary information about 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`.
`double` | `Matrix2DMatrix2DFunction.apply(DoubleMatrix2D x, DoubleMatrix2D y)` Applies a function to two arguments.
`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).
`void` | `LUDecompositionQuick.setLU(DoubleMatrix2D LU)` Sets the combined lower and upper triangular factor, `LU`.
`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`.
`void` | `Blas.assign(DoubleMatrix2D A, DoubleFunction function)` Assigns the result of a function to each cell; `x[row,col] = function(x[row,col])`.
`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` | `Blas.daxpy(double alpha, DoubleMatrix2D A, DoubleMatrix2D B)` Combined matrix scaling; `B = B + alpha*A`.
`void` | `Blas.dcopy(DoubleMatrix2D A, DoubleMatrix2D B)` Matrix assignment (copying); `B = A`.
`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` | `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` | `Blas.dger(double alpha, DoubleMatrix1D x, DoubleMatrix1D y, DoubleMatrix2D A)` Performs a rank 1 update; `A = A + alpha*x*y'`.
`void` | `Blas.dscal(double alpha, DoubleMatrix2D A)` Matrix scaling; `A = alpha*A`.
`void` | `Blas.dswap(DoubleMatrix2D x, DoubleMatrix2D y)` Swaps the elements of two matrices; `B <==> A`.
`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` | `Blas.dtrmv(boolean isUpperTriangular, boolean transposeA, boolean isUnitTriangular, DoubleMatrix2D A, DoubleMatrix1D x)` Triangular matrix-vector multiplication; `x = A*x` or `x = A'*x`.
`double` | `Algebra.cond(DoubleMatrix2D A)` Returns the condition of matrix `A`, which is the ratio of largest to smallest singular value.
`double` | `Algebra.det(DoubleMatrix2D A)` Returns the determinant of matrix `A`.
`DoubleMatrix2D` | `Algebra.inverse(DoubleMatrix2D A)` Returns the inverse or pseudo-inverse of matrix `A`.
`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.
`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]`.
`String` | `Algebra.toString(DoubleMatrix2D matrix)` Returns a String with (propertyName, propertyValue) pairs.
`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`.

Constructors in cern.colt.matrix.linalg with parameters of type DoubleMatrix2D
`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.
`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.
`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.
`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.
`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.

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| Colt 1.2.0
PREV NEXT | FRAMES NO FRAMES

Jump to the Colt Homepage