NAG Library Routine Document
e04yaf (lsq_check_deriv)
1
Purpose
e04yaf checks that a usersupplied subroutine for evaluating a vector of functions and the matrix of their first derivatives produces derivative values which are consistent with the function values calculated.
2
Specification
Fortran Interface
Subroutine e04yaf ( 
m, n, lsqfun, x, fvec, fjac, ldfjac, iw, liw, w, lw, ifail) 
Integer, Intent (In)  ::  m, n, ldfjac, liw, lw  Integer, Intent (Inout)  ::  iw(liw), ifail  Real (Kind=nag_wp), Intent (In)  ::  x(n)  Real (Kind=nag_wp), Intent (Inout)  ::  fjac(ldfjac,n), w(lw)  Real (Kind=nag_wp), Intent (Out)  ::  fvec(m)  External  ::  lsqfun 

C Header Interface
#include nagmk26.h
void 
e04yaf_ (const Integer *m, const Integer *n, void (NAG_CALL *lsqfun)(Integer *iflag, const Integer *m, const Integer *n, const double xc[], double fvec[], double fjac[], const Integer *ldfjac, Integer iw[], const Integer *liw, double w[], const Integer *lw), const double x[], double fvec[], double fjac[], const Integer *ldfjac, Integer iw[], const Integer *liw, double w[], const Integer *lw, Integer *ifail) 

3
Description
Routines for minimizing a sum of squares of
$m$ nonlinear functions (or ‘residuals’),
${f}_{\mathit{i}}\left({x}_{1},{x}_{2},\dots ,{x}_{n}\right)$, for
$\mathit{i}=1,2,\dots ,m$ and
$m\ge n$, may require you to supply a subroutine to evaluate the
${f}_{i}$ and their first derivatives.
e04yaf checks the derivatives calculated by such usersupplied subroutines, e.g., routines of the form required for
e04gbf,
e04gdf and
e04hef. As well as the routine to be checked (
lsqfun), you must supply a point
$x={\left({x}_{1},{x}_{2},\dots ,{x}_{n}\right)}^{\mathrm{T}}$ at which the check will be made.
e04yaf is essentially identical to CHKLSJ in the NPL Algorithms Library.
e04yaf first calls
lsqfun to evaluate the
${f}_{i}\left(x\right)$ and their first derivatives, and uses these to calculate the sum of squares
$F\left(x\right)={\displaystyle \sum _{i=1}^{m}}{\left[{f}_{i}\left(x\right)\right]}^{2}$,
and its first derivatives
${g}_{j}={\left.\frac{\partial F}{\partial {x}_{j}}\right}_{x}$, for
$j=1,2,\dots ,n$. The components of
$g$ along two orthogonal directions (defined by unit vectors
${p}_{1}$ and
${p}_{2}$, say) are then calculated; these will be
${g}^{\mathrm{T}}{p}_{1}$ and
${g}^{\mathrm{T}}{p}_{2}$ respectively. The same components are also estimated by finite differences, giving quantities
where
$h$ is a small positive scalar. If the relative difference between
${v}_{1}$ and
${g}^{\mathrm{T}}{p}_{1}$ or between
${v}_{2}$ and
${g}^{\mathrm{T}}{p}_{2}$ is judged too large, an error indicator is set.
4
References
None.
5
Arguments
 1: $\mathbf{m}$ – IntegerInput
 2: $\mathbf{n}$ – IntegerInput

On entry: the number $m$ of residuals, ${f}_{i}\left(x\right)$, and the number $n$ of variables, ${x}_{j}$.
Constraint:
$1\le {\mathbf{n}}\le {\mathbf{m}}$.
 3: $\mathbf{lsqfun}$ – Subroutine, supplied by the user.External Procedure

lsqfun must calculate the vector of values
${f}_{i}\left(x\right)$ and their first derivatives
$\frac{\partial {f}_{i}}{\partial {x}_{j}}$ at any point
$x$. (The minimization routines mentioned in
Section 3 give you the option of resetting an argument to terminate immediately.
e04yaf will also terminate immediately, without finishing the checking process, if the argument in question is reset.)
The specification of
lsqfun is:
Fortran Interface
Subroutine lsqfun ( 
iflag, m, n, xc, fvec, fjac, ldfjac, iw, liw, w, lw) 
Integer, Intent (In)  ::  m, n, ldfjac, liw, lw  Integer, Intent (Inout)  ::  iflag, iw(liw)  Real (Kind=nag_wp), Intent (In)  ::  xc(n)  Real (Kind=nag_wp), Intent (Inout)  ::  fjac(ldfjac,n), w(lw)  Real (Kind=nag_wp), Intent (Out)  ::  fvec(m) 

C Header Interface
#include nagmk26.h
void 
lsqfun (Integer *iflag, const Integer *m, const Integer *n, const double xc[], double fvec[], double fjac[], const Integer *ldfjac, Integer iw[], const Integer *liw, double w[], const Integer *lw) 

 1: $\mathbf{iflag}$ – IntegerInput/Output

