confun must calculate the vector

c (x)

of nonlinear constraint functions and (optionally) its Jacobian (

= \frac{\partial c}{\partial x}

) for a specified

n

-element vector

x

. If there are no nonlinear constraints (i.e.,

ncnln = 0

), confun will never be called by e04us and confun may be the dummy method E04UDM. (E04UDM is included in the NAG Library.) If there are nonlinear constraints, the first call to confun will occur before the first call to objfun.

Syntax

C#
public delegate void E04US_CONFUN( ref int mode, int ncnln, int n, int[] needc, double[] x, double[] c, double[,] cjac, int nstate )

Visual Basic
Public Delegate Sub E04US_CONFUN ( _ ByRef mode As Integer, _ ncnln As Integer, _ n As Integer, _ needc As Integer(), _ x As Double(), _ c As Double(), _ cjac As Double(,), _ nstate As Integer _ )

Visual C++
public delegate void E04US_CONFUN( int% mode, int ncnln, int n, array<int>^ needc, array<double>^ x, array<double>^ c, array<double,2>^ cjac, int nstate )

F#
type E04US_CONFUN = delegate of mode : int byref * ncnln : int * n : int * needc : int[] * x : float[] * c : float[] * cjac : float[,] * nstate : int -> unit

Parameters

mode

Type: System..::..Int32%

On entry: indicates which values must be assigned during each call of confun. Only the following values need be assigned, for each value of

i

such that

needc [i - 1] > 0

$mode = 0$: $c [i - 1]$ .
$mode = 1$: All available elements in the $i$ th row of cjac.
$mode = 2$: $c [i - 1]$ and all available elements in the $i$ th row of cjac.

On exit: may be set to a negative value if you wish to terminate the solution to the current problem, and in this case e04us will terminate with ifail set to mode.

ncnln: Type: System..::..Int32
On entry: $n_{N}$ , the number of nonlinear constraints.

n: Type: System..::..Int32
On entry: $n$ , the number of variables.

needc: Type: array<System..::..Int32>[]()[][]
On entry: the indices of the elements of c and/or cjac that must be evaluated by confun. If $needc [i - 1] > 0$ , then the $i$ th element of c and/or the available elements of the $i$ th row of cjac (see parameter mode) must be evaluated at $x$ .

x: Type: array<System..::..Double>[]()[][]
On entry: $x$ , the vector of variables at which the constraint functions and/or all available elements of the constraint Jacobian are to be evaluated.

c: Type: array<System..::..Double>[]()[][]
On exit: if $needc [i - 1] > 0$ and $mode = 0$ or $2$ , $c [i - 1]$ must contain the value of the $i$ th constraint at $x$ . The remaining elements of c, corresponding to the non-positive elements of needc, are ignored.

cjac

Type: array<System..::..Double,2>[,](,)[,][,]

On entry: is set to a special value.

On exit: if

needc [i - 1] > 0

and

mode = 1

2

, the

i

th row of cjac must contain the available elements of the vector

\nabla c_{i}

given by

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

where

\frac{\partial c_{i}}{\partial x_{j}}

is the partial derivative of the

i

th constraint with respect to the

j

th variable, evaluated at the point

x

. See also the parameter nstate. The remaining rows of cjac, corresponding to non-positive elements of needc, are ignored.

If all elements of the constraint Jacobian are known (i.e.,

Derivative Level = 2

3

), any constant elements may be assigned to cjac one time only at the start of the optimization. An element of cjac that is not subsequently assigned in confun will retain its initial value throughout. Constant elements may be loaded into cjac either before the call to e04us or during the first call to confun (signalled by the value

nstate = 1

). The ability to preload constants is useful when many Jacobian elements are identically zero, in which case cjac may be initialized to zero and nonzero elements may be reset by confun.

Note that constant nonzero elements do affect the values of the constraints. Thus, if

cjac [i - 1, j - 1]

is set to a constant value, it need not be reset in subsequent calls to confun, but the value

cjac [i - 1, j - 1] \times x [j - 1]

must nonetheless be added to

c [i - 1]

. For example, if

cjac [0, 0] = 2

and

cjac [0, 1] = - 5

, then the term

2 \times x [0] - 5 \times x [1]

must be included in the definition of

c [0]

It must be emphasized that, if

Derivative Level = 0

1

, unassigned elements of cjac are not treated as constant; they are estimated by finite differences, at nontrivial expense. If you do not supply a value for the optional parameter Difference Interval, 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.

nstate: Type: System..::..Int32
On entry: if $nstate = 1$ then e04us is calling confun for the first time. This parameter setting allows you to save computation time if certain data must be read or calculated only once.

Syntax

Parameters

See Also