Main Page | Class Hierarchy | Alphabetical List | Data Structures | File List | Data Fields | Globals

MRAmrange.h File Reference

#include <iostream.h>
#include "BufferBase.h"
#include "MRAmlevel.h"

Include dependency graph for MRAmrange.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Data Structures

class  MRAmrange

Functions

bool connected (MRAmrange, MRAmrange)
bool contains (MRAmrange, MRAmrange)
MRAmrange Difference (MRAmrange, MRAmrange)
bool disjoint (MRAmrange, MRAmrange)
bool equal (MRAmrange, MRAmrange)
bool interior (MRAmrange, MRAmrange)
MRAmrange Intersection (MRAmrange, MRAmrange)
MRAmrange operator * (MRAmrange lhs, MRAmrange rhs)
bool operator!= (MRAmrange lhs, MRAmrange rhs)
MRAmrange operator+ (MRAmrange lhs, MRAmrange rhs)
MRAmrange operator- (MRAmrange lhs, MRAmrange rhs)
bool operator< (MRAmrange lhs, MRAmrange rhs)
ostream & operator<< (ostream &os, MRAmrange &mrange)
BufferBase & operator<< (BufferBase &buffer, MRAmrange &mrange)
bool operator<= (MRAmrange lhs, MRAmrange rhs)
bool operator== (MRAmrange lhs, MRAmrange rhs)
bool operator> (MRAmrange lhs, MRAmrange rhs)
bool operator>= (MRAmrange lhs, MRAmrange rhs)
istream & operator>> (istream &is, MRAmrange &mrange)
BufferBase & operator>> (BufferBase &buffer, MRAmrange &mrange)
MRAmrange Union (MRAmrange, MRAmrange)

Function Documentation

bool connected (  MRAmrange  ,
MRAmrange 
) 
 

Definition at line 58 of file MRAmrange.cpp.

References MRAmrange._dim, MRAmrange.good(), MRAmrange.is_empty(), MRAmrange.mmax, and MRAmrange.mmin.

Referenced by Union(). 

00059 {
00060    if ( !lhs.good() || !rhs.good() || !lhs || !rhs ) return false;
00061    if ( lhs._dim != rhs._dim ) return false;
00062 //   if ( lhs.is_empty() || rhs.is_empty() ) return false;
00063    if ( lhs.is_empty() || rhs.is_empty() ) return true;
00064    if ( lhs <= rhs || lhs >= rhs ) return true;
00065    for( int d = 0; d < lhs._dim; ++d ) {
00066       if ( lhs.mmin[d] <= rhs.mmin[d] && lhs.mmax[d] >= rhs.mmin[d] - 1 )
00067           return true;
00068       if ( lhs.mmax[d] >= rhs.mmax[d] && lhs.mmin[d] <= rhs.mmax[d] + 1 )
00069           return true;
00070    }
00071    return false;
00072 }

bool contains (  MRAmrange  ,
MRAmrange 
) 
 

Definition at line 30 of file MRAmrange.cpp.

References MRAmrange._dim, MRAmrange.good(), MRAmrange.is_empty(), MRAmrange.mmax, and MRAmrange.mmin.

Referenced by operator<(), operator<=(), operator>(), and operator>=(). 

00031 {
00032    if ( !lhs.good() || !rhs.good() || !lhs || !rhs ) return false;
00033    if ( lhs._dim != rhs._dim ) return false;
00034    if ( rhs.is_empty() ) return true;
00035    if ( lhs.is_empty() ) return false;
00036    for( int d = 0; d < lhs._dim; ++d ) {
00037       if ( rhs.mmin[d] < lhs.mmin[d] || rhs.mmax[d] > lhs.mmax[d] )
00038           return false;
00039    }
00040    return true;
00041 }

MRAmrange Difference (  MRAmrange  ,
MRAmrange 
) 
 

Definition at line 142 of file MRAmrange.cpp.

References MRAmrange._dim, MRAmrange.clrstate(), disjoint(), MRAmrange.good(), interior(), MRAmrange.is_empty(), MRAmrange.mmax, MRAmrange.mmin, MRAmrange.set_empty(), and MRAmrange.setstate().

Referenced by operator-(). 

