RealVec.h

#ifndef PSCF_REAL_VEC_H
#define PSCF_REAL_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 = double>
   class RealVec : public Vec<D, T>
   {
 
   public:
 
 
 
      RealVec<D, T>()
        : Vec<D, T>()
      {}
 
      RealVec<D, T>(const RealVec<D, T>& v)
       : Vec<D, T>(v)
      {}
 
      RealVec<D, T>(T const * v)
       : Vec<D, T>(v)
      {}
 
      explicit RealVec<D, T>(T s)
       : Vec<D, T>(s)
      {}
 
      static const int Width = 25;
 
      static const int Precision = 17;
 
   };
 
   // Friend functions and operators
 
   template <int D, typename T>
   std::istream& operator >> (std::istream& in, RealVec<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 RealVec<D, T> &vector)
   {
      for (int i = 0; i < D; ++i) {
         out.setf(std::ios::scientific);
         out.width(RealVec<D>::Width);
         out.precision(RealVec<D>::Precision);
         out << vector[i];
      }
      return out;
   }
 
   // Equality operators
   
   #define PSCF_REALVEC_EPSILON 1.0E-8
   
   template <int D, typename T>
   bool operator==(const RealVec<D, T>& v1, const RealVec<D, T>& v2) 
   {
      for (int i = 0; i < D; ++i) {
         if ( fabs(v1[i] - v2[i]) > PSCF_REALVEC_EPSILON) {
            return false;
         }
      }
      return true;
   }
   #undef PSCF_REALVEC_EPSILON
   
   template <int D, typename T>
   bool operator!=(const RealVec<D, T>& v1, const RealVec<D, T>& v2) 
   { return !(v1 == v2); }
   
}
#endif