Add files via upload

Author: vlarmet

R/contract.R

@@ -1,11 +1,11 @@
 #' Contraction hierarchies algorithm
 #' @description Contract a graph by using contraction hierarchies algorithm
-#' @param Graph  An object generated by cppRouting::makegraph() function.
+#' @param Graph  An object generated by makegraph() or cpp_simplify() function.
 #' @param silent Logical. If TRUE, progress is not displayed.
 #' @return A contracted graph.
 #' @details Contraction hierarchy is a speed-up technique for finding shortest path in a graph.
 #' It consist of two steps : preprocessing phase and query. cpp_contract() preprocess the input graph to later use special query algorithm implemented in get_distance_pair(),get_distance_matrix() and get_path_pair() functions. 
-#' To see the benefits of using contraction hierarchies, see the package description : https://github.com/vlarmet/cppRouting.
+#' To see the benefits of using contraction hierarchies, see the package description : \url{https://github.com/vlarmet/cppRouting/blob/master/README.md}.
 #' @examples 
 #' #Data describing edges of the graph
 #' edges<-data.frame(from_vertex=c(0,0,1,1,2,2,3,4,4), 

R/get_detour.R

@@ -1,6 +1,6 @@
 #' Return the nodes that can be reached in a detour time set around the shortest path
 #' 
-#' @param Graph  An object generated by cppRouting::makegraph() function.
+#' @param Graph  An object generated by makegraph() or cpp_simplify() function.
 #' @param from A vector of one or more vertices from which shortest path are calculated (origin).
 #' @param to A vector of one or more vertices (destination).
 #' @param extra numeric. Additional cost 

R/get_distance_mat.R

@@ -6,12 +6,12 @@
 #' @param algorithm Character. Only for contracted graph, "mch" for Many to many CH, "phast" for PHAST algorithm
 #' @param allcores Logical. If TRUE, all cores are used.
 #' @return Matrix of shortest distances.
-#' @note If graph is not contracted, get_distance_matrix() recursively perform Dijkstra algorithm for each 'from' nodes.
+#' @details If graph is not contracted, get_distance_matrix() recursively perform Dijkstra algorithm for each 'from' nodes.
 #' If graph is contracted, the user has the choice between : \itemize{
-#'   \item many to many contraction hierarchies (mch) : should be applied if the matrix is square or 'almost' square.
+#'   \item many to many contraction hierarchies (mch) : optimal for square matrix.  
 #'   \item PHAST (phast) : outperform mch on rectangular matrix
 #' }
-#'  See details in package website : https://github.com/vlarmet/cppRouting/blob/master/README.md
+#'  See details in package website : \url{https://github.com/vlarmet/cppRouting/blob/master/README.md}
 #' @examples 
 #' #Data describing edges of the graph
 #' edges<-data.frame(from_vertex=c(0,0,1,1,2,2,3,4,4), 
