vector: Move as_vector to vector.hpp as suggested by Ruprecht.

This also overrides for the const case, as suggested by Klatt.

Signed-off-by: Matthew Emmett <[email protected]>

Author: memmett

examples/advection_diffusion/advection_diffusion_sweeper.hpp

@@ -19,13 +19,14 @@
 #endif
 
 using namespace std;
+using pfasst::encap::Encapsulation;
+using pfasst::encap::as_vector;
+
 
 template<typename time = pfasst::time_precision>
 class AdvectionDiffusionSweeper
   : public pfasst::encap::IMEXSweeper<time>
 {
-    typedef pfasst::encap::Encapsulation<time> Encapsulation;
-
     FFT fft;
 
     vector<complex<double>> ddx, lap;
@@ -35,12 +36,6 @@ class AdvectionDiffusionSweeper
     double nu = 0.02;
     size_t nf1evals = 0;
 
-    inline DVectorT& as_dvector(shared_ptr<Encapsulation> x)
-    {
-      shared_ptr<DVectorT> y = dynamic_pointer_cast<DVectorT>(x); assert(y);
-      return *y.get();
-    }
-
   public:
     AdvectionDiffusionSweeper(size_t nvars)
     {
@@ -58,9 +53,9 @@ class AdvectionDiffusionSweeper
       cout << "number of f1 evals: " << nf1evals << endl;
     }
 
-    void exact(shared_ptr<Encapsulation> q, time t)
+    void exact(shared_ptr<Encapsulation<time>> q, time t)
     {
-      this->exact(as_dvector(q), t);
+      this->exact(as_vector<double,time>(q), t);
     }
 
     void exact(DVectorT& q, time t)
@@ -82,8 +77,8 @@ class AdvectionDiffusionSweeper
 
     void echo_error(time t, bool predict = false)
     {
-      DVectorT& qend = as_dvector(this->get_end_state());
-      DVectorT  qex(qend.size());
+      auto& qend = as_vector<double,time>(this->get_end_state());
+      DVectorT qex(qend.size());
 
       exact(qex, t);
 
@@ -109,10 +104,10 @@ class AdvectionDiffusionSweeper
       echo_error(t + dt);
     }
 
-    void f1eval(shared_ptr<Encapsulation> _f, shared_ptr<Encapsulation> _q, time /*t*/)
+    void f1eval(shared_ptr<Encapsulation<time>> _f, shared_ptr<Encapsulation<time>> _q, time /*t*/)
     {
-      DVectorT& q = as_dvector(_q);
-      DVectorT& f = as_dvector(_f);
+      auto& q = as_vector<double,time>(_q);
+      auto& f = as_vector<double,time>(_f);
 
       double c = -v / double(q.size());
 
@@ -125,10 +120,10 @@ class AdvectionDiffusionSweeper
       nf1evals++;
     }
 
-    void f2eval(shared_ptr<Encapsulation> _f, shared_ptr<Encapsulation> _q, time /*t*/)
+    void f2eval(shared_ptr<Encapsulation<time>> _f, shared_ptr<Encapsulation<time>> _q, time /*t*/)
     {
-      DVectorT& q = as_dvector(_q);
-      DVectorT& f = as_dvector(_f);
+      auto& q = as_vector<double,time>(_q);
+      auto& f = as_vector<double,time>(_f);
 
       double c = nu / double(q.size());
 
@@ -139,12 +134,12 @@ class AdvectionDiffusionSweeper
       fft.backward(f);
     }
 
-    void f2comp(shared_ptr<Encapsulation> _f, shared_ptr<Encapsulation> _q, time /*t*/, time dt,
-                shared_ptr<Encapsulation> _rhs)
+    void f2comp(shared_ptr<Encapsulation<time>> _f, shared_ptr<Encapsulation<time>> _q, time /*t*/, time dt,
+                shared_ptr<Encapsulation<time>> _rhs)
     {
-      DVectorT& q = as_dvector(_q);
-      DVectorT& f = as_dvector(_f);
-      DVectorT& rhs = as_dvector(_rhs);
+      auto& q = as_vector<double,time>(_q);
+      auto& f = as_vector<double,time>(_f);
+      auto& rhs = as_vector<double,time>(_rhs);
 
       auto* z = fft.forward(rhs);
       for (size_t i = 0; i < q.size(); i++) {

examples/advection_diffusion/spectral_transfer_1d.hpp

@@ -21,24 +21,12 @@ class SpectralTransfer1D
 
     FFT fft;
 
-    inline DVectorT& as_dvector(shared_ptr<Encapsulation> x)
-    {
-      shared_ptr<DVectorT> y = dynamic_pointer_cast<DVectorT>(x); assert(y);
-      return *y.get();
-    }
-
-    inline const DVectorT& as_const_dvector(shared_ptr<const Encapsulation> x)
-    {
-      shared_ptr<const DVectorT> y = dynamic_pointer_cast<const DVectorT>(x); assert(y);
-      return *y.get();
-    }
-
   public:
 
     void interpolate(shared_ptr<Encapsulation> dst, shared_ptr<const Encapsulation> src)
     {
-      auto& fine = as_dvector(dst);
-      auto& crse = as_const_dvector(src);
+      auto& fine = as_vector<double,time>(dst);
+      auto& crse = as_vector<double,time>(src);
 
       auto* crse_z = fft.forward(crse);
       auto* fine_z = fft.get_workspace(fine.size())->z;
@@ -62,8 +50,8 @@ class SpectralTransfer1D
 
     void restrict(shared_ptr<Encapsulation> dst, shared_ptr<const Encapsulation> src)
     {
-      auto& fine = as_const_dvector(src);
-      auto& crse = as_dvector(dst);
+      auto& fine = as_vector<double,time>(src);
+      auto& crse = as_vector<double,time>(dst);
 
       size_t xrat = fine.size() / crse.size();
 

include/pfasst/encap/vector.hpp

@@ -27,14 +27,14 @@ namespace pfasst
      *     precision of the time points; defaults to pfasst::time_precision
      */
     template<typename scalar, typename time = time_precision>
-    class VectorEncapsulation 
+    class VectorEncapsulation
       : public vector<scalar>, public Encapsulation<time>
     {
       public:
         //! @{
         /**
          */
-        VectorEncapsulation(int size) 
+        VectorEncapsulation(int size)
           : vector<scalar>(size)
         {
           zero();
@@ -49,7 +49,7 @@ namespace pfasst
         {}
         /**
          * @throws std::bad_cast
-         *     if `other` can not be transformed into pfasst::encap::VectorEncapsulation via 
+         *     if `other` can not be transformed into pfasst::encap::VectorEncapsulation via
          *     `dynamic_cast`
          */
         VectorEncapsulation(const Encapsulation<time>& other)
@@ -65,7 +65,7 @@ namespace pfasst
         {}
         /**
          * @throws std::bad_cast
-         *     if `other` can not be transformed into pfasst::encap::VectorEncapsulation via 
+         *     if `other` can not be transformed into pfasst::encap::VectorEncapsulation via
          *     `dynamic_cast`
          */
         VectorEncapsulation(Encapsulation<time>&& other)
@@ -109,7 +109,7 @@ namespace pfasst
         }
 
         /**
-         * @note In case any of the elements of `dst` or `src` can not be transformed via 
+         * @note In case any of the elements of `dst` or `src` can not be transformed via
          *     `dynamic_cast` into pfasst::encap::VectorEncapsulation std::abort is called.
          */
         void mat_apply(vector<shared_ptr<Encapsulation<time>>> dst, time a, matrix<time> mat,
@@ -153,7 +153,7 @@ namespace pfasst
 
         /**
          * maximum norm of contained elements.
-         * 
+         *
          * This uses std::max with custom comparison function.
          */
         scalar norm0() const
@@ -183,6 +183,24 @@ namespace pfasst
         }
     };
 
+    template<typename scalar, typename time = time_precision>
+    VectorEncapsulation<scalar,time>& as_vector(shared_ptr<Encapsulation<time>> x)
+    {
+      typedef VectorEncapsulation<scalar,time> VectorT;
+      shared_ptr<VectorT> y = dynamic_pointer_cast<VectorT>(x);
+      assert(y);
+      return *y.get();
+    }
+
+    template<typename scalar, typename time = time_precision>
+    const VectorEncapsulation<scalar,time>& as_vector(shared_ptr<const Encapsulation<time>> x)
+    {
+      typedef VectorEncapsulation<scalar,time> VectorT;
+      shared_ptr<const VectorT> y = dynamic_pointer_cast<const VectorT>(x);
+      assert(y);
+      return *y.get();
+    }
+
   }
 }