facets 2.1.3 → 2.2.0

data/lib/core/facets/enumerable/mash.rb

@@ -0,0 +1,58 @@
+require 'enumerator'
+
+module Enumerable
+
+  # Like <tt>#map</tt>/<tt>#collect</tt>, but generates a Hash.  The block
+  # is expected to return two values: the key and the value for the new hash.
+  #
+  #   numbers  = (1..3)
+  #   squares  = numbers.mash { |n| [n, n*n] }   # { 1=>1, 2=>4, 3=>9 }
+  #   sq_roots = numbers.mash { |n| [n*n, n] }   # { 1=>1, 4=>2, 9=>3 }
+  #
+  # CREDIT: Trans
+  # CREDIT: Andrew Dudzik (adudzik)
+  #
+  # NOTE: Would #correlate would be better?
+
+  def mash(&yld)
+    if yld
+      inject({}) do |h, *kv| # Used to be inject({}) do |h,kv|
+        r = *yld[*kv]        # The *-op works differnt from to_a on single element hash!!!
+        nk, nv = *r          # Used to be nk, nv = *yld[*kv].to_a.flatten
+        h[nk] = nv
+        h
+      end
+    else
+      Enumerator.new(self,:graph)  # Used to be Hash[*self.to_a] or Hash[*self.to_a.flatten]
+    end
+  end
+
+  # Alias for #mash. This is the original name for this method.
+  alias_method :graph,   :mash
+
+  # An alias for #mash that was used for a while b/c of it's similarity to #collect,
+  # but it seems like a misnomer and may well be deprecated in the future.
+  alias_method :collate, :mash
+
+end
+
+
+class Hash
+
+  # In place version of #mash.
+  #
+  #   NOTE: Hash#mash! is only useful for Hash. It is not generally
+  #         applicable to Enumerable.
+
+  def mash!(&yld)
+    replace(mash(&yld))
+  end
+
+  # Alias for #mash!. This is the original name for this method.
+  alias_method :graph!, :mash!
+
+  # An alias for #mash! that was used for a while b/c of it's similarity to #collect,
+  # but it seems like a misnomer and may well be deprecated in the future.
+  alias_method :collate!, :mash!
+
+end

data/lib/core/facets/enumerable/permutation.rb

@@ -1,22 +1,12 @@
-# TITLE:
-#   Permutations
-#
-# DESCRIPTION:
-#   Enumerble permutation extensions.
-#
-# AUTHORS:
-#   - Florian Gross
-
 require 'facets/integer/factorial'
 
-#
 module Enumerable
 
   # Permutation proves the possible orders of an enumerable.
   # Each is index by a permutation number. The maximum number of
   # arrangements is the factorial of the size of the array.
   #
-  # CREDIT Florian Gross
+  #   CREDIT: Florian Gross
 
   def permutation(number)
       arr = to_a
@@ -24,7 +14,8 @@ module Enumerable
       nextfactor = factor = 1
       arr.each_with_index {|x,i|
           case i
-          when 0: next
+          when 0
+            next
           else
               nextfactor = factor * (i+1)
               out.insert(number % nextfactor / factor, x)
@@ -33,11 +24,12 @@ module Enumerable
       }
       out
   end
-  alias :permute :permutation
+
+  alias_method :permute, :permutation
 
   # Calculate permutation number.
   #
-  # CREDIT Florian Gross
+  #   CREDIT: Florian Gross
 
   def permutation_number(original_array=self.to_a.sort)
       arr = to_a
@@ -66,41 +58,44 @@ module Enumerable
   #   cab
   #   cba
   #
-  # CREDIT Florian Gross
+  #   CREDIT: Daniel Sheppard
 
   def each_permutation()
-      arr = to_a
-      size = arr.size
-      perm_count = (1...size).inject(0) { |s,x| s + x * x.factorial }
-      weights = Array.new(size-1) {|i| (i+1).factorial }
-      s = weights.size
-      x,i,v,pos = nil
-      0.upto(perm_count) do |v|
-          out = arr[0..0]
-          arr.each_with_index {|x,i|
-              case i
-                  when 0: next
-                  when s: out.insert(v / weights[i-1], x)
-                  else out.insert(v % weights[i] / weights[i-1], x)
-              end
-          }
+      pos = Array.new(size) {|i| i}
+      s = (0...size).to_a.reverse
+      out = nil
+      while true
+          out = []
+          pos.each_with_index {|p,i| out.insert(p, self[i]) }
           yield out
+          break if s.each do |i|
+              break if pos[i] > 0 && pos[i] -= 1
+              pos[i] = i
+          end
       end
   end
 
