e04vj may be used before e04vh to determine the sparsity pattern for the Jacobian.

Syntax

C#
public static void e04vj( int nf, int n, E04..::..E04VJ_USRFUN usrfun, int[] iafun, int[] javar, out int nea, double[] a, int[] igfun, int[] jgvar, out int neg, double[] x, double[] xlow, double[] xupp, E04..::..e04vhOptions options, out int ifail )

public static void e04vj(
	int nf,
	int n,
	E04..::..E04VJ_USRFUN usrfun,
	int[] iafun,
	int[] javar,
	out int nea,
	double[] a,
	int[] igfun,
	int[] jgvar,
	out int neg,
	double[] x,
	double[] xlow,
	double[] xupp,
	E04..::..e04vhOptions options,
	out int ifail
)

Visual Basic
Public Shared Sub e04vj ( _ nf As Integer, _ n As Integer, _ usrfun As E04..::..E04VJ_USRFUN, _ iafun As Integer(), _ javar As Integer(), _ <OutAttribute> ByRef nea As Integer, _ a As Double(), _ igfun As Integer(), _ jgvar As Integer(), _ <OutAttribute> ByRef neg As Integer, _ x As Double(), _ xlow As Double(), _ xupp As Double(), _ options As E04..::..e04vhOptions, _ <OutAttribute> ByRef ifail As Integer _ )

Visual Basic

Public Shared Sub e04vj ( _
	nf As Integer, _
	n As Integer, _
	usrfun As E04..::..E04VJ_USRFUN, _
	iafun As Integer(), _
	javar As Integer(), _
	<OutAttribute> ByRef nea As Integer, _
	a As Double(), _
	igfun As Integer(), _
	jgvar As Integer(), _
	<OutAttribute> ByRef neg As Integer, _
	x As Double(), _
	xlow As Double(), _
	xupp As Double(), _
	options As E04..::..e04vhOptions, _
	<OutAttribute> ByRef ifail As Integer _
)

Visual C++
public: static void e04vj( int nf, int n, E04..::..E04VJ_USRFUN^ usrfun, array<int>^ iafun, array<int>^ javar, [OutAttribute] int% nea, array<double>^ a, array<int>^ igfun, array<int>^ jgvar, [OutAttribute] int% neg, array<double>^ x, array<double>^ xlow, array<double>^ xupp, E04..::..e04vhOptions^ options, [OutAttribute] int% ifail )

Visual C++

public:
static void e04vj(
	int nf, 
	int n, 
	E04..::..E04VJ_USRFUN^ usrfun, 
	array<int>^ iafun, 
	array<int>^ javar, 
	[OutAttribute] int% nea, 
	array<double>^ a, 
	array<int>^ igfun, 
	array<int>^ jgvar, 
	[OutAttribute] int% neg, 
	array<double>^ x, 
	array<double>^ xlow, 
	array<double>^ xupp, 
	E04..::..e04vhOptions^ options, 
	[OutAttribute] int% ifail
)

F#
static member e04vj : nf : int * n : int * usrfun : E04..::..E04VJ_USRFUN * iafun : int[] * javar : int[] * nea : int byref * a : float[] * igfun : int[] * jgvar : int[] * neg : int byref * x : float[] * xlow : float[] * xupp : float[] * options : E04..::..e04vhOptions * ifail : int byref -> unit

static member e04vj : 
        nf : int * 
        n : int * 
        usrfun : E04..::..E04VJ_USRFUN * 
        iafun : int[] * 
        javar : int[] * 
        nea : int byref * 
        a : float[] * 
        igfun : int[] * 
        jgvar : int[] * 
        neg : int byref * 
        x : float[] * 
        xlow : float[] * 
        xupp : float[] * 
        options : E04..::..e04vhOptions * 
        ifail : int byref -> unit

Parameters

nf: Type: System..::..Int32
On entry: $nf$ , the number of problem functions in $F (x)$ , including the objective function (if any) and the linear and nonlinear constraints. Simple upper and lower bounds on $x$ can be defined using the parameters xlow and xupp and should not be included in $F$ .

Constraint: $nf > 0$ .

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

Constraint: $n > 0$ .

usrfun: Type: NagLibrary..::..E04..::..E04VJ_USRFUN
usrfun must define the problem functions $F (x)$ . This method is passed to e04vj as the external parameter usrfun.
A delegate of type E04VJ_USRFUN.

