Uses of Class jsat.linear.Matrix (Java Statistical Analysis Tool 0.0.8 API)

Packages that use Matrix
Package	Description
jsat
jsat.classifiers.neuralnetwork.activations
jsat.classifiers.neuralnetwork.initializers
jsat.classifiers.neuralnetwork.regularizers
jsat.clustering
jsat.datatransform
jsat.datatransform.visualization
jsat.distributions.kernels
jsat.distributions.multivariate
jsat.linear
jsat.linear.solvers
jsat.math

Uses of Matrix in jsat

Methods in jsat that return Matrix
Modifier and Type	Method and Description
`Matrix`	DataSet.`getDataMatrix()` Creates a matrix from the data set, where each row represent a data point, and each column is one of the numeric example from the data set.
`Matrix`	DataSet.`getDataMatrixView()` Creates a matrix backed by the data set, where each row is a data point from the dataset, and each column is one of the numeric examples from the data set.

Uses of Matrix in jsat.classifiers.neuralnetwork.activations

Methods in jsat.classifiers.neuralnetwork.activations with parameters of type Matrix
Modifier and Type	Method and Description
`void`	TanhLayer.`activate(Matrix input, Matrix output, boolean rowMajor)`
`void`	SoftSignLayer.`activate(Matrix input, Matrix output, boolean rowMajor)`
`void`	SoftmaxLayer.`activate(Matrix input, Matrix output, boolean rowMajor)`
`void`	SigmoidLayer.`activate(Matrix input, Matrix output, boolean rowMajor)`
`void`	ReLU.`activate(Matrix input, Matrix output, boolean rowMajor)`
`void`	LinearLayer.`activate(Matrix input, Matrix output, boolean rowMajor)`
`void`	ActivationLayer.`activate(Matrix input, Matrix output, boolean rowMajor)` Computes the activation function of this layer on the given input.
`void`	TanhLayer.`backprop(Matrix input, Matrix output, Matrix delta_partial, Matrix errout, boolean rowMajor)`
`void`	SoftSignLayer.`backprop(Matrix input, Matrix output, Matrix delta_partial, Matrix errout, boolean rowMajor)`
`void`	SoftmaxLayer.`backprop(Matrix input, Matrix output, Matrix delta_partial, Matrix errout, boolean rowMajor)`
`void`	SigmoidLayer.`backprop(Matrix input, Matrix output, Matrix delta_partial, Matrix errout, boolean rowMajor)`
`void`	ReLU.`backprop(Matrix input, Matrix output, Matrix delta_partial, Matrix errout, boolean rowMajor)`
`void`	LinearLayer.`backprop(Matrix input, Matrix output, Matrix delta_partial, Matrix errout, boolean rowMajor)`
`void`	ActivationLayer.`backprop(Matrix input, Matrix output, Matrix delta_partial, Matrix errout, boolean rowMajor)` This method computes the backpropagated error to a given layer.

Uses of Matrix in jsat.classifiers.neuralnetwork.initializers

Methods in jsat.classifiers.neuralnetwork.initializers with parameters of type Matrix
Modifier and Type	Method and Description
`void`	WeightInitializer.`init(Matrix w, Random rand)` Initializes the values of the given weight matrix
`void`	TanhInitializer.`init(Matrix w, Random rand)`
`void`	GaussianNormalInit.`init(Matrix w, Random rand)`

Uses of Matrix in jsat.classifiers.neuralnetwork.regularizers

Methods in jsat.classifiers.neuralnetwork.regularizers with parameters of type Matrix
Modifier and Type	Method and Description
`void`	WeightRegularizer.`applyRegularization(Matrix W, Vec b)` Applies regularization to one matrix, where the rows of the matrix correspond tot he weights associated to one neuron's input.
`void`	Max2NormRegularizer.`applyRegularization(Matrix W, Vec b)`
`void`	WeightRegularizer.`applyRegularization(Matrix W, Vec b, ExecutorService ex)` Applies regularization to one matrix, where the rows of the matrix correspond tot he weights associated to one neuron's input.
`void`	Max2NormRegularizer.`applyRegularization(Matrix W, Vec b, ExecutorService ex)`

Uses of Matrix in jsat.clustering

Method parameters in jsat.clustering with type arguments of type Matrix
Modifier and Type	Method and Description
`protected double`	EMGaussianMixture.`clusterCompute(int K, DataSet dataSet, int[] assignment, List<Vec> means, List<Matrix> covs, ExecutorService execServ)`

