Data Structures

• We have handled simple kinds of data.

  e.g., an allele of a haploid individual was represented by an integer, 0 or 1.

• An array can group data of same type.

• Frequently convinient to group different types of data together to represent more complex data.

  Examples:

  • Substructured disease population dynamics.

    Convinient to have the ``state'' data of each subpopulation together.
    

  • You are interested in evolution at multiple loci.

    Relevant data to characterize a single individual:
       Alleles at each locus
       Phenotypes
    

Defining and declaring structures

• If you are trying to represent a location in 2-dimensional plane, you can use x-y coordinate.
• Let's define a new data structure type: coord

  struct coord {
    int x;
    int y;
  };
  

  Two integers are grouped together to make this structure.

• The keyword struct is followed by the name of structure. x and y are the members of this struct.

• You can use this new type (int or double are the types you have used previously) to declare variables.

  struct coord  c1, c2;
  

• Combining the deintion and declaration

  struct coord {
    int x;
    int y;
  } c1, c2;
  

Accessing the members

• Structure memebers can be used like any other variables.

  c1.x = 10;
  c1.y = 20;
  c2.x = c1.x;
  c2.y = c1.y;
  

  

  Each variable has a container for each member. You can access the value by varName.memberName.

• The following will do the same thing as the above example.

  c2 = c1;
  

More complex structures

• Structure can contain other structures as the members.

  struct line {
    struct coord begin;
    struct coord end;
  };
  
  struct line l1;
  
  l1.begin.x = 0;
  l1.begin.y = 0;
  l1.end.x = 10;
  l1.end.y = 10;
  

• Arrays and pointers can be the members of structures.

  struct genotype {
    int locus1[2];
    int locus2[2];
  } g1;
  
  g1.locus1[0] = g1.locus1[1] = 1;
  
  struct myArray {
    double *data;
    int size;
  } arr;
  
  arr.data = (double *) calloc(20, sizeof(double));
  arr.size = 20;
  

• Structure can be passed to a function

  CntLessThan(arr, 10.0);
  
  int CntLessThan(struct myArray thisArr, double x) {
    int i, cnt = 0;
    for (i = 0; i < thisArr.size; i++) {
      cnt += (thisArr.data[i] < x);
    }
  }
  

• pointers to structures.

  struct myArray *aPtr;
  
  aPtr = & arr;
  (*aPtr).data[0] = (*aPtr).data[1] + (*aPtr).data[2];
  

  Don't forget the parenthese here.

• Using a pointer to the structure with the indirect membership operator (->) The member of a structure pointed by a pointer can be also accessed with ``->''

  tmp = aPtr->size - 1;
  tmp = (*aPtr).size - 1;
  

  These two statements are exactly same.

• You can create an array of structures

  struct genotypes pop[100];
  

Exercises

1. Create (define) a structure struct time, whose members are three integers, corresponding hour, minute, and second.
2. Make a function TimeIntvl() which takes two variables of struct time as the arguments, and returns the difference between the two time in seconds.
3. Can you modify this function, so it takes two pointers to struct time as the arguments?