tuple_vector.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
 
// includes, FEAT
#include <kernel/lafem/meta_element.hpp>
 
 
// includes, system
#include <iostream>
#include <type_traits>
 
namespace FEAT
{
  namespace LAFEM
  {
    template<
      typename First_,
      typename... Rest_>
    class TupleVector
    {
    private:
      template<typename,typename...>
      friend class TupleVector;
 
      typedef TupleVector<Rest_...> RestClass;
 
      void _read_from_binary(std::istream& file)
      {
        //process first
        _first.read_from(FileMode::fm_binary, file);
 
        // append rest
        _rest._read_from_binary(file);
      }
 
      void _write_out_binary(std::ostream& file) const
      {
        //process first
        _first.write_out(FileMode::fm_binary, file);
 
        // append rest
        _rest._write_out_binary(file);
      }
 
    public:
      static constexpr int num_blocks = TupleVector<Rest_...>::num_blocks + 1;
 
      typedef typename First_::DataType DataType;
      typedef typename First_::IndexType IndexType;
 
      template <typename DT2_ = DataType, typename IT2_ = IndexType>
      using ContainerType = TupleVector<
        typename First_::template ContainerType<DT2_, IT2_>,
        typename Rest_::template ContainerType<DT2_, IT2_>...>;
 
      template <typename DataType2_, typename IndexType2_>
      using ContainerTypeByDI = ContainerType<DataType2_, IndexType2_>;
 
      // ensure that all sub-vector have the same data-type
      static_assert(std::is_same<DataType, typename RestClass::DataType>::value,
                    "sub-vectors have different data-types");
      static_assert(std::is_same<IndexType, typename RestClass::IndexType>::value,
                    "sub-vectors have different index-types");
 
    protected:
      First_ _first;
      RestClass _rest;
 
      static String sub_name_list()
      {
        return First_::name() + "," + RestClass::sub_name_list();
      }
 
    public:
      TupleVector()
      {
      }
 
      explicit TupleVector(First_&& the_first, RestClass&& the_rest) :
        _first(std::forward<First_>(the_first)),
        _rest(std::forward<RestClass>(the_rest))
      {
      }
 
      explicit TupleVector(First_&& the_first, Rest_&&... the_rest) :
        _first(std::forward<First_>(the_first)),
        _rest(std::forward<Rest_>(the_rest)...)
      {
      }
 
      TupleVector(TupleVector&& other) :
        _first(std::forward<First_>(other._first)),
        _rest(std::forward<RestClass>(other._rest))
      {
      }
 
      TupleVector& operator=(TupleVector&& other)
      {
        if(this != &other)
        {
          _first = std::forward<First_>(other._first);
          _rest = std::forward<RestClass>(other._rest);
        }
        return *this;
      }
 
      TupleVector(const TupleVector&) = delete;
      TupleVector& operator=(const TupleVector&) = delete;
 
      TupleVector clone(LAFEM::CloneMode mode = LAFEM::CloneMode::Weak) const
      {
        return TupleVector(_first.clone(mode), _rest.clone(mode));
      }
 
      void clone(const TupleVector& other, CloneMode clone_mode)
      {
        _first.clone(other._first, clone_mode);
        _rest.clone(other._rest, clone_mode);
      }
 
      void clone(const TupleVector& other)
      {
        _first.clone(other._first);
        _rest.clone(other._rest);
      }
 
      std::uint64_t get_checkpoint_size(SerialConfig& config)
      {
        return sizeof(std::uint64_t) + _first.get_checkpoint_size(config) + _rest.get_checkpoint_size(config); //sizeof(std::uint64_t) bits needed to store lenght of checkpointed _first
      }
 
      void restore_from_checkpoint_data(std::vector<char> & data)
      {
        std::uint64_t isize = *(std::uint64_t*) data.data(); //get size of checkpointed _first
        std::vector<char>::iterator start = std::begin(data) + sizeof(std::uint64_t);
        std::vector<char>::iterator last_of_first = std::begin(data) + sizeof(std::uint64_t) + (int) isize;
        std::vector<char> buffer_first(start, last_of_first);
        _first.restore_from_checkpoint_data(buffer_first);
 
        data.erase(std::begin(data), last_of_first);
        _rest.restore_from_checkpoint_data(data);
      }
 
