hpcombi.hpp

//
// libsemigroups - C++ library for semigroups and monoids
// Copyright (C) 2019-2025 James D. Mitchell
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
//
 
// TODO check the doc, return values and parameters are missing in some cases.
// TODO constexpr where possible
 
// This file contains declarations of specializations of the class adapters in
// adapters.hpp for the element types in HPCombi.
 
#ifndef LIBSEMIGROUPS_HPCOMBI_HPP_
#define LIBSEMIGROUPS_HPCOMBI_HPP_
 
// Must include config.hpp so that LIBSEMIGROUPS_HPCOMBI_ENABLED
// is defined, if so specified at during configure.
#include "config.hpp"  // for LIBSEMIGROUPS_HPCOMBI_ENABLED
 
// TODO fix the warnings in HPCombi that these suppressions are hear to
// silence.
#if defined(LIBSEMIGROUPS_HPCOMBI_ENABLED)
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wpedantic"
#pragma GCC diagnostic ignored "-Wswitch-default"
#endif
#include "hpcombi/hpcombi.hpp"  // for `HPCombi::Perm16`, ...
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
 
#include <algorithm>         // for max_element
#include <cstddef>           // for size_t
#include <cstdint>           // for uint8_t
#include <initializer_list>  // for begin, end, initializer_list
#include <numeric>           // for iota
#include <string_view>       // for basic_string_view
#include <type_traits>       // for is_base_of_v, enable_if_t, is_int...
#include <unordered_map>     // for swap, unordered_map
#include <utility>           // for forward, move
#include <vector>            // for vector
 
#include "adapters.hpp"   // for Complexity, Degree, ...
#include "debug.hpp"      // for LIBSEMIGROUPS_ASSERT
#include "exception.hpp"  // for LIBSEMIGROUPS_EXCEPTION
#include "is-transf.hpp"  // for throw_if_not_ptransf etc
#include "types.hpp"      // for enable_if_is_same
#endif
 
#if defined(LIBSEMIGROUPS_HPCOMBI_ENABLED) \
    || defined(LIBSEMIGROUPS_PARSED_BY_DOXYGEN)
namespace libsemigroups {



  template <typename Thing>
  struct Complexity<
      Thing,
      std::enable_if_t<std::is_base_of_v<HPCombi::PTransf16, Thing>>> {
    constexpr size_t operator()(Thing const& x) const noexcept {
      (void) x;
      return 0;
    }
  };

  template <typename Thing>
  struct Degree<
      Thing,
      std::enable_if_t<std::is_base_of_v<HPCombi::PTransf16, Thing>>> {
    constexpr size_t operator()(Thing const& x) const noexcept {
      (void) x;
      return 16;
    }
  };

  template <typename Thing>
  struct One<Thing,
             std::enable_if_t<std::is_base_of_v<HPCombi::PTransf16, Thing>>> {
    Thing operator()(size_t n = 0) const noexcept {
      (void) n;
      return Thing::one();
    }

    Thing operator()(Thing const& x) const noexcept {
      (void) x;
      return Thing::one();
    }
  };

  template <typename Thing>
  struct Product<
      Thing,
      std::enable_if_t<std::is_base_of_v<HPCombi::PTransf16, Thing>>> {
    void operator()(Thing&       xy,
                    Thing const& x,
                    Thing const& y,
                    size_t       deg = 0) const noexcept {
      (void) deg;
      xy = y * x;
    }
  };

  template <typename Thing>
  struct Swap<Thing,
              std::enable_if_t<std::is_base_of_v<HPCombi::PTransf16, Thing>>> {
    void operator()(Thing& x, Thing& y) const noexcept {
      std::swap(x, y);
    }
  };

  template <typename Thing>
  struct IncreaseDegree<
      Thing,
      std::enable_if_t<std::is_base_of_v<HPCombi::PTransf16, Thing>>> {
    inline constexpr void operator()(Thing const& x, size_t n) const noexcept {
      (void) x;
      (void) n;
    }
  };

  template <>
  struct Inverse<HPCombi::Perm16> {
    HPCombi::Perm16 operator()(HPCombi::Perm16 const& x) const noexcept {
      return x.inverse();
    }
  };

