NAG C Library Function Document

nag_opt_handle_solve_dfls (e04ffc)

Note: this function uses optional parameters to define choices in the problem specification and in the details of the algorithm. If you wish to use default settings for all of the optional parameters, you need only read Sections 1 to 10 of this document. If, however, you wish to reset some or all of the settings please refer to Section 11 for a detailed description of the algorithm and to Section 12 for a detailed description of the specification of the optional parameters.

1
Purpose

nag_opt_handle_solve_dfls (e04ffc) is a derivative-free solver from the NAG optimization modelling suite for small to medium-scale nonlinear least squares problems with bound constraints.

2
Specification

#include <nag.h>
#include <nage04.h>
void  nag_opt_handle_solve_dfls (void *handle,
void (*objfun)(Integer nvar, const double x[], Integer nres, double rx[], Integer *inform, Nag_Comm *comm),
void (*mon)(Integer nvar, const double x[], Integer *inform, const double rinfo[], const double stats[], Nag_Comm *comm),
Integer nvar, double x[], Integer nres, double rx[], double rinfo[], double stats[], Nag_Comm *comm, NagError *fail)

3
Description

nag_opt_handle_solve_dfls (e04ffc) serves as a solver for compatible problems stored as a handle. The handle points to an internal data structure which defines the problem and serves as a means of communication for functions in the suite.
nag_opt_handle_solve_dfls (e04ffc) is aimed at minimizing a sum of a squares objective function subject to bound constraints:
minimize xn i=1 mr ri x 2   (a) subject to lxxux ,   (b) (1)
Here the rix are smooth nonlinear functions called residuals and lx and ux are n-dimensional vectors defining bounds on the variables. Typically, in a calibration or data fitting context, the residuals will be defined as the difference between a data point and a nonlinear model (see Section 2.2.3 in the e04 Chapter Introduction)
To define a compatible problem handle, you must call nag_opt_handle_init (e04rac) followed by nag_opt_handle_set_nlnls (e04rmc) to initialize it and optionally call nag_opt_handle_set_simplebounds (e04rhc) to define bounds on the variables. If nag_opt_handle_set_simplebounds (e04rhc) is not called, all the variables will be considered free by the solver. It should be noted that nag_opt_handle_solve_dfls (e04ffc) always assumes that the Jacobian of the residuals is dense, therefore defining a sparse structure for the residuals in the call to nag_opt_handle_set_nlnls (e04rmc) will have no effect.
It is possible to fix some variables with the definition of the bounds. However, some constraints must be met in order to be able to call the solver:
The solver is based on a derivative-free trust region framework. This type of method is well suited for small to medium-scale problems (around 100 variables) for which the derivatives are unavailable or not easy to compute and/or for which the function evaluations are expensive or noisy. For a detailed description of the algorithm see Section 11. The algorithm behaviour and solver strategy can be modified by various optional parameters (see Section 12) which can be set by nag_opt_handle_opt_set (e04zmc) and nag_opt_handle_opt_set_file (e04zpc) anytime between the initialization of the handle by nag_opt_handle_init (e04rac) and a call to the solver. The default values for these optional parameters are chosen to work well in the general case but it is recommended to tune them to your particular problem. In particular, if the objective function is noisy, it is highly recommended to set the optional parameter DFLS Trust Region Update to SLOW to improve convergence. Once the solver has finished, options may be modified for the next solve. The solver may be called repeatedly with various starting points and/or optional parameters.

4
References

Powell M J D (2009) The BOBYQA algorithm for bound constrained optimization without derivatives Report DAMTP 2009/NA06 University of Cambridge http://www.damtp.cam.ac.uk/user/na/NA_papers/NA2009_06.pdf
Zhang H, CONN A R and Scheinberg k (2010) A Derivative-Free Algorithm for Least-Squares Minimization SIAM J. Optim. 20(6) 3555–3576

5
Arguments

