NAG FL Interface
e05sbf (nlp_pso)
Note: this routine 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
e05sbf is designed to search for the global minimum or maximum of an arbitrary function, subject to general nonlinear constraints, using Particle Swarm Optimization (PSO). Derivatives are not required, although these may be used by an accompanying local minimization routine if desired.
e05sbf is essentially identical to
e05saf, with an expert interface and various additional arguments added; otherwise most arguments are identical. In particular,
e05saf does not handle general constraints.
2
Specification
Fortran Interface
Subroutine e05sbf ( 
ndim, ncon, npar, xb, fb, cb, bl, bu, xbest, fbest, cbest, objfun, confun, monmod, iopts, opts, iuser, ruser, itt, inform, ifail) 
Integer, Intent (In) 
:: 
ndim, ncon, npar 
Integer, Intent (Inout) 
:: 
iopts(*), iuser(*), ifail 
Integer, Intent (Out) 
:: 
itt(7), inform 
Real (Kind=nag_wp), Intent (In) 
:: 
bl(ndim+ncon), bu(ndim+ncon) 
Real (Kind=nag_wp), Intent (Inout) 
:: 
xbest(ndim,npar), fbest(npar), cbest(ncon,npar), opts(*), ruser(*) 
Real (Kind=nag_wp), Intent (Out) 
:: 
xb(ndim), fb, cb(ncon) 
External 
:: 
objfun, confun, monmod 

C Header Interface
#include <nag.h>
void 
e05sbf_ (const Integer *ndim, const Integer *ncon, const Integer *npar, double xb[], double *fb, double cb[], const double bl[], const double bu[], double xbest[], double fbest[], double cbest[], void (NAG_CALL *objfun)(Integer *mode, const Integer *ndim, const double x[], double *objf, double vecout[], const Integer *nstate, Integer iuser[], double ruser[]), void (NAG_CALL *confun)(Integer *mode, const Integer *ncon, const Integer *ndim, const Integer *ldcj, const Integer needc[], const double x[], double c[], double cjac[], const Integer *nstate, Integer iuser[], double ruser[]), void (NAG_CALL *monmod)(const Integer *ndim, const Integer *ncon, const Integer *npar, double x[], const double xb[], const double *fb, const double cb[], const double xbest[], const double fbest[], const double cbest[], const Integer itt[], Integer iuser[], double ruser[], Integer *inform), Integer iopts[], double opts[], Integer iuser[], double ruser[], Integer itt[], Integer *inform, Integer *ifail) 

C++ Header Interface
#include <nag.h> extern "C" {
void 
e05sbf_ (const Integer &ndim, const Integer &ncon, const Integer &npar, double xb[], double &fb, double cb[], const double bl[], const double bu[], double xbest[], double fbest[], double cbest[], void (NAG_CALL *objfun)(Integer &mode, const Integer &ndim, const double x[], double &objf, double vecout[], const Integer &nstate, Integer iuser[], double ruser[]), void (NAG_CALL *confun)(Integer &mode, const Integer &ncon, const Integer &ndim, const Integer &ldcj, const Integer needc[], const double x[], double c[], double cjac[], const Integer &nstate, Integer iuser[], double ruser[]), void (NAG_CALL *monmod)(const Integer &ndim, const Integer &ncon, const Integer &npar, double x[], const double xb[], const double &fb, const double cb[], const double xbest[], const double fbest[], const double cbest[], const Integer itt[], Integer iuser[], double ruser[], Integer &inform), Integer iopts[], double opts[], Integer iuser[], double ruser[], Integer itt[], Integer &inform, Integer &ifail) 
}

The routine may be called by the names e05sbf or nagf_glopt_nlp_pso.
Before calling
e05sbf,
e05zkf must be called with
optstr set to ‘
Initialize = e05sbf’. Optional parameters may also be specified by calling
e05zkf before the call to
e05sbf.
3
Description
e05sbf uses a stochastic method based on Particle Swarm Optimization (PSO) to search for the global optimum of a nonlinear function
$F$, subject to a set of bound constraints on the variables, and optionally a set of general nonlinear constraints. In the PSO algorithm (see
Section 11), a set of particles is generated in the search space, and advances each iteration to (hopefully) better positions using a heuristic velocity based upon
inertia,
cognitive memory and
global memory. The inertia is provided by a decreasingly weighted contribution from a particles current velocity, the cognitive memory refers to the best candidate found by an individual particle and the global memory refers to the best candidate found by all the particles. This allows for a global search of the domain in question.
Further, this may be coupled with a selection of local minimization routines, which may be called during the iterations of the heuristic algorithm, the interior phase, to hasten the discovery of locally optimal points, and after the heuristic phase has completed to attempt to refine the final solution, the exterior phase. Different options may be set for the local optimizer in each phase.
Without loss of generality, the problem is assumed to be stated in the following form:
where the objective
$F\left(\mathbf{x}\right)$ is a scalar function,
$\mathbf{c}\left(\mathbf{x}\right)$ is a vector of scalar constraint functions,
$\mathbf{x}$ is a vector in
${R}^{\mathit{ndim}}$ and the vectors
$\mathbf{\ell}\le \mathbf{u}$ are lower and upper bounds respectively for the
$\mathit{ndim}$ variables and
$\mathit{ncon}$ constraints. Both the objective function and the
$\mathit{ncon}$ constraints may be nonlinear. Continuity of
$F$, and the functions
$\mathbf{c}\left(\mathbf{x}\right)$, is not essential. For functions which are smooth and primarily unimodal, faster solutions will almost certainly be achieved by using
Chapter E04 routines directly.
For functions which are smooth and multimodal, gradient dependent local minimization routines may be coupled with e05sbf.
For multimodal functions for which derivatives cannot be provided, particularly functions with a significant level of noise in their evaluation,
e05sbf should be used either alone, or coupled with
e04cbf.
For heavily constrained problems,
e05sbf should either be used alone, or coupled with
e04ucf/e04uca provided the function and the constraints are sufficiently smooth.
The
$\mathit{ndim}$ lower and upper box bounds on the variable
$\mathbf{x}$ are included to initialize the particle swarm into a finite hypervolume, although their subsequent influence on the algorithm is user determinable (see the option
Boundary in
Section 12). It is strongly recommended that sensible bounds are provided for all variables and constraints.
e05sbf may also be used to maximize the objective function, or to search for a feasible point satisfying the simple bounds and general constraints (see the option
Optimize).
Due to the nature of global optimization, unless a predefined target is provided, there is no definitive way of knowing when to end a computation. As such several stopping heuristics have been implemented into the algorithm. If any of these is achieved,
e05sbf will exit with
${\mathbf{ifail}}={\mathbf{1}}$, and the parameter
inform will indicate which criteria was reached. See
inform for more information.
In addition, you may provide your own stopping criteria through
monmod,
objfun and
confun.
e05saf provides a simpler interface, without the inclusion of general nonlinear constraints.
4
References
Gill P E, Murray W and Wright M H (1981) Practical Optimization Academic Press
Kennedy J and Eberhart R C (1995) Particle Swarm Optimization Proceedings of the 1995 IEEE International Conference on Neural Networks 1942–1948
Koh B, George A D, Haftka R T and Fregly B J (2006) Parallel Asynchronous Particle Swarm Optimization International Journal for Numerical Methods in Engineering 67(4) 578–595
Vaz A I and Vicente L N (2007) A Particle Swarm Pattern Search Method for Bound Constrained Global Optimization Journal of Global Optimization 39(2) 197–219 Kluwer Academic Publishers
5
Arguments
Note: for descriptions of the symbolic variables, see
Section 11.

1:
$\mathbf{ndim}$ – Integer
Input

On entry: $\mathit{ndim}$, the number of dimensions.
Constraint:
${\mathbf{ndim}}\ge 1$.

2:
$\mathbf{ncon}$ – Integer
Input

On entry: $\mathit{ncon}$, the number of constraints, not including box constraints.
Constraint:
${\mathbf{ncon}}\ge 0$.

3:
$\mathbf{npar}$ – Integer
Input

On entry:
$\mathit{npar}$, the number of particles to be used in the swarm. Assuming all particles remain within constraints, each complete iteration will perform at least
npar function evaluations. Otherwise, significantly fewer objective function evaluations may be performed.
Suggested value:
${\mathbf{npar}}=10\times {\mathbf{ndim}}$.
Constraint:
${\mathbf{npar}}\ge 5\times \mathbf{num\_threads}$, where num_threads is the value returned by the OpenMP environment variable OMP_NUM_THREADS, or num_threads is $1$ for a serial version of this routine.

4:
$\mathbf{xb}\left({\mathbf{ndim}}\right)$ – Real (Kind=nag_wp) array
Output

On exit: the location of the best solution found, $\stackrel{~}{\mathbf{x}}$, in ${R}^{\mathit{ndim}}$.

5:
$\mathbf{fb}$ – Real (Kind=nag_wp)
Output

On exit: the objective value of the best solution, $\stackrel{~}{f}=F\left(\stackrel{~}{\mathbf{x}}\right)$.

6:
$\mathbf{cb}\left({\mathbf{ncon}}\right)$ – Real (Kind=nag_wp) array
Output

On exit: the constraint violations of the best solution found,
$\stackrel{~}{\mathbf{e}}=\mathbf{e}\left(\stackrel{~}{\mathbf{x}}\right)$. These may have been deemed to be acceptable given the tolerance and scaling of the constraints. See
Sections 11 and
12.

7:
$\mathbf{bl}\left({\mathbf{ndim}}+{\mathbf{ncon}}\right)$ – Real (Kind=nag_wp) array
Input

8:
$\mathbf{bu}\left({\mathbf{ndim}}+{\mathbf{ncon}}\right)$ – Real (Kind=nag_wp) array
Input

On entry:
${\mathbf{bl}}$ is
$\mathbf{\ell}$, the array of lower bounds,
bu is
$\mathbf{u}$, the array of upper bounds. The first
ndim entries in
bl and
bu must contain the lower and upper simple (box) bounds of the variables respectively. These must be provided to initialize the sample population into a finite hypervolume, although their subsequent influence on the algorithm is user determinable (see the option
Boundary in
Section 12).
The next
ncon entries must contain the lower and upper bounds for any general constraints respectively.
If
${\mathbf{bl}}\left(i\right)={\mathbf{bu}}\left(i\right)$ for any
$i\in \left\{1,\dots ,{\mathbf{ndim}}\right\}$, variable
$i$ will remain locked to
${\mathbf{bl}}\left(i\right)$ regardless of the
Boundary option selected.
It is strongly advised that you place sensible lower and upper bounds on all variables and constraints, even if your model allows for unbounded variables or constraints.
Constraints:
 ${\mathbf{bl}}\left(\mathit{i}\right)\le {\mathbf{bu}}\left(\mathit{i}\right)$, for $\mathit{i}=1,2,\dots ,{\mathbf{ndim}}+{\mathbf{ncon}}$;
 ${\mathbf{bl}}\left(i\right)\ne {\mathbf{bu}}\left(i\right)$ for at least one $i\in \left\{1,\dots ,{\mathbf{ndim}}\right\}$.

