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

MRAmrange Class Reference

#include <MRAmrange.h>

Collaboration diagram for MRAmrange:

Collaboration graph
[legend]

Public Member Functions

bool baddim ()
void clear ()
void clrstate (int)
MRAmrange & copy (const MRAmrange &)
MRAmrange & Difference (MRAmrange)
int dim ()
bool fail ()
bool frag ()
bool good ()
MRAmrange & Intersection (MRAmrange)
bool is_empty ()
bool is_null ()
 MRAmrange (MRAmlevel)
 MRAmrange (const MRAmlevel &mmin2, const MRAmlevel &mmax2)
 MRAmrange (int dim)
 MRAmrange ()
 MRAmrange (const MRAmrange &)
MRAmrange & operator *= (MRAmrange)
bool operator! ()
MRAmrange & operator() (const MRAmlevel &mmin2, const MRAmlevel &mmax2)
MRAmrange & operator() (int dim)
MRAmrange & operator() ()
MRAmrange & operator() (const MRAmrange &)
MRAmrange & operator+= (MRAmrange)
MRAmrange & operator-= (MRAmrange)
MRAmrange & operator<< (BufferBase &)
MRAmrange & operator= (const MRAmrange &)
MRAmrange & operator>> (BufferBase &)
int rdstate (int=0xFF)
void read (ostream &)
void read (BufferBase &)
void report (ostream &os=cout)
void set_empty ()
void set_null ()
void setstate (int)
int sizeb ()
MRAmrange & Union (MRAmrange)
void write (istream &)
void write (BufferBase &)

Data Fields

MRAmlevel mmax
MRAmlevel mmin

Static Public Attributes

const int baddimbit = 0x04
const int failbit = 0x02
const int fragbit = 0x08
const int goodbit = 0x01

Protected Attributes

int _dim
int _state

Friends

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, MRAmrange)
bool operator!= (MRAmrange, MRAmrange)
MRAmrange operator+ (MRAmrange, MRAmrange)
MRAmrange operator- (MRAmrange, MRAmrange)
bool operator< (MRAmrange, MRAmrange)
ostream & operator<< (ostream &, MRAmrange &)
BufferBase & operator<< (BufferBase &, MRAmrange &)
bool operator<= (MRAmrange, MRAmrange)
bool operator== (MRAmrange, MRAmrange)
bool operator> (MRAmrange, MRAmrange)
bool operator>= (MRAmrange, MRAmrange)
istream & operator>> (istream &, MRAmrange &)
BufferBase & operator>> (BufferBase &, MRAmrange &)
MRAmrange Union (MRAmrange, MRAmrange)

Constructor & Destructor Documentation

MRAmrange::MRAmrange (  const MRAmrange &   ) 
 

Definition at line 188 of file MRAmrange.h.

References _dim, _state, mmax, and mmin. 

00189 {
00190       _state = mrange._state;
00191       _dim = mrange._dim;
00192       mmin = mrange.mmin;
00193       mmax = mrange.mmax;
00194 }

MRAmrange::MRAmrange (   ) 
 

Definition at line 197 of file MRAmrange.h.

References mmax, and mmin. 

00198   : _state(0), _dim(0)
00199 {
00200    mmin();
00201    mmax();
00202 }

MRAmrange::MRAmrange (  int  dim  ) 
 

Definition at line 205 of file MRAmrange.h.

References mmax, and mmin. 

00206   : _state(goodbit), _dim(dim)
00207 {
00208    mmin(dim);
00209    mmax(dim);
00210 }

MRAmrange::MRAmrange (  const MRAmlevel &  mmin2,
const MRAmlevel &  mmax2
) 
 

Definition at line 213 of file MRAmrange.h.

References MRAmlevel._dim, baddimbit, goodbit, mmax, and mmin. 

00214 {
00215    if ( mmin2._dim != 0 && mmin2._dim == mmax2._dim ) {
00216       _state = goodbit;
00217       _dim = mmin2._dim;
00218       mmin = mmin2;
00219       mmax = mmax2;
00220    } else {
00221       _state &= !goodbit; _state |= baddimbit;
00222       _dim = 0;
00223       mmin();
00224       mmax();
00225    }
00226 }

