dijkstra_graph 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 40d8dfafa22964edb55043f62194663df6ffe708
-  data.tar.gz: 7c76517bd99090caca0eb6bafb488c147851391f
+  metadata.gz: d771e3085a0ffda14a30fc7fa92cf8e69208e984
+  data.tar.gz: 315da882ae3971d9c9a92e92755812074b5d4f3c
 SHA512:
-  metadata.gz: 06cd0b89391979779f79bca07e34d8ea6e4917249d9d7d3a748f9c7843859e7b83acf6d6d248cc405e6a9683f3d3fbd5cbafb9283c4d5b8b626c483adf99cecf
-  data.tar.gz: 610fce885958f2aa28ae069448368fb080df6a24f74ab265d955b2d4739e4c281ea83bb5e13df4ca877c673979b7ed1bccba276c0fb08ce4517c9ac4092a2bbd
+  metadata.gz: 5b0ceec8d23b964237a72e57ddcf3697300dbf755910a5ba3a459e36a0860e7cdd5818a2f8eeb8cef34bd3185b45cd9ca0aad47c145d29c1bd761cbf01b096c9
+  data.tar.gz: 5917752b4b7fefdf63a149b6d70c2d4e7134b21de7621d0bfc49e8992e017eb23a1423f75ae47d6c3ee27021b487a3e76b79bfda3d866dc5fac4d92b7f9df0bc

data/.rubocop.yml

@@ -1,4 +1,4 @@
-Style/BlockLength:
+Metrics/BlockLength:
   Exclude:
     - 'dijkstra_graph.gemspec'
     - 'Rakefile'

data/README.md

@@ -32,25 +32,71 @@ get_edge_weight(source, destination)
 get_adjacent_vertices(source)
 
 # Use Dijkstra's algorithm to find the shortest distances
-# from the start vertex to each of the other vertices
+# from the source vertex to each of the other vertices
 #
-# Returns a hash of form { 'start' => 0, 'a' => 3, 'b' => 4 },
-# where result[v] indicates the shortest distance from start to v
-shortest_distances(start)
+# Returns a hash of form { 'source' => 0, 'a' => 3, 'b' => 4 },
+# where result[v] indicates the shortest distance from source to v
+shortest_distances(source)
 
 # Use Dijkstra's algorithm to find the shortest paths
-# from the start vertex to each of the other vertices
+# from the source vertex to each of the other vertices
 #
 # Returns a hash of form { 'c' => ['a', 'b', 'c'] }, where
-# result[v] indicates the shortest path from start to v
-shortest_paths(start)
+# result[v] indicates the shortest path from source to v
+shortest_paths(source)
+
+# Use Dijkstra's algorithm to find the shortest paths
+# from the source vertex to vertices within a given radius
+#
+# Returns a hash of form { 'c' => ['a', 'b', 'c'] }, where
+# result[v] indicates the shortest path from source to v
+shortest_paths_in_radius(source, radius)
 
 # Use Dijkstra's algorithm to find the shortest path
-# from the start vertex to the destination vertex
+# from the source vertex to the destination vertex
 #
 # Returns an array of vertices along the shortest path
 # of form ['a', 'b', 'c'], or [] if no such path exists
-shortest_path(start, destination)
+shortest_path(source, destination)
+```
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'dijkstra_graph'
+```
+
+Then you can require the gem in Ruby programs:
+
+```ruby
+require 'dijkstra_graph'
+
+graph = DijkstraGraph::Graph.new
+graph.add_undirected_edge('Burnaby', 'Vancouver', 10)
+graph.add_edge('Burnaby', 'Port Coquitlam', 23)
+graph.add_edge('Vancouver', 'Langley', 37)
+graph.add_undirected_edge('Langley', 'Port Coquitlam', 35)
+shortest_paths_from_vancouver = graph.shortest_paths('Vancouver')
+
+# => { 'Burnaby' => ['Vancouver', 'Burnaby'],
+#      'Langley' => ['Vancouver', 'Langley'],
+#      'Port Coquitlam' => ['Vancouver', 'Burnaby', 'Port Coquitlam'] }
+
+van_paths_within_35k = graph.shortest_paths_in_radius('Vancouver', 35)
+
+# => { 'Burnaby' => ['Vancouver', 'Burnaby'],
+#      'Port Coquitlam' => ['Vancouver', 'Burnaby', 'Port Coquitlam'] }
+
+van_to_portco_path = graph.shortest_path('Vancouver', 'Port Coquitlam')
+
+# => ['Vancouver', 'Burnaby', 'Port Coquitlam']
+
+distances_from_vancouver = graph.shortest_distances('Vancouver')
+
+# => { 'Vancouver' => 0, 'Burnaby' => 10,
+#      'Langley' => 37, 'Port Coquitlam' => 33 }
 ```
 
 ## Development
