CS31 Lab 4: C Pointers and IA32

This lab should be done with a partner of your choosing.

The setup procedure for this lab will be similar to Labs 2 and 3. First, both you and your partner should run setup31 to grab the starting point code for this assignment. Suppose users molly and tejas which to work together. Molly (mdanner1) can start by running

  [~]$ setup31 labs/04 tdanner1

  [~]$ setup31 labs/04 mdanner1

For the next step only one partner should copy over the starting code

  [~]$ cd ~/cs31/labs/04
  [04]$ cp -r ~lammert/public/cs31/labs/04/* ./
  [04]$ ls
  Makefile loop.s mainloop.c readfile.c small.txt swap.s
  large.txt loop_C_goto_version mainswap.c readfile.h stats.c

[04]$ git add *
[04]$ git commit -m "lab 4 start"
[04]$ git push

[~]$ cd ~/cs31/labs/04
[04]$ git pull

Lab 4 Goals:

• Gain experience using pointers and dynamic memory allocation in C.
• Practice using gdb and valgrind to debug C memory bugs.
• Practice converting C code to equivalent IA32 assembly instructions.

For this program you will implement the program started in stats.c that takes a single command line argument, which is the name of a file of data values (floats, one per line), and computes and prints out a set of statistics about the data values.

The starting point code comes with two input files that you can use to test your solution:

./stats small.txt
Results:
--------
num values:         16
      mean:      1.812
    median:      1.500
   std dev:      1.031
unused array capacity: 4

./stats large.txt
Results:
--------
num values:         94
      mean:      1.161
    median:      1.000
   std dev:      0.788
unused array capacity: 66

In stats.c is the starting point into which you will put your code. It contains the prototype for the getvalues function that you need to implement, and has some code to get the filename command line argument.

You should structure your program in the following way:

1. Make a call to getvalues, passing in the filename of the file containing the data values, and passing in two values by reference: the address of an int variable to store the size of the array (number of values read in); and the address of an int variable to store the total array capacity.

   Note: The function will return an array of float values initialized to the values read in from the file, or NULL on error (like malloc fails or the file cannot be opened).

2. Compute the mean (average), the median (the middle value) and the standard deviation of the set of values and print them out.

   Note: You will likely need to sort the values prior to computing the median.

3. Print out the results, plus information about the number of values in the data set and the amount of unused capacity in the array storing the values.

Statistic Functions

1. mean: the average of the set of values. For example, if the set is: 5, 6, 4, 2, 7, the mean is 4.8 (24.0/5).
2. median: the middle value in the set of values. For example, if the set is: 5, 6, 4, 2, 7, the median value is 5 (2 and 4 are smaller and 6 and 7 are larger).
3. stddev: is given by the following formula:

   $$s = \sqrt{\frac{1}{N-1}\sum_{i=1}^N(x_i - \bar{x})^2}$$
   Where $N$ is the number of data values, $x_i$ is the $i$th data value, and $\bar{x}$ is the mean value of the $N$ input values.

Feel free to discuss the math on Piazza or in person with your classmates. While we're using it to ensure that your pointers are working correctly, the math itself is not the focus of this assignment...

Requirements

• getvalues: The array of values must be dynamically allocated on the heap by calling malloc. You should start out allocating an array of 20 float values. As you read in values into the current array, if you run out of capacity:
  1. Call malloc to allocate space for a new array that is twice the size of the current full one.
  2. Copy values from the old full array to the new array (and make the new array the current one).
  3. Free the space allocated by the old array by calling free.
  When all of the data values have been read in from the file, the function should return the filled, dynamically allocated, array to the caller (the function's return type is float *). The size and capacity of the array should be "passed" back to the caller via the pointer parameters that are used for pass-by-reference values.

  NOTE: there are other ways to do this type of alloc and re-alloc in C. However, this is the way I want you to do it for this assignment: make sure you start out with a dynamically allocated array of 20 floats, then each time it fills up, allocate a new array of twice the current size, copy values from the old to new, and free the old.

• For full credit, your program must be free of valgrind errors.

• Your code should be commented, modular, robust, and use meaningful variable and function names. This includes having a top-level comment describing your program and listing your and your partner's names and the date. In addition, every function should include a brief description of its behavior. You should not use any global variables for this assignment.

• It should be evident that you applied top-down design when constructing your submission (e.g., there are multiple functions, each with a specific, documented role).

• You should not assume that we will test your code with the sample input files that have been provided.

Hints & Tips

double sqrt(double val);

// this function computes the sum of the first x positive int values
//   x: the top of the range of values to sum
//   returns: the sum of the values 0 to x inclusive
int loop(int x) {
  int res, i;
  res = 0;
  for(i=1; i <= x; i++) {
    res = res + i;
  }
  return res;
}

void swap(int *x, int *y);

int a, b;
a = 10;
b = 8;
printf("%d %d\n", a, b);  // prints: 10 8 
swap(&a, &b);  // swap the values stored in a and b
printf("%d %d\n", a, b);  // prints: 8 10 

Home Page