开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数值算法/人工智能 > 生物技术 > 查看源码
nw_spliced_aligner32.cpp
资源名称：ncbi_cxx_win--Jul_08_2004.zip　[点击查看]
上传用户：yhdzpy8989
上传日期：2007-06-13
资源大小：13604k
文件大小：19k
源码类别：

生物技术

开发平台：

C/C++

nw_spliced_aligner32.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: nw_spliced_aligner32.cpp,v $
  4.  * PRODUCTION Revision 1000.3  2004/06/01 18:05:06  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.15
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /* $Id: nw_spliced_aligner32.cpp,v 1000.3 2004/06/01 18:05:06 gouriano Exp $
  11. * ===========================================================================
  12. *
  13. *                            PUBLIC DOMAIN NOTICE                          
  14. *               National Center for Biotechnology Information
  15. *                                                                          
  16. *  This software/database is a "United States Government Work" under the   
  17. *  terms of the United States Copyright Act.  It was written as part of    
  18. *  the author's official duties as a United States Government employee and 
  19. *  thus cannot be copyrighted.  This software/database is freely available 
  20. *  to the public for use. The National Library of Medicine and the U.S.    
  21. *  Government have not placed any restriction on its use or reproduction.  
  22. *                                                                          
  23. *  Although all reasonable efforts have been taken to ensure the accuracy  
  24. *  and reliability of the software and data, the NLM and the U.S.          
  25. *  Government do not and cannot warrant the performance or results that    
  26. *  may be obtained by using this software or data. The NLM and the U.S.    
  27. *  Government disclaim all warranties, express or implied, including       
  28. *  warranties of performance, merchantability or fitness for any particular
  29. *  purpose.                                                                
  30. *                                                                          
  31. *  Please cite the author in any work or product based on this material.   
  32. *
  33. * ===========================================================================
  34. *
  35. * Authors:  Yuri Kapustin
  36. *
  37. * File Description:  CSplicedAligner32
  38. *                   
  39. * ===========================================================================
  40. *
  41. */
  44. #include <ncbi_pch.hpp>
  45. #include <algo/align/nw_spliced_aligner32.hpp>
  46. #include <algo/align/align_exception.hpp>
  48. BEGIN_NCBI_SCOPE
  50. const unsigned char g_nwspl32_donor[splice_type_count_32][2] = {
  51.     {'G','T'}, // donor type 1 in CDonorAcceptorMatrix coding
  52.     {'G','C'}, // 2
  53.     {'A','T'}  // 3
  54. };
  56. const unsigned char g_nwspl32_acceptor[splice_type_count_32][2] = {
  57.     {'A','G'}, // 1
  58.     {'A','G'}, // 2
  59.     {'A','C'}  // 3
  60. };
  63. // Transcript coding
  64. // (lower bits contain jump value for gaps and introns)
  65. const Uint4 kTypeDiag   = 0x00000000;  // single match or mismatch
  66. const Uint4 kTypeGap    = 0x40000000;  // gap - any type
  67. const Uint4 kTypeIntron = 0x80000000;  // intron
  70. // Donor-acceptor static object used
  71. // to figure out what donors and aceptors
  72. // could be transformed to any given na pair
  73. // by mutating either of its characters (but not both).
  74. // donor types:      bits 5-7
  75. // acceptor types:   bits 1-3
  77. class CDonorAcceptorMatrix {
  78. public:
  79.     CDonorAcceptorMatrix() {
  80.         memset(m_matrix, 0, sizeof m_matrix);
  81.         m_matrix['A']['A'] = 0x47; //       3 ; 1, 2, 3
  82.         m_matrix['A']['G'] = 0x47; //       3 ; 1, 2, 3
  83.         m_matrix['A']['T'] = 0x57; // 1,    3 ; 1, 2, 3
  84.         m_matrix['A']['C'] = 0x67; //    2, 3 ; 1, 2, 3
  85.         m_matrix['G']['A'] = 0x33; // 1, 2    ;
  86.         m_matrix['G']['G'] = 0x33; // 1, 2    ; 1, 2
  87.         m_matrix['G']['T'] = 0x70; // 1, 2, 3 ;
  88.         m_matrix['G']['C'] = 0x34; // 1, 2    ;       3
  89.         m_matrix['T']['A'] = 0x00; //         ;
  90.         m_matrix['T']['G'] = 0x03; //         ; 1, 2
  91.         m_matrix['T']['T'] = 0x50; // 1,    3 ;
  92.         m_matrix['T']['C'] = 0x24; //    2    ;       3
  93.         m_matrix['C']['A'] = 0x00; //         ;
  94.         m_matrix['C']['G'] = 0x03; //         ; 1, 2
  95.         m_matrix['C']['T'] = 0x50; // 1,    3 ;
  96.         m_matrix['C']['C'] = 0x24; //    2    ;       3
  97.     }
  98.     const Uint1* GetMatrix() const {
  99.         return m_matrix[0];
  100.     }
  101. private:
  102.     Uint1 m_matrix [256][256];
  103. };
  106. namespace {
  107.     CDonorAcceptorMatrix g_dnr_acc_matrix;
  108. }
  110. CSplicedAligner32::CSplicedAligner32():
  111.       m_Wd1(GetDefaultWd1()),
  112.       m_Wd2(GetDefaultWd2())
  113. {
  114.     for(unsigned char st = 0; st < splice_type_count_32; ++st) {
  115.         m_Wi[st] = GetDefaultWi(st);
  116.     }
  117. }
  119. CSplicedAligner32::CSplicedAligner32(const char* seq1, size_t len1,
  120.                                        const char* seq2, size_t len2)
  121.     : CSplicedAligner(seq1, len1, seq2, len2),
  122.       m_Wd1(GetDefaultWd1()),
  123.       m_Wd2(GetDefaultWd2())
  124. {
  125.     for(unsigned char st = 0; st < splice_type_count_32; ++st) {
  126.         m_Wi[st] = GetDefaultWi(st);
  127.     }
  128. }
  131. CNWAligner::TScore CSplicedAligner32::GetDefaultWi(unsigned char splice_type)
  132. {
  133.     switch(splice_type) {
  134.         case 0: return -15; // GT/AG
  135.         case 1: return -18; // GC/AG
  136.         case 2: return -21; // AT/AC
  137.         default: {
  138.             NCBI_THROW(CAlgoAlignException,
  139.                        eInvalidSpliceTypeIndex,
  140.                        "Invalid splice type index");
  141.         }
  142.     }
  143. }
  146. // Evaluate dynamic programming matrix. Create transcript.
  147. CNWAligner::TScore CSplicedAligner32::x_Align (
  148.                          const char* seg1, size_t len1,
  149.                          const char* seg2, size_t len2,
  150.                          vector<ETranscriptSymbol>* transcript )
  151. {
  152.     const size_t N1 = len1 + 1;
  153.     const size_t N2 = len2 + 1;
  155.     vector<TScore> stl_rowV (N2), stl_rowF (N2);
  156.     TScore* rowV    = &stl_rowV[0];
  157.     TScore* rowF    = &stl_rowF[0];
  159.     // index calculation: [i,j] = i*n2 + j
  160.     vector<Uint4> stl_bm (N1*N2);
  161.     Uint4* backtrace_matrix = &stl_bm[0];
  163.     TScore* pV = rowV - 1;
  165.     const char* seq1   = seg1 - 1;
  166.     const char* seq2   = seg2 - 1;
  168.     const TNCBIScore (*sm) [NCBI_FSM_DIM] = m_ScoreMatrix.s;
  170.     bool bFreeGapLeft1  = m_esf_L1 && seg1 == m_Seq1;
  171.     bool bFreeGapRight1 = m_esf_R1 && m_Seq1 + m_SeqLen1 - len1 == seg1;
  172.     bool bFreeGapLeft2  = m_esf_L2 && seg2 == m_Seq2;
  173.     bool bFreeGapRight2 = m_esf_R2 && m_Seq2 + m_SeqLen2 - len2 == seg2;
  175.     TScore wgleft1   = bFreeGapLeft1? 0: m_Wg;
  176.     TScore wsleft1   = bFreeGapLeft1? 0: m_Ws;
  177.     TScore wg1 = wgleft1, ws1 = wsleft1;
  179.     // recurrences
  180.     TScore wgleft2   = bFreeGapLeft2? 0: m_Wg;
  181.     TScore wsleft2   = bFreeGapLeft2? 0: m_Ws;
  182.     TScore V  = 0;
  183.     TScore V0 = 0;
  184.     TScore E, G, n0;
  185.     Uint4 type;
  187.     // store candidate donors
  188.     size_t* jAllDonors [splice_type_count_32];
  189.     TScore* vAllDonors [splice_type_count_32];
  190.     vector<size_t> stl_jAllDonors (splice_type_count_32 * N2);
  191.     vector<TScore> stl_vAllDonors (splice_type_count_32 * N2);
  192.     for(unsigned char st = 0; st < splice_type_count_32; ++st) {
  193.         jAllDonors[st] = &stl_jAllDonors[st*N2];
  194.         vAllDonors[st] = &stl_vAllDonors[st*N2];
  195.     }
  196.     size_t  jTail[splice_type_count_32], jHead[splice_type_count_32];
  197.     TScore  vBestDonor   [splice_type_count_32];
  198.     size_t  jBestDonor   [splice_type_count_32];
  200.     // place to store gap opening starts
  201.     size_t ins_start;
  202.     vector<size_t> stl_del_start(N2);
  203.     size_t* del_start = &stl_del_start[0];
  205.     // donor/acceptor matrix
  206.     const Uint1 * dnr_acc_matrix = g_dnr_acc_matrix.GetMatrix();
  208.     // fake row (above lambda)
  209.     rowV[0] = kInfMinus;
  210.     size_t k;
  211.     for (k = 0; k < N2; k++) {
  212.         rowV[k] = rowF[k] = kInfMinus;
  213. del_start[k] = k;
  214.     }
  215.     k = 0;
  217.     size_t i, j = 0, k0;
  218.     unsigned char ci;
  219.     for(i = 0;  i < N1;  ++i, j = 0) {
  221.         V = i > 0? (V0 += wsleft2) : 0;
  222.         E = kInfMinus;
  223.         ins_start = k0 = k;
  224.         backtrace_matrix[k++] = kTypeGap; // | del_start[0]
  225.         ci = i > 0? seq1[i]: 'N';
  227.         for(unsigned char st = 0; st < splice_type_count_32; ++st) {
  228.             jTail[st] = jHead[st] = 0;
  229.             vBestDonor[st] = kInfMinus;
  230.         }
  232.         if(i == N1 - 1 && bFreeGapRight1) {
  233.                 wg1 = ws1 = 0;
  234.         }
  236.         TScore wg2 = m_Wg, ws2 = m_Ws;
  237.             
  238.         // detect donor candidate
  239.         if(N2 > 2) {
  240.             unsigned char d1 = seq2[1], d2 = seq2[2];
  241.             Uint1 dnr_type = 0xF0 & dnr_acc_matrix[(size_t(d1)<<8)|d2];
  243.             for(Uint1 st = 0; st < splice_type_count_32; ++st ) {
  244.                 jAllDonors[st][jTail[st]] = j;
  245.                 if(dnr_type & (0x10 << st)) {
  246.                     vAllDonors[st][jTail[st]] = 
  247.                         ( d1 == g_nwspl32_donor[st][0] && d2 == g_nwspl32_donor[st][1] ) ?
  248.                         V: (V + m_Wd1);
  249.                 }
  250.                 else { // both chars distorted
  251.                     vAllDonors[st][jTail[st]] = V + m_Wd2;
  252.                 }
  253.                 ++(jTail[st]);
  254.             }
  255.         }
  257.         for (j = 1; j < N2; ++j, ++k) {
  258.             
  259.             G = pV[j] + sm[ci][(unsigned char)seq2[j]];
  260.             pV[j] = V;
  262.             n0 = V + wg1;
  263.             if(E >= n0) {
  264.                 E += ws1;      // continue the gap
  265.             }
  266.             else {
  267.                 E = n0 + ws1;  // open a new gap
  268. ins_start = k-1;
  269.             }
  271.             if(j == N2 - 1 && bFreeGapRight2) {
  272.                 wg2 = ws2 = 0;
  273.             }
  274.             n0 = rowV[j] + wg2;
  275.             if(rowF[j] >= n0) {
  276.                 rowF[j] += ws2;
  277.             }
  278.             else {
  279.                 rowF[j] = n0 + ws2;
  280.                 del_start[j] = k-N2;
  281.             }
  283.             // evaluate the score (V)
  284.             if (E >= rowF[j]) {
  285.                 if(E >= G) {
  286.                     V = E;
  287.                     type = kTypeGap | ins_start;
  288.                 }
  289.                 else {
  290.                     V = G;
  291.                     type = kTypeDiag;
  292.                 }
  293.             } else {
  294.                 if(rowF[j] >= G) {
  295.                     V = rowF[j];
  296.                     type = kTypeGap | del_start[j];
  297.                 }
  298.                 else {
  299.                     V = G;
  300.                     type = kTypeDiag;
  301.                 }
  302.             }
  304.             // find out if there are new donors
  305.             for(unsigned char st = 0; st < splice_type_count_32; ++st) {
  307.                 if(jTail[st] > jHead[st])  {
  308.                     if(j - jAllDonors[st][jHead[st]] >= m_IntronMinSize) {
  309.                         if(vAllDonors[st][jHead[st]] > vBestDonor[st]) {
  310.                             vBestDonor[st] = vAllDonors[st][jHead[st]];
  311.                             jBestDonor[st] = jAllDonors[st][jHead[st]];
  312.                         }
  313.                         ++(jHead[st]);
  314.                     }
  315.                 }
  316.             }
  317.                 
  318.             // check splice signal
  319.             Uint4 dnr_pos = kMax_UI4;
  320.             unsigned char c1 = seq2[j-1], c2 = seq2[j];
  321.             Uint1 acc_mask = 0x0F & dnr_acc_matrix[(size_t(c1)<<8)|c2];
  322.             for(Uint1 st = 0; st < splice_type_count_32; ++st ) {
  323.                 if(acc_mask & (0x01 << st)) {
  324.                     TScore vAcc = vBestDonor[st] + m_Wi[st];
  325.                     if( c1 != g_nwspl32_acceptor[st][0] || c2 != g_nwspl32_acceptor[st][1] ) {
  326.                         vAcc += m_Wd1;
  327.                     }
  328.                     if(vAcc > V) {
  329.                         V = vAcc;
  330.                         dnr_pos = k0 + jBestDonor[st];
  331.                     }
  332.                 }
  333.                 else {   // try arbitrary splice
  334.                     TScore vAcc = vBestDonor[st] + m_Wi[st] + m_Wd2;
  335.                     if(vAcc > V) {
  336.                         V = vAcc;
  337.                         dnr_pos = k0 + jBestDonor[st];
  338.                     }
  339.                 }
  340.             }
  341.             
  342.             if(dnr_pos != kMax_UI4) {
  343.                 type = kTypeIntron | dnr_pos;
  344.             }
  346.             backtrace_matrix[k] = type;
  348.             // detect donor candidates
  349.             if(j < N2 - 2) {
  350.                 unsigned char d1 = seq2[j+1], d2 = seq2[j+2];
  351.                 Uint1 dnr_mask = 0xF0 & dnr_acc_matrix[(size_t(d1)<<8)|d2];
  352.                 for(Uint1 st = 0; st < splice_type_count_32; ++st ) {
  353.                     if( dnr_mask & (0x10 << st) ) {
  354.                         if( d1 == g_nwspl32_donor[st][0] && d2 == g_nwspl32_donor[st][1] ) {
  355.                             if(V > vBestDonor[st]) {
  356.                                 jAllDonors[st][jTail[st]] = j;
  357.                                 vAllDonors[st][jTail[st]] = V;
  358.                                 ++(jTail[st]);
  359.                             }
  360.                         } else {
  361.                             TScore v = V + m_Wd1;
  362.                             if(v > vBestDonor[st]) {
  363.                                 jAllDonors[st][jTail[st]] = j;
  364.                                 vAllDonors[st][jTail[st]] = v;
  365.                                 ++(jTail[st]);
  366.                             }
  367.                         }
  368.                     }
  369.                     else { // both chars distorted
  370.                         TScore v = V + m_Wd2;
  371.                         if(v > vBestDonor[st]) {
  372.                             jAllDonors[st][jTail[st]] = j;
  373.                             vAllDonors[st][jTail[st]] = v;
  374.                             ++(jTail[st]);
  375.                         }
  376.                     }
  377.                 }
  378.             }
  379.         }
  381.         pV[j] = V;
  383.         if(i == 0) {
  384.             V0 = wgleft2;
  385.             wg1 = m_Wg;
  386.             ws1 = m_Ws;
  387.         }
  389.     }
  391.     try {
  392.     x_DoBackTrace(backtrace_matrix, N1, N2, transcript);
  393.     }
  394.     catch(exception&) { // GCC hack
  395.       throw;
  396.     }
  397.     
  398.     return V;
  399. }
  403. // perform backtrace step;
  404. void CSplicedAligner32::x_DoBackTrace ( const Uint4* backtrace_matrix,
  405.                                          size_t N1, size_t N2,
  406.                                          vector<ETranscriptSymbol>* transcript)
  407. {
  408.     transcript->clear();
  409.     transcript->reserve(N1 + N2);
  411.     const Uint4 mask_jump = 0x3FFFFFFF;
  412.     const Uint4 mask_type = ~mask_jump;
  414.     size_t k = N1*N2 - 1;
  416.     while (k != 0) {
  417.         Uint4 Key = backtrace_matrix[k];
  418.         Uint4 type = Key & mask_type;
  420. if(type == kTypeDiag) {
  421.     transcript->push_back(eTS_Match);
  422.     k -= N2 + 1;
  423. }
  424. else {
  425.   Uint4 k2 = (Key & mask_jump);
  426.   if(k2 >= k) {
  427.         NCBI_THROW(CAlgoAlignException, eInternal,
  428.                            "Incorrect backtrace jump detected");
  429.   }
  431.   ETranscriptSymbol ts;
  432.   Uint4 decr;
  433.   if(type == kTypeIntron) {
  434.     ts = eTS_Intron;
  435.     decr = 1;
  436.   }
  437.   else {
  438.     Uint4 kdel = k / N2, k2del = k2 / N2;
  439.     Uint4 kmod = k % N2, k2mod = k2 % N2;
  440.     if(kdel == k2del) {
  441.       ts = eTS_Insert;
  442.       decr = 1;
  443.     }
  444.     else if(kmod == k2mod) {
  445.       ts = eTS_Delete;
  446.       decr = N2;
  447.     }
  448.     else {
  449.       // ts = eTS_DiagSpace;
  450.       NCBI_THROW(CAlgoAlignException, eInternal,
  451.                          "Diag spaces not yet supported");
  452.     }
  453.   }
  455.   for(; k > k2; k -= decr) {
  456.     transcript->push_back(ts);
  457.   }
  458.   if(k != k2) {
  459.       NCBI_THROW(CAlgoAlignException, eInternal,
  460.                          "Backtrace jump failed");
  461.   }
  462. }
  463.     } // while
  464. }
  468. CNWAligner::TScore CSplicedAligner32::x_ScoreByTranscript() const
  469. {
  470.     const size_t dim = m_Transcript.size();
  471.     if(dim == 0) return 0;
  473.     TScore score = 0;
  475.     const char* p1 = m_Seq1;
  476.     const char* p2 = m_Seq2;
  478.     const TNCBIScore (*sm) [NCBI_FSM_DIM] = m_ScoreMatrix.s;
  480.     char state1;   // 0 = normal, 1 = gap, 2 = intron
  481.     char state2;   // 0 = normal, 1 = gap
  483.     switch( m_Transcript[dim - 1] ) {
  485.     case eTS_Match:
  486.         state1 = state2 = 0;
  487.         break;
  489.     case eTS_Insert:
  490.         state1 = 1; state2 = 0; score += m_Wg;
  491.         break;
  493.     case eTS_Intron:
  494.         state1 = 0; state2 = 0;
  495.         break; // intron flag set later
  497.     case eTS_Delete:
  498.         state1 = 0; state2 = 1; score += m_Wg;
  499.         break;
  501.     default: {
  502.         NCBI_THROW(CAlgoAlignException, eInternal,
  503.                    "Invalid transcript symbol");
  504.         }
  505.     }
  507.     for(int i = dim - 1; i >= 0; --i) {
  509.         unsigned char c1 = m_Seq1? *p1: 0;
  510.         unsigned char c2 = m_Seq2? *p2: 0;
  511.         switch(m_Transcript[i]) {
  513.         case eTS_Match: {
  514.             state1 = state2 = 0;
  515.             score += sm[c1][c2];
  516.             ++p1; ++p2;
  517.         }
  518.         break;
  520.         case eTS_Insert: {
  521.             if(state1 != 1) score += m_Wg;
  522.             state1 = 1; state2 = 0;
  523.             score += m_Ws;
  524.             ++p2;
  525.         }
  526.         break;
  528.         case eTS_Delete: {
  529.             if(state2 != 1) score += m_Wg;
  530.             state1 = 0; state2 = 1;
  531.             score += m_Ws;
  532.             ++p1;
  533.         }
  534.         break;
  536.         case eTS_Intron: {
  538.             if(state1 != 2) {
  539.                 for(unsigned char k = 0; k < splice_type_count_32; ++k) {
  540.                     if(*p2 == g_nwspl32_donor[k][0] && *(p2 + 1) == g_nwspl32_donor[k][1]) {
  541.                         score += m_Wi[k];
  542.                         break;
  543.                     }
  544.                 }
  545.             }
  546.             state1 = 2; state2 = 0;
  547.             ++p2;
  548.         }
  549.         break;
  551.         default: {
  552.         NCBI_THROW(CAlgoAlignException, eInternal,
  553.                    "Invalid transcript symbol");
  554.         }
  555.         }
  556.     }
  558.     if(m_esf_L1) {
  559.         size_t g = 0;
  560.         for(int i = dim - 1; i >= 0; --i) {
  561.             if(m_Transcript[i] == eTS_Insert) ++g; else break;
  562.         }
  563.         if(g > 0) {
  564.             score -= (m_Wg + g*m_Ws);
  565.         }
  566.     }
  568.     if(m_esf_L2) {
  569.         size_t g = 0;
  570.         for(int i = dim - 1; i >= 0; --i) {
  571.             if(m_Transcript[i] == eTS_Delete) ++g; else break;
  572.         }
  573.         if(g > 0) {
  574.             score -= (m_Wg + g*m_Ws);
  575.         }
  576.     }
  578.     if(m_esf_R1) {
  579.         size_t g = 0;
  580.         for(size_t i = 0; i < dim; ++i) {
  581.             if(m_Transcript[i] == eTS_Insert) ++g; else break;
  582.         }
  583.         if(g > 0) {
  584.             score -= (m_Wg + g*m_Ws);
  585.         }
  586.     }
  588.     if(m_esf_R2) {
  589.         size_t g = 0;
  590.         for(size_t i = 0; i < dim; ++i) {
  591.             if(m_Transcript[i] == eTS_Delete) ++g; else break;
  592.         }
  593.         if(g > 0) {
  594.             score -= (m_Wg + g*m_Ws);
  595.         }
  596.     }
  598.     return score;
  599. }
  602. END_NCBI_SCOPE
  606. /*
  607.  * ===========================================================================
  608.  * $Log: nw_spliced_aligner32.cpp,v $
  609.  * Revision 1000.3  2004/06/01 18:05:06  gouriano
  610.  * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.15
  611.  *
  612.  * Revision 1.15  2004/05/21 21:41:02  gorelenk
  613.  * Added PCH ncbi_pch.hpp
  614.  *
  615.  * Revision 1.14  2004/05/18 21:43:40  kapustin
  616.  * Code cleanup
  617.  *
  618.  * Revision 1.13  2004/05/17 14:50:57  kapustin
  619.  * Add/remove/rearrange some includes and object declarations
  620.  *
  621.  * Revision 1.12  2004/04/23 14:39:47  kapustin
  622.  * Add Splign library and other changes
  623.  *
  624.  * Revision 1.10  2003/11/20 17:54:23  kapustin
  625.  * Alternative conventional splice penalty adjusted
  626.  *
  627.  * Revision 1.9  2003/10/31 19:40:13  kapustin
  628.  * Get rid of some WS and GCC complains
  629.  *
  630.  * Revision 1.8  2003/10/27 21:00:17  kapustin
  631.  * Set intron penalty defaults differently for 16- and 32-bit versions according to the expected quality of sequences those variants are supposed to be used with.
  632.  *
  633.  * Revision 1.7  2003/10/14 19:31:52  kapustin
  634.  * Use one flag for all gap types
  635.  *
  636.  * Revision 1.6  2003/09/30 19:50:04  kapustin
  637.  * Make use of standard score matrix interface
  638.  *
  639.  * Revision 1.5  2003/09/26 14:43:18  kapustin
  640.  * Remove exception specifications
  641.  *
  642.  * Revision 1.4  2003/09/10 20:25:21  kapustin
  643.  * Use unsigned char for score matrix index
  644.  *
  645.  * Revision 1.3  2003/09/10 19:13:10  kapustin
  646.  * Change backtrace type constants to allow larger jump values
  647.  *
  648.  * Revision 1.2  2003/09/04 16:07:38  kapustin
  649.  * Use STL vectors for exception-safe dynamic arrays and matrices
  650.  *
  651.  * Revision 1.1  2003/09/02 22:34:49  kapustin
  652.  * Initial revision
  653.  *
  654.  * ===========================================================================
  655.  */