Eigen::DynamicSGroup Class Reference

Dynamic symmetry group. More...

Inheritance diagram for Eigen::DynamicSGroup:

Classes
struct	Generator
struct	GroupElement

Public Member Functions
template<typename Gen_ >
void	add (Gen_)
void	add (int one, int two, int flags=0)
void	addAntiHermiticity (int one, int two)
void	addAntiSymmetry (int one, int two)
void	addHermiticity (int one, int two)
void	addSymmetry (int one, int two)
template<typename Op , typename RV , typename Index , std::size_t N, typename... Args>
RV	apply (const std::array< Index, N > &idx, RV initial, Args &&... args) const
template<typename Op , typename RV , typename Index , typename... Args>
RV	apply (const std::vector< Index > &idx, RV initial, Args &&... args) const
	DynamicSGroup ()
	DynamicSGroup (const DynamicSGroup &o)
	DynamicSGroup (DynamicSGroup &&o)
int	globalFlags () const
template<typename Tensor_ >
internal::tensor_symmetry_value_setter< Tensor_, DynamicSGroup >	operator() (Tensor_ &tensor, std::array< typename Tensor_::Index, Tensor_::NumIndices > const &indices) const
template<typename Tensor_ , typename... IndexTypes>
internal::tensor_symmetry_value_setter< Tensor_, DynamicSGroup >	operator() (Tensor_ &tensor, typename Tensor_::Index firstIndex, IndexTypes... otherIndices) const
DynamicSGroup &	operator= (const DynamicSGroup &o)
DynamicSGroup &	operator= (DynamicSGroup &&o)
std::size_t	size () const

Private Member Functions
int	findElement (GroupElement e) const
GroupElement	ge (Generator const &g) const
template<typename Index , std::size_t N, int... n>
std::array< Index, N >	h_permute (std::size_t which, const std::array< Index, N > &idx, internal::numeric_list< int, n... >) const
template<typename Index >
std::vector< Index >	h_permute (std::size_t which, std::vector< Index > idx) const
GroupElement	mul (Generator g1, Generator g2) const
GroupElement	mul (Generator g1, GroupElement g2) const
GroupElement	mul (GroupElement g1, Generator g2) const
GroupElement	mul (GroupElement, GroupElement) const
void	updateGlobalFlags (int flagDiffOfSameGenerator)

Private Attributes
std::vector< GroupElement >	m_elements
std::vector< Generator >	m_generators
int	m_globalFlags
std::size_t	m_numIndices

Detailed Description

Dynamic symmetry group.

The DynamicSGroup class represents a symmetry group that need not be known at compile time. It is useful if one wants to support arbitrary run-time defineable symmetries for tensors, but it is also instantiated if a symmetry group is defined at compile time that would be either too large for the compiler to reasonably generate (using templates to calculate this at compile time is very inefficient) or that the compiler could generate the group but that it wouldn't make sense to unroll the loop for setting coefficients anymore.

Definition at line 17 of file DynamicSymmetry.h.

Constructor & Destructor Documentation

DynamicSGroup() [1/3]

Eigen::DynamicSGroup::DynamicSGroup ( )

inlineexplicit

Definition at line 20 of file DynamicSymmetry.h.

: m_numIndices(1), m_elements(), m_generators(), m_globalFlags(0) { m_elements.push_back(ge(Generator(0, 0, 0))); }

Code

DynamicSGroup() [2/3]

Eigen::DynamicSGroup::DynamicSGroup ( const DynamicSGroup &  o )

inline

Definition at line 21 of file DynamicSymmetry.h.

: m_numIndices(o.m_numIndices), m_elements(o.m_elements), m_generators(o.m_generators), m_globalFlags(o.m_globalFlags) { }

Code

DynamicSGroup() [3/3]

Eigen::DynamicSGroup::DynamicSGroup ( DynamicSGroup &&  o )

inline

Definition at line 22 of file DynamicSymmetry.h.

: m_numIndices(o.m_numIndices), m_elements(), m_generators(o.m_generators), m_globalFlags(o.m_globalFlags) { std::swap(m_elements, o.m_elements); }