9:
$\mathbf{xbest}\left({\mathbf{ndim}},{\mathbf{npar}}\right)$ – Real (Kind=nag_wp) array
Input/Output

Note: the $i$th component of the best position of the $j$th particle, ${\hat{x}}_{j}\left(i\right)$, is stored in ${\mathbf{xbest}}\left(i,j\right)$.
On entry: if using ${\mathbf{Start}}=\mathrm{WARM}$, the initial particle positions, ${\hat{\mathbf{x}}}_{j}^{0}$.
On exit: the best positions found,
${\hat{\mathbf{x}}}_{j}$, by the
npar particles in the swarm.

10:
$\mathbf{fbest}\left({\mathbf{npar}}\right)$ – Real (Kind=nag_wp) array
Input/Output

On entry: if using
${\mathbf{Start}}=\mathrm{WARM}$, objective function values,
${\hat{f}}_{j}^{0}=F\left({\hat{\mathbf{x}}}_{j}^{0}\right)$, corresponding to the
npar particle locations stored in
xbest.
On exit: objective function values,
${\hat{f}}_{j}=F\left({\hat{\mathbf{x}}}_{j}\right)$, corresponding to the locations returned in
xbest.

11:
$\mathbf{cbest}\left({\mathbf{ncon}},{\mathbf{npar}}\right)$ – Real (Kind=nag_wp) array
Input/Output

Note: the $k$th constraint violation of the $j$th particle is stored in ${\mathbf{cbest}}\left(k,j\right)$.
On entry: if using
${\mathbf{Start}}=\mathrm{WARM}$, the initial constraint violations,
${\hat{\mathbf{e}}}_{j}^{0}=\mathbf{e}\left({\hat{\mathbf{x}}}_{j}^{0}\right)$, corresponding to the
npar particle locations.
On exit: the final constraint violations,
${\hat{\mathbf{e}}}_{j}$, corresponding to the locations returned in
xbest.

12:
$\mathbf{objfun}$ – Subroutine, supplied by the user.
External Procedure

objfun must, depending on the value of
mode, calculate the objective function
and/or calculate the gradient of the objective function for a
$\mathit{ndim}$variable vector
$\mathbf{x}$. Gradients are only required if a local minimizer has been chosen which requires gradients. See the option
Local Minimizer for more information.
The specification of
objfun is:
Fortran Interface
Integer, Intent (In) 
:: 
ndim, nstate 
Integer, Intent (Inout) 
:: 
mode, iuser(*) 
Real (Kind=nag_wp), Intent (In) 
:: 
x(ndim) 
Real (Kind=nag_wp), Intent (Inout) 
:: 
objf, vecout(ndim), ruser(*) 

C++ Header Interface
#include <nag.h> extern "C" {
}


1:
$\mathbf{mode}$ – Integer
Input/Output

On entry: indicates which functionality is required.
 ${\mathbf{mode}}=0$
 $F\left(\mathbf{x}\right)$ should be returned in objf. The value of objf on entry may be used as an upper bound for the calculation. Any expected value of $F\left(\mathbf{x}\right)$ that is greater than objf may be approximated by this upper bound; that is objf can remain unaltered.
 ${\mathbf{mode}}=1$
 ${\mathbf{Local\; Minimizer}}=\mathrm{e04ucf}$ only
First derivatives can be evaluated and returned in vecout. Any unaltered elements of vecout will be approximated using finite differences.
 ${\mathbf{mode}}=2$
 ${\mathbf{Local\; Minimizer}}=\mathrm{e04ucf}$ only
$F\left(\mathbf{x}\right)$ must be calculated and returned in objf, and available first derivatives can be evaluated and returned in vecout. Any unaltered elements of vecout will be approximated using finite differences.
 ${\mathbf{mode}}=5$
 $F\left(\mathbf{x}\right)$ must be calculated and returned in objf. The value of objf on entry may not be used as an upper bound.
 ${\mathbf{mode}}=6$
 ${\mathbf{Local\; Minimizer}}=\mathrm{e04dgf}$ or $\mathrm{e04kzf}$ only
All first derivatives must be evaluated and returned in vecout.
 ${\mathbf{mode}}=7$
 ${\mathbf{Local\; Minimizer}}=\mathrm{e04dgf}$ or $\mathrm{e04kzf}$ only
$F\left(\mathbf{x}\right)$ must be calculated and returned in objf, and all first derivatives must be evaluated and returned in vecout.
On exit: if the value of
mode is set to be negative,
e05sbf will exit as soon as possible with
${\mathbf{ifail}}={\mathbf{3}}$ and
${\mathbf{inform}}={\mathbf{mode}}$.

2:
$\mathbf{ndim}$ – Integer
Input

On entry: the number of dimensions.

3:
$\mathbf{x}\left({\mathbf{ndim}}\right)$ – Real (Kind=nag_wp) array
Input

On entry: $\mathbf{x}$, the point at which the objective function and/or its gradient are to be evaluated.

4:
$\mathbf{objf}$ – Real (Kind=nag_wp)
Input/Output

On entry: the value of
objf passed to
objfun varies with the argument
mode.
 ${\mathbf{mode}}=0$
 objf is an upper bound for the value of $F\left(\mathbf{x}\right)$, often equal to the best constraint penalised value of $F\left(\mathbf{x}\right)$ found so far by a given particle if the objective function is strictly positive (see Section 11). Only objective function values less than the value of objf on entry will be used further. As such this upper bound may be used to stop further evaluation when this will only increase the objective function value above the upper bound.
 ${\mathbf{mode}}=1$, $2$, $5$, $6$ or $7$
 objf is meaningless on entry.
On exit: the value of
objf returned varies with the argument
mode.
 ${\mathbf{mode}}=0$
 objf must be the value of $F\left(\mathbf{x}\right)$. Only values of $F\left(\mathbf{x}\right)$ strictly less than objf on entry need be accurate.
 ${\mathbf{mode}}=1$ or $6$
 Need not be set.
 ${\mathbf{mode}}=2$, $5$ or $7$
 $F\left(\mathbf{x}\right)$ must be calculated and returned in objf. The entry value of objf may not be used as an upper bound.

5:
$\mathbf{vecout}\left({\mathbf{ndim}}\right)$ – Real (Kind=nag_wp) array
Input/Output

On entry: if
${\mathbf{Local\; Minimizer}}=\mathrm{e04ucf}$ or
$\mathrm{}$,
the values of
vecout are used internally to indicate whether a finite difference approximation is required. See
e04ucf/e04uca.
On exit: the required values of
vecout returned to the calling routine depend on the value of
mode.
 ${\mathbf{mode}}=0$ or $5$
 The value of vecout need not be set.
 ${\mathbf{mode}}=1$ or $2$
 vecout can contain components of the gradient of the objective function $\frac{\partial F}{\partial {x}_{i}}$ for some $i=1,2,\dots {\mathbf{ndim}}$, or acceptable approximations. Any unaltered elements of vecout will be approximated using finite differences.
 ${\mathbf{mode}}=6$ or $7$
 vecout must contain the gradient of the objective function $\frac{\partial F}{\partial {x}_{i}}$ for all $i=1,2,\dots {\mathbf{ndim}}$. Approximation of the gradient is strongly discouraged, and no finite difference approximations will be performed internally (see e04dgf/e04dga and e04kzf).

6:
$\mathbf{nstate}$ – Integer
Input

On entry:
nstate indicates various stages of initialization throughout the routine. This allows for permanent global arguments to be initialized the least number of times. For example, you may initialize a random number generator seed.
 ${\mathbf{nstate}}=3$
 SMP users only. objfun is called for the first time in a parallel region on a new thread other than the master thread. You may use this opportunity to set up any threaddependent information in iuser and ruser.
 ${\mathbf{nstate}}=2$
 objfun is called for the very first time. You may save computational time if certain data must be read or calculated only once.
 ${\mathbf{nstate}}=1$
 objfun is called for the first time by a NAG local minimization routine. You may save computational time if certain data required for the local minimizer need only be calculated at the initial point of the local minimization.
 ${\mathbf{nstate}}=0$
 Used in all other cases.

7:
$\mathbf{iuser}\left(*\right)$ – Integer array
User Workspace

8:
$\mathbf{ruser}\left(*\right)$ – Real (Kind=nag_wp) array
User Workspace

objfun is called with the arguments
iuser and
ruser as supplied to
e05sbf. You should use the arrays
iuser and
ruser to supply information to
objfun.
objfun must either be a module subprogram USEd by, or declared as EXTERNAL in, the (sub)program from which
e05sbf is called. Arguments denoted as
Input must
not be changed by this procedure.
Note: objfun should not return floatingpoint NaN (Not a Number) or infinity values, since these are not handled by
e05sbf. If your code inadvertently
does return any NaNs or infinities,
e05sbf is likely to produce unexpected results.

13:
$\mathbf{confun}$ – Subroutine, supplied by the NAG Library or the user.
External Procedure

confun must calculate any constraints other than the box constraints. If no constraints are required,
confun may be
the dummy constraint routine
e05szm. (
e05szm is included in the NAG Library).
For information on how a NAG local minimizer will use
confun see the documentation for
e04uca.
The specification of
confun is:
Fortran Interface
Subroutine confun ( 
mode, ncon, ndim, ldcj, needc, x, c, cjac, nstate, iuser, ruser) 
Integer, Intent (In) 
:: 
ncon, ndim, ldcj, needc(ncon), nstate 
Integer, Intent (Inout) 
:: 
mode, iuser(*) 
Real (Kind=nag_wp), Intent (In) 
:: 
x(ndim) 
Real (Kind=nag_wp), Intent (Inout) 
:: 
cjac(ldcj,ndim), ruser(*) 
Real (Kind=nag_wp), Intent (Out) 
:: 
c(ncon) 

C Header Interface
void 
confun_ (Integer *mode, const Integer *ncon, const Integer *ndim, const Integer *ldcj, const Integer needc[], const double x[], double c[], double cjac[], const Integer *nstate, Integer iuser[], double ruser[]) 

C++ Header Interface
#include <nag.h> extern "C" {
void 
confun_ (Integer &mode, const Integer &ncon, const Integer &ndim, const Integer &ldcj, const Integer needc[], const double x[], double c[], double cjac[], const Integer &nstate, Integer iuser[], double ruser[]) 
}


1:
$\mathbf{mode}$ – Integer
Input/Output

On entry: indicates which values must be assigned during each call of
confun. Only the following values need be assigned, for each value of
$k\in \left\{1,\dots ,{\mathbf{ncon}}\right\}$ such that
${\mathbf{needc}}\left(k\right)>0$:
 ${\mathbf{mode}}=0$
 the constraint values ${c}_{k}\left(\mathbf{x}\right)$.
 ${\mathbf{mode}}=1$
 rows of the constraint Jacobian,
$\frac{\partial {c}_{k}}{\partial {x}_{\mathit{i}}}\left(\mathbf{x}\right)$, for $\mathit{i}=1,2,\dots ,{\mathbf{ndim}}$.
 ${\mathbf{mode}}=2$
 the constraint values ${c}_{k}\left(\mathbf{x}\right)$ and the corresponding rows of the constraint Jacobian,
