matrix.hpp

//
// libsemigroups - C++ library for semigroups and monoids
// Copyright (C) 2020-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(1) tpp file
// TODO(1) put the detail stuff into detail/matrix-common.hpp
// TODO(1) there're no complete set of init methods for matrices
 
#ifndef LIBSEMIGROUPS_MATRIX_HPP_
#define LIBSEMIGROUPS_MATRIX_HPP_
 
#include <algorithm>         // for min
#include <array>             // for array
#include <bitset>            // for bitset
#include <cstddef>           // for size_t
#include <cstdint>           // for uint64_t
#include <initializer_list>  // for initializer_list
#include <iosfwd>            // for ostringstream
#include <iterator>          // for distance
#include <numeric>           // for inner_product
#include <ostream>           // for operator<<, basic_ostream
#include <string>            // for string
#include <tuple>             // for tie
#include <type_traits>       // for false_type, is_signed, true_type
#include <unordered_map>     // for unordered_map
#include <unordered_set>     // for unordered_set
#include <utility>           // for forward, make_pair, pair
#include <vector>            // for vector
 
#include "adapters.hpp"   // for Degree
#include "bitset.hpp"     // for BitSet
#include "config.hpp"     // for LIBSEMIGROUPS_PARSED_BY_DOXYGEN
#include "constants.hpp"  // for POSITIVE_INFINITY
#include "debug.hpp"      // for LIBSEMIGROUPS_ASSERT
#include "exception.hpp"  // for LIBSEMIGROUPS_EXCEPTION
 
#include "detail/containers.hpp"  // for StaticVector1
#include "detail/formatters.hpp"  // for formatter of POSITIVE_INFINITY ...
#include "detail/string.hpp"      // for detail::to_string
 
namespace libsemigroups {


  // Detail
 
  namespace detail {
 
    template <typename T>
    struct IsStdBitSetHelper : std::false_type {};
 
    template <size_t N>
    struct IsStdBitSetHelper<std::bitset<N>> : std::true_type {};
 
    template <typename T>
    static constexpr bool IsStdBitSet = IsStdBitSetHelper<T>::value;
 
    struct MatrixPolymorphicBase {};
 
    template <typename T>
    struct IsMatrixHelper {
      static constexpr bool value
          = std::is_base_of<detail::MatrixPolymorphicBase, T>::value;
    };
  }  // namespace detail

  template <typename T>
  constexpr bool IsMatrix = detail::IsMatrixHelper<T>::value;
 
  namespace matrix {

    template <typename Mat>
    auto throw_if_not_square(Mat const& x) -> std::enable_if_t<IsMatrix<Mat>> {
      if (x.number_of_rows() != x.number_of_cols()) {
        LIBSEMIGROUPS_EXCEPTION("expected a square matrix, but found {}x{}",
                                x.number_of_rows(),
                                x.number_of_cols());
      }
    }

    template <typename Mat>
    auto throw_if_bad_dim(Mat const& x, Mat const& y)
        -> std::enable_if_t<IsMatrix<Mat>> {
      if (x.number_of_rows() != y.number_of_rows()
          || x.number_of_cols() != y.number_of_cols()) {
        LIBSEMIGROUPS_EXCEPTION(
            "expected matrices with the same dimensions, the 1st argument is a "
            "{}x{} matrix, and the 2nd is a {}x{} matrix",
            x.number_of_rows(),
            x.number_of_cols(),
            y.number_of_rows(),
            y.number_of_cols());
      }
    }

    template <typename Mat>
    auto throw_if_bad_coords(Mat const& x, size_t r, size_t c)
        -> std::enable_if_t<IsMatrix<Mat>> {
      if (r >= x.number_of_rows()) {
        LIBSEMIGROUPS_EXCEPTION("invalid row index in ({}, {}), expected "
                                "values in [0, {}) x [0, {})",
                                r,
                                c,
                                x.number_of_rows(),
                                x.number_of_cols(),
                                r);
      }
      if (c >= x.number_of_cols()) {
        LIBSEMIGROUPS_EXCEPTION("invalid column index in ({}, {}), expected "
                                "values in [0, {}) x [0, {})",
                                r,
                                c,
                                x.number_of_rows(),
                                x.number_of_cols(),
                                r);
      }
    }
  }  // namespace matrix

  // Detail
  namespace detail {
    template <typename Container,
              typename Subclass,
              typename TRowView,
              typename Semiring = void>
    class MatrixCommon : MatrixPolymorphicBase {
     public:
      // MatrixCommon - Aliases - public
 
      using scalar_type            = typename Container::value_type;
      using scalar_reference       = typename Container::reference;
      using scalar_const_reference = typename Container::const_reference;
      using semiring_type          = Semiring;
 
      using container_type = Container;
      using iterator       = typename Container::iterator;
      using const_iterator = typename Container::const_iterator;
 
      using RowView = TRowView;
 
      scalar_type scalar_one() const noexcept {
        return static_cast<Subclass const*>(this)->one_impl();
      }
 
      scalar_type scalar_zero() const noexcept {
        return static_cast<Subclass const*>(this)->zero_impl();
      }
 
      Semiring const* semiring() const noexcept {
        return static_cast<Subclass const*>(this)->semiring_impl();
      }
 
     private:
      // MatrixCommon - Semiring arithmetic - private
 
      scalar_type plus_no_checks(scalar_type x, scalar_type y) const noexcept {
        return static_cast<Subclass const*>(this)->plus_no_checks_impl(y, x);
      }
 
      scalar_type product_no_checks(scalar_type x,
                                    scalar_type y) const noexcept {
        return static_cast<Subclass const*>(this)->product_no_checks_impl(y, x);
      }
 
     protected:
      // MatrixCommon - Container functions - protected
 
      // TODO(1) use constexpr-if, not SFINAE
      template <typename SFINAE = container_type>
      auto resize(size_t r, size_t c) -> std::enable_if_t<
          std::is_same<SFINAE, std::vector<scalar_type>>::value> {
        _container.resize(r * c);
      }
 
      template <typename SFINAE = container_type>
      auto resize(size_t, size_t) -> std::enable_if_t<
          !std::is_same<SFINAE, std::vector<scalar_type>>::value> {}
 
     public:
      // MatrixCommon - Constructors + destructor - public
 
      // none of the constructors are noexcept because they allocate
      MatrixCommon()                               = default;
      MatrixCommon(MatrixCommon const&)            = default;
      MatrixCommon(MatrixCommon&&)                 = default;
      MatrixCommon& operator=(MatrixCommon const&) = default;
      MatrixCommon& operator=(MatrixCommon&&)      = default;
 
      explicit MatrixCommon(std::initializer_list<scalar_type> const& c)
          : MatrixCommon() {
        resize(1, c.size());
        std::copy(c.begin(), c.end(), _container.begin());
      }
 
      explicit MatrixCommon(std::vector<std::vector<scalar_type>> const& m)
          : MatrixCommon() {
        init(m);
      }
 
      MatrixCommon(
          std::initializer_list<std::initializer_list<scalar_type>> const& m)
          : MatrixCommon() {
        init(m);
      }
 
     private:
      // not noexcept because resize isn't
      template <typename T>
      void init(T const& m) {
        size_t const R = m.size();
        if (R == 0) {
          return;
        }
        size_t const C = m.begin()->size();
        resize(R, C);
        for (size_t r = 0; r < R; ++r) {
          auto row = m.begin() + r;
          for (size_t c = 0; c < C; ++c) {
            _container[r * C + c] = *(row->begin() + c);
          }
        }
      }
 
      // not noexcept because init isn't
      void
      init(std::initializer_list<std::initializer_list<scalar_type>> const& m) {
        init<std::initializer_list<std::initializer_list<scalar_type>>>(m);
      }
 
     public:
      explicit MatrixCommon(RowView const& rv) : MatrixCommon() {
        resize(1, rv.size());
        std::copy(rv.cbegin(), rv.cend(), _container.begin());
      }
 
      ~MatrixCommon() = default;
 
      // not noexcept because mem allocate is required
      Subclass one() const {
        size_t const n = number_of_rows();
        Subclass     x(semiring(), n, n);
        std::fill(x.begin(), x.end(), scalar_zero());
        for (size_t r = 0; r < n; ++r) {
          x(r, r) = scalar_one();
        }
        return x;
      }

      // Comparison operators
 
      // not noexcept because apparently vector::operator== isn't
      bool operator==(MatrixCommon const& that) const {
        return _container == that._container;
      }
 
      // not noexcept because apparently vector::operator== isn't
      bool operator==(RowView const& that) const {
        return number_of_rows() == 1
               && static_cast<RowView>(*static_cast<Subclass const*>(this))
                      == that;
      }
 
      // not noexcept because apparently vector::operator< isn't
      bool operator<(MatrixCommon const& that) const {
        return _container < that._container;
      }
 
      // not noexcept because apparently vector::operator< isn't
      bool operator<(RowView const& that) const {
        return number_of_rows() == 1
               && static_cast<RowView>(*static_cast<Subclass const*>(this))
                      < that;
      }
 
      // not noexcept because operator== isn't
      template <typename T>
      bool operator!=(T const& that) const {
        static_assert(IsMatrix<T> || std::is_same_v<T, RowView>);
        return !(*this == that);
      }
 
      // not noexcept because operator< isn't
      template <typename T>
      bool operator>(T const& that) const {
        static_assert(IsMatrix<T> || std::is_same_v<T, RowView>);
        return that < *this;
      }
 
      // not noexcept because operator< isn't
      template <typename T>
      bool operator>=(T const& that) const {
        static_assert(IsMatrix<T> || std::is_same_v<T, RowView>);
        return that < *this || that == *this;
      }
 
      // not noexcept because operator< isn't
      template <typename T>
      bool operator<=(T const& that) const {
        static_assert(IsMatrix<T> || std::is_same_v<T, RowView>);
        return *this < that || that == *this;
      }

      // Attributes
 
      // not noexcept because vector::operator[] isn't, and neither is
      // array::operator[]
      scalar_reference operator()(size_t r, size_t c) {
        return this->_container[r * number_of_cols() + c];
      }
 
      scalar_reference at(size_t r, size_t c) {
        matrix::throw_if_bad_coords(static_cast<Subclass const&>(*this), r, c);
        return this->operator()(r, c);
      }
 
      // not noexcept because vector::operator[] isn't, and neither is
      // array::operator[]
      scalar_const_reference operator()(size_t r, size_t c) const {
        return this->_container[r * number_of_cols() + c];
      }
 
      scalar_const_reference at(size_t r, size_t c) const {
        matrix::throw_if_bad_coords(static_cast<Subclass const&>(*this), r, c);
        return this->operator()(r, c);
      }
 
      // noexcept because number_of_rows_impl is noexcept
      size_t number_of_rows() const noexcept {
        return static_cast<Subclass const*>(this)->number_of_rows_impl();
      }
 
      // noexcept because number_of_cols_impl is noexcept
      size_t number_of_cols() const noexcept {
        return static_cast<Subclass const*>(this)->number_of_cols_impl();
      }
 
      // not noexcept because Hash<T>::operator() isn't
      size_t hash_value() const {
        return Hash<Container>()(_container);
      }

      // Arithmetic operators - in-place
 
      // not noexcept because memory is allocated
      void product_inplace_no_checks(Subclass const& A, Subclass const& B) {
        LIBSEMIGROUPS_ASSERT(number_of_rows() == number_of_cols());
        LIBSEMIGROUPS_ASSERT(A.number_of_rows() == number_of_rows());
        LIBSEMIGROUPS_ASSERT(B.number_of_rows() == number_of_rows());
        LIBSEMIGROUPS_ASSERT(A.number_of_cols() == number_of_cols());
        LIBSEMIGROUPS_ASSERT(B.number_of_cols() == number_of_cols());
        LIBSEMIGROUPS_ASSERT(&A != this);
        LIBSEMIGROUPS_ASSERT(&B != this);
 
        // Benchmarking boolean matrix multiplication reveals that using a
        // non-static container_type gives the best performance, when compared
        // to static container_type the performance is more or less the same
        // (but not thread-safe), and there appears to be a performance
        // penalty of about 50% when using static thread_local container_type
        // (when compiling with clang).
        size_t const             N = A.number_of_rows();
        std::vector<scalar_type> tmp(N, 0);
 
        for (size_t c = 0; c < N; c++) {
          for (size_t i = 0; i < N; i++) {
            tmp[i] = B(i, c);
          }
          for (size_t r = 0; r < N; r++) {
            (*this)(r, c) = std::inner_product(
                A._container.begin() + r * N,
                A._container.begin() + (r + 1) * N,
                tmp.begin(),
                scalar_zero(),
                [this](scalar_type x, scalar_type y) {
                  return this->plus_no_checks(x, y);
                },
                [this](scalar_type x, scalar_type y) {
                  return this->product_no_checks(x, y);
                });
          }
        }
      }
 
      // not noexcept because iterator increment isn't
      void operator*=(scalar_type a) {
        for (auto it = _container.begin(); it < _container.end(); ++it) {
          *it = product_no_checks(*it, a);
        }
      }
 
      // not noexcept because vector::operator[] and array::operator[] aren't
      void operator+=(Subclass const& that) {
        LIBSEMIGROUPS_ASSERT(that.number_of_rows() == number_of_rows());
        LIBSEMIGROUPS_ASSERT(that.number_of_cols() == number_of_cols());
        for (size_t i = 0; i < _container.size(); ++i) {
          _container[i] = plus_no_checks(_container[i], that._container[i]);
        }
      }
 
      void operator+=(RowView const& that) {
        LIBSEMIGROUPS_ASSERT(number_of_rows() == 1);
        RowView(*static_cast<Subclass const*>(this)) += that;
      }
 
      void operator+=(scalar_type a) {
        for (auto it = _container.begin(); it < _container.end(); ++it) {
          *it = plus_no_checks(*it, a);
        }
      }
 
      // TODO(2) implement operator*=(Subclass const&)

      // Arithmetic operators - not in-place
 
      // not noexcept because operator+= isn't
      Subclass operator+(Subclass const& y) const {
        Subclass result(*static_cast<Subclass const*>(this));
        result += y;
        return result;
      }
 
      // not noexcept because product_inplace_no_checks isn't
      Subclass operator*(Subclass const& y) const {
        Subclass result(*static_cast<Subclass const*>(this));
        result.product_inplace_no_checks(*static_cast<Subclass const*>(this),
                                         y);
        return result;
      }
 
      Subclass operator*(scalar_type a) const {
        Subclass result(*static_cast<Subclass const*>(this));
        result *= a;
        return result;
      }
 
      Subclass operator+(scalar_type a) const {
        Subclass result(*static_cast<Subclass const*>(this));
        result += a;
        return result;
      }

      // Iterators
 
      // noexcept because vector::begin and array::begin are noexcept
      iterator begin() noexcept {
        return _container.begin();
      }
 
      // noexcept because vector::end and array::end are noexcept
      iterator end() noexcept {
        return _container.end();
      }
 
      // noexcept because vector::begin and array::begin are noexcept
      const_iterator begin() const noexcept {
        return _container.begin();
      }
 
      // noexcept because vector::end and array::end are noexcept
      const_iterator end() const noexcept {
        return _container.end();
      }
 
      // noexcept because vector::cbegin and array::cbegin are noexcept
      const_iterator cbegin() const noexcept {
        return _container.cbegin();
      }
 
      // noexcept because vector::cend and array::cend are noexcept
      const_iterator cend() const noexcept {
        return _container.cend();
      }
 
      template <typename U>
      std::pair<scalar_type, scalar_type> coords(U const& it) const {
        static_assert(
            std::is_same<U, iterator>::value
                || std::is_same<U, const_iterator>::value,
            "the parameter it must be of type iterator or const_iterator");
        scalar_type const v = std::distance(_container.begin(), it);
        return std::make_pair(v / number_of_cols(), v % number_of_cols());
      }

      // Modifiers
 
      // noexcept because vector::swap and array::swap are noexcept
      void swap(MatrixCommon& that) noexcept {
        std::swap(_container, that._container);
      }
 
      // noexcept because swap is noexcept, and so too are number_of_rows and
      // number_of_cols
      void transpose_no_checks() noexcept {
        LIBSEMIGROUPS_ASSERT(number_of_rows() == number_of_cols());
        if (number_of_rows() == 0) {
          return;
        }
        auto& x = *this;
        for (size_t r = 0; r < number_of_rows() - 1; ++r) {
          for (size_t c = r + 1; c < number_of_cols(); ++c) {
            std::swap(x(r, c), x(c, r));
          }
        }
      }
 
      void transpose() {
        matrix::throw_if_not_square(static_cast<Subclass&>(*this));
        transpose_no_checks();
      }

      // Rows
 
      // not noexcept because there's an allocation
      RowView row_no_checks(size_t i) const {
        auto& container = const_cast<Container&>(_container);
        return RowView(static_cast<Subclass const*>(this),
                       container.begin() + i * number_of_cols(),
                       number_of_cols());
      }
 
      RowView row(size_t i) const {
        if (i >= number_of_rows()) {
          LIBSEMIGROUPS_EXCEPTION(
              "index out of range, expected value in [{}, {}), found {}",
              0,
              number_of_rows(),
              i);
        }
        return row_no_checks(i);
      }
 
      // not noexcept because there's an allocation
      template <typename T>
      void rows(T& x) const {
        auto& container = const_cast<Container&>(_container);
        for (auto itc = container.begin(); itc != container.end();
             itc += number_of_cols()) {
          x.emplace_back(
              static_cast<Subclass const*>(this), itc, number_of_cols());
        }
        LIBSEMIGROUPS_ASSERT(x.size() == number_of_rows());
      }

      // Friend functions
 
      friend std::ostream& operator<<(std::ostream& os, MatrixCommon const& x) {
        os << detail::to_string(x);
        return os;
      }
 
     private:
      // Private data
      container_type _container;
    };
 
