MRAcrange.cpp

Go to the documentation of this file.

// MRAcrange.cpp
//////////////////////////////////////////////////////////////////////
//          (c) Copyright 2002 Brown Deer Technology, LLC.
//                        All rights reserved.
//////////////////////////////////////////////////////////////////////

#ifdef USE_STD
#include <iostream>
using namespace std;
#else
#include <iostream.h>
#endif

#include "BufferBase.h"
#include "MRAclevel.h"

#include "MRAcrange.h"

// ##### overloaded namespace functions #####

bool equal( MRAcrange lhs, MRAcrange rhs ) 
{
   if ( lhs._state != rhs._state ) return false;
   if ( lhs.cmin != rhs.cmin ) return false;
   if ( lhs.cmax != rhs.cmax ) return false;
   return true;
}

bool contains( MRAcrange lhs, MRAcrange rhs )
{
   if ( !lhs.good() || !rhs.good() || !lhs || !rhs ) return false;
   if ( rhs.is_empty() ) return true;
   if ( lhs.is_empty() ) return false;
   if ( int(rhs.cmin) < int(lhs.cmin) || int(rhs.cmax) > int(lhs.cmax) ) 
      return false;
   return true;
}

bool disjoint( MRAcrange lhs, MRAcrange rhs )
{
   if ( !lhs.good() || !rhs.good() || !lhs || !rhs ) return false;
   if ( lhs.is_empty() || rhs.is_empty() ) return false;
   if ( lhs <= rhs || lhs >= rhs ) return false;
   if ( int(lhs.cmin) < int(rhs.cmin) && int(lhs.cmax) < int(rhs.cmin) ) 
      return true;
   if ( int(lhs.cmin) > int(rhs.cmax) && int(lhs.cmax) > int(rhs.cmax) ) 
      return true;
   return false;
}

bool connected( MRAcrange lhs, MRAcrange rhs )
{
   if ( !lhs.good() || !rhs.good() || !lhs || !rhs ) return false;
   if ( lhs.is_empty() || rhs.is_empty() ) return false;
   if ( lhs <= rhs || lhs >= rhs ) return true;
   if ( int(lhs.cmin) <= int(rhs.cmin) && int(lhs.cmax) >= int(rhs.cmin) - 1 ) 
      return true;
   if ( int(lhs.cmax) >= int(rhs.cmax) && int(lhs.cmin) <= int(rhs.cmax) + 1 ) 
      return true;
   return false;
}

bool interior( MRAcrange lhs, MRAcrange rhs )
{
   if ( !lhs.good() || !rhs.good() || !lhs || !rhs ) return false;
   if ( lhs.is_empty() || rhs.is_empty() ) return false;
   if ( lhs >= rhs || disjoint( lhs, rhs ) ) return false;
   if ( int(lhs.cmin) <= int(rhs.cmin) || int(lhs.cmax) >= int(rhs.cmax) ) 
      return false;
   return true;
}

MRAcrange Union( MRAcrange lhs, MRAcrange rhs )
{
   MRAcrange crange;
   if ( !lhs.good() || !rhs.good() || !lhs || !rhs ) {
      crange.clrstate(MRAcrange::goodbit);
      crange.setstate(MRAcrange::failbit);
   } else if ( rhs.is_empty() ) {
      crange = lhs;
   } else if ( lhs.is_empty() ) {
      crange = rhs;
   } else if ( !connected( lhs, rhs ) ) {
      crange.clrstate(MRAcrange::goodbit);
      crange.setstate(MRAcrange::failbit);
      crange.setstate(MRAcrange::fragbit);
   } else {
      crange = lhs;
      if ( int(rhs.cmin) < int(crange.cmin) ) crange.cmin = rhs.cmin;
      if ( int(rhs.cmax) > int(crange.cmin) ) crange.cmax = rhs.cmax;
   } 
   return crange;
}

MRAcrange Intersection( MRAcrange lhs, MRAcrange rhs )
{
   MRAcrange crange;
   if ( !lhs.good() || !rhs.good() || !lhs || !rhs ) {
      crange.clrstate(MRAcrange::goodbit);
      crange.setstate(MRAcrange::failbit);
   } else if ( lhs.is_empty() ) {
      crange = lhs;
   } else if ( rhs.is_empty() ) {
      crange = rhs;
   } else if ( disjoint( lhs, rhs ) ) {
      crange.set_empty();
   } else {
      crange = lhs;
      if ( int(rhs.cmin) > int(crange.cmin) ) crange.cmin = rhs.cmin;
      if ( int(rhs.cmax) < int(crange.cmax) ) crange.cmax = rhs.cmax;
   } 
   return crange;
}