Uses of Matrix in jsat.datatransform

Fields in jsat.datatransform declared as Matrix
Modifier and Type	Field and Description
`protected Matrix`	WhitenedPCA.`transform` The final transformation matrix, that will create new points `y` = `transform` * x

Uses of Matrix in jsat.datatransform.visualization

Methods in jsat.datatransform.visualization with parameters of type Matrix
Modifier and Type	Method and Description
`SimpleDataSet`	MDS.`transform(Matrix delta)`
`SimpleDataSet`	MDS.`transform(Matrix delta, ExecutorService ex)`

Uses of Matrix in jsat.distributions.kernels

Fields in jsat.distributions.kernels declared as Matrix
Modifier and Type	Field and Description
`protected Matrix`	KernelPoint.`InvK`
`protected Matrix`	KernelPoint.`InvKExpanded`
`protected Matrix`	KernelPoint.`K`
`protected Matrix`	KernelPoint.`KExpanded`

Uses of Matrix in jsat.distributions.multivariate

Methods in jsat.distributions.multivariate with parameters of type Matrix
Modifier and Type	Method and Description
`void`	NormalM.`setCovariance(Matrix covMatrix)` Sets the covariance matrix for this matrix.
`void`	NormalM.`setMeanCovariance(Vec mean, Matrix covariance)` Sets the mean and covariance for this distribution.

Constructors in jsat.distributions.multivariate with parameters of type Matrix
Constructor and Description
`NormalM(Vec mean, Matrix covariance)`

Uses of Matrix in jsat.linear

Subclasses of Matrix in jsat.linear
Modifier and Type	Class and Description
`class`	`DenseMatrix`
`class`	`GenericMatrix` This Class provides default implementations of most all functions in row major form.
`class`	`MatrixOfVecs` This class provides a base mechanism to create a Matrix 'view' from a list of `Vec` objects.
`class`	`RandomMatrix` Stores a Matrix full of random values in constant O(1) space by re-computing all matrix values on the fly as need.
`class`	`SparseMatrix` Creates a new Sparse Matrix where each row is backed by a sparse vector.
`class`	`SubMatrix` This class allows for the selection of an area of a matrix to operate on independently.
`class`	`TransposeView` This class provides a free view of the transpose of a matrix.

