Merge pull request #24 from algosup/dev

Author: Alexis SANTOS

.gitignore

@@ -0,0 +1,5 @@
+.vscode/settings.json
+*.exe
+*.bin
+*.txt
+*.smsh

src/alt.cpp

@@ -18,10 +18,9 @@
  * Steps of the Algorithm:
  * 1. If `save_alt` is enabled, attempt to load precomputed landmark data from storage.
  * 2. Initialize storage structures for distance calculations.
- * 3. Select the first landmark as an arbitrary node (first node in the dataset).
+ * 3. Select the first landmark as the node with the smallest ID (e.g., ID 1 if available).
  * 4. Compute shortest-path distances using Dijkstra’s algorithm:
- *    - `dist_landmark_to[i][j]` stores the shortest path distance **to** node `i` from landmark `j`.
- *    - `dist_landmark_from[i][j]` stores the shortest path distance **from** node `i` to landmark `j`.
+ *    - `dist_landmark[i][j]` stores the shortest path distance from landmark `j` to node `i`.
  * 5. Iteratively select `nb_alt` landmarks using the farthest-node heuristic:
  *    - Find the node that has the maximum minimum distance from previous landmarks.
  *    - Recompute shortest-path distances using Dijkstra’s algorithm.
@@ -31,11 +30,10 @@
  * Mathematical Background:
  * - Landmark heuristics use the triangle inequality:
  *
- *     h(n) = max{ |d_L(goal) - d_L(n)|, |d_F(n) - d_F(goal)| }
+ *     h(n) = max{ |d_L(goal) - d_L(n)| }
  *
  *   where:
  *   - `d_L(n)` is the precomputed distance from landmark `L` to node `n`.
- *   - `d_F(n)` is the precomputed distance from node `n` to landmark `L`.
  *
  * - The farthest-node landmark selection ensures a wide spread of landmarks,
  *   improving heuristic accuracy in large graphs.
@@ -72,24 +70,31 @@ void preprocessAlt(graph& gdata, config& conf)
     std::vector<int> md(n, std::numeric_limits<int>::max());
     std::vector<int> d(n, -1);
 
-    gdata.dist_landmark_to.resize(n, std::vector<int>(conf.nb_alt, -1));
-    gdata.dist_landmark_from.resize(n, std::vector<int>(conf.nb_alt, -1));
+    gdata.dist_landmark.resize(n, std::vector<int>(conf.nb_alt, -1));
 
-    int fl = gdata.node_to_index.begin()->first;
+    int fl = std::numeric_limits<int>::max();
+    for (const auto& kv : gdata.node_to_index)
+    {
+        if (kv.first < fl)
+            fl = kv.first;
+    }
+    
     landmarks.push_back(fl);
     console("info", "processing landmark " + std::to_string(fl) + " (1/" + std::to_string(conf.nb_alt) + ")");
     logger("processing landmark " + std::to_string(fl) + " (1/" + std::to_string(conf.nb_alt) + ")");
 
-    d = dijkstraSingleSource(gdata.adjacency, fl, n, gdata.node_to_index);
+    d = dijkstraSingleSource(gdata, fl, n);
     {
         int i = 0;
         for (auto& kv : gdata.node_to_index) {
             size_t idx = kv.second;
-            gdata.dist_landmark_to[idx][i] = d[idx];
-            gdata.dist_landmark_from[idx][i] = d[idx];
-            if (d[idx] >= 0 && d[idx] < md[idx]) md[idx] = d[idx];
+            gdata.dist_landmark[idx][i] = d[idx];
+            if (d[idx] >= 0 && d[idx] < md[idx])
+                md[idx] = d[idx];
         }
     }
+    
+    md[gdata.node_to_index[fl]] = -1;
 
     for (int i = 1; i < conf.nb_alt; ++i) {
         int nl = -1;
@@ -119,12 +124,12 @@ void preprocessAlt(graph& gdata, config& conf)
         logger("processing landmark " + std::to_string(nl) +
             " (" + std::to_string(i + 1) + "/" + std::to_string(conf.nb_alt) + ")");
 
-        d = dijkstraSingleSource(gdata.adjacency, nl, n, gdata.node_to_index);
+        d = dijkstraSingleSource(gdata, nl, n);
         for (auto& kv : gdata.node_to_index) {
             size_t idx = kv.second;
-            gdata.dist_landmark_to[idx][i] = d[idx];
-            gdata.dist_landmark_from[idx][i] = d[idx];
-            if (d[idx] >= 0 && d[idx] < md[idx]) md[idx] = d[idx];
+            gdata.dist_landmark[idx][i] = d[idx];
+            if (d[idx] >= 0 && d[idx] < md[idx])
+                md[idx] = d[idx];
         }
 
         size_t selected_idx = gdata.node_to_index[nl];
@@ -137,5 +142,4 @@ void preprocessAlt(graph& gdata, config& conf)
     if (conf.save_alt) {
         saveAltData(gdata, conf);
     }
-}
-
+}

