Permutation.cc

Go to the documentation of this file.

#include "casm/container/Permutation.hh"
 
#include "casm/misc/algorithm.hh"
 
namespace CASM {
 
/* PERMUTATION CLASS DEFINITON:
 
class Permutation {
private:
before permutation
result of performing
  std::vector<Index> m_perm_array;
 
public:
  Permutation(const std::vector<Index> &init_perm): m_perm_array(init_perm){};
 
 
  Index size() const { return m_perm_array.size();};
 
and that no value is repeated bool is_perm() const;
 
  bool has_fixed_points() const;
 
  Permutation inverse() const;
 
  Permutation transformed_by(const Permutation& trans_perm) const;
 
  const Index&  operator[](Index i) const { return m_perm_array[i];};
 
  template<typename T>
  std::vector<T> permute(const std::vector<T> &before_array) const;
 
  template<typename T>
  std::vector<T> ipermute(const std::vector<T> &before_array) const;
 
 
};
*/
 
//**************************************************************
 
bool Permutation::is_perm() const {
  for (Index i = 0; i < size(); i++) {
    if (!valid_index(m_perm_array[i]) || m_perm_array[i] >= size() ||
        find_index(m_perm_array, m_perm_array[i]) < i)
      return false;
  }
  return true;
}
 
//**************************************************************
 
Index Permutation::character() const {
  Index result = 0;
  for (Index i = 0; i < size(); ++i) {
    if (m_perm_array[i] == i) ++result;
  }
  return result;
}
 
//**************************************************************
 
bool Permutation::has_fixed_points() const {
  for (Index i = 0; i < size(); i++) {
    if (m_perm_array[i] == i) return true;
  }
  return false;
}
 
//**************************************************************
 
bool Permutation::is_identity() const {
  for (Index i = 0; i < size(); i++) {
    if (m_perm_array[i] != i) return false;
  }
  return true;
}
 
//**************************************************************
void Permutation::append_fixed_points(Index N_new) {
  if (!N_new) return;
  Index orig_size = m_perm_array.size();
  for (Index i = 0; i < N_new; ++i) {
    m_perm_array.push_back(i + orig_size);
  }
}
 
//**************************************************************
 
Permutation Permutation::inverse() const {
  std::vector<Index> im_perm_array(size(), 0);
  for (Index i = 0; i < size(); i++) {
    im_perm_array[m_perm_array[i]] = i;
  }
  return Permutation(std::move(im_perm_array));
}
 
//**************************************************************
Permutation Permutation::make_block_permutation(
    const std::vector<Index> &block_dims) const {
  assert(block_dims.size() == size());
  std::vector<Index> block_perm;
  block_perm.reserve(sum(block_dims) * size());
  std::vector<Index> i_start(block_dims.size(), 0);
  for (Index i = 0; i + 1 < block_dims.size(); i++) {
    i_start[i + 1] = i_start[i] + block_dims[i];
  }
 
  for (Index i = 0; i < size(); i++) {
    for (Index j = 0; j < block_dims[m_perm_array[i]]; ++j) {
      block_perm.push_back(i_start[m_perm_array[i]] + j);
    }
  }
  return Permutation(std::move(block_perm));
}
 
//**************************************************************
Permutation Permutation::transformed_by(const Permutation &trans_perm) const {
  // Equivalent to Permutation(trans_perm*(*this)*trans_perm.inverse());
  // There's probably a faster element-wise implementation, but it would be
  // confusing
  return Permutation(
      trans_perm.permute(permute(trans_perm.inverse().m_perm_array)));
}
 
//**************************************************************
 
//**************************************************************
 
Permutation Permutation::operator*(const Permutation &RHS) const {
  // not sure if this is obvious.
  return Permutation(permute(RHS.m_perm_array));
}
 
//**************************************************************
 
}  // namespace CASM