NAG Library Routine Document

d02nnf (ivp_stiff_imp_revcom)

1

Purpose

2

Specification

3

Description

!     Declarations 

      Call linear algebra setup routine 
      Call integrator setup routine 
      irevcm=0 
 1000 Call d02nnf(neq, neqmax, t, tout, y, ydot, rwork, rtol, 
       atol, itol, inform, ysave, ny2dim, wkjac, nwkjac, jacpvt, 
       njcpvt, imon, inln, ires, irevcm, lderiv, 
       itask, itrace, ifail)

      If (irevcm.gt.0) Then 
        If (irevcm.gt.7 .and. irevcm.lt.11) Then 
          If (irevcm.eq.8) Then 
            supply the Jacobian matrix                        (i) 
          Else If (irevcm.eq.9) Then 
            perform monitoring tasks requested by the user   (ii) 
          Else If (irevcm.eq.10) Then 
            indicates an unsuccessful step 
          End If 
        Else 
          evaluate the residual                             (iii) 
        Endif 
        Go To 1000 
      End If 

!     post processing (optional linear algebra diagnostic call 
!     (sparse case only), optional integrator diagnostic call) 

      Stop 
      End

      ifail = 1
      errloc = d02zaf(neq,rowk(51+neqmax),rwork(51),ifail)
!     CHECK IFAIL BEFORE PROCEEDING

4

References

5

Arguments

1:     $\mathbf{neq}$ – IntegerInput

On initial entry: the number of equations to be solved.

Constraint: $\mathbf{neq}\ge 1$.

2:     $\mathbf{ldysav}$ – IntegerInput

On initial entry: a bound on the maximum number of equations to be solved during the integration.

Constraint: $\mathbf{ldysav}\ge \mathbf{neq}$.

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

On initial entry: $t$, the value of the independent variable. The input value of t is used only on the first call as the initial point of the integration.

On final exit: the value at which the computed solution $y$ is returned (usually at tout).

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

On initial entry: the next value of $t$ at which a computed solution is desired. For the initial $t$, the input value of tout is used to determine the direction of integration. Integration is permitted in either direction (see also itask).

Constraint: $\mathbf{tout}\ne \mathbf{t}$.

On exit: is unaltered unless $\mathbf{itask}=6$ and $\mathbf{lderiv}\left(2\right)=\mathrm{.TRUE.}$ on entry (see also itask and lderiv) in which case tout will be set to the result of taking a small step at the start of the integration.

5:     $\mathbf{y}\left(\mathbf{neq}\right)$ – Real (Kind=nag_wp) arrayInput/Output

On initial entry: the values of the dependent variables (solution). On the first call the first neq elements of $y$ must contain the vector of initial values.

On final exit: the computed solution vector evaluated at t (usually $t=\mathbf{tout}$).

6:     $\mathbf{ydot}\left(\mathbf{neq}\right)$ – Real (Kind=nag_wp) arrayInput/Output

On initial entry: if $\mathbf{lderiv}\left(1\right)=\mathrm{.TRUE.}$, ydot must contain approximations to the time derivatives $y^{\prime }$ of the vector $y$. If $\mathbf{lderiv}\left(1\right)=\mathrm{.FALSE.}$, ydot need not be set on entry.

On final exit: contains the time derivatives $y^{\prime }$ of the vector $y$ at the last integration point.

7:     $\mathbf{rwork}\left(50+4\times \mathbf{neq}\right)$ – Real (Kind=nag_wp) arrayCommunication Array

On initial entry: must be the same array as used by one of the method setup routines d02mvf, d02nvf or d02nwf, and by one of the storage setup routines d02nsf, d02ntf or d02nuf. The contents of rwork must not be changed between any call to a setup routine and the first call to d02nnf.

On intermediate re-entry: must contain residual evaluations as described under the argument irevcm.

On intermediate exit: contains information for jac, resid and monitr operations as described under Section 3 and the argument irevcm.

8:     $\mathbf{rtol}\left(*\right)$ – Real (Kind=nag_wp) arrayInput

Note: the dimension of the array rtol must be at least $1$ if $\mathbf{itol}=1$ or $2$, and at least $\mathbf{neq}$ otherwise.

On initial entry: the relative local error tolerance.

Constraint: $\mathbf{rtol}\left(i\right)\ge 0.0$ for all relevant $i$ (see itol).

