facets 1.8.54 → 2.0.0

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

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

@@ -1,38 +0,0 @@
-
-require 'facets/core/enumerable/cart'
-
-module Enumerable
-
-  # Operator alias for cross-product.
-  #
-  #   a = [1,2] ** [4,5]
-  #   a  #=> [[1, 4],[1, 5],[2, 4],[2, 5]]
-  #
-  def **(enum)
-    Enumerable.cart(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/op_tilde_self.rb

@@ -1,46 +0,0 @@
-require 'facets/core/enumerable/elementwise'
-
-module Enumerable
-
-  # Operator equivalent of #elementwise.
-
-  def ~@
-    elementwise
-  end
-
-end
-
-
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-=begin test
-
-  require 'test/unit'
-
-  class TestOpTildeSelf < Test::Unit::TestCase
-
-    def test_ew
-      a = [1,2,3]
-      b = [4,5]
-      assert_equal( [4,5,6], a.ew + 3 )
-      assert_equal( [5,7], a.ew + b )
-      assert_equal( [[5,7],[3,4,5]], a.ew.+(b,2) )
-      assert_equal( [[5,7],[4,5,6]], a.ew.+(b,3) )
-    end
-
-    def test_op_tilde_self
-      a = [1,2,3]
-      b = [4,5]
-      assert_equal( [4,5,6], ~a + 3 )
-      assert_equal( [5,7], ~a + b )
-      assert_equal( [[5,7],[3,4,5]], (~a).+(b,2) )
-      assert_equal( [[5,7],[4,5,6]], (~a).+(b,3) )
-    end
-
-  end
-
-=end

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

@@ -1,57 +0,0 @@
-#--
-# CREDIT Gavin Sinclair
-# CREDIT Gregory of Laurel, Maryland
-#++
-
-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.
-
-  def partition_by #:yield:
-    r = Hash.new{ |h,k| h[k]=[] }
-    each do |e|
-      r[ yield(e) ] << e
-    end
-    return r
-  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/permutation.rb

@@ -1,142 +0,0 @@
-
-require 'facets/core/integer/factorial'
-
-module Enumerable
-
-    # Permutation proves the possible orders of an enumerable.
-    # Each is index by a oermutation numnber. The maximum number of
-    # arrangements is the factorial of the size of the array.
-
-    def permutation(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
-    alias :permute :permutation
-
-    #
-
-    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

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

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

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

@@ -1,8 +0,0 @@
-# = cart.rb
-#
-# Stub for <tt>cart.rb</tt>.
-#
-# CREDIT Thomas Halfner
-
-require 'facets/core/enumerable/cart.rb'
-

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

@@ -1,8 +0,0 @@
-# = cartesian_product.rb
-#
-# Stub for <tt>cart.rb</tt>.
-#
-# CREDIT Thomas Halfner
-
-require 'facets/core/enumerable/cart.rb'
-

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

@@ -1,73 +0,0 @@
-
-module Enumerable
-
-  # Produces an array of arrays of all possible combinations
-  # of the given arrays in the positions given. (Imagine
-  # it like a slot machine dial. This gives evey combination
-  # that could come up.)
-  #
-  #   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_01
-      a = [1,2]
-      b = [3,4]
-      z = Enumerable.combinations(a,b)
-      r = [[1,3],[1,4],[2,3],[2,4]]
-      assert_equal( r, z )
-    end
-
-    def test_02
-      a = %w|a b|
-      b = %w|a x|
-      c = %w|x y|
-      z = Enumerable.combinations(a, b, c)
-      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"] ]
-      assert_equal( r, z )
-    end
-
-  end
-
-=end