pythonknot 0.1.4__tar.gz → 0.1.9__tar.gz

pythonknot-0.1.9/MANIFEST.in

@@ -0,0 +1,4 @@
+include src/cpp_module/CMakeLists.txt
+recursive-include src/cpp_module/ginac/ *.*
+recursive-include src/cpp_module/cmake_file/ *.*
+recursive-include src/cpp_module/src/ *.*

pythonknot-0.1.9/PKG-INFO

@@ -0,0 +1,12 @@
+Metadata-Version: 2.1
+Name: pythonknot
+Version: 0.1.9
+Summary: pythonknot for knot theory calculation
+Home-page: 
+Author: yjianzhu
+Author-email: yjianzhu@mail.ustc.edu.cn
+License: UNKNOWN
+Platform: UNKNOWN
+
+Python Knot is a Python package for creating and manipulating knots and links, calculating knot invariants, and more.
+

pythonknot-0.1.9/setup.py

@@ -0,0 +1,151 @@
+import setuptools
+
+import os
+import re
+import subprocess
+import sys
+from pathlib import Path
+
+from setuptools import Extension, setup
+from setuptools.command.build_ext import build_ext
+
+# Convert distutils Windows platform specifiers to CMake -A arguments
+PLAT_TO_CMAKE = {
+    "win32": "Win32",
+    "win-amd64": "x64",
+    "win-arm32": "ARM",
+    "win-arm64": "ARM64",
+}
+
+
+# A CMakeExtension needs a sourcedir instead of a file list.
+# The name must be the _single_ output extension from the CMake build.
+# If you need multiple extensions, see scikit-build.
+class CMakeExtension(Extension):
+    def __init__(self, name: str, sourcedir: str = "") -> None:
+        super().__init__(name, sources=[])
+        self.sourcedir = os.fspath(Path(sourcedir).resolve())
+
+
+class CMakeBuild(build_ext):
+    def build_extension(self, ext: CMakeExtension) -> None:
+        # Must be in this form due to bug in .resolve() only fixed in Python 3.10+
+        ext_fullpath = Path.cwd() / self.get_ext_fullpath(ext.name)
+        extdir = ext_fullpath.parent.resolve()
+
+        # Using this requires trailing slash for auto-detection & inclusion of
+        # auxiliary "native" libs
+
+        debug = int(os.environ.get("DEBUG", 0)) if self.debug is None else self.debug
+        cfg = "Debug" if debug else "Release"
+
+        # CMake lets you override the generator - we need to check this.
+        # Can be set with Conda-Build, for example.
+        cmake_generator = os.environ.get("CMAKE_GENERATOR", "")
+
+        # Set Python_EXECUTABLE instead if you use PYBIND11_FINDPYTHON
+        # EXAMPLE_VERSION_INFO shows you how to pass a value into the C++ code
+        # from Python.
+        cmake_args = [
+            f"-DCMAKE_LIBRARY_OUTPUT_DIRECTORY={extdir}{os.sep}",
+            f"-DPYTHON_EXECUTABLE={sys.executable}",
+            f"-DCMAKE_BUILD_TYPE={cfg}",  # not used on MSVC, but no harm
+        ]
+        build_args = []
+        # Adding CMake arguments set as environment variable
+        # (needed e.g. to build for ARM OSx on conda-forge)
+        if "CMAKE_ARGS" in os.environ:
+            cmake_args += [item for item in os.environ["CMAKE_ARGS"].split(" ") if item]
+
+        # In this example, we pass in the version to C++. You might not need to.
+        cmake_args += [f"-DEXAMPLE_VERSION_INFO={self.distribution.get_version()}"]
+
+        if self.compiler.compiler_type != "msvc":
+            # Using Ninja-build since it a) is available as a wheel and b)
+            # multithreads automatically. MSVC would require all variables be
+            # exported for Ninja to pick it up, which is a little tricky to do.
+            # Users can override the generator with CMAKE_GENERATOR in CMake
+            # 3.15+.
+            if not cmake_generator or cmake_generator == "Ninja":
+                try:
+                    import ninja
+
+                    ninja_executable_path = Path(ninja.BIN_DIR) / "ninja"
+                    cmake_args += [
+                        "-GNinja",
+                        f"-DCMAKE_MAKE_PROGRAM:FILEPATH={ninja_executable_path}",
+                    ]
+                except ImportError:
+                    pass
+
+        else:
+            # Single config generators are handled "normally"
+            single_config = any(x in cmake_generator for x in {"NMake", "Ninja"})
+
+            # CMake allows an arch-in-generator style for backward compatibility
+            contains_arch = any(x in cmake_generator for x in {"ARM", "Win64"})
+
+            # Specify the arch if using MSVC generator, but only if it doesn't
+            # contain a backward-compatibility arch spec already in the
+            # generator name.
+            if not single_config and not contains_arch:
+                cmake_args += ["-A", PLAT_TO_CMAKE[self.plat_name]]
+
+            # Multi-config generators have a different way to specify configs
+            if not single_config:
+                cmake_args += [
+                    f"-DCMAKE_LIBRARY_OUTPUT_DIRECTORY_{cfg.upper()}={extdir}"
+                ]
+                build_args += ["--config", cfg]
+
+        if sys.platform.startswith("darwin"):
+            # Cross-compile support for macOS - respect ARCHFLAGS if set
+            archs = re.findall(r"-arch (\S+)", os.environ.get("ARCHFLAGS", ""))
+            if archs:
+                cmake_args += ["-DCMAKE_OSX_ARCHITECTURES={}".format(";".join(archs))]
+
+        # Set CMAKE_BUILD_PARALLEL_LEVEL to control the parallel build level
+        # across all generators.
+        if "CMAKE_BUILD_PARALLEL_LEVEL" not in os.environ:
+            # self.parallel is a Python 3 only way to set parallel jobs by hand
+            # using -j in the build_ext call, not supported by pip or PyPA-build.
+            if hasattr(self, "parallel") and self.parallel:
+                # CMake 3.12+ only.
+                build_args += [f"-j{self.parallel}"]
+
+        build_temp = Path(self.build_temp) / ext.name
+        if not build_temp.exists():
+            build_temp.mkdir(parents=True)
+
+        subprocess.run(
+            ["cmake", ext.sourcedir, *cmake_args], cwd=build_temp, check=True
+        )
+        subprocess.run(
+            ["cmake", "--build", ".", *build_args], cwd=build_temp, check=True
+        )
+
+setuptools.setup(
+    name="pythonknot",
+    version="0.1.9",
+    author="yjianzhu",
+    author_email="yjianzhu@mail.ustc.edu.cn",
+    description="pythonknot for knot theory calculation",
+    long_description="Python Knot is a Python package for creating and manipulating knots and links, calculating knot invariants, and more.",
+    #packages=setuptools.find_packages(),
+    url = "",
+    ext_modules=[CMakeExtension(name="pythonknot.alexander_poly", sourcedir="src/cpp_module/")],
+    cmdclass={"build_ext": CMakeBuild},
+
+    packages=setuptools.find_packages(where='src'), 
+    package_dir={"": "src"},
+    zip_safe=False,
+    install_requires=[
+        'numpy',
+        'scipy',
+        'pybind11[global]',
+        'rmsd',
+        'setuptools',
+        'wheel'
+    ],
+    include_package_data=True,
+)

