facets 1.1.0 → 1.2.0

data/lib/facet/enumerable/partition_by.rb

@@ -1,55 +1 @@
-
-module Enumerable
-
-  # See Enumerable#partition for the background. #partition_by is best
-  # explained by example.
-  #
-  #   (1..5).partition_by { |n| n % 3 }
-  #        #=> { 0 => [3], 1 => [1, 4], 2 => [2,5] } 
-  #
-  #   ["I had", 1, "dollar and", 50, "cents"].partition_by { |e| e.class }
-  #        #=> { String => ["I had","dollar and","cents"], Fixnum => [1,50] } 
-  #
-  # #partition_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.
-  #--
-  # Credit goes to Gavin Sinclair.
-  #++
-  def partition_by #:yield:
-    result = {}
-    self.each do |e|
-      value = yield e
-      (result[value] ||= []) << e
-    end
-    result
-  end
-
-end
-
-
-
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-=begin test
-
-  require 'test/unit'
-
-  class TCEnumerable < Test::Unit::TestCase
-
-    def test_partition_by
-      x = (1..5).partition_by{ |n| n % 3 }
-      o = { 0 => [3], 1 => [1, 4], 2 => [2,5] }
-      assert_equal( o, x )
-      x = ["I had", 1, "dollar and", 50, "cents"].partition_by { |e| e.class }
-      o = { String => ["I had","dollar and","cents"], Fixnum => [1,50] }
-      assert_equal( o, x )
-    end
-
-  end
-
-=end
+require 'facets/core/enumerable/partition_by.rb'

data/lib/facet/enumerable/permute.rb

@@ -1,135 +1 @@
-
-require 'facet/integer/factorial'
-
-module Enumerable
-
-    def permute(number)
-        arr = to_a
-        out = arr[0..0]
-        nextfactor = factor = 1
-        arr.each_with_index {|x,i|
-            case i
-            when 0: next
-            else
-                nextfactor = factor * (i+1)
-                out.insert(number % nextfactor / factor, x)
-                factor = nextfactor
-            end
-        }
-        out
-    end
-
-    def permutation_number(original_array=self.to_a.sort)
-        arr = to_a
-        m = 1
-        v = 0
-        last_indicies = Hash.new(0)
-        original_array.each_with_index {|x,i|
-            next if i==0
-            m *= i
-            done = original_array[0..i]
-            v += m * arr.select {|y| done.include?(y)}.rindex(x)
-        }
-        v
-    end
-
-    # Applys a block to each possible permutation of an array/enumerable.
-    #
-    #   %w[a b c].each_permutation { |x| puts(x.join('')) }
-    #
-    # produces
-    #
-    #   abc
-    #   acb
-    #   bac
-    #   bca
-    #   cab
-    #   cba
-    #
-    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
-
-    #-- 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
-    #++
-
-end
-
-
-#  _____       _
-# |_   _|__ __| |_
-#   | |/ -_|_-<  _|
-#   |_|\___/__/\__|
-#
-=begin test
-
-  require 'test/unit'
-  require 'set'
-
-  class TCEnumerable < Test::Unit::TestCase
-
-    def test_001
-      o = Set.new
-      %w[a b c].each_permutation { |x| o << x.join('') }
-      r = Set.new(['abc','acb','bac','bca','cab','cba'])
-      assert_equal( r, o )
-    end
-  end
-
-=end
-
-
-#   ___ _
-#  / __| |_  __ _ _ _  __ _ ___ ___
-# | (__| ' \/ _` | ' \/ _` / -_|_-<
-#  \___|_||_\__,_|_||_\__, \___/__/
-#                     |___/
-#
-=begin changelog
-
-  2005-10-05 (trans):
-  - Changed 'Class Array' to 'module Enumerable'
-  - Replaced with Daniel Sheppard's code.
-
-=end
-
-
-#   ___            _ _ _
-#  / __|_ _ ___ __| (_) |_ ___
-# | (__| '_/ -_) _` | |  _(_-<
-#  \___|_| \___\__,_|_|\__/__/
-#
-=begin credits
-
-  - Daniel Sheppard
-  - Paul Battley (old version of each_permutation)
-
-=end
+require 'facets/core/enumerable/permute.rb'

data/lib/facet/enumerable/probability.rb

@@ -1,59 +1 @@
-#--
-# Credit goes to Brian Schröder for current code
-# and Derek for original.
-#++
-module Enumerable
-
-  # Generates a hash mapping each unique symbol in the array
-  # to the relative frequency, i.e. the probablity, of
-  # it appearence.
-  def probability
-    probs = Hash.new(0.0)
-    size = 0.0
-    each do | e |
-      probs[e] += 1.0
-      size += 1.0
-    end
-    probs.keys.each { |e| probs[e] /= size }
-    probs
-  end
-
-# old def
-#
-#   def probability
-#     arr = self.to_a
-#     probHash = Hash.new
-#     size = arr.size.to_f
-#     arr.uniq.each do |i|
-#       ct = arr.inject(0) do |mem,obj|
-#         obj.eql?(i) ? (mem+1) : mem
-#       end
-#       probHash[i] = ct.to_f/size
-#     end
-#     probHash
-#   end
-
-end
-
-
-
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-=begin test
-
-  require 'test/unit'
-
-  class TCEnumerable < Test::Unit::TestCase
-
-    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
-
-  end
-
-=end
+require 'facets/core/enumerable/probability.rb'

data/lib/facet/enumerable/project.rb

