PDF version (NAG web site
, 64bit version, 64bit version)
NAG Toolbox: nag_ode_bvp_shoot_genpar_intern (d02ag)
Purpose
nag_ode_bvp_shoot_genpar_intern (d02ag) solves a twopoint boundary value problem for a system of ordinary differential equations, using initial value techniques and Newton iteration; it generalizes
nag_ode_bvp_shoot_bval (d02ha) to include the case where parameters other than boundary values are to be determined.
Syntax
[
h,
param,
c,
ifail] = d02ag(
h,
e,
parerr,
param,
m1,
aux,
bcaux,
raaux,
prsol, 'n',
n, 'n1',
n1)
[
h,
param,
c,
ifail] = nag_ode_bvp_shoot_genpar_intern(
h,
e,
parerr,
param,
m1,
aux,
bcaux,
raaux,
prsol, 'n',
n, 'n1',
n1)
Description
nag_ode_bvp_shoot_genpar_intern (d02ag) solves a twopoint boundary value problem by determining the unknown parameters
${p}_{1},{p}_{2},\dots ,{p}_{{\mathit{n}}_{1}}$ of the problem. These parameters may be, but need not be, boundary values (as they are in
nag_ode_bvp_shoot_bval (d02ha)); 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
nag_ode_bvp_shoot_bval (d02ha) and you are advised to study this first. (There the parameters
${p}_{1},{p}_{2},\dots ,{p}_{{\mathit{n}}_{1}}$ correspond to the unknown boundary conditions.) It is assumed that we have a system of
$\mathit{n}$ firstorder ordinary differential equations of the form
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
${\mathit{n}}_{1}$ unknown parameters
${p}_{1},{p}_{2},\dots ,{p}_{{\mathit{n}}_{1}}$ which are to be determined, and for which initial estimates must be supplied. The number of unknown parameters
${\mathit{n}}_{1}$ must not exceed the number of equations
$\mathit{n}$. If
${\mathit{n}}_{1}<\mathit{n}$, we assume that
$\left(\mathit{n}{\mathit{n}}_{1}\right)$ 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
${\mathit{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 $\left(i,j\right)$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 ${\mathit{n}}_{1}$ evaluations of the differential system.
References
None.
Parameters
You are strongly recommended to read
Description and
Further Comments in conjunction with this section.
Compulsory Input Parameters
 1:
$\mathrm{h}$ – double scalar

h must be set to an estimate of the step size,
$h$, needed for integration.
 2:
$\mathrm{e}\left({\mathbf{n}}\right)$ – double array

${\mathbf{e}}\left(i\right)$ must be set to a small quantity to control the
$i$th solution component. The element
${\mathbf{e}}\left(i\right)$ 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
${\mathbf{e}}\left(i\right)$ should not be chosen too small. They should usually be several orders of magnitude larger than
machine precision.
 3:
$\mathrm{parerr}\left({\mathbf{n1}}\right)$ – double array

${\mathbf{parerr}}\left(i\right)$ must be set to a small quantity to control the
$i$th parameter component. The element
${\mathbf{parerr}}\left(i\right)$ 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
${\mathbf{parerr}}\left(i\right)$ should not be chosen too small. They should usually be several orders of magnitude larger than
machine precision.
 4:
$\mathrm{param}\left({\mathbf{n1}}\right)$ – double array

${\mathbf{param}}\left(\mathit{i}\right)$ must be set to an estimate for the $\mathit{i}$th parameter, ${p}_{\mathit{i}}$, for $\mathit{i}=1,2,\dots ,{\mathbf{n1}}$.
 5:
$\mathrm{m1}$ – int64int32nag_int scalar

Determines whether or not the final solution is computed as well as the parameter values.
 ${\mathbf{m1}}=1$
 The final solution is not calculated;
 ${\mathbf{m1}}>1$
 The final values of the solution at interval (length of range)/$\left({\mathbf{m1}}1\right)$ 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 ${\mathbf{c}}\left(1,i\right)$.
 6:
$\mathrm{aux}$ – function handle or string containing name of mfile

aux must evaluate the functions
${f}_{i}$ (i.e., the derivatives
${y}_{i}^{\prime}$) for given values of its arguments,
$x,{y}_{1},\dots ,{y}_{\mathit{n}}$,
${p}_{1},\dots ,{p}_{{\mathit{n}}_{1}}\text{.}$
[f] = aux(y, x, param)
Input Parameters
 1:
$\mathrm{y}\left(:\right)$ – double array

${y}_{\mathit{i}}$, for $\mathit{i}=1,2,\dots ,\mathit{n}$, the value of the argument.
 2:
$\mathrm{x}$ – double scalar

$x$, the value of the argument.
 3:
$\mathrm{param}\left(:\right)$ – double array

${p}_{\mathit{i}}$, for $\mathit{i}=1,2,\dots ,{\mathit{n}}_{1}$, the value of the parameters.
Output Parameters
 1:
$\mathrm{f}\left(:\right)$ – double array

The value of
${f}_{\mathit{i}}$, for $\mathit{i}=1,2,\dots ,\mathit{n}$.
 7:
$\mathrm{bcaux}$ – function handle or string containing name of mfile

bcaux must evaluate the values of
${y}_{i}$ at the end points of the range given the values of
${p}_{1},\dots ,{p}_{{\mathit{n}}_{1}}$.
[g0, g1] = bcaux(param)
Input Parameters
 1:
$\mathrm{param}\left(:\right)$ – double array

${p}_{\mathit{i}}$, for $\mathit{i}=1,2,\dots ,\mathit{n}$, the value of the parameters.
Output Parameters
 1:
$\mathrm{g0}\left(:\right)$ – double array

The values
${y}_{\mathit{i}}$, for
$\mathit{i}=1,2,\dots ,\mathit{n}$, at the boundary point
${x}_{0}$ (see
raaux).
 2:
$\mathrm{g1}\left(:\right)$ – double array

The values
${y}_{\mathit{i}}$, for
$\mathit{i}=1,2,\dots ,\mathit{n}$, at the boundary point
${x}_{1}$ (see
raaux).
 8:
$\mathrm{raaux}$ – function handle or string containing name of mfile

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}_{{\mathit{n}}_{1}}$.
[x0, x1, r] = raaux(param)
Input Parameters
 1:
$\mathrm{param}\left(:\right)$ – double array

${p}_{\mathit{i}}$, for $\mathit{i}=1,2,\dots ,{\mathit{n}}_{1}$, the value of the parameters.
Output Parameters
 1:
$\mathrm{x0}$ – double scalar

Must contain the lefthand end of the range, ${x}_{0}$.
 2:
$\mathrm{x1}$ – double scalar

Must contain the righthand end of the range ${x}_{1}$.
 3:
$\mathrm{r}$ – double scalar

Must contain the matching point, $r$.
 9:
$\mathrm{prsol}$ – function handle or string containing name of mfile

prsol is called at each iteration of the Newton method and can be used to print the current values of the parameters
${p}_{\mathit{i}}$, for
$\mathit{i}=1,2,\dots ,{\mathit{n}}_{1}$, their errors,
${e}_{i}$, and the sum of squares of the errors at the matching point,
$r$.
prsol(param, res, n1, err)
Input Parameters
 1:
$\mathrm{param}\left({\mathbf{n1}}\right)$ – double array

${p}_{\mathit{i}}$, for $\mathit{i}=1,2,\dots ,{\mathit{n}}_{1}$, the current value of the parameters.
 2:
$\mathrm{res}$ – double scalar

The sum of squares of the errors in the arguments, $\sum _{i=1}^{{\mathit{n}}_{1}}}{e}_{i}^{2$.
 3:
$\mathrm{n1}$ – int64int32nag_int scalar

${\mathit{n}}_{1}$, the number of parameters.
 4:
$\mathrm{err}\left({\mathbf{n1}}\right)$ – double array

The errors in the parameters,
${e}_{\mathit{i}}$, for $\mathit{i}=1,2,\dots ,{\mathit{n}}_{1}$.
Optional Input Parameters
 1:
$\mathrm{n}$ – int64int32nag_int scalar

Default:
the dimension of the array
e.
$\mathit{n}$, the total number of differential equations.
 2:
$\mathrm{n1}$ – int64int32nag_int scalar

Default:
the dimension of the arrays
parerr,
param. (An error is raised if these dimensions are not equal.)
${\mathit{n}}_{1}$, the number of parameters.
If
${\mathbf{n1}}<{\mathbf{n}}$, the last
${\mathbf{n}}{\mathbf{n1}}$ differential equations (in
aux) are driving equations (see
Description).
Constraint:
${\mathbf{n1}}\le {\mathbf{n}}$.
Output Parameters
 1:
$\mathrm{h}$ – double scalar

The last step length used.
 2:
$\mathrm{param}\left({\mathbf{n1}}\right)$ – double array

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 ${\mathbf{parerr}}\left(i\right)\times \left(1+\left{\mathbf{param}}\left(i\right)\right\right)$ if the error occurred when calculating the approximate derivatives).
 3:
