| Package | Description |
|---|---|
| cern.colt.matrix.tfcomplex |
Matrix interfaces and factories holding elements of fcomplex data type.
|
| cern.colt.matrix.tfcomplex.impl |
Efficient and flexible dense and sparse 1, 2 and 3-dimensional matrices holding elements of fcomplex data type.
|
| cern.colt.matrix.tfloat |
Matrix interfaces and factories holding elements of float data type.
|
| cern.colt.matrix.tfloat.algo |
Linear Algebraic matrix computations operating on
FloatMatrix2D
and FloatMatrix1D. |
| cern.colt.matrix.tfloat.algo.decomposition |
Martrix decompositions.
|
| cern.colt.matrix.tfloat.algo.solver |
Iterative solvers
BiCG - BiConjugate gradients.
BiCGstab - BiConjugate gradients stabilized.
CG - Conjugate gradients.
CGS - Conjugate gradients squared.
Chebyshev - The Chebyshev iteration for symmetrical, positive definite matrices.
GMRES - Generalized minimal residual using restart.
IR - Iterative refinement (Richardson's method).
QMR - Quasi-minimal residual.
HyBR - Hybrid Bidiagonalization Regularization.
MRNSD - Modified Residual Norm Steepest Descent.
CGLS - Conjugate Gradient for Least Squares.
|
| cern.colt.matrix.tfloat.algo.solver.preconditioner |
Preconditioners for iterative solvers.
|
| cern.colt.matrix.tfloat.impl |
Efficient and flexible dense and sparse 1, 2 and 3-dimensional matrices holding elements of float data type.
|
| Modifier and Type | Method and Description |
|---|---|
abstract FloatMatrix1D |
FComplexMatrix1D.getImaginaryPart()
Returns the imaginary part of this matrix
|
abstract FloatMatrix1D |
FComplexMatrix1D.getRealPart()
Returns the real part of this matrix
|
| Modifier and Type | Method and Description |
|---|---|
FComplexMatrix1D |
FComplexMatrix1D.assignImaginary(FloatMatrix1D other)
Replaces imaginary part of the receiver with the values of another real
matrix.
|
FComplexMatrix1D |
FComplexMatrix1D.assignReal(FloatMatrix1D other)
Replaces real part of the receiver with the values of another real
matrix.
|
| Modifier and Type | Method and Description |
|---|---|
FloatMatrix1D |
WrapperFComplexMatrix1D.getImaginaryPart() |
FloatMatrix1D |
DenseFComplexMatrix1D.getImaginaryPart() |
FloatMatrix1D |
SparseFComplexMatrix1D.getImaginaryPart() |
FloatMatrix1D |
WrapperFComplexMatrix1D.getRealPart() |
FloatMatrix1D |
DenseFComplexMatrix1D.getRealPart() |
FloatMatrix1D |
SparseFComplexMatrix1D.getRealPart() |
| Modifier and Type | Method and Description |
|---|---|
FComplexMatrix1D |
DenseFComplexMatrix1D.assignImaginary(FloatMatrix1D other) |
FComplexMatrix1D |
DenseFComplexMatrix1D.assignReal(FloatMatrix1D other) |
| Constructor and Description |
|---|
DenseFComplexMatrix1D(FloatMatrix1D realPart)
Constructs a complex matrix with the same size as realPart
matrix and fills the real part of this matrix with elements of
realPart.
|
| Modifier and Type | Method and Description |
|---|---|
FloatMatrix1D |
FloatFactory1D.append(FloatMatrix1D A,
FloatMatrix1D B)
C = A||B; Constructs a new matrix which is the concatenation of two other
matrices.
|
FloatMatrix1D |
FloatFactory1D.ascending(int size)
Constructs a matrix with cells having ascending values.
|
FloatMatrix1D |
FloatMatrix1D.assign(float value)
Sets all cells to the state specified by value.
|
FloatMatrix1D |
FloatMatrix1D.assign(float[] values)
Sets all cells to the state specified by values.
|
FloatMatrix1D |
FloatMatrix1D.assign(FloatFunction f)
Assigns the result of a function to each cell;
x[i] = function(x[i]).
|
FloatMatrix1D |
FloatMatrix1D.assign(FloatMatrix1D other)
Replaces all cell values of the receiver with the values of another
matrix.
|
FloatMatrix1D |
FloatMatrix1D.assign(FloatMatrix1D y,
FloatFloatFunction function)
Assigns the result of a function to each cell;
x[i] = function(x[i],y[i]).
|
FloatMatrix1D |
FloatMatrix1D.assign(FloatMatrix1D y,
FloatFloatFunction function,
IntArrayList nonZeroIndexes)
Assigns the result of a function to each cell;
x[i] = function(x[i],y[i]).
|
FloatMatrix1D |
FloatMatrix1D.assign(FloatProcedure cond,
float value)
Assigns a value to all cells that satisfy a condition.
|
FloatMatrix1D |
FloatMatrix1D.assign(FloatProcedure cond,
FloatFunction f)
Assigns the result of a function to all cells that satisfy a condition.
|
FloatMatrix1D |
FloatMatrix1D.copy()
Constructs and returns a deep copy of the receiver.
|
FloatMatrix1D |
FloatFactory1D.descending(int size)
Constructs a matrix with cells having descending values.
|
FloatMatrix1D |
FloatFactory2D.diagonal(FloatMatrix2D A)
Constructs a new vector consisting of the diagonal elements of A
.
|
FloatMatrix1D |
FloatMatrix1D.like()
Construct and returns a new empty matrix of the same dynamic type
as the receiver, having the same size.
|
abstract FloatMatrix1D |
FloatMatrix1D.like(int size)
Construct and returns a new empty matrix of the same dynamic type
as the receiver, having the specified size.
|
abstract FloatMatrix1D |
FloatMatrix2D.like1D(int size)
Construct and returns a new 1-d matrix of the corresponding dynamic
type, entirelly independent of the receiver.
|
FloatMatrix1D |
FloatFactory1D.make(AbstractFloatList values)
Constructs a matrix from the values of the given list.
|
FloatMatrix1D |
FloatFactory1D.make(float[] values)
Constructs a matrix with the given cell values.
|
FloatMatrix1D |
FloatFactory1D.make(FloatMatrix1D[] parts)
Constructs a matrix which is the concatenation of all given parts.
|
FloatMatrix1D |
FloatFactory1D.make(int size)
Constructs a matrix with the given shape, each cell initialized with
zero.
|
FloatMatrix1D |
FloatFactory1D.make(int size,
float initialValue)
Constructs a matrix with the given shape, each cell initialized with the
given value.
|
FloatMatrix1D |
FloatFactory1D.random(int size)
Constructs a matrix with uniformly distributed values in (0,1)
(exclusive).
|
FloatMatrix1D |
FloatFactory1D.repeat(FloatMatrix1D A,
int repeat)
C = A||A||..||A; Constructs a new matrix which is concatenated
repeat times.
|
FloatMatrix1D |
FloatFactory1D.sample(int size,
float value,
float nonZeroFraction)
Constructs a randomly sampled matrix with the given shape.
|
abstract FloatMatrix1D |
FloatMatrix2D.vectorize()
Returns a vector obtained by stacking the columns of the matrix on top of
one another.
|
abstract FloatMatrix1D |
FloatMatrix3D.vectorize()
Returns a vector obtained by stacking the columns of each slice of the
matrix on top of one another.
|
FloatMatrix1D |
FloatMatrix2D.viewColumn(int column)
Constructs and returns a new slice view representing the rows of
the given column.
|
FloatMatrix1D |
FloatMatrix1D.viewFlip()
Constructs and returns a new flip view.
|
FloatMatrix1D |
FloatMatrix1D.viewPart(int index,
int width)
Constructs and returns a new sub-range view that is a
width sub matrix starting at index.
|
FloatMatrix1D |
FloatMatrix2D.viewRow(int row)
Constructs and returns a new slice view representing the columns
of the given row.
|
FloatMatrix1D |
FloatMatrix1D.viewSelection(FloatProcedure condition)
Constructs and returns a new selection view that is a matrix
holding the cells matching the given condition.
|
FloatMatrix1D |
FloatMatrix1D.viewSelection(int[] indexes)
Constructs and returns a new selection view that is a matrix
holding the indicated cells.
|
FloatMatrix1D |
FloatMatrix1D.viewSorted()
Sorts the vector into ascending order, according to the natural
ordering.
|
FloatMatrix1D |
FloatMatrix1D.viewStrides(int stride)
Constructs and returns a new stride view which is a sub matrix
consisting of every i-th cell.
|
FloatMatrix1D |
FloatMatrix2D.zMult(FloatMatrix1D y,
FloatMatrix1D z)
Linear algebraic matrix-vector multiplication; z = A * y;
Equivalent to return A.zMult(y,z,1,0);
|
FloatMatrix1D |
FloatMatrix2D.zMult(FloatMatrix1D y,
FloatMatrix1D z,
float alpha,
float beta,
boolean transposeA)
Linear algebraic matrix-vector multiplication;
z = alpha * A * y + beta*z.
|
| Modifier and Type | Method and Description |
|---|---|
float |
FloatMatrix1D.aggregate(FloatMatrix1D other,
FloatFloatFunction aggr,
FloatFloatFunction f)
Applies a function to each corresponding cell of two matrices and
aggregates the results.
|
FloatMatrix1D |
FloatFactory1D.append(FloatMatrix1D A,
FloatMatrix1D B)
C = A||B; Constructs a new matrix which is the concatenation of two other
matrices.
|
FloatMatrix2D |
FloatFactory2D.appendColumn(FloatMatrix2D A,
FloatMatrix1D b)
C = A||b; Constructs a new matrix which is the column-wise concatenation
of two other matrices.
|
FloatMatrix2D |
FloatFactory2D.appendRow(FloatMatrix2D A,
FloatMatrix1D b)
C = A||b; Constructs a new matrix which is the row-wise concatenation of
two other matrices.
|
boolean |
FloatMatrix1DProcedure.apply(FloatMatrix1D element)
Applies a procedure to an argument.
|
FloatMatrix1D |
FloatMatrix1D.assign(FloatMatrix1D other)
Replaces all cell values of the receiver with the values of another
matrix.
|
FloatMatrix1D |
FloatMatrix1D.assign(FloatMatrix1D y,
FloatFloatFunction function)
Assigns the result of a function to each cell;
x[i] = function(x[i],y[i]).
|
FloatMatrix1D |
FloatMatrix1D.assign(FloatMatrix1D y,
FloatFloatFunction function,
IntArrayList nonZeroIndexes)
Assigns the result of a function to each cell;
x[i] = function(x[i],y[i]).
|
FloatMatrix2D |
FloatFactory2D.diagonal(FloatMatrix1D vector)
Constructs a new diagonal matrix whose diagonal elements are the elements
of vector.
|
FloatMatrix1D |
FloatFactory1D.make(FloatMatrix1D[] parts)
Constructs a matrix which is the concatenation of all given parts.
|
FloatMatrix1D |
FloatFactory1D.repeat(FloatMatrix1D A,
int repeat)
C = A||A||..||A; Constructs a new matrix which is concatenated
repeat times.
|
void |
FloatMatrix1D.swap(FloatMatrix1D other)
Swaps each element this[i] with other[i].
|
FloatArrayList |
FloatFactory1D.toList(FloatMatrix1D values)
Constructs a list from the given matrix.
|
float |
FloatMatrix1D.zDotProduct(FloatMatrix1D y)
Returns the dot product of two vectors x and y, which is
Sum(x[i]*y[i]).
|
float |
FloatMatrix1D.zDotProduct(FloatMatrix1D y,
int from,
int length)
Returns the dot product of two vectors x and y, which is
Sum(x[i]*y[i]).
|
float |
FloatMatrix1D.zDotProduct(FloatMatrix1D y,
int from,
int length,
IntArrayList nonZeroIndexes)
Returns the dot product of two vectors x and y, which is
Sum(x[i]*y[i]).
|
FloatMatrix1D |
FloatMatrix2D.zMult(FloatMatrix1D y,
FloatMatrix1D z)
Linear algebraic matrix-vector multiplication; z = A * y;
Equivalent to return A.zMult(y,z,1,0);
|
FloatMatrix1D |
FloatMatrix2D.zMult(FloatMatrix1D y,
FloatMatrix1D z,
float alpha,
float beta,
boolean transposeA)
Linear algebraic matrix-vector multiplication;
z = alpha * A * y + beta*z.
|
| Modifier and Type | Method and Description |
|---|---|
FloatMatrix1D |
DenseFloatAlgebra.backwardSolve(FloatMatrix2D U,
FloatMatrix1D b)
Solves the upper triangular system U*x=b;
|
FloatMatrix1D |
DenseFloatAlgebra.forwardSolve(FloatMatrix2D L,
FloatMatrix1D b)
Solves the lower triangular system U*x=b;
|
FloatMatrix1D |
DenseFloatAlgebra.kron(FloatMatrix1D x,
FloatMatrix1D y)
Computes the Kronecker product of two real matrices.
|
FloatMatrix1D |
DenseFloatAlgebra.mult(FloatMatrix2D A,
FloatMatrix1D y)
Linear algebraic matrix-vector multiplication; z = A * y.
|
FloatMatrix1D |
DenseFloatAlgebra.permute(FloatMatrix1D A,
int[] indexes,
float[] work)
Modifies the given vector A such that it is permuted as
specified; Useful for pivoting.
|
FloatMatrix1D |
SparseFloatAlgebra.solve(FloatMatrix2D A,
FloatMatrix1D b)
Solves A*x = b.
|
FloatMatrix1D |
DenseFloatAlgebra.solve(FloatMatrix2D A,
FloatMatrix1D b)
Solves A*x = b.
|
FloatMatrix1D |
FloatSorting.sort(FloatMatrix1D vector)
Sorts the vector into ascending order, according to the natural
ordering.
|
FloatMatrix1D |
FloatSorting.sort(FloatMatrix1D vector,
FloatComparator c)
Sorts the vector into ascending order, according to the order induced by
the specified comparator.
|
static FloatMatrix1D |
FloatStatistic.viewSample(FloatMatrix1D matrix,
float fraction,
FloatRandomEngine randomGenerator)
Constructs and returns a sampling view with a size of
round(matrix.size() * fraction).
|
| Modifier and Type | Method and Description |
|---|---|
float |
FloatStatistic.VectorVectorFunction.apply(FloatMatrix1D x,
FloatMatrix1D y)
Applies a function to two argument vectors.
|
FloatMatrix1D |
DenseFloatAlgebra.backwardSolve(FloatMatrix2D U,
FloatMatrix1D b)
Solves the upper triangular system U*x=b;
|
static DynamicFloatBin1D |
FloatStatistic.bin(FloatMatrix1D vector)
Fills all cell values of the given vector into a bin from which
statistics measures can be retrieved efficiently.
|
void |
FloatProperty.checkDense(FloatMatrix1D A) |
void |
FloatProperty.checkSparse(FloatMatrix1D A) |
int |
FloatMatrix1DComparator.compare(FloatMatrix1D o1,
FloatMatrix1D o2)
Compares its two arguments for order.
|
static FloatIHistogram2D |
FloatStatistic.cube(FloatMatrix1D x,
FloatMatrix1D y,
FloatMatrix1D weights)
2-d OLAP cube operator; Fills all cells of the given vectors into the
given histogram.
|
static FloatIHistogram3D |
FloatStatistic.cube(FloatMatrix1D x,
FloatMatrix1D y,
FloatMatrix1D z,
FloatMatrix1D weights)
3-d OLAP cube operator; Fills all cells of the given vectors into the
given histogram.
|
float |
FloatBlas.dasum(FloatMatrix1D x)
Returns the sum of absolute values; |x[0]| + |x[1]| + ...
|
float |
SmpFloatBlas.dasum(FloatMatrix1D x) |
void |
FloatBlas.daxpy(float alpha,
FloatMatrix1D x,
FloatMatrix1D y)
Combined vector scaling; y = y + alpha*x.
|
void |
SmpFloatBlas.daxpy(float alpha,
FloatMatrix1D x,
FloatMatrix1D y) |
void |
FloatBlas.dcopy(FloatMatrix1D x,
FloatMatrix1D y)
Vector assignment (copying); y = x.
|
void |
SmpFloatBlas.dcopy(FloatMatrix1D x,
FloatMatrix1D y) |
float |
FloatBlas.ddot(FloatMatrix1D x,
FloatMatrix1D y)
Returns the dot product of two vectors x and y, which is
Sum(x[i]*y[i]).
|
float |
SmpFloatBlas.ddot(FloatMatrix1D x,
FloatMatrix1D y) |
void |
FloatBlas.dgemv(boolean transposeA,
float alpha,
FloatMatrix2D A,
FloatMatrix1D x,
float beta,
FloatMatrix1D y)
Generalized linear algebraic matrix-vector multiply;
y = alpha*A*x + beta*y.
|
void |
SmpFloatBlas.dgemv(boolean transposeA,
float alpha,
FloatMatrix2D A,
FloatMatrix1D x,
float beta,
FloatMatrix1D y) |
void |
FloatBlas.dger(float alpha,
FloatMatrix1D x,
FloatMatrix1D y,
FloatMatrix2D A)
Performs a rank 1 update; A = A + alpha*x*y'.
|
void |
SmpFloatBlas.dger(float alpha,
FloatMatrix1D x,
FloatMatrix1D y,
FloatMatrix2D A) |
float |
FloatBlas.dnrm2(FloatMatrix1D x)
Return the 2-norm; sqrt(x[0]^2 + x[1]^2 + ...).
|
float |
SmpFloatBlas.dnrm2(FloatMatrix1D x) |
void |
FloatBlas.drot(FloatMatrix1D x,
FloatMatrix1D y,
float c,
float s)
Applies a givens plane rotation to (x,y);
x = c*x + s*y; y = c*y - s*x.
|
void |
SmpFloatBlas.drot(FloatMatrix1D x,
FloatMatrix1D y,
float c,
float s) |
void |
FloatBlas.dscal(float alpha,
FloatMatrix1D x)
Vector scaling; x = alpha*x.
|
void |
SmpFloatBlas.dscal(float alpha,
FloatMatrix1D x) |
void |
FloatBlas.dswap(FloatMatrix1D x,
FloatMatrix1D y)
Swaps the elements of two vectors; y <==> x.
|
void |
SmpFloatBlas.dswap(FloatMatrix1D x,
FloatMatrix1D y) |
void |
FloatBlas.dsymv(boolean isUpperTriangular,
float alpha,
FloatMatrix2D A,
FloatMatrix1D x,
float beta,
FloatMatrix1D y)
Symmetric matrix-vector multiplication; y = alpha*A*x + beta*y.
|
void |
SmpFloatBlas.dsymv(boolean isUpperTriangular,
float alpha,
FloatMatrix2D A,
FloatMatrix1D x,
float beta,
FloatMatrix1D y) |
void |
FloatBlas.dtrmv(boolean isUpperTriangular,
boolean transposeA,
boolean isUnitTriangular,
FloatMatrix2D A,
FloatMatrix1D x)
Triangular matrix-vector multiplication; x = A*x or x = A'*x.
|
void |
SmpFloatBlas.dtrmv(boolean isUpperTriangular,
boolean transposeA,
boolean isUnitTriangular,
FloatMatrix2D A,
FloatMatrix1D x) |
boolean |
FloatProperty.equals(FloatMatrix1D A,
float value)
Returns whether all cells of the given matrix A are equal to the
given value.
|
boolean |
FloatProperty.equals(FloatMatrix1D A,
FloatMatrix1D B)
Returns whether both given matrices A and B are equal.
|
FloatMatrix1D |
DenseFloatAlgebra.forwardSolve(FloatMatrix2D L,
FloatMatrix1D b)
Solves the lower triangular system U*x=b;
|
static FloatIHistogram1D |
FloatStatistic.histogram(FloatIHistogram1D histo,
FloatMatrix1D vector)
Fills all cells of the given vector into the given histogram.
|
static FloatIHistogram2D |
FloatStatistic.histogram(FloatIHistogram2D histo,
FloatMatrix1D x,
FloatMatrix1D y)
Fills all cells of the given vectors into the given histogram.
|
static FloatIHistogram2D |
FloatStatistic.histogram(FloatIHistogram2D histo,
FloatMatrix1D x,
FloatMatrix1D y,
FloatMatrix1D weights)
Fills all cells of the given vectors into the given histogram.
|
static FloatIHistogram3D |
FloatStatistic.histogram(FloatIHistogram3D histo,
FloatMatrix1D x,
FloatMatrix1D y,
FloatMatrix1D z,
FloatMatrix1D weights)
Fills all cells of the given vectors into the given histogram.
|
int |
FloatBlas.idamax(FloatMatrix1D x)
Returns the index of largest absolute value;
i such that |x[i]| == max(|x[0]|,|x[1]|,...)..
|
int |
SmpFloatBlas.idamax(FloatMatrix1D x) |
FloatMatrix1D |
DenseFloatAlgebra.kron(FloatMatrix1D x,
FloatMatrix1D y)
Computes the Kronecker product of two real matrices.
|
float |
DenseFloatAlgebra.mult(FloatMatrix1D x,
FloatMatrix1D y)
Inner product of two vectors; Sum(x[i] * y[i]).
|
FloatMatrix1D |
DenseFloatAlgebra.mult(FloatMatrix2D A,
FloatMatrix1D y)
Linear algebraic matrix-vector multiplication; z = A * y.
|
FloatMatrix2D |
DenseFloatAlgebra.multOuter(FloatMatrix1D x,
FloatMatrix1D y,
FloatMatrix2D A)
Outer product of two vectors; Sets A[i,j] = x[i] * y[j].
|
float |
DenseFloatAlgebra.norm(FloatMatrix1D x,
Norm type) |
float |
DenseFloatAlgebra.norm1(FloatMatrix1D x)
Returns the one-norm of vector x, which is
Sum(abs(x[i])).
|
float |
DenseFloatAlgebra.norm2(FloatMatrix1D x)
Returns the two-norm (aka euclidean norm) of vector x;
equivalent to Sqrt(mult(x,x)).
|
float |
DenseFloatAlgebra.normF(FloatMatrix1D A)
Returns the Frobenius norm of matrix A, which is
Sqrt(Sum(A[i]2)).
|
float |
DenseFloatAlgebra.normInfinity(FloatMatrix1D x)
Returns the infinity norm of vector x, which is
Max(abs(x[i])).
|
FloatMatrix1D |
DenseFloatAlgebra.permute(FloatMatrix1D A,
int[] indexes,
float[] work)
Modifies the given vector A such that it is permuted as
specified; Useful for pivoting.
|
FloatMatrix1D |
SparseFloatAlgebra.solve(FloatMatrix2D A,
FloatMatrix1D b)
Solves A*x = b.
|
FloatMatrix1D |
DenseFloatAlgebra.solve(FloatMatrix2D A,
FloatMatrix1D b)
Solves A*x = b.
|
FloatMatrix1D |
FloatSorting.sort(FloatMatrix1D vector)
Sorts the vector into ascending order, according to the natural
ordering.
|
FloatMatrix1D |
FloatSorting.sort(FloatMatrix1D vector,
FloatComparator c)
Sorts the vector into ascending order, according to the order induced by
the specified comparator.
|
int[] |
FloatSorting.sortIndex(FloatMatrix1D vector)
Sorts indexes of the
vector into ascending order. |
int[] |
FloatSorting.sortIndex(FloatMatrix1D vector,
FloatComparator c)
Sorts indexes of the
vector according to the comparator
c. |
int[] |
FloatSorting.sortIndex(FloatMatrix1D vector,
IntComparator comp)
Multithreaded method that sorts indexes of the
vector
according to the comparator comp. |
String |
FloatFormatter.toSourceCode(FloatMatrix1D matrix)
Returns a string s such that Object[] m = s is a legal
Java statement.
|
String |
FloatFormatter.toString(FloatMatrix1D matrix)
Returns a string representation of the given matrix.
|
static FloatMatrix1D |
FloatStatistic.viewSample(FloatMatrix1D matrix,
float fraction,
FloatRandomEngine randomGenerator)
Constructs and returns a sampling view with a size of
round(matrix.size() * fraction).
|
FloatMatrix2D |
DenseFloatAlgebra.xmultOuter(FloatMatrix1D x,
FloatMatrix1D y)
Outer product of two vectors; Returns a matrix with
A[i,j] = x[i] * y[j].
|
| Modifier and Type | Method and Description |
|---|---|
FloatMatrix1D |
DenseFloatEigenvalueDecomposition.getImagEigenvalues()
Returns the imaginary parts of the eigenvalues.
|
FloatMatrix1D |
DenseFloatEigenvalueDecomposition.getRealEigenvalues()
Returns the real parts of the eigenvalues.
|
FloatMatrix1D |
DenseFloatCholeskyDecomposition.solve(FloatMatrix1D b) |
FloatMatrix1D |
DenseFloatLUDecomposition.solve(FloatMatrix1D b)
Solves A*x = b.
|
FloatMatrix1D |
DenseFloatQRDecomposition.solve(FloatMatrix1D b)
Least squares solution of A*x = b; returns x.
|
| Modifier and Type | Method and Description |
|---|---|
void |
SparseFloatCholeskyDecomposition.solve(FloatMatrix1D b)
Solves A*x = b(in-place).
|
FloatMatrix1D |
DenseFloatCholeskyDecomposition.solve(FloatMatrix1D b) |
void |
DenseFloatLUDecompositionQuick.solve(FloatMatrix1D B)
Solves the system of equations A*X = B (in-place).
|
FloatMatrix1D |
DenseFloatLUDecomposition.solve(FloatMatrix1D b)
Solves A*x = b.
|
FloatMatrix1D |
DenseFloatQRDecomposition.solve(FloatMatrix1D b)
Least squares solution of A*x = b; returns x.
|
void |
SparseFloatLUDecomposition.solve(FloatMatrix1D b)
Solves A*x = b(in-place).
|
void |
SparseFloatQRDecomposition.solve(FloatMatrix1D b)
Solve a least-squares problem (min ||Ax-b||_2, where A is m-by-n with m
>= n) or underdetermined system (Ax=b, where m < n).
|
| Modifier and Type | Method and Description |
|---|---|
void |
FloatGivensRotation.apply(FloatMatrix1D x,
int i1,
int i2)
Applies the Givens rotation to two elements of a vector
|
boolean |
AbstractFloatIterationMonitor.converged(float r,
FloatMatrix1D x) |
boolean |
FloatIterationMonitor.converged(float r,
FloatMatrix1D x)
Checks for convergence
|
boolean |
HyBRFloatIterationMonitor.converged(float r,
FloatMatrix1D x) |
boolean |
AbstractFloatIterationMonitor.converged(FloatMatrix1D r) |
boolean |
FloatIterationMonitor.converged(FloatMatrix1D r)
Checks for convergence
|
boolean |
AbstractFloatIterationMonitor.converged(FloatMatrix1D r,
FloatMatrix1D x) |
boolean |
FloatIterationMonitor.converged(FloatMatrix1D r,
FloatMatrix1D x)
Checks for convergence
|
void |
FloatIterationReporter.monitor(float r,
FloatMatrix1D x,
int i)
Registers current information
|
void |
NoFloatIterationReporter.monitor(float r,
FloatMatrix1D x,
int i) |
FloatMatrix1D |
FloatIR.solve(FloatMatrix2D A,
FloatMatrix1D b,
FloatMatrix1D x) |
FloatMatrix1D |
FloatQMR.solve(FloatMatrix2D A,
FloatMatrix1D b,
FloatMatrix1D x) |
FloatMatrix1D |
FloatIterativeSolver.solve(FloatMatrix2D A,
FloatMatrix1D b,
FloatMatrix1D x)
Solves the given problem, writing result into the vector.
|
FloatMatrix1D |
FloatMRNSD.solve(FloatMatrix2D A,
FloatMatrix1D b,
FloatMatrix1D x) |
FloatMatrix1D |
FloatCGS.solve(FloatMatrix2D A,
FloatMatrix1D b,
FloatMatrix1D x) |
FloatMatrix1D |
FloatHyBR.solve(FloatMatrix2D A,
FloatMatrix1D b,
FloatMatrix1D x) |
FloatMatrix1D |
FloatCGLS.solve(FloatMatrix2D A,
FloatMatrix1D b,
FloatMatrix1D x) |
FloatMatrix1D |
FloatBiCGstab.solve(FloatMatrix2D A,
FloatMatrix1D b,
FloatMatrix1D x) |
FloatMatrix1D |
FloatCG.solve(FloatMatrix2D A,
FloatMatrix1D b,
FloatMatrix1D x) |
FloatMatrix1D |
FloatBiCG.solve(FloatMatrix2D A,
FloatMatrix1D b,
FloatMatrix1D x) |
FloatMatrix1D |
FloatChebyshev.solve(FloatMatrix2D A,
FloatMatrix1D b,
FloatMatrix1D x) |
FloatMatrix1D |
FloatGMRES.solve(FloatMatrix2D A,
FloatMatrix1D b,
FloatMatrix1D x) |
| Constructor and Description |
|---|
FloatBiCG(FloatMatrix1D template)
Constructor for BiCG.
|
FloatBiCGstab(FloatMatrix1D template)
Constructor for BiCGstab.
|
FloatCG(FloatMatrix1D template)
Constructor for CG.
|
FloatCGS(FloatMatrix1D template)
Constructor for CGS.
|
FloatChebyshev(FloatMatrix1D template,
float eigmin,
float eigmax)
Constructor for Chebyshev.
|
FloatGMRES(FloatMatrix1D template)
Constructor for GMRES.
|
FloatGMRES(FloatMatrix1D template,
int restart)
Constructor for GMRES.
|
FloatIR(FloatMatrix1D template)
Constructor for IR.
|
FloatQMR(FloatMatrix1D template)
Constructor for QMR.
|
FloatQMR(FloatMatrix1D template,
FloatPreconditioner M1,
FloatPreconditioner M2)
Constructor for QMR.
|
| Modifier and Type | Class and Description |
|---|---|
class |
DenseFloatMatrix1D
Dense 1-d matrix (aka vector) holding float elements.
|
class |
SparseFloatMatrix1D
Sparse hashed 1-d matrix (aka vector) holding float elements.
|
class |
WrapperFloatMatrix1D
1-d matrix holding float elements; either a view wrapping another
matrix or a matrix whose views are wrappers.
|
| Modifier and Type | Method and Description |
|---|---|
FloatMatrix1D |
SparseFloatMatrix1D.assign(float value)
Sets all cells to the state specified by value.
|
FloatMatrix1D |
DenseFloatMatrix1D.assign(float value) |
FloatMatrix1D |
DenseFloatMatrix1D.assign(float[] values) |
FloatMatrix1D |
DenseFloatMatrix1D.assign(FloatFunction function) |
FloatMatrix1D |
DenseFloatMatrix1D.assign(FloatMatrix1D source) |
FloatMatrix1D |
DenseFloatMatrix1D.assign(FloatMatrix1D y,
FloatFloatFunction function) |
FloatMatrix1D |
DenseFloatMatrix1D.assign(FloatProcedure cond,
float value) |
FloatMatrix1D |
DenseFloatMatrix1D.assign(FloatProcedure cond,
FloatFunction function) |
FloatMatrix1D |
WrapperFloatMatrix1D.like(int size) |
FloatMatrix1D |
SparseFloatMatrix1D.like(int size)
Construct and returns a new empty matrix of the same dynamic type
as the receiver, having the specified size.
|
FloatMatrix1D |
DenseFloatMatrix1D.like(int size) |
FloatMatrix1D |
SparseCCFloatMatrix2D.like1D(int size) |
FloatMatrix1D |
SparseRCFloatMatrix2D.like1D(int size) |
FloatMatrix1D |
DenseLargeFloatMatrix2D.like1D(int size) |
FloatMatrix1D |
DenseFloatMatrix2D.like1D(int size) |
FloatMatrix1D |
SparseFloatMatrix2D.like1D(int size) |
FloatMatrix1D |
DiagonalFloatMatrix2D.like1D(int size) |
FloatMatrix1D |
DenseColumnFloatMatrix2D.like1D(int size) |
FloatMatrix1D |
WrapperFloatMatrix2D.like1D(int size) |
FloatMatrix1D |
SparseFloatMatrix3D.vectorize() |
FloatMatrix1D |
WrapperFloatMatrix3D.vectorize() |
FloatMatrix1D |
DenseFloatMatrix2D.vectorize() |
FloatMatrix1D |
SparseFloatMatrix2D.vectorize() |
FloatMatrix1D |
DenseFloatMatrix3D.vectorize() |
FloatMatrix1D |
DenseColumnFloatMatrix2D.vectorize() |
FloatMatrix1D |
WrapperFloatMatrix2D.vectorize() |
FloatMatrix1D |
WrapperFloatMatrix2D.viewColumn(int column) |
FloatMatrix1D |
WrapperFloatMatrix1D.viewFlip() |
FloatMatrix1D |
WrapperFloatMatrix1D.viewPart(int index,
int width) |
FloatMatrix1D |
WrapperFloatMatrix2D.viewRow(int row) |
FloatMatrix1D |
WrapperFloatMatrix1D.viewSelection(int[] indexes) |
FloatMatrix1D |
WrapperFloatMatrix1D.viewStrides(int _stride) |
FloatMatrix1D |
SparseCCFloatMatrix2D.zMult(FloatMatrix1D y,
FloatMatrix1D z,
float alpha,
float beta,
boolean transposeA) |
FloatMatrix1D |
SparseRCFloatMatrix2D.zMult(FloatMatrix1D y,
FloatMatrix1D z,
float alpha,
float beta,
boolean transposeA) |
FloatMatrix1D |
DenseFloatMatrix2D.zMult(FloatMatrix1D y,
FloatMatrix1D z,
float alpha,
float beta,
boolean transposeA) |
FloatMatrix1D |
SparseFloatMatrix2D.zMult(FloatMatrix1D y,
FloatMatrix1D z,
float alpha,
float beta,
boolean transposeA) |
FloatMatrix1D |
DiagonalFloatMatrix2D.zMult(FloatMatrix1D y,
FloatMatrix1D z,
float alpha,
float beta,
boolean transposeA) |
FloatMatrix1D |
DenseColumnFloatMatrix2D.zMult(FloatMatrix1D y,
FloatMatrix1D z,
float alpha,
float beta,
boolean transposeA) |
| Modifier and Type | Method and Description |
|---|---|
float |
DenseFloatMatrix1D.aggregate(FloatMatrix1D other,
FloatFloatFunction aggr,
FloatFloatFunction f) |
FloatMatrix1D |
DenseFloatMatrix1D.assign(FloatMatrix1D source) |
FloatMatrix1D |
DenseFloatMatrix1D.assign(FloatMatrix1D y,
FloatFloatFunction function) |
void |
DenseFloatMatrix1D.swap(FloatMatrix1D other) |
float |
DenseFloatMatrix1D.zDotProduct(FloatMatrix1D y,
int from,
int length) |
FloatMatrix1D |
SparseCCFloatMatrix2D.zMult(FloatMatrix1D y,
FloatMatrix1D z,
float alpha,
float beta,
boolean transposeA) |
FloatMatrix1D |
SparseRCFloatMatrix2D.zMult(FloatMatrix1D y,
FloatMatrix1D z,
float alpha,
float beta,
boolean transposeA) |
FloatMatrix1D |
DenseFloatMatrix2D.zMult(FloatMatrix1D y,
FloatMatrix1D z,
float alpha,
float beta,
boolean transposeA) |
FloatMatrix1D |
SparseFloatMatrix2D.zMult(FloatMatrix1D y,
FloatMatrix1D z,
float alpha,
float beta,
boolean transposeA) |
FloatMatrix1D |
DiagonalFloatMatrix2D.zMult(FloatMatrix1D y,
FloatMatrix1D z,
float alpha,
float beta,
boolean transposeA) |
FloatMatrix1D |
DenseColumnFloatMatrix2D.zMult(FloatMatrix1D y,
FloatMatrix1D z,
float alpha,
float beta,
boolean transposeA) |
| Constructor and Description |
|---|
WrapperFloatMatrix1D(FloatMatrix1D newContent) |
Jump to the Parallel Colt Homepage