Laboratoire ICAR » Plateforme TXM

// This file is part of Eigen, a lightweight C++ template library

// for linear algebra.

//

// Copyright (C) 2013 Christian Seiler <christian@iwakd.de>

//

// This Source Code Form is subject to the terms of the Mozilla

// Public License v. 2.0. If a copy of the MPL was not distributed

// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.

#ifndef EIGEN_CXX11_TENSORSYMMETRY_TEMPLATEGROUPTHEORY_H

#define EIGEN_CXX11_TENSORSYMMETRY_TEMPLATEGROUPTHEORY_H

namespace Eigen {

namespace internal {

namespace group_theory {

/** \internal

  * \file CXX11/src/TensorSymmetry/util/TemplateGroupTheory.h

  * This file contains C++ templates that implement group theory algorithms.

  *

  * The algorithms allow for a compile-time analysis of finite groups.

  *

  * Currently only Dimino's algorithm is implemented, which returns a list

  * of all elements in a group given a set of (possibly redundant) generators.

  * (One could also do that with the so-called orbital algorithm, but that

  * is much more expensive and usually has no advantages.)

  */

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

 *                "Ok kid, here is where it gets complicated."

 *                         - Amelia Pond in the "Doctor Who" episode

 *                           "The Big Bang"

 *

 * Dimino's algorithm

 * ==================

 *

 * The following is Dimino's algorithm in sequential form:

 *

 * Input: identity element, list of generators, equality check,

 *        multiplication operation

 * Output: list of group elements

 *

 * 1. add identity element

 * 2. remove identities from list of generators

 * 3. add all powers of first generator that aren't the

 *    identity element

 * 4. go through all remaining generators:

 *        a. if generator is already in the list of elements

 *                -> do nothing

 *        b. otherwise

 *                i.   remember current # of elements

 *                     (i.e. the size of the current subgroup)

 *                ii.  add all current elements (which includes

 *                     the identity) each multiplied from right

 *                     with the current generator to the group

 *                iii. add all remaining cosets that are generated

 *                     by products of the new generator with itself

 *                     and all other generators seen so far

 *

 * In functional form, this is implemented as a long set of recursive

 * templates that have a complicated relationship.

 *

 * The main interface for Dimino's algorithm is the template

 * enumerate_group_elements. All lists are implemented as variadic

 * type_list<typename...> and numeric_list<typename = int, int...>

 * templates.

 *

 * 'Calling' templates is usually done via typedefs.

 *

 * This algorithm is an extended version of the basic version. The

 * extension consists in the fact that each group element has a set

 * of flags associated with it. Multiplication of two group elements

 * with each other results in a group element whose flags are the

 * XOR of the flags of the previous elements. Each time the algorithm

 * notices that a group element it just calculated is already in the

 * list of current elements, the flags of both will be compared and

 * added to the so-called 'global flags' of the group.

 *

 * The rationale behind this extension is that this allows not only

 * for the description of symmetries between tensor indices, but

 * also allows for the description of hermiticity, antisymmetry and

 * antihermiticity. Negation and conjugation each are specific bit

 * in the flags value and if two different ways to reach a group

 * element lead to two different flags, this poses a constraint on

 * the allowed values of the resulting tensor. For example, if a

 * group element is reach both with and without the conjugation

 * flags, it is clear that the resulting tensor has to be real.

 *

 * Note that this flag mechanism is quite generic and may have other

 * uses beyond tensor properties.

 *

 * IMPORTANT: 

 *     This algorithm assumes the group to be finite. If you try to

 *     run it with a group that's infinite, the algorithm will only

 *     terminate once you hit a compiler limit (max template depth).

 *     Also note that trying to use this implementation to create a

 *     very large group will probably either make you hit the same

 *     limit, cause the compiler to segfault or at the very least

 *     take a *really* long time (hours, days, weeks - sic!) to

 *     compile. It is not recommended to plug in more than 4

 *     generators, unless they are independent of each other.

 */

/** \internal

  *

  * \class strip_identities

  * \ingroup CXX11_TensorSymmetry_Module

  *

  * \brief Cleanse a list of group elements of the identity element

  *

  * This template is used to make a first pass through all initial

  * generators of Dimino's algorithm and remove the identity

  * elements.

  *

  * \sa enumerate_group_elements

  */

template<template<typename, typename> class Equality, typename id, typename L> struct strip_identities;

template<

  template<typename, typename> class Equality,

  typename id,

  typename t,

  typename... ts

>

struct strip_identities<Equality, id, type_list<t, ts...>>

{

  typedef typename conditional<

    Equality<id, t>::value,

    typename strip_identities<Equality, id, type_list<ts...>>::type,

    typename concat<type_list<t>, typename strip_identities<Equality, id, type_list<ts...>>::type>::type

  >::type type;

  constexpr static int global_flags = Equality<id, t>::global_flags | strip_identities<Equality, id, type_list<ts...>>::global_flags;

};

template<

  template<typename, typename> class Equality,

  typename id

  EIGEN_TPL_PP_SPEC_HACK_DEFC(typename, ts)

>

struct strip_identities<Equality, id, type_list<EIGEN_TPL_PP_SPEC_HACK_USE(ts)>>

{

  typedef type_list<> type;

  constexpr static int global_flags = 0;

};

/** \internal

  *

  * \class dimino_first_step_elements_helper 

  * \ingroup CXX11_TensorSymmetry_Module

  *

  * \brief Recursive template that adds powers of the first generator to the list of group elements

  *

  * This template calls itself recursively to add powers of the first

  * generator to the list of group elements. It stops if it reaches

  * the identity element again.

  *

  * \sa enumerate_group_elements, dimino_first_step_elements

  */

template<