@@ -63,4 +109,4 @@ Bug reports and pull requests are welcome on GitHub at https://github.com/msayso
 
 ## License
 
-The weighted_graph library is open source and available under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+The dijkstra_graph library is open source and available under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/lib/dijkstra_graph/graph.rb

@@ -13,7 +13,7 @@ module DijkstraGraph
   # Vertices 'to-visit' are stored in a priority queue that
   # uses a Fibonacci heap to give O(1) insert, amortized O(1)
   # decrease_priority, and amortized O(log n) delete_min.
-  # Priority represents path distance from the start vertex.
+  # Priority represents path distance from the source vertex.
   #
   # The shortest distances found so far to each vertex are
   # stored in a simple hash which gives O(1) read/write.
@@ -24,13 +24,13 @@ module DijkstraGraph
     end
 
     # Use Dijkstra's algorithm to find the shortest distances
-    # from the start vertex to each of the other vertices
+    # from the source vertex to each of the other vertices
     #
-    # Returns a hash of form { 'start' => 0, 'a' => 3, 'b' => 4 },
-    # where result[v] indicates the shortest distance from start to v
-    def shortest_distances(start)
+    # Returns a hash of form { 'source' => 0, 'a' => 3, 'b' => 4 },
+    # where result[v] indicates the shortest distance from source to v
+    def shortest_distances(source)
       distances = Hash.new { Float::INFINITY } # Initial distances = Inf
-      queue = initialize_queue(start)          # Begin at start node
+      queue = initialize_queue(source)         # Begin at source node
       until queue.empty?
         v, distances[v] = queue.delete_min     # Visit next closest vertex
         update_distances_to_neighbours(v, distances, queue) # Update neighbours
@@ -39,69 +39,108 @@ module DijkstraGraph
     end
 
     # Use Dijkstra's algorithm to find the shortest paths
-    # from the start vertex to each of the other vertices
+    # from the source vertex to each of the other vertices
     #
     # Returns a hash of form { 'c' => ['a', 'b', 'c'] }, where
-    # result[v] indicates the shortest path from start to v
-    def shortest_paths(start)
+    # result[v] indicates the shortest path from source to v
+    def shortest_paths(source)
       predecessors = {}                        # Initialize vertex predecessors
       distances = Hash.new { Float::INFINITY } # Initialize distances to Inf
-      queue = initialize_queue(start)          # Initialize queue with start
+      queue = initialize_queue(source)         # Initialize queue with source
       until queue.empty?
         # Visit next closest vertex and update neighbours
         v, distances[v] = queue.delete_min
-        update_paths_to_neighbours(v, predecessors, distances, queue)
+        update_paths_to_neighbours(v, distances, queue, predecessors)
       end
-      PathUtil.path_arrays(predecessors, start)
+      PathUtil.path_arrays(predecessors, source)
+    end
+
+    # Use Dijkstra's algorithm to find the shortest paths
+    # from the source vertex to vertices within a given radius
+    #
+    # Returns a hash of form { 'c' => ['a', 'b', 'c'] }, where
+    # result[v] indicates the shortest path from source to v
+    def shortest_paths_in_radius(source, radius)
+      predecessors = {}                        # Initialize vertex predecessors
+      distances = Hash.new { Float::INFINITY } # Initialize distances to Inf
+      queue = initialize_queue(source)         # Initialize queue with source
+      until queue.empty?
+        # Visit next closest vertex and update neighbours
+        v, distance = queue.delete_min
+        return PathUtil.path_arrays(predecessors, source) if distance > radius
+        distances[v] = distance
+        update_neighbours_in_radius(v, distances, queue, predecessors, radius)
+      end
+      PathUtil.path_arrays(predecessors, source)
     end
 
     # Use Dijkstra's algorithm to find the shortest path