Methods in jsat.linear that return Matrix
Modifier and Type	Method and Description
`Matrix`	Matrix.`add(double c)` Creates a new Matrix that stores the result of `A+c`
`Matrix`	Matrix.`add(double c, ExecutorService threadPool)` Creates a new Matrix that stores the result of `A+c`
`Matrix`	Matrix.`add(Matrix B)` Creates a new Matrix that stores the result of `A+B`
`Matrix`	Matrix.`add(Matrix B, ExecutorService threadPool)` Creates a new Matrix that stores the result of `A+B`
`static Matrix`	LUPDecomposition.`backSub(Matrix U, Matrix y)` Solves for the matrix x such that U x = y
`static Matrix`	LUPDecomposition.`backSub(Matrix U, Matrix y, ExecutorService threadpool)` Solves for the matrix x such that U x = y
`abstract Matrix`	Matrix.`clone()`
`Matrix`	GenericMatrix.`clone()`
`static Matrix`	MatrixStatistics.`covarianceMatrix(Vec mean, DataSet dataSet)` Computes the weighted covariance matrix of the data set
`static <V extends Vec> Matrix`	MatrixStatistics.`covarianceMatrix(Vec mean, List<V> dataSet)`
`static Matrix`	Matrix.`diag(Vec a)` Returns a new dense square matrix such that the main diagonal contains the values given in `a`
`static Matrix`	LUPDecomposition.`forwardSub(Matrix L, Matrix b)` Solves for the matrix x such that L x = b
`static Matrix`	LUPDecomposition.`forwardSub(Matrix L, Matrix b, ExecutorService threadpool)` Solves for the matrix x such that L x = b
`Matrix`	SubMatrix.`getBaseMatrix()` Returns the matrix that is the base for this sub matrix.
`Matrix`	EigenValueDecomposition.`getD()` Return the block diagonal eigenvalue matrix
`Matrix`	CholeskyDecomposition.`getLT()` The Cholesky Decomposition computes the factorization A = L L^T.
`protected Matrix`	TransposeView.`getMatrixOfSameType(int rows, int cols)`
`protected Matrix`	SubMatrix.`getMatrixOfSameType(int rows, int cols)`
`protected Matrix`	RandomMatrix.`getMatrixOfSameType(int rows, int cols)`
`protected Matrix`	MatrixOfVecs.`getMatrixOfSameType(int rows, int cols)`
`protected abstract Matrix`	GenericMatrix.`getMatrixOfSameType(int rows, int cols)` Creates a new matrix of the same type
`protected Matrix`	DenseMatrix.`getMatrixOfSameType(int rows, int cols)`
`Matrix`	SingularValueDecomposition.`getPseudoInverse()` Returns the Moore–Penrose pseudo inverse of the matrix.
`Matrix`	SingularValueDecomposition.`getPseudoInverse(double tol)` Returns the Moore–Penrose pseudo inverse of the matrix.
`Matrix`	SingularValueDecomposition.`getS()` Returns the diagonal matrix S such that the SVD product results in the original matrix.
`Matrix`	SingularValueDecomposition.`getU()` Returns the backing matrix U of the SVD.
`Matrix`	SingularValueDecomposition.`getV()` Returns the backing matrix V of the SVD.
`Matrix`	EigenValueDecomposition.`getV()` Return a copy of the eigenvector matrix
`Matrix`	EigenValueDecomposition.`getVRaw()` Returns the raw eigenvector matrix.
`Matrix`	EigenValueDecomposition.`getVT()` Returns a copy of the transposed eigenvector matrix.
`Matrix[]`	SparseMatrix.`lup()`
`abstract Matrix[]`	Matrix.`lup()`
`Matrix[]`	GenericMatrix.`lup()`
`Matrix[]`	DenseMatrix.`lup()`
`Matrix[]`	SparseMatrix.`lup(ExecutorService threadPool)`
`abstract Matrix[]`	Matrix.`lup(ExecutorService threadPool)`
`Matrix[]`	GenericMatrix.`lup(ExecutorService threadPool)`
`Matrix[]`	DenseMatrix.`lup(ExecutorService threadPool)`
`Matrix`	Matrix.`multiply(double c)` Creates a new Matrix that stores Ac*
`Matrix`	Matrix.`multiply(double c, ExecutorService threadPool)` Creates a new Matrix that stores Ac*
`Matrix`	Matrix.`multiply(Matrix B)` Creates a new matrix that stores AB*
`Matrix`	Matrix.`multiply(Matrix B, ExecutorService threadPool)` Creates a new matrix that stores AB*
`Matrix`	Matrix.`multiplyTranspose(Matrix B)` Returns the new matrix C that is C = AB^T*
`Matrix`	Matrix.`multiplyTranspose(Matrix B, ExecutorService threadPool)` Returns the new matrix C that is C = AB^T*
`static Matrix`	Matrix.`pascal(int size)` Creates a new square matrix that is a pascal matrix.
`Matrix[]`	SparseMatrix.`qr()`
`abstract Matrix[]`	Matrix.`qr()`
`Matrix[]`	GenericMatrix.`qr()`
`Matrix[]`	DenseMatrix.`qr()`
`Matrix[]`	SparseMatrix.`qr(ExecutorService threadPool)`
`abstract Matrix[]`	Matrix.`qr(ExecutorService threadPool)`
`Matrix[]`	GenericMatrix.`qr(ExecutorService threadPool)`
`Matrix[]`	DenseMatrix.`qr(ExecutorService threadPool)`
`Matrix`	SingularValueDecomposition.`solve(Matrix B)` Solves the linear system of equations for A x = B by using the equation `x = A^-1 B = V S^-1 U^T B` When A is not full rank, this results in a more numerically stable approximation that minimizes the least squares error.
`Matrix`	QRDecomposition.`solve(Matrix B)`
`Matrix`	LUPDecomposition.`solve(Matrix B)`
`Matrix`	CholeskyDecomposition.`solve(Matrix B)` Solves the linear system of equations A x = B
`Matrix`	SingularValueDecomposition.`solve(Matrix b, ExecutorService threadpool)` Solves the linear system of equations for A x = B by using the equation `x = A^-1 B = V S^-1 U^T B` When A is not full rank, this results in a more numerically stable approximation that minimizes the least squares error.
`Matrix`	QRDecomposition.`solve(Matrix B, ExecutorService threadpool)`
`Matrix`	LUPDecomposition.`solve(Matrix B, ExecutorService threadpool)`
`Matrix`	CholeskyDecomposition.`solve(Matrix B, ExecutorService threadpool)` Solves the linear system of equations A x = B
`Matrix`	Matrix.`subtract(double c)` Creates a new Matrix that stores the result of A-c
`Matrix`	Matrix.`subtract(double c, ExecutorService threadPool)` Creates a new Matrix that stores the result of A-c
`Matrix`	Matrix.`subtract(Matrix B)` Creates a new Matrix that stores the result of A-B
`Matrix`	Matrix.`subtract(Matrix B, ExecutorService threadPool)` Creates a new Matrix that stores the result of A-B
`Matrix`	Matrix.`transpose()` Returns a new matrix that is the transpose of this matrix.
`Matrix`	Matrix.`transposeMultiply(Matrix B)` Creates a new matrix equal to A'B*, or the same result as `A.transpose().multiply(B)`
`Matrix`	Matrix.`transposeMultiply(Matrix B, ExecutorService threadPool)` Computes the result matrix of A'B*, or the same result as `A.transpose().multiply(B)`

