Difference between revisions of "Pi Computed in C"

Latest revision as of 18:29, 20 June 2007

Here we try out a small program that computes the value of Pi using the 
following formula:

Pi = 4 * (1 - 1/3 + 1/5 - 1/7 + 1/9 - ... )

Here is the code:

  1 #include <stdio.h>
  2 #include <math.h>

  3 int main(int argc, char *argv[]){
  4        double t, k = 3.0, l = -1.0;
  5        int i, s;

  6        if(argc < 2){
  7                fprintf(stderr, "%s <number of iterations>\n", argv[0]);
  8                exit(1);
  9        }

        
 10        t = 1.0; 
 11        for(i = 0, s = atoi(argv[1]); i < s; i++){
 12                t += l/k; 
 13                k += 2.0; 
 14                l *= -1.0; 
 15        }
 16        t *= 4; 
 17        printf("My value of Pi: %1.6f, math.h's value of Pi: %.16f\n", t, M_PI); 
 18        printf("Absolute difference: %.16f\n", fabs(M_PI - t)); 

 19        return 0; 
 20 }

To compile the program, remove all lines numberings, those are just there to 
make it easier to go through the code. Then type in your shell, provided that 
you save the code in a file called pi.c:

 % gcc -o pi pi.c -lm

We compile pi.c to a binary called pi. -lm tells the linker (a part of the 
compiler) that we want to use math libraries. Using the -lm flag is not always 
neseccary though. Anyway, to run the program type the following in your shell:

 % ./pi 1000

The number 1000 is the number of iterations we would like to do in the main 
loop, i.e. how many items we want to use in the formula above. You should get 
something like this:

 $ ./pi 1000
 My value of Pi: 3.142592, math.h's value of Pi: 3.1415926535897931
 Absolute difference: 0.0009990007497471

Lets dissect the code. On line 1 and 2 we include some standard libraries.

  1 #include <stdio.h>
  2 #include <math.h>

stdio.h contains standard input/output functions such as printf and alike. 
math.h contains math functions such as sin, fabs, etc. What are those .h files 
anyway? It demands some explanation. Assume you would like to use some 
function like printf in your program. This function is nothing you have written 
yourself, the function comes in compiled form in your standard libraries. When 
the program is compiled a program called the linker (often ld, try man ld) 
tries to figure out how to call functions in these standard libraries. This is 
something that more or less just happens, as a new C programmer this is nothing 
you have to worry about. What is important here is that the compiler wants to 
know what printf looks like, i.e. how many arguments it wants, return type etc. 
Information about this is included in the .h files, which often is referred to 
as a header file (.h for header). We often talk about function prototypes, i.e. 
a description of the function. But why? So that the compiler can complain when 
you try to use a function is some way that is considerer incorrect, using the 
wrong number of arguments for instance. Hope that sorts it out.