MRAmrange::MRAmrange (  MRAmlevel   ) 
 

Definition at line 229 of file MRAmrange.h.

References MRAmlevel._dim, baddimbit, goodbit, mmax, and mmin. 

00230 {
00231    if ( mlevel._dim != 0 ) {
00232       _state = goodbit;
00233       _dim = mlevel._dim;
00234       mmin = mlevel;
00235       mmax = mlevel;
00236    } else {
00237       _state &= !goodbit; _state |= baddimbit;
00238       _dim = 0;
00239       mmin();
00240       mmax();
00241    }
00242 }

Member Function Documentation

bool MRAmrange::baddim (   ) 
 

Definition at line 370 of file MRAmrange.h.

References baddimbit, and rdstate().

Referenced by report(). 

00370 { return rdstate(baddimbit) != 0; }

void MRAmrange::clear (   ) 
 

Definition at line 352 of file MRAmrange.h.

References goodbit.

Referenced by operator()(), and set_empty(). 

00352 { _state = goodbit; }

void MRAmrange::clrstate (  int   ) 
 

Definition at line 358 of file MRAmrange.h.

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

00358 { _state &= ~s; }

MRAmrange & MRAmrange::copy (  const MRAmrange &   ) 
 

Definition at line 245 of file MRAmrange.h.

References _dim, _state, mmax, and mmin.

Referenced by operator=(). 

00246 {
00247    _state = mrange._state;
00248    _dim = mrange._dim;
00249    mmin = mrange.mmin;
00250    mmax = mrange.mmax;
00251    return *this;
00252 }

MRAmrange & MRAmrange::Difference (  MRAmrange   ) 
 

Definition at line 237 of file MRAmrange.cpp.

References _dim, baddimbit, clrstate(), disjoint, failbit, fragbit, good(), goodbit, interior, is_empty(), is_null(), mmax, mmin, set_empty(), and setstate().

Referenced by operator-=(). 

00238 {
00239    if ( !good() || !rhs.good() || is_null() || !rhs ) {
00240       clrstate(MRAmrange::goodbit);
00241       setstate(MRAmrange::failbit);
00242    } else if ( _dim != rhs._dim ) {
00243       clrstate(MRAmrange::goodbit);
00244       setstate(MRAmrange::failbit);
00245       setstate(MRAmrange::baddimbit);
00246    } else if ( is_empty() ) {
00247       return *this;
00248    } else if ( rhs.is_empty() ) {
00249       *this = rhs;
00250    } if ( disjoint( *this, rhs ) ) {
00251       return *this;;
00252    } if ( *this == rhs ) {
00253       set_empty();
00254    } if ( *this < rhs ) {
00255       set_empty();
00256    } if ( interior( *this, rhs) ) {
00257       clrstate(MRAmrange::goodbit);
00258       setstate(MRAmrange::failbit);
00259       setstate(MRAmrange::fragbit);
00260    } else {
00261       if ( interior( rhs, *this ) ) {
00262          clrstate(MRAmrange::goodbit);
00263          setstate(MRAmrange::failbit);
00264          setstate(MRAmrange::fragbit);
00265       } else {
00266          for( int d = 0; d < _dim; ++d ) {
00267             if ( rhs.mmin[d] > mmin[d] ) mmax[d] = rhs.mmin[d] - 1;
00268             if ( rhs.mmax[d] < mmax[d] ) mmin[d] = rhs.mmax[d] + 1;
00269          }
00270       }
00271    }
00272    return *this;
00273 }

int MRAmrange::dim (   ) 
 

Definition at line 394 of file MRAmrange.h.

Referenced by MRAmspec.MRAmspec(), and MRAmspec.operator()(). 

00394 { return _dim; }

bool MRAmrange::fail (   ) 
 

Definition at line 367 of file MRAmrange.h.

References failbit, and rdstate().

