IntVec.h

#ifndef PSCF_INT_VEC_H
#define PSCF_INT_VEC_H
 
/*
* PSCF - Polymer Self-Consistent Field Theory
*
* Copyright 2016 - 2022, The Regents of the University of Minnesota
* Distributed under the terms of the GNU General Public License.
*/
 
#include "Vec.h"
#include <iostream>
#include <util/global.h>
 
namespace Pscf
{
 
   template <int D, typename T = int>
   class IntVec : public Vec<D, T>
   {
 
   public:
 
 
 
      IntVec<D, T>()
        : Vec<D, T>()
      {}
 
      IntVec<D, T>(const IntVec<D, T>& v)
       : Vec<D, T>(v)
      {}
 
      IntVec<D, T>(T const * v)
       : Vec<D, T>(v)
      {}
 
      explicit IntVec<D, T>(T s)
       : Vec<D, T>(s)
      {}
 
      static const int Width = 10;
 
   };
 
   // Friend functions and operators
 
   template <int D, typename T>
   std::istream& operator >> (std::istream& in, IntVec<D, T> &vector)
   {
      for (int i = 0; i < D; ++i) {
         in >> vector[i];
      }
      return in;
   }
 
   template <int D, typename T>
   std::ostream& operator << (std::ostream& out, const IntVec<D, T> &vector)
   {
      for (int i = 0; i < D; ++i) {
         out.width(IntVec<D, T>::Width);
         out << vector[i];
      }
      return out;
   }
 
   template <int D, typename T>
   inline
   bool operator == (const IntVec<D, T>& v1, const IntVec<D, T>& v2)
   {
      for (int i = 0; i < D; ++i) {
         if (v1[i] != v2[i]) {
            return false;
         }
      }
      return true;
   }
 
   template <int D, typename T>
   inline
   bool operator == (const IntVec<D, T>& v1, const Vec<D, T>& v2)
   {
      for (int i = 0; i < D; ++i) {
         if (v1[i] != v2[i]) {
            return false;
         }
      }
      return true;
   }
 
   template <int D, typename T>
   inline
   bool operator == (const Vec<D, T>& v1, const IntVec<D, T>& v2)
   {  return (v2 == v1); }
 
   template <int D, typename T>
   inline
   bool operator != (const IntVec<D, T>& v1, const IntVec<D, T>& v2)
   { return !(v1 == v2); }
 
   template <int D, typename T>
   inline
   bool operator != (const IntVec<D, T>& v1, const Vec<D, T>& v2)
   {  return !(v1 == v2); }
 
   template <int D, typename T>
   inline
   bool operator != (const Vec<D, T>& v1, const IntVec<D, T>& v2)
   {  return !(v2 == v1); }
 
   template <int D, typename T>
   inline
   bool operator < (const IntVec<D, T>& v1, const IntVec<D, T>& v2)
   {
      for (int i = 0; i < D; ++i) {
         if (v1[i] > v2[i]) {
            return false;
         } else
         if (v1[i] < v2[i]) {
             return true;
         }
         // This point is reached iff v1[i] == v2[i]
      }
      // If loop completes, the vectors are equal
      return false;
   }
 
   template <int D, typename T>
   inline
   bool operator <= (const IntVec<D, T>& v1, const IntVec<D, T>& v2)
   {
      for (int i = 0; i < D; ++i) {
         if (v1[i] > v2[i]) {
           return false;
         } else
         if (v1[i] < v2[i]) {
            return true;
         }
         // This point is reached iff v1[i] == v2[i]
      }
      // If loop completes, the vectors are equal
      return true;
   }
 
   template <int D, typename T>
   inline
   bool operator > (const IntVec<D, T>& v1, const IntVec<D, T>& v2)
   {  return !(v1 <= v2); }
 
   template <int D, typename T>
   inline
   bool operator >= (const IntVec<D, T>& v1, const IntVec<D, T>& v2)
   {  return !(v1 < v2); }
 
}
#endif