C   23

sort.c

Guest on 15th January 2022 05:01:50 AM

  1. #include <ncbi.h>
  2. #include <blast/blast.h>
  3.  
  4. /******************  BLAST_HitList Comparison Routines  *********************/
  5. ValNodePtr LIBCALL
  6. BlastHitListCmpCriterionAdd(vnpp, crit)
  7.         ValNodePtr      PNTR vnpp;
  8.         BLAST_HLCmp     crit;
  9. {
  10.         ValNodePtr      vnp;
  11.  
  12.         if (vnpp == NULL)
  13.                 return NULL;
  14.  
  15.         for (vnp = *vnpp; vnp != NULL; vnp = vnp->next) {
  16.                 if (vnp->choice == crit)
  17.                         return vnp;
  18.         }
  19.  
  20.         switch (crit) {
  21.         case BLAST_HLCMP_PVALUE:
  22.                 return ValNodeAddFunction(vnpp, crit, (FnPtr)BlastHitListCmpByPvalue);
  23.         case BLAST_HLCMP_EVALUE:
  24.                 return ValNodeAddFunction(vnpp, crit, (FnPtr)BlastHitListCmpByEvalue);
  25.         case BLAST_HLCMP_SCORE:
  26.                 return ValNodeAddFunction(vnpp, crit, (FnPtr)BlastHitListCmpByScore);
  27.         case BLAST_HLCMP_COUNT:
  28.                 return ValNodeAddFunction(vnpp, crit, (FnPtr)BlastHitListCmpByCount);
  29.         case BLAST_HLCMP_LENGTH:
  30.                 return ValNodeAddFunction(vnpp, crit, (FnPtr)BlastHitListCmpByLength);
  31.         case BLAST_HLCMP_HIGHSCORE:
  32.                 return ValNodeAddFunction(vnpp, crit, (FnPtr)BlastHitListCmpByHighScore);
  33.         case BLAST_HLCMP_TOTALSCORE:
  34.                 return ValNodeAddFunction(vnpp, crit, (FnPtr)BlastHitListCmpByTotalScore);
  35.         default:
  36.                 return NULL;
  37.         }
  38.         /*NOTREACHED*/
  39. }
  40.  
  41. int LIBCALL
  42. BlastHitListCmpStd(hli, hlj, vnp)
  43.         BLAST_HitListPtr        hli, hlj;
  44.         ValNodePtr      vnp;
  45. {
  46.         register int (LIBCALLBACK *func)();
  47.         register BLAST_HSPPtr   hi, hj;
  48.         register int    i;
  49.  
  50.         if (hli == NULL)
  51.                 return (hlj != NULL ? 1 : 0);
  52.         if (hlj == NULL)
  53.                 return -1;
  54.  
  55.         hi = hli->best_hsp;
  56.         hj = hlj->best_hsp;
  57.         if (hi == NULL)
  58.                 return (hj != NULL ? 1 : 0);
  59.         if (hj == NULL)
  60.                 return -1;
  61.  
  62.         for (; vnp != NULL; vnp = vnp->next) {
  63.                 func = (int (LIBCALLBACK *)())vnp->data.funcvalue;
  64.                 i = (*func)(&hli, &hlj);
  65.                 if (i != 0)
  66.                         return i;
  67.         }
  68.  
  69.         return 0;
  70. }
  71.  
  72. int LIBCALL
  73. BlastHitListPtrCmpStd(hli, hlj, vnp)
  74.         BLAST_HitListPtr        PNTR hli, PNTR hlj;
  75.         ValNodePtr      vnp;
  76. {
  77.         register int (LIBCALLBACK *func)();
  78.         register BLAST_HSPPtr   hi, hj;
  79.         register int    i;
  80.  
  81.         if (hli == NULL)
  82.                 return (hlj != NULL ? 1 : 0);
  83.         if (hlj == NULL)
  84.                 return -1;
  85.  
  86.         hi = (*hli)->best_hsp;
  87.         hj = (*hlj)->best_hsp;
  88.         if (hi == NULL)
  89.                 return (hj != NULL ? 1 : 0);
  90.         if (hj == NULL)
  91.                 return -1;
  92.  
  93.         for (; vnp != NULL; vnp = vnp->next) {
  94.                 func = (int (LIBCALLBACK *)())vnp->data.funcvalue;
  95.                 i = (*func)(hli, hlj);
  96.                 if (i != 0)
  97.                         return i;
  98.         }
  99.  
  100.         return 0;
  101. }
  102. void LIBCALL
  103. BlastHitListSort(hlpp, vnp)
  104.         BLAST_HitListPtr PNTR   hlpp;
  105.         ValNodePtr      vnp;
  106. {
  107.         LinkSort1((VoidPtr PNTR)hlpp, offsetof(BLAST_HitList,next), BlastHitListPtrCmpStd, vnp);
  108. }
  109.  
  110. int LIBCALL
  111. BlastHitListCmpByPvalue(hli, hlj)
  112.         BLAST_HitListPtr        PNTR hli, PNTR hlj;
  113. {
  114.         register BLAST_HSPPtr   hi, hj;
  115.  
  116.         hi = (*hli)->best_hsp;
  117.         hj = (*hlj)->best_hsp;
  118.  
  119.         if (hi->pvalue < hj->pvalue)
  120.                 return -1;
  121.         if (hi->pvalue > hj->pvalue)
  122.                 return 1;
  123.         return 0;
  124. }
  125.  
  126. int LIBCALL
  127. BlastHitListCmpByEvalue(hli, hlj)
  128.         BLAST_HitListPtr        PNTR hli, PNTR hlj;
  129. {
  130.         register BLAST_HSPPtr   hi, hj;
  131.  
  132.         hi = (*hli)->best_hsp;
  133.         hj = (*hlj)->best_hsp;
  134.  
  135.         if (hi->evalue < hj->evalue)
  136.                 return -1;
  137.         if (hi->evalue > hj->evalue)
  138.                 return 1;
  139.         return 0;
  140. }
  141.  
  142. int LIBCALL
  143. BlastHitListCmpByLength(hli, hlj)
  144.         BLAST_HitListPtr        PNTR hli, PNTR hlj;
  145. {
  146.         BLAST_HSPPtr    hp;
  147.         BLAST_Offset    imax, jmax;
  148.  
  149.         hp = (*hli)->best_hsp;
  150.         imax = MAX(hp->q_seg.len, hp->s_seg.len);
  151.  
  152.         hp = (*hlj)->best_hsp;
  153.         jmax = MAX(hp->q_seg.len, hp->s_seg.len);
  154.  
  155.         if (imax < jmax)
  156.                 return -1;
  157.         if (imax > jmax)
  158.                 return 1;
  159.         return 0;
  160. }
  161.  
  162. int LIBCALL
  163. BlastHitListCmpByCount(hli, hlj)
  164.         BLAST_HitListPtr        PNTR hli, PNTR hlj;
  165. {
  166.         register int    i, j;
  167.  
  168.         i = BlastHSPCount(*(*hli)->hpp);
  169.         j = BlastHSPCount(*(*hlj)->hpp);
  170.  
  171.         return j - i;
  172. }
  173.  
  174. int LIBCALL
  175. BlastHitListCmpByHighScore(hli, hlj)
  176.         BLAST_HitListPtr        PNTR hli, PNTR hlj;
  177. {
  178.         register BLAST_Score    si, sj, sdiff;
  179.  
  180.         si = (*(*hli)->hpp)->score;
  181.         sj = (*(*hlj)->hpp)->score;
  182.  
  183.         sdiff = sj - si;
  184.         return SIGN(sdiff);
  185. }
  186.  
  187. int LIBCALL
  188. BlastHitListCmpByScore(hli, hlj)
  189.         BLAST_HitListPtr        PNTR hli, PNTR hlj;
  190. {
  191.         register BLAST_HSPPtr   hpi, hpj;
  192.         BLAST_Score     si, sj, sdiff;
  193.  
  194.         hpi = *(*hli)->hpp;
  195.         hpj = *(*hlj)->hpp;
  196.  
  197.         while (hpi != NULL && hpj != NULL) {
  198.                 si = hpi->score;
  199.                 sj = hpj->score;
  200.                 sdiff = sj - si;
  201.                 if (sdiff != 0)
  202.                         return (sdiff > 0 ? 1 : -1);
  203.                 hpi = hpi->next;
  204.                 hpj = hpj->next;
  205.         }
  206.         if (hpi == NULL)
  207.                 return (hpj != NULL ? 1 : 0);
  208.         return -1;
  209. }
  210.  
  211. int LIBCALL
  212. BlastHitListCmpByTotalScore(hli, hlj)
  213.         BLAST_HitListPtr        PNTR hli, PNTR hlj;
  214. {
  215.         register BLAST_HSPPtr   hp;
  216.         register BLAST_Score    s;
  217.         BLAST_Score     si, sj, sdiff;
  218.  
  219.         for (hp = *(*hli)->hpp, s = 0; hp != NULL; hp = hp->next)
  220.                 s += hp->score;
  221.         si = s;
  222.  
  223.         for (hp = *(*hlj)->hpp, s = 0; hp != NULL; hp = hp->next)
  224.                 s += hp->score;
  225.         sj = s;
  226.  
  227.         sdiff = sj - si;
  228.         return SIGN(sdiff);
  229. }
  230. /******************  BLAST_HSP Comparison Routines  *********************/
  231. ValNodePtr LIBCALL
  232. BlastHSPCmpCriterionAdd(vnpp, crit)
  233.         ValNodePtr      PNTR vnpp;
  234.         BLAST_HSPCmp    crit;
  235. {
  236.         ValNodePtr      vnp;
  237.  
  238.         if (vnpp == NULL)
  239.                 return NULL;
  240.  
  241.         for (vnp = *vnpp; vnp != NULL; vnp = vnp->next) {
  242.                 if (vnp->choice == crit)
  243.                         return vnp;
  244.         }
  245.  
  246.         switch (crit) {
  247.         case BLAST_HSPCMP_PVALUE:
  248.                 return ValNodeAddFunction(vnpp, crit, (FnPtr)BlastHSPCmpByPvalue);
  249.         case BLAST_HSPCMP_EVALUE:
  250.                 return ValNodeAddFunction(vnpp, crit, (FnPtr)BlastHSPCmpByEvalue);
  251.         case BLAST_HSPCMP_FRAME:
  252.                 return ValNodeAddFunction(vnpp, crit, (FnPtr)BlastHSPCmpByFrame);
  253.         case BLAST_HSPCMP_SCORE:
  254.                 return ValNodeAddFunction(vnpp, crit, (FnPtr)BlastHSPCmpByScore);
  255.         case BLAST_HSPCMP_NORMSCORE:
  256.                 return ValNodeAddFunction(vnpp, crit, (FnPtr)BlastHSPCmpByNormScore);
  257.         case BLAST_HSPCMP_N:
  258.                 return ValNodeAddFunction(vnpp, crit, (FnPtr)BlastHSPCmpByN);
  259.         case BLAST_HSPCMP_LENGTH:
  260.                 return ValNodeAddFunction(vnpp, crit, (FnPtr)BlastHSPCmpByLength);
  261.         case BLAST_HSPCMP_OFFSET:
  262.                 return ValNodeAddFunction(vnpp, crit, (FnPtr)BlastHSPCmpByOffset);
  263.         default:
  264.                 return NULL;
  265.         }
  266.         /*NOTREACHED*/
  267. }
  268.  
  269. int LIBCALL
  270. BlastHSPCmpStd(hspi, hspj, vnp)
  271.         BLAST_HSPPtr    hspi, hspj;
  272.         ValNodePtr      vnp;
  273. {
  274.         register int (LIBCALLBACK *func)();
  275.         register int    i;
  276.  
  277.         if (hspi == NULL)
  278.                 return (hspj != NULL ? 1 : 0);
  279.         if (hspj == NULL)
  280.                 return -1;
  281.  
  282.         for (; vnp != NULL; vnp = vnp->next) {
  283.                 func = (int (LIBCALLBACK *)())vnp->data.funcvalue;
  284.                 i = (*func)(&hspi, &hspj);
  285.                 if (i != 0)
  286.                         return i;
  287.         }
  288.  
  289.         return 0;
  290. }
  291.  
  292. int LIBCALL
  293. BlastHSPPtrCmpStd(hspi, hspj, vnp)
  294.         BLAST_HSPPtr    PNTR hspi, PNTR hspj;
  295.         ValNodePtr      vnp;
  296. {
  297.         register int (LIBCALLBACK *func)();
  298.         register int    i;
  299.  
  300.         if (hspi == NULL)
  301.                 return (hspj != NULL ? 1 : 0);
  302.         if (hspj == NULL)
  303.                 return -1;
  304.  
  305.         for (; vnp != NULL; vnp = vnp->next) {
  306.                 func = (int (LIBCALLBACK *)())vnp->data.funcvalue;
  307.                 i = (*func)(hspi, hspj);
  308.                 if (i != 0)
  309.                         return i;
  310.         }
  311.  
  312.         return 0;
  313. }
  314. void LIBCALL
  315. BlastHSPSort(hspp, vnp)
  316.         BLAST_HSPPtr PNTR       hspp;
  317.         ValNodePtr      vnp;
  318. {
  319.         LinkSort1((VoidPtr PNTR)hspp, offsetof(BLAST_HSP,next), BlastHSPPtrCmpStd, vnp);
  320. }
  321.  
  322. int LIBCALL
  323. BlastHSPCmpByPvalue(hspi, hspj)
  324.         BLAST_HSPPtr    PNTR hspi, PNTR hspj;
  325. {
  326.         register double xi, xj, ratio;
  327.  
  328.         xi = (*hspi)->pvalue;
  329.         xj = (*hspj)->pvalue;
  330.  
  331.         if (xi != 0. && xj != 0.) {
  332.                 ratio = xi / xj;
  333.                 if (ratio < 1.00001 && ratio > 0.99999)
  334.                         return 0;
  335.         }
  336.  
  337.         if (xi < xj)
  338.                 return -1;
  339.         if (xi > xj)
  340.                 return 1;
  341.         return 0;
  342. }
  343.  
  344. int LIBCALL
  345. BlastHSPCmpByEvalue(hspi, hspj)
  346.         BLAST_HSPPtr    PNTR hspi, PNTR hspj;
  347. {
  348.         register double xi, xj, ratio;
  349.  
  350.         xi = (*hspi)->evalue;
  351.         xj = (*hspj)->evalue;
  352.  
  353.         if (xi > 1. && xj < 1.) /* avoids possible arithmetic overflow */
  354.                 return 1;
  355.  
  356.         if (xi != 0. && xj != 0.) {
  357.                 ratio = xi / xj;
  358.                 if (ratio < 1.00001 && ratio > 0.99999)
  359.                         return 0;
  360.         }
  361.  
  362.         if (xi < xj)
  363.                 return -1;
  364.         if (xi > xj)
  365.                 return 1;
  366.         return 0;
  367. }
  368.  
  369. int LIBCALL
  370. BlastHSPCmpByFrame(hspi, hspj)
  371.         BLAST_HSPPtr    PNTR hspi, PNTR hspj;
  372. {
  373.         int     fi, fj;
  374.  
  375.         fi = (*hspi)->q_seg.frame;
  376.         fj = (*hspj)->q_seg.frame;
  377.         if (fi != fj) {
  378.                 fi = SIGN(fi);
  379.                 fj = SIGN(fj);
  380.                 if (fi > fj)
  381.                         return -1;
  382.                 if (fi < fj)
  383.                         return 1;
  384.         }
  385.  
  386.         fi = (*hspi)->s_seg.frame;
  387.         fj = (*hspj)->s_seg.frame;
  388.         if (fi != fj) {
  389.                 fi = SIGN(fi);
  390.                 fj = SIGN(fj);
  391.                 if (fi > fj)
  392.                         return -1;
  393.                 if (fi < fj)
  394.                         return 1;
  395.         }
  396.  
  397.         return 0;
  398. }
  399.  
  400. int LIBCALL
  401. BlastHSPCmpByScore(hspi, hspj)
  402.         BLAST_HSPPtr    PNTR hspi, PNTR hspj;
  403. {
  404.         BLAST_Score     si, sj, sdiff;
  405.  
  406.         si = (*hspi)->score;
  407.         sj = (*hspj)->score;
  408.         sdiff = sj - si;
  409.         return SIGN(sdiff);
  410. }
  411.  
  412. int LIBCALL
  413. BlastHSPCmpByNormScore(hspi, hspj)
  414.         BLAST_HSPPtr    PNTR hspi, PNTR hspj;
  415. {
  416.         BLAST_Score     si, sj, sdiff;
  417.         BLAST_KarlinBlkPtr      ki, kj;
  418.         register double xi, xj, ratio;
  419.  
  420.         si = (*hspi)->score;
  421.         ki = (*hspi)->kbp;
  422.         sj = (*hspj)->score;
  423.         kj = (*hspj)->kbp;
  424.         if (ki == kj) {
  425.                 sdiff = sj - si;
  426.                 return SIGN(sdiff);
  427.         }
  428.  
  429.         xi = ki->Lambda * si;
  430.         xj = kj->Lambda * sj;
  431.  
  432.         if (xi != 0. && xj != 0.) {
  433.                 ratio = xi / xj;
  434.                 if (ratio < 1.00001 && ratio > 0.99999)
  435.                         return 0;
  436.         }
  437.  
  438.         if (xi > xj)
  439.                 return -1;
  440.         if (xi < xj)
  441.                 return 1;
  442.         return 0;
  443. }
  444.  
  445. int LIBCALL
  446. BlastHSPCmpByLength(hspi, hspj)
  447.         BLAST_HSPPtr    PNTR hspi, PNTR hspj;
  448. {
  449.         BLAST_HSPPtr    hp;
  450.         BLAST_Offset    imax, jmax;
  451.  
  452.         hp = *hspi;
  453.         imax = MAX(hp->q_seg.len, hp->s_seg.len);
  454.         hp = *hspj;
  455.         jmax = MAX(hp->q_seg.len, hp->s_seg.len);
  456.  
  457.         if (imax < jmax)
  458.                 return -1;
  459.         if (imax > jmax)
  460.                 return 1;
  461.         return 0;
  462. }
  463.  
  464. int LIBCALL
  465. BlastHSPCmpByOffset(hspi, hspj)
  466.         BLAST_HSPPtr    PNTR hspi, PNTR hspj;
  467. {
  468.         register unsigned long  oi, oj;
  469.  
  470.         oi = (*hspi)->q_seg.offset;
  471.         oj = (*hspj)->q_seg.offset;
  472.         if (oi > oj)
  473.                 return 1;
  474.         if (oi < oj)
  475.                 return -1;
  476.  
  477.         oi = (*hspi)->s_seg.offset;
  478.         oj = (*hspj)->s_seg.offset;
  479.         if (oi > oj)
  480.                 return 1;
  481.         if (oi < oj)
  482.                 return -1;
  483.  
  484.         return 0;
  485. }
  486.  
  487. int LIBCALL
  488. BlastHSPCmpByN(hspi, hspj)
  489.         BLAST_HSPPtr    PNTR hspi, PNTR hspj;
  490. {
  491.         register int    i, j;
  492.  
  493.         i = (*hspi)->n;
  494.         j = (*hspj)->n;
  495.  
  496.         return j - i;
  497. }

Raw Paste


Login or Register to edit or fork this paste. It's free.