d02agf solves a two-point boundary value problem for a system of ordinary differential equations, using initial value techniques and Newton iteration; it generalizes d02haf to include the case where parameters other than boundary values are to be determined.

2 Specification

Fortran Interface

Subroutine d02agf (

h, e, parerr, param, c, n, n1, m1, aux, bcaux, raaux, prsol, mat, copy, wspace, wspac1, wspac2, ifail)

Integer, Intent (In)	::	n, n1, m1
Integer, Intent (Inout)	::	ifail
Real (Kind=nag_wp), Intent (In)	::	e(n), parerr(n1), copy(1,1)
Real (Kind=nag_wp), Intent (Inout)	::	h, param(n1)
Real (Kind=nag_wp), Intent (Out)	::	c(m1,n), mat(n1,n1), wspace(n,9), wspac1(n), wspac2(n)
External	::	aux, bcaux, raaux, prsol

C Header Interface

#include <nag.h>

void

d02agf_ (double *h, const double e[], const double parerr[], double param[], double c[], const Integer *n, const Integer *n1, const Integer *m1,
void (NAG_CALL *aux)(double f[], const double y[], const double *x, const double param[]),
void (NAG_CALL *bcaux)(double g0[], double g1[], const double param[]),
void (NAG_CALL *raaux)(double *x0, double *x1, double *r, const double param[]),
void (NAG_CALL *prsol)(const double param[], const double *res, const Integer *n1, const double err[]),
double mat[], const double copy[], double wspace[], double wspac1[], double wspac2[], Integer *ifail)

The routine may be called by the names d02agf or nagf_ode_bvp_shoot_genpar_intern.

3 Description

d02agf solves a two-point boundary value problem by determining the unknown parameters

p_{1}, p_{2}, \dots, p_{n_{1}}

of the problem. These parameters may be, but need not be, boundary values (as they are in d02haf); they may include eigenvalue parameters in the coefficients of the differential equations, length of the range of integration, etc. The notation and methods used are similar to those of d02haf and you are advised to study this first. (There the parameters

p_{1}, p_{2}, \dots, p_{n_{1}}

correspond to the unknown boundary conditions.) It is assumed that we have a system of

n

first-order ordinary differential equations of the form

\frac{d y_{i}}{d x} = f_{i} (x, y_{1}, y_{2}, \dots, y_{n}), i = 1, 2, \dots, n,

and that derivatives

f_{i}

are evaluated by aux. The system, including the boundary conditions given by bcaux, and the range of integration and matching point,

r

, given by raaux, involves the

n_{1}

unknown parameters

p_{1}, p_{2}, \dots, p_{n_{1}}

which are to be determined, and for which initial estimates must be supplied. The number of unknown parameters

n_{1}

must not exceed the number of equations

n

. If

n_{1} < n

, we assume that

(n - n_{1})

equations of the system are not involved in the matching process. These are usually referred to as ‘driving equations’; they are independent of the parameters and of the solutions of the other

n_{1}

equations. In numbering the equations for aux, the driving equations must be put last.

The estimated values of the parameters are corrected by a form of Newton iteration. The Newton correction on each iteration is calculated using a matrix whose

(i, j)

th element depends on the derivative of the

i

th component of the solution,

y_{i}

, with respect to the

j

th parameter,

p_{j}

. This matrix is calculated by a simple numerical differentiation technique which requires

n_{1}

evaluations of the differential system.

4 References

None.

5 Arguments

You are strongly recommended to read Sections 3 and 9 in conjunction with this section.

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

On entry: h must be set to an estimate of the step size,

h

, needed for integration.

On exit: the last step length used.

2: $e (n)$ – Real (Kind=nag_wp) array Input

On entry:

e (i)

must be set to a small quantity to control the

i

th solution component. The element

e (i)

is used:

(i)in the bound on the local error in the $i$ th component of the solution $y_{i}$ during integration,
(ii)in the convergence test on the $i$ th component of the solution $y_{i}$ at the matching point in the Newton iteration.

The elements

e (i)

should not be chosen too small. They should usually be several orders of magnitude larger than machine precision.

