PHYSICS 115/242 Homework 2, Solutions

Transcription

1 PHYSICS 115/242 Homework 2, Solutions 1. Trapezium Rule I wrote a function trap to do the trapezoidal rule, and put it in a separate file, trap.c. This is as follows: /****************************************************************** * File: trap.c * * usage: trap(f, a, b, n) * * where f(x) is the the function to be integrated using the * trapezium rule * a is the lower limit * b is the upper limit * n is the number of intervals * To use: repeatedly call the routine, doubling n each time until * the desired accuracy has been reached. *****************************************************************/ double trap (double f(double), double a, double b, int n) double h, sum; int i; h = (b - a) / n; // set stepsize sum =.5 * (f(a) + f(b)); // initialize sum with end points, factor 1/2 for (i = 1; i < n; i++) sum += f(a + i * h); // intermediate points return h * sum; // return answer Note that declaration of f should really be as a pointer to a function, i.e. double trap (double (*f)(double), double a, double b, int n) but having f(double) rather than double (*f)(double) also works. I then wrote a program, call trap.c, to call trap as follows: #include <math.h> #include <stdio.h> double f(double x) // define function to be integrated 1

2 return 1 / (1 + x); main() double x, a, b, h, exact, ans, trap(); int i, n, iter, ITERMAX; exact = log((double) 2); ITERMAX = 8; b = 1.; a = ; // exact answer // set no. of iterations // set upper limit // set lower limit printf (" h ans (exact-ans)/h^2 \n"); n = 1; for (iter = ; iter < ITERMAX; iter++) // keep doubling no. of intervals h = (b - a)/n; ans = trap(f, a, b, n); n *= 2; // double n for next iteration printf ("%12.5f %12.5f %12.5f \n", h, ans, (ans - exact)/(h*h)); The two files trap.c and call trap.c compiled together with the command gcc trap.c call_trap.c The code is executed with the command./a.out. The resulting output is: OUTPUT h ans (exact-ans)/h^ The exact answer is ln2 =

3 From the last column we see that for small h the error is equal to.625h 2 = h 2 /16. From the theory, the coefficient of h 2 is predicted to be 1 12 [f (b) f (a)] = 1 ( 14 ) = 1 16, as found numerically. 2. Simpson s Rule As in the previous question I wrote a function to do the integration, simp and put this in a separate file simp.c. /****************************************************************** * File: simp.c * * usage: simp(f, a, b, n) * * where f(x) is the the function to be integrated using Simpson s rule. * a is the lower limit. * b is the upper limit. * n is the number of intervals. * Note: n must be even. A better code would check for this. * To use: repeatedly call the routine, doubling n each time until * the desired accuracy has been reached. *****************************************************************/ double simp (double f(double), double a, double b, int n) double h, sum1, sum2; int i; if (n%2!= ) printf("\n ERROR in simp.c. No. of intervals must be even.\n\n"); exit(1); h = (b - a) / n; // set stepsize sum1 = ; sum2 = ; // initialization for (i = 1; i < n; i+=2) sum1 += f(a + i*h); // odd points for (i = 2; i < n; i+=2) sum2 += f(a + i*h); // even points return h*(4*sum1 + 2*sum2 + f(a) + f(b))/3; //include first //and last points and return answer I then called this routine with the following code: #include <math.h> #include <stdio.h> 3