  template<typename, typename> class Multiply,

  template<typename, typename> class Equality,

  typename id,

  typename g,

  typename current_element,

  typename elements,

  bool dont_add_current_element   // = false

>

struct dimino_first_step_elements_helper

#ifndef EIGEN_PARSED_BY_DOXYGEN

  : // recursive inheritance is too difficult for Doxygen

  public dimino_first_step_elements_helper<

    Multiply,

    Equality,

    id,

    g,

    typename Multiply<current_element, g>::type,

    typename concat<elements, type_list<current_element>>::type,

    Equality<typename Multiply<current_element, g>::type, id>::value

  > {};

template<

  template<typename, typename> class Multiply,

  template<typename, typename> class Equality,

  typename id,

  typename g,

  typename current_element,

  typename elements

>

struct dimino_first_step_elements_helper<Multiply, Equality, id, g, current_element, elements, true>

#endif // EIGEN_PARSED_BY_DOXYGEN

{

  typedef elements type;

  constexpr static int global_flags = Equality<current_element, id>::global_flags;

};

/** \internal

  *

  * \class dimino_first_step_elements

  * \ingroup CXX11_TensorSymmetry_Module

  *

  * \brief Add all powers of the first generator to the list of group elements

  *

  * This template takes the first non-identity generator and generates the initial

  * list of elements which consists of all powers of that generator. For a group

  * with just one generated, it would be enumerated after this.

  *

  * \sa enumerate_group_elements

  */

template<

  template<typename, typename> class Multiply,

  template<typename, typename> class Equality,

  typename id,

  typename generators

>

struct dimino_first_step_elements

{

  typedef typename get<0, generators>::type first_generator;

  typedef typename skip<1, generators>::type next_generators;

  typedef type_list<first_generator> generators_done;

  typedef dimino_first_step_elements_helper<

    Multiply,

    Equality,

    id,

    first_generator,

    first_generator,

    type_list<id>,

    false

  > helper;

  typedef typename helper::type type;

  constexpr static int global_flags = helper::global_flags;

};

/** \internal

  *

  * \class dimino_get_coset_elements

  * \ingroup CXX11_TensorSymmetry_Module

  *

  * \brief Generate all elements of a specific coset

  *

  * This template generates all the elements of a specific coset by

  * multiplying all elements in the given subgroup with the new

  * coset representative. Note that the first element of the

  * subgroup is always the identity element, so the first element of

  * ther result of this template is going to be the coset

  * representative itself.

  *

  * Note that this template accepts an additional boolean parameter

  * that specifies whether to actually generate the coset (true) or

  * just return an empty list (false).

  *

  * \sa enumerate_group_elements, dimino_add_cosets_for_rep

  */

template<

  template<typename, typename> class Multiply,

  typename sub_group_elements,

  typename new_coset_rep,

  bool generate_coset      // = true

>

struct dimino_get_coset_elements

{

  typedef typename apply_op_from_right<Multiply, new_coset_rep, sub_group_elements>::type type;

};

template<

  template<typename, typename> class Multiply,

  typename sub_group_elements,

  typename new_coset_rep

>

struct dimino_get_coset_elements<Multiply, sub_group_elements, new_coset_rep, false>

{

  typedef type_list<> type;

};

/** \internal

  *

  * \class dimino_add_cosets_for_rep

  * \ingroup CXX11_TensorSymmetry_Module

  *

  * \brief Recursive template for adding coset spaces

  *

  * This template multiplies the coset representative with a generator

  * from the list of previous generators. If the new element is not in

  * the group already, it adds the corresponding coset. Finally it

  * proceeds to call itself with the next generator from the list.

  *

  * \sa enumerate_group_elements, dimino_add_all_coset_spaces

  */

template<

  template<typename, typename> class Multiply,

  template<typename, typename> class Equality,

  typename id,

  typename sub_group_elements,

  typename elements,

  typename generators,

  typename rep_element,

  int sub_group_size

>

struct dimino_add_cosets_for_rep;

template<

  template<typename, typename> class Multiply,

  template<typename, typename> class Equality,

  typename id,

  typename sub_group_elements,

  typename elements,

  typename g,

  typename... gs,

  typename rep_element,

  int sub_group_size

>

struct dimino_add_cosets_for_rep<Multiply, Equality, id, sub_group_elements, elements, type_list<g, gs...>, rep_element, sub_group_size>

{

  typedef typename Multiply<rep_element, g>::type new_coset_rep;

  typedef contained_in_list_gf<Equality, new_coset_rep, elements> _cil;

  constexpr static bool add_coset = !_cil::value;

  typedef typename dimino_get_coset_elements<

    Multiply,

    sub_group_elements,

    new_coset_rep,

    add_coset

  >::type coset_elements;

  typedef dimino_add_cosets_for_rep<

    Multiply,

    Equality,

    id,

    sub_group_elements,

    typename concat<elements, coset_elements>::type,

    type_list<gs...>,

    rep_element,

    sub_group_size

  > _helper;

  typedef typename _helper::type type;

  constexpr static int global_flags = _cil::global_flags | _helper::global_flags;

  /* Note that we don't have to update global flags here, since

   * we will only add these elements if they are not part of

   * the group already. But that only happens if the coset rep

   * is not already in the group, so the check for the coset rep

   * will catch this.

   */

};

template<

  template<typename, typename> class Multiply,

  template<typename, typename> class Equality,