    template <typename Scalar>
    class MatrixDynamicDim {
     public:
      MatrixDynamicDim() : _number_of_cols(0), _number_of_rows(0) {}
      MatrixDynamicDim(MatrixDynamicDim const&)            = default;
      MatrixDynamicDim(MatrixDynamicDim&&)                 = default;
      MatrixDynamicDim& operator=(MatrixDynamicDim const&) = default;
      MatrixDynamicDim& operator=(MatrixDynamicDim&&)      = default;
 
      MatrixDynamicDim(size_t r, size_t c)
          : _number_of_cols(c), _number_of_rows(r) {}
 
      ~MatrixDynamicDim() = default;
 
      void swap(MatrixDynamicDim& that) noexcept {
        std::swap(_number_of_cols, that._number_of_cols);
        std::swap(_number_of_rows, that._number_of_rows);
      }
 
     protected:
      size_t number_of_rows_impl() const noexcept {
        return _number_of_rows;
      }
 
      size_t number_of_cols_impl() const noexcept {
        return _number_of_cols;
      }
 
     private:
      size_t _number_of_cols;
      size_t _number_of_rows;
    };
 
    template <typename PlusOp,
              typename ProdOp,
              typename ZeroOp,
              typename OneOp,
              typename Scalar>
    struct MatrixStaticArithmetic {
      MatrixStaticArithmetic()                              = default;
      MatrixStaticArithmetic(MatrixStaticArithmetic const&) = default;
      MatrixStaticArithmetic(MatrixStaticArithmetic&&)      = default;
      MatrixStaticArithmetic& operator=(MatrixStaticArithmetic const&)
          = default;
      MatrixStaticArithmetic& operator=(MatrixStaticArithmetic&&) = default;
 
      // TODO(2) from here to the end of MatrixStaticArithmetic should be
      // private or protected
      using scalar_type = Scalar;
 
      static constexpr scalar_type plus_no_checks_impl(scalar_type x,
                                                       scalar_type y) noexcept {
        return PlusOp()(x, y);
      }
 
      static constexpr scalar_type
      product_no_checks_impl(scalar_type x, scalar_type y) noexcept {
        return ProdOp()(x, y);
      }
 
      static constexpr scalar_type one_impl() noexcept {
        return OneOp()();
      }
 
      static constexpr scalar_type zero_impl() noexcept {
        return ZeroOp()();
      }
 
      static constexpr void const* semiring_impl() noexcept {
        return nullptr;
      }
    };

    // RowViews - class for cheaply storing iterators to rows
 
    template <typename Mat, typename Subclass>
    class RowViewCommon {
      static_assert(IsMatrix<Mat>,
                    "the template parameter Mat must be derived from "
                    "MatrixPolymorphicBase");
 
     public:
      using const_iterator = typename Mat::const_iterator;
      using iterator       = typename Mat::iterator;
 
      using scalar_type            = typename Mat::scalar_type;
      using scalar_reference       = typename Mat::scalar_reference;
      using scalar_const_reference = typename Mat::scalar_const_reference;
 
      using Row         = typename Mat::Row;
      using matrix_type = Mat;
 
      size_t size() const noexcept {
        return static_cast<Subclass const*>(this)->length_impl();
      }
 
     private:
      scalar_type plus_no_checks(scalar_type x, scalar_type y) const noexcept {
        return static_cast<Subclass const*>(this)->plus_no_checks_impl(y, x);
      }
 
      scalar_type product_no_checks(scalar_type x,
                                    scalar_type y) const noexcept {
        return static_cast<Subclass const*>(this)->product_no_checks_impl(y, x);
      }
 
     public:
      RowViewCommon()                                = default;
      RowViewCommon(RowViewCommon const&)            = default;
      RowViewCommon(RowViewCommon&&)                 = default;
      RowViewCommon& operator=(RowViewCommon const&) = default;
      RowViewCommon& operator=(RowViewCommon&&)      = default;
 
      explicit RowViewCommon(Row const& r)
          : RowViewCommon(const_cast<Row&>(r).begin()) {}
 
      // Not noexcept because iterator::operator[] isn't
      scalar_const_reference operator[](size_t i) const {
        return _begin[i];
      }
 
      // Not noexcept because iterator::operator[] isn't
      scalar_reference operator[](size_t i) {
        return _begin[i];
      }
 
      // Not noexcept because iterator::operator[] isn't
      scalar_const_reference operator()(size_t i) const {
        return (*this)[i];
      }
 
      // Not noexcept because iterator::operator[] isn't
      scalar_reference operator()(size_t i) {
        return (*this)[i];
      }
 
      // noexcept because begin() is
      const_iterator cbegin() const noexcept {
        return _begin;
      }
 
      // not noexcept because iterator arithmetic isn't
      const_iterator cend() const {
        return _begin + size();
      }
 
      // noexcept because begin() is
      const_iterator begin() const noexcept {
        return _begin;
      }
 
      // not noexcept because iterator arithmetic isn't
      const_iterator end() const {
        return _begin + size();
      }
 
      // noexcept because begin() is
      iterator begin() noexcept {
        return _begin;
      }
 
      // not noexcept because iterator arithmetic isn't
      iterator end() noexcept {
        return _begin + size();
      }

      // Arithmetic operators
 
      // not noexcept because operator[] isn't
      void operator+=(RowViewCommon const& x) {
        auto& this_ = *this;
        for (size_t i = 0; i < size(); ++i) {
          this_[i] = plus_no_checks(this_[i], x[i]);
        }
      }
 
      // not noexcept because iterator arithmeic isn't
      void operator+=(scalar_type a) {
        for (auto& x : *this) {
          x = plus_no_checks(x, a);
        }
      }
 
      // not noexcept because iterator arithmeic isn't
      void operator*=(scalar_type a) {
        for (auto& x : *this) {
          x = product_no_checks(x, a);
        }
      }
 
      // not noexcept because operator*= isn't
      Row operator*(scalar_type a) const {
        Row result(*static_cast<Subclass const*>(this));
        result *= a;
        return result;
      }
 
      // not noexcept because operator+= isn't
      Row operator+(RowViewCommon const& that) const {
        Row result(*static_cast<Subclass const*>(this));
        result += static_cast<Subclass const&>(that);
        return result;
      }
 
      template <typename U>
      bool operator==(U const& that) const {
        // TODO(1) static assert that U is Row or RowView
        return std::equal(begin(), end(), that.begin());
      }
 
      template <typename U>
      bool operator!=(U const& that) const {
        return !(*this == that);
      }
 
      template <typename U>
      bool operator<(U const& that) const {
        return std::lexicographical_compare(
            cbegin(), cend(), that.cbegin(), that.cend());
      }
 
      template <typename U>
      bool operator>(U const& that) const {
        return that < *this;
      }
 
      void swap(RowViewCommon& that) noexcept {
        std::swap(that._begin, _begin);
      }
 
      friend std::ostream& operator<<(std::ostream&        os,
                                      RowViewCommon const& x) {
        os << detail::to_string(x);
        return os;
      }
 
     protected:
      explicit RowViewCommon(iterator first) : _begin(first) {}
 
     private:
      iterator _begin;
    };
 
    template <typename Container>
    void throw_if_any_row_wrong_size(Container const& m) {
      if (m.size() <= 1) {
        return;
      }
      uint64_t const C  = m.begin()->size();
      auto           it = std::find_if_not(
          m.begin() + 1, m.end(), [&C](typename Container::const_reference r) {
            return r.size() == C;
          });
      if (it != m.end()) {
        LIBSEMIGROUPS_EXCEPTION("invalid argument, expected every item to "
                                "have length {}, found {} in entry {}",
                                C,
                                it->size(),
                                std::distance(m.begin(), it));
      }
    }
 
    template <typename Scalar>
    void throw_if_any_row_wrong_size(
        std::initializer_list<std::initializer_list<Scalar>> m) {
      throw_if_any_row_wrong_size<
          std::initializer_list<std::initializer_list<Scalar>>>(m);
    }
 
  }  // namespace detail

  // Matrix forward declarations
 
#ifndef LIBSEMIGROUPS_PARSED_BY_DOXYGEN
  template <typename PlusOp,
            typename ProdOp,
            typename ZeroOp,
            typename OneOp,
            size_t R,
            size_t C,
            typename Scalar>
  class StaticMatrix;
 
  template <typename... Args>
  class DynamicMatrix;
 
  template <typename PlusOp,
            typename ProdOp,
            typename ZeroOp,
            typename OneOp,
            typename Scalar>
  class DynamicMatrix<PlusOp, ProdOp, ZeroOp, OneOp, Scalar>;
 
  template <typename Semiring, typename Scalar>
  class DynamicMatrix<Semiring, Scalar>;
#endif


  // StaticRowViews - static arithmetic

  template <typename PlusOp,
            typename ProdOp,
            typename ZeroOp,
            typename OneOp,
            size_t C,
            typename Scalar>
  class StaticRowView
      : public detail::RowViewCommon<
            StaticMatrix<PlusOp, ProdOp, ZeroOp, OneOp, 1, C, Scalar>,
            StaticRowView<PlusOp, ProdOp, ZeroOp, OneOp, C, Scalar>>,
        public detail::
            MatrixStaticArithmetic<PlusOp, ProdOp, ZeroOp, OneOp, Scalar> {
   private:
    using RowViewCommon = detail::RowViewCommon<
        StaticMatrix<PlusOp, ProdOp, ZeroOp, OneOp, 1, C, Scalar>,
        StaticRowView<PlusOp, ProdOp, ZeroOp, OneOp, C, Scalar>>;
    friend RowViewCommon;
 
    template <size_t R>
    using StaticMatrix_ = ::libsemigroups::
        StaticMatrix<PlusOp, ProdOp, ZeroOp, OneOp, R, C, Scalar>;
 
   public:
    using const_iterator = typename RowViewCommon::const_iterator;

    using iterator = typename RowViewCommon::iterator;

    using scalar_type = Scalar;

    using scalar_reference = typename RowViewCommon::scalar_reference;

    // clang-format off
    // NOLINTNEXTLINE(whitespace/line_length)
    using scalar_const_reference = typename RowViewCommon::scalar_const_reference;
    // clang-format on

    using matrix_type = typename RowViewCommon::matrix_type;

    using Row = typename matrix_type::Row;

    StaticRowView() = default;

    StaticRowView(StaticRowView const&) = default;

    StaticRowView(StaticRowView&&) = default;

    StaticRowView& operator=(StaticRowView const&) = default;

    StaticRowView& operator=(StaticRowView&&) = default;
 
#ifndef LIBSEMIGROUPS_PARSED_BY_DOXYGEN
    using RowViewCommon::RowViewCommon;
 
    // TODO(2) This constructor should be private
    template <size_t R>
    StaticRowView(StaticMatrix_<R> const*,
                  typename RowViewCommon::iterator it,
                  size_t)
        : RowViewCommon(it) {}
 
    using RowViewCommon::size;
#else
    explicit StaticRowView(Row const& r);

    static constexpr size_t size() const noexcept;

    iterator begin() noexcept;

    iterator end();

    const_iterator cbegin() const noexcept;

    iterator cend();

    scalar_reference operator()(size_t i);

    scalar_const_reference operator()(size_t i) const;

    scalar_reference operator[](size_t i);

    scalar_const_reference operator[](size_t i) const;

    template <typename U>
    bool operator==(U const& that) const;

    template <typename U>
    bool operator!=(U const& that) const;

    // clang-format off
    // NOLINTNEXTLINE(whitespace/line_length)
    // clang-format on
    template <typename U>
    bool operator<(U const& that) const;

    template <typename U>
    bool operator<(U const& that) const;

    Row operator+(StaticRowView const& that);

    void operator+=(StaticRowView const& that);

    void operator+=(scalar_type a);

    Row operator*(scalar_type a) const;

    void operator*=(scalar_type a);
#endif
 
   private:
    static constexpr size_t length_impl() noexcept {
      return C;
    }
  };

  // DynamicRowViews - static arithmetic
 
#ifndef LIBSEMIGROUPS_PARSED_BY_DOXYGEN
  // Doxygen needs to ignore this so that the actual implementation of
  // DynamicRowView gets documented.
  template <typename... Args>
  class DynamicRowView;
#endif

  template <typename PlusOp,
            typename ProdOp,
            typename ZeroOp,
            typename OneOp,
            typename Scalar>
  class DynamicRowView<PlusOp, ProdOp, ZeroOp, OneOp, Scalar>
      : public detail::RowViewCommon<
            DynamicMatrix<PlusOp, ProdOp, ZeroOp, OneOp, Scalar>,
            DynamicRowView<PlusOp, ProdOp, ZeroOp, OneOp, Scalar>>,
        public detail::
            MatrixStaticArithmetic<PlusOp, ProdOp, ZeroOp, OneOp, Scalar> {
   private:
    using DynamicMatrix_ = DynamicMatrix<PlusOp, ProdOp, ZeroOp, OneOp, Scalar>;
    using RowViewCommon  = detail::RowViewCommon<
        DynamicMatrix_,
        DynamicRowView<PlusOp, ProdOp, ZeroOp, OneOp, Scalar>>;
    friend RowViewCommon;
 
   public:
    using const_iterator = typename RowViewCommon::const_iterator;

    using iterator = typename RowViewCommon::iterator;

    using scalar_type = Scalar;

    using scalar_reference = typename RowViewCommon::scalar_reference;

    // clang-format off
    // NOLINTNEXTLINE(whitespace/line_length)
    using scalar_const_reference = typename RowViewCommon::scalar_const_reference;
    // clang-format on

    using matrix_type = typename RowViewCommon::matrix_type;

    using Row = typename matrix_type::Row;

    DynamicRowView() = default;

    DynamicRowView(DynamicRowView const&) = default;

    DynamicRowView(DynamicRowView&&) = default;

    DynamicRowView& operator=(DynamicRowView const&) = default;

    DynamicRowView& operator=(DynamicRowView&&) = default;

    explicit DynamicRowView(Row const& r)
        : RowViewCommon(r), _length(r.number_of_cols()) {}
 
#ifndef LIBSEMIGROUPS_PARSED_BY_DOXYGEN
    using RowViewCommon::RowViewCommon;
 
    // TODO(2) This constructor should be private
    DynamicRowView(DynamicMatrix_ const*, iterator const& it, size_t N)
        : RowViewCommon(it), _length(N) {}
 
    using RowViewCommon::size;
#else
    size_t size() const noexcept;

    iterator begin() noexcept;

    iterator end();

    const_iterator cbegin() const noexcept;

    iterator cend();

    scalar_reference operator()(size_t i);

    scalar_const_reference operator()(size_t i) const;

    scalar_reference operator[](size_t i);

    scalar_const_reference operator[](size_t i) const;

    template <typename U>
    bool operator==(U const& that) const;

    template <typename U>
    bool operator!=(U const& that) const;

    template <typename U>
    bool operator<(U const& that) const;

    template <typename U>
    bool operator<(U const& that) const;

    Row operator+(DynamicRowView const& that);

    void operator+=(DynamicRowView const& that);

    void operator+=(scalar_type a);

    Row operator*(scalar_type a) const;

    void operator*=(scalar_type a);
#endif  // LIBSEMIGROUPS_PARSED_BY_DOXYGEN
 
   private:
    size_t length_impl() const noexcept {
      return _length;
    }
    size_t _length;
  };

  // DynamicRowViews - dynamic arithmetic

  template <typename Semiring, typename Scalar>
  class DynamicRowView<Semiring, Scalar>
      : public detail::RowViewCommon<DynamicMatrix<Semiring, Scalar>,
                                     DynamicRowView<Semiring, Scalar>> {
   private:
    using DynamicMatrix_ = DynamicMatrix<Semiring, Scalar>;
    friend DynamicMatrix_;
    using RowViewCommon
        = detail::RowViewCommon<DynamicMatrix_,
                                DynamicRowView<Semiring, Scalar>>;
    friend RowViewCommon;
 
   public:
    using const_iterator = typename RowViewCommon::const_iterator;

    using iterator = typename RowViewCommon::iterator;

    using scalar_type = Scalar;

    using scalar_reference = typename RowViewCommon::scalar_reference;

    // clang-format off
    // NOLINTNEXTLINE(whitespace/line_length)
    using scalar_const_reference = typename RowViewCommon::scalar_const_reference;
    // clang-format on

    using matrix_type = typename RowViewCommon::matrix_type;

    using Row = typename matrix_type::Row;

    DynamicRowView() = default;

    DynamicRowView(DynamicRowView const&) = default;

    DynamicRowView(DynamicRowView&&) = default;

    DynamicRowView& operator=(DynamicRowView const&) = default;

    DynamicRowView& operator=(DynamicRowView&&) = default;

    explicit DynamicRowView(Row const& r) : RowViewCommon(r), _matrix(&r) {}
 
#ifndef LIBSEMIGROUPS_PARSED_BY_DOXYGEN
    using RowViewCommon::RowViewCommon;
 
    // TODO(2) This constructor should be private
    DynamicRowView(DynamicMatrix_ const* mat, iterator const& it, size_t)
        : RowViewCommon(it), _matrix(mat) {}
 
    using RowViewCommon::size;
#else
    size_t size() const noexcept;

    iterator begin() noexcept;

    iterator end();

    const_iterator cbegin() const noexcept;

    iterator cend();

    scalar_reference operator()(size_t i);

    scalar_const_reference operator()(size_t i) const;

    scalar_reference operator[](size_t i);

    scalar_const_reference operator[](size_t i) const;

    template <typename U>
    bool operator==(U const& that) const;

    template <typename U>
    bool operator!=(U const& that) const;

    template <typename U>
    bool operator<(U const& that) const;

    template <typename U>
    bool operator<(U const& that) const;

    Row operator+(DynamicRowView const& that);

    void operator+=(DynamicRowView const& that);

    void operator+=(scalar_type a);

    Row operator*(scalar_type a) const;

    void operator*=(scalar_type a);
#endif
 
   private:
    size_t length_impl() const noexcept {
      return _matrix->number_of_cols();
    }
 
    scalar_type plus_no_checks_impl(scalar_type x,
                                    scalar_type y) const noexcept {
      return _matrix->plus_no_checks_impl(x, y);
    }
 
    scalar_type product_no_checks_impl(scalar_type x,
                                       scalar_type y) const noexcept {
      return _matrix->product_no_checks_impl(x, y);
    }
 
    DynamicMatrix_ const* _matrix;
  };

