eymiha_util 0.1.0

data/gem_package.rb

@@ -0,0 +1,31 @@
+class GemPackage
+  
+  attr_reader :name, :version, :files
+  
+  def initialize
+    @name = 'eymiha_util'
+    @version = '0.1.0'
+    @files = FileList[
+      '*.rb',
+      'lib/*',
+      'test/*',
+      'html/**/*'
+    ]
+  end
+
+  def fill_spec(s)
+    s.name = name
+    s.version = version
+    s.summary = "Eymiha general utility classes and methods"
+    s.files = files.to_a
+    s.require_path = 'lib'
+    s.autorequire = name
+    s.has_rdoc = true
+    s.rdoc_options << "--all"
+    s.author = "Dave Anderson"
+    s.email = "dave@eymiha.com"
+    s.homepage = "http://www.eymiha.com"
+    s.rubyforge_project = "cori"
+  end
+
+end

data/lib/envelope.rb

@@ -0,0 +1,126 @@
+# Envelopes are useful when finding the boundaries of a set of instances.
+# They expand as new values are added, and keep track of how many items
+# have been added to construct them.
+
+# An EnvelopeException is generally raised when adding an object to an
+# instance that it does not know how to interpret, or when requesting
+# bounderies before any values have been added.
+class EnvelopeException < Exception
+end
+
+
+# A BaseEnvelope provides a means to keep and provide a count of objects that
+# have been added to an envelope.
+class BaseEnvelope
+
+  # Called when requesting envelope bounderies before any values have been
+  # added.
+  def raise_no_envelope
+    raise EnvelopeException, "No values are enveloped"
+  end
+
+  # Called when the value cannot be compared with the the boundaries of the
+  # instance.
+  def raise_no_compare(value=nil)
+    value = "'#{value}' " unless value == nil
+    raise EnvelopeException,
+      "The value #{value}cannot be compared with the envelope"
+  end
+
+  # count of added values reader.
+  attr_reader :count
+  
+  # Returns a new instance with no values added.
+  def initialize
+    @count = 0
+  end
+
+end
+
+
+# An Envelope is the minimum envelope that will completely contain a set of
+# values. Values may be added to an instance, and it can return the number
+# of values considered so far and its high and low boundaries.
+#
+# Envelopes can be used to generate ranges, however the result may be of
+# limited utility if the types of values being enveloped don't play nicely
+# with ranges.
+class Envelope < BaseEnvelope
+
+  # Creates and returns an instance. If an argument is given, it is passed to
+  # the set method to initialize the new instance.
+  def initialize(value=nil)
+    super()
+    add(value) unless value == nil
+  end
+  
+  # Returns a string representation of the instance.
+  def to_s
+    values = (count > 0)? "\n  high  #{high}\n  low   #{low}" : ""
+    "Envelope: count #{count}#{values}"
+  end
+  
+  # Adds a value to the instance. When
+  # * x is an Envelope, it is coalesced into the instance.
+  # * otherwise, the envelope is extened to contain the value.
+  # * if the value cannot be compared to the boundaries, an EnvelopeException is raised.
+  # The modified instance is returned.
+  def add(value)
+    if value.kind_of? Envelope
+      count = value.count
+      if (count > 0)
+        add value.high
+        add value.low
+        @count += (count-2)
+      end
+      self
+    else
+      begin
+        @high = value if (@count == 0 || value > @high)
+        @low = value if (@count == 0 || value < @low)
+        @count += 1
+        self
+      rescue
+        raise_no_compare value
+      end
+    end
+  end
+  
+  # Returns the high boundary of the instance.
+  # * if there are no boundaries, an EnvelopeException is raised.
+  def high
+    raise_no_envelope if @count == 0
+    @high
+  end
+  
+  # Returns the low boundary of the instance.
+  # * if there are no boundaries, an EnvelopeException is raised.
+  def low 
+    raise_no_envelope if @count == 0
+    @low
+  end
+
+  # Returns true if the instance completely contains the argument:
+  # * value is an Envelope, its high and low are contained.
+  # * otherwise, the value is contained.
+  # * if the value cannot be compared to the boundaries, an EnvelopeException is raised.
+  def contains?(value)
+    if value.kind_of? Envelope
+      (contains? value.high) && (contains? value.low)
+    else
+      begin
+        (value >= low) && (value <= high)
+      rescue
+        raise_no_compare value
+      end
+    end
+  end
+  
+  alias === contains?
+
+  # Returns an inclusive range from the low to high boundaries
+  def to_range
+    low..high
+  end
+  
+end

data/lib/histogram.rb