-  #-- OLD VERSION
-  #def each_permutation( prefixed=[] )
-  #  s = self.to_a
-  #  if (length < 2)
-  #    # there are no elements left to permute
-  #    yield(prefixed + self)
-  #  else
-  #    # recursively permute the remaining elements
-  #    s.each_with_index do |e, i|
-  #      (s[0,i]+s[(i+1)..-1]).each_permutation(prefixed+[e]) { |a| yield a }
-  #    end
-  #  end
-  #end
-  #++
+  # OLD VERSION
+  #   #   CREDIT: Florian Gross
+  #
+  #   def each_permutation()
+  #       arr = to_a
+  #       size = arr.size
+  #       perm_count = (1...size).inject(0) { |s,x| s + x * x.factorial }
+  #       weights = Array.new(size-1) {|i| (i+1).factorial }
+  #       s = weights.size
+  #       x,i,v,pos = nil
+  #       0.upto(perm_count) do |v|
+  #           out = arr[0..0]
+  #           arr.each_with_index {|x,i|
+  #               case i
+  #                   when 0: next
+  #                   when s: out.insert(v / weights[i-1], x)
+  #                   else out.insert(v % weights[i] / weights[i-1], x)
+  #               end
+  #           }
+  #           yield out
+  #       end
+  #   end
 
 end

data/lib/core/facets/enumerable/probability.rb

@@ -1,30 +1,10 @@
-# TITLE:
-#
-#   Enumerable Statistical Extensions
-#
-# FILE:
-#
-#   statistics.rb
-#
-# DESCRIPTION:
-#
-#   Extensions for statistical information.
-#
-#   Note that String#entropy has been deprecated.
-#   Use str.chars.entropy instead.
-#
-# AUTHORS:
-#
-#   CREDIT Derek
-#   CREDIT Brian Schröder
-#   CREDIT Florian Gross
-
-#
 module Enumerable
 
   # In Statistics mode is the value that occurs most
   # frequently in a given set of data.
   #
+  #   CREDIT: Trans
+
   def mode
     count = Hash.new(0)
     each {|x| count[x] += 1 }
@@ -34,10 +14,9 @@ module Enumerable
   # Generates a hash mapping each unique symbol in the array
   # to the relative frequency, i.e. the probablity, of
   # it appearence.
-  #--
-  # Credit goes to Brian Schröder for current code
-  # and Derek for original.
-  #++
+  #
+  #   CREDIT: Brian Schröder
+
   def probability
     probs = Hash.new(0.0)
     size = 0.0
@@ -64,8 +43,6 @@ module Enumerable
   #     probHash
   #   end
 
-  # CREDIT Derek
-
   # Shannon's entropy for an array - returns the average
   # bits per symbol required to encode the array.
   # Lower values mean less "entropy" - i.e. less unique
@@ -73,6 +50,8 @@ module Enumerable
   #
   #   %w{ a b c d e e e }.entropy  #=>
   #
+  #   CREDIT: Derek
+
   def entropy
     arr = to_a
     probHash = arr.probability
@@ -83,12 +62,12 @@ module Enumerable
     h
   end
 
-  # CREDIT Derek
-
   # Returns the maximum possible Shannon entropy of the array
   # with given size assuming that it is an "order-0" source
   # (each element is selected independently of the next).
   #
+  #   CREDIT: Derek
+
   def ideal_entropy
     arr = to_a
     unitProb = 1.0.to_f / arr.size.to_f
@@ -97,9 +76,9 @@ module Enumerable
 
   # Generates a hash mapping each unique symbol in the array
   # to the absolute frequency it appears.
-  #--
-  # Credit goes to Brian Schröder and Derek for inspiration.
-  #++
+  #
+  #   CREDIT: Brian Schröder
+
   def frequency
     #probs = Hash.new(0)
     #each do |e|
@@ -121,9 +100,8 @@ module Enumerable
   #   # Returns all persons that share their last name with another person.
   #   persons.collisions { |person| person.last_name }
   #
-  #--
-  # Credit goes to Florian Gross.
-  #++
+  #   CREDIT: Florian Gross
+
   def commonality( &block )
     had_no_block = !block
     block ||= lambda { |item| item }
@@ -152,6 +130,8 @@ end
 
 # class String
 #
+#   NOTE: String#entropy has been deprecated.
+#   Use str.chars.entropy instead.
 #   def entropy
 #     split(//).entropy
 #   end
@@ -162,57 +142,3 @@ end
 #   # end
 #
 # end