-    # from the start vertex to the destination vertex
+    # from the source vertex to the destination vertex
     #
     # Returns an array of vertices along the shortest path
     # of form ['a', 'b', 'c'], or [] if no such path exists
-    def shortest_path(start, dest)
+    def shortest_path(source, dest)
       predecessors = {}                        # Initialize vertex predecessors
       distances = Hash.new { Float::INFINITY } # Initialize distances to Inf
-      queue = initialize_queue(start)          # Initialize queue with start
+      queue = initialize_queue(source)         # Initialize queue with source
       until queue.empty?
         v, distances[v] = queue.delete_min     # Visit next closest node
-        return PathUtil.path_array(predecessors, start, dest) if v == dest
-        update_paths_to_neighbours(v, predecessors, distances, queue)
+        return PathUtil.path_array(predecessors, source, dest) if v == dest
+        update_paths_to_neighbours(v, distances, queue, predecessors)
       end
-      [] # No path found from start to dest
+      [] # No path found from source to dest
     end
 
     private
 
-    # Initialize priority queue with start vertex at distance = 0
-    def initialize_queue(start_vertex)
+    # Initialize priority queue with source vertex at distance = 0
+    def initialize_queue(source_vertex)
       queue = PriorityQueue.new
-      queue[start_vertex] = 0
+      queue[source_vertex] = 0
       queue
     end
 
     # Update distances to neighbours of v and queue changed neighbours
     def update_distances_to_neighbours(v, distances, queue)
-      distance_v = distances[v]
-      get_adjacent_vertices(v).each do |w|
-        distance_through_v = distance_v + get_edge_weight(v, w)
-        if distance_through_v < distances[w]
-          queue[w] = distances[w] = distance_through_v
-        end
-      end
+      update_neighbours(v, distances, method(:update_distance),
+                        distances: distances, queue: queue)
     end
 
     # Update paths to neighbours of v and queue changed neighbours
-    def update_paths_to_neighbours(v, predecessors, distances, queue)
+    def update_paths_to_neighbours(v, distances, queue, predecessors)
+      update_neighbours(v, distances, method(:update_path),
+                        distances: distances, queue: queue,
+                        predecessors: predecessors, predecessor: v)
+    end
+
+    # Update paths to neighbours of v in radius and queue changed neighbours
+    def update_neighbours_in_radius(v, distances, queue, predecessors, radius)
+      update_neighbours(v, distances, method(:update_path),
+                        distances: distances, queue: queue, radius: radius,
+                        predecessors: predecessors, predecessor: v)
+    end
+
+    # Apply given method to each neighbour we find a shorter path to
+    def update_neighbours(v, distances, update_method, update_params)
       distance_v = distances[v]
       get_adjacent_vertices(v).each do |w|
         distance_through_v = distance_v + get_edge_weight(v, w)
         if distance_through_v < distances[w]
-          queue[w] = distances[w] = distance_through_v
-          predecessors[w] = v
+          update_method.call(w, distance_through_v, update_params)
         end
       end
     end
+
+    # Update shortest distance to vertex
+    def update_distance(vertex, distance, params)
+      params[:queue][vertex] = params[:distances][vertex] = distance
+    end
+
+    # Update shortest path to vertex
+    def update_path(vertex, distance, params)
+      return if params[:radius] && distance > params[:radius]
+      update_distance(vertex, distance, params)
+      params[:predecessors][vertex] = params[:predecessor]
+    end
   end
 end

data/lib/dijkstra_graph/version.rb

@@ -1,3 +1,3 @@
 module DijkstraGraph
-  VERSION = '0.1.0'.freeze
+  VERSION = '0.1.1'.freeze
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dijkstra_graph
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Mark Sayson