$\frac{\partial {c}_{k}}{\partial {x}_{\mathit{i}}}\left(\mathbf{x}\right)$, for $\mathit{i}=1,2,\dots ,{\mathbf{ndim}}$.
On exit: may be set to a negative value if you wish to terminate the solution to the current problem. In this case e05sbf will terminate with ${\mathbf{ifail}}={\mathbf{3}}$ and ${\mathbf{inform}}={\mathbf{mode}}$ as soon as possible.

2:
$\mathbf{ncon}$ – Integer
Input

On entry: the number of constraints, not including box bounds.

3:
$\mathbf{ndim}$ – Integer
Input

On entry: the number of variables.

4:
$\mathbf{ldcj}$ – Integer
Input

On entry: the first dimension of the array
cjac as declared in the (sub)program from which
e05sbf is called.

5:
$\mathbf{needc}\left({\mathbf{ncon}}\right)$ – Integer array
Input

On entry: the indices of the elements of
c and/or
cjac that must be evaluated by
confun. If
${\mathbf{needc}}\left(k\right)>0$, the
$k$th element of
c, corresponding to the values of the
$k$th constraint, and/or the available elements of the
$k$th row of
cjac, corresponding to the derivatives of the
$k$th constraint, must be evaluated at
$\mathbf{x}$ (see argument
mode).

6:
$\mathbf{x}\left({\mathbf{ndim}}\right)$ – Real (Kind=nag_wp) array
Input

On entry: $\mathbf{x}$, the vector of variables at which the constraint functions and/or the available elements of the constraint Jacobian are to be evaluated.

7:
$\mathbf{c}\left({\mathbf{ncon}}\right)$ – Real (Kind=nag_wp) array
Output

On exit: if
${\mathbf{needc}}\left(k\right)>0$ and
${\mathbf{mode}}=0$ or
$2$,
${\mathbf{c}}\left(k\right)$ must contain the value of
${c}_{k}\left(\mathbf{x}\right)$. The remaining elements of
c, corresponding to the nonpositive elements of
needc, need not be set.

8:
$\mathbf{cjac}\left({\mathbf{ldcj}},{\mathbf{ndim}}\right)$ – Real (Kind=nag_wp) array
Input/Output

Note: the derivative of the $k$th constraint with respect to the $i$th component, $\frac{\partial {c}_{k}}{\partial {x}_{\mathrm{i}}}$, is stored in ${\mathbf{cjac}}\left(k,i\right)$.
On entry: the elements of
cjac are set to special values which enable
e05sbf to detect whether they are changed by
confun.
On exit: if
${\mathbf{needc}}\left(k\right)>0$ and
${\mathbf{mode}}=1$ or
$2$, the elements of
cjac corresponding to the
$k$th row of the constraint Jacobian should contain the available elements of the vector
$\nabla {c}_{k}$ given by
where
$\frac{\partial {c}_{k}}{\partial {x}_{i}}$ is the partial derivative of the
$k$th constraint with respect to the
$i$th variable, evaluated at the point
$\mathbf{x}$; elements of
cjac that remain unaltered will be approximated internally using finite differences. The remaining rows of
cjac, corresponding to nonpositive elements of
needc, need not be set.
It must be emphasized that unassigned elements of
cjac are not treated as constant; they are estimated by finite differences, at nontrivial expense. An interval for each element of
$\mathbf{x}$ is computed automatically at the start of the optimization. The automatic procedure can usually identify constant elements of
cjac, which are then computed once only by finite differences.

9:
$\mathbf{nstate}$ – Integer
Input

On entry:
nstate indicates various stages of initialization throughout the routine. This allows for permanent global arguments to be initialized a minimum number of times. For example, you may initialize a random number generator seed. Note that unless the option
${\mathbf{Optimize}}=\mathrm{CONSTRAINTS}$ has been set,
objfun will be called before
confun.
 ${\mathbf{nstate}}=3$
 SMP users only. objfun is called for the first time in a parallel region on a new thread other than the master thread. You may use this opportunity to set up any threaddependent information in iuser and ruser.
 ${\mathbf{nstate}}=2$
 confun is called for the very first time. This argument setting allows you to save computational time if certain data must be read or calculated only once.
 ${\mathbf{nstate}}=1$
 confun is called for the first time during a NAG local minimization routine. This argument setting allows you to save computational time if certain data required for the local minimizer need only be calculated at the initial point of the local minimization.
 ${\mathbf{nstate}}=0$
 Used in all other cases.

10:
$\mathbf{iuser}\left(*\right)$ – Integer array
User Workspace

11:
$\mathbf{ruser}\left(*\right)$ – Real (Kind=nag_wp) array
User Workspace

confun is called with the arguments
iuser and
ruser as supplied to
e05sbf. You should use the arrays
iuser and
ruser to supply information to
confun.
confun must either be a module subprogram USEd by, or declared as EXTERNAL in, the (sub)program from which
e05sbf is called. Arguments denoted as
Input must
not be changed by this procedure.
Note: confun should not return floatingpoint NaN (Not a Number) or infinity values, since these are not handled by
e05sbf. If your code inadvertently
does return any NaNs or infinities,
e05sbf is likely to produce unexpected results.
confun should be tested separately before being used in conjunction with
e05sbf.

14:
$\mathbf{monmod}$ – Subroutine, supplied by the NAG Library or the user.
External Procedure

A userspecified monitoring and modification function.
monmod is called once every complete iteration after a finalization check. It may be used to modify the particle locations that will be evaluated at the next iteration. This permits the incorporation of algorithmic modifications such as including additional advection heuristics and genetic mutations.
monmod is only called during the main loop of the algorithm, and as such will be unaware of any further improvement from the final local minimization. If no monitoring and/or modification is required,
monmod may be the dummy monitoring routine
e05sym. (
e05sym is included in the NAG Library).
The specification of
monmod is:
Fortran Interface
Subroutine monmod ( 
ndim, ncon, npar, x, xb, fb, cb, xbest, fbest, cbest, itt, iuser, ruser, inform) 
Integer, Intent (In) 
:: 
ndim, ncon, npar, itt(7) 
Integer, Intent (Inout) 
:: 
iuser(*), inform 
Real (Kind=nag_wp), Intent (In) 
:: 
xb(ndim), fb, cb(ncon), xbest(ndim,npar), fbest(npar), cbest(ncon,npar) 
Real (Kind=nag_wp), Intent (Inout) 
:: 
x(ndim,npar), ruser(*) 

C Header Interface
void 
monmod_ (const Integer *ndim, const Integer *ncon, const Integer *npar, double x[], const double xb[], const double *fb, const double cb[], const double xbest[], const double fbest[], const double cbest[], const Integer itt[], Integer iuser[], double ruser[], Integer *inform) 

C++ Header Interface
#include <nag.h> extern "C" {
void 
monmod_ (const Integer &ndim, const Integer &ncon, const Integer &npar, double x[], const double xb[], const double &fb, const double cb[], const double xbest[], const double fbest[], const double cbest[], const Integer itt[], Integer iuser[], double ruser[], Integer &inform) 
}


1:
$\mathbf{ndim}$ – Integer
Input

On entry: the number of dimensions.

2:
$\mathbf{ncon}$ – Integer
Input

On entry: the number of constraints.

3:
$\mathbf{npar}$ – Integer
Input

On entry: the number of particles.

4:
$\mathbf{x}\left({\mathbf{ndim}},{\mathbf{npar}}\right)$ – Real (Kind=nag_wp) array
Input/Output

Note: the $i$th component of the $j$th particle, ${x}_{j}\left(i\right)$, is stored in ${\mathbf{x}}\left(i,j\right)$.
On entry: the
npar particle locations,
${\mathbf{x}}_{j}$, which will currently be used during the next iteration unless altered in
monmod.
On exit: the particle locations to be used during the next iteration.

5:
$\mathbf{xb}\left({\mathbf{ndim}}\right)$ – Real (Kind=nag_wp) array
Input

On entry: the location, $\stackrel{~}{\mathbf{x}}$, of the best solution yet found.

6:
$\mathbf{fb}$ – Real (Kind=nag_wp)
Input

On entry: the objective value, $\stackrel{~}{f}=F\left(\stackrel{~}{\mathbf{x}}\right)$, of the best solution yet found.

7:
$\mathbf{cb}\left({\mathbf{ncon}}\right)$ – Real (Kind=nag_wp) array
Input

On entry: the constraint violations, $\stackrel{~}{\mathbf{e}}=\mathbf{e}\left(\stackrel{~}{\mathbf{x}}\right)$, of the best solution yet found.

8:
$\mathbf{xbest}\left({\mathbf{ndim}},{\mathbf{npar}}\right)$ – Real (Kind=nag_wp) array
Input

Note: the $i$th component of the position of the $j$th particle's cognitive memory, ${\hat{x}}_{j}\left(i\right)$, is stored in ${\mathbf{xbest}}\left(i,j\right)$.
On entry: the locations currently in the cognitive memory,
${\hat{\mathbf{x}}}_{\mathit{j}}$, for
$\mathit{j}=1,2,\dots ,{\mathbf{npar}}$ (see
Section 11).

9:
$\mathbf{fbest}\left({\mathbf{npar}}\right)$ – Real (Kind=nag_wp) array
Input

On entry: the objective values currently in the cognitive memory,
$F\left({\hat{\mathbf{x}}}_{\mathit{j}}\right)$, for $\mathit{j}=1,2,\dots ,{\mathbf{npar}}$.

10:
$\mathbf{cbest}\left({\mathbf{ncon}},{\mathbf{npar}}\right)$ – Real (Kind=nag_wp) array
Input

Note: the $k$th constraint violation of the $j$th particle's cognitive memory is stored in ${\mathbf{cbest}}\left(k,j\right)$.
On entry: the constraint violations currently in the cognitive memory,
$\hat{\mathbf{e}}=\mathbf{e}\left({\hat{\mathbf{x}}}_{\mathit{j}}\right)$, for $\mathit{j}=1,2,\dots ,{\mathbf{npar}}$, evaluated at ${\hat{\mathbf{x}}}_{j}$.

11:
$\mathbf{itt}\left(7\right)$ – Integer array
Input

On entry: iteration and function evaluation counters (see description of
itt below).

12:
$\mathbf{iuser}\left(*\right)$ – Integer array
User Workspace

13:
$\mathbf{ruser}\left(*\right)$ – Real (Kind=nag_wp) array
User Workspace

monmod is called with the arguments
iuser and
ruser as supplied to
e05sbf. You should use the arrays
iuser and
ruser to supply information to
monmod.

14:
$\mathbf{inform}$ – Integer
Input/Output

On entry:
${\mathbf{inform}}=\mathbf{thread\_num}$, where
thread_num is the value returned by a call of
x06adf. If running in serial this will always be zero.
On exit: setting
${\mathbf{inform}}<0$ will cause near immediate exit from
e05sbf. This value will be returned as
inform with
${\mathbf{ifail}}={\mathbf{3}}$. You need not set
inform unless you wish to force an exit.
monmod must either be a module subprogram USEd by, or declared as EXTERNAL in, the (sub)program from which
e05sbf is called. Arguments denoted as
Input must
not be changed by this procedure.