Referenced by report(). 

00367 { return rdstate(failbit) != 0; }

bool MRAmrange::frag (   ) 
 

Definition at line 373 of file MRAmrange.h.

References fragbit, and rdstate().

Referenced by report(). 

00373 { return rdstate(fragbit) != 0; }

bool MRAmrange::good (   ) 
 

Definition at line 364 of file MRAmrange.h.

References goodbit.

Referenced by connected(), contains(), Difference(), Difference(), disjoint(), interior(), Intersection(), Intersection(), is_empty(), report(), Union(), and Union(). 

00364 { return _state == goodbit; }

MRAmrange & MRAmrange::Intersection (  MRAmrange   ) 
 

Definition at line 213 of file MRAmrange.cpp.

References _dim, baddimbit, clrstate(), disjoint, failbit, good(), goodbit, is_empty(), is_null(), mmax, mmin, set_empty(), and setstate().

Referenced by operator *=(). 

00214 {
00215    if ( !good() || !rhs.good() || is_null() || !rhs ) {
00216       clrstate(MRAmrange::goodbit);
00217       setstate(MRAmrange::failbit);
00218    } else if ( _dim != rhs._dim ) {
00219       clrstate(MRAmrange::goodbit);
00220       setstate(MRAmrange::failbit);
00221       setstate(MRAmrange::baddimbit);
00222    } else if ( is_empty() ) {
00223       return *this;
00224    } else if ( rhs.is_empty() ) {
00225       *this = rhs;
00226    } if ( disjoint( *this, rhs ) ) {
00227       set_empty();
00228    } else {
00229       for( int d = 0; d < _dim; ++d ) {
00230          if ( rhs.mmin[d] > mmin[d] ) mmin[d] = rhs.mmin[d];
00231          if ( rhs.mmax[d] < mmax[d] ) mmax[d] = rhs.mmax[d];
00232       }
00233    } 
00234    return *this;
00235 }

bool MRAmrange::is_empty (   ) 
 

Definition at line 341 of file MRAmrange.h.

References failbit, good(), mmax, and setstate().

Referenced by connected(), contains(), Difference(), Difference(), disjoint(), interior(), Intersection(), Intersection(), Union(), and Union(). 

00342 {
00343    if ( good() ) {
00344       for( int d = 0; d < _dim; ++d ) if ( mmin[d] > mmax[d] ) return true;
00345    } else {
00346       setstate(failbit);
00347    }
00348    return false;
00349 }

bool MRAmrange::is_null (   ) 
 

Definition at line 316 of file MRAmrange.h.

Referenced by Difference(), Intersection(), operator!(), set_empty(), and Union(). 

00317 {
00318    if ( _dim == 0 ) return true;
00319    return false;
00320 }

MRAmrange & MRAmrange::operator *= (  MRAmrange   ) 
 

Definition at line 382 of file MRAmrange.h.

References Intersection(). 

00383 {
00384    return Intersection(rhs); 
00385 }

bool MRAmrange::operator! (   ) 
 

Definition at line 323 of file MRAmrange.h.

References is_null(). 

00324 {
00325    return is_null();
00326 }

MRAmrange & MRAmrange::operator() (  const MRAmlevel &  mmin2,
const MRAmlevel &  mmax2
) 
 

Definition at line 288 of file MRAmrange.h.

References MRAmlevel._dim, baddimbit, clear(), mmax, mmin, and setstate(). 

00291 { 
00292    if ( mmin2._dim != 0 && mmin2._dim == mmax2._dim ) {
00293       clear();
00294       _dim = mmin2._dim;
00295       mmin = mmin2;
00296       mmax = mmax2;
00297    } else {
00298       clear(); setstate(baddimbit);
00299       _dim = 0;
00300       mmin();
00301       mmax();
00302    }
00303    return *this;
00304 }

MRAmrange & MRAmrange::operator() (  int  dim  ) 
 

Definition at line 278 of file MRAmrange.h.

References clear(), mmax, and mmin. 