00143 {
00144    MRAmrange mrange;
00145    if ( !lhs.good() || !rhs.good() || !lhs || !rhs ) {
00146       mrange.clrstate(MRAmrange::goodbit);
00147       mrange.setstate(MRAmrange::failbit);
00148    } else if ( lhs._dim != rhs._dim ) {
00149       mrange.clrstate(MRAmrange::goodbit);
00150       mrange.setstate(MRAmrange::failbit);
00151       mrange.setstate(MRAmrange::baddimbit);
00152    } else if ( lhs.is_empty() ) {
00153       mrange = lhs;
00154    } else if ( rhs.is_empty() ) {
00155       mrange = rhs;
00156    } if ( disjoint( lhs, rhs ) ) {
00157       mrange = lhs;
00158    } if ( lhs == rhs ) {
00159       mrange(lhs._dim);
00160       mrange.set_empty();
00161    } if ( lhs < rhs ) {
00162       mrange(lhs._dim);
00163       mrange.set_empty();
00164    } if ( interior( lhs, rhs) ) {
00165       mrange.clrstate(MRAmrange::goodbit);
00166       mrange.setstate(MRAmrange::failbit);
00167       mrange.setstate(MRAmrange::fragbit);
00168    } else {
00169       if ( interior( rhs, lhs ) ) {
00170          mrange = lhs;
00171          mrange.clrstate(MRAmrange::goodbit);
00172          mrange.setstate(MRAmrange::failbit);
00173          mrange.setstate(MRAmrange::fragbit);
00174       } else {
00175          mrange = lhs; 
00176          for( int d = 0; d < lhs._dim; ++d ) {
00177             if ( rhs.mmin[d] > lhs.mmin[d] ) mrange.mmax[d] = rhs.mmin[d] - 1;
00178             if ( rhs.mmax[d] < lhs.mmax[d] ) mrange.mmin[d] = rhs.mmax[d] + 1;
00179          }
00180       }
00181    } 
00182    return mrange;
00183 }

bool disjoint (  MRAmrange  ,
MRAmrange 
) 
 

Definition at line 43 of file MRAmrange.cpp.

References MRAmrange._dim, MRAmrange.good(), MRAmrange.is_empty(), MRAmrange.mmax, and MRAmrange.mmin.

Referenced by Difference(), interior(), and Intersection(). 

00044 {
00045    if ( !lhs.good() || !rhs.good() || !lhs || !rhs ) return false;
00046    if ( lhs._dim != rhs._dim ) return false;
00047    if ( lhs.is_empty() || rhs.is_empty() ) return false;
00048    if ( lhs <= rhs || lhs >= rhs ) return false;
00049    for( int d = 0; d < lhs._dim; ++d ) {
00050       if ( lhs.mmin[d] < rhs.mmin[d] && lhs.mmax[d] < rhs.mmin[d] )
00051           return true;
00052       if ( lhs.mmin[d] > rhs.mmax[d] && lhs.mmax[d] > rhs.mmax[d] )
00053           return true;
00054    }
00055    return false;
00056 }

bool equal (  MRAmrange  ,
MRAmrange 
) 
 

Definition at line 21 of file MRAmrange.cpp.

References MRAmrange._dim, MRAmrange._state, MRAmrange.mmax, and MRAmrange.mmin.

Referenced by operator!=(), and operator==(). 

00022 {
00023    if ( lhs._state != rhs._state ) return false;
00024    if ( lhs._dim != rhs._dim ) return false;
00025    if ( lhs.mmin != rhs.mmin ) return false;
00026    if ( lhs.mmax != rhs.mmax ) return false;
00027    return true;
00028 }

bool interior (  MRAmrange  ,
MRAmrange 
) 
 

Definition at line 74 of file MRAmrange.cpp.

References MRAmrange._dim, disjoint(), MRAmrange.good(), MRAmrange.is_empty(), MRAmrange.mmax, and MRAmrange.mmin.

Referenced by Difference(). 

00075 {
00076    if ( !lhs.good() || !rhs.good() || !lhs || !rhs ) return false;
00077    if ( lhs._dim != rhs._dim ) return false;
00078    if ( lhs.is_empty() || rhs.is_empty() ) return false;
00079    if ( lhs >= rhs || disjoint( lhs, rhs ) ) return false;
00080    for( int d = 0; d < lhs._dim; ++d ) {
00081       if ( lhs.mmin[d] <= rhs.mmin[d] || lhs.mmax[d] >= rhs.mmax[d] )
00082           return false;
00083    }
00084    return true;
00085 }

MRAmrange Intersection (  MRAmrange  ,
MRAmrange 
) 
 

Definition at line 115 of file MRAmrange.cpp.

References MRAmrange._dim, MRAmrange.clrstate(), disjoint(), MRAmrange.good(), MRAmrange.is_empty(), MRAmrange.mmax, MRAmrange.mmin, MRAmrange.set_empty(), and MRAmrange.setstate().

Referenced by operator *(). 

00116 {
00117    MRAmrange mrange;
00118    if ( !lhs.good() || !rhs.good() || !lhs || !rhs ) {
00119       mrange.clrstate(MRAmrange::goodbit);
00120       mrange.setstate(MRAmrange::failbit);
00121    } else if ( lhs._dim != rhs._dim ) {
00122       mrange.clrstate(MRAmrange::goodbit);
00123       mrange.setstate(MRAmrange::failbit);
00124       mrange.setstate(MRAmrange::baddimbit);
00125    } else if ( lhs.is_empty() ) {
00126       mrange = lhs;
00127    } else if ( rhs.is_empty() ) {
00128       mrange = rhs;
00129    } if ( disjoint( lhs, rhs ) ) {
00130       mrange(lhs._dim);
00131       mrange.set_empty();
00132    } else {
00133       mrange = lhs;
00134       for( int d = 0; d < lhs._dim; ++d ) {
00135          if ( rhs.mmin[d] > mrange.mmin[d] ) mrange.mmin[d] = rhs.mmin[d];
00136          if ( rhs.mmax[d] < mrange.mmax[d] ) mrange.mmax[d] = rhs.mmax[d];
00137       }
00138    } 
00139    return mrange;
00140 }