15:
$\mathbf{iopts}\left(*\right)$ – Integer array
Communication Array

Note: the dimension of this array is dictated by the requirements of associated functions that must have been previously called. This array
must be the same array passed as argument
iopts in the previous call to
e05zkf.
On entry: optional parameter array as generated and possibly modified by calls to
e05zkf. The contents of
iopts must not be modified directly between calls to
e05sbf,
e05zkf or
e05zlf.

16:
$\mathbf{opts}\left(*\right)$ – Real (Kind=nag_wp) array
Communication Array

Note: the dimension of this array is dictated by the requirements of associated functions that must have been previously called. This array
must be the same array passed as argument
opts in the previous call to
e05zkf.
On entry: optional parameter array as generated and possibly modified by calls to
e05zkf. The contents of
opts must not be modified directly between calls to
e05sbf,
e05zkf or
e05zlf.

17:
$\mathbf{iuser}\left(*\right)$ – Integer array
User Workspace

iuser is not used by
e05sbf, but is passed directly to
objfun,
confun and
monmod and may be used to pass information to these routines.
With care, you may also write information back into
iuser. This might be useful, for example, should there be a need to preserve the state of a random number generator.
With SMPenabled versions of
e05sbf the array
iuser provided are classified as OpenMP shared memory. Use of
iuser has to take account of this in order to preserve thread safety whenever information is written back to either of these arrays.

18:
$\mathbf{ruser}\left(*\right)$ – Real (Kind=nag_wp) array
User Workspace

ruser is not used by
e05sbf, but is passed directly to
objfun,
confun and
monmod and may be used to pass information to these routines.
With care, you may also write information back into
ruser. This might be useful, for example, should there be a need to preserve the state of a random number generator.
With SMPenabled versions of
e05sbf the array
ruser provided are classified as OpenMP shared memory. Use of
ruser has to take account of this in order to preserve thread safety whenever information is written back to either of these arrays.

19:
$\mathbf{itt}\left(7\right)$ – Integer array
Output

On exit: integer iteration counters for
e05sbf.
 ${\mathbf{itt}}\left(1\right)$
 Number of complete iterations.
 ${\mathbf{itt}}\left(2\right)$
 Number of complete iterations without improvement to the current optimum.
 ${\mathbf{itt}}\left(3\right)$
 Number of particles converged to the current optimum.
 ${\mathbf{itt}}\left(4\right)$
 Number of improvements to the optimum.
 ${\mathbf{itt}}\left(5\right)$
 Number of function evaluations performed.
 ${\mathbf{itt}}\left(6\right)$
 Number of particles reset.
 ${\mathbf{itt}}\left(7\right)$
 Number of violated constraints at completion. Note this is always calculated using the ${L}^{1}$ norm and a nonzero result does not necessarily mean that the algorithm did not find a suitably constrained point with respect to the single norm used.

20:
$\mathbf{inform}$ – Integer
Output

On exit: indicates which finalization criterion was reached. The possible values of
inform are:
inform  Meaning 
$<0$  Exit from a usersupplied subroutine. 
0  e05sbf has detected an error and terminated. 
1  The provided objective target has been achieved. (Target Objective Value). 
2  The standard deviation of the location of all the particles is below the set threshold (Swarm Standard Deviation). If the solution returned is not satisfactory, you may try setting a smaller value of Swarm Standard Deviation, or try adjusting the options governing the repulsive phase (Repulsion Initialize, Repulsion Finalize). 
3  The total number of particles converged (Maximum Particles Converged) to the current global optimum has reached the set limit. This is the number of particles which have moved to a distance less than Distance Tolerance from the optimum with regard to the ${L}^{2}$ norm. If the solution is not satisfactory, you may consider lowering the Distance Tolerance. However, this may hinder the global search capability of the algorithm. 
4  The maximum number of iterations without improvement (Maximum Iterations Static) has been reached, and the required number of particles (Maximum Iterations Static Particles) have converged to the current optimum. Increasing either of these options will allow the algorithm to continue searching for longer. Alternatively if the solution is not satisfactory, restarting the application several times with ${\mathbf{Repeatability}}=\mathrm{OFF}$ may lead to an improved solution. 
5  The maximum number of iterations (Maximum Iterations Completed) has been reached. If the number of iterations since improvement is small, then a better solution may be found by increasing this limit, or by using the option Local Minimizer with corresponding exterior options. Otherwise if the solution is not satisfactory, you may try rerunning the application several times with ${\mathbf{Repeatability}}=\mathrm{OFF}$ and a lower iteration limit, or adjusting the options governing the repulsive phase (Repulsion Initialize, Repulsion Finalize). 
6  The maximum allowed number of function evaluations (Maximum Function Evaluations) has been reached. As with ${\mathbf{inform}}=5$, increasing this limit if the number of iterations without improvement is small, or decreasing this limit and running the algorithm multiple times with ${\mathbf{Repeatability}}=\mathrm{OFF}$, may provide a superior result. 
7  A feasible point has been found. The objective has not been minimized, although it has been evaluated at the final solutions given in xb and xbest (${\mathbf{Optimize}}=\mathrm{CONSTRAINTS}$). 
If you wish to continue from the final position gained from a previous simulation with adjusted options, you may set the option
${\mathbf{Start}}=\mathrm{WARM}$, and pass back in the returned arrays
xbest,
fbest, and
cbest. You should either record the returned values of
xb,
fb and
cb for comparison, as these will not be reused by the algorithm, or include them in
xbest,
fbest and
cbest respectively by overwriting the entries corresponding to one particle with the relevant information.

21:
$\mathbf{ifail}$ – Integer
Input/Output

On entry:
ifail must be set to
$0$,
$1\text{or}1$. If you are unfamiliar with this argument you should refer to
Section 7 in the Introduction to the NAG Library CL Interface for details.
On exit: the most common exit will be
${\mathbf{ifail}}={\mathbf{1}}$.
For this reason, the value
$1\text{or}1$ is recommended. If the output of error messages is undesirable, the value
$1$ is recommended; otherwise, the recommended value is
$1$.
When the value $\mathbf{1}\text{or}1$ is used it is essential to test the value of ifail on exit.
e05sbf returns ${\mathbf{ifail}}={\mathbf{0}}$ if and only if a finalization criterion has been reached which can guarantee success. This may only happen if:

(i)The option Target Objective Value has been set and has been reached at a sufficiently constrained point within the search domain.

(ii)The option ${\mathbf{Optimize}}=\mathrm{CONSTRAINTS}$ has been set, and a sufficiently constrained point has been found within the search domain.
These finalization criteria are not active using default option settings, and must be explicitly set using
e05zkf if required.
e05sbf will return ${\mathbf{ifail}}={\mathbf{1}}$ if no error has been detected, and a finalization criterion has been achieved which cannot guarantee success. This does not indicate that the routine has failed, merely that the returned solution cannot be guaranteed to be the true global optimum.
The value of
inform should be examined to determine which finalization criterion was reached.
Other positive values of
ifail indicate that either an error or a warning has been triggered. See
Sections 6,
7 and
11 for more information.
6
Error Indicators and Warnings
If on entry
${\mathbf{ifail}}=0$ or
$1$, explanatory error messages are output on the current error message unit (as defined by
x04aaf).
Errors or warnings detected by the routine:
 ${\mathbf{ifail}}=1$

A finalization criterion was reached that cannot guarantee success.
On exit, ${\mathbf{inform}}=\u2329\mathit{\text{value}}\u232a$.
 ${\mathbf{ifail}}=2$

If the option
Target Warning has been activated, this indicates that the
Target Objective Value has been achieved to specified tolerances at a sufficiently constrained point, either during the initialization phase, or during the first two iterations of the algorithm. While this is not necessarily an error, it may occur if:

(i)The target was achieved at the first point sampled by the routine. This will be the mean of the lower and upper bounds.

(ii)The target may have been achieved at a randomly generated sample point. This will always be a possibility provided that the domain under investigation contains a point with a target objective value.

(iii)If the Local Minimizer has been set, then a sample point may have been inside the basin of attraction of a satisfactory point. If this occurs repeatedly when the routine is called, it may imply that the objective is largely unimodal, and that it may be more efficient to use the routine selected as the Local Minimizer directly.
Assuming that
objfun is correct, you may wish to set a better
Target Objective Value, or a stricter
Target Objective Tolerance.
 ${\mathbf{ifail}}=3$

User requested exit
$\u2329\mathit{\text{value}}\u232a$ during call to
confun.
User requested exit
$\u2329\mathit{\text{value}}\u232a$ during call to
monmod.
User requested exit
$\u2329\mathit{\text{value}}\u232a$ during call to
objfun.
 ${\mathbf{ifail}}=4$

Unable to locate strictly feasible point.
$\u2329\mathit{\text{value}}\u232a$ constraints remain violated. This exit may be suppressed using the option
Constraint Warning.
 ${\mathbf{ifail}}=11$

On entry, ${\mathbf{ndim}}=\u2329\mathit{\text{value}}\u232a$.
Constraint: ${\mathbf{ndim}}\ge 1$.
 ${\mathbf{ifail}}=12$

On entry, ${\mathbf{npar}}=\u2329\mathit{\text{value}}\u232a$.
Constraint: ${\mathbf{npar}}\ge 5\times \mathbf{num\_threads}$, where num_threads is the value returned by the OpenMP environment variable OMP_NUM_THREADS, or num_threads is $1$ for a serial version of this routine.
 ${\mathbf{ifail}}=13$

On entry, ${\mathbf{ncon}}=\u2329\mathit{\text{value}}\u232a$.
Constraint: ${\mathbf{ncon}}\ge 0$.
 ${\mathbf{ifail}}=14$

On entry, ${\mathbf{bl}}\left(\u2329\mathit{\text{value}}\u232a\right)=\u2329\mathit{\text{value}}\u232a$ and ${\mathbf{bu}}\left(\u2329\mathit{\text{value}}\u232a\right)=\u2329\mathit{\text{value}}\u232a$.
Constraint: ${\mathbf{bu}}\left(i\right)\ge {\mathbf{bl}}\left(i\right)$ for all $i$.
On entry, ${\mathbf{bl}}\left(i\right)={\mathbf{bu}}\left(i\right)$ for all box bounds $i$.
Constraint: ${\mathbf{bu}}\left(i\right)>{\mathbf{bl}}\left(i\right)$ for at least one box bound $i$.
 ${\mathbf{ifail}}=17$

e05sbf has been called with ${\mathbf{ncon}}>0$ and the dummy constraint function e05szm. Only use e05szm with ${\mathbf{ncon}}=0$.
 ${\mathbf{ifail}}=18$

The option ${\mathbf{Optimize}}=\mathrm{CONSTRAINTS}$ is active, however ${\mathbf{ncon}}=0$.
 ${\mathbf{ifail}}=19$

Error $\u2329\mathit{\text{value}}\u232a$ occurred whilst adjusting to exterior local minimizer options.
Error $\u2329\mathit{\text{value}}\u232a$ occurred whilst adjusting to interior local minimizer options.
 ${\mathbf{ifail}}=21$

