passagemath-gap-pkg-semigroups 10.6.29__cp312-abi3-musllinux_1_2_x86_64.whl

gap/pkg/semigroups/gapbind14/demo/PackageInfo.g

@@ -0,0 +1,87 @@
+#
+# gapbind_demo: Minimal demo of how to use gapbind14
+#
+# This file contains package meta data. For additional information on
+# the meaning and correct usage of these fields, please consult the
+# manual of the "Example" package as well as the comments in its
+# PackageInfo.g file.
+#
+SetPackageInfo( rec(
+
+PackageName := "gapbind_demo",
+Subtitle := "Minimal demo of how to use gapbind14",
+Version := "0.1",
+Date := "15/07/2022", # dd/mm/yyyy format
+License := "GPL-2.0-or-later",
+
+Persons := [
+  rec(
+    FirstNames := "James D.",
+    LastName := "Mitchell",
+    WWWHome := "https://jdbm.me",
+    Email := "jdm3@st-andrews.ac.uk",
+    IsAuthor := true,
+    IsMaintainer := true,
+    PostalAddress := "KY169 SS",
+    Place := "St Andrews",
+    Institution := "University of St Andrews",
+  ),
+],
+
+#SourceRepository := rec( Type := "TODO", URL := "URL" ),
+#IssueTrackerURL := "TODO",
+PackageWWWHome := "na/",
+PackageInfoURL := Concatenation( ~.PackageWWWHome, "PackageInfo.g" ),
+README_URL     := Concatenation( ~.PackageWWWHome, "README.md" ),
+ArchiveURL     := Concatenation( ~.PackageWWWHome,
+                                 "/", ~.PackageName, "-", ~.Version ),
+
+ArchiveFormats := ".tar.gz",
+
+##  Status information. Currently the following cases are recognized:
+##    "accepted"      for successfully refereed packages
+##    "submitted"     for packages submitted for the refereeing
+##    "deposited"     for packages for which the GAP developers agreed
+##                    to distribute them with the core GAP system
+##    "dev"           for development versions of packages
+##    "other"         for all other packages
+##
+Status := "dev",
+
+AbstractHTML   :=  "",
+
+PackageDoc := rec(
+  BookName  := "gapbind_demo",
+  ArchiveURLSubset := ["doc"],
+  HTMLStart := "doc/chap0.html",
+  PDFFile   := "doc/manual.pdf",
+  SixFile   := "doc/manual.six",
+  LongTitle := "Minimal demo of how to use gapbind14",
+),
+
+Dependencies := rec(
+  GAP := ">= 4.11",
+  NeededOtherPackages := [ ],
+  SuggestedOtherPackages := [ ],
+  ExternalConditions := [ ],
+),
+
+AvailabilityTest := function()
+  local dir, lib;
+  dir := DirectoriesPackagePrograms("gapbind_demo");
+  lib := Filename(dir, "gapbind_demo.so");
+  if lib = fail then
+    LogPackageLoadingMessage(PACKAGE_WARNING,
+                             "failed to load kernel module of package gapbind_demo");
+    return fail;
+  fi;
+  return true;
+end,
+
+TestFile := "tst/testall.g",
+
+#Keywords := [ "TODO" ],
+
+));
+
+

gap/pkg/semigroups/gapbind14/demo/README.md

@@ -0,0 +1,17 @@
+# The GAP package gapbind_demo
+
+TODO: add a description of your package; perhaps also instructions how how to
+install and use it, resp. where to find out more
+
+
+## Contact
+
+TODO: add info on how to contact you and/or how to report issues with your
+package
+
+## License
+
+TODO: Provide information on the license of your package. A license is
+important as it determines who has a right to distribute your package. The
+"default" license to consider is GNU General Public License v2 or later, as
+that is the license of GAP itself.

gap/pkg/semigroups/gapbind14/demo/configure