MRAmrange operator * (  MRAmrange  lhs,
MRAmrange  rhs
) 
 

Definition at line 172 of file MRAmrange.h.

References Intersection(). 

00173 {
00174    return Intersection( lhs, rhs );
00175 }

bool operator!= (  MRAmrange  lhs,
MRAmrange  rhs
) 
 

Definition at line 124 of file MRAmrange.h.

References equal(). 

00125 {
00126    return !equal( rhs, lhs );
00127 }

MRAmrange operator+ (  MRAmrange  lhs,
MRAmrange  rhs
) 
 

Definition at line 164 of file MRAmrange.h.

References Union(). 

00165 {
00166    return Union( lhs, rhs );
00167 }

MRAmrange operator- (  MRAmrange  lhs,
MRAmrange  rhs
) 
 

Definition at line 180 of file MRAmrange.h.

References Difference(). 

00181 {
00182    return Difference( lhs, rhs );
00183 }

bool operator< (  MRAmrange  lhs,
MRAmrange  rhs
) 
 

Definition at line 132 of file MRAmrange.h.

References contains(). 

00133 {
00134    return contains( rhs, lhs ) && lhs != rhs;
00135 }

ostream& operator<< (  ostream &  os,
MRAmrange &  mrange
) 
 

Definition at line 481 of file MRAmrange.h.

References MRAmrange.read(). 

00482 {
00483    mrange.read(os);
00484    return os;
00485 }

BufferBase& operator<< (  BufferBase &  buffer,
MRAmrange &  mrange
) 
 

Definition at line 467 of file MRAmrange.h.

References MRAmrange.read(). 

00468 {
00469    mrange.read(buffer);
00470    return buffer;
00471 }

bool operator<= (  MRAmrange  lhs,
MRAmrange  rhs
) 
 

Definition at line 144 of file MRAmrange.h.

References contains(). 

00145 {
00146    return contains( rhs, lhs );
00147 }

bool operator== (  MRAmrange  lhs,
MRAmrange  rhs
) 
 

Definition at line 118 of file MRAmrange.h.

References equal(). 

00119 {
00120    return equal( rhs, lhs );
00121 }

bool operator> (  MRAmrange  lhs,
MRAmrange  rhs
) 
 

Definition at line 138 of file MRAmrange.h.

References contains(). 

00139 {
00140    return contains( lhs, rhs ) && lhs != rhs;
00141 }

bool operator>= (  MRAmrange  lhs,
MRAmrange  rhs
) 
 

Definition at line 150 of file MRAmrange.h.

References contains(). 

00151 {
00152    return contains( lhs, rhs );
00153 }

istream& operator>> (  istream &  is,
MRAmrange &  mrange
) 
 

Definition at line 474 of file MRAmrange.h.

References MRAmrange.write(). 

00475 {
00476    mrange.write(is);
00477    return is;
00478 }

BufferBase& operator>> (  BufferBase &  buffer,
MRAmrange &  mrange
) 
 

Definition at line 460 of file MRAmrange.h.

References MRAmrange.write(). 

00461 {
00462    mrange.write(buffer);
00463    return buffer;
00464 }

MRAmrange Union (  MRAmrange  ,
MRAmrange 
) 
 

Definition at line 87 of file MRAmrange.cpp.

References MRAmrange._dim, MRAmrange.clrstate(), connected(), MRAmrange.good(), MRAmrange.is_empty(), MRAmrange.mmax, MRAmrange.mmin, and MRAmrange.setstate().

Referenced by operator+(). 

00088 {
00089    MRAmrange mrange;
00090    if ( !lhs.good() || !rhs.good() || !lhs || !rhs ) {
00091       mrange.clrstate(MRAmrange::goodbit);
00092       mrange.setstate(MRAmrange::failbit);
00093    } else if ( lhs._dim != rhs._dim ) {
00094       mrange.clrstate(MRAmrange::goodbit);
00095       mrange.setstate(MRAmrange::failbit);
00096       mrange.setstate(MRAmrange::baddimbit);
00097    } else if ( rhs.is_empty() ) {
00098       mrange = lhs;
00099    } else if ( lhs.is_empty() ) {
00100       mrange = rhs;
00101    } if ( !connected( lhs, rhs ) ) {
00102       mrange.clrstate(MRAmrange::goodbit);
00103       mrange.setstate(MRAmrange::failbit);
00104       mrange.setstate(MRAmrange::fragbit);
00105    } else {
00106       mrange = lhs;
00107       for( int d = 0; d < lhs._dim; ++d ) {
00108          if ( rhs.mmin[d] < mrange.mmin[d] ) mrange.mmin[d] = rhs.mmin[d];
00109          if ( rhs.mmax[d] > mrange.mmin[d] ) mrange.mmax[d] = rhs.mmax[d];
00110       }
00111    } 
00112    return mrange;
00113 }

Generated on Mon May 31 21:40:19 2004 for SR2k4 Assembler by doxygen 1.3.6