9:     $\mathbf{atol}\left(*\right)$ – Real (Kind=nag_wp) arrayInput

Note: the dimension of the array atol must be at least $1$ if $\mathbf{itol}=1$ or $3$, and at least $\mathbf{neq}$ otherwise.

On initial entry: the absolute local error tolerance.

Constraint: $\mathbf{atol}\left(i\right)\ge 0.0$ for all relevant $i$ (see itol).

10:   $\mathbf{itol}$ – IntegerInput

On initial entry: a value to indicate the form of the local error test. itol indicates to d02nnf whether to interpret either or both of rtol or atol as a vector or a scalar. The error test to be satisfied is $‖e_i/w_i‖<1.0$, where $w_i$ is defined as follows:

itol	rtol	atol	$w_i$
1	scalar	scalar	$\mathbf{rtol}\left(1\right)\times \left|y_i\right|+\mathbf{atol}\left(1\right)$
2	scalar	vector	$\mathbf{rtol}\left(1\right)\times \left|y_i\right|+\mathbf{atol}\left(i\right)$
3	vector	scalar	$\mathbf{rtol}\left(i\right)\times \left|y_i\right|+\mathbf{atol}\left(1\right)$
4	vector	vector	$\mathbf{rtol}\left(i\right)\times \left|y_i\right|+\mathbf{atol}\left(i\right)$

$e_i$ is an estimate of the local error in $y_i$, computed internally, and the choice of norm to be used is defined by a previous call to an integrator setup routine.

Constraint: $\mathbf{itol}=1$, $2$, $3$ or $4$.

11:   $\mathbf{inform}\left(23\right)$ – Integer arrayCommunication Array

12:   $\mathbf{ysav}\left(\mathbf{ldysav},\mathbf{sdysav}\right)$ – Real (Kind=nag_wp) arrayCommunication Array

13:   $\mathbf{sdysav}$ – IntegerInput

On initial entry: the second dimension of the array ysav as declared in the (sub)program from which d02nnf is called. An appropriate value for sdysav is described in the specifications of the integrator setup routines d02mvf, d02nvf and d02nwf. This value must be the same as that supplied to the integrator setup routine.

14:   $\mathbf{wkjac}\left(\mathbf{nwkjac}\right)$ – Real (Kind=nag_wp) arrayInput/Output

On intermediate re-entry: elements of the Jacobian as defined under the description of irevcm. If a numerical Jacobian was requested then wkjac is used for workspace.

On intermediate exit: the Jacobian is overwritten.

15:   $\mathbf{nwkjac}$ – IntegerInput

On initial entry: the dimension of the array wkjac as declared in the (sub)program from which d02nnf is called. The actual size depends on the linear algebra method used. An appropriate value for nwkjac is described in the specifications of the linear algebra setup routines d02nsf, d02ntf and d02nuf for full, banded and sparse matrix linear algebra respectively. This value must be the same as that supplied to the linear algebra setup routine.

16:   $\mathbf{jacpvt}\left(\mathbf{njcpvt}\right)$ – Integer arrayCommunication Array

17:   $\mathbf{njcpvt}$ – IntegerInput

On initial entry: the dimension of the array jacpvt as declared in the (sub)program from which d02nnf is called. The actual size depends on the linear algebra method used. An appropriate value for njcpvt is described in the specifications of the linear algebra setup routines d02ntf and d02nuf for banded and sparse matrix linear algebra respectively. This value must be the same as that supplied to the linear algebra setup routine. When full matrix linear algebra is chosen, the array jacpvt is not used and hence njcpvt should be set to $1$.

18:   $\mathbf{imon}$ – IntegerInput/Output

On intermediate exit: used to pass information between d02nnf and the monitr operation (see Section 3). With $\mathbf{irevcm}=9$, imon contains a flag indicating under what circumstances the return from d02nnf occurred:

$\mathbf{imon}=-2$

