MRAmrange.cpp

Go to the documentation of this file.

// MRAmrange.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 "MRAmlevel.h"

#include "MRAmrange.h"

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

bool equal( MRAmrange lhs, MRAmrange rhs ) 
{
   if ( lhs._state != rhs._state ) return false;
   if ( lhs._dim != rhs._dim ) return false;
   if ( lhs.mmin != rhs.mmin ) return false;
   if ( lhs.mmax != rhs.mmax ) return false;
   return true;
}

bool contains( MRAmrange lhs, MRAmrange rhs )
{
   if ( !lhs.good() || !rhs.good() || !lhs || !rhs ) return false;
   if ( lhs._dim != rhs._dim ) return false;
   if ( rhs.is_empty() ) return true;
   if ( lhs.is_empty() ) return false;
   for( int d = 0; d < lhs._dim; ++d ) {
      if ( rhs.mmin[d] < lhs.mmin[d] || rhs.mmax[d] > lhs.mmax[d] )
          return false;
   }
   return true;
}

bool disjoint( MRAmrange lhs, MRAmrange rhs )
{
   if ( !lhs.good() || !rhs.good() || !lhs || !rhs ) return false;
   if ( lhs._dim != rhs._dim ) return false;
   if ( lhs.is_empty() || rhs.is_empty() ) return false;
   if ( lhs <= rhs || lhs >= rhs ) return false;
   for( int d = 0; d < lhs._dim; ++d ) {
      if ( lhs.mmin[d] < rhs.mmin[d] && lhs.mmax[d] < rhs.mmin[d] )
          return true;
      if ( lhs.mmin[d] > rhs.mmax[d] && lhs.mmax[d] > rhs.mmax[d] )
          return true;
   }
   return false;
}

bool connected( MRAmrange lhs, MRAmrange rhs )
{
   if ( !lhs.good() || !rhs.good() || !lhs || !rhs ) return false;
   if ( lhs._dim != rhs._dim ) return false;
//   if ( lhs.is_empty() || rhs.is_empty() ) return false;
   if ( lhs.is_empty() || rhs.is_empty() ) return true;
   if ( lhs <= rhs || lhs >= rhs ) return true;
   for( int d = 0; d < lhs._dim; ++d ) {
      if ( lhs.mmin[d] <= rhs.mmin[d] && lhs.mmax[d] >= rhs.mmin[d] - 1 )
          return true;
      if ( lhs.mmax[d] >= rhs.mmax[d] && lhs.mmin[d] <= rhs.mmax[d] + 1 )
          return true;
   }
   return false;
}

bool interior( MRAmrange lhs, MRAmrange rhs )
{
   if ( !lhs.good() || !rhs.good() || !lhs || !rhs ) return false;
   if ( lhs._dim != rhs._dim ) return false;
   if ( lhs.is_empty() || rhs.is_empty() ) return false;
   if ( lhs >= rhs || disjoint( lhs, rhs ) ) return false;
   for( int d = 0; d < lhs._dim; ++d ) {
      if ( lhs.mmin[d] <= rhs.mmin[d] || lhs.mmax[d] >= rhs.mmax[d] )
          return false;
   }
   return true;
}

MRAmrange Union( MRAmrange lhs, MRAmrange rhs )
{
   MRAmrange mrange;
   if ( !lhs.good() || !rhs.good() || !lhs || !rhs ) {
      mrange.clrstate(MRAmrange::goodbit);
      mrange.setstate(MRAmrange::failbit);
   } else if ( lhs._dim != rhs._dim ) {
      mrange.clrstate(MRAmrange::goodbit);
      mrange.setstate(MRAmrange::failbit);
      mrange.setstate(MRAmrange::baddimbit);
   } else if ( rhs.is_empty() ) {
      mrange = lhs;
   } else if ( lhs.is_empty() ) {
      mrange = rhs;
   } if ( !connected( lhs, rhs ) ) {
      mrange.clrstate(MRAmrange::goodbit);
      mrange.setstate(MRAmrange::failbit);
      mrange.setstate(MRAmrange::fragbit);
   } else {
      mrange = lhs;
      for( int d = 0; d < lhs._dim; ++d ) {
         if ( rhs.mmin[d] < mrange.mmin[d] ) mrange.mmin[d] = rhs.mmin[d];
         if ( rhs.mmax[d] > mrange.mmin[d] ) mrange.mmax[d] = rhs.mmax[d];
      }
   } 
   return mrange;
}

MRAmrange Intersection( MRAmrange lhs, MRAmrange rhs )
{
   MRAmrange mrange;
   if ( !lhs.good() || !rhs.good() || !lhs || !rhs ) {
      mrange.clrstate(MRAmrange::goodbit);
      mrange.setstate(MRAmrange::failbit);
   } else if ( lhs._dim != rhs._dim ) {
      mrange.clrstate(MRAmrange::goodbit);
      mrange.setstate(MRAmrange::failbit);
      mrange.setstate(MRAmrange::baddimbit);
   } else if ( lhs.is_empty() ) {
      mrange = lhs;
   } else if ( rhs.is_empty() ) {
      mrange = rhs;
   } if ( disjoint( lhs, rhs ) ) {
      mrange(lhs._dim);
      mrange.set_empty();
   } else {
      mrange = lhs;
      for( int d = 0; d < lhs._dim; ++d ) {
         if ( rhs.mmin[d] > mrange.mmin[d] ) mrange.mmin[d] = rhs.mmin[d];
         if ( rhs.mmax[d] < mrange.mmax[d] ) mrange.mmax[d] = rhs.mmax[d];
      }
   } 
   return mrange;
}