@@ -0,0 +1,109 @@
+# Histograms have lots of uses - whenever you need to keep track of the
+# occurences of items and how many times they've occured, a histogram is
+# just what's needed.
+
+
+# An exception thrown when adding Arrays to Histograms that cannot be
+# meaningfully interpretted.
+class HistogramException < Exception
+end
+
+
+# A Histogram is a hash whose values are counts of the occurences of the keys.
+class Histogram < Hash
+
+  # Creates and returns an instance. If arguments are given, they are passed to
+  # the add method to initialize the new instance.
+  def initialize(key=nil,number=1)
+    super()
+    add(key,number) unless key == nil
+  end
+
+  # Returns the number of occurences of the given key. If an array of keys
+  # is given, the sum of the number of occurences of those keys is returned.
+  def count(check_keys = keys)
+    check_keys = [check_keys] if ! check_keys.kind_of? Array
+    count = 0
+    check_keys.each { |key| count += self[key] if has_key? key }
+    count
+  end
+
+  # Adds the key to the instance if it doesn't already exist, and adds the
+  # specified count to it value. If the key is
+  # * an Array, each member of the array is added. if the member itself is an Array, then if that array has one member, the member is added as a key; if two members, the member is added as a key and a count; otherwise, a HistogramException is thrown.
+  # * another histogram, the keys and counts in the key are added to the instance.
+  def add(key,count=1)
+    if key.kind_of? Array
+      key.each { |member|
+        if member.kind_of? Array
+          if member.size == 1
+            add(member[0])
+          elsif (member.size == 2) && (member[1].kind_of? Fixnum)
+            add(member[0],member[1])
+          else
+            raise HistogramException, "add cannot interpret Array to add"
+          end
+        else
+          add member
+        end
+      }
+    elsif key.kind_of? Histogram
+      key.each_pair { |k,v| add(k,v) }
+    else
+      self[key] = ((value = self[key]) == nil) ? count : value+count
+    end
+    self
+  end
+
+  # Returns the number of keys in the instance.
+  def key_count
+    keys.size
+  end
+
+  # Returns a new Histogram containing the elements with occurences greater
+  # than or equal to the given count.
+  def >=(count)
+    result = Histogram.new
+    each_pair { |k,v| result.add(k,v) if v >= count }
+    result
+  end
+ 
+  # Returns a new Histogram containing the elements with occurences greater
+  # than the given count.
+  def >(count)
+    result = Histogram.new
+    each_pair { |k,v| result.add(k,v) if v > count }
+    result
+  end
+
+  # Returns a new Histogram containing the elements with occurences less than
+  # or equal to the given count.
+  def <=(count)
+    result = Histogram.new
+    each_pair { |k,v| result.add(k,v) if v <= count }
+    result
+  end
+
+  # Returns a new Histogram containing the elements with occurences less than
+  # the given count.
+  def <(count)
+    result = Histogram.new
+    each_pair { |k,v| result.add(k,v) if v < count }
+    result
+  end
+
+  # If count is a number, a new Histogram containing the elements with
+  # occurences equal to the given countis returned. If the count is a
+  # histogram, true is returned if the instance contains the same keys and
+  # values; false otherwise.
+  def ==(count)
+    if count.kind_of? Numeric
+      result = Histogram.new
+      each_pair { |k,v| result.add(k,v) if v >= count }
+      result
+    else
+      super
+    end
+  end
+
+end

data/rakefile.rb

@@ -0,0 +1,2 @@
+require 'gem_package'
+require 'gem_raker'

data/test/tc_envelope.rb