1:     handle void *Input
On entry: the handle to the problem. It needs to be initialized by nag_opt_handle_init (e04rac) and the objective must be declared as nonlinear least squares by a call to the function nag_opt_handle_set_nlnls (e04rmc). The function nag_opt_handle_set_simplebounds (e04rhc) can optionally be called to define box bounds. It must not be changed between calls to the NAG optimization modelling suite.
2:     objfun function, supplied by the userExternal Function
objfun must evaluate the value of the nonlinear residuals rix at a specified point x.
The specification of objfun is:
void  objfun (Integer nvar, const double x[], Integer nres, double rx[], Integer *inform, Nag_Comm *comm)
1:     nvar IntegerInput
On entry: n, the number of variables in the problem, as set during the initialization of the handle by nag_opt_handle_init (e04rac).
2:     x[nvar] const doubleInput
On entry: x, the vector of variable values at which the residuals ri are to be evaluated.
3:     nres IntegerInput
On entry: mr, the number of residuals in the problem, as set during the initialization of the handle by nag_opt_handle_set_nlnls (e04rmc).
4:     rx[nres] doubleOutput
On exit: the value of the residuals rix at x.
5:     inform Integer *Input/Output
On entry: a non-negative value.
On exit: may be used to request the solver to stop immediately. Specifically, if inform<0 then the value of rx will be discarded and the solver will terminate immediately with fail.code= NE_USER_STOP otherwise, the solver will proceed normally.
6:     comm Nag_Comm *
Pointer to structure of type Nag_Comm; the following members are relevant to objfun.
userdouble *
iuserInteger *
pPointer 
The type Pointer will be void *. Before calling nag_opt_handle_solve_dfls (e04ffc) you may allocate memory and initialize these pointers with various quantities for use by objfun when called from nag_opt_handle_solve_dfls (e04ffc) (see Section 3.3.1.1 in How to Use the NAG Library and its Documentation).
Note: objfun should not return floating-point NaN (Not a Number) or infinity values, since these are not handled by nag_opt_handle_solve_dfls (e04ffc). If your code inadvertently does return any NaNs or infinities, nag_opt_handle_solve_dfls (e04ffc) is likely to produce unexpected results.
3:     mon function, supplied by the userExternal Function
mon is provided to enable you to monitor the progress of the optimization and, if necessary, to halt the optimization process using argument inform.
If no monitoring is required, mon may be specified as NULLFN.
mon is called at the end of every ith step where i is controlled by the optional parameter DFLS Monitor Frequency (default value 0, mon is never called).
The specification of mon is:
void  mon (Integer nvar, const double x[], Integer *inform, const double rinfo[], const double stats[], Nag_Comm *comm)
1:     nvar IntegerInput
On entry: n, the number of variables in the problem.
2:     x[nvar] const doubleInput
On entry: the current best point.
3:     inform Integer *Input/Output
On entry: a non-negative value.
On exit: may be used to request the solver to stop immediately. Specifically, if inform<0 then the value of rx will be discarded and the solver will terminate immediately with fail.code= NE_USER_STOP otherwise, the solver will proceed normally.
4:     rinfo[100] const doubleInput
On entry: best objective value computed and various indicators (the values are as described in the main argument rinfo).
5:     stats[100] const doubleInput
On entry: solver statistics at the end of the current iteration (the values are as described in the main argument stats).
6:     comm Nag_Comm *
Pointer to structure of type Nag_Comm; the following members are relevant to mon.
userdouble *
iuserInteger *
pPointer 
The type Pointer will be void *. Before calling nag_opt_handle_solve_dfls (e04ffc) you may allocate memory and initialize these pointers with various quantities for use by mon when called from nag_opt_handle_solve_dfls (e04ffc) (see Section 3.3.1.1 in How to Use the NAG Library and its Documentation).
4:     nvar IntegerInput
On entry: n, the number of variables in the problem. It must be unchanged from the value set during the initialization of the handle by nag_opt_handle_init (e04rac).
Constraint: nvar2.
5:     x[nvar] doubleInput/Output
On entry: x0, the initial estimates of the variables x.
On exit: the final values of the variables x.
6:     nres IntegerInput
On entry: mr, the number of residuals in the problem. It must be unchanged from the value set during the definition of the objective structure by nag_opt_handle_set_nlnls (e04rmc).
7:     rx[nres] doubleOutput
On exit: the values of the residuals at the final point given in x.
8:     rinfo[100] doubleOutput
On exit: optimal objective value and various indicators at the end of the final iteration as given in the table below:
0 objective function value fx (sum of the squared residuals);
1 ρ, the size of trust region at the end of the algorithm;
2 the number of interpolation points used by the solver.
4-101 reserved for future use.
9:     stats[100] doubleOutput
On exit: solver statistics at the end of the final iteration as given in the table below:
0 number of calls to the objective function;
1 if Stats Time is activated, total time spent in the solver (including time spent evaluating the objective);
2 if Stats Time is activated, total time spent evaluating the objective function;
3 number of steps.
5-101 reserved for future use.
10:   comm Nag_Comm *
The NAG communication argument (see Section 3.3.1.1 in How to Use the NAG Library and its Documentation).
11:   fail NagError *Input/Output
The NAG error argument (see Section 3.7 in How to Use the NAG Library and its Documentation).

