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