stakach-algorithms 1.0.4 → 1.0.5

data/lib/containers/kd_tree.rb

@@ -1,113 +1,113 @@
-=begin rdoc
-
-    A kd-tree is a binary tree that allows one to store points (of any space dimension: 2D, 3D, etc). 
-    The structure of the resulting tree makes it so that large portions of the tree are pruned
-    during queries.
-    
-    One very good use of the tree is to allow nearest neighbor searching. Let's say you have a number
-    of points in 2D space, and you want to find the nearest 2 points from a specific point:
-    
-    First, put the points into the tree:
-    
-      kdtree = Algorithms::Containers::KDTree.new( {0 => [4, 3], 1 => [3, 4], 2 => [-1, 2], 3 => [6, 4],
-                                       4 => [3, -5], 5 => [-2, -5] })
-    
-    Then, query on the tree:
-    
-      puts kd.find_nearest([0, 0], 2) => [[5, 2], [9, 1]]
-      
-    The result is an array of [distance, id] pairs. There seems to be a bug in this version.
-      
-    Note that the point queried on does not have to exist in the tree. However, if it does exist,
-    it will be returned.
-
-=end
-module Algorithms
-  module Containers
-    class KDTree
-      Node = Struct.new(:id, :coords, :left, :right)
-  
-      # Points is a hash of id => [coord, coord] pairs.
-      def initialize(points)
-        raise "must pass in a hash" unless points.kind_of?(Hash)
-        @dimensions = points[ points.keys.first ].size
-        @root = build_tree(points.to_a)
-        @nearest = []
-      end
-  
-      # Find k closest points to given coordinates 
-      def find_nearest(target, k_nearest)
-        @nearest = []
-        nearest(@root, target, k_nearest, 0)
-      end
-  
-      # points is an array
-      def build_tree(points, depth=0)
-        return if points.empty?
-    
-        axis = depth % @dimensions
-    
-        points.sort! { |a, b| a.last[axis] <=> b.last[axis] }
-        median = points.size / 2
-    
-        node = Node.new(points[median].first, points[median].last, nil, nil)
-        node.left = build_tree(points[0...median], depth+1)
-        node.right = build_tree(points[median+1..-1], depth+1)
-        node
-      end
-      private :build_tree
-
-      # Euclidian distanced, squared, between a node and target coords
-      def distance2(node, target)
-        return nil if node.nil? or target.nil?
-        c = (node.coords[0] - target[0])
-        d = (node.coords[1] - target[1])
-        c * c + d * d
-      end
-      private :distance2
-
-      # Update array of nearest elements if necessary
-      def check_nearest(nearest, node, target, k_nearest)
-        d = distance2(node, target) 
-        if nearest.size < k_nearest || d < nearest.last[0]
-          nearest.pop if nearest.size >= k_nearest
-          nearest << [d, node.id]
-          nearest.sort! { |a, b| a[0] <=> b[0] }
-        end
-        nearest
-      end
-      private :check_nearest
-  
-      # Recursively find nearest coordinates, going down the appropriate branch as needed
-      def nearest(node, target, k_nearest, depth)
-        axis = depth % @dimensions
-  
-        if node.left.nil? && node.right.nil? # Leaf node
-          @nearest = check_nearest(@nearest, node, target, k_nearest)
-          return
-        end
-  
-        # Go down the nearest split
-        if node.right.nil? || (node.left && target[axis] <= node.coords[axis])
-          nearer = node.left
-          further = node.right
-        else
-          nearer = node.right
-          further = node.left
-        end
-        nearest(nearer, target, k_nearest, depth+1)
-  
-        # See if we have to check other side
-        if further
-          if @nearest.size < k_nearest || (target[axis] - node.coords[axis])**2 < @nearest.last[0]
-            nearest(further, target, k_nearest, depth+1)
-          end
-        end
-  
-        @nearest = check_nearest(@nearest, node, target, k_nearest)
-      end
-      private :nearest
-  
-    end
-  end
+=begin rdoc
+
+    A kd-tree is a binary tree that allows one to store points (of any space dimension: 2D, 3D, etc). 
+    The structure of the resulting tree makes it so that large portions of the tree are pruned
+    during queries.
+    
+    One very good use of the tree is to allow nearest neighbor searching. Let's say you have a number
+    of points in 2D space, and you want to find the nearest 2 points from a specific point:
+    
+    First, put the points into the tree:
+    
+      kdtree = Algorithms::Containers::KDTree.new( {0 => [4, 3], 1 => [3, 4], 2 => [-1, 2], 3 => [6, 4],
+                                       4 => [3, -5], 5 => [-2, -5] })
+    
+    Then, query on the tree:
+    
+      puts kd.find_nearest([0, 0], 2) => [[5, 2], [9, 1]]
+      
+    The result is an array of [distance, id] pairs. There seems to be a bug in this version.
+      
+    Note that the point queried on does not have to exist in the tree. However, if it does exist,
+    it will be returned.
+
+=end
+module Algorithms
+  module Containers
+    class KDTree
+      Node = Struct.new(:id, :coords, :left, :right)
+  
+      # Points is a hash of id => [coord, coord] pairs.
+      def initialize(points)
+        raise "must pass in a hash" unless points.kind_of?(Hash)
+        @dimensions = points[ points.keys.first ].size
+        @root = build_tree(points.to_a)
+        @nearest = []
+      end
+  
+      # Find k closest points to given coordinates 
+      def find_nearest(target, k_nearest)
+        @nearest = []
+        nearest(@root, target, k_nearest, 0)
+      end
+  
+      # points is an array
+      def build_tree(points, depth=0)
+        return if points.empty?
+    
+        axis = depth % @dimensions
+    
+        points.sort! { |a, b| a.last[axis] <=> b.last[axis] }
+        median = points.size / 2
+    
+        node = Node.new(points[median].first, points[median].last, nil, nil)
+        node.left = build_tree(points[0...median], depth+1)
+        node.right = build_tree(points[median+1..-1], depth+1)
+        node
+      end
+      private :build_tree
+
+      # Euclidian distanced, squared, between a node and target coords
+      def distance2(node, target)
+        return nil if node.nil? or target.nil?
+        c = (node.coords[0] - target[0])
+        d = (node.coords[1] - target[1])
+        c * c + d * d
+      end
+      private :distance2
+
+      # Update array of nearest elements if necessary
+      def check_nearest(nearest, node, target, k_nearest)
+        d = distance2(node, target) 
+        if nearest.size < k_nearest || d < nearest.last[0]
+          nearest.pop if nearest.size >= k_nearest
+          nearest << [d, node.id]
+          nearest.sort! { |a, b| a[0] <=> b[0] }
+        end
+        nearest
+      end
+      private :check_nearest
+  
+      # Recursively find nearest coordinates, going down the appropriate branch as needed
+      def nearest(node, target, k_nearest, depth)
+        axis = depth % @dimensions
+  
+        if node.left.nil? && node.right.nil? # Leaf node
+          @nearest = check_nearest(@nearest, node, target, k_nearest)
+          return
+        end
+  
+        # Go down the nearest split
+        if node.right.nil? || (node.left && target[axis] <= node.coords[axis])
+          nearer = node.left
+          further = node.right
+        else
+          nearer = node.right
+          further = node.left
+        end
+        nearest(nearer, target, k_nearest, depth+1)
+  
+        # See if we have to check other side
+        if further
+          if @nearest.size < k_nearest || (target[axis] - node.coords[axis])**2 < @nearest.last[0]
+            nearest(further, target, k_nearest, depth+1)
+          end
+        end
+  
+        @nearest = check_nearest(@nearest, node, target, k_nearest)
+      end
+      private :nearest
+  
+    end
+  end
 end

