naginterfaces.library.inteq.volterra2

naginterfaces.library.inteq.volterra2(ck, cg, cf, method, iorder, alim, tlim, nmesh, tol, thresh, lwk, data=None)

volterra2 computes the solution of a nonlinear convolution Volterra integral equation of the second kind using a reducible linear multi-step method.

For full information please refer to the NAG Library document for d05ba

https://support.nag.com/numeric/nl/nagdoc_30/flhtml/d05/d05baf.html

Parameters

ckcallable retval = ck(t, data=None)

$ck$ must evaluate the kernel $k\left(t\right)$ of the integral equation (1).

Parameters

tfloat

$t$, the value of the independent variable.

dataarbitrary, optional, modifiable in place

User-communication data for callback functions.

Returns

retvalfloat

The value of $k$ at the specified point.

cgcallable retval = cg(s, y, data=None)

$cg$ must evaluate the function $g(s,y\left(s\right))$ in (1).

Parameters

sfloat

$s$, the value of the independent variable.

yfloat

The value of the solution $y$ at the point $s$.

dataarbitrary, optional, modifiable in place

User-communication data for callback functions.

Returns

retvalfloat

The value of $g$ at the specified points.

cfcallable retval = cf(t, data=None)

$cf$ must evaluate the function $f\left(t\right)$ in (1).

Parameters

tfloat

$t$, the value of the independent variable.

dataarbitrary, optional, modifiable in place

User-communication data for callback functions.

Returns

retvalfloat

The value of $f$ at the specified point.

methodstr, length 1

The type of method which you wish to employ.

$method=\text{'A'}$

For Adams’ type formulae.

$method=\text{'B'}$

For backward differentiation formulae.

iorderint

The order of the method to be used.

alimfloat

$a$, the lower limit of the integration interval.

tlimfloat

The final point of the integration interval, $T$.

nmeshint

The number of equidistant points at which the solution is sought.

tolfloat

The relative accuracy required in the computed values of the solution.

threshfloat

The threshold value for use in the evaluation of the estimated relative errors. For two successive meshes the following condition must hold at each point of the coarser mesh

$$\frac{|Y_1-Y_2|}{max(\left|Y_1\right|,\left|Y_2\right|,\left|thresh\right|)}\le tol\text{,}$$

where $Y_1$ is the computed solution on the coarser mesh and $Y_2$ is the computed solution at the corresponding point in the finer mesh. If this condition is not satisfied then the step size is halved and the solution is recomputed.

Note: $thresh$ can be used to effect a relative, absolute or mixed error test. If $thresh=0.0$ then pure relative error is measured and, if the computed solution is small and $thresh=1.0$, absolute error is measured.

lwkint

The dimension of the array $work$.

dataarbitrary, optional

User-communication data for callback functions.

Returns

ynfloat, ndarray, shape $\left(nmesh\right)$

$yn[\text{i}-1]$ contains the most recent approximation of the true solution $y\left(t\right)$ at the specified point $t=alim+\text{i}\times \text{H}$, for $\text{i}=1,2,\dots ,nmesh$, where $\text{H}=(tlim-alim)/nmesh$.

errestfloat, ndarray, shape $\left(nmesh\right)$

$errest[\text{i}-1]$ contains the most recent approximation of the relative error in the computed solution at the point $t=alim+\text{i}\times \text{H}$, for $\text{i}=1,2,\dots ,nmesh$, where $\text{H}=(tlim-alim)/nmesh$.

workfloat, ndarray, shape $\left(lwk\right)$

If $errno$ = 5 or 6, $work\left[0\right]$ contains the size of $lwk$ required for the algorithm to proceed further.

Raises

NagValueError

(errno $1$)

On entry, $method=\text{'A'}$ and $iorder=2$.

Constraint: if $method=\text{'A'}$, $3\le iorder\le 6$.

(errno $1$)

On entry, $tol=⟨value⟩$.

Constraint: $\sqrt{\text{machine precision}}\le tol\le 1.0$.

(errno $1$)

On entry, $alim=⟨value⟩$ and $tlim=⟨value⟩$.

Constraint: $tlim>alim$.

(errno $1$)

On entry, $alim=⟨value⟩$.

Constraint: $alim\ge 0.0$.

(errno $1$)

On entry, $method=\text{'B'}$ and $iorder=6$.

Constraint: if $method=\text{'B'}$, $2\le iorder\le 5$.

(errno $1$)

On entry, $iorder=⟨value⟩$.

Constraint: $2\le iorder\le 6$.

(errno $1$)

On entry, $method=⟨value⟩$.

Constraint: $method=\text{'A'}$ or $\text{'B'}$.

(errno $2$)

On entry, $method=\text{'A'}$, $iorder=⟨value⟩$ and $nmesh=⟨value⟩$.

Constraint: if $method=\text{'A'}$, $nmesh\ge iorder-1$.

(errno $2$)

On entry, $method=\text{'B'}$, $iorder=⟨value⟩$ and $nmesh=⟨value⟩$.

Constraint: if $method=\text{'B'}$, $nmesh\ge iorder$.

(errno $3$)

On entry, $lwk=⟨value⟩$.

Constraint: $lwk\ge 10\times nmesh+6$; that is, $⟨value⟩$.

(errno $4$)

The solution is not converging. See Further Comments.

Warns

NagAlgorithmicWarning

(errno $5$)

The workspace which has been supplied is too small for the required accuracy. The number of extrapolations, so far, is $⟨value⟩$. If you require one more extrapolation extend the size of workspace to: $lwk=⟨value⟩$.

(errno $6$)

The workspace which has been supplied is too small for the required accuracy. The number of extrapolations, so far, is $⟨value⟩$. If you require one more extrapolation extend the size of workspace to: $lwk=⟨value⟩$.

Notes

volterra2 computes the numerical solution of the nonlinear convolution Volterra integral equation of the second kind

$$y\left(t\right)=f\left(t\right)+{\int }_a^{t}k(t-s)g(s,y\left(s\right))ds\text{,}a\le t\le T\text{.}$$

It is assumed that the functions involved in (1) are sufficiently smooth. The function uses a reducible linear multi-step formula selected by you to generate a family of quadrature rules. The reducible formulae available in volterra2 are the Adams–Moulton formulae of orders $3$ to $6$, and the backward differentiation formulae (BDF) of orders $2$ to $5$. For more information about the behaviour and the construction of these rules we refer to Lubich (1983) and Wolkenfelt (1982).

The algorithm is based on computing the solution in a step-by-step fashion on a mesh of equispaced points. The initial step size which is given by $(T-a)/N$, $N$ being the number of points at which the solution is sought, is halved and another approximation to the solution is computed. This extrapolation procedure is repeated until successive approximations satisfy a user-specified error requirement.

The above methods require some starting values. For the Adams’ formula of order greater than $3$ and the BDF of order greater than $2$ we employ an explicit Dormand–Prince–Shampine Runge–Kutta method (see Shampine (1986)). The above scheme avoids the calculation of the kernel, $k\left(t\right)$, on the negative real line.

References

Lubich, Ch, 1983, On the stability of linear multi-step methods for Volterra convolution equations, IMA J. Numer. Anal. (3), 439–465

Shampine, L F, 1986, Some practical Runge–Kutta formulas, Math. Comput. (46(173)), 135–150

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