@@ -0,0 +1,99 @@
+require 'test/unit'
+
+require 'envelope'
+
+class TC_Envelope < Test::Unit::TestCase
+  
+  def test_count
+    base = BaseEnvelope.new
+    assert(base.count == 0)
+  end
+
+  def test_empty
+    envelope = Envelope.new
+    assert(envelope.count == 0)
+    assert_raise(EnvelopeException) { envelope.high }
+    assert_raise(EnvelopeException) { envelope.low }
+  end
+  
+  def test_add_numbers
+    envelope = Envelope.new
+    envelope.add 1
+    assert(envelope.high == 1)
+    assert(envelope.low == 1)
+    assert(envelope.count == 1)
+    envelope.add 2
+    envelope.add(-3)
+    envelope.add 4.5
+    assert(envelope.high == 4.5)
+    assert(envelope.low == -3)
+    assert(envelope.count == 4)
+    envelope.add envelope
+    assert(envelope.high == 4.5)
+    assert(envelope.low == -3)
+    assert(envelope.count == 8)
+    assert_raise(EnvelopeException) { envelope.add "bad" }
+    assert(envelope.count == 8)
+    envelope = Envelope.new
+  end
+  
+  def test_add_letters
+    envelope = Envelope.new('c').add('m').add('e')
+    assert(envelope.low == 'c')
+    assert(envelope.high == 'm')
+    assert(envelope.contains?('d'))
+    assert(!(envelope.contains?('a')))
+    assert(!(envelope.contains?('r')))
+    assert(envelope.contains?(envelope))
+    assert(envelope.contains?(Envelope.new('e').add('h')))
+    assert(!(envelope.contains?(Envelope.new('a').add('h'))))
+    assert(!(envelope.contains?(Envelope.new('e').add('s'))))
+    assert(envelope === 'd')
+    assert(!(envelope === 'a'))
+    assert(!(envelope === 'r'))
+    assert(envelope === envelope)
+    assert(envelope === Envelope.new('e').add('h'))
+    assert(!(envelope === Envelope.new('a').add('h')))
+    assert(!(envelope === Envelope.new('e').add('s')))
+    range = envelope.to_range
+    assert(range === 'd')
+    assert(!(range === 'a'))
+    assert(!(range === 'r'))
+  end
+
+  def test_add_strings
+    envelope = Envelope.new("carl").add("marie").add("edward")
+    assert(envelope.low == "carl")
+    assert(envelope.high == "marie")
+    assert(envelope.contains?("dennis"))
+    assert(!(envelope.contains?("aaron")))
+    assert(!(envelope.contains?("ralph")))
+    assert(envelope.contains?(envelope))
+    assert(envelope.contains?(Envelope.new("edward").add("harry")))
+    assert(!(envelope.contains?(Envelope.new("aaron").add("harry"))))
+    assert(!(envelope.contains?(Envelope.new("edward").add("sally"))))
+    range = envelope.to_range
+    assert(range === "dennis")
+    assert(!(range === "aaron"))
+    assert(!(range === "ralph"))
+  end
+
+  def test_contains
+    envelope = Envelope.new(0.75).add(3)
+    assert(envelope.contains?(1))
+    assert(envelope.contains?(3))
+    assert(envelope.contains?(2))
+    assert(!(envelope.contains?(0)))
+    assert(!(envelope.contains?(4)))
+    assert(envelope.contains?(envelope))
+    assert(envelope.contains?(Envelope.new(1.5).add(2.5)))
+    assert(!(envelope.contains?(Envelope.new(0.5).add(2.5))))
+    assert(!(envelope.contains?(Envelope.new(1.5).add(3.5))))
+    assert_raise(EnvelopeException) { envelope.add "bad" }
+    range = envelope.to_range
+    assert(range === 2.5)
+    assert(!(range === 0))
+    assert(!(range === 4))
+  end
+
+end

data/test/tc_histogram.rb

@@ -0,0 +1,52 @@
+require 'test/unit'
+
+require 'histogram'
+
+class TC_Histogram < Test::Unit::TestCase
+  
+  def test_empty
+    histogram = Histogram.new
+    assert(histogram.count == 0)
+    assert(histogram.keys == [])
+  end
+
+  def test_loading
+    h1 = Histogram.new "hello"
+    h1.add "goodbye",2
+    assert(h1.count == 3)
+    assert(h1.count("hello") == 1)
+    assert(h1.count("goodbye") == 2)
+    assert(h1.count("everyone") == 0)
+    assert(h1.key_count == 2)
+    h2 = Histogram.new [["hello", 4], "goodbye", "everyone"]
+    assert(h2.count == 6)
+    assert(h2.count("hello") == 4)
+    assert(h2.count("goodbye") == 1)
+    assert(h2.count("everyone") == 1)
+    assert(h2.key_count == 3)
+    h1.add h2
+    assert(h1.count == 9)
+    assert(h1.count("hello") == 5)
+    assert(h1.count("goodbye") == 3)
+    assert(h1.count("everyone") == 1)
+    assert(h1.key_count == 3)
+    assert(h1.has_key?("hello"))
+    assert(h1.has_key?("goodbye"))
+    assert(h1.has_key?("everyone"))
+    assert(!(h1.has_key? "help"))
+  end
+  
+  def test_subset
+    h = Histogram.new [["hello", 4], ["goodbye", 3], "everyone"]
+    h1 = Histogram.new [["hello", 4], ["goodbye", 3]]
+    assert((h >= 3) == h1)
+    h2 = Histogram.new [["hello", 4]]
+    assert((h > 3) == h2)
+    assert((h == 4) == h2)
+    h3 = Histogram.new [["goodbye", 3], "everyone"]
+    assert((h <= 3) == h3)
+    h4 = Histogram.new "everyone"
+    assert((h < 3) == h4)
+  end
+  
+end

metadata

@@ -0,0 +1,51 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.0
+specification_version: 1
+name: eymiha_util
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+date: 2007-05-10 00:00:00 -04:00
+summary: Eymiha general utility classes and methods
+require_paths: 
+- lib
+email: dave@eymiha.com
+homepage: http://www.eymiha.com
+rubyforge_project: cori
+description: 
+autorequire: eymiha_util
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Dave Anderson
+files: 
+- gem_package.rb
+- rakefile.rb
+- lib/envelope.rb
+- lib/histogram.rb
+- test/tc_envelope.rb
+- test/tc_histogram.rb
+test_files: []
+
+rdoc_options: 
+- --all
+extra_rdoc_files: []
+
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: []
+