      std::uint64_t set_checkpoint_data(std::vector<char>& data, SerialConfig& config)
      {
        std::size_t old_size = data.size();
        data.insert(std::end(data), sizeof(std::uint64_t), 0); //add placeholder
        std::uint64_t ireal_size = _first.set_checkpoint_data(data, config); //add data of _first to the overall checkpoint and save its size
        char* csize = reinterpret_cast<char*>(&ireal_size);
        for(std::size_t i(0) ; i < sizeof(std::uint64_t) ; ++i)  //overwrite the guessed datalength
        {
          data[old_size +i] = csize[i];
        }
 
        return sizeof(std::uint64_t) + ireal_size + _rest.set_checkpoint_data(data, config); //generate and add checkpoint data for the _rest
      }
 
      First_& first()
      {
        return _first;
      }
 
      const First_& first() const
      {
        return _first;
      }
 
      TupleVector<Rest_...>& rest()
      {
        return _rest;
      }
 
      const TupleVector<Rest_...>& rest() const
      {
        return _rest;
      }
 
      template<int i_>
      typename TupleElement<i_, First_, Rest_...>::Type& at()
      {
        static_assert((0 <= i_) && (i_ < num_blocks), "invalid sub-vector index");
        return TupleElement<i_, First_, Rest_...>::get(*this);
      }
 
      template<int i_>
      typename TupleElement<i_, First_, Rest_...>::Type const& at() const
      {
        static_assert((0 <= i_) && (i_ < num_blocks), "invalid sub-vector index");
        return TupleElement<i_, First_, Rest_...>::get(*this);
      }
 
      template <Perspective perspective_ = Perspective::native>
      Index size() const
      {
        return _first.template size<perspective_>() + _rest.template size<perspective_>();
      }
 
      int blocks() const
      {
        return num_blocks;
      }
 
      static String name()
      {
        return String("TupleVector<") + sub_name_list() + ">";
      }
 
      void format(DataType value = DataType(0))
      {
        first().format(value);
        rest().format(value);
      }
 
      void format(Random & rng, DataType min, DataType max)
      {
        first().format(rng, min, max);
        rest().format(rng, min, max);
      }
 
      void clear()
      {
        first().clear();
        rest().clear();
      }
 
      //template<typename First2_, typename... Rest2_>
      void copy(const TupleVector/*<First2_, Rest2_...>*/& x, bool full = false)
      {
        first().copy(x.first(), full);
        rest().copy(x.rest(), full);
      }
 
      void axpy(const TupleVector& x, DataType alpha = DataType(1))
      {
        first().axpy(x.first(), alpha);
        rest().axpy(x.rest(), alpha);
      }
 
      void component_product(const TupleVector & x, const TupleVector & y)
      {
        first().component_product(x.first(), y.first());
        rest().component_product(x.rest(), y.rest());
      }
 
      void component_invert(const TupleVector& x, DataType alpha = DataType(1))
      {
        first().component_invert(x.first(), alpha);
        rest().component_invert(x.rest(), alpha);
      }
 
      void scale(const TupleVector& x, DataType alpha)
      {
        first().scale(x.first(), alpha);
        rest().scale(x.rest(), alpha);
      }
 
      DataType dot(const TupleVector& x) const
      {
        return first().dot(x.first()) + rest().dot(x.rest());
      }
 
      DataType triple_dot(const TupleVector& x, const TupleVector& y) const
      {
        return first().triple_dot(x.first(), y.first())
          + rest().triple_dot(x.rest(), y.rest());
      }
 
      DataType norm2sqr() const
      {
        return first().norm2sqr() + rest().norm2sqr();
      }
 
      DataType norm2() const
      {
        return Math::sqrt(norm2sqr());
      }
 
