## Documentation Center |

Form initial guess for BVP solvers

`solinit = bvpinit(x,yinit)solinit = bvpinit(x,yinit,parameters)solinit = bvpinit(sol,[anew bnew])solinit = bvpinit(sol,[anew bnew],parameters)`

`solinit = bvpinit(x,yinit)` forms
the initial guess for a boundary value problem solver.

`x` is a vector that specifies an initial mesh.
If you want to solve the BVP on [*a*,*b*],
then specify `x(1)` as *a* and `x(end)` as *b*.
The solver adapts this mesh to the solution, so a guess like `xb=nlinspace(a,b,10)` often
suffices. However, in difficult cases, you should place mesh points
where the solution changes rapidly. The entries of `x` must
be in

Increasing order if

*a*<*b*Decreasing order if

*a*>*b*

For two-point boundary value problems, the entries of `x` must
be distinct. That is, if *a*<*b*,
the entries must satisfy `x(1)` < `x(2)` <
... < `x(end)`. If *a*>*b*,
the entries must satisfy `x(1)` > `x(2)` >
... > `x(end)`

For multipoint boundary value problem, you can specify the points
in [*a*,*b*] at which the boundary
conditions apply, other than the endpoints *a* and *b*,
by repeating their entries in `x`. For example, if
you set

x = [0, 0.5, 1, 1, 1.5, 2];

the boundary conditions apply at three points: the endpoints `0` and `2`,
and the repeated entry 1. In general, repeated entries represent boundary
points between regions in [*a*,*b*].
In the preceding example, the repeated entry 1 divides the interval `[0,2]` into
two regions: `[0,1]` and `[1,2]`.

`yinit` is a guess for the solution. It can
be either a vector, or a function:

Vector – For each component of the solution,

`bvpinit`replicates the corresponding element of the vector as a constant guess across all mesh points. That is,`yinit(i)`is a constant guess for the`i`th component`yinit(i,:)`of the solution at all the mesh points in`x`.Function – For a given mesh point, the guess function must return a vector whose elements are guesses for the corresponding components of the solution. The function must be of the form

y = guess(x)

where

`x`is a mesh point and`y`is a vector whose length is the same as the number of components in the solution. For example, if the guess function is a function,`bvpinit`callsy(:,j) = guess(x(j))

at each mesh point.

For multipoint boundary value problems, the guess function must be of the form

y = guess(x, k)

where

`y`an initial guess for the solution at`x`in region`k`. The function must accept the input argument`k`, which is provided for flexibility in writing the guess function. However, the function is not required to use`k`.

`solinit = bvpinit(x,yinit,parameters)` indicates
that the boundary value problem involves unknown parameters. Use the
vector `parameters` to provide a guess for all unknown
parameters.

`solinit` is a structure with the following
fields. The structure can have any name, but the fields must be named `x`, `y`,
and `parameters`.

Ordered nodes of the initial mesh. | |

Initial guess for the solution with | |

Optional. |

`solinit = bvpinit(sol,[anew bnew])` forms
an initial guess on the interval `[anew bnew]` from
a solution `sol` on an interval [*a*,*b*].
The new interval must be larger than the previous one, so either `anew <= `*a* `<` *b* `<=
bnew` or `anew
>= `*a* `>` *b* `>=
bnew`. The solution `sol` is
extrapolated to the new interval. If `sol` contains `parameters`,
they are copied to `solinit`.

`solinit = bvpinit(sol,[anew bnew],parameters)` forms `solinit` as
described above, but uses `parameters` as a guess
for unknown parameters in `solinit`.

Was this topic helpful?