pythonknot-0.1.9/src/cpp_module/cmake_file/FindCLN.cmake

@@ -0,0 +1,122 @@
+# CLN_FOUND		CLN has been successfully found
+# CLN_INCLUDE_DIR       the include directories
+# CLN_LIBRARIES         CLN library and its dependencies (if any)
+
+if (CLN_INCLUDE_DIR AND CLN_LIBRARIES)
+	set(CLN_FIND_QUIETLY TRUE)
+endif()
+
+function(_cl_get_version _out_major _out_minor _out_patch _cl_version_h)
+	file(STRINGS ${_cl_version_h} _cl_vinfo REGEX "^#define[\t ]+CL_VERSION_.*")
+	if (NOT _cl_vinfo)
+		message(FATAL_ERROR "include file ${_cl_version_h} does not exist")
+	endif()
+	string(REGEX REPLACE "^.*CL_VERSION_MAJOR[ \t]+([0-9]+).*" "\\1" ${_out_major} "${_cl_vinfo}")
+	string(REGEX REPLACE "^.*CL_VERSION_MINOR[ \t]+([0-9]+).*" "\\1" ${_out_minor} "${_cl_vinfo}")
+	string(REGEX REPLACE "^.*CL_VERSION_PATCHLEVEL[ \t]+([0-9]+).*" "\\1" ${_out_patch} "${_cl_vinfo}")
+	if (NOT ${_out_major} MATCHES "[0-9]+")
+		message(FATAL_ERROR "failed to determine CL_VERSION_MAJOR, "
+			            "expected a number, got ${${_out_major}}")
+	endif()
+	if (NOT ${_out_minor} MATCHES "[0-9]+")
+		message(FATAL_ERROR "failed to determine CL_VERSION_MINOR, "
+			            "expected a number, got ${${_out_minor}}")
+	endif()
+	if (NOT ${_out_patch} MATCHES "[0-9]+")
+		message(FATAL_ERROR "failed to determine CL_VERSION_PATCHLEVEL, "
+			            "expected a number, got ${${_out_patch}}")
+	endif()
+	message(STATUS "found CLN [${_cl_version_h}], version ${${_out_major}}.${${_out_minor}}.${${_out_patch}}")
+	set(${_out_major} ${${_out_major}} PARENT_SCOPE)
+	set(${_out_minor} ${${_out_minor}} PARENT_SCOPE)
+	set(${_out_patch} ${${_out_patch}} PARENT_SCOPE)
+endfunction()
+
+set(CLN_FOUND)
+set(CLN_INCLUDE_DIR)
+set(CLN_LIBRARIES)
+
+# include(FindPkgConfig)
+# if (PKG_CONFIG_FOUND)
+# 	pkg_check_modules(_cln cln)
+# endif()
+
+find_path(CLN_INCLUDE_DIR NAMES cln/cln.h
+			  HINTS ${_cln_INCLUDE_DIRS}
+				$ENV{CLN_DIR}/include
+				${CLN_DIR}/include
+				)
+find_library(CLN_LIBRARIES NAMES libcln cln
+			   HINTS ${_cln_LIBRARY_DIR}
+			         ${_cln_LIBRARY_DIRS}
+				 $ENV{CLN_DIR}/lib
+				 ${CLN_DIR}/lib
+				 )
+
+if (CLN_INCLUDE_DIR)
+	_cl_get_version(CLN_VERSION_MAJOR
+			CLN_VERSION_MINOR
+			CLN_VERSION_PATCHLEVEL
+			${CLN_INCLUDE_DIR}/cln/version.h)
+	set(CLN_VERSION ${CLN_VERSION_MAJOR}.${CLN_VERSION_MINOR}.${CLN_VERSION_PATCHLEVEL})
+	# Check if the version reported by pkg-config is the same
+	# as the one read from the header. This prevents us from
+	# picking the wrong version of CLN (say, if several versions
+	# are installed)
+	# if (_cln_FOUND AND NOT CLN_VERSION VERSION_EQUAL _cln_VERSION)
+	# 	if (NOT CLN_FIND_QUIETLY)
+	# 		message(ERROR "pkg-config and version.h disagree, "
+	# 			      "${_cln_VERSION} vs ${CLN_VERSION}, "
+	# 			      "please check your installation")
+	# 	endif()
+	# 	set(CLN_LIBRARIES CLN-NOTFOUND)
+	# 	set(CLN_INCLUDE_DIR CLN-NOTFOUND)
+	# 	set(CLN_LIBRARY_DIRS)
+	# 	set(CLN_VERSION)
+	# endif()
+endif()
+
+# Check if the version embedded into the library is the same as the one in the headers.
+if (CLN_INCLUDE_DIR AND CLN_LIBRARIES AND NOT CMAKE_CROSSCOMPILING)
+	include(CheckCXXSourceRuns)
+	set(_save_required_includes ${CMAKE_REQUIRED_INCLUDES})
+	set(_save_required_libraries ${CMAKE_REQUIRED_LIBRARIES})
+	set(CMAKE_REQUIRED_INCLUDES ${CMAKE_REQUIRED_INCLUDES} ${CLN_INCLUDE_DIR})
+	set(CMAKE_REQUIRED_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES} ${CLN_LIBRARIES})
+	check_cxx_source_runs("
+		#include <cln/version.h>
+		int main() {
+			return (CL_VERSION_MAJOR == cln::version_major) &&
+			       (CL_VERSION_MINOR == cln::version_minor) &&
+			       (CL_VERSION_PATCHLEVEL == cln::version_patchlevel) ? 0 : 1;
+		}
+		"
+		_cl_version_matches)
+	set(CMAKE_REQUIRED_LIBRARIES ${_save_required_libraries})
+	set(CMAKE_REQUIRED_INCLUDES ${_save_required_includes})
+	if (NOT _cl_version_matches)
+		if (NOT CLN_FIND_QUIETLY)
+			message(ERROR "header (version differs from the library one, "
+				      "please check your installation.")
+		endif()
+		set(CLN_INCLUDE_DIR CLN-NOTFOUND)
+		set(CLN_LIBRARIES CLN-NOTFOUND)
+		set(CLN_LIBRARY_DIRS)
+		set(CLN_VERSION)
+	endif()
+endif()
+
+if (CLN_LIBRARIES AND CLN_INCLUDE_DIR)
+	set(_cln_library_dirs)
+	foreach(_l ${CLN_LIBRARIES})
+		get_filename_component(_d "${_l}" PATH)
+		list(APPEND _cln_library_dirs "${_d}")
+	endforeach()
+	list(REMOVE_DUPLICATES _cln_library_dirs)
+	set(CLN_LIBRARY_DIRS ${_cln_library_dirs})
+endif()
+
+include(FindPackageHandleStandardArgs)
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(CLN REQUIRED_VARS CLN_LIBRARIES CLN_INCLUDE_DIR
+				      VERSION_VAR CLN_VERSION)
+

