primer_on_scientific_programming_with_python

Exercise 9.52. Use the modules from Exer. 9.49 and 9.50.

Make a program oscillator_conv.py where you import the Problem and Solver classes from the oscillator module in Exercise 9.50 and implement a loop in which Δt is reduced. The end result should be a plot with the curves u versus t corresponding to the various Δt values. Typically, we want to do something like

from oscillator import Problem, Solver

from scitools.std import plot, hold, hardcopy

problem = Problem() problem.initialize() solver = Solver() solver.initialize()

# see how the solution changes by halving dt n times: n = 4

for k in range(n): solver.solve(problem)

u, t = solver.u[:,0], solver.t

# plot u

solver.dt = solver.dt/2.0

Extend this program with another loop over increasing m values. Hopefully, you will realize how flexible the classes from Exercises 9.49

and 9.50 are for solving a variety of problems. We can give a set of physical and numerical parameters in a flexible way on the command line, and in the program we may make loops or other constructions to

mentioned in above, discrete versions of the functions are more convenient on computers. We will illustrate the concept of discrete functions throught some introductory examples. In fact, we used discrete functions in Chapter 4 to plot curves: We defined a finite set of coordinates x and stored the corresponding function values f(x) in an array. A plotting program would then draw straight lines between the function values. A discrete representation of a continuous function is, from a programming point of view, nothing but storing a finite set of coordinates and function values in an array. Nevertheless, we will in this chapter be more formal and describe discrete functions by precise mathematical terms.

A.1.1 The Sine Function

Suppose we want to generate a plot of the sine function for values of x between 0 and π. To this end, we define a set of x-values and an associated set of values of the sine function. More precisely, we define n + 1 points by

where h = π/n and n 1 is an integer. The associated function values are defined as

Mathematically, we have a sequence of coordinates (xi)ni=0 and of function values (si)ni=0 (see the start of Chapter 5 for an explanation of the notation and the sequence concept). Often we “merge” the two sequences to one sequence of points: (xi, si)ni=0. Sometimes we also use a shorter notation, just xi, si, or (xi, si) if the exact limits are not of importance. The set of coordinates (xi)ni=0 constitutes a mesh or a grid. The individual coordinates xi are known as nodes in the mesh (or grid). The discrete representation of the sine function on [0, π] consists of the mesh and the corresponding sequence of function values (si)ni=0 at the nodes. The parameter n is often referred to as the mesh resolution.

In a program, we represent the mesh by a coordinate array, say x, and the function values by another array, say s. To plot the sine function we can simply write

from scitools.std import *

n = int(sys.argv[1])

x = linspace(0, pi, n+1) s = sin(x)

plot(x, s, legend=’sin(x), n=%d’ % n, hardcopy=’tmp.eps’)

Figure A.1 shows the resulting plot for n = 5, 10, 20 and 100. As pointed out in Chapter 4, the curve looks smoother the more points

files that can be downloaded you will, hopefully, always find a test on input data.

A.1.2 Interpolation

Suppose we have a discrete representation of the sine function: (xi, si)ni=0. At the nodes we have the exact sine values si, but what about the points in between these nodes? Finding function values between the nodes is called interpolation, or we can say that we interpolate a discrete function.

A graphical interpolation procedure could be to look at one of the plots in Figure A.1 to find the function value corresponding to a point x between the nodes. Since the plot is a straight line from node value to node value, this means that a function value between two nodes is found from a straight line approximation4 to the underlying continuous function. We formulate this procedure precisely in terms of mathematics in the next paragraph.

Assume that we know that a given x lies in the interval from x = xk to xk+1, where the integer k is given. In the interval xk x < xk+1, we define the linear function that passes through (xk, sk) and (xk+1, sk+1):

That is, Sk(x) coincides with sin(x) at xk and xk+1, and between these nodes, Sk(x) is linear. We say that Sk(x) interpolates the discrete function (xi, si)ni=0 ].

A.1.3 Evaluating the Approximation

Given the values (xi, si)ni=0 and the formula (A.3), we want to compute an approximation of the sine function for any x in the interval from x = 0 to x = π. In order to do that, we have to compute k for a given value of x. More precisely, for a given x we have to find k such that xk x xk+1. We can do that by defining

k = x/h

where the function z denotes the largest integer that is smaller than z. In Python, z is computed by int(z). The program below takes x and n as input and computes the approximation of sin(x). The program

4Strictly speaking, we also assume that the function to be interpolated is rather smooth. It is easy to see that if the function is very wild, i.e., the values of the function changes very rapidly, this procedure may fail even for very large values of n. Chapter 4.4.2 provides an example.