      DataType max_abs_element() const
      {
        return Math::max(first().max_abs_element(), rest().max_abs_element());
      }
 
      DataType min_abs_element() const
      {
        return Math::min(first().min_abs_element(), rest().min_abs_element());
      }
 
      DataType max_element() const
      {
        return Math::max(first().max_element(), rest().max_element());
      }
 
      DataType min_element() const
      {
        return Math::min(first().min_element(), rest().min_element());
      }
 
      template <typename First2_, typename... Rest2_>
      DataType max_rel_diff(const TupleVector<First2_, Rest2_...>& x) const
      {
        return Math::max(first().max_rel_diff(x.first()), rest().max_rel_diff(x.rest()));
      }
 
      void set_vec(DataType * const pval_set) const
      {
        this->first().set_vec(pval_set);
        this->rest().set_vec(pval_set + this->first().template size<Perspective::pod>());
      }
 
      void set_vec_inv(const DataType * const pval_set)
      {
        this->first().set_vec_inv(pval_set);
        this->rest().set_vec_inv(pval_set + this->first().template size<Perspective::pod>());
      }
 
      template <typename First2_, typename... Rest2_>
      void convert(const TupleVector<First2_, Rest2_...>& other)
      {
        this->first().convert(other.first());
        this->rest().convert(other.rest());
      }
 
      std::size_t bytes() const
      {
        return _first.bytes() + _rest.bytes();
      }
 
      void read_from(FileMode mode, const String& filename)
      {
        std::ifstream file(filename.c_str(), std::ifstream::in | std::ifstream::binary);
        if (! file.is_open())
          XABORTM("Unable to open Vector file " + filename);
        read_from(mode, file);
        file.close();
      }
 
      void read_from(FileMode mode, std::istream& file)
      {
        switch(mode)
        {
          case FileMode::fm_binary:
          {
            std::uint64_t magic; // magic_number
            file.read((char *)&magic, (long)(sizeof(std::uint64_t)));
            if (magic != 101)
              XABORTM("Given file or file component is no TupleVector!");
            std::uint64_t count; // subvector count
            file.read((char *)&count, (long)(sizeof(std::uint64_t)));
            //if (count != num_blocks)
            //  XABORTM("TupleVector file read in component count mismatch: class has " + stringify(num_blocks) + "- " + stringify(count) + " read in!");
 
            _read_from_binary(file);
            break;
          }
          default:
            XABORTM("Filemode not supported!");
        }
      }
 
      void write_out(FileMode mode, const String& filename) const
      {
        std::ofstream file(filename.c_str(), std::ofstream::out | std::ofstream::binary);
        if (! file.is_open())
          XABORTM("Unable to open Vector file " + filename);
        write_out(mode, file);
        file.close();
      }
 
      void write_out(FileMode mode, std::ostream& file) const
      {
        switch(mode)
        {
          case FileMode::fm_binary:
          {
            size_t gsize(2 * sizeof(std::uint64_t)); // magic_number and subvector count
            std::vector<char> result(gsize);
            char * array(result.data());
            std::uint64_t * uiarray(reinterpret_cast<std::uint64_t *>(array));
            uiarray[0] = 101; 
            uiarray[1] = num_blocks;
 
            file.write(result.data(), long(result.size()));
 
            _write_out_binary(file);
            break;
          }
          default:
            XABORTM("Filemode not supported!");
        }
      }
    }; // class TupleVector<...>
 
    template<typename First_>
    class TupleVector<First_>
    {
    private:
      template<typename,typename...>
      friend class TupleVector;
 
      void _read_from_binary(std::istream& file)
      {
        //process first
        _first.read_from(FileMode::fm_binary, file);
      }
 
      void _write_out_binary(std::ostream& file) const
      {
        //process first
        _first.write_out(FileMode::fm_binary, file);
      }
 
    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 ContainerType = TupleVector<typename First_::template ContainerType<DT2_, IT2_> >;
 
      template <typename DataType2_, typename IndexType2_>
      using ContainerTypeByDI = ContainerType<DataType2_, IndexType2_>;
 
