# Documentation

### This is machine translation

Translated by
Mouseover text to see original. Click the button below to return to the English version of the page.

# bvp4c

Solve boundary value problems for ordinary differential equations

## Syntax

```sol = bvp4c(odefun,bcfun,solinit) sol = bvp4c(odefun,bcfun,solinit,options) solinit = bvpinit(x, yinit, params) ```

## Arguments

 `odefun` A function handle that evaluates the differential equations f(x,y). It can have the form```dydx = odefun(x,y) dydx = odefun(x,y,parameters)```For a scalar `x` and a column vector `y`, `odefun(x,y)` must return a column vector, `dydx`, representing f(x,y). `parameters` is a vector of unknown parameters. `bcfun` A function handle that computes the residual in the boundary conditions. For two-point boundary value conditions of the form bc(y(a),y(b)), `bcfun` can have the form```res = bcfun(ya,yb) res = bcfun(ya,yb,parameters)```where `ya` and `yb` are column vectors corresponding to y(a) and y(b). `parameters` is a vector of unknown parameters. The output `res` is a column vector.See Multipoint Boundary Value Problems for a description of `bcfun` for multipoint boundary value problems. `solinit` A structure containing the initial guess for a solution. You create `solinit` using the function `bvpinit`. `solinit` has the following fields. `x` Ordered nodes of the initial mesh. Boundary conditions are imposed at a = `solinit.x(1)` and b = `solinit.x(end)`. `y` Initial guess for the solution such that `solinit.y(:,i)` is a guess for the solution at the node `solinit.x(i)`. `parameters` Optional. `A` vector that provides an initial guess for unknown parameters. The structure can have any name, but the fields must be named `x`, `y`, and `parameters`. You can form `solinit` with the helper function `bvpinit`. See `bvpinit` for details. `options` Optional integration argument. A structure you create using the `bvpset` function. See `bvpset` for details.

## Description

`sol = bvp4c(odefun,bcfun,solinit)` integrates a system of ordinary differential equations of the form

y′ = f(x,y)

on the interval [a,b] subject to two-point boundary value conditions bc(y(a),y(b)) = 0.

`odefun` and `bcfun` are function handles. See Create Function Handle for more information.

Parameterizing Functions explains how to provide additional parameters to the function `odefun`, as well as the boundary condition function `bcfun`, if necessary.

`bvp4c` can also solve multipoint boundary value problems. See Multipoint Boundary Value Problems. You can use the function `bvpinit` to specify the boundary points, which are stored in the input argument `solinit`. See the reference page for `bvpinit` for more information.

The `bvp4c` solver can also find unknown parameters p for problems of the form

y′ = f(x,y, p)

0 = bc(y(a),y(b),p)

where p corresponds to `parameters`. You provide `bvp4c` an initial guess for any unknown parameters in `solinit.parameters`. The `bvp4c` solver returns the final values of these unknown parameters in `sol.parameters`.

`bvp4c` produces a solution that is continuous on `[a,b]` and has a continuous first derivative there. Use the function `deval` and the output `sol` of `bvp4c` to evaluate the solution at specific points `xint` in the interval `[a,b]`.

`sxint = deval(sol,xint)`

The structure `sol` returned by `bvp4c` has the following fields:

 `sol.x` Mesh selected by `bvp4c` `sol.y` Approximation to y(x) at the mesh points of `sol.x` `sol.yp` Approximation to y′(x) at the mesh points of `sol.x` `sol.parameters` Values returned by `bvp4c` for the unknown parameters, if any `sol.solver` '`bvp4c`' `sol.stats` Computational cost statistics (also displayed when the `stats` option is set with `bvpset`).

The structure `sol` can have any name, and `bvp4c` creates the fields `x`, `y`, `yp`, `parameters`, and `solver`.

`sol = bvp4c(odefun,bcfun,solinit,options)` solves as above with default integration properties replaced by the values in `options`, a structure created with the `bvpset` function. See `bvpset` for details.

```solinit = bvpinit(x, yinit, params)``` forms the initial guess `solinit` with the vector `params` of guesses for the unknown parameters.

### Singular Boundary Value Problems

`bvp4c` solves a class of singular boundary value problems, including problems with unknown parameters `p`, of the form

y′ = S · y/x + F(x,y,p)

0 = bc(y(0),y(b),p)

The interval is required to be [0, b] with b > 0. Often such problems arise when computing a smooth solution of ODEs that result from partial differential equations (PDEs) due to cylindrical or spherical symmetry. For singular problems, you specify the (constant) matrix `S` as the value of the `'SingularTerm'` option of `bvpset`, and `odefun` evaluates only f(x,y,p). The boundary conditions must be consistent with the necessary condition S·y(0) = 0 and the initial guess should satisfy this condition.

### Multipoint Boundary Value Problems

`bvp4c` can solve multipoint boundary value problems where a = a0 < a1 < a2 < ...< an = b are boundary points in the interval [a,b]. The points a1,a2,...,an−1 represent interfaces that divide [a,b] into regions. `bvp4c` enumerates the regions from left to right (from a to b), with indices starting from 1. In region k, [ak−1,ak], `bvp4c` evaluates the derivative as

`yp = odefun(x,y,k) `

In the boundary conditions function

