clear all
format short
set(0, 'defaultaxesfontsize', 12)
set(0, 'defaultlinelinewidth', 1.5)
set(0, 'defaultFunctionLinelinewidth', 1.5)
set(0, 'defaultscattermarkerfacecolor', 'flat')
gcf;
set(gcf, 'Position', [0 0 600 350], 'Theme', 'light')
addpath ../FNC_matlab

Starting MATLAB ...

Executing ...

10.2.Shooting¶

One way to attack the TPBVP (10.1.1) is to adapt our IVP solving techniques from Chapter 6 to it. Those techniques work only when we know the entire initial state, but we can allow that state to vary in order to achieve the stated conditions.

This is the idea behind the shooting method. Imagine adjusting your aiming point and power to sink a basketball shot from the free-throw line. The way in which you miss—too long, flat trajectory, etc.—informs how you will adjust for your next attempt.

Example 10.2.1 (Naive shooting)

Let’s first examine the shooting approach for the TPBVP from Example 10.1.2 with $\lambda=0.6$ .

lambda = 0.6;
phi = @(r, w, dwdr) lambda ./ w.^2 - dwdr ./ r;

We convert the ODE to a first-order system in order to apply a numerical method. We also have to truncate the domain to avoid division by zero.

f = @(r, w) [ w(2); phi(r, w(1), w(2)) ];
a = eps;  b = 1;

The BVP specifies $w'(0)=y_2(0)=0$ . We can try multiple values for the unknown $w(0)=y_1(0)$ and plot the solutions.

clf
ivp = ode;
ivp.ODEFcn = f;
ivp.InitialTime = a;
for w0 = 0.4:0.1:0.9
    ivp.InitialValue = [w0; 0];
    sol = solve(ivp, a, b);
    plot(sol.Time, sol.Solution(1, :))
    hold on
end
xlabel('r'),  ylabel('w(r)')
title('Solutions for multiple choices of w(0)')

On the graph, it’s the curve starting at $w(0)=0.8$ that comes closest to the required condition $w(1)=1$ , but it’s a bit too large.

