stakach-algorithms 1.0.4 → 1.0.5

data/lib/algorithms/string.rb

@@ -1,10 +1,10 @@
-=begin rdoc
-    This module implements string algorithms. Documentation is provided for each algorithm.
-    
-=end
-
-
-begin
-	require 'CString' unless RUBY_PLATFORM =~ /java/
-rescue
-end
+=begin rdoc
+    This module implements string algorithms. Documentation is provided for each algorithm.
+    
+=end
+
+
+begin
+	require 'CString' unless RUBY_PLATFORM =~ /java/
+rescue
+end

data/lib/algorithms/version.rb

@@ -1,3 +1,3 @@
 module Algorithms
-	VERSION = "1.0.4"
+	VERSION = "1.0.5"
 end

data/lib/algorithms.rb

@@ -1,69 +1,69 @@
-=begin rdoc
-  The 'Algorithms and Containers' library is an effort to provide a set of commonly used
-  algorithms and containers to Ruby programmers.
-
-  This is a Google Summer of Code 2008 project
-
-  Written by Kanwei Li, mentored by Austin Ziegler
-
-  To avoid typing Algorithms::Containers::xxx to initialize containers, include the Algorithms namespace and Containers module.
-
-    require 'algorithms'
-    include Algorithms
-    include Containers
-
-    tree = RBTreeMap.new
-
-  instead of:
-
-    require 'algorithms'
-
-    tree = Algorithms::Containers::RBTreeMap.new
-
-  Done so far:
-  * Heaps           - Algorithms::Containers::Heap, Algorithms::Containers::MaxHeap, Algorithms::Containers::MinHeap
-  * Priority Queue  - Algorithms::Containers::PriorityQueue
-  * Stack           - Algorithms::Containers::Stack
-  * Queue           - Algorithms::Containers::Queue
-  * Deque           - Algorithms::Containers::Deque, Algorithms::Containers::CDeque (C extension), Algorithms::Containers::RubyDeque
-  * Red-Black Trees - Algorithms::Containers::RBTreeMap, Algorithms::Containers::CRBTreeMap (C extension), Algorithms::Containers::RubyRBTreeMap
-  * Splay Trees     - Algorithms::Containers::SplayTreeMap
-  * Tries           - Algorithms::Containers::Trie
-  * Suffix Array    - Algorithms::Containers::SuffixArray
-  * kd Tree         - Algorithms::Containers::KDTree
-
-  * Search algorithms
-    - Binary Search         - Algorithms::Algorithms::Search.binary_search
-    - Knuth-Morris-Pratt    - Algorithms::Algorithms::Search.kmp_search
-  * Sort algorithms
-    - Bubble sort           - Algorithms::Algorithms::Sort.bubble_sort
-    - Comb sort             - Algorithms::Algorithms::Sort.comb_sort
-    - Selection sort        - Algorithms::Algorithms::Sort.selection_sort
-    - Heapsort              - Algorithms::Algorithms::Sort.heapsort
-    - Insertion sort        - Algorithms::Algorithms::Sort.insertion_sort
-    - Shell sort            - Algorithms::Algorithms::Sort.shell_sort
-    - Quicksort             - Algorithms::Algorithms::Sort.quicksort
-    - Mergesort             - Algorithms::Algorithms::Sort.mergesort
-  * String algorithms
-    - Levenshtein distance  - Algorithms::Algorithms::String.levenshtein_dist
-=end
-
-module Algorithms
-  module Algorithms; end
-  module Containers; end
-end
-
-require 'algorithms/search'
-require 'algorithms/sort'
-require 'algorithms/string'
-require 'containers/heap'
-require 'containers/stack'
-require 'containers/deque'
-require 'containers/queue'
-require 'containers/priority_queue'
-require 'containers/rb_tree_map'
-require 'containers/splay_tree_map'
-require 'containers/suffix_array'
-require 'containers/trie'
-require 'containers/kd_tree'
-
+=begin rdoc
+  The 'Algorithms and Containers' library is an effort to provide a set of commonly used
+  algorithms and containers to Ruby programmers.
+
+  This is a Google Summer of Code 2008 project
+
+  Written by Kanwei Li, mentored by Austin Ziegler
+
+  To avoid typing Algorithms::Containers::xxx to initialize containers, include the Algorithms namespace and Containers module.
+
+    require 'algorithms'
+    include Algorithms
+    include Containers
+
+    tree = RBTreeMap.new
+
+  instead of:
+
+    require 'algorithms'
+
+    tree = Algorithms::Containers::RBTreeMap.new
+
+  Done so far:
+  * Heaps           - Algorithms::Containers::Heap, Algorithms::Containers::MaxHeap, Algorithms::Containers::MinHeap
+  * Priority Queue  - Algorithms::Containers::PriorityQueue
+  * Stack           - Algorithms::Containers::Stack
+  * Queue           - Algorithms::Containers::Queue
+  * Deque           - Algorithms::Containers::Deque, Algorithms::Containers::CDeque (C extension), Algorithms::Containers::RubyDeque
+  * Red-Black Trees - Algorithms::Containers::RBTreeMap, Algorithms::Containers::CRBTreeMap (C extension), Algorithms::Containers::RubyRBTreeMap
+  * Splay Trees     - Algorithms::Containers::SplayTreeMap
+  * Tries           - Algorithms::Containers::Trie
+  * Suffix Array    - Algorithms::Containers::SuffixArray
+  * kd Tree         - Algorithms::Containers::KDTree
+
+  * Search algorithms
+    - Binary Search         - Algorithms::Algorithms::Search.binary_search
+    - Knuth-Morris-Pratt    - Algorithms::Algorithms::Search.kmp_search
+  * Sort algorithms
+    - Bubble sort           - Algorithms::Algorithms::Sort.bubble_sort
+    - Comb sort             - Algorithms::Algorithms::Sort.comb_sort
+    - Selection sort        - Algorithms::Algorithms::Sort.selection_sort
+    - Heapsort              - Algorithms::Algorithms::Sort.heapsort
+    - Insertion sort        - Algorithms::Algorithms::Sort.insertion_sort
+    - Shell sort            - Algorithms::Algorithms::Sort.shell_sort
+    - Quicksort             - Algorithms::Algorithms::Sort.quicksort
+    - Mergesort             - Algorithms::Algorithms::Sort.mergesort
+  * String algorithms
+    - Levenshtein distance  - Algorithms::Algorithms::String.levenshtein_dist
+=end
+
+module Algorithms
+  module Algorithms; end
+  module Containers; end
+end
+
+require 'algorithms/search'
+require 'algorithms/sort'
+require 'algorithms/string'
+require 'containers/heap'
+require 'containers/stack'
+require 'containers/deque'
+require 'containers/queue'
+require 'containers/priority_queue'
+require 'containers/rb_tree_map'
+require 'containers/splay_tree_map'
+require 'containers/suffix_array'
+require 'containers/trie'
+require 'containers/kd_tree'
+

