| Modifier and Type | Method and Description |
|---|---|
Vector |
Matrix.getColumn(int j)
Get the specified column in the matrix as a vector.
|
Vector |
ImmutableMatrix.getColumn(int j) |
Vector |
Matrix.getRow(int i)
Get the specified row in the matrix as a vector.
|
Vector |
ImmutableMatrix.getRow(int i) |
Vector |
Matrix.multiply(Vector v)
Right multiply this matrix, A, by a vector.
|
Vector |
ImmutableMatrix.multiply(Vector v) |
| Modifier and Type | Method and Description |
|---|---|
static boolean |
MatrixPropertyUtils.areAllSparse(Vector... vectors)
Checks if all vectors are SparseVector.
|
static boolean |
MatrixPropertyUtils.areEqual(Vector v1,
Vector v2,
double epsilon)
Checks if two vectors are equal, i.e., v1 - v2 is a zero vector, up to a precision.
|
static boolean |
MatrixPropertyUtils.areOrthogonal(Vector[] v,
double epsilon)
Checks if a set of vectors are orthogonal, i.e., for any v1, v2 in v,
v1 ∙ v2 == 0.
|
static boolean |
MatrixPropertyUtils.areOrthogonal(Vector v1,
Vector v2,
double epsilon)
Checks if two vectors are orthogonal, i.e., v1 ∙ v2 == 0.
|
static boolean |
MatrixPropertyUtils.areOrthogonormal(Vector[] v,
double epsilon)
Checks if a set of vectors are orthogonormal.
|
static boolean |
MatrixPropertyUtils.areOrthogonormal(Vector v1,
Vector v2,
double epsilon)
Checks if two vectors are orthogonormal.
|
static boolean |
MatrixPropertyUtils.isNaN(Vector v)
Checks if a vector contains any
NaN entry. |
static boolean |
MatrixPropertyUtils.isZero(Vector v,
double epsilon)
Checks if a vector is a zero vector, i.e., all its entries are 0, up to a precision.
|
Vector |
Matrix.multiply(Vector v)
Right multiply this matrix, A, by a vector.
|
Vector |
ImmutableMatrix.multiply(Vector v) |
static void |
MatrixPropertyUtils.throwIfInvalidIndex(Vector v,
int index)
Checks if an index is a valid index.
|
static void |
MatrixPropertyUtils.throwIfNotEqualSize(Vector v1,
Vector v2)
Checks if the input vectors have the same size.
|
| Modifier and Type | Method and Description |
|---|---|
Vector |
EigenProperty.eigenVector()
Get an eigenvector.
|
Vector |
InverseIteration.getEigenVector()
Get an eigenvector.
|
Vector |
InverseIteration.getEigenVector(Vector v0,
int maxIterations)
Get an eigenvector from an initial guess.
|
| Modifier and Type | Method and Description |
|---|---|
List<Vector> |
EigenProperty.eigenbasis()
Get the eigenvectors.
|
| Modifier and Type | Method and Description |
|---|---|
Vector |
InverseIteration.getEigenVector(Vector v0,
int maxIterations)
Get an eigenvector from an initial guess.
|
boolean |
InverseIteration.StoppingCriterion.toStop(Vector v)
Check whether we stop with the current eigenvector.
|
| Constructor and Description |
|---|
DQDS(int n,
Vector q,
Vector e)
Computes all the eigenvalues of the symmetric positive definite tridiagonal matrix associated
with the
q and e values to high relative accuracy. |
| Modifier and Type | Method and Description |
|---|---|
Vector |
LDDecomposition.D()
The diagonal entries of the diagonal matrix D.
|
Vector |
LDFactorizationFromRoot.D() |
Vector |
LDDecomposition.L()
The sub-diagonal entries of the unit lower triangular matrix L.
|
Vector |
LDFactorizationFromRoot.L() |
Vector |
LDDecomposition.LD() |
Vector |
LDDecomposition.LLD() |
| Modifier and Type | Method and Description |
|---|---|
List<Vector> |
SymmetricEigenFor2x2Matrix.getEigenvectors()
Gets the eigenvectors.
|
List<Vector> |
MR3.getEigenvectors()
Gets all the eigenvectors which corresponds to the list of eigenvalues.
|
List<Vector> |
SymmetricEigenByMR3.getEigenvectors() |
| Modifier and Type | Method and Description |
|---|---|
int[] |
BlockSplitPointSearch.compute(Vector D,
Vector E,
Vector E2)
Searches splitting points in the symmetric tridiagonal matrix.
|
static RealInterval[] |
EigenBoundUtils.computeGershgorinIntervals(Vector D,
Vector E)
Computes the Gershgorin bounds for all eigenvalues in a symmetric tridiagonal matrix
T.
|
| Constructor and Description |
|---|
EigenCount(Vector D,
Vector E2)
Creates an instance for a symmetric tridiagonal matrix T.
|
EigenCountInRange(Vector D,
Vector E2)
Creates an instance for counting the number of eigenvalues of the symmetric tridiagonal
matrix T that are in a given interval.
|
LDDecomposition(Vector D,
Vector L,
double sigma) |
LDFactorizationFromRoot(Vector D,
Vector E,
double sigma)
Creates a decomposition for a symmetric tridiagonal matrix T.
|
MR3(Vector D,
Vector E)
Creates an instance for computing eigenvalues and eigenvectors of a given symmetric
tridiagonal matrix T.
|
MR3(Vector D,
Vector E,
boolean wantEigenvector)
Creates an instance for computing eigenvalues (and eigenvectors) of a given symmetric
tridiagonal matrix T.
|
MR3(Vector D,
Vector E,
boolean wantEigenvector,
double minRelativeGap)
Creates an instance for computing eigenvalues (and eigenvectors) of a given symmetric
tridiagonal matrix T.
|
| Modifier and Type | Method and Description |
|---|---|
Vector |
Getvec.getEigenvector() |
| Modifier and Type | Method and Description |
|---|---|
List<Vector> |
SymmetricQRAlgorithm.getEigenvectors()
Gets the eigenvectors of A, which are the columns of Q.
|
List<Vector> |
QRAlgorithm.getEigenVectors() |
| Modifier and Type | Method and Description |
|---|---|
Vector |
LSProblem.getInitialGuess()
Gets the initial guess of the solution for the problem.
|
Vector |
LinearSystemSolver.Solution.getParticularSolution(Vector b)
Get a particular solution for the linear system.
|
Vector |
ForwardSubstitution.solve(LowerTriangularMatrix L,
Vector b)
Solve Lx = b.
|
Vector |
ForwardSubstitution.solve(LowerTriangularMatrix L,
Vector b,
double epsilon) |
Vector |
OLSSolverByQR.solve(LSProblem problem)
In the ordinary least square sense, solve
\[
Ax = y
\]
|
Vector |
OLSSolverBySVD.solve(LSProblem problem)
In the ordinary least square sense, solve
\[
Ax = y
\]
|
Vector |
LUSolver.solve(LSProblem problem)
Solve Ax = b.
|
Vector |
ThomasAlgorithm.solve(TridiagonalMatrix A,
Vector d)
Solves a tridiagonal matrix equation.
|
Vector |
BackwardSubstitution.solve(UpperTriangularMatrix U,
Vector b)
Solve Ux = b.
|
Vector |
BackwardSubstitution.solve(UpperTriangularMatrix U,
Vector b,
double epsilon) |
| Modifier and Type | Method and Description |
|---|---|
List<Vector> |
Kernel.basis()
Get the kernel basis.
|
Map<Integer,Vector> |
Kernel.basisAndFreeVars()
Get the kernel basis and the associated free variables for each basis/column.
|
List<Vector> |
LinearSystemSolver.Solution.getHomogeneousSoln()
Get the basis of the homogeneous solution for the linear system,
Ax = b.
|
| Modifier and Type | Method and Description |
|---|---|
Vector |
LinearSystemSolver.Solution.getParticularSolution(Vector b)
Get a particular solution for the linear system.
|
Vector |
ForwardSubstitution.solve(LowerTriangularMatrix L,
Vector b)
Solve Lx = b.
|
Vector |
ForwardSubstitution.solve(LowerTriangularMatrix L,
Vector b,
double epsilon) |
Vector |
ThomasAlgorithm.solve(TridiagonalMatrix A,
Vector d)
Solves a tridiagonal matrix equation.
|
Vector |
BackwardSubstitution.solve(UpperTriangularMatrix U,
Vector b)
Solve Ux = b.
|
Vector |
BackwardSubstitution.solve(UpperTriangularMatrix U,
Vector b,
double epsilon) |
LSProblem |
LSProblem.withInitialGuess(Vector initialGuess)
Overrides the initial guess of the solution.
|
| Constructor and Description |
|---|
LSProblem(Matrix A,
Vector b)
Constructs a system of linear equations Ax = b.
|
| Modifier and Type | Method and Description |
|---|---|
Vector |
PermutationMatrix.getColumn(int j) |
Vector |
DefaultMatrixStorage.getColumn(int j)
Get a column.
|
Vector |
GivensMatrix.getColumn(int j) |
Vector |
PermutationMatrix.getRow(int i) |
Vector |
DefaultMatrixStorage.getRow(int i)
Get a row.
|
Vector |
GivensMatrix.getRow(int i) |
Vector |
PermutationMatrix.multiply(Vector v)
Left multiplication by P.
|
Vector |
GivensMatrix.multiply(Vector v) |
Vector |
GivensMatrix.multiplyInPlace(Vector v)
Right multiplies this matrix, A, by a vector.
|
Vector |
GivensMatrix.rotate(Vector x)
Deprecated.
Not supported yet.
|
| Modifier and Type | Method and Description |
|---|---|
Vector |
PermutationMatrix.multiply(Vector v)
Left multiplication by P.
|
Vector |
GivensMatrix.multiply(Vector v) |
Vector |
GivensMatrix.multiplyInPlace(Vector v)
Right multiplies this matrix, A, by a vector.
|
Vector |
GivensMatrix.rotate(Vector x)
Deprecated.
Not supported yet.
|
void |
DefaultMatrixStorage.setColumn(int j,
Vector v)
Set the values for a column in the matrix, i.e., [*, j].
|
void |
DefaultMatrixStorage.setRow(int i,
Vector v)
Set the values for a row in the matrix, i.e., [i, *].
|
| Modifier and Type | Method and Description |
|---|---|
Vector |
DenseMatrix.getColumn(int j) |
Vector |
DenseMatrix.getColumn(int j,
int beginRow,
int endRow)
Gets a sub-column of the j-th column, from
beginRow row to
endRow row, inclusively. |
Vector |
DenseMatrix.getRow(int i) |
Vector |
DenseMatrix.getRow(int i,
int beginCol,
int endCol)
Gets a sub-row of the i-th row, from
beginCol column to
endCol column, inclusively. |
Vector |
DenseMatrix.multiply(Vector v) |
| Modifier and Type | Method and Description |
|---|---|
Vector |
DenseMatrix.multiply(Vector v) |
void |
DenseMatrix.setColumn(int j,
Vector v)
Changes the matrix column values to a vector value.
|
void |
DenseMatrix.setRow(int i,
Vector v)
Changes the matrix row values to a vector value.
|
| Constructor and Description |
|---|
DenseMatrix(Vector v)
Constructs a column matrix from a vector.
|
| Modifier and Type | Method and Description |
|---|---|
Vector |
DiagonalMatrix.multiply(Vector v) |
| Modifier and Type | Method and Description |
|---|---|
Vector |
DiagonalMatrix.multiply(Vector v) |
| Modifier and Type | Method and Description |
|---|---|
Vector |
SymmetricMatrix.getColumn(int j) |
Vector |
LowerTriangularMatrix.getColumn(int j) |
Vector |
UpperTriangularMatrix.getColumn(int j) |
Vector |
SymmetricMatrix.getRow(int i) |
Vector |
LowerTriangularMatrix.getRow(int i) |
Vector |
UpperTriangularMatrix.getRow(int i) |
Vector |
SymmetricMatrix.multiply(Vector v) |
Vector |
LowerTriangularMatrix.multiply(Vector v) |
Vector |
UpperTriangularMatrix.multiply(Vector v) |
| Modifier and Type | Method and Description |
|---|---|
Vector |
SymmetricMatrix.multiply(Vector v) |
Vector |
LowerTriangularMatrix.multiply(Vector v) |
Vector |
UpperTriangularMatrix.multiply(Vector v) |
| Modifier and Type | Method and Description |
|---|---|
Vector |
SimpleMatrixMathOperation.multiply(MatrixAccess A,
Vector v) |
Vector |
AutoParallelMatrixMathOperation.multiply(MatrixAccess A,
Vector v) |
Vector |
MatrixMathOperation.multiply(MatrixAccess A,
Vector v)
A * v
|
| Modifier and Type | Method and Description |
|---|---|
Vector |
SimpleMatrixMathOperation.multiply(MatrixAccess A,
Vector v) |
Vector |
AutoParallelMatrixMathOperation.multiply(MatrixAccess A,
Vector v) |
Vector |
MatrixMathOperation.multiply(MatrixAccess A,
Vector v)
A * v
|
| Modifier and Type | Class and Description |
|---|---|
class |
SparseVector
A sparse vector stores only non-zero values.
|
| Modifier and Type | Method and Description |
|---|---|
Vector |
SparseVector.add(double c) |
Vector |
SparseVector.add(Vector that) |
Vector |
SparseVector.divide(Vector that) |
Vector |
SparseVector.leftMultiply(Matrix A)
Left multiplies a matrix.
|
Vector |
SparseVector.minus(double c) |
Vector |
SparseVector.minus(Vector that) |
Vector |
LILSparseMatrix.multiply(Vector v) |
Vector |
CSRSparseMatrix.multiply(Vector v) |
Vector |
DOKSparseMatrix.multiply(Vector v) |
Vector |
SparseVector.pow(double c) |
| Modifier and Type | Method and Description |
|---|---|
Vector |
SparseVector.add(Vector that) |
double |
SparseVector.angle(Vector that) |
Vector |
SparseVector.divide(Vector that) |
double |
SparseVector.innerProduct(Vector that) |
Vector |
SparseVector.minus(Vector that) |
SparseVector |
SparseVector.multiply(Vector that) |
Vector |
LILSparseMatrix.multiply(Vector v) |
Vector |
CSRSparseMatrix.multiply(Vector v) |
Vector |
DOKSparseMatrix.multiply(Vector v) |
| Constructor and Description |
|---|
SparseVector(Vector v)
Constructs a sparse vector from a vector.
|
| Modifier and Type | Method and Description |
|---|---|
Vector |
IterativeLinearSystemSolver.Solution.search(Vector... initials) |
| Modifier and Type | Method and Description |
|---|---|
IterationMonitor<Vector> |
IterativeLinearSystemSolver.Solution.step() |
| Modifier and Type | Method and Description |
|---|---|
Vector |
IterativeLinearSystemSolver.Solution.search(Vector... initials) |
| Modifier and Type | Method and Description |
|---|---|
IterativeLinearSystemSolver.Solution |
IterativeLinearSystemSolver.solve(LSProblem problem,
IterationMonitor<Vector> monitor)
Solves iteratively
\[
Ax = b
\]
until the solution converges, i.e., the norm of residual
(b - Ax) is less than or equal to the threshold.
|
| Modifier and Type | Method and Description |
|---|---|
Vector |
JacobiPreconditioner.solve(Vector x)
Return \(P^{-1}x\), where P is the diagonal matrix
of A.
|
Vector |
IdentityPreconditioner.solve(Vector x)
Return the input vector x.
|
Vector |
Preconditioner.solve(Vector x)
Solve Mv = x, where M is the preconditioner matrix.
|
Vector |
SSORPreconditioner.solve(Vector x)
Solve Mz = x using this SSOR preconditioner.
|
Vector |
JacobiPreconditioner.transposeSolve(Vector x)
\(P^{\mathsf T} = P^{-1}\) for Jacobi preconditioner.
|
Vector |
IdentityPreconditioner.transposeSolve(Vector x)
Return the input vector x.
|
Vector |
Preconditioner.transposeSolve(Vector x)
Solve \(M^{\mathsf T}v = x\), where M is the preconditioner
matrix.
|
Vector |
SSORPreconditioner.transposeSolve(Vector x)
\(M^{\mathsf T}x = M^{-1}x\) as M is symmetric.
|
| Modifier and Type | Method and Description |
|---|---|
Vector |
JacobiPreconditioner.solve(Vector x)
Return \(P^{-1}x\), where P is the diagonal matrix
of A.
|
Vector |
IdentityPreconditioner.solve(Vector x)
Return the input vector x.
|
Vector |
Preconditioner.solve(Vector x)
Solve Mv = x, where M is the preconditioner matrix.
|
Vector |
SSORPreconditioner.solve(Vector x)
Solve Mz = x using this SSOR preconditioner.
|
Vector |
JacobiPreconditioner.transposeSolve(Vector x)
\(P^{\mathsf T} = P^{-1}\) for Jacobi preconditioner.
|
Vector |
IdentityPreconditioner.transposeSolve(Vector x)
Return the input vector x.
|
Vector |
Preconditioner.transposeSolve(Vector x)
Solve \(M^{\mathsf T}v = x\), where M is the preconditioner
matrix.
|
Vector |
SSORPreconditioner.transposeSolve(Vector x)
\(M^{\mathsf T}x = M^{-1}x\) as M is symmetric.
|
| Modifier and Type | Method and Description |
|---|---|
Vector |
SORSweep.backward(Vector x)
Perform a backward sweep.
|
Vector |
SORSweep.forward(Vector x)
Perform a forward sweep.
|
| Modifier and Type | Method and Description |
|---|---|
Vector |
SORSweep.backward(Vector x)
Perform a backward sweep.
|
Vector |
SORSweep.forward(Vector x)
Perform a forward sweep.
|
| Modifier and Type | Method and Description |
|---|---|
IterativeLinearSystemSolver.Solution |
SuccessiveOverrelaxationSolver.solve(LSProblem problem,
IterationMonitor<Vector> monitor) |
IterativeLinearSystemSolver.Solution |
SymmetricSuccessiveOverrelaxationSolver.solve(LSProblem problem,
IterationMonitor<Vector> monitor) |
IterativeLinearSystemSolver.Solution |
GaussSeidelSolver.solve(LSProblem problem,
IterationMonitor<Vector> monitor) |
IterativeLinearSystemSolver.Solution |
JacobiSolver.solve(LSProblem problem,
IterationMonitor<Vector> monitor) |
| Constructor and Description |
|---|
SORSweep(Matrix A,
Vector b,
double omega)
Construct an instance to perform forward or backward sweep for a linear
system Ax = b.
|
| Modifier and Type | Class and Description |
|---|---|
class |
SVEC
SVEC converts a symmetric matrix \(K = \{K_{ij}\}\) into a vector of dimension n(n+1)/2. |
| Modifier and Type | Method and Description |
|---|---|
static Vector |
MatrixUtils.colMeanVector(MatrixTable A)
Get the column mean vector of a given matrix.
|
static Vector |
MatrixUtils.colSumVector(MatrixTable A)
Get the column sum vector of a given matrix.
|
Vector |
ColumnBindMatrix.getColumn(int j) |
Vector |
DiagonalSum.getColumn(int j) |
Vector |
SubMatrixRef.getColumn(int j) |
Vector |
ColumnBindMatrix.getRow(int i) |
Vector |
DiagonalSum.getRow(int i) |
Vector |
SubMatrixRef.getRow(int i) |
Vector |
ColumnBindMatrix.multiply(Vector v) |
Vector |
DiagonalSum.multiply(Vector v) |
Vector |
SubMatrixRef.multiply(Vector v) |
Vector |
FastKroneckerProduct.multiply(Vector v) |
static Vector |
MatrixUtils.rowMeanVector(MatrixTable A)
Get the row mean vector of a given matrix.
|
static Vector |
MatrixUtils.rowSumVector(MatrixTable A)
Get the row sum vector of a given matrix.
|
static Vector[] |
MatrixUtils.toColumns(Matrix A)
Get an array of all column vectors from a matrix.
|
static Vector[] |
MatrixUtils.toRows(Matrix A)
Get an array of all row vectors from a matrix.
|
| Modifier and Type | Method and Description |
|---|---|
static Matrix |
MatrixFactory.cbind(Vector... vectors)
Combines an array of vectors by columns.
|
Vector |
ColumnBindMatrix.multiply(Vector v) |
Vector |
DiagonalSum.multiply(Vector v) |
Vector |
SubMatrixRef.multiply(Vector v) |
Vector |
FastKroneckerProduct.multiply(Vector v) |
static Matrix |
MatrixFactory.rbind(Vector... vectors)
Combines an array of vectors by rows.
|
| Modifier and Type | Method and Description |
|---|---|
static Matrix |
MatrixFactory.cbind(List<Vector> vectors)
Combines a list of vectors by columns.
|
static Matrix |
MatrixFactory.rbind(List<Vector> vectors)
Combines a list of array of vectors by rows.
|
| Constructor and Description |
|---|
ColumnBindMatrix(Vector... vectors) |
DiagonalSum(Matrix A,
Vector d) |
MAT(Vector v)
Constructs the MAT of a vector.
|
OuterProduct(Vector a,
Vector b) |
VariancebtX(Vector b,
Matrix X)
Computes \(b'Xb\).
|
| Modifier and Type | Field and Description |
|---|---|
Vector |
HouseholderContext.generator
The vector which is used to generate the Householder vector.
|
Vector |
HouseholderContext.v
The defining vector which is perpendicular to the Householder hyperplane.
|
| Modifier and Type | Method and Description |
|---|---|
Vector |
Householder4SubVector.definingVector() |
Vector |
HouseholderReflection.definingVector()
Get the Householder defining vector which is orthogonal to the Householder hyperplane.
|
Vector |
Householder4ZeroGenerator.reflect(Vector x) |
Vector |
Householder4SubVector.reflect(Vector x) |
Vector |
HouseholderReflection.reflect(Vector x)
Apply the Householder matrix, H, to a column vector, x.
|
| Modifier and Type | Method and Description |
|---|---|
static HouseholderContext |
HouseholderContext.getContext(Vector x)
Generates the context information from a generating vector x.
|
Vector |
Householder4ZeroGenerator.reflect(Vector x) |
Vector |
Householder4SubVector.reflect(Vector x) |
Vector |
HouseholderReflection.reflect(Vector x)
Apply the Householder matrix, H, to a column vector, x.
|
void |
HouseholderReflection.reflectVectors(Vector[] vectors,
int startIndex,
int endIndex)
Apply the Householder matrix, H, to an array of vectors.
|
| Constructor and Description |
|---|
Householder4SubVector(int size,
int startIndex,
Vector v) |
Householder4SubVector(int size,
Vector v) |
Householder4SubVector(int size,
Vector v,
double beta,
double lambda) |
HouseholderContext(Vector v,
double beta,
Vector generator,
double lambda)
Constructs a Householder context information.
|
HouseholderReflection(Vector v)
Construct a Householder matrix from the vector that defines the
hyperplane orthogonal to the vector.
|
HouseholderReflection(Vector v,
double beta,
double lambda) |
| Modifier and Type | Class and Description |
|---|---|
class |
CombinedVectorByRef
For efficiency, this wrapper concatenates two or more vectors by references
(without data copying).
|
class |
ImmutableVector
This is a read-only view of a
Vector instance. |
class |
SubVectorRef
Represents a sub-vector backed by the referenced vector, without data
copying.
|
| Modifier and Type | Method and Description |
|---|---|
Vector |
SubVectorRef.add(double c) |
Vector |
ImmutableVector.add(double scalar) |
Vector |
Vector.add(double c)
Add a constant to all entries in this vector.
|
Vector |
ImmutableVector.add(Vector that) |
Vector |
Vector.add(Vector that)
\(this + that\)
|
Vector |
SubVectorRef.deepCopy() |
Vector |
Vector.deepCopy() |
Vector |
CombinedVectorByRef.deepCopy() |
Vector |
ImmutableVector.divide(Vector that) |
Vector |
Vector.divide(Vector that)
Divide
this by that, entry-by-entry. |
Vector |
SubVectorRef.minus(double c) |
Vector |
ImmutableVector.minus(double scalar) |
Vector |
Vector.minus(double c)
Subtract a constant from all entries in this vector.
|
Vector |
ImmutableVector.minus(Vector that) |
Vector |
Vector.minus(Vector that)
\(this - that\)
|
Vector |
ImmutableVector.multiply(Vector that) |
Vector |
Vector.multiply(Vector that)
Multiply
this by that, entry-by-entry. |
Vector |
SubVectorRef.opposite() |
Vector |
ImmutableVector.opposite() |
Vector |
Vector.opposite()
Get the opposite of this vector.
|
Vector |
SubVectorRef.pow(double c) |
Vector |
ImmutableVector.pow(double scalar) |
Vector |
Vector.pow(double c)
Take the exponentiation of all entries in this vector, entry-by-entry.
|
Vector |
SubVectorRef.scaled(double c) |
Vector |
ImmutableVector.scaled(double scalar) |
Vector |
Vector.scaled(double c)
Scale this vector by a constant, entry-by-entry.
|
Vector |
SubVectorRef.scaled(Real c) |
Vector |
ImmutableVector.scaled(Real scalar) |
Vector |
Vector.scaled(Real c)
Scale this vector by a constant, entry-by-entry.
|
Vector |
ImmutableVector.ZERO() |
Vector |
Vector.ZERO()
Get a 0-vector that has the same length as this vector.
|
| Modifier and Type | Method and Description |
|---|---|
Vector |
ImmutableVector.add(Vector that) |
Vector |
Vector.add(Vector that)
\(this + that\)
|
double |
ImmutableVector.angle(Vector that) |
double |
Vector.angle(Vector that)
Measure the angle, \(\theta\), between
this and that. |
Vector |
ImmutableVector.divide(Vector that) |
Vector |
Vector.divide(Vector that)
Divide
this by that, entry-by-entry. |
double |
SubVectorRef.innerProduct(Vector that) |
double |
ImmutableVector.innerProduct(Vector that) |
double |
Vector.innerProduct(Vector that)
Inner product in the Euclidean space is the dot product.
|
Vector |
ImmutableVector.minus(Vector that) |
Vector |
Vector.minus(Vector that)
\(this - that\)
|
Vector |
ImmutableVector.multiply(Vector that) |
Vector |
Vector.multiply(Vector that)
Multiply
this by that, entry-by-entry. |
| Constructor and Description |
|---|
CombinedVectorByRef(Vector v1,
Vector v2,
Vector... others) |
CombinedVectorByRef(Vector v1,
Vector v2,
Vector... others) |
ImmutableVector(Vector v)
Construct a read-only version of a vector.
|
SubVectorRef(Vector v,
int from,
int to) |
| Modifier and Type | Class and Description |
|---|---|
class |
DenseVector
This class implements the standard, dense,
double based vector
representation. |
| Modifier and Type | Method and Description |
|---|---|
static Vector |
VectorMathOperation.abs(Vector v)
Computes the absolute values of a vector, element-by-element.
|
Vector |
DenseVector.add(Vector that) |
static Vector |
VectorMathOperation.cos(Vector v)
Computes the cosine of a vector, element-by-element.
|
Vector |
DenseVector.divide(Vector that) |
static Vector |
VectorMathOperation.exp(Vector v)
Computes the exponential of a vector, element-by-element.
|
static Vector |
VectorMathOperation.log(Vector v)
Computes the log of a vector, element-by-element.
|
Vector |
DenseVector.minus(Vector that) |
Vector |
DenseVector.multiply(Vector that) |
static Vector |
VectorMathOperation.rbinom(int n,
int nTrials,
Vector p)
Generates
n random binomial numbers. |
static Vector |
VectorMathOperation.rbinom(int n,
int nTrials,
Vector p,
RandomLongGenerator uniform)
Generates
n random binomial numbers. |
static Vector |
VectorMathOperation.rnorm(int n)
Generates
n random standard Normals. |
static Vector |
VectorMathOperation.rnorm(int n,
RandomStandardNormalGenerator z)
Generates
n random standard Normals. |
static Vector |
VectorMathOperation.sin(Vector v)
Computes the sine of a vector, element-by-element.
|
static Vector |
VectorMathOperation.sqrt(Vector v)
Computes the square roots of a vector, element-by-element.
|
static Vector |
VectorMathOperation.squared(Vector v)
Computes the squares of a vector, element-by-element.
|
| Modifier and Type | Method and Description |
|---|---|
static Vector |
VectorMathOperation.abs(Vector v)
Computes the absolute values of a vector, element-by-element.
|
Vector |
DenseVector.add(Vector that) |
DenseVector |
VectorMathOperation.add(Vector v1,
double c)
Adds a constant to a vector, element-by-element.
|
DenseVector |
VectorMathOperation.add(Vector v1,
Vector v2)
Adds two vectors, element-by-element.
|
double |
DenseVector.angle(Vector that) |
double |
VectorMathOperation.angle(Vector v1,
Vector v2)
Computes the angle between two vectors.
|
static Vector |
VectorMathOperation.cos(Vector v)
Computes the cosine of a vector, element-by-element.
|
Vector |
DenseVector.divide(Vector that) |
DenseVector |
VectorMathOperation.divide(Vector v1,
Vector v2)
A vector is divided by another vector, element-by-element.
|
static Vector |
VectorMathOperation.exp(Vector v)
Computes the exponential of a vector, element-by-element.
|
double |
DenseVector.innerProduct(Vector that) |
double |
VectorMathOperation.innerProduct(Vector v1,
Vector v2)
Computes the inner or dot product of two vectors.
|
static Vector |
VectorMathOperation.log(Vector v)
Computes the log of a vector, element-by-element.
|
Vector |
DenseVector.minus(Vector that) |
DenseVector |
VectorMathOperation.minus(Vector v1,
double c)
Subtracts a constant from a vector, element-by-element.
|
DenseVector |
VectorMathOperation.minus(Vector v1,
Vector v2)
A vector subtracts another vector, element-by-element.
|
Vector |
DenseVector.multiply(Vector that) |
DenseVector |
VectorMathOperation.multiply(Vector v1,
Vector v2)
Multiplies two vectors, element-by-element.
|
double |
VectorMathOperation.norm(Vector v1)
Computes the norm of a vector.
|
double |
VectorMathOperation.norm(Vector v1,
double p)
Computes the norm of a vector.
|
DenseVector |
VectorMathOperation.opposite(Vector v1)
Multiples a vector by -1, element-by-element.
|
DenseVector |
VectorMathOperation.pow(Vector v1,
double c)
Takes a power of a vector, element-by-element.
|
static Vector |
VectorMathOperation.rbinom(int n,
int nTrials,
Vector p)
Generates
n random binomial numbers. |
static Vector |
VectorMathOperation.rbinom(int n,
int nTrials,
Vector p,
RandomLongGenerator uniform)
Generates
n random binomial numbers. |
DenseVector |
VectorMathOperation.scaled(Vector v1,
double c)
Scales a vector, element-by-element.
|
DenseVector |
VectorMathOperation.scaled(Vector v1,
Real c)
Scales a vector, element-by-element.
|
static Vector |
VectorMathOperation.sin(Vector v)
Computes the sine of a vector, element-by-element.
|
static Vector |
VectorMathOperation.sqrt(Vector v)
Computes the square roots of a vector, element-by-element.
|
static Vector |
VectorMathOperation.squared(Vector v)
Computes the squares of a vector, element-by-element.
|
static double |
VectorMathOperation.sum(Vector v)
Computes the sum of all vector elements.
|
| Constructor and Description |
|---|
DenseVector(Vector v)
Casts any vector to a
DenseVector. |
| Modifier and Type | Class and Description |
|---|---|
class |
Basis
A basis is a set of linearly independent vectors spanning a vector space.
|
| Modifier and Type | Method and Description |
|---|---|
static Vector |
VectorFactory.concat(Collection<Vector> vectors)
Concatenates an array of vectors into one vector.
|
static Vector |
VectorFactory.concat(Vector... vectors)
Concatenates an array of vectors into one vector.
|
static Vector[] |
VectorFactory.cumsum(Vector[] arr)
Gets the cumulative sums.
|
static Vector |
VectorFactory.diagonal(Matrix A)
Gets the diagonal of a matrix as a vector.
|
static Vector |
VectorFactory.foreach(Vector vector,
DoubleUnaryOperator f)
Constructs a new vector in which each entry is the result of applying a
function to the corresponding entry of a vector.
|
static Vector |
VectorFactory.foreach(Vector vector,
UnivariateRealFunction f)
Constructs a new vector in which each entry is the result of applying a
function to the corresponding entry of a vector.
|
static Vector |
VectorFactory.foreachColumn(Matrix matrix,
RealScalarFunction f)
Constructs a vector in which each entry is the result of applying a
RealScalarFunction to each column of an input matrix. |
static Vector |
VectorFactory.foreachRow(Matrix matrix,
RealScalarFunction f)
Constructs a vector in which each entry is the result of applying a
RealScalarFunction to each row of an input matrix. |
static Vector |
VectorFactory.foreachVector(Collection<Vector> vectors,
RealScalarFunction f)
Applies a
RealScalarFunction on each input vector. |
static Vector[] |
VectorFactory.foreachVector(Collection<Vector> vectors,
RealVectorFunction f)
Applies a real vector function on each input vector.
|
static Vector |
VectorFactory.foreachVector(Vector[] vectors,
RealScalarFunction f)
Applies a
RealScalarFunction on each input vector. |
static Vector[] |
VectorFactory.foreachVector(Vector[] vectors,
RealVectorFunction f)
Applies a real vector function on each input vector.
|
static Vector[] |
VectorFactory.get0s(int dimension,
int n)
Gets
n 0 vectors. |
static Vector |
VectorFactory.getCoordinate(Collection<Vector> vectors,
int i)
Gets the vector entries from a particular coordinate.
|
static Vector |
VectorFactory.getCoordinate(Vector[] vectors,
int i)
Gets the vector entries from a particular coordinate.
|
Vector |
RealVectorSpace.getLinearSpan(double... d)
Deprecated.
Not supported yet.
|
Vector |
RealVectorSpace.getSpanningCoefficients(Vector b)
Find a linear combination of the basis that best approximates a vector in the least square
sense.
|
static Vector |
VectorFactory.replaceInPlace(Vector original,
int from,
Vector replacement)
Replaces a sub-vector with a given smaller vector.
|
static Vector |
VectorFactory.subDiagonal(Matrix A)
Gets the sub-diagonal of a matrix as a vector.
|
static Vector |
VectorFactory.subVector(Vector vector,
int[] indices)
Gets a sub-vector from a vector according to a given array
of ordered indices (repetition allowed).
|
static Vector |
VectorFactory.subVector(Vector vector,
int from,
int to)
Gets a sub-vector from a vector.
|
static Vector |
VectorFactory.subVector(Vector vector,
List<Integer> indices)
Gets a sub-vector from a vector according to a given array
of ordered indices (repetition allowed).
|
static Vector |
VectorFactory.superDiagonal(Matrix A)
Gets the super-diagonal of a matrix as a vector.
|
| Modifier and Type | Method and Description |
|---|---|
List<Vector> |
RealVectorSpace.getBasis()
Get the orthogonal basis.
|
static List<Vector> |
Basis.getBasis(int dim)
Get the full set of the standard basis vectors.
|
static List<Vector> |
Basis.getBasis(int dim,
int nCols)
Get a subset of the standard basis vectors.
|
List<Vector> |
RealVectorSpace.getComplement()
Get the basis of the orthogonal complement.
|
static List<Vector> |
VectorFactory.getOffsetVectors(Vector v0,
Vector dv,
int a,
int b)
Given the reference vector
v0, the delta dv, and
the range [a, b], the offset vectors are:
\[
v0 + a \cdot dv, v0 + (a + 1) \cdot dv, \ldots , v0 + b \cdot dv |
| Modifier and Type | Method and Description |
|---|---|
static Vector |
VectorFactory.concat(Vector... vectors)
Concatenates an array of vectors into one vector.
|
static Vector[] |
VectorFactory.cumsum(Vector[] arr)
Gets the cumulative sums.
|
static Vector |
VectorFactory.foreach(Vector vector,
DoubleUnaryOperator f)
Constructs a new vector in which each entry is the result of applying a
function to the corresponding entry of a vector.
|
static Vector |
VectorFactory.foreach(Vector vector,
UnivariateRealFunction f)
Constructs a new vector in which each entry is the result of applying a
function to the corresponding entry of a vector.
|
static Vector |
VectorFactory.foreachVector(Vector[] vectors,
RealScalarFunction f)
Applies a
RealScalarFunction on each input vector. |
static Vector[] |
VectorFactory.foreachVector(Vector[] vectors,
RealVectorFunction f)
Applies a real vector function on each input vector.
|
static Vector |
VectorFactory.getCoordinate(Vector[] vectors,
int i)
Gets the vector entries from a particular coordinate.
|
static List<Vector> |
VectorFactory.getOffsetVectors(Vector v0,
Vector dv,
int a,
int b)
Given the reference vector
v0, the delta dv, and
the range [a, b], the offset vectors are:
\[
v0 + a \cdot dv, v0 + (a + 1) \cdot dv, \ldots , v0 + b \cdot dv |
Vector |
RealVectorSpace.getSpanningCoefficients(Vector b)
Find a linear combination of the basis that best approximates a vector in the least square
sense.
|
boolean |
RealVectorSpace.isInKernel(Vector b)
Deprecated.
Not supported yet.
|
boolean |
RealVectorSpace.isSpanned(Vector b)
Check whether a vector is in the span of the basis.
|
static Vector |
VectorFactory.replaceInPlace(Vector original,
int from,
Vector replacement)
Replaces a sub-vector with a given smaller vector.
|
static Vector |
VectorFactory.subVector(Vector vector,
int[] indices)
Gets a sub-vector from a vector according to a given array
of ordered indices (repetition allowed).
|
static Vector |
VectorFactory.subVector(Vector vector,
int from,
int to)
Gets a sub-vector from a vector.
|
static Vector |
VectorFactory.subVector(Vector vector,
List<Integer> indices)
Gets a sub-vector from a vector according to a given array
of ordered indices (repetition allowed).
|
| Modifier and Type | Method and Description |
|---|---|
static Vector |
VectorFactory.concat(Collection<Vector> vectors)
Concatenates an array of vectors into one vector.
|
static Vector |
VectorFactory.foreachVector(Collection<Vector> vectors,
RealScalarFunction f)
Applies a
RealScalarFunction on each input vector. |
static Vector[] |
VectorFactory.foreachVector(Collection<Vector> vectors,
RealVectorFunction f)
Applies a real vector function on each input vector.
|
static Vector |
VectorFactory.getCoordinate(Collection<Vector> vectors,
int i)
Gets the vector entries from a particular coordinate.
|
| Constructor and Description |
|---|
Projection(Vector v,
List<Vector> basis)
Project a vector v onto a set of basis \(\{w_{i}\}\).
|
Projection(Vector v,
Vector w)
Project a vector v onto another vector.
|
Projection(Vector v,
Vector[] basis)
Project a vector v onto a set of basis \(\{w_{i}\}\).
|
Projection(Vector v,
Vector[] basis)
Project a vector v onto a set of basis \(\{w_{i}\}\).
|
RealVectorSpace(double epsilon,
Vector... elements)
Construct a vector space from an array of vectors.
|
RealVectorSpace(Vector... elements)
Construct a vector space from an array of vectors.
|
| Constructor and Description |
|---|
Projection(Vector v,
List<Vector> basis)
Project a vector v onto a set of basis \(\{w_{i}\}\).
|
RealVectorSpace(List<Vector> elements)
Construct a vector space from a list of vectors.
|
RealVectorSpace(List<Vector> elements,
double epsilon)
Construct a vector space from a list of vectors.
|
| Modifier and Type | Method and Description |
|---|---|
Vector |
DerivativeFunction.evaluate(double x,
Vector y)
Computes the derivative at the given point, x.
|
Vector |
ODE1stOrder.y0()
Gets the initial value of y, that is, \(y_{0}\).
|
| Modifier and Type | Method and Description |
|---|---|
Vector |
DerivativeFunction.evaluate(double x,
Vector y)
Computes the derivative at the given point, x.
|
| Constructor and Description |
|---|
ODE1stOrder(DerivativeFunction dy,
Vector y0,
double x0,
double x1)
Constructs a first order ODE with the given vector-valued function and its initial values.
|
ODE1stOrder(RealVectorFunction F,
Vector y0,
double x0,
double x1)
Constructs a first order ODE with the given vector-valued function and its initial values.
|
ODE1stOrderWith2ndDerivative(DerivativeFunction dy,
DerivativeFunction ddy,
Vector y0,
double x0,
double x1)
Constructs a first order ODE with initial values.
|
ODE1stOrderWith2ndDerivative(RealVectorFunction dy,
RealVectorFunction ddy,
Vector y0,
double x0,
double x1)
Constructs a first order ODE with initial values.
|
| Modifier and Type | Method and Description |
|---|---|
Vector[] |
ODEIntegrator.integrate(ODE1stOrder ode,
double[] x)
This is the integration method that approximates the solution of a
first order ODE.
|
Vector[] |
ODESolution.y()
Get the corresponding values of the dependent variable.
|
| Constructor and Description |
|---|
ODESolution(double[] x,
Vector[] y)
Create a solution with estimated values at the given points.
|
| Modifier and Type | Method and Description |
|---|---|
Vector |
ABMPredictorCorrector1.correct(DerivativeFunction dy,
double h,
double[] x,
Vector[] y) |
Vector |
ABMPredictorCorrector3.correct(DerivativeFunction dy,
double h,
double[] x,
Vector[] y) |
Vector |
ABMPredictorCorrector4.correct(DerivativeFunction dy,
double h,
double[] x,
Vector[] y) |
Vector |
ABMPredictorCorrector5.correct(DerivativeFunction dy,
double h,
double[] x,
Vector[] y) |
Vector |
ABMPredictorCorrector2.correct(DerivativeFunction dy,
double h,
double[] x,
Vector[] y) |
Vector |
ABMPredictorCorrector.correct(DerivativeFunction dy,
double h,
double[] x,
Vector[] y) |
Vector |
ABMPredictorCorrector1.predict(DerivativeFunction dy,
double h,
double[] x,
Vector[] y) |
Vector |
ABMPredictorCorrector3.predict(DerivativeFunction dy,
double h,
double[] x,
Vector[] y) |
Vector |
ABMPredictorCorrector4.predict(DerivativeFunction dy,
double h,
double[] x,
Vector[] y) |
Vector |
ABMPredictorCorrector5.predict(DerivativeFunction dy,
double h,
double[] x,
Vector[] y) |
Vector |
ABMPredictorCorrector2.predict(DerivativeFunction dy,
double h,
double[] x,
Vector[] y) |
Vector |
ABMPredictorCorrector.predict(DerivativeFunction dy,
double h,
double[] x,
Vector[] y) |
| Modifier and Type | Method and Description |
|---|---|
Vector |
ABMPredictorCorrector1.correct(DerivativeFunction dy,
double h,
double[] x,
Vector[] y) |
Vector |
ABMPredictorCorrector3.correct(DerivativeFunction dy,
double h,
double[] x,
Vector[] y) |
Vector |
ABMPredictorCorrector4.correct(DerivativeFunction dy,
double h,
double[] x,
Vector[] y) |
Vector |
ABMPredictorCorrector5.correct(DerivativeFunction dy,
double h,
double[] x,
Vector[] y) |
Vector |
ABMPredictorCorrector2.correct(DerivativeFunction dy,
double h,
double[] x,
Vector[] y) |
Vector |
ABMPredictorCorrector.correct(DerivativeFunction dy,
double h,
double[] x,
Vector[] y) |
Vector |
ABMPredictorCorrector1.predict(DerivativeFunction dy,
double h,
double[] x,
Vector[] y) |
Vector |
ABMPredictorCorrector3.predict(DerivativeFunction dy,
double h,
double[] x,
Vector[] y) |
Vector |
ABMPredictorCorrector4.predict(DerivativeFunction dy,
double h,
double[] x,
Vector[] y) |
Vector |
ABMPredictorCorrector5.predict(DerivativeFunction dy,
double h,
double[] x,
Vector[] y) |
Vector |
ABMPredictorCorrector2.predict(DerivativeFunction dy,
double h,
double[] x,
Vector[] y) |
Vector |
ABMPredictorCorrector.predict(DerivativeFunction dy,
double h,
double[] x,
Vector[] y) |
| Modifier and Type | Method and Description |
|---|---|
Vector[] |
RungeKuttaIntegrator.integrate(ODE1stOrder ode,
double[] x) |
Vector |
RungeKutta8.step(DerivativeFunction dy,
Vector y0,
double x0,
double x1,
double h) |
Vector |
RungeKuttaStepper.step(DerivativeFunction dy,
Vector y0,
double x0,
double x1,
double h) |
Vector |
RungeKutta5.step(DerivativeFunction dy,
Vector y0,
double x0,
double x1,
double h) |
Vector |
RungeKutta7.step(DerivativeFunction dy,
Vector y0,
double x0,
double x1,
double h) |
Vector |
RungeKutta10.step(DerivativeFunction dy,
Vector y0,
double x0,
double x1,
double h) |
Vector |
RungeKutta1.step(DerivativeFunction dy,
Vector y0,
double x0,
double x1,
double h) |
Vector |
RungeKutta2.step(DerivativeFunction dy,
Vector y0,
double x0,
double x1,
double h) |
Vector |
RungeKutta3.step(DerivativeFunction dy,
Vector y0,
double x0,
double x1,
double h) |
Vector |
RungeKutta6.step(DerivativeFunction dy,
Vector y0,
double x0,
double x1,
double h) |
Vector |
RungeKutta4.step(DerivativeFunction dy,
Vector y0,
double x0,
double x1,
double h) |
| Modifier and Type | Method and Description |
|---|---|
Vector |
RungeKutta8.step(DerivativeFunction dy,
Vector y0,
double x0,
double x1,
double h) |
Vector |
RungeKuttaStepper.step(DerivativeFunction dy,
Vector y0,
double x0,
double x1,
double h) |
Vector |
RungeKutta5.step(DerivativeFunction dy,
Vector y0,
double x0,
double x1,
double h) |
Vector |
RungeKutta7.step(DerivativeFunction dy,
Vector y0,
double x0,
double x1,
double h) |
Vector |
RungeKutta10.step(DerivativeFunction dy,
Vector y0,
double x0,
double x1,
double h) |
Vector |
RungeKutta1.step(DerivativeFunction dy,
Vector y0,
double x0,
double x1,
double h) |
Vector |
RungeKutta2.step(DerivativeFunction dy,
Vector y0,
double x0,
double x1,
double h) |
Vector |
RungeKutta3.step(DerivativeFunction dy,
Vector y0,
double x0,
double x1,
double h) |
Vector |
RungeKutta6.step(DerivativeFunction dy,
Vector y0,
double x0,
double x1,
double h) |
Vector |
RungeKutta4.step(DerivativeFunction dy,
Vector y0,
double x0,
double x1,
double h) |
| Modifier and Type | Field and Description |
|---|---|
protected Vector[] |
PDETimeSpaceGrid1D.u
the solution matrix
|
| Modifier and Type | Method and Description |
|---|---|
abstract Vector |
PDETimeSpaceGrid1D.getRHS(int m) |
Vector[] |
PDETimeSpaceGrid1D.propagate()
Propagates the grid to the next time step by solving \(Au=d\).
|
| Modifier and Type | Method and Description |
|---|---|
Vector |
CrankNicolsonConvectionDiffusionEquation1D.Coefficients.getRHS(Vector um,
double tm)
Computes the right hand side vector of the Crank-Nicolson scheme.
|
| Modifier and Type | Method and Description |
|---|---|
Vector |
CrankNicolsonConvectionDiffusionEquation1D.Coefficients.getRHS(Vector um,
double tm)
Computes the right hand side vector of the Crank-Nicolson scheme.
|
| Modifier and Type | Method and Description |
|---|---|
Vector |
CrankNicolsonHeatEquation1D.Coefficients.getRHS(Vector um,
double tm,
double tmp1) |
| Modifier and Type | Method and Description |
|---|---|
Vector |
CrankNicolsonHeatEquation1D.Coefficients.getRHS(Vector um,
double tm,
double tmp1) |
| Modifier and Type | Method and Description |
|---|---|
Double |
Ridders.evaluate(Vector x)
Evaluate the function f at x, where x is from the domain.
|
double |
Ridders.evaluate(Vector x,
double h)
Evaluate numerically the derivative of f at point x, f'(x), with step size h.
|
| Modifier and Type | Class and Description |
|---|---|
class |
Gradient
The gradient of a scalar field is a vector field which points in the direction of the greatest
rate of increase of the scalar field, and of which the magnitude is the greatest rate of change.
|
| Modifier and Type | Method and Description |
|---|---|
Vector |
GradientFunction.evaluate(Vector x) |
| Modifier and Type | Method and Description |
|---|---|
Vector |
GradientFunction.evaluate(Vector x) |
Matrix |
JacobianFunction.evaluate(Vector x) |
Matrix |
HessianFunction.evaluate(Vector x) |
Double |
MultivariateFiniteDifference.evaluate(Vector x)
Evaluate numerically the partial derivative of f at point x.
|
double |
MultivariateFiniteDifference.evaluate(Vector x,
double h)
Evaluate numerically the partial derivative of f at point x with step size h.
|
| Constructor and Description |
|---|
BorderedHessian(RealScalarFunction f,
RealScalarFunction g,
Vector x)
Construct the bordered Hessian matrix for multivariate functions f and g at
point x.
|
Gradient(RealScalarFunction f,
Vector x)
Construct the gradient vector for a multivariate function f at point x.
|
Hessian(RealScalarFunction f,
Vector x)
Construct the Hessian matrix for a multivariate function f at point x.
|
Jacobian(List<RealScalarFunction> f,
Vector x)
Construct the Jacobian matrix for a multivariate function f at point x.
|
Jacobian(RealScalarFunction[] f,
Vector x)
Construct the Jacobian matrix for a multivariate function f at point x.
|
Jacobian(RealVectorFunction f,
Vector x)
Construct the Jacobian matrix for a multivariate function f at point x.
|
| Modifier and Type | Field and Description |
|---|---|
protected Function<Vector,R> |
SubFunction.f
the original, unrestricted function
|
| Modifier and Type | Method and Description |
|---|---|
static Vector |
SubFunction.getAllParts(Vector variables,
Map<Integer,Double> fixing)
Combines the variable and fixed values to form an input to the original
function.
|
| Modifier and Type | Method and Description |
|---|---|
static Vector |
SubFunction.getAllParts(Vector variables,
Map<Integer,Double> fixing)
Combines the variable and fixed values to form an input to the original
function.
|
| Constructor and Description |
|---|
SubFunction(Function<Vector,R> f,
Map<Integer,Double> fixing)
Constructs a sub-function.
|
| Modifier and Type | Method and Description |
|---|---|
Matrix |
R1toMatrix.evaluate(Vector x) |
Matrix |
R2toMatrix.evaluate(Vector x) |
| Modifier and Type | Method and Description |
|---|---|
Double |
R1Projection.evaluate(Vector x) |
Double |
RealScalarSubFunction.evaluate(Vector x) |
Double |
QuadraticFunction.evaluate(Vector z) |
Double |
AbstractTrivariateRealFunction.evaluate(Vector x) |
Double |
AbstractBivariateRealFunction.evaluate(Vector x) |
| Constructor and Description |
|---|
QuadraticFunction(Matrix H,
Vector p)
Construct a quadratic function of this form: \(f(x) = \frac{1}{2}x^{\mathsf T}Hx+x^{\mathsf T}p\).
|
QuadraticFunction(Matrix H,
Vector p,
double c)
Construct a quadratic function of this form: \(f(x) = \frac{1}{2}x^{\mathsf T}Hx+x^{\mathsf T}p + c\).
|
| Modifier and Type | Method and Description |
|---|---|
Double |
AbstractUnivariateRealFunction.evaluate(Vector x) |
| Modifier and Type | Method and Description |
|---|---|
abstract Vector |
AbstractR1RnFunction.evaluate(double x) |
Vector |
AbstractR1RnFunction.evaluate(Vector x) |
Vector |
RealVectorSubFunction.evaluate(Vector x) |
| Modifier and Type | Method and Description |
|---|---|
Vector |
AbstractR1RnFunction.evaluate(Vector x) |
Vector |
RealVectorSubFunction.evaluate(Vector x) |
| Modifier and Type | Method and Description |
|---|---|
Double |
Rastrigin.evaluate(Vector x) |
| Modifier and Type | Method and Description |
|---|---|
Double |
MultinomialBetaFunction.evaluate(Vector a) |
| Modifier and Type | Method and Description |
|---|---|
Vector |
NewtonSystemRoot.solve(RealScalarFunction[] f,
Vector guess)
Searches for a root, x such that f(x) = 0.
|
Vector |
NewtonSystemRoot.solve(RealVectorFunction f,
Vector guess)
Searches for a root, x such that f(x) = 0.
|
| Modifier and Type | Method and Description |
|---|---|
Vector |
NewtonSystemRoot.solve(RealScalarFunction[] f,
Vector guess)
Searches for a root, x such that f(x) = 0.
|
Vector |
NewtonSystemRoot.solve(RealVectorFunction f,
Vector guess)
Searches for a root, x such that f(x) = 0.
|
| Constructor and Description |
|---|
Point(Vector coordinates)
Create a point with given coordinates.
|
| Modifier and Type | Method and Description |
|---|---|
void |
VectorMonitor.addIterate(Vector x) |
| Modifier and Type | Method and Description |
|---|---|
double |
AfterNoImprovement.energy(Vector x,
double... information) |
boolean |
StopCondition.isStopped(Vector x,
double... information)
This is called after each iteration to determine whether the termination conditions are met,
e.g., convergence.
|
boolean |
AndStopConditions.isStopped(Vector x,
double... information) |
boolean |
AfterNoImprovement.isStopped(Vector x,
double... information) |
boolean |
AtThreshold.isStopped(Vector x,
double... information) |
boolean |
AfterIterations.isStopped(Vector x,
double... information) |
boolean |
OrStopConditions.isStopped(Vector x,
double... information) |
| Modifier and Type | Method and Description |
|---|---|
Vector |
FlexibleTable.getColumn(int col) |
Vector |
FlexibleTable.getRow(int row) |
| Modifier and Type | Method and Description |
|---|---|
Iterator<Vector> |
MultiDimensionalGrid.iterator() |
| Modifier and Type | Method and Description |
|---|---|
static void |
DimensionCheck.throwIfIncompatible4Multiplication(Table A,
Vector v)
Throws if
A.nCols() ! |
| Modifier and Type | Interface and Description |
|---|---|
static interface |
SubProblemMinimizer.ConstrainedMinimizerFactory<U extends ConstrainedMinimizer<ConstrainedOptimProblem,IterativeSolution<Vector>>>
This factory constructs a new instance of
ConstrainedMinimizer to solve a real valued minimization
problem.
|
| Modifier and Type | Method and Description |
|---|---|
IterativeSolution<Vector> |
SubProblemMinimizer.solve(ConstrainedOptimProblem subProblem)
Solves a constrained optimization sub-problem that is already in the form
of a ConstrainedOptimProblem.
|
SubProblemMinimizer.IterativeSolution<Vector> |
SubProblemMinimizer.solve(ConstrainedOptimProblem problem,
Map<Integer,Double> fixing)
Solves a constrained sub-problem by specifying the fixing explicitly.
|
SubProblemMinimizer.IterativeSolution<Vector> |
SubProblemMinimizer.solve(ConstrainedOptimSubProblem problem) |
| Constructor and Description |
|---|
SubProblemMinimizer(SubProblemMinimizer.ConstrainedMinimizerFactory<? extends ConstrainedMinimizer<ConstrainedOptimProblem,IterativeSolution<Vector>>> factory) |
| Modifier and Type | Method and Description |
|---|---|
static Vector |
ConstraintsUtils.evaluate(Constraints constraints,
Vector x)
Evaluates the constraints.
|
| Modifier and Type | Method and Description |
|---|---|
static Vector |
ConstraintsUtils.evaluate(Constraints constraints,
Vector x)
Evaluates the constraints.
|
static boolean |
ConstraintsUtils.isSatisfied(Constraints constraints,
Vector x)
Checks if the constraints are satisfied.
|
static boolean |
ConstraintsUtils.isSatisfied(Constraints constraints,
Vector x,
double epsilon)
Checks if the constraints are satisfied.
|
| Modifier and Type | Method and Description |
|---|---|
Vector |
LinearLessThanConstraints.getFeasibleInitialPoint()
Given a collection of linear less-than-or-equal-to constraints,
find a feasible initial point that satisfy the constraints.
|
Vector |
LinearGreaterThanConstraints.getFeasibleInitialPoint()
Given a collection of linear greater-than-or-equal-to constraints,
find a feasible initial point that satisfy the constraints.
|
Vector |
LinearLessThanConstraints.getFeasibleInitialPoint(LinearEqualityConstraints equal)
Given a collection of linear less-than-or-equal-to constraints as well as a collection of equality constraints,
find a feasible initial point that satisfy the constraints.
|
Vector |
LinearGreaterThanConstraints.getFeasibleInitialPoint(LinearEqualityConstraints equal)
Given a collection of linear greater-than-or-equal-to constraints as well as a collection of
equality constraints,
find a feasible initial point that satisfy the constraints.
|
Vector |
BoxConstraints.lowerBounds()
Gets the lower bounds.
|
Vector |
BoxConstraints.upperBounds()
Gets the upper bounds.
|
| Modifier and Type | Method and Description |
|---|---|
Matrix |
LinearConstraints.getActiveConstraints(Vector x,
double epsilon)
Get the active constraint.
|
ArrayList<Integer> |
LinearConstraints.getActiveRows(Vector x,
double epsilon)
Get the active constraint indices.
|
static boolean |
BoxConstraints.isInBox(Vector x,
Vector lower,
Vector upper)
Check if a solution is within a box.
|
| Constructor and Description |
|---|
BoxConstraints(Vector lower,
Vector upper)
Construct a set of bound constraints.
|
LinearConstraints(Matrix A,
Vector b)
Construct a collection of linear constraints.
|
LinearEqualityConstraints(Matrix A,
Vector b)
Construct a collection of linear equality constraints.
|
LinearGreaterThanConstraints(Matrix A,
Vector b)
Construct a collection of linear greater-than or equal-to constraints.
|
LinearLessThanConstraints(Matrix A,
Vector b)
Construct a collection of linear less-than or equal-to constraints.
|
| Constructor and Description |
|---|
CentralPath(Matrix X,
Vector y,
Matrix S)
Construct a central path.
|
| Constructor and Description |
|---|
EqualityConstraints(Vector b,
SymmetricMatrix C,
SymmetricMatrix[] A)
Construct the equality constraints for a dual SDP problem,
\(\sum_{i=1}^{p}y_i\mathbf{A_i}+\textbf{S} = \textbf{C}, \textbf{S} \succeq \textbf{0}\).
|
SDPDualProblem(Vector b,
SymmetricMatrix C,
SymmetricMatrix[] A)
Constructs a dual SDP problem.
|
| Modifier and Type | Method and Description |
|---|---|
PrimalDualSolution |
SDPT3v4.iterate(PrimalDualSolution soln0,
Vector Ax,
Vector Aty,
double mu) |
PrimalDualSolution |
AntoniouLu2007.iterate(PrimalDualSolution soln0,
Vector Ax,
Vector Aty,
double mu) |
PrimalDualSolution |
SDPT3v4_1b.iterate(PrimalDualSolution soln0,
Vector Ax,
Vector Aty,
double mu) |
PrimalDualSolution |
SDPT3v4_1a.iterate(PrimalDualSolution soln0,
Vector Ax,
Vector Aty,
double mu) |
| Constructor and Description |
|---|
PrimalDualSolution(Vector x,
Vector s,
Vector y)
Construct a solution to a primal and a dual SOCP problems.
|
| Modifier and Type | Method and Description |
|---|---|
Vector |
SOCPGeneralConstraint.b()
Gets b.
|
Vector |
SOCPDualProblem1.b()
Gets b.
|
Vector |
SOCPDualProblem.b()
Gets b.
|
Vector |
SOCPDualProblem1.c_full() |
Vector |
SOCPDualProblem1.c_l_full() |
Vector |
SOCPDualProblem1.c_l() |
Vector |
SOCPDualProblem1.c_q_full() |
Vector |
SOCPDualProblem1.c_q(int i)
Gets \(c^q_i\).
|
Vector |
SOCPDualProblem1.c_u() |
Vector |
SOCPGeneralConstraint.c()
Gets c.
|
Vector |
SOCPLinearEquality.c() |
Vector |
SOCPLinearInequality.c() |
Vector |
SOCPDualProblem.c() |
Vector |
SOCPDualProblem.c(int i)
Gets \(c_{i}\).
|
| Constructor and Description |
|---|
EqualityConstraints(Vector b,
Matrix[] A,
Vector[] c)
Constructs the equality constraints for a dual SOCP problem,
\[
\max_y \mathbf{b'y} \textrm{ s.t.,} \\
\mathbf{{A^q}_i'y + s_i = c^q_i}, s_i \in K_i, i = 1, 2, ..., q \\
\mathbf{{A^{\ell}}^T y + z^{\ell} = c^{\ell}} \\
\mathbf{{A^{u}}^T y = c^{u}} \\
\]
|
EqualityConstraints(Vector b,
Matrix[] A,
Vector[] c)
Constructs the equality constraints for a dual SOCP problem,
\[
\max_y \mathbf{b'y} \textrm{ s.t.,} \\
\mathbf{{A^q}_i'y + s_i = c^q_i}, s_i \in K_i, i = 1, 2, ..., q \\
\mathbf{{A^{\ell}}^T y + z^{\ell} = c^{\ell}} \\
\mathbf{{A^{u}}^T y = c^{u}} \\
\]
|
EqualityConstraints(Vector b,
Matrix[] A,
Vector[] c)
Constructs the equality constraints for a dual SOCP problem, \(\max_y \mathbf{b'y}
\textrm{ s.t.,} \\ \mathbf{\hat{A}_i'y + s_i = \hat{c}_i} \\ s_i \in K_i, i = 1, 2, ...,
q\).
|
EqualityConstraints(Vector b,
Matrix[] A,
Vector[] c)
Constructs the equality constraints for a dual SOCP problem, \(\max_y \mathbf{b'y}
\textrm{ s.t.,} \\ \mathbf{\hat{A}_i'y + s_i = \hat{c}_i} \\ s_i \in K_i, i = 1, 2, ...,
q\).
|
SOCPDualProblem(Vector b,
Matrix[] A,
Vector[] c)
Constructs a dual SOCP problem.
\[
\max_y \mathbf{b'y} \textrm{ s.t.,} \\
\mathbf{\hat{A}_i'y + s_i = \hat{c}_i} \\
s_i \in K_i, i = 1, 2, ..., q
\]
|
SOCPDualProblem(Vector b,
Matrix[] A,
Vector[] c)
Constructs a dual SOCP problem.
\[
\max_y \mathbf{b'y} \textrm{ s.t.,} \\
\mathbf{\hat{A}_i'y + s_i = \hat{c}_i} \\
s_i \in K_i, i = 1, 2, ..., q
\]
|
SOCPDualProblem1(Vector b,
Matrix[] A_q,
Vector[] c_q)
Constructs a dual SOCP problem.
\[
\max_y \mathbf{b'y} \textrm{ s.t.,} \\
\mathbf{{A^q}_i'y + s_i = c^q_i}, s_i \in K_i, i = 1, 2, ..., q \\
\]
|
SOCPDualProblem1(Vector b,
Matrix[] A_q,
Vector[] c_q)
Constructs a dual SOCP problem.
\[
\max_y \mathbf{b'y} \textrm{ s.t.,} \\
\mathbf{{A^q}_i'y + s_i = c^q_i}, s_i \in K_i, i = 1, 2, ..., q \\
\]
|
SOCPDualProblem1(Vector b,
Matrix[] A_q,
Vector[] c_q,
Matrix A_l,
Vector c_l,
Matrix A_u,
Vector c_u)
Constructs a dual SOCP problem.
\[
\max_y \mathbf{b'y} \textrm{ s.t.,} \\
\mathbf{{A^q}_i'y + s_i = c^q_i}, s_i \in K_i, i = 1, 2, ..., q \\
\mathbf{{A^{\ell}}^T y + z^{\ell} = c^{\ell}} \\
\mathbf{{A^{u}}^T y = c^{u}} \\
\]
|
SOCPDualProblem1(Vector b,
Matrix[] A_q,
Vector[] c_q,
Matrix A_l,
Vector c_l,
Matrix A_u,
Vector c_u)
Constructs a dual SOCP problem.
\[
\max_y \mathbf{b'y} \textrm{ s.t.,} \\
\mathbf{{A^q}_i'y + s_i = c^q_i}, s_i \in K_i, i = 1, 2, ..., q \\
\mathbf{{A^{\ell}}^T y + z^{\ell} = c^{\ell}} \\
\mathbf{{A^{u}}^T y = c^{u}} \\
\]
|
SOCPGeneralConstraint(Matrix A,
Vector c,
Vector b,
double d)
Constructs a SOCP general constraint.
|
SOCPGeneralProblem(Vector f,
List<SOCPGeneralConstraint> constraints)
Construct a general Second Order Conic Programming problem.
|
SOCPGeneralProblem(Vector f,
SOCPGeneralConstraint[] constraints)
Construct a general Second Order Conic Programming problem.
|
SOCPGeneralProblem1(Vector f,
List<SOCPGeneralConstraint> generalConstraints)
Construct a general Second Order Conic Programming problem.
\[
\begin{align*}
\min_x \quad & \mathbf{f^T} x \\
\textrm{s.t.}
|
SOCPGeneralProblem1(Vector f,
List<SOCPGeneralConstraint> generalConstraints,
List<SOCPLinearInequality> linearInequalities,
List<SOCPLinearEquality> linearEqualities)
Construct a general Second Order Conic Programming problem.
\[
\begin{align*}
\min_x \quad & \mathbf{f^T} x \\
\textrm{s.t.}
|
SOCPGeneralProblem1(Vector f,
SOCPGeneralConstraint[] generalConstraints,
SOCPLinearInequality[] linearInequalities,
SOCPLinearEquality[] linearEqualities)
Construct a general Second Order Conic Programming problem.\[
\begin{align*}
\min_x \quad &; \mathbf{f^T} x \\
\textrm{s.t.}
|
SOCPLinearEquality(Matrix A,
Vector c) |
SOCPLinearInequality(Matrix A,
Vector c) |
| Modifier and Type | Method and Description |
|---|---|
Vector |
SOCPPortfolioObjectiveFunction.b()
Gets the objective vector, b, in the compact form.
|
| Modifier and Type | Method and Description |
|---|---|
boolean |
SOCPPortfolioProblem.areAllConstraintsSatisfied(Vector x)
Checks whether the constraints are satisfied with a solution vector x.
|
boolean |
PortfolioRiskExactSigma.areAllConstraintsSatisfied(Vector y)
Checks whether all SOCP constraints represented by this portfolio
constraint are satisfied.
|
boolean |
SOCPPortfolioProblem1.areAllConstraintsSatisfied(Vector x)
Checks whether the constraints are satisfied with a solution vector x.
|
boolean |
MarketImpact1.areAllConstraintsSatisfied(Vector y)
Checks whether all SOCP constraints represented by this portfolio
constraint are satisfied.
|
abstract boolean |
SOCPPortfolioConstraint.areAllConstraintsSatisfied(Vector y)
Checks whether all SOCP constraints represented by this portfolio
constraint are satisfied.
|
Double |
SOCPPortfolioObjectiveFunction.evaluate(Vector y)
Computes the final objective function value.
|
Double |
PortfolioRiskExactSigma.evaluate(Vector y) |
Double |
MarketImpact1.evaluate(Vector y) |
| Constructor and Description |
|---|
MarketImpact1(Vector w_0,
Vector m)
Constructs a market impact term.
|
SOCPPortfolioObjectiveFunction(Vector r_bar,
double[] lambda,
SOCPRiskConstraint risk,
SOCPPortfolioConstraint impact)
Constructs the objective function for an SOCP portfolio optimization (minimization) problem.
|
SOCPPortfolioObjectiveFunction(Vector r_bar,
double lambda,
SOCPRiskConstraint risk)
Constructs the objective function for an SOCP portfolio optimization (minimization) problem
without a market impact term.
|
| Constructor and Description |
|---|
LPCanonicalProblem1(Vector cost,
LinearGreaterThanConstraints greater)
Construct a linear programming problem in the canonical form.
|
LPCanonicalProblem1(Vector c,
Matrix A,
Vector b)
Construct a linear programming problem in the canonical form.
|
LPCanonicalProblem2(Vector cost,
LinearLessThanConstraints less)
Construct a linear programming problem in the canonical form.
|
LPCanonicalProblem2(Vector c,
Matrix A,
Vector b)
Construct a linear programming problem in the canonical form.
|
LPProblemImpl1(Vector cost,
LinearGreaterThanConstraints greater,
LinearEqualityConstraints equal)
Construct a general linear programming problem with only greater-than-or-equal-to and
equality constraints.
|
LPProblemImpl1(Vector cost,
LinearGreaterThanConstraints greater,
LinearLessThanConstraints less,
LinearEqualityConstraints equal,
BoxConstraints bounds)
Construct a general linear programming problem.
|
LPStandardProblem(Vector c,
LinearEqualityConstraints equal)
Construct a linear programming problem in the standard form.
|
| Modifier and Type | Method and Description |
|---|---|
Vector |
LPRevisedSimplexSolver.findFeasiblePoint(Matrix A,
Vector b) |
| Modifier and Type | Method and Description |
|---|---|
Vector |
LPRevisedSimplexSolver.findFeasiblePoint(Matrix A,
Vector b) |
dev.nm.solver.multivariate.constrained.convex.sdp.socp.qp.lp.simplex.solver.LPRevisedSimplexSolver.WorkingSet |
LPRevisedSimplexSolver.findVertex(Matrix A,
Vector b,
Vector x0) |
| Constructor and Description |
|---|
Problem(Matrix A,
Vector b,
Vector c) |
| Modifier and Type | Method and Description |
|---|---|
ImmutableVector |
QPProblemOnlyEqualityConstraints.getSolutionToOriginalProblem(Vector phi)
Backs out the solution for the original (constrained) problem, if the modified
(unconstrained) problem can be solved.
|
| Modifier and Type | Method and Description |
|---|---|
QPSolution |
QPPrimalActiveSetMinimizer.Solution.search(Vector initial)
Searches for a minimizer for the quadratic programming problem.
|
| Modifier and Type | Method and Description |
|---|---|
IterativeSolution<Vector> |
BoxGeneralizedSimulatedAnnealingMinimizer.solve(BoxOptimProblem problem) |
| Modifier and Type | Method and Description |
|---|---|
IterativeSolution<Vector> |
PenaltyMethodMinimizer.solve(ConstrainedOptimProblem problem) |
| Modifier and Type | Method and Description |
|---|---|
Double |
SumOfPenalties.evaluate(Vector x) |
Double |
FletcherPenalty.evaluate(Vector x) |
Double |
AbsoluteErrorPenalty.evaluate(Vector x) |
Double |
ZeroPenalty.evaluate(Vector x) |
Double |
CourantPenalty.evaluate(Vector x) |
| Modifier and Type | Method and Description |
|---|---|
Vector |
SQPActiveSetMinimizer.Solution.minimizer() |
Vector |
SQPActiveSetMinimizer.Solution.search(Vector... initials)
Search for a solution that optimizes the objective function from the
given starting points.
|
Vector |
SQPActiveSetOnlyInequalityConstraintMinimizer.Solution.search(Vector... initials) |
Vector |
SQPActiveSetMinimizer.Solution.search(Vector x0)
Search for a solution that minimizes the objective function from the
given starting point.
|
Vector |
SQPActiveSetMinimizer.Solution.search(Vector x0,
Vector lambda0,
Vector mu0)
Search for a solution that minimizes the objective function from the
given starting point.
|
| Modifier and Type | Method and Description |
|---|---|
IterativeSolution<Vector> |
SQPActiveSetOnlyInequalityConstraintMinimizer.solve(RealScalarFunction f,
GreaterThanConstraints greater)
Minimize a function subject to only inequality constraints.
|
IterativeSolution<Vector> |
SQPActiveSetOnlyInequalityConstraintMinimizer.solve(RealScalarFunction f,
RealVectorFunction g,
GreaterThanConstraints greater)
Minimize a function subject to only inequality constraints.
|
| Modifier and Type | Method and Description |
|---|---|
double |
SQPASVariation.alpha(Vector x,
Vector d,
Vector v,
Vector u)
Get the percentage increment along the minimizer increment direction.
|
double |
SQPASVariation1.alpha(Vector x,
Vector d,
Vector v,
Vector u)
Get the percentage increment along the minimizer increment direction.
|
Matrix |
SQPASVariation.getInitialHessian(Vector x0,
Vector v0,
Vector u0)
Get the initial Hessian matrix.
|
Matrix |
SQPASVariation1.getInitialHessian(Vector x0,
Vector v0,
Vector u0) |
Vector |
SQPActiveSetMinimizer.Solution.search(Vector... initials)
Search for a solution that optimizes the objective function from the
given starting points.
|
Vector |
SQPActiveSetOnlyInequalityConstraintMinimizer.Solution.search(Vector... initials) |
Vector |
SQPActiveSetMinimizer.Solution.search(Vector x0)
Search for a solution that minimizes the objective function from the
given starting point.
|
Vector |
SQPActiveSetMinimizer.Solution.search(Vector x0,
Vector lambda0,
Vector mu0)
Search for a solution that minimizes the objective function from the
given starting point.
|
void |
SQPActiveSetMinimizer.Solution.setInitials(Vector... initials)
Supply the starting points for the search.
|
Matrix |
SQPASVariation.updateHessian(Vector x1,
Vector v1,
Vector u1,
Vector d,
Vector g0,
Matrix Ae0,
Matrix Ai0,
Matrix W0)
Update the Hessian matrix using the latest iterates.
|
Matrix |
SQPASVariation1.updateHessian(Vector x1,
Vector v1,
Vector u1,
Vector d,
Vector g0,
Matrix Ae0,
Matrix Ai0,
Matrix W0)
Update the Hessian matrix using the latest iterates.
|
| Modifier and Type | Method and Description |
|---|---|
IterativeSolution<Vector> |
SQPActiveSetOnlyEqualityConstraint1Minimizer.solve(ConstrainedOptimProblem problem) |
IterativeSolution<Vector> |
SQPActiveSetOnlyEqualityConstraint1Minimizer.solve(RealScalarFunction f,
EqualityConstraints equal)
Minimize a function subject to only equality constraints.
|
| Modifier and Type | Method and Description |
|---|---|
double |
SQPASEVariation1.alpha(Vector x,
Vector d,
Vector v) |
double |
SQPASEVariation.alpha(Vector x,
Vector d,
Vector u)
Get the percentage increment along the minimizer increment direction.
|
Matrix |
SQPASEVariation1.getInitialHessian(Vector x0,
Vector v0) |
Matrix |
SQPASEVariation.getInitialHessian(Vector x0,
Vector u0)
Get the initial Hessian matrix.
|
Matrix |
SQPASEVariation2.updateHessian(Vector x1,
Vector v1,
Vector d,
Vector g0,
Matrix A0,
Matrix W0) |
Matrix |
SQPASEVariation1.updateHessian(Vector x1,
Vector v1,
Vector d,
Vector g0,
Matrix A0,
Matrix W0) |
Matrix |
SQPASEVariation.updateHessian(Vector x1,
Vector u1,
Vector d,
Vector g0,
Matrix A0,
Matrix W0)
Update the Hessian matrix using the latest iterates.
|
protected Matrix |
SQPASEVariation1.W(Vector x,
Vector u)
Compute W.
|
| Modifier and Type | Interface and Description |
|---|---|
interface |
IPMinimizer<T extends IPProblem,S extends MinimizationSolution<Vector>>
An Integer Programming minimizer minimizes an objective function subject to equality/inequality
constraints as well as integral constraints.
|
| Modifier and Type | Method and Description |
|---|---|
Vector |
BruteForceIPMinimizer.Solution.minimizer() |
| Modifier and Type | Method and Description |
|---|---|
void |
BruteForceIPMinimizer.Solution.search(Vector initial) |
| Constructor and Description |
|---|
BruteForceIPMinimizer(SubProblemMinimizer.ConstrainedMinimizerFactory<? extends ConstrainedMinimizer<ConstrainedOptimProblem,IterativeSolution<Vector>>> factory)
Constructs a brute force minimizer to solve integral constrained
minimization problems.
|
| Modifier and Type | Method and Description |
|---|---|
MinimizationSolution<Vector> |
ILPBranchAndBoundMinimizer.solve(ILPProblem problem) |
| Modifier and Type | Method and Description |
|---|---|
static LinearGreaterThanConstraints |
ILPNode.getGreaterThanConstraint(Vector minimizer,
int i)
Construct a greater-than constraint for the branching greater-than subproblem.
|
static LinearLessThanConstraints |
ILPNode.getLessThanConstraint(Vector minimizer,
int i)
Construct a less-than constraint for the branching less-than subproblem.
|
| Modifier and Type | Method and Description |
|---|---|
MinimizationSolution<Vector> |
SimplexCuttingPlaneMinimizer.solve(ILPProblem problem) |
| Constructor and Description |
|---|
ILPProblemImpl1(Vector cost,
LinearGreaterThanConstraints greater,
LinearLessThanConstraints less,
LinearEqualityConstraints equal,
BoxConstraints bounds,
int[] integers,
double epsilon)
Construct an ILP problem, in which the variables can be real or integral.
|
PureILPProblem(Vector cost,
LinearGreaterThanConstraints greater,
LinearLessThanConstraints less,
LinearEqualityConstraints equal,
BoxConstraints bounds,
double epsilon)
Construct a pure ILP problem.
|
| Modifier and Type | Method and Description |
|---|---|
Vector |
BoxOptimProblem.lowerBound()
Gets the lower bounds.
|
Vector |
BoxOptimProblem.upperBound()
Gets the upper bounds.
|
| Constructor and Description |
|---|
BoxOptimProblem(RealScalarFunction f,
Vector lower,
Vector upper)
Constructs an optimization problem with box constraints.
|
| Modifier and Type | Method and Description |
|---|---|
IterativeSolution<Vector> |
DEOptim.solve(OptimProblem problem) |
| Modifier and Type | Method and Description |
|---|---|
Best2Bin.DeBest2BinCell |
Best2Bin.getSimpleCell(RealScalarFunction f,
Vector x) |
Rand1Bin.DeRand1BinCell |
Rand1Bin.getSimpleCell(RealScalarFunction f,
Vector x) |
| Constructor and Description |
|---|
DeBest2BinCell(RealScalarFunction f,
Vector x) |
DeOptimCell(RealScalarFunction f,
Vector x) |
DeRand1BinCell(RealScalarFunction f,
Vector x) |
| Modifier and Type | Method and Description |
|---|---|
Vector |
IntegralConstrainedCellFactory.IntegerConstraint.round(Vector x) |
Vector |
IntegralConstrainedCellFactory.AllIntegers.round(Vector x) |
Vector |
IntegralConstrainedCellFactory.SomeIntegers.round(Vector x) |
| Modifier and Type | Method and Description |
|---|---|
ConstrainedCellFactory.ConstrainedCell |
IntegralConstrainedCellFactory.getSimpleCell(RealScalarFunction f,
Vector x) |
abstract ConstrainedCellFactory.ConstrainedCell |
ConstrainedCellFactory.getSimpleCell(RealScalarFunction f,
Vector x)
Override this method to put in whatever constraints in the minimization problem.
|
Vector |
IntegralConstrainedCellFactory.IntegerConstraint.round(Vector x) |
Vector |
IntegralConstrainedCellFactory.AllIntegers.round(Vector x) |
Vector |
IntegralConstrainedCellFactory.SomeIntegers.round(Vector x) |
| Constructor and Description |
|---|
ConstrainedCell(RealScalarFunction f,
Vector x) |
| Modifier and Type | Method and Description |
|---|---|
LocalSearchCellFactory.LocalSearchCell |
LocalSearchCellFactory.getSimpleCell(RealScalarFunction f,
Vector x) |
| Constructor and Description |
|---|
LocalSearchCell(RealScalarFunction f,
Vector x) |
| Modifier and Type | Field and Description |
|---|---|
protected Vector[] |
SimpleGridMinimizer.Solution.initials |
protected Vector |
SimpleGridMinimizer.Solution.xmin |
| Modifier and Type | Method and Description |
|---|---|
Vector |
SimpleGridMinimizer.Solution.search(Vector... initials) |
| Modifier and Type | Method and Description |
|---|---|
IterativeSolution<Vector> |
SimpleGridMinimizer.solve(OptimProblem problem) |
| Modifier and Type | Method and Description |
|---|---|
SimpleCellFactory.SimpleCell |
SimpleCellFactory.getSimpleCell(RealScalarFunction f,
Vector x)
Construct an instance of a
SimpleCell. |
Vector |
SimpleGridMinimizer.Solution.search(Vector... initials) |
void |
SimpleGridMinimizer.Solution.setInitials(Vector... initials) |
| Constructor and Description |
|---|
RealScalarFunctionChromosome(RealScalarFunction f,
Vector x)
Construct an instance of
RealScalarFunctionChromosome. |
SimpleCell(RealScalarFunction f,
Vector x) |
| Constructor and Description |
|---|
PerturbationAroundPoint(RealScalarFunction f,
SimpleCellFactory factory,
int poolSize,
Vector var,
Vector initial0,
long seed)
Generate an initial pool of chromosomes by adding a variance around a given initial.
|
UniformMeshOverRegion(RealScalarFunction f,
SimpleCellFactory factory,
RandomLongGenerator uniform,
int minDiscretization,
Vector[] initials0,
double epsilon)
Generate an initial pool of chromosomes by putting a uniform mesh/grid/net over the entire
region.
|
| Modifier and Type | Method and Description |
|---|---|
Vector[] |
UniformDistributionOverBox2.getInitials()
Generate a set of initial points for optimization.
|
Vector[] |
UniformDistributionOverBox1.getInitials()
Generate a set of initial points for optimization.
|
Vector[] |
DefaultSimplex.getInitials(Vector... initials)
Build a simplex of N+1 vertices from an initial point, where N is the dimension of the initial points.
|
Vector[] |
InitialsFactory.getInitials(Vector... initials)
Generate a set of initial points for optimization from the fewer than required points.
|
Vector[] |
UniformDistributionOverBox2.getInitials(Vector... notused) |
Vector[] |
UniformDistributionOverBox1.getInitials(Vector... notused) |
| Modifier and Type | Method and Description |
|---|---|
Vector[] |
DefaultSimplex.getInitials(Vector... initials)
Build a simplex of N+1 vertices from an initial point, where N is the dimension of the initial points.
|
Vector[] |
InitialsFactory.getInitials(Vector... initials)
Generate a set of initial points for optimization from the fewer than required points.
|
Vector[] |
UniformDistributionOverBox2.getInitials(Vector... notused) |
Vector[] |
UniformDistributionOverBox1.getInitials(Vector... notused) |
| Modifier and Type | Method and Description |
|---|---|
IterativeSolution<Vector> |
LeastPth.solve(MinMaxProblem<T> problem) |
| Modifier and Type | Interface and Description |
|---|---|
interface |
MultivariateMinimizer<P extends OptimProblem,S extends MinimizationSolution<Vector>>
This is a minimizer that minimizes a multivariate function or a
Vector function.
|
| Modifier and Type | Method and Description |
|---|---|
Vector |
BruteForceMinimizer.Solution.minimizer() |
| Modifier and Type | Method and Description |
|---|---|
void |
BruteForceMinimizer.Solution.setDomain(List<Vector> domain)
Gives the domain values for the brute force search to try.
|
BruteForceMinimizer.Solution |
BruteForceMinimizer.solve(Function<Vector,R> f) |
| Modifier and Type | Method and Description |
|---|---|
IterativeSolution<Vector> |
SimulatedAnnealingMinimizer.solve(OptimProblem problem) |
| Modifier and Type | Method and Description |
|---|---|
double |
MetropolisAcceptanceProbabilityFunction.acceptanceProbability(Vector currentState,
double currentEnergy,
Vector proposedState,
double proposedEnergy,
double temperature) |
double |
TemperedAcceptanceProbabilityFunction.acceptanceProbability(Vector currentState,
double energyCurrent,
Vector proposedState,
double energyProposed,
double temperature)
Computes the probability that the next state transition will be accepted.
|
double |
GSAAcceptanceProbabilityFunction.acceptanceProbability(Vector currentState,
double currentEnergy,
Vector proposedState,
double proposedEnergy,
double temperature) |
double |
BoxGSAAcceptanceProbabilityFunction.acceptanceProbability(Vector currentState,
double currentEnergy,
Vector proposedState,
double proposedEnergy,
double temperature) |
| Constructor and Description |
|---|
BoxGSAAcceptanceProbabilityFunction(Vector lower,
Vector upper,
double qa)
Constructs a boxed acceptance probability function.
|
| Modifier and Type | Method and Description |
|---|---|
Vector |
AnnealingFunction.nextProposal(Vector currentState,
double temperature)
Gets the next proposal, given the current state and the temperature.
|
Vector |
GSAAnnealingFunction.nextProposal(Vector currentState,
double temperature) |
Vector |
SimpleAnnealingFunction.nextProposal(Vector x0,
double temperature) |
Vector |
BoxGSAAnnealingFunction.nextProposal(Vector currentState,
double temperature) |
| Modifier and Type | Method and Description |
|---|---|
Vector |
AnnealingFunction.nextProposal(Vector currentState,
double temperature)
Gets the next proposal, given the current state and the temperature.
|
Vector |
GSAAnnealingFunction.nextProposal(Vector currentState,
double temperature) |
Vector |
SimpleAnnealingFunction.nextProposal(Vector x0,
double temperature) |
Vector |
BoxGSAAnnealingFunction.nextProposal(Vector currentState,
double temperature) |
| Constructor and Description |
|---|
BoxGSAAnnealingFunction(Vector lower,
Vector upper,
double qv,
RandomLongGenerator uniform)
Constructs a boxed annealing function.
|
| Modifier and Type | Method and Description |
|---|---|
Vector |
NelderMeadMinimizer.Solution.search(Vector... simplex)
Perform a Nelder-Mead search from an initial simplex.
|
| Modifier and Type | Method and Description |
|---|---|
Vector |
NelderMeadMinimizer.Solution.search(Vector... simplex)
Perform a Nelder-Mead search from an initial simplex.
|
void |
NelderMeadMinimizer.Solution.setInitials(Vector... simplex) |
| Modifier and Type | Method and Description |
|---|---|
Vector |
ZangwillMinimizer.ZangwillImpl.getDirection(Vector xk) |
Vector |
PowellMinimizer.PowellImpl.getDirection(Vector xk) |
| Modifier and Type | Method and Description |
|---|---|
IterativeSolution<Vector> |
ZangwillMinimizer.solve(C2OptimProblem problem) |
IterativeSolution<Vector> |
FletcherReevesMinimizer.solve(C2OptimProblem problem) |
IterativeSolution<Vector> |
PowellMinimizer.solve(C2OptimProblem problem) |
IterativeSolution<Vector> |
ConjugateGradientMinimizer.solve(C2OptimProblem problem) |
| Modifier and Type | Method and Description |
|---|---|
Vector |
ZangwillMinimizer.ZangwillImpl.getDirection(Vector xk) |
Vector |
PowellMinimizer.PowellImpl.getDirection(Vector xk) |
double |
ZangwillMinimizer.ZangwillImpl.getIncrement(Vector xk,
Vector dk) |
double |
PowellMinimizer.PowellImpl.getIncrement(Vector xk,
Vector dk) |
| Modifier and Type | Method and Description |
|---|---|
double |
LineSearch.Solution.linesearch(Vector x,
Vector d)
Get the increment α so that f(x + α * d) is (approximately) minimized.
|
| Modifier and Type | Field and Description |
|---|---|
protected Vector |
QuasiNewtonMinimizer.QuasiNewtonImpl.dk
the line search direction at the k-th iteration
|
protected Vector |
QuasiNewtonMinimizer.QuasiNewtonImpl.gk
the gradient at the k-th iteration
|
| Modifier and Type | Method and Description |
|---|---|
Vector |
QuasiNewtonMinimizer.QuasiNewtonImpl.getDirection(Vector xk) |
| Modifier and Type | Method and Description |
|---|---|
IterativeSolution<Vector> |
HuangMinimizer.solve(C2OptimProblem problem) |
IterativeSolution<Vector> |
BFGSMinimizer.solve(C2OptimProblem problem) |
| Modifier and Type | Method and Description |
|---|---|
static Matrix |
BFGSMinimizer.dampedBFGSHessianUpdate(Matrix H,
Vector gamma,
Vector delta)
Damped BFGS Hessian update.
|
Vector |
QuasiNewtonMinimizer.QuasiNewtonImpl.getDirection(Vector xk) |
double |
QuasiNewtonMinimizer.QuasiNewtonImpl.getIncrement(Vector xk,
Vector dk) |
| Modifier and Type | Method and Description |
|---|---|
protected abstract Vector |
SteepestDescentMinimizer.SteepestDescentImpl.getDirection(Vector xk)
Get the next search direction.
|
Vector |
NewtonRaphsonMinimizer.NewtonRaphsonImpl.getDirection(Vector xk) |
Vector |
GaussNewtonMinimizer.MySteepestDescent.GaussNewtonImpl.getDirection(Vector xk) |
Vector |
SteepestDescentMinimizer.SteepestDescentImpl.search(Vector... initials) |
Vector |
SteepestDescentMinimizer.SteepestDescentImpl.step() |
| Modifier and Type | Method and Description |
|---|---|
abstract IterativeSolution<Vector> |
SteepestDescentMinimizer.solve(C2OptimProblem problem)
Solve a minimization problem with a C2 objective function.
|
IterativeSolution<Vector> |
NewtonRaphsonMinimizer.solve(C2OptimProblem problem) |
IterativeSolution<Vector> |
FirstOrderMinimizer.solve(C2OptimProblem problem) |
IterativeSolution<Vector> |
GaussNewtonMinimizer.MySteepestDescent.solve(C2OptimProblem problem) |
IterativeSolution<Vector> |
GaussNewtonMinimizer.solve(RealVectorFunction vf)
Solve the minimization problem to minimize F = vf' * vf.
|
IterativeSolution<Vector> |
GaussNewtonMinimizer.solve(RealVectorFunction vf,
RntoMatrix J)
Solve the minimization problem to minimize F = vf' * vf.
|
| Modifier and Type | Method and Description |
|---|---|
protected abstract Vector |
SteepestDescentMinimizer.SteepestDescentImpl.getDirection(Vector xk)
Get the next search direction.
|
Vector |
NewtonRaphsonMinimizer.NewtonRaphsonImpl.getDirection(Vector xk) |
Vector |
GaussNewtonMinimizer.MySteepestDescent.GaussNewtonImpl.getDirection(Vector xk) |
protected double |
SteepestDescentMinimizer.SteepestDescentImpl.getIncrement(Vector xk,
Vector dk)
Get the increment fraction, \(\alpha _{k}\).
|
Vector |
SteepestDescentMinimizer.SteepestDescentImpl.search(Vector... initials) |
void |
SteepestDescentMinimizer.SteepestDescentImpl.setInitials(Vector... initials) |
| Modifier and Type | Method and Description |
|---|---|
Vector |
CointegrationMLE.beta(int r)
Get the r-th cointegrating factor, counting from 1.
|
Vector |
CointegrationMLE.getEigenvalues()
Get the set of real eigenvalues.
|
Vector |
JohansenTest.getStats(CointegrationMLE coint)
Get the set of likelihood ratio test statistics for testing H(r)
in H(r+1).
|
| Modifier and Type | Method and Description |
|---|---|
Vector |
TauEstimator.estimatedPopulationEigenvalues(Vector initials)
Estimates population eigenvalues from given sample eigenvalues.
|
Vector |
LedoitWolf2016.Result.lambda()
Gets sample eigenvalues.
|
Vector |
LedoitWolf2016.Result.linshrink_tau()
Gets linear shrinkage tau in ascending order.
|
Vector |
LedoitWolf2016.Result.nlshrink_tau()
Gets nonlinear shrinkage tau in ascending order.
|
Vector |
NonlinearShrinkageEstimator.nonlinearShrunkEigenvalues()
Gets the nonlinear shrinkage eigenvalues in ascending order.
|
Vector |
LedoitWolf2016.Result.tau()
Gets estimated population eigenvalues in ascending order.
|
| Modifier and Type | Method and Description |
|---|---|
Vector |
TauEstimator.estimatedPopulationEigenvalues(Vector initials)
Estimates population eigenvalues from given sample eigenvalues.
|
| Constructor and Description |
|---|
NonlinearShrinkageEstimator(Vector tau,
int n) |
TauEstimator(int p,
int n,
Vector sample_lambdas) |
TauEstimator(int p,
int n,
Vector sample_lambdas,
int max_optimizer_iterations,
double epsilon) |
| Modifier and Type | Field and Description |
|---|---|
Vector |
QuEST.Result.estimated_lambda
estimated lambda
|
Vector |
QuEST.Result.pw
number of each distinct eigenvalues
|
Vector |
QuEST.Result.t
distinct population eigenvalues
|
Vector |
QuEST.Result.tau
population eigenvalues in ascending order
|
| Constructor and Description |
|---|
QuEST(Vector tau,
int n) |
QuEST(Vector tau,
int n,
double tol,
double left_tol) |
| Modifier and Type | Method and Description |
|---|---|
Vector |
CorrelationMatrix.stdev()
Gets the standard deviations of the elements.
|
Vector |
CorrelationMatrix.var()
Gets the variance of the elements.
|
| Modifier and Type | Method and Description |
|---|---|
Vector |
MultivariateNormalDistribution.mean() |
Vector |
MultivariateProbabilityDistribution.mean()
Gets the mean of this distribution.
|
Vector |
MultivariateTDistribution.mean() |
Vector |
DirichletDistribution.mean() |
Vector |
MultinomialDistribution.mean() |
Vector |
MultivariateNormalDistribution.mode() |
Vector |
MultivariateProbabilityDistribution.mode()
Gets the mode of this distribution.
|
Vector |
MultivariateTDistribution.mode() |
Vector |
DirichletDistribution.mode() |
Vector |
MultinomialDistribution.mode() |
| Modifier and Type | Method and Description |
|---|---|
double |
AbstractBivariateProbabilityDistribution.cdf(Vector x) |
double |
MultivariateNormalDistribution.cdf(Vector x) |
double |
MultivariateProbabilityDistribution.cdf(Vector x)
Gets the cumulative probability F(x) = Pr(X ≤ x).
|
double |
MultivariateTDistribution.cdf(Vector x) |
double |
DirichletDistribution.cdf(Vector x) |
double |
MultinomialDistribution.cdf(Vector x) |
double |
AbstractBivariateProbabilityDistribution.density(Vector x) |
double |
MultivariateNormalDistribution.density(Vector x) |
double |
MultivariateProbabilityDistribution.density(Vector x)
The density function, which, if exists, is the derivative of F.
|
double |
MultivariateTDistribution.density(Vector x) |
double |
DirichletDistribution.density(Vector x) |
double |
MultinomialDistribution.density(Vector x) |
double |
MultivariateNormalDistribution.moment(Vector t) |
double |
MultivariateProbabilityDistribution.moment(Vector t)
The moment generating function is the expected value of \(e^{tX}\).
|
double |
MultivariateTDistribution.moment(Vector t) |
double |
DirichletDistribution.moment(Vector t) |
double |
MultinomialDistribution.moment(Vector t) |
| Constructor and Description |
|---|
MultivariateNormalDistribution(Vector mu,
Matrix Sigma)
Constructs an instance with the given mean and covariance matrix.
|
MultivariateTDistribution(int v,
Vector mu,
Matrix Sigma)
Constructs an instance with the given mean and scale matrix.
|
| Modifier and Type | Method and Description |
|---|---|
MultivariateProbabilityDistribution |
MultivariateExponentialFamily.getDistribution(Vector theta)
Construct a probability distribution in the exponential family.
|
| Modifier and Type | Method and Description |
|---|---|
ProbabilityDistribution |
ExponentialFamily.getDistribution(Vector theta)
Construct a probability distribution in the exponential family.
|
| Modifier and Type | Method and Description |
|---|---|
Vector |
MultivariateStateEquation.xt_mean(int t,
Vector xt_1)
Predicts the next state without control variable.
\[
E(x_t) = G_t \cdot x_\{t - 1\} + H_t \cdot u_t
\]
|
Vector |
MultivariateStateEquation.xt_mean(int t,
Vector xt_1,
Vector ut)
Predicts the next state.
\[
E(x_t) = G_t \cdot x_\{t - 1\} + H_t \cdot u_t
\]
|
| Modifier and Type | Method and Description |
|---|---|
MultivariateDLMSim.Innovation |
MultivariateDLMSim.next(Vector u)
Gets the next innovation.
|
Vector |
MultivariateStateEquation.xt_mean(int t,
Vector xt_1)
Predicts the next state without control variable.
\[
E(x_t) = G_t \cdot x_\{t - 1\} + H_t \cdot u_t
\]
|
Vector |
MultivariateStateEquation.xt_mean(int t,
Vector xt_1,
Vector ut)
Predicts the next state.
\[
E(x_t) = G_t \cdot x_\{t - 1\} + H_t \cdot u_t
\]
|
ImmutableVector |
MultivariateStateEquation.xt(int t,
Vector xt_1)
Evaluates the state equation without the control variable.
\[
x_t = G_t \cdot x_\{t - 1\} + H_t \cdot u_t + w_t
\]
|
ImmutableVector |
MultivariateStateEquation.xt(int t,
Vector xt_1,
Vector ut)
Evaluates the state equation.
\[
x_t = G_t \cdot x_\{t - 1\} + H_t \cdot u_t + w_t
\]
|
ImmutableVector |
MultivariateObservationEquation.yt_mean(int t,
Vector xt)
Predicts the next observation.
\[
E(y_t) = F_t \cdot x_t
\]
|
ImmutableVector |
MultivariateObservationEquation.yt(int t,
Vector xt)
Evaluates the observation equation.
\[
y_t = F_t \cdot x_t + v_t
\]
|
| Constructor and Description |
|---|
MultivariateDLM(Vector m0,
Matrix C0,
MultivariateObservationEquation Yt,
MultivariateStateEquation Xt)
Construct a (multivariate) controlled dynamic linear model.
|
| Modifier and Type | Method and Description |
|---|---|
Vector |
AbstractBivariateEVD.mean() |
Vector |
AbstractBivariateEVD.mode() |
| Modifier and Type | Method and Description |
|---|---|
double |
AbstractBivariateEVD.moment(Vector t) |
| Modifier and Type | Method and Description |
|---|---|
Vector |
ConfidenceInterval.getLower()
Get the lower bounds of the confidence intervals.
|
Vector |
ConfidenceInterval.getMean()
Get the mean values.
|
Vector |
ConfidenceInterval.getUpper()
Get the upper bounds of the confidence intervals.
|
Vector |
EstimateByLogLikelihood.standardError()
Get the standard errors of the fitted parameters.
|
| Constructor and Description |
|---|
ConfidenceInterval(double confidenceLevel,
Vector mean,
Vector lower,
Vector upper)
Create an instance with the confidence interval information.
|
EstimateByLogLikelihood(Vector fittedParameters,
RealScalarFunction logLikelihoodFunction) |
| Modifier and Type | Method and Description |
|---|---|
FAEstimator |
FactorAnalysis.getEstimators(Vector initial,
int maxIterations)
Gets the estimators (estimated psi, loading matrix, degree of freedom,
test statistics, p-value, etc) obtained from the factor analysis, given
the initial psi and the maximum number of iterations.
|
| Modifier and Type | Method and Description |
|---|---|
Vector |
ImplicitModelPCA.Result.b(int n)
Gets the factor loading for the n-th subject.
|
Vector |
ExplicitImplicitModelPCA.Result.b(int n)
Gets the implicit factor loading for the n-th subject.
|
Vector |
ImplicitModelPCA.Result.e_t(int t)
Gets the residual of all subject at time t.
|
Vector |
ExplicitImplicitModelPCA.Result.e_t(int t)
Gets the residual of all subject at time t.
|
Vector |
ImplicitModelPCA.Result.f(int t)
Gets the factor values at time t.
|
Vector |
ExplicitImplicitModelPCA.Result.f(int t)
Gets the implicit factor values at time t.
|
Vector |
ImplicitModelPCA.Result.R_bar()
Gets R_bar, the average of observations over time per subject.
|
Vector |
ExplicitImplicitModelPCA.Result.R_bar()
Gets R_bar, the average of observations over time per subject.
|
| Modifier and Type | Method and Description |
|---|---|
Vector |
PCA.cumulativeProportionVar()
Gets the cumulative proportion of overall variance explained by the
principal components
|
Vector |
PCA.loading(int i)
Gets the loading vector of the i-th principal component.
|
Vector |
PCAbyEigen.loading(int i) |
Vector |
PCAbySVD.mean() |
Vector |
PCA.mean()
Gets the sample means that were subtracted.
|
Vector |
PCA.proportionVar()
Gets the proportion of overall variance explained by each of the
principal components.
|
Vector |
PCAbyEigen.proportionVar() |
Vector |
PCAbySVD.scale() |
Vector |
PCA.scale()
Gets the scalings applied to each variable.
|
Vector |
PCAbyEigen.scale()
Gets the scalings applied to each variable.
|
Vector |
PCA.sdPrincipalComponents()
Gets the standard deviations of the principal components (i.e., the
square roots of the eigenvalues of the correlation (or covariance)
matrix).
|
Vector |
PCAbyEigen.sdPrincipalComponents()
Gets the standard deviations of the principal components (i.e., the
square roots of the eigenvalues of the correlation (or covariance)
matrix).
|
| Constructor and Description |
|---|
PCAbySVD(Matrix data,
Vector mean,
Vector scale)
Performs Principal Component Analysis, using the preferred SVD method, on
a data matrix with (optional) mean vector and scaling vector provided.
|
| Modifier and Type | Method and Description |
|---|---|
Vector |
ForwardBackwardProcedure.scaledAlpha(int t)
Gets the scaled forward probabilities at time t.
|
Vector |
ForwardBackwardProcedure.scaledBeta(int t)
Gets the scaled backward probabilities at time t.
|
| Constructor and Description |
|---|
HiddenMarkovModel(Vector PI,
Matrix A,
RandomNumberGenerator[] B) |
HMMRNG(Vector PI,
Matrix A,
RandomNumberGenerator[] B)
Constructs a hidden Markov model.
|
| Modifier and Type | Method and Description |
|---|---|
static Vector[] |
BaumWelch.gamma(HiddenMarkovModel model,
int[] observations,
Matrix[] xi)
Gets the (T-1 * N) γ matrix, where the (t, i)-th
entry is \(\gamma _{t}(i)\).
|
| Constructor and Description |
|---|
DiscreteHMM(Vector PI,
Matrix A,
Matrix B)
Constructs a discrete hidden Markov model.
|
| Constructor and Description |
|---|
MixtureHMM(Vector PI,
Matrix A,
MixtureDistribution dist)
Constructs a mixture hidden Markov model.
|
| Modifier and Type | Method and Description |
|---|---|
Double[] |
PoissonMixtureDistribution.getMStepParams(double[] observations,
Vector[] u) |
Object[] |
MixtureDistribution.getMStepParams(double[] observations,
Vector[] u)
Maximize, for each state, the log-likelihood of the distribution with
respect to the observations and current estimators.
|
BetaMixtureDistribution.Lambda[] |
BetaMixtureDistribution.getMStepParams(double[] observations,
Vector[] u) |
Double[] |
ExponentialMixtureDistribution.getMStepParams(double[] observations,
Vector[] u) |
BinomialMixtureDistribution.Lambda[] |
BinomialMixtureDistribution.getMStepParams(double[] observations,
Vector[] u) |
LogNormalMixtureDistribution.Lambda[] |
LogNormalMixtureDistribution.getMStepParams(double[] observations,
Vector[] u) |
GammaMixtureDistribution.Lambda[] |
GammaMixtureDistribution.getMStepParams(double[] observations,
Vector[] u) |
NormalMixtureDistribution.Lambda[] |
NormalMixtureDistribution.getMStepParams(double[] observations,
Vector[] u) |
| Modifier and Type | Method and Description |
|---|---|
static Vector |
MCUtils.getStateCounts(int[] states)
Count the numbers of occurrences of states.
|
static Vector |
SimpleMC.getStationaryProbabilities(Matrix A)
Gets the stationary state probabilities of a Markov chain that is irreducible, aperiodic and
strongly connected (positive recurrent).
|
| Constructor and Description |
|---|
SimpleMC(Vector PI,
Matrix A)
Constructs a time-homogeneous Markov chain with a finite state space.
|
| Constructor and Description |
|---|
NormalRVG(Vector mu,
Matrix sigma)
Constructs a multivariate Normal random vector generator.
|
NormalRVG(Vector mu,
Matrix sigma,
double epsilon,
RandomStandardNormalGenerator rnorm)
Constructs a multivariate Normal random vector generator.
|
NormalRVG(Vector mu,
Matrix sigma,
RandomStandardNormalGenerator rnorm)
Constructs a multivariate Normal random vector generator.
|
| Modifier and Type | Method and Description |
|---|---|
protected Vector |
HybridMCMC.nextProposedState(Vector currentState) |
protected Vector |
MultipointHybridMCMC.nextProposedState(Vector currentState) |
Vector |
LeapFrogging.p()
Gets the current momentum.
|
Vector |
LeapFrogging.DynamicsState.p()
Gets the momentum.
|
Vector |
LeapFrogging.x()
Gets the current position.
|
Vector |
LeapFrogging.DynamicsState.x()
Gets the position.
|
| Modifier and Type | Method and Description |
|---|---|
static double |
AbstractHybridMCMC.H(LeapFrogging.DynamicsState state,
RealScalarFunction logF,
Vector m)
Evaluates a system's total energy at a given state.
|
protected boolean |
HybridMCMC.isProposalAccepted(Vector currentState,
Vector proposedState) |
protected boolean |
MultipointHybridMCMC.isProposalAccepted(Vector currentState,
Vector proposedState) |
static double |
AbstractHybridMCMC.k(Vector p,
Vector m)
Evaluates the standard kinetic energy, k = p^2 / 2m.
|
protected Vector |
HybridMCMC.nextProposedState(Vector currentState) |
protected Vector |
MultipointHybridMCMC.nextProposedState(Vector currentState) |
| Constructor and Description |
|---|
AbstractHybridMCMC(Vector initialState,
RandomNumberGenerator rng)
Constructs a new instance with the given parameters.
|
DynamicsState(Vector x,
Vector p)
Constructs a new instance with the given position and momentum.
|
HybridMCMC(RealScalarFunction logF,
RealVectorFunction dLogF,
Vector m,
double dt,
int L,
Vector initialState,
RandomLongGenerator rlg)
Constructs a new instance with the given parameters.
|
LeapFrogging(RealVectorFunction dU,
Vector m,
Vector x,
Vector p,
double dt)
Constructs a new instance with the given parameters.
|
MultipointHybridMCMC(RealScalarFunction logF,
RealVectorFunction dLogF,
Vector m,
double dt,
int L,
int M,
Vector initialState,
RandomLongGenerator uniform)
Constructs a new instance with equal weights to the M configurations.
|
MultipointHybridMCMC(RealScalarFunction logF,
RealVectorFunction dLogF,
Vector m,
double dt,
int L,
int M,
Vector w,
Vector initialState,
RandomLongGenerator uniform)
Constructs a new instance with the given parameters.
|
| Modifier and Type | Method and Description |
|---|---|
protected Vector |
RobustAdaptiveMetropolis.nextProposedState(Vector currentState) |
protected Vector |
Metropolis.nextProposedState(Vector currentState) |
protected abstract Vector |
AbstractMetropolis.nextProposedState(Vector currentState)
Proposes a next state for the system.
|
protected Vector |
MetropolisHastings.nextProposedState(Vector currentState) |
| Modifier and Type | Method and Description |
|---|---|
double |
MetropolisHastings.ProposalDensityFunction.evaluate(Vector x,
Vector y)
Evaluates the density at the given points.
|
static boolean |
MetropolisUtils.isProposalAccepted(RealScalarFunction logf,
RandomLongGenerator uniform,
Vector currentState,
Vector proposedState)
Uses the given LOG density function to determine whether the given state transition should be
accepted.
|
protected boolean |
RobustAdaptiveMetropolis.isProposalAccepted(Vector currentState,
Vector proposedState) |
protected boolean |
Metropolis.isProposalAccepted(Vector currentState,
Vector proposedState) |
protected abstract boolean |
AbstractMetropolis.isProposalAccepted(Vector currentState,
Vector proposedState)
Decides whether the given proposed state should be accepted, or whether the system should
remain in it's current state.
|
protected boolean |
MetropolisHastings.isProposalAccepted(Vector x,
Vector y) |
static double |
MetropolisUtils.logAcceptanceRatio(RealScalarFunction logf,
Vector currentState,
Vector proposedState)
Computes the log of the acceptance ratio.
|
protected Vector |
RobustAdaptiveMetropolis.nextProposedState(Vector currentState) |
protected Vector |
Metropolis.nextProposedState(Vector currentState) |
protected abstract Vector |
AbstractMetropolis.nextProposedState(Vector currentState)
Proposes a next state for the system.
|
protected Vector |
MetropolisHastings.nextProposedState(Vector currentState) |
| Constructor and Description |
|---|
AbstractMetropolis(Vector initialState,
RandomNumberGenerator rng)
Constructs a new instance with the given parameters.
|
Metropolis(RealScalarFunction logf,
RealVectorFunction proposalFunction,
Vector initialState,
RandomLongGenerator uniform)
Constructs a new instance with the given parameters.
|
Metropolis(RealScalarFunction logf,
Vector initialState,
double sigma,
RandomLongGenerator uniform)
Constructs a new instance, which draws the offset of the next proposed state from the
previous state from a standard Normal distribution, with the given variance and zero
covariance.
|
Metropolis(RealScalarFunction logf,
Vector initialState,
Matrix scale,
RandomLongGenerator uniform)
Constructs a new instance, which draws the offset of the next proposed state from the
previous state from a standard Normal distribution, multiplied by the given scale matrix.
|
MetropolisHastings(RealScalarFunction logf,
ProposalFunction proposalFunction,
MetropolisHastings.ProposalDensityFunction proposalDensity,
Vector initialState,
RandomNumberGenerator rng)
Constructs a new instance with the given parameters.
|
RobustAdaptiveMetropolis(RealScalarFunction logf,
double targetAcceptance,
Vector initialState,
RandomLongGenerator uniform)
Constructs an instance which assumes an initial variance of 1 per variable, uses a gamma of
0.5.
|
RobustAdaptiveMetropolis(RealScalarFunction logf,
Matrix initialScale,
double gamma,
double targetAcceptance,
Vector initialState,
RandomStandardNormalGenerator rnorm,
RandomLongGenerator uniform)
Constructs a new instance with the given parameters.
|
| Modifier and Type | Method and Description |
|---|---|
Vector |
HybridMCMCProposalFunction.evaluate(Vector x) |
Vector |
GaussianProposalFunction.evaluate(Vector x) |
| Modifier and Type | Method and Description |
|---|---|
Vector |
HybridMCMCProposalFunction.evaluate(Vector x) |
Vector |
GaussianProposalFunction.evaluate(Vector x) |
| Constructor and Description |
|---|
HybridMCMCProposalFunction(Vector m,
RandomLongGenerator uniform)
Constructs a hybrid MC proposal function.
|
| Modifier and Type | Method and Description |
|---|---|
double |
LinearModel.Ey(Vector x)
Computes the expectation \(E(y(x))\) given an input.
|
| Constructor and Description |
|---|
LMBeta(Vector betaHat)
Constructs an instance of
Beta. |
LMProblem(Vector y,
Matrix X)
Constructs a linear regression problem, assuming
a constant term (the intercept)
equal weights assigned to all observations
|
LMProblem(Vector y,
Matrix X,
boolean intercept)
Constructs a linear regression problem, assuming equal weights to all observations.
|
LMProblem(Vector y,
Matrix X,
boolean intercept,
Vector weights)
Constructs a linear regression problem.
|
LMProblem(Vector y,
Matrix X,
Vector weights)
Constructs a linear regression problem, assuming a constant term (the intercept).
|
| Modifier and Type | Method and Description |
|---|---|
double |
GeneralizedLinearModel.Ey(Vector x) |
void |
GLMFitting.fit(GLMProblem problem,
Vector beta0Initial)
Fits a Generalized Linear Model.
|
void |
IWLS.fit(GLMProblem probelm,
Vector beta0Initial) |
| Constructor and Description |
|---|
GLMProblem(Vector y,
Matrix X,
boolean intercept,
GLMFamily family)
Construct a GLM problem.
|
GLMResiduals(GLMProblem problem,
Vector fitted)
Performs residual analysis for a GLM regression.
|
| Modifier and Type | Method and Description |
|---|---|
double |
GLMGamma.AIC(Vector y,
Vector mu,
Vector weight,
double prelogLike,
double deviance,
int nFactors) |
double |
GLMGaussian.AIC(Vector y,
Vector mu,
Vector weight,
double preLogLike,
double deviance,
int nFactors) |
double |
GLMBinomial.AIC(Vector y,
Vector mu,
Vector weight,
double prelogLike,
double deviance,
int nFactors) |
double |
GLMExponentialDistribution.AIC(Vector y,
Vector mu,
Vector weight,
double preLogLike,
double deviance,
int nFactors)
AIC = 2 * #param - 2 * log-likelihood
|
double |
GLMInverseGaussian.AIC(Vector y,
Vector mu,
Vector weight,
double prelogLike,
double deviance,
int nFactors) |
double |
GLMPoisson.AIC(Vector y,
Vector mu,
Vector weight,
double preLogLike,
double deviance,
int nFactors) |
double |
GLMGamma.dispersion(Vector y,
Vector mu,
int nFactors) |
double |
GLMGaussian.dispersion(Vector y,
Vector mu,
int nFactors) |
double |
GLMBinomial.dispersion(Vector y,
Vector mu,
int nFactors) |
double |
GLMExponentialDistribution.dispersion(Vector y,
Vector mu,
int nFactors)
Different distribution models have different ways to compute dispersion, Φ.
|
double |
GLMInverseGaussian.dispersion(Vector y,
Vector mu,
int nFactors) |
double |
GLMPoisson.dispersion(Vector y,
Vector mu,
int nFactors) |
double |
GLMGamma.overdispersion(Vector y,
Vector mu,
int nFactors) |
double |
GLMGaussian.overdispersion(Vector y,
Vector mu,
int nFactors) |
double |
GLMBinomial.overdispersion(Vector y,
Vector mu,
int nFactors) |
double |
GLMExponentialDistribution.overdispersion(Vector y,
Vector mu,
int nFactors)
Over-dispersion is the presence of greater variability (statistical dispersion)
in a data set than would be expected based on the nominal variance of a given simple statistical model.
|
double |
GLMInverseGaussian.overdispersion(Vector y,
Vector mu,
int nFactors) |
double |
GLMPoisson.overdispersion(Vector y,
Vector mu,
int nFactors) |
| Modifier and Type | Method and Description |
|---|---|
double |
GeneralizedLinearModelQuasiFamily.Ey(Vector x) |
void |
QuasiGLMNewtonRaphson.fit(GLMProblem problem,
Vector beta0Initial) |
| Constructor and Description |
|---|
QuasiGLMProblem(Vector y,
Matrix X,
boolean intercept,
QuasiFamily quasiFamily)
Constructs a quasi GLM problem.
|
| Modifier and Type | Method and Description |
|---|---|
double |
ConstrainedLASSObyQP.Ey(Vector x) |
double |
UnconstrainedLASSObyCoordinateDescent.Ey(Vector x) |
double |
ConstrainedLASSObyLARS.Ey(Vector x) |
double |
UnconstrainedLASSObyQP.Ey(Vector x) |
| Constructor and Description |
|---|
ConstrainedLASSOProblem(Vector y,
Matrix X,
double t)
Constructs a LASSO problem in the constrained form.
|
UnconstrainedLASSOProblem(Vector y,
Matrix X,
double lambda)
Constructs a LASSO problem.
|
| Modifier and Type | Method and Description |
|---|---|
Vector |
LARSProblem.XL2Norm()
Gets the L2 norms of the covariates (a vector of ones if no
standardization is required).
|
Vector |
LARSProblem.XMean()
Gets the mean vector to be subtracted from the covariates (a vector of
zeros if no intercept is included).
|
Vector |
LARSProblem.yLARS()
Gets the vector of response variable (possibly demeaned) to be used in
LARS.
|
| Modifier and Type | Method and Description |
|---|---|
List<Vector> |
LARSFitting.Estimators.betas()
Gets the sequence of betas.
|
| Constructor and Description |
|---|
LARSProblem(Vector y,
Matrix X)
Constructs a LASSO variation of the Least Angel Regression (LARS)
problem, where an intercept is included in the model and the covariates
are normalized first.
|
LARSProblem(Vector y,
Matrix X,
boolean lasso)
Constructs a Least Angel Regression (LARS) problem, where an intercept is
included in the model and the covariates are normalized first.
|
LARSProblem(Vector y,
Matrix X,
boolean normalized,
boolean lasso)
Constructs a Least Angel Regression (LARS) problem, where an intercept is
included in the model.
|
LARSProblem(Vector y,
Matrix X,
boolean intercept,
boolean normalized,
boolean lasso)
Constructs a Least Angel Regression (LARS) problem.
|
| Modifier and Type | Method and Description |
|---|---|
double |
LogisticRegression.Ey(Vector x)
Calculates the probability of occurrence (y = 1).
|
| Constructor and Description |
|---|
LogisticBeta(Vector betaHat,
LogisticResiduals residuals)
Construct an instance of
Beta. |
| Modifier and Type | Method and Description |
|---|---|
double |
OLSRegression.Ey(Vector x)
Predicts the conditional response for one observation.
|
static double |
OLSRegression.Ey(Vector beta,
Vector x,
boolean intercept)
Predicts a response using explicitly supplied coefficients.
|
| Constructor and Description |
|---|
OLSBeta(Vector betaHat,
OLSResiduals residuals)
Constructs an instance of
Beta. |
OLSResiduals(LMProblem problem,
Vector betaHat)
Performs the residual analysis for an ordinary linear regression problem.
|
| Constructor and Description |
|---|
LMResiduals(LMProblem problem,
Vector fitted)
Performs residual analysis for a linear regression problem.
|
| Modifier and Type | Method and Description |
|---|---|
protected Vector |
MultivariateRandomProcess.dB(double dt)
Get a Brownian motion increment.
|
protected Vector |
MultivariateRandomProcess.Zt()
Get a d-dimensional Gaussian innovation.
|
| Constructor and Description |
|---|
MultivariateBrownianRRG(int d,
TimeGrid timePoints,
Vector initial)
Construct a random realization generator to produce multi-dimensional Brownian paths at time points specified.
|
MultivariateRandomRealizationOfRandomProcess(MultivariateDiscreteSDE sde,
TimeGrid timeGrid,
Vector x0)
Construct a random realization generator from a multivariate discrete SDE.
|
MultivariateRandomRealizationOfRandomProcess(MultivariateSDE sde,
TimeGrid timeGrid,
Vector x0)
Construct a random realization generator from a multivariate SDE.
|
MultivariateRandomWalk(MultivariateDiscreteSDE sde,
TimeGrid timeGrid,
Vector x0)
Construct a multivariate stochastic process from an SDE.
|
| Modifier and Type | Method and Description |
|---|---|
Vector |
MultivariateFt.dWt()
Get the increment of the driving Brownian motion during the time differential.
|
Vector |
FtAdaptedVectorFunction.evaluate(MultivariateFt ft)
Evaluate this function, f, at time t.
|
Vector |
MultivariateFtWt.Wt()
Get the current value(s) of the driving Brownian motion(s).
|
Vector |
MultivariateFt.Xt()
Get the current value of the stochastic process.
|
Vector |
MultivariateFt.Zt()
Get the current value of the Gaussian innovation.
|
| Modifier and Type | Method and Description |
|---|---|
void |
MultivariateFt.setXt(Vector Xt)
Set the current value of the stochastic process.
|
void |
MultivariateFt.setZt(Vector Zt)
Set the current value of the Gaussian innovation.
|
void |
MultivariateFtWt.setZt(Vector Zt) |
| Modifier and Type | Method and Description |
|---|---|
Vector |
ZeroDriftVector.evaluate(MultivariateFt ft) |
Vector |
ConstantDriftVector.evaluate(MultivariateFt ft) |
| Constructor and Description |
|---|
ConstantDriftVector(Vector mu)
Construct a constant drift function.
|
| Modifier and Type | Method and Description |
|---|---|
Vector |
MultivariateBrownianSDE.dXt(MultivariateFt ft) |
Vector |
MultivariateDiscreteSDE.dXt(MultivariateFt ft)
This is the SDE specification of a stochastic process.
|
Vector |
MultivariateEulerSDE.dXt(MultivariateFt ft)
This is the SDE specification of a stochastic process.
|
| Constructor and Description |
|---|
MultivariateBrownianSDE(Vector mu,
Matrix sigma)
Construct a multi-dimensional Brownian motion.
|
| Modifier and Type | Method and Description |
|---|---|
protected OLSRegression |
Heteroskedasticity.getAuxiliaryOLSRegression(Vector y,
LMResiduals residuals)
Get the auxiliary regression.
|
protected OLSRegression |
White.getAuxiliaryOLSRegression(Vector y,
LMResiduals residuals) |
| Modifier and Type | Method and Description |
|---|---|
Vector |
MultivariateGenericTimeTimeSeries.get(int i)
Get the i-th value.
|
Vector |
MultivariateTimeSeries.Entry.getValue() |
Vector[] |
MultivariateGenericTimeTimeSeries.toArray()
Convert this multivariate time series into an array of vectors.
|
| Constructor and Description |
|---|
Entry(T time,
Vector value)
Construct an instance of
TimeSeries.Entry. |
MultivariateGenericTimeTimeSeries(T[] timestamps,
Vector[] values)
Construct a multivariate time series from timestamps and vectors.
|
| Constructor and Description |
|---|
Entry(double time,
Vector value)
Construct an instance of
TimeSeries.Entry. |
| Modifier and Type | Method and Description |
|---|---|
Vector |
MultivariateIntTimeTimeSeries.get(int t)
Get the value at time
t (random access). |
Vector |
MultivariateSimpleTimeSeries.get(int t) |
| Constructor and Description |
|---|
Entry(int time,
Vector value)
Construct an instance of
Entry. |
MultivariateSimpleTimeSeries(Vector... values)
Construct an instance of
MultivariateSimpleTimeSeries. |
| Modifier and Type | Method and Description |
|---|---|
static Vector |
UnivariateTimeSeriesUtils.toVector(UnivariateTimeSeries<?,?> ts)
Cast a time series into a vector, discarding the timestamps.
|
| Constructor and Description |
|---|
VARIMAModel(Vector mu,
Matrix[] phi,
int d,
Matrix[] theta)
Construct a multivariate ARIMA model with unit variance.
|
VARIMAModel(Vector mu,
Matrix[] phi,
int d,
Matrix[] theta,
Matrix sigma)
Construct a multivariate ARIMA model.
|
VARIMASim(VARIMAModel arima,
Vector[] lags,
Vector[] innovations,
RandomVectorGenerator rvg)
Construct a multivariate ARIMA model.
|
VARIMASim(VARIMAModel arima,
Vector[] lags,
Vector[] innovations,
RandomVectorGenerator rvg)
Construct a multivariate ARIMA model.
|
VARIMAXModel(Vector mu,
Matrix[] phi,
int d,
Matrix[] theta,
Matrix psi)
Construct a multivariate ARIMAX model with unit variance.
|
VARIMAXModel(Vector mu,
Matrix[] phi,
int d,
Matrix[] theta,
Matrix psi,
Matrix sigma)
Construct a multivariate ARIMAX model.
|
| Modifier and Type | Method and Description |
|---|---|
Vector |
VARMAModel.conditionalMean(Matrix arLags,
Matrix maLags)
Compute the multivariate ARMA conditional mean, given all the lags.
|
Vector |
VARMAModel.unconditionalMean()
Compute the multivariate ARMA unconditional mean.
|
| Modifier and Type | Method and Description |
|---|---|
Matrix |
VARMAXModel.armaxMean(Matrix arLags,
Matrix maLags,
Vector exVar)
Compute the multivariate ARMAX conditional mean.
|
| Constructor and Description |
|---|
VARMAModel(Vector mu,
Matrix[] phi,
Matrix[] theta)
Construct a multivariate ARMA model with unit variance.
|
VARMAModel(Vector mu,
Matrix[] phi,
Matrix[] theta,
Matrix sigma)
Construct a multivariate ARMA model.
|
VARMAXModel(Vector mu,
Matrix[] phi,
Matrix[] theta,
Matrix psi)
Construct a multivariate ARMAX model with unit variance.
|
VARMAXModel(Vector mu,
Matrix[] phi,
Matrix[] theta,
Matrix psi,
Matrix sigma)
Construct a multivariate ARMAX model.
|
VARModel(Vector mu,
Matrix[] phi)
Construct a VAR model with unit variance.
|
VARModel(Vector mu,
Matrix[] phi,
Matrix sigma)
Construct a VAR model.
|
VARXModel(Vector mu,
Matrix[] phi,
Matrix psi)
Construct a VARX model with unit variance.
|
VARXModel(Vector mu,
Matrix[] phi,
Matrix psi,
Matrix sigma)
Construct a VARX model.
|
VECM(Vector mu,
Matrix pi,
Matrix[] gamma,
Matrix psi,
Matrix sigma)
Construct a VECM(p) model.
|
VECMLongrun(Vector mu,
Matrix pi,
Matrix[] gamma,
Matrix psi,
Matrix sigma)
Construct a long-run VECM(p) model.
|
VECMTransitory(Vector mu,
Matrix pi,
Matrix[] gamma,
Matrix psi,
Matrix sigma)
Construct a transitory VECM(p) model.
|
VMAModel(Vector mu,
Matrix[] theta)
Construct a multivariate MA model with unit variance.
|
VMAModel(Vector mu,
Matrix[] theta,
Matrix sigma)
Construct a multivariate MA model.
|
| Modifier and Type | Method and Description |
|---|---|
Vector |
ARIMAForecastMultiStep.allForecasts()
Gets all the predictions of the next h steps in one vector.
|
Vector |
ARIMAForecastMultiStep.allMSEs()
Gets all the mean squared errors (MSE) of the h-step ahead predictions.
|
| Modifier and Type | Method and Description |
|---|---|
Vector |
ARMAForecastMultiStep.allForecasts()
Gets all the predictions of the next h steps in one vector.
|
Vector |
ARMAForecastMultiStep.allMSEs()
Gets all the mean squared errors (MSE) of the h-step ahead predictions.
|
Vector |
ARMAFit.stderr()
Get the asymptotic standard errors of the estimators.
|
| Modifier and Type | Field and Description |
|---|---|
protected Vector |
TradingPair.price1 |
protected Vector |
TradingPair.price2 |
protected Vector |
TradingPair.spread |
| Modifier and Type | Method and Description |
|---|---|
Vector |
TradingPair.spread()
S = A - bB
|
| Modifier and Type | Method and Description |
|---|---|
TradingPair |
RobustCointegration.computeRobustPair(String symbol1,
String symbol2,
Vector price1,
Vector price2) |
static Matrix |
PairingModelUtils.getPriceMatrix(Vector p1,
Vector p2) |
| Constructor and Description |
|---|
TradingPair(String symbol1,
String symbol2,
Vector price1,
Vector price2,
double beta)
Constructs a related pair for trading, e.g., cointegrated pair.
|
| Modifier and Type | Method and Description |
|---|---|
Vector |
ExtremalGeneralizedEigenvalueBySDP.computeOptimalPositions(int card)
Computes the solution to the problem described in Section 3.2 in reference.
|
Vector |
ExtremalGeneralizedEigenvalueSolver.computeOptimalPositions(int card)
Computes the solution to the problem described in Section 3.2 in reference.
|
Vector |
ExtremalGeneralizedEigenvalueByGreedySearch.computeOptimalPositions(int card) |
Vector |
ExtremalGeneralizedEigenvalueByGreedySearch.getOptimalPositions(int minCard,
int maxCard) |
| Modifier and Type | Method and Description |
|---|---|
double |
ExtremalGeneralizedEigenvalueBySDP.getLambda(Vector x)
Computes the value of the objective function in eq. 10, reference [1].
|
| Modifier and Type | Method and Description |
|---|---|
default Vector |
PortfolioOptimizationAlgorithm.MeanEstimator.getMeans(Matrix returns,
PortfolioOptimizationAlgorithm.SymbolLookup symbolLookup,
LocalDateTimeInterval interval) |
Vector |
PortfolioOptimizationAlgorithm.SampleMeanEstimator.getMeans(Matrix returns,
PortfolioOptimizationAlgorithm.SymbolLookup symbolLookup,
LocalDateTimeInterval interval) |
Vector |
TopNOptimizationAlgorithm.getOptimalWeights(Matrix returns,
Vector weights0,
PortfolioOptimizationAlgorithm.SymbolLookup symbolLookup,
LocalDateTimeInterval interval) |
Vector |
Lai2010OptimizationAlgorithm.getOptimalWeights(Matrix returns,
Vector weights0,
PortfolioOptimizationAlgorithm.SymbolLookup symbolLookup,
LocalDateTimeInterval interval) |
Vector |
PortfolioOptimizationAlgorithm.getOptimalWeights(Matrix returns,
Vector weights0,
PortfolioOptimizationAlgorithm.SymbolLookup symbolLookup,
LocalDateTimeInterval interval)
Computes the optimal weights for the products using returns.
|
static Vector |
TopNOptimizationAlgorithm.getTopN(Vector w0,
int N,
double B) |
| Modifier and Type | Method and Description |
|---|---|
Vector |
TopNOptimizationAlgorithm.getOptimalWeights(Matrix returns,
Vector weights0,
PortfolioOptimizationAlgorithm.SymbolLookup symbolLookup,
LocalDateTimeInterval interval) |
Vector |
Lai2010OptimizationAlgorithm.getOptimalWeights(Matrix returns,
Vector weights0,
PortfolioOptimizationAlgorithm.SymbolLookup symbolLookup,
LocalDateTimeInterval interval) |
Vector |
PortfolioOptimizationAlgorithm.getOptimalWeights(Matrix returns,
Vector weights0,
PortfolioOptimizationAlgorithm.SymbolLookup symbolLookup,
LocalDateTimeInterval interval)
Computes the optimal weights for the products using returns.
|
static double |
PortfolioUtils.getPortfolioReturns(Vector weights,
Vector mu)
Computes the expected portfolio return.
|
static double |
PortfolioUtils.getPortfolioVariance(Vector weights,
Matrix sigma)
Computes the portfolio variance.
|
static double |
PortfolioUtils.getSharpeRatio(Vector weights,
Vector mu,
Matrix sigma,
double benchmarkRate)
Computes the portfolio Sharpe ratio.
|
static Vector |
TopNOptimizationAlgorithm.getTopN(Vector w0,
int N,
double B) |
| Modifier and Type | Method and Description |
|---|---|
Vector |
MarkowitzCriticalLine.getOptimalWeightForSetLambda(double lambda) |
Vector |
MCLNiedermayer.getOptimalWeightForSetLambda(double lambda) |
Vector |
MarkowitzCriticalLine.getOptimalWeightForTargetReturn(double target) |
Vector |
MCLNiedermayer.getOptimalWeightForTargetReturn(double target) |
Vector |
TurningPoint.weight() |
| Constructor and Description |
|---|
MCLNiedermayer(Vector gain,
Matrix covariance)
Creates the critical line for given gain vector and covariance matrix,
with non-negativity constraint.
|
MCLNiedermayer(Vector gain,
Matrix covariance,
Vector lower,
Vector upper)
Creates the critical line for given gain vector and covariance matrix,
with given lower and upper bounds for weights.
|
| Modifier and Type | Method and Description |
|---|---|
Vector |
Corvalan2005.getDiversifiedWeights(Corvalan2005.WeightsConstraint constraint,
Vector weights0,
Matrix sigma,
Vector r)
Finds the optimal weights for a diversified portfolio.
|
Vector |
Corvalan2005.getDiversifiedWeights(Corvalan2005.WeightsConstraint constraint,
Vector weights0,
Matrix sigma,
Vector r,
EqualityConstraints extraEqualityConstraints,
LessThanConstraints extraLessThanConstraints)
Finds the optimal weights for a diversified portfolio.
|
| Modifier and Type | Method and Description |
|---|---|
Vector |
Corvalan2005.getDiversifiedWeights(Corvalan2005.WeightsConstraint constraint,
Vector weights0,
Matrix sigma,
Vector r)
Finds the optimal weights for a diversified portfolio.
|
Vector |
Corvalan2005.getDiversifiedWeights(Corvalan2005.WeightsConstraint constraint,
Vector weights0,
Matrix sigma,
Vector r,
EqualityConstraints extraEqualityConstraints,
LessThanConstraints extraLessThanConstraints)
Finds the optimal weights for a diversified portfolio.
|
| Constructor and Description |
|---|
Corvalan2005(Minimizer<? super ConstrainedOptimProblem,IterativeSolution<Vector>> minimizer,
DiversificationMeasure diversificationMeasure,
double deltaSigma,
double deltaR)
Constructs an instance of the Corvalan model.
|
| Constructor and Description |
|---|
MinimumWeights(Vector minWeights) |
| Modifier and Type | Method and Description |
|---|---|
Vector |
Lai2010NPEBModel.OptimalWeights.weights() |
| Constructor and Description |
|---|
OptimalWeights(Vector weights,
Ceta.PortfolioMoments moments) |
| Modifier and Type | Field and Description |
|---|---|
Vector |
GARCHResamplerFactory2.initialReturns |
Vector |
GARCHResamplerFactory2.initialSigma2 |
| Modifier and Type | Field and Description |
|---|---|
protected Vector |
MVOptimizerMinWeights.w0 |
| Modifier and Type | Method and Description |
|---|---|
Vector |
MVOptimizerShrankMean.optimalWeights(Vector mu0,
Matrix V,
double lambda,
double eta) |
Vector |
MVOptimizerNoConstraint.optimalWeights(Vector mu,
Matrix V,
double lambda,
double eta) |
Vector |
MVOptimizerLongOnly.optimalWeights(Vector mu,
Matrix V,
double lambda,
double eta) |
Vector |
MVOptimizer.optimalWeights(Vector mu,
Matrix V,
double lambda,
double eta)
Solves for the optimal weights given the moments, lambda, and eta.
|
Vector |
MVOptimizerMinWeights.optimalWeights(Vector mu,
Matrix V,
double lambda,
double eta) |
| Modifier and Type | Method and Description |
|---|---|
Vector |
MVOptimizerShrankMean.optimalWeights(Vector mu0,
Matrix V,
double lambda,
double eta) |
Vector |
MVOptimizerNoConstraint.optimalWeights(Vector mu,
Matrix V,
double lambda,
double eta) |
Vector |
MVOptimizerLongOnly.optimalWeights(Vector mu,
Matrix V,
double lambda,
double eta) |
Vector |
MVOptimizer.optimalWeights(Vector mu,
Matrix V,
double lambda,
double eta)
Solves for the optimal weights given the moments, lambda, and eta.
|
Vector |
MVOptimizerMinWeights.optimalWeights(Vector mu,
Matrix V,
double lambda,
double eta) |
| Constructor and Description |
|---|
MVOptimizerMinWeights(Vector w0)
Constructs the solver with a constraint on the minimum weights (w ≥
w0).
|
| Modifier and Type | Method and Description |
|---|---|
protected Vector |
MarkowitzByCLM.getOptimalW(double q) |
protected Vector |
MarkowitzByQP.getOptimalW(double q)
Solves w_eff = argmin {q * (w' Σ w) - w'r}.
|
Vector |
MarkowitzByQP.getOptimalWeights()
Gets the Markowitz optimal portfolio weights, for a given risk aversion
coefficient.
|
| Constructor and Description |
|---|
MarkowitzByCLM(Vector r,
Matrix V)
Solves w_eff = argmin {q * (w' V w) - w'r}, w'1 = 1, w ≥ 0.
|
MarkowitzByCLM(Vector r,
Matrix V,
Vector w_lower,
Vector w_upper)
Solves w_eff = argmin {q * (w' V w) - w'r}, w'1 = 1, w ≥ w_lower, w
≤ w_upper.
|
MarkowitzByCLM(Vector r,
Matrix V,
Vector w_lower,
Vector w_upper,
double benchmarkRate)
Constructs a Markowitz portfolio from expected future returns
and future covariance for a given benchmark rate, with lower and
upper limits on asset weights.
|
MarkowitzByQP(Vector mu,
Matrix sigma)
Constructs a Markowitz portfolio from expected future returns
and future covariance, assuming no short selling constraint and
zero benchmark rate.
|
MarkowitzByQP(Vector mu,
Matrix sigma,
QPConstraint constraints)
Constructs a Markowitz portfolio from expected future returns
and future covariance, assuming zero benchmark rate for Sharpe
ratio calculation.
|
MarkowitzByQP(Vector mu,
Matrix sigma,
QPConstraint constraints,
double benchmarkRate)
Constructs a Markowitz portfolio from expected future returns
and future covariance.
|
MarkowitzByQP(Vector mu,
Matrix sigma,
Vector lower,
Vector upper)
Constructs a Markowitz portfolio from expected future returns
and future covariance, with lower and upper limits on asset
weights, assuming zero benchmark rate.
|
MarkowitzByQP(Vector mu,
Matrix sigma,
Vector lower,
Vector upper,
double benchmarkRate)
Constructs a Markowitz portfolio from expected future returns
and future covariance for a given benchmark rate, with lower and
upper limits on asset weights.
|
| Constructor and Description |
|---|
QPMinWeights(Vector minW) |
QPWeightsLimit(Vector minW,
Vector maxW) |
| Modifier and Type | Method and Description |
|---|---|
Vector |
NMSAAM.getOptimalWeights(Matrix returns,
Vector weights0,
PortfolioOptimizationAlgorithm.SymbolLookup symbolLookup,
LocalDateTimeInterval interval) |
| Modifier and Type | Method and Description |
|---|---|
Vector |
NMSAAM.getOptimalWeights(Matrix returns,
Vector weights0,
PortfolioOptimizationAlgorithm.SymbolLookup symbolLookup,
LocalDateTimeInterval interval) |
| Modifier and Type | Method and Description |
|---|---|
boolean |
SOCPLinearBlackList.areAllConstraintsSatisfied(Vector y) |
boolean |
SOCPZeroValue.areAllConstraintsSatisfied(Vector y) |
boolean |
SOCPLinearZeroValue.areAllConstraintsSatisfied(Vector y) |
boolean |
SOCPSelfFinancing.areAllConstraintsSatisfied(Vector y) |
boolean |
SOCPLinearSectorNeutrality.areAllConstraintsSatisfied(Vector y) |
boolean |
SOCPNoTradingList1.areAllConstraintsSatisfied(Vector y) |
boolean |
SOCPSectorNeutrality.areAllConstraintsSatisfied(Vector y) |
boolean |
SOCPLinearSelfFinancing.areAllConstraintsSatisfied(Vector y) |
boolean |
SOCPMaximumLoan.areAllConstraintsSatisfied(Vector y) |
boolean |
SOCPLinearMaximumLoan.areAllConstraintsSatisfied(Vector y) |
double |
SOCPZeroValue.bias(Vector y)
Computes the amount of deviation from zero value, hence bias.
|
double |
SOCPSelfFinancing.bias(Vector y)
Computes the amount of deviation from self financing, hence bias.
|
double |
SOCPSectorNeutrality.bias(Vector y)
Computes the amount of deviation from neutrality, hence bias.
|
Double |
SOCPLinearBlackList.evaluate(Vector x) |
Double |
SOCPZeroValue.evaluate(Vector y) |
Double |
SOCPLinearZeroValue.evaluate(Vector y) |
Double |
SOCPSelfFinancing.evaluate(Vector y) |
Double |
SOCPLinearSectorNeutrality.evaluate(Vector y) |
Double |
SOCPNoTradingList1.evaluate(Vector x)
Note:
x here is the trading size, not the position. |
Double |
SOCPSectorNeutrality.evaluate(Vector y) |
Double |
SOCPLinearSelfFinancing.evaluate(Vector y) |
Double |
SOCPMaximumLoan.evaluate(Vector y) |
Double |
SOCPLinearMaximumLoan.evaluate(Vector y) |
| Constructor and Description |
|---|
SOCPLinearMaximumLoan(Vector w0,
Vector l)
Creates a maximum loan constraint.
|
SOCPLinearMaximumLoan(Vector w0,
Vector l,
double epsilon)
Creates a maximum loan constraint.
|
SOCPLinearSectorNeutrality(Vector[] S)
Creates a sector neutrality constraint.
|
SOCPLinearSectorNeutrality(Vector[] S,
double epsilon)
Creates a sector neutrality constraint.
|
SOCPLinearSelfFinancing(Vector w0)
Creates a self financing constraint.
|
SOCPLinearSelfFinancing(Vector w0,
double epsilon)
Creates a self financing constraint.
|
SOCPMaximumLoan(Vector w_0,
Vector l)
Constructs a maximum loan constraint.
|
SOCPMaximumLoan(Vector w_0,
Vector l,
double epsilon)
Constructs a maximum loan constraint.
|
SOCPNoTradingList1(Vector w_0,
Matrix D_BL0)
Constructs a black list constraint.
|
SOCPNoTradingList1(Vector w_0,
Matrix D_BL0,
double epsilon)
Constructs a black list constraint.
|
SOCPNoTradingList1(Vector w_0,
Vector bl)
Constructs a black list constraint.
|
SOCPSectorNeutrality(Vector w_0,
Vector[] S)
Constructs a sector neutral constraint.
|
SOCPSectorNeutrality(Vector w_0,
Vector[] S)
Constructs a sector neutral constraint.
|
SOCPSectorNeutrality(Vector w_0,
Vector[] S,
double epsilon)
Constructs a sector neutral constraint.
|
SOCPSectorNeutrality(Vector w_0,
Vector[] S,
double epsilon)
Constructs a sector neutral constraint.
|
SOCPSelfFinancing(Vector w_0)
Constructs a zero value constraint.
|
SOCPSelfFinancing(Vector w_0,
double epsilon)
Constructs a zero value constraint.
|
SOCPZeroValue(Vector w_0)
Constructs a zero value constraint.
|
SOCPZeroValue(Vector w_0,
double epsilon)
Constructs a zero value constraint.
|
| Modifier and Type | Method and Description |
|---|---|
boolean |
SOCPNoTradingList2.areAllConstraintsSatisfied(Vector y) |
boolean |
SOCPSectorExposure.areAllConstraintsSatisfied(Vector y) |
boolean |
SOCPLinearSectorExposure.areAllConstraintsSatisfied(Vector y) |
Double |
SOCPNoTradingList2.evaluate(Vector x)
Note:
x here is the trading size, not the position. |
Double |
SOCPSectorExposure.evaluate(Vector y) |
Double |
SOCPLinearSectorExposure.evaluate(Vector y) |
| Constructor and Description |
|---|
SOCPLinearSectorExposure(Vector[] S,
Vector u)
Creates a sector exposure constraint.
|
SOCPLinearSectorExposure(Vector[] S,
Vector u)
Creates a sector exposure constraint.
|
SOCPLinearSectorExposure(Vector[] S,
Vector u,
double epsilon)
Creates a sector exposure constraint.
|
SOCPLinearSectorExposure(Vector[] S,
Vector u,
double epsilon)
Creates a sector exposure constraint.
|
SOCPNoTradingList2(Vector w_0,
Matrix D_BL0)
Constructs a black list constraint.
|
SOCPNoTradingList2(Vector w_0,
Matrix D_BL0,
double epsilon)
Constructs a black list constraint.
|
SOCPSectorExposure(Vector w_0,
Vector[] S,
Vector u)
Constructs a sector exposure constraint.
|
SOCPSectorExposure(Vector w_0,
Vector[] S,
Vector u)
Constructs a sector exposure constraint.
|
SOCPSectorExposure(Vector w_0,
Vector[] S,
Vector u,
double epsilon)
Constructs a sector exposure constraint.
|
SOCPSectorExposure(Vector w_0,
Vector[] S,
Vector u,
double epsilon)
Constructs a sector exposure constraint.
|
| Modifier and Type | Method and Description |
|---|---|
static Vector |
Returns.getMeanReturns(double[][] returns)
Computes a vector of mean returns of the input returns (one column for
one asset).
|
static Vector |
Returns.getMeanReturns(Matrix returns)
Computes a vector of mean returns of the input returns (one column for
one asset).
|
| Modifier and Type | Method and Description |
|---|---|
Vector |
ReturnsMoments.mu()
Gets the mean vector.
|
| Constructor and Description |
|---|
ReturnsMoments(Vector mu,
Matrix V)
Constructs an instance.
|
| Modifier and Type | Method and Description |
|---|---|
Vector |
Infantino2010PCA.Signal.dReturns()
Gets the difference between predicted accumulated returns and
realized accumulated
returns at time T-H+1, the last historical fully realized
accumulated return.
|
Vector |
Infantino2010PCA.Signal.realizedReturns(int t)
Gets the last H-period accumulated realized return.
|
Vector |
Infantino2010PCA.Signal.S_t_hat(int t)
Predicts the accumulated H-period return at time t.
|
static Vector |
Infantino2010PCA.sumUpLastRows(Matrix D,
int lastIndex,
int nRows)
Sums up, for each column, the last
nRows rows. |
Copyright © 2010-2026 NM Group. All Rights Reserved.