00279 { 
00280    clear();
00281    _dim = dim;
00282    mmin(dim); 
00283    mmax(dim); 
00284    return *this; 
00285 }

MRAmrange & MRAmrange::operator() (   ) 
 

Definition at line 268 of file MRAmrange.h.

References mmax, and mmin. 

00269 { 
00270    _state = 0;
00271    _dim = 0; 
00272    mmin();
00273    mmax(); 
00274    return *this; 
00275 }

MRAmrange & MRAmrange::operator() (  const MRAmrange &   ) 
 

Definition at line 258 of file MRAmrange.h.

References _dim, _state, mmax, and mmin. 

00259 { 
00260    _state = mrange._state;
00261    _dim = mrange._dim;
00262    mmin = mrange.mmin;
00263    mmax = mrange.mmax;
00264    return *this;
00265 }

MRAmrange & MRAmrange::operator+= (  MRAmrange   ) 
 

Definition at line 376 of file MRAmrange.h.

References Union(). 

00377 { 
00378    return Union(rhs); 
00379 }

MRAmrange & MRAmrange::operator-= (  MRAmrange   ) 
 

Definition at line 388 of file MRAmrange.h.

References Difference(). 

00389 { 
00390    return Difference(rhs); 
00391 }

MRAmrange & MRAmrange::operator<< (  BufferBase &   ) 
 

Definition at line 423 of file MRAmrange.h.

References write(). 

00424 {
00425    write(buffer);
00426    return *this;
00427 }

MRAmrange & MRAmrange::operator= (  const MRAmrange &   ) 
 

Definition at line 255 of file MRAmrange.h.

References copy(). 

00255 { return copy(rhs); }

MRAmrange & MRAmrange::operator>> (  BufferBase &   ) 
 

Definition at line 437 of file MRAmrange.h.

References read(). 

00438 {
00439    read(buffer);
00440    return *this;
00441 }

int MRAmrange::rdstate (  int  = 0xFF  ) 
 

Definition at line 361 of file MRAmrange.h.

Referenced by baddim(), fail(), and frag(). 

00361 { return (_state & s); }

void MRAmrange::read (  ostream &   ) 
 

Definition at line 451 of file MRAmrange.h.

References mmax, and mmin. 

00452 {
00453    os << mmin;
00454    os << mmax;
00455 }

void MRAmrange::read (  BufferBase &   ) 
 

Definition at line 430 of file MRAmrange.h.

References mmax, and mmin.

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

00431 {
00432    buffer << mmin;
00433    buffer << mmax;
00434 }

void MRAmrange::report (  ostream &  os = cout  ) 
 

Definition at line 400 of file MRAmrange.h.

References baddim(), fail(), frag(), good(), mmax, and mmin.

Referenced by MRAsbObject.check_mpart(), MRAmspec.report(), and MRAsbObject.set_mpart(). 

00400                                     {
00401    os << "MRAmrange::report(){\n";
00402    os << "state = " << _state << " = 0b0000"<<frag()<<baddim()<<fail()<<good()<< '\n';
00403    os << "dim = " << _dim;
00404    if ( _dim == 0 ) cout << " ==> is null\n";
00405    else cout << "\n";
00406    for( int d = 0; d < _dim; ++d ) {
00407       os << "mmin[] = " << mmin[d] 
00408          << " mmax[] = " << mmax[d];
00409       if ( mmin[d] > mmax[d] ) cout << " ==> is_empty\n";
00410       else cout << "\n";
00411    }
00412    os << "}\n";
00413 }

void MRAmrange::set_empty (   ) 
 

Definition at line 329 of file MRAmrange.h.

References clear(), failbit, is_null(), mmax, mmin, and setstate().

Referenced by Difference(), Difference(), Intersection(), Intersection(), MRAsbObject.MRAsbObject(), MRAsbObject.operator()(), and MRAsbObject.set_empty(). 

00330 {
00331    if ( !is_null() ) {
00332       clear();
00333       mmin = MRAmlevel::mmax_limit;
00334       mmax = MRAmlevel::mmin_limit;
00335    } else {
00336       setstate(failbit);
00337    }
00338 }