pythonknot-0.1.9/src/cpp_module/cmake_file/FindGINAC.cmake

@@ -0,0 +1,157 @@
+# GINAC_FOUND		CiNaC has been successfully found
+# GINAC_INCLUDE_DIRS    the include directories
+# GINAC_LIBRARIES       GiNaC library and its dependencies
+
+if (GINAC_INCLUDE_DIRS AND GINAC_LIBRARIES)
+	set(GINAC_FIND_QUIETLY TRUE)
+endif()
+
+function(_ginac_headers_version _out_major _out_minor _out_patch _version_h)
+	file(STRINGS ${_version_h} _ginac_vinfo REGEX "^#define[\t ]+GINACLIB_.*_VERSION.*")
+	if (NOT _ginac_vinfo)
+		message(FATAL_ERROR "include file ${_version_h} does not exist")
+	endif()
+	string(REGEX REPLACE "^.*GINACLIB_MAJOR_VERSION[ \t]+([0-9]+).*" "\\1" ${_out_major} "${_ginac_vinfo}")
+	string(REGEX REPLACE "^.*GINACLIB_MINOR_VERSION[ \t]+([0-9]+).*" "\\1" ${_out_minor} "${_ginac_vinfo}")
+	string(REGEX REPLACE "^.*GINACLIB_MICRO_VERSION[ \t]+([0-9]+).*" "\\1" ${_out_patch} "${_ginac_vinfo}")
+	if (NOT ${_out_major} MATCHES "[0-9]+")
+		message(FATAL_ERROR "failed to determine GINACLIB_MAJOR_VERSION, "
+			            "expected a number, got ${${_out_major}}")
+	endif()
+	if (NOT ${_out_minor} MATCHES "[0-9]+")
+		message(FATAL_ERROR "failed to determine GINACLIB_MINOR_VERSION, "
+			            "expected a number, got ${${_out_minor}}")
+	endif()
+	if (NOT ${_out_patch} MATCHES "[0-9]+")
+		message(FATAL_ERROR "failed to determine GINACLIB_MINOR_VERSION, "
+			            "expected a number, got ${${_out_patch}}")
+	endif()
+	set(${_out_major} ${${_out_major}} PARENT_SCOPE)
+	set(${_out_minor} ${${_out_minor}} PARENT_SCOPE)
+	set(${_out_patch} ${${_out_patch}} PARENT_SCOPE)
+endfunction()
+
+set(GINAC_FOUND)
+set(GINAC_INCLUDE_DIRS)
+set(GINAC_LIBRARIES)
+set(GINAC_LIBRARY_DIRS)
+set(GINAC_VERSION)
+
+include(FindPkgConfig)
+find_package(CLN 1.2.2)
+
+if (PKG_CONFIG_FOUND)
+	pkg_check_modules(_ginac ginac)
+else()
+	set(_ginac_LIBRARIES ginac cln gmp)
+endif()
+
+if (NOT CLN_FOUND)
+	set(GINAC_INCLUDE_DIRS GINAC-NOTFOUND)
+	set(GINAC_LIBRARIES GINAC-NOTFOUND)
+else()
+	find_path(_ginac_include_dir NAMES ginac/ginac.h
+				     HINTS ${_ginac_INCLUDE_DIRS}
+				           $ENV{GINAC_DIR}/include)
+	if (_ginac_include_dir)
+		set(GINAC_INCLUDE_DIRS ${_ginac_include_dir}
+				       ${_ginac_INCLUDE_DIRS}
+				       ${CLN_INCLUDE_DIR})
+		list(REMOVE_DUPLICATES GINAC_INCLUDE_DIRS)
+	else()
+		set(GINAC_INCLUDE_DIRS GINAC-NOTFOUND)
+		set(GINAC_LIBRARIES GINAC-NOTFOUND)
+		if (NOT GINAC_FIND_QUIETLY)
+			message(ERROR "couldn't find ginac.h")
+		endif()
+	endif()
+
+	if (GINAC_INCLUDE_DIRS)
+		find_library(_ginac_lib NAMES libginac ginac
+					HINTS ${_ginac_LIBRARY_DIRS}
+					      $ENV{GINAC_DIR}/lib)
+		if (_ginac_lib)
+			set(GINAC_LIBRARIES ${_ginac_lib} ${CLN_LIBRARIES})
+			list(REMOVE_DUPLICATES GINAC_LIBRARIES)
+		else()
+			set(GINAC_LIBRARIES GINAC-NOTFOUND)
+			set(GINAC_INCLUDE_DIRS GINAC-NOTFOUND)
+			if (NOT GINAC_FIND_QUIETLY)
+				message(ERROR "couldn't find libginac")
+			endif()
+		endif()
+	endif()
+endif()
+
+if (GINAC_INCLUDE_DIRS)
+	_ginac_headers_version(GINACLIB_MAJOR_VERSION
+			       GINACLIB_MINOR_VERSION
+			       GINACLIB_MICRO_VERSION
+			       ${_ginac_include_dir}/ginac/version.h)
+	set(GINAC_VERSION ${GINACLIB_MAJOR_VERSION}.${GINACLIB_MINOR_VERSION}.${GINACLIB_MICRO_VERSION})
+	# Check if the version reported by pkg-config is the same
+	# as the one read from the header. This prevents us from
+	# picking the wrong version of GINAC (say, if several versions
+	# are installed)
+	if (PKG_CONFIG_FOUND AND NOT GINAC_VERSION VERSION_EQUAL _ginac_VERSION)
+		if (NOT CLN_FIND_QUIETLY)
+			message(ERROR "pkg-config and version.h disagree, "
+				      "${_ginac_VERSION} vs ${GINAC_VERSION}, "
+				      "please check your installation")
+		endif()
+		set(GINAC_LIBRARIES GINAC-NOTFOUND)
+		set(GINAC_INCLUDE_DIRS GINAC-NOTFOUND)
+		set(GINAC_LIBRARY_DIRS)
+		set(GINAC_VERSION)
+	endif()
+endif()
+
+# Check if the version embedded into the library is the same as the one in the headers.
+if (GINAC_INCLUDE_DIRS AND GINAC_LIBRARIES AND NOT CMAKE_CROSSCOMPILING)
+	include(CheckCXXSourceRuns)
+	set(_save_required_includes ${CMAKE_REQUIRED_INCLUDES})
+	set(_save_required_libraries ${CMAKE_REQUIRED_LIBRARIES})
+	set(CMAKE_REQUIRED_INCLUDES ${CMAKE_REQUIRED_INCLUDES} ${GINAC_INCLUDE_DIRS})
+	set(CMAKE_REQUIRED_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES} ${GINAC_LIBRARIES})
+	check_cxx_source_runs("
+		#include <ginac/version.h>
+		#include <cln/version.h>
+		#include <stdio.h>
+		int main() {
+			return (CL_VERSION_MAJOR == cln::version_major) &&
+			       (CL_VERSION_MINOR == cln::version_minor) &&
+			       (CL_VERSION_PATCHLEVEL == cln::version_patchlevel) &&
+			       (GINACLIB_MAJOR_VERSION == GiNaC::version_major) &&
+			       (GINACLIB_MINOR_VERSION == GiNaC::version_minor) &&
+			       (GINACLIB_MICRO_VERSION == GiNaC::version_micro) ? 0 : 1;
+		}
+		"
+		_ginac_version_matches)
+	set(CMAKE_REQUIRED_LIBRARIES ${_save_required_libraries})
+	set(CMAKE_REQUIRED_INCLUDES ${_save_required_includes})
+	if (NOT _ginac_version_matches)
+		if (NOT GINAC_FIND_QUIETLY)
+			message(ERROR "header version differs from the library one, "
+				      "please check your installation.")
+		endif()
+		set(GINAC_INCLUDE_DIRS GINAC-NOTFOUND)
+		set(GINAC_LIBRARIES GINAC_NOTFOUND)
+		set(GINAC_LIBRARY_DIRS)
+		set(GINAC_VERSION)
+	endif()
+endif()
+
+if (GINAC_LIBRARIES AND GINAC_INCLUDE_DIRS)
+	set(_ginac_library_dirs)
+	foreach(_l ${GINAC_LIBRARIES})
+		get_filename_component(_d "${_l}" PATH)
+		list(APPEND _ginac_library_dirs "${_d}")
+	endforeach()
+	list(REMOVE_DUPLICATES _ginac_library_dirs)
+	set(GINAC_LIBRARY_DIRS ${_ginac_library_dirs})
+endif()
+
+include(FindPackageHandleStandardArgs)
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(GiNaC REQUIRED_VARS GINAC_LIBRARIES GINAC_INCLUDE_DIRS
+					VERSION_VAR GINAC_VERSION)
+