  typename id,

  typename sub_group_elements,

  typename elements

  EIGEN_TPL_PP_SPEC_HACK_DEFC(typename, empty),

  typename rep_element,

  int sub_group_size

>

struct dimino_add_cosets_for_rep<Multiply, Equality, id, sub_group_elements, elements, type_list<EIGEN_TPL_PP_SPEC_HACK_USE(empty)>, rep_element, sub_group_size>

{

  typedef elements type;

  constexpr static int global_flags = 0;

};

/** \internal

  *

  * \class dimino_add_all_coset_spaces

  * \ingroup CXX11_TensorSymmetry_Module

  *

  * \brief Recursive template for adding all coset spaces for a new generator

  *

  * This template tries to go through the list of generators (with

  * the help of the dimino_add_cosets_for_rep template) as long as

  * it still finds elements that are not part of the group and add

  * the corresponding cosets.

  *

  * \sa enumerate_group_elements, dimino_add_cosets_for_rep

  */

template<

  template<typename, typename> class Multiply,

  template<typename, typename> class Equality,

  typename id,

  typename sub_group_elements,

  typename elements,

  typename generators,

  int sub_group_size,

  int rep_pos,

  bool stop_condition        // = false

>

struct dimino_add_all_coset_spaces

{

  typedef typename get<rep_pos, elements>::type rep_element;

  typedef dimino_add_cosets_for_rep<

    Multiply,

    Equality,

    id,

    sub_group_elements,

    elements,

    generators,

    rep_element,

    sub_group_elements::count

  > _ac4r;

  typedef typename _ac4r::type new_elements;

  constexpr static int new_rep_pos = rep_pos + sub_group_elements::count;

  constexpr static bool new_stop_condition = new_rep_pos >= new_elements::count;

  typedef dimino_add_all_coset_spaces<

    Multiply,

    Equality,

    id,

    sub_group_elements,

    new_elements,

    generators,

    sub_group_size,

    new_rep_pos,

    new_stop_condition

  > _helper;

  typedef typename _helper::type type;

  constexpr static int global_flags = _helper::global_flags | _ac4r::global_flags;

};

template<

  template<typename, typename> class Multiply,

  template<typename, typename> class Equality,

  typename id,

  typename sub_group_elements,

  typename elements,

  typename generators,

  int sub_group_size,

  int rep_pos

>

struct dimino_add_all_coset_spaces<Multiply, Equality, id, sub_group_elements, elements, generators, sub_group_size, rep_pos, true>

{

  typedef elements type;

  constexpr static int global_flags = 0;

};

/** \internal

  *

  * \class dimino_add_generator

  * \ingroup CXX11_TensorSymmetry_Module

  *

  * \brief Enlarge the group by adding a new generator.

  *

  * It accepts a boolean parameter that determines if the generator is redundant,

  * i.e. was already seen in the group. In that case, it reduces to a no-op.

  *

  * \sa enumerate_group_elements, dimino_add_all_coset_spaces

  */

template<

  template<typename, typename> class Multiply,

  template<typename, typename> class Equality,

  typename id,

  typename elements,

  typename generators_done,

  typename current_generator,

  bool redundant          // = false

>

struct dimino_add_generator

{

  /* this template is only called if the generator is not redundant

   * => all elements of the group multiplied with the new generator

   *    are going to be new elements of the most trivial coset space

   */

  typedef typename apply_op_from_right<Multiply, current_generator, elements>::type multiplied_elements;

  typedef typename concat<elements, multiplied_elements>::type new_elements;

  constexpr static int rep_pos = elements::count;

  typedef dimino_add_all_coset_spaces<

    Multiply,

    Equality,

    id,

    elements, // elements of previous subgroup

    new_elements,

    typename concat<generators_done, type_list<current_generator>>::type,

    elements::count, // size of previous subgroup

    rep_pos,

    false // don't stop (because rep_pos >= new_elements::count is always false at this point)

  > _helper;

  typedef typename _helper::type type;

  constexpr static int global_flags = _helper::global_flags;

};

template<

  template<typename, typename> class Multiply,

  template<typename, typename> class Equality,

  typename id,

  typename elements,

  typename generators_done,

  typename current_generator

>

struct dimino_add_generator<Multiply, Equality, id, elements, generators_done, current_generator, true>

{

  // redundant case

  typedef elements type;

  constexpr static int global_flags = 0;

};

/** \internal

  *

  * \class dimino_add_remaining_generators

  * \ingroup CXX11_TensorSymmetry_Module

  *

  * \brief Recursive template that adds all remaining generators to a group

  *

  * Loop through the list of generators that remain and successively

  * add them to the group.

  *

  * \sa enumerate_group_elements, dimino_add_generator

  */

template<

  template<typename, typename> class Multiply,

  template<typename, typename> class Equality,

  typename id,

  typename generators_done,

  typename remaining_generators,

  typename elements

>

struct dimino_add_remaining_generators

{

  typedef typename get<0, remaining_generators>::type first_generator;

  typedef typename skip<1, remaining_generators>::type next_generators;

  typedef contained_in_list_gf<Equality, first_generator, elements> _cil;

  typedef dimino_add_generator<

    Multiply,

    Equality,

    id,

    elements,

    generators_done,

    first_generator,

    _cil::value

  > _helper;

  typedef typename _helper::type new_elements;

  typedef dimino_add_remaining_generators<

    Multiply,

    Equality,

    id,

    typename concat<generators_done, type_list<first_generator>>::type,

    next_generators,

    new_elements

  > _next_iter;

