Eigen::DynamicSGroup Class Reference

Dynamic symmetry group. More...

#include <DynamicSymmetry.h>

Inheritance diagram for Eigen::DynamicSGroup:

Classes
struct	Generator
struct	GroupElement

Public Member Functions
	DynamicSGroup ()
	DynamicSGroup (const DynamicSGroup &o)
	DynamicSGroup (DynamicSGroup &&o)
DynamicSGroup &	operator= (const DynamicSGroup &o)
DynamicSGroup &	operator= (DynamicSGroup &&o)
void	add (int one, int two, int flags=0)
template<typename Gen_ >
void	add (Gen_)
void	addSymmetry (int one, int two)
void	addAntiSymmetry (int one, int two)
void	addHermiticity (int one, int two)
void	addAntiHermiticity (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
int	globalFlags () const
std::size_t	size () const
template<typename Tensor_ , typename... IndexTypes>
internal::tensor_symmetry_value_setter< Tensor_, DynamicSGroup >	operator() (Tensor_ &tensor, typename Tensor_::Index firstIndex, IndexTypes... otherIndices) const
template<typename Tensor_ >
internal::tensor_symmetry_value_setter< Tensor_, DynamicSGroup >	operator() (Tensor_ &tensor, std::array< typename Tensor_::Index, Tensor_::NumIndices > const &indices) const

Private Member Functions
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	ge (Generator const &g) const
GroupElement	mul (GroupElement, GroupElement) const
GroupElement	mul (Generator g1, GroupElement g2) const
GroupElement	mul (GroupElement g1, Generator g2) const
GroupElement	mul (Generator g1, Generator g2) const
int	findElement (GroupElement e) const
void	updateGlobalFlags (int flagDiffOfSameGenerator)

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

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.

Constructor & Destructor Documentation

DynamicSGroup() [1/3]

Eigen::DynamicSGroup::DynamicSGroup ( )

inlineexplicit

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

References ge(), and m_elements.

DynamicSGroup() [2/3]

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

inline

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

DynamicSGroup() [3/3]

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

inline

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

References m_elements, and swap().

Member Function Documentation

add() [1/2]

template<typename Gen_ >

void Eigen::DynamicSGroup::add ( Gen_  )

inline

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

References add().

add() [2/2]

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

inline

                                                          {
  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());
}

References e(), eigen_assert, findElement(), ge(), i, m_elements, m_generators, m_numIndices, mul(), p, and updateGlobalFlags().

Referenced by add(), Eigen::DynamicSGroupFromTemplateArgs< Gen >::add_all(), addAntiHermiticity(), addAntiSymmetry(), addHermiticity(), addSymmetry(), and test_symgroups_dynamic().

addAntiHermiticity()

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

inline

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

References add(), Eigen::ConjugationFlag, and Eigen::NegationFlag.

addAntiSymmetry()

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

inline

{ add(one, two, NegationFlag); }

References add(), and Eigen::NegationFlag.

addHermiticity()

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

inline

{ add(one, two, ConjugationFlag); }

References add(), and Eigen::ConjugationFlag.

addSymmetry()

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

inline

{ add(one, two, 0); }

References add().

Referenced by test_tensor_dynsym().

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

                                                                                   {
    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;
  }

References compute_granudrum_aor::args, eigen_assert, h_permute(), i, m_elements, m_numIndices, N, run(), and size().

Referenced by test_symgroups_dynamic().

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

                                                                                 {
    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;
  }

References compute_granudrum_aor::args, eigen_assert, h_permute(), i, m_elements, m_numIndices, run(), and size().

findElement()

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

inlineprivate

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

References e(), and m_elements.

Referenced by add().

ge()

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

inlineprivate

                                                   {
    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;
  }

References Eigen::DynamicSGroup::GroupElement::flags, Eigen::DynamicSGroup::Generator::flags, k, m_numIndices, Eigen::DynamicSGroup::Generator::one, Eigen::DynamicSGroup::GroupElement::representation, and Eigen::DynamicSGroup::Generator::two.

Referenced by add(), DynamicSGroup(), and mul().

globalFlags()

int Eigen::DynamicSGroup::globalFlags ( ) const

inline

{ return m_globalFlags; }

References m_globalFlags.

Referenced by test_symgroups_dynamic().

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

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

References m_elements, m_numIndices, and n.

Referenced by apply().

h_permute() [2/2]

template<typename Index >

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

inlineprivate

                                                                                 {
    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;
  }

References i, k, m_elements, and m_numIndices.

mul() [1/4]

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

inlineprivate

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

References ge(), and mul().

Referenced by mul().

mul() [2/4]

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

inlineprivate

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

References ge(), and mul().

Referenced by mul().

mul() [3/4]

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

inlineprivate

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

References ge(), and mul().

Referenced by mul().

mul() [4/4]

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

inlineprivate

                                                                                          {
  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;
}

References eigen_assert, eigen_internal_assert, Eigen::DynamicSGroup::GroupElement::flags, i, m_numIndices, Eigen::DynamicSGroup::GroupElement::representation, and v.

Referenced by add().

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

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

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

                                                                                                                     {
    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...}});
  }

operator=() [1/2]

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

inline

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

References m_elements, m_generators, m_globalFlags, and m_numIndices.

Referenced by Eigen::DynamicSGroupFromTemplateArgs< Gen >::operator=().

operator=() [2/2]

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

inline

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

References m_elements, m_generators, m_globalFlags, m_numIndices, and swap().

size()

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

inline

{ return m_elements.size(); }

References m_elements.

Referenced by apply(), and test_symgroups_dynamic().

updateGlobalFlags()

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

inlineprivate

                                                                        {
  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
       */
  }
}

References Eigen::ConjugationFlag, Eigen::GlobalImagFlag, Eigen::GlobalRealFlag, Eigen::GlobalZeroFlag, m_globalFlags, and Eigen::NegationFlag.

Referenced by add().

Member Data Documentation

m_elements

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

private

Referenced by add(), apply(), DynamicSGroup(), findElement(), h_permute(), operator=(), and size().

m_generators

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

private

Referenced by add(), and operator=().

m_globalFlags

int Eigen::DynamicSGroup::m_globalFlags

private

Referenced by globalFlags(), operator=(), and updateGlobalFlags().

m_numIndices

std::size_t Eigen::DynamicSGroup::m_numIndices

private

Referenced by add(), apply(), ge(), h_permute(), mul(), and operator=().

---

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

• DynamicSymmetry.h