tuple_mirror.hpp

// FEAT3: Finite Element Analysis Toolbox, Version 3
// Copyright (C) 2010 by Stefan Turek & the FEAT group
// FEAT3 is released under the GNU General Public License version 3,
// see the file 'copyright.txt' in the top level directory for details.
 
#pragma once
 
#include <kernel/lafem/dense_vector.hpp>
#include <kernel/lafem/tuple_vector.hpp>
#include <kernel/lafem/meta_element.hpp>
 
namespace FEAT
{
  namespace LAFEM
  {
    template<
      typename First_,
      typename... Rest_>
    class TupleMirror
    {
      template<typename,typename...>
      friend class TupleMirror;
 
      typedef TupleMirror<Rest_...> RestClass;
 
    public:
      static constexpr int num_blocks = RestClass::num_blocks + 1;
 
      typedef typename First_::DataType DataType;
      typedef typename First_::IndexType IndexType;
 
      // ensure that all sub-vector have the same data-type
      static_assert(std::is_same<DataType, typename RestClass::DataType>::value, "sub-mirrors have different data-types");
      static_assert(std::is_same<IndexType, typename RestClass::IndexType>::value, "sub-mirrors have different index-types");
 
      template <typename DT2_ = DataType, typename IT2_ = IndexType>
      using MirrorType = TupleMirror<
        typename First_::template MirrorType<DT2_, IT2_>,
        typename Rest_::template MirrorType<DT2_, IT2_>...>;
 
      template <typename DataType2_, typename IndexType2_>
      using MirrorTypeByDI = MirrorType<DataType2_, IndexType2_>;
 
    protected:
      First_ _first;
      RestClass _rest;
 
      TupleMirror(First_&& the_first, RestClass&& the_rest) :
        _first(std::forward<First_>(the_first)),
        _rest(std::forward<RestClass>(the_rest))
      {
      }
 
    public:
      TupleMirror()
      {
      }
 
      explicit TupleMirror(First_&& the_first, Rest_&&... the_rest) :
        _first(std::forward<First_>(the_first)),
        _rest(std::forward<Rest_>(the_rest)...)
      {
      }
 
      TupleMirror(TupleMirror&& other) :
        _first(std::forward<First_>(other._first)),
        _rest(std::forward<RestClass>(other._rest))
      {
      }
 
      TupleMirror& operator=(TupleMirror&& other)
      {
        if(this != &other)
        {
          _first = std::forward<First_>(other._first);
          _rest = std::forward<RestClass>(other._rest);
        }
        return *this;
      }
 
      TupleMirror clone(CloneMode clone_mode = CloneMode::Weak) const
      {
        return TupleMirror(_first.clone(clone_mode), _rest.clone(clone_mode));
      }
 
      template<typename... SubMirror2_>
      void convert(const TupleMirror<SubMirror2_...>& other)
      {
        this->_first.convert(other._first);
        this->_rest.convert(other._rest);
      }
 
      template<typename Tv_, typename... Tw_>
      static TupleMirror make_empty(const TupleVector<Tv_, Tw_...>& tmpl_vec)
      {
        return TupleMirror(First_::make_empty(tmpl_vec.first()), RestClass::make_empty(tmpl_vec.rest()));
      }
 
      std::size_t bytes() const
      {
        return _first.bytes() + _rest.bytes();
      }
 
      bool empty() const
      {
        return _first.empty() && _rest.empty();
      }
 
      First_& first()
      {
        return _first;
      }
 
      const First_& first() const
      {
        return _first;
      }
 
      RestClass& rest()
      {
        return _rest;
      }
 
      const RestClass& rest() const
      {
        return _rest;
      }
 
      template<typename Tv_, typename... Tw_>
      Index buffer_size(const TupleVector<Tv_, Tw_...>& vector) const
      {
        return _first.buffer_size(vector.first()) + _rest.buffer_size(vector.rest());
      }
 
      template<typename Tv_, typename... Tw_>
      DenseVector<DataType, IndexType> create_buffer(const TupleVector<Tv_, Tw_...>& vector) const
      {
        return DenseVector<DataType, IndexType>(buffer_size(vector));
      }
 
      template<int i_>
      typename TupleElement<i_, First_, Rest_...>::Type& at()
      {
        return TupleElement<i_, First_, Rest_...>::get(*this);
      }
 
      template<int i_>
      typename TupleElement<i_, First_, Rest_...>::Type const& at() const
      {
        return TupleElement<i_, First_, Rest_...>::get(*this);
      }
 
      template<typename Tv_, typename... Tw_>
      void gather(
        LAFEM::DenseVector<DataType, IndexType>& buffer,
        const LAFEM::TupleVector<Tv_, Tw_...>& vector,
        const Index buffer_offset = Index(0)) const
      {
        _first.gather(buffer, vector.first(), buffer_offset);
        _rest.gather(buffer, vector.rest(), buffer_offset + _first.buffer_size(vector.first()));
      }
 