  typedef typename _next_iter::type type;

  constexpr static int global_flags =

    _cil::global_flags |

    _helper::global_flags |

    _next_iter::global_flags;

};

template<

  template<typename, typename> class Multiply,

  template<typename, typename> class Equality,

  typename id,

  typename generators_done,

  typename elements

>

struct dimino_add_remaining_generators<Multiply, Equality, id, generators_done, type_list<>, elements>

{

  typedef elements type;

  constexpr static int global_flags = 0;

};

/** \internal

  *

  * \class enumerate_group_elements_noid

  * \ingroup CXX11_TensorSymmetry_Module

  *

  * \brief Helper template that implements group element enumeration

  *

  * This is a helper template that implements the actual enumeration

  * of group elements. This has been split so that the list of

  * generators can be cleansed of the identity element before

  * performing the actual operation.

  *

  * \sa enumerate_group_elements

  */

template<

  template<typename, typename> class Multiply,

  template<typename, typename> class Equality,

  typename id,

  typename generators,

  int initial_global_flags = 0

>

struct enumerate_group_elements_noid

{

  typedef dimino_first_step_elements<Multiply, Equality, id, generators> first_step;

  typedef typename first_step::type first_step_elements;

  typedef dimino_add_remaining_generators<

    Multiply,

    Equality,

    id,

    typename first_step::generators_done,

    typename first_step::next_generators, // remaining_generators

    typename first_step::type // first_step elements

  > _helper;

  typedef typename _helper::type type;

  constexpr static int global_flags =

    initial_global_flags |

    first_step::global_flags |

    _helper::global_flags;

};

// in case when no generators are specified

template<

  template<typename, typename> class Multiply,

  template<typename, typename> class Equality,

  typename id,

  int initial_global_flags

>

struct enumerate_group_elements_noid<Multiply, Equality, id, type_list<>, initial_global_flags>

{

  typedef type_list<id> type;

  constexpr static int global_flags = initial_global_flags;

};

/** \internal

  *

  * \class enumerate_group_elements

  * \ingroup CXX11_TensorSymmetry_Module

  *

  * \brief Enumerate all elements in a finite group

  *

  * This template enumerates all elements in a finite group. It accepts

  * the following template parameters:

  *

  * \tparam Multiply      The multiplication operation that multiplies two group elements

  *                       with each other.

  * \tparam Equality      The equality check operation that checks if two group elements

  *                       are equal to another.

  * \tparam id            The identity element

  * \tparam _generators   A list of (possibly redundant) generators of the group

  */

template<

  template<typename, typename> class Multiply,

  template<typename, typename> class Equality,

  typename id,

  typename _generators

>

struct enumerate_group_elements

  : public enumerate_group_elements_noid<

      Multiply,

      Equality,

      id,

      typename strip_identities<Equality, id, _generators>::type,

      strip_identities<Equality, id, _generators>::global_flags

    >

{

};

} // end namespace group_theory

} // end namespace internal

} // end namespace Eigen

#endif // EIGEN_CXX11_TENSORSYMMETRY_TEMPLATEGROUPTHEORY_H

/*

 * kate: space-indent on; indent-width 2; mixedindent off; indent-mode cstyle;

 */

// This file is part of Eigen, a lightweight C++ template library

// for linear algebra.

//

// Copyright (C) 2013 Christian Seiler <christian@iwakd.de>

//

// This Source Code Form is subject to the terms of the Mozilla

// Public License v. 2.0. If a copy of the MPL was not distributed

// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.

#ifndef EIGEN_CXX11_TENSORSYMMETRY_SYMMETRY_H

#define EIGEN_CXX11_TENSORSYMMETRY_SYMMETRY_H

namespace Eigen {

enum {

  NegationFlag           = 0x01,

  ConjugationFlag        = 0x02

};

enum {

  GlobalRealFlag         = 0x01,

  GlobalImagFlag         = 0x02,

  GlobalZeroFlag         = 0x03

};

namespace internal {

template<std::size_t NumIndices, typename... Sym>                   struct tensor_symmetry_pre_analysis;

template<std::size_t NumIndices, typename... Sym>                   struct tensor_static_symgroup;

template<bool instantiate, std::size_t NumIndices, typename... Sym> struct tensor_static_symgroup_if;

template<typename Tensor_> struct tensor_symmetry_calculate_flags;

template<typename Tensor_> struct tensor_symmetry_assign_value;

template<typename... Sym> struct tensor_symmetry_num_indices;

} // end namespace internal

template<int One_, int Two_>

struct Symmetry

{

  static_assert(One_ != Two_, "Symmetries must cover distinct indices.");

  constexpr static int One = One_;

  constexpr static int Two = Two_;

  constexpr static int Flags = 0;

};

template<int One_, int Two_>

struct AntiSymmetry

{

  static_assert(One_ != Two_, "Symmetries must cover distinct indices.");

  constexpr static int One = One_;

  constexpr static int Two = Two_;

  constexpr static int Flags = NegationFlag;

};

template<int One_, int Two_>

struct Hermiticity

{

  static_assert(One_ != Two_, "Symmetries must cover distinct indices.");

  constexpr static int One = One_;

  constexpr static int Two = Two_;

  constexpr static int Flags = ConjugationFlag;

};

template<int One_, int Two_>

struct AntiHermiticity

{

  static_assert(One_ != Two_, "Symmetries must cover distinct indices.");

  constexpr static int One = One_;

  constexpr static int Two = Two_;

