e05sbf (nlp_pso) : NAG Library, Mark 28

ndim

– Integer Input

On entry:

ndim

, the number of dimensions.

Constraint:

ndim \geq 1

ncon

– Integer Input

On entry:

ncon

, the number of constraints, not including box constraints.

Constraint:

ncon \geq 0

npar

– Integer Input

On entry:

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:

npar = 10 \times ndim

Constraint:

npar \geq 5 \times 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.

xb (ndim)

– Real (Kind=nag_wp) array Output

On exit: the location of the best solution found,

\tilde{x}

, in

R^{ndim}

fb

– Real (Kind=nag_wp) Output

On exit: the objective value of the best solution,

\tilde{f} = F (\tilde{x})

cb (ncon)

– Real (Kind=nag_wp) array Output

On exit: the constraint violations of the best solution found,

\tilde{e} = e (\tilde{x})

. These may have been deemed to be acceptable given the tolerance and scaling of the constraints. See Sections 11 and 12.

bl (ndim + ncon)

– Real (Kind=nag_wp) array Input

bu (ndim + ncon)

– Real (Kind=nag_wp) array Input

On entry:

bl

ℓ

, the array of lower bounds, bu is

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.

bl (i) = bu (i)

for any

i \in {1, \dots, ndim}

, variable

i

will remain locked to

bl (i)

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:

$bl (i) \leq bu (i)$ , for $i = 1, 2, \dots, ndim + ncon$ ;
$bl (i) \neq bu (i)$ for at least one $i \in {1, \dots, ndim}$ .

xbest (ndim, npar)

– Real (Kind=nag_wp) array Input/Output

Note: the

i

th component of the best position of the

j

th particle,

{\hat{x}}_{j} (i)

, is stored in

xbest (i, j)

On entry: if using

Start = WARM

, the initial particle positions,

{\hat{x}}_{j}^{0}

On exit: the best positions found,

{\hat{x}}_{j}

, by the npar particles in the swarm.

10:

fbest (npar)

– Real (Kind=nag_wp) array Input/Output

On entry: if using

Start = WARM

, objective function values,

{\hat{f}}_{j}^{0} = F ({\hat{x}}_{j}^{0})

, corresponding to the npar particle locations stored in xbest.

On exit: objective function values,

{\hat{f}}_{j} = F ({\hat{x}}_{j})

, corresponding to the locations returned in xbest.

11:

cbest (ncon, npar)

– Real (Kind=nag_wp) array Input/Output

Note: the

k

th constraint violation of the

j

th particle is stored in

cbest (k, j)

On entry: if using

Start = WARM

, the initial constraint violations,

{\hat{e}}_{j}^{0} = e ({\hat{x}}_{j}^{0})

, corresponding to the npar particle locations.

On exit: the final constraint violations,

{\hat{e}}_{j}

, corresponding to the locations returned in xbest.

12:

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

ndim

-variable vector

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

Subroutine objfun (

mode, ndim, x, objf, vecout, nstate, iuser, ruser)

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

void	objfun (Integer mode, const Integer ndim, const double x[], double objf, double vecout[], const Integer nstate, Integer iuser[], double ruser[])

1: $mode$ – Integer Input/Output

On entry: indicates which functionality is required.

$mode = 0$: $F (x)$ 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 (x)$ that is greater than objf may be approximated by this upper bound; that is objf can remain unaltered.
$mode = 1$: $Local Minimizer = e04ucf$ only
First derivatives can be evaluated and returned in vecout. Any unaltered elements of vecout will be approximated using finite differences.
$mode = 2$: $Local Minimizer = e04ucf$ only
$F (x)$ 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.
$mode = 5$: $F (x)$ must be calculated and returned in objf. The value of objf on entry may not be used as an upper bound.
$mode = 6$: $Local Minimizer = e04dgf$ or $e04kzf$ only
All first derivatives must be evaluated and returned in vecout.
$mode = 7$: $Local Minimizer = e04dgf$ or $e04kzf$ only
$F (x)$ 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

ifail = 3

and

inform = mode

2: $ndim$ – Integer Input

