renaudb-batfish 0.1.0 → 0.1.1

data/README.rdoc

@@ -4,6 +4,10 @@ Just a bunch of functions.
 
 Batfish is a collection of useful algorithms and data structures that I developed through the years for various projects. I decided to publish in case my hard drive comes to crash and for everyone to use.
 
+http://renaudbourassa.com/projects/batfish/
+
+http://github.com/renaudb/batfish/
+
 == Install
 
 If you haven't already, add github's gem server to your sources:
@@ -38,5 +42,9 @@ Here is a list of the algorithms and data structures batfish implements.
 
 === Data Structures
 
+- Linked List
+  - Sorted Linked List
+- Stack
+- Queue
 - BK-Tree
 - Trie

data/Rakefile

@@ -2,19 +2,6 @@ require 'rake'
 require 'rake/testtask'
 require 'rake/rdoctask'
 
-begin
-  require 'jeweler'
-  Jeweler::Tasks.new do |gemspec|
-    gemspec.name     = "batfish"
-    gemspec.summary  = "Just a bunch of functions."
-    gemspec.email    = "me@renaudbourassa.com"
-    gemspec.homepage = "http://github.com/renaudb/batfish"
-    gemspec.authors  = ["Renaud Bourassa"]
-  end
-rescue LoadError
-  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
-end
-
 Rake::TestTask.new do |t|
   t.test_files = FileList['test/test*.rb']
   t.verbose = true

data/batfish.gemspec

@@ -1,29 +1,31 @@
-# Generated by jeweler
-# DO NOT EDIT THIS FILE
-# Instead, edit Jeweler::Tasks in Rakefile, and run `rake gemspec`
 # -*- encoding: utf-8 -*-
 
 Gem::Specification.new do |s|
   s.name = %q{batfish}