  constexpr static int Flags = ConjugationFlag | NegationFlag;

};

/** \class DynamicSGroup

  * \ingroup TensorSymmetry_Module

  *

  * \brief 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.

  */

class DynamicSGroup;

/** \internal

  *

  * \class DynamicSGroupFromTemplateArgs

  * \ingroup TensorSymmetry_Module

  *

  * \brief Dynamic symmetry group, initialized from template arguments

  *

  * This class is a child class of DynamicSGroup. It uses the template arguments

  * specified to initialize itself.

  */

template<typename... Gen>

class DynamicSGroupFromTemplateArgs;

/** \class StaticSGroup

  * \ingroup TensorSymmetry_Module

  *

  * \brief Static symmetry group

  *

  * This class represents a symmetry group that is known and resolved completely

  * at compile time. Ideally, no run-time penalty is incurred compared to the

  * manual unrolling of the symmetry.

  *

  * <b><i>CAUTION:</i></b>

  *

  * Do not use this class directly for large symmetry groups. The compiler

  * may run into a limit, or segfault or in the very least will take a very,

  * very, very long time to compile the code. Use the SGroup class instead

  * if you want a static group. That class contains logic that will

  * automatically select the DynamicSGroup class instead if the symmetry

  * group becomes too large. (In that case, unrolling may not even be

  * beneficial.)

  */

template<typename... Gen>

class StaticSGroup;

/** \class SGroup

  * \ingroup TensorSymmetry_Module

  *

  * \brief Symmetry group, initialized from template arguments

  *

  * This class represents a symmetry group whose generators are already

  * known at compile time. It may or may not be resolved at compile time,

  * depending on the estimated size of the group.

  *

  * \sa StaticSGroup

  * \sa DynamicSGroup

  */

template<typename... Gen>

class SGroup : public internal::tensor_symmetry_pre_analysis<internal::tensor_symmetry_num_indices<Gen...>::value, Gen...>::root_type

{

  public:

    constexpr static std::size_t NumIndices = internal::tensor_symmetry_num_indices<Gen...>::value;

    typedef typename internal::tensor_symmetry_pre_analysis<NumIndices, Gen...>::root_type Base;

    // make standard constructors + assignment operators public

    inline SGroup() : Base() { }

    inline SGroup(const SGroup<Gen...>& other) : Base(other) { }

    inline SGroup(SGroup<Gen...>&& other) : Base(other) { }

    inline SGroup<Gen...>& operator=(const SGroup<Gen...>& other) { Base::operator=(other); return *this; }

    inline SGroup<Gen...>& operator=(SGroup<Gen...>&& other) { Base::operator=(other); return *this; }

    // all else is defined in the base class

};

namespace internal {

template<typename... Sym> struct tensor_symmetry_num_indices

{

  constexpr static std::size_t value = 1;

};

template<int One_, int Two_, typename... Sym> struct tensor_symmetry_num_indices<Symmetry<One_, Two_>, Sym...>

{

private:

  constexpr static std::size_t One = static_cast<std::size_t>(One_);

  constexpr static std::size_t Two = static_cast<std::size_t>(Two_);

  constexpr static std::size_t Three = tensor_symmetry_num_indices<Sym...>::value;

  // don't use std::max, since it's not constexpr until C++14...

  constexpr static std::size_t maxOneTwoPlusOne = ((One > Two) ? One : Two) + 1;

public:

  constexpr static std::size_t value = (maxOneTwoPlusOne > Three) ? maxOneTwoPlusOne : Three;

};

template<int One_, int Two_, typename... Sym> struct tensor_symmetry_num_indices<AntiSymmetry<One_, Two_>, Sym...>

  : public tensor_symmetry_num_indices<Symmetry<One_, Two_>, Sym...> {};

template<int One_, int Two_, typename... Sym> struct tensor_symmetry_num_indices<Hermiticity<One_, Two_>, Sym...>

  : public tensor_symmetry_num_indices<Symmetry<One_, Two_>, Sym...> {};

template<int One_, int Two_, typename... Sym> struct tensor_symmetry_num_indices<AntiHermiticity<One_, Two_>, Sym...>

  : public tensor_symmetry_num_indices<Symmetry<One_, Two_>, Sym...> {};

/** \internal

  *

  * \class tensor_symmetry_pre_analysis

  * \ingroup TensorSymmetry_Module

  *

  * \brief Pre-select whether to use a static or dynamic symmetry group

  *

  * When a symmetry group could in principle be determined at compile time,

  * this template implements the logic whether to actually do that or whether

  * to rather defer that to runtime.

  *

  * The logic is as follows:

  * <dl>

  * <dt><b>No generators (trivial symmetry):</b></dt>

  * <dd>Use a trivial static group. Ideally, this has no performance impact

  *     compared to not using symmetry at all. In practice, this might not

  *     be the case.</dd>

  * <dt><b>More than 4 generators:</b></dt>

  * <dd>Calculate the group at run time, it is likely far too large for the

  *     compiler to be able to properly generate it in a realistic time.</dd>

  * <dt><b>Up to and including 4 generators:</b></dt>

  * <dd>Actually enumerate all group elements, but then check how many there

  *     are. If there are more than 16, it is unlikely that unrolling the

  *     loop (as is done in the static compile-time case) is sensible, so

  *     use a dynamic group instead. If there are at most 16 elements, actually

  *     use that static group. Note that the largest group with 4 generators

  *     still compiles with reasonable resources.</dd>

  * </dl>

  *

  * Note: Example compile time performance with g++-4.6 on an Intenl Core i5-3470

  *       with 16 GiB RAM (all generators non-redundant and the subgroups don't

  *       factorize):

  *

  *          # Generators          -O0 -ggdb               -O2

  *          -------------------------------------------------------------------

  *          1                 0.5 s  /   250 MiB     0.45s /   230 MiB

  *          2                 0.5 s  /   260 MiB     0.5 s /   250 MiB

  *          3                 0.65s  /   310 MiB     0.62s /   310 MiB

  *          4                 2.2 s  /   860 MiB     1.7 s /   770 MiB

  *          5               130   s  / 13000 MiB   120   s / 11000 MiB

  *

  * It is clear that everything is still very efficient up to 4 generators, then

  * the memory and CPU requirements become unreasonable. Thus we only instantiate

  * the template group theory logic if the number of generators supplied is 4 or

  * lower, otherwise this will be forced to be done during runtime, where the

  * algorithm is reasonably fast.

  */

template<std::size_t NumIndices>

struct tensor_symmetry_pre_analysis<NumIndices>

{