4 double f(double x) return exp(-x) * sin(x); // define function to be integrated main() double x, a, b, h, ans, prevans, EPS; double simp(); int i, n, iter, count, ITERMAX; ITERMAX = 15; // set no. of iterations b = 2.; // set upper limit a = ; // set lower limit EPS = 1.e-8; // set desired precision prevans = 1.e+1; ans = ; // initially set "previous answer" to // a ridiculous value // print header printf (" h ans ans-prevans (ans-prevans)/h^4 \n"); n = 2; // initialize number of intervals to 2 count = ; // initialize counter for iterations while(fabs(ans-prevans)>eps && count<itermax)//keep doubling no.of intervals // until convergence occurs or reach // max no. of iterations count++; // increase the iteration counter by 1 h = (b - a)/n; // set the stepsize prevans = ans; // set "previous answer" to that from // previous iteration ans = simp(f, a, b, n); // do Simpson s rule with n intervals if (n > 2) printf ("%13.5f %15.1f %15.1f %8.5f \n", h, ans, (ans-prevans), (ans-prevans)/(h*h*h*h)); else printf ("%13.5f %15.1f \n", h, ans); // print result for this iteratio n *= 2; // double n for next iteration if (count == ITERMAX) // check that convergence occurred and // print error message if it did not printf (" ERROR: Did not converge to the desired precision in %2d iterations The output is as follows. You can see that the error goes down like h 4 as expected. h ans ans-prevans (ans-prevans)/h^

5 Hence, the answer to 8 decimal places is The program stopped when the difference between the current answer and the previous answer (with half the number of intervals) is less than the desired accuracy of 1 8. This required n = (b a)/h = 128 intervals. Note: Although not a rigorous result, the last value is generally within the desired precision of the exact answer. This is certainly the case if the error is small enough that higher order terms beyond h 4 in the expansion of the error are negligible. 3. Romberg Integration I defined three separate functions, romb.c, which does the Romberg error extrapolation and which calls trap.c, and call romb.c which calls the Romberg routine. It is also necessary to define a variable ITER MAX which gives the maximum number Romberg iterations. In order that this variable can be accessed from both romb.c and call romb.c it is defined in a file romb.h which is included in romb.c and call romb.c. Here is romb.c /****************************************************************** * File: romb.c * * usage: romb(f, a, b, iter) * * where f(x) is the function to be integrated using * Romberg integration. * a is the lower limit. * b is the upper limit. * n is the number of intervals. * iter is the iteration level of the Romberg integration. * iter = is trapezium, iter = 1 is Simpson, etc. * To use: call romb repeatedly with iter =, 1, 2 etc. * Uses the trapezium rule function trap(f, a, b, n). * The value of ITERMAX is given in romb.h *****************************************************************/ #include <math.h> #include "romb.h" double romb (double f(double), double a, double b, int iter) double static R[ITERMAX][ITERMAX]; 5

6 double scale; double trap(); int i, n; n = pow(2, iter); // get the value of n R[][iter] = trap(f, a, b, n); // trapezium rule with n intervals scale = 4; for (i = 1; i <= iter; i++) // do Romberg iterations to level "iter" // for iter= (1st call) this loop is ignore R[i][iter] = (scale * R[i-1][iter] - R[i-1][iter-1]) / (scale - 1); scale *= 4; return R[iter][iter]; NotethattheRombergarrayR[][]isdeclaredstatic,sothatthevaluesinitarepreserved between successive calls to the function romb. This is essential because romb will be called successivelywithiterequalto,1,2,,andeachvalueof iterneedsvaluesofthematrix R obtained from previous values of iter in order to do the Romberg error elimination. Hence, these must be preserved between successive calls. Note, too, that there is a small inefficiency in this code. When evaluating the trapezium rule for 2n intervals half the function evaluations have already been done in the calculation for n intervals, and an efficient code would incorporate the result for n intervals to avoid calculating those function values again. However, here, for simplicity, I just call the routine trap for each value of n, thereby recalculating previously calculated values. The file romb.h just contains the one line #define ITER_MAX 1 Next here is call romb.c: /****************************************************************** * The value of ITERMAX is given in romb.h ******************************************************************/ #include <math.h> #include <stdio.h> #include "romb.h" double f(double x) return exp(-x*x/2); // define function to be integrated main() 6