On entry: the number of dimensions.

3: $x (ndim)$ – Real (Kind=nag_wp) array Input

On entry:

x

, the point at which the objective function and/or its gradient are to be evaluated.

4: $objf$ – Real (Kind=nag_wp) Input/Output

On entry: the value of objf passed to objfun varies with the argument mode.

$mode = 0$: objf is an upper bound for the value of $F (x)$ , often equal to the best constraint penalised value of $F (x)$ 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.
$mode = 1$ , $2$ , $5$ , $6$ or $7$: objf is meaningless on entry.

On exit: the value of objf returned varies with the argument mode.

$mode = 0$: objf must be the value of $F (x)$ . Only values of $F (x)$ strictly less than objf on entry need be accurate.
$mode = 1$ or $6$: Need not be set.
$mode = 2$ , $5$ or $7$: $F (x)$ must be calculated and returned in objf. The entry value of objf may not be used as an upper bound.

5: $vecout (ndim)$ – Real (Kind=nag_wp) array Input/Output

On entry: if

Local Minimizer = e04ucf

, 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.

$mode = 0$ or $5$: The value of vecout need not be set.
$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 ndim$ , or acceptable approximations. Any unaltered elements of vecout will be approximated using finite differences.
$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 ndim$ . Approximation of the gradient is strongly discouraged, and no finite difference approximations will be performed internally (see e04dgf/e04dga and e04kzf).

6: $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.

$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 thread-dependent information in iuser and ruser.
$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.
$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.
$nstate = 0$: Used in all other cases.

7: $iuser (*)$ – Integer array User Workspace

8: $ruser (*)$ – 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 floating-point 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:

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[])

1: $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 {1, \dots, ncon}

such that

needc (k) > 0

$mode = 0$: the constraint values $c_{k} (x)$ .
$mode = 1$: rows of the constraint Jacobian, $\frac{\partial c_{k}}{\partial x_{i}} (x)$ , for $i = 1, 2, \dots, ndim$ .
$mode = 2$: the constraint values $c_{k} (x)$ and the corresponding rows of the constraint Jacobian, $\frac{\partial c_{k}}{\partial x_{i}} (x)$ , for $i = 1, 2, \dots, 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

ifail = 3

and

inform = mode

as soon as possible.

2: $ncon$ – Integer Input

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

3: $ndim$ – Integer Input

On entry: the number of variables.

4: $ldcj$ – Integer Input

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

5: $needc (ncon)$ – Integer array Input

On entry: the indices of the elements of c and/or cjac that must be evaluated by confun. If

needc (k) > 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

x

(see argument mode).

6: $x (ndim)$ – Real (Kind=nag_wp) array Input

On entry:

x

, the vector of variables at which the constraint functions and/or the available elements of the constraint Jacobian are to be evaluated.

7: $c (ncon)$ – Real (Kind=nag_wp) array Output

On exit: if

needc (k) > 0

and

mode = 0

2

c (k)

must contain the value of

c_{k} (x)

. The remaining elements of c, corresponding to the non-positive elements of needc, need not be set.

8: $cjac (ldcj, ndim)$ – 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_{i}}

, is stored in

cjac (k, i)

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

needc (k) > 0

and

mode = 1

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

\nabla c_{k} = (\frac{\partial c_{k}}{\partial x_{1}}, \frac{\partial c_{k}}{\partial x_{2}}, \dots, \frac{\partial c_{k}}{\partial x_{n}}),

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

x

; elements of cjac that remain unaltered will be approximated internally using finite differences. The remaining rows of cjac, corresponding to non-positive 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

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: $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

Optimize = CONSTRAINTS

has been set, objfun will be called before confun.

$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 thread-dependent information in iuser and ruser.
$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.
$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.
$nstate = 0$: Used in all other cases.

10: $iuser (*)$ – Integer array User Workspace

11: $ruser (*)$ – 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 floating-point 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:

monmod

– Subroutine, supplied by the NAG Library or the user. External Procedure

A user-specified 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)