What about this like then?

  3 int main(int argc, char *argv[]){

All C programs are composed of functions more or less. The compiler looks for 
a function called main. When the program is executed, that is by your shell, 
control is transfered from the shell to the place where main starts. I will 
later try (supposed I have some spare time) to explain how to write a shell, 
something that is easier than it might seem. Also there are two arguments to 
this function. int argc, char *argv[]. int argc is the number of arguments to 
the program and char *argv[] are those arguments. Arguments? These are the ones 
you provided via the command line when you started the program, "1000" as an 
example. However the programs name is always the first argument. If we look at 
the example where we did:

 % ./pi 1000

Then *argv[] looks like {"./pi", "1000"}. That also means that argc = 2, NOT 1 
as you might expect. That means that the first argument that you are likely to 
be interested in is argv[1]. As an exercise you could try to write a program 
that prints it's own name.

Here we declare some variables that we use later on:

  4        double t, k = 3.0, l = -1.0;
  5        int i, s;

Nothing much about these really, just keep in mind that variables should be 
declared in the beginning of each code block. That is the beginning of 
functions, loops, if statements etc. Quiet frankly everything that looks like 
this is valid syntax:

 {
     int a, ...
 }

Newer versions of gcc allows you to declare variables everywhere, but try to 
avoid that. You probably want your program to be compatible with older versions 
of gcc and other compilers.

Here we check that the user have supplied the correct number of arguments to 
the program:

  6        if(argc < 2){
  7                fprintf(stderr, "%s <number of iterations>\n", argv[0]);
  8                exit(1);
  9        }

        

Recall that argc is the number of arguments to the program. If these are less 
than 2 we have a problem. We print out a message, on line 7, that tells the 
user that he/she tried to use the program in an incorrect way. Then we exit the 
program with the value 1. Why 1? I'll explain this at the end of this example, 
bare with me for a while. We use the function fprintf which could be 
interpreted as: File-PRINT-Format. FILE here refers to the file stderr, which 
is a standard file of type FILE*. See the example ConnectingASocketInC for a 
better explanation about this. PRINT simply refers to printing, that is writing 
something to the shell. Format means that want to format the output in some 
sense. The %s in "%s <number of iterations>" refers to a string, that is the 
second argument given to fprintf, namely argv[0]. Check your manpages for 
fprintf (that is man fprintf) for a lot more details.

Simply set t to 1.0.

 
 10        t = 1.0; 

This for-loop can be interpreted as follows. First set i to 0, then s to 
atoi(argv[0]). Observe that we do both these things before the first ;. This 
part is just done once, that is when we enter the loop. What is this atoi? The 
argument "1000" in the example above, i.e. the number of iterations we want to 
do, comes as a string, not a number. Therefor we have to convert this string 
to a number. atoi does this, (man atoi).

This loop will loop as long as i is less than s. That is i < s. This test is 
done at the beginning of the loop. In every iteration of the loop i will be 
incremented by one. This is done at the end of the loop.

 11        for(i = 0, s = atoi(argv[1]); i < s; i++){

Here, compute t += l/k. This corresponds to some random part of the formula, 
for example: -1/3 or 1/5.

 12                t += l/k; 

Increment k by two, so if k = 3 before this, then k = 5 after this.

 13                k += 2.0; 

Multiply l by -1.0, something that simply changes the sign of l. -1*-1 = 1, 
math you know.

 14                l *= -1.0; 

This loop is as said repeated say 1000 times, after that we multiply the result 
by 4, according to the formula.

 16        t *= 4; 

Now lets print the result. Here again we use formated printing. But where is 
the stderr thing? Shouldn't we write to a file? Well this is done implicitly. 
Since C programmers like to print a lot, there is a standard function printf 
that is the equivalent of fprintf(stdout, ..., ...). We could as well have 
written fprintf(stdout, "My value of Pi ... ", ...);

 17        printf("My value of Pi: %.16f, math.h's value of Pi: %.16f\n", t, M_PI); 
 18        printf("Absolute difference: %.16f\n", fabs(M_PI - t)); 

What is this format %.16f? f is for float, we want to print a floating point 
number, also we want 16 significant decimals. This .16 thing is just a way to 
tell the how many decimals se want, nice huh? M_PI is a constant from math.h 
that simply is set to the value of Pi, using as high accuracy as the computer 
allows. We also use the function fabs that calculates the absolute value of a 
value. fabs could well be something like:

 double fabs(double a){
     if(a >= 0.0){
         return a; 
     }
     return -a; 
 }

At last we return 0. What is the deal with returning things? Is there any 
function that checks the value? I haven't written anyone anyway. Simply put, if 
you return anything from main or use the function exit(value); This value is 
returned to the shell. The return value is normally interpreted in fashion that 
0 means, "everything is alright, program did NOT crash", everything else means 
"The program crashed.". The return value is a way to tell the shell how things 
went wrong. What a value of 23 would mean is quiet undefined, it's more or less 
up to the program to decide that it means. But it's quiet useful when a 
shellscript executes a program. For example, shellscript start_daemon.sh tries 
to start a random daemon, like a mail server, if something goes wrong the error 
code can be used to print a message "/var/tmp is full, free at least 10 Mb 
space.".

 19        return 0;