iafun: Type: array<System..::..Int32>[]()[][]
An array of size [lena]
On exit: define the coordinates $(i, j)$ and values $A_{i j}$ of the nonzero elements of the linear part $A$ of the function $F (x) = f (x) + A x$ .
In particular, nea triples $(iafun [k - 1], javar [k - 1], a [k - 1])$ define the row and column indices $i = iafun [k - 1]$ and $j = javar [k - 1]$ of the element $A_{i j} = a [k - 1]$ .

javar: Type: array<System..::..Int32>[]()[][]
An array of size [lena]
On exit: define the coordinates $(i, j)$ and values $A_{i j}$ of the nonzero elements of the linear part $A$ of the function $F (x) = f (x) + A x$ .
In particular, nea triples $(iafun [k - 1], javar [k - 1], a [k - 1])$ define the row and column indices $i = iafun [k - 1]$ and $j = javar [k - 1]$ of the element $A_{i j} = a [k - 1]$ .

nea: Type: System..::..Int32%
On exit: is the number of nonzero entries in $A$ such that $F (x) = f (x) + A x$ .

a: Type: array<System..::..Double>[]()[][]
An array of size [lena]
On exit: define the coordinates $(i, j)$ and values $A_{i j}$ of the nonzero elements of the linear part $A$ of the function $F (x) = f (x) + A x$ .
In particular, nea triples $(iafun [k - 1], javar [k - 1], a [k - 1])$ define the row and column indices $i = iafun [k - 1]$ and $j = javar [k - 1]$ of the element $A_{i j} = a [k - 1]$ .

igfun: Type: array<System..::..Int32>[]()[][]
An array of size [leng]
On exit: define the coordinates $(i, j)$ of the nonzero elements of $G$ , the nonlinear part of the derivatives $J (x) = G (x) + A$ of the function $F (x) = f (x) + A x$ .

jgvar: Type: array<System..::..Int32>[]()[][]
An array of size [leng]
On exit: define the coordinates $(i, j)$ of the nonzero elements of $G$ , the nonlinear part of the derivatives $J (x) = G (x) + A$ of the function $F (x) = f (x) + A x$ .

neg: Type: System..::..Int32%
On exit: the number of nonzero entries in $G$ .

x: Type: array<System..::..Double>[]()[][]
An array of size [n]
On entry: an initial estimate of the variables $x$ . The contents of $x$ will be used by e04vj in the call of usrfun, and so each element of x should be within the bounds given by xlow and xupp.

xlow: Type: array<System..::..Double>[]()[][]
An array of size [n]
On entry: contain the lower and upper bounds $l_{x}$ and $u_{x}$ on the variables $x$ .
To specify a nonexistent lower bound ${[l_{x}]}_{j} = - \infty$ , set $xlow [j - 1] \leq - bigbnd$ , where $bigbnd$ is the optional parameter Infinite Bound Size. To specify a nonexistent upper bound $xupp [j - 1] \geq bigbnd$ .

To fix the $j$ th variable (say, $x_{j} = β$ , where $|β| < bigbnd$ ), set $xlow [j - 1] = xupp [j - 1] = β$ .

xupp: Type: array<System..::..Double>[]()[][]
An array of size [n]
On entry: contain the lower and upper bounds $l_{x}$ and $u_{x}$ on the variables $x$ .
To specify a nonexistent lower bound ${[l_{x}]}_{j} = - \infty$ , set $xlow [j - 1] \leq - bigbnd$ , where $bigbnd$ is the optional parameter Infinite Bound Size. To specify a nonexistent upper bound $xupp [j - 1] \geq bigbnd$ .

To fix the $j$ th variable (say, $x_{j} = β$ , where $|β| < bigbnd$ ), set $xlow [j - 1] = xupp [j - 1] = β$ .

options: Type: NagLibrary..::..E04..::..e04vhOptions
An Object of type E04.e04vjOptions. Used to configure optional parameters to this method.

ifail: Type: System..::..Int32%
On exit: $ifail = 0$ unless the method detects an error or a warning has been flagged (see [Error Indicators and Warnings]).

Description

When using e04vh, if you set the optional parameter

Derivative Option = 0

and usrfun provides none of the derivatives, you may need to call e04vj to determine the input arrays iafun, javar, a, igfun and jgvar. These arrays define the pattern of nonzeros in the Jacobian matrix. A typical sequence of calls could be

e04vj determines the sparsity pattern for the Jacobian and identifies the constant elements automatically. To do so, e04vj approximates the problem functions,

F (x)

, at three random perturbations of the given initial point

x

. If an element of the approximate Jacobian is the same at all three points, then it is taken to be constant. If it is zero, it is taken to be identically zero. Since the random points are not chosen close together, the heuristic will correctly classify the Jacobian elements in the vast majority of cases. In general, e04vj finds that the Jacobian can be permuted to the form:

