Quelle kbe-impl.hpp Sprache: C

//
// libsemigroups - C++ library for semigroups and monoids
// Copyright (C) 2019 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/>.
//

// This file contains the implementation of the KBE class in include/kbe.hpp
// and is included directly in knuth-bendix.cpp, because (for reasons of
// efficiency) it depends on some of the implementational details of the
// KnuthBendix class.

#ifndef LIBSEMIGROUPS_SRC_KBE_IMPL_HPP_
#define LIBSEMIGROUPS_SRC_KBE_IMPL_HPP_

namespace libsemigroups {
  namespace detail {

    KBE::KBE(internal_string_type const& w) : _kb_word(w) {}
    KBE::KBE(internal_string_type&& w) : _kb_word(std::move(w)) {}

    KBE::KBE(KnuthBendix& kb, internal_string_type const& w) : KBE(w) {
      kb._impl->internal_rewrite(&_kb_word);
    }

    KBE::KBE(KnuthBendix& kb, internal_string_type&& w) : KBE(std::move(w)) {
      kb._impl->internal_rewrite(&_kb_word);
    }

    KBE::KBE(KnuthBendix& kb, letter_type const& a)
        : KBE(kb, KnuthBendix::KnuthBendixImpl::uint_to_internal_string(a)) {}

    KBE::KBE(KnuthBendix& kb, word_type const& w)
        : KBE(kb, KnuthBendix::KnuthBendixImpl::word_to_internal_string(w)) {}

    bool KBE::operator==(KBE const& that) const {
      return that._kb_word == this->_kb_word;
    }

    bool KBE::operator<(KBE const& that) const {
      return shortlex_compare(_kb_word, that._kb_word);
    }

    void KBE::swap(KBE& x) {
      std::swap(x._kb_word, _kb_word);
    }

    KBE::internal_string_type const& KBE::string() const noexcept {
      return _kb_word;
    }

    word_type KBE::word(KnuthBendix const& kb) const {
      return kb._impl->internal_string_to_word(_kb_word);
    }

    std::string KBE::string(KnuthBendix const& kb) const {
      std::string out(_kb_word);
      kb._impl->internal_to_external_string(out);  // changes out in-place
      return out;
    }

  }  // namespace detail

  template <>
  word_type
  FroidurePin<detail::KBE,
              FroidurePinTraits<detail::KBE, fpsemigroup::KnuthBendix>>::
      factorisation(detail::KBE const& x) {
    return x.word(*state());
  }

  template <>
  tril FroidurePin<detail::KBE,
                   FroidurePinTraits<detail::KBE, fpsemigroup::KnuthBendix>>::
      is_finite() const {
    // Turns out that the FroidurePin can be finished without the state
    // being finished, this sounds like a bug, I'm not 100% sure how that
    // works. Probably the state of the FroidurePin and the underlying
    // KnuthBendix are not the same object, and one is being used when the
    // other one should be, or something.
    if (finished() || state()->is_obviously_finite()) {
      return tril::TRUE;
    }
    if (state()->is_obviously_infinite()) {
      return tril::FALSE;
    }
    return tril::unknown;
  }
}  // namespace libsemigroups
#endif  // LIBSEMIGROUPS_SRC_KBE_IMPL_HPP_

quality93%

¤ Dauer der Verarbeitung: 0.1 Sekunden (vorverarbeitet) ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung ist noch experimentell.