pythonknot-0.1.9/src/cpp_module/cmake_file/FindGMP.cmake

@@ -0,0 +1,76 @@
+# Try to find the GMP library
+# https://gmplib.org/
+#
+# This module supports requiring a minimum version, e.g. you can do
+#   find_package(GMP 6.0.0)
+# to require version 6.0.0 to newer of GMP.
+#
+# Once done this will define
+#
+#  GMP_FOUND - system has GMP lib with correct version
+#  GMP_INCLUDES - the GMP include directory
+#  GMP_LIBRARIES - the GMP library
+#  GMP_VERSION - GMP version
+#
+# Copyright (c) 2016 Jack Poulson, <jack.poulson@gmail.com>
+# Redistribution and use is allowed according to the terms of the BSD license.
+
+find_path(GMP_INCLUDES NAMES gmp.h PATHS $ENV{GMPDIR} ${INCLUDE_INSTALL_DIR})
+
+# Set GMP_FIND_VERSION to 5.1.0 if no minimum version is specified
+if(NOT GMP_FIND_VERSION)
+  if(NOT GMP_FIND_VERSION_MAJOR)
+    set(GMP_FIND_VERSION_MAJOR 5)
+  endif()
+  if(NOT GMP_FIND_VERSION_MINOR)
+    set(GMP_FIND_VERSION_MINOR 1)
+  endif()
+  if(NOT GMP_FIND_VERSION_PATCH)
+    set(GMP_FIND_VERSION_PATCH 0)
+  endif()
+  set(GMP_FIND_VERSION
+    "${GMP_FIND_VERSION_MAJOR}.${GMP_FIND_VERSION_MINOR}.${GMP_FIND_VERSION_PATCH}")
+endif()
+
+message("GMP_INCLUDES=${GMP_INCLUDES}")
+if(GMP_INCLUDES)
+  # Since the GMP version macros may be in a file included by gmp.h of the form
+  # gmp-.*[_]?.*.h (e.g., gmp-x86_64.h), we search each of them.
+  file(GLOB GMP_HEADERS "${GMP_INCLUDES}/gmp.h" "${GMP_INCLUDES}/gmp-*.h")
+  foreach(gmp_header_filename ${GMP_HEADERS})
+    file(READ "${gmp_header_filename}" _gmp_version_header)
+    string(REGEX MATCH
+      "define[ \t]+__GNU_MP_VERSION[ \t]+([0-9]+)" _gmp_major_version_match
+      "${_gmp_version_header}")
+    if(_gmp_major_version_match)
+      set(GMP_MAJOR_VERSION "${CMAKE_MATCH_1}")
+      string(REGEX MATCH "define[ \t]+__GNU_MP_VERSION_MINOR[ \t]+([0-9]+)"
+        _gmp_minor_version_match "${_gmp_version_header}")
+      set(GMP_MINOR_VERSION "${CMAKE_MATCH_1}")
+      string(REGEX MATCH "define[ \t]+__GNU_MP_VERSION_PATCHLEVEL[ \t]+([0-9]+)"
+        _gmp_patchlevel_version_match "${_gmp_version_header}")
+      set(GMP_PATCHLEVEL_VERSION "${CMAKE_MATCH_1}")
+      set(GMP_VERSION
+        ${GMP_MAJOR_VERSION}.${GMP_MINOR_VERSION}.${GMP_PATCHLEVEL_VERSION})
+    endif()
+  endforeach()
+
+  # Check whether found version exists and exceeds the minimum requirement
+  if(NOT GMP_VERSION)
+    set(GMP_VERSION_OK FALSE)
+    message(STATUS "GMP version was not detected")
+  elseif(${GMP_VERSION} VERSION_LESS ${GMP_FIND_VERSION})
+    set(GMP_VERSION_OK FALSE)
+    message(STATUS "GMP version ${GMP_VERSION} found in ${GMP_INCLUDES}, "
+                   "but at least version ${GMP_FIND_VERSION} is required")
+  else()
+    set(GMP_VERSION_OK TRUE)
+  endif()
+endif()
+
+find_library(GMP_LIBRARIES gmp PATHS $ENV{GMPDIR} ${LIB_INSTALL_DIR})
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(GMP DEFAULT_MSG
+                                  GMP_INCLUDES GMP_LIBRARIES GMP_VERSION_OK)
+mark_as_advanced(GMP_INCLUDES GMP_LIBRARIES)

