c05axf attempts to locate a zero of a continuous function using a continuation method based on a secant iteration. It uses reverse communication for evaluating the function.

2 Specification

Fortran Interface

Subroutine c05axf (

x, fx, tol, ir, scal, c, ind, ifail)

Integer, Intent (In)	::	ir
Integer, Intent (Inout)	::	ind, ifail
Real (Kind=nag_wp), Intent (In)	::	fx, tol, scal
Real (Kind=nag_wp), Intent (Inout)	::	x, c(26)

C Header Interface

#include <nag.h>

void	c05axf_ (double x, const double fx, const double tol, const Integer ir, const double scal, double c[], Integer ind, Integer *ifail)

The routine may be called by the names c05axf or nagf_roots_contfn_cntin_rcomm.

3 Description

c05axf uses a modified version of an algorithm given in Swift and Lindfield (1978) to compute a zero

α

of a continuous function

f (x)

. The algorithm used is based on a continuation method in which a sequence of problems

f (x) - θ_{r} f (x_{0}), r = 0, 1, \dots, m

are solved, where

1 = θ_{0} > θ_{1} > \dots > θ_{m} = 0

(the value of

m

is determined as the algorithm proceeds) and where

x_{0}

is your initial estimate for the zero of

f (x)

. For each

θ_{r}

the current problem is solved by a robust secant iteration using the solution from earlier problems to compute an initial estimate.

You must supply an error tolerance tol. tol is used directly to control the accuracy of solution of the final problem (

θ_{m} = 0

) in the continuation method, and

\sqrt{tol}