3: $parerr (n1)$ – Real (Kind=nag_wp) array Input

On entry:

parerr (i)

must be set to a small quantity to control the

i

th parameter component. The element

parerr (i)

is used:

(i)in the convergence test on the $i$ th parameter in the Newton iteration,
(ii)in perturbing the $i$ th parameter when approximating the derivatives of the components of the solution with respect to the $i$ th parameter, for use in the Newton iteration.

The elements

parerr (i)

should not be chosen too small. They should usually be several orders of magnitude larger than machine precision.

4: $param (n1)$ – Real (Kind=nag_wp) array Input/Output

On entry:

param (i)

must be set to an estimate for the

i

th parameter,

p_{i}

, for

i = 1, 2, \dots, n1

On exit: the corrected value for the

i

th parameter, unless an error has occurred, when it contains the last calculated value of the parameter (possibly perturbed by

parerr (i) \times (1 + | param (i) |)

if the error occurred when calculating the approximate derivatives).

5: $c (m1, n)$ – Real (Kind=nag_wp) array Output

On exit: the solution when

m1 > 1

(see m1).

m1 = 1

, the elements of c are not used.

6: $n$ – Integer Input

On entry:

n

, the total number of differential equations.

7: $n1$ – Integer Input

On entry:

n_{1}

, the number of parameters.

n1 < n

, the last

n - n1

differential equations (in aux) are driving equations (see Section 3).

Constraint:

n1 \leq n

8: $m1$ – Integer Input

On entry: determines whether or not the final solution is computed as well as the parameter values.

$m1 = 1$: The final solution is not calculated;
$m1 > 1$: The final values of the solution at interval (length of range)/ $(m1 - 1)$ are calculated and stored sequentially in the array c starting with the values of $y_{i}$ evaluated at the first end point (see raaux) stored in $c (1, i)$ .

9: $aux$ – Subroutine, supplied by the user. External Procedure

aux must evaluate the functions

f_{i}