Methods in jsat.linear with parameters of type Matrix
Modifier and Type	Method and Description
`Matrix`	Matrix.`add(Matrix B)` Creates a new Matrix that stores the result of `A+B`
`Matrix`	Matrix.`add(Matrix B, ExecutorService threadPool)` Creates a new Matrix that stores the result of `A+B`
`static void`	RowColumnOps.`addCol(Matrix A, int j, double c)` Updates the values of column `j` in the given matrix to be A[:,j] = A[:,j]+ c
`static void`	RowColumnOps.`addCol(Matrix A, int j, int start, int to, double c)` Updates the values of column `j` in the given matrix to be A[:,j] = A[:,j]+ c
`static void`	RowColumnOps.`addDiag(Matrix A, int start, int to, double c)` Updates the values along the main diagonal of the matrix by adding a constant to them
`static void`	RowColumnOps.`addMultCol(Matrix A, int j, int start, int to, double t, double[] c)` Updates the values of column `j` in the given matrix to be A[:,j] = A[:,j]+c[:]*`t`. The Matrix `A` and array `c` do not need to have the same dimensions, so long as they both have indices in the given range.
`static void`	RowColumnOps.`addMultCol(Matrix A, int j, int start, int to, double t, Vec c)` Updates the values of column `j` in the given matrix to be A[:,j] = A[:,j]+c[:]*`t`. The Matrix `A` and vector `c` do not need to have the same dimensions, so long as they both have indices in the given range.
`static void`	RowColumnOps.`addMultRow(Matrix A, int i, int start, int to, double t, double[] c)` Updates the values of row `i` in the given matrix to be A[i,:] = A[i,:]+c[:]*`t`. The Matrix `A` and array `c` do not need to have the same dimensions, so long as they both have indices in the given range.
`static void`	RowColumnOps.`addMultRow(Matrix A, int i, int start, int to, double t, Vec c)` Updates the values of row `i` in the given matrix to be A[i,:] = A[i,:]+c[:]*`t`. The Matrix `A` and array `c` do not need to have the same dimensions, so long as they both have indices in the given range.
`static void`	RowColumnOps.`addRow(Matrix A, int i, double c)` Updates the values of row `i` in the given matrix to be A[i,:] = A[i,:]+ c
`static void`	RowColumnOps.`addRow(Matrix A, int i, int start, int to, double c)` Updates the values of row `i` in the given matrix to be A[i,:] = A[i,:]+ c
`static Matrix`	LUPDecomposition.`backSub(Matrix U, Matrix y)` Solves for the matrix x such that U x = y
`static Matrix`	LUPDecomposition.`backSub(Matrix U, Matrix y, ExecutorService threadpool)` Solves for the matrix x such that U x = y
`static Vec`	LUPDecomposition.`backSub(Matrix U, Vec y)` Solves for the vector x such that U x = y
`static boolean`	Matrix.`canMultiply(Matrix A, Matrix B)` Convenience method that will return `true` only if the two input matrices have dimensions compatible for multiplying AB*
`void`	Matrix.`copyTo(Matrix other)` Copes the values of this matrix into the other matrix of the same dimensions
`void`	Vec.`copyToCol(Matrix A, int col)` Copies the values of this vector into a column of another Matrix.
`void`	Vec.`copyToRow(Matrix A, int row)` Copies the values of this vector into a row of another Matrix
`static void`	MatrixStatistics.`covarianceMatrix(Vec mean, DataSet dataSet, Matrix covariance)` Computes the weighted covariance matrix of the given data set.
`static void`	MatrixStatistics.`covarianceMatrix(Vec mean, DataSet dataSet, Matrix covariance, double sumOfWeights, double sumOfSquaredWeights)` Computes the weighted covariance matrix of the given data set.
`static void`	MatrixStatistics.`covarianceMatrix(Vec mean, List<DataPoint> dataSet, Matrix covariance)` Computes the weighted result for the covariance matrix of the given data set.
`static void`	MatrixStatistics.`covarianceMatrix(Vec mean, List<DataPoint> dataSet, Matrix covariance, double sumOfWeights, double sumOfSquaredWeights)` Computes the weighted result for the covariance matrix of the given data set.
`static <V extends Vec> void`	MatrixStatistics.`covarianceMatrix(Vec mean, Matrix covariance, List<V> dataSet)`
`static void`	Matrix.`diagMult(Matrix A, Vec b)` Alters the matrix A so that it contains the result of A times a sparse matrix represented by only its diagonal values or A = Adiag(b)*.
`static void`	Matrix.`diagMult(Vec b, Matrix A)` Alters the matrix A so that it contains the result of sparse matrix represented by only its diagonal values times A or A = diag(b)A*.
`static void`	RowColumnOps.`divCol(Matrix A, int j, double c)` Updates the values of column `j` in the given matrix to be A[:,j] = A[:,j]/c
`static void`	RowColumnOps.`divCol(Matrix A, int j, int start, int to, double c)` Updates the values of column `j` in the given matrix to be A[:,j] = A[:,j]/c
`static void`	RowColumnOps.`divCol(Matrix A, int j, int start, int to, double[] c)` Updates the values of column `j` in the given matrix to be A[:,j] = A[:,j]/c[j]. The Matrix `A` and array `c` do not need to have the same dimensions, so long as they both have indices in the given range.
`static void`	RowColumnOps.`divCol(Matrix A, int j, int start, int to, Vec c)` Updates the values of column `j` in the given matrix to be A[:,j] = A[:,j]/c[j]. The Matrix `A` and vector `c` do not need to have the same dimensions, so long as they both have indices in the given range.
`static void`	RowColumnOps.`divRow(Matrix A, int i, double c)` Updates the values of row `i` in the given matrix to be A[i,:] = A[i,:] / c
`static void`	RowColumnOps.`divRow(Matrix A, int i, int start, int to, double c)` Updates the values of row `i` in the given matrix to be A[i,:] = A[i,:] / c
`static void`	RowColumnOps.`fillCol(Matrix A, int j, int from, int to, double val)` Fills the values in a column of the matrix
`static void`	RowColumnOps.`fillRow(Matrix A, int i, int from, int to, double val)` Fills the values in a row of the matrix
`static Matrix`	LUPDecomposition.`forwardSub(Matrix L, Matrix b)` Solves for the matrix x such that L x = b
`static Matrix`	LUPDecomposition.`forwardSub(Matrix L, Matrix b, ExecutorService threadpool)` Solves for the matrix x such that L x = b
`static Vec`	LUPDecomposition.`forwardSub(Matrix L, Vec b)` Solves for the vector x such that L x = b
`static void`	HessenbergForm.`hess(Matrix A)`
`static void`	HessenbergForm.`hess(Matrix A, ExecutorService threadpool)` Alters the matrix A such that it is in upper Hessenberg form.
`static boolean`	Matrix.`isSymmetric(Matrix A)` Checks to see if the given input is a perfectly symmetric matrix
`static boolean`	Matrix.`isSymmetric(Matrix A, double eps)` Checks to see if the given input is approximately symmetric.
`static void`	RowColumnOps.`multCol(Matrix A, int j, double c)` Updates the values of column `j` in the given matrix to be A[:,j] = A[:,j]* c
`static void`	RowColumnOps.`multCol(Matrix A, int j, int start, int to, double c)` Updates the values of column `j` in the given matrix to be A[:,j] = A[:,j]* c
`void`	VecPaired.`multiply(double c, Matrix A, Vec b)`
`void`	Vec.`multiply(double c, Matrix A, Vec b)` If this is vector `a`, this this computes b = b + c `a`^T*`A`
`void`	SparseVector.`multiply(double c, Matrix A, Vec b)`
`void`	ScaledVector.`multiply(double c, Matrix A, Vec b)`
`void`	RandomVector.`multiply(double c, Matrix A, Vec b)`
`void`	DenseVector.`multiply(double c, Matrix A, Vec b)`
`Vec`	Vec.`multiply(Matrix A)` Returns a new vector that is the result of the vector matrix product `this^TA`
`Matrix`	Matrix.`multiply(Matrix B)` Creates a new matrix that stores AB*
`Matrix`	Matrix.`multiply(Matrix B, ExecutorService threadPool)` Creates a new matrix that stores AB*
`void`	SparseMatrix.`multiply(Matrix B, Matrix C)`
`abstract void`	Matrix.`multiply(Matrix B, Matrix C)` Alters the matrix C to be equal to C = C+AB*
`void`	GenericMatrix.`multiply(Matrix b, Matrix C)`
`void`	DenseMatrix.`multiply(Matrix b, Matrix C)`
`void`	SparseMatrix.`multiply(Matrix B, Matrix C, ExecutorService threadPool)`
`abstract void`	Matrix.`multiply(Matrix B, Matrix C, ExecutorService threadPool)` Alters the matrix C to be equal to C = C+AB*
`void`	GenericMatrix.`multiply(Matrix b, Matrix C, ExecutorService threadPool)`
`void`	DenseMatrix.`multiply(Matrix b, Matrix C, ExecutorService threadPool)`
`void`	Vec.`multiply(Matrix A, Vec b)` If this is vector `a`, this this computes b = b + `a`^T*`A`
`Matrix`	Matrix.`multiplyTranspose(Matrix B)` Returns the new matrix C that is C = AB^T*
`Matrix`	Matrix.`multiplyTranspose(Matrix B, ExecutorService threadPool)` Returns the new matrix C that is C = AB^T*
`void`	SparseMatrix.`multiplyTranspose(Matrix B, Matrix C)`
`abstract void`	Matrix.`multiplyTranspose(Matrix B, Matrix C)` Alters the matrix C to be equal to C = C+AB^T*
`void`	GenericMatrix.`multiplyTranspose(Matrix b, Matrix C)`
`void`	SparseMatrix.`multiplyTranspose(Matrix B, Matrix C, ExecutorService threadPool)`
`abstract void`	Matrix.`multiplyTranspose(Matrix B, Matrix C, ExecutorService threadPool)` Alters the matrix C to be equal to C = C+AB^T*
`void`	GenericMatrix.`multiplyTranspose(Matrix b, Matrix C, ExecutorService threadPool)`
`static void`	RowColumnOps.`multRow(Matrix A, int i, double c)` Updates the values of row `i` in the given matrix to be A[i,:] = A[i,:] * c
`static void`	RowColumnOps.`multRow(Matrix A, int i, double[] c)` Updates the values of row `i` in the given matrix to be A[i,:] = A[i,:] .* c[i]
`static void`	RowColumnOps.`multRow(Matrix A, int i, int start, int to, double c)` Updates the values of row `i` in the given matrix to be A[i,:] = A[i,:] * c
`static void`	RowColumnOps.`multRow(Matrix A, int i, int start, int to, double[] c)` Updates the values of row `i` in the given matrix to be A[i,:] = A[i,:] .* c[i] The Matrix `A` and array `c` do not need to have the same dimensions, so long as they both have indices in the given range.
`static void`	RowColumnOps.`multRow(Matrix A, int i, int start, int to, Vec c)` Updates the values of row `i` in the given matrix to be A[i,:] = A[i,:] .* c[i] The Matrix `A` and vector `c` do not need to have the same dimensions, so long as they both have indices in the given range.
`static void`	RowColumnOps.`multRow(Matrix A, int i, Vec c)` Updates the values of row `i` in the given matrix to be A[i,:] = A[i,:] .* c[i] The Matrix `A` and vector `c` do not need to have the same dimensions, so long as they both have indices in the given range.
`void`	SparseMatrix.`mutableAdd(double c, Matrix B)`
`abstract void`	Matrix.`mutableAdd(double c, Matrix B)` Alters the current matrix to store the value A+cB*
`void`	GenericMatrix.`mutableAdd(double c, Matrix b)`
`void`	DenseMatrix.`mutableAdd(double c, Matrix b)`
`void`	SparseMatrix.`mutableAdd(double c, Matrix B, ExecutorService threadPool)`
`abstract void`	Matrix.`mutableAdd(double c, Matrix B, ExecutorService threadPool)` Alters the current matrix to store the value A+cB*
`void`	GenericMatrix.`mutableAdd(double c, Matrix b, ExecutorService threadPool)`
`void`	Matrix.`mutableAdd(Matrix B)` Alters the current matrix to store the value A+B
`void`	Matrix.`mutableAdd(Matrix B, ExecutorService threadpool)` Alters the current matrix to store the value A+B
`void`	Matrix.`mutableSubtract(double c, Matrix B)` Alters the current matrix to store A-cB*
`void`	Matrix.`mutableSubtract(double c, Matrix B, ExecutorService threadPool)` Alters the current matrix to store A-cB*
`void`	Matrix.`mutableSubtract(Matrix B)` Alters the current matrix to store A-B
`void`	Matrix.`mutableSubtract(Matrix B, ExecutorService threadpool)` Alters the current matrix to store A-B
`static void`	Matrix.`OuterProductUpdate(Matrix A, Vec x, Vec y, double c)` Alters the matrix A such that, A = A + c x * y'*
`static void`	Matrix.`OuterProductUpdate(Matrix A, Vec x, Vec y, double c, ExecutorService threadpool)` Alters the matrix A such that, A = A + c x * y'*
`static boolean`	Matrix.`sameDimensions(Matrix A, Matrix B)` Convenience method that will return `true` only if the two input matrices have the exact same dimensions.
`Matrix`	SingularValueDecomposition.`solve(Matrix B)` Solves the linear system of equations for A x = B by using the equation `x = A^-1 B = V S^-1 U^T B` When A is not full rank, this results in a more numerically stable approximation that minimizes the least squares error.
`Matrix`	QRDecomposition.`solve(Matrix B)`
`Matrix`	LUPDecomposition.`solve(Matrix B)`
`Matrix`	CholeskyDecomposition.`solve(Matrix B)` Solves the linear system of equations A x = B
`Matrix`	SingularValueDecomposition.`solve(Matrix b, ExecutorService threadpool)` Solves the linear system of equations for A x = B by using the equation `x = A^-1 B = V S^-1 U^T B` When A is not full rank, this results in a more numerically stable approximation that minimizes the least squares error.
`Matrix`	QRDecomposition.`solve(Matrix B, ExecutorService threadpool)`
`Matrix`	LUPDecomposition.`solve(Matrix B, ExecutorService threadpool)`
`Matrix`	CholeskyDecomposition.`solve(Matrix B, ExecutorService threadpool)` Solves the linear system of equations A x = B
`Matrix`	Matrix.`subtract(Matrix B)` Creates a new Matrix that stores the result of A-B
`Matrix`	Matrix.`subtract(Matrix B, ExecutorService threadPool)` Creates a new Matrix that stores the result of A-B
`static void`	RowColumnOps.`swapCol(Matrix A, int j, int k)` Swaps the columns `j` and `k` in the given matrix.
`static void`	RowColumnOps.`swapCol(Matrix A, int j, int k, int start, int to)` Swaps the columns `j` and `k` in the given matrix.
`static void`	RowColumnOps.`swapRow(Matrix A, int j, int k)` Swaps the columns `j` and `k` in the given matrix.
`static void`	RowColumnOps.`swapRow(Matrix A, int j, int k, int start, int to)` Swaps the rows `j` and `k` in the given matrix.
`void`	SparseMatrix.`transpose(Matrix C)`
`abstract void`	Matrix.`transpose(Matrix C)` Overwrites the values stored in matrix C to store the value of A'
`void`	GenericMatrix.`transpose(Matrix C)`
`void`	DenseMatrix.`transpose(Matrix C)`
`Matrix`	Matrix.`transposeMultiply(Matrix B)` Creates a new matrix equal to A'B*, or the same result as `A.transpose().multiply(B)`
`Matrix`	Matrix.`transposeMultiply(Matrix B, ExecutorService threadPool)` Computes the result matrix of A'B*, or the same result as `A.transpose().multiply(B)`
`void`	SparseMatrix.`transposeMultiply(Matrix B, Matrix C)`
`abstract void`	Matrix.`transposeMultiply(Matrix B, Matrix C)` Alters the matrix C so that C = C + A'B*
`void`	GenericMatrix.`transposeMultiply(Matrix b, Matrix C)`
`void`	DenseMatrix.`transposeMultiply(Matrix b, Matrix C)`
`void`	SparseMatrix.`transposeMultiply(Matrix B, Matrix C, ExecutorService threadPool)`
`abstract void`	Matrix.`transposeMultiply(Matrix B, Matrix C, ExecutorService threadPool)` Alters the matrix C so that C = C + A'B*
`void`	GenericMatrix.`transposeMultiply(Matrix b, Matrix C, ExecutorService threadPool)`
`void`	DenseMatrix.`transposeMultiply(Matrix b, Matrix C, ExecutorService threadPool)`