  // StaticMatrix with compile time semiring arithmetic

  template <typename PlusOp,
            typename ProdOp,
            typename ZeroOp,
            typename OneOp,
            size_t R,
            size_t C,
            typename Scalar>
  class StaticMatrix
      : public detail::
            MatrixStaticArithmetic<PlusOp, ProdOp, ZeroOp, OneOp, Scalar>,
        public detail::MatrixCommon<
            std::array<Scalar, R * C>,
            StaticMatrix<PlusOp, ProdOp, ZeroOp, OneOp, R, C, Scalar>,
            StaticRowView<PlusOp, ProdOp, ZeroOp, OneOp, C, Scalar>> {
    // StaticMatrix - Aliases - private
 
    using MatrixCommon = ::libsemigroups::detail::MatrixCommon<
        std::array<Scalar, R * C>,
        StaticMatrix<PlusOp, ProdOp, ZeroOp, OneOp, R, C, Scalar>,
        StaticRowView<PlusOp, ProdOp, ZeroOp, OneOp, C, Scalar>>;
    friend MatrixCommon;
 
   public:
    // StaticMatrix - Aliases - public

    using scalar_type = typename MatrixCommon::scalar_type;

    using scalar_reference = typename MatrixCommon::scalar_reference;

    // clang-format off
    // NOLINTNEXTLINE(whitespace/line_length)
    using scalar_const_reference = typename MatrixCommon::scalar_const_reference;
    // clang-format on

    using Row = StaticMatrix<PlusOp, ProdOp, ZeroOp, OneOp, 1, C, Scalar>;

    using RowView = StaticRowView<PlusOp, ProdOp, ZeroOp, OneOp, C, Scalar>;

    using Plus = PlusOp;

    using Prod = ProdOp;

    using Zero = ZeroOp;

    using One = OneOp;

    using iterator = typename MatrixCommon::iterator;

    using const_iterator = typename MatrixCommon::const_iterator;
 
    static constexpr size_t nr_rows = R;
    static constexpr size_t nr_cols = C;

    // StaticMatrix - Constructors + destructor - public

    explicit StaticMatrix(std::initializer_list<scalar_type> const& c)
        : MatrixCommon(c) {
      static_assert(R == 1,
                    "cannot construct Matrix from the given initializer list, "
                    "incompatible dimensions");
      LIBSEMIGROUPS_ASSERT(c.size() == C);
    }

    explicit StaticMatrix(
        std::initializer_list<std::initializer_list<scalar_type>> const& m)
        : MatrixCommon(m) {}

    explicit StaticMatrix(std::vector<std::vector<scalar_type>> const& m)
        : MatrixCommon(m) {}

    explicit StaticMatrix(RowView const& rv) : MatrixCommon(rv) {
      static_assert(
          R == 1,
          "cannot construct Matrix with more than one row from RowView!");
    }

    StaticMatrix() = default;

    StaticMatrix(StaticMatrix const&) = default;

    StaticMatrix(StaticMatrix&&) = default;

    StaticMatrix& operator=(StaticMatrix const&) = default;

    StaticMatrix& operator=(StaticMatrix&&) = default;
 
#ifndef LIBSEMIGROUPS_PARSED_BY_DOXYGEN
    // For uniformity of interface, the args do nothing
    StaticMatrix(size_t r, size_t c) : StaticMatrix() {
      (void) r;
      (void) c;
      LIBSEMIGROUPS_ASSERT(r == number_of_rows());
      LIBSEMIGROUPS_ASSERT(c == number_of_cols());
    }
 
    // For uniformity of interface, the first arg does nothing
    StaticMatrix(void const* ptr, std::initializer_list<scalar_type> const& c)
        : StaticMatrix(c) {
      (void) ptr;
      LIBSEMIGROUPS_ASSERT(ptr == nullptr);
    }
 
    // For uniformity of interface, the first arg does nothing
    StaticMatrix(
        void const*                                                      ptr,
        std::initializer_list<std::initializer_list<scalar_type>> const& m)
        : StaticMatrix(m) {
      (void) ptr;
      LIBSEMIGROUPS_ASSERT(ptr == nullptr);
    }
 
    // For uniformity of interface, the first arg does nothing
    explicit StaticMatrix(void const* ptr, RowView const& rv)
        : StaticMatrix(rv) {
      (void) ptr;
      LIBSEMIGROUPS_ASSERT(ptr == nullptr);
    }
 
    // For uniformity of interface, no arg used for anything
    StaticMatrix(void const* ptr, size_t r, size_t c) : StaticMatrix(r, c) {
      (void) ptr;
      LIBSEMIGROUPS_ASSERT(ptr == nullptr);
    }
#endif
 
    ~StaticMatrix() = default;
 
#ifndef LIBSEMIGROUPS_PARSED_BY_DOXYGEN
    static StaticMatrix one(size_t n) {
      // If specified the value of n must equal R or otherwise weirdness will
      // ensue...
      LIBSEMIGROUPS_ASSERT(n == 0 || n == R);
      (void) n;
#if defined(__APPLE__) && defined(__clang__) \
    && (__clang_major__ == 13 || __clang_major__ == 14)
      // With Apple clang version 13.1.6 (clang-1316.0.21.2.5) something goes
      // wrong and the value R is optimized away somehow, meaning that the
      // values on the diagonal aren't actually set. This only occurs when
      // libsemigroups is compiled with -O2 or higher.
      size_t volatile const m = R;
#else
      size_t const m = R;
#endif
      StaticMatrix x(m, m);
      std::fill(x.begin(), x.end(), ZeroOp()());
      for (size_t r = 0; r < m; ++r) {
        x(r, r) = OneOp()();
      }
      return x;
    }
 
    static StaticMatrix one(void const* ptr, size_t n = 0) {
      (void) ptr;
      LIBSEMIGROUPS_ASSERT(ptr == nullptr);
      LIBSEMIGROUPS_ASSERT(n == 0 || n == R);
      return one(n);
    }
#endif  // LIBSEMIGROUPS_PARSED_BY_DOXYGEN

    // StaticMatrix - member function aliases - public
#ifdef LIBSEMIGROUPS_PARSED_BY_DOXYGEN
    scalar_reference operator()(size_t r, size_t c);

    scalar_reference at(size_t r, size_t c);

    scalar_const_reference operator()(size_t r, size_t c) const;

    scalar_const_reference at(size_t r, size_t c) const;

    iterator begin() noexcept;

    iterator end();

    const_iterator cbegin() const noexcept;

    const_iterator cend();

    bool operator==(StaticMatrix const& that) const;

    bool operator==(RowView const& that) const;

    bool operator!=(StaticMatrix const& that) const;

    bool operator!=(RowView const& that) const;

    bool operator<(StaticMatrix const& that) const;

    bool operator<(RowView const& that) const;

    bool operator>(StaticMatrix const& that) const;

    std::pair<scalar_type, scalar_type> coords(const_iterator it) const;

    size_t number_of_rows() const noexcept;

    size_t number_of_cols() const noexcept;

    StaticMatrix operator+(StaticMatrix const& that);

    void operator+=(StaticMatrix const& that);

    void operator+=(RowView const& that);

    void operator+=(scalar_type a);

    StaticMatrix operator*(StaticMatrix const& that);

    void operator*=(scalar_type a);

    void product_inplace_no_checks(StaticMatrix const& x,
                                   StaticMatrix const& y);

    RowView row_no_checks(size_t i) const;

    RowView row(size_t i) const;

    template <typename T>
    void rows(T& x) const;

    void swap(StaticMatrix& that) noexcept;

    void transpose();

    void transpose_no_checks();

    static StaticMatrix one() const;

    size_t hash_value() const;

    template <typename U>
    bool operator<=(U const& that) const;

    template <typename U>
    bool operator>=(U const& that) const;

    StaticMatrix operator*(scalar_type a);

    StaticMatrix operator+(scalar_type a);

    scalar_type scalar_zero() const noexcept;

    scalar_type scalar_one() const noexcept;

    semiring_type const* semiring() const noexcept;
 
#else
    using MatrixCommon::at;
    using MatrixCommon::begin;
    using MatrixCommon::cbegin;
    using MatrixCommon::cend;
    using MatrixCommon::coords;
    using MatrixCommon::end;
    using MatrixCommon::hash_value;
    using MatrixCommon::number_of_cols;
    using MatrixCommon::number_of_rows;
    using MatrixCommon::one;
    using MatrixCommon::operator!=;
    using MatrixCommon::operator();
    using MatrixCommon::operator*;
    using MatrixCommon::operator*=;
    using MatrixCommon::operator+;
    using MatrixCommon::operator+=;
    using MatrixCommon::operator<;  // NOLINT(whitespace/operators)
    using MatrixCommon::operator<=;
    using MatrixCommon::operator==;
    using MatrixCommon::operator>;  // NOLINT(whitespace/operators)
    using MatrixCommon::operator>=;
    using MatrixCommon::product_inplace_no_checks;
    using MatrixCommon::row;
    using MatrixCommon::row_no_checks;
    using MatrixCommon::rows;
    using MatrixCommon::scalar_one;
    using MatrixCommon::scalar_zero;
    using MatrixCommon::semiring;
    using MatrixCommon::swap;
    using MatrixCommon::transpose;
    using MatrixCommon::transpose_no_checks;
#endif  // LIBSEMIGROUPS_PARSED_BY_DOXYGEN
 
   private:
    // StaticMatrix - implementation of MatrixCommon requirements - private
 
    static constexpr size_t number_of_rows_impl() noexcept {
      return R;
    }
    static constexpr size_t number_of_cols_impl() noexcept {
      return C;
    }
  };

  // DynamicMatrix with compile time semiring arithmetic

  template <typename PlusOp,
            typename ProdOp,
            typename ZeroOp,
            typename OneOp,
            typename Scalar>
  class DynamicMatrix<PlusOp, ProdOp, ZeroOp, OneOp, Scalar>
      : public detail::MatrixDynamicDim<Scalar>,
        public detail::MatrixCommon<
            std::vector<Scalar>,
            DynamicMatrix<PlusOp, ProdOp, ZeroOp, OneOp, Scalar>,
            DynamicRowView<PlusOp, ProdOp, ZeroOp, OneOp, Scalar>>,
        public detail::
            MatrixStaticArithmetic<PlusOp, ProdOp, ZeroOp, OneOp, Scalar> {
    using MatrixDynamicDim = ::libsemigroups::detail::MatrixDynamicDim<Scalar>;
    using MatrixCommon     = ::libsemigroups::detail::MatrixCommon<
        std::vector<Scalar>,
        DynamicMatrix<PlusOp, ProdOp, ZeroOp, OneOp, Scalar>,
        DynamicRowView<PlusOp, ProdOp, ZeroOp, OneOp, Scalar>>;
    friend MatrixCommon;
 
   public:
    using scalar_type = typename MatrixCommon::scalar_type;

    using scalar_reference = typename MatrixCommon::scalar_reference;

    // clang-format off
    // NOLINTNEXTLINE(whitespace/line_length)
    using scalar_const_reference = typename MatrixCommon::scalar_const_reference;
    // clang-format on

    using Row = DynamicMatrix;

    using RowView = DynamicRowView<PlusOp, ProdOp, ZeroOp, OneOp, Scalar>;

    using Plus = PlusOp;

    using Prod = ProdOp;

    using Zero = ZeroOp;

    using One = OneOp;

    using semiring_type = void;

    DynamicMatrix() = default;

    DynamicMatrix(DynamicMatrix const&) = default;

    DynamicMatrix(DynamicMatrix&&) = default;

    DynamicMatrix& operator=(DynamicMatrix const&) = default;

    DynamicMatrix& operator=(DynamicMatrix&&) = default;

    DynamicMatrix(size_t r, size_t c) : MatrixDynamicDim(r, c), MatrixCommon() {
      resize(number_of_rows(), number_of_cols());
    }

    explicit DynamicMatrix(std::initializer_list<scalar_type> const& c)
        : MatrixDynamicDim(1, c.size()), MatrixCommon(c) {}

    explicit DynamicMatrix(
        std::initializer_list<std::initializer_list<scalar_type>> const& m)
        : MatrixDynamicDim(m.size(), std::empty(m) ? 0 : m.begin()->size()),
          MatrixCommon(m) {}

    explicit DynamicMatrix(std::vector<std::vector<scalar_type>> const& m)
        : MatrixDynamicDim(m.size(), std::empty(m) ? 0 : m.begin()->size()),
          MatrixCommon(m) {}

    explicit DynamicMatrix(RowView const& rv)
        : MatrixDynamicDim(1, rv.size()), MatrixCommon(rv) {}
 
#ifndef LIBSEMIGROUPS_PARSED_BY_DOXYGEN
    // For uniformity of interface, the first arg does nothing
    DynamicMatrix(void const* ptr, size_t r, size_t c) : DynamicMatrix(r, c) {
      (void) ptr;
      LIBSEMIGROUPS_ASSERT(ptr == nullptr);
    }
 
    // For uniformity of interface, the first arg does nothing
    DynamicMatrix(void const* ptr, std::initializer_list<scalar_type> const& c)
        : DynamicMatrix(c) {
      (void) ptr;
      LIBSEMIGROUPS_ASSERT(ptr == nullptr);
    }
 
    // For uniformity of interface, the first arg does nothing
    DynamicMatrix(
        void const*                                                      ptr,
        std::initializer_list<std::initializer_list<scalar_type>> const& m)
        : DynamicMatrix(m) {
      (void) ptr;
      LIBSEMIGROUPS_ASSERT(ptr == nullptr);
    }
 
    static DynamicMatrix one(void const* ptr, size_t n) {
      (void) ptr;
      LIBSEMIGROUPS_ASSERT(ptr == nullptr);
      return one(n);
    }
#endif  // LIBSEMIGROUPS_PARSED_BY_DOXYGEN
 
    ~DynamicMatrix() = default;

    static DynamicMatrix one(size_t n) {
      DynamicMatrix x(n, n);
      std::fill(x.begin(), x.end(), ZeroOp()());
      for (size_t r = 0; r < n; ++r) {
        x(r, r) = OneOp()();
      }
      return x;
    }
 
#ifdef LIBSEMIGROUPS_PARSED_BY_DOXYGEN
    scalar_reference at(size_t r, size_t c);

    scalar_reference at(size_t r, size_t c) const;

    iterator begin() noexcept;

    const_iterator cbegin() noexcept;

    const_iterator cend() noexcept;

    std::pair<scalar_type, scalar_type> coords(const_iterator it) const;

    iterator end() noexcept;

    size_t hash_value() const;

    size_t number_of_cols() const noexcept;

    size_t number_of_rows() const noexcept;

    bool operator!=(DynamicMatrix const& that) const;

    bool operator!=(RowView const& that) const;

    scalar_reference operator()(size_t r, size_t c);

    scalar_const_reference operator()(size_t r, size_t c) const;
    DynamicMatrix operator*(scalar_type a);

    DynamicMatrix operator*(DynamicMatrix const& that);

    void operator*=(scalar_type a);

    DynamicMatrix operator+(DynamicMatrix const& that);

    void operator+=(DynamicMatrix const& that);

    void operator+=(RowView const& that);

    void operator+=(scalar_type a);

    bool operator<(DynamicMatrix const& that) const;

    bool operator<(RowView const& that) const;

    template <typename T>
    bool operator<=(T const& that) const;

    bool operator==(DynamicMatrix const& that) const;

    bool operator==(RowView const& that) const;

    bool operator>(DynamicMatrix const& that) const;

    template <typename T>
    bool operator>=(T const& that) const;

    void product_inplace_no_checks(DynamicMatrix const& x,
                                   DynamicMatrix const& y);

    RowView row(size_t i) const;

    RowView row_no_checks(size_t i) const;

    template <typename T>
    void rows(T& x) const;

    scalar_type scalar_one() const noexcept;

    scalar_type scalar_zero() const noexcept;

    semiring_type const* semiring() const noexcept;

    void transpose();

    void transpose_no_checks();
#else
    using MatrixCommon::at;
    using MatrixCommon::begin;
    using MatrixCommon::cbegin;
    using MatrixCommon::cend;
    using MatrixCommon::coords;
    using MatrixCommon::end;
    using MatrixCommon::hash_value;
    using MatrixCommon::number_of_cols;
    using MatrixCommon::number_of_rows;
    using MatrixCommon::one;
    using MatrixCommon::operator!=;
    using MatrixCommon::operator();
    using MatrixCommon::operator*;
    using MatrixCommon::operator*=;
    using MatrixCommon::operator+;
    using MatrixCommon::operator+=;
    using MatrixCommon::operator<;  // NOLINT(whitespace/operators)
    using MatrixCommon::operator<=;
    using MatrixCommon::operator==;
    using MatrixCommon::operator>;  // NOLINT(whitespace/operators)
    using MatrixCommon::operator>=;
    using MatrixCommon::product_inplace_no_checks;
    using MatrixCommon::row;
    using MatrixCommon::row_no_checks;
    using MatrixCommon::rows;
    using MatrixCommon::scalar_one;
    using MatrixCommon::scalar_zero;
    using MatrixCommon::semiring;
    // using MatrixCommon::swap; // Don't want this use the one below.
    using MatrixCommon::transpose;
    using MatrixCommon::transpose_no_checks;
#endif  // LIBSEMIGROUPS_PARSED_BY_DOXYGEN

    void swap(DynamicMatrix& that) noexcept {
      static_cast<MatrixDynamicDim&>(*this).swap(
          static_cast<MatrixDynamicDim&>(that));
      static_cast<MatrixCommon&>(*this).swap(static_cast<MatrixCommon&>(that));
    }
 
   private:
    using MatrixCommon::resize;
  };