Either the option arrays have not been initialized for e05sbf, or they have become corrupted.
 ${\mathbf{ifail}}=32$

Derivative checks indicate possible errors in the supplied derivatives.
Gradient checks may be disabled by setting ${\mathbf{Verify\; Gradients}}=\mathrm{OFF}$.
 ${\mathbf{ifail}}=51$

Multiple SMP threads have been detected; however, the option
SMP Callback Thread Safe has not been set.
Set
${\mathbf{SMP\; Callback\; Thread\; Safe}}=\mathrm{YES}$ if the provided callbacks are thread safe.
Set
${\mathbf{SMP\; Callback\; Thread\; Safe}}=\mathrm{NO}$ if the provided callbacks are not thread safe, to force serial execution.
 ${\mathbf{ifail}}=99$
An unexpected error has been triggered by this routine. Please
contact
NAG.
See
Section 7 in the Introduction to the NAG Library FL Interface for further information.
 ${\mathbf{ifail}}=399$
Your licence key may have expired or may not have been installed correctly.
See
Section 8 in the Introduction to the NAG Library FL Interface for further information.
 ${\mathbf{ifail}}=999$
Dynamic memory allocation failed.
See
Section 9 in the Introduction to the NAG Library FL Interface for further information.
7
Accuracy
If
${\mathbf{ifail}}={\mathbf{0}}$ (or
${\mathbf{ifail}}={\mathbf{2}}$) or
${\mathbf{ifail}}={\mathbf{1}}$ on exit, a criterion will have been reached depending on user selected options. As with all global optimization software, the solution achieved may not be the true global optimum. Various options allow for either greater search diversity or faster convergence to a (local) optimum (See
Sections 11 and
12).
Provided the objective function and constraints are sufficiently well behaved, if a local minimizer is used in conjunction with e05sbf, then it is more likely that the final result will at least be in the near vicinity of a local optimum, and due to the global search characteristics of the particle swarm, this solution should be superior to many other local optima.
Caution should be used in accelerating the rate of convergence, as with faster convergence, less of the domain will remain searchable by the swarm, making it increasingly difficult for the algorithm to detect the basins of attraction of superior local optima. Using the options
Repulsion Initialize and
Repulsion Finalize described in
Section 12 will help to overcome this, by causing the swarm to diverge away from the current optimum once no more local improvement is likely.
On successful exit with guaranteed success,
${\mathbf{ifail}}={\mathbf{0}}$ (or
${\mathbf{ifail}}={\mathbf{2}}$). This may happen if a
Target Objective Value is assigned and is reached by the algorithm at a satisfactorily constrained point. It will also occur if a constrained point is found when
${\mathbf{Optimize}}=\mathrm{CONSTRAINTS}$ is set.
On successful exit without guaranteed success, ${\mathbf{ifail}}={\mathbf{1}}$ is returned. This will happen if another finalization criterion is achieved without the detection of an error.
In both cases, the value of
inform provides further information as to the cause of the exit.
8
Parallelism and Performance
e05sbf is threaded by NAG for parallel execution in multithreaded implementations of the NAG Library.
e05sbf 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 routine. Please also consult the
Users' Note for your implementation for any additional implementationspecific information.
The algorithm has been parallelized to allow for a high degree of asynchronicity between threads. Each thread is assigned a static number of the
npar particles requested, and performs a subiteration using these particles and a private copy of
$\stackrel{~}{\mathbf{x}}$. The thread only updates this private copy if a superior solution is found. In these implementations, this routine may make calls to the usersupplied functions from within an OpenMP parallel region. Thus OpenMP directives within the user functions can only be used if you are compiling the usersupplied function and linking the executable in accordance with the instructions in the
Users' Note for your implementation.
Once a thread has completed a subiteration, it enters a brief critical section where it compares this private $\stackrel{~}{\mathbf{x}}$ to a globally accessible version. If either is superior, the inferior version is updated and the thread continues into a new subiteration.
Parallelizing the algorithm in this way allows for individual threads to continue searching even if other threads are completing subiterations in inferior times. The optional parameter
SMP Thread Overrun allows you to force a synchronization across the team of threads once one thread completes sufficiently more subiterations than the slowest thread. In particular, this may be used to force synchronization after every subiteration if so desired.
When using an SMP parallel version of this routine, you must indicate that the callback routines are thread safe by setting the optional parameter
SMP Callback Thread Safe before calling
e05sbf in a multithreaded environment. See
Section 12.2 for more information on this and other SMP options.
Note: the stochastic method used in e05sbf will not produce repeatable answers when run on multiple threads.
The memory used by e05sbf is relatively static throughout. Indeed, most of the memory required is used to store the current particle locations, the cognitive particle memories, the particle velocities and the particle weights. As such, e05sbf may be used in problems with high dimension number (${\mathbf{ndim}}>100$) without the concern of computational resource exhaustion, although the probability of successfully locating the global optimum will decrease dramatically with the increase in dimensionality.
Due to the stochastic nature of the algorithm, the result will vary over multiple runs. This is particularly true if arguments and options are chosen to accelerate convergence at the expense of the global search. However, the option ${\mathbf{Repeatability}}=\mathrm{ON}$ may be set to initialize the internal random number generator using a preset seed, which will result in identical solutions being obtained.
(For SMP users only) The option
${\mathbf{Repeatability}}=\mathrm{ON}$ will use preset seeds to initialize the random number generator on each thread, however due to the unpredictable nature of parallel communication, this cannot ensure repeatable results when running on multiple threads, even with
SMP Thread Overrun set to force synchronization every iteration.
10
Example
This example uses a particle swarm to find the global minimum of the twodimensional Schwefel function:
subject to the constraints:
The global optimum has an objective value of ${f}_{\mathrm{min}}=731.707$, located at $\mathbf{x}=\left(394.15,433.48\right)$. Only the third constraint is active at this point.
The example demonstrates how to initialize and set the options arrays using
e05zkf, how to query options using
e05zlf, and finally how to search for the global optimum using
e05sbf. The problem is solved twice, first using
e05sbf alone, and secondly by coupling
e05sbf with
e04ucf/e04uca as a dedicated local minimizer. In both cases the default option
${\mathbf{Repeatability}}=\mathrm{ON}$ is used to produce repeatable solutions.
Note: for users of multithreaded implementations of the NAG Library the following example program does not include the setting of the optional parameter
SMP Callback Thread Safe, and as such if run on multiple threads it will issue an error message. See the additional example program provided for
e05saf for more information on how to safely access independent subsections of the provided
iuser and
ruser arrays from multiple threads and how to use
e05zkf to set additional SMP threading related options.
10.1
Program Text
10.2
Program Data
None.
10.3
Program Results
11
Algorithmic Details
The following pseudocode describes the algorithm used with the repulsion mechanism.
The definition of terms used in the above pseudocode are as follows.
${n}_{p}$

the number of particles, npar 
${\mathbf{\ell}}_{\mathrm{box}}$ 
array of ndim lower box bounds 
${\mathbf{u}}_{\mathrm{box}}$ 
array of ndim upper box bounds 
${\mathbf{x}}_{j}$ 
position of particle $j$ 
${\hat{\mathbf{x}}}_{j}$ 
best position found by particle $j$ 
$\stackrel{~}{\mathbf{x}}$ 
best position found by any particle 
${f}_{j}$ 
$F\left({\mathbf{x}}_{j}\right)$ 
${\hat{f}}_{j}$ 
$F\left({\hat{\mathbf{x}}}_{j}\right)$, best value found by particle $j$ 
$\stackrel{~}{f}$ 
$F\left(\stackrel{~}{\mathbf{x}}\right)$, best value found by any particle 
${e}_{k}\left(\mathbf{x}\right)$ 
$k$th (scaled) constraint violation at $\mathbf{x}$, evaluated as $\mathrm{min}\phantom{\rule{0.125em}{0ex}}\left({c}_{k}\left(\mathbf{x}\right){l}_{{\mathbf{ndim}}+k},0.0\right)+\mathrm{max}\phantom{\rule{0.125em}{0ex}}\left({c}_{k}\left(\mathbf{x}\right){u}_{{\mathbf{ndim}}+k},0.0\right)$; this may be scaled by the maximum $k$th constraint found thus far 
$\mathbf{e}\left(\mathbf{x}\right)$ 
the array of ncon constraint violations, ${e}_{\mathit{k}}\left(\mathbf{x}\right)$, for $\mathit{k}=1,2,\dots ,{\mathbf{ncon}}$, at a point $\mathbf{x}$ 
${\mathbf{e}}_{j}$ 
$\mathbf{e}\left({\mathbf{x}}_{j}\right)$, the array of constraint violations evaluated at ${\mathbf{x}}_{j}$ 
${\hat{\mathbf{e}}}_{j}$ 
$\mathbf{e}\left({\hat{\mathbf{x}}}_{j}\right)$, the array of constraint violations evaluated at ${\hat{\mathbf{x}}}_{j}$ 
$\stackrel{~}{\mathbf{e}}$ 
$\mathbf{e}\left(\stackrel{~}{\mathbf{x}}\right)$, the array of constraint violations evaluated at $\stackrel{~}{\mathbf{x}}$ 
${\mathbf{v}}_{j}$ 
velocity of particle $j$ 
${w}_{j}$ 
weight on ${\mathbf{v}}_{j}$ for velocity update, decreasing according to Weight Decrease 
${\mathbf{V}}_{\mathrm{max}}$ 
maximum absolute velocity, dependent upon Maximum Variable Velocity 
${I}_{c}$ 
swarm iteration counter 
${I}_{s}$ 
iterations since $\stackrel{~}{\mathbf{x}}$ was updated 
${f}_{\mathrm{scale}}$ 
objective function scaling defined by the options Constraint Scaling, Objective Scaling and Objective Scale. 
${\mathbf{D}}_{1},{\mathbf{D}}_{2}$ 
diagonal matrices with random elements in range $\left(0,1\right)$ 
${C}_{s}$ 
the cognitive advance coefficient which weights velocity towards ${\hat{\mathbf{x}}}_{j}$, adjusted using Advance Cognitive 
${C}_{g}$ 
the global advance coefficient which weights velocity towards $\stackrel{~}{\mathbf{x}}$, adjusted using Advance Global 
$\mathit{dtol}$ 
the Distance Tolerance for resetting a converged particle 
$\mathbf{R}\in U\left({\mathbf{\ell}}_{\mathrm{box}},{\mathbf{u}}_{\mathrm{box}}\right)$ 
an array of random numbers whose $i$th element is drawn from a uniform distribution in the range $\left({{\mathbf{\ell}}_{\mathrm{box}}}_{\mathit{i}},{{\mathbf{u}}_{\mathrm{box}}}_{\mathit{i}}\right)$, for $\mathit{i}=1,2,\dots ,{\mathbf{ndim}}$ 
${O}_{i}$ 
local optimizer interior options 
${O}_{e}$ 
local optimizer exterior options 
$\varphi \left({w}_{j}\right)$ 
a function of ${w}_{j}$ designed to increasingly weight towards minimizing constraint violations as ${w}_{j}$ decreases 
$\mathrm{LOCMIN}\left(\mathbf{x},f,\mathbf{e},O\right)$ 
apply local optimizer using the set of options $O$ using the solution $\left(\mathbf{x},f,\mathbf{e}\right)$ as the starting point, if used (not default) 
monmod 
monitor progress and possibly modify ${\mathbf{x}}_{j}$ 
BOUNDARY 
apply required behaviour for ${\mathbf{x}}_{j}$ outside bounding box, (see Boundary) 
new ($\stackrel{~}{f}$) 
true if $\stackrel{~}{\mathbf{x}}$, $\stackrel{~}{\mathbf{c}}$, $\stackrel{~}{f}$ were updated at this iteration 
Additionally a repulsion phase can be introduced by changing from the default values of options
Repulsion Finalize (
${r}_{f}$),
Repulsion Initialize (
${r}_{i}$) and
Repulsion Particles (
${r}_{p}$). If the number of static particles is denoted
${n}_{s}$ then the following can be inserted after the new(
$\stackrel{~}{f}$) check in the pseudocode above.
12
Optional Parameters
This section can be skipped if you wish to use the default values for all optional parameters, otherwise, the following is a list of the optional parameters available and 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:
 the keywords;
 a parameter value,