  typedef StaticSGroup<> root_type;

};

template<std::size_t NumIndices, typename Gen_, typename... Gens_>

struct tensor_symmetry_pre_analysis<NumIndices, Gen_, Gens_...>

{

  constexpr static std::size_t max_static_generators = 4;

  constexpr static std::size_t max_static_elements = 16;

  typedef tensor_static_symgroup_if<(sizeof...(Gens_) + 1 <= max_static_generators), NumIndices, Gen_, Gens_...> helper;

  constexpr static std::size_t possible_size = helper::size;

  typedef typename conditional<

    possible_size == 0 || possible_size >= max_static_elements,

    DynamicSGroupFromTemplateArgs<Gen_, Gens_...>,

    typename helper::type

  >::type root_type;

};

template<bool instantiate, std::size_t NumIndices, typename... Gens>

struct tensor_static_symgroup_if

{

  constexpr static std::size_t size = 0;

  typedef void type;

};

template<std::size_t NumIndices, typename... Gens>

struct tensor_static_symgroup_if<true, NumIndices, Gens...> : tensor_static_symgroup<NumIndices, Gens...> {};

template<typename Tensor_>

struct tensor_symmetry_assign_value

{

  typedef typename Tensor_::Index Index;

  typedef typename Tensor_::Scalar Scalar;

  constexpr static std::size_t NumIndices = Tensor_::NumIndices;

  static inline int run(const std::array<Index, NumIndices>& transformed_indices, int transformation_flags, int dummy, Tensor_& tensor, const Scalar& value_)

  {

    Scalar value(value_);

    if (transformation_flags & ConjugationFlag)

      value = numext::conj(value);

    if (transformation_flags & NegationFlag)

      value = -value;

    tensor.coeffRef(transformed_indices) = value;

    return dummy;

  }

};

template<typename Tensor_>

struct tensor_symmetry_calculate_flags

{

  typedef typename Tensor_::Index Index;

  constexpr static std::size_t NumIndices = Tensor_::NumIndices;

  static inline int run(const std::array<Index, NumIndices>& transformed_indices, int transform_flags, int current_flags, const std::array<Index, NumIndices>& orig_indices)

  {

    if (transformed_indices == orig_indices) {

      if (transform_flags & (ConjugationFlag | NegationFlag))

        return current_flags | GlobalImagFlag; // anti-hermitian diagonal

      else if (transform_flags & ConjugationFlag)

        return current_flags | GlobalRealFlag; // hermitian diagonal

      else if (transform_flags & NegationFlag)

        return current_flags | GlobalZeroFlag; // anti-symmetric diagonal

    }

    return current_flags;

  }

};

template<typename Tensor_, typename Symmetry_, int Flags = 0>

class tensor_symmetry_value_setter

{

  public:

    typedef typename Tensor_::Index Index;

    typedef typename Tensor_::Scalar Scalar;

    constexpr static std::size_t NumIndices = Tensor_::NumIndices;

    inline tensor_symmetry_value_setter(Tensor_& tensor, Symmetry_ const& symmetry, std::array<Index, NumIndices> const& indices)

      : m_tensor(tensor), m_symmetry(symmetry), m_indices(indices) { }

    inline tensor_symmetry_value_setter<Tensor_, Symmetry_, Flags>& operator=(Scalar const& value)

    {

      doAssign(value);

      return *this;

    }

  private:

    Tensor_& m_tensor;

    Symmetry_ m_symmetry;

    std::array<Index, NumIndices> m_indices;

    inline void doAssign(Scalar const& value)

    {

      #ifdef EIGEN_TENSOR_SYMMETRY_CHECK_VALUES

        int value_flags = m_symmetry.template apply<internal::tensor_symmetry_calculate_flags<Tensor_>, int>(m_indices, m_symmetry.globalFlags(), m_indices);

        if (value_flags & GlobalRealFlag)

          eigen_assert(numext::imag(value) == 0);

        if (value_flags & GlobalImagFlag)

          eigen_assert(numext::real(value) == 0);

      #endif

      m_symmetry.template apply<internal::tensor_symmetry_assign_value<Tensor_>, int>(m_indices, 0, m_tensor, value);

    }

};

} // end namespace internal

} // end namespace Eigen

#endif // EIGEN_CXX11_TENSORSYMMETRY_SYMMETRY_H

/*

 * kate: space-indent on; indent-width 2; mixedindent off; indent-mode cstyle;

 */

// This file is part of Eigen, a lightweight C++ template library

// for linear algebra.

//

// Copyright (C) 2013 Christian Seiler <christian@iwakd.de>

//

// This Source Code Form is subject to the terms of the Mozilla