7 double x, a, b, ans, prevans, EPS; double romb(); int i, iter ; b = 1.; a = ; EPS = 1.e-12; ans = 1.e+1; // set upper limit // set lower limit // set desired precision // initially set "answer" to a // ridiculously large value prevans = ; printf (" iter ans ans - prevans \n");//print header iter = ; while(fabs(ans-prevans)>eps && iter<=itermax)//keep doubling no.of intervals // until convergence occurs or reach // max no. of iterations prevans = ans; // set "previous answer" to that from // previous iteration ans = romb(f, a, b, iter); // call Romberg at level "iter" if (iter > ) printf ("%5i %18.13f %13.4e \n", iter, ans, fabs(ans-prevans)) else printf ("%5i %18.13f\n",iter,ans);//print result for this iteration iter++; // increase the iteration level by 1 if (iter > ITERMAX) // check that convergence occurred and // print error message if it did not printf (" ERROR:Did not converge to the desired precision, %9.4e, in %2d ite else printf("\n Ans =%18.13f\n", ans); (trap.c has already been given above). The code is compiled with the command gcc trap.c romb.c call_romb.c The output is as follows: iter ans ans - prevans e e e e e-13 Ans =

8 The program stopped when (answer - previous answer) is less than The answer is therefore Note the rapid convergence. 4. Consider one interval, i.e. I = x1 x f(x)dx where x 1 x = h. Expanding f(x) about x 1/2 gives f(x) = f 1/2 +(x x 1/2 )f 1/2 +(x x 1/2 ) 21 2 f 1/2 +. Integrating from x to x 1 the term involving f 1/2 gives zero and so we have I = hf 1/ f 1/2 3 [ (x x1/2 ) 3] x 1 x + = hf 1/2 + h3 24 f 1/2 +. To leading order in h we can write f 1/2 = (f 1 f )/h and so our final result for one interval is I = hf 1/2 + h2 24 (f 1 f )+. Now consider the integral from x (= a) to x n (= b) and divide the range of integration into n intervals. This gives b a f(x)dx = h(f 1/2 +f 3/2 + +f n 1/2 )+ h2 [ ] f 24 1 f +f 2 f 1 + +f n f n 1 + = h(f 1/2 +f 3/2 + +f n 3/2 +f n 1/2 )+ h2 24 [f (b) f (a)]+. Hence the midpoint rule, like the trapezium rule, is a second order method, i.e. the error is proportional to h Oscillations of a pendulum (a) The energy of a pendulum, given by E = 1 2 ml θ 2 +mgl(1 cosθ), is conserved. Since θ = when θ = θ m, the energy is given by E = mgl(1 cosθ m ). Hence [ ] 1/2 2g θ = l (cosθ cosθ m) = 2π 2 cosθ cosθm. T where T = 2π l/g is the period for small oscillations. The time for the pendulum to swing from θ = to θ m is a quarter of a period and so T(θ m ) T = 2 π θm dθ cosθ cosθm. 8

9 (b) Now cosθ = 1 2sin 2 θ/2 so T(θ m ) T = 1 π θm dθ sin 2 (θ m /2) sin 2 (θ/2) Let sinψ = sin(θ/2)/sin(θ m /2) so (1/2)cos(θ/2)dθ = sin(θ m /2) cosψdψ. Hence we have T(θ m ) T = 1 π = 2 π = 2 π 2cosψ sin(θ m /2)dψ cos(θ/2) sin(θ m /2) 1 sin 2 ψ dψ cos(θ/2) dψ 1 sin 2 (θ m /2)sin 2 ψ. (c) Use the Taylor series expansion 1 1 x 2 = x x4 + to obtain T(θ m ) T = 2 π [ sin2 (θ m /2)sin 2 ψ + 3 ] 8 sin4 (θ m /2)sin 4 ψ + dψ. Now dψ = π 2, sin 2 ψdψ = 1 2 sin 4 ψdψ = 1 4 = 1 4 (1 cos2ψ)dψ = π 4, (1 2cos2ψ +cos 2 2ψ)dψ [1 2cos2ψ + 12 ] (1+cos4ψ) dψ = 3π 16. This gives T(θ m ) T = sin2 ( θm 2 ) sin4 ( θm 2 ) +, i.e. a = 1/4,b = 9/64. (d) Now we do the numerics. I chose to use Simpson s rule, and use the file simp.c described above for this. I call simp.c with the following code, which I call pend.c: 9