Code

Member Function Documentation

add() [1/2]

template<typename Gen_ >

void Eigen::DynamicSGroup::add ( Gen_  )

inline

Definition at line 29 of file DynamicSymmetry.h.

{ add(Gen_::One, Gen_::Two, Gen_::Flags); }

Code

add() [2/2]

void Eigen::DynamicSGroup::add ( int  one, int  two, int  flags = 0  )

inline

Definition at line 197 of file DynamicSymmetry.h.

{
  eigen_assert(one >= 0);
  eigen_assert(two >= 0);
  eigen_assert(one != two);
 
  if ((std::size_t)one >= m_numIndices || (std::size_t)two >= m_numIndices) {
    std::size_t newNumIndices = (one > two) ? one : two + 1;
    for (auto& gelem : m_elements) {
      gelem.representation.reserve(newNumIndices);
      for (std::size_t i = m_numIndices; i < newNumIndices; i++)
        gelem.representation.push_back(i);
    }
    m_numIndices = newNumIndices;
  }
 
  Generator g{one, two, flags};
  GroupElement e = ge(g);
 
  /* special case for first generator */
  if (m_elements.size() == 1) {
    while (!e.isId()) {
      m_elements.push_back(e);
      e = mul(e, g);
    }
 
    if (e.flags > 0)
      updateGlobalFlags(e.flags);
 
    // only add in case we didn't have identity
    if (m_elements.size() > 1)
      m_generators.push_back(g);
    return;
  }
 
  int p = findElement(e);
  if (p >= 0) {
    updateGlobalFlags(p);
    return;
  }
 
  std::size_t coset_order = m_elements.size();
  m_elements.push_back(e);
  for (std::size_t i = 1; i < coset_order; i++)
    m_elements.push_back(mul(m_elements[i], e));
  m_generators.push_back(g);
 
  std::size_t coset_rep = coset_order;
  do {
    for (auto g : m_generators) {
      e = mul(m_elements[coset_rep], g);
      p = findElement(e);
      if (p < 0) {
        // element not yet in group
        m_elements.push_back(e);
        for (std::size_t i = 1; i < coset_order; i++)
          m_elements.push_back(mul(m_elements[i], e));
      } else if (p > 0) {
        updateGlobalFlags(p);
      }
    }
    coset_rep += coset_order;
  } while (coset_rep < m_elements.size());
}

Code

addAntiHermiticity()

void Eigen::DynamicSGroup::addAntiHermiticity ( int  one, int  two  )

inline

Definition at line 33 of file DynamicSymmetry.h.

{ add(one, two, NegationFlag | ConjugationFlag); }

Code

addAntiSymmetry()

void Eigen::DynamicSGroup::addAntiSymmetry ( int  one, int  two  )

inline

Definition at line 31 of file DynamicSymmetry.h.

{ add(one, two, NegationFlag); }

Code

addHermiticity()

void Eigen::DynamicSGroup::addHermiticity ( int  one, int  two  )

inline

Definition at line 32 of file DynamicSymmetry.h.

{ add(one, two, ConjugationFlag); }

Code

addSymmetry()

void Eigen::DynamicSGroup::addSymmetry ( int  one, int  two  )

inline

Definition at line 30 of file DynamicSymmetry.h.

{ add(one, two, 0); }

Code

apply() [1/2]

template<typename Op , typename RV , typename Index , std::size_t N, typename... Args>

RV Eigen::DynamicSGroup::apply ( const std::array< Index, N > &  idx, RV  initial, Args &&...  args  ) const

inline

Definition at line 36 of file DynamicSymmetry.h.

    {
      eigen_assert(N >= m_numIndices && "Can only apply symmetry group to objects that have at least the required amount of indices.");
      for (std::size_t i = 0; i < size(); i++)
        initial = Op::run(h_permute(i, idx, typename internal::gen_numeric_list<int, N>::type()), m_elements[i].flags, initial, std::forward<Args>(args)...);
      return initial;
    }

Code

apply() [2/2]