pythonknot-0.1.9/src/cpp_module/cmake_file/FindPythonAnaconda.cmake

@@ -0,0 +1,98 @@
+# tested on OSX Yosemite and Ubuntu 14.04 LTS
+# handle anaconda dependencies
+cmake_minimum_required(VERSION 3.7)
+
+option(ANACONDA_PYTHON_VERBOSE "Anaconda dependency info" OFF)
+
+if(NOT CMAKE_FIND_ANACONDA_PYTHON_INCLUDED)
+  set(CMAKE_FIND_ANACONDA_PYTHON_INCLUDED 1)
+
+  # find anaconda installation
+  set(_cmd conda info --root)
+  execute_process(
+    COMMAND ${_cmd}
+    RESULT_VARIABLE _r
+    OUTPUT_VARIABLE _o
+    ERROR_VARIABLE _e
+    OUTPUT_STRIP_TRAILING_WHITESPACE
+    ERROR_STRIP_TRAILING_WHITESPACE
+    )
+  
+  if(ANACONDA_PYTHON_VERBOSE)
+    message("Executing conda info --root")
+    message("_r = ${_r}")
+    message("_o = ${_o}")
+    message("_e = ${_e}")
+  endif()
+
+  IF(IS_DIRECTORY ${_o})
+     set(ANACONDA_PYTHON_FOUND True)
+  endif()
+
+  if(ANACONDA_PYTHON_FOUND)
+    set( ANACONDA_PYTHON_DIR ${_o} )
+    message( "Found anaconda root directory ${ANACONDA_PYTHON_DIR}" )
+
+    # find python version
+    #
+    set(_cmd python --version)
+    execute_process(
+      COMMAND ${_cmd}
+      RESULT_VARIABLE _r
+      OUTPUT_VARIABLE _o
+      ERROR_VARIABLE _e
+      OUTPUT_STRIP_TRAILING_WHITESPACE
+      ERROR_STRIP_TRAILING_WHITESPACE
+      )
+    
+    if(ANACONDA_PYTHON_VERBOSE)
+      message("Executing python --version")
+      message("_r = ${_r}")
+      message("_o = ${_o}")
+      message("_e = ${_e}")
+    endif()
+    
+    string (REGEX MATCH "Python ([0-9]+)[.]([0-9]+)[.]([0-9]+)" _py_version_found "${_e}")
+    set( _py_version_major ${CMAKE_MATCH_1} )
+    set( _py_version_minor ${CMAKE_MATCH_2} )
+    set( _py_version_patch ${CMAKE_MATCH_3} )
+    set( ANACONDA_PYTHON_VERSION ${_py_version_major}.${_py_version_minor} )
+
+    
+    if( ${_py_version_major} MATCHES 2 )
+      set( _py_ext "")
+    else()
+      set( _py_ext "m")
+    endif()
+
+    set(_py_id "python${ANACONDA_PYTHON_VERSION}${_py_ext}")
+    
+    if( NOT DEFINED ENV{CONDA_DEFAULT_ENV} )
+      set( env_CONDA_DEFAULT_ENV "root" )
+      message( WARNING "Could not find anaconda environment setting; using default root" )
+    else()
+      set( env_CONDA_DEFAULT_ENV $ENV{CONDA_DEFAULT_ENV} )
+    endif()
+
+    message( "Using anaconda ${env_CONDA_DEFAULT_ENV} environment" )
+    if( env_CONDA_DEFAULT_ENV STREQUAL "root" )
+      set(PYTHON_INCLUDE_DIR "${ANACONDA_PYTHON_DIR}/include/${_py_id}" CACHE INTERNAL "")
+      set(PYTHON_LIBRARY "${ANACONDA_PYTHON_DIR}/lib/lib${_py_id}${CMAKE_SHARED_LIBRARY_SUFFIX}" CACHE INTERNAL "")
+    else()
+      set(PYTHON_INCLUDE_DIR "${ANACONDA_PYTHON_DIR}/envs/${env_CONDA_DEFAULT_ENV}/include/${_py_id}" CACHE INTERNAL "")
+      set(PYTHON_LIBRARY "${ANACONDA_PYTHON_DIR}/envs/${env_CONDA_DEFAULT_ENV}/lib/lib${_py_id}${CMAKE_SHARED_LIBRARY_SUFFIX}" CACHE INTERNAL "")
+    endif()
+    
+    set(PYTHON_INCLUDE_DIRS "${PYTHON_INCLUDE_DIR}")
+    set(PYTHON_LIBRARIES "${PYTHON_LIBRARY}")
+
+    set(FOUND_PYTHONLIBS TRUE)
+  else()
+    message( "Not found: anaconda root directory..." )    
+    message( "Trying system python install..." )    
+    FindPythonLibs()
+  endif()
+  
+  message( "PYTHON_INCLUDE_DIR = ${PYTHON_INCLUDE_DIR}")
+  message( "PYTHON_LIBRARY = ${PYTHON_LIBRARY}")
+endif()

