scgraph 3.2.0__tar.gz → 3.2.2__tar.gz

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

@@ -49,7 +49,11 @@ else()
     # OPTIMIZATION FLAGS
     # -----------------------------
     set(CMAKE_BUILD_TYPE Release)
-    set(CMAKE_CXX_FLAGS_RELEASE "-O3 -march=native -DNDEBUG")
+    if(MSVC)
+        set(CMAKE_CXX_FLAGS_RELEASE "/O2 /DNDEBUG")
+    else()
+        set(CMAKE_CXX_FLAGS_RELEASE "-O3 -march=native -DNDEBUG")
+    endif()
 
     # -----------------------------
     # Find Packages

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scgraph
-Version: 3.2.0
+Version: 3.2.2
 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.2}/build/cp314-cp314-linux_x86_64/CMakeFiles/CheckCXX/CMakeLists.txt

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

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

@@ -26,7 +26,7 @@ include = [
 
 [project]
 name = "scgraph"
-version = "3.2.0"
+version = "3.2.2"
 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.2}/scgraph/cpp/bindings/graph_bindings.cpp

@@ -10,6 +10,9 @@
 #include <nanobind/stl/tuple.h>
 #include <nanobind/stl/shared_ptr.h>
 #include <nanobind/operators.h>
+#include <string>
+#include <stdexcept>
+#include <memory>
 #include "../src/graph.hpp"
 #include "../src/contraction_hierarchies.hpp"
 #include "../src/transit_node_routing.hpp"

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

@@ -5,6 +5,7 @@
 #include <string>
 #include <functional>
 #include <optional>
+#include <tuple>
 #include "graph_utils.hpp"
 
 class CHGraph {

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

@@ -6,6 +6,8 @@
 #include <stdexcept>
 #include <algorithm>
 #include <iostream>
+#include <cmath>
+#include <functional>
 
 // Constructor
 Graph::Graph(const std::vector<std::unordered_map<int, double>>& graph_data, bool validate)
@@ -464,7 +466,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.2}/scgraph/cpp/src/graph.hpp

@@ -1,4 +1,6 @@
 #pragma once
+#include <vector>
+#include <unordered_map>
 #include <set>
 #include <functional>
 #include <optional>

{scgraph-3.2.0 → scgraph-3.2.2}/scgraph/cpp/src/graph_utils.cpp

@@ -1,6 +1,7 @@
 #include "graph_utils.hpp"
 #include <stdexcept>
 #include <algorithm>
+#include <string>
 
 std::set<int> get_origin_ids(const std::variant<int, std::set<int>>& origin_id) {
     if (std::holds_alternative<int>(origin_id)) {

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

@@ -3,6 +3,7 @@
 #include <algorithm>
 #include <limits>
 #include <iostream>
+#include <functional>
 
 TNRGraph::TNRGraph(const std::vector<std::unordered_map<int, double>>& graph,
                    int num_transit_nodes,
@@ -66,16 +67,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.2}/scgraph/cpp/src/transit_node_routing.hpp

@@ -4,6 +4,7 @@
 #include <utility>
 #include <set>
 #include <optional>
+#include <functional>
 #include "contraction_hierarchies.hpp"
 
 class TNRGraph : public CHGraph {

{scgraph-3.2.0 → scgraph-3.2.2}/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: