nag_ode_bvp_coll_nlin_solve (d02tlc) : NAG Library, Mark 26

ffun

– function, supplied by the userExternal Function

ffun must evaluate the functions

f_{i}

for given values

x, z (y (x))

The specification of ffun is:

void	ffun (double x, const double y[], Integer neq, const Integer m[], double f[], Nag_Comm *comm)

1: $x$ – doubleInput

On entry:

x

, the independent variable.

2: $y [\dim]$ – const doubleInput

Note: the dimension, dim, of the array y is

neq \times \max (m [i])

Where

Y (i, j)

appears in this document, it refers to the array element

y [j \times neq + i - 1]

On entry:

Y (i, j)

contains

y_{i}^{(j)} (x)

, for

i = 1, 2, \dots, neq

and

j = 0, 1, \dots, m [i - 1] - 1

.
Note:

y_{i}^{(0)} (x) = y_{i} (x)

3: $neq$ – IntegerInput

On entry: the number of differential equations.

4: $m [neq]$ – const IntegerInput

On entry:

m [i - 1]

contains

m_{i}

, the order of the

i

th differential equation, for

i = 1, 2, \dots, neq

5: $f [neq]$ – doubleOutput

On exit:

f [i - 1]

must contain

f_{i}

, for

i = 1, 2, \dots, neq

6: $comm$ – Nag_Comm *

Pointer to structure of type Nag_Comm; the following members are relevant to ffun.

user – double *
iuser – Integer *
p – Pointer: The type Pointer will be void *. Before calling nag_ode_bvp_coll_nlin_solve (d02tlc) you may allocate memory and initialize these pointers with various quantities for use by ffun when called from nag_ode_bvp_coll_nlin_solve (d02tlc) (see Section 3.3.1.1 in How to Use the NAG Library and its Documentation).

Note: ffun should not return floating-point NaN (Not a Number) or infinity values, since these are not handled by nag_ode_bvp_coll_nlin_solve (d02tlc). If your code inadvertently does return any NaNs or infinities, nag_ode_bvp_coll_nlin_solve (d02tlc) is likely to produce unexpected results.

fjac

– function, supplied by the userExternal Function

fjac must evaluate the partial derivatives of

f_{i}

with respect to the elements of

z (y (x)) = (y_{1} (x), y_{1}^{1} (x), \dots, y_{1}^{(m_{1} - 1)} (x), y_{2} (x), \dots, y_{n}^{(m_{n} - 1)} (x))

The specification of fjac is:

void	fjac (double x, const double y[], Integer neq, const Integer m[], double dfdy[], Nag_Comm *comm)

1: $x$ – doubleInput

On entry:

x

, the independent variable.

2: $y [\dim]$ – const doubleInput

Note: the dimension, dim, of the array y is

neq \times \max (m [i])

Where

Y (i, j)

appears in this document, it refers to the array element

y [j \times neq + i - 1]

On entry:

Y (i, j)

contains

y_{i}^{(j)} (x)

, for

i = 1, 2, \dots, neq

and

j = 0, 1, \dots, m [i - 1] - 1

.
Note:

y_{i}^{(0)} (x) = y_{i} (x)

3: $neq$ – IntegerInput

On entry: the number of differential equations.

4: $m [neq]$ – const IntegerInput

On entry:

m [i - 1]

contains

m_{i}

, the order of the

i

th differential equation, for

i = 1, 2, \dots, neq

5: $dfdy [\dim]$ – doubleInput/Output

Note: the dimension, dim, of the array dfdy is

neq \times neq \times \max (m [i])

Where

DFDY (i, j, k)

appears in this document, it refers to the array element

dfdy [k \times neq \times neq + (j - 1) \times neq + i - 1]

On entry: set to zero.

On exit:

DFDY (i, j, k)

must contain the partial derivative of

f_{i}

with respect to

y_{j}^{(k)}

, for

i = 1, 2, \dots, neq

j = 1, 2, \dots, neq

and

k = 0, 1, \dots, m [j - 1] - 1

. Only nonzero partial derivatives need be set.

6: $comm$ – Nag_Comm *

Pointer to structure of type Nag_Comm; the following members are relevant to fjac.

user – double *
iuser – Integer *
p – Pointer: The type Pointer will be void *. Before calling nag_ode_bvp_coll_nlin_solve (d02tlc) you may allocate memory and initialize these pointers with various quantities for use by fjac when called from nag_ode_bvp_coll_nlin_solve (d02tlc) (see Section 3.3.1.1 in How to Use the NAG Library and its Documentation).

Note: fjac should not return floating-point NaN (Not a Number) or infinity values, since these are not handled by nag_ode_bvp_coll_nlin_solve (d02tlc). If your code inadvertently does return any NaNs or infinities, nag_ode_bvp_coll_nlin_solve (d02tlc) is likely to produce unexpected results.

gafun

– function, supplied by the userExternal Function

gafun must evaluate the boundary conditions at the left-hand end of the range, that is functions

g_{i} (z (y (a)))

for given values of

z (y (a))

The specification of gafun is:

void	gafun (const double ya[], Integer neq, const Integer m[], Integer nlbc, double ga[], Nag_Comm *comm)

1: $ya [\dim]$ – const doubleInput

Note: the dimension, dim, of the array ya is

neq \times \max (m [i])

Where

YA (i, j)

appears in this document, it refers to the array element

ya [j \times neq + i - 1]

On entry:

YA (i, j)

contains

y_{i}^{(j)} (a)

, for

i = 1, 2, \dots, neq

and

j = 0, 1, \dots, m [i - 1] - 1

.
Note:

y_{i}^{(0)} (a) = y_{i} (a)

2: $neq$ – IntegerInput

On entry: the number of differential equations.

3: $m [neq]$ – const IntegerInput

On entry:

m [i - 1]

contains

m_{i}

, the order of the

i

th differential equation, for

i = 1, 2, \dots, neq

4: $nlbc$ – IntegerInput

On entry: the number of boundary conditions at

a

5: $ga [nlbc]$ – doubleOutput

On exit:

ga [i - 1]

must contain

g_{i} (z (y (a)))

, for

i = 1, 2, \dots, nlbc

6: $comm$ – Nag_Comm *

Pointer to structure of type Nag_Comm; the following members are relevant to gafun.

user – double *
iuser – Integer *
p – Pointer: The type Pointer will be void *. Before calling nag_ode_bvp_coll_nlin_solve (d02tlc) you may allocate memory and initialize these pointers with various quantities for use by gafun when called from nag_ode_bvp_coll_nlin_solve (d02tlc) (see Section 3.3.1.1 in How to Use the NAG Library and its Documentation).

Note: gafun should not return floating-point NaN (Not a Number) or infinity values, since these are not handled by nag_ode_bvp_coll_nlin_solve (d02tlc). If your code inadvertently does return any NaNs or infinities, nag_ode_bvp_coll_nlin_solve (d02tlc) is likely to produce unexpected results.

gbfun

– function, supplied by the userExternal Function

gbfun must evaluate the boundary conditions at the right-hand end of the range, that is functions

{\bar{g}}_{i} (z (y (b)))

for given values of

z (y (b))

The specification of gbfun is:

void	gbfun (const double yb[], Integer neq, const Integer m[], Integer nrbc, double gb[], Nag_Comm *comm)

1: $yb [\dim]$ – const doubleInput

Note: the dimension, dim, of the array yb is

neq \times \max (m [i])

Where

YB (i, j)

appears in this document, it refers to the array element

yb [j \times neq + i - 1]

On entry:

YB (i, j)

contains

y_{i}^{(j)} (b)

, for

i = 1, 2, \dots, neq

and

j = 0, 1, \dots, m [i - 1] - 1

.
Note:

y_{i}^{(0)} (b) = y_{i} (b)

2: $neq$ – IntegerInput

On entry: the number of differential equations.

3: $m [neq]$ – const IntegerInput

On entry:

m [i - 1]

contains

m_{i}

, the order of the

i

th differential equation, for

i = 1, 2, \dots, neq

4: $nrbc$ – IntegerInput

On entry: the number of boundary conditions at

b

5: $gb [nrbc]$ – doubleOutput

On exit:

gb [i - 1]

must contain

{\bar{g}}_{i} (z (y (b)))

, for

i = 1, 2, \dots, nrbc

6: $comm$ – Nag_Comm *

Pointer to structure of type Nag_Comm; the following members are relevant to gbfun.

user – double *
iuser – Integer *
p – Pointer: The type Pointer will be void *. Before calling nag_ode_bvp_coll_nlin_solve (d02tlc) you may allocate memory and initialize these pointers with various quantities for use by gbfun when called from nag_ode_bvp_coll_nlin_solve (d02tlc) (see Section 3.3.1.1 in How to Use the NAG Library and its Documentation).

Note: gbfun should not return floating-point NaN (Not a Number) or infinity values, since these are not handled by nag_ode_bvp_coll_nlin_solve (d02tlc). If your code inadvertently does return any NaNs or infinities, nag_ode_bvp_coll_nlin_solve (d02tlc) is likely to produce unexpected results.

gajac

– function, supplied by the userExternal Function

gajac must evaluate the partial derivatives of

g_{i} (z (y (a)))

with respect to the elements of

z (y (a)) = (y_{1} (a), y_{1}^{1} (a), \dots, y_{1}^{(m_{1} - 1)} (a), y_{2} (a), \dots, y_{n}^{(m_{n} - 1)} (a))

The specification of gajac is:

void	gajac (const double ya[], Integer neq, const Integer m[], Integer nlbc, double dgady[], Nag_Comm *comm)

1: $ya [\dim]$ – const doubleInput

Note: the dimension, dim, of the array ya is

neq \times \max (m [i])

Where

YA (i, j)

appears in this document, it refers to the array element

ya [j \times neq + i - 1]

On entry:

YA (i, j)

contains

y_{i}^{(j)} (a)

, for

i = 1, 2, \dots, neq

and

j = 0, 1, \dots, m [i - 1] - 1

.
Note:

y_{i}^{(0)} (a) = y_{i} (a)

2: $neq$ – IntegerInput

On entry: the number of differential equations.

3: $m [neq]$ – const IntegerInput

On entry:

m [i - 1]

contains

m_{i}

, the order of the

i

th differential equation, for

i = 1, 2, \dots, neq

4: $nlbc$ – IntegerInput

On entry: the number of boundary conditions at

a

5: $dgady [\dim]$ – doubleInput/Output

Note: the dimension, dim, of the array dgady is

nlbc \times neq \times \max (m [i])

Where

DGADY (i, j, k)

appears in this document, it refers to the array element

dgady [k \times nlbc \times neq + (j - 1) \times nlbc + i - 1]

On entry: set to zero.

On exit:

DGADY (i, j, k)

must contain the partial derivative of

g_{i} (z (y (a)))

with respect to

y_{j}^{(k)} (a)

, for

i = 1, 2, \dots, nlbc

j = 1, 2, \dots, neq

and

k = 0, 1, \dots, m [j - 1] - 1

. Only nonzero partial derivatives need be set.

6: $comm$ – Nag_Comm *

Pointer to structure of type Nag_Comm; the following members are relevant to gajac.

user – double *
iuser – Integer *
p – Pointer: The type Pointer will be void *. Before calling nag_ode_bvp_coll_nlin_solve (d02tlc) you may allocate memory and initialize these pointers with various quantities for use by gajac when called from nag_ode_bvp_coll_nlin_solve (d02tlc) (see Section 3.3.1.1 in How to Use the NAG Library and its Documentation).

Note: gajac should not return floating-point NaN (Not a Number) or infinity values, since these are not handled by nag_ode_bvp_coll_nlin_solve (d02tlc). If your code inadvertently does return any NaNs or infinities, nag_ode_bvp_coll_nlin_solve (d02tlc) is likely to produce unexpected results.

gbjac

– function, supplied by the userExternal Function

gbjac must evaluate the partial derivatives of

{\bar{g}}_{i} (z (y (b)))

with respect to the elements of

z (y (b)) = (y_{1} (b), y_{1}^{1} (b), \dots, y_{1}^{(m_{1} - 1)} (b), y_{2} (b), \dots, y_{n}^{(m_{n} - 1)} (b))

The specification of gbjac is:

void	gbjac (const double yb[], Integer neq, const Integer m[], Integer nrbc, double dgbdy[], Nag_Comm *comm)

1: $yb [\dim]$ – const doubleInput

Note: the dimension, dim, of the array yb is

neq \times \max (m [i])

Where

YB (i, j)

appears in this document, it refers to the array element

yb [j \times neq + i - 1]

On entry:

YB (i, j)

contains

y_{i}^{(j)} (b)

, for

i = 1, 2, \dots, neq

and

j = 0, 1, \dots, m [i - 1] - 1

.
Note:

y_{i}^{(0)} (b) = y_{i} (b)

2: $neq$ – IntegerInput

On entry: the number of differential equations.

3: $m [neq]$ – const IntegerInput

On entry:

m [i - 1]

contains

m_{i}

, the order of the

i

th differential equation, for

i = 1, 2, \dots, neq

4: $nrbc$ – IntegerInput

On entry: the number of boundary conditions at

b

5: $dgbdy [\dim]$ – doubleInput/Output

Note: the dimension, dim, of the array dgbdy is

nrbc \times neq \times \max (m [i])

Where

DGBDY (i, j, k)

appears in this document, it refers to the array element

dgbdy [(k - 1) \times nrbc \times neq + (j - 1) \times nrbc + i - 1]

On entry: set to zero.

On exit:

DGBDY (i, j, k)

must contain the partial derivative of

{\bar{g}}_{i} (z (y (b)))

with respect to

y_{j}^{(k)} (b)

, for

i = 1, 2, \dots, nrbc

j = 1, 2, \dots, neq

and

k = 0, 1, \dots, m [j - 1] - 1

. Only nonzero partial derivatives need be set.

6: $comm$ – Nag_Comm *

Pointer to structure of type Nag_Comm; the following members are relevant to gbjac.

user – double *
iuser – Integer *
p – Pointer: The type Pointer will be void *. Before calling nag_ode_bvp_coll_nlin_solve (d02tlc) you may allocate memory and initialize these pointers with various quantities for use by gbjac when called from nag_ode_bvp_coll_nlin_solve (d02tlc) (see Section 3.3.1.1 in How to Use the NAG Library and its Documentation).

Note: gbjac should not return floating-point NaN (Not a Number) or infinity values, since these are not handled by nag_ode_bvp_coll_nlin_solve (d02tlc). If your code inadvertently does return any NaNs or infinities, nag_ode_bvp_coll_nlin_solve (d02tlc) is likely to produce unexpected results.

guess

– function, supplied by the userExternal Function

guess must return initial approximations for the solution components

y_{i}^{(j)}

and the derivatives

y_{i}^{(m_{i})}

, for

i = 1, 2, \dots, neq

and

j = 0, 1, \dots, m [i - 1] - 1

. Try to compute each derivative

y_{i}^{(m_{i})}

such that it corresponds to your approximations to

y_{i}^{(j)}

, for

j = 0, 1, \dots, m [i - 1] - 1

. You should not call ffun to compute

y_{i}^{(m_{i})}

If nag_ode_bvp_coll_nlin_solve (d02tlc) is being used in conjunction with nag_ode_bvp_coll_nlin_contin (d02txc) as part of a continuation process, guess is not called by nag_ode_bvp_coll_nlin_solve (d02tlc) after the call to nag_ode_bvp_coll_nlin_contin (d02txc).

The specification of guess is:

void	guess (double x, Integer neq, const Integer m[], double y[], double dym[], Nag_Comm *comm)

1: $x$ – doubleInput

On entry:

x

, the independent variable;

x \in [a, b]

2: $neq$ – IntegerInput

On entry: the number of differential equations.

3: $m [neq]$ – const IntegerInput

On entry:

m [i - 1]

contains

m_{i}

, the order of the

i

th differential equation, for

i = 1, 2, \dots, neq

4: $y [\dim]$ – doubleOutput

Note: the dimension, dim, of the array y is

neq \times \max (m [i])

Where

Y (i, j)

appears in this document, it refers to the array element

y [j \times neq + i - 1]

On exit:

Y (i, j)

must contain

y_{i}^{(j)} (x)

, for

i = 1, 2, \dots, neq

and

j = 0, 1, \dots, m [i - 1] - 1

.
Note:

y_{i}^{(0)} (x) = y_{i} (x)

5: $dym [neq]$ – doubleOutput

On exit:

dym [i - 1]

must contain

y_{i}^{(m_{i})} (x)

, for

i = 1, 2, \dots, neq

6: $comm$ – Nag_Comm *

Pointer to structure of type Nag_Comm; the following members are relevant to guess.

user – double *
iuser – Integer *
p – Pointer: The type Pointer will be void *. Before calling nag_ode_bvp_coll_nlin_solve (d02tlc) you may allocate memory and initialize these pointers with various quantities for use by guess when called from nag_ode_bvp_coll_nlin_solve (d02tlc) (see Section 3.3.1.1 in How to Use the NAG Library and its Documentation).

Note: guess should not return floating-point NaN (Not a Number) or infinity values, since these are not handled by nag_ode_bvp_coll_nlin_solve (d02tlc). If your code inadvertently does return any NaNs or infinities, nag_ode_bvp_coll_nlin_solve (d02tlc) is likely to produce unexpected results.

rcomm [\dim]

– doubleCommunication Array

Note: the dimension,

\dim

, of this array is dictated by the requirements of associated functions that must have been previously called. This array MUST be the same array passed as argument rcomm in the previous call to nag_ode_bvp_coll_nlin_setup (d02tvc).

On entry: this must be the same array as supplied to nag_ode_bvp_coll_nlin_setup (d02tvc) and must remain unchanged between calls.

On exit: contains information about the solution for use on subsequent calls to associated functions.

icomm [\dim]

– IntegerCommunication Array

Note: the dimension,

\dim

, of this array is dictated by the requirements of associated functions that must have been previously called. This array MUST be the same array passed as argument icomm in the previous call to nag_ode_bvp_coll_nlin_setup (d02tvc).

On entry: this must be the same array as supplied to nag_ode_bvp_coll_nlin_setup (d02tvc) and must remain unchanged between calls.

On exit: contains information about the solution for use on subsequent calls to associated functions.

10:

comm

– Nag_Comm *

The NAG communication argument (see Section 3.3.1.1 in How to Use the NAG Library and its Documentation).

11:

fail

– NagError *Input/Output

The NAG error argument (see Section 3.7 in How to Use the NAG Library and its Documentation).

NAG Library Function Document

nag_ode_bvp_coll_nlin_solve (d02tlc)

▸▿ 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 Library Function Document

nag_ode_bvp_coll_nlin_solve (d02tlc)

▸▿ 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

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