10 #include <math.h> #include <stdio.h> #define PI // Numerical value of Pi / 2 double theta_m; // By declaring theta_m outside any of the // functions it is global in scope double f(double x) // define function to be integrated return 1 / sqrt(1 - pow(sin(x),2) * pow(sin(.5*theta_m),2)); main() double f(double), x, h, a, b, ans, ansold, eps); double simp(); int i, n; eps = 1.E-6; ans = ; ansold = 1.E+4; a = ; b = PI2; printf (" theta_m = "); scanf ("%lf", &theta_m); // set the precision; 1^-6 here // set lower limit // set upper limit // prompt for theta_max // give the value of theta_max printf (" h ans ans-prev ans \n"); n = 2; while (fabs(ansold - ans) > eps) // keep doubling no. of intervals until // desired precision has been obtained h = (b - a) / n; ansold = ans; ans = simp(f, a, b, n); ans /= PI2; // divide by PI2 if (n > 2) printf ("%12.5f %12.6f %13.4e\n", h, ans, fabs(ans-ansold)); else printf ("%12.5f %12.6f \n", h, ans); n *= 2; // double n for next iteration NotethatIreadinthevalueofθ m fromthecommandline,soidonotneedtorecompile for different values of this parameter. Study the form of the scanf command (the & symbol means the variable is passed by reference ). Note, too, that I declared theta m before any of the functions, so it is global in scope, i.e. it is accessible to all the routines. If I had not done this, the function f(x) would 1

11 not have known its value, and incorrect results would have occurred. A classier way to do this would be to put the declaration for theta m, and the definition of PI2, in a file called, say pend.h, and add the statement #include "pend.h" near the top of pend.c before any functions are defined. Running the code produces the output shown below. Columns of output refer to h, answer, and answer - previous answer. The program stops when the last column is less than 1 6. The results are compared with the values from the series (up to order θ 4 m). As expected the series works well for small θ m but is poor for larger values. Notice that the period is close to that for small oscillations up to fairly large values of θ m. For example, with θ m = π/4, the difference is only about 4%. OUTPUT theta_m =.1 h ans ans-prev ans e-8 Period = 1.63 Series -> 1.63 theta_m =.2 h ans ans-prev ans e e-12 Period = Series -> theta_m = (= pi/4) h ans ans-prev ans e e-7 Period = Series -> theta_m = (= pi/2) h ans ans-prev ans e e e-7 Period = Series ->

12 theta_m = (= 3pi/4) h ans ans-prev ans e e e e-7 Period = Series -> First of all we do the substitution x = y 2 so the singularity at the lower limit is removed: I = 1 sinx dx = 2 x3/2 1 siny 2 y 2 dy. (1) We can t use the trapezium rule because this would require evaluation of the integrand at y = which is ill defined. Hence use the Midpoint Rule. I put the midpoint routine in a separate file, midpt.c, as follows: /****************************************************************** * File: midpt.c * * usage: midpt(f, a, b, n) * * where f(x) is the the function to be integrated using the * midpoint rule * a is the lower limit * b is the upper limit * n is the number of intervals * To use: repeatedly call the routine, doubling n each time until * the desired accuracy has been reached. *****************************************************************/ double midpt (double f(double), double a, double b, int n) double h, sum; int i; h = (b - a) / n; // set stepsize sum = ; // initialize for (i = ; i < n; i++) sum += f(a + (i+.5)*h); // do the sum return h * sum; // return answer and call this function with the following routine: 12

