facets 1.1.0 → 1.2.0

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

@@ -0,0 +1,65 @@
+#--
+# Credit goes to Gavin Sinclair.
+#++
+module Enumerable
+
+  # Enumerable#one? returns +true+ if and only if <em>exactly one</em>
+  # element in the collection satisfies the given predicate.
+  #
+  # If no predicate is provided, Enumerable#one? returns +true+ if
+  # and only if <em>exactly one</em> element has a true value
+  # (i.e. not +nil+ or +false+).
+  #
+  #   [].one?                      # false
+  #   [nil].one?                   # false
+  #   [5].one?                     # true
+  #   [5,8,9].one?                 # false
+  #   (1...10).one? { |n| n == 5 } # true
+  #   (1...10).one? { |n| n < 5 }  # false
+  #
+  def one?  # :yield: e
+    matches = 0
+    if block_given?
+      self.each do |e|
+        if yield(e)
+          matches += 1
+          return false if matches > 1
+        end
+      end
+      return (matches == 1)
+    else
+      one? { |e| e }
+    end
+  end
+
+end
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+
+  require 'test/unit'
+
+  class TCEnumerable < Test::Unit::TestCase
+
+    def test_one?
+      a = [nil, true]
+      assert( a.one? )
+      a = [true, false]
+      assert( a.one? )
+      a = [true, true]
+      assert( ! a.one? )
+      a = [true, 1]
+      assert( ! a.one? )
+      a = [1, 1]
+      assert( ! a.one? )
+    end
+
+  end
+
+=end

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

@@ -0,0 +1,38 @@
+
+require 'facet/enumerable/cross'
+
+module Enumerable
+
+  # Operator alias for cross-product.
+  #
+  #   a = [1,2] ** [4,5]
+  #   a  #=> [[1, 4],[1, 5],[2, 4],[2, 5]]
+  #
+  def **(enum)
+    Enumerable.cross(self, enum)
+  end
+
+end
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+
+  require 'test/unit'
+
+  class TCEnumerable < Test::Unit::TestCase
+
+    def test_op_pow
+      a = [1,2,3] ** [4,5,6]
+      assert_equal( [[1, 4],[1, 5],[1, 6],[2, 4],[2, 5],[2, 6],[3, 4],[3, 5],[3, 6]], a )
+    end
+
+  end
+
+=end

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

@@ -0,0 +1,55 @@
+
+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

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

@@ -0,0 +1,135 @@
+
+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

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

@@ -0,0 +1,59 @@
+#--
+# 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

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

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

data/lib/facets/core/enumerable/self/combinations.rb

@@ -0,0 +1,68 @@
+
+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

data/lib/facets/core/enumerable/self/cross.rb

@@ -0,0 +1,79 @@
+#--
+# 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