Line data    Source code

       1           1 : // Distributed under the MIT License.
       2             : // See LICENSE.txt for details.
       3             : 
       4             : /// \file
       5             : /// Defines metafunctions used to compute the Symmetry<...> for a Tensor
       6             : 
       7             : #pragma once
       8             : 
       9             : #include <type_traits>
      10             : 
      11             : #include "Utilities/Array.hpp"
      12             : #include "Utilities/TMPL.hpp"
      13             : 
      14             : namespace detail {
      15             : template <size_t Size>
      16             : constexpr int find_reduced_index(
      17             :     const cpp20::array<std::pair<int, int>, Size>& t, const int value) {
      18             :   for (size_t i = 0; i < Size; ++i) {
      19             :     if (t[i].first == value) {
      20             :       return t[i].second;
      21             :     }
      22             :   }
      23             :   return 0;
      24             : }
      25             : 
      26             : template <size_t Size>
      27             : constexpr cpp20::array<int, Size> symmetry(
      28             :     const std::array<int, Size>& input_symm) {
      29             :   cpp20::array<int, Size> output_symm{};
      30             :   int next_symm_entry = 1;
      31             :   cpp20::array<std::pair<int, int>, Size> input_to_output_map{};
      32             :   size_t input_to_output_map_size = 0;
      33             :   for (size_t i = Size - 1; i < Size; --i) {
      34             :     // clang-tidy: use gsl::at
      35             :     int found_symm_entry =
      36             :         find_reduced_index(input_to_output_map, input_symm[i]);  // NOLINT
      37             :     if (found_symm_entry == 0) {
      38             :       output_symm[i] = next_symm_entry;  // NOLINT
      39             :       input_to_output_map[input_to_output_map_size].first =
      40             :           input_symm[i];  // NOLINT
      41             :       input_to_output_map[input_to_output_map_size].second = output_symm[i];
      42             :       input_to_output_map_size++;
      43             :       next_symm_entry++;
      44             :     } else {
      45             :       output_symm[i] = found_symm_entry;
      46             :     }
      47             :   }
      48             :   return output_symm;
      49             : }
      50             : 
      51             : template <typename IndexSequence, typename SymmetrySequence>
      52             : struct SymmetryImpl;
      53             : 
      54             : template <size_t... Is, std::int32_t... Ss>
      55             : struct SymmetryImpl<std::index_sequence<Is...>,
      56             :                     tmpl::integral_list<std::int32_t, Ss...>> {
      57             :   static_assert((... and (Ss > 0)),
      58             :                 "Symmetry values must be positive integers.");
      59             :   static constexpr cpp20::array<int, sizeof...(Is)> t =
      60             :       symmetry(std::array<int, sizeof...(Is)>{{Ss...}});
      61             :   using type = tmpl::integral_list<std::int32_t, t[Is]...>;
      62             : };
      63             : }  // namespace detail
      64             : 
      65             : /// \ingroup TensorGroup
      66             : /// \brief Computes the canonical symmetry from the integers `T`
      67             : ///
      68             : /// \details
      69             : /// Compute the canonical symmetry typelist given a set of integers, T. The
      70             : /// resulting typelist is in ascending order of the integers, from right to
      71             : /// left. For example, the result of `Symmetry<1, 2, 1, 3>` is
      72             : /// `integral_list<int32_t, 2, 3, 2, 1>`. Anti-symmetries are not currently
      73             : /// supported.
      74             : ///
      75             : /// \tparam T the integers denoting the symmetry of the Tensor
      76             : template <std::int32_t... T>
      77           1 : using Symmetry = typename detail::SymmetryImpl<
      78             :     std::make_index_sequence<sizeof...(T)>,
      79             :     tmpl::integral_list<std::int32_t, T...>>::type;