template<typename Op , typename RV , typename Index , typename... Args>

RV Eigen::DynamicSGroup::apply ( const std::vector< Index > &  idx, RV  initial, Args &&...  args  ) const

inline

Definition at line 45 of file DynamicSymmetry.h.

    {
      eigen_assert(idx.size() >= m_numIndices && "Can only apply symmetry group to objects that have at least the required amount of indices.");
      for (std::size_t i = 0; i < size(); i++)
        initial = Op::run(h_permute(i, idx), m_elements[i].flags, initial, std::forward<Args>(args)...);
      return initial;
    }

Code

findElement()

int Eigen::DynamicSGroup::findElement ( GroupElement  e ) const

inlineprivate

Definition at line 142 of file DynamicSymmetry.h.

    {
      for (auto ee : m_elements) {
        if (ee.representation == e.representation)
          return ee.flags ^ e.flags;
      }
      return -1;
    }

Code

ge()

GroupElement Eigen::DynamicSGroup::ge ( Generator const &  g ) const

inlineprivate

Definition at line 110 of file DynamicSymmetry.h.

    {
      GroupElement result;
      result.representation.reserve(m_numIndices);
      result.flags = g.flags;
      for (std::size_t k = 0; k < m_numIndices; k++) {
        if (k == (std::size_t)g.one)
          result.representation.push_back(g.two);
        else if (k == (std::size_t)g.two)
          result.representation.push_back(g.one);
        else
          result.representation.push_back(int(k));
      }
      return result;
    }

Code

globalFlags()

int Eigen::DynamicSGroup::globalFlags ( ) const

inline

Definition at line 53 of file DynamicSymmetry.h.

{ return m_globalFlags; }

Code

h_permute() [1/2]

template<typename Index , std::size_t N, int... n>

std::array<Index, N> Eigen::DynamicSGroup::h_permute ( std::size_t  which, const std::array< Index, N > &  idx, internal::numeric_list< int, n... >    ) const

inlineprivate

Definition at line 93 of file DynamicSymmetry.h.

    {
      return std::array<Index, N>{{ idx[n >= m_numIndices ? n : m_elements[which].representation[n]]... }};
    }

Code

h_permute() [2/2]

template<typename Index >

std::vector<Index> Eigen::DynamicSGroup::h_permute ( std::size_t  which, std::vector< Index >  idx  ) const

inlineprivate

Definition at line 99 of file DynamicSymmetry.h.

    {
      std::vector<Index> result;
      result.reserve(idx.size());
      for (auto k : m_elements[which].representation)
        result.push_back(idx[k]);
      for (std::size_t i = m_numIndices; i < idx.size(); i++)
        result.push_back(idx[i]);
      return result;
    }

Code

mul() [1/4]

GroupElement Eigen::DynamicSGroup::mul ( Generator  g1, Generator  g2  ) const

inlineprivate

Definition at line 137 of file DynamicSymmetry.h.

    {
      return mul(ge(g1), ge(g2));
    }

Code

mul() [2/4]

GroupElement Eigen::DynamicSGroup::mul ( Generator  g1, GroupElement  g2  ) const

inlineprivate

Definition at line 127 of file DynamicSymmetry.h.

    {
      return mul(ge(g1), g2);
    }

Code

mul() [3/4]

GroupElement Eigen::DynamicSGroup::mul ( GroupElement  g1, Generator  g2  ) const

inlineprivate

Definition at line 132 of file DynamicSymmetry.h.

    {
      return mul(g1, ge(g2));
    }

Code

mul() [4/4]

DynamicSGroup::GroupElement Eigen::DynamicSGroup::mul ( GroupElement  g1, GroupElement  g2  ) const

inlineprivate

Definition at line 181 of file DynamicSymmetry.h.

{
  eigen_internal_assert(g1.representation.size() == m_numIndices);
  eigen_internal_assert(g2.representation.size() == m_numIndices);
 
  GroupElement result;
  result.representation.reserve(m_numIndices);
  for (std::size_t i = 0; i < m_numIndices; i++) {
    int v = g2.representation[g1.representation[i]];
    eigen_assert(v >= 0);
    result.representation.push_back(v);
  }
  result.flags = g1.flags ^ g2.flags;
  return result;
}