(i.e., the derivatives

y_{i}^{'}

) for given values of its arguments,

x, y_{1}, \dots, y_{n}

p_{1}, \dots, p_{n_{1}} .

The specification of aux is:

Fortran Interface

Subroutine aux (

f, y, x, param)

Real (Kind=nag_wp), Intent (In)	::	y(), x, param()
Real (Kind=nag_wp), Intent (Out)	::	f(*)

C Header Interface

void	aux (double f[], const double y[], const double *x, const double param[])

In the description of the arguments of d02agf below,

n

and

n1

denote the numerical values of n and n1 in the call of d02agf.

1: $f (*)$ – Real (Kind=nag_wp) array Output: On exit: the value of $f_{i}$ , for $i = 1, 2, \dots, n$ .
2: $y (*)$ – Real (Kind=nag_wp) array Input: On entry: $y_{i}$ , for $i = 1, 2, \dots, n$ , the value of the argument.
3: $x$ – Real (Kind=nag_wp) Input: On entry: $x$ , the value of the argument.
4: $param (*)$ – Real (Kind=nag_wp) array Input: On entry: $p_{i}$ , for $i = 1, 2, \dots, n_{1}$ , the value of the parameters.

aux must either be a module subprogram USEd by, or declared as EXTERNAL in, the (sub)program from which d02agf is called. Arguments denoted as Input must not be changed by this procedure.

Note: aux should not return floating-point NaN (Not a Number) or infinity values, since these are not handled by d02agf. If your code inadvertently does return any NaNs or infinities, d02agf is likely to produce unexpected results.

10: $bcaux$ – Subroutine, supplied by the user. External Procedure

bcaux must evaluate the values of

y_{i}

at the end points of the range given the values of

p_{1}, \dots, p_{n_{1}}

The specification of bcaux is:

Fortran Interface

Subroutine bcaux (

g0, g1, param)

Real (Kind=nag_wp), Intent (In)	::	param(*)
Real (Kind=nag_wp), Intent (Out)	::	g0(), g1()

C Header Interface

void	bcaux (double g0[], double g1[], const double param[])

In the description of the arguments of d02agf below,

n

and

n1

denote the numerical values of n and n1 in the call of d02agf.

1: $g0 (*)$ – Real (Kind=nag_wp) array Output: On exit: the values $y_{i}$ , for $i = 1, 2, \dots, n$ , at the boundary point $x_{0}$ (see raaux).
2: $g1 (*)$ – Real (Kind=nag_wp) array Output: On exit: the values $y_{i}$ , for $i = 1, 2, \dots, n$ , at the boundary point $x_{1}$ (see raaux).
3: $param (*)$ – Real (Kind=nag_wp) array Input: On entry: $p_{i}$ , for $i = 1, 2, \dots, n$ , the value of the parameters.

bcaux must either be a module subprogram USEd by, or declared as EXTERNAL in, the (sub)program from which d02agf is called. Arguments denoted as Input must not be changed by this procedure.

Note: bcaux should not return floating-point NaN (Not a Number) or infinity values, since these are not handled by d02agf. If your code inadvertently does return any NaNs or infinities, d02agf is likely to produce unexpected results.

11: $raaux$ – Subroutine, supplied by the user. External Procedure

raaux must evaluate the end points,

x_{0}

and

x_{1}

, of the range and the matching point,

r

, given the values

p_{1}, p_{2}, \dots, p_{n_{1}}

The specification of raaux is:

Fortran Interface

Subroutine raaux (

x0, x1, r, param)

Real (Kind=nag_wp), Intent (In)	::	param(*)
Real (Kind=nag_wp), Intent (Out)	::	x0, x1, r

C Header Interface

void	raaux (double x0, double x1, double *r, const double param[])

In the description of the arguments of d02agf below,

n1

denotes the numerical value of n1 in the call of d02agf.

1: $x0$ – Real (Kind=nag_wp) Output: On exit: must contain the left-hand end of the range, $x_{0}$ .
2: $x1$ – Real (Kind=nag_wp) Output: On exit: must contain the right-hand end of the range $x_{1}$ .
3: $r$ – Real (Kind=nag_wp) Output: On exit: must contain the matching point, $r$ .
4: $param (*)$ – Real (Kind=nag_wp) array Input: On entry: $p_{i}$ , for $i = 1, 2, \dots, n_{1}$ , the value of the parameters.

raaux must either be a module subprogram USEd by, or declared as EXTERNAL in, the (sub)program from which d02agf is called. Arguments denoted as Input must not be changed by this procedure.

Note: raaux should not return floating-point NaN (Not a Number) or infinity values, since these are not handled by d02agf. If your code inadvertently does return any NaNs or infinities, d02agf is likely to produce unexpected results.

12: $prsol$ – Subroutine, supplied by the user. External Procedure

prsol is called at each iteration of the Newton method and can be used to print the current values of the parameters

p_{i}

, for

i = 1, 2, \dots, n_{1}

, their errors,

e_{i}

, and the sum of squares of the errors at the matching point,

r

The specification of prsol is:

Fortran Interface

Subroutine prsol (

param, res, n1, err)

Integer, Intent (In)	::	n1
Real (Kind=nag_wp), Intent (In)	::	param(n1), res, err(n1)

C Header Interface

void	prsol (const double param[], const double res, const Integer n1, const double err[])

1: $param (n1)$ – Real (Kind=nag_wp) array Input: On entry: $p_{i}$ , for $i = 1, 2, \dots, n_{1}$ , the current value of the parameters.
2: $res$ – Real (Kind=nag_wp) Input: On entry: the sum of squares of the errors in the arguments, $\sum_{i = 1}^{n_{1}} e_{i}^{2}$ .
3: $n1$ – Integer Input: On entry: $n_{1}$ , the number of parameters.
4: $err (n1)$ – Real (Kind=nag_wp) array Input: On entry: the errors in the parameters, $e_{i}$ , for $i = 1, 2, \dots, n_{1}$ .

prsol must either be a module subprogram USEd by, or declared as EXTERNAL in, the (sub)program from which d02agf is called. Arguments denoted as Input must not be changed by this procedure.

13: $mat (n1, n1)$ – Real (Kind=nag_wp) array Workspace

14: $copy (1, 1)$ – Real (Kind=nag_wp) array Input

15: $wspace (n, 9)$ – Real (Kind=nag_wp) array Workspace

16: $wspac1 (n)$ – Real (Kind=nag_wp) array Workspace

17: $wspac2 (n)$ – Real (Kind=nag_wp) array Workspace

18: $ifail$ – Integer Input/Output

On 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

0

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

On 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:

Note: a further discussion of these errors and the steps which might be taken to correct them is given in Section 9.

$ifail = 1$: On entry, $n1 = ⟨ value ⟩$ and $n = ⟨ value ⟩$ .
Constraint: $n1 \leq n$ .

$ifail = 2$: No further progress can be made when stepping to obtain a Jacobian update for the current parameter values. Step length $h = ⟨ value ⟩$ .

$ifail = 3$: Currently the matching point $r$ does not lie in range $[x_{0}, x_{1}]$ .
If $x_{0}$ , $x_{1}$ or $r$ depend on the parameters then this may occur when care is not taken to avoid it.
$r = ⟨ value ⟩$ , $x_{0} = ⟨ value ⟩$ and $x_{1} = ⟨ value ⟩$ .

$ifail = 4$: No further progress can be made when stepping to a solution corresponding to the current parameter values.
Step length $h = ⟨ value ⟩$ .
The step length for integration h has halved more than $13$ times (or too many steps were needed to reach the end of the range of integration) in attempting to control the local truncation error whilst integrating to obtain the solution corresponding to the current values $p_{i}$ . If, on failure, h has the sign of $r - x_{0}$ then failure has occurred whilst integrating from $x_{0}$ to $r$ , otherwise it has occurred whilst integrating from $x_{1}$ to $r$ .

$ifail = 5$: The Jacobian for parameter corrections is singular.

$ifail = 6$: The Newton method failed to converge while updating parameter values.

$ifail = 7$: The Newton method has not converged after $12$ iterations while updating parameter values.

$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

If the process converges, the accuracy to which the unknown parameters are determined is usually close to that specified by you; and the solution, if requested, is usually determined to the accuracy specified.

8 Parallelism and Performance

d02agf is threaded by NAG for parallel execution in multithreaded implementations of the NAG Library.

d02agf 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 implementation-specific information.

9 Further Comments

The time taken by d02agf depends on the complexity of the system, and on the number of iterations required. In practice, integration of the differential equations is by far the most costly process involved.

There may be particular difficulty in integrating the differential equations in one direction (indicated by

ifail = 2

4

). The value of

r

should be adjusted to avoid such difficulties.

If the matching point

r

is at one of the end points

x_{0}

x_{1}

and some of the parameters are used only to determine the boundary values at this point, then good initial estimates for these parameters are not required, since they are completely determined by the routine (for example, see

p_{2}

in EX1 of Section 10).

Wherever they occur in the procedure, the error parameters contained in the arrays e and parerr are used in ‘mixed’ form; that is

e (i)

always occurs in expressions of the form

e (i) \times (1 + | y_{i} |)

, and

parerr (i)

always occurs in expressions of the form

parerr (i) \times (1 + | p_{i} |)

. Though not ideal for every application, it is expected that this mixture of absolute and relative error testing will be adequate for most purposes.

Note that convergence is not guaranteed. You are strongly advised to provide an output prsol, as shown in EX1 of Section 10, in order to monitor the progress of the iteration. Failure of the Newton iteration to converge (see

ifail = 6

7

) usually results from poor starting approximations to the parameters, though occasionally such failures occur because the elements of one or both of the arrays parerr or e are too small. (It should be possible to distinguish these cases by studying the output from prsol.) Poor starting approximations can also result in the failure described under

ifail = 4

and

5

in Section 6 (especially if these errors occur after some Newton iterations have been completed, that is, after two or more calls of prsol). More frequently, a singular matrix in the Newton method (monitored as

ifail = 5

) occurs because the mathematical problem has been posed incorrectly. The case

ifail = 4

usually occurs because

h

r

has been poorly estimated, so these values should be checked first. If

ifail = 2

is monitored, the solution

y_{1}, y_{2}, \dots, y_{n}

is sensitive to perturbations in the parameters

p_{i}

. Reduce the size of one or more values

parerr (i)

to reduce the perturbations. Since only one value

p_{i}

is perturbed at any time when forming the matrix, the perturbation which is too large can be located by studying the final output from prsol and the values of the parameters returned by d02agf. If this change leads to other types of failure improve the initial values of

p_{i}

by other means.

The computing time for integrating the differential equations can sometimes depend critically on the quality of the initial estimates for the parameters

p_{i}

. If it seems that too much computing time is required and, in particular, if the values

err (i)

(available on each call of prsol) are much larger than the expected values of the solution at the matching point

r

, then the coding of aux, bcaux and raaux should be checked for errors. If no errors can be found, an independent attempt should be made to improve the initial estimates for

param (i)

The subroutine can be used to solve a very wide range of problems, for example:

(a)eigenvalue problems, including problems where the eigenvalue occurs in the boundary conditions;
(b)problems where the differential equations depend on some parameters which are to be determined so as to satisfy certain boundary conditions (see EX1 in Section 10);
(c)problems where one of the end points of the range of integration is to be determined as the point where a variable $y_{i}$ takes a particular value (see EX2 in Section 10);
(d)singular problems and problems on infinite ranges of integration where the values of the solution at $x_{0}$ or $x_{1}$ or both are determined by a power series or an asymptotic expansion (or a more complicated expression) and where some of the coefficients in the expression are to be determined (see EX1 in Section 10); and
(e)differential equations with certain terms defined by other independent (driving) differential equations.

10 Example

For this routine two examples are presented. There is a single example program for d02agf, with a main program and the code to solve the two example problems given in Example 1 (EX1) and Example 2 (EX2).

Example 1 (EX1)

This example finds the solution of the differential equation

y^{''} = \frac{y^{3} - y^{'}}{2 x}

on the range

0 \leq x \leq 16

, with boundary conditions

y (0) = 0.1

and

y (16) = 1 / 6

We cannot use the differential equation at

x = 0

because it is singular, so we take the truncated series expansion

y (x) = \frac{1}{10} + p_{1} \frac{\sqrt{x}}{10} + \frac{x}{100}

near the origin (which is correct to the number of terms given in this case). Here

p_{1}

is one of the parameters to be determined. We choose the range as

[0.1, 16]

and setting

p_{2} = y^{'} (16)

, we can determine all the boundary conditions. We take the matching point to be

16

, the end of the range, and so a good initial guess for

p_{2}

is not necessary. We write

y = y (1)

y^{'} = y (2)

, and estimate

p_{1} = param (1) = 0.2

p_{2} = param (2) = 0.0

Example 2 (EX2)

This example finds the gravitational constant

p_{1}

and the range

p_{2}

over which a projectile must be fired to hit the target with a given velocity. The differential equations are

\begin{array}{l} y^{'} = \tan ϕ \\ v^{'} = \frac{- (p_{1} \sin ϕ + 0.00002 v^{2})}{v \cos ϕ} \\ ϕ^{'} = \frac{- p_{1}}{v^{2}} k \end{array}

on the range

0 < x < p_{2}

with boundary conditions

\begin{array}{l} y = 0, & v = 500, & ϕ = 0.5 & at & x = 0 \\ y = 0, & v = 450, & ϕ = p_{3} & at & x = p_{2} . \end{array}

We write

y = y (1)

v = y (2)

ϕ = y (3)

, and we take the matching point

r = p_{2}

. We estimate

p_{1} = param (1) = 32

p_{2} = param (2) = 6000

and

p_{3} = param (3) = 0.54

(though this estimate is not important).

d02ag: FL CL CPP AD

NAG FL Interfaced02agf (bvp_​shoot_​genpar_​intern)

▸▿ Contents

1 Purpose

2 Specification

3 Description

4 References

5 Arguments

6 Error Indicators and Warnings

7 Accuracy

8 Parallelism and Performance

9 Further Comments

10 Example

10.1 Program Text

10.2 Program Data

10.3 Program Results

NAG FL Interface
d02agf (bvp_shoot_genpar_intern)