Constructors in jsat.linear with parameters of type Matrix
Constructor and Description
`CholeskyDecomposition(Matrix A)` Computes the Cholesky Decomposition of the matrix A.
`CholeskyDecomposition(Matrix A, ExecutorService threadpool)` Computes the Cholesky Decomposition of the matrix A.
`DenseMatrix(Matrix toCopy)` Creates a new dense matrix that has a copy of all the same values as the given one
`EigenValueDecomposition(Matrix A)` Creates a new new Eigen Value Decomposition.
`EigenValueDecomposition(Matrix A, double eps)` Creates a new new Eigen Value Decomposition.
`LUPDecomposition(Matrix A)`
`LUPDecomposition(Matrix A, ExecutorService threadpool)`
`LUPDecomposition(Matrix L, Matrix U, Matrix P)`
`QRDecomposition(Matrix A)`
`QRDecomposition(Matrix A, ExecutorService threadpool)`
`QRDecomposition(Matrix Q, Matrix R)`
`SingularValueDecomposition(Matrix A)` Creates a new SVD of the matrix `A` such that A = U Σ V^T.
`SingularValueDecomposition(Matrix A, int maxIterations)` Creates a new SVD of the matrix `A` such that A = U Σ V^T.
`SingularValueDecomposition(Matrix U, Matrix V, double[] s)` Sets the values for a SVD explicitly.
`SubMatrix(Matrix baseMatrix, int firstRow, int firstColumn, int toRow, int toCol)` Creates a new matrix that is a sub view of the given base matrix.
`TransposeView(Matrix base)`