13 #include <math.h> #include <stdio.h> double f(double x) return 2 * sin(x*x) / (x*x); // define function to be integrated main() double x, a, b, h, ans, prevans, eps; double midpt(); int i, n, iter; eps = 1.e-4; ans = ; prevans = 1e+1; b = 1.; a = ; // set the precision; 1^-4 here // set upper limit // set lower limit printf (" h ans ans-prev ans \n"); n = 1; while (fabs(prevans - ans) > eps) //keep doubling no. of intervals until // desired precision has been obtained prevans = ans; h = (b - a) / n; // set width of one interval ans = midpt(f, a, b, n); // call midpoint method if (n > 1) printf ("%13.5f %13.8f %13.4e\n", h, ans, fabs(ans-prevans)); else printf ("%13.5f %13.8f \n", h, ans); // print result n *= 2; // double n for next iteration The resulting output is h ans ans-prev ans e e e e e e-5 The program stopped when the difference between the last two estimates is less than 1 4. The answer to 4 dps is therefore

14 7. [242 students only] (a) First of all we evaluate the integrals I m = e x2 x m dx for m =,2,4 and 6. The result for m = is given to you in the question: I = π. To get I 2 we integrate by parts: I 2 = e x2 x 2 dx = 1 x d 2 = 1 [ xe x2] 2 dx e x2 dx e x2 dx = I 2 = π 2. Integrating by parts in the same way gives I 4 = 3 2 I 2 = 3 π 4 I 6 = 5 2 I 4 = 15 π 8 The source code below generates the x i and w i from a numerical recipes program. It gives the same results as cutting and pasting the values from the table I gave. SOURCE IMPLICIT REAL(8), REAL(8) INTEGER NONE DIMENSION(5) :: x, w sqrtpi, x2, x4, x6 N, i sqrtpi = sqrt(acos(-1._8)) print (A, $), " N = " read *, N if (N == 4) then x(1) = x(2) = x(3) = x(4) = w(1) = w(2) =

15 w(3) = w(4) = elseif (N == 3) then x(1) = x(2) =. x(3) = w(1) = w(2) = w(3) = elseif (N == 2) then x(1) = x(2) = w(1) = w(2) = else print (" N must be 2, 3 or 4") stop endif END x2 = ; x4 = ; x6 = do i = 1, N x2 = x2 + x(i)**2 * w(i) x4 = x4 + x(i)**4 * w(i) x6 = x6 + x(i)**6 * w(i) enddo print (i2,2x,8f1.6), N, x2, sqrtpi/2, x4, 3*sqrtpi/4, x6, 15*sqrtpi/8 The output below shows results for integrals of f(x) = x 2,x 4,x 6 and x 8 together with the exact results derived above. OUTPUT (Running the program 3 times, just displaying the important line of output, and adding a first line to label the columns.) N x2 x2(ex) x4 x4(ex) x6 x6(ex) It is seen that i. with N = 2 the exact answer is given for x 2 but not for x 4 or x 6, ii. with N = 3 the exact answer is given for x 2 and x 4 but not for x 6, and iii. with N = 4 the exact answer is given for x 2,x 4 and x 6, as requested. Bearing in mind that the method gives correctly the trivial result of for f(x) = x m with m odd, we see that these results are consistent with the claim that the method works exactly for polynomials up to order 2N 1. 15

16 (b) The source code is REAL(8), DIMENSION(4) :: x, w REAL(8) sum f(x) = 1/(exp(x) + 1) x(1) = x(2) = x(3) = x(4) = w(1) = w(2) = w(3) = w(4) = sum = do i = 1, 4 sum = sum + w(i) * f(x(i)) enddo print (" Integral = ", f12.5), sum END The output is Integral = so the answer is.88623, which is, in fact, correct to 5 decimal places. In fact, the integral turns out to equal π/2, the same as x2 exp( x 2 )dx in part (a) (a fact which I had not realized when I set the question.) 16