home *** CD-ROM | disk | FTP | other *** search
/ Collection of Education / collectionofeducationcarat1997.iso / SCIENCE / STAGES12.ZIP / MOVES.C < prev    next >
Text File  |  1991-04-21  |  12KB  |  443 lines
  1. #include "header.h"
  2. #include "file.h"
  3.  
  4. #define FACTOR    1000
  5.  
  6. /************************************************************************/
  7. /**    cycle movement calculations                       **/
  8. /************************************************************************/
  9. /*  includes the functions:
  10.     forward
  11.     backward
  12.     cellcheck
  13. */
  14. static cellcheck (int cellnum, int part, int *ok, int *flagp, char dir,
  15.           double days, double life, char *opstr);
  16.  
  17.  
  18. /********************************/
  19. /*     function: forward    */
  20. /********************************/
  21. /* returns 1 if all movements ok,
  22.    returns 0 if any movement caused spermiation */
  23. forward (initseq, index, third, days, cell, ok, endspotp, opstr)
  24.   int initseq, index;
  25.   double third, days;
  26.   int *cell, *ok, *endspotp;
  27.   char *opstr;
  28. {
  29.   double d[4];            /* four day counts, starting    */
  30.                 /* from beg, 1/3, 2/3, and end    */
  31.                 /* of current stage        */
  32.   /* the following array duplicates the d[4] array.  it is used to track
  33.      stages after the particular cell has been spermiated */
  34.   double dd[4];
  35.   double life[4];        /* time til spermiation, from    */
  36.                   /* the beg, 1/3, 2/3 and end    */
  37.   int i;            /* cell sequence number        */
  38.   int j;            /* stage array counter        */
  39.   int k;            /* iteration var        */
  40.   int here;            /* temp var for cell stage #    */
  41.   int strsetq;            /* error opstr set yet?  if so,    */
  42.                 /* don't set it again          */
  43.  
  44. #if (DEBUG > 4)
  45. #if PC
  46.   clrscr1(3);
  47.   gotoxy(1, 1);
  48.   cprintf("%sforward:  entering", tab);
  49.   hitreturn(1);
  50. #else
  51.   printf("\tforward:  entering\n");
  52. #endif
  53. #endif
  54.   strsetq = 0;
  55.   *endspotp = 0;
  56.   /*  d[0] starts .001 of the way into the stage[index] */
  57.   life[0] = stage[index]*0.999;
  58.   life[1] = 2*third;
  59.   life[2] = third;
  60.   /*  d[3] starts .001 from the end of the stage[index] */
  61.   life[3] = stage[index]*0.001;
  62.   for ( k=0; k<4; k++ ) {
  63.     ok[k] = 1;
  64.     d[k] = days - life[k];    /* d vars            */
  65.     dd[k] = d[k];
  66.     cell[k] = 0;        /* init cell vars to anything    */
  67.   } /* for k */
  68.  
  69. #if (DEBUG > 4)
  70. #if PC
  71.     clrscr1(1);
  72.     gotoxy(1, 5);
  73.     cprintf("%sforward: life: [0]=<%lf>  [1]=<%lf>", tab, life[0], life[1]);
  74.     gotoxy(1, 6);
  75.     cprintf("%s               [2]=<%lf>  [3]=<%lf>", tab, life[2], life[3]);
  76.     gotoxy(1, 7);
  77.     cprintf("%sforward:    d: [0]=<%lf>  [1]=<%lf>", tab, d[0], d[1]);
  78.     gotoxy(1, 8);
  79.     cprintf("%s               [2]=<%lf>  [3]=<%lf>", tab, d[2], d[3]);
  80.     gotoxy(1, 9);
  81.     cprintf("%sforward:   dd: [0]=<%lf>  [1]=<%lf>", tab, dd[0], dd[1]);
  82.     gotoxy(1, 10);
  83.     cprintf("%s               [2]=<%lf>  [3]=<%lf>", tab, dd[2], dd[3]);
  84.     hitreturn(1);
  85. #else
  86.   printf("\t: \n");
  87. #endif
  88. #endif
  89.  
  90.   for ( k=0; k<4; k++ ) {
  91.     i = initseq;
  92.     j = index;
  93.     while ((d[k] > 0.0) && ok[k]) {
  94. #if (DEBUG > 4)
  95. #if PC
  96.       clrscr1(1);
  97.       gotoxy(1, 5);
  98.       cprintf("%sforward:  i=<%d>  CellNames[i]=<%s>",
  99.           tab, i, CellNames[i]);
  100.       hitreturn(1);
  101. #else
  102.       printf("\tforward:  i=<%d>  CellNames[i]=<%s>\n", i, CellNames[i]);
  103. #endif
  104. #endif
  105.       here = getcellstg(CellNames[i]);
  106.       if (here == INVALID) {
  107. #if PC
  108.     clrscr1(1);
  109.     gotoxy(1, 5);
  110.     cprintf("%sforward:  Illegal value, here=<%d>", tab, here);
  111.     gotoxy(1, 7);
  112.     cprintf("%s          Sorry, aborting.", tab);
  113. #else
  114.     printf("\tforward:  Illegal value, here=<%d>\n", here);
  115.     printf("\t          Sorry, aborting.");
  116. #endif
  117.     printexit(601);
  118.       } /* if INVALID */
  119.  
  120.       /* skip cells in same stage as current cell, to get to first successor
  121.      cell in the next stage, but only move fwd til i > MaxCellIndex+1
  122.      '+1' because of epididymis */
  123.       while ((++i <= MaxCellIndex+1) && (getcellstg(CellNames[i])==here));
  124.       cellcheck(i, k, ok, &strsetq, 'F', days, life[k], opstr);
  125.  
  126.       switch (ok[k]) {
  127.       case 1:    /* cell ok, still in cycle */
  128.     j = ++j % NumStages;
  129.     if (d[k] < stage[j]) {
  130.       /* move ends @ this stage: find which 3d moves ends in */
  131.       if (d[k] <= (stage[j]/3.0)) {
  132.         *endspotp = 1;
  133.       } else {
  134.         if (d[k] <= (2.0*stage[j]/3.0)) {
  135.           *endspotp = 2;
  136.         } else {
  137.           *endspotp = 3;
  138.         }
  139.       }
  140.     }
  141.     life[k] += stage[j];
  142.     d[k] -= stage[j];
  143.     dd[k] = d[k];
  144.     break;
  145.       case 2:    /* cell into epididymis */
  146.     life[k] += EpiTime;
  147.     d[k] -= EpiTime;
  148.     /* for stage tracking, just use stage index j and ignore cell */
  149.     j = ++j % NumStages;
  150.     dd[k] -= stage[j];
  151.     break;
  152.       case 0:
  153.       default:  /* ejaculate: but keep going, to get final stage reached */
  154.     j = ++j % NumStages;
  155.     dd[k] -= stage[j];
  156.     break;
  157.       } /* switch */
  158.     } /* while d[k] */
  159.  
  160. #if (DEBUG > 4)
  161. #if PC
  162.     clrscr1(1);
  163.     gotoxy(1, 5);
  164.     cprintf("%sforward: k=<%d>  ok[k]=<%d>  cell#=<%d>  stg#=<%d>",
  165.         tab, k, ok[k], i, j);
  166.     hitreturn(1);
  167. #else
  168.     printf("\tforward: \n");
  169. #endif
  170. #endif
  171.  
  172.     /* stopped moving: set cell or stage reached */
  173.     switch (ok[k]) {
  174.     case 1:    /* reached normal cell */
  175.       cell[k] = i;
  176.       break;
  177.     case 2:    /* reached epi: use stage that would've been reached */
  178.       cell[k] = j;
  179.       break;
  180.     case 0:
  181.     default:    /* ejaculated: set cell[k] to stage reached */
  182.       cell[k] = j;
  183.       break;
  184.     } /* switch */
  185.   } /* for k */
  186.  
  187. #if (DEBUG > 4)
  188. #if PC
  189.   clrscr1(1);
  190.   gotoxy(1, 4);
  191.   cprintf("%sforward:  mid-function", tab);
  192.   gotoxy(1, 5);
  193.   cprintf("%sforward:  cell:  [0]=<%d>  [1]=<%d>", tab, cell[0], cell[1]);
  194.   gotoxy(1, 6);
  195.   cprintf("%s                 [2]=<%d>  [3]=<%d>", tab, cell[2], cell[3]);
  196.   hitreturn(1);
  197. #else
  198.   printf("\t: \n");
  199. #endif
  200. #endif
  201.  
  202.   /* for those starting pts which ended up with epi/ejact cells, continue
  203.      to track stages */
  204.   for ( k=0; k<4; k++ ) {
  205.     if (ok[k] != 1) {
  206.       j = cell[k];    /* the stage this starting pt left off at */
  207.       while (dd[k] > 0.0) {
  208.     j = ++j % NumStages;
  209.     dd[k] -= stage[j];
  210.       } /* while dd[k] */
  211.  
  212.       /* stopped moving: set stage reached */
  213.       cell[k] = j+1;
  214.     } /* if */
  215.   } /* for k */
  216. #if (DEBUG > 4)
  217. #if PC
  218.   clrscr1(1);
  219.   gotoxy(1, 4);
  220.   cprintf("%sforward:  leaving", tab);
  221.   gotoxy(1, 5);
  222.   cprintf("%sforward:  cell:  [0]=<%d>  [1]=<%d>", tab, cell[0], cell[1]);
  223.   gotoxy(1, 6);
  224.   cprintf("%s                 [2]=<%d>  [3]=<%d>", tab, cell[2], cell[3]);
  225.   gotoxy(1, 7);
  226.   cprintf("%s          endspot=<%d>", tab, *endspotp);
  227.   hitreturn(1);
  228. #else
  229.   printf("\tforward:  leaving\n");
  230. #endif
  231. #endif
  232.   return(0);
  233. } /* forward */
  234.  
  235. /********************************/
  236. /*     function: backward    */
  237. /********************************/
  238. /* returns 1 if all movements ok,
  239.    returns 0 if any movement went further back than when
  240.    cell entered cycle */
  241. backward (initseq, index, third, days, cell, ok, endspotp, opstr)
  242.   int initseq, index;
  243.   double third, days;
  244.   int *cell, *ok, *endspotp;
  245.   char *opstr;
  246. {
  247.   double d[4];            /* four day counts, starting    */
  248.                   /* from beg, 1/3, 2/3, and end     */
  249.                 /* of current stage        */
  250.   /* the following array duplicates the d[4] array.  it is used to track
  251.      stages after the particular cell has been spermiated.     */
  252.   double dd[4];
  253.   double life[4];        /* time til cell released, from    */
  254.                   /* the beg, 1/3, 2/3 and end    */
  255.   int i;            /* cell sequence number        */
  256.   int j;            /* stage array counter        */
  257.   int k;            /* iteration var        */
  258.   int here;            /* temp var for cell stage #    */
  259.   int strsetq;            /* error opstr set yet?        */
  260.  
  261.   strsetq = 0;
  262.   *endspotp = 3;
  263.   /*  d[3] starts .001 from the end of the stage[index] */
  264.   life[3] = stage[index]*0.999;
  265.   life[2] = 2*third;
  266.   life[1] = third;
  267.   /*  d[0] starts .001 of the way into the stage[index] */
  268.   life[0] = stage[index]*0.001;
  269.   for ( k=0; k<4; k++ ) {
  270.     ok[k] = 1;            /* init ok vars    */
  271.     d[k] = days - life[k];    /* init d vars    */
  272.     dd[k] = d[k];
  273.     cell[k] = 0;        /* init cell vars to anything */
  274.   }
  275.  
  276.   for ( k=3; k>-1; k-- ) {
  277.     i = initseq;
  278.     j = index;
  279.     while ((d[k] > 0) && ok[k]) {
  280.       here = getcellstg(CellNames[i]);
  281.       /* skip cells in same stage as current cell, to get to first successor
  282.      cell in the next stage, but only move bwd til i = 0 */
  283.       while ((--i >= 0) && (getcel