IntVector.h

#ifndef UTIL_INT_VECTOR_H
#define UTIL_INT_VECTOR_H
 
/*
* Util Package - C++ Utilities for Scientific Computation
*
* Copyright 2010 - 2017, The Regents of the University of Minnesota
* Distributed under the terms of the GNU General Public License.
*/
 
#include <util/global.h>
#include <util/space/Dimension.h>
#ifdef UTIL_MPI
#include <util/mpi/MpiTraits.h>
#endif
 
#include <iostream>
 
namespace Util
{
 
   class IntVector
   {
 
   public:
 
 
      
      IntVector()
      {}
 
      IntVector(const IntVector& v)
      {
         elem_[0] = v.elem_[0];
         elem_[1] = v.elem_[1];
         elem_[2] = v.elem_[2];
      }
 
      explicit IntVector(int scalar)
      {
         elem_[0] = scalar;
         elem_[1] = scalar;
         elem_[2] = scalar;
      }
 
      explicit IntVector(const int* v)
      {
         elem_[0] = v[0];
         elem_[1] = v[1];
         elem_[2] = v[2];
      }
 
      IntVector(int x, int y, int z = 0)
      {
         elem_[0] = x;
         elem_[1] = y;
         elem_[2] = z;
      }
 
      
      IntVector& zero()
      {
         elem_[0] = 0;
         elem_[1] = 0;
         elem_[2] = 0;
         return *this;
      }
 
      template <class Archive>
      void serialize(Archive& ar, const unsigned int version);
 
 
      
      IntVector& operator=(const IntVector& v)
      {
         elem_[0] = v.elem_[0];
         elem_[1] = v.elem_[1];
         elem_[2] = v.elem_[2];
         return *this;
      }
 
      IntVector& operator=(const int* v)
      {
         elem_[0] = v[0];
         elem_[1] = v[1];
         elem_[2] = v[2];
         return *this;
      }
 
 
      
      void operator+=(const IntVector& dv)
      {
         elem_[0] += dv.elem_[0];
         elem_[1] += dv.elem_[1];
         elem_[2] += dv.elem_[2];
      }
 
      void operator-=(const IntVector& dv)
      {
         elem_[0] -= dv.elem_[0];
         elem_[1] -= dv.elem_[1];
         elem_[2] -= dv.elem_[2];
      }
 
      void operator*=(int s)
      {
         elem_[0] *= s;
         elem_[1] *= s;
         elem_[2] *= s;
      }
 
 
      
      const int& operator[](int i) const
      {
         assert(i >= 0);      
         assert(i < Dimension);      
         return elem_[i]; 
      }
 
      int& operator[](int i)
      { 
         assert(i >= 0);      
         assert(i < Dimension);      
         return elem_[i]; 
      }
 
 
      
      int square() const
      {  return elem_[0]*elem_[0] + elem_[1]*elem_[1] + elem_[2]*elem_[2]; }
 
      int dot(const IntVector& v) const
      {
         return elem_[0]*v.elem_[0] + elem_[1]*v.elem_[1] + elem_[2]*v.elem_[2];
      }
 
 
 
      IntVector& add(const IntVector& v1, const IntVector& v2)
      {
         elem_[0] = v1.elem_[0] + v2.elem_[0];
         elem_[1] = v1.elem_[1] + v2.elem_[1];
         elem_[2] = v1.elem_[2] + v2.elem_[2];
         return *this;
      }
 
      IntVector& subtract(const IntVector& v1, const IntVector& v2)
      {
         elem_[0] = v1.elem_[0] - v2.elem_[0];
         elem_[1] = v1.elem_[1] - v2.elem_[1];
         elem_[2] = v1.elem_[2] - v2.elem_[2];
         return *this;
      }
 
      IntVector& multiply(const IntVector& v, int s)
      {
         elem_[0] = v.elem_[0]*s;
         elem_[1] = v.elem_[1]*s;
         elem_[2] = v.elem_[2]*s;
         return *this;
      }
 
      IntVector& cross(const IntVector& v1, const IntVector& v2)
      {
         elem_[0] = v1.elem_[1]*v2.elem_[2] - v1.elem_[2]*v2.elem_[1];
         elem_[1] = v1.elem_[2]*v2.elem_[0] - v1.elem_[0]*v2.elem_[2];
         elem_[2] = v1.elem_[0]*v2.elem_[1] - v1.elem_[1]*v2.elem_[0];
         return *this;
      }
 
 
 
      
      static const IntVector Zero;
     
      static void initStatic();
 
      #ifdef UTIL_MPI
      static void commitMpiType();
      #endif
 
 
   private:
 
      static const int Width  = 15;
 
      int elem_[Dimension];
 
   //friends:
 
      friend bool operator == (const IntVector& v1, const IntVector& v2);
 
      friend bool operator == (const IntVector& v1, const int* v2);
 
      friend std::istream& operator >> (std::istream& in, IntVector &vector);
 
      friend std::ostream& operator << (std::ostream& out, const IntVector &vector);
 
   };
 
   bool operator == (const IntVector& v1, const IntVector& v2);
 
   bool operator == (const IntVector& v1, const int* v2);
 
   bool operator == (const int* v1, const IntVector& v2);
 
   bool operator != (const IntVector& v1, const IntVector& v2);
 
   bool operator != (const IntVector& v1, const int* v2);
 
   bool operator != (const int* v1, const IntVector& v2);
 
   std::istream& operator >> (std::istream& in, IntVector &vector);
 
   std::ostream& operator << (std::ostream& out, const IntVector &vector);
 
   #ifdef UTIL_MPI
   template <> class MpiTraits<IntVector> 
   {  
   public:  
      static MPI::Datatype type;    
      static bool hasType;          
   };
   #endif
 
   /*
   * Serialize to/from an archive.
   */
   template <class Archive>
   inline 
   void IntVector::serialize(Archive& ar, const unsigned int version)
   { 
      ar & elem_[0];
      ar & elem_[1];
      ar & elem_[2];
   }
 
} 
#endif