where the letters $a$, $i$ and $r$ denote options that take character, integer and real values respectively;
 the default value, where the symbol $\epsilon $ is a generic notation for machine precision (see x02ajf), and $\mathit{Imax}$ represents the largest representable integer value (see x02bbf).
All options accept the value ‘DEFAULT’ in order to return single options to their default states.
Keywords and character values are case insensitive, however they must be separated by at least one space.
For
e05sbf the maximum length of the argument
cvalue used by
e05zlf is
$15$.
Advance Cognitive  $r$  Default $\text{}=2.0$ 
The cognitive advance coefficient, ${C}_{s}$. When larger than the global advance coefficient, this will cause particles to be attracted toward their previous best positions. Setting $r=0.0$ will cause e05sbf to act predominantly as a local optimizer. Setting $r>2.0$ may cause the swarm to diverge, and is generally inadvisable. At least one of the global and cognitive coefficients must be nonzero.
Advance Global  $r$  Default $\text{}=2.0$ 
The global advance coefficient, ${C}_{g}$. When larger than the cognitive coefficient this will encourage convergence toward the best solution yet found. Values $r\in \left(0,1\right)$ will inhibit particles overshooting the optimum. Values $r\in \left[1,2\right)$ cause particles to fly over the optimum some of the time. Larger values can prohibit convergence. Setting $r=0.0$ will remove any attraction to the current optimum, effectively generating a Monte Carlo multistart optimization algorithm. At least one of the global and cognitive coefficients must be nonzero.
Boundary  $a$  Default $\text{}=\mathrm{FLOATING}$ 
Determines the behaviour if particles leave the domain described by the box bounds. This only affects the general PSO algorithm, and will not pass down to any NAG local minimizers chosen.
This option is only effective in those dimensions for which ${\mathbf{bl}}\left(i\right)\ne {\mathbf{bu}}\left(i\right)$, $i=1,2,\dots ,{\mathbf{ndim}}$.
 IGNORE
 The box bounds are ignored. The objective function is still evaluated at the new particle position.
 RESET
 The particle is reinitialized inside the domain. ${\hat{\mathbf{x}}}_{j}$, ${\hat{f}}_{j}$ and ${\hat{\mathbf{e}}}_{j}$ are not affected.
 FLOATING
 The particle position remains the same, however the objective function will not be evaluated at the next iteration. The particle will probably be advected back into the domain at the next advance due to attraction by the cognitive and global memory.
 HYPERSPHERICAL
 The box bounds are wrapped around an $\mathit{ndim}$dimensional hypersphere. As such a particle leaving through a lower bound will immediately reenter through the corresponding upper bound and vice versa. The standard distance between particles is also modified accordingly.
 FIXED
 The particle rests on the boundary, with the corresponding dimensional velocity set to $0.0$.
Constraint Norm  $a$  Default $\text{}=\mathrm{L1}$ 
Determines with respect to which norm the constraint residuals should be constructed. These are automatically scaled with respect to
ncon as stated. For the set of (scaled) violations
$\mathbf{e}$, these may be,
 L1
 The ${L}^{1}$ norm will be used, ${\Vert \mathbf{e}\Vert}_{1}=\frac{1}{{\mathbf{ncon}}}{\displaystyle \sum _{1}^{{\mathbf{ncon}}}}\left{e}_{k}\right$
 L2
 The ${L}^{2}$ norm will be used, ${\Vert \mathbf{e}\Vert}_{2}=\frac{1}{{\mathbf{ncon}}}\sqrt{{\displaystyle \sum _{1}^{{\mathbf{ncon}}}}{e}_{k}^{2}}$
 L2SQ
 The square of the ${L}^{2}$ norm will be used, ${\Vert \mathbf{e}\Vert}_{{2}^{2}}=\frac{1}{{\mathbf{ncon}}}{\displaystyle \sum _{1}^{{\mathbf{ncon}}}}{e}_{k}^{2}$
 LMAX
 The ${L}^{\infty}$ norm will be used, ${\Vert \mathbf{e}\Vert}_{\infty}={\displaystyle \underset{0<k\le {\mathbf{ncon}}}{\mathrm{max}}}\phantom{\rule{0.25em}{0ex}}\left(\left{e}_{k}\right\right)$
Constraint Scale Maximum  $r$  Default $\text{}=\text{1.0E6}$ 
Internally, each constraint violation is scaled with respect to the maximum violation yet achieved for that constraint. This option acts as a ceiling for this scale.
Constraint:
$r>1.0$.
Constraint Scaling  $a$  Default $\text{}=\mathrm{INITIAL}$ 
Determines whether to scale the constraints and objective function when constructing the penalty function.
 OFF
 Neither the constraint violations nor the objective will be scaled automatically. This should only be used if the constraints and objective are similarly scaled everywhere throughout the domain.
 INITIAL
 The maximum of the initial cognitive memories, ${\hat{f}}_{j}$ and ${\hat{\mathbf{e}}}_{j}$, will be used to scale the objective function and constraint violations respectively.
 ADAPTIVE
 Initially, the maximum of the initial cognitive memories, ${\hat{f}}_{j}$ and ${\hat{\mathbf{e}}}_{j}$, will be used to scale the objective function and constraint violations respectively. If a significant change is detected in the behaviour of the constraints or the objective, these will be rescaled with respect to the current state of the cognitive memory.
Constraint Superiority  $r$  Default $\text{}=0.01$ 
The minimum scaled improvement in the constraint violation for a location to be immediately superior to that in memory, regardless of the objective value.
Constraint:
$r>0.0$.
Constraint Tolerance  $r$  Default $\text{}={10}^{4}$ 
The maximum scaled violation of the constraints for which a sample particle is considered comparable to the current global optimum. Should this not be exceeded, then the current global optimum will be updated if the value of the objective function of the sample particle is superior.
Constraint Warning  $a$  Default $\text{}=\mathrm{ON}$ 
Activates or deactivates the error exit associated with the inability to completely satisfy all constraints, ${\mathbf{ifail}}={\mathbf{4}}$. It is advisable to deactivate this option if ${\mathbf{ifail}}={\mathbf{0}}$ on entry and the satisfaction of all constraints is not program critical.
 OFF
 No error will be returned.
 ON
 An error will be returned if any constraints are sufficiently violated at the end of the simulation.
Distance Scaling  $a$  Default $\text{}=\mathrm{ON}$ 
Determines whether distances should be scaled by box widths.
 ON
 When a distance is calculated between $\mathbf{x}$ and $\mathbf{y}$, a scaled ${L}^{2}$ norm is used.
 OFF
 Distances are calculated as the standard ${L}^{2}$ norm without any rescaling.
Distance Tolerance  $r$  Default $\text{}={10}^{4}$ 
This is the distance, $\mathit{dtol}$ between particles and the global optimum which must be reached for the particle to be considered converged, i.e., that any subsequent movement of such a particle cannot significantly alter the global optimum. Once achieved the particle is reset into the box bounds to continue searching.
Constraint:
$r>0.0$.
Function Precision  $r$  Default $\text{}={\epsilon}^{0.9}$ 
The parameter defines ${\epsilon}_{r}$, which is intended to be a measure of the accuracy with which the problem function $F\left(\mathbf{x}\right)$ can be computed. If $r<\epsilon $ or $r\ge 1$, the default value is used.
The value of
${\epsilon}_{r}$ should reflect the relative precision of
$1+\leftF\left(\mathbf{x}\right)\right$; i.e.,
${\epsilon}_{r}$ acts as a relative precision when
$\leftF\right$ is large, and as an absolute precision when
$\leftF\right$ is small. For example, if
$F\left(\mathbf{x}\right)$ is typically of order
$1000$ and the first six significant digits are known to be correct, an appropriate value for
${\epsilon}_{r}$ would be
${10}^{6}$. In contrast, if
$F\left(\mathbf{x}\right)$ is typically of order
${10}^{4}$ and the first six significant digits are known to be correct, an appropriate value for
${\epsilon}_{r}$ would be
${10}^{10}$. The choice of
${\epsilon}_{r}$ can be quite complicated for badly scaled problems; see Chapter 8 of
Gill et al. (1981) for a discussion of scaling techniques. The default value is appropriate for most simple functions that are computed with full accuracy. However when the accuracy of the computed function values is known to be significantly worse than full precision, the value of
${\epsilon}_{r}$ should be large enough so that no attempt will be made to distinguish between function values that differ by less than the error inherent in the calculation.
Local Boundary Restriction  $r$  Default $\text{}=0.5$ 
Contracts the box boundaries used by a box constrained local minimizer to,
$\left[{\beta}_{l},{\beta}_{u}\right]$, containing the start point
$x$, where
Smaller values of
$r$ thereby restrict the size of the domain exposed to the local minimizer, possibly reducing the amount of work done by the local minimizer.
Constraint:
$0.0\le r\le 1.0$.
Local Interior Iterations  ${i}_{1}$  
Local Interior Major Iterations  ${i}_{1}$  
Local Exterior Iterations  ${i}_{2}$  
Local Exterior Major Iterations  ${i}_{2}$  
The maximum number of iterations or function evaluations the chosen local minimizer will perform inside (outside) the main loop if applicable. For the NAG minimizers these correspond to:
Minimizer 
Parameter/option 
Default Interior 
Default Exterior 
e04cbf 
maxcal 
${\mathbf{ndim}}+10$ 
$2\times {\mathbf{ndim}}+15$ 
e04dgf/e04dga 
Iteration Limit 
$\mathrm{max}\phantom{\rule{0.125em}{0ex}}\left(30,3\times {\mathbf{ndim}}\right)$ 
$\mathrm{max}\phantom{\rule{0.125em}{0ex}}\left(50,5\times {\mathbf{ndim}}\right)$ 
e04ucf/e04uca 
Major Iteration Limit 
$\mathrm{max}\phantom{\rule{0.125em}{0ex}}\left(10,2\times {\mathbf{ndim}}\right)$ 
$\mathrm{max}\phantom{\rule{0.125em}{0ex}}\left(30,3\times {\mathbf{ndim}}\right)$ 
Unless set, these are functions of the parameters passed to e05sbf.
Setting $i=0$ will disable the local minimizer in the corresponding algorithmic region. For example, setting ${\mathbf{Local\; Interior\; Iterations}}=0$ and ${\mathbf{Local\; Exterior\; Iterations}}=30$ will cause the algorithm to perform no local minimizations inside the main loop of the algorithm, and a local minimization with upto $30$ iterations after the main loop has been exited.
Note: currently
e04jyf or
e04kzf are restricted to using
$400\times {\mathbf{ndim}}$ and
$50\times {\mathbf{ndim}}$ as function evaluation limits respectively. This applies to both local minimizations inside and outside the main loop. They may still be deactivated in either phase by setting
$i=0$, and may subsequently be reactivated in either phase by setting
$i>0$.
Constraint:
${i}_{1}\ge 0$, ${i}_{2}\ge 0$.
Local Interior Tolerance  ${r}_{1}$  Default $\text{}={10}^{4}$ 
Local Exterior Tolerance  ${r}_{2}$  Default $\text{}={10}^{4}$ 
This is the tolerance provided to a local minimizer in the interior (exterior) of the main loop of the algorithm.
Constraint:
${r}_{1}>0.0$,${r}_{2}>0.0$.
Local Interior Minor Iterations  ${i}_{1}$  
Local Exterior Minor Iterations  ${i}_{2}$  
Where applicable, the secondary number of iterations the chosen local minimizer will use inside (outside) the main loop. Currently the relevant default values are:
Minimizer 
Parameter/option 
Default Interior 
Default Exterior 
e04ucf/e04uca 
Minor Iteration Limit 
$\mathrm{max}\phantom{\rule{0.125em}{0ex}}\left(10,2\times {\mathbf{ndim}}\right)$ 
$\mathrm{max}\phantom{\rule{0.125em}{0ex}}\left(30,3\times {\mathbf{ndim}}\right)$ 
Constraint:
${i}_{1}\ge 0$, ${i}_{2}\ge 0$.
Local Minimizer  $a$  Default $\text{}=\mathrm{OFF}$ 
Allows for a choice of
Chapter E04 routines to be used as a coupled, dedicated local minimizer.
 ${\mathbf{Local\; Minimizer}}=\mathrm{OFF}$
 No local minimization will be performed in either the INTERIOR or EXTERIOR sections of the algorithm.
 ${\mathbf{Local\; Minimizer}}=\mathrm{e04cbf}$
 Use e04cbf as the local minimizer. This does not require the calculation of derivatives.