  // DynamicMatrix with runtime semiring arithmetic

  template <typename Semiring, typename Scalar>
  class DynamicMatrix<Semiring, Scalar>
      : public detail::MatrixDynamicDim<Scalar>,
        public detail::MatrixCommon<std::vector<Scalar>,
                                    DynamicMatrix<Semiring, Scalar>,
                                    DynamicRowView<Semiring, Scalar>,
                                    Semiring> {
    using MatrixCommon = detail::MatrixCommon<std::vector<Scalar>,
                                              DynamicMatrix<Semiring, Scalar>,
                                              DynamicRowView<Semiring, Scalar>,
                                              Semiring>;
    friend MatrixCommon;
    using MatrixDynamicDim = ::libsemigroups::detail::MatrixDynamicDim<Scalar>;
 
   public:
    using scalar_type = typename MatrixCommon::scalar_type;

    using scalar_reference = typename MatrixCommon::scalar_reference;

    // clang-format off
    // NOLINTNEXTLINE(whitespace/line_length)
    using scalar_const_reference = typename MatrixCommon::scalar_const_reference;
    // clang-format on

    using Row = DynamicMatrix;

    using RowView = DynamicRowView<Semiring, Scalar>;
 
    friend RowView;

    using semiring_type = Semiring;

    DynamicMatrix() = delete;

    DynamicMatrix(DynamicMatrix const&) = default;

    DynamicMatrix(DynamicMatrix&&) = default;

    DynamicMatrix& operator=(DynamicMatrix const&) = default;

    DynamicMatrix& operator=(DynamicMatrix&&) = default;

    DynamicMatrix(Semiring const* sr, size_t r, size_t c)
        : MatrixDynamicDim(r, c), MatrixCommon(), _semiring(sr) {
      resize(number_of_rows(), number_of_cols());
    }

    explicit DynamicMatrix(
        Semiring const*                                                  sr,
        std::initializer_list<std::initializer_list<scalar_type>> const& rws)
        : MatrixDynamicDim(rws.size(),
                           std::empty(rws) ? 0 : rws.begin()->size()),
          MatrixCommon(rws),
          _semiring(sr) {}

    explicit DynamicMatrix(Semiring const*                              sr,
                           std::vector<std::vector<scalar_type>> const& rws)
        : MatrixDynamicDim(rws.size(), (rws.empty() ? 0 : rws.begin()->size())),
          MatrixCommon(rws),
          _semiring(sr) {}

    explicit DynamicMatrix(Semiring const*                           sr,
                           std::initializer_list<scalar_type> const& rw)
        : MatrixDynamicDim(1, rw.size()), MatrixCommon(rw), _semiring(sr) {}

    explicit DynamicMatrix(RowView const& rv)
        : MatrixDynamicDim(1, rv.size()),
          MatrixCommon(rv),
          _semiring(rv._matrix->semiring()) {}

    // No static DynamicMatrix::one(size_t n) because we need a semiring!
    static DynamicMatrix one(Semiring const* semiring, size_t n) {
      DynamicMatrix x(semiring, n, n);
      std::fill(x.begin(), x.end(), x.scalar_zero());
      for (size_t r = 0; r < n; ++r) {
        x(r, r) = x.scalar_one();
      }
      return x;
    }
 
    ~DynamicMatrix() = default;
 
#ifdef LIBSEMIGROUPS_PARSED_BY_DOXYGEN
    scalar_reference at(size_t r, size_t c);

    scalar_reference at(size_t r, size_t c) const;

    iterator begin() noexcept;

    const_iterator cbegin() noexcept;

    const_iterator cend() noexcept;

    std::pair<scalar_type, scalar_type> coords(const_iterator it) const;

    iterator end() noexcept;

    size_t hash_value() const;

    size_t number_of_cols() const noexcept;

    size_t number_of_rows() const noexcept;

    bool operator!=(DynamicMatrix const& that) const;

    bool operator!=(RowView const& that) const;

    scalar_reference operator()(size_t r, size_t c);

    scalar_const_reference operator()(size_t r, size_t c) const;
    DynamicMatrix operator*(scalar_type a);

    DynamicMatrix operator*(DynamicMatrix const& that);

    void operator*=(scalar_type a);

    DynamicMatrix operator+(DynamicMatrix const& that);

    void operator+=(DynamicMatrix const& that);

    void operator+=(RowView const& that);

    void operator+=(scalar_type a);

    bool operator<(DynamicMatrix const& that) const;

    bool operator<(RowView const& that) const;

    template <typename T>
    bool operator<=(T const& that) const;

    bool operator==(DynamicMatrix const& that) const;

    bool operator==(RowView const& that) const;

    bool operator>(DynamicMatrix const& that) const;

    template <typename T>
    bool operator>=(T const& that) const;

    void product_inplace_no_checks(DynamicMatrix const& x,
                                   DynamicMatrix const& y);

    RowView row(size_t i) const;

    RowView row_no_checks(size_t i) const;

    template <typename T>
    void rows(T& x) const;

    scalar_type scalar_one() const noexcept;

    scalar_type scalar_zero() const noexcept;

    semiring_type const* semiring() const noexcept;

    void transpose();

    void transpose_no_checks();
#else
    using MatrixCommon::at;
    using MatrixCommon::begin;
    using MatrixCommon::cbegin;
    using MatrixCommon::cend;
    using MatrixCommon::coords;
    using MatrixCommon::end;
    using MatrixCommon::hash_value;
    using MatrixCommon::number_of_cols;
    using MatrixCommon::number_of_rows;
    using MatrixCommon::one;
    using MatrixCommon::operator!=;
    using MatrixCommon::operator();
    using MatrixCommon::operator*;
    using MatrixCommon::operator*=;
    using MatrixCommon::operator+;
    using MatrixCommon::operator+=;
    using MatrixCommon::operator<;  // NOLINT(whitespace/operators)
    using MatrixCommon::operator<=;
    using MatrixCommon::operator==;
    using MatrixCommon::operator>;  // NOLINT(whitespace/operators)
    using MatrixCommon::operator>=;
    using MatrixCommon::product_inplace_no_checks;
    using MatrixCommon::row;
    using MatrixCommon::row_no_checks;
    using MatrixCommon::rows;
    using MatrixCommon::scalar_one;
    using MatrixCommon::scalar_zero;
    using MatrixCommon::semiring;
    // using MatrixCommon::swap; // Don't want this use the one below.
    using MatrixCommon::transpose;
    using MatrixCommon::transpose_no_checks;
#endif  // LIBSEMIGROUPS_PARSED_BY_DOXYGEN

    void swap(DynamicMatrix& that) noexcept {
      static_cast<MatrixDynamicDim&>(*this).swap(
          static_cast<MatrixDynamicDim&>(that));
      static_cast<MatrixCommon&>(*this).swap(static_cast<MatrixCommon&>(that));
      std::swap(_semiring, that._semiring);
    }
 
   private:
    using MatrixCommon::resize;
 
    scalar_type plus_no_checks_impl(scalar_type x,
                                    scalar_type y) const noexcept {
      return _semiring->plus_no_checks(x, y);
    }
 
    scalar_type product_no_checks_impl(scalar_type x,
                                       scalar_type y) const noexcept {
      return _semiring->product_no_checks(x, y);
    }
 
    scalar_type one_impl() const noexcept {
      return _semiring->scalar_one();
    }
 
    scalar_type zero_impl() const noexcept {
      return _semiring->scalar_zero();
    }
 
    Semiring const* semiring_impl() const noexcept {
      return _semiring;
    }
 
    Semiring const* _semiring;
  };

  // Helper structs to check if matrix is static, or has a pointer to a
  // semiring
 
  namespace detail {
    template <typename T>
    struct IsStaticMatrixHelper : std::false_type {};
 
    template <typename PlusOp,
              typename ProdOp,
              typename ZeroOp,
              typename OneOp,
              size_t R,
              size_t C,
              typename Scalar>
    struct IsStaticMatrixHelper<
        StaticMatrix<PlusOp, ProdOp, ZeroOp, OneOp, R, C, Scalar>>
        : std::true_type {};
 
    template <typename T>
    struct IsMatWithSemiringHelper : std::false_type {};
 
    template <typename Semiring, typename Scalar>
    struct IsMatWithSemiringHelper<DynamicMatrix<Semiring, Scalar>>
        : std::true_type {};
 
    template <typename S, typename T = void>
    struct IsTruncMatHelper : std::false_type {};
 
  }  // namespace detail

  template <typename T>
  constexpr bool IsStaticMatrix = detail::IsStaticMatrixHelper<T>::value;

  template <typename T>
  constexpr bool IsDynamicMatrix = IsMatrix<T> && !IsStaticMatrix<T>;

  template <typename T>
  static constexpr bool IsMatWithSemiring
      = detail::IsMatWithSemiringHelper<T>::value;
 
  namespace detail {
 
    template <typename T>
    static constexpr bool IsTruncMat = IsTruncMatHelper<T>::value;
 
    template <typename Mat>
    void throw_if_semiring_nullptr(Mat const& m) {
      if (IsMatWithSemiring<Mat> && m.semiring() == nullptr) {
        LIBSEMIGROUPS_EXCEPTION(
            "the matrix's pointer to a semiring is nullptr!")
      }
    }
 
    template <typename Mat, typename Container>
    auto throw_if_bad_dim(Container const& m)
        -> std::enable_if_t<IsStaticMatrix<Mat>> {
      // Only call this if you've already called throw_if_any_row_wrong_size
      uint64_t const R = m.size();
      uint64_t const C = std::empty(m) ? 0 : m.begin()->size();
      if (R != Mat::nr_rows || C != Mat::nr_cols) {
        LIBSEMIGROUPS_EXCEPTION(
            "invalid argument, cannot initialize an {}x{} matrix with compile "
            "time dimension, with an {}x{} container",
            Mat::nr_rows,
            Mat::nr_cols,
            R,
            C);
      }
    }
 
    template <typename Mat, typename Container>
    auto throw_if_bad_dim(Container const&)
        -> std::enable_if_t<IsDynamicMatrix<Mat>> {}
  }  // namespace detail

  namespace matrix {

    template <typename Mat>
    constexpr auto threshold(Mat const&) noexcept
        -> std::enable_if_t<!detail::IsTruncMat<Mat>,
                            typename Mat::scalar_type> {
      return UNDEFINED;
    }

    template <typename Mat>
    constexpr auto threshold(Mat const&) noexcept
        -> std::enable_if_t<detail::IsTruncMat<Mat> && !IsMatWithSemiring<Mat>,
                            typename Mat::scalar_type> {
      return detail::IsTruncMatHelper<Mat>::threshold;
    }

    template <typename Mat>
    auto threshold(Mat const& x) noexcept
        -> std::enable_if_t<detail::IsTruncMat<Mat> && IsMatWithSemiring<Mat>,
                            typename Mat::scalar_type> {
      return x.semiring()->threshold();
    }
  }  // namespace matrix

  // Boolean matrices - compile time semiring arithmetic


  struct BooleanPlus {
    constexpr bool operator()(bool x, bool y) const noexcept {
      return x || y;
    }
  };

  struct BooleanProd {
    constexpr bool operator()(bool x, bool y) const noexcept {
      return x & y;
    }
  };

  struct BooleanOne {
    constexpr bool operator()() const noexcept {
      return true;
    }
  };

  struct BooleanZero {
    constexpr bool operator()() const noexcept {
      return false;
    }
  };

  // The use of `int` rather than `bool` as the scalar type for dynamic
  // boolean matrices is intentional, because the bit iterators implemented in
  // std::vector<bool> entail a significant performance penalty.
  using DynamicBMat
      = DynamicMatrix<BooleanPlus, BooleanProd, BooleanZero, BooleanOne, int>;

  template <size_t R, size_t C>
  using StaticBMat = StaticMatrix<BooleanPlus,
                                  BooleanProd,
                                  BooleanZero,
                                  BooleanOne,
                                  R,
                                  C,
                                  int>;

  // FLS + JDM considered adding BMat8 and decided it wasn't a good idea.
  template <size_t R = 0, size_t C = R>
  using BMat
      = std::conditional_t<R == 0 || C == 0, DynamicBMat, StaticBMat<R, C>>;
 
  namespace detail {
    template <typename T>
    struct IsBMatHelper : std::false_type {};
 
    template <size_t R, size_t C>
    struct IsBMatHelper<StaticBMat<R, C>> : std::true_type {};
 
    template <>
    struct IsBMatHelper<DynamicBMat> : std::true_type {};
 
    template <typename T>
    struct BitSetCapacity {
      static constexpr size_t value = BitSet<1>::max_size();
    };
 
    template <size_t R, size_t C>
    struct BitSetCapacity<StaticBMat<R, C>> {
      static_assert(R == C, "the number of rows and columns must be equal");
      static constexpr size_t value = R;
    };
  }  // namespace detail

  template <typename T>
  static constexpr bool IsBMat = detail::IsBMatHelper<T>::value;
 
  namespace detail {
    // This function is required for exceptions and to_human_readable_repr, so
    // that if we encounter an entry of a matrix (Scalar type), then it can be
    // printed correctly. If we just did fmt::format("{}", val) and val ==
    // POSITIVE_INFINITY, but the type of val is, say, size_t, then this
    // wouldn't use the formatter for PositiveInfinity.
    //
    // Also in fmt v11.1.4 the custom formatter for POSITIVE_INFINITY and
    // NEGATIVE_INFINITY stopped working (and I wasn't able to figure out why)
    template <typename Scalar>
    std::string entry_repr(Scalar a) {
      if constexpr (std::is_same_v<Scalar, NegativeInfinity>
                    || std::is_signed_v<Scalar>) {
        if (a == NEGATIVE_INFINITY) {
          return u8"-\u221E";
        }
      }
      if (a == POSITIVE_INFINITY) {
        return u8"+\u221E";
      }
      return fmt::format("{}", a);
    }
  }  // namespace detail
 
  namespace matrix {

    //! but a matrix shouldn't contain values except \c 0 and \c 1.
    template <typename Mat>
    std::enable_if_t<IsBMat<Mat>> throw_if_bad_entry(Mat const& m) {
      using scalar_type = typename Mat::scalar_type;
      auto it           = std::find_if_not(
          m.cbegin(), m.cend(), [](scalar_type x) { return x == 0 || x == 1; });
      if (it != m.cend()) {
        auto [r, c] = m.coords(it);
        LIBSEMIGROUPS_EXCEPTION(
            "invalid entry, expected 0 or 1 but found {} in entry ({}, {})",
            detail::entry_repr(*it),
            r,
            c);
      }
    }

    template <typename Mat>
    std::enable_if_t<IsBMat<Mat>>
    throw_if_bad_entry(Mat const&, typename Mat::scalar_type val) {
      if (val != 0 && val != 1) {
        LIBSEMIGROUPS_EXCEPTION("invalid entry, expected 0 or 1 but found {}",
                                detail::entry_repr(val));
      }
    }
  }  // namespace matrix

  // Integer matrices - compile time semiring arithmetic


  //! \tparam Scalar the type of the entries in the matrix.
  template <typename Scalar>
  struct IntegerPlus {
    //! \exceptions
    //! \noexcept
    constexpr Scalar operator()(Scalar x, Scalar y) const noexcept {
      return x + y;
    }
  };

  //! \tparam Scalar the type of the entries in the matrix.
  template <typename Scalar>
  struct IntegerProd {
    //! \exceptions
    //! \noexcept
    constexpr Scalar operator()(Scalar x, Scalar y) const noexcept {
      return x * y;
    }
  };

  //! the additive identity of the integer semiring.
  template <typename Scalar>
  struct IntegerZero {
    //! \exceptions
    //! \noexcept
    constexpr Scalar operator()() const noexcept {
      return 0;
    }
  };

  //! the multiplicative identity of the integer semiring.
  template <typename Scalar>
  struct IntegerOne {
    //! \exceptions
    //! \noexcept
    constexpr Scalar operator()() const noexcept {
      return 1;
    }
  };

  template <typename Scalar>
  using DynamicIntMat = DynamicMatrix<IntegerPlus<Scalar>,
                                      IntegerProd<Scalar>,
                                      IntegerZero<Scalar>,
                                      IntegerOne<Scalar>,
                                      Scalar>;

  template <size_t R, size_t C, typename Scalar>
  using StaticIntMat = StaticMatrix<IntegerPlus<Scalar>,
                                    IntegerProd<Scalar>,
                                    IntegerZero<Scalar>,
                                    IntegerOne<Scalar>,
                                    R,
                                    C,
                                    Scalar>;

  template <size_t R = 0, size_t C = R, typename Scalar = int>
  using IntMat = std::conditional_t<R == 0 || C == 0,
                                    DynamicIntMat<Scalar>,
                                    StaticIntMat<R, C, Scalar>>;
  namespace detail {
    template <typename T>
    struct IsIntMatHelper : std::false_type {};
 
    template <size_t R, size_t C, typename Scalar>
    struct IsIntMatHelper<StaticIntMat<R, C, Scalar>> : std::true_type {};
 
    template <typename Scalar>
    struct IsIntMatHelper<DynamicIntMat<Scalar>> : std::true_type {};
  }  // namespace detail

  template <typename T>
  static constexpr bool IsIntMat = detail::IsIntMatHelper<T>::value;
 
  namespace matrix {
    //! \param x the matrix to check.
    template <typename Mat>
    std::enable_if_t<IsIntMat<Mat>> throw_if_bad_entry(Mat const& x) {
      using scalar_type = typename Mat::scalar_type;
      auto it = std::find_if(x.cbegin(), x.cend(), [](scalar_type val) {
        return val == POSITIVE_INFINITY || val == NEGATIVE_INFINITY;
      });
      if (it != x.cend()) {
        auto [r, c] = x.coords(it);
        LIBSEMIGROUPS_EXCEPTION(
            "invalid entry, expected entries to be integers, "
            "but found {} in entry ({}, {})",
            detail::entry_repr(*it),
            r,
            c);
      }
    }