      template<typename Tv_, typename... Tw_>
      void scatter_axpy(
        LAFEM::TupleVector<Tv_, Tw_...>& vector,
        const LAFEM::DenseVector<DataType, IndexType>& buffer,
        const DataType alpha = DataType(1),
        const Index buffer_offset = Index(0)) const
      {
        _first.scatter_axpy(vector.first(), buffer, alpha, buffer_offset);
        _rest.scatter_axpy(vector.rest(), buffer, alpha, buffer_offset + _first.buffer_size(vector.first()));
      }
 
      template<Perspective perspective_, typename Tv_, typename... Tw_>
      Index mask_scatter(const LAFEM::TupleVector<Tv_, Tw_...>& vector, std::vector<int>& mask,
        const int value, const Index offset = Index(0)) const
      {
        Index nf = _first.template mask_scatter<perspective_>(vector.first(), mask, value, offset);
        Index nr = _rest.template mask_scatter<perspective_>(vector.rest(), mask, value, offset + nf);
        return nf + nr;
      }
 
      void dump(std::ostream& os) const
      {
        os << this->first() << ",";
        this->rest().dump(os);
      }
    }; // class TupleMirror<...>
 
    template<typename First_>
    class TupleMirror<First_>
    {
      template<typename,typename...>
      friend class TupleMirror;
 
    public:
      static constexpr int num_blocks = 1;
 
      typedef typename First_::DataType DataType;
      typedef typename First_::IndexType IndexType;
 
      template <typename DT2_ = DataType, typename IT2_ = IndexType>
      using MirrorType = TupleMirror<typename First_::template MirrorType<DT2_, IT2_> >;
 
      template <typename DataType2_, typename IndexType2_>
      using MirrorTypeByDI = MirrorType<DataType2_, IndexType2_>;
 
    protected:
      First_ _first;
 
    public:
      TupleMirror()
      {
      }
 
      explicit TupleMirror(First_&& the_first) :
        _first(std::forward<First_>(the_first))
      {
      }
 
      TupleMirror(TupleMirror&& other) :
        _first(std::forward<First_>(other._first))
      {
      }
 
      TupleMirror& operator=(TupleMirror&& other)
      {
        if(this != &other)
        {
          _first = std::forward<First_>(other._first);
        }
        return *this;
      }
 
      TupleMirror clone() const
      {
        return TupleMirror(_first.clone());
      }
 
      TupleMirror clone(CloneMode clone_mode = CloneMode::Weak) const
      {
        return TupleMirror(_first.clone(clone_mode));
      }
 
      template<typename SubMirror2_>
      void convert(const TupleMirror<SubMirror2_>& other)
      {
        this->_first.convert(other._first);
      }
 
      template<typename Tv_>
      static TupleMirror make_empty(const TupleVector<Tv_>& tmpl_vec)
      {
        return TupleMirror(First_::make_empty(tmpl_vec.first()));
      }
 
      std::size_t bytes() const
      {
        return _first.bytes();
      }
      bool empty() const
      {
        return _first.empty();
      }
 
      First_& first()
      {
        return _first;
      }
 
      const First_& first() const
      {
        return _first;
      }
 
      template<typename Tv_>
      Index buffer_size(const TupleVector<Tv_>& vector) const
      {
        return _first.buffer_size(vector.first());
      }
 
      template<typename Tv_>
      DenseVector<DataType, IndexType> create_buffer(const TupleVector<Tv_>& vector) const
      {
        return DenseVector<DataType, IndexType>(buffer_size(vector));
      }
 
      template<int i_>
      First_& at()
      {
        static_assert(i_ == 0, "invalid sub-mirror index");
        return _first;
      }
 
      template<int i_>
      const First_& at() const
      {
        static_assert(i_ == 0, "invalid sub-mirror index");
        return _first;
      }
 
      template<typename Tv_>
      void gather(
        LAFEM::DenseVector<DataType, IndexType>& buffer,
        const LAFEM::TupleVector<Tv_>& vector,
        const Index buffer_offset = Index(0)) const
      {
        _first.gather(buffer, vector.first(), buffer_offset);
      }
 
      template<typename Tv_>
      void scatter_axpy(
        LAFEM::TupleVector<Tv_>& vector,
        const LAFEM::DenseVector<DataType, IndexType>& buffer,
        const DataType alpha = DataType(1),
        const Index buffer_offset = Index(0)) const
      {
        _first.scatter_axpy(vector.first(), buffer, alpha, buffer_offset);
      }
 
      template<Perspective perspective_, typename Tv_>
      Index mask_scatter(const LAFEM::TupleVector<Tv_>& vector, std::vector<int>& mask,
        const int value, const Index offset = Index(0)) const
      {
        return _first.template mask_scatter<perspective_>(vector.first(), mask, value, offset);
      }
 
      void dump(std::ostream& os) const
      {
        os << this->first();
      }
    }; // class TupleMirror<First_>
 
    template <typename First_, typename... Rest_>
    inline std::ostream& operator<< (std::ostream & os, const TupleMirror<First_, Rest_...>& x)
    {
      os << "[";
      x.dump(os);
      os << "]";
      return os;
    }
  } // namespace LAFEM
} // namespace FEAT