Code

operator()() [1/2]

template<typename Tensor_ >

internal::tensor_symmetry_value_setter<Tensor_, DynamicSGroup> Eigen::DynamicSGroup::operator() ( Tensor_ &  tensor, std::array< typename Tensor_::Index, Tensor_::NumIndices > const &  indices  ) const

inline

Definition at line 64 of file DynamicSymmetry.h.

    {
      return internal::tensor_symmetry_value_setter<Tensor_, DynamicSGroup>(tensor, *this, indices);
    }

Code

operator()() [2/2]

template<typename Tensor_ , typename... IndexTypes>

internal::tensor_symmetry_value_setter<Tensor_, DynamicSGroup> Eigen::DynamicSGroup::operator() ( Tensor_ &  tensor, typename Tensor_::Index  firstIndex, IndexTypes...  otherIndices  ) const

inline

Definition at line 57 of file DynamicSymmetry.h.

    {
      static_assert(sizeof...(otherIndices) + 1 == Tensor_::NumIndices, "Number of indices used to access a tensor coefficient must be equal to the rank of the tensor.");
      return operator()(tensor, std::array<typename Tensor_::Index, Tensor_::NumIndices>{{firstIndex, otherIndices...}});
    }

Code

operator=() [1/2]

DynamicSGroup& Eigen::DynamicSGroup::operator= ( const DynamicSGroup &  o )

inline

Definition at line 23 of file DynamicSymmetry.h.

{ m_numIndices = o.m_numIndices; m_elements = o.m_elements; m_generators = o.m_generators; m_globalFlags = o.m_globalFlags; return *this; }

Code

operator=() [2/2]

DynamicSGroup& Eigen::DynamicSGroup::operator= ( DynamicSGroup &&  o )

inline

Definition at line 24 of file DynamicSymmetry.h.

{ m_numIndices = o.m_numIndices; std::swap(m_elements, o.m_elements); m_generators = o.m_generators; m_globalFlags = o.m_globalFlags; return *this; }

Code

size()

std::size_t Eigen::DynamicSGroup::size ( ) const

inline

Definition at line 54 of file DynamicSymmetry.h.

{ return m_elements.size(); }

Code

updateGlobalFlags()

void Eigen::DynamicSGroup::updateGlobalFlags ( int  flagDiffOfSameGenerator )

inlineprivate

Definition at line 262 of file DynamicSymmetry.h.

{
    switch (flagDiffOfSameGenerator) {
      case 0:
      default:
        // nothing happened
        break;
      case NegationFlag:
        // every element is it's own negative => whole tensor is zero
        m_globalFlags |= GlobalZeroFlag;
        break;
      case ConjugationFlag:
        // every element is it's own conjugate => whole tensor is real
        m_globalFlags |= GlobalRealFlag;
        break;
      case (NegationFlag | ConjugationFlag):
        // every element is it's own negative conjugate => whole tensor is imaginary
        m_globalFlags |= GlobalImagFlag;
        break;
      /* NOTE:
       *   since GlobalZeroFlag == GlobalRealFlag | GlobalImagFlag, if one generator
       *   causes the tensor to be real and the next one to be imaginary, this will
       *   trivially give the correct result
       */
    }
}

Code

Member Data Documentation

m_elements

std::vector<GroupElement> Eigen::DynamicSGroup::m_elements

private

Definition at line 88 of file DynamicSymmetry.h.

m_generators

std::vector<Generator> Eigen::DynamicSGroup::m_generators

private

Definition at line 89 of file DynamicSymmetry.h.

m_globalFlags

int Eigen::DynamicSGroup::m_globalFlags

private

Definition at line 90 of file DynamicSymmetry.h.

m_numIndices

std::size_t Eigen::DynamicSGroup::m_numIndices

private

Definition at line 87 of file DynamicSymmetry.h.

---

The documentation for this class was generated from the following file:

• DynamicSymmetry.h