    template <typename Mat>
    std::enable_if_t<IsIntMat<Mat>>
    throw_if_bad_entry(Mat const&, typename Mat::scalar_type val) {
      if (val == POSITIVE_INFINITY || val == NEGATIVE_INFINITY) {
        LIBSEMIGROUPS_EXCEPTION(
            "invalid entry, expected entries to be integers, "
            "but found {}",
            detail::entry_repr(val));
      }
    }
  }  // namespace matrix

  // Max-plus matrices

  // Static arithmetic
  template <typename Scalar>
  struct MaxPlusPlus {
    static_assert(std::is_signed<Scalar>::value,
                  "MaxPlus requires a signed integer type as parameter!");
    //! \exceptions
    //! \noexcept
    Scalar operator()(Scalar x, Scalar y) const noexcept {
      if (x == NEGATIVE_INFINITY) {
        return y;
      } else if (y == NEGATIVE_INFINITY) {
        return x;
      }
      return std::max(x, y);
    }
  };

  //! integer type).
  template <typename Scalar>
  struct MaxPlusProd {
    static_assert(std::is_signed<Scalar>::value,
                  "MaxPlus requires a signed integer type as parameter!");
    //! \exceptions
    //! \noexcept
    Scalar operator()(Scalar x, Scalar y) const noexcept {
      if (x == NEGATIVE_INFINITY || y == NEGATIVE_INFINITY) {
        return NEGATIVE_INFINITY;
      }
      return x + y;
    }
  };

  //! integer type).
  template <typename Scalar>
  struct MaxPlusZero {
    static_assert(std::is_signed<Scalar>::value,
                  "MaxPlus requires a signed integer type as parameter!");
    //! \exceptions
    //! \noexcept
    constexpr Scalar operator()() const noexcept {
      return NEGATIVE_INFINITY;
    }
  };

  template <typename Scalar>
  using DynamicMaxPlusMat = DynamicMatrix<MaxPlusPlus<Scalar>,
                                          MaxPlusProd<Scalar>,
                                          MaxPlusZero<Scalar>,
                                          IntegerZero<Scalar>,
                                          Scalar>;

  template <size_t R, size_t C, typename Scalar>
  using StaticMaxPlusMat = StaticMatrix<MaxPlusPlus<Scalar>,
                                        MaxPlusProd<Scalar>,
                                        MaxPlusZero<Scalar>,
                                        IntegerZero<Scalar>,
                                        R,
                                        C,
                                        Scalar>;

  template <size_t R = 0, size_t C = R, typename Scalar = int>
  using MaxPlusMat = std::conditional_t<R == 0 || C == 0,
                                        DynamicMaxPlusMat<Scalar>,
                                        StaticMaxPlusMat<R, C, Scalar>>;
 
  namespace detail {
    template <typename T>
    struct IsMaxPlusMatHelper : std::false_type {};
 
    template <size_t R, size_t C, typename Scalar>
    struct IsMaxPlusMatHelper<StaticMaxPlusMat<R, C, Scalar>> : std::true_type {
    };
 
    template <typename Scalar>
    struct IsMaxPlusMatHelper<DynamicMaxPlusMat<Scalar>> : std::true_type {};
  }  // namespace detail

  template <typename T>
  static constexpr bool IsMaxPlusMat = detail::IsMaxPlusMatHelper<T>::value;
 
  namespace matrix {
    //! \ref POSITIVE_INFINITY.
    template <typename Mat>
    auto throw_if_bad_entry(Mat const& x)
        -> std::enable_if_t<IsMaxPlusMat<Mat>> {
      using scalar_type = typename Mat::scalar_type;
      auto it = std::find_if(x.cbegin(), x.cend(), [](scalar_type val) {
        return val == POSITIVE_INFINITY;
      });
      if (it != x.cend()) {
        auto [r, c] = x.coords(it);
        LIBSEMIGROUPS_EXCEPTION(
            "invalid entry, expected entries to be integers or {} (= {}), "
            "but found {} (= {}) in entry ({}, {})",
            entry_repr(NEGATIVE_INFINITY),
            static_cast<scalar_type>(NEGATIVE_INFINITY),
            entry_repr(POSITIVE_INFINITY),
            static_cast<scalar_type>(POSITIVE_INFINITY),
            r,
            c);
      }
    }

    template <typename Mat>
    std::enable_if_t<IsMaxPlusMat<Mat>>
    throw_if_bad_entry(Mat const&, typename Mat::scalar_type val) {
      if (val == POSITIVE_INFINITY) {
        using scalar_type = typename Mat::scalar_type;
        LIBSEMIGROUPS_EXCEPTION("invalid entry, expected entries to be "
                                "integers or {} (= {}) but found {} (= {})",
                                entry_repr(NEGATIVE_INFINITY),
                                static_cast<scalar_type>(NEGATIVE_INFINITY),
                                entry_repr(POSITIVE_INFINITY),
                                static_cast<scalar_type>(POSITIVE_INFINITY));
      }
    }
  }  // namespace matrix

  // Min-plus matrices


  // Static arithmetic
  template <typename Scalar>
  struct MinPlusPlus {
    static_assert(std::is_signed<Scalar>::value,
                  "MinPlus requires a signed integer type as parameter!");
    //! \exceptions
    //! \noexcept
    Scalar operator()(Scalar x, Scalar y) const noexcept {
      if (x == POSITIVE_INFINITY) {
        return y;
      } else if (y == POSITIVE_INFINITY) {
        return x;
      }
      return std::min(x, y);
    }
  };

  //! integer type).
  template <typename Scalar>
  struct MinPlusProd {
    static_assert(std::is_signed<Scalar>::value,
                  "MinPlus requires a signed integer type as parameter!");
    //! \exceptions
    //! \noexcept
    Scalar operator()(Scalar x, Scalar y) const noexcept {
      if (x == POSITIVE_INFINITY || y == POSITIVE_INFINITY) {
        return POSITIVE_INFINITY;
      }
      return x + y;
    }
  };

  //! integer type).
  template <typename Scalar>
  struct MinPlusZero {
    static_assert(std::is_signed<Scalar>::value,
                  "MinPlus requires a signed integer type as parameter!");
    //! \exceptions
    //! \noexcept
    constexpr Scalar operator()() const noexcept {
      return POSITIVE_INFINITY;
    }
  };

  template <typename Scalar>
  using DynamicMinPlusMat = DynamicMatrix<MinPlusPlus<Scalar>,
                                          MinPlusProd<Scalar>,
                                          MinPlusZero<Scalar>,
                                          IntegerZero<Scalar>,
                                          Scalar>;

  template <size_t R, size_t C, typename Scalar>
  using StaticMinPlusMat = StaticMatrix<MinPlusPlus<Scalar>,
                                        MinPlusProd<Scalar>,
                                        MinPlusZero<Scalar>,
                                        IntegerZero<Scalar>,
                                        R,
                                        C,
                                        Scalar>;
  template <size_t R = 0, size_t C = R, typename Scalar = int>
  using MinPlusMat = std::conditional_t<R == 0 || C == 0,
                                        DynamicMinPlusMat<Scalar>,
                                        StaticMinPlusMat<R, C, Scalar>>;
 
  namespace detail {
    template <typename T>
    struct IsMinPlusMatHelper : std::false_type {};
 
    template <size_t R, size_t C, typename Scalar>
    struct IsMinPlusMatHelper<StaticMinPlusMat<R, C, Scalar>> : std::true_type {
    };
 
    template <typename Scalar>
    struct IsMinPlusMatHelper<DynamicMinPlusMat<Scalar>> : std::true_type {};
  }  // namespace detail

  template <typename T>
  static constexpr bool IsMinPlusMat = detail::IsMinPlusMatHelper<T>::value;
 
  namespace matrix {
    //! \ref NEGATIVE_INFINITY.
    template <typename Mat>
    std::enable_if_t<IsMinPlusMat<Mat>> throw_if_bad_entry(Mat const& x) {
      using scalar_type = typename Mat::scalar_type;
      auto it = std::find_if(x.cbegin(), x.cend(), [](scalar_type val) {
        return val == NEGATIVE_INFINITY;
      });
      if (it != x.cend()) {
        auto [r, c] = x.coords(it);
        LIBSEMIGROUPS_EXCEPTION(
            "invalid entry, expected entries to be integers or {} (= {}), "
            "but found {} (= {}) in entry ({}, {})",
            entry_repr(POSITIVE_INFINITY),
            static_cast<scalar_type>(POSITIVE_INFINITY),
            entry_repr(NEGATIVE_INFINITY),
            static_cast<scalar_type>(NEGATIVE_INFINITY),
            r,
            c);
      }
    }

    template <typename Mat>
    std::enable_if_t<IsMinPlusMat<Mat>>
    throw_if_bad_entry(Mat const&, typename Mat::scalar_type val) {
      if (val == NEGATIVE_INFINITY) {
        using scalar_type = typename Mat::scalar_type;
        LIBSEMIGROUPS_EXCEPTION("invalid entry, expected entries to be "
                                "integers or {} (= {}) but found {} (= {})",
                                entry_repr(POSITIVE_INFINITY),
                                static_cast<scalar_type>(POSITIVE_INFINITY),
                                entry_repr(NEGATIVE_INFINITY),
                                static_cast<scalar_type>(NEGATIVE_INFINITY));
      }
    }
  }  // namespace matrix

  // Max-plus matrices with threshold


  //! integer type).
  template <size_t T, typename Scalar>
  struct MaxPlusTruncProd {
    static_assert(std::is_signed<Scalar>::value,
                  "MaxPlus requires a signed integer type as parameter!");
    //! \exceptions
    //! \noexcept
    Scalar operator()(Scalar x, Scalar y) const noexcept {
      LIBSEMIGROUPS_ASSERT((x >= 0 && x <= static_cast<Scalar>(T))
                           || x == NEGATIVE_INFINITY);
      LIBSEMIGROUPS_ASSERT((y >= 0 && y <= static_cast<Scalar>(T))
                           || y == NEGATIVE_INFINITY);
      if (x == NEGATIVE_INFINITY || y == NEGATIVE_INFINITY) {
        return NEGATIVE_INFINITY;
      }
      return std::min(x + y, static_cast<Scalar>(T));
    }
  };

  //! signed integer type (defaults to \c int).
  template <typename Scalar = int>
  class MaxPlusTruncSemiring {
    static_assert(std::is_signed<Scalar>::value,
                  "MaxPlus requires a signed integer type as parameter!");
 
   public:
    MaxPlusTruncSemiring() = delete;

    MaxPlusTruncSemiring(MaxPlusTruncSemiring const&) noexcept = default;

    MaxPlusTruncSemiring(MaxPlusTruncSemiring&&) noexcept = default;

    MaxPlusTruncSemiring& operator=(MaxPlusTruncSemiring const&) noexcept
        = default;

    MaxPlusTruncSemiring& operator=(MaxPlusTruncSemiring&&) noexcept = default;
 
    ~MaxPlusTruncSemiring() = default;

    //! \complexity
    //! Constant.
    explicit MaxPlusTruncSemiring(Scalar threshold) : _threshold(threshold) {
      if (threshold < 0) {
        LIBSEMIGROUPS_EXCEPTION("expected non-negative value, found {}",
                                threshold);
      }
    }

    //! \exceptions
    //! \noexcept
    static constexpr Scalar scalar_one() noexcept {
      return 0;
    }

    //! \exceptions
    //! \noexcept
    static constexpr Scalar scalar_zero() noexcept {
      return NEGATIVE_INFINITY;
    }

    //! \complexity
    //! Constant.
    Scalar product_no_checks(Scalar x, Scalar y) const noexcept {
      LIBSEMIGROUPS_ASSERT((x >= 0 && x <= _threshold)
                           || x == NEGATIVE_INFINITY);
      LIBSEMIGROUPS_ASSERT((y >= 0 && y <= _threshold)
                           || y == NEGATIVE_INFINITY);
      if (x == NEGATIVE_INFINITY || y == NEGATIVE_INFINITY) {
        return NEGATIVE_INFINITY;
      }
      return std::min(x + y, _threshold);
    }

    //! \complexity
    //! Constant.
    Scalar plus_no_checks(Scalar x, Scalar y) const noexcept {
      LIBSEMIGROUPS_ASSERT((x >= 0 && x <= _threshold)
                           || x == NEGATIVE_INFINITY);
      LIBSEMIGROUPS_ASSERT((y >= 0 && y <= _threshold)
                           || y == NEGATIVE_INFINITY);
      if (x == NEGATIVE_INFINITY) {
        return y;
      } else if (y == NEGATIVE_INFINITY) {
        return x;
      }
      return std::max(x, y);
    }

    //! \complexity
    //! Constant.
    Scalar threshold() const noexcept {
      return _threshold;
    }
 
   public:
    Scalar const _threshold;
  };

  template <size_t T, typename Scalar>
  using DynamicMaxPlusTruncMat = DynamicMatrix<MaxPlusPlus<Scalar>,
                                               MaxPlusTruncProd<T, Scalar>,
                                               MaxPlusZero<Scalar>,
                                               IntegerZero<Scalar>,
                                               Scalar>;

  template <size_t T, size_t R, size_t C, typename Scalar>
  using StaticMaxPlusTruncMat = StaticMatrix<MaxPlusPlus<Scalar>,
                                             MaxPlusTruncProd<T, Scalar>,
                                             MaxPlusZero<Scalar>,
                                             IntegerZero<Scalar>,
                                             R,
                                             C,
                                             Scalar>;
  template <size_t T = 0, size_t R = 0, size_t C = R, typename Scalar = int>
  using MaxPlusTruncMat = std::conditional_t<
      R == 0 || C == 0,
      std::conditional_t<T == 0,
                         DynamicMatrix<MaxPlusTruncSemiring<Scalar>, Scalar>,
                         DynamicMaxPlusTruncMat<T, Scalar>>,
      StaticMaxPlusTruncMat<T, R, C, Scalar>>;
 
  namespace detail {
    template <typename T>
    struct IsMaxPlusTruncMatHelper : std::false_type {};
 
    template <size_t T, size_t R, size_t C, typename Scalar>
    struct IsMaxPlusTruncMatHelper<StaticMaxPlusTruncMat<T, R, C, Scalar>>
        : std::true_type {
      static constexpr Scalar threshold = T;
    };
 
    template <size_t T, typename Scalar>
    struct IsMaxPlusTruncMatHelper<DynamicMaxPlusTruncMat<T, Scalar>>
        : std::true_type {
      static constexpr Scalar threshold = T;
    };
 
    template <typename Scalar>
    struct IsMaxPlusTruncMatHelper<
        DynamicMatrix<MaxPlusTruncSemiring<Scalar>, Scalar>> : std::true_type {
      static constexpr Scalar threshold = UNDEFINED;
    };
  }  // namespace detail

  template <typename T>
  static constexpr bool IsMaxPlusTruncMat
      = detail::IsMaxPlusTruncMatHelper<T>::value;
 
  namespace detail {
    template <typename T>
    struct IsTruncMatHelper<T, std::enable_if_t<IsMaxPlusTruncMat<T>>>
        : std::true_type {
      static constexpr typename T::scalar_type threshold
          = IsMaxPlusTruncMatHelper<T>::threshold;
    };
  }  // namespace detail
 
  namespace matrix {
    //! (only applies to matrices with run time arithmetic).
    template <typename Mat>
    std::enable_if_t<IsMaxPlusTruncMat<Mat>> throw_if_bad_entry(Mat const& m) {
      // TODO(1) to tpp
      detail::throw_if_semiring_nullptr(m);
 
      using scalar_type   = typename Mat::scalar_type;
      scalar_type const t = matrix::threshold(m);
      auto it = std::find_if_not(m.cbegin(), m.cend(), [t](scalar_type x) {
        return x == NEGATIVE_INFINITY || (0 <= x && x <= t);
      });
      if (it != m.cend()) {
        auto [r, c] = m.coords(it);
        LIBSEMIGROUPS_EXCEPTION(
            "invalid entry, expected values in {{0, 1, ..., {}, {} (= {})}} "
            "but found {} in entry ({}, {})",
            t,
            entry_repr(NEGATIVE_INFINITY),
            static_cast<scalar_type>(NEGATIVE_INFINITY),
            detail::entry_repr(*it),
            r,
            c);
      }
    }

    template <typename Mat>
    std::enable_if_t<IsMaxPlusTruncMat<Mat>>
    throw_if_bad_entry(Mat const& m, typename Mat::scalar_type val) {
      detail::throw_if_semiring_nullptr(m);
      using scalar_type   = typename Mat::scalar_type;
      scalar_type const t = matrix::threshold(m);
      if (val == POSITIVE_INFINITY || 0 > val || val > t) {
        LIBSEMIGROUPS_EXCEPTION(
            "invalid entry, expected values in {{0, 1, ..., {}, -{} (= {})}} "
            "but found {}",
            t,
            entry_repr(NEGATIVE_INFINITY),
            static_cast<scalar_type>(NEGATIVE_INFINITY),
            detail::entry_repr(val));
      }
    }
  }  // namespace matrix

  // Min-plus matrices with threshold


  //! \tparam Scalar the type of the values in the semiring.
  template <size_t T, typename Scalar>
  struct MinPlusTruncProd {
    //! \exceptions
    //! \noexcept
    Scalar operator()(Scalar x, Scalar y) const noexcept {
      LIBSEMIGROUPS_ASSERT((x >= 0 && x <= static_cast<Scalar>(T))
                           || x == POSITIVE_INFINITY);
      LIBSEMIGROUPS_ASSERT((y >= 0 && y <= static_cast<Scalar>(T))
                           || y == POSITIVE_INFINITY);
      if (x == POSITIVE_INFINITY || y == POSITIVE_INFINITY) {
        return POSITIVE_INFINITY;
      }
      return std::min(x + y, static_cast<Scalar>(T));
    }
  };

