scgraph 3.1.0__tar.gz → 3.2.0__tar.gz

{scgraph-3.1.0 → scgraph-3.2.0}/CMakeLists.txt

@@ -70,6 +70,7 @@ else()
         scgraph/cpp/src/graph.cpp
         scgraph/cpp/src/graph_utils.cpp
         scgraph/cpp/src/contraction_hierarchies.cpp
+        scgraph/cpp/src/transit_node_routing.cpp
     )
 
 

{scgraph-3.1.0 → scgraph-3.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scgraph
-Version: 3.1.0
+Version: 3.2.0
 Summary: Determine an approximate distance and route between two points on earth.
 Author-Email: Connor Makowski <conmak@mit.edu>
 License-Expression: MIT
@@ -19,7 +19,7 @@ Description-Content-Type: text/markdown
 # SCGraph
 [![PyPI version](https://badge.fury.io/py/scgraph.svg)](https://badge.fury.io/py/scgraph)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-[![PyPI Downloads](https://pepy.tech/badge/scgraph)](https://pypi.org/project/scgraph/)
+[![PyPI Downloads](https://static.pepy.tech/badge/scgraph)](https://pepy.tech/project/scgraph/)
 
 **A high-performance, lightweight Python library for shortest path routing on geographic and supply chain networks.**
 
@@ -191,21 +191,24 @@ All algorithms are available on `Graph` objects and accessible from `GeoGraph` v
 | `algorithm_fn` | Description | Time Complexity |
 |---|---|---|
 | `'dijkstra'` | Standard Dijkstra; general purpose, non-negative weights (default) | O((n+m) log n) |
+| `'dijkstra_buckets'` | Dijkstra with buckets (Dial's algorithm); efficient for non-negative weights (ideally >= 1) | O(n+m+W) |
 | `'dijkstra_negative'` | Dijkstra with cycle detection; supports negative weights | O(n·m) |
 | `'a_star'` | A* with optional heuristic; faster than Dijkstra with a good heuristic | O((n+m) log n) |
 | `'bellman_ford'` | Bellman-Ford; supports negative weights, slower than Dijkstra | O(n·m) |
 | `'bmssp'` | [BMSSP Algorithm](https://arxiv.org/pdf/2504.17033) / [Implementation](https://github.com/connor-makowski/bmsspy) | O(m log^(2/3)(n)) |
 | `'cached_shortest_path'` | Caches shortest path tree from origin; near-instant repeated queries | O((n+m) log n) first, O(1) after |
 | `'contraction_hierarchy'` | Bidirectional Dijkstra on preprocessed CH graph; fast arbitrary queries | O(k log k) per query |
+| `'tnr'` | [Transit Node Routing](https://en.wikipedia.org/wiki/Transit_node_routing); extremely fast for global queries | O(1) per query (global) |
 
 ## Performance Guide
 
 | Scenario | Recommended Approach |
 |---|---|
 | Single query | `dijkstra` (default) |
+| Weights generally >= 1 | `dijkstra_buckets` |
 | Repeated queries from one origin | `cached_shortest_path` |
 | Large distance matrix (same graph) | `distance_matrix` method |
-| Many arbitrary queries on a fixed graph | `contraction_hierarchy` |
+| Many arbitrary queries on a fixed graph | `contraction_hierarchy` or `tnr` |
 | Graph with negative weights | `dijkstra_negative` |
 
 ## Heuristic Functions (for A*)

{scgraph-3.1.0 → scgraph-3.2.0}/README.md

@@ -1,7 +1,7 @@
 # SCGraph
 [![PyPI version](https://badge.fury.io/py/scgraph.svg)](https://badge.fury.io/py/scgraph)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-[![PyPI Downloads](https://pepy.tech/badge/scgraph)](https://pypi.org/project/scgraph/)
+[![PyPI Downloads](https://static.pepy.tech/badge/scgraph)](https://pepy.tech/project/scgraph/)
 
 **A high-performance, lightweight Python library for shortest path routing on geographic and supply chain networks.**
 
@@ -173,21 +173,24 @@ All algorithms are available on `Graph` objects and accessible from `GeoGraph` v
 | `algorithm_fn` | Description | Time Complexity |
 |---|---|---|
 | `'dijkstra'` | Standard Dijkstra; general purpose, non-negative weights (default) | O((n+m) log n) |
+| `'dijkstra_buckets'` | Dijkstra with buckets (Dial's algorithm); efficient for non-negative weights (ideally >= 1) | O(n+m+W) |
 | `'dijkstra_negative'` | Dijkstra with cycle detection; supports negative weights | O(n·m) |
 | `'a_star'` | A* with optional heuristic; faster than Dijkstra with a good heuristic | O((n+m) log n) |
 | `'bellman_ford'` | Bellman-Ford; supports negative weights, slower than Dijkstra | O(n·m) |
 | `'bmssp'` | [BMSSP Algorithm](https://arxiv.org/pdf/2504.17033) / [Implementation](https://github.com/connor-makowski/bmsspy) | O(m log^(2/3)(n)) |
 | `'cached_shortest_path'` | Caches shortest path tree from origin; near-instant repeated queries | O((n+m) log n) first, O(1) after |
 | `'contraction_hierarchy'` | Bidirectional Dijkstra on preprocessed CH graph; fast arbitrary queries | O(k log k) per query |
+| `'tnr'` | [Transit Node Routing](https://en.wikipedia.org/wiki/Transit_node_routing); extremely fast for global queries | O(1) per query (global) |
 
 ## Performance Guide
 
 | Scenario | Recommended Approach |
 |---|---|
 | Single query | `dijkstra` (default) |
+| Weights generally >= 1 | `dijkstra_buckets` |
 | Repeated queries from one origin | `cached_shortest_path` |
 | Large distance matrix (same graph) | `distance_matrix` method |
-| Many arbitrary queries on a fixed graph | `contraction_hierarchy` |
+| Many arbitrary queries on a fixed graph | `contraction_hierarchy` or `tnr` |
 | Graph with negative weights | `dijkstra_negative` |
 
 ## Heuristic Functions (for A*)

{scgraph-3.1.0 → scgraph-3.2.0}/build/cp314-cp314-linux_x86_64/CMakeFiles/CheckCXX/CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 4.2.3)
+cmake_minimum_required(VERSION 4.3.1)
 set(CMAKE_MODULE_PATH "")
 
 project(CheckCXX LANGUAGES CXX)

{scgraph-3.1.0 → scgraph-3.2.0}/pyproject.toml

@@ -26,7 +26,7 @@ include = [
 
 [project]
 name = "scgraph"
-version = "3.1.0"
+version = "3.2.0"
 description = "Determine an approximate distance and route between two points on earth."
 authors = [
     {name="Connor Makowski", email="conmak@mit.edu"}

{scgraph-3.1.0 → scgraph-3.2.0}/scgraph/__init__.py

@@ -2,7 +2,7 @@
 # SCGraph
 [![PyPI version](https://badge.fury.io/py/scgraph.svg)](https://badge.fury.io/py/scgraph)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-[![PyPI Downloads](https://pepy.tech/badge/scgraph)](https://pypi.org/project/scgraph/)
+[![PyPI Downloads](https://static.pepy.tech/badge/scgraph)](https://pepy.tech/project/scgraph/)
 
 **A high-performance, lightweight Python library for shortest path routing on geographic and supply chain networks.**
 
@@ -174,21 +174,24 @@ All algorithms are available on `Graph` objects and accessible from `GeoGraph` v
 | `algorithm_fn` | Description | Time Complexity |
 |---|---|---|
 | `'dijkstra'` | Standard Dijkstra; general purpose, non-negative weights (default) | O((n+m) log n) |
+| `'dijkstra_buckets'` | Dijkstra with buckets (Dial's algorithm); efficient for non-negative weights (ideally >= 1) | O(n+m+W) |
 | `'dijkstra_negative'` | Dijkstra with cycle detection; supports negative weights | O(n·m) |
 | `'a_star'` | A* with optional heuristic; faster than Dijkstra with a good heuristic | O((n+m) log n) |
 | `'bellman_ford'` | Bellman-Ford; supports negative weights, slower than Dijkstra | O(n·m) |
 | `'bmssp'` | [BMSSP Algorithm](https://arxiv.org/pdf/2504.17033) / [Implementation](https://github.com/connor-makowski/bmsspy) | O(m log^(2/3)(n)) |
 | `'cached_shortest_path'` | Caches shortest path tree from origin; near-instant repeated queries | O((n+m) log n) first, O(1) after |
 | `'contraction_hierarchy'` | Bidirectional Dijkstra on preprocessed CH graph; fast arbitrary queries | O(k log k) per query |
+| `'tnr'` | [Transit Node Routing](https://en.wikipedia.org/wiki/Transit_node_routing); extremely fast for global queries | O(1) per query (global) |
 
 ## Performance Guide
 
 | Scenario | Recommended Approach |
 |---|---|
 | Single query | `dijkstra` (default) |
+| Weights generally >= 1 | `dijkstra_buckets` |
 | Repeated queries from one origin | `cached_shortest_path` |
 | Large distance matrix (same graph) | `distance_matrix` method |
-| Many arbitrary queries on a fixed graph | `contraction_hierarchy` |
+| Many arbitrary queries on a fixed graph | `contraction_hierarchy` or `tnr` |
 | Graph with negative weights | `dijkstra_negative` |
 
 ## Heuristic Functions (for A*)

{scgraph-3.1.0 → scgraph-3.2.0}/scgraph/cpp/bindings/graph_bindings.cpp

@@ -12,6 +12,7 @@
 #include <nanobind/operators.h>
 #include "../src/graph.hpp"
 #include "../src/contraction_hierarchies.hpp"
+#include "../src/transit_node_routing.hpp"
 
 namespace nb = nanobind;
 using namespace nb::literals;
@@ -143,7 +144,17 @@ NB_MODULE(cpp, m) {
         }, nb::arg("origin_id"), nb::arg("destination_id"),
            "Find shortest path using Dijkstra's algorithm")
 
+        .def("dijkstra_buckets", [](Graph& self,
+                                    const std::variant<int, std::set<int>>& origin_id,
+                                    int destination_id,
+                                    std::optional<double> max_edge_weight) -> nb::dict {
+            return graph_result_to_dict(self.dijkstra_buckets(origin_id, destination_id, max_edge_weight));
+        }, nb::arg("origin_id"), nb::arg("destination_id"),
+           nb::arg("max_edge_weight") = nb::none(),
+           "Find shortest path using Dijkstra with buckets")
+
         .def("dijkstra_negative", [](Graph& self,
+
                                      const std::variant<int, std::set<int>>& origin_id,
                                      int destination_id,
                                      std::optional<int> cycle_check_iterations) -> nb::dict {
@@ -193,12 +204,21 @@ NB_MODULE(cpp, m) {
         .def("create_contraction_hierarchy", &Graph::create_contraction_hierarchy,
              nb::arg("heuristic_fn") = nullptr,
              "Create a Contraction Hierarchies (CH) graph")
-        .def("contraction_hierarchy", [](Graph& self, int origin_id, int destination_id,
-                                         bool length_only) -> nb::dict {
+        .def("contraction_hierarchy", [](Graph& self, int origin_id, int destination_id) -> nb::dict {
             return graph_result_to_dict(self.contraction_hierarchy(origin_id, destination_id));
         }, nb::arg("origin_id"), nb::arg("destination_id"),
-           nb::arg("length_only") = false,
-           "Get shortest path using Contraction Hierarchies");
+           "Get shortest path using Contraction Hierarchies")
+
+        // Transit Node Routing
+        .def("create_tnr_hierarchy", &Graph::create_tnr_hierarchy,
+             nb::arg("num_transit_nodes") = 100, nb::arg("heuristic_fn") = nullptr,
+             "Create a Transit Node Routing (TNR) graph")
+        .def("set_tnr_graph", &Graph::set_tnr_graph, nb::arg("tnr_graph"),
+             "Set the TNRGraph object for the graph")
+        .def("tnr", [](Graph& self, int origin_id, int destination_id, bool length_only) -> nb::dict {
+            return graph_result_to_dict(self.tnr(origin_id, destination_id, length_only));
+        }, nb::arg("origin_id"), nb::arg("destination_id"), nb::arg("length_only") = false,
+           "Get shortest path using Transit Node Routing");
 
     // CHGraph class
     nb::class_<CHGraph>(m, "CHGraph")
@@ -317,5 +337,188 @@ NB_MODULE(cpp, m) {
             }
 
             return CHGraph(nodes_count, ranks, forward_graph, backward_graph, shortcuts, original_graph);
-        }, nb::arg("filename"), "Load a CHGraph from a JSON file.");
-}
+            }, nb::arg("filename"), "Load a CHGraph from a JSON file.");
+
+            // TNRGraph class
+            nb::class_<TNRGraph, CHGraph>(m, "TNRGraph")
+                .def(nb::init<const std::vector<std::unordered_map<int, double>>&, int, std::function<double(CHGraph*, int)>>(),
+                     nb::arg("graph"), nb::arg("num_transit_nodes") = 100, nb::arg("heuristic_fn") = nullptr,
+                     "Initialize and preprocess a TNRGraph")
+                .def(nb::init<int, const std::vector<int>&, 
+ 
+                      const std::vector<std::unordered_map<int, double>>&,
+                      const std::vector<std::unordered_map<int, double>>&,
+                      const std::unordered_map<std::pair<int, int>, int, pair_hash>&,
+                      const std::optional<std::vector<std::unordered_map<int, double>>>&,
+                      const std::set<int>&,
+                      const std::unordered_map<std::pair<int, int>, double, pair_hash>&,
+                      const std::vector<std::unordered_map<int, double>>&,
+                      const std::vector<std::unordered_map<int, double>>&>(),
+             nb::arg("nodes_count"), nb::arg("ranks"), nb::arg("forward_graph"),
+             nb::arg("backward_graph"), nb::arg("shortcuts"), nb::arg("original_graph"),
+             nb::arg("transit_nodes"), nb::arg("distance_table"),
+             nb::arg("forward_access_nodes"), nb::arg("backward_access_nodes"),
+             "Initialize a TNRGraph from pre-calculated data")
+            .def("search", [](TNRGraph& self, int origin_id, int destination_id, bool length_only) -> nb::dict {
+            return graph_result_to_dict(self.search(origin_id, destination_id, length_only));
+            }, nb::arg("origin_id"), nb::arg("destination_id"), nb::arg("length_only") = false,
+            "Perform a bidirectional search on the TNR")
+            .def("get_shortest_path", [](TNRGraph& self, int origin_id, int destination_id, bool length_only) -> nb::dict {
+            return graph_result_to_dict(self.search(origin_id, destination_id, length_only));
+            }, nb::arg("origin_id"), nb::arg("destination_id"), nb::arg("length_only") = false,
+            "Wrapper for search to match scgraph naming conventions")
+            .def_prop_ro("transit_nodes", &TNRGraph::get_transit_nodes)
+            .def_prop_ro("distance_table", [](const TNRGraph& self) {
+            nb::dict d;
+            for (const auto& [key, dist] : self.get_distance_table()) {
+                d[nb::cast(key)] = dist;
+            }
+            return d;
+            })
+            .def_prop_ro("forward_access_nodes", &TNRGraph::get_forward_access_nodes)
+            .def_prop_ro("backward_access_nodes", &TNRGraph::get_backward_access_nodes)
+            .def("save_as_tnrjson", [](const TNRGraph& self, const std::string& filename) {
+                if (filename.size() < 8 || filename.substr(filename.size() - 8) != ".tnrjson") {
+                    throw std::invalid_argument("Filename must end with .tnrjson");
+                }
+
+                nb::dict d;
+                d["type"] = "TNRGraph";
+                d["nodes_count"] = self.get_nodes_count();
+
+                nb::list t_nodes;
+                for (int node : self.get_transit_nodes()) {
+                    t_nodes.append(node);
+                }
+                d["transit_nodes"] = t_nodes;
+
+                nb::dict dist_table_str;
+                for (const auto& [key, dist] : self.get_distance_table()) {
+                    std::string key_str = "(" + std::to_string(key.first) + "," + std::to_string(key.second) + ")";
+                    dist_table_str[nb::cast(key_str)] = dist;
+                }
+                d["distance_table"] = dist_table_str;
+
+                auto convert_access_nodes = [](const std::vector<std::unordered_map<int, double>>& access_nodes) {
+                    nb::list access_str;
+                    for (const auto& node_map : access_nodes) {
+                        nb::dict d_map;
+                        for (const auto& [k, v] : node_map) {
+                            d_map[nb::cast(std::to_string(k))] = v;
+                        }
+                        access_str.append(d_map);
+                    }
+                    return access_str;
+                };
+
+                d["forward_access_nodes"] = convert_access_nodes(self.get_forward_access_nodes());
+                d["backward_access_nodes"] = convert_access_nodes(self.get_backward_access_nodes());
+
+                nb::dict ch_data;
+                ch_data["ranks"] = self.get_ranks();
+                ch_data["forward_graph"] = self.get_forward_graph();
+                ch_data["backward_graph"] = self.get_backward_graph();
+
+                nb::dict shortcuts_str;
+                for (const auto& [key, via_node_id] : self.get_shortcuts()) {
+                    std::string key_str = "(" + std::to_string(key.first) + ", " + std::to_string(key.second) + ")";
+                    shortcuts_str[nb::cast(key_str)] = via_node_id;
+                }
+                ch_data["shortcuts"] = shortcuts_str;
+                ch_data["original_graph"] = self.get_original_graph();
+                ch_data["nodes_count"] = self.get_nodes_count();
+
+                d["ch_data"] = ch_data;
+
+                nb::module_ json = nb::module_::import_("json");
+                nb::module_ builtins = nb::module_::import_("builtins");
+                nb::object f = builtins.attr("open")(filename, "w");
+                json.attr("dump")(d, f);
+                f.attr("close")();
+            }, nb::arg("filename"), "Save the current TNRGraph as a JSON file.")
+            .def_static("load_from_tnrjson", [](const std::string& filename) {
+                if (filename.size() < 8 || filename.substr(filename.size() - 8) != ".tnrjson") {
+                    throw std::invalid_argument("Filename must end with .tnrjson");
+                }
+
+                nb::module_ json = nb::module_::import_("json");
+                nb::module_ builtins = nb::module_::import_("builtins");
+                nb::object f = builtins.attr("open")(filename, "r");
+                nb::dict data = nb::cast<nb::dict>(json.attr("load")(f));
+                f.attr("close")();
+
+                if (!data.contains("type") || nb::cast<std::string>(data["type"]) != "TNRGraph") {
+                    throw std::invalid_argument("JSON file is not a valid TNRGraph.");
+                }
+
+                int nodes_count = nb::cast<int>(data["nodes_count"]);
+
+                std::set<int> transit_nodes;
+                for (auto item : nb::cast<nb::list>(data["transit_nodes"])) {
+                    transit_nodes.insert(nb::cast<int>(item));
+                }
+
+                std::unordered_map<std::pair<int, int>, double, pair_hash> distance_table;
+                for (auto [key, dist] : nb::cast<nb::dict>(data["distance_table"])) {
+                    std::string key_str = nb::cast<std::string>(key);
+                    size_t comma = key_str.find(',');
+                    int t_f = std::stoi(key_str.substr(1, comma - 1));
+                    int t_b = std::stoi(key_str.substr(comma + 1, key_str.size() - comma - 2));
+                    distance_table[{t_f, t_b}] = nb::cast<double>(dist);
+                }
+
+                auto convert_access_nodes = [](nb::list access_str) {
+                    std::vector<std::unordered_map<int, double>> access_nodes;
+                    for (auto item : access_str) {
+                        nb::dict d = nb::cast<nb::dict>(item);
+                        std::unordered_map<int, double> node_map;
+                        for (auto [k, v] : d) {
+                            node_map[std::stoi(nb::cast<std::string>(k))] = nb::cast<double>(v);
+                        }
+                        access_nodes.push_back(node_map);
+                    }
+                    return access_nodes;
+                };
+
+                std::vector<std::unordered_map<int, double>> forward_access_nodes = convert_access_nodes(nb::cast<nb::list>(data["forward_access_nodes"]));
+                std::vector<std::unordered_map<int, double>> backward_access_nodes = convert_access_nodes(nb::cast<nb::list>(data["backward_access_nodes"]));
+
+                nb::dict ch_data = nb::cast<nb::dict>(data["ch_data"]);
+                std::vector<int> ranks = nb::cast<std::vector<int>>(ch_data["ranks"]);
+
+                auto convert_graph = [](nb::list raw_graph) {
+                    std::vector<std::unordered_map<int, double>> graph;
+                    for (auto item : raw_graph) {
+                        nb::dict d = nb::cast<nb::dict>(item);
+                        std::unordered_map<int, double> node_map;
+                        for (auto [k, v] : d) {
+                            node_map[std::stoi(nb::cast<std::string>(k))] = nb::cast<double>(v);
+                        }
+                        graph.push_back(node_map);
+                    }
+                    return graph;
+                };
+
+                std::vector<std::unordered_map<int, double>> forward_graph = convert_graph(nb::cast<nb::list>(ch_data["forward_graph"]));
+                std::vector<std::unordered_map<int, double>> backward_graph = convert_graph(nb::cast<nb::list>(ch_data["backward_graph"]));
+
+                nb::dict shortcuts_raw = nb::cast<nb::dict>(ch_data["shortcuts"]);
+                std::unordered_map<std::pair<int, int>, int, pair_hash> shortcuts;
+                for (auto [key, via_node_id] : shortcuts_raw) {
+                    std::string key_str = nb::cast<std::string>(key);
+                    size_t comma = key_str.find(',');
+                    int shortcut_origin_id = std::stoi(key_str.substr(1, comma - 1));
+                    size_t start_dest = comma + 1;
+                    while (start_dest < key_str.size() && (key_str[start_dest] == ' ' || key_str[start_dest] == '\t')) start_dest++;
+                    int shortcut_destination_id = std::stoi(key_str.substr(start_dest, key_str.size() - start_dest - 1));
+                    shortcuts[{shortcut_origin_id, shortcut_destination_id}] = nb::cast<int>(via_node_id);
+                }
+
+                std::optional<std::vector<std::unordered_map<int, double>>> original_graph = std::nullopt;
+                if (ch_data.contains("original_graph") && !ch_data["original_graph"].is_none()) {
+                    original_graph = convert_graph(nb::cast<nb::list>(ch_data["original_graph"]));
+                }
+
+                return TNRGraph(nodes_count, ranks, forward_graph, backward_graph, shortcuts, original_graph, transit_nodes, distance_table, forward_access_nodes, backward_access_nodes);
+            }, nb::arg("filename"), "Load a TNRGraph from a JSON file.");
+            }

{scgraph-3.1.0 → scgraph-3.2.0}/scgraph/cpp/src/contraction_hierarchies.hpp

@@ -8,7 +8,7 @@
 #include "graph_utils.hpp"
 
 class CHGraph {
-private:
+protected:
     int nodes_count;
     std::vector<int> ranks;
     std::vector<std::unordered_map<int, double>> forward_graph;

{scgraph-3.1.0 → scgraph-3.2.0}/scgraph/cpp/src/graph.cpp

@@ -17,10 +17,11 @@ Graph::Graph(const std::vector<std::unordered_map<int, double>>& graph_data, boo
     }
 }
 
-// Override reset_cache to also clear __ch_graph__
+// Override reset_cache to also clear __ch_graph__ and __tnr_graph__
 void Graph::reset_cache() {
     GraphUtils::reset_cache();
     __ch_graph__ = nullptr;
+    __tnr_graph__ = nullptr;
 }
 
 // Tree algorithms
@@ -139,6 +140,78 @@ GraphResult Graph::dijkstra(const std::variant<int, std::set<int>>& origin_id, i
     };
 }
 
+GraphResult Graph::dijkstra_buckets(const std::variant<int, std::set<int>>& origin_id, int destination_id,
+                                     std::optional<double> max_edge_weight) {
+    input_check(origin_id, destination_id);
+    auto origin_ids = get_origin_ids(origin_id);
+
+    double max_weight = 0.0;
+    if (max_edge_weight.has_value()) {
+        max_weight = max_edge_weight.value();
+    } else {
+        for (const auto& node_edges : graph) {
+            for (const auto& [connected_id, connected_distance] : node_edges) {
+                if (connected_distance > max_weight) {
+                    max_weight = connected_distance;
+                }
+            }
+        }
+    }
+    int num_buckets = static_cast<int>(std::ceil(max_weight)) + 1;
+
+    const size_t n = graph.size();
+    std::vector<double> distance_matrix(n, std::numeric_limits<double>::infinity());
+    std::vector<int> predecessor(n, -1);
+    std::vector<std::vector<int>> buckets(num_buckets);
+
+    for (int oid : origin_ids) {
+        distance_matrix[oid] = 0.0;
+        buckets[0].push_back(oid);
+    }
+
+    int current_dist = 0;
+    size_t nodes_in_buckets = origin_ids.size();
+
+    while (nodes_in_buckets > 0) {
+        int bucket_idx = current_dist % num_buckets;
+        while (buckets[bucket_idx].empty()) {
+            current_dist++;
+            bucket_idx = current_dist % num_buckets;
+            if (nodes_in_buckets == 0) break;
+            if (distance_matrix[destination_id] < static_cast<double>(current_dist)) break;
+        }
+
+        if (nodes_in_buckets == 0 || distance_matrix[destination_id] < static_cast<double>(current_dist)) break;
+
+        int current_id = buckets[bucket_idx].back();
+        buckets[bucket_idx].pop_back();
+        nodes_in_buckets--;
+
+        if (distance_matrix[current_id] < static_cast<double>(current_dist)) {
+            continue;
+        }
+
+        for (const auto& [connected_id, connected_distance] : graph[current_id]) {
+            double possible_distance = distance_matrix[current_id] + connected_distance;
+            if (possible_distance < distance_matrix[connected_id]) {
+                distance_matrix[connected_id] = possible_distance;
+                predecessor[connected_id] = current_id;
+                buckets[static_cast<int>(possible_distance) % num_buckets].push_back(connected_id);
+                nodes_in_buckets++;
+            }
+        }
+    }
+
+    if (distance_matrix[destination_id] == std::numeric_limits<double>::infinity()) {
+        throw std::runtime_error("The origin and destination nodes are not connected.");
+    }
+
+    return GraphResult{
+        reconstruct_path(destination_id, predecessor),
+        distance_matrix[destination_id]
+    };
+}
+
 GraphResult Graph::dijkstra_negative(const std::variant<int, std::set<int>>& origin_id, int destination_id,
                                      std::optional<int> cycle_check_iterations) {
     input_check(origin_id, destination_id);
@@ -379,3 +452,19 @@ GraphResult Graph::contraction_hierarchy(int origin_id, int destination_id) {
     }
     return __ch_graph__->get_shortest_path(origin_id, destination_id);
 }
+
+std::shared_ptr<TNRGraph> Graph::create_tnr_hierarchy(int num_transit_nodes, std::function<double(CHGraph*, int)> heuristic_fn) {
+    __tnr_graph__ = std::make_shared<TNRGraph>(get_graph(), num_transit_nodes, heuristic_fn);
+    return __tnr_graph__;
+}
+
+void Graph::set_tnr_graph(std::shared_ptr<TNRGraph> tnr_graph) {
+    __tnr_graph__ = tnr_graph;
+}
+
+GraphResult Graph::tnr(int origin_id, int destination_id, bool length_only) {
+    if (__tnr_graph__ == nullptr) {
+        throw std::runtime_error("TNRGraph has not been set. Use set_tnr_graph() first.");
+    }
+    return __tnr_graph__->search(origin_id, destination_id, length_only);
+}

{scgraph-3.1.0 → scgraph-3.2.0}/scgraph/cpp/src/graph.hpp

@@ -6,17 +6,19 @@
 #include <memory>
 #include "graph_utils.hpp"
 
-class CHGraph; // Forward declaration
+#include "contraction_hierarchies.hpp"
+#include "transit_node_routing.hpp"
 
 class Graph : public GraphUtils {
 private:
     std::shared_ptr<CHGraph> __ch_graph__ = nullptr;
+    std::shared_ptr<TNRGraph> __tnr_graph__ = nullptr;
 
 public:
     // Constructor
     explicit Graph(const std::vector<std::unordered_map<int, double>>& graph_data, bool validate = false);
 
-    // Override reset_cache to also clear ch_graph
+    // Override reset_cache to also clear ch_graph and tnr_graph
     void reset_cache();
 
     // Tree algorithms
@@ -25,6 +27,8 @@ public:
 
     // Shortest path algorithms
     GraphResult dijkstra(const std::variant<int, std::set<int>>& origin_id, int destination_id);
+    GraphResult dijkstra_buckets(const std::variant<int, std::set<int>>& origin_id, int destination_id,
+                                 std::optional<double> max_edge_weight = std::nullopt);
     GraphResult dijkstra_negative(const std::variant<int, std::set<int>>& origin_id, int destination_id,
                                   std::optional<int> cycle_check_iterations = std::nullopt);
     GraphResult a_star(const std::variant<int, std::set<int>>& origin_id, int destination_id,
@@ -38,4 +42,10 @@ public:
     // Contraction Hierarchies
     std::shared_ptr<CHGraph> create_contraction_hierarchy(std::function<double(CHGraph*, int)> heuristic_fn = nullptr);
     GraphResult contraction_hierarchy(int origin_id, int destination_id);
+
+    // Transit Node Routing
+    std::shared_ptr<TNRGraph> create_tnr_hierarchy(int num_transit_nodes = 100, std::function<double(CHGraph*, int)> heuristic_fn = nullptr);
+    void set_tnr_graph(std::shared_ptr<TNRGraph> tnr_graph);
+    GraphResult tnr(int origin_id, int destination_id, bool length_only = false);
+
 };