d05bwc computes the quadrature weights associated with the Adams' methods of orders three to six and the Backward Differentiation Formulae (BDF) methods of orders two to five. These rules, which are referred to as reducible quadrature rules, can then be used in the solution of Volterra integral and integro-differential equations.

2 Specification

#include <nag.h>

void	d05bwc (Nag_ODEMethod method, Integer iorder, Integer nomg, double omega[], double sw[], NagError *fail)

The function may be called by the names: d05bwc or nag_inteq_volterra_weights.

3 Description

d05bwc computes the weights

W_{i, j}

and

ω_{i}

for a family of quadrature rules related to the Adams' methods of orders three to six and the BDF methods of orders two to five, for approximating the integral:

\int_{0}^{t} ϕ (s) d s ≃ h \sum_{j = 0}^{p - 1} W_{i, j} ϕ (j \times h) + h \sum_{j = p}^{i} ω_{i - j} ϕ (j \times h), 0 \leq t \leq T,

(1)

with

t = i \times h

, for

i = 0, 1, \dots, n

, for some given constant

h

In (1),

h

is a uniform mesh,

p

is related to the order of the method being used and

W_{i, j}

ω_{i}

are the starting and the convolution weights respectively. The mesh size

h

is determined as

h = \frac{T}{n}

, where

n = n_{w} + p - 1

and

n_{w}

is the chosen number of convolution weights

w_{j}

, for

j = 1, 2, \dots, n_{w} - 1

. A description of how these weights can be used in the solution of a Volterra integral equation of the second kind is given in Section 9. For a general discussion of these methods, see Wolkenfelt (1982) for more details.

4 References

Lambert J D (1973) Computational Methods in Ordinary Differential Equations John Wiley

Wolkenfelt P H M (1982) The construction of reducible quadrature rules for Volterra integral and integro-differential equations IMA J. Numer. Anal. 2 131–152

5 Arguments

1: $method$ – Nag_ODEMethod Input

On entry: the type of method to be used.

$method = Nag_Adams$: For Adams' type formulae.
$method = Nag_BDF$: For Backward Differentiation Formulae.

Constraint:

method = Nag_Adams

Nag_BDF

2: $iorder$ – Integer Input

On entry: the order of the method to be used. The number of starting weights,

p

is determined by method and iorder.

method = Nag_Adams

p = iorder - 1

method = Nag_BDF

p = iorder

Constraints:

if $method = Nag_Adams$ , $3 \leq iorder \leq 6$ ;
if $method = Nag_BDF$ , $2 \leq iorder \leq 5$ .

3: $nomg$ – Integer Input

On entry: the number of convolution weights,

n_{w}

Constraint:

nomg \geq 1

4: $omega [nomg]$ – double Output

On exit: contains the first nomg convolution weights.

5: $sw [n \times p]$ – double Output

Note: the

(i, j)

th element of the matrix is stored in

sw [(j - 1) \times n + i - 1]

On exit:

sw [j \times n + i - 1]

contains the weights

W_{i, j}

, for

i = 1, 2, \dots, n

and

j = 0, 1, \dots, p - 1

, where

n

is as defined in Section 3.

6: $fail$ – NagError * Input/Output

The NAG error argument (see Section 7 in the Introduction to the NAG Library CL Interface).

6 Error Indicators and Warnings

NE_ALLOC_FAIL: Dynamic memory allocation failed.
See Section 3.1.2 in the Introduction to the NAG Library CL Interface for further information.
NE_BAD_PARAM: On entry, argument $⟨ value ⟩$ had an illegal value.
NE_ENUM_INT: On entry, $method = Nag_Adams$ and $iorder = 2$ .
Constraint: if $method = Nag_Adams$ , $3 \leq iorder \leq 6$ .

On entry, $method = Nag_BDF$ and $iorder = 6$ .
Constraint: if $method = Nag_BDF$ , $2 \leq iorder \leq 5$ .
NE_INT: On entry, $iorder = ⟨ value ⟩$ .
Constraint: $2 \leq iorder \leq 6$ .

On entry, $nomg = ⟨ value ⟩$ .
Constraint: $nomg \geq 1$ .
NE_INTERNAL_ERROR: An internal error has occurred in this function. Check the function call and any array sizes. If the call is correct then please contact NAG for assistance.
See Section 7.5 in the Introduction to the NAG Library CL Interface for further information.
NE_NO_LICENCE: Your licence key may have expired or may not have been installed correctly.
See Section 8 in the Introduction to the NAG Library CL Interface for further information.

7 Accuracy

Not applicable.

8 Parallelism and Performance

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

d05bwc is not threaded in any implementation.

9 Further Comments

Reducible quadrature rules are most appropriate for solving Volterra integral equations (and integro-differential equations). In this section, we propose the following algorithm which you may find useful in solving a linear Volterra integral equation of the form

y (t) = f (t) + \int_{0}^{t} K (t, s) y (s) d s, 0 \leq t \leq T,

(2)

using d05bwc. In (2),

K (t, s)

and

f (t)

are given and the solution

y (t)

is sought on a uniform mesh of size

h

such that

T = n h

. Discretization of (2) yields

y_{i} = f (i \times h) + h \sum_{j = 0}^{p - 1} W_{i, j} K (i, h, j, h) y_{j} + h \sum_{j = p}^{i} ω_{i - j} K (i, h, j, h) y_{j},

(3)

where

y_{i} ≃ y (i \times h)

. We propose the following algorithm for computing

y_{i}

from (3) after a call to d05bwc:

(a)Equation (3) requires starting values, $y_{j}$ , for $j = 1, 2, \dots, p - 1$ , with $y_{0} = f (0)$ . These starting values can be computed by solving the linear system

$y_{i} = f (i \times h) + h \sum_{j = 0}^{p - 1} sw [j \times n + i - 1] K (i, h, j, h) y_{j}, i = 1, 2, \dots, p - 1 .$
(b)Compute the inhomogeneous terms

$σ_{i} = f (i \times h) + h \sum_{j = 0}^{p - 1} sw [j \times n + i - 1] K (i, h, j, h) y_{j}, i = p, p + 1, \dots, n .$
(c)Start the iteration for $i = p, p + 1, \dots, n$ to compute $y_{i}$ from:

$(1 - h \times omega [0] K (i, h, i, h)) y_{i} = σ_{i} + h \sum_{j = p}^{i - 1} omega [i - j] K (i, h, j, h) y_{j} .$

Note that for a nonlinear integral equation, the solution of a nonlinear algebraic system is required at step (a) and a single nonlinear equation at step (c).

10 Example

The following example generates the first ten convolution and thirteen starting weights generated by the fourth-order BDF method.

d05bw: FL CL CPP AD PY MB

NAG CL Interfaced05bwc (volterra_​weights)

▸▿ 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 CL Interface
d05bwc (volterra_weights)