permutation.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/util/assertion.hpp>
#include <kernel/util/random.hpp>
 
//includes, system
#include<vector>
 
namespace FEAT
{
  namespace Adjacency
  {
    class Permutation
    {
    public:
      using IndexVector = std::vector < Index>;
 
      enum class ConstrType
      {
        none,
        identity,
        perm,
        swap,
        inv_perm,
        inv_swap
      };
 
    private:
      IndexVector _perm_pos;
      IndexVector _swap_pos;
 
    public:
      Permutation() :
        _perm_pos(),
        _swap_pos()
      {
      }
 
      explicit Permutation(
        Index num_entries,
        ConstrType constr_type = ConstrType::none,
        const Index* v = nullptr);
 
      explicit Permutation(
        Index num_entries,
        Random& random);
 
      Permutation(Permutation&& other);
      Permutation& operator=(Permutation&&);
 
      virtual ~Permutation();
 
      Permutation clone() const
      {
        if(!_perm_pos.empty())
          return Permutation(this->size(), ConstrType::perm, _perm_pos.data());
        else
          return Permutation();
      }
 
      Permutation inverse() const
      {
        if(!_perm_pos.empty())
          return Permutation(this->size(), ConstrType::inv_perm, _perm_pos.data());
        else
          return Permutation();
      }
 
      Index size() const
      {
        XASSERTM(_perm_pos.size()==_swap_pos.size(), "perm_pos and swap_pos have different sizes");
        return Index(_perm_pos.size());
      }
 
      bool empty() const
      {
        return _perm_pos.empty();
      }
 
      Index* get_perm_pos()
      {
        return _perm_pos.data();
      }
 
      const Index* get_perm_pos() const
      {
        return _perm_pos.data();
      }
 
      Index* get_swap_pos()
      {
        return _swap_pos.data();
      }
 
      const Index* get_swap_pos() const
      {
        return _swap_pos.data();
      }
 
      template<typename IT_>
      IT_ map(IT_ i) const
      {
        return IT_(_perm_pos.at(std::size_t(i)));
      }
 
      void calc_swap_from_perm();
 
      void calc_perm_from_swap();
 
      template<typename Tx_>
      void apply(Tx_* x, bool invert = false) const
      {
        XASSERT(x != nullptr);
 
        if(!invert)
        {
          // apply in-situ swapping
          for(Index i(0); i+1 < this->size(); ++i)
          {
            Index j(_swap_pos[i]);
            ASSERTM((j >= i) && (j < this->size()), "invalid swap position");
            if(j > i)
            {
              Tx_ t(x[i]);
              x[i] = x[j];
              x[j] = t;
            }
          }
        }
        else
        {
          // apply inverse in-situ swapping
          for(Index i(this->size() -1); i > 0; --i)
          {
            Index j(_swap_pos[i-1]);
            ASSERTM((j >= i-1) && (j < this->size()), "invalid swap position");
            if(j > i-1)
            {
              Tx_ t(x[i-1]);
              x[i-1] = x[j];
              x[j] = t;
            }
          }
        }
      }
 
      template<typename Ty_, typename Tx_>
     // void operator()(Ty_* y, const Tx_* x, bool invert = false) const
      void apply(Ty_* y, const Tx_* x, bool invert = false) const
      {
        XASSERT(y != nullptr);
        XASSERT(x != nullptr);
        if(!invert)
        {
          for(Index i(0); i < this->size(); ++i)
          {
            y[i] = Ty_(x[_perm_pos[i]]);
          }
        }
        else
        {
          for(Index i(0); i < this->size(); ++i)
          {
            y[_perm_pos[i]] = Ty_(x[i]);
          }
        }
      }
 
      void concat(const Permutation& p);
 
    }; // class Permutation
  } // namespace Adjacency
} // namespace FEAT