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

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

生物技术

开发平台：

C/C++

Int_fuzz.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: Int_fuzz.cpp,v $
  4.  * PRODUCTION Revision 1000.2  2004/06/01 19:32:23  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R6.12
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /* $Id: Int_fuzz.cpp,v 1000.2 2004/06/01 19:32:23 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.  * Author:  .......
  36.  *
  37.  * File Description:
  38.  *   .......
  39.  *
  40.  * Remark:
  41.  *   This code was originally generated by application DATATOOL
  42.  *   using specifications from the ASN data definition file
  43.  *   'general.asn'.
  44.  *
  45.  * ===========================================================================
  46.  */
  48. // standard includes
  50. // generated includes
  51. #include <ncbi_pch.hpp>
  52. #include <objects/general/Int_fuzz.hpp>
  54. #include <algorithm>
  55. #include <set>
  56. #include <math.h>
  58. // generated classes
  60. BEGIN_NCBI_SCOPE
  62. BEGIN_objects_SCOPE // namespace ncbi::objects::
  64. // destructor
  65. CInt_fuzz::~CInt_fuzz(void)
  66. {
  67. }
  70. void CInt_fuzz::GetLabel(string* label, TSeqPos pos, bool right) const
  71. {
  72.     char lim = 0;
  73.     switch (Which()) {
  74.     case CInt_fuzz::e_P_m:
  75.         (*label) += "<+-" + NStr::IntToString(GetP_m()) + ">";
  76.         break;
  77.     case CInt_fuzz::e_Range:
  78.         (*label) += "<" + NStr::IntToString(GetRange().GetMin()) +
  79.             "." + NStr::IntToString(GetRange().GetMax()) + ">";
  80.         break;
  81.     case CInt_fuzz::e_Pct:
  82.         (*label) += "<" + NStr::IntToString(GetPct()) + "%>";
  83.         break;
  84.     case CInt_fuzz::e_Lim:
  85.         switch (GetLim()) {
  86.         case eLim_unk:
  87.         case eLim_other:
  88.             (*label) += "<?>";
  89.             break;
  90.         case eLim_gt:
  91.             lim = '>';
  92.             break;
  93.         case eLim_lt:
  94.             lim = '<';
  95.             break;
  96.         case eLim_tr:
  97.             lim = 'r';
  98.             break;
  99.         case eLim_tl:
  100.             lim = '^';
  101.             break;
  102.         default:
  103.             break;
  104.         }
  105.         break;
  106.     default:
  107.         break;
  108.     }
  110.     if (lim  &&  lim != 'r') {
  111.         (*label) += lim;
  112.         lim = 0;
  113.     }
  115.     if (right) {
  116.         (*label) += NStr::IntToString(pos + 1);
  117.     }
  119.     if (lim == 'r') {
  120.         (*label) += '^';
  121.     }
  123.     if (!right) {
  124.         (*label) += NStr::IntToString(pos + 1);
  125.     }
  126. }
  129. void CInt_fuzz::AssignTranslated(const CInt_fuzz& f2, TSeqPos n1, TSeqPos n2)
  130. {
  131.     switch (f2.Which()) {
  132.     case e_Range:
  133.         SetRange().SetMin(f2.GetRange().GetMin() + n1 - n2);
  134.         SetRange().SetMax(f2.GetRange().GetMax() + n1 - n2);
  135.         break;
  136.     case e_Pct:
  137.         // use double to avoid overflow
  138.         SetPct((TSeqPos)((double)f2.GetPct() * n1 / n2));
  139.         break;
  140.     case e_Alt:
  141.         ITERATE (TAlt, it, f2.GetAlt()) {
  142.             SetAlt().push_back(*it + n1 - n2);
  143.         }
  144.         break;
  145.     default:
  146.         Assign(f2);
  147.         break;
  148.     }
  149. }
  152. void CInt_fuzz::Add(const CInt_fuzz& f2, TSeqPos& n1, TSeqPos n2,
  153.                     ECombine mode)
  154. {
  155.     static const double kInfinity = 1.0e20;
  156.     bool                hit_pct = false, hit_unk = false, hit_circle = false;
  157.     double              min_delta = 0.0, max_delta = 0.0;
  158.     set<TSignedSeqPos>  offsets;
  159.     for (int i = 0;  i < 2;  ++i) {
  160.         const CInt_fuzz& f = i ? f2 : *this;
  161.         TSeqPos          n = i ? n2 : n1;
  163.         switch (f.Which()) {
  164.         case e_P_m:
  165.             min_delta -= f.GetP_m();
  166.             max_delta += f.GetP_m();
  167.             break;
  169.         case e_Range:
  170.             min_delta -= n - f.GetRange().GetMin();
  171.             max_delta += f.GetRange().GetMax() - n;
  172.             break;
  174.         case e_Pct:
  175.             min_delta -= 0.001 * n * f.GetPct();
  176.             max_delta += 0.001 * n * f.GetPct();
  177.             hit_pct = true;
  178.             break;
  180.         case e_Lim:
  181.             switch (f.GetLim()) {
  182.             case eLim_unk:
  183.                 hit_unk   = (!hit_unk  ||  mode != eReduce);
  184.                 min_delta = -kInfinity;
  185.                 // fall through
  186.             case eLim_gt:
  187.                 max_delta = kInfinity;
  188.                 break;
  189.             case eLim_lt:
  190.                 min_delta = -kInfinity;
  191.                 break;
  192.             case eLim_tr:
  193.                 min_delta += 0.5;
  194.                 max_delta += 0.5;
  195.                 break;
  196.             case eLim_tl:
  197.                 min_delta -= 0.5;
  198.                 max_delta -= 0.5;
  199.                 break;
  200.             case eLim_circle:
  201.                 hit_circle = (!hit_circle  ||  mode != eReduce);
  202.                 break;
  203.             default:
  204.                 break;
  205.             }
  206.             break;
  208.         case e_Alt:
  209.         {
  210.             if (f.GetAlt().empty()) {
  211.                 break;
  212.             }
  213.             if (offsets.empty()) {
  214.                 ITERATE (TAlt, it, f.GetAlt()) {
  215.                     offsets.insert(*it - n);
  216.                 }
  217.             } else if (mode == eReduce) {
  218.                 // possibly too optimistic; endpoints may balance better
  219.                 // than interior points
  220.                 min_delta = max_delta = f.GetAlt().front();
  221.                 ITERATE (TAlt, it, f.GetAlt()) {
  222.                     if (*it < min_delta) {
  223.                         min_delta = *it;
  224.                     } else if (*it > max_delta) {
  225.                         max_delta = *it;
  226.                     }
  227.                 }
  228.                 min_delta += *offsets.rbegin();
  229.                 max_delta += *offsets.begin();
  230.                 offsets.clear();
  231.             } else {
  232.                 set<TSignedSeqPos> offsets0(offsets);
  233.                 offsets.clear();
  234.                 ITERATE (set<TSignedSeqPos>, it, offsets0) {
  235.                     ITERATE (TAlt, it2, f.GetAlt()) {
  236.                         offsets.insert(*it + *it2 - n);
  237.                     }
  238.                 }
  239.             }
  240.             break;
  241.         }
  243.         default:
  244.             break;
  245.         }
  247.         if (mode == eReduce  &&  max_delta - min_delta < kInfinity / 2) {
  248.             swap(min_delta, max_delta);
  249.         }
  250.     }
  252.     if (min_delta > max_delta) {
  253.         swap(min_delta, max_delta);
  254.     }
  256.     TSignedSeqPos min_delta_sp = TSignedSeqPos(floor(min_delta + 0.5));
  257.     TSignedSeqPos max_delta_sp = TSignedSeqPos(floor(max_delta + 0.5));
  259.     if (min_delta < -kInfinity / 2) {
  260.         if (max_delta > kInfinity / 2) {
  261.             if ( /* mode == eReduce  && */ !hit_unk ) {
  262.                 // assume cancellation
  263.                 SetP_m(0);
  264.             } else {
  265.                 SetLim(eLim_unk);
  266.             }
  267.         } else {
  268.             if ( !offsets.empty() ) {
  269.                 n1 += *offsets.rbegin();
  270.             }
  271.             n1 += max_delta_sp;
  272.             SetLim(eLim_lt);
  273.         }
  274.     } else if (max_delta > kInfinity / 2) {
  275.         if ( !offsets.empty() ) {
  276.             n1 += *offsets.begin();
  277.         }
  278.         n1 += min_delta_sp;
  279.         SetLim(eLim_gt);
  280.     } else if ( !offsets.empty() ) {
  281.         if (max_delta - min_delta < 0.5) {
  282.             TAlt& alt = SetAlt();
  283.             alt.clear();
  284.             ITERATE(set<TSignedSeqPos>, it, offsets) {
  285.                 alt.push_back(n1 + *it + min_delta_sp);
  286.                 }
  287.         } else if (mode == eReduce) {
  288.             TRange& r = SetRange();
  289.             min_delta += *offsets.rbegin();
  290.             max_delta += *offsets.begin();
  291.             if (min_delta > max_delta) {
  292.                 swap(min_delta, max_delta);
  293.             }
  294.             r.SetMin(n1 + min_delta_sp);
  295.             r.SetMax(n1 + max_delta_sp);
  296.         } else {
  297.             // assume there's enough spread to cover any gaps
  298.                 TRange& r = SetRange();
  299.                 r.SetMin(n1 + min_delta_sp + *offsets.begin());
  300.                 r.SetMax(n1 + max_delta_sp + *offsets.rbegin());
  301.         }
  302.     } else if (max_delta - min_delta < 0.5) { // single point identified
  303.         double delta  = 0.5 * (min_delta + max_delta);
  304.         double rdelta = floor(delta + 0.5);
  305.         n1 += (TSignedSeqPos)rdelta;
  306.         if (delta - rdelta > 0.25) {
  307.             SetLim(eLim_tr);
  308.         } else if (delta - rdelta < -0.25) {
  309.             SetLim(eLim_tl);
  310.         } else if (hit_circle) {
  311.             SetLim(eLim_circle);
  312.         } else {
  313.             SetP_m(0);
  314.         }
  315.     } else if (hit_pct) {
  316.         n1 += (TSignedSeqPos)floor(0.5 * (min_delta + max_delta + 1));
  317.         SetPct((TSeqPos)floor(500.0 * (max_delta - min_delta) / n1 + 0.5));
  318.     } else if (min_delta + max_delta < 0.5) { // symmetric
  319.         SetP_m(max_delta_sp);
  320.     } else {
  321.         TRange& r = SetRange();
  322.         r.SetMin(n1 + min_delta_sp);
  323.         r.SetMax(n1 + max_delta_sp);
  324.     }
  325. }
  328. void CInt_fuzz::Negate(TSeqPos n)
  329. {
  330.     switch (Which()) {
  331.     case e_P_m:
  332.     case e_Pct:
  333.         break; // already symmetric
  335.     case e_Range:
  336.     {
  337.         TRange& r       = SetRange();
  338.         TSeqPos old_max = r.GetMax();
  339.         r.SetMax(n + n - r.GetMin());
  340.         r.SetMin(n + n - old_max);
  341.         break;
  342.     }
  344.     case e_Lim:
  345.         switch (GetLim()) {
  346.         case eLim_gt:  SetLim(eLim_lt);  break;
  347.         case eLim_lt:  SetLim(eLim_gt);  break;
  348.         case eLim_tr:  SetLim(eLim_tl);  break;
  349.         case eLim_tl:  SetLim(eLim_tr);  break;
  350.         default:       break;
  351.         }
  352.         break;
  354.     case e_Alt:
  355.         NON_CONST_ITERATE(TAlt, it, SetAlt()) {
  356.             *it = n + n - *it;
  357.         }
  358.         break;
  360.     default:
  361.         break;
  362.     }
  363. }
  366. END_objects_SCOPE // namespace ncbi::objects::
  368. END_NCBI_SCOPE
  370. /*
  371.  * ===========================================================================
  372.  *
  373.  * $Log: Int_fuzz.cpp,v $
  374.  * Revision 1000.2  2004/06/01 19:32:23  gouriano
  375.  * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R6.12
  376.  *
  377.  * Revision 6.12  2004/05/19 17:21:39  gorelenk
  378.  * Added include of PCH - ncbi_pch.hpp
  379.  *
  380.  * Revision 6.11  2004/04/12 16:51:46  vasilche
  381.  * Fixed conversion warnings.
  382.  *
  383.  * Revision 6.10  2004/01/06 14:36:06  dicuccio
  384.  * Removed unnecessary #include of ncbiapp.hpp and ncbireg.hpp.  Added <set> where
  385.  * needed.
  386.  *
  387.  * Revision 6.9  2003/10/15 19:07:09  ucko
  388.  * Fix some logic errors with lt/gt limits in CInt_fuzz::Add
  389.  *
  390.  * Revision 6.8  2003/10/15 17:37:15  ucko
  391.  * Fix a couple of instances of unintentional fall-through.
  392.  *
  393.  * Revision 6.7  2003/10/15 16:22:24  ucko
  394.  * Sigh, add missing parenthesis.
  395.  *
  396.  * Revision 6.6  2003/10/15 16:20:09  ucko
  397.  * portability fixes to use of double in CInt_fuzz::Add
  398.  *
  399.  * Revision 6.5  2003/10/15 15:43:07  ucko
  400.  * Add more operations: AssignTranslated, Add, Subtract, and Negate/Negative.
  401.  *
  402.  * Revision 6.4  2002/12/26 12:46:37  dicuccio
  403.  * Removed spurious dependency on Seq_point.hpp
  404.  *
  405.  * Revision 6.3  2002/10/08 18:52:21  clausen
  406.  * Changed TSeqPos from 0 based to 1 based in GetLabel()
  407.  *
  408.  * Revision 6.2  2002/10/03 19:11:02  clausen
  409.  * Removed extra whitespace
  410.  *
  411.  * Revision 6.1  2002/10/03 16:47:26  clausen
  412.  * Added GetLabel()
  413.  *
  414.  * ===========================================================================
  415.  */
  417. /* Original file checksum: lines: 61, chars: 1885, CRC32: bf6aceba */