Interval.cpp
上传用户:romrleung
上传日期:2022-05-23
资源大小:18897k
文件大小:3k
源码类别:

MySQL数据库

开发平台:

Visual C++

  1. /* Copyright (C) 2003 MySQL AB
  2.    This program is free software; you can redistribute it and/or modify
  3.    it under the terms of the GNU General Public License as published by
  4.    the Free Software Foundation; either version 2 of the License, or
  5.    (at your option) any later version.
  6.    This program is distributed in the hope that it will be useful,
  7.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  8.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  9.    GNU General Public License for more details.
  10.    You should have received a copy of the GNU General Public License
  11.    along with this program; if not, write to the Free Software
  12.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  13. #include "Interval.hpp"
  14. #undef min
  15. #undef max
  16. Uint32 max(Uint32 a, Uint32 b)  { return a > b ? a : b; }
  17. Uint32 min(Uint32 a, Uint32 b)  { return a < b ? a : b; }
  18. Interval::Interval() 
  19.   set(1, 0); // EmptyInterval
  20. }
  21. Interval::Interval(Uint32 f, Uint32 l) 
  22.   set(f, l); 
  23. }
  24. bool
  25. Interval::isEmpty() const 
  26. {
  27.   return (m_first > m_last) ? true : false; 
  28. }
  29. bool 
  30. Interval::isEqual(Uint32 a, Uint32 b) const 
  31. {
  32.   return (a==m_first && b==m_last);
  33. }
  34. bool 
  35. Interval::inInterval(Uint32 a) const 
  36. {
  37.   return (m_first <= a && a <= m_last);
  38. }
  39. void 
  40. Interval::set(Uint32 first, Uint32 last) 
  41. {
  42.   m_first = first;
  43.   m_last = last;
  44.   normalize();
  45. }
  46. void 
  47. Interval::set(const Interval i) 
  48. {
  49.   m_first = i.first();
  50.   m_last = i.last();
  51.   normalize();
  52. }
  53. void 
  54. Interval::setFirst(Uint32 first) 
  55.   m_first = first; 
  56. }
  57. void
  58. Interval::setLast(Uint32 last) 
  59.   m_last = last; 
  60. }
  61. void
  62. Interval::onlyLeft(Uint32 n) 
  63. {
  64.   if (size() > n) m_last = m_first + n - 1;
  65. }  
  66. void
  67. Interval::onlyUpToValue(Uint32 n) 
  68. {
  69.   m_last = min(n, m_last);
  70.   normalize();
  71. }
  72. /*****************************************************************************/
  73. void 
  74. Interval::normalize() 
  75. {
  76.   if (isEmpty()) {
  77.     m_first = 1;
  78.     m_last = 0;
  79.   }
  80. }
  81. /*****************************************************************************/
  82. bool 
  83. intervalAdd(const Interval a, const Interval b, Interval * r) 
  84. {
  85.   /**
  86.    * Non-empty disjoint intervals
  87.    */
  88.   if (!a.isEmpty() &&
  89.       !b.isEmpty() && 
  90.       (a.last() + 1 < b.first() || 
  91.        b.last() + 1 < a.first()) ) {
  92.     return false; // Illegal add
  93.   }
  94.   
  95.   /**
  96.    * Interval A empty -> return B
  97.    */
  98.   if (a.isEmpty()) { 
  99.     r->set(b); 
  100.     return true; 
  101.   }
  102.   /**
  103.    * Interval B empty -> return A
  104.    */
  105.   if (b.isEmpty()) { 
  106.     r->set(a); 
  107.     return true; 
  108.   }
  109.   
  110.   r->set(min(a.first(), b.first()), 
  111.  max(a.last(), b.last()));
  112.   return true;
  113. }
  114. /**
  115.  * Subtract the left part of interval 'a' up to last of 'b'.
  116.  *
  117.  * @note  This is NOT ordinary arithmetic interval minus.
  118.  *        In ordinary arithmetic, [11-25] - [12-15] would be undefined,
  119.  *        but here it is [11-25] - [12-15] = [16-25].
  120.  */
  121. void
  122. intervalLeftMinus(const Interval a, const Interval b, Interval * r) 
  123. {
  124.   if(b.last() != intervalMax)
  125.     r->set(max(a.first(), b.last()+1), a.last());
  126.   else 
  127.     r->set(max(a.first(), intervalMax), a.last());
  128. }
  129. void
  130. intervalCut(const Interval a, const Interval b, Interval * r) 
  131. {
  132.   r->set(max(a.first(), b.first()), min(a.last(), b.last()));
  133.   r->normalize();
  134. }
  135. bool 
  136. intervalDisjoint(const Interval a, const Interval b) 
  137. {
  138.   return (a.isEmpty() || 
  139.   b.isEmpty() || 
  140.   a.last() < b.first() || 
  141.   b.last() < a.first());
  142. }