@@ -0,0 +1,34 @@
+#!/bin/sh
+# usage: configure gappath
+# this script creates a `Makefile' from `Makefile.in'
+
+set -e
+
+GAPPATH=../..
+while test "$#" -ge 1 ; do
+  option="$1" ; shift
+  case "$option" in
+    --with-gaproot=*) GAPPATH=${option#--with-gaproot=}; ;;
+    -*)               echo "ERROR: unsupported argument $option" ; exit 1;;
+    *)                GAPPATH="$option" ;;
+  esac
+done
+
+if test ! -r "$GAPPATH/sysinfo.gap" ; then
+    echo
+    echo "No file $GAPPATH/sysinfo.gap found."
+    echo
+    echo "Usage: ./configure [GAPPATH]"
+    echo "       where GAPPATH is a path to your GAP installation"
+    echo "       (The default for GAPPATH is \"../..\")"
+    echo
+    echo "Either your GAPPATH is incorrect or the GAP it is pointing to"
+    echo "is not properly compiled (do \"./configure && make\" there first)."
+    echo
+    echo "Aborting... No Makefile is generated."
+    echo
+    exit 1
+fi
+
+echo "Using settings from $GAPPATH/sysinfo.gap"
+sed -e "s;@GAPPATH@;$GAPPATH;g" Makefile.in > Makefile

gap/pkg/semigroups/gapbind14/demo/gap/gapbind_demo.gd

@@ -0,0 +1,19 @@
+#
+# gapbind_demo: Minimal demo of how to use gapbind14
+#
+#! @Chapter Introduction
+#!
+#! gapbind_demo is a package which does some
+#! interesting and cool things
+#!
+#! @Chapter Functionality
+#!
+#!
+#! @Section Example Methods
+#!
+#! This section will describe the example
+#! methods of gapbind_demo
+
+#! @Description
+#!   Insert documentation for your function here
+DeclareGlobalFunction( "gapbind_demo_Example" );

gap/pkg/semigroups/gapbind14/demo/gap/gapbind_demo.gi

@@ -0,0 +1,10 @@
+#
+# gapbind_demo: Minimal demo of how to use gapbind14
+#
+# Implementations
+#
+InstallGlobalFunction( gapbind_demo_Example,
+function()
+	Print( "This is a placeholder function, replace it with your own code.\n" );
+end );
+

gap/pkg/semigroups/gapbind14/demo/init.g

@@ -0,0 +1,16 @@
+#
+# gapbind_demo: Minimal demo of how to use gapbind14
+#
+# Reading the declaration part of the package.
+#
+if LoadKernelExtension("gapbind_demo") = false then
+    Error("failed to load gapbind_demo kernel extension");
+fi;
+
+if not IsBoundGlobal("IsTGapBind14Obj") then
+  DeclareCategory("IsTGapBind14Obj", IsObject);
+  BindGlobal("TheTypeTGapBind14Obj",
+             NewType(NewFamily("TGapBind14ObjFamily"), IsTGapBind14Obj));
+fi;
+
+ReadPackage( "gapbind_demo", "gap/gapbind_demo.gd");

gap/pkg/semigroups/gapbind14/demo/makedoc.g

@@ -0,0 +1,10 @@
+#
+# gapbind_demo: Minimal demo of how to use gapbind14
+#
+# This file is a script which compiles the package manual.
+#
+if fail = LoadPackage("AutoDoc", "2018.02.14") then
+    Error("AutoDoc version 2018.02.14 or newer is required.");
+fi;
+
+AutoDoc( rec( scaffold := true, autodoc := true ) );

gap/pkg/semigroups/gapbind14/demo/read.g

@@ -0,0 +1,6 @@
+#
+# gapbind_demo: Minimal demo of how to use gapbind14
+#
+# Reading the implementation part of the package.
+#
+ReadPackage( "gapbind_demo", "gap/gapbind_demo.gi");

gap/pkg/semigroups/gapbind14/demo/src/gapbind_demo.cc