1: $ndim$ – Integer Input: On entry: the number of dimensions.
2: $ncon$ – Integer Input: On entry: the number of constraints.
3: $npar$ – Integer Input: On entry: the number of particles.
4: $x (ndim, npar)$ – Real (Kind=nag_wp) array Input/Output: Note: the $i$ th component of the $j$ th particle, $x_{j} (i)$ , is stored in $x (i, j)$ .

On entry: the npar particle locations, $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: $xb (ndim)$ – Real (Kind=nag_wp) array Input: On entry: the location, $\tilde{x}$ , of the best solution yet found.
6: $fb$ – Real (Kind=nag_wp) Input: On entry: the objective value, $\tilde{f} = F (\tilde{x})$ , of the best solution yet found.
7: $cb (ncon)$ – Real (Kind=nag_wp) array Input: On entry: the constraint violations, $\tilde{e} = e (\tilde{x})$ , of the best solution yet found.
8: $xbest (ndim, npar)$ – 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} (i)$ , is stored in $xbest (i, j)$ .

On entry: the locations currently in the cognitive memory, ${\hat{x}}_{j}$ , for $j = 1, 2, \dots, npar$ (see Section 11).
9: $fbest (npar)$ – Real (Kind=nag_wp) array Input: On entry: the objective values currently in the cognitive memory, $F ({\hat{x}}_{j})$ , for $j = 1, 2, \dots, npar$ .
10: $cbest (ncon, npar)$ – Real (Kind=nag_wp) array Input: Note: the $k$ th constraint violation of the $j$ th particle's cognitive memory is stored in $cbest (k, j)$ .

On entry: the constraint violations currently in the cognitive memory, $\hat{e} = e ({\hat{x}}_{j})$ , for $j = 1, 2, \dots, npar$ , evaluated at ${\hat{x}}_{j}$ .
11: $itt (7)$ – Integer array Input: On entry: iteration and function evaluation counters (see description of itt below).
12: $iuser (*)$ – Integer array User Workspace
13: $ruser (*)$ – 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: $inform$ – Integer Input/Output: On entry: $inform = 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 $inform < 0$ will cause near immediate exit from e05sbf. This value will be returned as inform with $ifail = 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:

iopts (*)

– 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:

opts (*)

– Real (Kind=nag_wp) array Communication Array

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:

iuser (*)

– 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 SMP-enabled 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:

ruser (*)

– 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 SMP-enabled 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:

itt (7)

– Integer array Output

On exit: integer iteration counters for e05sbf.

$itt (1)$: Number of complete iterations.
$itt (2)$: Number of complete iterations without improvement to the current optimum.
$itt (3)$: Number of particles converged to the current optimum.
$itt (4)$: Number of improvements to the optimum.
$itt (5)$: Number of function evaluations performed.
$itt (6)$: Number of particles reset.
$itt (7)$: 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:

inform

– Integer Output

On exit: indicates which finalization criterion was reached. The possible values of inform are:

inform	Meaning
$< 0$	Exit from a user-supplied 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, re-starting the application several times with $Repeatability = 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 re-running the application several times with $Repeatability = 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 $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 $Repeatability = 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 ( $Optimize = CONSTRAINTS$ ).

If you wish to continue from the final position gained from a previous simulation with adjusted options, you may set the option

Start = 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 re-used 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:

ifail

– Integer Input/Output

On entry: ifail must be set to

0

−1

1

to set behaviour on detection of an error; these values have no effect when no error is detected.

On exit: the most common exit will be

ifail = 1

For this reason, the value

−1

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 $- 1$ or $1$ is used it is essential to test the value of ifail on exit.

e05sbf returns

ifail = 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 $Optimize = 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

ifail = 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.