src/api.cpp

@@ -106,7 +106,7 @@ std::string ipToString(const sockaddr_in& addr)
  *   - Response Buffer: O(1)
  *   - Graph Memory Usage: O(V + E).
  */
-int launchApiGateway(const graph& gdata, const config& conf)
+int launchApiGateway(const graph& gdata, search_buffers& buffers, const config& conf)
 {
 #ifdef _WIN32
     WSADATA wsa_data;
@@ -153,7 +153,7 @@ int launchApiGateway(const graph& gdata, const config& conf)
         return 1;
     }
 
-    console("success", "server is listening on port 80.");
+    console("success", "server is listening on port 80. press any touch to close it.");
     logger("server is listening on port 80.");
 
     while (true)
@@ -224,7 +224,12 @@ int launchApiGateway(const graph& gdata, const config& conf)
                     try {
                         size_t amp_pos = query_part.find("&", st_pos);
                         std::string val = query_part.substr(st_pos + 6, amp_pos - (st_pos + 6));
-                        start_val = std::stoi(val);
+                        size_t consumed = 0;
+                        int parsed = std::stoi(val, &consumed);
+                        if (consumed != val.size()) {
+                            throw std::invalid_argument("invalid integer parameter");
+                        }
+                        start_val = parsed;
                         start_ok = true;
                     }
                     catch (...) {
@@ -238,7 +243,12 @@ int launchApiGateway(const graph& gdata, const config& conf)
                     try {
                         size_t amp_pos = query_part.find("&", en_pos);
                         std::string val = query_part.substr(en_pos + 4, amp_pos - (en_pos + 4));
-                        end_val = std::stoi(val);
+                        size_t consumed = 0;
+                        int parsed = std::stoi(val, &consumed);
+                        if (consumed != val.size()) {
+                            throw std::invalid_argument("invalid integer parameter");
+                        }
+                        end_val = parsed;
                         end_ok = true;
                     }
                     catch (...) {
@@ -324,7 +334,12 @@ int launchApiGateway(const graph& gdata, const config& conf)
 
         path_result pres;
         if (success) {
-            pres = findShortestPath(gdata, conf, start_val, end_val, used_weight);
+            if(conf.search_engine == 1) {
+                pres = findShortestPathUnidirectional(gdata, buffers, conf, start_val, end_val, used_weight); 
+            }
+            else {
+                pres = findShortestPathBidirectional(gdata, buffers, conf, start_val, end_val, used_weight);
+            }
             if (pres.total_time < 0) {
                 success = false;
                 message_response = "NO PATH FOUND";

src/bu_alt.cpp

@@ -50,24 +50,12 @@ void saveAltData(const graph& gdata, const config& conf)
         }
 
         {
-            uint64_t outer_size = static_cast<uint64_t>(gdata.dist_landmark_to.size());
+            uint64_t outer_size = static_cast<uint64_t>(gdata.dist_landmark.size());
             ofs.write(reinterpret_cast<const char*>(&outer_size), sizeof(outer_size));
 
-            for (const auto& row : gdata.dist_landmark_to) {
+            for (const auto& row : gdata.dist_landmark) {
                 uint64_t inner_size = static_cast<uint64_t>(row.size());
                 ofs.write(reinterpret_cast<const char*>(&inner_size), sizeof(inner_size));
-
-                ofs.write(reinterpret_cast<const char*>(row.data()), inner_size * sizeof(int));
-            }
-        }
-        {
-            uint64_t outer_size = static_cast<uint64_t>(gdata.dist_landmark_from.size());
-            ofs.write(reinterpret_cast<const char*>(&outer_size), sizeof(outer_size));
-
-            for (const auto& row : gdata.dist_landmark_from) {
-                uint64_t inner_size = static_cast<uint64_t>(row.size());
-                ofs.write(reinterpret_cast<const char*>(&inner_size), sizeof(inner_size));
-
                 ofs.write(reinterpret_cast<const char*>(row.data()), inner_size * sizeof(int));
             }
         }
@@ -94,13 +82,10 @@ void saveAltData(const graph& gdata, const config& conf)
  * data from a binary file. The format must match the one used by `saveAltData`.
  *
  * Data Loaded:
- * - dist_landmark_to:
+ * - dist_landmark:
  *   - Reads the number of nodes (outer size).
  *   - For each node, reads the number of landmarks, then reads `int` distances.
  *
- * - dist_landmark_from:
- *   - Same pattern as dist_landmark_to.
- *
  * Steps of Execution:
  * 1. Open the input file in binary mode.
  * 2. Check if the file is empty (size == 0); if empty, return `false` to force preprocessing.
@@ -144,56 +129,27 @@ bool loadAltData(graph& gdata, config& conf)
             uint64_t outer_size = 0;
             ifs.read(reinterpret_cast<char*>(&outer_size), sizeof(outer_size));
             if (!ifs.good()) {
-                console("error", "failed to read the size of dist_landmark_to, processing landmarks again");
-                logger("error: failed to read the size of dist_landmark_to, processing landmarks again.");
-                return false;
-            }
-
-            gdata.dist_landmark_to.resize(static_cast<size_t>(outer_size));
-            for (size_t i = 0; i < outer_size; ++i) {
-                uint64_t inner_size = 0;
-                ifs.read(reinterpret_cast<char*>(&inner_size), sizeof(inner_size));
-                if (!ifs.good()) {
-                    console("error", "failed to read the size of a dist_landmark_to row, processing landmarks again");
-                    logger("error: failed to read the size of a dist_landmark_to row, processing landmarks again.");
-                    return false;
-                }
-
-                gdata.dist_landmark_to[i].resize(static_cast<size_t>(inner_size));
-                ifs.read(reinterpret_cast<char*>(gdata.dist_landmark_to[i].data()),
-                    static_cast<std::streamsize>(inner_size * sizeof(int)));
-                if (!ifs.good()) {
-                    console("error", "failed to read dist_landmark_to row data, processing landmarks again");
-                    logger("error: failed to read dist_landmark_to row data, processing landmarks again.");
-                    return false;
-                }
-            }
-        }
-        {
-            uint64_t outer_size = 0;
-            ifs.read(reinterpret_cast<char*>(&outer_size), sizeof(outer_size));
-            if (!ifs.good()) {
-                console("error", "failed to read the size of dist_landmark_from, processing landmarks again");
-                logger("error: failed to read the size of dist_landmark_from, processing landmarks again.");
+                console("error", "failed to read the size of dist_landmark, processing landmarks again");
+                logger("error: failed to read the size of dist_landmark, processing landmarks again.");
                 return false;
             }
 
-            gdata.dist_landmark_from.resize(static_cast<size_t>(outer_size));
+            gdata.dist_landmark.resize(static_cast<size_t>(outer_size));
             for (size_t i = 0; i < outer_size; ++i) {
                 uint64_t inner_size = 0;
                 ifs.read(reinterpret_cast<char*>(&inner_size), sizeof(inner_size));
                 if (!ifs.good()) {
-                    console("error", "failed to read the size of a dist_landmark_from row, processing landmarks again");
-                    logger("error: failed to read the size of a dist_landmark_from row, processing landmarks again.");
+                    console("error", "failed to read the size of a dist_landmark row, processing landmarks again");
+                    logger("error: failed to read the size of a dist_landmark row, processing landmarks again.");
                     return false;
                 }
 
-                gdata.dist_landmark_from[i].resize(static_cast<size_t>(inner_size));
-                ifs.read(reinterpret_cast<char*>(gdata.dist_landmark_from[i].data()),
-                    static_cast<std::streamsize>(inner_size * sizeof(int)));
+                gdata.dist_landmark[i].resize(static_cast<size_t>(inner_size));
+                ifs.read(reinterpret_cast<char*>(gdata.dist_landmark[i].data()),
+                         static_cast<std::streamsize>(inner_size * sizeof(int)));
                 if (!ifs.good()) {
-                    console("error", "failed to read dist_landmark_from row data, processing landmarks again");
-                    logger("error: failed to read dist_landmark_from row data, processing landmarks again");
+                    console("error", "failed to read dist_landmark row data, processing landmarks again");
+                    logger("error: failed to read dist_landmark row data, processing landmarks again.");
                     return false;
                 }
             }