One-dimensioal array

• What is an array?
  • If you are interested in how population sizes changes in 5 populations, you might declare 5 variables:

        int pop0, pop1, pop2, pop3, pop4;

    Manipulating these variables become cumbersome.

  • Array is a variable with an index (or subscript), and declared as:

        int pop[5];

    The integer (5) inside of [  ] indicate that the array pop has 5 array elements in this case.

  • A variable is like a single container. An array is like a container with divisor.

    

  • Note well that the index for the 1st array element is 0 NOT 1
  • An array element is specified by the name of the array and the array index.

    pop[0] means the first compartment of an array pop.

    You can use it as if it is a simple variable.

    #include <stdio.h>
    int main (void) {
      int pop[5], newbaby = 5, newpop;
    
      pop[0] = 25;  pop[1] = 34;
    
      pop[0] += newbaby; 
      pop[0] = pop[0] + pop[1];
      pop[1] = 0;
    
      printf("After the pop marge, pop0 is %d, pop2 is %d", pop[0], pop[1]);
      return 0;
    }
    

• Details:
  • Pay particular attention to the ends of an array.

    Declaration:
    double score[1000]

    • The last element of this array is
      score[999]
    • You CAN read the value of score[1000], but it will contain a junk value.
    • If you write a value to the out-of-range element, you get run-time error (ususally, ``segmentation fault'').

  • Array elements within an array have to be the same type (e.g. int, double).

  • Array size (declaration):
    The size (number of elements in an array) has to be known to the compiler at the time of compilation.
    • This is ok:

      #define NUM_SUBPOP 10
      
      int pop[NUM_SUBPOP];
      

    • This is NOT ok:

      int numSubPop = 100;
      int pop[numSubPop];
      

  • Initialization
    • for loop:

      int i, a[100];
      
      for (i = 0; i < 100; i++) {
        a[i] = 10;
      }
      

    • At the declaration:

      double prob[3] = {0.36, 0.48, 0.16};
      int pop[] = {25, 34, 11, 51, 38};
      

      You can omit the size of an array (pop[]) with this method.
    • At the declaration:

      double b[100] = {1.0};
      

      All elements are initialized to be 1.0.
• Exercises:
  1. Make a program which will do the following. This is a practice of manipulating array elements. At each ``step'', compile the program and run it to make sure it is working.
     • declare a local array (buz) with 100 integer elements.
     • Initialize the array buz using the following rule:
       Assign 0 to the first element, 2 to the second element, 4 to the third element, 6 to the forth .... untill you assign values to all 100 elements.
     • Print out the values of the first and last elements. (Step 1)
     • Instead of printing out the first and last value, print out the values of all elements. (Step 2)
     • Multiply the 4-th element by 100, and update the 4-th element with this product. Then add the second and 3rd elements, and assign this value to the first element. Then print out only the first 6 elements of the array. Was the manipulation successful? (Step 3)

     • Add up all elements and print the value of the sum (Step 4)

  2. Use the following code as the starting point. Copy /home/progClass/src/logistic/vector.c. And make functions which will do vector manipulations with the 3 global arrays.

     #include <stdio.h>
     #include <stdlib.h>
     #include <time.h>
     
     #define VECT_SIZE 10
     
     void MkRandVect(void);
     void PrintVect(void);
     
     /* global variables */
     int gVectA[VECT_SIZE];
     int gVectB[VECT_SIZE];
     int gVectC[VECT_SIZE];
     
     int main (void) {
       int i, seed;
     
       seed=time(NULL);
       srand48(seed);
     
       MkRandVect();
       PrintVect();
     
       /* Call the vector manipulation function here */
       PrintVect();
     
       return 0;
     }
     
     void MkRandVect(void) {
       int j;
       for (j = 0; j < VECT_SIZE; j++) {
         gVectA[j] = (int) (drand48() * 10);
         gVectB[j] = (int) (drand48() * 10);    
       }
     }
     

     • Make a function void PrintVect(void).
       This function will print the values of 3 arrays gVectA ~ C in the following format.
       A: 9 2 3 2 8 5 3 2 0 5
       B: 8 2 5 5 8 3 1 5 4 6
       C: 4 3 0 2 9 7 4 1 2 0
       10 elements of each array is printed in a line.
     • Make a function void AddVect(void).
       This function make gVectC by adding gVectA and gVectB (element by element).
     • Make a function int InnerProduct(void).
       This function make a ``dot product'' or ``inner product'' of gVectA and gVectB, and return the value.

       Inner product of 2 vectors: $x = (x_0, x_1, x_2, x_3, x_4), y = (y_0, y_1, y_2, y_3, y_3)$ is
       

       $$x \cdot y = x_0 \cdot y_0 + x_1 \cdot y_1 + x_2 \cdot y_2 + x_3 \cdot y_3 + x_4 \cdot y_4$$
       
       

     • Make a function void RevVectA(void)
       Reverse the order of gVectA, and store it in gVectC

  3. Make a local array with 100 elements of double. Using drand48(), assign random floating-point numbers to the 100 elements. Find the elements with the largest value and the smallest value. Print out these 2 values.

     In addition to printing the largest and smallest value, can you modify the program to print out the positions (indices) of the elements which contain the two extreme values?