naginterfaces.library.ode.bvp_​fd_​nonlin_​fixedbc

naginterfaces.library.ode.bvp_fd_nonlin_fixedbc(u, v, a, b, tol, fcn, x, np, itrace, comm, data=None, io_manager=None)

bvp_fd_nonlin_fixedbc solves a two-point boundary value problem with assigned boundary values for a system of ordinary differential equations, using a deferred correction technique and a Newton iteration.

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

https://support.nag.com/numeric/nl/nagdoc_30/flhtml/d02/d02gaf.html

Parameters

ufloat, array-like, shape $(n,2)$

$u[\text{i}-1,0]$ must be set to the known or estimated value of $y_{\text{i}}$ at $a$ and $u[\text{i}-1,1]$ must be set to the known or estimated value of $y_{\text{i}}$ at $b$, for $\text{i}=1,2,\dots ,\text{n}$.

vfloat, array-like, shape $(n,2)$

$v[\text{i}-1,\text{j}-1]$ must be set to $0.0$ if $u[\text{i}-1,\text{j}-1]$ is a known value and to $1.0$ if $u[\text{i}-1,\text{j}-1]$ is an estimated value, for $\text{j}=1,2,\dots ,2$, for $\text{i}=1,2,\dots ,\text{n}$.

afloat

$a$, the left-hand boundary point.

bfloat

$b$, the right-hand boundary point.

tolfloat

A positive absolute error tolerance. If

$$a=x_1<x_2<\cdots <x_{np}=b$$

is the final mesh, $z_j\left(x_i\right)$ is the $j$th component of the approximate solution at $x_i$, and $y_j\left(x\right)$ is the $j$th component of the true solution of equation (1) (see Notes) and the boundary conditions, then, except in extreme cases, it is expected that

$$|z_j\left(x_i\right)-y_j\left(x_i\right)|\le tol\text{,}i=1,2,\dots ,np\text{and}j=1,2,\dots ,\text{n}\text{.}$$

fcncallable f = fcn(n, x, y, data=None)

$fcn$ must evaluate the functions $f_{\text{i}}$ (i.e., the derivatives $y_{\text{i}}^{\prime }$), for $\text{i}=1,2,\dots ,\text{n}$, at a general point $x$.

Parameters

nint

$\text{n}$, the number of equations.

xfloat

$x$, the value of the argument.

yfloat, ndarray, shape $\left(n\right)$

$y_{\text{i}}$, for $\text{i}=1,2,\dots ,\text{n}$, the value of the argument.

dataarbitrary, optional, modifiable in place

User-communication data for callback functions.

Returns

ffloat, array-like, shape $\left(n\right)$

The values of $f_{\text{i}}$, for $\text{i}=1,2,\dots ,\text{n}$.

xfloat, array-like, shape $\left(\text{mnp}\right)$

If $np\ge 4$ (see $np$), the first $np$ elements must define an initial mesh. Otherwise the elements of $x$ need not be set.

npint

Determines whether a default or user-supplied mesh is used.

$np=0$

A default value of $4$ for $np$ and a corresponding equispaced mesh $x\left[0\right],x\left[1\right],\dots ,x[np-1]$ are used.

$np\ge 4$

You must define an initial mesh using the array $x$ as described.

itraceint

If $itrace=0$ warning messages be suppressed, otherwise warning messages will be printed (see Exceptions).

commdict, communication object, modified in place

Communication structure.

On initial entry: need not be set.

dataarbitrary, optional

User-communication data for callback functions.

io_managerFileObjManager, optional

Manager for I/O in this routine.

Returns

xfloat, ndarray, shape $\left(\text{mnp}\right)$

$x\left[0\right],x\left[1\right],\dots ,x[np-1]$ define the final mesh (with the returned value of $np$) satisfying the relation (3).

yfloat, ndarray, shape $(n,\text{mnp})$

The approximate solution $z_j\left(x_i\right)$ satisfying (2), on the final mesh, that is

$$y[j-1,i-1]=z_j\left(x_i\right)\text{,}i=1,2,\dots ,np\text{and}j=1,2,\dots ,\text{n}\text{,}$$

where $np$ is the number of points in the final mesh.

The remaining columns of $y$ are not used.

npint

The number of points in the final (returned) mesh.

Raises

NagValueError

(errno $1$)

The sequence $x$ is not strictly increasing. For $i=⟨value⟩$, $x[i-1]=⟨value⟩$ and $x\left[i\right]=⟨value⟩$.

(errno $1$)

On entry: $b=⟨value⟩$ and $x[np-1]=⟨value⟩$.