// Public License v. 2.0. If a copy of the MPL was not distributed

// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.

#ifndef EIGEN_CXX11_TENSORSYMMETRY_DYNAMICSYMMETRY_H

#define EIGEN_CXX11_TENSORSYMMETRY_DYNAMICSYMMETRY_H

namespace Eigen {

class DynamicSGroup

{

  public:

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

    inline DynamicSGroup(const DynamicSGroup& o) : m_numIndices(o.m_numIndices), m_elements(o.m_elements), m_generators(o.m_generators), m_globalFlags(o.m_globalFlags) { }

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

    inline DynamicSGroup& operator=(const DynamicSGroup& o) { m_numIndices = o.m_numIndices; m_elements = o.m_elements; m_generators = o.m_generators; m_globalFlags = o.m_globalFlags; return *this; }

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

    void add(int one, int two, int flags = 0);

    template<typename Gen_>

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

    inline void addSymmetry(int one, int two) { add(one, two, 0); }

    inline void addAntiSymmetry(int one, int two) { add(one, two, NegationFlag); }

    inline void addHermiticity(int one, int two) { add(one, two, ConjugationFlag); }

    inline void addAntiHermiticity(int one, int two) { add(one, two, NegationFlag | ConjugationFlag); }

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

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

    {

      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;

    }

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

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

    {

      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;

    }

    inline int globalFlags() const { return m_globalFlags; }

    inline std::size_t size() const { return m_elements.size(); }

    template<typename Tensor_, typename... IndexTypes>

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

    {

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

    }

    template<typename Tensor_>

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

    {

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

    }

  private:

    struct GroupElement {

      std::vector<int> representation;

      int flags;

      bool isId() const

      {

        for (std::size_t i = 0; i < representation.size(); i++)

          if (i != (size_t)representation[i])

            return false;

        return true;

      }

    };

    struct Generator {

      int one;

      int two;

      int flags;

      constexpr inline Generator(int one_, int two_, int flags_) : one(one_), two(two_), flags(flags_) {}

    };

    std::size_t m_numIndices;

    std::vector<GroupElement> m_elements;

    std::vector<Generator> m_generators;

    int m_globalFlags;

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

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

    {

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

    }

    template<typename Index>

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

    {

      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;

    }

    inline GroupElement ge(Generator const& g) const

    {

      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;

    }

    GroupElement mul(GroupElement, GroupElement) const;

    inline GroupElement mul(Generator g1, GroupElement g2) const

    {

      return mul(ge(g1), g2);

    }

    inline GroupElement mul(GroupElement g1, Generator g2) const

    {

      return mul(g1, ge(g2));

    }

    inline GroupElement mul(Generator g1, Generator g2) const

    {

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

    }

    inline int findElement(GroupElement e) const

    {

      for (auto ee : m_elements) {

        if (ee.representation == e.representation)

          return ee.flags ^ e.flags;

      }

      return -1;

    }

    void updateGlobalFlags(int flagDiffOfSameGenerator);

};

// dynamic symmetry group that auto-adds the template parameters in the constructor

template<typename... Gen>

class DynamicSGroupFromTemplateArgs : public DynamicSGroup

{

  public:

    inline DynamicSGroupFromTemplateArgs() : DynamicSGroup()

    {

      add_all(internal::type_list<Gen...>());

    }

    inline DynamicSGroupFromTemplateArgs(DynamicSGroupFromTemplateArgs const& other) : DynamicSGroup(other) { }

    inline DynamicSGroupFromTemplateArgs(DynamicSGroupFromTemplateArgs&& other) : DynamicSGroup(other) { }

    inline DynamicSGroupFromTemplateArgs<Gen...>& operator=(const DynamicSGroupFromTemplateArgs<Gen...>& o) { DynamicSGroup::operator=(o); return *this; }

    inline DynamicSGroupFromTemplateArgs<Gen...>& operator=(DynamicSGroupFromTemplateArgs<Gen...>&& o) { DynamicSGroup::operator=(o); return *this; }

  private:

    template<typename Gen1, typename... GenNext>

    inline void add_all(internal::type_list<Gen1, GenNext...>)

    {

      add(Gen1());

      add_all(internal::type_list<GenNext...>());

    }

    inline void add_all(internal::type_list<>)

    {

    }

};

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

{

  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;

}

inline void DynamicSGroup::add(int one, int two, int flags)

{

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

}

inline void DynamicSGroup::updateGlobalFlags(int flagDiffOfSameGenerator)

{

    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

       */

    }

}

} // end namespace Eigen

#endif // EIGEN_CXX11_TENSORSYMMETRY_DYNAMICSYMMETRY_H

/*

 * kate: space-indent on; indent-width 2; mixedindent off; indent-mode cstyle;

 */

// This file is part of Eigen, a lightweight C++ template library

// for linear algebra.

//

// Copyright (C) 2013 Christian Seiler <christian@iwakd.de>

//

// This Source Code Form is subject to the terms of the Mozilla

// Public License v. 2.0. If a copy of the MPL was not distributed

// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.

#ifndef EIGEN_CXX11_TENSORSYMMETRY_STATICSYMMETRY_H

#define EIGEN_CXX11_TENSORSYMMETRY_STATICSYMMETRY_H

namespace Eigen {

namespace internal {

template<typename list> struct tensor_static_symgroup_permutate;

template<int... nn>

struct tensor_static_symgroup_permutate<numeric_list<int, nn...>>

{

  constexpr static std::size_t N = sizeof...(nn);

  template<typename T>