$n_{p}$	the number of particles, npar
$ℓ_{box}$	array of ndim lower box bounds
$u_{box}$	array of ndim upper box bounds
$x_{j}$	position of particle $j$
${\hat{x}}_{j}$	best position found by particle $j$
$\tilde{x}$	best position found by any particle
$f_{j}$	$F (x_{j})$
${\hat{f}}_{j}$	$F ({\hat{x}}_{j})$ , best value found by particle $j$
$\tilde{f}$	$F (\tilde{x})$ , best value found by any particle
$e_{k} (x)$	$k$ th (scaled) constraint violation at $x$ , evaluated as $\min (c_{k} (x) - l_{ndim + k}, 0.0) + \max (c_{k} (x) - u_{ndim + k}, 0.0)$ ; this may be scaled by the maximum $k$ th constraint found thus far
$e (x)$	the array of ncon constraint violations, $e_{k} (x)$ , for $k = 1, 2, \dots, ncon$ , at a point $x$
$e_{j}$	$e (x_{j})$ , the array of constraint violations evaluated at $x_{j}$
${\hat{e}}_{j}$	$e ({\hat{x}}_{j})$ , the array of constraint violations evaluated at ${\hat{x}}_{j}$
$\tilde{e}$	$e (\tilde{x})$ , the array of constraint violations evaluated at $\tilde{x}$
$v_{j}$	velocity of particle $j$
$w_{j}$	weight on $v_{j}$ for velocity update, decreasing according to Weight Decrease
$V_{\max}$	maximum absolute velocity, dependent upon Maximum Variable Velocity
$I_{c}$	swarm iteration counter
$I_{s}$	iterations since $\tilde{x}$ was updated
$f_{scale}$	objective function scaling defined by the options Constraint Scaling, Objective Scaling and Objective Scale.
$D_{1}, D_{2}$	diagonal matrices with random elements in range $(0, 1)$
$C_{s}$	the cognitive advance coefficient which weights velocity towards ${\hat{x}}_{j}$ , adjusted using Advance Cognitive
$C_{g}$	the global advance coefficient which weights velocity towards $\tilde{x}$ , adjusted using Advance Global
$dtol$	the Distance Tolerance for resetting a converged particle
$R \in U (ℓ_{box}, u_{box})$	an array of random numbers whose $i$ th element is drawn from a uniform distribution in the range $({ℓ_{box}}_{i}, {u_{box}}_{i})$ , for $i = 1, 2, \dots, ndim$
$O_{i}$	local optimizer interior options
$O_{e}$	local optimizer exterior options
$ϕ (w_{j})$	a function of $w_{j}$ designed to increasingly weight towards minimizing constraint violations as $w_{j}$ decreases
$LOCMIN (x, f, e, O)$	apply local optimizer using the set of options $O$ using the solution $(x, f, e)$ as the starting point, if used (not default)
monmod	monitor progress and possibly modify $x_{j}$
BOUNDARY	apply required behaviour for $x_{j}$ outside bounding box, (see Boundary)
new ( $\tilde{f}$ )	true if $\tilde{x}$ , $\tilde{c}$ , $\tilde{f}$ were updated at this iteration

Minimizer	Parameter/option	Default Interior	Default Exterior
e04cbf	maxcal	$ndim + 10$	$2 \times ndim + 15$
e04dgf/e04dga	Iteration Limit	$\max (30, 3 \times ndim)$	$\max (50, 5 \times ndim)$
e04ucf/e04uca	Major Iteration Limit	$\max (10, 2 \times ndim)$	$\max (30, 3 \times ndim)$

NAG FL Interface
e05sbf (nlp_pso)

▸▿ Contents

1 Purpose

2 Specification

3 Description

4 References

5 Arguments

6 Error Indicators and Warnings

7 Accuracy

8 Parallelism and Performance

9 Further Comments

10 Example

10.1 Program Text

10.2 Program Data

10.3 Program Results

11 Algorithmic Details

12 Optional Parameters

12.1 Description of the Optional Parameters

12.2 Description of the SMP optional parameters

NAG FL Interfacee05sbf (nlp_​pso)

▸▿ Contents

1 Purpose

2 Specification

3 Description

4 References

5 Arguments

6 Error Indicators and Warnings

7 Accuracy

8 Parallelism and Performance

9 Further Comments

10 Example

10.1 Program Text

10.2 Program Data

10.3 Program Results

11 Algorithmic Details

12 Optional Parameters

12.1 Description of the Optional Parameters

12.2 Description of the SMP optional parameters

NAG FL Interface
e05sbf (nlp_pso)