  template <typename Int>
  struct ImageRightAction<HPCombi::Perm16,
                          Int,
                          std::enable_if_t<std::is_integral_v<Int>>> {
    void operator()(Int&                   res,
                    Int const&             pt,
                    HPCombi::Perm16 const& x) const noexcept {
      LIBSEMIGROUPS_ASSERT(pt < 16);
      res = static_cast<Int>(x[pt]);
    }

    Int operator()(Int const& pt, HPCombi::Perm16 const& x) const noexcept {
      LIBSEMIGROUPS_ASSERT(pt < 16);
      return x[pt];
    }
  };

  template <>
  struct ImageRightAction<HPCombi::PPerm16, HPCombi::PPerm16> {
    void operator()(HPCombi::PPerm16&       res,
                    HPCombi::PPerm16 const& pt,
                    HPCombi::PPerm16 const& x) const noexcept {
      res = (x * pt).left_one();
    }
  };

  template <>
  struct ImageLeftAction<HPCombi::PPerm16, HPCombi::PPerm16> {
    void operator()(HPCombi::PPerm16&       res,
                    HPCombi::PPerm16 const& pt,
                    HPCombi::PPerm16 const& x) const noexcept {
      res = (pt * x).right_one();
    }
  };

  template <>
  struct Complexity<HPCombi::BMat8> {
    constexpr inline size_t operator()(HPCombi::BMat8 const& x) const noexcept {
      (void) x;
      return 0;
    }
  };

  template <>
  struct Degree<HPCombi::BMat8> {
    constexpr inline size_t operator()(HPCombi::BMat8 const& x) const noexcept {
      (void) x;
      return 8;
    }
  };

  template <>
  struct IncreaseDegree<HPCombi::BMat8> {
    inline void operator()(HPCombi::BMat8 const& x, size_t n) const noexcept {
      (void) x;
      (void) n;
    }
  };

  template <>
  struct One<HPCombi::BMat8> {
    inline HPCombi::BMat8 operator()(size_t n = 0) const noexcept {
      (void) n;
      return HPCombi::BMat8::one();
    }

    inline HPCombi::BMat8 operator()(HPCombi::BMat8 const& x) const noexcept {
      (void) x;
      return x.one();
    }
  };

  template <>
  struct Product<HPCombi::BMat8> {
    inline void operator()(HPCombi::BMat8&       xy,
                           HPCombi::BMat8 const& x,
                           HPCombi::BMat8 const& y,
                           size_t                deg = 0) const noexcept {
      (void) deg;
      xy = x * y;
    }
  };

  // HERE in doc review
  template <>
  struct ImageRightAction<HPCombi::BMat8, HPCombi::BMat8> {
    void operator()(HPCombi::BMat8&       res,
                    HPCombi::BMat8 const& pt,
                    HPCombi::BMat8 const& x) const noexcept {
      res = (pt * x).row_space_basis();
    }
  };

  template <>
  struct ImageLeftAction<HPCombi::BMat8, HPCombi::BMat8> {
    void operator()(HPCombi::BMat8& res,
                    HPCombi::BMat8  pt,
                    HPCombi::BMat8  x) const noexcept {
      res = (x * pt).col_space_basis();
    }
  };

  template <>
  struct Inverse<HPCombi::BMat8> {
    inline HPCombi::BMat8 operator()(HPCombi::BMat8 const& x) const noexcept {
      // The following assertion fails because x.one() is the 8x8 identity but
      // x * x.transpose() is not always.
      // LIBSEMIGROUPS_ASSERT(x * x.transpose() == x.one());
      return x.transpose();
    }
  };

  // Konieczny adapters - `HPCombi::BMat8`

  template <>
  struct LambdaValue<HPCombi::BMat8> {
    using type = HPCombi::BMat8;
  };

  template <>
  struct RhoValue<HPCombi::BMat8> {
    using type = HPCombi::BMat8;
  };

  template <>
  struct Lambda<HPCombi::BMat8, HPCombi::BMat8> {
    void operator()(HPCombi::BMat8&       res,
                    HPCombi::BMat8 const& x) const noexcept {
      res = x.row_space_basis();
    }
  };

  template <>
  struct Rho<HPCombi::BMat8, HPCombi::BMat8> {
    void operator()(HPCombi::BMat8&       res,
                    HPCombi::BMat8 const& x) const noexcept {
      res = x.col_space_basis();
    }
  };