prints the approximation S(x) and the exact5 value of sin(x) so we can look at the development of the error when n is increased.

from numpy import * import sys

xp = eval(sys.argv[1]) n = int(sys.argv[2])

def S_k(k):

return s[k] + \

((s[k+1] - s[k])/(x[k+1] - x[k]))*(xp - x[k])

h = pi/n

x = linspace(0, pi, n+1) s = sin(x)

k = int(xp/h)

print ’Approximation of sin(%s): ’ % xp, S_k(k) print ’Exact value of sin(%s): ’ % xp, sin(xp) print ’Eror in approximation: ’, sin(xp) - S_k(k)

√

To study the approximation, we put x = 2 and use the program eval_sine.py for n = 5, 10 and 20.

Terminal

Note that the error is reduced as the n increases.

A.1.4 Generalization

In general, we can create a discrete version of a continuous function as follows. Suppose a continuous function f (x) is defined on an interval

5The value is not really exact – it is the value of sin(x) provided by the computer, math.sin(x), and this value is calculated from an algorithm that only yields an approximation to sin(x). Exercise 2.38 provides an example of the type of algorithm in question.

Now, (xi, yi)ni=0 is the discrete version of the continuous function f (x). The program discrete_func.py takes f, a, b and n as input, computes the discrete version of f , and then applies the discrete version to make a plot of f .

def discrete_func(f, a, b, n): x = linspace(a, b, n+1)

y = zeros(len(x))

for i in xrange(len(x)): y[i] = func(x[i])

return x, y

from scitools.std import *

f_formula = sys.argv[1] a = eval(sys.argv[2]) b = eval(sys.argv[3]) n = int(sys.argv[4])

f = StringFunction(f_formula)

x, y = discrete_func(f, a, b, n) plot(x, y)

We can equally well make a vectorized version of the discrete_func function:

def discrete_func(f, a, b, n): x = linspace(a, b, n+1)

y = f(x) return x, y

However, for the StringFunction tool to work properly in vectorized mode, we need to follow the recipe in Chapter 4.4.3:

f = StringFunction(f_formula)

f.vectorize(globals())

The corresponding vectorized program is found in the file discrete_func_vec.py.

A.2.1 Di erentiating the Sine Function

In order to get a feeling for how good the approximation (A.6) to the derivative really is, we explore an example. Consider f (x) = sin(x) and the associated derivative f (x) = cos(x). If we put x = 1,we have

The program forward_diff.py, shown below, computes the derivative of f (x) using the approximation (A.6), where x and h are input parameters.

forward_diff.py 1 0.001

The approximated value is: 0.53988148036

A.2.2 Di erences on a Mesh

Frequently, we will need finite di erence approximations to a discrete function defined on a mesh. Suppose we have a discrete representation of the sine function: (xi, si)ni=0, as introduced in Chapter A.1.1. We want to use (A.6) to compute approximations to the derivative of the sine function at the nodes in the mesh. Since we only have function values at the nodes, the h in (A.6) must be the di erence between nodes, i.e., h = xi+1 − xi. At node xi we then have the following approximation of the derivative:

for i = 0, 1, . . . , n − 1. Note that we have not defined an approximate derivative at the end point x = xn. We cannot apply (A.7) directly since sn+1 is undefined (outside the mesh). However, the derivative of a function can also be defined as

This alternative approximation to the derivative is referred to as a backward di erence formula, whereas the expression (A.6) is known as a forward di erence formula. The names are natural: The forward formula goes forward, i.e., in the direction of increasing x and i to collect information about the change of the function, while the backward formula goes backwards, i.e., toward smaller x and i value to fetch function information.

At the end point we can apply the backward formula and thus define

We now have an approximation to the derivative at all the nodes. A plain specialized program for computing the derivative of the sine function on a mesh and comparing this discrete derivative with the exact derivative is displayed below (the name of the file is diff_sine_plot1.py).

from scitools.std import *

n = int(sys.argv[1])

h = pi/n

x = linspace(0, pi, n+1) s = sin(x)

z = zeros(len(s))

for i in xrange(len(z)-1): z[i] = (s[i+1] - s[i])/h

# special formula for end point_ z[-1] = (s[-1] - s[-2])/h plot(x, z)

xfine = linspace(0, pi, 1001) # for more accurate plot exact = cos(xfine)

hold() plot(xfine, exact)

legend(’Approximate function’, ’Correct function’) title(’Approximate and discrete functions, n=%d’ % n)

In Figure A.2 we see the resulting graphs for n = 5, 10, 20 and 100. Again, we note that the error is reduced as n increases.