On a call to
objfun during a local minimization,
${\mathbf{mode}}=5$.
 ${\mathbf{Local\; Minimizer}}=\mathrm{e04kzf}$
 Use e04kzf as the local minimizer. This requires the calculation of derivatives in objfun, as indicated by mode.
The box bounds forwarded to this routine from
e05sbf will have been acted upon by
Local Boundary Restriction. As such, the domain exposed may be greatly smaller than that provided to
e05sbf.
Accurate derivatives must be provided to this routine, and will not be approximated internally. Each iteration of this local minimizer also requires the calculation of both the objective function and its derivative. Hence on a call to
objfun during a local minimization,
${\mathbf{mode}}=7$.
 ${\mathbf{Local\; Minimizer}}=\mathrm{e04jyf}$
 Use e04jyf as the local minimizer. This does not require the calculation of derivatives.
On a call to
objfun during a local minimization,
${\mathbf{mode}}=5$.
The box bounds forwarded to this routine from
e05sbf will have been acted upon by
Local Boundary Restriction. As such, the domain exposed may be greatly smaller than that provided to
e05sbf.
 ${\mathbf{Local\; Minimizer}}=\mathrm{e04dgf}$
 Use e04dgf/e04dga as the local minimizer.
Accurate derivatives must be provided, and will not be approximated internally. Additionally, each call to
objfun during a local minimization will require either the objective to be evaluated alone, or both the objective and its gradient to be evaluated. Hence on a call to
objfun,
${\mathbf{mode}}=5$ or
$7$.
 ${\mathbf{Local\; Minimizer}}=\mathrm{e04ucf}$
 Use e04ucf/e04uca as the local minimizer.
This operates such that any derivatives of either the objective function or the constraint Jacobian, which you cannot supply, will be approximated internally using finite differences.
Either, the objective, objective gradient, or both may be requested during a local minimization, and as such on a call to
objfun,
${\mathbf{mode}}=1$,
$2$ or
$5$.
The box bounds forwarded to this routine from
e05sbf will have been acted upon by
Local Boundary Restriction. As such, the domain exposed may be greatly smaller than that provided to
e05sbf.
Maximum Function Evaluations  $i$  Default $=\mathit{Imax}$ 
The maximum number of evaluations of the objective function. When reached this will return ${\mathbf{ifail}}={\mathbf{1}}$ and ${\mathbf{inform}}=6$.
Constraint:
$i>0$.
Maximum Iterations Completed  $i$  Default $\text{}=1000\times {\mathbf{ndim}}$ 
The maximum number of complete iterations that may be performed. Once exceeded e05sbf will exit with ${\mathbf{ifail}}={\mathbf{1}}$ and ${\mathbf{inform}}=5$.
Unless set, this adapts to the parameters passed to e05sbf.
Constraint:
$i\ge 1$.
Maximum Iterations Static  $i$  Default $\text{}=100$ 
The maximum number of iterations without any improvement to the current global optimum. If exceeded
e05sbf will exit with
${\mathbf{ifail}}={\mathbf{1}}$ and
${\mathbf{inform}}=4$. This exit will be hindered by setting
Maximum Iterations Static Particles to larger values.
Constraint:
$i\ge 1$.
Maximum Iterations Static Particles  $i$  Default $\text{}=0$ 
The minimum number of particles that must have converged to the current optimum before the routine may exit due to
Maximum Iterations Static with
${\mathbf{ifail}}={\mathbf{1}}$ and
${\mathbf{inform}}=4$.
Constraint:
$i\ge 0$.
Maximum Particles Converged  $i$  Default $=\mathit{Imax}$ 
The maximum number of particles that may converge to the current optimum. When achieved, e05sbf will exit with ${\mathbf{ifail}}={\mathbf{1}}$ and ${\mathbf{inform}}=3$. This exit will be hindered by setting ‘Repulsion’ options, as these cause the swarm to reexpand.
Constraint:
$i>0$.
Maximum Particles Reset  $i$  Default $=\mathit{Imax}$ 
The maximum number of particles that may be reset after converging to the current optimum. Once achieved no further particles will be reset, and any particles within
Distance Tolerance of the global optimum will continue to evolve as normal.
Constraint:
$i>0$.
Maximum Variable Velocity  $r$  Default $\text{}=0.25$ 
Along any dimension $j$, the absolute velocity is bounded above by $\left{\mathbf{v}}_{j}\right\le r\times \left({\mathbf{u}}_{j}{\mathbf{\ell}}_{j}\right)={\mathbf{V}}_{\mathrm{max}}$. Very low values will greatly increase convergence time. There is no upper limit, although larger values will allow more particles to be advected out of the box bounds, and values greater than $4.0$ may cause significant and potentially unrecoverable swarm divergence.
Constraint:
$r>0.0$.
Objective Scale  $r$  Default $\text{}=1.0$ 
The initial scale for the objective function. This will remain fixed if ${\mathbf{Objective\; Scaling}}=\mathrm{USER}$ is selected.
Objective Scaling  $a$  Default $\text{}=\mathrm{MAXIMUM}$ 
The method of (re)scaling applied to the objective function when the routine detects a significant difference between the scale and the global and cognitive memory (
$\stackrel{~}{f}$ and
${\hat{f}}_{j}$). This only has an effect when
${\mathbf{ncon}}>0$ and
Constraint Scaling is active.
 MAXIMUM
 The objective is rescaled with respect to the maximum absolute value of the objective in the cognitive and global memory.
 MEAN
 The objective is rescaled with respect to the mean absolute value of the objective in the cognitive and global memory.
 USER
 The scale remains fixed at the value set using Objective Scale.
Optimize  $a$  Default $\text{}=\mathrm{MINIMIZE}$ 
Determines whether to maximize or minimize the objective function, or ignore the objective and search for a constrained point.
 MINIMIZE
 The objective function will be minimized.
 MAXIMIZE
 The objective function will be maximized. This is accomplished by minimizing the negative of the objective.
 CONSTRAINTS
 The objective function will be ignored, and the algorithm will attempt to find a feasible point given the provided constraints. The objective function will be evaluated at the best point found with regards to constraint violations, and the final positions returned in xbest. The objective will be calculated at the best point found in terms of constraints only. Should a constrained point be found, e05sbf will exit with ${\mathbf{ifail}}={\mathbf{0}}$ and ${\mathbf{inform}}=6$.
Constraint:
if ${\mathbf{Optimize}}=\mathrm{CONSTRAINTS}$, ${\mathbf{ncon}}>0$ is required.
Repeatability  $a$  Default $\text{}=\mathrm{OFF}$ 
Allows for the same random number generator seed to be used for every call to
e05sbf.
${\mathbf{Repeatability}}=\mathrm{OFF}$ is recommended in general.
 OFF
 The internal generation of random numbers will be nonrepeatable.
 ON
 The same seed will be used.
Repulsion Finalize  $i$  Default $=\mathit{Imax}$ 
The number of iterations performed in a repulsive phase before recontraction. This allows a rediversified swarm to contract back toward the current optimum, allowing for a finer search of the near optimum space.
Constraint:
$i\ge 2$.
Repulsion Initialize  $i$  Default $=\mathit{Imax}$ 
The number of iterations without any improvement to the global optimum before the algorithm begins a repulsive phase. This phase allows the particle swarm to reexpand away from the current optimum, allowing more of the domain to be investigated. The repulsive phase is automatically ended if a superior optimum is found.
Constraint:
$i\ge 2$.
Repulsion Particles  $i$  Default $\text{}=0$ 
The number of particles required to have converged to the current optimum before any repulsive phase may be initialized. This will prevent repulsion before a satisfactory search of the near optimum area has been performed, which may happen for large dimensional problems.
Constraint:
$i\ge 0$.
Seed  $i$  Default $\text{}=0$ 
Sets the random number generator seed to be used when
${\mathbf{Repeatability}}=\mathrm{ON}$. If set to 0, the default seed will be used. If not, the absolute value of
Seed will be used to generate the random number generator seed.
Start  $a$  Default $\text{}=\mathrm{COLD}$ 
Used to affect the initialization of the routine.
 COLD
 The random number generators and all initialization data will be generated internally. The variables xbest, fbest and cbest need not be set.
 WARM
 You must supply the initial best location, function and constraint violation values xbest, fbest and cbest. This option is recommended if you already have a data set you wish to improve upon.