6
Error Indicators and Warnings

NE_ALLOC_FAIL
Dynamic memory allocation failed.
See Section 2.3.1.2 in How to Use the NAG Library and its Documentation for further information.
NE_BAD_PARAM
On entry, argument value had an illegal value.
NE_BOUND
Optional argument DFLS Starting Trust Region ρbeg=value, lxi=value, uxi=value and i=value.
Constraint: if lxiuxi in coordinate i, then uxi-lxi2×ρbeg.
Use nag_opt_handle_opt_set (e04zmc) to set compatible option values.
NE_HANDLE
The supplied handle does not define a valid handle to the data structure for the NAG optimization modelling suite. It has not been initialized by nag_opt_handle_init (e04rac) or it has been corrupted.
NE_INT
There were nr=value unequal bounds.
Constraint: nr2.
There were nr=value unequal bounds and the optional argument DFLS Number Interp Points npt=value
Constraint: nr+2nptnr+1×nr+22 .
Use nag_opt_handle_opt_set (e04zmc) to set compatible option values.
NE_INTERNAL_ERROR
An internal error has occurred in this function. Check the function call and any array sizes. If the call is correct then please contact NAG for assistance.
See Section 2.7.6 in How to Use the NAG Library and its Documentation for further information.
NE_NO_IMPROVEMENT
No progress, the solver was stopped after value consecutive slow steps.
Use the optional argument DFLS Maximum Slow Steps to modify the maximum number of slow steps accepted.
The solver stopped after 5×DFLS Maximum Slow Steps consecutive slow steps and a trust region above the tolerance set by DFLS Trust Region Slow Tol.
NE_NO_LICENCE
Your licence key may have expired or may not have been installed correctly.
See Section 2.7.5 in How to Use the NAG Library and its Documentation for further information.
NE_PHASE
The problem is already being solved.
NE_REAL_2
Inconsistent optional arguments DFLS Trust Region Tolerance ρend and DFLS Trust Region Slow Tol ρtol.
Constraint: ρend<ρtol.
Use nag_opt_handle_opt_set (e04zmc) to set compatible option values.
Inconsistent optional arguments DFLS Trust Region Tolerance ρend and DFLS Starting Trust Region ρbeg.
Constraint: ρend<ρbeg.
Use nag_opt_handle_opt_set (e04zmc) to set compatible option values.
NE_REF_MATCH
The information supplied does not match with that previously stored.
On entry, nres=value must match that given during the definition of the objective in the handle, i.e., value.
The information supplied does not match with that previously stored.
On entry, nvar=value must match that given during initialization of the handle, i.e., value.
NE_RESCUE_FAILED
A rescue procedure has been called in order to correct damage from rounding errors when computing an update to a quadratic approximation of F, but no further progress could be made. Check your specification of objfun and whether the function needs rescaling. Try a different initial x.
NE_SETUP_ERROR
The solver does not support the model defined in the handle.
It supports only nonlinear least squares problems with bound constraints.
NE_TIME_LIMIT
The solver terminated after the maximum time allowed was exceeded.
Maximum number of seconds exceeded. Use option Time Limit to reset the limit.
NE_TOO_MANY_ITER
Maximum number of function evaluations exceeded.
NE_TR_STEP_FAILED
The predicted reduction in a trust region step was non-positive. Check your specification of objfun and whether the function needs rescaling. Try a different initial x.
NE_USER_STOP
User requested termination after a call to the objective function. inform was set to a negative value within the user-supplied function objfun.
User requested termination during a monitoring step. inform was set to a negative value within the user-supplied function mon
NW_NOT_CONVERGED
The problem was solved to an acceptable level after value consecutive slow iterations.
Use the optional argument DFLS Maximum Slow Steps to modify the maximum number of slow steps accepted.
The solver stopped after DFLS Maximum Slow Steps consecutive slow steps and a trust region below the tolerance set by DFLS Trust Region Slow Tol.

