eymiha_util 0.1.6 → 1.0.0

data/lib/histogram.rb

@@ -1,109 +0,0 @@
-# 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/lib/methodic_hash.rb

@@ -1,66 +0,0 @@
-# The MethodicHash is some method_missing magic that uses method names as hash
-# keys, so hash assignment and lookup appear to be attribute writing and
-# reading. For instance, if
-#
-#   mh = MethodicHash.new
-#   mh['four']  = 'iv'
-#   mh[:seven]  = 'vii'
-#   mh.eighteen = 'xviii'
-#
-# then
-#
-#   mh['four']     ---> 'iv'
-#   mh[:four]      ---> 'iv'
-#   mh.four        ---> 'iv'
-#   mh['seven']    ---> 'vii'
-#   mh[:seven]     ---> 'vii'
-#   mh.seven       ---> 'vii'
-#   mh['eighteen'] ---> 'xviii'
-#   mh[:eighteen]  ---> 'xviii'
-#   mh.eighteen    ---> 'xviii'
-#
-# This allows access to simply declared facts to be embedded in Ruby code and
-# leverages the possibility of hashing procs.
-#
-# Note that if the hash uses anything but strings or symbols as keys, the
-# magic stands a good chance of failing, raising an error or acting in a
-# bizarre manner. Note also that methods of the Hash cannot be used as
-# 'attribute' names.
-class MethodicHash < Hash
-  
-  # Try to look up using a key directly, or if that fails as a string, or as
-  # a symbol as last resort. If a symbol conversion doesn't exists, rescue
-  # with a nil.
-  def [](key)
-    begin
-      super(key) || super(key.to_s) || super(key.to_sym)
-    rescue
-      nil
-    end
-  end
-  
-  # Deletes and returns the key-value pairs from hash whose keys are equal to
-  # key.to_s or key.to_sym. If both key.to_s and key.to_sym are in the hash,
-  # then both values are returned in an Array, respectively. If neither key is
-  # found, the delete is deferred to the Hash.
-  def delete(key,&block)
-    values = [key.to_s, key.to_sym].collect {|k| super(k){ nil } }.compact
-    case values.size
-      when 0 then super(key,&block)
-      when 1 then values[0]
-      when 2 then values
-    end
-  end
-  
-  # A missing method is assummed to be the assignment of a value of a key, or
-  # the lookup of a value with a key.
-  def method_missing(method,*args)
-    string = method.to_s
-    if string[string.length-1,1] == '='
-      self[string[0,string.length-1].to_sym] = args[0]
-    else
-      self[method]
-    end
-  end
-
-end