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 | Class and Description |
---|---|
class |
Ridders
Ridders' method computes the numerical derivative of a function.
|
Modifier and Type | Class and Description |
---|---|
class |
GradientFunction
The gradient function, g(x), evaluates the gradient of a real scalar function f at a point x.
|
class |
HessianFunction
The Hessian function, H(x), evaluates the Hessian of a real scalar function f at a point x.
|
class |
JacobianFunction
The Jacobian function, J(x), evaluates the Jacobian of a real vector-valued function f at a point x.
|
class |
MultivariateFiniteDifference
A partial derivative of a multivariate function is the derivative with respect to one of the variables with the others held constant.
|
Modifier and Type | Class and Description |
---|---|
class |
DBeta
This is the first order derivative function of the
Beta function w.r.t x, \({\partial \over \partial x} \mathrm{B}(x, y)\). |
class |
DBetaRegularized
This is the first order derivative function of the Regularized Incomplete Beta function,
BetaRegularized , w.r.t the upper limit, x. |
class |
DErf
This is the first order derivative function of the Error function,
Erf . |
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 |
SubFunction<R>
A sub-function, g, is defined over a subset of the domain of another
(original) function,
f.
|
Modifier and Type | Field and Description |
---|---|
protected Function<Vector,R> |
SubFunction.f
the original, unrestricted function
|
Constructor and Description |
---|
SubFunction(Function<Vector,R> f,
Map<Integer,Double> fixing)
Constructs a sub-function.
|
Modifier and Type | Interface and Description |
---|---|
interface |
RntoMatrix
This interface is a function that maps from Rn to a Matrix space.
|
Modifier and Type | Class and Description |
---|---|
class |
R1toConstantMatrix
A constant matrix function maps a real number to a constant matrix: \(R^n \rightarrow A\).
|
class |
R1toMatrix
This is a function that maps from R1 to a Matrix space.
|
class |
R2toMatrix
This is a function that maps from R2 to a Matrix space.
|
Modifier and Type | Class and Description |
---|---|
class |
CauchyPolynomial
The Cauchy's polynomial of a polynomial takes this form:
|
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: x2 + 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 |
RealScalarFunction
A real valued function a \(R^n \rightarrow R\) function, \(y = f(x_1, ..., x_n)\).
|
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
dimensionOfRange() by always
returning 1, and 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} \times x'Hx + x'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. |
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\,}}}}
\]
ai and bi 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 | Interface and Description |
---|---|
interface |
RealVectorFunction
A vector-valued function a \(R^n \rightarrow R^m\) function, \([y_1,...,y_m] = f(x_1,...,x_n)\).
|
Modifier and Type | Class and Description |
---|---|
class |
AbstractR1RnFunction
This is a function that takes one real argument and outputs one vector value.
|
class |
AbstractRealVectorFunction
This abstract implementation implements
dimensionOfDomain() and
dimensionOfRange() by returning the input arguments at constructor. |
class |
RealVectorSubFunction
This constructs a
RealVectorFunction from another RealVectorFunction by
restricting/fixing the values of a subset of variables. |
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.
When s <= 1 , we use an approximation of P(s,x) together with a higher-order Newton like method.
In both cases, the estimated value is then improved using Halley's method, c.f., HalleyRoot . |
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 |
---|---|
double[] |
Bins.getBinObjectValues(Function<List<T>,Double> f)
Applies a function to the items of each bin.
|
Constructor and Description |
---|
BruteForce(Function<D,R> function)
Constructs a brute force search for a function.
|
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.
|
class |
SOCPPortfolioObjectiveFunction
Constructs the objective function for portfolio optimization.
|
class |
SOCPRiskConstraint |
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 |
---|---|
BruteForceMinimizer.Solution |
BruteForceMinimizer.solve(Function<Vector,R> f) |
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.
|
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 | Class and Description |
---|---|
class |
GaussianProposalFunction
A proposal generator where each perturbation is a random vector, where each element is drawn
from a standard Normal distribution, multiplied by a scale matrix.
|
class |
HybridMCMCProposalFunction |
class |
ProposalFunction
A proposal function goes from the current state to the next state, where a state is a vector.
|
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 |
MultivariateAutoCorrelationFunction
This is the auto-correlation function of a multi-dimensional time series {Xt}.
|
class |
MultivariateAutoCovarianceFunction
This is the auto-covariance function of a multi-dimensional time series {Xt},
\[
K(i, j) = E((X_i - \mu_i) \times (X_j - \mu_j)')
\]
For a stationary process, the auto-covariance depends only on the lag, |i - j|.
|
Modifier and Type | Class and Description |
---|---|
class |
VARMAAutoCorrelation
Compute the Auto-Correlation Function (ACF) for a vector AutoRegressive Moving Average (ARMA) model, assuming that
EXt = 0.
|
class |
VARMAAutoCovariance
Compute the Auto-CoVariance Function (ACVF) for a vector AutoRegressive Moving Average (ARMA) model, assuming that
EXt = 0.
|
Modifier and Type | Class and Description |
---|---|
class |
AutoCorrelationFunction
This is the auto-correlation function of a univariate time series {xt}.
|
class |
AutoCovarianceFunction
This is the auto-covariance function of a univariate time series {xt}.
|
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
EXt = 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.
|
Modifier and Type | Class and Description |
---|---|
static class |
CetaMaximizer.NegCetaFunction |
Modifier and Type | Class and Description |
---|---|
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 |
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-2020 NM FinTech Ltd.. All Rights Reserved.