  template <>
  struct Rank<HPCombi::BMat8> {
    inline size_t operator()(HPCombi::BMat8 const& x) const noexcept {
      return x.row_space_size();
    }
  };

  // Konieczny adapters - `HPCombi::PPerm16`

  template <>
  struct LambdaValue<HPCombi::PPerm16> {
    using type = HPCombi::PPerm16;
  };

  template <>
  struct RhoValue<HPCombi::PPerm16> {
    using type = HPCombi::PPerm16;
  };

  template <>
  struct Lambda<HPCombi::PPerm16, HPCombi::PPerm16> {
    void operator()(HPCombi::PPerm16&       res,
                    HPCombi::PPerm16 const& x) const noexcept {
      res = x.left_one();
    }
  };

  template <>
  struct Rho<HPCombi::PPerm16, HPCombi::PPerm16> {
    void operator()(HPCombi::PPerm16&       res,
                    HPCombi::PPerm16 const& x) const noexcept {
      res = x.right_one();
    }
  };

  // Konieczny adapters - Transf16

  template <>
  struct ImageRightAction<HPCombi::Transf16, HPCombi::PTransf16> {
    void operator()(HPCombi::PTransf16&       res,
                    HPCombi::Transf16 const&  x,
                    HPCombi::PTransf16 const& y) const noexcept {
      res = (y * static_cast<HPCombi::PTransf16>(static_cast<HPCombi::epu8>(x)))
                .left_one();
    }
  };

  template <>
  struct ImageLeftAction<HPCombi::Transf16, HPCombi::Vect16> {
    void operator()(HPCombi::Vect16&         res,
                    HPCombi::Transf16 const& x,
                    HPCombi::Vect16 const&   y) const noexcept;
  };

  template <>
  struct LambdaValue<HPCombi::Transf16> {
    using type = HPCombi::PTransf16;
  };

  template <>
  struct RhoValue<HPCombi::Transf16> {
    using type = HPCombi::Vect16;
  };

  template <>
  struct Lambda<HPCombi::Transf16, HPCombi::PTransf16> {
    void operator()(HPCombi::PTransf16&      res,
                    HPCombi::Transf16 const& x) const noexcept {
      res = x.left_one();
    }
  };

  template <>
  struct Rho<HPCombi::Transf16, HPCombi::Vect16> {
    void operator()(HPCombi::Vect16&         res,
                    HPCombi::Transf16 const& x) const noexcept;
  };

  // Konieczny adapters - PTransf16

  template <>
  struct ImageRightAction<HPCombi::PTransf16, HPCombi::PTransf16> {
    void operator()(HPCombi::PTransf16&       res,
                    HPCombi::PTransf16 const& pt,
                    HPCombi::PTransf16 const& x) const noexcept {
      // Note that this is the opposite of what's stated above because
      // composition is the wrong way around in HPCombi
      res = (x * pt).left_one();
    }
  };

  template <>
  struct ImageLeftAction<HPCombi::PTransf16, HPCombi::Vect16> {
    // We cannot use "right_one" here because in HPCombi, right_one for a
    // partial transformation is not an L-class invariant unfortunately.
    void operator()(HPCombi::Vect16&          res,
                    HPCombi::PTransf16 const& x,
                    HPCombi::Vect16 const&    y) const noexcept;
  };

  template <>
  struct LambdaValue<HPCombi::PTransf16> {
    using type = HPCombi::PTransf16;
  };

  template <>
  struct RhoValue<HPCombi::PTransf16> {
    using type = HPCombi::Vect16;
  };

  template <>
  struct Lambda<HPCombi::PTransf16, HPCombi::PTransf16> {
    void operator()(HPCombi::PTransf16&       res,
                    HPCombi::PTransf16 const& x) const noexcept {
      // This is the opposite of what might be expected because multiplication
      // is the wrong way around in HPCombi
      res = x.left_one();
    }
  };

  template <>
  struct Rho<HPCombi::PTransf16, HPCombi::Vect16> {
    void operator()(HPCombi::Vect16&          res,
                    HPCombi::PTransf16 const& x) const noexcept;
  };

  // Konieczny adapters - generic

