CS 2073, Fall 2005  Program 9  Numerical Solution of  Laplace's Equation  Due (on time): 2005-11-14  23:59:59  Due (late):        2005-11-16  23:59:59

Program 9 must be emailed to: nrwagner@cs.utsa.edu following directions for: running and submitting a C program, with deadlines: 2005-11-14  23:59:59 (that's Monday, 14 November 2005, 11:59:59 pm) for full credit. 2005-11-16  23:59:59 (that's Wednesday, 16 November 2005, 11:59:59 pm) for 75% credit.

1. In this write-up, I assume that the 2-dimensional arrays are 61-by-61, that is, with indexes going from 0 to 60 inclusive.

2. You should use a named constant for the size of the box:

   #define M 30  /* height and width of box */
   

3. Here are possible declarations for the two 2-dimensional arrays that are needed:

   double t[M+2][M+2]; /* rows and columns */
   char   c[M+2][M+2]; /* matching character array */
   

4. Here are possible prototypes for functions that you should use:

   void initialize(double t[M+2][M+2]);
   double step(double t[M+2][M+2]); /* one iteration, returns maximum change */
   void store(double t[M+2][M+2], char c[M+2][M+2]);  /* stores proper char in c */
   void display(char c[M+2][M+2]);   /* prints c out */
   

5. When you run your program, use 0.25 degrees for the criterion for deciding when to terminate, as discussed by Kaufman. Print the number of steps needed to meet the criterion.

6. Finally, your program should use letters from A to Z to indicate the temperature range in the final output, inserting the proper character in the array t, and the printing c. You should use as a temperature key the one below, which shows which letter is used for a given temperature range.

   Temperature key, temperature followed by letter
   32 Z 36 Y 40 Y 44 X 48 X 52 W 56 W 60 V 64 V 68 U 72 T 76 T	80 S 84 S 88 R 92 R 96 Q 100 Q 104 P 108 O 112 O 116 N 120 N	124 M 128 M 132 L 136 L 140 K 144 J 148 J 152 I 156 I 160 H 164 H 168 G	172 G 176 F 180 E 184 E 188 D 192 D 196 C 200 C 204 B 208 B 212 A

7. The constant M should be divisible by 3, such as 30 or 60. Here is a diagram of the grid for M == 30. Notice that in this diagram, the black labels on the top and left are in terms of a general value M, while the red labels on the bottom and right show what it would look like with M == 30.
   

   Above, the white boundary cells are not allowed to change value, while the cyan interior cells are the ones that change.

8. Here is sample output: Sample output.

1. Start by assembling the suggested code above into sort of an "outline", using what are called stubs (empty functions) for the functions. I've done that for you, and here is one such result: stubs.c

   This "stubs" program actually compiles and runs, but it doesn't do anything. Most of the bodies of the functions are empty, but step ought to return something, so I just returned 0. (What would happen if you return 1 instead? Try it out and see.)

2. Now you need to fill in code for the functions. Start with initialize. This is easy, even if a little annoying. Refer up to the cyan diagram above to keep things straight. Here's one way you could proceed:
   • Initialize all cells to 90.0, say (or some other number will do just as well).
   • Initialize all cells in the inner square (the 10-by-10 square when M == 30) to 212.0. (This will overwrite the previous assignment to 90.0.)
   • Initialize the bottom row, and halfway up the left and right columns to 32.0.
   • Initialize the top row to 100.0.
   • Finally (wheh!) the hardest part: initialize cells on the upper left and right so they smoothly go from 32.0 to 100.0. You can just use another "magic" formula: Initialize cells on the far left and far right for row i, for i from 0 to M/2 + 1 inclusive to -68.0/(M/2+1)*i + 100.0. (This is a linear equation which has value 100.0 when i == 100.0, and has value 32.0 when i == M/2+1.)

3. Next do the store function. This function looks at every cell of the t array, and based on its value, decides on a corresponding char to put into the c array. We want to use an 'A' for temperature 32.0, down to a 'Z' for temperature 212.0, with intermediate letters for intermediate temperatures. First declare a string:

   char alf[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
   

   Notice that 'A' is the same as alf[0] and 'Z' is the same as alf[25]. So we just want a linear function f such that f(32) = 25 and f(212) = 0. But this is easy:

   f(T) = -25.0*T/180.0 + 25.0*212.0/180.0 = (212.0 - T)/7.2;
   

4. Next write the display function, that just prints the c array, row-by-row, using a %c format for each char. At this point you can test your functions so far without using the step function at all. When you call initialize, store, and display, this is what the result should be (roughly, assuming M == 30): Output.
5. Finally, we have the step function. This uses Kaufman's "magic" formula:

   t[i][j] = (t[i-1][j] + t[i+1][j] +
              t[i][j-1] + t[i][j+1])/4.0;
   

   It is all-important that you apply the formula only to the cells colored cyan above. The boundary cells must not be touched. This is very clever on Kaufman's part: since the formula reaches out to cells outside the given cell, we would have to worry about an array subscript out of range if we had not kept the boundary as a "buffer".

   Often in applications like this one, it's important to make use only of "old" values" (before the step), and then all at once change over to all the new values. In this case, though, it doesn't matter, and the end result will be the same either way.

1. Run the program for M == 30.
2. Run the program again for M == 60.

Contents of email submission for Program 9: Last Name, First Name; Course Number; Program Number. The source code for your program. Results of a run for M == 30, include the number of steps needed. Results of a run for M == 60, include the number of steps needed.