-
-
-
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-=begin test
-
-  require 'test/unit'
-
-  class TestEnumerable < Test::Unit::TestCase
-
-    def test_entropy
-      assert_equal( 1.0, %w{ a b }.entropy )
-    end
-
-    def test_ideal_entropy
-      assert_equal( 1.0, %w{ a b }.ideal_entropy )
-      assert_equal( 2.0, %w{ a a b b }.ideal_entropy )
-    end
-
-    def test_probability
-      assert_equal( {'a'=>0.5,'b'=>0.5}, %w{a b}.probability )
-      assert_equal( {'tom'=>0.5,'boy'=>0.5}, %w{tom boy}.probability )
-    end
-
-    def test_frequency
-      assert_equal( {'a'=>1,'b'=>1}, %w{a b}.frequency )
-      assert_equal( {'tom'=>1,'boy'=>1}, %w{tom boy}.frequency )
-    end
-
-    def test_commonality
-      a = [1,2,2,3,3,3]
-      r = { 2 => [2,2], 3 => [3,3,3] }
-      assert_equal( r, a.commonality )
-      a = [1,2,2,3,3,3]
-      r = {false=>[1, 2, 2], true=>[3, 3, 3]}
-      assert_equal( r, a.commonality { |x| x > 2 } )
-    end
-
-#     def test_collisions
-#       a = [1,2,2,3,3,3]
-#       assert_equal( [2,3], a.collisions )
-#       a = [1,2,2,3,3,3]
-#       r = {false=>[1, 2, 2], true=>[3, 3, 3]}
-#       assert_equal( r, a.collisions { |x| x > 2 } )
-#     end
-
-  end
-
-=end

data/lib/core/facets/enumerable/split.rb

@@ -0,0 +1,113 @@
+module Enumerable
+
+  unless (RUBY_VERSION[0,3] == '1.9')
+    # #group_by is used to group items in a collection by something they
+    # have in common.  The common factor is the key in the resulting hash, the
+    # array of like elements is the value.
+    #
+    #   (1..5).group_by { |n| n % 3 }
+    #        #=> { 0 => [3], 1 => [1, 4], 2 => [2,5] }
+    #
+    #   ["I had", 1, "dollar and", 50, "cents"].group_by { |e| e.class }
+    #        #=> { String => ["I had","dollar and","cents"], Fixnum => [1,50] }
+    #
+    #   CREDIT: Erik Veenstra
+    #
+    # TODO:
+    #   - Deprecate #group_by when released for Ruby 1.9.
+
+    def group_by #:yield:
+      #h = k = e = nil
+      r = Hash.new
+      each{ |e| (r[yield(e)] ||= []) << e }
+      r
+    end
+  end
+
+  # This alias is the original Facets name for the method, but Ruby 1.9 has
+  # adopted #group_by as the name, so eventually #partition_by will be deprecated.
+
+  alias_method :partition_by, :group_by
+
+  # Split on matching pattern. Unlike #divide this does not include matching elements.
+  #
+  #   ['a1','a2','b1','a3','b2','a4'].split(/^b/)
+  #   => [['a1','a2'],['a3'],['a4']]
+  #
+  # CREDIT: Trans
+
+  def split(pattern)
+    memo = []
+    each do |obj|
+      if pattern === obj
+        memo.push []
+      else
+        memo.last << obj
+      end
+    end
+    memo
+  end
+
+  # Divide on matching pattern.
+  #
+  #   ['a1','b1','a2','b2'].divide(/^a/)
+  #   => [['a1,'b1'],['a2','b2']]
+  #
+  #   CREDIT: Trans
+
+  def divide(pattern)
+    memo = []
+    each do |obj|
+      memo.push [] if pattern === obj
+      memo.last << obj
+    end
+    memo
+  end
+
+  # Similar to #group_by but returns an array of the groups.
+  # Returned elements are sorted by block.
+  #
+  #    %w{this is a test}.cluster_by {|x| x[0]}
+  #
+  # _produces_
+  #
+  #    [ ['a'], ['is'], ['this', 'test'] ]
+  #
+  # CREDIT Erik Veenstra
+
+  def cluster_by(&b)
+    group_by(&b).sort.transpose.pop || []   # group_by(&b).values ?
+  end
+
+  # Modulate. Divide an array into groups by modulo of the index.
+  #
+  # [2,4,6,8].modulate(2)  #=> [[2,6],[4,8]]
+  #
+  # CREDIT: Trans
+  #
+  # NOTE: Would this be better named 'collate'?
+
+  def modulate(modulo)
+    return to_a if modulo == 1
+    raise ArgumentError, 'bad modulo' if size % modulo != 0
+    r = Array.new(modulo, [])
+    (0...size).each do |i|
+      r[i % level] += [self[i]]
+    end
+    r
+  end
+
+  # DEPRECATED -- Use 'each_slice(n).to_a' as of 1.9.
+  # Partition an array into parts of given length.
+  #
+  # CREDIT WhyTheLuckyStiff
+  #
+  #   def / len
+  #     inject([]) do |ary, x|
+  #       ary << [] if [*ary.last].nitems % len == 0
+  #       ary.last << x
+  #       ary
+  #     end
+  #   end
+
+end