  //! integral type.
  template <typename Scalar = int>
  class MinPlusTruncSemiring {
    static_assert(std::is_integral<Scalar>::value,
                  "MinPlus requires an integral type as parameter!");
 
   public:
    MinPlusTruncSemiring() = delete;

    MinPlusTruncSemiring(MinPlusTruncSemiring const&) noexcept = default;

    MinPlusTruncSemiring(MinPlusTruncSemiring&&) noexcept = default;

    MinPlusTruncSemiring& operator=(MinPlusTruncSemiring const&) noexcept
        = default;

    MinPlusTruncSemiring& operator=(MinPlusTruncSemiring&&) noexcept = default;

    //! \complexity
    //! Constant.
    explicit MinPlusTruncSemiring(Scalar threshold) : _threshold(threshold) {
      if (std::is_signed<Scalar>::value && threshold < 0) {
        LIBSEMIGROUPS_EXCEPTION("expected non-negative value, found {}",
                                threshold);
      }
    }

    //! \exceptions
    //! \noexcept
    static constexpr Scalar scalar_one() noexcept {
      return 0;
    }

    //! \noexcept
    // TODO(1) These mem fns (one and zero) aren't needed?
    static constexpr Scalar scalar_zero() noexcept {
      return POSITIVE_INFINITY;
    }

    //! \complexity
    //! Constant.
    Scalar product_no_checks(Scalar x, Scalar y) const noexcept {
      LIBSEMIGROUPS_ASSERT((x >= 0 && x <= _threshold)
                           || x == POSITIVE_INFINITY);
      LIBSEMIGROUPS_ASSERT((y >= 0 && y <= _threshold)
                           || y == POSITIVE_INFINITY);
      if (x == POSITIVE_INFINITY || y == POSITIVE_INFINITY) {
        return POSITIVE_INFINITY;
      }
      return std::min(x + y, _threshold);
    }

    //! \complexity
    //! Constant.
    Scalar plus_no_checks(Scalar x, Scalar y) const noexcept {
      LIBSEMIGROUPS_ASSERT((x >= 0 && x <= _threshold)
                           || x == POSITIVE_INFINITY);
      LIBSEMIGROUPS_ASSERT((y >= 0 && y <= _threshold)
                           || y == POSITIVE_INFINITY);
      if (x == POSITIVE_INFINITY) {
        return y;
      } else if (y == POSITIVE_INFINITY) {
        return x;
      }
      return std::min(x, y);
    }

    //! \complexity
    //! Constant.
    Scalar threshold() const noexcept {
      return _threshold;
    }
 
   public:
    Scalar const _threshold;
  };

  template <size_t T, typename Scalar>
  using DynamicMinPlusTruncMat = DynamicMatrix<MinPlusPlus<Scalar>,
                                               MinPlusTruncProd<T, Scalar>,
                                               MinPlusZero<Scalar>,
                                               IntegerZero<Scalar>,
                                               Scalar>;

  template <size_t T, size_t R, size_t C, typename Scalar>
  using StaticMinPlusTruncMat = StaticMatrix<MinPlusPlus<Scalar>,
                                             MinPlusTruncProd<T, Scalar>,
                                             MinPlusZero<Scalar>,
                                             IntegerZero<Scalar>,
                                             R,
                                             C,
                                             Scalar>;

  template <size_t T = 0, size_t R = 0, size_t C = R, typename Scalar = int>
  using MinPlusTruncMat = std::conditional_t<
      R == 0 || C == 0,
      std::conditional_t<T == 0,
                         DynamicMatrix<MinPlusTruncSemiring<Scalar>, Scalar>,
                         DynamicMinPlusTruncMat<T, Scalar>>,
      StaticMinPlusTruncMat<T, R, C, Scalar>>;
 
  namespace detail {
    template <typename T>
    struct IsMinPlusTruncMatHelper : std::false_type {};
 
    template <size_t T, size_t R, size_t C, typename Scalar>
    struct IsMinPlusTruncMatHelper<StaticMinPlusTruncMat<T, R, C, Scalar>>
        : std::true_type {
      static constexpr Scalar threshold = T;
    };
 
    template <size_t T, typename Scalar>
    struct IsMinPlusTruncMatHelper<DynamicMinPlusTruncMat<T, Scalar>>
        : std::true_type {
      static constexpr Scalar threshold = T;
    };
 
    template <typename Scalar>
    struct IsMinPlusTruncMatHelper<
        DynamicMatrix<MinPlusTruncSemiring<Scalar>, Scalar>> : std::true_type {
      static constexpr Scalar threshold = UNDEFINED;
    };
  }  // namespace detail

  template <typename T>
  static constexpr bool IsMinPlusTruncMat
      = detail::IsMinPlusTruncMatHelper<T>::value;
 
  namespace detail {
    template <typename T>
    struct IsTruncMatHelper<T, std::enable_if_t<IsMinPlusTruncMat<T>>>
        : std::true_type {
      static constexpr typename T::scalar_type threshold
          = IsMinPlusTruncMatHelper<T>::threshold;
    };
  }  // namespace detail
 
  namespace matrix {
    // TODO(1) to tpp
    template <typename Mat>
    std::enable_if_t<IsMinPlusTruncMat<Mat>> throw_if_bad_entry(Mat const& m) {
      // Check that the semiring pointer isn't the nullptr if it shouldn't be
      detail::throw_if_semiring_nullptr(m);
 
      using scalar_type   = typename Mat::scalar_type;
      scalar_type const t = matrix::threshold(m);
      auto it = std::find_if_not(m.cbegin(), m.cend(), [t](scalar_type x) {
        return x == POSITIVE_INFINITY || (0 <= x && x <= t);
      });
      if (it != m.cend()) {
        uint64_t r, c;
        std::tie(r, c) = m.coords(it);
 
        LIBSEMIGROUPS_EXCEPTION(
            "invalid entry, expected values in {{0, 1, ..., {}, {} (= {})}} "
            "but found {} in entry ({}, {})",
            t,
            detail::entry_repr(POSITIVE_INFINITY),
            static_cast<scalar_type>(POSITIVE_INFINITY),
            detail::entry_repr(*it),
            r,
            c);
      }
    }

    template <typename Mat>
    std::enable_if_t<IsMinPlusTruncMat<Mat>>
    throw_if_bad_entry(Mat const& m, typename Mat::scalar_type val) {
      detail::throw_if_semiring_nullptr(m);
 
      using scalar_type   = typename Mat::scalar_type;
      scalar_type const t = matrix::threshold(m);
      if (!(val == POSITIVE_INFINITY || (0 <= val && val <= t))) {
        LIBSEMIGROUPS_EXCEPTION(
            "invalid entry, expected values in {{0, 1, ..., {}, {} (= {})}} "
            "but found {}",
            t,
            detail::entry_repr(POSITIVE_INFINITY),
            static_cast<scalar_type>(POSITIVE_INFINITY),
            detail::entry_repr(val));
      }
    }
  }  // namespace matrix

  // NTP matrices

 
  namespace detail {
    template <size_t T, size_t P, typename Scalar>
    constexpr Scalar thresholdperiod(Scalar x) noexcept {
      if (x > T) {
        return T + (x - T) % P;
      }
      return x;
    }
 
    template <typename Scalar>
    inline Scalar thresholdperiod(Scalar x,
                                  Scalar threshold,
                                  Scalar period) noexcept {
      if (x > threshold) {
        return threshold + (x - threshold) % period;
      }
      return x;
    }
  }  // namespace detail

  // Static arithmetic
  template <size_t T, size_t P, typename Scalar>
  struct NTPPlus {
    //! \exceptions
    //! \noexcept
    constexpr Scalar operator()(Scalar x, Scalar y) const noexcept {
      return detail::thresholdperiod<T, P>(x + y);
    }
  };

  //! \tparam Scalar the type of the values in the semiring.
  template <size_t T, size_t P, typename Scalar>
  struct NTPProd {
    //! \exceptions
    //! \noexcept
    constexpr Scalar operator()(Scalar x, Scalar y) const noexcept {
      return detail::thresholdperiod<T, P>(x * y);
    }
  };

  // Dynamic arithmetic
  template <typename Scalar = size_t>
  class NTPSemiring {
   public:
    // Deleted to avoid uninitialised values of period and threshold.
    NTPSemiring() = delete;

    NTPSemiring(NTPSemiring const&) = default;

    NTPSemiring(NTPSemiring&&) = default;

    NTPSemiring& operator=(NTPSemiring const&) = default;

    NTPSemiring& operator=(NTPSemiring&&) = default;
 
    ~NTPSemiring() = default;

    //! \complexity
    //! Constant.
    NTPSemiring(Scalar t, Scalar p) : _period(p), _threshold(t) {
      if constexpr (std::is_signed<Scalar>::value) {
        if (t < 0) {
          LIBSEMIGROUPS_EXCEPTION(
              "expected non-negative value for 1st argument, found {}", t);
        }
      }
      if (p <= 0) {
        LIBSEMIGROUPS_EXCEPTION(
            "expected positive value for 2nd argument, found {}", p);
      }
    }

    //! \exceptions
    //! \noexcept
    static constexpr Scalar scalar_one() noexcept {
      return 1;
    }

    //! \complexity
    //! Constant.
    static constexpr Scalar scalar_zero() noexcept {
      return 0;
    }

    //! \complexity
    //! Constant.
    Scalar product_no_checks(Scalar x, Scalar y) const noexcept {
      LIBSEMIGROUPS_ASSERT(x >= 0 && x <= _period + _threshold - 1);
      LIBSEMIGROUPS_ASSERT(y >= 0 && y <= _period + _threshold - 1);
      return detail::thresholdperiod(x * y, _threshold, _period);
    }

    //! \complexity
    //! Constant.
    Scalar plus_no_checks(Scalar x, Scalar y) const noexcept {
      LIBSEMIGROUPS_ASSERT(x >= 0 && x <= _period + _threshold - 1);
      LIBSEMIGROUPS_ASSERT(y >= 0 && y <= _period + _threshold - 1);
      return detail::thresholdperiod(x + y, _threshold, _period);
    }

    //! \complexity
    //! Constant.
    Scalar threshold() const noexcept {
      return _threshold;
    }

    //! \complexity
    //! Constant.
    Scalar period() const noexcept {
      return _period;
    }
 
   private:
    Scalar _period;
    Scalar _threshold;
  };

  template <typename Scalar>
  using DynamicNTPMatWithSemiring = DynamicMatrix<NTPSemiring<Scalar>, Scalar>;

  template <size_t T, size_t P, typename Scalar>
  using DynamicNTPMatWithoutSemiring = DynamicMatrix<NTPPlus<T, P, Scalar>,
                                                     NTPProd<T, P, Scalar>,
                                                     IntegerZero<Scalar>,
                                                     IntegerOne<Scalar>,
                                                     Scalar>;

  template <size_t T, size_t P, size_t R, size_t C, typename Scalar>
  using StaticNTPMat = StaticMatrix<NTPPlus<T, P, Scalar>,
                                    NTPProd<T, P, Scalar>,
                                    IntegerZero<Scalar>,
                                    IntegerOne<Scalar>,
                                    R,
                                    C,
                                    Scalar>;

  template <size_t T        = 0,
            size_t P        = 0,
            size_t R        = 0,
            size_t C        = R,
            typename Scalar = size_t>
  using NTPMat = std::conditional_t<
      R == 0 || C == 0,
      std::conditional_t<T == 0 && P == 0,
                         DynamicNTPMatWithSemiring<Scalar>,
                         DynamicNTPMatWithoutSemiring<T, P, Scalar>>,
      StaticNTPMat<T, P, R, C, Scalar>>;
 
  namespace detail {
    template <typename T>
    struct IsNTPMatHelper : std::false_type {};
 
    template <typename Scalar>
    struct IsNTPMatHelper<DynamicNTPMatWithSemiring<Scalar>> : std::true_type {
      static constexpr Scalar threshold = UNDEFINED;
      static constexpr Scalar period    = UNDEFINED;
    };
 
    template <size_t T, size_t P, typename Scalar>
    struct IsNTPMatHelper<DynamicNTPMatWithoutSemiring<T, P, Scalar>>
        : std::true_type {
      static constexpr Scalar threshold = T;
      static constexpr Scalar period    = P;
    };
 
    template <size_t T, size_t P, size_t R, size_t C, typename Scalar>
    struct IsNTPMatHelper<StaticNTPMat<T, P, R, C, Scalar>> : std::true_type {
      static constexpr Scalar threshold = T;
      static constexpr Scalar period    = P;
    };
  }  // namespace detail

  template <typename U>
  static constexpr bool IsNTPMat = detail::IsNTPMatHelper<U>::value;
 
  namespace detail {
    template <typename T>
    struct IsTruncMatHelper<T, std::enable_if_t<IsNTPMat<T>>> : std::true_type {
      static constexpr typename T::scalar_type threshold
          = IsNTPMatHelper<T>::threshold;
      static constexpr typename T::scalar_type period
          = IsNTPMatHelper<T>::period;
    };
 
  }  // namespace detail
 
  namespace matrix {
    //! \noexcept
    template <size_t T, size_t P, size_t R, size_t C, typename Scalar>
    constexpr Scalar period(StaticNTPMat<T, P, R, C, Scalar> const&) noexcept {
      return P;
    }

    template <size_t T, size_t P, typename Scalar>
    constexpr Scalar
    period(DynamicNTPMatWithoutSemiring<T, P, Scalar> const&) noexcept {
      return P;
    }

    //! \noexcept
    template <typename Scalar>
    Scalar period(DynamicNTPMatWithSemiring<Scalar> const& x) noexcept {
      return x.semiring()->period();
    }
  }  // namespace matrix
 
  namespace matrix {
    //! defined (only applies to matrices with run time arithmetic).
    template <typename Mat>
    std::enable_if_t<IsNTPMat<Mat>> throw_if_bad_entry(Mat const& m) {
      detail::throw_if_semiring_nullptr(m);
 
      using scalar_type   = typename Mat::scalar_type;
      scalar_type const t = matrix::threshold(m);
      scalar_type const p = matrix::period(m);
      auto it = std::find_if_not(m.cbegin(), m.cend(), [t, p](scalar_type x) {
        return (0 <= x && x < p + t);
      });
      if (it != m.cend()) {
        uint64_t r, c;
        std::tie(r, c) = m.coords(it);
 
        LIBSEMIGROUPS_EXCEPTION(
            "invalid entry, expected values in {{0, 1, ..., {}}}, but "
            "found {} in entry ({}, {})",
            p + t,
            detail::entry_repr(*it),
            r,
            c);
      }
    }

    template <typename Mat>
    std::enable_if_t<IsNTPMat<Mat>>
    throw_if_bad_entry(Mat const& m, typename Mat::scalar_type val) {
      detail::throw_if_semiring_nullptr(m);
      using scalar_type   = typename Mat::scalar_type;
      scalar_type const t = matrix::threshold(m);
      scalar_type const p = matrix::period(m);
      if (val < 0 || val >= p + t) {
        LIBSEMIGROUPS_EXCEPTION(
            "invalid entry, expected values in {{0, 1, ..., {}}}, but "
            "found {}",
            p + t,
            detail::entry_repr(val));
      }
    }
  }  // namespace matrix

  // Projective max-plus matrices
 
  namespace detail {
    template <typename T>
    class ProjMaxPlusMat : MatrixPolymorphicBase {
     public:
      using scalar_type            = typename T::scalar_type;
      using scalar_reference       = typename T::scalar_reference;
      using scalar_const_reference = typename T::scalar_const_reference;
      using semiring_type          = void;
 
      using container_type = typename T::container_type;
      using iterator       = typename T::iterator;
      using const_iterator = typename T::const_iterator;
 
      using underlying_matrix_type = T;
 
      using RowView = typename T::RowView;
 
      // Note that Rows are never normalised, and that's why we use the
      // underlying matrix Row type and not 1 x n ProjMaxPlusMat's instead
      // (since these will be normalised according to their entries, and
      // this might not correspond to the normalised entries of the matrix).
      using Row = typename T::Row;
 
      scalar_type scalar_one() const noexcept {
        return _underlying_mat.scalar_one();
      }
 
      scalar_type scalar_zero() const noexcept {
        return _underlying_mat.scalar_zero();
      }

      // ProjMaxPlusMat - Constructors + destructor - public
 
      ProjMaxPlusMat() : _is_normalized(false), _underlying_mat() {}
      ProjMaxPlusMat(ProjMaxPlusMat const&)            = default;
      ProjMaxPlusMat(ProjMaxPlusMat&&)                 = default;
      ProjMaxPlusMat& operator=(ProjMaxPlusMat const&) = default;
      ProjMaxPlusMat& operator=(ProjMaxPlusMat&&)      = default;
 
      ProjMaxPlusMat(size_t r, size_t c)
          : _is_normalized(false), _underlying_mat(r, c) {}
 
      // TODO(1) other missing constructors
      ProjMaxPlusMat(
          typename underlying_matrix_type::semiring_type const* semiring,
          size_t                                                r,
          size_t                                                c)
          : _is_normalized(false), _underlying_mat(semiring, r, c) {}
 
      explicit ProjMaxPlusMat(std::vector<std::vector<scalar_type>> const& m)
          : _is_normalized(false), _underlying_mat(m) {
        normalize();
      }
 
      ProjMaxPlusMat(
          std::initializer_list<std::initializer_list<scalar_type>> const& m)
          : ProjMaxPlusMat(
              std::vector<std::vector<scalar_type>>(m.begin(), m.end())) {}
 
      ~ProjMaxPlusMat() = default;
 
      ProjMaxPlusMat one() const {
        auto result = ProjMaxPlusMat(_underlying_mat.one());
        return result;
      }
 
      static ProjMaxPlusMat one(size_t n) {
        return ProjMaxPlusMat(T::one(n));
      }

      // Comparison operators
 
      bool operator==(ProjMaxPlusMat const& that) const {
        normalize();
        that.normalize();
        return _underlying_mat == that._underlying_mat;
      }
 