@@ -0,0 +1,142 @@
+//
+// gapbind14
+// Copyright (C) 2022 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 <https://www.gnu.org/licenses/>.
+//
+
+// A minimal demo of how to use gapbind14
+
+#include <iostream>  // for cout
+#include <string>    // for string
+
+extern "C" {
+#include <gap_all.h>  // GAP headers
+}
+
+// GAPBIND14: include this header
+#include "gapbind14/gapbind14.hpp"
+
+namespace gapbind_demo {
+  void testing1() {
+    std::ios_base::Init();
+    std::cout << "it works\n";
+  }
+
+  std::string testing2() {
+    return "it works\n";
+  }
+
+  void testing3(std::string str) {
+    Pr("it works %s", (Int) str.c_str(), 0L);
+  }
+
+  std::string testing4(std::string str) {
+    return "it works " + str + "\n";
+  }
+
+  std::string testing4(int i) {
+    return "it works like it's over " + std::to_string(i);
+  }
+
+  int testing6(std::string str, size_t i) {
+    if (i == 0) {
+      throw std::runtime_error("can't take mod of 0!");
+    }
+    return std::hash<std::string>()(str) % i;
+  }
+
+  size_t testing7(size_t i) {
+    return i;
+  }
+
+  struct Pet {
+    explicit Pet(std::string name) : name(name) {}
+    void setName(const std::string& name_) {
+      name = name_;
+    }
+    const std::string& getName() const {
+      return name;
+    }
+
+    std::string getName(const std::string& name_) {
+      return name + name_;
+    }
+
+    void terminate() {
+      name = "dead";
+    }
+
+    std::string name;
+  };
+}  // namespace gapbind_demo
+
+namespace gapbind14 {
+  template <>
+  struct IsGapBind14Type<gapbind_demo::Pet> : std::true_type {};
+};  // namespace gapbind14
+
+GAPBIND14_MODULE(gapbind_demo) {
+  gapbind14::InstallGlobalFunction("testing1", &gapbind_demo::testing1);
+  gapbind14::InstallGlobalFunction("testing2", &gapbind_demo::testing2);
+  gapbind14::InstallGlobalFunction("testing3", &gapbind_demo::testing3);
+  gapbind14::InstallGlobalFunction(
+      "testing4_string",
+      gapbind14::overload_cast<std::string>(&gapbind_demo::testing4));
+  gapbind14::InstallGlobalFunction(
+      "testing4_int", gapbind14::overload_cast<int>(&gapbind_demo::testing4));
+  gapbind14::InstallGlobalFunction("testing6", &gapbind_demo::testing6);
+  gapbind14::InstallGlobalFunction("testing7", &gapbind_demo::testing7);
+  gapbind14::class_<gapbind_demo::Pet>("Pet")
+      .def(gapbind14::init<std::string>{}, "make")
+      .def("setName", &gapbind_demo::Pet::setName)
+      .def("getName", gapbind14::overload_cast<>(&gapbind_demo::Pet::getName))
+      .def("getNamestring",
+           gapbind14::overload_cast<std::string const&>(
+               &gapbind_demo::Pet::getName))
+      .def("terminate", &gapbind_demo::Pet::terminate);
+}
+
+static Int InitKernel(StructInitInfo* module) {
+  gapbind14::init_kernel("gapbind_demo");
+  return 0;
+}
+
+static Int InitLibrary(StructInitInfo* module) {
+  gapbind14::init_library("gapbind_demo");
+  return 0;
+}
+
+static StructInitInfo module = {
+    /* type        = */ MODULE_DYNAMIC,
+    /* name        = */ "gapbind_demo",
+    /* revision_c  = */ 0,
+    /* revision_h  = */ 0,
+    /* version     = */ 0,
+    /* crc         = */ 0,
+    /* initKernel  = */ InitKernel,
+    /* initLibrary = */ InitLibrary,
+    /* checkInit   = */ 0,
+    /* preSave     = */ 0,
+    /* postSave    = */ 0,
+    /* postRestore = */ 0,
+    /* moduleStateSize      = */ 0,
+    /* moduleStateOffsetPtr = */ 0,
+    /* initModuleState      = */ 0,
+    /* destroyModuleState   = */ 0,
+};
+
+extern "C" StructInitInfo* Init__Dynamic(void) {
+  return &module;
+}

gap/pkg/semigroups/gapbind14/demo/tst/testall.g

@@ -0,0 +1,12 @@
+#
+# gapbind_demo: Minimal demo of how to use gapbind14
+#
+# This file runs package tests. It is also referenced in the package
+# metadata in PackageInfo.g.
+#
+LoadPackage( "gapbind_demo" );
+
+TestDirectory(DirectoriesPackageLibrary( "gapbind_demo", "tst" ),
+  rec(exitGAP := true));
+
+FORCE_QUIT_GAP(1); # if we ever get here, there was an error

gap/pkg/semigroups/gapbind14/include/gapbind14/cpp_fn.hpp