void MRAmrange::set_null (   ) 
 

Definition at line 307 of file MRAmrange.h.

References mmax, and mmin. 

00308 {
00309    _state = 0;
00310    _dim = 0;
00311    mmin();
00312    mmax();
00313 }

void MRAmrange::setstate (  int   ) 
 

Definition at line 355 of file MRAmrange.h.

Referenced by Difference(), Difference(), Intersection(), Intersection(), is_empty(), operator()(), set_empty(), Union(), and Union(). 

00355 { _state |= s; }

int MRAmrange::sizeb (   ) 
 

Definition at line 397 of file MRAmrange.h.

References mmax, mmin, and MRAmlevel.sizeb().

Referenced by MRAmspec.sizeb(). 

00397 { return mmin.sizeb() + mmax.sizeb(); }

MRAmrange & MRAmrange::Union (  MRAmrange   ) 
 

Definition at line 187 of file MRAmrange.cpp.

References _dim, baddimbit, clrstate(), connected, failbit, fragbit, good(), goodbit, is_empty(), is_null(), mmax, mmin, and setstate().

Referenced by operator+=(). 

00188 {
00189    if ( !good() || !rhs.good() || is_null() || !rhs ) {
00190       clrstate(MRAmrange::goodbit);
00191       setstate(MRAmrange::failbit);
00192    } else if ( _dim != rhs._dim ) {
00193       clrstate(MRAmrange::goodbit);
00194       setstate(MRAmrange::failbit);
00195       setstate(MRAmrange::baddimbit);
00196    } else if ( rhs.is_empty() ) {
00197       return *this;
00198    } else if ( is_empty() ) {
00199       *this = rhs;
00200    } if ( !connected( *this, rhs ) ) {
00201       clrstate(MRAmrange::goodbit);
00202       setstate(MRAmrange::failbit);
00203       setstate(MRAmrange::fragbit);
00204    } else {
00205       for( int d = 0; d < _dim; ++d ) {
00206          if ( rhs.mmin[d] < mmin[d] ) mmin[d] = rhs.mmin[d];
00207          if ( rhs.mmax[d] > mmin[d] ) mmax[d] = rhs.mmax[d];
00208       }
00209    } 
00210    return *this;
00211 }

void MRAmrange::write (  istream &   ) 
 

Definition at line 444 of file MRAmrange.h.

References mmax, and mmin. 

00445 {
00446    is >> mmin;
00447    is >> mmax;
00448 }

void MRAmrange::write (  BufferBase &   ) 
 

Definition at line 416 of file MRAmrange.h.

References mmax, and mmin.

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

00417 {
00418    buffer >> mmin;
00419    buffer >> mmax;
00420 }

Friends And Related Function Documentation

bool connected (  MRAmrange  ,
MRAmrange 
)  [friend]
 

Definition at line 58 of file MRAmrange.cpp.

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 
)  [friend]
 

Definition at line 30 of file MRAmrange.cpp. 

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 
)  [friend]
 

Definition at line 142 of file MRAmrange.cpp. 

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 
)  [friend]
 

Definition at line 43 of file MRAmrange.cpp.

Referenced by Difference(), 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 
)  [friend]
 

Definition at line 21 of file MRAmrange.cpp. 

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 
)  [friend]
 

Definition at line 74 of file MRAmrange.cpp.

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 
)  [friend]
 

Definition at line 115 of file MRAmrange.cpp. 

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
)  [friend]
 

Definition at line 172 of file MRAmrange.h. 

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

bool operator!= (  MRAmrange  lhs,
MRAmrange  rhs
)  [friend]
 

Definition at line 124 of file MRAmrange.h. 

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

MRAmrange operator+ (  MRAmrange  lhs,
MRAmrange  rhs
)  [friend]
 

Definition at line 164 of file MRAmrange.h. 

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

MRAmrange operator- (  MRAmrange  lhs,
MRAmrange  rhs
)  [friend]
 