@@ -1,11 +1 @@
-#--
-# CREDIT Sean O'Halpin
-#++
-
-module Enumerable
-
-  def project(&block)
-    self.map{|x| x.instance_eval(&block) }
-  end
-
-end
+require 'facets/core/enumerable/project.rb'

data/lib/facet/enumerable/self/combinations.rb

@@ -1,68 +1 @@
-
-module Enumerable
-
-  # Produces an array of arrays of all possible combinations
-  # of the given arrays in the position given. (Explain me better?)
-  #
-  #   a = %w|a b|
-  #   b = %w|a x|
-  #   c = %w|x y|
-  #   Array.combinations(a, b, c).each { |x| p x }
-  #
-  # produces
-  #
-  #   ["a", "a", "x"]
-  #   ["a", "a", "y"]
-  #   ["a", "x", "x"]
-  #   ["a", "x", "y"]
-  #   ["b", "a", "x"]
-  #   ["b", "a", "y"]
-  #   ["b", "x", "x"]
-  #   ["b", "x", "y"]
-  #
-  def self.combinations(head, *rest)
-    crest = rest.empty? ? [[]] : combinations(*rest)
-    head.inject([]) { |combs, item|
-      combs + crest.map { |comb| [item] + comb }
-    }
-  end
-
-end
-
-
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-=begin test
-
-  require 'test/unit'
-
-  class TCEnumerable < Test::Unit::TestCase
-
-    def test_combinations
-      a = [1,2]
-      b = [3,4]
-      r = Enumerable.combinations(a,b)
-      assert_equal( [[1,3],[1,4],[2,3],[2,4]], r )
-
-      r = [ ["a", "a", "x"],
-            ["a", "a", "y"],
-            ["a", "x", "x"],
-            ["a", "x", "y"],
-            ["b", "a", "x"],
-            ["b", "a", "y"],
-            ["b", "x", "x"],
-            ["b", "x", "y"] ]
-      a = %w|a b|
-      b = %w|a x|
-      c = %w|x y|
-      z = Enumerable.combinations(a, b, c)
-      assert_equal( r, z )
-    end
-
-  end
-
-=end
+require 'facets/core/enumerable/self/combinations.rb'

data/lib/facet/enumerable/self/cross.rb

@@ -1,79 +1 @@
-#--
-# Cross product adapted from code by Michael Neuman.
-#++
-require 'generator'
-
-module Enumerable
-
-  #  Provides the cross-product of two or more Enumerables.
-  #  This is the class-level method. The instance method
-  #  calls on this.
-  #
-  #    Enumerable.cross([1,2], [4], ["apple", "banana"])
-  #    #=> [[1, 4, "apple"], [1, 4, "banana"], [2, 4, "apple"], [2, 4, "banana"]]
-  #
-  #    Enumerable.cross([1,2], [3,4])
-  #    #=> [[1, 3], [1, 4], [2, 3], [2, 4]]
-  #
-  def self.cross(*enums, &block)
-    raise if enums.empty?
-    gens = enums.map{|e| Generator.new(e)}
-    return [] if gens.any? {|g| g.end?}
-    sz = gens.size
-    res = []
-    tuple = Array.new(sz)
-
-    loop do
-      # fill tuple
-      (0 ... sz).each { |i| 
-        tuple[i] = gens[i].current 
-      }
-      if block.nil?
-        res << tuple.dup
-      else
-        block.call(tuple.dup)
-      end
-
-      # step forward
-      gens[-1].next
-      (sz-1).downto(0) { |i|
-        if gens[i].end?
-          if i > 0
-            gens[i].rewind
-            gens[i-1].next
-          else
-            return res
-          end
-        end
-      }
-    end
-  end
-
-end
-
-
-
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-=begin test
-
-  require 'test/unit'
-
-  class TCEnumerable < Test::Unit::TestCase
-
-    def test_cross
-      i = [[1,2], [3,4]]
-      o = [[1, 3], [1, 4], [2, 3], [2, 4]]
-      assert_equal( o, Enumerable.cross(*i) )
-      i = [[1,2], [4], ["apple", "banana"]]
-      o = [[1, 4, "apple"], [1, 4, "banana"], [2, 4, "apple"], [2, 4, "banana"]]
-      assert_equal( o, Enumerable.cross(*i) )
-    end
-
-  end
-
-=end
+require 'facets/core/enumerable/self/cross.rb'

data/lib/facet/enumerable/to_h.rb

@@ -1,50 +1 @@
-
-module Enumerable
-
-  # Produces a hash from an Enumerable with index for keys.
-  #
-  #   enu = 'a'..'b'
-  #   enu.to_h  #=> { 0=>'a', 1=>'b' }
-  #
-  # If a block is passed, the hash values will be set by 
-  # calling the block with the enumerated element and it's
-  # counter.
-  #
-  #   enu = 'a'..'b'
-  #   enu.to_h{ |e,i| e }  #=> { 0=>'a', 1=>'b' }
-  #
-  # See also #graph.
-  #
-  def to_h( &blk )
-    h = {}
-    if block_given?
-      each_with_index{ |e,i| h[i] = blk.call(e,i) }
-    else
-      each_with_index{ |e,i| h[i] = e }
-    end
-    h
-  end
-
-end
-
-
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-=begin test
-
-  require 'test/unit'
-
-  class TCEnumerable < Test::Unit::TestCase
-
-    def test_to_h
-      a = [:a,:b,:c]
-      assert_equal( { 0=>:a, 1=>:b, 2=>:c }, a.to_h )
-    end
-
-  end
-
-=end
+require 'facets/core/enumerable/to_h.rb'