is used to control the accuracy in the intermediate problems (

θ_{1}, θ_{2}, \dots, θ_{m - 1}

4 References

Swift A and Lindfield G R (1978) Comparison of a continuation method for the numerical solution of a single nonlinear equation Comput. J. 21 359–362

5 Arguments

Note: this routine uses reverse communication. Its use involves an initial entry, intermediate exits and re-entries, and a final exit, as indicated by the argument ind. Between intermediate exits and re-entries, all arguments other than fx must remain unchanged.

1: $x$ – Real (Kind=nag_wp) Input/Output

On initial entry: an initial approximation to the zero.

On intermediate exit: the point at which

f

must be evaluated before re-entry to the routine.

On final exit: the final approximation to the zero.

2: $fx$ – Real (Kind=nag_wp) Input

On initial entry: if

ind = 1

, fx need not be set.

ind = −1

, fx must contain

f (x)

for the initial value of x.

On intermediate re-entry: must contain

f (x)

for the current value of x.

3: $tol$ – Real (Kind=nag_wp) Input

On initial entry: a value that controls the accuracy to which the zero is determined. tol is used in determining the convergence of the secant iteration used at each stage of the continuation process. It is used directly when solving the last problem (

θ_{m} = 0

in Section 3), and

\sqrt{tol}

is used for the problem defined by

θ_{r}

r < m

. Convergence to the accuracy specified by tol is not guaranteed, and so you are recommended to find the zero using at least two values for tol to check the accuracy obtained.

Constraint:

tol > 0.0

4: $ir$ – Integer Input

On initial entry: indicates the type of error test required, as follows. Solving the problem defined by

θ_{r}

1 \leq r \leq m

, involves computing a sequence of secant iterates

x_{r}^{0}, x_{r}^{1}, \dots

. This sequence will be considered to have converged only if:

for

ir = 0

| x_{r}^{(i + 1)} - x_{r}^{(i)} | \leq eps \times \max (1.0, | x_{r}^{(i)} |),

for

ir = 1

| x_{r}^{(i + 1)} - x_{r}^{(i)} | \leq eps,

for

ir = 2

| x_{r}^{(i + 1)} - x_{r}^{(i)} | \leq eps \times | x_{r}^{(i)} |,

for some

i > 1

; here

eps

is either tol or

\sqrt{tol}

as discussed above. Note that there are other subsidiary conditions (not given here) which must also be satisfied before the secant iteration is considered to have converged.

Constraint:

ir = 0

1

2

5: $scal$ – Real (Kind=nag_wp) Input

On initial entry: a factor for use in determining a significant approximation to the derivative of

f (x)

x = x_{0}

, the initial value. A number of difference approximations to

f^{'} (x_{0})

are calculated using

f^{'} (x_{0}) \sim (f (x_{0} + h) - f (x_{0})) / h

where

| h | < | scal |

and

h

has the same sign as scal. A significance (cancellation) check is made on each difference approximation and the approximation is rejected if insignificant.

Suggested value:

\sqrt{ε}

, where

ε

is the machine precision returned by x02ajf.

Constraint:

scal

must be sufficiently large that

x + scal \neq x

on the computer.

6: $c (26)$ – Real (Kind=nag_wp) array Communication Array

(

c (5)

contains the current

θ_{r}

, this value may be useful in the event of an error exit.)

7: $ind$ – Integer Input/Output

On initial entry: must be set to

1

−1

$ind = 1$: fx need not be set.
$ind = −1$: fx must contain $f (x)$ .

On intermediate exit: contains

2

3

4

. The calling program must evaluate

f

at x, storing the result in fx, and re-enter c05axf with all other arguments unchanged.

On final exit: contains

0

Constraint: on entry

ind = −1

1

2

3

4

Note: any values you return to c05axf 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 c05axf. If your code does inadvertently return any NaNs or infinities, c05axf is likely to produce unexpected results.

8: $ifail$ – Integer Input/Output

On initial 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.

A value of

0

causes the printing of an error message and program execution will be halted; otherwise program execution continues. A value of

−1

means that an error message is printed while a value of

1

means that it is not.

If halting is not appropriate, the value

−1

1

is recommended. If message printing is undesirable, then the value

1

is recommended. Otherwise, the value

−1

is recommended since useful values can be provided in some output arguments even when

ifail \neq 0

on exit. When the value $- 1$ or $1$ is used it is essential to test the value of ifail on exit.

On final exit:

ifail = 0

unless the routine detects an error or a warning has been flagged (see Section 6).

6 Error Indicators and Warnings

If on entry

ifail = 0

−1

, explanatory error messages are output on the current error message unit (as defined by x04aaf).

Errors or warnings detected by the routine:

$ifail = 1$: On entry, $ir = ⟨ value ⟩$ .
Constraint: $ir = 0$ , $1$ or $2$ .

On entry, $tol = ⟨ value ⟩$ .
Constraint: $tol > 0.0$ .

$ifail = 2$: On initial entry, $ind = ⟨ value ⟩$ .
Constraint: $ind = −1$ or $1$ .

On intermediate entry, $ind = ⟨ value ⟩$ .
Constraint: $ind = 2$ , $3$ or $4$ .

$ifail = 3$: On entry, $scal = ⟨ value ⟩$ .
Constraint: $x + scal \neq x$ (to machine accuracy).

Significant derivatives of $f$ cannot be computed. This can happen when $f$ is almost constant and nonzero, for any value of scal.

$ifail = 4$: Current problem in the continuation sequence cannot be solved. Perhaps the original problem had no solution or the continuation path passes through a set of insoluble problems: consider refining the initial approximation to the zero. Alternatively, tol is too small, and the accuracy requirement is too stringent, or too large and the initial approximation too poor.

$ifail = 5$: Continuation away from the initial point is not possible. This error exit will usually occur if the problem has not been properly posed or the error requirement is extremely stringent.

$ifail = 6$: Final problem (with $θ_{m} = 0$ ) cannot be solved. It is likely that too much accuracy has been requested, or that the zero is at $α = 0$ and $ir = 2$ .

$ifail = - 99$: An unexpected error has been triggered by this routine. Please contact NAG.
See Section 7 in the Introduction to the NAG Library FL Interface for further information.

$ifail = - 399$: Your licence key may have expired or may not have been installed correctly.
See Section 8 in the Introduction to the NAG Library FL Interface for further information.

$ifail = - 999$: Dynamic memory allocation failed.
See Section 9 in the Introduction to the NAG Library FL Interface for further information.

7 Accuracy

The accuracy of the approximation to the zero depends on tol and ir. In general decreasing tol will give more accurate results. Care must be exercised when using the relative error criterion (

ir = 2

If the zero is at

x = 0

, or if the initial value of x and the zero bracket the point

x = 0

, it is likely that an error exit with

ifail = 4

5

6

will occur.

It is possible to request too much or too little accuracy. Since it is not possible to achieve more than machine accuracy, a value of

tol ≪ machine precision

should not be input and may lead to an error exit with

ifail = 4

5

6

. For the reasons discussed under

ifail = 4

in Section 6, tol should not be taken too large, say no larger than

tol = 1.0E−3

8 Parallelism and Performance

Background information to multithreading can be found in the Multithreading documentation.

c05axf is not threaded in any implementation.

9 Further Comments

For most problems, the time taken on each call to c05axf will be negligible compared with the time spent evaluating

f (x)

between calls to c05axf. However, the initial value of x and the choice of tol will clearly affect the timing. The closer that x is to the root, the less evaluations of