    protected:
      First_ _first;
 
      static String sub_name_list()
      {
        return First_::name();
      }
 
    public:
      TupleVector()
      {
      }
 
      explicit TupleVector(First_&& the_first) :
        _first(std::forward<First_>(the_first))
      {
      }
 
      TupleVector(TupleVector&& other) :
        _first(std::forward<First_>(other._first))
      {
      }
 
      TupleVector& operator=(TupleVector&& other)
      {
        if(this != &other)
        {
          _first = std::forward<First_>(other._first);
        }
        return *this;
      }
 
      TupleVector(const TupleVector&) = delete;
      TupleVector& operator=(const TupleVector&) = delete;
 
      TupleVector clone(LAFEM::CloneMode mode = LAFEM::CloneMode::Weak) const
      {
        return TupleVector(_first.clone(mode));
      }
 
      void clone(const TupleVector& other, CloneMode clone_mode)
      {
        _first.clone(other._first, clone_mode);
      }
 
      void clone(const TupleVector& other)
      {
        _first.clone(other._first);
      }
 
      First_& first()
      {
        return _first;
      }
 
      const First_& first() const
      {
        return _first;
      }
 
      std::uint64_t get_checkpoint_size(SerialConfig& config)
      {
        return _first.get_checkpoint_size(config);
      }
 
      void restore_from_checkpoint_data(std::vector<char> & data)
      {
        _first.restore_from_checkpoint_data(data);
      }
 
      std::uint64_t set_checkpoint_data(std::vector<char>& data, SerialConfig& config)
      {
        return _first.set_checkpoint_data(data, config);
      }
 
      template <Perspective perspective_ = Perspective::native>
      Index size() const
      {
        return _first.template size<perspective_>();
      }
 
      int blocks() const
      {
        return num_blocks;
      }
 
      static String name()
      {
        return String("TupleVector<") + sub_name_list() + ">";
      }
 
      template<int i_>
      typename TupleElement<i_, First_>::Type& at()
      {
        static_assert(i_ == 0, "invalid sub-vector index");
        return first();
      }
 
      template<int i_>
      typename TupleElement<i_, First_>::Type const& at() const
      {
        static_assert(i_ == 0, "invalid sub-vector index");
        return first();
      }
 
      void format(DataType value = DataType(0))
      {
        _first.format(value);
      }
 
      void format(Random & rng, DataType min, DataType max)
      {
        first().format(rng, min, max);
      }
 
      void clear()
      {
        _first.clear();
      }
 
      //template<typename First2_>
      void copy(const TupleVector/*<First2_>*/& x, bool full = false)
      {
        first().copy(x.first(), full);
      }
 
      void axpy(const TupleVector& x, DataType alpha = DataType(1))
      {
        first().axpy(x.first(), alpha);
      }
 
      void component_product(const TupleVector & x, const TupleVector & y)
      {
        first().component_product(x.first(), y.first());
      }
 
      void component_invert(const TupleVector& x, DataType alpha = DataType(1))
      {
        first().component_invert(x.first(), alpha);
      }
 
      void scale(const TupleVector& x, DataType alpha)
      {
        first().scale(x.first(), alpha);
      }
 
      DataType dot(const TupleVector& x) const
      {
        return first().dot(x.first());
      }
 
      DataType triple_dot(const TupleVector& x, const TupleVector& y) const
      {
        return first().triple_dot(x.first(), y.first());
      }
 
      DataType triple_dot_i(const TupleVector& x, const TupleVector& y) const
      {
        return first().triple_dot_i(x.first(), y.first());
      }
 
      DataType norm2sqr() const
      {
        return first().norm2sqr();
      }
 
      DataType norm2() const
      {
        return first().norm2();
      }
 
      DataType max_abs_element() const
      {
        return first().max_abs_element();
      }
 
      DataType min_abs_element() const
      {
        return first().min_abs_element();
      }
 
      DataType max_element() const
      {
        return first().max_element();
      }
 
      DataType min_element() const
      {
        return first().min_element();
      }
 