      bool operator!=(ProjMaxPlusMat const& that) const {
        return !(_underlying_mat == that._underlying_mat);
      }
 
      bool operator<(ProjMaxPlusMat const& that) const {
        normalize();
        that.normalize();
        return _underlying_mat < that._underlying_mat;
      }
 
      bool operator>(ProjMaxPlusMat const& that) const {
        return that < *this;
      }
 
      template <typename Thing>
      bool operator>=(Thing const& that) const {
        static_assert(IsMatrix<Thing> || std::is_same_v<Thing, RowView>);
        return that < *this || that == *this;
      }
 
      // not noexcept because operator< isn't
      template <typename Thing>
      bool operator<=(Thing const& that) const {
        static_assert(IsMatrix<Thing> || std::is_same_v<Thing, RowView>);
        return *this < that || that == *this;
      }

      // Attributes
 
      scalar_reference operator()(size_t r, size_t c) {
        // to ensure the returned value is normalised
        normalize();
        // to ensure that the matrix is renormalised if the returned scalar is
        // assigned.
        _is_normalized = false;
        return _underlying_mat(r, c);
      }
 
      scalar_reference at(size_t r, size_t c) {
        matrix::throw_if_bad_coords(*this, r, c);
        return this->operator()(r, c);
      }
 
      scalar_const_reference operator()(size_t r, size_t c) const {
        normalize();
        return _underlying_mat(r, c);
      }
 
      scalar_const_reference at(size_t r, size_t c) const {
        matrix::throw_if_bad_coords(*this, r, c);
        return this->operator()(r, c);
      }
 
      size_t number_of_rows() const noexcept {
        return _underlying_mat.number_of_rows();
      }
 
      size_t number_of_cols() const noexcept {
        return _underlying_mat.number_of_cols();
      }
 
      size_t hash_value() const {
        normalize();
        return Hash<T>()(_underlying_mat);
      }

      // Arithmetic operators - in-place
 
      void product_inplace_no_checks(ProjMaxPlusMat const& A,
                                     ProjMaxPlusMat const& B) {
        _underlying_mat.product_inplace_no_checks(A._underlying_mat,
                                                  B._underlying_mat);
        normalize(true);  // force normalize
      }
 
      void operator+=(ProjMaxPlusMat const& that) {
        _underlying_mat += that._underlying_mat;
        normalize(true);  // force normalize
      }
 
      void operator*=(scalar_type a) {
        _underlying_mat *= a;
        normalize(true);  // force normalize
      }
 
      void operator+=(scalar_type a) {
        _underlying_mat += a;
        normalize(true);  // force normalize
      }
 
      ProjMaxPlusMat operator*(scalar_type a) const {
        ProjMaxPlusMat result(*this);
        result *= a;
        return result;
      }
 
      ProjMaxPlusMat operator+(scalar_type a) const {
        ProjMaxPlusMat result(*this);
        result += a;
        return result;
      }

      // Arithmetic operators - not in-place
 
      ProjMaxPlusMat operator+(ProjMaxPlusMat const& that) const {
        return ProjMaxPlusMat(_underlying_mat + that._underlying_mat);
      }
 
      ProjMaxPlusMat operator*(ProjMaxPlusMat const& that) const {
        return ProjMaxPlusMat(_underlying_mat * that._underlying_mat);
      }

      // Iterators
 
      // The following should probably be commented out because I can't
      // currently think how to ensure that the matrix is normalised if it's
      // changed this way.
 
      iterator begin() noexcept {
        // to ensure the returned value is normalised
        normalize();
        // to ensure that the matrix is renormalised if the returned scalar is
        // assigned.
        _is_normalized = false;
        return _underlying_mat.begin();
      }
 
      iterator end() noexcept {
        // to ensure the returned value is normalised
        normalize();
        // to ensure that the matrix is renormalised if the returned scalar is
        // assigned.
        _is_normalized = false;
        return _underlying_mat.end();
      }
 
      const_iterator begin() const noexcept {
        normalize();
        return _underlying_mat.begin();
      }
 
      const_iterator end() const noexcept {
        normalize();
        return _underlying_mat.end();
      }
 
      const_iterator cbegin() const noexcept {
        normalize();
        return _underlying_mat.cbegin();
      }
 
      const_iterator cend() const noexcept {
        normalize();
        return _underlying_mat.cend();
      }

      // Modifiers
 
      void swap(ProjMaxPlusMat& that) noexcept {
        std::swap(_underlying_mat, that._underlying_mat);
      }
 
      void transpose() noexcept {
        _underlying_mat.transpose();
      }
 
      void transpose_no_checks() noexcept {
        _underlying_mat.transpose_no_checks();
      }

      // Rows
 
      RowView row(size_t i) const {
        normalize();
        return _underlying_mat.row(i);
      }
 
      template <typename C>
      void rows(C& x) const {
        normalize();
        return _underlying_mat.rows(x);
      }

      // Friend functions
 
      friend std::ostream& operator<<(std::ostream&         os,
                                      ProjMaxPlusMat const& x) {
        x.normalize();
        os << detail::to_string(x._underlying_mat);
        return os;
      }
 
      T const& underlying_matrix() const noexcept {
        normalize();
        return _underlying_mat;
      }
 
     private:
      explicit ProjMaxPlusMat(T&& mat)
          : _is_normalized(false), _underlying_mat(std::move(mat)) {
        normalize();
      }
 
      void normalize(bool force = false) const {
        if ((_is_normalized && !force)
            || (_underlying_mat.number_of_rows() == 0)
            || (_underlying_mat.number_of_cols() == 0)) {
          _is_normalized = true;
          return;
        }
        scalar_type const n = *std::max_element(_underlying_mat.cbegin(),
                                                _underlying_mat.cend());
        std::for_each(_underlying_mat.begin(),
                      _underlying_mat.end(),
                      [&n](scalar_type& s) {
                        if (s != NEGATIVE_INFINITY) {
                          s -= n;
                        }
                      });
        _is_normalized = true;
      }
 
      mutable bool _is_normalized;
      mutable T    _underlying_mat;
    };
  }  // namespace detail


  template <size_t R, size_t C, typename Scalar>
  using StaticProjMaxPlusMat
      = detail::ProjMaxPlusMat<StaticMaxPlusMat<R, C, Scalar>>;

  template <typename Scalar>
  using DynamicProjMaxPlusMat
      = detail::ProjMaxPlusMat<DynamicMaxPlusMat<Scalar>>;

  template <size_t R = 0, size_t C = R, typename Scalar = int>
  using ProjMaxPlusMat = std::conditional_t<R == 0 || C == 0,
                                            DynamicProjMaxPlusMat<Scalar>,
                                            StaticProjMaxPlusMat<R, C, Scalar>>;
 
  namespace detail {
    template <typename T>
    struct IsProjMaxPlusMatHelper : std::false_type {};
 
    template <size_t R, size_t C, typename Scalar>
    struct IsProjMaxPlusMatHelper<StaticProjMaxPlusMat<R, C, Scalar>>
        : std::true_type {};
 
    template <typename Scalar>
    struct IsProjMaxPlusMatHelper<DynamicProjMaxPlusMat<Scalar>>
        : std::true_type {};
  }  // namespace detail

  template <typename T>
  static constexpr bool IsProjMaxPlusMat
      = detail::IsProjMaxPlusMatHelper<T>::value;
 
  namespace matrix {
    // \ingroup projmaxplus_group
    //
    //! \throws LibsemigroupsException if
    //! `throw_if_bad_entry(x.underlying_matrix())` throws.
    template <typename Mat>
    constexpr std::enable_if_t<IsProjMaxPlusMat<Mat>>
    throw_if_bad_entry(Mat const& x) {
      throw_if_bad_entry(x.underlying_matrix());
    }
 
    // \ingroup projmaxplus_group
    //
    //! \throws LibsemigroupsException if
    //! `throw_if_bad_entry(x.underlying_matrix(), val)` throws.
    template <typename Mat>
    constexpr std::enable_if_t<IsProjMaxPlusMat<Mat>>
    throw_if_bad_entry(Mat const& x, typename Mat::scalar_type val) {
      throw_if_bad_entry(x.underlying_matrix(), val);
    }

    // Matrix helpers - pow

    //! \endcode
    // TODO(1) pow_no_checks
    // TODO(2) version that changes x in-place
    template <typename Mat>
    Mat pow(Mat const& x, typename Mat::scalar_type e) {
      using scalar_type = typename Mat::scalar_type;
 
      if constexpr (std::is_signed<scalar_type>::value) {
        if (e < 0) {
          LIBSEMIGROUPS_EXCEPTION(
              "negative exponent, expected value >= 0, found {}", e);
        }
      }
 
      throw_if_not_square(x);
 
      typename Mat::semiring_type const* sr = nullptr;
 
      if constexpr (IsMatWithSemiring<Mat>) {
        sr = x.semiring();
      }
 
      if (e == 0) {
        return x.one();
      }
 
      auto y = Mat(x);
      if (e == 1) {
        return y;
      }
      auto z = (e % 2 == 0 ? x.one() : y);
 
      Mat tmp(sr, x.number_of_rows(), x.number_of_cols());
      while (e > 1) {
        tmp.product_inplace_no_checks(y, y);
        std::swap(y, tmp);
        e /= 2;
        if (e % 2 == 1) {
          tmp.product_inplace_no_checks(z, y);
          std::swap(z, tmp);
        }
      }
      return z;
    }

    // Matrix helpers - rows

    //!
    //! \complexity
    //! \f$O(m)\f$ where \f$m\f$ is the number of rows in the matrix \p x.
    template <typename Mat, typename = std::enable_if_t<IsDynamicMatrix<Mat>>>
    std::vector<typename Mat::RowView> rows(Mat const& x) {
      std::vector<typename Mat::RowView> container;
      x.rows(container);
      return container;
    }

    //! \complexity
    //! \f$O(m)\f$ where \f$m\f$ is the number of rows in the matrix \p x.
    template <typename Mat, typename = std::enable_if_t<IsStaticMatrix<Mat>>>
    detail::StaticVector1<typename Mat::RowView, Mat::nr_rows>
    rows(Mat const& x) {
      detail::StaticVector1<typename Mat::RowView, Mat::nr_rows> container;
      x.rows(container);
      return container;
    }

    // Matrix helpers - bitset_rows
 
    // The main function
    //! \complexity
    //! \f$O(mn)\f$ where \f$m\f$ is the number of rows in `views` and
    //! and \f$n\f$ is the number of columns in any vector in `views`.
    template <typename Mat, size_t R, size_t C, typename Container>
    void bitset_rows(Container&&                          views,
                     detail::StaticVector1<BitSet<C>, R>& result) {
      using RowView    = typename Mat::RowView;
      using value_type = typename std::decay_t<Container>::value_type;
      // std::vector<bool> is used as value_type in the benchmarks
      static_assert(IsBMat<Mat>, "IsBMat<Mat> must be true!");
      static_assert(std::is_same<value_type, RowView>::value
                        || std::is_same<value_type, std::vector<bool>>::value,
                    "Container::value_type must equal Mat::RowView or "
                    "std::vector<bool>!!");
      static_assert(R <= BitSet<1>::max_size(),
                    "R must be at most BitSet<1>::max_size()!");
      static_assert(C <= BitSet<1>::max_size(),
                    "C must be at most BitSet<1>::max_size()!");
      LIBSEMIGROUPS_ASSERT(views.size() <= R);
      LIBSEMIGROUPS_ASSERT(views.empty() || views[0].size() <= C);
      for (auto const& v : views) {
        result.emplace_back(v.cbegin(), v.cend());
      }
    }

    //! \complexity
    //! \f$O(mn)\f$ where \f$m\f$ is the number of rows in \p views and
    //! and \f$n\f$ is the number of columns in any vector in \p views.
    template <typename Mat, size_t R, size_t C, typename Container>
    auto bitset_rows(Container&& views) {
      using RowView    = typename Mat::RowView;
      using value_type = typename std::decay_t<Container>::value_type;
      static_assert(IsBMat<Mat>, "IsBMat<Mat> must be true!");
      static_assert(std::is_same<value_type, RowView>::value
                        || std::is_same<value_type, std::vector<bool>>::value,
                    "Container::value_type must equal Mat::RowView or "
                    "std::vector<bool>!!");
      static_assert(R <= BitSet<1>::max_size(),
                    "R must be at most BitSet<1>::max_size()!");
      static_assert(C <= BitSet<1>::max_size(),
                    "C must be at most BitSet<1>::max_size()!");
      LIBSEMIGROUPS_ASSERT(views.size() <= R);
      LIBSEMIGROUPS_ASSERT(views.empty() || views[0].size() <= C);
      detail::StaticVector1<BitSet<C>, R> result;
      bitset_rows<Mat>(std::forward<Container>(views), result);
      return result;
    }
 
    // Helper
    //! \complexity
    //! \f$O(mn)\f$ where \f$m\f$ is the number of rows in \p x and and
    //! \f$n\f$ is the number of columns in \p x.
    template <typename Mat, size_t R, size_t C>
    void bitset_rows(Mat const&                           x,
                     detail::StaticVector1<BitSet<C>, R>& result) {
      static_assert(IsBMat<Mat>, "IsBMat<Mat> must be true!");
      static_assert(R <= BitSet<1>::max_size(),
                    "R must be at most BitSet<1>::max_size()!");
      static_assert(C <= BitSet<1>::max_size(),
                    "C must be at most BitSet<1>::max_size()!");
      LIBSEMIGROUPS_ASSERT(x.number_of_cols() <= C);
      LIBSEMIGROUPS_ASSERT(x.number_of_rows() <= R);
      bitset_rows<Mat>(std::move(rows(x)), result);
    }
 
    // Helper
    //! \complexity
    //! \f$O(mn)\f$ where \f$m\f$ is the number of rows in \p x and
    //! and \f$n\f$ is the number of columns in \p x.
    template <typename Mat>
    auto bitset_rows(Mat const& x) {
      static_assert(IsBMat<Mat>, "IsBMat<Mat> must be true!");
      LIBSEMIGROUPS_ASSERT(x.number_of_rows() <= BitSet<1>::max_size());
      LIBSEMIGROUPS_ASSERT(x.number_of_cols() <= BitSet<1>::max_size());
      size_t const M = detail::BitSetCapacity<Mat>::value;
      return bitset_rows<Mat, M, M>(std::move(rows(x)));
    }

    // Matrix helpers - bitset_row_basis

    //! \f$c\f$ is the size of each bitset in `rows`.
    // This works with std::vector and StaticVector1, with value_type equal
    // to std::bitset and BitSet.
    template <typename Mat, typename Container>
    void bitset_row_basis(Container&& rows, std::decay_t<Container>& result) {
      using value_type = typename std::decay_t<Container>::value_type;
      static_assert(IsBMat<Mat>, "IsBMat<Mat> must be true!");
      static_assert(IsBitSet<value_type> || detail::IsStdBitSet<value_type>,
                    "Container::value_type must be BitSet or std::bitset");
      LIBSEMIGROUPS_ASSERT(rows.size() <= BitSet<1>::max_size());
      LIBSEMIGROUPS_ASSERT(rows.empty()
                           || rows[0].size() <= BitSet<1>::max_size());
 
      std::sort(rows.begin(), rows.end(), detail::LessBitSet());
      // Remove duplicates
      rows.erase(std::unique(rows.begin(), rows.end()), rows.end());
      for (size_t i = 0; i < rows.size(); ++i) {
        value_type cup;
        cup.reset();
        for (size_t j = 0; j < i; ++j) {
          if ((rows[i] & rows[j]) == rows[j]) {
            cup |= rows[j];
          }
        }
        for (size_t j = i + 1; j < rows.size(); ++j) {
          if ((rows[i] & rows[j]) == rows[j]) {
            cup |= rows[j];
          }
        }
        if (cup != rows[i]) {
          result.push_back(std::move(rows[i]));
        }
      }
    }

    //! \complexity
    //! \f$O(r ^ 2 c)\f$ where \f$r\f$ is the size of \p rows and
    //! \f$c\f$ is the size of each bitset in \p rows.
    template <typename Mat, typename Container>
    std::decay_t<Container> bitset_row_basis(Container&& rows) {
      using value_type = typename std::decay_t<Container>::value_type;
      static_assert(IsBMat<Mat>, "IsBMat<Mat> must be true!");
      static_assert(IsBitSet<value_type> || detail::IsStdBitSet<value_type>,
                    "Container::value_type must be BitSet or std::bitset");
      LIBSEMIGROUPS_ASSERT(rows.size() <= BitSet<1>::max_size());
      LIBSEMIGROUPS_ASSERT(rows.empty()
                           || rows[0].size() <= BitSet<1>::max_size());
      std::decay_t<Container> result;
      bitset_row_basis<Mat>(std::forward<Container>(rows), result);
      return result;
    }

    //! \complexity
    //! \f$O(r ^ 2 c)\f$ where \f$r\f$ is the number of rows in \p x and
    //! \f$c\f$ is the number of columns in \p x.
    template <typename Mat, size_t M = detail::BitSetCapacity<Mat>::value>
    detail::StaticVector1<BitSet<M>, M> bitset_row_basis(Mat const& x) {
      static_assert(IsBMat<Mat>, "IsBMat<Mat> must be true!");
      LIBSEMIGROUPS_ASSERT(x.number_of_rows() <= BitSet<1>::max_size());
      LIBSEMIGROUPS_ASSERT(x.number_of_cols() <= BitSet<1>::max_size());
      detail::StaticVector1<BitSet<M>, M> result;
      bitset_row_basis<Mat>(std::move(bitset_rows(x)), result);
      return result;
    }