7
Accuracy

The solver can declare convergence on two conditions:
(i) The trust region radius is below the tolerance ρend set by the optional parameter DFLS Trust Region Tolerance. When this condition is met, the corresponding solution will generally be at a distance lower than 10×ρend of a local minimimum.
(ii) The sum of the square of the residuals is below the tolerance set by the optional parameter DFLS Small Residuals Tol. In a data fitting context, this condition means that the error between the observed data and the model is smaller than the requested tolerance.

8
Parallelism and Performance

nag_opt_handle_solve_dfls (e04ffc) makes calls to BLAS and/or LAPACK routines, which may be threaded within the vendor library used by this implementation. Consult the documentation for the vendor library for further information.
Please consult the x06 Chapter Introduction for information on how to control and interrogate the OpenMP environment used within this function. Please also consult the Users' Note for your implementation for any additional implementation-specific information.

9
Further Comments

9.1
Description of the Printed Output

The solver can print information to give an overview of the problem and of the progress of the computation. The output may be sent to two independent file ID which are set by optional parameters Print File and Monitoring File. Optional parameters Print Level, Print Options, Monitoring Level and Print Solution determine the exposed level of detail. This allows, for example, a detailed log file to be generated while the condensed information is displayed on the screen.
By default (Print File=6, Print Level=2), four sections are printed to the standard output: a header, a list of options, an iteration log and a summary.
Header
The header contains statistics about the problem. It should look like:
  ----------------------------------------------
  E04FF, Derivative-free solver for data fitting
         (nonlinear least squares problems)
  ----------------------------------------------
  Problem statistics
    Number of variables                 10
    Number of unconstrained variables   10
    Number of fixed variables            0
    Number of residuals                 10
Optional parameters list
If Print Options is set to YES, a list of the optional parameters and their values is printed. The list shows all options of the solver, each displayed on one line. The line contains the option name, its current value and an indicator for how it was set. The options left at their defaults are noted by (d) and the ones set by the user are noted by (U). Note that the output format is compatible with the file format expected by nag_opt_handle_opt_set_file (e04zpc). The output looks as follows:
     Stats Time                    =                 Yes     * U
     Dfls Trust Region Tolerance   =         1.00000E-07     * U
     Dfls Max Objective Calls      =                 500     * d
     Dfls Starting Trust Region    =         1.10000E-01     * U
     Dfls Number Interp Points     =                   0     * d
Iteration log
If Print Level2, the solver will print a summary line for each step. An iteration is considered successful when it yields a decrease of the objective sufficiently close to the decrease predicted by the quadratic model. The line shows the step number, the value of the objective function, the radius of the trust region and the cumulative number of objective function evaluations. The output looks as follow:
  ----------------------------------------
   step |    obj       rho     |    nf   |
  ----------------------------------------
      1 |  3.82E+01  1.10E-01  |    13   |
      2 |  3.55E+01  1.10E-01  |    14   |
      3 |  3.05E+01  1.10E-01  |    15   |
      4 |  2.15E+01  1.10E-01  |    18   |
Occasionally, the letter ‘s’ is printed at the end of the line indicating that the progress is considered slow by the slow convergence detection heuristic. After a certain number of consecutive slow steps, the solver is stopped. The limit on the number of slow iterations can be controlled by the optional parameter DFLS Maximum Slow Steps and the tolerance on the trust region radius before the solver can be stopped is driven by DFLS Trust Region Slow Tol.
Summary
Once the solver finishes, a summary is produced:
  Status: Converged, small trust region size.
 
  Value of the objective                    2.23746E-06
  Number of objective function evaluations          107
  Number of steps                                    51