Swarm Standard Deviation  $r$  Default $\text{}=0.1$ 
The target standard deviation of the particle distances from the current optimum. Once the standard deviation is below this level, e05sbf will exit with ${\mathbf{ifail}}={\mathbf{1}}$ and ${\mathbf{inform}}=2$. This criterion will be penalized by the use of ‘Repulsion’ options, as these cause the swarm to reexpand, increasing the standard deviation of the particle distances from the best point.
In SMP parallel implementations of
e05sbf, the standard deviation will be calculated based only on the particles local to the particular thread that checks for finalization. Considerably fewer particles may be used in this calculation than when the algorithm is run in serial. It is therefore recommended that you provide a smaller value of
Swarm Standard Deviation when running in parallel than when running in serial.
Constraint:
$r\ge 0.0$.
Target Objective  $a$  Default $\text{}=\mathrm{OFF}$ 
Target Objective Value  $r$  Default $\text{}=0.0$ 
Activate or deactivate the use of a target value as a finalization criterion. If active, then once the supplied target value for the objective function is found (beyond the first iteration if
Target Warning is active)
e05sbf will exit with
${\mathbf{ifail}}={\mathbf{0}}$ and
${\mathbf{inform}}=1$. Other than checking for feasibility only (
${\mathbf{Optimize}}=\mathrm{CONSTRAINTS}$), this is the only finalization criterion that guarantees that the algorithm has been successful. If the target value was achieved at the initialization phase or first iteration and
Target Warning is active,
e05sbf will exit with
${\mathbf{ifail}}={\mathbf{2}}$. This option may take any real value
$r$, or the character ON/OFF as well as DEFAULT. If this option is queried using
e05zlf, the current value of
$r$ will be returned in
rvalue, and
cvalue will indicate whether this option is ON or OFF. The behaviour of the option is as follows:
 $r$
 Once a point is found with an objective value within the Target Objective Tolerance of $r$, e05sbf will exit successfully with ${\mathbf{ifail}}={\mathbf{0}}$ and ${\mathbf{inform}}=1$.
 OFF
 The current value of $r$ will remain stored, however it will not be used as a finalization criterion.
 ON
 The current value of $r$ stored will be used as a finalization criterion.
 DEFAULT
 The stored value of $r$ will be reset to its default value ($0.0$), and this finalization criterion will be deactivated.
Target Objective Safeguard  $r$  Default $\text{}=10.0\epsilon $ 
If you have given a target objective value to reach in
$\mathit{objval}$ (the value of the optional parameter
Target Objective Value),
$\mathit{objsfg}$ sets your desired safeguarded termination tolerance, for when
$\mathit{objval}$ is close to zero.
Constraint:
$\mathit{objsfg}\ge 2\epsilon $.
Target Objective Tolerance  $r$  Default $\text{}=0.0$ 
The optional tolerance to a userspecified target value.
Constraint:
$r\ge 0.0$.
Target Warning  $a$  Default $\text{}=\mathrm{OFF}$ 
Activates or deactivates the error exit associated with the target value being achieved before entry into the main loop of the algorithm, ${\mathbf{ifail}}={\mathbf{2}}$.
 OFF
 No error will be returned, and the routine will exit normally.
 ON
 An error will be returned if the target objective is reached prematurely, and the routine will exit with ${\mathbf{ifail}}={\mathbf{2}}$.
Verify Gradients  $a$  Default $\text{}=\mathrm{ON}$ 
Adjusts the level of gradient checking performed when gradients are required. Gradient checks are only performed on the first call to the chosen local minimizer if it requires gradients. There is no guarantee that the gradient check will be correct, as the finite differences used in the gradient check are themselves subject to inaccuracies.
 OFF
 No gradient checking will be performed.
 ON
 A cheap gradient check will be performed on both the gradients corresponding to the objective through objfun and those provided via the constraint Jacobian through confun.
 OBJECTIVE
 A more expensive gradient check will be performed on the gradients corresponding to the objective objfun. The gradients of the constraints will not be checked.
 CONSTRAINTS
 A more expensive check will be performed on the elements of cjac provided via confun. The objective gradient will not be checked.
 FULL
 A more expensive check will be performed on both the gradient of the objective and the constraint Jacobian.
Weight Decrease  $a$  Default $\text{}=\mathrm{INTEREST}$ 
Determines how particle weights decrease.
 OFF
 Weights do not decrease.
 INTEREST
 Weights decrease through compound interest as ${w}_{\mathit{IT}+1}={w}_{\mathit{IT}}\left(1{W}_{\mathit{val}}\right)$, where ${W}_{\mathit{val}}$ is the Weight Value and $\mathit{IT}$ is the current number of iterations.
 LINEAR
 Weights decrease linearly following ${w}_{\mathit{IT}+1}={w}_{\mathit{IT}}\mathit{IT}\times \left({W}_{\mathit{max}}{W}_{\mathit{min}}\right)/{\mathit{IT}}_{\mathit{max}}$, where $\mathit{IT}$ is the iteration number and ${\mathit{IT}}_{\mathit{max}}$ is the maximum number of iterations as set by Maximum Iterations Completed.
Weight Initial  $r$  Default $\text{}={W}_{\mathit{max}}$ 
The initial value of any particle's inertial weight, ${W}_{\mathit{ini}}$, or the minimum possible initial value if initial weights are randomized. When set, this will override ${\mathbf{Weight\; Initialize}}=\mathrm{RANDOMIZED}$ or $\mathrm{MAXIMUM}$, and as such these must be set afterwards if so desired.
Constraint:
${W}_{\mathit{min}}\le r\le {W}_{\mathit{max}}$.
Weight Initialize  $a$  Default $\text{}=\mathrm{MAXIMUM}$ 
Determines how the initial weights are distributed.
 INITIAL
 All weights are initialized at the initial weight, ${W}_{\mathit{ini}}$, if set. If Weight Initial has not been set, this will be the maximum weight, ${W}_{\mathit{max}}$.
 MAXIMUM
 All weights are initialized at the maximum weight, ${W}_{\mathit{max}}$.
 RANDOMIZED
 Weights are uniformly distributed in $\left({W}_{\mathit{min}},{W}_{\mathit{max}}\right)$ or $\left({W}_{\mathit{ini}},{W}_{\mathit{max}}\right)$ if Weight Initial has been set.
Weight Maximum  $r$  Default $\text{}=1.0$ 
The maximum particle weight, ${W}_{\mathit{max}}$.
Constraint:
$1.0\ge r\ge {W}_{\mathit{min}}$ (If ${W}_{\mathit{ini}}$ has been set then $1.0\ge r\ge {W}_{\mathit{ini}}$.)
Weight Minimum  $r$  Default $\text{}=0.1$ 
The minimum achievable weight of any particle, ${W}_{\mathit{min}}$. Once achieved, no further weight reduction is possible.
Constraint:
$0.0\le r\le {W}_{\mathit{max}}$ (If ${W}_{\mathit{ini}}$ has been set then $0.0\le r\le {W}_{\mathit{ini}}$.)
Weight Reset  $a$  Default $\text{}=\mathrm{MAXIMUM}$ 
Determines how particle weights are reinitialized.
 INITIAL
 Weights are reinitialized at the initial weight if set. If Weight Initial has not been set, this will be the maximum weight.
 MAXIMUM
 Weights are reinitialized at the maximum weight.
 RANDOMIZED
 Weights are uniformly distributed in $\left({W}_{\mathit{min}},{W}_{\mathit{max}}\right)$ or $\left({W}_{\mathit{ini}},{W}_{\mathit{max}}\right)$ if Weight Initial has been set.
Weight Value  $r$  Default $\text{}=0.01$ 
The constant ${W}_{\mathit{val}}$ used with ${\mathbf{Weight\; Decrease}}=\mathrm{INTEREST}$.
Constraint:
$0.0\le r\le \frac{1}{3}$.
12.2
Description of the SMP optional parameters
This section details additional options available to users of multithreaded implementations of the NAG Library. In particular it includes the option
SMP Callback Thread Safe, which must be set before calling
e05sbf with multiple threads.
SMP Callback Thread Safe  $a$  Default $\text{}=\mathrm{WARNING}$ 
Declare that the callback routines you provide are or are not thread safe. In particular, this indicates that access to the shared memory arrays
iuser and
ruser from within your provided callbacks is done in a thread safe manner. If these arrays are just used to pass constant data, then you may assume they are thread safe. If these are also used for workspace, or passing variable data such as random number generator seeds, then you must ensure these are accessed and updated safely. Whilst this can be done using OpenMP critical sections, we suggest their use is minimized to prevent unnecessary bottlenecks, and that instead individual threads have access to independent subsections of the provided arrays where possible.
 YES
 The callback routines have been programmed in a thread safe way. The algorithm will use OMP_NUM_THREADS threads.
 NO
 The callback routines are not thread safe. Setting this option will force the algorithm to run on a single thread only, and is advisable only for debugging purposes, or if you wish to parallelize your callback functions.
 WARNING
 This will cause an immediate exit from e05sbf with ${\mathbf{ifail}}={\mathbf{51}}$ if multiple threads are detected. This is to inform you that you have not declared the callback functions either to be thread safe, or that they are thread unsafe and you wish the algorithm to run in serial.
SMP Local Minimizer External  $a$  Default $\text{}=\mathrm{ALL}$ 
Determines how many threads will attempt to locally minimize the best found solution after the routine has exited the main loop.
 MASTER
 Only the master thread will attempt to find any improvement. The local minimization will be launched from the best known solution. All other threads will remain effectively idle.
 ALL
 The master thread will perform a local minimization from the best known solution, while all other threads will perform a local minimization from randomly generated perturbations of the best known solution, increasing the chance of an improvement. Assuming all local minimizations will take approximately the same amount of computation, this will be effectively free in terms of real time. It will however increase the number of function evaluations performed.
SMP Monitor  $a$  Default $\text{}=\mathrm{SINGLE}$ 
Determines whether the usersupplied function
monmod is invoked once every subiteration each thread performs, or only once by a single thread after all threads have completed at least one subiteration.
 SINGLE
 Only one thread will invoke monmod, after all threads have performed at least one subiteration.
 ALL
 Each thread will invoke monmod each time it completes a subiteration. If you wish to alter x using monmod you should use this option, as monmod will only receive the arrays x, xbest, fbest and cbest private to the calling thread.
SMP Subswarm  $i$  Default $\text{}=1$ 
Determines how many threads support a particle subswarm. This is an extra collection of particles constrained to search only within a hypercube of edge length $10.0\times {\mathbf{Distance\; Tolerance}}$ of the best point known to an individual thread. This may improve the number of iterations required to find a provided target, particularly if no local minimizer is in use.
If $i\le 0$, then this will be disabled on all the threads.
If $i\ge \mathtt{OMP\_NUM\_THREADS}$, then all the threads will support a particle subswarm.
SMP Thread Overrun  $i$  Default $\text{}=\mathit{Imax}$ 
This option provides control over the level of asynchronicity present in a simulation. In particular, a barrier synchronization between all threads is performed if any thread completes $i$ subiterations more than the slowest thread, causing all threads to be exposed to the current best solution. Allowing asynchronous behaviour does however allow individual threads to focus on different global optimum candidates some of the time, which can inhibit convergence to unwanted suboptima. It also allows for threads to continue searching when other threads are completing subiterations at a slower rate.
If $i<1$, the algorithm will force a synchronization between threads at the end of each iteration.