pythonknot-0.1.9/src/cpp_module/ginac/.git/hooks/applypatch-msg.sample

@@ -0,0 +1,15 @@
+#!/bin/sh
+#
+# An example hook script to check the commit log message taken by
+# applypatch from an e-mail message.
+#
+# The hook should exit with non-zero status after issuing an
+# appropriate message if it wants to stop the commit.  The hook is
+# allowed to edit the commit message file.
+#
+# To enable this hook, rename this file to "applypatch-msg".
+
+. git-sh-setup
+commitmsg="$(git rev-parse --git-path hooks/commit-msg)"
+test -x "$commitmsg" && exec "$commitmsg" ${1+"$@"}
+:

pythonknot-0.1.9/src/cpp_module/ginac/.git/hooks/commit-msg.sample

@@ -0,0 +1,24 @@
+#!/bin/sh
+#
+# An example hook script to check the commit log message.
+# Called by "git commit" with one argument, the name of the file
+# that has the commit message.  The hook should exit with non-zero
+# status after issuing an appropriate message if it wants to stop the
+# commit.  The hook is allowed to edit the commit message file.
+#
+# To enable this hook, rename this file to "commit-msg".
+
+# Uncomment the below to add a Signed-off-by line to the message.
+# Doing this in a hook is a bad idea in general, but the prepare-commit-msg
+# hook is more suited to it.
+#
+# SOB=$(git var GIT_AUTHOR_IDENT | sed -n 's/^\(.*>\).*$/Signed-off-by: \1/p')
+# grep -qs "^$SOB" "$1" || echo "$SOB" >> "$1"
+
+# This example catches duplicate Signed-off-by lines.
+
+test "" = "$(grep '^Signed-off-by: ' "$1" |
+	 sort | uniq -c | sed -e '/^[ 	]*1[ 	]/d')" || {
+	echo >&2 Duplicate Signed-off-by lines.
+	exit 1
+}