Optionally, if Stats Time is set to YES, the timings are printed:
  Timings
     Total time spent in the solver            0.056
     Time spent in the objective evaluation    0.012
Additionally, if Print Solution is set to YES, the solution is printed along with the bounds:
  Computed Solution:
    idx   Lower bound        Value      Upper bound
      1       -inf       -1.00000E+00        inf
      2       -inf       -1.00000E+00        inf
      3       -inf       -1.00000E+00        inf
      4       -inf       -1.00000E+00        inf

10
Example

In this example, we minimize the Kowalik and Osborne function with bounds on some of the variables. In this problem, the number of variables n=4 and the number of residuals mr=11. The residuals ri are computed by
rix = zi- yi yi+ x2 yi yi+ x3 +x4 x1 (2)
where
y = 4.0000,2.0000,1.0000,0.5000,0.2500,0.1670,0.1250,0.1000,0.0833,0.0714,0.0625 z = 0.1957,0.1947,0.1735,0.1600,0.0844,0.0627,0.0456,0.0342,0.0323,0.0235,0.0246 (3)
The following bounds are defined on the variables
0.2 x2 1.0 0.3 x4 (4)
The initial guess is
x0= 0.25,0.39,0.415,0.39 (5)
The expected solution is
x*= 0.1813,0.5901,0.2569,0.3000 (6)

10.1
Program Text

Program Text (e04ffce.c)

10.2
Program Data

None.

10.3
Program Results

Program Results (e04ffce.r)

11
Algorithmic Details

This section contains a short description of the algorithm used in nag_opt_handle_solve_dfls (e04ffc) which is based on Powell's method BOBYQA Powell (2009) and the work of Zhang et al. (2010). It is based on a model-based derivative-free trust region framework adapted to exploit least squares problems structure.

11.1
Derivative-free trust region algorithm

In this section, we are interested in generic problems of the form
minimize xn fx (7)
where the derivatives of the objective function f are not easily available. A model-based derivative-free optimization (DFO) algorithm maintains a set of points Yk centred on an iterate xk to build quadratic interpolation models of the objective
fxk+s ϕks= fxk+ gkTs+ 12sTHks (8)
where gk and Hk are built with the interpolation conditions
yYk , ​ϕk y-xk =fy (9)
Note that if the number of interpolation points npt is smaller than nr+1×nr+22, the model chosen is the one for which the hessian Hk is the closest to Hk-1 in the Frobenius norm sense. This model is iteratively optimized over a trust region, updated and moved around the new computed points. More precisely, it can be described as: In the rest of this documentation page, we call an iteration successful when the trial point xk+sk is accepted as the next iterate.

11.2
Bounds on the variables

The bounds on the variables are handled during the model optimization step (step 2(i) of DFO Algorithm) with an active set method. If a bound is hit, it is fixed and step 2(i) is restarted. The set of active constraints is kept throughout the optimization, progressively fixing the corresponding variables.

11.3
Adaptation to nonlinear least squares problems

In the specific case where f is a sum of square fx=i=1mrrix2, a good approximation of the hessian of the objective can be
2fx JxTJx (10)
where J is the mr by n first derivative matrix of f. This approximation is the main idea behind the Gauss–Newton and Levenberg–Marquardt methods. Following the work of Zhang et al. (2010), it is possible to adapt it to the DFO framework. In nag_opt_handle_solve_dfls (e04ffc), one quadratic model is built for each residual ri 
rix+s rix+ g(i)Ts+ 12sTH(i)s (11)
We call J=g(1),g(2),...T. To build the model of the objective f, we then choose
fx+s ϕs= fx+ gfTs+ 12sTHfs (12)
where gf is chosen as
gf= JTfx (13)
and Hf as
Hf= JTJ + 0 if   gfκ1 κ3 fxI if   gf<κ1   and   12 fx< κ2gf i=1 mr rix H(i) otherwise (14)
The constants κ1, κ2 and κ3 are chosen as proposed in Zhang et al. (2010). The first expression amounts to making a Gauss–Newton approximation when we are far from a stationary point, the second to a Levenberg–Marquardt approximation when we are close to a stationary point with small residuals while the third takes the full hessian into account.
nag_opt_handle_solve_dfls (e04ffc) integrates this method of building models into the framework presented in the algorithm DFO Algorithm.