Definition at line 180 of file MRAmrange.h. 

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

bool operator< (  MRAmrange  lhs,
MRAmrange  rhs
)  [friend]
 

Definition at line 132 of file MRAmrange.h. 

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

ostream& operator<< (  ostream &  os,
MRAmrange &  mrange
)  [friend]
 

Definition at line 481 of file MRAmrange.h. 

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

BufferBase& operator<< (  BufferBase &  buffer,
MRAmrange &  mrange
)  [friend]
 

Definition at line 467 of file MRAmrange.h. 

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

bool operator<= (  MRAmrange  lhs,
MRAmrange  rhs
)  [friend]
 

Definition at line 144 of file MRAmrange.h. 

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

bool operator== (  MRAmrange  lhs,
MRAmrange  rhs
)  [friend]
 

Definition at line 118 of file MRAmrange.h. 

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

bool operator> (  MRAmrange  lhs,
MRAmrange  rhs
)  [friend]
 

Definition at line 138 of file MRAmrange.h. 

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

bool operator>= (  MRAmrange  lhs,
MRAmrange  rhs
)  [friend]
 

Definition at line 150 of file MRAmrange.h. 

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

istream& operator>> (  istream &  is,
MRAmrange &  mrange
)  [friend]
 

Definition at line 474 of file MRAmrange.h. 

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

BufferBase& operator>> (  BufferBase &  buffer,
MRAmrange &  mrange
)  [friend]
 

Definition at line 460 of file MRAmrange.h. 

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

MRAmrange Union (  MRAmrange  ,
MRAmrange 
)  [friend]
 

Definition at line 87 of file MRAmrange.cpp. 

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 }

Field Documentation

int MRAmrange._dim [protected]
 

Definition at line 86 of file MRAmrange.h.

Referenced by connected(), contains(), copy(), Difference(), Difference(), disjoint(), equal(), interior(), Intersection(), Intersection(), MRAmrange(), operator()(), Union(), and Union().

int MRAmrange._state [protected]
 

Definition at line 85 of file MRAmrange.h.

Referenced by copy(), equal(), MRAmrange(), and operator()().

const int MRAmrange.baddimbit = 0x04 [static]
 

Definition at line 26 of file MRAmrange.h.

Referenced by baddim(), Difference(), Intersection(), MRAmrange(), operator()(), and Union().

const int MRAmrange.failbit = 0x02 [static]
 

Definition at line 25 of file MRAmrange.h.

Referenced by Difference(), fail(), Intersection(), is_empty(), set_empty(), and Union().

const int MRAmrange.fragbit = 0x08 [static]
 

Definition at line 27 of file MRAmrange.h.

Referenced by Difference(), frag(), and Union().

const int MRAmrange.goodbit = 0x01 [static]
 

Definition at line 24 of file MRAmrange.h.

Referenced by clear(), Difference(), good(), Intersection(), MRAmrange(), and Union().

MRAmlevel MRAmrange.mmax
 

Definition at line 29 of file MRAmrange.h.

Referenced by connected(), contains(), copy(), Difference(), Difference(), disjoint(), equal(), interior(), Intersection(), Intersection(), is_empty(), MRAsbObject.mpart(), MRAmrange(), operator()(), read(), report(), set_empty(), MRAsbBase.set_mspec(), MCFTPrequest.set_mspec(), MCFTPquote.set_mspec(), set_null(), sizeb(), Union(), Union(), and write().

MRAmlevel MRAmrange.mmin
 

Definition at line 29 of file MRAmrange.h.

Referenced by connected(), contains(), copy(), Difference(), Difference(), disjoint(), equal(), interior(), Intersection(), Intersection(), MRAmrange(), operator()(), read(), report(), set_empty(), MRAsbBase.set_mspec(), MCFTPrequest.set_mspec(), MCFTPquote.set_mspec(), set_null(), sizeb(), Union(), Union(), and write().

The documentation for this class was generated from the following files:
Generated on Mon May 31 21:41:28 2004 for SR2k4 Assembler by doxygen 1.3.6