Uses of Matrix in jsat.linear.solvers

Methods in jsat.linear.solvers with parameters of type Matrix
Modifier and Type	Method and Description
`static Vec`	ConjugateGradient.`solve(double eps, Matrix A, Vec x, Vec b)` Uses the Conjugate Gradient method to solve a linear system of equations involving a symmetric positive definite matrix. A symmetric positive definite matrix is a matrix A such that: A^T = A x^T * A * x > 0 for all x != 0 NOTE: No checks will be performed to confirm these properties of the given matrix.
`static Vec`	ConjugateGradient.`solve(double eps, Matrix A, Vec x, Vec b, Matrix Minv)` Uses the Conjugate Gradient method to solve a linear system of equations involving a symmetric positive definite matrix. A symmetric positive definite matrix is a matrix A such that: A^T = A x^T * A * x > 0 for all x != 0 NOTE: No checks will be performed to confirm these properties of the given matrix.
`static Vec`	ConjugateGradient.`solve(Matrix A, Vec b)`
`static Vec`	ConjugateGradient.`solveCGNR(double eps, Matrix A, Vec x, Vec b)` Uses the Conjugate Gradient method to compute the least squares solution to a system of linear equations. Computes the least squares solution to A x = b.
`static Vec`	ConjugateGradient.`solveCGNR(Matrix A, Vec b)`