data/lib/containers/priority_queue.rb

@@ -1,117 +1,117 @@
-require 'containers/heap'
-
-=begin rdoc
-    A Priority Queue is a data structure that behaves like a queue except that elements have an
-    associated priority. The #next and #pop methods return the item with the next highest priority.
-    
-    Priority Queues are often used in graph problems, such as Dijkstra's Algorithm for shortest
-    path, and the A* search algorithm for shortest path.
-    
-    This container is implemented using the Fibonacci heap included in the Collections library.
-=end
-module Algorithms
-  module Containers
-    class PriorityQueue
-      include Enumerable
-  
-      # Create a new, empty PriorityQueue
-      def initialize(&block)
-        # We default to a priority queue that returns the largest value
-        block ||= lambda { |x, y| (x <=> y) == 1 }
-        @heap = Heap.new(&block)
-      end
-  
-      # Returns the number of elements in the queue.
-      # 
-      #    q = Algorithms::Containers::PriorityQueue.new
-      #    q.size #=> 0
-      #    q.push("Alaska", 1)
-      #    q.size #=> 1
-      def size
-        @heap.size
-      end
-      alias_method :length, :size
-
-      # Add an object to the queue with associated priority.
-      # 
-      #   q = Algorithms::Containers::PriorityQueue.new
-      #   q.push("Alaska", 1)
-      #   q.pop #=> "Alaska"
-      def push(object, priority)    
-        @heap.push(priority, object)
-      end
-  
-      # Clears all the items in the queue.
-      def clear
-        @heap.clear
-      end
-  
-      # Returns true if the queue is empty, false otherwise.
-      def empty?
-        @heap.empty?
-      end
-
-      # call-seq:
-      #     has_priority? priority -> boolean
-      #     
-      # Return true if the priority is in the queue, false otherwise.
-      #
-      #     q = PriorityQueue.new
-      #     q.push("Alaska", 1)
-      #
-      #     q.has_priority?(1)    #=> true 
-      #     q.has_priority?(2)    #=> false
-      def has_priority?(priority)
-        @heap.has_key?(priority)
-      end
-  
-      # call-seq:
-      #     next -> object
-      #
-      # Return the object with the next highest priority, but does not remove it
-      #
-      #     q = Algorithms::Containers::PriorityQueue.new
-      #     q.push("Alaska", 50)
-      #     q.push("Delaware", 30)
-      #     q.push("Georgia", 35)
-      #     q.next          #=> "Alaska"
-      def next
-        @heap.next
-      end
-  
-      # call-seq:
-      #     pop -> object
-      #
-      # Return the object with the next highest priority and removes it from the queue
-      #
-      #     q = Algorithms::Containers::PriorityQueue.new
-      #     q.push("Alaska", 50)
-      #     q.push("Delaware", 30)
-      #     q.push("Georgia", 35)
-      #     q.pop         #=> "Alaska"
-      #     q.size        #=> 2
-      def pop
-        @heap.pop
-      end
-      alias_method :next!, :pop
-
-      # call-seq:
-      #     delete(priority) -> object
-      #     delete(priority) -> nil
-      #
-      # Delete an object with specified priority from the queue. If there are duplicates, an
-      # arbitrary object with that priority is deleted and returned. Returns nil if there are 
-      # no objects with the priority.
-      #
-      #     q = PriorityQueue.new
-      #     q.push("Alaska", 50)
-      #     q.push("Delaware", 30)
-      #     q.delete(50)            #=> "Alaska"
-      #     q.delete(10)            #=> nil
-      def delete(priority)
-        @heap.delete(priority)
-      end
-
-    end
-  end
+require 'containers/heap'
+
+=begin rdoc
+    A Priority Queue is a data structure that behaves like a queue except that elements have an
+    associated priority. The #next and #pop methods return the item with the next highest priority.
+    
+    Priority Queues are often used in graph problems, such as Dijkstra's Algorithm for shortest
+    path, and the A* search algorithm for shortest path.
+    
+    This container is implemented using the Fibonacci heap included in the Collections library.
+=end
+module Algorithms
+  module Containers
+    class PriorityQueue
+      include Enumerable
+  
+      # Create a new, empty PriorityQueue
+      def initialize(&block)
+        # We default to a priority queue that returns the largest value
+        block ||= lambda { |x, y| (x <=> y) == 1 }
+        @heap = Heap.new(&block)
+      end
+  
+      # Returns the number of elements in the queue.
+      # 
+      #    q = Algorithms::Containers::PriorityQueue.new
+      #    q.size #=> 0
+      #    q.push("Alaska", 1)
+      #    q.size #=> 1
+      def size
+        @heap.size
+      end
+      alias_method :length, :size
+
+      # Add an object to the queue with associated priority.
+      # 
+      #   q = Algorithms::Containers::PriorityQueue.new
+      #   q.push("Alaska", 1)
+      #   q.pop #=> "Alaska"
+      def push(object, priority)    
+        @heap.push(priority, object)
+      end
+  
+      # Clears all the items in the queue.
+      def clear
+        @heap.clear
+      end
+  
+      # Returns true if the queue is empty, false otherwise.
+      def empty?
+        @heap.empty?
+      end
+
+      # call-seq:
+      #     has_priority? priority -> boolean
+      #     
+      # Return true if the priority is in the queue, false otherwise.
+      #
+      #     q = PriorityQueue.new
+      #     q.push("Alaska", 1)
+      #
+      #     q.has_priority?(1)    #=> true 
+      #     q.has_priority?(2)    #=> false
+      def has_priority?(priority)
+        @heap.has_key?(priority)
+      end
+  
+      # call-seq:
+      #     next -> object
+      #
+      # Return the object with the next highest priority, but does not remove it
+      #
+      #     q = Algorithms::Containers::PriorityQueue.new
+      #     q.push("Alaska", 50)
+      #     q.push("Delaware", 30)
+      #     q.push("Georgia", 35)
+      #     q.next          #=> "Alaska"
+      def next
+        @heap.next
+      end
+  
+      # call-seq:
+      #     pop -> object
+      #
+      # Return the object with the next highest priority and removes it from the queue
+      #
+      #     q = Algorithms::Containers::PriorityQueue.new
+      #     q.push("Alaska", 50)
+      #     q.push("Delaware", 30)
+      #     q.push("Georgia", 35)
+      #     q.pop         #=> "Alaska"
+      #     q.size        #=> 2
+      def pop
+        @heap.pop
+      end
+      alias_method :next!, :pop
+
+      # call-seq:
+      #     delete(priority) -> object
+      #     delete(priority) -> nil
+      #
+      # Delete an object with specified priority from the queue. If there are duplicates, an
+      # arbitrary object with that priority is deleted and returned. Returns nil if there are 
+      # no objects with the priority.
+      #
+      #     q = PriorityQueue.new
+      #     q.push("Alaska", 50)
+      #     q.push("Delaware", 30)
+      #     q.delete(50)            #=> "Alaska"
+      #     q.delete(10)            #=> nil
+      def delete(priority)
+        @heap.delete(priority)
+      end
+
+    end
+  end
 end

