scgraph 3.2.0__tar.gz → 3.2.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scgraph
-Version: 3.2.0
+Version: 3.2.1
 Summary: Determine an approximate distance and route between two points on earth.
 Author-Email: Connor Makowski <conmak@mit.edu>
 License-Expression: MIT

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

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

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

@@ -464,7 +464,7 @@ void Graph::set_tnr_graph(std::shared_ptr<TNRGraph> 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.");
+        create_tnr_hierarchy();
     }
     return __tnr_graph__->search(origin_id, destination_id, length_only);
 }

{scgraph-3.2.0 → scgraph-3.2.1}/scgraph/cpp/src/transit_node_routing.cpp

@@ -66,16 +66,29 @@ TNRGraph::TNRGraph(const std::vector<std::unordered_map<int, double>>& graph,
         backward_access_nodes[i] = compute_access_nodes(i, false);
     }
 
-    // 3. Compute Distance Table
+    // 3. Compute Distance Table using full Dijkstra on original_graph (one tree per transit origin)
+    size_t n = original_graph.size();
     for (int origin : transit_nodes) {
-        for (int target : transit_nodes) {
-            if (origin == target) {
-                distance_table[{origin, target}] = 0.0;
-            } else {
-                auto res = CHGraph::search(origin, target);
-                distance_table[{origin, target}] = res.length;
+        std::vector<double> dist(n, std::numeric_limits<double>::infinity());
+        dist[origin] = 0.0;
+        using PQItem = std::pair<double, int>;
+        std::priority_queue<PQItem, std::vector<PQItem>, std::greater<PQItem>> pq;
+        pq.push({0.0, origin});
+        while (!pq.empty()) {
+            auto [d, u] = pq.top();
+            pq.pop();
+            if (d > dist[u]) continue;
+            for (const auto& [v, w] : original_graph[u]) {
+                double nd = d + w;
+                if (nd < dist[v]) {
+                    dist[v] = nd;
+                    pq.push({nd, v});
+                }
             }
         }
+        for (int target : transit_nodes) {
+            distance_table[{origin, target}] = dist[target];
+        }
     }
 }
 

{scgraph-3.2.0 → scgraph-3.2.1}/scgraph/transit_node_routing.py

@@ -139,22 +139,26 @@ class TNRGraphPreprocessing:
             for i in range(self.nodes_count)
         ]
 
-        # 3. Compute Distance Table between transit nodes
+        # 3. Compute Distance Table using full Dijkstra on original_graph (one tree per transit origin)
         self.distance_table = {}
         t_nodes_list = list(self.transit_nodes)
+        n = len(self.original_graph)
 
-        # Note: This is O(T^2) which is slow for Python.
-        # For a production implementation, we'd use many-to-one Dijkstra.
         for origin in t_nodes_list:
-            # We use CH search for distance
-            # This can be optimized by using a simpler Dijkstra if we're only going transit-to-transit
-            for target in t_nodes_list:
-                if origin == target:
-                    self.distance_table[(origin, target)] = 0
+            dist = [float("inf")] * n
+            dist[origin] = 0
+            open_leaves = [(0, origin)]
+            while open_leaves:
+                d, u = heappop(open_leaves)
+                if d > dist[u]:
                     continue
-                # Bidirectional CH search is very fast
-                res = CHGraph.search(self, origin, target)
-                self.distance_table[(origin, target)] = res["length"]
+                for v, w in self.original_graph[u].items():
+                    nd = d + w
+                    if nd < dist[v]:
+                        dist[v] = nd
+                        heappush(open_leaves, (nd, v))
+            for target in t_nodes_list:
+                self.distance_table[(origin, target)] = dist[target]
 
 
 class TNRGraphAlgorithms: