cpp-pd-code-simplify-interface 0.1.0__py3-none-any.whl

cpp_pd_code_simplify_interface/__init__.py

@@ -0,0 +1,21 @@
+from .main import (
+    PdCodeSimplifyInterfaceError,
+    compile_simplifier,
+    get_simplifier_executable,
+    get_simplifier_library,
+    normalize_pd_code,
+    normalize_pd_codes,
+    simplify,
+    simplify_many,
+)
+
+__all__ = [
+    "PdCodeSimplifyInterfaceError",
+    "compile_simplifier",
+    "get_simplifier_executable",
+    "get_simplifier_library",
+    "normalize_pd_code",
+    "normalize_pd_codes",
+    "simplify",
+    "simplify_many",
+]

cpp_pd_code_simplify_interface/__main__.py

@@ -0,0 +1,4 @@
+from .main import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

cpp_pd_code_simplify_interface/data/include/pdcode_simplify/pdcode_simplify.hpp

@@ -0,0 +1,145 @@
+#pragma once
+
+#include <array>
+#include <cstddef>
+#include <iosfwd>
+#include <string>
+#include <vector>
+
+#if defined(_WIN32) && (defined(PDCODE_SIMPLIFY_SHARED) || defined(PDCODE_SIMPLIFY_BUILD_SHARED))
+#if defined(PDCODE_SIMPLIFY_BUILD_SHARED)
+#define PDCODE_SIMPLIFY_API __declspec(dllexport)
+#else
+#define PDCODE_SIMPLIFY_API __declspec(dllimport)
+#endif
+#elif defined(PDCODE_SIMPLIFY_BUILD_SHARED) && defined(__GNUC__)
+#define PDCODE_SIMPLIFY_API __attribute__((visibility("default")))
+#else
+#define PDCODE_SIMPLIFY_API
+#endif
+
+namespace pdcode_simplify {
+
+struct Endpoint {
+    int crossing = -1;
+    int strand = -1;
+
+    friend bool operator==(const Endpoint& lhs, const Endpoint& rhs) {
+        return lhs.crossing == rhs.crossing && lhs.strand == rhs.strand;
+    }
+
+    friend bool operator!=(const Endpoint& lhs, const Endpoint& rhs) {
+        return !(lhs == rhs);
+    }
+};
+
+using Crossing = std::array<int, 4>;
+using PDCode = std::vector<Crossing>;
+
+enum class Direction {
+    Left,
+    Right
+};
+
+struct GreenCrossing {
+    int from_face = -1;
+    int to_face = -1;
+    std::string strand_level;
+};
+
+struct SimplifierOptions {
+    int max_paths = 100;
+};
+
+struct LinkComponentSummary {
+    std::vector<int> crossing_indices;
+};
+
+struct ComponentAnalysis {
+    std::vector<LinkComponentSummary> components;
+    std::size_t crossingless_components = 0;
+
+    std::size_t components_with_crossings() const {
+        return components.size();
+    }
+
+    std::size_t total_components() const {
+        return components.size() + crossingless_components;
+    }
+};
+
+struct RandomInflationOptions {
+    int moves = 16;
+    unsigned int seed = 1;
+    int type_ii_percentage = 50;
+};
+
+struct RandomInflationResult {
+    PDCode code;
+    unsigned int seed = 1;
+    int type_i_moves = 0;
+    int type_ii_moves = 0;
+};
+
+struct ReidemeisterSimplificationResult {
+    PDCode code;
+    std::size_t crossingless_components = 0;
+    int type_i_moves = 0;
+    int type_ii_moves = 0;
+};
+
+struct PDSimplificationResult {
+    PDCode code;
+    std::size_t crossingless_components = 0;
+    int reidemeister_i_moves = 0;
+    int nugatory_crossing_moves = 0;
+};
+
+struct SimplificationResult {
+    bool found = false;
+    Direction direction = Direction::Left;
+    std::vector<Endpoint> red_path;
+    std::vector<int> green_path;
+    std::vector<GreenCrossing> green_crossings;
+    std::size_t tested_red_paths = 0;
+    std::size_t tested_green_paths = 0;
+};
+
+PDCODE_SIMPLIFY_API PDCode parse_pd_code(const std::string& text);
+PDCODE_SIMPLIFY_API std::string format_pd_code(const PDCode& code);
+PDCODE_SIMPLIFY_API std::string format_endpoint(const Endpoint& endpoint);
+PDCODE_SIMPLIFY_API std::string format_direction(Direction direction);
+
+PDCODE_SIMPLIFY_API ComponentAnalysis analyze_components(
+    const PDCode& code,
+    std::size_t known_crossingless_components = 0);
+
+PDCODE_SIMPLIFY_API ComponentAnalysis analyze_components_after_removing_crossings(
+    const PDCode& code,
+    const std::vector<int>& removed_crossings,
+    std::size_t known_crossingless_components = 0);
+
+PDCODE_SIMPLIFY_API std::size_t count_crossingless_components_after_removing_crossings(
+    const PDCode& code,
+    const std::vector<int>& removed_crossings,
+    std::size_t known_crossingless_components = 0);
+
+PDCODE_SIMPLIFY_API RandomInflationResult randomly_increase_crossings(
+    const PDCode& code,
+    const RandomInflationOptions& options = RandomInflationOptions{});
+
+PDCODE_SIMPLIFY_API ReidemeisterSimplificationResult simplify_reidemeister_i_ii(
+    const PDCode& code,
+    std::size_t known_crossingless_components = 0);
+
+PDCODE_SIMPLIFY_API PDSimplificationResult simplify_pd_code(
+    const PDCode& code,
+    std::size_t known_crossingless_components = 0);
+
+PDCODE_SIMPLIFY_API SimplificationResult find_simplification(
+    const PDCode& code,
+    const SimplifierOptions& options = SimplifierOptions{});
+
+PDCODE_SIMPLIFY_API std::ostream& operator<<(std::ostream& out, const Endpoint& endpoint);
+
+}  // namespace pdcode_simplify

cpp_pd_code_simplify_interface/data/src/native_interface.cpp

@@ -0,0 +1,195 @@
+#include "pdcode_simplify/pdcode_simplify.hpp"
+
+#include <cstdlib>
+#include <cstring>
+#include <exception>
+#include <sstream>
+#include <string>
+#include <vector>
+
+namespace {
+
+bool denotes_crossingless_unknot(const std::string& text) {
+    std::string compact;
+    for (char c : text) {
+        if (c != ' ' && c != '\t' && c != '\r' && c != '\n') {
+            compact.push_back(c);
+        }
+    }
+    return compact == "PD[]" || compact == "[]";
+}
+
+std::string json_escape(const std::string& text) {
+    std::ostringstream escaped;
+    for (char c : text) {
+        switch (c) {
+            case '\\':
+                escaped << "\\\\";
+                break;
+            case '"':
+                escaped << "\\\"";
+                break;
+            case '\n':
+                escaped << "\\n";
+                break;
+            case '\r':
+                escaped << "\\r";
+                break;
+            case '\t':
+                escaped << "\\t";
+                break;
+            default:
+                escaped << c;
+                break;
+        }
+    }
+    return escaped.str();
+}
+
+void append_component_counts(
+    std::ostringstream& out,
+    const pdcode_simplify::ComponentAnalysis& analysis) {
+    out << "\"components_with_crossings\":" << analysis.components_with_crossings()
+        << ",\"crossingless_components\":" << analysis.crossingless_components
+        << ",\"total_components\":" << analysis.total_components();
+}
+
+std::string result_to_json(
+    const pdcode_simplify::SimplificationResult& result,
+    const pdcode_simplify::ComponentAnalysis& input_components,
+    const pdcode_simplify::ComponentAnalysis* after_removal_components,
+    const pdcode_simplify::PDSimplificationResult& pd_simplification,
+    const pdcode_simplify::ComponentAnalysis& search_components) {
+    std::ostringstream out;
+    out << "{";
+    out << "\"simplification_found\":" << (result.found ? "true" : "false") << ",";
+    out << "\"input_components\":{";
+    append_component_counts(out, input_components);
+    out << "},";
+    if (after_removal_components != nullptr) {
+        out << "\"after_removal_components\":{";
+        append_component_counts(out, *after_removal_components);
+        out << "},";
+    }
+    out << "\"pd_simplification\":{"
+        << "\"enabled\":true,"
+        << "\"reidemeister_i_moves\":" << pd_simplification.reidemeister_i_moves << ","
+        << "\"nugatory_crossing_moves\":" << pd_simplification.nugatory_crossing_moves << ","
+        << "\"output_crossings\":" << pd_simplification.code.size()
+        << "},";
+    out << "\"search_components\":{";
+    append_component_counts(out, search_components);
+    out << "},";
+    out << "\"tested_red_paths\":" << result.tested_red_paths << ",";
+    out << "\"tested_green_paths\":" << result.tested_green_paths;
+    if (result.found) {
+        out << ",";
+        out << "\"direction\":\"" << pdcode_simplify::format_direction(result.direction) << "\",";
+        out << "\"red_path\":[";
+        for (std::size_t i = 0; i < result.red_path.size(); ++i) {
+            if (i != 0) {
+                out << ",";
+            }
+            out << "{\"crossing\":" << result.red_path[i].crossing
+                << ",\"strand\":" << result.red_path[i].strand << "}";
+        }
+        out << "],";
+        out << "\"green_path\":[";
+        for (std::size_t i = 0; i < result.green_path.size(); ++i) {
+            if (i != 0) {
+                out << ",";
+            }
+            out << result.green_path[i];
+        }
+        out << "],";
+        out << "\"green_crossings\":[";
+        for (std::size_t i = 0; i < result.green_crossings.size(); ++i) {
+            if (i != 0) {
+                out << ",";
+            }
+            const auto& crossing = result.green_crossings[i];
+            out << "{\"from_face\":" << crossing.from_face
+                << ",\"to_face\":" << crossing.to_face
+                << ",\"strand_level\":\"" << json_escape(crossing.strand_level) << "\"}";
+        }
+        out << "]";
+    }
+    out << "}";
+    return out.str();
+}
+
+char* copy_string(const std::string& text) {
+    char* result = static_cast<char*>(std::malloc(text.size() + 1));
+    if (result == nullptr) {
+        return nullptr;
+    }
+    std::memcpy(result, text.c_str(), text.size() + 1);
+    return result;
+}
+
+}  // namespace
+
+extern "C" {
+
+#if defined(_WIN32)
+__declspec(dllexport)
+#endif
+char* pdcode_simplify_run_json(
+    const char* pd_text,
+    int max_paths,
+    unsigned long long known_crossingless_components,
+    const int* removed_crossings,
+    unsigned long long removed_crossing_count) {
+    try {
+        if (pd_text == nullptr) {
+            return copy_string("{\"error\":\"pd_text must not be null\"}");
+        }
+
+        const std::string text(pd_text);
+        pdcode_simplify::SimplifierOptions options;
+        options.max_paths = max_paths;
+
+        const pdcode_simplify::PDCode code = pdcode_simplify::parse_pd_code(text);
+        std::size_t crossingless = static_cast<std::size_t>(known_crossingless_components);
+        if (denotes_crossingless_unknot(text)) {
+            ++crossingless;
+        }
+
+        const auto input_components = pdcode_simplify::analyze_components(code, crossingless);
+        pdcode_simplify::ComponentAnalysis after_removal_components;
+        const bool has_removal = removed_crossings != nullptr && removed_crossing_count > 0;
+        if (has_removal) {
+            std::vector<int> removed(
+                removed_crossings,
+                removed_crossings + static_cast<std::size_t>(removed_crossing_count));
+            after_removal_components =
+                pdcode_simplify::analyze_components_after_removing_crossings(
+                    code, removed, crossingless);
+        }
+
+        const auto pd_simplification = pdcode_simplify::simplify_pd_code(code, crossingless);
+        const auto search_components = pdcode_simplify::analyze_components(
+            pd_simplification.code,
+            pd_simplification.crossingless_components);
+        const auto result = pdcode_simplify::find_simplification(pd_simplification.code, options);
+        return copy_string(result_to_json(
+            result,
+            input_components,
+            has_removal ? &after_removal_components : nullptr,
+            pd_simplification,
+            search_components));
+    } catch (const std::exception& error) {
+        return copy_string(std::string("{\"error\":\"") + json_escape(error.what()) + "\"}");
+    } catch (...) {
+        return copy_string("{\"error\":\"unknown C++ exception\"}");
+    }
+}
+
+#if defined(_WIN32)
+__declspec(dllexport)
+#endif
+void pdcode_simplify_free_string(char* text) {
+    std::free(text);
+}
+
+}  // extern "C"