-  s.version = "0.1.0"
+  s.version = "0.1.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Renaud Bourassa"]
-  s.date = %q{2009-08-23}
+  s.date = %q{2009-09-23}
   s.email = %q{me@renaudbourassa.com}
   s.extra_rdoc_files = [
-    "README.rdoc"
+     "README.rdoc"
   ]
   s.files = [
-    "README.rdoc",
+     "README.rdoc",
      "Rakefile",
-     "VERSION",
      "batfish.gemspec",
      "lib/batfish.rb",
      "lib/data/bktree.rb",
+     "lib/data/linkedlist.rb",
+     "lib/data/queue.rb",
+     "lib/data/stack.rb",
      "lib/data/trie.rb",
      "test/helper.rb",
      "test/test_bktree.rb",
+     "test/test_linkedlist.rb",
+     "test/test_queue.rb",
+     "test/test_stack.rb",
      "test/test_trie.rb"
   ]
   s.homepage = %q{http://github.com/renaudb/batfish}
@@ -32,8 +34,11 @@ Gem::Specification.new do |s|
   s.rubygems_version = %q{1.3.3}
   s.summary = %q{Just a bunch of functions.}
   s.test_files = [
-    "test/helper.rb",
+     "test/helper.rb",
      "test/test_bktree.rb",
+     "test/test_linkedlist.rb",
+     "test/test_queue.rb",
+     "test/test_stack.rb",
      "test/test_trie.rb"
   ]
 

data/lib/batfish.rb

@@ -1,2 +1,5 @@
-require 'data/trie'
-require 'data/bktree'
+require File.dirname(__FILE__) + '/data/linkedlist'
+require File.dirname(__FILE__) + '/data/stack'
+require File.dirname(__FILE__) + '/data/queue'
+require File.dirname(__FILE__) + '/data/trie'
+require File.dirname(__FILE__) + '/data/bktree'

data/lib/data/bktree.rb

@@ -1,6 +1,6 @@
 module Batfish
 
-  # A BK-tree is a datastructure used for
+  # A BK-tree is a data structure used for
   # nearest neighbor lookup in a metric space.
   # A metric space is any space with the
   # following properties:
@@ -9,18 +9,18 @@ module Batfish
   # * d(x,y) = d(y,x)
   # * d(x,z) <= d(x,y) + d(y,z)
   #
-  # To use this datastructure, the objects added
+  # To use this data structure, the objects added
   # to it must have a distance_to(other) class method
   # defined.
   class BKTree
     attr_reader :root
     
-    # Initialize a BKTree.
-    def initialize
+    # Initializes a BKTree.
+    def initialize()
       @root = nil
     end
     
-    # Add an object to the tree.
+    # Adds an object to the tree.
     # Returns the tree itself so several
     # adds may be chained together.
     def add(obj)
@@ -34,7 +34,7 @@ module Batfish
     alias_method :<<, :add
 
     # Returns true if the tree is empty.
-    def empty?
+    def empty?()
       return @root.nil? ? true : false
     end
     
@@ -100,7 +100,7 @@ module Batfish
     class Node
       attr_reader :value, :children
       
-      # Initialize a BKTree Node with
+      # Initializes a BKTree Node with
       # the given object as its value
       # or nil if no object is given.
       def initialize(obj=nil)
@@ -108,7 +108,7 @@ module Batfish
         @children = {}
       end
       
-      # Add a node to a node in
+      # Adds a node to a node in
       # a recursive way.
       def add(obj)
         distance = obj.distance_to(@value)

data/lib/data/linkedlist.rb

@@ -0,0 +1,183 @@
+module Batfish
+
+  # A Linked List is a data structure 
+  # that consists of a sequence of data 
+  # records such that each record point 
+  # to the following record of the 
+  # sequence.
+  class LinkedList
+    attr_reader :first
+    
+    # Initializes a Linked List.
+    def initialize()
+      @first = nil
+    end
+    
+    # Returns true if the linked list
+    # is empty.
+    def empty?()
+      return @first.nil?
+    end
+    
+    # Returns true if the given object
+    # is present in the tree.
+    def include?(obj)
+      self.each do |node| 
+        if node == obj
+          return true
+        end
+      end
+      return false
+    end
+    
+    # Returns the length of the linked
+    # list.
+    def length()
+      length = 0
+      self.each { length += 1 }
+      return length
+    end
+
+    # Inserts an object at the beginning
+    # of the linked list. Returns the
+    # linked list itself so several
+    # inserts may be chained together.
+    def insert_begin(obj)
+      node = Node.new(obj)
+      node.next, @first = @first, node
+      return self
+    end
+    alias_method :<<, :insert_begin
+    
+    # Inserts an object after a given
+    # object in the linked list.
+    # Returns nil if the given object
+    # can't be found otherwise returns
+    # the linked list itself so several
+    # inserts may be chained together.
+    def insert_after(obj, after)
+      node = Node.new(obj)
+      cur = @first
+      while cur
+        if cur.value == after
+          cur.next, node.next = node, cur.next
+          return self
+        end
+        cur = cur.next
+      end
+      return nil
+    end
+
+    # Removes the object at the beginning
+    # of the linked list. Returns the
+    # removed object.
+    def delete_begin()
+      node = @first
+      @first = @first.next
+      return node.value
+    end
+
+    # Removes the object after a given
+    # object in the linked list. Returns
+    # nil if the object can't be found,
+    # otherwise returns the removed
+    # object.
+    def delete_after(after)
+      cur = @first
+      while cur
+        if cur.value == after
+          node = cur.next
+          cur.next = node.next
+          return node
+        end
+        cur = cur.next
+      end
+      return nil
+    end
+
+    # Removes a given object in the linked
+    # list. Returns nil if the object
+    # can't be found, otherwise returns
+    # the removed object.
+    def delete(obj)
+      cur = @first
+      if cur.value == obj
+        @first = @first.next
+      end
+      while cur.next do
+        if cur.next.value == obj
+          node = cur.next
+          cur.next = node.next
+          return node.value
+        end
+        cur = cur.next
+      end
+      return nil
+    end
+    
+    # Calls block once for each object
+    # in the stack, starting with the
+    # object at the beginning.
+    def each()
+      cur = @first
+      while cur do
+        yield cur.value
+        cur = cur.next
+      end
+    end
+    
+    # This class represents a node in
+    # a Linked List.
+    class Node
+      attr_accessor :next
+      attr_reader :value
+      
+      # Initializes a Linked List Node with
+      # the given object as its value
+      # or nil if no object is given.
+      def initialize(obj=nil)
+        @value = obj
+        @next = nil
+      end
+    end
+  end
+  
+  # A Sorted Linked List is a data
+  # structure that consists of an
+  # ordered sequence of data records 
+  # such that each record point to 
+  # the following record of the sequence.
+  class SortedLinkedList < LinkedList
+    
+    # Inserts an object in the linked list,
+    # keeping the objects ordered.
+    def insert(obj)
+      node = Node.new(obj)
+      if @first.nil?
+        @first = node
+        return self
+      end
+      prev = nil
+      cur = @first
+      while cur
+        if block_given? 
+          if yield(cur.value, obj) >= 0
+            break
+          end
+        elsif obj <= cur.value
+          break
+        end
+        prev = cur
+        cur = cur.next
+      end
+      node.next = cur
+      if prev
+        prev.next = node
+      else
+        @first = node
+      end
+      return self
+    end
+    alias_method :<<, :insert
+  end
+end

data/lib/data/queue.rb

@@ -0,0 +1,72 @@
+module Batfish
+
+  # A Queue is a first in, first out
+  # (FIFO) data structure characterized
+  # by two fundamental operations:
+  # enqueue and dequeue.
+  class Queue
+    attr_reader :first, :last
+
+    # Initializes a Queue.
+    def initialize()
+      @first = nil
+      @last = nil
+    end
+    
+    # Returns true if the queue is
+    # empty.
+    def empty?()
+      return @first.nil?
+    end
+    
+    # Adds an object to the back
+    # of the queue. Returns the
+    # queue itself so several
+    # enqueue may be chained.
+    def enqueue(obj)
+      node = Node.new(obj)
+      if @first.nil?
+        @first = @last = node
+      else
+        @last.next = node
+        @last = node
+      end
+      return self
+    end
+    alias_method :<<, :enqueue
+    
+    # Removes the object at
+    # the front of the queue
+    # and returns it.
+    def dequeue()
+      node = @first
+      @first = @first.next 
+      return node.value
+    end
+    
+    # Calls block once for each
+    # object in the queue, starting
+    # with the one at the front.
+    def each()
+      cur = @first
+      while cur
+        yield cur.value
+        cur = cur.next
+      end
+    end
+    
+    # This class represents a node
+    # in a queue.
+    class Node
+      attr_accessor :value, :next, :prev
+      
+      # Initializes a Queue Node with
+      # the given object as its value 
+      # or nil if no object is given.
+      def initialize(obj=nil)
+        @value = obj
+        @next = nil
+      end
+    end
+  end
+end

data/lib/data/stack.rb

@@ -0,0 +1,66 @@
+module Batfish
+
+  # A Stack is a last in, first out
+  # (LIFO) data structure characterized
+  # by two fundamental operations:
+  # push and pop.
+  class Stack
+    attr_reader :first
+    
+    # Initializes a Stack.
+    def initialize()
+      @first = nil
+    end
+    
+    # Returns true if the stack is
+    # empty.
+    def empty?()
+      return @first.nil?
+    end
+    
+    # Adds an object to the top of
+    # the list. Returns the stack
+    # itself so several push may be
+    # chained.
+    def push(obj)
+      node = Node.new(obj)
+      node.next = @first
+      @first = node 
+      return self
+    end
+    alias_method :<<, :push
+    
+    # Removes the object at the top
+    # of the stack and returns it.
+    def pop()
+      node = @first
+      @first = @first.next 
+      return node.value
+    end
+    
+    # Calls block once for each object
+    # in the stack, starting with the
+    # one on the top.
+    def each()
+      cur = @first
+      while cur
+        yield cur.value
+        cur = cur.next
+      end
+    end
+    
+    # This class represents a node in
+    # a Stack.
+    class Node
+      attr_accessor :value, :next, :prev
+      
+      # Initializes a Stack Node with
+      # the given object as its value
+      # or nil if no object is given.
+      def initialize(obj=nil)
+        @value = obj
+        @next = nil
+      end
+    end
+  end
+end

data/lib/data/trie.rb

@@ -1,6 +1,6 @@
 module Batfish
 
-  # A Trie is a datastructure used to
+  # A Trie is a data structure used to
   # store key value pairs where the key
   # is a string. It does so by through
   # a tree-like structure where each edge
@@ -11,8 +11,8 @@ module Batfish
   class Trie
     attr_reader :root
     
-    # Initialize a Trie
-    def initialize
+    # Initializes a Trie.
+    def initialize()
       @root = Node.new()
     end
     
@@ -59,13 +59,13 @@ module Batfish
     end
 
     # Returns true if the trie is empty.
-    def empty?
+    def empty?()
       return @root.children.empty? ? true : false
     end
     
     # Calls block once for each key value
     # pair in the trie.
-    def each
+    def each()
       @root.each("") do |k, v|
         yield(k, v)
       end
@@ -76,7 +76,7 @@ module Batfish
     class Node
       attr_reader :value, :children
       
-      # Initialize a Trie Node with
+      # Initializes a Trie Node with
       # the given object as its value
       # or nil if no object is given.
       def initialize(value=nil)
@@ -84,7 +84,7 @@ module Batfish
         @children = {}
       end
       
-      # Add a node to a node in a
+      # Adds a node to a node in a
       # recursive way.
       def add(key, value)
         if key.empty?
@@ -98,7 +98,7 @@ module Batfish
         end
       end
 
-      # Delete a key value pair from 
+      # Deletes a key value pair from 
       # a node in a recursive way.
       def delete(key)
         if key.empty?
@@ -138,8 +138,8 @@ module Batfish
       # Calls block once for each key
       # value pairs under self.
       def each(key, &block)
-        if value
-          yield(key, value)
+        if @value
+          yield(key, @value)
         end
         @children.each do |letter, child|
           child.each(key + letter, &block)

data/test/test_linkedlist.rb

@@ -0,0 +1,119 @@
+require 'test/unit'
+require 'test/helper'
+
+include Batfish
+
+class TestLinkedList < Test::Unit::TestCase
+  
+  def setup
+    @ll = LinkedList.new()
+  end
+  
+  def test_empty?
+    assert(@ll.empty?)
+    @ll.insert_begin(1)
+    @ll.insert_begin(2)
+    @ll << 3 << 4 << 5
+    @ll.delete_begin()
+    @ll.delete_begin()
+    @ll.delete_begin()
+    @ll.delete_begin()
+    @ll.delete_begin()
+    assert(@ll.empty?)
+  end
+
+  def test_insert
+    @ll.insert_begin(5)
+    @ll.insert_begin(3)
+    @ll.insert_begin(1)
+    @ll.insert_after(2, 1)
+    @ll.insert_after(4, 3)
+    cur = @ll.first
+    i = 1
+    while cur
+      assert_equal(i, cur.value)
+      i += 1
+      cur = cur.next
+    end
+  end
+
+  def test_delete
+    @ll << 9 << 8 << 7 << 6 << 5 << 4 << 3 << 2 << 1
+    @ll.delete(8)
+    @ll.delete(5)
+    @ll.delete(2)
+    assert(!@ll.delete(99))
+    @ll.delete_begin
+    @ll.delete_begin
+    @ll.delete_after(7)
+    @ll.delete_after(4)
+    elements = [4,7]
+    cur = @ll.first
+    elements.each do |el|
+      assert_equal(el, cur.value)
+      cur = cur.next
+    end
+  end
+
+  def test_include?
+    @ll << 1
+    assert(@ll.include?(1))
+    @ll.delete(1)
+    assert(!@ll.include?(1))
+    @ll << 1
+    assert(@ll.include?(1))
+  end
+
+  def test_length
+    @ll << 1 << 2 << 3 << 4 << 5
+    assert_equal(5, @ll.length)
+    @ll.delete_begin()
+    @ll.delete_begin()
+    assert_equal(3, @ll.length)
+    @ll << 6
+    assert_equal(4, @ll.length)
+  end
+
+  def test_each
+    elements = [1,2,3,4,5]
+    elements.each do |el|
+      @ll << el
+    end
+    i = elements.length
+    @ll.each do |el|
+      assert_equal(i, el)
+      i -= 1
+    end
+  end
+end
+
+class TestSortedLinkedList < Test::Unit::TestCase
+
+  def setup
+    @sll = SortedLinkedList.new()
+  end
+
+  def test_insert
+    elements = [5,1,3,4,2,6]
+    elements.each do |el|
+      @sll << el
+    end
+    i = 1
+    @sll.each do |el|
+      assert_equal(i, el)
+      i += 1
+    end
+  end
+  
+  def test_insert_block
+    elements = [5,1,3,4,2,6]
+    elements.each do |el|
+      @sll.insert(el) { |x,y| -x <=> -y }
+    end
+    i = elements.length
+    @sll.each do |el|
+      assert_equal(i, el)
+      i -= 1
+    end
+  end
+end

data/test/test_queue.rb

@@ -0,0 +1,46 @@
+require 'test/unit'
+require 'test/helper'
+
+include Batfish
+
+class TestQueue < Test::Unit::TestCase
+
+  def setup
+    @q = Queue.new()
+  end
+
+  def test_empty?
+    assert(@q.empty?)
+    @q.enqueue(1)
+    @q.enqueue(2)
+    @q << 3 << 4
+    @q.dequeue()
+    @q.dequeue()
+    @q.dequeue()
+    @q.dequeue()
+    assert(@q.empty?)
+  end
+
+  def test_dequeue
+    @q << 1 << 2 << 3
+    assert_equal(1, @q.dequeue())
+    assert_equal(2, @q.dequeue())
+    @q << 4 << 5
+    assert_equal(3, @q.dequeue())
+    assert_equal(4, @q.dequeue())
+    assert_equal(5, @q.dequeue())
+    assert(@q.empty?)
+  end
+
+  def test_each
+    elements = [1,2,3,4,5,6]
+    elements.each do |el|
+      @q << el
+    end
+    i = 0
+    @q.each do |el|
+      assert_equal(elements[i], el)
+      i += 1
+    end
+  end
+end

data/test/test_stack.rb

@@ -0,0 +1,46 @@
+require 'test/unit'
+require 'test/helper'
+
+include Batfish
+
+class TestStack < Test::Unit::TestCase
+
+  def setup
+    @s = Stack.new()
+  end
+
+  def test_empty?
+    assert(@s.empty?)
+    @s.push(5)
+    @s.push(7)
+    @s << 1 << 2
+    @s.pop()
+    @s.pop()
+    @s.pop()
+    @s.pop()
+    assert(@s.empty?)
+  end
+
+  def test_pop
+    @s << 1 << 5 << 9
+    assert_equal(9, @s.pop)
+    assert_equal(5, @s.pop)
+    @s << 3 << 4
+    assert_equal(4, @s.pop)
+    assert_equal(3, @s.pop)
+    assert_equal(1, @s.pop)
+    assert(@s.empty?)
+  end
+
+  def test_each
+    elements = [1,5,9,13,8,5]
+    elements.each do |el|
+      @s << el
+    end
+    i = elements.length - 1
+    @s.each do |el|
+      assert_equal(el, elements[i])
+      i -= 1
+    end
+  end
+end

data/test/test_trie.rb

@@ -82,16 +82,19 @@ class TestTrie < Test::Unit::TestCase
   end
 
   def test_each
-    @t.add("dinosaur", 0)
-    @t.add("tyrannosaurus", 4)
-    @t.add("diplotomodon", 2)
-    @t.add("tyrannotitan", 5)
-    @t.add("raptor", 3)
-    @t.add("diplodocus", 1)
-    i = 0
+    words = {
+      "dinosaur" => 0,
+      "tyrannosaurus" => 4,
+      "diplotomodon" => 2,
+      "tyrannotitan" => 5,
+      "raptor" => 3,
+      "diplodocus" => 1
+    }
+    words.each do |k,v|
+      @t.add(k, v)
+    end
     @t.each do |k, v|
-      assert_equal(i, v)
-      i += 1
+      assert_equal(words[k.downcase], v)
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: renaudb-batfish
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors: 
 - Renaud Bourassa
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-08-23 00:00:00 -07:00
+date: 2009-09-23 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -24,13 +24,18 @@ extra_rdoc_files:
 files: 
 - README.rdoc
 - Rakefile
-- VERSION
 - batfish.gemspec
 - lib/batfish.rb
 - lib/data/bktree.rb
+- lib/data/linkedlist.rb
+- lib/data/queue.rb
+- lib/data/stack.rb
 - lib/data/trie.rb
 - test/helper.rb
 - test/test_bktree.rb
+- test/test_linkedlist.rb
+- test/test_queue.rb
+- test/test_stack.rb
 - test/test_trie.rb
 has_rdoc: false
 homepage: http://github.com/renaudb/batfish
@@ -62,4 +67,7 @@ summary: Just a bunch of functions.
 test_files: 
 - test/helper.rb
 - test/test_bktree.rb
+- test/test_linkedlist.rb
+- test/test_queue.rb
+- test/test_stack.rb
 - test/test_trie.rb

data/VERSION

@@ -1 +0,0 @@
-0.1.0