`bcfun(yleft,yright) `

`yleft(:,k)` is the solution at the left boundary of [ak−1,ak]. Similarly, `yright(:,k)` is the solution at the right boundary of region k. In particular,

`yleft(:,1) = y(a)`

and

`yright(:,end) = y(b)`

When you create an initial guess with

`solinit = bvpinit(xinit,yinit),`

use double entries in `xinit` for each interface point. See the reference page for `bvpinit` for more information.

If `yinit` is a function, `bvpinit` calls ```y = yinit(x,k)``` to get an initial guess for the solution at `x` in region `k`. In the solution structure `sol` returned by `bpv4c`, `sol.x` has double entries for each interface point. The corresponding columns of `sol.y` contain the left and right solution at the interface, respectively.

To see an example that solves a three-point boundary value problem, type `threebvp` at the MATLAB® command prompt.

### Note

The `bvp5c` function is used exactly like `bvp4c`, with the exception of the meaning of error tolerances between the two solvers. If S(x) approximates the solution y(x), `bvp4c` controls the residual |S′(x) – f(x,S(x))|. This controls indirectly the true error |y(x) – S(x)|. `bvp5c` controls the true error directly.

## Examples

### Using Initial Guess to Indicate Desired Solution

Boundary value problems can have multiple solutions. One purpose of the initial guess is to indicate which solution, among several, that you want.

The second-order differential equation

has exactly two solutions that satisfy the boundary conditions

Before using `bvp4c` to solve the problem, you need to rewrite the differential equation as a system of two first-order ODEs,

where and . This system has the required form

The function, f, and the boundary conditions, bc, are coded in MATLAB as the functions `twoode` and `twobc`.

```function dydx = twoode(x,y) dydx = [ y(2); -abs(y(1)) ]; ```
```function res = twobc(ya,yb) res = [ ya(1); yb(1) + 2 ]; ```

Form a guess structure consisting of an initial mesh of five equally spaced points in [0,4] and a guess of the constant values

```solinit = bvpinit(linspace(0,4,5),[1 0]); ```

Solve the problem using `bvp4c`.

```sol = bvp4c(@twoode,@twobc,solinit); ```

Evaluate the numerical solution at 100 equally spaced points and plot y(x).

```x = linspace(0,4); y = deval(sol,x); plot(x,y(1,:)) ```

To obtain the other solution of this problem, use the initial guess

```solinit = bvpinit(linspace(0,4,5),[-1 0]); sol = bvp4c(@twoode,@twobc,solinit); x = linspace(0,4); y = deval(sol,x); plot(x,y(1,:)) ```

### Compute Fourth Eigenvalue of Mathieu’s Equation

This boundary value problem involves an unknown parameter. The task is to compute the fourth (q = 5) eigenvalue λ of Mathieu's equation

y” + (λ – 2q cos2x)y = 0.

Because the unknown parameter λ is present, this second-order differential equation is subject to three boundary conditions:

y′(0) = 0

y′(π) = 0

y(0) = 1

It is convenient to use local functions to place all the functions required by `bvp4c` in a single file.

```function mat4bvp lambda = 15; solinit = bvpinit(linspace(0,pi,10),@mat4init,lambda); sol = bvp4c(@mat4ode,@mat4bc,solinit); fprintf('The fourth eigenvalue is approximately %7.3f.\n',... sol.parameters) xint = linspace(0,pi); Sxint = deval(sol,xint); plot(xint,Sxint(1,:)) axis([0 pi -1 1.1]) title('Eigenfunction of Mathieu''s equation.') xlabel('x') ylabel('solution y') % ------------------------------------------------------------ function dydx = mat4ode(x,y,lambda) q = 5; dydx = [ y(2) -(lambda - 2*q*cos(2*x))*y(1) ]; % ------------------------------------------------------------ function res = mat4bc(ya,yb,lambda) res = [ ya(2) yb(2) ya(1)-1 ]; % ------------------------------------------------------------ function yinit = mat4init(x) yinit = [ cos(4*x) -4*sin(4*x) ];```

The differential equation (converted to a first-order system) and the boundary conditions are coded as local functions `mat4ode` and `mat4bc`, respectively. Because unknown parameters are present, these functions must accept three input arguments, even though some of the arguments are not used.

The guess structure `solinit` is formed with `bvpinit`. An initial guess for the solution is supplied in the form of a function `mat4init`. We chose y = cos 4x because it satisfies the boundary conditions and has the correct qualitative behavior (the correct number of sign changes). In the call to `bvpinit`, the third argument (`lambda = 15`) provides an initial guess for the unknown parameter λ.

After the problem is solved with `bvp4c`, the field `sol.parameters` returns the value λ = 17.097, and the plot shows the eigenfunction associated with this eigenvalue.

## Algorithms

`bvp4c` is a finite difference code that implements the three-stage Lobatto IIIa formula. This is a collocation formula and the collocation polynomial provides a C1-continuous solution that is fourth-order accurate uniformly in `[a,b]`. Mesh selection and error control are based on the residual of the continuous solution.

## References

[1] Shampine, L.F., M.W. Reichelt, and J. Kierzenka, “Solving Boundary Value Problems for Ordinary Differential Equations in MATLAB with bvp4c