We can do much better than trial-and-error for the unknown part of the initial state. As usual, we can rewrite the ODE $u''(x) = \phi(x,u,u')$ in first-order form as

\begin{split} y_1' &= y_2,\\ y_2' &= \phi(x,y_1,y_2). \end{split}

(10.2.1)

We turn this into an IVP by specifying $y(a)=s_1$ , $y'(a)=s_2$ , for a vector $\mathbf{s}$ to be determined by the boundary conditions. Define the residual function $\mathbf{v}(\mathbf{s})$ by

\begin{split} v_1(s_1, s_2) &= g_1(y_1(a), y_2(a)) = g_1(s_1, s_2),\\ v_2(s_1, s_2) &= g_2(y_1(b), y_2(b)). \end{split}

(10.2.2)

The dependence of $v_2$ on $\mathbf{s}$ is indirect, through the solution of the IVP for $\mathbf{y}(x)$ . We now have a standard rootfinding problem that can be solved via the methods of Chapter 4.

10.2.1Implementation¶

Our implementation of shooting is given in Function 10.2.1. Note the structure: we use a rootfinding method that in turn relies on an IVP solver. This sort of arrangement is what makes us concerned with minimizing the number of objective function calls when rootfinding.

Algorithm 10.2.1 (shoot)

shoot.m

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
function [x, u, du_dx] = shoot(phi, a, b, ga, gb, init, tol)
%SHOOT   Shooting method for a two-point boundary-value problem.
% Input:
%   phi      defines u'' = phi(x, u, u') (function)
%   a, b     endpoints of the domain (scalars)
%   ga       residual boundary function of u(a), u'(a) 
%   gb       residual boundary function of u(b), u'(b) 
%   init     initial guess for u(a) and u'(a) (column vector)
%   tol      error tolerance (scalar)
% Output:
%   x        nodes in x (length n+1)
%   u        values of u(x)  (length n+1)
%   du_dx    values of u'(x) (length n+1)

    % To be solved by the IVP solver
    function f = shootivp(x, y)
      f = [ y(2); phi(x, y(1), y(2)) ];
    end

    % To be solved by levenberg
    function residual = objective(s)
      opt = odeset('RelTol', tol / 10, 'AbsTol', tol / 10);
      [x, y] = ode113(@shootivp, [a, b], s, opt);
      ya = y(1, :);
      yb = y(end, :);
      residual = [ga(ya(1), ya(2)); gb(yb(1), yb(2))];
    end

    y = [];    % shared variable
    s = levenberg(@objective, init, tol);

    % Don't need to solve the IVP again. It was done within the
    % objective function already.
    u = y(:, 1);            % solution     
    du_dx = y(:, 2);        % derivative
end

Example 10.2.2 (Shooting solution of a BVP)

We revisit Example 10.2.1 but let Function 10.2.1 do the heavy lifting.

lambda = 0.6;
phi = @(r, w, dwdr) lambda ./ w.^2 - dwdr ./ r;   
a = eps;  b = 1;    % avoid r=0 in denominator

We specify the given and unknown endpoint values.

ga = @(u, du) du;
gb = @(u, du) u - 1;

init = [0.8; 0];    % initial guess for u(a) and u'(a)
[r, w, dwdx] = shoot(phi, a, b, ga, gb, init, 1e-5);
clf,  plot(r, w)
title('Correct solution')
xlabel('r'),  ylabel('w(r)')

The value of $w$ at $r=1$ , meant to be exactly one, was computed to be

format long
w(end)

The accuracy is consistent with the error tolerance used for the IVP solution. The initial value $w(0)$ that gave this solution is

w(1)

10.2.2Instability¶

The accuracy of the shooting method should be comparable to those of the component pieces, the rootfinding method, and the IVP solver. However, the shooting method is unstable for some problems. An example illustrates the trouble.

Example 10.2.3 (Instability of shooting)

We solve the problem

u'' = \lambda^2 u + \lambda^2, \quad 0\le x \le 1, \quad u(0)=-1,\; u(1)=0.

(10.2.3)

The exact solution is easily confirmed to be

u(x) = \frac{\sinh(\lambda x)}{\sinh(\lambda)} - 1.

(10.2.4)

This solution satisfies $-1\le u(x) \le 0$ for all $x\in[0,1]$ . Now we compute shooting solutions for several values of $\lambda$ .

ga = @(u, du) u + 1;
gb = @(u, du) u;
clf
warning off
for lambda = 16:4:24
    phi = @(x, u, du_dx) lambda^2 * (u + 1);
    [x, u, du_dx] = shoot(phi, 0.0, 1.0, ga, gb, [-1; 0], 1e-8);
    plot(x, u, displayname=sprintf("lambda=%d", lambda))
    hold on
    xlabel('x'),  ylabel('u(x)')
    title('Shooting instability')
    legend(location="northwest");
    fprintf('u(1) = %.5e\n', u(end))
end

u(1) =

-3.03735e-07

u(1) =

-1.56149e-02

u(1) =

-5.04897e-01

As $\lambda$ increases, the numerical solution above fails to satisfy the boundary condition at $x=1$ .

The cause is readily explained. The solution to the ODE with $u(0)=-1$ and $u'(0)=s_2$ is

\frac{s_2}{\lambda}\sinh(\lambda x) - 1.

(10.2.5)

If $x$ is a fixed value in $[0,1]$ , we compute that the absolute condition number of (10.2.5) with respect to $s_2$ is the magnitude of the partial derivative,

\left| \frac{\sinh (\lambda x)}{\lambda} \right|,

(10.2.6)

which grows rapidly with $\lambda$ near $x=1$ . With the IVP solution so sensitive to $s_2$ , a numerical approach to find $s_2$ approximately is doomed.

The essence of the instability is that errors can grow exponentially away from the boundary at $x=a$ , where the state is arbitrarily being set (see Theorem 6.1.2). Using shooting, acceptable accuracy near $x=b$ therefore means requiring extraordinarily high accuracy near $x=a$ .

The instability of shooting can be circumvented by breaking the interval into smaller pieces and thus limiting the potential for error growth. However, we do not go into these details. Instead, the methods in the rest of this chapter treat both ends of the domain symmetrically and solve over the whole domain at once.

10.2.3Exercises¶

Exercise 10.2.4

✍ Consider the linear TPBVP

\begin{split} u'' &= p(x)u' + q(x)u + r(x),\\ u'(a) &= 0, \quad u(b)=\beta. \end{split}

(10.2.8)

The shooting IVP uses the same ODE with initial data $u(a)=s_1$ , $u'(a)=s_2$ to solve for a trial solution $u(x)$ . Define

z(x) = \frac{\partial u}{\partial s_1}.

(10.2.9)

By differentiating the IVP with respect to $s_1$ , show that $z$ satisfies the IVP

z'' = p(x)z' + q(x)z, \quad z(a)=1, \; z'(a)=0.

(10.2.10)

It follows that $z(x)$ is independent of $s_1$ , and therefore $u(x)$ is a linear function of $s_1$ at each fixed $x$ . Use the same type of argument to show that $u(x)$ is also a linear function of $s_2$ , and explain why the residual function $\mathbf{v}$ in (10.2.2) is a linear function of $\mathbf{s}$ .