  template <typename T>
  struct Rank<T,
              std::enable_if_t<std::is_base_of_v<HPCombi::PTransf16, T>,
                               RankState<T>>> {
    inline size_t operator()(T const& x) const noexcept {
      return x.rank();
    }
  };



#ifndef LIBSEMIGROUPS_PARSED_BY_DOXYGEN
  template <typename Return, typename Container>
  [[nodiscard]] enable_if_is_same<Return, HPCombi::PTransf16>
  make(Container&& cont);
#else
  template <typename Container>
  [[nodiscard]] HPCombi::PTransf16 make<HPCombi::PTransf16>(Container&& cont);
#endif

#ifndef LIBSEMIGROUPS_PARSED_BY_DOXYGEN
  template <typename Return, typename Container>
  [[nodiscard]] enable_if_is_same<Return, HPCombi::Transf16>
  make(Container&& cont);
#else
  template <typename Container>
  [[nodiscard]] HPCombi::Transf16 make<HPCombi::Transf16>(Container&& cont);
#endif

#ifndef LIBSEMIGROUPS_PARSED_BY_DOXYGEN
  template <typename Return, typename Container>
  [[nodiscard]] enable_if_is_same<Return, HPCombi::Perm16>
  make(Container&& cont);
#else
  template <typename Container>
  [[nodiscard]] HPCombi::Perm16 make<HPCombi::Perm16>(Container&& cont);
#endif

#ifndef LIBSEMIGROUPS_PARSED_BY_DOXYGEN
  template <typename Return, typename Container>
  [[nodiscard]] enable_if_is_same<Return, HPCombi::PPerm16>
  make(Container&& cont);
#else
  template <typename Container>
  [[nodiscard]] HPCombi::PPerm16 make<HPCombi::PPerm16>(Container&& cont);
#endif

#ifndef LIBSEMIGROUPS_PARSED_BY_DOXYGEN
  template <typename Return>
  [[nodiscard]] enable_if_is_same<Return, HPCombi::PTransf16>
  make(std::vector<uint8_t> const& dom,
       std::vector<uint8_t> const& ran,
       size_t                      deg = 16);
#else
  [[nodiscard]] HPCombi::PTransf16
  make<HPCombi::PTransf16>(std::vector<uint8_t> const& dom,
                           std::vector<uint8_t> const& ran,
                           size_t                      deg = 16);
#endif

#ifndef LIBSEMIGROUPS_PARSED_BY_DOXYGEN
  template <typename Return>
  [[nodiscard]] enable_if_is_same<Return, HPCombi::PPerm16>
  make(std::vector<uint8_t> const& dom,
       std::vector<uint8_t> const& ran,
       size_t                      deg = 16);
#else
  [[nodiscard]] HPCombi::PPerm16
  make<HPCombi::PPerm16>(std::vector<uint8_t> const& dom,
                         std::vector<uint8_t> const& ran,
                         size_t                      deg = 16);
#endif

#ifndef LIBSEMIGROUPS_PARSED_BY_DOXYGEN
  template <typename Return, typename Int>
  [[nodiscard]] enable_if_is_same<Return, HPCombi::PPerm16>
  make(std::initializer_list<Int> dom,
       std::initializer_list<Int> ran,
       size_t                     M) {
    return make<Return>(std::vector<uint8_t>(dom.begin(), dom.end()),
                        std::vector<uint8_t>(ran.begin(), ran.end()),
                        M);
  }
#else
  template <typename Int>
  [[nodiscard]] HPCombi::PPerm16
  make<HPCombi::PPerm16>(std::initializer_list<Int> const& dom,
                         std::initializer_list<Int> const& ran,
                         size_t                            M = 16);
#endif
 
#ifndef LIBSEMIGROUPS_PARSED_BY_DOXYGEN
  // We omit the doc for this version because the return type is awful and ruins
  // the rest of the doc in the table at the top of the page.
  template <typename Return>
  [[nodiscard]] std::enable_if_t<std::is_base_of_v<HPCombi::PTransf16, Return>,
                                 Return>
  make(std::initializer_list<uint8_t>&& cont) {
    return make<Return, std::initializer_list<uint8_t>>(std::move(cont));
  }
#endif
 
}  // namespace libsemigroups
 
#include "hpcombi.tpp"
 
#endif  // LIBSEMIGROUPS_HPCOMBI_ENABLED
#endif  // LIBSEMIGROUPS_HPCOMBI_HPP_