MRAcrange Difference( MRAcrange lhs, MRAcrange rhs )
{
   MRAcrange crange;
   if ( !lhs.good() || !rhs.good() || !lhs || !rhs ) {
      crange.clrstate(MRAcrange::goodbit);
      crange.setstate(MRAcrange::failbit);
   } else if ( lhs.is_empty() ) {
      crange = lhs;
   } else if ( rhs.is_empty() ) {
      crange = rhs;
   } else if ( disjoint( lhs, rhs ) ) {
      crange = lhs;
   } else if ( lhs == rhs ) {
      crange.set_empty();
   } else if ( lhs < rhs ) {
      crange.set_empty();
   } else if ( interior( lhs, rhs) ) {
      crange.clrstate(MRAcrange::goodbit);
      crange.setstate(MRAcrange::failbit);
      crange.setstate(MRAcrange::fragbit);
   } else {
      if ( interior( rhs, lhs ) ) {
         crange = lhs;
         crange.clrstate(MRAcrange::goodbit);
         crange.setstate(MRAcrange::failbit);
         crange.setstate(MRAcrange::fragbit);
      } else {
         crange = lhs; 
         if ( int(rhs.cmin) > int(lhs.cmin) ) crange.cmax = rhs.cmin - 1;
         if ( int(rhs.cmax) < int(lhs.cmax) ) crange.cmin = rhs.cmax + 1;
      }
   } 
   return crange;
}

// ##### class member functions #####

MRAcrange& MRAcrange::Union( MRAcrange rhs )
{
   if ( !good() || !rhs.good() || is_null() || !rhs ) {
      clrstate(MRAcrange::goodbit);
      setstate(MRAcrange::failbit);
   } else if ( rhs.is_empty() ) {
      return *this;
   } else if ( is_empty() ) {
      *this = rhs;
   } else if ( !connected( *this, rhs ) ) {
      clrstate(MRAcrange::goodbit);
      setstate(MRAcrange::failbit);
      setstate(MRAcrange::fragbit);
   } else {
      if ( int(rhs.cmin) < int(cmin) ) cmin = rhs.cmin;
      if ( int(rhs.cmax) > int(cmin) ) cmax = rhs.cmax;
   } 
   return *this;
}

MRAcrange& MRAcrange::Intersection( MRAcrange rhs )
{
   if ( !good() || !rhs.good() || is_null() || !rhs ) {
      clrstate(MRAcrange::goodbit);
      setstate(MRAcrange::failbit);
   } else if ( is_empty() ) {
      return *this;
   } else if ( rhs.is_empty() ) {
      *this = rhs;
   } else if ( disjoint( *this, rhs ) ) {
      set_empty();
   } else {
      if ( int(rhs.cmin) > int(cmin) ) cmin = rhs.cmin;
      if ( int(rhs.cmax) < int(cmax) ) cmax = rhs.cmax;
   } 
   return *this;
}

MRAcrange& MRAcrange::Difference( MRAcrange rhs )
{
   if ( !good() || !rhs.good() || is_null() || !rhs ) {
      clrstate(MRAcrange::goodbit);
      setstate(MRAcrange::failbit);
   } else if ( is_empty() ) {
      return *this;
   } else if ( rhs.is_empty() ) {
      *this = rhs;
   } else if ( disjoint( *this, rhs ) ) {
      return *this;;
   } else if ( *this == rhs ) {
      set_empty();
   } else if ( *this < rhs ) {
      set_empty();
   } else if ( interior( *this, rhs) ) {
      clrstate(MRAcrange::goodbit);
      setstate(MRAcrange::failbit);
      setstate(MRAcrange::fragbit);
   } else {
      if ( interior( rhs, *this ) ) {
         clrstate(MRAcrange::goodbit);
         setstate(MRAcrange::failbit);
         setstate(MRAcrange::fragbit);
      } else {
         if ( int(rhs.cmin) > int(cmin) ) cmax = rhs.cmin - 1;
         if ( int(rhs.cmax) < int(cmax) ) cmin = rhs.cmax + 1;
      }
   } 
   return *this;
}

---