On entry: to
lsqfun,
iflag will be set to
$2$.
On exit: if you reset
iflag to some negative number in
lsqfun and return control to
e04yaf, the routine will terminate immediately with
ifail set to your setting of
iflag.
 2: $\mathbf{m}$ – IntegerInput

On entry: the numbers $m$ of residuals.
 3: $\mathbf{n}$ – IntegerInput

On entry: the numbers $n$ of variables.
 4: $\mathbf{xc}\left({\mathbf{n}}\right)$ – Real (Kind=nag_wp) arrayInput

On entry: $x$, the point at which the values of the ${f}_{i}$ and the $\frac{\partial {f}_{i}}{\partial {x}_{j}}$ are required.
 5: $\mathbf{fvec}\left({\mathbf{m}}\right)$ – Real (Kind=nag_wp) arrayOutput

On exit: unless
iflag is reset to a negative number,
${\mathbf{fvec}}\left(\mathit{i}\right)$ must contain the value of
${f}_{\mathit{i}}$ at the point
$x$, for
$\mathit{i}=1,2,\dots ,m$.
 6: $\mathbf{fjac}\left({\mathbf{ldfjac}},{\mathbf{n}}\right)$ – Real (Kind=nag_wp) arrayOutput

On exit: unless
iflag is reset to a negative number,
${\mathbf{fjac}}\left(\mathit{i},\mathit{j}\right)$ must contain the value of
$\frac{\partial {f}_{\mathit{i}}}{\partial {x}_{\mathit{j}}}$ at the point
$x$, for
$\mathit{i}=1,2,\dots ,m$ and
$\mathit{j}=1,2,\dots ,n$.
 7: $\mathbf{ldfjac}$ – IntegerInput

On entry: the first dimension of the array
fjac as declared in the (sub)program from which
e04yaf is called.
 8: $\mathbf{iw}\left({\mathbf{liw}}\right)$ – Integer arrayWorkspace
 9: $\mathbf{liw}$ – IntegerInput
 10: $\mathbf{w}\left({\mathbf{lw}}\right)$ – Real (Kind=nag_wp) arrayWorkspace
 11: $\mathbf{lw}$ – IntegerInput

These arguments are present so that
lsqfun will be of the form required by the minimization routines mentioned in
Section 3.
lsqfun is called with the same arguments
iw,
liw,
w,
lw as in the call to
e04yaf. If the recommendation in the minimization routine document is followed, you will have no reason to examine or change the elements of
iw or
w. In any case,
lsqfun must not change the first
$3\times {\mathbf{n}}+{\mathbf{m}}+{\mathbf{m}}\times {\mathbf{n}}$ elements of
w.
lsqfun must either be a module subprogram USEd by, or declared as EXTERNAL in, the (sub)program from which
e04yaf is called. Arguments denoted as
Input must
not be changed by this procedure.
Note: lsqfun should not return floatingpoint NaN (Not a Number) or infinity values, since these are not handled by
e04yaf. If your code inadvertently
does return any NaNs or infinities,
e04yaf is likely to produce unexpected results.
 4: $\mathbf{x}\left({\mathbf{n}}\right)$ – Real (Kind=nag_wp) arrayInput

On entry:
${\mathbf{x}}\left(\mathit{j}\right)$, for
$\mathit{j}=1,2,\dots ,n$, must be set to the coordinates of a suitable point at which to check the derivatives calculated by
lsqfun. ‘Obvious’ settings, such as
$0$ or
$1$, should not be used since, at such particular points, incorrect terms may take correct values (particularly zero), so that errors can go undetected. For a similar reason, it is preferable that no two elements of
x should have the same value.
 5: $\mathbf{fvec}\left({\mathbf{m}}\right)$ – Real (Kind=nag_wp) arrayOutput

On exit: unless you set
iflag negative in the first call of
lsqfun,
${\mathbf{fvec}}\left(\mathit{i}\right)$ contains the value of
${f}_{\mathit{i}}$ at the point supplied by you in
x, for
$\mathit{i}=1,2,\dots ,m$.
 6: $\mathbf{fjac}\left({\mathbf{ldfjac}},{\mathbf{n}}\right)$ – Real (Kind=nag_wp) arrayOutput

On exit: unless you set
iflag negative in the first call of
lsqfun,
${\mathbf{fjac}}\left(\mathit{i},\mathit{j}\right)$ contains the value of the first derivative
$\frac{\partial {f}_{\mathit{i}}}{\partial {x}_{\mathit{j}}}$ at the point given in
x, as calculated by
lsqfun, for
$\mathit{i}=1,2,\dots ,m$ and
$\mathit{j}=1,2,\dots ,n$.
 7: $\mathbf{ldfjac}$ – IntegerInput

