facets 1.0.0 → 1.0.1

data/lib/facet/enumerable/ideal_entropy.rb

@@ -1,49 +0,0 @@
-
-module Enumerable
-
-  # 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 goes to Derek.
-  #++
-  def ideal_entropy
-    arr = self.to_a
-    unitProb = 1.0.to_f / arr.size.to_f
-    (-1.to_f * arr.size.to_f * unitProb * Math.log(unitProb)/Math.log(2.to_f))
-  end
-
-end
-
-# Not needed b/c ideal_entropy is only dependent on size.
-# class String
-#   def ideal_entropy
-#     self.split(//).ideal_entropy
-#   end
-# end
-
-
-
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-=begin test
-
-  require 'test/unit'
-
-  class TCEnumerable < Test::Unit::TestCase
-
-    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
-
-  end
-
-=end

data/lib/facet/enumerable/map_with_counter.rb

@@ -1,2 +0,0 @@
-# stub
-require 'facet/enumerable/collect_with_index'

data/lib/facet/enumerable/map_with_index.rb

@@ -1,2 +0,0 @@
-# stub
-require 'facet/enumerable/collect_with_index'

data/lib/facet/enumerable/none.rb

@@ -1,56 +0,0 @@
-#--
-# Credit goes to Gavin Sinclair.
-#++
-module Enumerable
-
-  # Enumerable#none? is the logical opposite of the builtin method
-  # Enumerable#any?.  It returns +true+ if and only if _none_ of
-  # the elements in the collection satisfy the predicate.
-  #
-  # If no predicate is provided, Enumerable#none? returns +true+
-  # if and only if _none_ of the elements have a true value
-  # (i.e. not +nil+ or +false+).
-  #
-  #   [].none?                      # true
-  #   [nil].none?                   # true
-  #   [5,8,9].none?                 # false
-  #   (1...10).none? { |n| n < 0 }  # true
-  #   (1...10).none? { |n| n > 0 }  # false
-  #
-  def none?  # :yield: e
-    if block_given?
-      not self.any? { |e| yield e }
-    else
-      not self.any?
-    end
-  end
-
-end
-
-
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-=begin test
-
-  require 'test/unit'
-
-  class TCEnumerable < Test::Unit::TestCase
-
-    def test_none?
-      a = [nil, nil]
-      assert( a.none? )
-      a = [false, false]
-      assert( a.none? )
-      a = [true, false]
-      assert( ! a.none? )
-      a = [nil, 1]
-      assert( ! a.none? )
-    end
-
-  end
-
-=end

data/lib/facet/enumerable/nonuniq.rb

@@ -1,39 +0,0 @@
-#--
-# Credit goes to martin DeMello
-#++
-
-module Enumerable
-
-  def nonuniq
-    h1 = {}
-    h2 = {}
-    each {|i|
-      h2[i] = true if h1[i]
-      h1[i] = true
-    }
-    h2.keys 
-  end
-
-  def nonuniq!
-    raise unless respond_to?(:replace)
-    h1 = {}
-    h2 = {}
-    each {|i|
-      h2[i] = true if h1[i]
-      h1[i] = true
-    }
-    self.replace(h2.keys)
-  end
-
-end
-
-
-
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-# TODO
-

data/lib/facet/enumerable/occur.rb

@@ -1,62 +0,0 @@
-
-module Enumerable
-
-  # Returns an array of elements for the elements that occur n times.
-  # Or according to the results of a given block.
-  #
-  #   [1,1,2,3,3,4,5,5].occur(1)             #=> [2,4]
-  #   [1,1,2,3,3,4,5,5].occur(2)             #=> [1,3,5]
-  #   [1,1,2,3,3,4,5,5].occur(3)             #=> []
-  #
-  #   [1,2,2,3,3,3].occur(1..1)              #=> [1]
-  #   [1,2,2,3,3,3].occur(2..3)              #=> [2,3]
-  #
-  #   [1,1,2,3,3,4,5,5].occur { |n| n == 1 } #=> [2,4]
-  #   [1,1,2,3,3,4,5,5].occur { |n| n > 1 }  #=> [1,3,5]
-  #
-  def occur(n=nil) #:yield:
-    result = Hash.new { |hash, key| hash[key] = Array.new }
-    self.each do |item|
-      key = item
-      result[key] << item
-    end
-    if block_given?
-      result.reject! { |key, values| ! yield(values.size) }
-    else
-      raise ArgumentError unless n
-      if Range === n
-        result.reject! { |key, values| ! n.include?(values.size) }
-      else
-        result.reject! { |key, values| values.size != n }
-      end
-    end
-    return result.values.flatten.uniq
-  end
-
-end
-
-
-
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-=begin test
-
-  require 'test/unit'
-
-  class TCEnumerable < Test::Unit::TestCase
-
-    def test_occur
-      arr = [:a,:b,:a]
-      assert_equal( [:b], arr.occur(1) )
-      assert_equal( [:a], arr.occur(2) )
-      assert_equal( [:b], arr.occur(1..1) )
-      assert_equal( [:a], arr.occur{ |n| n % 2 == 0 } )
-    end
-
-  end
-
-=end

data/lib/facet/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/facet/enumerable/op_pow.rb

@@ -1,38 +0,0 @@
-
-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/facet/enumerable/partition_by.rb

@@ -1,55 +0,0 @@
-
-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/facet/enumerable/permute.rb

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