home *** CD-ROM | disk | FTP | other *** search
/ Collection of Hack-Phreak Scene Programs / cleanhpvac.zip / cleanhpvac / TIERRA40.ZIP / BEAGLE / GENEWORK.C < prev    next >
C/C++ Source or Header  |  1992-09-11  |  12KB  |  422 lines
  1. /* genework.c  27-3-92  */
  2. /*** Beagle Explorer: Version 3.1  Copyright (c) 1990, 1991, 1992  Tom Ray ***/
  3.  
  4. #include  "beagle.h"
  5. #include  "externb.h"
  6.  
  7. extern FILE  *info;
  8. extern int  asize, psize, gsize, num_match, min_temp_siz;
  9. extern struct geneprobe  *p;
  10. extern Instruction  *pgene, *pprobe;
  11. extern HWND  wima, wili;
  12. struct insdel  *id;
  13.  
  14. int  find_next_use_template(Instruction  *pgene, int  start, int  tail_size,
  15.      int  *site, char  track)
  16. {   int  i;
  17.  
  18.     for(i = 0; i < tail_size - min_temp_siz; i++)
  19.         if(is_use_template(pgene + start + i, track))
  20.         {   *site = start + i;
  21.             return 1;
  22.         }
  23.     return 0;
  24. }
  25.  
  26. int  is_use_template(Instruction  *locus, char  track)
  27. {   int  i, j, match = 0;
  28.  
  29. #if PLOIDY == 1
  30.     for (j = 0; j < Tnum; j++)
  31.     {   if (locus->inst == templ[j].op)
  32.         {   match = 1;
  33.             break ;
  34.         }
  35.     }
  36.     if (!match)
  37.         return 0;
  38.     for(i = 1; i <= min_temp_siz; i++)
  39.         if((locus + i)->inst != Nop0 && (locus + i)->inst != Nop1)
  40.             return 0;
  41.     return 1;
  42. #else /* PLOIDY > 1 */
  43.     for (j = 0; j < Tnum; j++)
  44.     {   if (locus[track]->inst == templ[j].op)
  45.         {   match = 1;
  46.             break ;
  47.         }
  48.     }
  49.     if (!match)
  50.         return 0;
  51.     for(i = 1; i <= min_temp_siz; i++)
  52.         if((locus + i)[track]->inst != Nop0
  53.             && (locus + i)[track]->inst != Nop1)
  54.             return 0;
  55.     return 1;
  56. #endif /* PLOIDY == 1 */
  57. }
  58.  
  59. int  get_template_size(Instruction  *locus, int  tail_size, char  track)
  60. {   int  i;
  61.  
  62.     for(i = 0; i < tail_size; i++)
  63. #if PLOIDY == 1
  64.         if((locus + i)->inst != Nop0 && (locus + i)->inst != Nop1)
  65. #else /* PLOIDY > 1 */
  66.         if((locus + i)[track]->inst != Nop0
  67.             && (locus + i)[track]->inst != Nop1)
  68. #endif /* PLOIDY == 1 */
  69.             return i;
  70.     return tail_size;
  71. }
  72.  
  73. char * inst_name(int  inst, char  *name)
  74. {   sprintf(name,aid[inst].mn);
  75.     return name;
  76. }
  77.  
  78. char inst_letter(int  inst)
  79. {   if(inst < 10) return (char) inst + 48;
  80.     return (char) inst + 87;
  81. }
  82.  
  83. void unlap(char  track)
  84. {   int  c, i, j, m, diff, fit;
  85.     struct insdel  f = {0,0,0,0,0};
  86.  
  87.     for(m = 0; m < num_match; m++)
  88.     {   p[m].start = 0; p[m].stop = psize; }
  89.     for(m = 0; m < num_match - 1; m++)
  90.     {   diff = p[m + 1].position - p[m].position;
  91.         if(p[m].position + psize > p[m + 1].position)
  92.         {   f.idpos = psize; f.fit = 0;
  93.             for(c = diff; c < psize; c++)
  94.             {   fit = 0;
  95.                 for(i = diff, j = 0; i < psize; i++, j++)
  96.                 {   if(i < c)
  97.                     {   if((pprobe+i)->inst == (pgene+p[m].position+i)->inst)
  98.                             fit++;
  99.                     }
  100.                     else
  101.                     {   if((pprobe+j)->inst == (pgene+p[m+1].position+j)->inst)
  102.                             fit++;
  103.                     }
  104.                 }
  105.                 if(fit > f.fit)
  106.                 {   f.idpos = c;
  107.                     f.fit = fit;
  108.                 }
  109.             }
  110.             p[m].stop = f.idpos;
  111.             p[m + 1].start = f.idpos - diff;
  112.         }
  113.     }
  114. }
  115.  
  116. void lineup(char  track)
  117. {   int  c, i, j, m, r, pos, start, stop, diff;
  118.  
  119.     for(m = 0; m < num_match; m++)
  120.     {   r = 1;
  121.         diff = p[m].diff;
  122.         if(p[m].position < 0) pos = 0;
  123.         else pos = p[m].position;
  124.         pos += p[m].start;
  125.         r += 3 * (pos / 76);
  126.         c = 1 + pos % 76;
  127.         lcurset(wima,r,c);
  128.         if(p[m].position < 0) start = -p[m].position;
  129.         else start = 0;
  130.         if(p[m].start > start) start = p[m].start;
  131.         if(p[m].position + diff > gsize - psize)
  132.             stop = gsize - p[m].position;
  133.         else stop = psize + diff;
  134.         if(p[m].stop < stop) stop = p[m].stop;
  135.         for(i = j = start; i < stop; i++, j++)
  136.         {   if(!(c % 77)) { c = 1; r += 3; lcurset(wima,r,c); }
  137.             if(i > p[m].idpos && i <= p[m].idpos + diff)
  138.             {   vpc('+'); vatpa(r,c,NORML); }
  139.             else
  140.             {
  141. #if PLOIDY == 1
  142.                 vpc(inst_letter((int)(pprobe + j)->inst));
  143.                 if((pprobe + j)->inst ==
  144.                     (pgene + i + p[m].position)->inst)
  145. #else /* PLOIDY > 1 */
  146.                 vpc(inst_letter((int)(pprobe + j)[track]->inst));
  147.                 if((pprobe + j)[track]->inst ==
  148.                     (pgene + i + p[m].position)[track]->inst)
  149. #endif /* PLOIDY */
  150.                 {   vatpa(r - 1,c,REVNORML);
  151.                     vatpa(r,c,REVNORML);
  152.                 }
  153.                 else vatpa(r,c,NORML);
  154.             }
  155.             if(i == p[m].idpos) { j -= diff; }
  156.             c++;
  157.         }
  158.     }
  159. }
  160.  
  161. void comp_ins_del(void)
  162. {   int  i, j, id_count = 0, array_size = 10;
  163.  
  164.     id = (struct insdel  *) calloc(array_size, sizeof(struct insdel));
  165.     for(i = 0; i < asize - 1; i++)
  166.     {   for(j = i + 1; j < asize; j++)
  167.         {   if(abs(p[i].position - p[j].position) < 2 * psize / 3)
  168.             {   id_count++;
  169.                 if(id_count > array_size)
  170.                 {   array_size += 10;
  171.                     id = (struct insdel  *)
  172.                         realloc(id, array_size * sizeof(struct insdel));
  173.                 }
  174.                 id[id_count - 1] = ins_del(i,j);
  175.             }
  176.         }
  177.     }
  178.     id_count = clear_conflicts(id_count);
  179.     judgement(id_count);
  180.     free(id);
  181. }
  182.  
  183. int clear_conflicts(int  num)
  184. {   int  i, j, lnum = num;
  185.  
  186.     qsort(id, num, sizeof(struct insdel), idcmp);
  187.     for(i = num - 1; i > 0; i--)
  188.     {   for(j = i - 1; j >= 0; j--)
  189.         {   if(id[i].fit && id[j].fit && (id[i].first == id[j].first ||
  190.                 id[i].first == id[j].second || id[i].second == id[j].first ||
  191.                 id[i].second == id[j].second))
  192.             {   id[i].first = id[i].second = id[i].diff = id[i].idpos =
  193.                     id[i].fit = 0;
  194.                 lnum--; break;
  195.             }
  196.         }
  197.     }
  198.     qsort(id, num, sizeof(struct insdel), idcmp);
  199.     return lnum;
  200. }
  201.  
  202. int idcmp(const void  *i1, const void  *i2)
  203. {   struct insdel  *id1 = i1, *id2 = i2;
  204.  
  205.     return id2->fit - id1->fit;
  206. }
  207.  
  208. void judgement(int  num)
  209. {   int  i, lasize = asize, bfit, wfit, tfit;
  210.  
  211.     for(i = 0; i < num; i++)
  212.     {   bfit = p[id[i].first].fit;
  213.         wfit = p[id[i].second].fit;
  214.         if(wfit > bfit)
  215.         {   tfit = wfit;
  216.             wfit = bfit;  /* wfit = worse fit */
  217.             bfit = tfit;  /* bfit = better fit */
  218.         }
  219.         if(id[i].fit > bfit && id[i].fit > wfit * 1.2 &&
  220.             id[i].fit > psize * .4)
  221.         {   p[id[i].second].fit = 0;
  222.             p[id[i].second].position = 0;
  223.             p[id[i].first].fit = id[i].fit;
  224.             p[id[i].first].diff = id[i].diff;
  225.             p[id[i].first].idpos = id[i].idpos;
  226.             lasize--;
  227.         }
  228.     }
  229.     qsort(p, asize, sizeof(struct geneprobe), prcmp);
  230.     asize = lasize;
  231. }
  232.  
  233. struct insdel ins_del(int  i1, int  i2)
  234. {   int  p1, p2;
  235.     struct insdel  ifit, dfit, rfit;
  236.  
  237.     p1 = p[i1].position; p2 = p[i2].position;
  238.     if(p1 < p2)
  239.     {   ifit = insert(p1,p2);
  240.         dfit = delete(p2,p1);
  241.     }
  242.     else
  243.     {   ifit = insert(p2,p1);
  244.         dfit = delete(p1,p2);
  245.     }
  246.     if(ifit.fit > dfit.fit) rfit = ifit;
  247.     else rfit = dfit;
  248.     if(rfit.first == p[i1].position) { rfit.first = i1; rfit.second = i2; }
  249.     else { rfit.first = i2; rfit.second = i1; }
  250.     return rfit;
  251. }
  252.  
  253. struct insdel insert(int  p1, int  p2)
  254. {   int  diff, i, j, fit, start, stop;
  255.     struct insdel  f = {0,0,0,0,0};
  256.  
  257.     diff = p2 - p1;
  258.     if(p1 < 0) start = -p1;
  259.     else start = 0;
  260.     if(p2 > gsize - psize) stop = gsize - p2;
  261.     else stop = psize;
  262.     for(j = start + 1; j < stop - 1; j++)
  263.     {   fit = 0;
  264.         for(i = start; i < stop; i++)
  265.         {   if(i < j)
  266.             {   if((pprobe + i)->inst == (pgene + p1 + i)->inst)
  267.                     fit++;
  268.             }
  269.             else
  270.             {   if((pprobe + i)->inst == (pgene + p2 + i)->inst)
  271.                     fit++;
  272.             }
  273.         }
  274.         if(fit > f.fit)
  275.         {   f.idpos = j;
  276.             f.fit = fit;
  277.         }
  278.     }
  279.     f.first = p1;
  280.     f.second = p2;
  281.     f.diff = diff;
  282.     return f;
  283. }
  284.  
  285. struct insdel delete(int  p1, int  p2)
  286. {   int  diff, i, j, fit, start, stop;
  287.     struct insdel  f = {0,0,0,0,0};
  288.  
  289.     diff = p1 - p2;
  290.     if(p1 < 0) start = -p1;
  291.     else start = 0;
  292.     stop = psize - diff;
  293.     if(p1 + stop > gsize)
  294.         stop = gsize - p1;
  295.     for(j = start + 1; j < stop - 1; j++)
  296.     {   fit = 0;
  297.         for(i = start; i < stop; i++)
  298.         {   if(i < j)
  299.             {   if((pprobe + i)->inst == (pgene + p1 + i)->inst)
  300.                     fit++;
  301.             }
  302.             else
  303.             {   if((pprobe + i + diff)->inst == (pgene + p1 + i)->inst)
  304.                     fit++;
  305.             }
  306.         }
  307.         if(fit > f.fit)
  308.         {   f.idpos = j - 1;
  309.             f.fit = fit;
  310.         }
  311.     }
  312.     f.first = p1;
  313.     f.second = p2;
  314.     f.diff = -diff;
  315.     return f;
  316. }
  317.  
  318. int probefit(int  position, Instruction  *pprobe,
  319.         int  psize, Instruction  *pgene, int  gsize, char  track)
  320. {   int  i, fit = 0, start, stop;
  321.  
  322.     if(psize > gsize)
  323.     {   printf("probefit error: probe larger than genome\n");
  324.         vexit(0);
  325.     }
  326.     if(position < 0) { start = -position; stop = psize; }
  327.     if(position >= 0 && position < gsize - psize + 1)
  328.     {   start = 0; stop = psize; }
  329.     if(position > gsize - psize) { start = 0; stop = gsize - position; }
  330.     for(i = start; i < stop; i++)
  331. #if PLOIDY == 1
  332.         if((pprobe + i)->inst == (pgene + position + i)->inst)
  333. #else /* PLOIDY > 1 */
  334.         if((pprobe + i)[track]->inst == (pgene + position + i)[track]->inst)
  335. #endif /* PLOIDY == 1 */
  336.             fit++;
  337.     return fit;
  338. }
  339.  
  340. void probeslide(Instruction  *pprobe, int  psize,
  341.     Instruction  *pgene, int  gsize, char  track)
  342. {   int  fit, pos, i;
  343.  
  344.     pos = 1 - psize;
  345.     for(i = 0; i < gsize + psize - 1; i++)
  346.     {   fit = probefit(pos,pprobe,psize,pgene,gsize,track);
  347.         if(fit > p[0].fit)
  348.         {   p[0].position = pos;
  349.             p[0].fit = fit;
  350.             qsort(p, asize, sizeof(struct geneprobe), rprcmp);
  351.         }
  352.         pos++;
  353.     }
  354. }
  355.  
  356. void instlist(void)
  357. {   int  i;
  358.     char  name[10], tmp[10];
  359.  
  360.     wili = wigen(1,1,4,78,FRDOUBLE,"instruction list");
  361.     vcurrent(wili);
  362.     lcurset(wili,0,3);
  363.     for(i = 0; i < 8; i++)
  364.     {   vpc(inst_letter(i));
  365.         vpc(':');
  366.         sprintf(name,"%-6.6s", inst_name(i,tmp));
  367.         vps(name);
  368.         vpc(' ');
  369.     }
  370.     lcurset(wili,1,3);
  371.     for(i = 8; i < 16; i++)
  372.     {   vpc(inst_letter(i));
  373.         vpc(':');
  374.         sprintf(name,"%-6.6s", inst_name(i,tmp));
  375.         vps(name);
  376.         vpc(' ');
  377.     }
  378.     lcurset(wili,2,3);
  379.     for(i = 16; i < 24; i++)
  380.     {   vpc(inst_letter(i));
  381.         vpc(':');
  382.         sprintf(name,"%-6.6s", inst_name(i,tmp));
  383.         vps(name);
  384.         vpc(' ');
  385.     }
  386.     lcurset(wili,3,3);
  387.     for(i = 24; i < 32; i++)
  388.     {   vpc(inst_letter(i));
  389.         vpc(':');
  390.         sprintf(name,"%-6.6s", inst_name(i,tmp));
  391.         vps(name);
  392.         vpc(' ');
  393.     }
  394. }
  395.  
  396. FpInst get_gentype(char  genepath[], char  genefile[], char  genotype[])
  397. {   struct g_list *g;
  398.     FILE    *fp;
  399.     head_t  head;
  400.     indx_t  *indx;
  401.     char    path[90];
  402.     I16s    n;
  403.     FpInst  genome;
  404.  
  405.     g = (struct g_list  *) calloc(1, sizeof(struct g_list));
  406.     sprintf(path, "%s/%s", genepath, genefile);
  407.     fp = fopen(path, "rb");
  408.     head = read_head(fp);
  409.     indx = read_indx(fp, &head);
  410.     n = find_gen(indx, genotype, head.n);
  411.     g = get_gen(fp, &head, &indx[n], n);
  412.     genome = g->genome;
  413.     fclose(fp);
  414.     farfree(indx);
  415.     if (g)
  416.     {   if (g->gbits)
  417.             free(g->gbits);
  418.         free(g);
  419.     }
  420.     return genome;
  421. }
  422.