data/lib/containers/queue.rb

@@ -1,72 +1,72 @@
-require 'containers/deque'
-
-=begin rdoc
-    A Queue is a container that keeps elements in a first-in first-out (FIFO) order. Because of its
-    properties, it is often used as a buffer.
-    
-    This implementation uses a doubly-linked list, guaranteeing O(1) complexity for all operations.
-    
-=end
-module Algorithms
-  module Containers
-    class Queue
-      include Enumerable
-      # Create a new queue. Takes an optional array argument to initialize the queue.
-      #
-      #   q = Algorithms::Containers::Queue.new([1, 2, 3])
-      #   q.pop #=> 1
-      #   q.pop #=> 2
-      def initialize(ary=[])
-        @container = Deque.new(ary)
-      end
-   
-      # Returns the next item from the queue but does not remove it.
-      #
-      #   q = Algorithms::Containers::Queue.new([1, 2, 3])
-      #   q.next #=> 1
-      #   q.size #=> 3
-      def next
-        @container.front
-      end
-      
-      # Adds an item to the queue.
-      #
-      #   q = Algorithms::Containers::Queue.new([1])
-      #   q.push(2)
-      #   q.pop #=> 1
-      #   q.pop #=> 2
-      def push(obj)
-        @container.push_back(obj)
-      end
-      alias_method :<<, :push
-  
-      # Removes the next item from the queue and returns it.
-      #
-      #   q = Algorithms::Containers::Queue.new([1, 2, 3])
-      #   q.pop #=> 1
-      #   q.size #=> 2
-      def pop
-        @container.pop_front
-      end
-  
-      # Return the number of items in the queue.
-      #
-      #   q = Algorithms::Containers::Queue.new([1, 2, 3])
-      #   q.size #=> 3
-      def size
-        @container.size
-      end
-  
-      # Returns true if the queue is empty, false otherwise.
-      def empty?
-        @container.empty?
-      end
-  
-      # Iterate over the Queue in FIFO order.
-      def each(&block)
-        @container.each_forward(&block)
-      end
-
-    end
-  end
+require 'containers/deque'
+
+=begin rdoc
+    A Queue is a container that keeps elements in a first-in first-out (FIFO) order. Because of its
+    properties, it is often used as a buffer.
+    
+    This implementation uses a doubly-linked list, guaranteeing O(1) complexity for all operations.
+    
+=end
+module Algorithms
+  module Containers
+    class Queue
+      include Enumerable
+      # Create a new queue. Takes an optional array argument to initialize the queue.
+      #
+      #   q = Algorithms::Containers::Queue.new([1, 2, 3])
+      #   q.pop #=> 1
+      #   q.pop #=> 2
+      def initialize(ary=[])
+        @container = Deque.new(ary)
+      end
+   
+      # Returns the next item from the queue but does not remove it.
+      #
+      #   q = Algorithms::Containers::Queue.new([1, 2, 3])
+      #   q.next #=> 1
+      #   q.size #=> 3
+      def next
+        @container.front
+      end
+      
+      # Adds an item to the queue.
+      #
+      #   q = Algorithms::Containers::Queue.new([1])
+      #   q.push(2)
+      #   q.pop #=> 1
+      #   q.pop #=> 2
+      def push(obj)
+        @container.push_back(obj)
+      end
+      alias_method :<<, :push
+  
+      # Removes the next item from the queue and returns it.
+      #
+      #   q = Algorithms::Containers::Queue.new([1, 2, 3])
+      #   q.pop #=> 1
+      #   q.size #=> 2
+      def pop
+        @container.pop_front
+      end
+  
+      # Return the number of items in the queue.
+      #
+      #   q = Algorithms::Containers::Queue.new([1, 2, 3])
+      #   q.size #=> 3
+      def size
+        @container.size
+      end
+  
+      # Returns true if the queue is empty, false otherwise.
+      def empty?
+        @container.empty?
+      end
+  
+      # Iterate over the Queue in FIFO order.
+      def each(&block)
+        @container.each_forward(&block)
+      end
+
+    end
+  end
 end