    //! \complexity
    //! \f$O(r ^ 2 c)\f$ where \f$r\f$ is the number of rows in \p x
    //! and \f$c\f$ is the number of columns in \p x.
    template <typename Mat, typename Container>
    void bitset_row_basis(Mat const& x, Container& result) {
      using value_type = typename Container::value_type;
      static_assert(IsBMat<Mat>, "IsBMat<Mat> must be true!");
      static_assert(IsBitSet<value_type> || detail::IsStdBitSet<value_type>,
                    "Container::value_type must be BitSet or std::bitset");
      LIBSEMIGROUPS_ASSERT(x.number_of_rows() <= BitSet<1>::max_size());
      LIBSEMIGROUPS_ASSERT(x.number_of_cols() <= BitSet<1>::max_size());
      bitset_row_basis<Mat>(std::move(bitset_rows(x)), result);
    }

    // Matrix helpers - row_basis - MaxPlusTruncMat

    //! \f$O(r ^ 2 c)\f$ where \f$r\f$ is the size of \p views and
    //! \f$c\f$ is the size of each row view or bit set in \p views.
    template <typename Mat, typename Container>
    std::enable_if_t<IsMaxPlusTruncMat<Mat>>
    row_basis(Container&& views, std::decay_t<Container>& result) {
      using value_type = typename std::decay_t<Container>::value_type;
      static_assert(std::is_same<value_type, typename Mat::RowView>::value,
                    "Container::value_type must be Mat::RowView");
      using scalar_type = typename Mat::scalar_type;
      using Row         = typename Mat::Row;
 
      if (views.empty()) {
        return;
      }
 
      LIBSEMIGROUPS_ASSERT(result.empty());
 
      std::sort(views.begin(), views.end());
      Row tmp1(views[0]);
 
      for (size_t r1 = 0; r1 < views.size(); ++r1) {
        if (r1 == 0 || views[r1] != views[r1 - 1]) {
          std::fill(tmp1.begin(), tmp1.end(), tmp1.scalar_zero());
          for (size_t r2 = 0; r2 < r1; ++r2) {
            scalar_type max_scalar = matrix::threshold(tmp1);
            for (size_t c = 0; c < tmp1.number_of_cols(); ++c) {
              if (views[r2][c] == tmp1.scalar_zero()) {
                continue;
              }
              if (views[r1][c] >= views[r2][c]) {
                if (views[r1][c] != matrix::threshold(tmp1)) {
                  max_scalar
                      = std::min(max_scalar, views[r1][c] - views[r2][c]);
                }
              } else {
                max_scalar = tmp1.scalar_zero();
                break;
              }
            }
            if (max_scalar != tmp1.scalar_zero()) {
              tmp1 += views[r2] * max_scalar;
            }
          }
          if (tmp1 != views[r1]) {
            result.push_back(views[r1]);
          }
        }
      }
    }

    // Matrix helpers - row_basis - BMat
 
    // This version of row_basis for BMat's is for used for compatibility
    // with the MatrixCommon framework, i.e. so that BMat's exhibit the same
    // interface/behaviour as other matrices.
    //
    // This version takes a container of row views of BMat, converts it to a
    // container of BitSets, computes the row basis using the BitSets, then
    // selects those row views in views that belong to the computed basis.

    //! \exceptions
    //! \no_libsemigroups_except
    // TODO(2) complexity
    template <typename Mat, typename Container>
    std::enable_if_t<IsBMat<Mat>> row_basis(Container&&              views,
                                            std::decay_t<Container>& result) {
      using RowView    = typename Mat::RowView;
      using value_type = typename std::decay_t<Container>::value_type;
      // std::vector<bool> is used as value_type in the benchmarks
      static_assert(std::is_same<value_type, RowView>::value
                        || std::is_same<value_type, std::vector<bool>>::value,
                    "Container::value_type must equal Mat::RowView or "
                    "std::vector<bool>!!");
 
      if (views.empty()) {
        return;
      }
 
      // Convert RowViews to BitSets
      size_t const M  = detail::BitSetCapacity<Mat>::value;
      auto         br = bitset_rows<Mat, M, M>(std::forward<Container>(views));
      using bitset_type = typename decltype(br)::value_type;
 
      // Map for converting bitsets back to row views
      std::unordered_map<bitset_type, size_t> lookup;
      LIBSEMIGROUPS_ASSERT(br.size() == views.size());
      for (size_t i = 0; i < br.size(); ++i) {
        lookup.insert({br[i], i});
      }
 
      // Compute rowbasis using bitsets + convert back to rowviews
      for (auto const& bs : bitset_row_basis<Mat>(br)) {
        auto it = lookup.find(bs);
        LIBSEMIGROUPS_ASSERT(it != lookup.end());
        result.push_back(views[it->second]);
      }
    }

    // Matrix helpers - row_basis - generic helpers

    // Row basis of rowspace of matrix <x> appended to <result>
    template <typename Mat,
              typename Container,
              typename = std::enable_if_t<IsMatrix<Mat>>>
    void row_basis(Mat const& x, Container& result) {
      row_basis<Mat>(std::move(rows(x)), result);
    }

    //! \f$O(r ^ 2 c)\f$ where \f$r\f$ is the number of rows in \p x
    //! and \f$c\f$ is the number of columns in \p x.
    // Row basis of rowspace of matrix <x>
    template <typename Mat, typename = std::enable_if_t<IsDynamicMatrix<Mat>>>
    std::vector<typename Mat::RowView> row_basis(Mat const& x) {
      std::vector<typename Mat::RowView> container;
      row_basis(x, container);
      return container;
    }

    //! \f$O(r ^ 2 c)\f$ where \f$r\f$ is the number of rows in \p x
    //! and \f$c\f$ is the number of columns in \p x.
    template <typename Mat, typename = std::enable_if_t<IsStaticMatrix<Mat>>>
    detail::StaticVector1<typename Mat::RowView, Mat::nr_rows>
    row_basis(Mat const& x) {
      detail::StaticVector1<typename Mat::RowView, Mat::nr_rows> container;
      row_basis(x, container);
      return container;
    }

    //! \exceptions
    //! \no_libsemigroups_except
    // TODO(2) complexity
    template <typename Mat, typename Container>
    std::decay_t<Container> row_basis(Container&& rows) {
      using value_type = typename std::decay_t<Container>::value_type;
      static_assert(IsMatrix<Mat>, "IsMatrix<Mat> must be true!");
      static_assert(std::is_same<value_type, typename Mat::RowView>::value,
                    "Container::value_type must be Mat::RowView");
 
      std::decay_t<Container> result;
      row_basis<Mat>(std::forward<Container>(rows), result);
      return result;
    }

    // Matrix helpers - row_space_size

    //! auto x = make<BMat<>>({{1, 0, 0}, {0, 0, 1}, {0, 1, 0}});
    //! matrix::row_space_size(x); // returns 7
    //! \endcode
    template <typename Mat, typename = std::enable_if_t<IsBMat<Mat>>>
    size_t row_space_size(Mat const& x) {
      size_t const M                 = detail::BitSetCapacity<Mat>::value;
      auto         bitset_row_basis_ = bitset_row_basis<Mat>(
          std::move(bitset_rows<Mat, M, M>(std::move(rows(x)))));
 
      std::unordered_set<BitSet<M>> st;
      st.insert(bitset_row_basis_.cbegin(), bitset_row_basis_.cend());
      std::vector<BitSet<M>> orb(bitset_row_basis_.cbegin(),
                                 bitset_row_basis_.cend());
      for (size_t i = 0; i < orb.size(); ++i) {
        for (auto& row : bitset_row_basis_) {
          auto cup = orb[i];
          for (size_t j = 0; j < x.number_of_rows(); ++j) {
            cup.set(j, cup[j] || row[j]);
          }
          if (st.insert(cup).second) {
            orb.push_back(std::move(cup));
          }
        }
      }
      return orb.size();
    }
 
  }  // namespace matrix

  //! \no_libsemigroups_except
  //!
  //! \warning This function does not detect overflows of `Mat::scalar_type`.
  template <typename Mat>
  auto operator+(typename Mat::scalar_type a, Mat const& x)
      -> std::enable_if_t<IsMatrix<Mat>, Mat> {
    return x + a;
  }

  //! \no_libsemigroups_except
  //!
  //! \warning This function does not detect overflows of `Mat::scalar_type`.
  template <typename Mat>
  auto operator*(typename Mat::scalar_type a, Mat const& x)
      -> std::enable_if_t<IsMatrix<Mat>, Mat> {
    return x * a;
  }


  //! \f$n\f$ is the number of columns of the matrix.
  template <typename Mat,
            typename
            = std::enable_if_t<IsMatrix<Mat> && !IsMatWithSemiring<Mat>>>
  Mat make(std::vector<std::vector<typename Mat::scalar_type>> const& rows) {
    detail::throw_if_any_row_wrong_size(rows);
    detail::throw_if_bad_dim<Mat>(rows);
    Mat m(rows);
    matrix::throw_if_bad_entry(m);
    return m;
  }

  //! \f$n\f$ is the number of columns of the matrix.
  template <typename Mat,
            typename
            = std::enable_if_t<IsMatrix<Mat> && !IsMatWithSemiring<Mat>>>
  Mat make(std::initializer_list<std::vector<typename Mat::scalar_type>> const&
               rows) {
    return make<Mat>(std::vector<std::vector<typename Mat::scalar_type>>(rows));
  }

  //! parameter \c R is \c 1.
  template <typename Mat,
            typename
            = std::enable_if_t<IsMatrix<Mat> && !IsMatWithSemiring<Mat>>>
  Mat make(std::initializer_list<typename Mat::scalar_type> const& row) {
    // TODO(0) Add row dimension checking for compile-time size matrices
    Mat m(row);
    matrix::throw_if_bad_entry(m);
    return m;
  }
  // TODO(1) vector version of above

  template <typename Mat,
            typename Semiring,
            typename = std::enable_if_t<IsMatrix<Mat>>>
  // TODO(1) pass Semiring by reference, this is hard mostly due to the way
  // the tests are written, which is not optimal.
  Mat make(Semiring const* semiring,
           std::initializer_list<
               std::initializer_list<typename Mat::scalar_type>> const& rows) {
    detail::throw_if_any_row_wrong_size(rows);
    detail::throw_if_bad_dim<Mat>(rows);
    Mat m(semiring, rows);
    matrix::throw_if_bad_entry(m);
    return m;
  }

  //! \f$n\f$ is the number of columns of the matrix.
  template <typename Mat,
            typename Semiring,
            typename = std::enable_if_t<IsMatrix<Mat>>>
  Mat make(Semiring const*                                            semiring,
           std::vector<std::vector<typename Mat::scalar_type>> const& rows) {
    detail::throw_if_any_row_wrong_size(rows);
    detail::throw_if_bad_dim<Mat>(rows);
    Mat m(semiring, rows);
    matrix::throw_if_bad_entry(m);
    return m;
  }

  //! \f$O(n)\f$ where \f$n\f$ is the number of columns of the matrix.
  template <typename Mat,
            typename Semiring,
            typename = std::enable_if_t<IsMatrix<Mat>>>
  Mat make(Semiring const*                                         semiring,
           std::initializer_list<typename Mat::scalar_type> const& row) {
    // TODO(0) Add row dimension checking for compile-time size matrices
    Mat m(semiring, row);
    matrix::throw_if_bad_entry(m);
    return m;
  }

  //! \f$O(mn)\f$ where \f$m\f$ is the number of rows and \f$n\f$ is the
  //! number of columns of the matrix.
  template <size_t R, size_t C, typename Scalar>
  ProjMaxPlusMat<R, C, Scalar>
  make(std::initializer_list<std::initializer_list<Scalar>> const& rows) {
    return ProjMaxPlusMat<R, C, Scalar>(
        make<ProjMaxPlusMat<R, C, Scalar>::underlying_matrix_type>(rows));
  }

  // Printing etc...

  //!
  //! \exceptions
  //! \no_libsemigroups_except
  template <typename S, typename T>
  std::ostringstream& operator<<(std::ostringstream&                os,
                                 detail::RowViewCommon<S, T> const& x) {
    os << "{";
    for (auto it = x.cbegin(); it != x.cend(); ++it) {
      os << *it;
      if (it != x.cend() - 1) {
        os << ", ";
      }
    }
    os << "}";
    return os;
  }

  //!
  //! \exceptions
  //! \no_libsemigroups_except
  template <typename Mat>
  auto operator<<(std::ostringstream& os, Mat const& x)
      -> std::enable_if_t<IsMatrix<Mat>, std::ostringstream&> {
    size_t n = 0;
    if (x.number_of_rows() != 1) {
      os << "{";
    }
    for (auto&& r : matrix::rows(x)) {
      os << r;
      if (n != x.number_of_rows() - 1) {
        os << ", ";
      }
      n++;
    }
    if (x.number_of_rows() != 1) {
      os << "}";
    }
    return os;
  }

  //! (default: \c 72).
  //!
  //! \throws LibsemigroupsException if \p braces does not have size \c 2.
  template <typename Mat>
  auto to_human_readable_repr(Mat const&         x,
                              std::string const& prefix,
                              std::string const& short_name = "",
                              std::string const& braces     = "{}",
                              size_t             max_width  = 72)
      -> std::enable_if_t<IsMatrix<Mat>, std::string> {
    if (braces.size() != 2) {
      LIBSEMIGROUPS_EXCEPTION(
          "the 4th argument (braces) must have size 2, found {}",
          braces.size());
    }
 
    size_t const R = x.number_of_rows();
    size_t const C = x.number_of_cols();
 
    std::vector<size_t> max_col_widths(C, 0);
    std::vector<size_t> row_widths(C, prefix.size() + 1);
    for (size_t r = 0; r < R; ++r) {
      for (size_t c = 0; c < C; ++c) {
        size_t width
            = detail::unicode_string_length(detail::entry_repr(x(r, c)));
        row_widths[r] += width;
        if (width > max_col_widths[c]) {
          max_col_widths[c] = width;
        }
      }
    }
    auto col_width
        = *std::max_element(max_col_widths.begin(), max_col_widths.end());
    // The total width if we pad the entries according to the widest column.
    auto const total_width = col_width * C + prefix.size() + 1;
    if (total_width > max_width) {
      // Padding according to the widest column is too wide!
      if (*std::max_element(row_widths.begin(), row_widths.end()) > max_width) {
        // If the widest row is too wide, then use the short name
        return fmt::format(
            "<{}x{} {}>", x.number_of_rows(), x.number_of_cols(), short_name);
      }
      // If the widest row is not too wide, then just don't pad the entries
      col_width = 0;
    }
 
    std::string result = fmt::format("{}", prefix);
    std::string rindent;
    auto const  lbrace = braces[0], rbrace = braces[1];
    if (R != 0 && C != 0) {
      result += lbrace;
      for (size_t r = 0; r < R; ++r) {
        result += fmt::format("{}{}", rindent, lbrace);
        rindent          = std::string(prefix.size() + 1, ' ');
        std::string csep = "";
        for (size_t c = 0; c < C; ++c) {
          result += fmt::format(
              "{}{:>{}}", csep, detail::entry_repr(x(r, c)), col_width);
          csep = ", ";
        }
        result += fmt::format("{}", rbrace);
        if (r != R - 1) {
          result += ",\n";
        }
      }
      result += rbrace;
    }
    result += ")";
    return result;
  }

  // Adapters


  //! satisfying \ref IsMatrix<Mat>.
  //!
  //! \tparam  Mat the type of matrices.
  template <typename Mat>
  struct Complexity<Mat, std::enable_if_t<IsMatrix<Mat>>> {
    //! \noexcept
    //!
    //! \complexity
    //! Constant.
    constexpr size_t operator()(Mat const& x) const noexcept {
      return x.number_of_rows() * x.number_of_rows() * x.number_of_rows();
    }
  };

  //! \ref IsMatrix<Mat>.
  //!
  //! \tparam  Mat the type of matrices.
  template <typename Mat>
  struct Degree<Mat, std::enable_if_t<IsMatrix<Mat>>> {
    //! \noexcept
    //!
    //! \complexity
    //! Constant.
    constexpr size_t operator()(Mat const& x) const noexcept {
      return x.number_of_rows();
    }
  };

  //! \ref IsMatrix<Mat>.
  //!
  //! \tparam  Mat the type of matrices.
  template <typename Mat>
  struct Hash<Mat, std::enable_if_t<IsMatrix<Mat>>> {
    //! \no_libsemigroups_except
    //!
    //! \complexity
    //! Constant.
    constexpr size_t operator()(Mat const& x) const {
      return x.hash_value();
    }
  };

  //! It is not possible to increase the degree of any of the types
  //! satisfying \ref IsMatrix, and as such the call operator of this type
  //! does nothing.
  template <typename Mat>
  struct IncreaseDegree<Mat, std::enable_if_t<IsMatrix<Mat>>> {
    constexpr void operator()(Mat&, size_t) const noexcept {
      // static_assert(false, "Cannot increase degree for Matrix");
      LIBSEMIGROUPS_ASSERT(false);
    }
  };

  //! \ref IsMatrix.
  //!
  //! \tparam Mat the type of matrices.
  template <typename Mat>
  struct One<Mat, std::enable_if_t<IsMatrix<Mat>>> {
    //!
    //! \complexity
    //! \f$O(m ^ 2)\f$ where \f$m\f$ is the number of rows of the
    //! matrix \p x.
    inline Mat operator()(Mat const& x) const {
      return x.one();
    }
  };

  //! \ref IsMatrix<Mat>.
  //!
  //! \tparam Mat the type of matrices.
  template <typename Mat>
  struct Product<Mat, std::enable_if_t<IsMatrix<Mat>>> {
    //!
    //! \warning
    //! This function only works for square matrices.
    inline void
    operator()(Mat& xy, Mat const& x, Mat const& y, size_t = 0) const {
      xy.product_inplace_no_checks(x, y);
    }
  };
}  // namespace libsemigroups
 
namespace std {
  template <size_t N,
            typename Mat,
            std::enable_if_t<libsemigroups::IsMatrix<Mat>>>
  inline void swap(Mat& x, Mat& y) noexcept {
    x.swap(y);
  }
}  // namespace std
 
#endif  // LIBSEMIGROUPS_MATRIX_HPP_