pyrfl 0.1.0__tar.gz

pyrfl-0.1.0/BUILD

@@ -0,0 +1,24 @@
+genrule(
+    name = "rfl_wheel",
+    srcs = [
+        "pyproject.toml",
+        "CMakeLists.txt",
+        "python_bindings/bindings.cpp",
+        "python_bindings/CMakeLists.txt",
+        # Sub-package source files (exported via wheel_srcs filegroups)
+        "//src/RFL/core:wheel_srcs",
+        "//src/RFL/legacy:wheel_srcs",
+    ] + glob(["cmake/*.cmake"]),
+    outs = ["dist"],
+    cmd = [
+        # Set up build tools in a venv
+        "python3 -m venv _venv",
+        "source _venv/bin/activate",
+        "pip install --quiet --cache-dir /tmp/pip_cache --upgrade pip",
+        "pip install --quiet --cache-dir /tmp/pip_cache build scikit-build-core pybind11 cmake ninja",
+        # Build the wheel directly into the output directory
+        "python -m build --wheel --outdir $OUTS $PKG_DIR",
+    ],
+    timeout = 1800, # 30 minutes to allow for C++ compilation
+    visibility = ["PUBLIC"],
+)

pyrfl-0.1.0/CMakeLists.txt

@@ -0,0 +1,105 @@
+cmake_minimum_required(VERSION 3.20...3.31)
+
+
+project(
+        RFL
+        VERSION 0.1.0
+        DESCRIPTION
+        "Random Fuzzy Library (RFL) - A library for Markov Chain Monte Carlo simulations of Finite Random Non-commutative geometries."
+        LANGUAGES CXX)
+
+set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+
+if(CMAKE_PROJECT_NAME STREQUAL PROJECT_NAME)
+        set(CMAKE_CXX_STANDARD 17)
+        set(CMAKE_CXX_STANDARD_REQUIRED ON)
+        set(CMAKE_CXX_EXTENSIONS OFF)
+
+        # Nicely supports folders in IDEs
+        set_property(GLOBAL PROPERTY USE_FOLDERS ON)
+        enable_testing()
+
+        add_compile_options(-Wall -Wextra -Wpedantic)
+        if(NOT SKBUILD)
+            add_compile_options(-fsanitize=address)
+            add_link_options(-fsanitize=address)
+        endif()
+endif()
+
+set(CPACK_PROJECT_NAME ${PROJECT_NAME})
+set(CPACK_PROJECT_VERSION ${PROJECT_VERSION})
+include(CPack)
+
+# Include ccache to speed up rebuild times.
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
+include(Ccache)
+
+option(${PROJECT_NAME}_ENABLE_CODE_COVERAGE "Enable code coverage through GCC." ON)
+
+# Include Please's output directory
+include(GitRoot)
+
+if(CMAKE_PROJECT_NAME STREQUAL PROJECT_NAME AND NOT SKBUILD)
+    include(Doxygen)
+    if(DOXYGEN_FOUND)
+        doxygen_add_docs(doxygen
+                ${PROJECT_SOURCE_DIR}/README.md
+                ${PROJECT_SOURCE_DIR}/core
+                ${PROJECT_SOURCE_DIR}/examples
+                COMMENT "Generate documentation for entire project")
+    endif()
+endif()
+
+# GSL is included with Armadillo above, but we need more.
+include(Armadillo)
+include(GSL)
+if(NOT SKBUILD)
+    include(LoadGoogleTest)
+endif()
+
+# Build legacy RFL library
+set(legacy_RFL_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/legacy")
+set(legacy_RFL_INCLUDE_DIR "${legacy_RFL_SOURCE_DIR}/include")
+add_subdirectory(${legacy_RFL_SOURCE_DIR}/source)
+
+# Add core RFL library
+set(core_RFL_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/core")
+set(core_RFL_INCLUDE_DIR "${core_RFL_SOURCE_DIR}")
+add_subdirectory(${core_RFL_SOURCE_DIR})
+
+# Add aliases for consumers
+add_library(RFL::core ALIAS rfl_core)
+add_library(RFL::rfl ALIAS rfl_core)
+add_library(RFL::legacy ALIAS rfl_legacy)
+
+# Add tests if building tests.
+if(CMAKE_PROJECT_NAME STREQUAL PROJECT_NAME AND NOT SKBUILD)
+        add_subdirectory(${legacy_RFL_SOURCE_DIR}/tests)
+endif()
+
+if(SKBUILD)
+    set(BUILD_PYTHON_BINDINGS_DEFAULT ON)
+else()
+    set(BUILD_PYTHON_BINDINGS_DEFAULT OFF)
+endif()
+option(BUILD_PYTHON_BINDINGS "Build Python bindings via pybind11" ${BUILD_PYTHON_BINDINGS_DEFAULT})
+if(BUILD_PYTHON_BINDINGS)
+    include(FetchContent)
+
+    # Fetch carma (NumPy/Armadillo bridge)
+    FetchContent_Declare(
+        carma
+        GIT_REPOSITORY https://github.com/RUrlus/carma.git
+        GIT_TAG        v0.8.0
+    )
+
+    # Fetch pybind11
+    FetchContent_Declare(
+        pybind11
+        GIT_REPOSITORY https://github.com/pybind/pybind11.git
+        GIT_TAG        v2.13.1
+    )
+    FetchContent_MakeAvailable(carma pybind11)
+
+    add_subdirectory(python_bindings)
+endif()

pyrfl-0.1.0/PKG-INFO

@@ -0,0 +1,13 @@
+Metadata-Version: 2.2
+Name: pyrfl
+Version: 0.1.0
+Summary: Random Fuzzy Library (RFL) - MCMC simulations of Finite Random Non-commutative geometries
+Author: Paul Druce, Mauro D'Arcangelo
+Requires-Python: >=3.8
+Requires-Dist: numpy>=1.20
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Provides-Extra: dev
+Requires-Dist: jupyter; extra == "dev"
+Requires-Dist: nbformat; extra == "dev"
+

pyrfl-0.1.0/README.md

@@ -0,0 +1,40 @@
+# RFL Documentation
+
+This directory contains the source code for the original RFL library created by Mauro D'arcangelo and its modern
+implementation.
+
+The aim is to deprecate Mauro's implementation (Original RFL) for version 1.0 of this project.
+The code will be preserved under a protected branch on this repository.
+
+## Original RFL
+
+The source code for the original library is in `./legacy`.
+The library defines two classes: `Cliff` and `Geom24`, defined in `legacy/include/Cliff.hpp` and `legacy/include/Geom24.hpp`,
+respectively.
+
+- `Cliff` is responsible for creating the 'gamma matrices' for a specific Clifford module.
+  The general way to specify a Clifford module is by setting two positive integers $p$ and $q$.
+- `Geom24` is the main Class for this library. It is responsible for setting up and running the simulation.
+
+The original RFL code inherently uses an action of the form:
+
+$$S(D) = g_2 \text{Tr}(D^2) + g_4 \text{Tr}(D^4)$$
+
+where $g_2$ and $g_4$ are real numbers. This action is the origin of the name of the class `Geom24` as the action
+contains the quadratic ($D^2$) and quartic ($D^4$) traces of the Dirac operator.
+
+## Core RFL
+
+The modern implementation of RFL refactors the original RFL source code to make it modular and extensible without compromising
+performance.
+The modern source code is found in `./core`.
+
+This refactoring allows for better testing and more flexibility for library users.
+It is constantly being developed, and any improvements or enhancements are welcome. Please leave an issue on the GitHub
+repo.
+
+The high performance that Mauro's original implementation strived to develop has been preserved.
+To ensure that this performance does not degrade, a unit test that captures the difference between the original and new
+implementations.
+This test requires that the new implementation is no more than 5% slower to run the same simulation in each
+implementation.

pyrfl-0.1.0/cmake/Armadillo.cmake

@@ -0,0 +1,28 @@
+# The purpose of this Cmake module is to find the Armadillo library.
+# This library may be installed by the system/user in the standard install
+# location, or it might be installed to a custom location by the build system
+# Please.
+set(LOCAL_ARMADILLO_INSTALL_DIR "${GIT_PROJECT_ROOT}/plz-out/gen/vendors/armadillo-12.6.6/install")
+
+# Create local variable which stores the files to search for
+message(DEBUG "Checking for local Armadillo library at ${LOCAL_ARMADILLO_INSTALL_DIR}")
+
+if(EXISTS "${LOCAL_ARMADILLO_INSTALL_DIR}/lib/libarmadillo${CMAKE_SHARED_LIBRARY_SUFFIX}"
+    OR EXISTS "${LOCAL_ARMADILLO_INSTALL_DIR}/lib/libarmadillo${CMAKE_STATIC_LIBRARY_SUFFIX}")
+    message(STATUS "Using local Armadillo library at ${LOCAL_ARMADILLO_INSTALL_DIR}")
+    set(ARMADILLO_LIBRARIES "${LOCAL_ARMADILLO_INSTALL_DIR}/lib/libarmadillo${CMAKE_SHARED_LIBRARY_SUFFIX}")
+    set(ARMADILLO_INCLUDE_DIRS "${LOCAL_ARMADILLO_INSTALL_DIR}/include")
+
+    set(ARMADILLO_FOUND TRUE)
+    include_directories(${ARMADILLO_INCLUDE_DIRS})
+    link_directories(${ARMADILLO_LIBRARIES})
+else()
+    message(STATUS "Using system Armadillo library")
+    find_package(Armadillo REQUIRED)
+    include_directories(${ARMADILLO_INCLUDE_DIRS})
+endif()
+
+# If the GSL package is not found, stop with an error
+if(NOT ARMADILLO_FOUND)
+    message(FATAL_ERROR "Armadillo library not found")
+endif()

pyrfl-0.1.0/cmake/Ccache.cmake

@@ -0,0 +1,5 @@
+find_program(CCACHE_PROGRAM ccache)
+if(CCACHE_PROGRAM)
+    set(CMAKE_CXX_COMPILER_LAUNCHER "${CCACHE_PROGRAM}")
+    set(CMAKE_CUDA_COMPILER_LAUNCHER "${CCACHE_PROGRAM}") # CMake 3.9+
+endif()

pyrfl-0.1.0/cmake/Doxygen.cmake

@@ -0,0 +1,51 @@
+find_package(Doxygen OPTIONAL_COMPONENTS dot)
+
+if(DOXYGEN_FOUND)
+    set(DOXYGEN_GENERATE_HTML YES)
+    set(DOXYGEN_HTML_OUTPUT
+            ${PROJECT_SOURCE_DIR}/RFL_docs)
+    set(DOXYGEN_USE_MDFILE_AS_MAINPAGE
+            "${CMAKE_CURRENT_SOURCE_DIR}/README.md")
+
+    # Settings for Inheritance Diagram etc.
+    set(DOXYGEN_EXTRACT_ALL YES)
+    set(DOXYGEN_CLASS_DIAGRAMS YES)
+    set(DOXYGEN_HIDE_UNDOC_RELATIONS NO)
+    set(DOXYGEN_CALL_GRAPH YES)
+    set(DOXYGEN_CALLER_GRAPH YES)
+    if(DOXYGEN_DOT_FOUND)
+        set(DOXYGEN_HAVE_DOT             YES)
+    endif()
+    set(DOXYGEN_CLASS_GRAPH          YES)
+    set(DOXYGEN_COLLABORATION_GRAPH  NO)
+    set(DOXYGEN_UML_LOOK             YES)
+    set(DOXYGEN_UML_LIMIT_NUM_FIELDS 50)
+    set(DOXYGEN_TEMPLATE_RELATIONS   YES)
+    set(DOXYGEN_DOT_GRAPH_MAX_NODES  100)
+    set(DOXYGEN_MAX_DOT_GRAPH_DEPTH  0)
+    set(DOXYGEN_DOT_TRANSPARENT      YES)
+    set(DOXYGEN_INTERACTIVE_SVG  YES)
+    set(DOXYGEN_USE_MATHJAX YES)
+    set(DOXYGEN_SOURCE_BROWSER YES)
+
+    # Exclude tests from documentation
+    set(DOXYGEN_EXCLUDE_PATTERNS */tests/*)
+endif()
+
+
+function(Doxygen input output)
+    if (NOT DOXYGEN_FOUND)
+        add_custom_target(doxygen COMMAND false
+                COMMENT "Doxygen not found")
+        return()
+    endif()
+    set(DOXYGEN_GENERATE_HTML YES)
+    set(DOXYGEN_HTML_OUTPUT
+            ${PROJECT_BINARY_DIR}/${output})
+
+
+    doxygen_add_docs(${output}
+            ${input}
+            COMMENT "Generate HTML documentation"
+            )
+endfunction()

pyrfl-0.1.0/cmake/GSL.cmake

@@ -0,0 +1,33 @@
+# Set the path to the local GSL installation
+set(LOCAL_GSL_PATH "${GIT_PROJECT_ROOT}/plz-out/gen/vendors/gsl-2.8/install")
+
+# Check if the GSL library is available in the local installation path
+message(DEBUG "Checking for local GSL library at ${LOCAL_GSL_PATH}")
+
+if(EXISTS "${LOCAL_GSL_PATH}/lib/libgsl${CMAKE_STATIC_LIBRARY_SUFFIX}"
+    OR EXISTS "${LOCAL_GSL_PATH}/lib/libgsl${CMAKE_SHARED_LIBRARY_SUFFIX}")
+    message(STATUS "Using local GSL library at ${LOCAL_GSL_PATH}")
+
+    # Set GSL include and library paths
+    set(GSL_INCLUDE_DIR "${LOCAL_GSL_PATH}/include")
+    set(GSL_LIBRARIES "${LOCAL_GSL_PATH}/lib/libgsl${CMAKE_STATIC_LIBRARY_SUFFIX}")
+
+    # Set GSL_FOUND to true as the library is locally found
+    set(GSL_FOUND TRUE)
+
+    # Add the GSL include directory to the include path
+    include_directories(${GSL_INCLUDE_DIR})
+
+    # Link the local GSL library
+    link_directories(${GSL_LIBRARIES})
+else()
+    # Fallback to system GSL library using find_package
+    message(STATUS "Using system GSL library")
+    find_package(GSL REQUIRED)
+    include_directories(${GSL_INCLUDE_DIRS})
+endif()
+
+# If the GSL package is not found, stop with an error
+if(NOT GSL_FOUND)
+    message(FATAL_ERROR "GSL library not found")
+endif()

pyrfl-0.1.0/cmake/GitRoot.cmake

@@ -0,0 +1,6 @@
+execute_process(
+    COMMAND git rev-parse --show-toplevel
+    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+    OUTPUT_VARIABLE GIT_PROJECT_ROOT
+    OUTPUT_STRIP_TRAILING_WHITESPACE
+)

pyrfl-0.1.0/cmake/LoadGoogleTest.cmake

@@ -0,0 +1,13 @@
+# Get GoogleTest
+include(FetchContent)
+FetchContent_Declare(
+    googletest
+    GIT_REPOSITORY https://github.com/google/googletest.git
+    GIT_TAG release-1.12.0)
+
+# For Windows: Prevent overriding the parent project's compiler/linker settings
+set(gtest_force_shared_crt
+    ON
+    CACHE BOOL "" FORCE)
+FetchContent_MakeAvailable(googletest)
+include(GoogleTest)

pyrfl-0.1.0/cmake/Please.cmake

@@ -0,0 +1,8 @@
+# Set the output directory for vendors
+set(VENDOR_OUTPUT_DIR "${GIT_PROJECT_ROOT}/plz-out/gen/vendors/")
+
+# Add the vendor output directory to the CMake prefix path
+list(INSERT CMAKE_PREFIX_PATH 0 "${VENDOR_OUTPUT_DIR}")
+
+# Print the CMake prefix path for debugging
+message(STATUS "CMAKE_PREFIX_PATH: ${CMAKE_PREFIX_PATH}")

pyrfl-0.1.0/core/BUILD

@@ -0,0 +1,41 @@
+cc_library(
+    name = "rfl",
+    srcs = [
+        "BarrettGlaser/Action.cpp",
+        "BarrettGlaser/Hamiltonian.cpp",
+        "BarrettGlaser/Metropolis.cpp",
+        "Clifford.cpp",
+        "DiracOperator.cpp",
+        "IDiracOperatorDerivatives.cpp",
+        "Simulation.cpp",
+    ],
+    hdrs = [
+        "BarrettGlaser/Action.hpp",
+        "BarrettGlaser/Hamiltonian.hpp",
+        "BarrettGlaser/Metropolis.hpp",
+        "Clifford.hpp",
+        "DiracOperator.hpp",
+        "GslRng.hpp",
+        "IAction.hpp",
+        "IAlgorithm.hpp",
+        "IDiracOperator.hpp",
+        "IDiracOperatorDerivatives.hpp",
+        "IRng.hpp",
+        "Simulation.hpp",
+    ],
+    includes = [
+        "./",  # TODO: This is not ideal, I should keep my header files in an include directory which matches what the output will be.
+    ],
+    linker_flags = [
+        "-larmadillo",  # Depends on armadillo
+        "-lgsl",  # Depends on GSL
+    ],
+    visibility = ["PUBLIC"],
+)
+
+# Export source files for the wheel build
+filegroup(
+    name = "wheel_srcs",
+    srcs = glob(["**/*.cpp", "**/*.hpp", "**/*.h", "**/CMakeLists.txt"]),
+    visibility = ["//src/RFL:rfl_wheel"],
+)

pyrfl-0.1.0/core/BarrettGlaser/Action.cpp

@@ -0,0 +1,30 @@
+//
+// Created by Paul Druce on 12/11/2022.
+//
+#include "./Action.hpp"
+
+using namespace std;
+using namespace arma;
+
+Action::Action(const double g_2) : m_g_2(g_2), m_g_4(1.0) {}
+
+Action::Action(const double g_2, const double g_4) : m_g_2(g_2), m_g_4(g_4) {}
+
+double Action::calculateSFromDirac(const IDiracOperator& dirac) const {
+  const cx_mat dirac_mat = dirac.getDiracMatrix();
+  const cx_mat dirac_squared = dirac_mat * dirac_mat;
+  const double trace_dirac_squared = trace(dirac_squared).real();
+  const double trace_dirac_4 = trace(dirac_squared * dirac_squared).real();
+  return m_g_2 * trace_dirac_squared + m_g_4 * trace_dirac_4;
+}
+
+double Action::calculateS(const IDiracOperator& dirac) const {
+  return m_g_2 * dirac.traceOfDiracSquared() + m_g_4 * dirac.traceOfDirac4();
+}
+
+void Action::setParams(const double g_2, const double g_4) {
+  this->m_g_2 = g_2;
+  this->m_g_4 = g_4;
+}
+void Action::setG4(const double value) { this->m_g_4 = value; }
+void Action::setG2(const double value) { this->m_g_2 = value; }

pyrfl-0.1.0/core/BarrettGlaser/Action.hpp

@@ -0,0 +1,96 @@
+//
+// Created by Paul Druce on 12/11/2022.
+//
+
+#ifndef RFL_ACTION_HPP
+#define RFL_ACTION_HPP
+#include "../IAction.hpp"
+#include "../IDiracOperator.hpp"
+
+/**
+ * @class Action
+ *
+ * @brief Implements the Barrett-Glaser action \f$ S(D) = g_2\text{Tr}(D^2) + g_4 \text{Tr}(D^4) \f$.
+ */
+class Action : public IAction {
+public:
+  /**
+   * Constructs a Barrett-Glaser action with quadratic and quartic coupling constants.
+   *
+   * @param g_2 Quadratic coupling constant.
+   * @param g_4 Quartic coupling constant.
+   */
+  Action(double g_2, double g_4);
+
+  /**
+   * Constructs a Barrett-Glaser action with quartic coupling constant equal to 1.0.
+   *
+   * @param g_2 Quadratic coupling constant.
+   */
+  explicit Action(double g_2);
+
+  /**
+   * Constructs a Barrett-Glaser action with coupling constants set to 0.0.
+   */
+  Action() : m_g_2(0.0), m_g_4(0.0){};
+
+  ~Action() override = default;
+
+  /**
+   * Sets the quadratic coupling constant \f$g_2\f$.
+   *
+   * @param value Quadratic coupling constant.
+   */
+  void setG2(double value);
+
+  /**
+   * Sets the quartic coupling constant \f$g_4\f$.
+   *
+   * @param value Quartic coupling constant.
+   */
+  void setG4(double value);
+
+  /**
+   * Sets the quadratic and quartic coupling constants.
+   *
+   * @param g_2 Quadratic coupling constant.
+   * @param g_4 Quartic coupling constant.
+   */
+  void setParams(double g_2, double g_4);
+
+  /**
+   * Returns the current quadratic coupling constant \f$g_2\f$.
+   *
+   * @return Quadratic coupling constant.
+   */
+  double getG2() const { return m_g_2; }
+
+  /**
+   * Returns the current quartic coupling constant \f$g_4\f$.
+   *
+   * @return Quartic coupling constant.
+   */
+  double getG4() const { return m_g_4; }
+
+  /**
+   * Calculates the Barrett-Glaser action using component matrix traces.
+   *
+   * @param dirac Dirac operator reference.
+   * @return Action value.
+   */
+  double calculateS(const IDiracOperator& dirac) const override;
+
+  /**
+   * Calculates the Barrett-Glaser action from the assembled Dirac operator matrix.
+   *
+   * Use calculateS() for faster performance.
+   *
+   * @param dirac Dirac operator reference.
+   * @return Action value.
+   */
+  double calculateSFromDirac(const IDiracOperator& dirac) const;
+
+private:
+  double m_g_2, m_g_4;
+};
+#endif// RFL_ACTION_HPP