(\begin{matrix} G (x) & A_{3} \\ A_{2} & A_{4} \end{matrix}),

where

A_{2}

A_{3}

and

A_{4}

are constant. Note that

G (x)

might contain elements that are also constant, but e04vj must classify them as nonlinear. This is because e04vh ‘removes’ linear variables from the calculation of

F

by setting them to zero before calling usrfun. A knowledgeable user would be able to move such elements from

F (x)

in usrfun and enter them as part of iafun, javar and a for e04vh.

References

Hock W and Schittkowski K (1981) Test Examples for Nonlinear Programming Codes. Lecture Notes in Economics and Mathematical Systems 187 Springer–Verlag

Error Indicators and Warnings

Errors or warnings detected by the method:

$ifail = 1$: The initialization method (E04VGF not in this release) has not been called or at least one of lencw, leniw or lenrw is less than $600$ .

$ifail = 2$: An input parameter is invalid. The output message provides more details of the invalid parameter.

$ifail = 3$: Undefined user-supplied function.
You have indicated that the problem functions are undefined by setting $status = - 1$ on exit from usrfun. This exit occurs if e04vj is unable to find a point at which the functions are defined.

$ifail = 4$: User requested termination.
You have indicated the wish to terminate the call to e04vj by setting status to a value $< - 1$ on exit from usrfun.

$ifail = 5$: Either lena or leng is too small, resulting in insufficient array to store the Jacobian information. Increase lena and/or leng

$ifail = 6$: Unable to estimate the Jacobian structure.

$ifail = 7$: Internal memory allocation failed when attempting to obtain the required workspace. Please contact NAG.

$ifail = 8$: Internal memory allocation insufficient. Please contact NAG.

$ifail = -9000$: An error occured, see message report.
$ifail = -1000$: The array lengths are not the same for arrays
$ifail = -1000$: The array lengths are not the same for arrays
$ifail = -8000$: Negative dimension for array $〈value〉$
$ifail = -6000$: Invalid Parameters $〈value〉$

Accuracy

Not applicable.

Parallelism and Performance

None.

Further Comments

None.

Example

It is a reformulation of Problem 74 from Hock and Schittkowski (1981) and involves the minimization of the nonlinear function

f (x) = 10^{- 6} x_{3}^{3} + \frac{2}{3} \times 10^{- 6} x_{4}^{3} + 3 x_{3} + 2 x_{4}

subject to the bounds

\begin{array}{r} - 0.55 \leq x_{1} \leq 0.55, \\ - 0.55 \leq x_{2} \leq 0.55, \\ 0 \leq x_{3} \leq 1200, \\ 0 \leq x_{4} \leq 1200, \end{array}

to the nonlinear constraints

\begin{matrix} 1000 \sin (- x_{1} - 0.25) + 1000 \sin (- x_{2} - 0.25) - x_{3} & = & - 894.8, \\ 1000 \sin (x_{1} - 0.25) + 1000 \sin (x_{1} - x_{2} - 0.25) - x_{4} & = & - 894.8, \\ 1000 \sin (x_{2} - 0.25) + 1000 \sin (x_{2} - x_{1} - 0.25) & = & - 1294.8, \end{matrix}

and to the linear constraints

\begin{matrix} - x_{1} + x_{2} \geq - 0.55, \\ x_{1} - x_{2} \geq - 0.55 . \end{matrix}

The initial point, which is infeasible, is

x_{0} = {(\begin{matrix} 0, & 0, & 0, & 0 \end{matrix})}^{T},

and

f (x_{0}) = 0

The optimal solution (to five figures) is

x^{*} = {(0.11887, - 0.39623, 679.94, 1026.0)}^{T},

and

f (x^{*}) = 5126.4

. All the nonlinear constraints are active at the solution.

The formulation of the problem combines the constraints and the objective into a single vector (

F

F = (\begin{matrix} \begin{matrix} 1000 \sin (- x_{1} - 0.25) + 1000 \sin (- x_{2} - 0.25) - x_{3} \\ 1000 \sin (x_{1} - 0.25) + 1000 \sin (x_{1} - x_{2} - 0.25) - x_{4} \\ 1000 \sin (x_{2} - 0.25) + 1000 \sin (x_{2} - x_{1} - 0.25) \end{matrix} \\ - x_{1} + x_{2} \\ x_{1} - x_{2} \\ 10^{- 6} x_{3}^{3} + \frac{2}{3} \times 10^{- 6} x_{4}^{3} + 3 x_{3} + 2 x_{4} \end{matrix})

Example program (C#): e04vje.cs

Example program data: e04vje.d

Example program results: e04vje.r