data/lib/containers/deque.rb

@@ -1,176 +1,176 @@
-=begin rdoc
-    A Deque is a container that allows items to be added and removed from both the front and back,
-    acting as a combination of a Stack and Queue.
-
-    This implementation uses a doubly-linked list, guaranteeing O(1) complexity for all operations.
-=end
-module Algorithms
-  module Containers
-    class RubyDeque
-      include Enumerable
-  
-      Node = Struct.new(:left, :right, :obj)
-  
-      # Create a new Deque. Takes an optional array argument to initialize the Deque.
-      #
-      #   d = Containers::Deque.new([1, 2, 3])
-      #   d.front #=> 1
-      #   d.back #=> 3
-      def initialize(ary=[])
-        @front = nil
-        @back = nil
-        @size = 0
-        ary.to_a.each { |obj| push_back(obj) }
-      end
-  
-      # Returns true if the Deque is empty, false otherwise.
-      def empty?
-        @size == 0
-      end
-  
-      # Removes all the objects in the Deque.
-      def clear
-        @front = @back = nil
-        @size = 0
-      end
-  
-      # Return the number of items in the Deque.
-      #
-      #   d = Containers::Deque.new([1, 2, 3])
-      #   d.size #=> 3
-      def size
-        @size
-      end
-      alias_method :length, :size
-  
-      # Returns the object at the front of the Deque but does not remove it.
-      #
-      #   d = Containers::Deque.new
-      #   d.push_front(1)
-      #   d.push_front(2)
-      #   d.front #=> 2
-      def front
-        @front && @front.obj
-      end
-  
-      # Returns the object at the back of the Deque but does not remove it.
-      #
-      #   d = Containers::Deque.new
-      #   d.push_front(1)
-      #   d.push_front(2)
-      #   d.back #=> 1
-      def back
-        @back && @back.obj
-      end
-  
-      # Adds an object at the front of the Deque.
-      #
-      #   d = Containers::Deque.new([1, 2, 3])
-      #   d.push_front(0)
-      #   d.pop_front #=> 0
-      def push_front(obj)
-        node = Node.new(nil, nil, obj)
-        if @front
-          node.right = @front
-          @front.left = node
-          @front = node
-        else
-          @front = @back = node
-        end
-        @size += 1
-        obj
-      end
-  
-      # Adds an object at the back of the Deque.
-      #
-      #   d = Containers::Deque.new([1, 2, 3])
-      #   d.push_back(4)
-      #   d.pop_back #=> 4
-      def push_back(obj)
-        node = Node.new(nil, nil, obj)
-        if @back
-          node.left = @back
-          @back.right = node
-          @back = node
-        else
-          @front = @back = node
-        end
-        @size += 1
-        obj
-      end
-  
-      # Returns the object at the front of the Deque and removes it.
-      #
-      #   d = Containers::Deque.new
-      #   d.push_front(1)
-      #   d.push_front(2)
-      #   d.pop_front #=> 2
-      #   d.size #=> 1
-      def pop_front
-        return nil unless @front
-        node = @front
-        if @size == 1
-          clear
-          return node.obj
-        else
-          @front.right.left = nil
-          @front = @front.right
-        end
-        @size -= 1
-        node.obj
-      end
-  
-      # Returns the object at the back of the Deque and removes it.
-      #
-      #   d = Containers::Deque.new
-      #   d.push_front(1)
-      #   d.push_front(2)
-      #   d.pop_back #=> 1
-      #   d.size #=> 1
-      def pop_back
-        return nil unless @back
-        node = @back
-        if @size == 1
-          clear
-          return node.obj
-        else
-          @back.left.right = nil
-          @back = @back.left
-        end
-        @size -= 1
-        node.obj
-      end
-  
-      # Iterate over the Deque in FIFO order.
-      def each_forward
-        return unless @front
-        node = @front
-        while node
-          yield node.obj
-          node = node.right
-        end
-      end
-      alias_method :each, :each_forward
-  
-      # Iterate over the Deque in LIFO order.
-      def each_backward
-        return unless @back
-        node = @back
-        while node
-          yield node.obj
-          node = node.left
-        end
-      end
-      alias_method :reverse_each, :each_backward
-
-    end
-  end
-  
-  begin
-    require 'CDeque'
-    Containers::Deque = Containers::CDeque
-  rescue LoadError # C Version could not be found, try ruby version
-    Containers::Deque = Containers::RubyDeque
-  end
-
-end
+=begin rdoc
+    A Deque is a container that allows items to be added and removed from both the front and back,
+    acting as a combination of a Stack and Queue.
+
+    This implementation uses a doubly-linked list, guaranteeing O(1) complexity for all operations.
+=end
+module Algorithms
+  module Containers
+    class RubyDeque
+      include Enumerable
+  
+      Node = Struct.new(:left, :right, :obj)
+  
+      # Create a new Deque. Takes an optional array argument to initialize the Deque.
+      #
+      #   d = Containers::Deque.new([1, 2, 3])
+      #   d.front #=> 1
+      #   d.back #=> 3
+      def initialize(ary=[])
+        @front = nil
+        @back = nil
+        @size = 0
+        ary.to_a.each { |obj| push_back(obj) }
+      end
+  
+      # Returns true if the Deque is empty, false otherwise.
+      def empty?
+        @size == 0
+      end
+  
+      # Removes all the objects in the Deque.
+      def clear
+        @front = @back = nil
+        @size = 0
+      end
+  
+      # Return the number of items in the Deque.
+      #
+      #   d = Containers::Deque.new([1, 2, 3])
+      #   d.size #=> 3
+      def size
+        @size
+      end
+      alias_method :length, :size
+  
+      # Returns the object at the front of the Deque but does not remove it.
+      #
+      #   d = Containers::Deque.new
+      #   d.push_front(1)
+      #   d.push_front(2)
+      #   d.front #=> 2
+      def front
+        @front && @front.obj
+      end
+  
+      # Returns the object at the back of the Deque but does not remove it.
+      #
+      #   d = Containers::Deque.new
+      #   d.push_front(1)
+      #   d.push_front(2)
+      #   d.back #=> 1
+      def back
+        @back && @back.obj
+      end
+  
+      # Adds an object at the front of the Deque.
+      #
+      #   d = Containers::Deque.new([1, 2, 3])
+      #   d.push_front(0)
+      #   d.pop_front #=> 0
+      def push_front(obj)
+        node = Node.new(nil, nil, obj)
+        if @front
+          node.right = @front
+          @front.left = node
+          @front = node
+        else
+          @front = @back = node
+        end
+        @size += 1
+        obj
+      end
+  
+      # Adds an object at the back of the Deque.
+      #
+      #   d = Containers::Deque.new([1, 2, 3])
+      #   d.push_back(4)
+      #   d.pop_back #=> 4
+      def push_back(obj)
+        node = Node.new(nil, nil, obj)
+        if @back
+          node.left = @back
+          @back.right = node
+          @back = node
+        else
+          @front = @back = node
+        end
+        @size += 1
+        obj
+      end
+  
+      # Returns the object at the front of the Deque and removes it.
+      #
+      #   d = Containers::Deque.new
+      #   d.push_front(1)
+      #   d.push_front(2)
+      #   d.pop_front #=> 2
+      #   d.size #=> 1
+      def pop_front
+        return nil unless @front
+        node = @front
+        if @size == 1
+          clear
+          return node.obj
+        else
+          @front.right.left = nil
+          @front = @front.right
+        end
+        @size -= 1
+        node.obj
+      end
+  
+      # Returns the object at the back of the Deque and removes it.
+      #
+      #   d = Containers::Deque.new
+      #   d.push_front(1)
+      #   d.push_front(2)
+      #   d.pop_back #=> 1
+      #   d.size #=> 1
+      def pop_back
+        return nil unless @back
+        node = @back
+        if @size == 1
+          clear
+          return node.obj
+        else
+          @back.left.right = nil
+          @back = @back.left
+        end
+        @size -= 1
+        node.obj
+      end
+  
+      # Iterate over the Deque in FIFO order.
+      def each_forward
+        return unless @front
+        node = @front
+        while node
+          yield node.obj
+          node = node.right
+        end
+      end
+      alias_method :each, :each_forward
+  
+      # Iterate over the Deque in LIFO order.
+      def each_backward
+        return unless @back
+        node = @back
+        while node
+          yield node.obj
+          node = node.left
+        end
+      end
+      alias_method :reverse_each, :each_backward
+
+    end
+  end
+  
+  begin
+    require 'CDeque'
+    Containers::Deque = Containers::CDeque
+  rescue  # C Version could not be found, try ruby version
+    Containers::Deque = Containers::RubyDeque
+  end
+
+end