AMRParticlePaths: IntVect.H Source File

00001 /*
00002 ** (c) 1996-2000 The Regents of the University of California (through
00003 ** E.O. Lawrence Berkeley National Laboratory), subject to approval by
00004 ** the U.S. Department of Energy.  Your use of this software is under
00005 ** license -- the license agreement is attached and included in the
00006 ** directory as license.txt or you may contact Berkeley Lab's Technology
00007 ** Transfer Department at TTD@lbl.gov.  NOTICE OF U.S. GOVERNMENT RIGHTS.
00008 ** The Software was developed under funding from the U.S. Government
00009 ** which consequently retains certain rights as follows: the
00010 ** U.S. Government has been granted for itself and others acting on its
00011 ** behalf a paid-up, nonexclusive, irrevocable, worldwide license in the
00012 ** Software to reproduce, prepare derivative works, and perform publicly
00013 ** and display publicly.  Beginning five (5) years after the date
00014 ** permission to assert copyright is obtained from the U.S. Department of
00015 ** Energy, and subject to any subsequent five (5) year renewals, the
00016 ** U.S. Government is granted for itself and others acting on its behalf
00017 ** a paid-up, nonexclusive, irrevocable, worldwide license in the
00018 ** Software to reproduce, prepare derivative works, distribute copies to
00019 ** the public, perform publicly and display publicly, and to permit
00020 ** others to do so.
00021 */
00022 
00023 #ifndef BL_INTVECT_H
00024 #define BL_INTVECT_H
00025 //
00026 // $Id: IntVect.H,v 1.21 2001/10/10 20:12:44 car Exp $
00027 //
00028 #include <iosfwd>
00029 
00030 #include <ccse-mpi.H>
00031 #include <SPACE.H>
00032 #include <Array.H>
00033 #include <BLassert.H>
00034 
00035 //
00036 // :
00038 
00047 class IntVect;
00048 
00049 namespace BoxLib
00050 {
00055     IntVect BASISV (int dir);
00056 
00060     IntVect min (const IntVect& p1, const IntVect& p2);
00061 
00065     IntVect max (const IntVect& p1, const IntVect& p2);
00066 
00070     IntVect scale (const IntVect& p, int s);
00071 
00076     IntVect reflect(const IntVect& a, int ref_ix, int idir);
00077 
00081     IntVect diagShift (const IntVect& p, int s);
00082 
00086     IntVect coarsen (const IntVect& p, int s);
00087 
00091     IntVect coarsen (const IntVect& p1, const IntVect& p2);
00092 }
00093 //
00095 //
00096 IntVect operator+ (int s, const IntVect& p);
00097 //
00099 //
00100 IntVect operator- (int s, const IntVect& p);
00101 //
00103 //
00104 IntVect operator* (int s, const IntVect& p);
00105 //
00107 //
00108 std::ostream& operator<< (std::ostream&  os, const IntVect& iv);
00109 //
00111 //
00112 std::istream& operator>> (std::istream& os, IntVect& iv);
00113     
00114 
00115 class IntVect
00116 {
00117     friend MPI_Datatype ParallelDescriptor::Mpi_typemap<IntVect>::type();
00118 public:
00119     //
00121     //
00122     IntVect ();
00123 
00128     IntVect (D_DECL(int i, int j, int k));
00129 
00133     explicit IntVect (const int* a);
00134 
00139     explicit IntVect (const Array<int>& a);
00140     //
00142     //
00143     IntVect (const IntVect& rhs);
00144     //
00146     //
00147     IntVect& operator= (const IntVect& rhs);
00148     //
00150     //
00151     int& operator[] (int i);
00152     //
00154     //
00155     int operator[] (int i) const;
00156     //
00158     //
00159     IntVect& setVal (int i,
00160                      int val);
00161 
00165     const int* getVect () const;
00166 
00170     bool operator== (const IntVect& p) const;
00171 
00175     bool operator!= (const IntVect& p) const;
00176 
00180     bool operator< (const IntVect& p) const;
00181 
00186     bool operator<= (const IntVect& p) const;
00187 
00191     bool operator> (const IntVect& p) const;
00192 
00197     bool operator>= (const IntVect& p) const;
00198 
00202     bool lexLT (const IntVect& s) const;
00203 
00207     bool lexGT (const IntVect& s) const;
00208     //
00210     //
00211     IntVect operator+ () const;
00212     //
00214     //
00215     IntVect operator- () const;
00216     //
00218     //
00219     IntVect& operator+= (int s);
00220     //
00222     //
00223     IntVect& operator+= (const IntVect& p);
00224 
00228     IntVect& operator*= (int s);
00229     //
00231     //
00232     IntVect& operator*= (const IntVect& p);
00233     //
00235     //
00236     IntVect& operator/= (int s);
00237     //
00239     //
00240     IntVect& operator/= (const IntVect& p);
00241     //
00243     //
00244     IntVect& operator-= (int s);
00245     //
00247     //
00248     IntVect& operator-= (const IntVect& p);
00249     //
00251     //
00252     IntVect operator+ (const IntVect& p) const;
00253     //
00255     //
00256     IntVect operator+ (int s) const;
00257     //
00259     //
00260     IntVect operator- (const IntVect& p) const;
00261     //
00263     //
00264     IntVect operator- (int s) const;
00265     //
00267     //
00268     IntVect operator* (const IntVect& p) const;
00269     //
00271     //
00272     IntVect operator* (int s) const;
00273     //
00275     //
00276     IntVect operator/ (const IntVect& p) const;
00277     //
00279     //
00280     IntVect operator/ (int s) const;
00281     //
00283     //
00284     IntVect& min (const IntVect& p);
00285     //
00287     //
00288     IntVect& max (const IntVect& p);
00289     //
00291     //
00292     IntVect& scale (int s);
00293 
00297     IntVect& reflect (int ref_ix,
00298                       int idir);
00299     //
00301     //
00302     IntVect& shift (int coord,
00303                     int s);
00304     //
00306     //
00307     IntVect& shift (const IntVect& iv);
00308     //
00310     //
00311     IntVect& diagShift (int s);
00312     //
00314     //
00315     IntVect& coarsen (const IntVect& p);
00316     //
00318     //
00319     IntVect& coarsen (int p);
00320 
00327     static const IntVect& TheZeroVector ();
00328 
00335     static const IntVect& TheUnitVector ();
00336 
00342     static const IntVect& TheNodeVector ();
00343 
00349     static const IntVect& TheCellVector ();
00350 
00351 protected:
00352 
00353     int vect[BL_SPACEDIM];
00354 };
00355 
00356 inline
00357 IntVect::IntVect ()
00358 {
00359     D_EXPR(vect[0] = 0, vect[1] = 0, vect[2] = 0);
00360 }
00361 
00362 inline
00363 IntVect::IntVect (D_DECL(int i, int j, int k))
00364 {
00365     D_EXPR(vect[0] = i, vect[1] = j, vect[2] = k);
00366 }
00367 
00368 inline
00369 IntVect::IntVect (const IntVect &iv)
00370 {
00371     D_EXPR(vect[0]=iv.vect[0], vect[1]=iv.vect[1], vect[2]=iv.vect[2]);
00372 }
00373 
00374 inline
00375 IntVect&
00376 IntVect::operator= (const IntVect &iv)
00377 {
00378     D_EXPR(vect[0]=iv.vect[0], vect[1]=iv.vect[1], vect[2]=iv.vect[2]);
00379     return *this;
00380 }
00381 
00382 inline
00383 int&
00384 IntVect::operator[] (int i)
00385 {
00386     BL_ASSERT(i>=0 && i < BL_SPACEDIM);
00387     return vect[i];
00388 }
00389 
00390 inline
00391 int
00392 IntVect::operator[] (int i) const
00393 {
00394     BL_ASSERT(i>=0 && i < BL_SPACEDIM);
00395     return vect[i];
00396 }
00397 
00398 inline
00399 const int*
00400 IntVect::getVect () const
00401 {
00402     return vect;
00403 }
00404 
00405 inline
00406 IntVect&
00407 IntVect::setVal (int i,
00408                  int val)
00409 {
00410     BL_ASSERT(i >=0 && i < BL_SPACEDIM);
00411     vect[i] = val;
00412     return *this;
00413 }
00414 
00415 inline
00416 bool
00417 IntVect::operator== (const IntVect& p) const
00418 {
00419     return D_TERM(vect[0] == p[0], && vect[1] == p[1], && vect[2] == p[2]);
00420 }
00421 
00422 inline
00423 bool
00424 IntVect::operator!= (const IntVect& p) const
00425 {
00426     return D_TERM(vect[0] != p[0], || vect[1] != p[1], || vect[2] != p[2]);
00427 }
00428 
00429 inline
00430 bool
00431 IntVect::operator< (const IntVect& p) const
00432 {
00433     return D_TERM(vect[0] < p[0], && vect[1] < p[1], && vect[2] < p[2]);
00434 }
00435 
00436 inline
00437 bool
00438 IntVect::operator<= (const IntVect& p) const
00439 {
00440     return D_TERM(vect[0] <= p[0], && vect[1] <= p[1], && vect[2] <= p[2]);
00441 }
00442 
00443 inline
00444 bool
00445 IntVect::operator> (const IntVect& p) const
00446 {
00447     return D_TERM(vect[0] > p[0], && vect[1] > p[1], && vect[2] > p[2]);
00448 }
00449 
00450 inline
00451 bool
00452 IntVect::operator>= (const IntVect& p) const
00453 {
00454     return D_TERM(vect[0] >= p[0], && vect[1] >= p[1], && vect[2] >= p[2]);
00455 }
00456 
00457 inline
00458 IntVect
00459 IntVect::operator+ () const
00460 {
00461     return *this;
00462 }
00463 
00464 inline
00465 IntVect
00466 IntVect::operator- () const
00467 {
00468     return IntVect(D_DECL(-vect[0], -vect[1], -vect[2] ));
00469 }
00470 
00471 inline
00472 IntVect&
00473 IntVect::operator+= (int s)
00474 {
00475     D_EXPR(vect[0] += s, vect[1] += s, vect[2] += s);
00476     return *this;
00477 }
00478 
00479 inline
00480 IntVect&
00481 IntVect::operator+= (const IntVect& p)
00482 {
00483     D_EXPR(vect[0] += p[0], vect[1] += p[1], vect[2] += p[2]);
00484     return *this;
00485 }
00486 
00487 inline
00488 IntVect&
00489 IntVect::operator*= (int s)
00490 {
00491     D_EXPR(vect[0] *= s, vect[1] *= s, vect[2] *= s);
00492     return *this;
00493 }
00494 
00495 inline
00496 IntVect&
00497 IntVect::operator*= (const IntVect &p)
00498 {
00499     D_EXPR(vect[0] *= p[0], vect[1] *= p[1], vect[2] *= p[2]);
00500     return *this;
00501 }
00502 
00503 inline
00504 IntVect&
00505 IntVect::operator/= (int s)
00506 {
00507     D_EXPR(vect[0] /= s, vect[1] /= s, vect[2] /= s);
00508     return *this;
00509 }
00510 
00511 inline
00512 IntVect&
00513 IntVect::operator/= (const IntVect& p)
00514 {
00515     D_EXPR(vect[0] /= p[0], vect[1] /= p[1], vect[2] /= p[2]);
00516     return *this;
00517 }
00518 
00519 inline
00520 IntVect&
00521 IntVect::operator-= (int s)
00522 {
00523     D_EXPR(vect[0] -= s, vect[1] -= s, vect[2] -= s);
00524     return *this;
00525 }
00526 
00527 inline
00528 IntVect&
00529 IntVect::operator-= (const IntVect& p)
00530 {
00531     D_EXPR(vect[0] -= p[0], vect[1] -= p[1], vect[2] -= p[2]);
00532     return *this;
00533 }
00534 
00535 inline
00536 IntVect
00537 IntVect::operator+ (const IntVect& p) const
00538 {
00539     return IntVect(D_DECL(vect[0] + p[0], vect[1] + p[1], vect[2] + p[2]));
00540 }
00541 
00542 inline
00543 IntVect
00544 IntVect::operator+ (int s) const
00545 {
00546     return IntVect(D_DECL(vect[0] + s, vect[1] + s, vect[2] + s));
00547 }
00548 
00549 inline
00550 IntVect
00551 IntVect::operator- (const IntVect& p) const
00552 {
00553     return IntVect(D_DECL(vect[0] - p[0], vect[1] - p[1], vect[2] - p[2]));
00554 }
00555 
00556 inline
00557 IntVect
00558 IntVect::operator- (int s) const
00559 {
00560     return IntVect(D_DECL(vect[0] - s, vect[1] - s, vect[2] - s));
00561 }
00562 
00563 inline
00564 IntVect
00565 IntVect::operator* (const IntVect& p) const
00566 {
00567     return IntVect(D_DECL(vect[0] * p[0], vect[1] * p[1], vect[2] * p[2]));
00568 }
00569 
00570 inline
00571 IntVect
00572 IntVect::operator* (int s) const
00573 {
00574     return IntVect(D_DECL(vect[0] * s, vect[1] * s, vect[2] * s));
00575 }
00576 
00577 inline
00578 IntVect
00579 IntVect::operator/ (const IntVect& p) const
00580 {
00581     return IntVect(D_DECL(vect[0] / p[0], vect[1] / p[1], vect[2] / p[2]));
00582 }
00583 
00584 inline
00585 IntVect
00586 IntVect::operator/ (int s) const
00587 {
00588     return IntVect(D_DECL(vect[0] / s, vect[1] / s, vect[2] / s));
00589 }
00590 
00591 #endif /*BL_INTVECT_H*/