Exit from d02nnf after $\mathbf{ires}=4$ (set in the resid operation (see Section 3) caused an early termination (this facility could be used to locate discontinuities).

$\mathbf{imon}=-1$

The current step failed repeatedly.

$\mathbf{imon}=0$

Exit from d02nnf after a call to the internal nonlinear equation solver.

$\mathbf{imon}=1$

The current step was successful.

On intermediate re-entry: may be reset to determine subsequent action in d02nnf.

$\mathbf{imon}=-2$

Integration is to be halted. A return will be made from d02nnf to the calling (sub)program with $\mathbf{ifail}=\mathbf{12}$.

$\mathbf{imon}=-1$

Allow d02nnf to continue with its own internal strategy. The integrator will try up to three restarts unless $\mathbf{imon}\ne -1$.

$\mathbf{imon}=0$

Return to the internal nonlinear equation solver, where the action taken is determined by the value of inln.

$\mathbf{imon}=1$

Normal exit to d02nnf to continue integration.

$\mathbf{imon}=2$

Restart the integration at the current time point. The integrator will restart from order $1$ when this option is used. The internal initialization module solves for new values of $y$ and $y^{\prime }$ by using the values supplied in y and ydot by the monitr operation (see Section 3) as initial estimates.

$\mathbf{imon}=3$

Try to continue with the same step size and order as was to be used before entering the monitr operation (see Section 3). hmin and hmax may be altered if desired.

$\mathbf{imon}=4$

Continue the integration but using a new value of hnext and possibly new values of hmin and hmax.

19:   $\mathbf{inln}$ – IntegerInput/Output

On intermediate re-entry: with $\mathbf{imon}=0$ and $\mathbf{irevcm}=9$, inln specifies the action to be taken by the internal nonlinear equation solver. By setting $\mathbf{inln}=3$ and returning to d02nnf, the residual vector is evaluated and placed in $\mathbf{rwork}\left(50+2\times \mathbf{neq}+\mathit{i}\right)$, for $\mathit{i}=1,2,\dots ,\mathbf{neq}$ and then the monitr operation (see Section 3) is invoked again. At present this is the only option available: inln must not be set to any other value.

On intermediate exit: contains a flag indicating the action to be taken, if any, by the internal nonlinear equation solver.

20:   $\mathbf{ires}$ – IntegerInput/Output

On intermediate exit: with $\mathbf{irevcm}=1$, $2$, $3$, $4$, $5$, $6$, $7$ or $11$, ires specifies the form of the residual to be returned by the resid operation (see Section 3).

If $\mathbf{ires}=1$, $-r=g\left(t,y\right)-A\left(t,y\right)y^{\prime }$ must be returned.

If $\mathbf{ires}=-1$, $-\hat{r}=-A\left(t,y\right)y^{\prime }$ must be returned.

On intermediate re-entry: should be unchanged unless one of the following actions is required of d02nnf in which case ires should be set accordingly.

$\mathbf{ires}=2$

Indicates to d02nnf that control should be passed back immediately to the calling (sub)program with the error indicator set to $\mathbf{ifail}=\mathbf{11}$.

$\mathbf{ires}=3$

Indicates to d02nnf that an error condition has occurred in the solution vector, its time derivative or in the value of $t$. The integrator will use a smaller time step to try to avoid this condition. If this is not possible d02nnf returns to the calling (sub)program with the error indicator set to $\mathbf{ifail}=\mathbf{7}$.

$\mathbf{ires}=4$

Indicates to d02nnf to stop its current operation and to enter the monitr operation (see Section 3) immediately.

21:   $\mathbf{irevcm}$ – IntegerInput/Output

On initial entry: must contain $0$.

On intermediate re-entry: should remain unchanged.

On intermediate exit: indicates what action you must take before re-entering d02nnf. The possible exit values of irevcm are $1$, $2$, $3$, $4$, $5$, $6$, $7$, $8$, $9$, $10$ or $11$ which should be interpreted as follows:

$\mathbf{irevcm}=1$, $2$, $3$, $4$, $5$, $6$, $7$ or $11$

Indicates that a resid operation (see Section 3) is required: you must supply the residual of the system. For each of these values of irevcm, $y_{\mathit{i}}$ is located in $\mathbf{y}\left(\mathit{i}\right)$, for $\mathit{i}=1,2,\dots ,\mathbf{neq}$.

For $\mathbf{irevcm}=1$, $3$, $6$ or $11$, $y_{\mathit{i}}^{\prime }$ is located in $\mathbf{ydot}\left(\mathit{i}\right)$ and $r_{\mathit{i}}$ should be stored in $\mathbf{rwork}\left(50+2\times \mathbf{neq}+\mathit{i}\right)$, for $\mathit{i}=1,2,\dots ,\mathbf{neq}$.

For $\mathbf{irevcm}=2$, $y_{\mathit{i}}^{\prime }$ is located in $\mathbf{rwork}\left(50+\mathbf{neq}+\mathit{i}\right)$ and $r_{\mathit{i}}$ should be stored in $\mathbf{rwork}\left(50+2\times \mathbf{neq}+\mathit{i}\right)$, for $\mathit{i}=1,2,\dots ,\mathbf{neq}$.

For $\mathbf{irevcm}=4$ or $7$, $y_{\mathit{i}}^{\prime }$ is located in $\mathbf{ydot}\left(\mathit{i}\right)$ and $r_{\mathit{i}}$ should be stored in $\mathbf{rwork}\left(50+\mathbf{neq}+\mathit{i}\right)$, for $\mathit{i}=1,2,\dots ,\mathbf{neq}$.

For $\mathbf{irevcm}=5$, $y_{\mathit{i}}^{\prime }$ is located in $\mathbf{rwork}\left(50+2\times \mathbf{neq}+\mathit{i}\right)$ and $r_{\mathit{i}}$ should be stored in $\mathbf{ydot}\left(\mathit{i}\right)$, for $\mathit{i}=1,2,\dots ,\mathbf{neq}$.

$\mathbf{irevcm}=8$

Indicates that a jac operation (see Section 3) is required: you must supply the Jacobian matrix.

If full matrix linear algebra is being used, the $\left(i,j\right)$th element of the Jacobian must be stored in $\mathbf{wkjac}\left(\left(j-1\right)\times \mathbf{neq}+i\right)$.

If banded matrix linear algebra is being used, the $\left(i,j\right)$th element of the Jacobian
must be stored in $\mathbf{wkjac}\left(\left(i-1\right)\times m_B+k\right)$, where $m_B=m_L+m_U+1$ and $k=\min \left(m_L-i+1,0\right)+j$; here $m_L$ and $m_U$ are the number of subdiagonals and superdiagonals, respectively, in the band.

If sparse matrix linear algebra is being used, d02nrf must be called to determine which column of the Jacobian is required and where it should be stored.

Call d02nrf(j, iplace, inform)

will return in j the number of the column of the Jacobian that is required and will set $\mathbf{iplace}=1$ or $2$ (see d02nrf). If $\mathbf{iplace}=1$, you must store the nonzero element $\left(i,j\right)$ of the Jacobian in $\mathbf{rwork}\left(50+2\times \mathbf{neq}+i\right)$; otherwise it must be stored in $\mathbf{rwork}\left(50+\mathbf{neq}+i\right)$.

$\mathbf{irevcm}=9$

Indicates that a monitr operation (see Section 3) can be performed.

$\mathbf{irevcm}=10$

Indicates that the current step was not successful, due to error test failure or convergence test failure. The only information supplied to you on this return is the current value of the variable $t$, located in $\mathbf{rwork}\left(19\right)$. No values must be changed before re-entering d02nnf; this facility enables you to determine the number of unsuccessful steps.

On final exit: $\mathbf{irevcm}=0$ indicating that the user-specified task has been completed or an error has been encountered (see the descriptions for itask and ifail).

Constraint: $0\le \mathbf{irevcm}\le 11$.

Note: any values you return to d02nnf as part of the reverse communication procedure should not include floating-point NaN (Not a Number) or infinity values, since these are not handled by d02nnf. If your code does inadvertently return any NaNs or infinities, d02nnf is likely to produce unexpected results.

22:   $\mathbf{lderiv}\left(2\right)$ – Logical arrayInput/Output

On initial entry: $\mathbf{lderiv}\left(1\right)$ must be set to .TRUE. if you have supplied both an initial $y$ and an initial $y^{\prime }$. $\mathbf{lderiv}\left(1\right)$ must be set to .FALSE. if only the initial $y$ has been supplied.

$\mathbf{lderiv}\left(2\right)$ must be set to .TRUE. if the integrator is to use a modified Newton method to evaluate the initial $y$ and $y^{\prime }$. Note that $y$ and $y^{\prime }$, if supplied, are used as initial estimates. This method involves taking a small step at the start of the integration, and if $\mathbf{itask}=6$ on entry, t and tout will be set to the result of taking this small step. $\mathbf{lderiv}\left(2\right)$ must be set to .FALSE. if the integrator is to use functional iteration to evaluate the initial $y$ and $y^{\prime }$, and if this fails a modified Newton method will then be attempted. $\mathbf{lderiv}\left(2\right)=\mathrm{.TRUE.}$ is recommended if there are implicit equations or the initial $y$ and $y^{\prime }$ are zero.

On final exit: $\mathbf{lderiv}\left(1\right)$ is normally unchanged. However if $\mathbf{itask}=6$ and internal initialization was successful then $\mathbf{lderiv}\left(1\right)=\mathrm{.TRUE.}$.

$\mathbf{lderiv}\left(2\right)=\mathrm{.TRUE.}$, if implicit equations were detected. Otherwise $\mathbf{lderiv}\left(2\right)=\mathrm{.FALSE.}$.

23:   $\mathbf{itask}$ – IntegerInput

On initial entry: the task to be performed by the integrator.

$\mathbf{itask}=1$

Normal computation of output values of $y\left(t\right)$ at $t=\mathbf{tout}$ (by overshooting and interpolating).

$\mathbf{itask}=2$

Take one step only and return.

$\mathbf{itask}=3$

Stop at the first internal integration point at or beyond $t=\mathbf{tout}$ and return.

$\mathbf{itask}=4$

Normal computation of output values of $y\left(t\right)$ at $t=\mathbf{tout}$ but without overshooting $t=\mathbf{tcrit}$. tcrit must be specified as an option in one of the integrator setup routines before the first call to the integrator, or specified in the optional input routine before a continuation call. tcrit (e.g., see d02nvf) may be equal to or beyond tout, but not before it in the direction of integration.

$\mathbf{itask}=5$

Take one step only and return, without passing tcrit (e.g., see d02nvf). tcrit must be specified under $\mathbf{itask}=4$.

$\mathbf{itask}=6$

The integrator will solve for the initial values of $y$ and $y^{\prime }$ only and then return to the calling (sub)program without doing the integration. This option can be used to check the initial values of $y$ and $y^{\prime }$. Functional iteration or a ‘small’ backward Euler method used in conjunction with a damped Newton iteration is used to calculate these values (see lderiv). Note that if a backward Euler step is used then the value of $t$ will have been advanced a short distance from the initial point.

Note:  if d02nnf is recalled with a different value of itask (and tout altered) then the initialization procedure is repeated, possibly leading to different initial conditions.

Constraint: $1\le \mathbf{itask}\le 6$.

24:   $\mathbf{itrace}$ – IntegerInput

On initial entry: the level of output that is printed by the integrator. itrace may take the value $-1$, $0$, $1$, $2$ or $3$.

$\mathbf{itrace}<-1$

$-1$ is assumed and similarly if $\mathbf{itrace}>3$, $3$ is assumed.

$\mathbf{itrace}=-1$

No output is generated.

$\mathbf{itrace}=0$

Only warning messages are printed on the current error message unit (see x04aaf).

$\mathbf{itrace}>0$

Warning messages are printed as above, and on the current advisory message unit (see x04abf) output is generated which details Jacobian entries, the nonlinear iteration and the time integration. The advisory messages are given in greater detail the larger the value of itrace.

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

$\mathbf{ifail}=1$

Either the integrator setup routine has not been called prior to the first call of this routine, or a communication array has become corrupted.

Either the linear algebra setup routine has not been called prior to the first call of this routine, or a communication array has become corrupted.

Either the routine was entered on a continuation call without a prior call of this routine, or a communication array has become corrupted.

Either the value of njcpvt is not the same as the value supplied to the setup routine or a communication array has become corrupted.
$\mathbf{njcpvt}=〈\mathit{\text{value}}〉$, njcpvt (setup) $=〈\mathit{\text{value}}〉$.

Either the value of nwkjac is not the same as the value supplied to the setup routine or a communication array has become corrupted.
$\mathbf{nwkjac}=〈\mathit{\text{value}}〉$, nwkjac (setup) $=〈\mathit{\text{value}}〉$.

Either the value of sdysav is not the same as the value supplied to the setup routine or a communication array has become corrupted.
$\mathbf{sdysav}=〈\mathit{\text{value}}〉$, sdysav (setup) $=〈\mathit{\text{value}}〉$.

Failure during internal time interpolation. tout and the current time are too close.
$\mathbf{itask}=〈\mathit{\text{value}}〉$ and $\mathbf{tout}=〈\mathit{\text{value}}〉$ and the current time is $〈\mathit{\text{value}}〉$.

$\mathbf{itask}=3$ and tout is more than an integration step behind the current time.
$\mathbf{tout}=〈\mathit{\text{value}}〉$, current time minus step size: $〈\mathit{\text{value}}〉$.

On entry, an illegal (negative) maximum number of steps was provided in a prior call to a setup routine. $\mathbf{maxstp}=〈\mathit{\text{value}}〉$.

On entry, an illegal (negative) maximum stepsize was provided in a prior call to a setup routine. $\mathbf{hmax}=〈\mathit{\text{value}}〉$.

On entry, an illegal (negative) minimum stepsize was provided in a prior call to a setup routine. $\mathbf{hmin}=〈\mathit{\text{value}}〉$.

On entry, $\mathbf{atol}=〈\mathit{\text{value}}〉$.
Constraint: $\mathbf{atol}\ge 0.0$.

On entry, $\mathbf{ires}=〈\mathit{\text{value}}〉$ and $\frac{dy}{dt}=0.0$ for all elements.
Check the evaluation of the residual for this value of ires.

On entry, $\mathbf{irevcm}=〈\mathit{\text{value}}〉$.
Constraint: $0\le \mathbf{irevcm}\le 11$.

On entry, $\mathbf{itask}=〈\mathit{\text{value}}〉$.
Constraint: $1\le \mathbf{itask}\le 5$.

On entry, $\mathbf{itask}=4$ or $5$ and tcrit is before the current time in the direction of integration.
$\mathbf{itask}=〈\mathit{\text{value}}〉$, $\mathbf{tcrit}=〈\mathit{\text{value}}〉$ and the current time is $〈\mathit{\text{value}}〉$.

On entry, $\mathbf{itask}=4$ or $5$ and tcrit is before tout in the direction of integration.
$\mathbf{itask}=〈\mathit{\text{value}}〉$, $\mathbf{tcrit}=〈\mathit{\text{value}}〉$ and $\mathbf{tout}=〈\mathit{\text{value}}〉$.

On entry, $\mathbf{itol}=〈\mathit{\text{value}}〉$.
Constraint: $1\le \mathbf{itol}\le 4$.

On entry, $\mathbf{neq}=〈\mathit{\text{value}}〉$.
Constraint: $\mathbf{neq}\ge 1$.

On entry, $\mathbf{neq}=〈\mathit{\text{value}}〉$ and $\mathbf{ldysav}=〈\mathit{\text{value}}〉$.
Constraint: $\mathbf{neq}\le \mathbf{ldysav}$.

On entry, $\mathbf{rtol}=〈\mathit{\text{value}}〉$.
Constraint: $\mathbf{rtol}\ge 0.0$.

On entry, tout is less than t with respect to the direction of integration given by the sign of h0 in a prior call to a setup routine.
$\mathbf{tout}=〈\mathit{\text{value}}〉$, $\mathbf{t}=〈\mathit{\text{value}}〉$ and $\mathbf{h0}=〈\mathit{\text{value}}〉$.

On entry, tout is too close to t to start integration.
$\mathbf{tout}=〈\mathit{\text{value}}〉$ and $\mathbf{t}=〈\mathit{\text{value}}〉$.

On re-entry, $\mathbf{imon}=〈\mathit{\text{value}}〉$.
Constraint: $-2\le \mathbf{imon}\le 4$.

On re-entry, $\mathbf{inln}=〈\mathit{\text{value}}〉$ for the case $\mathbf{irevcm}=9$ and $\mathbf{imon}=0$.
Constraint: $\mathbf{inln}=3$.

On re-entry, ires has been set to an illegal value during initialization.
$\mathbf{ires}=〈\mathit{\text{value}}〉$ at time $〈\mathit{\text{value}}〉$.

On re-entry, the solution vector appears to have been overwritten.
Further integration will not be attempted.

The initial stepsize, $h=〈\mathit{\text{value}}〉$, is too small.

Weight number $i=〈\mathit{\text{value}}〉$ used in the local error test is too small. Check the values of rtol and atol.
$\mathbf{atol}\left(i\right)$ and $\mathbf{y}\left(i\right)$ may both be zero.
Weight $i=〈\mathit{\text{value}}〉$.

$\mathbf{ifail}=2$

At time $〈\mathit{\text{value}}〉$ the maximum number of allowed steps on this call was taken before reaching the next output point $\mathbf{tout}=〈\mathit{\text{value}}〉$.
Maximum number of steps $=〈\mathit{\text{value}}〉$.

$\mathbf{ifail}=3$

Too much accuracy requested for precision of the machine at time $〈\mathit{\text{value}}〉$.
The tolerances should be checked; the requested accuracy should be reduced by a factor of at least $〈\mathit{\text{value}}〉$.

With the given values of rtol and atol no further progress can be made across the integration range from the current point t. The components $\mathbf{y}\left(1\right),\mathbf{y}\left(2\right),\dots ,\mathbf{y}\left(\mathbf{neq}\right)$ contain the computed values of the solution at the current point t.

$\mathbf{ifail}=4$

There were repeated error-test failures on an attempted step, before completing the requested task, but the integration was successful as far as t. The problem may have a singularity, or the local error requirements may be inappropriate.

$\mathbf{ifail}=5$

Nonlinear solver failed to converge using a damped Newton method to solve for initial values.
Damping factor: $〈\mathit{\text{value}}〉$; convergence rate: $〈\mathit{\text{value}}〉$.

$\mathbf{ifail}=6$

At time $〈\mathit{\text{value}}〉$, error weight $〈\mathit{\text{value}}〉$ became zero. Check the values of atol, rtol and itol supplied.

$\mathbf{ifail}=7$

On re-entry, $\mathbf{ires}=3$ which signals that an error condition has occurred in the solution vector, its time derivative or in the value of $t$. It was not possible to remove this condition.
$\mathbf{ires}=〈\mathit{\text{value}}〉$ at $t=〈\mathit{\text{value}}〉$.

$\mathbf{ifail}=8$

Attempt was made to reduce the step size to a value less than the minimum step size during the calculation of initial values.
Minimum stepsize: $〈\mathit{\text{value}}〉$.

The residual routine returned an error when calculating the initial values of the solution and its time derivative.

The user problem has one or more inconsistencies between the $\mathbf{ires}=1$ and $\mathbf{ires}=-1$ parts. Integration will not be attempted.

Workspace error occurred when trying to form the Jacobian matrix in calculating the initial values of the solution and its time derivative.

$\mathbf{ifail}=9$

A singular Jacobian has been encountered. You should check the problem formulation and Jacobian calculation.

$\mathbf{ifail}=10$

Larger integer workspace required.
Provided: $〈\mathit{\text{value}}〉$; required: $〈\mathit{\text{value}}〉$.

Not enough integer store provided for sparse matrix solver.
Units of store needed: $〈\mathit{\text{value}}〉$. Amount provided: $〈\mathit{\text{value}}〉$.

Not enough real store provided for sparse matrix solver.
Units of store needed: $〈\mathit{\text{value}}〉$. Amount provided: $〈\mathit{\text{value}}〉$.

Workspace error occurred when trying to form the Jacobian matrix in calculating the initial values of the solution and its time derivative.

$\mathbf{ifail}=11$

On re-entry, $\mathbf{ires}=2$, which signals that the integration should terminate. $\mathbf{ires}=〈\mathit{\text{value}}〉$ at time $〈\mathit{\text{value}}〉$.

$\mathbf{ifail}=12$

A return was forced by setting $\mathbf{imon}=-2$, but the integration was successful as far as t.

$\mathbf{ifail}=13$

The requested task has been completed, but it is estimated that a small change in rtol and atol is unlikely to produce any change in the computed solution. (This ONLY applies when you are NOT operating in one step mode; that is, when $\mathbf{itask}\ne 2$ or $5$.)

$\mathbf{ifail}=14$

On entry, too much accuracy requested for precision of the machine at the start of problem. The tolerances should be checked; the requested accuracy should be reduced by a factor of at least $〈\mathit{\text{value}}〉$.

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

8

Parallelism and Performance

9

Further Comments

10

Example

10.1

Program Text

Program Text (d02nnfe.f90)

10.2

Program Data

Program Data (d02nnfe.d)

10.3

Program Results

Program Results (d02nnfe.r)