renaudb-batfish 0.1.0

data/README.rdoc

@@ -0,0 +1,42 @@
+= Batfish
+
+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.
+
+== Install
+
+If you haven't already, add github's gem server to your sources:
+
+  gem sources -a http://gems.github.com
+
+Then, it's as easy as:
+
+  sudo gem install renaudb-batfish
+
+And voila! You are now setup to use batfish in any of your projects.
+
+== Usage
+
+To use batfish in one of your project, all you have to do is to include the library.
+
+   require 'batfish'
+
+And then use the classes like any other ruby class.
+
+    class Dictionary
+        attr_accessor :words
+
+        def initialize
+	    words = Batfish::Trie.new()
+	end  
+    end
+
+== Content
+
+Here is a list of the algorithms and data structures batfish implements.
+
+=== Data Structures
+
+- BK-Tree
+- Trie

data/Rakefile

@@ -0,0 +1,31 @@
+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
+end
+
+Rake::RDocTask.new do |t|
+  t.main = "README.rdoc"
+  t.rdoc_files.include("README.rdoc", "lib/**/*.rb")
+  t.rdoc_dir = "doc"
+end
+
+
+
+

data/VERSION

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

data/batfish.gemspec

@@ -0,0 +1,49 @@
+# 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.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.email = %q{me@renaudbourassa.com}
+  s.extra_rdoc_files = [
+    "README.rdoc"
+  ]
+  s.files = [
+    "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "batfish.gemspec",
+     "lib/batfish.rb",
+     "lib/data/bktree.rb",
+     "lib/data/trie.rb",
+     "test/helper.rb",
+     "test/test_bktree.rb",
+     "test/test_trie.rb"
+  ]
+  s.homepage = %q{http://github.com/renaudb/batfish}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.3}
+  s.summary = %q{Just a bunch of functions.}
+  s.test_files = [
+    "test/helper.rb",
+     "test/test_bktree.rb",
+     "test/test_trie.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

data/lib/batfish.rb

@@ -0,0 +1,2 @@
+require 'data/trie'
+require 'data/bktree'

data/lib/data/bktree.rb

@@ -0,0 +1,139 @@
+module Batfish
+
+  # A BK-tree is a datastructure used for
+  # nearest neighbor lookup in a metric space.
+  # A metric space is any space with the
+  # following properties:
+  #
+  # * d(x,y) = 0 <=> x = y
+  # * d(x,y) = d(y,x)
+  # * d(x,z) <= d(x,y) + d(y,z)
+  #
+  # To use this datastructure, the objects added
+  # to it must have a distance_to(other) class method
+  # defined.
+  class BKTree
+    attr_reader :root
+    
+    # Initialize a BKTree.
+    def initialize
+      @root = nil
+    end
+    
+    # Add an object to the tree.
+    # Returns the tree itself so several
+    # adds may be chained together.
+    def add(obj)
+      if @root
+        @root.add(obj)
+      else
+        @root = Node.new(obj)
+      end
+      return self
+    end
+    alias_method :<<, :add
+
+    # Returns true if the tree is empty.
+    def empty?
+      return @root.nil? ? true : false
+    end
+    
+    # Returns true if the given object is
+    # present in the tree.
+    def include?(obj)
+      self.include_near?(obj, 0)
+    end
+
+    # Return true if the given object is
+    # within threshold distance of an
+    # object in the tree.
+    def include_near?(obj, threshold)
+      self.fetch_near(obj, threshold) do
+        return true
+      end
+      return false
+    end
+
+    # Returns an array containing all
+    # object within threshold distance 
+    # of the given object. If a block is 
+    # given, it is called once for each 
+    # objects within threshold distance
+    # of the given object.
+    def fetch_near(obj, threshold)
+      objs = []
+      @root.fetch_near(obj, threshold) do |item|
+        yield(item) if block_given? 
+        objs << item
+      end
+      return objs
+    end
+
+    # Returns the nearest object to
+    # the given object.
+    def fetch_nearest(obj)
+      threshold = 0
+      nearests = []
+      while nearests.empty?
+        self.fetch_near(obj, threshold) do |item|
+          yield(item) if block_given? 
+          nearests << item
+        end
+        threshold += 1
+      end
+      return nearests
+    end
+
+    # Returns the minimum distance
+    # between the given object and
+    # an object in the tree.
+    def min_dist(obj)
+      threshold = 0
+      while !self.include_near?(obj, threshold)
+        threshold += 1
+      end
+      return threshold
+    end
+  
+    # This class represents a node
+    # in a BKTree.
+    class Node
+      attr_reader :value, :children
+      
+      # Initialize a BKTree Node with
+      # the given object as its value
+      # or nil if no object is given.
+      def initialize(obj=nil)
+        @value = obj
+        @children = {}
+      end
+      
+      # Add a node to a node in
+      # a recursive way.
+      def add(obj)
+        distance = obj.distance_to(@value)
+        if child = @children[distance]
+          child.add(obj)
+        else
+          @children[distance] = Node.new(obj)
+        end
+      end
+
+      # Calls block once for each
+      # object within threshold distance
+      # of the given object that are
+      # part of a child node of self.
+      def fetch_near(obj, threshold, &block)
+        distance = @value.distance_to(obj)
+        if distance <= threshold
+          yield @value
+        end
+        ((distance - threshold)..(distance + threshold)).each do |d|
+          if child = @children[d]
+            child.fetch_near(obj, threshold, &block)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/data/trie.rb

@@ -0,0 +1,151 @@
+module Batfish
+
+  # A Trie is a datastructure used to
+  # store key value pairs where the key
+  # is a string. It does so by through
+  # a tree-like structure where each edge
+  # as a character associated to it.
+  # To walk through the trie, you go down
+  # one character of the key at a time
+  # until you reach the end of the key.
+  class Trie
+    attr_reader :root
+    
+    # Initialize a Trie
+    def initialize
+      @root = Node.new()
+    end
+    
+    # Adds a key value pair to
+    # the trie. Returns the trie
+    # itself so calls to add may be
+    # chained together.
+    def add(key, value)
+      @root.add(key.to_s.upcase.split(""), value)
+      return self
+    end
+    alias_method :[]=, :add
+
+    # Deletes the given key value pair
+    # from the trie. Returns the trie
+    # itself so several delete may
+    # be chained.
+    def delete(key)
+      @root.delete(key.to_s.upcase.split(""))
+      return self
+    end
+    
+    # Returns the value associated with
+    # the given key. Returns nil if it
+    # is not found.
+    def fetch(key)
+      @root.fetch(key.upcase.split(""))
+    end
+    alias_method :[], :fetch
+    
+    # Returns true if the trie contains
+    # the given key.
+    def has_key?(key)
+      return self.fetch(key) ? true : false
+    end
+    
+    # Returns true if the trie contains
+    # the given value.
+    def has_value?(value)
+      self.each do |k, v|
+        return true if v == value
+      end
+      return false
+    end
+
+    # Returns true if the trie is empty.
+    def empty?
+      return @root.children.empty? ? true : false
+    end
+    
+    # Calls block once for each key value
+    # pair in the trie.
+    def each
+      @root.each("") do |k, v|
+        yield(k, v)
+      end
+    end
+    
+    # This class represents a node in
+    # a Trie.
+    class Node
+      attr_reader :value, :children
+      
+      # Initialize a Trie Node with
+      # the given object as its value
+      # or nil if no object is given.
+      def initialize(value=nil)
+        @value = value
+        @children = {}
+      end
+      
+      # Add a node to a node in a
+      # recursive way.
+      def add(key, value)
+        if key.empty?
+          @value = value
+        else
+          letter = key.shift
+          if !@children[letter]
+            @children[letter] = Node.new()
+          end
+          @children[letter].add(key, value)
+        end
+      end
+
+      # Delete a key value pair from 
+      # a node in a recursive way.
+      def delete(key)
+        if key.empty?
+          if !@value.nil? and @children.empty?
+            @value = nil
+            return true
+          else
+            @value = nil
+            return false
+          end
+        end
+        letter = key.shift
+        if @children[letter].delete(key)
+          @children.delete(letter)
+          if @children.empty?
+            return true
+          end
+        end
+        return false
+      end
+      
+      # Returns the value associated
+      # with key. Returns nil if it
+      # is not found.
+      def fetch(key)
+        if key.empty?
+          return @value
+        end
+        child = @children[key.shift]
+        if child
+          child.fetch(key)
+        else
+          return nil
+        end
+      end
+      
+      # Calls block once for each key
+      # value pairs under self.
+      def each(key, &block)
+        if value
+          yield(key, value)
+        end
+        @children.each do |letter, child|
+          child.each(key + letter, &block)
+        end
+      end
+    end
+  end
+end
+

data/test/helper.rb

@@ -0,0 +1 @@
+require 'lib/batfish'

data/test/test_bktree.rb

@@ -0,0 +1,84 @@
+require 'test/unit'
+require 'test/helper'
+
+include Batfish
+
+class Numeric
+  def distance_to(other)
+    return (self - other).abs
+  end
+end
+
+class TestBKTree < Test::Unit::TestCase
+
+  def setup
+    @t = BKTree.new()
+  end
+
+  def test_empty?
+    assert(@t.empty?)
+  end
+
+  def test_include?
+    @t.add(1)
+    @t.add(4)
+    @t.add(5)
+    @t.add(9)
+    @t.add(12)
+    assert(@t.include?(5))
+    assert(!@t.include?(6))
+  end
+
+  def test_include_near?
+    @t.add(1)
+    @t.add(4)
+    @t.add(5)
+    @t.add(9)
+    @t.add(12)
+    assert(@t.include_near?(11, 1))
+    assert(!@t.include_near?(20, 5))
+  end
+
+  def test_fetch_near
+    @t.add(1)
+    @t.add(4)
+    @t.add(5)
+    @t.add(9)
+    @t.add(12)
+    assert_equal([1,4,5,9,12], @t.fetch_near(0, 20).sort)
+    assert_equal([1,4,5], @t.fetch_near(0, 5).sort)
+    result = []
+    @t.fetch_near(0, 5) do |v|
+      result << v
+    end
+    assert_equal([1,4,5], result.sort)
+  end
+    
+  def test_min_dist
+    @t.add(1)
+    @t.add(4)
+    @t.add(5)
+    @t.add(9)
+    @t.add(12)
+    assert_equal(0, @t.min_dist(4))
+    assert_equal(0, @t.min_dist(12))
+    assert_equal(8, @t.min_dist(20))
+    assert_equal(2, @t.min_dist(-1))
+  end
+
+  def test_fetch_nearest
+    @t.add(1)
+    @t.add(4)
+    @t.add(5)
+    @t.add(9)
+    @t.add(11)
+    assert_equal([4], @t.fetch_nearest(4))
+    assert_equal([4], @t.fetch_nearest(3))
+    assert_equal([9,11], @t.fetch_nearest(10).sort)
+    result = []
+    @t.fetch_nearest(10) do |v|
+      result << v
+    end
+    assert_equal([9,11], result.sort)
+  end
+end

data/test/test_trie.rb

@@ -0,0 +1,97 @@
+require 'test/unit'
+require 'test/helper'
+
+include Batfish
+
+class TestTrie < Test::Unit::TestCase
+
+  def setup
+    @t = Trie.new()
+  end
+
+  def test_initialize
+    assert(@t.root.children.empty?)
+  end
+
+  def test_delete
+    @t["dinosaur"] = 0
+    @t["diplodocus"]  = 1
+    @t["diplotomodon"] = 2
+    @t["raptor"] = 3
+    @t["tyrannosaurus"] = 4
+    @t["tyrannotitan"] = 5
+    @t["velociraptor"] = 5
+    @t.delete("tyrannosaurus")
+    assert(!@t.has_key?("tyrannosaurus"))
+    assert(@t.has_key?("tyrannotitan"))
+    @t.delete("diplo")
+    assert(@t.has_key?("diplodocus"))
+    assert(@t.has_key?("diplotomodon"))
+    @t.delete("raptor")
+    assert(!@t.has_key?("raptor"))
+    assert(@t.has_key?("velociraptor"))
+  end
+
+  def test_fetch
+    @t["dinosaur"] = 0
+    @t["diplodocus"]  = 1
+    @t["diplotomodon"] = 2
+    @t["raptor"] = 3
+    @t["tyrannosaurus"] = 4
+    @t["tyrannotitan"] = 5
+    assert_equal(0, @t.fetch("dinosaur"))
+    assert_equal(1, @t.fetch("DiPlOdOcUs"))
+    assert_equal(nil, @t.fetch("velociraptor"))
+    assert_equal(nil, @t.fetch("tyranno"))
+  end
+
+  def test_has_key?
+    @t.add("dinosaur", 0)
+    @t.add("diplodocus", 1)
+    @t.add("diplotomodon", 2)
+    @t.add("raptor", 3)
+    @t.add("tyrannosaurus", 4)
+    @t.add("tyrannotitan", 5)
+    assert(@t.has_key?("dinosaur"))
+    assert(@t.has_key?("DiPlOdOcUs"))
+    assert(!@t.has_key?("velociraptor"))
+    assert(!@t.has_key?("tyranno"))
+  end
+
+  def test_has_value?
+    @t.add("dinosaur", 0)
+    @t.add("diplodocus", 1)
+    @t.add("diplotomodon", 2)
+    @t.add("raptor", 3)
+    @t.add("tyrannosaurus", 4)
+    @t.add("tyrannotitan", 5)
+    assert(@t.has_value?(0))
+    assert(@t.has_value?(5))
+    assert(!@t.has_value?(99))
+    assert(!@t.has_value?("dinosaur"))
+  end
+
+  def test_empty?
+    assert(@t.empty?)
+    @t.add("dinosaur", 0)
+    @t.add("diplodocus", 1)
+    assert(!@t.empty?)
+    @t.delete("dinosaur")
+    @t.delete("diplodocus")
+    assert(@t.empty?)
+  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
+    @t.each do |k, v|
+      assert_equal(i, v)
+      i += 1
+    end
+  end
+end

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification 
+name: renaudb-batfish
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Renaud Bourassa
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-08-23 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: 
+email: me@renaudbourassa.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- README.rdoc
+- Rakefile
+- VERSION
+- batfish.gemspec
+- lib/batfish.rb
+- lib/data/bktree.rb
+- lib/data/trie.rb
+- test/helper.rb
+- test/test_bktree.rb
+- test/test_trie.rb
+has_rdoc: false
+homepage: http://github.com/renaudb/batfish
+licenses: 
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Just a bunch of functions.
+test_files: 
+- test/helper.rb
+- test/test_bktree.rb
+- test/test_trie.rb