facets 0.9.0 → 1.0.0

data/lib/nano/enumerable/map_with_counter.rb

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

data/lib/nano/enumerable/map_with_index.rb

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

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

@@ -1,38 +0,0 @@
-
-require 'nano/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/nano/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/nano/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/nano/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/nano/enumerable/self/combinations.rb

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