@@ -0,0 +1,223 @@
+//
+// gapbind14
+// Copyright (C) 2020-2022 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 <https://www.gnu.org/licenses/>.
+//
+
+#ifndef INCLUDE_GAPBIND14_CPP_FN_HPP_
+#define INCLUDE_GAPBIND14_CPP_FN_HPP_
+
+#include <cstddef>      // for size_t
+#include <functional>   // for function
+#include <tuple>        // for tuple, tuple_element_t
+#include <type_traits>  // for true_type
+
+#include "gap_include.hpp"  // for UInt
+
+#define GAPBIND14_TRY(something)      \
+  try {                               \
+    something;                        \
+  } catch (std::exception const& e) { \
+    ErrorQuit(e.what(), 0L, 0L);      \
+  }
+
+namespace gapbind14 {
+
+  constexpr size_t MAX_FUNCTIONS = 96;
+  extern UInt      T_GAPBIND14_OBJ;
+
+  ////////////////////////////////////////////////////////////////////////
+  // Overloading
+  ////////////////////////////////////////////////////////////////////////
+
+  template <typename... TArgs>
+  struct overload_cast_impl {
+    constexpr overload_cast_impl() {}
+
+    template <typename TReturn>
+    constexpr auto operator()(TReturn (*pf)(TArgs...)) const noexcept
+        -> decltype(pf) {
+      return pf;
+    }
+
+    template <typename TReturn, typename TClass>
+    constexpr auto operator()(TReturn (TClass::*pmf)(TArgs...),
+                              std::false_type = {}) const noexcept
+        -> decltype(pmf) {
+      return pmf;
+    }
+
+    template <typename TReturn, typename TClass>
+    constexpr auto operator()(TReturn (TClass::*pmf)(TArgs...)
+                                  const) const noexcept -> decltype(pmf) {
+      return pmf;
+    }
+  };
+
+  template <typename... TArgs>
+  static constexpr overload_cast_impl<TArgs...> overload_cast = {};
+
+  namespace detail {
+    template <typename T>
+    class is_lambda {
+     private:
+      using no_ref = std::remove_reference_t<T>;
+
+     public:
+      static constexpr bool value = !(std::is_pointer<no_ref>::value
+                                      || std::is_member_pointer<no_ref>::value
+                                      || std::is_function<no_ref>::value);
+    };
+
+    template <typename T>
+    struct remove_class {};
+
+    template <typename C, typename R, typename... A>
+    struct remove_class<R (C::*)(A...)> {
+      using type = R(A...);
+    };
+
+    template <typename C, typename R, typename... A>
+    struct remove_class<R (C::*)(A...) const> {
+      using type = R(A...);
+    };
+
+    template <typename F>
+    struct strip_function_object {
+      using type = typename remove_class<decltype(&F::operator())>::type;
+    };
+
+    ////////////////////////////////////////////////////////////////////////
+    // Function return type and parameter type info
+    ////////////////////////////////////////////////////////////////////////
+
+    // For parameter packs . . .
+    template <typename... TArgs>
+    struct Pack {
+      template <size_t i>
+      using get = std::tuple_element_t<i, std::tuple<TArgs...>>;
+    };
+
+    template <typename TReturnType, typename... TArgs>
+    struct CppFunctionBase {
+      using arg_count   = std::integral_constant<unsigned, sizeof...(TArgs)>;
+      using return_type = TReturnType;
+      using params_type = Pack<TArgs...>;
+
+      // Function pointers . . .
+      template <typename SFINAE = TReturnType>
+      auto operator()(TReturnType (*f)(), TArgs... args)
+          -> std::enable_if_t<sizeof...(TArgs) == 0, SFINAE> {
+        return f();
+      }
+
+      template <typename SFINAE = TReturnType>
+      auto operator()(TReturnType (*f)(TArgs...), TArgs... args)
+          -> std::enable_if_t<sizeof...(TArgs) != 0, SFINAE> {
+        return f(args...);
+      }
+
+      template <typename SFINAE = TReturnType>
+      auto operator()(std::function<TReturnType(TArgs...)> f, TArgs... args)
+          -> std::enable_if_t<sizeof...(TArgs) == 0, SFINAE> {
+        return f();
+      }
+    };
+
+    // Member functions . . .
+    template <typename TClass, typename TReturnType, typename... TArgs>
+    struct CppMemFnBase {
+      using arg_count   = std::integral_constant<unsigned, sizeof...(TArgs)>;
+      using return_type = TReturnType;
+      using params_type = Pack<TArgs...>;
+      using class_type  = TClass;
+
+      template <typename SFINAE = TReturnType>
+      auto operator()(TReturnType (TClass::*mem_fn)(TArgs...),
+                      TClass* ptr,
+                      TArgs... args)
+          -> std::enable_if_t<sizeof...(TArgs) != 0, SFINAE> {
+        return (ptr->*mem_fn)(args...);
+      }
+
+      template <typename SFINAE = TReturnType>
+      auto operator()(TReturnType (TClass::*mem_fn)(TArgs...),
+                      TClass* ptr,
+                      TArgs... args)
+          -> std::enable_if_t<sizeof...(TArgs) == 0, SFINAE> {
+        return (ptr->*mem_fn)();
+      }
+
+      template <typename SFINAE = TReturnType>
+      auto operator()(TReturnType (TClass::*mem_fn)(TArgs...) const,
+                      TClass* ptr,
+                      TArgs... args)
+          -> std::enable_if_t<sizeof...(TArgs) != 0, SFINAE> {
+        return (ptr->*mem_fn)(args...);
+      }
+
+      template <typename SFINAE = TReturnType>
+      auto operator()(TReturnType (TClass::*mem_fn)(TArgs...) const,
+                      TClass* ptr,
+                      TArgs... args)
+          -> std::enable_if_t<sizeof...(TArgs) == 0, SFINAE> {
+        return (ptr->*mem_fn)();
+      }
+    };
+
+    // Base declaration . . .
+    template <typename TSignature, typename = void>
+    struct CppFunction {};
+
+    // Free functions . . .
+    template <typename TReturnType, typename... TArgs>
+    struct CppFunction<TReturnType(TArgs...)>
+        : CppFunctionBase<TReturnType, TArgs...> {};
+
+    // Function pointers . . .
+    template <typename TReturnType, typename... TArgs>
+    struct CppFunction<TReturnType (*)(TArgs...)>
+        : CppFunctionBase<TReturnType, TArgs...> {};
+
+    // Member functions . . .
+    template <typename TClass, typename TReturnType, typename... TArgs>
+    struct CppFunction<TReturnType (TClass::*)(TArgs...)>
+        : CppMemFnBase<TClass, TReturnType, TArgs...> {};
+
+    // Const member functions
+    template <typename TClass, typename TReturnType, typename... TArgs>
+    struct CppFunction<TReturnType (TClass::*)(TArgs...) const>
+        : CppMemFnBase<TClass, TReturnType, TArgs...> {};
+
+    // std::function objects
+    template <typename TReturnType, typename... TArgs>
+    struct CppFunction<std::function<TReturnType(TArgs...)>>
+        : CppFunctionBase<TReturnType, TArgs...> {};
+
+    // Lambdas?
+    template <typename Func>
+    struct CppFunction<Func, std::enable_if_t<detail::is_lambda<Func>::value>>
+        : CppFunction<typename detail::strip_function_object<Func>::type> {};
+
+    // For convenience . . .
+    template <typename TFunctionType>
+    using returns_void
+        = std::is_void<typename CppFunction<TFunctionType>::return_type>;
+
+    template <typename TFunctionType>
+    using arg_count = typename CppFunction<TFunctionType>::arg_count;
+  }  // namespace detail
+}  // namespace gapbind14
+#endif  // INCLUDE_GAPBIND14_CPP_FN_HPP_

gap/pkg/semigroups/gapbind14/include/gapbind14/gap_include.hpp

@@ -0,0 +1,26 @@
+//
+// gapbind14 for GAP
+// Copyright (C) 2020 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 <https://www.gnu.org/licenses/>.
+//
+
+#ifndef INCLUDE_GAPBIND14_GAP_INCLUDE_HPP_
+#define INCLUDE_GAPBIND14_GAP_INCLUDE_HPP_
+
+extern "C" {
+#include "gap_all.h"
+}
+
+#endif  // INCLUDE_GAPBIND14_GAP_INCLUDE_HPP_