|
Parallel Colt 0.9.4 | |||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||
| Packages that use FloatMatrix1D | |
|---|---|
| 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. |
| Uses of FloatMatrix1D in cern.colt.matrix.tfcomplex |
|---|
| Methods in cern.colt.matrix.tfcomplex that return FloatMatrix1D | |
|---|---|
abstract FloatMatrix1D |
FComplexMatrix1D.getImaginaryPart()
Returns the imaginary part of this matrix |
abstract FloatMatrix1D |
FComplexMatrix1D.getRealPart()
Returns the real part of this matrix |
| Methods in cern.colt.matrix.tfcomplex with parameters of type FloatMatrix1D | |
|---|---|
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. |
| Uses of FloatMatrix1D in cern.colt.matrix.tfcomplex.impl |
|---|
| Methods in cern.colt.matrix.tfcomplex.impl that return FloatMatrix1D | |
|---|---|
FloatMatrix1D |
WrapperFComplexMatrix1D.getImaginaryPart()
|
FloatMatrix1D |
SparseFComplexMatrix1D.getImaginaryPart()
|
FloatMatrix1D |
DenseFComplexMatrix1D.getImaginaryPart()
|
FloatMatrix1D |
WrapperFComplexMatrix1D.getRealPart()
|
FloatMatrix1D |
SparseFComplexMatrix1D.getRealPart()
|
FloatMatrix1D |
DenseFComplexMatrix1D.getRealPart()
|
| Methods in cern.colt.matrix.tfcomplex.impl with parameters of type FloatMatrix1D | |
|---|---|
FComplexMatrix1D |
DenseFComplexMatrix1D.assignImaginary(FloatMatrix1D other)
|
FComplexMatrix1D |
DenseFComplexMatrix1D.assignReal(FloatMatrix1D other)
|
| Constructors in cern.colt.matrix.tfcomplex.impl with parameters of type FloatMatrix1D | |
|---|---|
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. |
|
| Uses of FloatMatrix1D in cern.colt.matrix.tfloat |
|---|
| Methods in cern.colt.matrix.tfloat that return FloatMatrix1D | |
|---|---|
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 |
FloatMatrix3D.vectorize()
Returns a vector obtained by stacking the columns of each slice of the matrix on top of one another. |
abstract FloatMatrix1D |
FloatMatrix2D.vectorize()
Returns a vector obtained by stacking the columns 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. |
| Methods in cern.colt.matrix.tfloat with parameters of type FloatMatrix1D | |
|---|---|
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. |
| Uses of FloatMatrix1D in cern.colt.matrix.tfloat.algo |
|---|
| Methods in cern.colt.matrix.tfloat.algo that return FloatMatrix1D | |
|---|---|
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). |
| Methods in cern.colt.matrix.tfloat.algo with parameters of type FloatMatrix1D | |
|---|---|
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 |
SmpFloatBlas.dasum(FloatMatrix1D x)
|
float |
FloatBlas.dasum(FloatMatrix1D x)
Returns the sum of absolute values; |x[0]| + |x[1]| + ... |
void |
SmpFloatBlas.daxpy(float alpha,
FloatMatrix1D x,
FloatMatrix1D y)
|
void |
FloatBlas.daxpy(float alpha,
FloatMatrix1D x,
FloatMatrix1D y)
Combined vector scaling; y = y + alpha*x. |
void |
SmpFloatBlas.dcopy(FloatMatrix1D x,
FloatMatrix1D y)
|
void |
FloatBlas.dcopy(FloatMatrix1D x,
FloatMatrix1D y)
Vector assignment (copying); y = x. |
float |
SmpFloatBlas.ddot(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]). |
void |
SmpFloatBlas.dgemv(boolean transposeA,
float alpha,
FloatMatrix2D A,
FloatMatrix1D x,
float beta,
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.dger(float alpha,
FloatMatrix1D x,
FloatMatrix1D y,
FloatMatrix2D A)
|
void |
FloatBlas.dger(float alpha,
FloatMatrix1D x,
FloatMatrix1D y,
FloatMatrix2D A)
Performs a rank 1 update; A = A + alpha*x*y'. |
float |
SmpFloatBlas.dnrm2(FloatMatrix1D x)
|
float |
FloatBlas.dnrm2(FloatMatrix1D x)
Return the 2-norm; sqrt(x[0]^2 + x[1]^2 + ...). |
void |
SmpFloatBlas.drot(FloatMatrix1D x,
FloatMatrix1D y,
float c,
float s)
|
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.dscal(float alpha,
FloatMatrix1D x)
|
void |
FloatBlas.dscal(float alpha,
FloatMatrix1D x)
Vector scaling; x = alpha*x. |
void |
SmpFloatBlas.dswap(FloatMatrix1D x,
FloatMatrix1D y)
|
void |
FloatBlas.dswap(FloatMatrix1D x,
FloatMatrix1D y)
Swaps the elements of two vectors; y <==> x. |
void |
SmpFloatBlas.dsymv(boolean isUpperTriangular,
float alpha,
FloatMatrix2D A,
FloatMatrix1D x,
float beta,
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.dtrmv(boolean isUpperTriangular,
boolean transposeA,
boolean isUnitTriangular,
FloatMatrix2D A,
FloatMatrix1D x)
|
void |
FloatBlas.dtrmv(boolean isUpperTriangular,
boolean transposeA,
boolean isUnitTriangular,
FloatMatrix2D A,
FloatMatrix1D x)
Triangular matrix-vector multiplication; x = A*x or x = A'*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 |
SmpFloatBlas.idamax(FloatMatrix1D x)
|
int |
FloatBlas.idamax(FloatMatrix1D x)
Returns the index of largest absolute value; i such that |x[i]| == max(|x[0]|,|x[1]|,...).. |
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]. |
| Uses of FloatMatrix1D in cern.colt.matrix.tfloat.algo.decomposition |
|---|
| Methods in cern.colt.matrix.tfloat.algo.decomposition that return FloatMatrix1D | |
|---|---|
FloatMatrix1D |
DenseFloatEigenvalueDecomposition.getImagEigenvalues()
Returns the imaginary parts of the eigenvalues. |
FloatMatrix1D |
DenseFloatEigenvalueDecomposition.getRealEigenvalues()
Returns the real parts of the eigenvalues. |
FloatMatrix1D |
DenseFloatQRDecomposition.solve(FloatMatrix1D b)
Least squares solution of A*x = b; returns x. |
FloatMatrix1D |
DenseFloatLUDecomposition.solve(FloatMatrix1D b)
Solves A*x = b. |
FloatMatrix1D |
DenseFloatCholeskyDecomposition.solve(FloatMatrix1D b)
|
| Methods in cern.colt.matrix.tfloat.algo.decomposition with parameters of type FloatMatrix1D | |
|---|---|
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). |
void |
SparseFloatLUDecomposition.solve(FloatMatrix1D b)
Solves A*x = b(in-place). |
void |
SparseFloatCholeskyDecomposition.solve(FloatMatrix1D b)
Solves A*x = b(in-place). |
FloatMatrix1D |
DenseFloatQRDecomposition.solve(FloatMatrix1D b)
Least squares solution of A*x = b; returns x. |
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 |
DenseFloatCholeskyDecomposition.solve(FloatMatrix1D b)
|
| Uses of FloatMatrix1D in cern.colt.matrix.tfloat.algo.solver |
|---|
| Methods in cern.colt.matrix.tfloat.algo.solver with parameters of type FloatMatrix1D | |
|---|---|
void |
FloatGivensRotation.apply(FloatMatrix1D x,
int i1,
int i2)
Applies the Givens rotation to two elements of a vector |
boolean |
HyBRFloatIterationMonitor.converged(float r,
FloatMatrix1D x)
|
boolean |
FloatIterationMonitor.converged(float r,
FloatMatrix1D x)
Checks for convergence |
boolean |
AbstractFloatIterationMonitor.converged(float r,
FloatMatrix1D x)
|
boolean |
FloatIterationMonitor.converged(FloatMatrix1D r)
Checks for convergence |
boolean |
AbstractFloatIterationMonitor.converged(FloatMatrix1D r)
|
boolean |
FloatIterationMonitor.converged(FloatMatrix1D r,
FloatMatrix1D x)
Checks for convergence |
boolean |
AbstractFloatIterationMonitor.converged(FloatMatrix1D r,
FloatMatrix1D x)
|
void |
NoFloatIterationReporter.monitor(float r,
FloatMatrix1D x,
int i)
|
void |
FloatIterationReporter.monitor(float r,
FloatMatrix1D x,
int i)
Registers current information |
FloatMatrix1D |
FloatQMR.solve(FloatMatrix2D A,
FloatMatrix1D b,
FloatMatrix1D x)
|
FloatMatrix1D |
FloatMRNSD.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 |
FloatIR.solve(FloatMatrix2D A,
FloatMatrix1D b,
FloatMatrix1D x)
|
FloatMatrix1D |
FloatHyBR.solve(FloatMatrix2D A,
FloatMatrix1D b,
FloatMatrix1D x)
|
FloatMatrix1D |
FloatGMRES.solve(FloatMatrix2D A,
FloatMatrix1D b,
FloatMatrix1D x)
|
FloatMatrix1D |
FloatChebyshev.solve(FloatMatrix2D A,
FloatMatrix1D b,
FloatMatrix1D x)
|
FloatMatrix1D |
FloatCGS.solve(FloatMatrix2D A,
FloatMatrix1D b,
FloatMatrix1D x)
|
FloatMatrix1D |
FloatCGLS.solve(FloatMatrix2D A,
FloatMatrix1D b,
FloatMatrix1D x)
|
FloatMatrix1D |
FloatCG.solve(FloatMatrix2D A,
FloatMatrix1D b,
FloatMatrix1D x)
|
FloatMatrix1D |
FloatBiCGstab.solve(FloatMatrix2D A,
FloatMatrix1D b,
FloatMatrix1D x)
|
FloatMatrix1D |
FloatBiCG.solve(FloatMatrix2D A,
FloatMatrix1D b,
FloatMatrix1D x)
|
| Constructors in cern.colt.matrix.tfloat.algo.solver with parameters of type FloatMatrix1D | |
|---|---|
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. |
|
| Uses of FloatMatrix1D in cern.colt.matrix.tfloat.algo.solver.preconditioner |
|---|
| Uses of FloatMatrix1D in cern.colt.matrix.tfloat.impl |
|---|
| Subclasses of FloatMatrix1D in cern.colt.matrix.tfloat.impl | |
|---|---|
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. |
| Methods in cern.colt.matrix.tfloat.impl that return FloatMatrix1D | |
|---|---|
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 |
WrapperFloatMatrix2D.like1D(int size)
|
FloatMatrix1D |
SparseRCFloatMatrix2D.like1D(int size)
|
FloatMatrix1D |
SparseFloatMatrix2D.like1D(int size)
|
FloatMatrix1D |
SparseCCFloatMatrix2D.like1D(int size)
|
FloatMatrix1D |
DiagonalFloatMatrix2D.like1D(int size)
|
FloatMatrix1D |
DenseLargeFloatMatrix2D.like1D(int size)
|
FloatMatrix1D |
DenseFloatMatrix2D.like1D(int size)
|
FloatMatrix1D |
DenseColumnFloatMatrix2D.like1D(int size)
|
FloatMatrix1D |
WrapperFloatMatrix3D.vectorize()
|
FloatMatrix1D |
WrapperFloatMatrix2D.vectorize()
|
FloatMatrix1D |
SparseFloatMatrix3D.vectorize()
|
FloatMatrix1D |
SparseFloatMatrix2D.vectorize()
|
FloatMatrix1D |
DenseFloatMatrix3D.vectorize()
|
FloatMatrix1D |
DenseFloatMatrix2D.vectorize()
|
FloatMatrix1D |
DenseColumnFloatMatrix2D.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 |
SparseRCFloatMatrix2D.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 |
SparseCCFloatMatrix2D.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 |
DenseFloatMatrix2D.zMult(FloatMatrix1D y,
FloatMatrix1D z,
float alpha,
float beta,
boolean transposeA)
|
FloatMatrix1D |
DenseColumnFloatMatrix2D.zMult(FloatMatrix1D y,
FloatMatrix1D z,
float alpha,
float beta,
boolean transposeA)
|
| Methods in cern.colt.matrix.tfloat.impl with parameters of type FloatMatrix1D | |
|---|---|
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 |
SparseRCFloatMatrix2D.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 |
SparseCCFloatMatrix2D.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 |
DenseFloatMatrix2D.zMult(FloatMatrix1D y,
FloatMatrix1D z,
float alpha,
float beta,
boolean transposeA)
|
FloatMatrix1D |
DenseColumnFloatMatrix2D.zMult(FloatMatrix1D y,
FloatMatrix1D z,
float alpha,
float beta,
boolean transposeA)
|
| Constructors in cern.colt.matrix.tfloat.impl with parameters of type FloatMatrix1D | |
|---|---|
WrapperFloatMatrix1D(FloatMatrix1D newContent)
|
|
|
Parallel Colt 0.9.4 | |||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||