12
Optional Parameters

Several optional parameters in nag_opt_handle_solve_dfls (e04ffc) define choices in the problem specification or the algorithm logic. In order to reduce the number of formal arguments of nag_opt_handle_solve_dfls (e04ffc) these optional parameters have associated default values that are appropriate for most problems. Therefore, you need only specify those optional parameters whose values are to be different from their default values.
The remainder of this section can be skipped if you wish to use the default values for all optional parameters.
The optional parameters can be changed by calling nag_opt_handle_opt_set (e04zmc) anytime between the initialization of the handle by nag_opt_handle_init (e04rac) and the call to the solver. Modification of the arguments during intermediate monitoring stops is not allowed. Once the solver finishes, the optional parameters can be altered again for the next solve.
The option values may be retrieved by nag_opt_handle_opt_get (e04znc).
The following is a list of the optional parameters available. A full description of each optional parameter is provided in Section 12.1.

12.1
Description of the Optional Parameters

For each option, we give a summary line, a description of the optional parameter and details of constraints.
The summary line contains:
All options accept the value DEFAULT to return single options to their default states.
Keywords and character values are case and white space insensitive.
Defaults
This special keyword may be used to reset all optional parameters to their default values. Any argument value given with this keyword will be ignored.
DFLS Maximum Slow StepsiDefault =20
If DFLS Maximum Slow Steps>0, this argument defines the maximum number of consecutive slow iterations nslow allowed. Set it to 0 to deactivate the slow iteration detection. The algorithm can stop in two situations:
nslow>DFLS Maximum Slow Steps and ρ<DFLS Trust Region Slow Tol with fail.code= NW_NOT_CONVERGED
nslow>5×DFLS Maximum Slow Steps with fail.code= NE_NO_IMPROVEMENT
Constraint: DFLS Maximum Slow Steps0.
DFLS Max Objective CallsiDefault =500
A limit on the number of objective function evaluations the solver is allowed to compute. If the limit is reached, the solver stops with fail.code= NE_TOO_MANY_ITER.
Constraint: DFLS Max Objective Calls1.
DFLS Monitor FrequencyiDefault =0
If DFLS Monitor Frequency>0, the solver calls the user defined monitoring function mon at the end of every ith step.
Constraint: DFLS Monitor Frequency0.
DFLS Number Interp PointsiDefault =0
The number of interpolation points in Yk (9) used to build the quadratic models. If DFLS Number Interp Points=0, the number of points is chosen to be nr+2 where nr is the number of non-fixed variables.
Constraint: DFLS Number Interp Points0.
Consistency constraint, the solver stops with fail.code= NE_INT if not met:
nr+2DFLS Number Interp Pointsnr+1×nr+22.
DFLS Print FrequencyiDefault =1
If DFLS Print Frequency>0, the solver prints the iteration log to the appropriate units at the end of every ith step.
Constraint: DFLS Print Frequency0.
DFLS Small Residuals TolrDefault =ε0.75
This option defines the tolerance on the value of the residuals. Namely, the solver declares convergence if
f x = i=1 mr ri x 2 < DFLS Small Residuals Tol .
Constraint: DFLS Small Residuals Tol>ε2.
DFLS Starting Trust RegionrDefault =0.1
ρbeg, the initial trust region radius. This argument should be set to about one tenth of the greatest expected overall change to a variable: the initial quadratic model will be constructed by taking steps from the initial x of length ρbeg along each coordinate direction. The default value assumes that the variables have an order of magnitude 1.
Constraint: DFLS Starting Trust Region>ε.
Consistency constraints, the solver stops with fail.code= NE_BOUND or NE_REAL_2 if not met:
DFLS Starting Trust RegionDFLS Trust Region Tolerance.
DFLS Starting Trust Region 12 mini uxi-lxi
DFLS Trust Region TolerancerDefault =ε0.37
ρend, the requested trust region radius. The algorithm declares convergence when the trust region radius reaches this limit. It should indicate the absolute accuracy that is required in the final values of the variables.
Constraint: DFLS Trust Region Tolerance>ε.
Consistency constraints, the solver stops with fail.code= NE_BOUND or NE_REAL_2 if not met:
DFLS Starting Trust Region>DFLS Trust Region Tolerance.
DFLS Trust Region Slow TolrDefault =ε0.25
The minimal acceptable trust region radius for the solution to be declared as acceptable. The solver stops if:
nslow>DFLS Maximum Slow Steps and ρk<DFLS Trust Region Slow Tol
Constraint: DFLS Trust Region Slow Tol>ε.
Consistency constraints, the solver stops with fail.code= NE_BOUND or NE_REAL_2 if not met:
DFLS Trust Region Slow Tol>DFLS Trust Region Tolerance
DFLS Trust Region UpdateaDefault =FAST
Controls the speed at which the trust region is decreased after unsuccessful iterations. In smooth non-noisy cases, a fast decrease often leads to faster convergence. However, in noisy cases, a slow decrease is recommended to avoid premature stops.
Constraint: DFLS Trust Region Update=FAST or SLOW.
Infinite Bound SizerDefault =1020
This defines the ‘infinite’ bound bigbnd in the definition of the problem constraints. Any upper bound greater than or equal to bigbnd will be regarded as + (and similarly any lower bound less than or equal to -bigbnd will be regarded as -). Note that a modification of this optional parameter does not influence constraints which have already been defined; only the constraints formulated after the change will be affected.
Constraint: Infinite Bound Size1000.
Monitoring FileiDefault =-1
(See Section 3.3.1.1 in How to Use the NAG Library and its Documentation for further information on NAG data types.)
If i0, the Nag_FileID number (as returned from nag_open_file (x04acc)) for the secondary (monitoring) output. If set to -1, no secondary output is provided. The information output to this file ID is controlled by Monitoring Level.
Constraint: Monitoring File-1.
Monitoring LeveliDefault =4
This argument sets the amount of information detail that will be printed by the solver to the secondary output. The meaning of the levels is the same as with Print Level.
Constraint: 0Monitoring Level5.
Print FileiDefault =Nag_FileID number associated with stdout 
(See Section 3.3.1.1 in How to Use the NAG Library and its Documentation for further information on NAG data types.)
If i0, the Nag_FileID number (as returned from nag_open_file (x04acc), stdout as the default) for the primary output of the solver. If Print File=-1, the primary output is completely turned off independently of other settings. The information output to this unit is controlled by Print Level.
Constraint: Print File-1.
Print LeveliDefault =2
This argument defines how detailed information should be printed by the solver to the primary and secondary output.
i Output
0 No output from the solver
1 The Header and Summary.
2, 3, 4, 5 Additionally, the Iteration log.
Constraint: 0Print Level5.
Print OptionsaDefault =YES
If Print Options=YES, a listing of optional parameters will be printed to the primary output. It is always printed to the secondary output.
Constraint: Print Options=YES or NO.
Print SolutionaDefault =NO
If Print Solution=YES, the solution will be printed to the primary and secondary output.
Constraint: Print Solution=NO or YES.
Stats TimeaDefault =NO
This argument turns on timings of various parts of the algorithm to give a better overview of where most of the time is spent. This might be helpful for a choice of different solving approaches. It is possible to choose between CPU and wall clock time. Choice YES is equivalent to wall clock.
Constraint: Stats Time=YES, NO, CPU or WALL CLOCK.
Time LimitrDefault =106
A limit on seconds that the solver can use to solve one problem. If during the convergence check this limit is exceeded, the solver will terminate with fail.code= NE_TIME_LIMIT error message.
Warning: the timings are not computed if Stats Time is set to NO. The solver will therefore NOT be stopped if the time limit is exceeded in such a case.
Constraint: Time Limit>0.