$\mathrm{c}\left({\mathbf{m1}},{\mathbf{n}}\right)$ – double array

The solution when
${\mathbf{m1}}>1$ (see
m1).
If
${\mathbf{m1}}=1$, the elements of
c are not used.
 4:
$\mathrm{ifail}$ – int64int32nag_int scalar
${\mathbf{ifail}}={\mathbf{0}}$ unless the function detects an error (see
Error Indicators and Warnings).
Error Indicators and Warnings
Errors or warnings detected by the function:
 ${\mathbf{ifail}}=1$

This indicates that ${\mathbf{n1}}>{\mathbf{n}}$ on entry, that is the number of parameters is greater than the number of differential equations.
 ${\mathbf{ifail}}=2$

As for ${\mathbf{ifail}}={\mathbf{4}}$ except that the integration failed while calculating the matrix for use in the Newton iteration.
 ${\mathbf{ifail}}=3$

The current matching point
$r$ does not lie between the current end points
${x}_{0}$ and
${x}_{1}$. If the values
${x}_{0}$,
${x}_{1}$ and
$r$ depend on the parameters
${p}_{i}$, this may occur at any time in the Newton iteration if care is not taken to avoid it when coding
raaux.
 ${\mathbf{ifail}}=4$

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$.
 ${\mathbf{ifail}}=5$