      const typename First_::DataType operator()(Index index) const
      {
        ASSERT(index < size());
        return first()(index);
      }
 
      void operator()(Index index, typename First_::DataType value)
      {
        ASSERT(index < size());
        first()(index, value);
      }
 
      void set_vec(DataType * const pval_set) const
      {
        this->first().set_vec(pval_set);
      }
 
      void set_vec_inv(const DataType * const pval_set)
      {
        this->first().set_vec_inv(pval_set);
      }
 
      template <typename First2_>
      void convert(const TupleVector<First2_>& other)
      {
        this->first().convert(other.first());
      }
 
      std::size_t bytes() const
      {
        return _first.bytes();
      }
 
      void read_from(FileMode mode, const String& filename)
      {
        switch(mode)
        {
        case FileMode::fm_binary:
          read_from_binary(filename);
          break;
        default:
          XABORTM("Filemode not supported!");
        }
      }
 
      void read_from(FileMode mode, std::istream& file)
      {
        switch(mode)
        {
        case FileMode::fm_binary:
          read_from_binary(file);
          break;
        default:
          XABORTM("Filemode not supported!");
        }
      }
 
      void read_from_binary(const String& filename)
      {
        std::ifstream file(filename.c_str(), std::ifstream::in | std::ifstream::binary);
        if (! file.is_open())
          XABORTM("Unable to open Vector file " + filename);
        read_from_binary(file);
        file.close();
      }
 
      void read_from_binary(std::istream& file)
      {
        std::uint64_t magic; // magic_number
        file.read((char *)&magic, (long)(sizeof(std::uint64_t)));
        if (magic != 101)
          XABORTM("Given file or file component is no TupleVector!");
        std::uint64_t count; // subvector count
        file.read((char *)&count, (long)(sizeof(std::uint64_t)));
        if (count != 1)
          XABORTM("PowerVector file read in component count mismatch: class has 1 - " + stringify(count) + " read in!");
 
        _read_from_binary(file);
      }
 
      void write_out(FileMode mode, const String& filename) const
      {
        switch(mode)
        {
        case FileMode::fm_binary:
          write_out_binary(filename);
          break;
        default:
          XABORTM("Filemode not supported!");
        }
      }
 
      void write_out(FileMode mode, std::ostream& file) const
      {
        switch(mode)
        {
        case FileMode::fm_binary:
          write_out_binary(file);
          break;
        default:
          XABORTM("Filemode not supported!");
        }
      }
 
      void write_out_binary(const String& filename) const
      {
        std::ofstream file(filename.c_str(), std::ofstream::out | std::ofstream::binary);
        if (! file.is_open())
          XABORTM("Unable to open Vector file " + filename);
        write_out_binary(file);
        file.close();
      }
 
      void write_out_binary(std::ostream& file) const
      {
        size_t gsize(2 * sizeof(std::uint64_t)); // magic_number and subvector count
        std::vector<char> result(gsize);
        char * array(result.data());
        std::uint64_t * uiarray(reinterpret_cast<std::uint64_t *>(array));
        uiarray[0] = 101; 
        uiarray[1] = 1; //fixed num_blocks for tuple vector specialization
 
        file.write(result.data(), long(result.size()));
 
        _write_out_binary(file);
      }
    };
 
    template <typename First_>
    inline void dump_tuple_vector(std::ostream & os, const TupleVector<First_>& x)
    {
      os << x.first();
    }
 
    template <typename First_, typename... Rest_>
    inline void dump_tuple_vector(std::ostream & os, const TupleVector<First_, Rest_...>& x)
    {
      os << x.first() << ",";
      dump_tuple_vector<Rest_...>(os, x.rest());
    }
 
    template <typename First_, typename... Rest_>
    inline std::ostream& operator<< (std::ostream & os, const TupleVector<First_, Rest_...>& x)
    {
      os << "[";
      dump_tuple_vector(os, x);
      os << "]";
      return os;
    }
  } // namespace LAFEM
} // namespace FEAT