Overload List
Overload 1: function TrustRegion(Fun: TMKLTRFunction; JacProc: TJacobianFunction; const X: TVec; const Y: TVec; const CustomData: TObject; const LB: TVec; const UB: TVec; MaxIter: Integer; MaxTrialIter: Integer; const EPSArray: TDoubleArray; Rs: Double; out StopReason: TOptStopReason; const Control: TOptControl): Integer;
| # | Name | Type | Description |
|---|---|---|---|
| 1 | Fun | TMKLTRFunction | |
| 2 | JacProc | TJacobianFunction | |
| 3 | X | TVec | |
| 4 | Y | TVec | |
| 5 | CustomData | TObject | |
| 6 | LB | TVec | |
| 7 | UB | TVec | |
| 8 | MaxIter | Integer | |
| 9 | MaxTrialIter | Integer | |
| 10 | EPSArray | TDoubleArray | |
| 11 | Rs | Double | scalar |
| 12 | StopReason | TOptStopReason | |
| 13 | Control | TOptControl |
Returns: Int32
Overload 2: function TrustRegion(Fun: TMKLTRFunction; JacProc: TJacobianFunction; const X: TVec; const Y: TVec; const CustomData: TObject; MaxIter: Integer; MaxTrialIter: Integer; const EPSArray: TDoubleArray; Rs: Double; out StopReason: TOptStopReason; const Control: TOptControl): Integer;
| # | Name | Type | Description |
|---|---|---|---|
| 1 | Fun | TMKLTRFunction | |
| 2 | JacProc | TJacobianFunction | |
| 3 | X | TVec | |
| 4 | Y | TVec | |
| 5 | CustomData | TObject | |
| 6 | MaxIter | Integer | |
| 7 | MaxTrialIter | Integer | |
| 8 | EPSArray | TDoubleArray | |
| 9 | Rs | Double | scalar |
| 10 | StopReason | TOptStopReason | |
| 11 | Control | TOptControl |
Returns: Int32
Overload 3: function TrustRegion(Fun: TVectorFunction; JacProc: TJacobianFunction; const X: TVec; const Y: TVec; const LB: TVec; const UB: TVec; const Consts: TDoubleArray; const OConsts: TObjectArray; MaxIter: Integer; MaxTrialIter: Integer; const EPSArray: TDoubleArray; Rs: Double; out StopReason: TOptStopReason; const Control: TOptControl): Integer;
Trust region algorithm to find bounded minimum of vector function.
| # | Name | Type | Description |
|---|---|---|---|
| 1 | Fun | TVectorFunction | |
| 2 | JacProc | TJacobianFunction | |
| 3 | X | TVec | |
| 4 | Y | TVec | |
| 5 | LB | TVec | |
| 6 | UB | TVec | |
| 7 | Consts | TDoubleArray | |
| 8 | OConsts | TObjectArray | |
| 9 | MaxIter | Integer | |
| 10 | MaxTrialIter | Integer | |
| 11 | EPSArray | TDoubleArray | |
| 12 | Rs | Double | scalar |
| 13 | StopReason | TOptStopReason | |
| 14 | Control | TOptControl |
Returns: Int32
Additional parameters LB and UB define x lower and/or upper bounds.
Overload 4: function TrustRegion(Fun: TVectorFunction; JacProc: TJacobianFunction; const X: TVec; const Y: TVec; const Consts: TDoubleArray; const OConsts: TObjectArray; MaxIter: Integer; MaxTrialIter: Integer; const EPSArray: TDoubleArray; Rs: Double; out StopReason: TOptStopReason; const Control: TOptControl): Integer;
Trust region algorithm for finding minimum of vector function.
| # | Name | Description |
|---|---|---|
| 1 | Fun | The objective function to be minimized. |
| 2 | JacProc | The Jacobian matrix calculation procedure. If it is nil, then the numerical approximation will be used to evaluate Jacobi matrix elements. |
| 3 | X | Stores the initial estimates for X. On completion returns estimates, evaluated at function minimum. |
| 4 | Y | Returns objective function value, evaluated at minimum. |
| 5 | Consts | Additional Fun constant parameteres (can be/is usually nil). |
| 6 | OConsts | Additional Fun constant parameteres (can be/is usually nil). |
| 7 | MaxIter | Defines the maximum number of main TR algorithm loops. |
| 8 | MaxTrialIter | Defines the maximum number of iterations of trial-step calculation. |
| 9 | Control | Optional object, which allows the interruption of the search. |
| 10 | EPSArray | Array of size 6. Contains stopping tests. * eps[0]: Grad < eps[0] * eps[1]: ||F(x)|| < eps[1] * eps[2]: ||A(x)ij|| < eps[2] * eps[3]: ||s|| < eps[3] * eps[4]: ||F(x)||- ||F(x) - A(x)s|| < eps[4] * eps[5]: trial step precision. If eps[5] = 0, then eps[5] = 1E-10, where * A(x) = the jacobi matrix * F(x) = ||y - f(x)|| |
| 11 | Rs | Positive input variable used in determining the initial step bound, the initial size of the trust region. In most cases the factor should lie within the interval (0.1, 100.0). The generally recommended value is 100, which is used by default, if this param is set to 0. |
| 12 | StopReason | Returns the TR algorithm stop reason. |
Returns: Int32 - the number of iterations needed for results.
What it computes. Solves the nonlinear least-squares problem
min_x 1/2 || F(x)||_2^2 for the residual vector using Intel MKL's derivative trust-region solver (dtrnlsp; the bounded overload uses dtrnlspbc with the box LB <= x <= UB). At each step a trial step is accepted only if it stays inside the current trust region, whose radius is grown or shrunk from the agreement between the model and the true decrease. The Jacobian A(x)=d F/d x is supplied by JacProc or, when that is nil, approximated numerically.
Domain. X holds the n starting variables; Y
receives the m residual components (its length sets m). This is a double-precision routine; drive it with mvDouble vectors. EPSArray are six non-negative stopping thresholds; Rs ≥ 0 sets the initial trust radius (0 selects the default 100).
Defined behaviour. Returns the iteration count; X holds
the minimizer and Y the residual there. StopReason is TOptStopReason.OptResConverged when || F|| falls below EPSArray[1], or one of TOptStopReason.OptResSmallGrad,
TOptStopReason.optResSmallJacobian, TOptStopReason.OptResSmallStep, TOptStopReason.OptResMaxIter per the MKL stop code. Building MtxVec
Core (no MKL) raises an exception; this routine is not available under .NET.
The Trust Region (TR) algorithms are relatively new iterative algorithms for solving nonlinear optimization problems. They are widely used in power engineering, finance, applied mathematics, physics, computer science, economics, sociology, biology, medicine, mechanical engineering, chemistry, and other areas. TR methods have global convergence and local super convergence, which differenciates them from line search methods and Newton methods. TR methods have better convergence when compared with widely-used Newton-type methods.
The main idea behind TR algorithm is calculating a trial step and checking if the next values of x belong to the trust region. Calculation of the trial step is strongly associated with the approximation model.
For more on TR algorithm, check the following links:
- http://iridia.ulb.ac.be/~fvandenb/optimization/optimizationIntro.html
- http://en.wikipedia.org/wiki/Trust_region
Note:
This function is currently not supported under .NET. The objective function calls are threaded. The objective function should not be allocating any memory on the heap because calling threads are created outside of Delphi/BCB code.
#include "MtxExpr.hpp"
#include "Math387.hpp"
#include "Optimization.hpp"
void __fastcall TestVFun(TVec* const x, TVec* const f, const double * c, const int c_Size, System::TObject* const * o, const int o_Size)
{
double* X = x->PValues1D(0);
f->Values[0] = X[0] + 10.0*X[1];
f->Values[1] = 2.2360679774997896964091736687313*(X[2] - X[3]);
f->Values[2] = (X[1] - 2.0*X[2])*(X[1] - 2.0*X[2]);
f->Values[3] = 3.1622776601683793319988935444327*(X[0] - X[3])*(X[0] - X[3]);
}
void __fastcall Example()
{
Vector x,f;
TEPSArray epsarr;
TOptStopReason sr;
// Initial estimates for variabless
x->SetIt(false,OPENARRAY(double,(3,-1,0,1)));
// 4 components, size must match the TestVFun implementation above
f->Size(4,false);
// setup stopping criteria, use default values
epsarr[0] = 1.0E-5;
epsarr[1] = 1.0E-5;
epsarr[2] = 1.0E-5;
epsarr[3] = 1.0E-5;
epsarr[4] = 1.0E-5;
epsarr[5] = 1.0E-10;
// Minimize
TrustRegion(TestVFun,NULL,x,f,NULL,-1,NULL,-1,1000,100,epsarr,0.0,sr);
// x stores minimum position (variables)
// f stores function value at minimum
// sr stores stop reason
}Uses MtxExpr, Optimization, MtxVec, Math387;
// Objective function, 4 variables, 4 f components
procedure TestVFun(const x,f: TVec; const c: Array of double; const o: Array of TObject);
begin
f[0] := x[0] + 10.0*x[1];
f[1] := 2.2360679774997896964091736687313*(x[2] - x[3]);
f[2] := (x[1] - 2.0*x[2])*(x[1] - 2.0*x[2]);
f[3] := 3.1622776601683793319988935444327*(x[0] - x[3])*(x[0] - x[3]);
end;
procedure Example;
var x,f: Vector;
epsa: TEPSArray;
sr: TOptStopReason;
begin
// Initial estimates for variabless
x.SetIt(false,[3,-1,0,1]);
// 4 components, size must match the TestVFun implementation above
f.Size(4);
// setup stopping criteria, use default values
epsa[0] := 1.0E-5;
epsa[1] := 1.0E-5;
epsa[2] := 1.0E-5;
epsa[3] := 1.0E-5;
epsa[4] := 1.0E-5;
epsa[5] := 1.0E-10;
// Minimize
TrustRegion(TestVFun,x,f,[],[],1000,100,epsa,0.0,sr);
// x stores minimum position (variables)
// f stores function value at minimum
// sr stores stop reason
end;