Permutation.hh

Go to the documentation of this file.

// Permutation.hh
 
#ifndef PERMUTATION_HH
#define PERMUTATION_HH
 
#include <cassert>
#include <numeric>
#include <ostream>
#include <vector>
 
#include "casm/global/definitions.hh"
 
namespace CASM {
 
 
class Permutation {
 private:
  std::vector<Index> m_perm_array;
 
 public:
  explicit Permutation(Index N) : m_perm_array(N) {
    std::iota(m_perm_array.begin(), m_perm_array.end(), 0);
  }
 
  template <typename Iterator>
  Permutation(Iterator begin, Iterator end) : m_perm_array(begin, end) {}
  explicit Permutation(const std::vector<Index> &init_perm)
      : m_perm_array(init_perm) {}
  explicit Permutation(std::vector<Index> &&init_perm)
      : m_perm_array(std::move(init_perm)) {}
 
  Index size() const { return m_perm_array.size(); }
 
  const std::vector<Index> &perm_array() const { return m_perm_array; }
 
  bool is_perm() const;
 
  bool has_fixed_points() const;
 
  Index character() const;
 
  bool is_identity() const;
 
  void append_fixed_points(Index N_new);
 
  Permutation inverse() const;
 
  Permutation make_block_permutation(
      const std::vector<Index> &block_dims) const;
 
  Permutation transformed_by(const Permutation &trans_perm) const;
 
  const Index &operator[](Index i) const { return m_perm_array[i]; }
 
  Index &set(Index i) { return m_perm_array[i]; }
 
  template <typename Container>
  Container permute(const Container &_before) const;
 
  template <typename Container>
  Container ipermute(const Container &_before) const;
 
  template <typename Container>
  Container operator*(const Container &_before) const {
    return this->permute(_before);
  }
 
  Permutation operator*(const Permutation &RHS) const;
};
 
std::ostream &operator<<(std::ostream &, const Permutation &);
 
//************************************************************************************************************************************//
//************************************************************************************************************************************//
 
template <typename Container>
Container Permutation::permute(const Container &before_vec) const {
  assert(before_vec.size() == size() &&
         "WARNING: You're trying to permute a Container with an incompatible "
         "permutation!");
 
  Container after_vec(before_vec);
  // after_vec.reserve(size());
 
  for (Index i = 0; i < size(); i++) {
    after_vec[i] = before_vec[m_perm_array[i]];
  }
  return after_vec;
}
 
//**************************************************************
 
template <typename Container>
Container Permutation::ipermute(const Container &before_array) const {
  assert(before_array.size() == size() &&
         "WARNING: You're trying to permute an Container with an incompatible "
         "permutation!");
 
  Container after_array(before_array);
  // after_array.reserve(size());
 
  for (Index i = 0; i < size(); i++) {
    if (i != m_perm_array[i]) {
      after_array[m_perm_array[i]] = before_array[i];
    }
  }
  return after_array;
}
 
}  // namespace CASM
 
#endif