Uses of Matrix in jsat.math

Methods in jsat.math that return Matrix
Modifier and Type	Method and Description
`Matrix`	FunctionMat.`f(double... x)` Computes a matrix based on multivariate input
`Matrix`	FunctionMat.`f(Vec x)` Computes a matrix based on multivariate input
`Matrix`	FunctionMat.`f(Vec x, Matrix s)` Computes a matrix based on multivariate input
`Matrix`	FunctionMat.`f(Vec x, Matrix s, ExecutorService ex)` Computes a matrix based on multivariate input

Methods in jsat.math with parameters of type Matrix
Modifier and Type	Method and Description
`Matrix`	FunctionMat.`f(Vec x, Matrix s)` Computes a matrix based on multivariate input
`Matrix`	FunctionMat.`f(Vec x, Matrix s, ExecutorService ex)` Computes a matrix based on multivariate input

Uses of Classjsat.linear.Matrix

Uses of Matrix in jsat

Uses of Matrix in jsat.classifiers.neuralnetwork.activations

Uses of Matrix in jsat.classifiers.neuralnetwork.initializers

Uses of Matrix in jsat.classifiers.neuralnetwork.regularizers

Uses of Matrix in jsat.clustering

Uses of Matrix in jsat.datatransform

Uses of Matrix in jsat.datatransform.visualization

Uses of Matrix in jsat.distributions.kernels

Uses of Matrix in jsat.distributions.multivariate

Uses of Matrix in jsat.linear

Uses of Matrix in jsat.linear.solvers

Uses of Matrix in jsat.math

Uses of Class
jsat.linear.Matrix