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

MRAmrange.cpp File Reference

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

Include dependency graph for MRAmrange.cpp:

Include dependency graph

Go to the source code of this file.

Functions

bool connected (MRAmrange lhs, MRAmrange rhs)
bool contains (MRAmrange lhs, MRAmrange rhs)
MRAmrange Difference (MRAmrange lhs, MRAmrange rhs)
bool disjoint (MRAmrange lhs, MRAmrange rhs)
bool equal (MRAmrange lhs, MRAmrange rhs)
bool interior (MRAmrange lhs, MRAmrange rhs)
MRAmrange Intersection (MRAmrange lhs, MRAmrange rhs)
MRAmrange Union (MRAmrange lhs, MRAmrange rhs)

Function Documentation

bool connected (  MRAmrange  lhs,
MRAmrange  rhs
) 
 

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  lhs,
MRAmrange  rhs
) 
 

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  lhs,
MRAmrange  rhs
) 
 

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  lhs,
MRAmrange  rhs
) 
 

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  lhs,
MRAmrange  rhs
) 
 

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  lhs,
MRAmrange  rhs
) 
 

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  lhs,
MRAmrange  rhs
) 
 

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 Union (  MRAmrange  lhs,
MRAmrange  rhs
) 
 

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:18 2004 for SR2k4 Assembler by doxygen 1.3.6