naginterfaces.library.ode.bvp_​shoot_​genpar_​intern

naginterfaces.library.ode.bvp_shoot_genpar_intern(h, e, parerr, param, m1, aux, bcaux, raaux, prsol, data=None)

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

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

https://www.nag.com/numeric/nl/nagdoc_29.3/flhtml/d02/d02agf.html

Parameters

hfloat

$h$ must be set to an estimate of the step size, $h$, needed for integration.

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

$e[i-1]$ must be set to a small quantity to control the $i$th solution component. The element $e[i-1]$ is used:

1. in the bound on the local error in the $i$th component of the solution $y_i$ during integration,

2. 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-1]$ should not be chosen too small.

They should usually be several orders of magnitude larger than machine precision.

parerrfloat, array-like, shape $\left(\text{n1}\right)$

$parerr[i-1]$ must be set to a small quantity to control the $i$th parameter component. The element $parerr[i-1]$ is used:

1. in the convergence test on the $i$th parameter in the Newton iteration,

2. 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-1]$ should not be chosen too small.

They should usually be several orders of magnitude larger than machine precision.

paramfloat, array-like, shape $\left(\text{n1}\right)$

$param[\text{i}-1]$ must be set to an estimate for the $\text{i}$th parameter, $p_{\text{i}}$, for $\text{i}=1,2,\dots ,\text{n1}$.

m1int

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[0,i-1]$.

auxcallable f = aux(n, y, x, param, data=None)

$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_{\text{n}}$, $p_1,\dots ,p_{{\text{n}}_1}\text{.}$

Parameters

nint

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

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

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

xfloat

$x$, the value of the argument.

paramfloat, ndarray, shape $\left(\text{n1}\right)$

$p_{\text{i}}$, for $\text{i}=1,2,\dots ,{\text{n}}_1$, the value of the parameters.

dataarbitrary, optional, modifiable in place

User-communication data for callback functions.

Returns

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

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

bcauxcallable (g0, g1) = bcaux(n, param, data=None)

$bcaux$ must evaluate the values of $y_i$ at the end points of the range given the values of $p_1,\dots ,p_{{\text{n}}_1}$.

Parameters

nint

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

paramfloat, ndarray, shape $\left(\text{n1}\right)$

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

dataarbitrary, optional, modifiable in place

User-communication data for callback functions.

Returns

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

The values $y_{\text{i}}$, for $\text{i}=1,2,\dots ,\text{n}$, at the boundary point $x_0$ (see $raaux$).

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

The values $y_{\text{i}}$, for $\text{i}=1,2,\dots ,\text{n}$, at the boundary point $x_1$ (see $raaux$).

raauxcallable (x0, x1, r) = raaux(param, data=None)

$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_{{\text{n}}_1}$.

Parameters

paramfloat, ndarray, shape $\left(\text{n1}\right)$

$p_{\text{i}}$, for $\text{i}=1,2,\dots ,{\text{n}}_1$, the value of the parameters.

dataarbitrary, optional, modifiable in place

User-communication data for callback functions.

Returns

x0float

Must contain the left-hand end of the range, $x_0$.

x1float

Must contain the right-hand end of the range $x_1$.

rfloat

Must contain the matching point, $r$.

prsolcallable prsol(param, res, err, data=None)

$prsol$ is called at each iteration of the Newton method and can be used to print the current values of the parameters $p_{\text{i}}$, for $\text{i}=1,2,\dots ,{\text{n}}_1$, their errors, $e_i$, and the sum of squares of the errors at the matching point, $r$.

Parameters

paramfloat, ndarray, shape $\left(\text{n1}\right)$

$p_{\text{i}}$, for $\text{i}=1,2,\dots ,{\text{n}}_1$, the current value of the parameters.

resfloat

The sum of squares of the errors in the arguments, ${\sum }_{i=1}^{{\text{n}}_1}{e}_i^2$.

errfloat, ndarray, shape $\left(\text{n1}\right)$

The errors in the parameters, $e_{\text{i}}$, for $\text{i}=1,2,\dots ,{\text{n}}_1$.

dataarbitrary, optional, modifiable in place

User-communication data for callback functions.

dataarbitrary, optional

User-communication data for callback functions.

Returns

hfloat

The last step length used.

paramfloat, ndarray, shape $\left(\text{n1}\right)$

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-1]\times (1+\left|param\right[i-1\left]\right|)$ if the error occurred when calculating the approximate derivatives).

cfloat, ndarray, shape $(m1,n)$

The solution when $m1>1$ (see $m1$).

If $m1=1$, the elements of $c$ are not used.

Raises

NagValueError

(errno $1$)

On entry, $\text{n1}=⟨value⟩$ and $n=⟨value⟩$.

Constraint: $\text{n1}\le n$.

(errno $2$)

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

(errno $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⟩$.

(errno $4$)

No further progress can be made when stepping to a solution corresponding to the current parameter values.

Step length $h=⟨value⟩$.

(errno $5$)

The Jacobian for parameter corrections is singular.

(errno $6$)

The Newton method failed to converge while updating parameter values.

(errno $7$)

The Newton method has not converged after $12$ iterations while updating parameter values.

Notes

No equivalent traditional C interface for this routine exists in the NAG Library.

bvp_shoot_genpar_intern solves a two-point boundary value problem by determining the unknown parameters $p_1,p_2,\dots ,p_{{\text{n}}_1}$ of the problem. These parameters may be, but need not be, boundary values (as they are in bvp_shoot_bval()); 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 bvp_shoot_bval() and you are advised to study this first. (There the parameters $p_1,p_2,\dots ,p_{{\text{n}}_1}$ correspond to the unknown boundary conditions.) It is assumed that we have a system of $\text{n}$ first-order ordinary differential equations of the form

$$\frac{d{y}_i}{dx}=f_i(x,y_1,y_2,\dots ,y_{\text{n}})\text{,}i=1,2,\dots ,\text{n}\text{,}$$

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 ${\text{n}}_1$ unknown parameters $p_1,p_2,\dots ,p_{{\text{n}}_1}$ which are to be determined, and for which initial estimates must be supplied. The number of unknown parameters ${\text{n}}_1$ must not exceed the number of equations $\text{n}$. If ${\text{n}}_1<\text{n}$, we assume that $(\text{n}-{\text{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 ${\text{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 ${\text{n}}_1$ evaluations of the differential system.