Constraint: $a=x\left[0\right]<x\left[1\right]<\cdots <x[np-1]=b\text{,}np\ge 4$.

(errno $1$)

On entry: $a=⟨value⟩$ and $x\left[0\right]=⟨value⟩$.

Constraint: $a=x\left[0\right]<x\left[1\right]<\cdots <x[np-1]=b\text{,}np\ge 4$.

(errno $1$)

The sum of known left and right boundary values must equal the number of equations: the number of known left boundary values $=⟨value⟩$, the number of known right boundary values $=⟨value⟩$, the number of equations $=⟨value⟩$.

(errno $1$)

The number of known right boundary values must be less than the number of equations: the number of known right boundary values $=⟨value⟩$, the number of equations $=⟨value⟩$.

(errno $1$)

The number of known left boundary values must be less than the number of equations: the number of known left boundary values $=⟨value⟩$, the number of equations $=⟨value⟩$.

(errno $1$)

On entry, $a=⟨value⟩$ and $b=⟨value⟩$.

Constraint: $b>a$.

(errno $1$)

On entry, $\text{mnp}=⟨value⟩$.

Constraint: $\text{mnp}\ge 32$.

(errno $1$)

On entry, $np=⟨value⟩$ and $\text{mnp}=⟨value⟩$.

Constraint: $np\le \text{mnp}$.

(errno $1$)

On entry, $np=⟨value⟩$.

Constraint: $np=0$ or $np\ge 4$.

(errno $1$)

On entry, $tol=⟨value⟩$.

Constraint: $tol>0.0$.

(errno $1$)

On entry, $n=⟨value⟩$.

Constraint: $n\ge 2$.

(errno $2$)

The Newton iteration has failed to converge.

This could be due to there being too few points in the initial mesh or to the initial approximate solution being too inaccurate. If this latter reason is suspected or you cannot make changes to prevent this error, you should use the routine with a continuation facility instead.

(errno $5$)

A serious error occurred in a call to the internal integrator.

The error code internally was $⟨value⟩$. Please contact NAG.

Warns

NagAlgorithmicWarning

(errno $3$)

Newton iteration has reached round-off level.

If desired accuracy has not been reached, $tol$ is too small for this problem and this machine precision.

(errno $4$)

A finer mesh is required for the accuracy requested; that is, $\text{mnp}=⟨value⟩$ is not large enough.

Notes

In the NAG Library the traditional C interface for this routine uses a different algorithmic base. Please contact NAG if you have any questions about compatibility.

bvp_fd_nonlin_fixedbc solves a two-point boundary value problem for a system of $\text{n}$ differential equations in the interval [$a,b$]. The system is written in the form:

$$y_i^{\prime }=f_i(x,y_1,y_2,\dots ,y_{\text{n}})\text{,}i=1,2,\dots ,\text{n}$$

and the derivatives $f_i$ are evaluated by $fcn$. Initially, $\text{n}$ boundary values of the variables $y_i$ must be specified, some at $a$ and some at $b$. You must supply estimates of the remaining $\text{n}$ boundary values and all the boundary values are used in constructing an initial approximation to the solution. This approximate solution is corrected by a finite difference technique with deferred correction allied with a Newton iteration to solve the finite difference equations. The technique used is described fully in Pereyra (1979). The Newton iteration requires a Jacobian matrix $\frac{\partial f_i}{\partial y_j}$ and this is calculated by numerical differentiation using an algorithm described in Curtis et al. (1974).

You supply an absolute error tolerance and may also supply an initial mesh for the construction of the finite difference equations (alternatively a default mesh is used). The algorithm constructs a solution on a mesh defined by adding points to the initial mesh. This solution is chosen so that the error is everywhere less than your tolerance and so that the error is approximately equidistributed on the final mesh. The solution is returned on this final mesh.

If the solution is required at a few specific points then these should be included in the initial mesh. If on the other hand the solution is required at several specific points then you should use the interpolation functions provided in submodule interp if these points do not themselves form a convenient mesh.

References

Curtis, A R, Powell, M J D and Reid, J K, 1974, On the estimation of sparse Jacobian matrices, J. Inst. Maths. Applics. (13), 117–119

Pereyra, V, 1979, PASVA3: An adaptive finite-difference Fortran program for first order nonlinear, ordinary boundary problems, Codes for Boundary Value Problems in Ordinary Differential Equations. Lecture Notes in Computer Science, (eds B Childs, M Scott, J W Daniel, E Denman and P Nelson) (76), Springer–Verlag