On entry: the first dimension of the array
fjac as declared in the (sub)program from which
e04yaf is called.
Constraint:
${\mathbf{ldfjac}}\ge {\mathbf{m}}$.
 8: $\mathbf{iw}\left({\mathbf{liw}}\right)$ – Integer arrayWorkspace
 9: $\mathbf{liw}$ – IntegerInput

This array appears in the argument list purely so that, if
e04yaf is called by another library routine, the library routine can pass quantities to
lsqfun via
iw.
iw is not examined or changed by
e04yaf. In general you must provide an array
iw, but are advised not to use it.
On entry: the dimension of the array
iw as declared in the (sub)program from which
e04yaf is called.
Constraint:
${\mathbf{liw}}\ge 1$.
 10: $\mathbf{w}\left({\mathbf{lw}}\right)$ – Real (Kind=nag_wp) arrayWorkspace
 11: $\mathbf{lw}$ – IntegerInput

On entry: the dimension of the array
w as declared in the (sub)program from which
e04yaf is called.
Constraint:
${\mathbf{lw}}\ge 3\times {\mathbf{n}}+{\mathbf{m}}+{\mathbf{m}}\times {\mathbf{n}}$.
 12: $\mathbf{ifail}$ – IntegerInput/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 3.4 in How to Use the NAG Library and its Documentation for details.
For environments where it might be inappropriate to halt program execution when an error is detected, the value
$1\text{ or}1$ is recommended. If the output of error messages is undesirable, then the value
$1$ is recommended. Otherwise, because for this routine the values of the output arguments may be useful even if
${\mathbf{ifail}}\ne {\mathbf{0}}$ on exit, 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.
On exit:
${\mathbf{ifail}}={\mathbf{0}}$ unless the routine detects an error or a warning has been flagged (see
Section 6).
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).
Note: e04yaf may return useful information for one or more of the following detected errors or warnings.
Errors or warnings detected by the routine:
 ${\mathbf{ifail}}<0$

A negative value of
ifail indicates an exit from
e04yaf because you have set
iflag negative in
lsqfun. The setting of
ifail will be the same as your setting of
iflag. The check on
lsqfun will not have been completed.
 ${\mathbf{ifail}}=1$

On entry,  ${\mathbf{m}}<{\mathbf{n}}$, 
or  ${\mathbf{n}}<1$, 
or  ${\mathbf{ldfjac}}<{\mathbf{m}}$, 
or  ${\mathbf{liw}}<1$, 
or  ${\mathbf{lw}}<3\times {\mathbf{n}}+{\mathbf{m}}+{\mathbf{m}}\times {\mathbf{n}}$. 
 ${\mathbf{ifail}}=2$

You should check carefully the derivation and programming of expressions for the
$\frac{\partial {f}_{i}}{\partial {x}_{j}}$, because it is very unlikely that
lsqfun is calculating them correctly.
 ${\mathbf{ifail}}=99$
An unexpected error has been triggered by this routine. Please
contact
NAG.
See
Section 3.9 in How to Use the NAG Library and its Documentation for further information.
 ${\mathbf{ifail}}=399$
Your licence key may have expired or may not have been installed correctly.
See
Section 3.8 in How to Use the NAG Library and its Documentation for further information.
 ${\mathbf{ifail}}=999$
Dynamic memory allocation failed.
See
Section 3.7 in How to Use the NAG Library and its Documentation for further information.
7
Accuracy
ifail is set to
$2$ if
for
$k=1\text{ or}2$. (See
Section 3 for definitions of the quantities involved.) The scalar
$h$ is set equal to
$\sqrt{\epsilon}$, where
$\epsilon $ is the
machine precision as given by
x02ajf.
8
Parallelism and Performance
e04yaf 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.
e04yaf calls
lsqfun three times.
Before using
e04yaf to check the calculation of the first derivatives, you should be confident that
lsqfun is calculating the residuals correctly.
e04yaf only checks the derivatives calculated by a usersupplied routine when
${\mathbf{iflag}}=2$. So, if
lsqfun is intended for use in conjunction with a minimization routine which may set
iflag to
$1$, you must check that, for given settings of the
${\mathbf{xc}}\left(j\right)$,
lsqfun produces the same values for the
$\frac{\partial {f}_{i}}{\partial {x}_{j}}$ when
iflag is set to
$1$ as when
iflag is set to
$2$.
10
Example
Suppose that it is intended to use
e04gbf or
e04gdf to find least squares estimates of
${x}_{1},{x}_{2}$ and
${x}_{3}$ in the model
using the
$15$ sets of data given in the following table.
The following program could be used to check the first derivatives calculated by
lsqfun. (The tests of whether
${\mathbf{iflag}}=0$ or
$1$ in
lsqfun are present ready for when
lsqfun is called by
e04gbf or
e04gdf.
e04yaf will always call
lsqfun with
iflag set to 2.)
10.1
Program Text
Program Text (e04yafe.f90)
10.2
Program Data
Program Data (e04yafe.d)
10.3
Program Results
Program Results (e04yafe.r)