The matrix of the equations to be solved for corrections to the variable parameters in the Newton method is singular (as determined by
nag_lapack_dgetrf (f07ad)).
 ${\mathbf{ifail}}=6$

A satisfactory correction to the parameters was not obtained on the last Newton iteration employed. A Newton iteration is deemed to be unsatisfactory if the sum of the squares of the residuals (which can be printed using
prsol) has not been reduced after three iterations using a new Newton correction.
 ${\mathbf{ifail}}=7$

Convergence has not been obtained after $12$ satisfactory iterations of the Newton method.
 ${\mathbf{ifail}}=99$
An unexpected error has been triggered by this routine. Please
contact
NAG.
 ${\mathbf{ifail}}=399$
Your licence key may have expired or may not have been installed correctly.
 ${\mathbf{ifail}}=999$
Dynamic memory allocation failed.
A further discussion of these errors and the steps which might be taken to correct them is given in
Further Comments.
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.
Further Comments
The time taken by nag_ode_bvp_shoot_genpar_intern (d02ag) 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 ${\mathbf{ifail}}={\mathbf{2}}$ or ${\mathbf{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}$ or
${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 function (for example, see
${p}_{2}$ in EX1 of
Example).
Wherever they occur in the procedure, the error parameters contained in the arrays
e and
parerr are used in ‘mixed’ form; that is
${\mathbf{e}}\left(i\right)$ always occurs in expressions of the form
${\mathbf{e}}\left(i\right)\times \left(1+\left{y}_{i}\right\right)$, and
${\mathbf{parerr}}\left(i\right)$ always occurs in expressions of the form
${\mathbf{parerr}}\left(i\right)\times \left(1+\left{p}_{i}\right\right)$. 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
Example, in order to monitor the progress of the iteration. Failure of the Newton iteration to converge (see
${\mathbf{ifail}}={\mathbf{6}}$ or
${\mathbf{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
${\mathbf{ifail}}={\mathbf{4}}$ and
${\mathbf{5}}$ in
Error Indicators and Warnings (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
${\mathbf{ifail}}={\mathbf{5}}$) occurs because the mathematical problem has been posed incorrectly. The case
${\mathbf{ifail}}={\mathbf{4}}$ usually occurs because
$h$ or
$r$ has been poorly estimated, so these values should be checked first. If
${\mathbf{ifail}}={\mathbf{2}}$ is monitored, the solution
${y}_{1},{y}_{2},\dots ,{y}_{\mathit{n}}$ is sensitive to perturbations in the parameters
${p}_{i}$. Reduce the size of one or more values
${\mathbf{parerr}}\left(i\right)$ 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
nag_ode_bvp_shoot_genpar_intern (d02ag). 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
${\mathbf{err}}\left(i\right)$ (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
${\mathbf{param}}\left(i\right)$.
The function 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 Example); 
(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 Example); 
(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 Example); and 
(e) 
differential equations with certain terms defined by other independent (driving) differential equations. 
Example
For this function two examples are presented. There is a single example program for nag_ode_bvp_shoot_genpar_intern (d02ag), 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
on the range
$0\le x\le 16$, with boundary conditions
$y\left(0\right)=0.1$ and
$y\left(16\right)=1/6$.
We cannot use the differential equation at
$x=0$ because it is singular, so we take the truncated series expansion
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
$\left[0.1,16\right]$ and setting
${p}_{2}={y}^{\prime}\left(16\right)$, 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={\mathbf{y}}\left(1\right)$,
${y}^{\prime}={\mathbf{y}}\left(2\right)$, and estimate
${p}_{1}={\mathbf{param}}\left(1\right)=0.2$,
${p}_{2}={\mathbf{param}}\left(2\right)=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
on the range
$0<x<{p}_{2}$ with boundary conditions
We write
$y={\mathbf{y}}\left(1\right)$,
$v={\mathbf{y}}\left(2\right)$,
$\varphi ={\mathbf{y}}\left(3\right)$, and we take the matching point
$r={p}_{2}$. We estimate
${p}_{1}={\mathbf{param}}\left(1\right)=32$,
${p}_{2}={\mathbf{param}}\left(2\right)=6000$ and
${p}_{3}={\mathbf{param}}\left(3\right)=0.54$ (though this estimate is not important).
Open in the MATLAB editor:
d02ag_example
function d02ag_example
fprintf('d02ag example results\n\n');
global iprint;
h = 0.1;
e = [0.0001; 0.0001];
parerr = [1e05; 0.001];
param = [0.2; 0];
m1 = 6;
n = 2;
marray = zeros(1,m1);
fprintf('Case 1 \n\n');
iprint = 0;
[h, param, c, ifail] = ...
d02ag(...
h, e, parerr, param, int64(m1), @aux1, @bcaux1, @raaux1, @prsol);
fprintf('Final parameters \n');
disp(sprintf(' %10.2e',param));
fprintf('\n Final solution \n');
fprintf(' Xvalue Components of solution\n');
[x0, x1, r] = raaux1(param);
h = (x1x0)/double(m11);
for i = 1:m1;
m = x0 + double(i1)*h;
fprintf('%8.2f ',m);
fprintf('%14.4e',c(i,1:n));
fprintf('\n');
marray(i) = m;
end
fprintf('\n\n Case 2 \n\n');
iprint = 0;
h = 10.0;
param = [32.0; 6000.0; 0.54];
parerr = [1.0e5; 1.0e4; 1.0e4];
e = [1.0e2; 1.0e2; 1.0e2];
n = 3;
m1 = 6;
qarray = zeros(1,m1);
[h, param, c1, ifail] = ...
d02ag( ...
h, e, parerr, param, int64(m1), @aux2, @bcaux2, @raaux2, @prsol);
fprintf('Final parameters\n');
fprintf(' %10.2e',param);
fprintf('\n\nFinal solution\n');
fprintf(' Xvalue Components of solution\n');
[x0, x1, r] = raaux2(param);
h = (x1x0)/double(m11);
for i = 1:m1;
q = x0 + double(i1)*h;
fprintf('%8.0f ',q);
fprintf('%14.4e',c1(i,1:n));
fprintf('\n');
qarray(i) = q;
end
fig1 = figure;
display_plot(marray, c, 'Solution and Derivative');
fig2 = figure;
display_plot(qarray, c1, 'Height and Velocity');
function [f] = aux1(y,x,param)
f(1) = y(2);
f(2) = (y(1)^3y(2))/(2.0*x);
function [g0,g1] = bcaux1(param)
z = 0.1;
g0(1) = 0.1 + param(1)*sqrt(z)*0.1 + 0.01*z;
g0(2) = param(1)*0.05/sqrt(z) + 0.01;
g1(1) = 1.0/6.0;
g1(2) = param(2);
function [] = prsol(param, resid, n, err)
global iprint;
if iprint == 1
fprintf('Current parameters: ');
fprintf('%15.6e ', param(1:n));
fprintf('\nResiduals: ');
fprintf('%13.6e ', err(1:n));
fprintf('\nSum of residuals squared = %13.6e\n', resid);
end
function [x0, x1, r] = raaux1(param)
x0 = 0.1;
x1 = 16;
r = 16;
function [f] = aux2(y,x,param)
c = cos(y(3));
s = sin(y(3));
f(1) = s/c;
f(2) = (param(1)*s+0.00002*y(2)*y(2))/(y(2)*c);
f(3) = param(1)/(y(2)*y(2));
function [g0,g1] = bcaux2(param)
g0(1) = 0;
g0(2) = 500;
g0(3) = 0.5;
g1(1) = 0;
g1(2) = 450;
g1(3) = param(3);
function [x0, x1, r] = raaux2(param)
x0 = double(0);
x1 = param(2);
r = param(2);
function display_plot(data, index, ylabelString)
if strncmp(ylabelString, 'Solution', 8)
plot(data,index(:,1),'+',data,index(:,2),'x');
set(gca, 'XLim', [0 16]);
set(gca, 'XTick', [0 4 8 12 16]);
title('Parameterized Twopoint Boundaryvalue Problem');
xlabel('x');
ylabel(ylabelString);
legend('solution y(x)','derivative y''(x)','Location','Best');
else
[haxes, hline1, hline2] = plotyy(data,index(:,1),data,index(:,3));
hold on
hline3 = plot(data,index(:,2));
set(haxes(1), 'YLim', [0 850]);
set(haxes(1), 'YMinorTick', 'on');
set(haxes(1), 'YTick', [0 200 400 600 800]);
set(haxes(2), 'YLim', [1 1]);
set(haxes(2), 'YMinorTick', 'on');
set(haxes(2), 'YTick', [1 0.5 0 0.5 1]);
for iaxis = 1:2
set(haxes(iaxis), 'XLim', [0 6000]);
set(haxes(iaxis), 'XTick', [0 1000 2000 3000 4000 5000 6000]);
end
set(gca, 'box', 'off');
title(['Range from Projectile Terminal Velocity']);
xlabel('x');
ylabel(haxes(1),ylabelString);
ylabel(haxes(2),'Angle');
legend('angle','height','velocity','Location','Best');
set(hline1, 'Linewidth', 0.5, 'Marker', '+', 'LineStyle', '');
set(hline2, 'Linewidth', 0.5, 'Marker', '*', 'LineStyle', '');
set(hline3, 'Linewidth', 0.5, 'Marker', 'x', 'LineStyle', '', ...
'Color', 'Magenta');
end
d02ag example results
Case 1
Final parameters
4.64e02 3.49e03
Final solution
Xvalue Components of solution
0.10 1.0247e01 1.7341e02
3.28 1.2170e01 4.1796e03
6.46 1.3382e01 3.5764e03
9.64 1.4488e01 3.4178e03
12.82 1.5572e01 3.4142e03
16.00 1.6667e01 3.4943e03
Case 2
Final parameters
3.24e+01 5.96e+03 5.35e01
Final solution
Xvalue Components of solution
0 0.0000e+00 5.0000e+02 5.0000e01
1193 5.2981e+02 4.5156e+02 3.2807e01
2385 8.0765e+02 4.2030e+02 1.2315e01
3578 8.2080e+02 4.0944e+02 1.0316e01
4771 5.5625e+02 4.2001e+02 3.2958e01
5963 0.0000e+00 4.5000e+02 5.3523e01
PDF version (NAG web site
, 64bit version, 64bit version)
© The Numerical Algorithms Group Ltd, Oxford, UK. 2009–2015