Description Continued...

builtin

Execute builtin function from overloaded method

Syntax

• builtin(function,x1,...,xn)
  [y1,..,yn] = builtin(function,x1,...,xn)
  

Description

builtin is used in methods that overload builtin functions to execute the original builtin function. If function is a string containing the name of a builtin function, then

builtin(function,x1,...,xn) evaluates that function at the given arguments.

[y1,..,yn] = builtin(function,x1,...,xn) returns multiple output arguments.

Remarks

builtin(...) is the same as feval(...) except that it calls the original builtin version of the function even if an overloaded one exists. (For this to work you must never overload builtin.)

bvp4c

Solve two-point boundary value problems (BVPs) for ordinary differential equations

Syntax

• sol = bvp4c(odefun,bcfun,solinit)
  sol = bvp4c(odefun,bcfun,solinit,options)
  sol = bvp4c(odefun,bcfun,solinit,options,p1,p2...)
  

Arguments

odefun	A function that evaluates the differential equations . It can have the form dydx = odefun(x,y) dydx = odefun(x,y,p1,p2,...) dydx = odefun(x,y,parameters) dydx = odefun(x,y,parameters,p1,p2,...) where x is a scalar corresponding to , and y is a column vector corresponding to . parameters is a vector of unknown parameters, and p1,p2,... are known parameters. The output dydx is a column vector.
bcfun	A function that computes the residual in the boundary conditions . It can have the form res = bcfun(ya,yb) res = bcfun(ya,yb,p1,p2,...) res = bcfun(ya,yb,parameters) res = bcfun(ya,yb,parameters,p1,p2,...) where ya and yb are column vectors corresponding to and . parameters is a vector of unknown parameters, and p1,p2,... are known parameters. The output res is a column vector.
solinit	A structure with fields:
	x	Ordered nodes of the initial mesh. Boundary conditions are imposed at = solinit.x(1) and = 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.
p1,p2...	Optional. Known parameters that the solver passes to odefun, bcfun, and all the functions specified in options.

Description

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

• 

on the interval [a,b] subject to general two-point boundary conditions

• 

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

• 

where 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 at the mesh points of sol.x
sol.yp	Approximation to at the mesh points of sol.x
sol.parameters	Values returned by bvp4c for the unknown parameters, if any
sol.solver	'bvp4c'

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.

sol = bvp4c(odefun,bcfun,solinit,options,p1,p2...) passes constant known parameters, p1, p2, ..., to odefun, bcfun, and all the functions the user specifies in options. Use options = [] as a placeholder if no options are set.

Examples

Example 1. Boundary value problems can have multiple solutions and one purpose of the initial guess is to indicate which solution you want. The second order differential equation

• 

has exactly two solutions that satisfy the boundary conditions

• 

Prior to solving this problem with bvp4c, you must write the differential equation as a system of two first order ODEs

• 

Here and . This system has the required form

• 

The function and the boundary conditions are coded in MATLAB as 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 constant values and with the command

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

Now solve the problem with

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

Evaluate the numerical solution at 100 equally spaced points and plot with

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

You can obtain the other solution of this problem with the initial guess

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

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

• 

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

• 

It is convenient to use subfunctions to place all the functions required by bvp4c in a single M-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 subfunctions 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 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 , 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 C¹-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.