Permutation.hh

Go to the documentation of this file.

// Permutation.hh

#ifndef PERMUTATION_HH
#define PERMUTATION_HH

#include "casm/container/Array.hh"

namespace CASM {


  class Permutation {
  private:
    Array<Index> m_perm_array;

  public:
    Permutation(Index N): m_perm_array(Array<Index>::sequence(0, N - 1)) {};

    Permutation(const std::vector<Index> &init_perm) {
      m_perm_array.reserve(init_perm.size());
      for(auto it = init_perm.cbegin(); it != init_perm.cend(); ++it)
        m_perm_array.push_back(*it);
    };
    Permutation(const Array<Index> &init_perm): m_perm_array(init_perm) {};
    Permutation(ReturnArray<Index> &init_perm): m_perm_array(init_perm) {};

    Index size() const {
      return m_perm_array.size();
    };

    const Array<Index> &perm_array() const {
      return m_perm_array;
    };

    bool is_perm() const;

    bool has_fixed_points() const;

    void append_fixed_points(Index N_new);

    Permutation inverse() const;

    Permutation make_block_permutation(const Array<Index> &block_dims)const;

    Permutation transformed_by(const Permutation &trans_perm) const;

    const Index  &operator[](Index i) const {
      return m_perm_array[i];
    };

    const Index  &at(Index i) const {
      return m_perm_array[i];
    };

    template<typename T>
    ReturnArray<T> permute(const Array<T> &before_array) const;

    template<typename T>
    std::vector<T> permute(const std::vector<T> &before_array) const;

    template<typename T>
    ReturnArray<T> ipermute(const Array<T> &before_array) const;

    template<typename T>
    ReturnArray<T> operator*(const Array<T> &before_array) const {
      return this->permute(before_array);
    }

    Permutation operator*(const Permutation &RHS) const;

    jsonParser &to_json(jsonParser &json) const;
    void from_json(const jsonParser &json);
  };

  jsonParser &to_json(const Permutation &value, jsonParser &json);
  void from_json(Permutation &value, const jsonParser &json);

  std::ostream &operator<<(std::ostream &, const Permutation &);

  //************************************************************************************************************************************//
  //************************************************************************************************************************************//

  template<typename T>
  ReturnArray<T> Permutation::permute(const Array<T> &before_array) const {
    assert(before_array.size() == size() && "WARNING: You're trying to permute an Array with an incompatible permutation!");

    Array<T> after_array;
    after_array.reserve(size());

    for(Index i = 0; i < size(); i++) {
      after_array.push_back(before_array[m_perm_array[i]]);
    }
    return after_array;
  }


  //************************************************************************************************************************************//

  template<typename T>
  std::vector<T> Permutation::permute(const std::vector<T> &before_vec) const {
    assert(before_vec.size() == size() && "WARNING: You're trying to permute an Array with an incompatible permutation!");

    std::vector<T> after_vec;
    after_vec.reserve(size());

    for(Index i = 0; i < size(); i++) {
      after_vec.push_back(before_vec[m_perm_array[i]]);
    }
    return after_vec;
  }

  //**************************************************************

  template<typename T>
  ReturnArray<T> Permutation::ipermute(const Array<T> &before_array) const {
    assert(before_array.size() == size() && "WARNING: You're trying to permute an Array with an incompatible permutation!");

    Array<T> 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;

  }

}


#endif