@@ -87,24 +87,24 @@ get_distance_matrix<-function(Graph,from,to,algorithm="phast",allcores=FALSE){
     }
     else{
 
-      test<-data.frame(id=Graph$dict$id,rank=(Graph$nbnode)-Graph$rank)
+      invrank<-(Graph$nbnode)-Graph$rank
 
       if (allcores==TRUE){
 
         if (length(to)< length(from)){
-          res<-Phast_par(test$rank[to_id+1],
-                         test$rank[from_id+1],
-                         test$rank[match(Graph$data$to,test$id)],
-                         test$rank[match(Graph$data$from,test$id)],
+          res<-Phast_par(invrank[to_id+1],
+                         invrank[from_id+1],
+                         invrank[Graph$data$to+1],
+                         invrank[Graph$data$from+1],
                          Graph$data[,3],
                          Graph$nbnode)
 
         }
         else {
-          res<-Phast_par(test$rank[from_id+1],
-                         test$rank[to_id+1],
-                         test$rank[match(Graph$data$from,test$id)],
-                         test$rank[match(Graph$data$to,test$id)],
+          res<-Phast_par(invrank[from_id+1],
+                         invrank[to_id+1],
+                         invrank[Graph$data$from+1],
+                         invrank[Graph$data$to+1],
                          Graph$data[,3],
                          Graph$nbnode)
 
@@ -113,8 +113,8 @@ get_distance_matrix<-function(Graph,from,to,algorithm="phast",allcores=FALSE){
 
       }
       else {
-        if (length(to)< length(from))  res<-Phast3(test$rank[to_id+1],test$rank[from_id+1],test$rank[match(Graph$data$to,test$id)],test$rank[match(Graph$data$from,test$id)],Graph$data[,3],Graph$nbnode)
-        else res<-Phast3(test$rank[from_id+1],test$rank[to_id+1],test$rank[match(Graph$data$from,test$id)],test$rank[match(Graph$data$to,test$id)],Graph$data[,3],Graph$nbnode)
+        if (length(to)< length(from))  res<-Phast3(invrank[to_id+1],invrank[from_id+1],invrank[Graph$data$to+1],invrank[Graph$data$from+1],Graph$data[,3],Graph$nbnode)
+        else res<-Phast3(invrank[from_id+1],invrank[to_id+1],invrank[Graph$data$from+1],invrank[Graph$data$to+1],Graph$data[,3],Graph$nbnode)
       }
     }
 

R/get_distance_pair.R

@@ -4,16 +4,23 @@
 #' @param from A vector of one or more vertices from which distances are calculated (origin).
 #' @param to A vector of one or more vertices (destination).
 #' @param algorithm character. "Dijkstra" for uni-directional Dijkstra, "bi" for bi-directional Dijkstra, "A*" for A star unidirectional search or "NBA" for New bi-directional A star .Default to "Dijkstra"
-#' @param constant numeric. Constant to maintain the heuristic function admissible in A* algorithm. 
+#' @param constant numeric. Constant to maintain the heuristic function admissible in A* and NBA algorithms. 
 #' Default to 1, when cost is expressed in the same unit than coordinates. See details
 #' @param allcores Logical. If TRUE, all cores are used.
 #' @return Vector of shortest distances.
 #' @note 'from' and 'to' must be the same length.
-#' @details If the input graph has been contracted by cpp_contract() function, the algorithm is a modified bidirectional search.
-#' To perform A* and New Bidirectional A star, projected coordinates should be provided in the Graph object.  
+#' @details If graph is not contracted, the user has the choice between : \itemize{
+#'   \item unidirectional Dijkstra (Dijkstra) 
+#'   \item A star (A*) : projected coordinates should be provided
+#'   \item bidirectional Dijkstra (bi)
+#'   \item New bi-directional A star (NBA) : projected coordinates should be provided
+#' }
+#' 
+#' If the input graph has been contracted by cpp_contract() function, the algorithm is a modified bidirectional search.  
+#'   
 #' In A* and New Bidirectional A star algorithms, euclidean distance is used as heuristic function.
-#' To understand how A star algorithm work, see https://en.wikipedia.org/wiki/A*_search_algorithm .
-#' To understand the importance of constant parameter, see the package description : https://github.com/vlarmet/cppRouting
+#' To understand how A star algorithm work, see \url{https://en.wikipedia.org/wiki/A*_search_algorithm}.
+#' To understand the importance of constant parameter, see the package description : \url{https://github.com/vlarmet/cppRouting/blob/master/README.md}
 #' @examples 
 #' #Data describing edges of the graph
 #' edges<-data.frame(from_vertex=c(0,0,1,1,2,2,3,4,4), 

R/get_multi_paths.R

@@ -1,6 +1,6 @@
 #' Compute all shortest paths between origin and destination nodes.
 #' 
-#' @param Graph  An object generated by cppRouting::makegraph() function.
+#' @param Graph  An object generated by makegraph() or cpp_simplify() function.
 #' @param from A vector of one or more vertices from which shortest paths are calculated (origin).
 #' @param to A vector of one or more vertices (destination).
 #' @param keep numeric or character. Vertices of interest that will be returned. 

R/get_path_pair.R

@@ -1,6 +1,6 @@
 #' Compute shortest path between origin and destination nodes.
 #' 
-#' @param Graph  An object generated by cppRouting::makegraph() function.
+#' @param Graph   An object generated by makegraph(), cpp_simplify() or cpp_contract() function.
 #' @param from A vector of one or more vertices from which shortest paths are calculated (origin).
 #' @param to A vector of one or more vertices (destination).
 #' @param algorithm character. "Dijkstra" for uni-directional Dijkstra, "bi" for bi-directional Dijkstra, "A*" for A star unidirectional search or "NBA" for New bi-directional A star .Default to "Dijkstra"
@@ -10,11 +10,18 @@
 #' Default to 1, when cost is expressed in the same unit than coordinates. See details
 #' @return List or a data.frame containing shortest path nodes between from and to.
 #' @note 'from' and 'to' must be the same length.
-#' @details If the input graph has been contracted by cpp_contract() function, the algorithm is a modified bidirectional search.
-#' To perform A* and New Bidirectional A star, projected coordinates should be provided in the Graph object.  
+#' @details If graph is not contracted, the user has the choice between : \itemize{
+#'   \item unidirectional Dijkstra (Dijkstra) 
+#'   \item A star (A*) : projected coordinates should be provided
+#'   \item bidirectional Dijkstra (bi)
+#'   \item New bi-directional A star (NBA) : projected coordinates should be provided
+#' }
+#' 
+#' If the input graph has been contracted by cpp_contract() function, the algorithm is a modified bidirectional search.  
+#'   
 #' In A* and New Bidirectional A star algorithms, euclidean distance is used as heuristic function.
-#' To understand how A star algorithm work, see https://en.wikipedia.org/wiki/A*_search_algorithm .
-#' To understand the importance of constant parameter, see the package description : https://github.com/vlarmet/cppRouting
+#' To understand how A star algorithm work, see \url{https://en.wikipedia.org/wiki/A*_search_algorithm}.
+#' To understand the importance of constant parameter, see the package description : \url{https://github.com/vlarmet/cppRouting/blob/master/README.md}
 #' @examples
 #' #Data describing edges of the graph
 #' edges<-data.frame(from_vertex=c(0,0,1,1,2,2,3,4,4), 

R/simplify.R

@@ -1,12 +1,12 @@
 #' Reduce the number of edges by removing non-intersection nodes, duplicated edges and isolated loops in the graph.
 #' 
-#' @param Graph  An object generated by cppRouting::makegraph() function.
+#' @param Graph  An object generated by makegraph() function.
 #' @param keep Character or integer vector. Nodes of interest that will not be removed. Default to NULL
 #' @param rm_loop Logical. if TRUE, isolated loops as removed. Default to TRUE
 #' @param iterate Logical. If TRUE, process is repeated until only intersection nodes remain in the graph. Default to FALSE
 #' @param silent Logical. If TRUE and iterate set to TRUE, number of iteration and number of removed nodes are printed to the console.
 #' @return The simplified cppRouting graph
-#' @details To understand why process can be iterated, see the package description : https://github.com/vlarmet/cppRouting  
+#' @details To understand why process can be iterated, see the package description : \url{https://github.com/vlarmet/cppRouting/blob/master/README.md}  
 #' 
 #' The first iteration usually eliminates the majority of non-intersection nodes and is therefore faster.
 #' @examples