MRAmrange Difference( MRAmrange lhs, MRAmrange rhs )
{
   MRAmrange mrange;
   if ( !lhs.good() || !rhs.good() || !lhs || !rhs ) {
      mrange.clrstate(MRAmrange::goodbit);
      mrange.setstate(MRAmrange::failbit);
   } else if ( lhs._dim != rhs._dim ) {
      mrange.clrstate(MRAmrange::goodbit);
      mrange.setstate(MRAmrange::failbit);
      mrange.setstate(MRAmrange::baddimbit);
   } else if ( lhs.is_empty() ) {
      mrange = lhs;
   } else if ( rhs.is_empty() ) {
      mrange = rhs;
   } if ( disjoint( lhs, rhs ) ) {
      mrange = lhs;
   } if ( lhs == rhs ) {
      mrange(lhs._dim);
      mrange.set_empty();
   } if ( lhs < rhs ) {
      mrange(lhs._dim);
      mrange.set_empty();
   } if ( interior( lhs, rhs) ) {
      mrange.clrstate(MRAmrange::goodbit);
      mrange.setstate(MRAmrange::failbit);
      mrange.setstate(MRAmrange::fragbit);
   } else {
      if ( interior( rhs, lhs ) ) {
         mrange = lhs;
         mrange.clrstate(MRAmrange::goodbit);
         mrange.setstate(MRAmrange::failbit);
         mrange.setstate(MRAmrange::fragbit);
      } else {
         mrange = lhs; 
         for( int d = 0; d < lhs._dim; ++d ) {
            if ( rhs.mmin[d] > lhs.mmin[d] ) mrange.mmax[d] = rhs.mmin[d] - 1;
            if ( rhs.mmax[d] < lhs.mmax[d] ) mrange.mmin[d] = rhs.mmax[d] + 1;
         }
      }
   } 
   return mrange;
}

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

MRAmrange& MRAmrange::Union( MRAmrange rhs )
{
   if ( !good() || !rhs.good() || is_null() || !rhs ) {
      clrstate(MRAmrange::goodbit);
      setstate(MRAmrange::failbit);
   } else if ( _dim != rhs._dim ) {
      clrstate(MRAmrange::goodbit);
      setstate(MRAmrange::failbit);
      setstate(MRAmrange::baddimbit);
   } else if ( rhs.is_empty() ) {
      return *this;
   } else if ( is_empty() ) {
      *this = rhs;
   } if ( !connected( *this, rhs ) ) {
      clrstate(MRAmrange::goodbit);
      setstate(MRAmrange::failbit);
      setstate(MRAmrange::fragbit);
   } else {
      for( int d = 0; d < _dim; ++d ) {
         if ( rhs.mmin[d] < mmin[d] ) mmin[d] = rhs.mmin[d];
         if ( rhs.mmax[d] > mmin[d] ) mmax[d] = rhs.mmax[d];
      }
   } 
   return *this;
}

MRAmrange& MRAmrange::Intersection( MRAmrange rhs )
{
   if ( !good() || !rhs.good() || is_null() || !rhs ) {
      clrstate(MRAmrange::goodbit);
      setstate(MRAmrange::failbit);
   } else if ( _dim != rhs._dim ) {
      clrstate(MRAmrange::goodbit);
      setstate(MRAmrange::failbit);
      setstate(MRAmrange::baddimbit);
   } else if ( is_empty() ) {
      return *this;
   } else if ( rhs.is_empty() ) {
      *this = rhs;
   } if ( disjoint( *this, rhs ) ) {
      set_empty();
   } else {
      for( int d = 0; d < _dim; ++d ) {
         if ( rhs.mmin[d] > mmin[d] ) mmin[d] = rhs.mmin[d];
         if ( rhs.mmax[d] < mmax[d] ) mmax[d] = rhs.mmax[d];
      }
   } 
   return *this;
}

MRAmrange& MRAmrange::Difference( MRAmrange rhs )
{
   if ( !good() || !rhs.good() || is_null() || !rhs ) {
      clrstate(MRAmrange::goodbit);
      setstate(MRAmrange::failbit);
   } else if ( _dim != rhs._dim ) {
      clrstate(MRAmrange::goodbit);
      setstate(MRAmrange::failbit);
      setstate(MRAmrange::baddimbit);
   } else if ( is_empty() ) {
      return *this;
   } else if ( rhs.is_empty() ) {
      *this = rhs;
   } if ( disjoint( *this, rhs ) ) {
      return *this;;
   } if ( *this == rhs ) {
      set_empty();
   } if ( *this < rhs ) {
      set_empty();
   } if ( interior( *this, rhs) ) {
      clrstate(MRAmrange::goodbit);
      setstate(MRAmrange::failbit);
      setstate(MRAmrange::fragbit);
   } else {
      if ( interior( rhs, *this ) ) {
         clrstate(MRAmrange::goodbit);
         setstate(MRAmrange::failbit);
         setstate(MRAmrange::fragbit);
      } else {
         for( int d = 0; d < _dim; ++d ) {
            if ( rhs.mmin[d] > mmin[d] ) mmax[d] = rhs.mmin[d] - 1;
            if ( rhs.mmax[d] < mmax[d] ) mmin[d] = rhs.mmax[d] + 1;
         }
      }
   }
   return *this;
}

---