| Modifier and Type | Method and Description |
|---|---|
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(Vector[] vectors,
RealScalarFunction f)
Applies a
RealScalarFunction on each input vector. |
| Modifier and Type | Class and Description |
|---|---|
class |
LinearInterpolator
Define a univariate function by linearly interpolating between adjacent points.
|
class |
NevilleTable
Neville's algorithm is a polynomial interpolation algorithm.
|
| Modifier and Type | Method and Description |
|---|---|
RealScalarFunction |
BicubicInterpolation.interpolate(BivariateGrid grid) |
RealScalarFunction |
BivariateGridInterpolation.interpolate(BivariateGrid grid)
Constructs a real valued function from a grid of observations.
|
RealScalarFunction |
BicubicSpline.interpolate(BivariateGrid grid) |
RealScalarFunction |
BilinearInterpolation.interpolate(BivariateGrid grid) |
| Modifier and Type | Method and Description |
|---|---|
RealScalarFunction |
RecursiveGridInterpolation.interpolate(MultivariateGrid grid) |
RealScalarFunction |
MultivariateGridInterpolation.interpolate(MultivariateGrid grid)
Construct a real valued function from a grid of observations.
|
| Modifier and Type | Method and Description |
|---|---|
RealScalarFunction |
ODE.F()
Get the differential, \(y^{(n)} = F\).
|
| Constructor and Description |
|---|
ODE(RealScalarFunction F,
double[] initials,
double x0,
double x1)
Construct an ODE of order n together with its initial values.
|
ODE1stOrder(RealScalarFunction[] Y,
double[] y0,
double x0,
double x1)
Constructs a system of first order ODEs \(\{Y_{i}\}\) with their initial values
\(\{y_{i0}\}\).
\[
y_1' = Y_1(x, y_1, y_2, y_3, ...), y_1(0) = y_{10}\\
y_2' = Y_2(x, y_1, y_2, y_3, ...), y_2(0) = y_{20}\\
y_3' = Y_3(x, y_1, y_2, y_3, ...), y_3(0) = y_{30}\\
|
| Modifier and Type | Class and Description |
|---|---|
class |
Ridders
Ridders' method computes the numerical derivative of a function.
|
| Constructor and Description |
|---|
Ridders(RealScalarFunction f,
int[] varidx)
Construct the derivative function of a vector-valued function using Ridder's method.
|
Ridders(RealScalarFunction f,
int[] varidx,
double rate,
int discretization)
Construct the derivative function of a vector-valued function using Ridder's method.
|
| Modifier and Type | Class and Description |
|---|---|
class |
MultivariateFiniteDifference
A partial derivative of a multivariate function is the derivative with respect to one of the variables with the others held constant.
|
| 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.
|
GradientFunction(RealScalarFunction f)
Construct the gradient function of a real scalar function f.
|
Hessian(RealScalarFunction f,
Vector x)
Construct the Hessian matrix for a multivariate function f at point x.
|
HessianFunction(RealScalarFunction f)
Construct the Hessian function of a real scalar function f.
|
Jacobian(RealScalarFunction[] f,
Vector x)
Construct the Jacobian matrix for a multivariate function f at point x.
|
MultivariateFiniteDifference(RealScalarFunction f,
int[] varidx)
Construct the partial derivative of a multi-variable function.
|
| Constructor and Description |
|---|
Jacobian(List<RealScalarFunction> f,
Vector x)
Construct the Jacobian matrix for a multivariate function f at point x.
|
| Modifier and Type | Class and Description |
|---|---|
class |
DBeta
|
class |
DBetaRegularized
This is the first order derivative function of the Regularized Incomplete Beta function,
BetaRegularized, w.r.t the upper limit, x.
\[
{\partial \over \partial x} \mathrm{B_x}(p, q) = \frac{x^{p-1}(1-x)^{q-1}}{\mathrm{B_x}(p, q)}
\] |
class |
DErf
This is the first order derivative function of the Error function,
Erf.
\[
{d \over dx}\mbox{Erf}(x) = \frac{2}{\sqrt{\pi}}\exp(-x^2)
\] |
class |
Dfdx
The first derivative is a measure of how a function changes as its input changes.
|
class |
DGamma
This is the first order derivative function of the Gamma function, \({d \mathrm{\Gamma}(x) \over dx}\).
|
class |
DGaussian
This is the first order derivative function of a
Gaussian function, \({d \mathrm{\phi}(x) \over dx}\). |
class |
DPolynomial
This is the first order derivative function of a
Polynomial, which, again, is a polynomial. |
class |
FiniteDifference
A finite difference (divided by a small increment) is an approximation of the
derivative of a function.
|
| Modifier and Type | Class and Description |
|---|---|
class |
CauchyPolynomial
The Cauchy's polynomial of a polynomial takes this form:
C(x) = |p_n|x^n + |p_{n-1}|x^{n-1} + ... + |p_1|x - |p_0| = 0
Note: the sign of the constant is negative.
|
class |
Polynomial
A polynomial is a
UnivariateRealFunction that represents a finite length expression constructed from variables and constants,
using the operations of addition, subtraction, multiplication, and constant non-negative whole number exponents. |
class |
QuadraticMonomial
A quadratic monomial has this form: \(x^{2} + ux + v\).
|
class |
ScaledPolynomial
This constructs a scaled polynomial that has neither too big or too small coefficients,
hence avoiding overflow or underflow.
|
| Modifier and Type | Interface and Description |
|---|---|
interface |
BivariateRealFunction
A bivariate real function takes two real arguments and outputs one real value.
|
interface |
TrivariateRealFunction
A trivariate real function takes three real arguments and outputs one real value.
|
| Modifier and Type | Class and Description |
|---|---|
class |
AbstractBivariateRealFunction
A bivariate real function takes two real arguments and outputs one real value.
|
class |
AbstractRealScalarFunction
This abstract implementation implements
Function.dimensionOfRange() by always
returning 1, and Function.dimensionOfDomain() by returning the input argument
for the dimension of domain. |
class |
AbstractTrivariateRealFunction
A trivariate real function takes three real arguments and outputs one real value.
|
class |
QuadraticFunction
A quadratic function takes this form: \(f(x) = \frac{1}{2}x^{\mathsf T}Hx+x^{\mathsf T}p + c\).
|
class |
R1Projection
Projection creates a real-valued function
RealScalarFunction from a vector-valued function RealVectorFunction by
taking only one of its coordinate components in the vector output. |
class |
RealScalarSubFunction
This constructs a
RealScalarFunction from another
RealScalarFunction by restricting/fixing the values of a subset of
variables. |
| Constructor and Description |
|---|
RealScalarSubFunction(RealScalarFunction f,
Map<Integer,Double> fixing)
Construct a scalar sub-function.
|
| Modifier and Type | Interface and Description |
|---|---|
interface |
UnivariateRealFunction
A univariate real function takes one real argument and outputs one real value.
|
| Modifier and Type | Class and Description |
|---|---|
class |
AbstractUnivariateRealFunction
A univariate real function takes one real argument and outputs one real value.
|
class |
ContinuedFraction
A continued fraction representation of a number has this form:
\[
z = b_0 + \cfrac{a_1}{b_1 + \cfrac{a_2}{b_2 + \cfrac{a_3}{b_3 + \cfrac{a_4}{b_4 + \ddots\,}}}}
\]
\(a_{i}\) and \(b_{i}\) can be functions of x, which in turn makes z a function of x.
|
class |
StepFunction
A step function (or staircase function) is a finite linear combination of indicator functions of
intervals.
|
| Modifier and Type | Class and Description |
|---|---|
class |
Rastrigin
The Rastrigin function is a non-convex function used as a performance test problem for
optimization algorithms.
|
| Modifier and Type | Class and Description |
|---|---|
class |
Beta
The beta function defined as:
\[
B(x,y) = \frac{\Gamma(x)\Gamma(y)}{\Gamma(x+y)}= \int_0^1t^{x-1}(1-t)^{y-1}\,dt, x > 0, y > 0
\]
The R equivalent function is
beta. |
class |
BetaRegularized
The Regularized Incomplete Beta function is defined as:
\[
I_x(p,q) = \frac{B(x;\,p,q)}{B(p,q)} = \frac{1}{B(p,q)} \int_0^x t^{p-1}\,(1-t)^{q-1}\,dt, p > 0, q > 0
\]
The R equivalent function is
pbeta. |
class |
BetaRegularizedInverse
The inverse of the Regularized Incomplete Beta function is defined at:
\[
x = I^{-1}_{(p,q)}(u), 0 \le u \le 1
\]
The R equivalent function is
qbeta. |
class |
LogBeta
This class represents the log of Beta function
log(B(x, y)). |
class |
MultinomialBetaFunction
A multinomial Beta function is defined as:
\[
\frac{\prod_{i=1}^K \Gamma(\alpha_i)}{\Gamma\left(\sum_{i=1}^K
\alpha_i\right)},\qquad\boldsymbol{\alpha}=(\alpha_1,\cdots,\alpha_K)
\]
|
| Modifier and Type | Class and Description |
|---|---|
class |
Digamma
The digamma function is defined as the logarithmic derivative of the gamma function.
|
class |
GammaGergoNemes
The Gergo Nemes' algorithm is very simple and quick to compute the Gamma function, if accuracy is not critical.
|
class |
GammaLanczos
Lanczos approximation provides a way to compute the Gamma function such that the accuracy can be made arbitrarily precise.
|
class |
GammaLanczosQuick
Lanczos approximation, computations are done in
double. |
class |
GammaLowerIncomplete
The Lower Incomplete Gamma function is defined as:
\[
\gamma(s,x) = \int_0^x t^{s-1}\,e^{-t}\,{\rm d}t = P(s,x)\Gamma(s)
\]
P(s,x) is the Regularized Incomplete Gamma P function.
|
class |
GammaRegularizedP
The Regularized Incomplete Gamma P function is defined as:
\[
P(s,x) = \frac{\gamma(s,x)}{\Gamma(s)} = 1 - Q(s,x), s \geq 0, x \geq 0
\]
The R equivalent function is
pgamma. |
class |
GammaRegularizedPInverse
The inverse of the Regularized Incomplete Gamma P function is defined as:
\[
x = P^{-1}(s,u), 0 \geq u \geq 1
\]
When
s > 1, we use the asymptotic inversion method. |
class |
GammaRegularizedQ
The Regularized Incomplete Gamma Q function is defined as:
\[
Q(s,x)=\frac{\Gamma(s,x)}{\Gamma(s)}=1-P(s,x), s \geq 0, x \geq 0
\]
The algorithm used for computing the regularized incomplete Gamma Q function depends on the values of s and x.
|
class |
GammaUpperIncomplete
The Upper Incomplete Gamma function is defined as:
\[
\Gamma(s,x) = \int_x^{\infty} t^{s-1}\,e^{-t}\,{\rm d}t = Q(s,x) \times \Gamma(s)
\]
The integrand has the same form as the Gamma function, but the lower limit of the integration is a variable.
|
class |
LogGamma
The log-Gamma function, \(\log (\Gamma(z))\), for positive real numbers, is the log of the Gamma function.
|
class |
Trigamma
The trigamma function is defined as the logarithmic derivative of the digamma function.
|
| Modifier and Type | Class and Description |
|---|---|
class |
CumulativeNormalHastings
Hastings algorithm is faster but less accurate way to compute the cumulative standard Normal.
|
class |
CumulativeNormalInverse
The inverse of the cumulative standard Normal distribution function is defined as:
\[
N^{-1}(u)
\]
This implementation uses the Beasley-Springer-Moro algorithm.
|
class |
CumulativeNormalMarsaglia
Marsaglia is about 3 times slower but is more accurate to compute the cumulative standard Normal.
|
class |
Erf
The Error function is defined as:
\[
\operatorname{erf}(x) = \frac{2}{\sqrt{\pi}}\int_{0}^x e^{-t^2} dt
\]
|
class |
Erfc
This complementary Error function is defined as:
\[
\operatorname{erfc}(x)
= 1-\operatorname{erf}(x)
= \frac{2}{\sqrt{\pi}} \int_x^{\infty} e^{-t^2}\,dt
\]
|
class |
ErfInverse
The inverse of the Error function is defined as:
\[
\operatorname{erf}^{-1}(x)
\]
|
class |
Gaussian
The Gaussian function is defined as:
\[
f(x) = a e^{- { \frac{(x-b)^2 }{ 2 c^2} } }
\]
|
| Modifier and Type | Method and Description |
|---|---|
Vector |
NewtonSystemRoot.solve(RealScalarFunction[] f,
Vector guess)
Searches for a root, x such that f(x) = 0.
|
| Modifier and Type | Method and Description |
|---|---|
double[] |
Bins.getBinKeyValues(RealScalarFunction f)
Applies a function to the key of each bin.
|
| Modifier and Type | Method and Description |
|---|---|
List<RealScalarFunction> |
Constraints.getConstraints()
Get the list of constraint functions.
|
| Modifier and Type | Method and Description |
|---|---|
List<RealScalarFunction> |
GeneralConstraints.getConstraints()
Get the constraints.
|
| Constructor and Description |
|---|
GeneralConstraints(RealScalarFunction... constraints)
Construct an instance of constraints from an array of real-valued functions.
|
GeneralEqualityConstraints(RealScalarFunction... constraints)
Constructs an instance of equality constraints from an array of
real-valued functions.
|
GeneralGreaterThanConstraints(RealScalarFunction... constraints)
Construct an instance of greater-than-or-equal-to inequality constraints from an array of
real-valued functions.
|
GeneralLessThanConstraints(RealScalarFunction... constraints)
Construct an instance of less-than or equal-to inequality constraints from an array of real-valued functions.
|
| Constructor and Description |
|---|
GeneralConstraints(Collection<RealScalarFunction> constraints)
Construct an instance of constraints from a collection of real-valued functions.
|
GeneralEqualityConstraints(Collection<RealScalarFunction> constraints)
Constructs an instance of equality constraints from a collection of
real-valued functions.
|
GeneralGreaterThanConstraints(Collection<RealScalarFunction> constraints)
Construct an instance of greater-than-or-equal-to inequality constraints from a collection of
real-valued functions.
|
GeneralLessThanConstraints(Collection<RealScalarFunction> constraints)
Construct an instance of less-than or equal-to inequality constraints from a collection of real-valued functions.
|
| Modifier and Type | Method and Description |
|---|---|
List<RealScalarFunction> |
LinearConstraints.getConstraints() |
| Constructor and Description |
|---|
LowerBoundConstraints(RealScalarFunction f,
double lower)
Construct a lower bound constraints for all variables in a function.
|
NonNegativityConstraints(RealScalarFunction f)
Construct a lower bound constraints for all variables in a function.
|
UpperBoundConstraints(RealScalarFunction f,
double lower)
Construct an upper bound constraints for all variables in a function.
|
| Modifier and Type | Method and Description |
|---|---|
List<RealScalarFunction> |
SDPDualProblem.EqualityConstraints.getConstraints() |
| Modifier and Type | Method and Description |
|---|---|
RealScalarFunction |
SOCPDualProblem1.f() |
RealScalarFunction |
SOCPDualProblem.f() |
| Modifier and Type | Method and Description |
|---|---|
List<RealScalarFunction> |
SOCPDualProblem1.EqualityConstraints.getConstraints() |
List<RealScalarFunction> |
SOCPDualProblem.EqualityConstraints.getConstraints() |
| Modifier and Type | Class and Description |
|---|---|
class |
MarketImpact1
Constructs the constraint coefficient arrays of a market impact term in the
compact form.
|
class |
PortfolioRiskExactSigma
Constructs the constraint coefficient arrays of the portfolio risk term in
the compact form.
|
class |
SOCPPortfolioConstraint
An SOCP constraint for portfolio optimization, e.g., market impact, is
represented by a set of constraints in this form:
\[
||A^{T}x+c||_{2}\leq b^{T}x+d
\]
or this form:
\[
A^T x = c, x \in \Re^m
\]
or this form:
\[
A^T x \leq c, x \in \Re^m
\]
|
class |
SOCPPortfolioObjectiveFunction
Constructs the objective function for portfolio optimization.
|
class |
SOCPRiskConstraint |
| Modifier and Type | Method and Description |
|---|---|
RealScalarFunction |
LPProblemImpl1.f() |
| Modifier and Type | Method and Description |
|---|---|
RealScalarFunction |
LPRevisedSimplexSolver.Problem.f() |
| Modifier and Type | Class and Description |
|---|---|
class |
QPProblemOnlyEqualityConstraints
A quadratic programming problem with only equality constraints can be converted into
a equivalent quadratic programming problem without constraints, hence a mere quadratic function.
|
| Modifier and Type | Class and Description |
|---|---|
class |
AbsoluteErrorPenalty
This penalty function sums up the absolute error penalties.
|
class |
CourantPenalty
This penalty function sums up the squared error penalties.
|
class |
FletcherPenalty
This penalty function sums up the squared costs penalties.
|
class |
MultiplierPenalty
A multiplier penalty function allows different weights to be assigned to the constraints.
|
class |
PenaltyFunction
A function P: Rn -> R is a penalty function for a constrained optimization problem if it has these properties.
|
class |
SumOfPenalties
This penalty function sums up the costs from a set of constituent penalty functions.
|
class |
ZeroPenalty
This is a dummy zero cost (no cost) penalty function.
|
| Modifier and Type | Method and Description |
|---|---|
SQPASVariation |
SQPActiveSetMinimizer.VariationFactory.newVariation(RealScalarFunction f,
RealVectorFunction g,
EqualityConstraints equal,
GreaterThanConstraints greater)
Construct a new instance of
SQPASVariation for an SQP
problem. |
void |
SQPASVariation1.set(RealScalarFunction f,
RealVectorFunction g,
EqualityConstraints equal,
GreaterThanConstraints greater)
Associate this variation to a particular general constrained minimization
problem.
|
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.
|
| Constructor and Description |
|---|
Solution(RealScalarFunction f,
RealVectorFunction g,
EqualityConstraints equal,
GreaterThanConstraints greater) |
| Modifier and Type | Field and Description |
|---|---|
protected RealScalarFunction |
SQPASEVariation1.f |
| Modifier and Type | Field and Description |
|---|---|
protected List<RealScalarFunction> |
SQPASEVariation1.a |
| Modifier and Type | Method and Description |
|---|---|
SQPASEVariation |
SQPActiveSetOnlyEqualityConstraint1Minimizer.VariationFactory.newVariation(RealScalarFunction f,
EqualityConstraints equal)
Construct a new instance of
SQPASEVariation for an SQP problem. |
void |
SQPASEVariation1.set(RealScalarFunction f,
EqualityConstraints equal)
Associate this variation to a particular general constrained minimization problem with only equality constraints.
|
IterativeSolution<Vector> |
SQPActiveSetOnlyEqualityConstraint1Minimizer.solve(RealScalarFunction f,
EqualityConstraints equal)
Minimize a function subject to only equality constraints.
|
| Modifier and Type | Method and Description |
|---|---|
RealScalarFunction |
IPProblemImpl1.f() |
| Constructor and Description |
|---|
IPProblemImpl1(RealScalarFunction f,
EqualityConstraints equal,
LessThanConstraints less,
int[] integers)
Construct a constrained optimization problem with integral constraints.
|
IPProblemImpl1(RealScalarFunction f,
EqualityConstraints equal,
LessThanConstraints less,
int[] integers,
double epsilon)
Construct a constrained optimization problem with integral constraints.
|
| Constructor and Description |
|---|
BruteForceIPProblem(RealScalarFunction f,
BruteForceIPProblem.IntegerDomain[] integers,
double epsilon)
Construct an integral constrained minimization problem with explicit integral domains.
|
BruteForceIPProblem(RealScalarFunction f,
EqualityConstraints equal,
LessThanConstraints less,
BruteForceIPProblem.IntegerDomain[] integers,
double epsilon)
Construct an integral constrained minimization problem with explicit integral domains.
|
| Modifier and Type | Method and Description |
|---|---|
RealScalarFunction |
ILPNode.f() |
| Modifier and Type | Method and Description |
|---|---|
RealScalarFunction |
ILPProblemImpl1.f() |
| Modifier and Type | Method and Description |
|---|---|
RealScalarFunction |
ConstrainedOptimProblemImpl1.f() |
RealScalarFunction |
NonNegativityConstraintOptimProblem.f() |
RealScalarFunction |
BoxOptimProblem.f() |
| Constructor and Description |
|---|
BoxOptimProblem(RealScalarFunction f,
BoxConstraints box)
Constructs an optimization problem with box constraints.
|
BoxOptimProblem(RealScalarFunction f,
Vector lower,
Vector upper)
Constructs an optimization problem with box constraints.
|
ConstrainedOptimProblemImpl1(RealScalarFunction f,
EqualityConstraints equal,
LessThanConstraints less)
Constructs a constrained optimization problem.
|
NonNegativityConstraintOptimProblem(RealScalarFunction f)
Construct a constrained optimization problem with only non-negative variables.
|
| 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) |
Solution(RealScalarFunction f) |
| 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.
|
| 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 RealScalarFunction |
SimpleGridMinimizer.Solution.f |
| Modifier and Type | Method and Description |
|---|---|
RealScalarFunction |
RealScalarFunctionChromosome.f()
Get the objective function.
|
| Modifier and Type | Method and Description |
|---|---|
SimpleCellFactory.SimpleCell |
SimpleCellFactory.getSimpleCell(RealScalarFunction f,
Vector x)
Construct an instance of a
SimpleCell. |
| Constructor and Description |
|---|
RealScalarFunctionChromosome(RealScalarFunction f,
Vector x)
Construct an instance of
RealScalarFunctionChromosome. |
SimpleCell(RealScalarFunction f,
Vector x) |
Solution(RealScalarFunction f) |
| 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 |
|---|---|
RealScalarFunction |
MinMaxProblem.error(T omega)
e(x, ω) is the error function, or the minmax objective, for a given ω.
|
| Modifier and Type | Method and Description |
|---|---|
RealScalarFunction |
OptimProblem.f()
Get the objective function.
|
RealScalarFunction |
C2OptimProblemImpl.f() |
| Constructor and Description |
|---|
C2OptimProblemImpl(RealScalarFunction f)
Construct an optimization problem with an objective function.
|
C2OptimProblemImpl(RealScalarFunction f,
RealVectorFunction g)
Construct an optimization problem with an objective function.
|
C2OptimProblemImpl(RealScalarFunction f,
RealVectorFunction g,
RntoMatrix H)
Construct an optimization problem with an objective function.
|
| Constructor and Description |
|---|
MultivariateExponentialFamily(RealScalarFunction h,
RealVectorFunction eta,
RealVectorFunction T,
RealScalarFunction A)
Construct a factory to construct probability distribution in the exponential family of this
form.
\[
f_X(x|\boldsymbol \theta) = h(x) \exp\Big(\boldsymbol\eta({\boldsymbol \theta}) \cdot
\mathbf{T}(x) - A({\boldsymbol \theta}) \Big)
\]
|
| Constructor and Description |
|---|
ExponentialFamily(UnivariateRealFunction h,
RealVectorFunction eta,
AbstractR1RnFunction T,
RealScalarFunction A)
Construct a factory to construct probability distribution in the exponential family of this
form.
\[
f_X(x|\boldsymbol \theta) = h(x) \exp\Big(\boldsymbol\eta({\boldsymbol \theta}) \cdot
\mathbf{T}(x) - A({\boldsymbol \theta}) \Big)
\]
|
| Modifier and Type | Method and Description |
|---|---|
RealScalarFunction |
EstimateByLogLikelihood.getLogLikelihoodFunction()
Get the log-likelihood function.
|
| Constructor and Description |
|---|
EstimateByLogLikelihood(Vector fittedParameters,
RealScalarFunction logLikelihoodFunction) |
| Modifier and Type | Class and Description |
|---|---|
class |
ACERFunction
The ACER (Average Conditional Exceedance Rate) function \(\epsilon_k(\eta)\) approximates the
probability
\[
\epsilon_k(\eta) = Pr(X_k > \eta | X_1 \le \eta, X_2 \le \eta, ..., X_{k-1} \le \eta)
\]
for a sequence of stochastic process observations \(X_i\) with a k-step memory.
|
class |
ACERInverseFunction
The inverse of the ACER function.
\[
\epsilon_k^{-1}(x) = \exp(\frac{1}{c}( \log(-\log\frac{x}{q}) - \log a)) + b
\]
|
class |
ACERLogFunction
The ACER function in log scale (base e), i.e., \(log(\epsilon_k(\eta))\).
|
class |
ACERReturnLevel
Given an ACER function, compute the return level \(\eta\) for a given return period \(R\).
|
| Modifier and Type | Class and Description |
|---|---|
class |
ReturnLevel
Given a GEV distribution of a random variable \(X\), the return level \(\eta\) is the value that
is expected to be exceeded on average once every interval of time \(T\), with a probability of
\(1 / T\).
|
class |
ReturnPeriod
The return period \(R\) of a level \(\eta\) for a random variable \(X\) is the mean number of
trials that must be done for \(X\) to exceed \(\eta\).
|
| 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.
|
| Constructor and Description |
|---|
HybridMCMC(RealScalarFunction logF,
RealVectorFunction dLogF,
Vector m,
double dt,
int L,
Vector initialState,
RandomLongGenerator rlg)
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 |
|---|---|
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.
|
static double |
MetropolisUtils.logAcceptanceRatio(RealScalarFunction logf,
Vector currentState,
Vector proposedState)
Computes the log of the acceptance ratio.
|
| Constructor and Description |
|---|
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 |
|---|---|
static RealScalarFunction |
LogisticRegression.logLikelihood(LogisticProblem problem)
Constructs the log-likelihood function for a logistic regression problem.
|
| Modifier and Type | Class and Description |
|---|---|
class |
Bt
This is a
FiltrationFunction that returns \(B(t_i)\),
the Brownian motion value at the i-th time point. |
class |
F_Sum_BtDt
This represents a function of this integral
\[
I = \int_{0}^{1} B(t)dt
\]
|
class |
F_Sum_tBtDt
This represents a function of this integral
\[
\int_{0}^{1} (t - 0.5) * B(t) dt
\]
|
class |
FiltrationFunction
A filtration function, parameterized by a fixed filtration, is a function of time,
\(f(\mathfrak{F_{t_i}})\).
|
| Modifier and Type | Class and Description |
|---|---|
class |
AutoCorrelationFunction
This is the auto-correlation function of a univariate time series \(\{x_{t}\}\).
|
class |
AutoCovarianceFunction
This is the auto-covariance function of a univariate time series \(\{x_{t}\}\).
|
| Modifier and Type | Class and Description |
|---|---|
class |
SampleAutoCorrelation
This is the sample Auto-Correlation Function (ACF) for a univariate data set.
|
class |
SampleAutoCovariance
This is the sample Auto-Covariance Function (ACVF) for a univariate data set.
|
class |
SamplePartialAutoCorrelation
This is the sample partial Auto-Correlation Function (PACF) for a univariate data set.
|
| Modifier and Type | Class and Description |
|---|---|
class |
AutoCorrelation
Compute the Auto-Correlation Function (ACF) for an AutoRegressive Moving Average (ARMA) model, assuming that
\(EX_{t} = 0\).
|
class |
AutoCovariance
Computes the Auto-CoVariance Function (ACVF) for an AutoRegressive Moving Average (ARMA) model by
recursion.
|
| Modifier and Type | Class and Description |
|---|---|
class |
Ceta
The function C(η) to be maximized (Eq. 3.8).
|
| Modifier and Type | Class and Description |
|---|---|
static class |
CetaMaximizer.NegCetaFunction |
| Modifier and Type | Class and Description |
|---|---|
class |
SOCPLinearBlackList
A black list means that the positions of some assets must be zero.
\[
x_i = 0, \quad \text{for selected indices }i
\]
|
class |
SOCPLinearMaximumLoan
A maximum loan constraint.
\[
x_j + \max(0, w^0_j) \leq l_j, \quad l_j \leq 0
\]
where \(w^0_j\) and \(x_j\) are the initial and the additional weights for
asset \(i\) respectively.
|
class |
SOCPLinearSectorNeutrality
A sector neutrality means that the sum of weights for given sectors are zero.
\[
\sum_{j \in S_i} y_j = 0, \quad i = 1, \ldots, k
\]
where \(S_i\)'s represent the given \(k\) sectors.
|
class |
SOCPLinearSelfFinancing
A self financing constraint.
\[
\sum_{j=1}^{n}x_{j} = 0, \quad y = w_0 + x
\]
where \(y\) is the new weights, \(w_0\) is the initial weights, and \(x\) is
the change of weights.
|
class |
SOCPLinearZeroValue
A zero value constraint.
\[
\sum_{j=1}^{n}y_{j} = 0
\]
where \(y\) is the new weights.
|
class |
SOCPMaximumLoan
Transforms a maximum loan constraint into the compact SOCP form.
|
class |
SOCPNoTradingList1
Transforms a black list (not to trade a new position) constraint into the
compact SOCP form.
|
class |
SOCPSectorNeutrality
Transforms a sector neutral constraint into the compact SOCP form.
|
class |
SOCPSelfFinancing
Transforms a self financing constraint into the compact SOCP form.
|
class |
SOCPZeroValue
Transforms a zero value constraint into the compact SOCP form.
|
| Modifier and Type | Class and Description |
|---|---|
class |
SOCPLinearSectorExposure
A sector exposure constraint.
\[
\sum_{j \in S_i} |y_j| \leq u_i, \quad i=1, \ldots, k
\]
where \(y_j\) is the new weight for asset j, \(S_i\) are the given sectors,
and \(u_i\) is the exposure limit for \(S_i\).
|
class |
SOCPNoTradingList2
Transforms a black list (not to trade a new position) constraint into the
compact SOCP form.
|
class |
SOCPSectorExposure
Transforms a sector exposure constraint into the compact SOCP form.
|
Copyright © 2010-2026 NM Group. All Rights Reserved.