  constexpr static inline std::array<T, N> run(const std::array<T, N>& indices)

  {

    return {{indices[nn]...}};

  }

};

template<typename indices_, int flags_>

struct tensor_static_symgroup_element

{

  typedef indices_ indices;

  constexpr static int flags = flags_;

};

template<typename Gen, int N>

struct tensor_static_symgroup_element_ctor

{

  typedef tensor_static_symgroup_element<

    typename gen_numeric_list_swapped_pair<int, N, Gen::One, Gen::Two>::type,

    Gen::Flags

  > type;

};

template<int N>

struct tensor_static_symgroup_identity_ctor

{

  typedef tensor_static_symgroup_element<

    typename gen_numeric_list<int, N>::type,

    0

  > type;

};

template<typename iib>

struct tensor_static_symgroup_multiply_helper

{

  template<int... iia>

  constexpr static inline numeric_list<int, get<iia, iib>::value...> helper(numeric_list<int, iia...>) {

    return numeric_list<int, get<iia, iib>::value...>();

  }

};

template<typename A, typename B>

struct tensor_static_symgroup_multiply

{

  private:

    typedef typename A::indices iia;

    typedef typename B::indices iib;

    constexpr static int ffa = A::flags;

    constexpr static int ffb = B::flags;

  public:

    static_assert(iia::count == iib::count, "Cannot multiply symmetry elements with different number of indices.");

    typedef tensor_static_symgroup_element<

      decltype(tensor_static_symgroup_multiply_helper<iib>::helper(iia())),

      ffa ^ ffb

    > type;

};

template<typename A, typename B>

struct tensor_static_symgroup_equality

{

    typedef typename A::indices iia;

    typedef typename B::indices iib;

    constexpr static int ffa = A::flags;

    constexpr static int ffb = B::flags;

    static_assert(iia::count == iib::count, "Cannot compare symmetry elements with different number of indices.");

    constexpr static bool value = is_same<iia, iib>::value;

  private:

    /* this should be zero if they are identical, or else the tensor

     * will be forced to be pure real, pure imaginary or even pure zero

     */

    constexpr static int flags_cmp_ = ffa ^ ffb;

    /* either they are not equal, then we don't care whether the flags

     * match, or they are equal, and then we have to check

     */

    constexpr static bool is_zero      = value && flags_cmp_ == NegationFlag;

    constexpr static bool is_real      = value && flags_cmp_ == ConjugationFlag;

    constexpr static bool is_imag      = value && flags_cmp_ == (NegationFlag | ConjugationFlag);

  public:

    constexpr static int global_flags = 

      (is_real ? GlobalRealFlag : 0) |

      (is_imag ? GlobalImagFlag : 0) |

      (is_zero ? GlobalZeroFlag : 0);

};

template<std::size_t NumIndices, typename... Gen>

struct tensor_static_symgroup

{

  typedef StaticSGroup<Gen...> type;

  constexpr static std::size_t size = type::static_size;

};

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

constexpr static inline std::array<Index, N> tensor_static_symgroup_index_permute(std::array<Index, N> idx, internal::numeric_list<int, ii...>, internal::numeric_list<int, jj...>)

{

  return {{ idx[ii]..., idx[jj]... }};

}

template<typename Index, int... ii>

static inline std::vector<Index> tensor_static_symgroup_index_permute(std::vector<Index> idx, internal::numeric_list<int, ii...>)

{

  std::vector<Index> result{{ idx[ii]... }};

  std::size_t target_size = idx.size();

  for (std::size_t i = result.size(); i < target_size; i++)

    result.push_back(idx[i]);

  return result;

}

template<typename T> struct tensor_static_symgroup_do_apply;

template<typename first, typename... next>

struct tensor_static_symgroup_do_apply<internal::type_list<first, next...>>

{

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

  static inline RV run(const std::array<Index, NumIndices>& idx, RV initial, Args&&... args)

  {

    static_assert(NumIndices >= SGNumIndices, "Can only apply symmetry group to objects that have at least the required amount of indices.");

    typedef typename internal::gen_numeric_list<int, NumIndices - SGNumIndices, SGNumIndices>::type remaining_indices;

    initial = Op::run(tensor_static_symgroup_index_permute(idx, typename first::indices(), remaining_indices()), first::flags, initial, std::forward<Args>(args)...);

    return tensor_static_symgroup_do_apply<internal::type_list<next...>>::template run<Op, RV, SGNumIndices>(idx, initial, args...);

  }

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

  static inline RV run(const std::vector<Index>& idx, RV initial, Args&&... args)

  {

    eigen_assert(idx.size() >= SGNumIndices && "Can only apply symmetry group to objects that have at least the required amount of indices.");

    initial = Op::run(tensor_static_symgroup_index_permute(idx, typename first::indices()), first::flags, initial, std::forward<Args>(args)...);

    return tensor_static_symgroup_do_apply<internal::type_list<next...>>::template run<Op, RV, SGNumIndices>(idx, initial, args...);

  }

};

template<EIGEN_TPL_PP_SPEC_HACK_DEF(typename, empty)>

struct tensor_static_symgroup_do_apply<internal::type_list<EIGEN_TPL_PP_SPEC_HACK_USE(empty)>>

{

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

  static inline RV run(const std::array<Index, NumIndices>&, RV initial, Args&&...)

  {

    // do nothing

    return initial;

  }

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

  static inline RV run(const std::vector<Index>&, RV initial, Args&&...)

  {

    // do nothing

    return initial;

  }

};

} // end namespace internal

template<typename... Gen>

class StaticSGroup