mack-facets 0.8.2 → 0.8.3

data/lib/gems/facets-2.4.5/lib/core/facets/enumerable/duplicates.rb

@@ -1,38 +0,0 @@
-module Enumerable
-
-  # Returns a list on non-unique,
-  #
-  #   [1,1,2,2,3,4,5].nonuniq  #=> [1,2]
-  #
-  #   CREDIT: Martin DeMello
-
-  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
-
-  # Return list of dulicate elements.
-  #
-  #   CREDIT: Thibaut Barrère
-
-  alias_method :duplicates, :nonuniq
-
-end
-

data/lib/gems/facets-2.4.5/lib/core/facets/enumerable/each_by.rb

@@ -1,33 +0,0 @@
-require 'enumerator'
-
-module Enumerable
-
-  # Iterate through slices. If slice +steps+ is not
-  # given, the arity of the block is used.
-  #
-  #   x = []
-  #   [1,2,3,4].each_by{ |a,b| x << [a,b] }
-  #   x  #=> [ [1,2], [3,4] ]
-  #
-  #   x = []
-  #   [1,2,3,4,5,6].each_by(3){ |a| x << a }
-  #   x  #=> [ [1,2,3], [4,5,6] ]
-  #
-  # This is just like each_slice, except that it will check
-  # the arity of the block. If each_slice ever suppots this
-  # this method can be deprecated.
-  #
-  #  CREDIT: Trans
-
-  def each_by(steps=nil, &block)
-    if steps
-      each_slice(steps, &block)
-    else
-      steps = block.arity.abs
-      each_slice(steps, &block)
-      #each_slice(steps) {|i| block.call(*i)}
-    end
-  end
-
-end
-

data/lib/gems/facets-2.4.5/lib/core/facets/enumerable/entropy.rb

@@ -1,37 +0,0 @@
-require 'facets/enumerable/probability'
-
-module Enumerable
-
-  # Shannon's entropy for an array - returns the average
-  # bits per symbol required to encode the array.
-  # Lower values mean less "entropy" - i.e. less unique
-  # information in the array.
-  #
-  #   %w{ a b c d e e e }.entropy  #=>
-  #
-  #   CREDIT: Derek
-
-  def entropy
-    arr = to_a
-    probHash = arr.probability
-    # h is the Shannon entropy of the array
-    h = -1.to_f * probHash.keys.inject(0.to_f) do |sum, i|
-      sum + (probHash[i] * (Math.log(probHash[i])/Math.log(2.to_f)))
-    end
-    h
-  end
-
-  # 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: Derek
-
-  def ideal_entropy
-    arr = 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
-

data/lib/gems/facets-2.4.5/lib/core/facets/enumerable/frequency.rb

@@ -1,18 +0,0 @@
-module Enumerable
-
-  # Generates a hash mapping each unique symbol in the array
-  # to the absolute frequency it appears.
-  #
-  #  CREDIT: Brian Schröder
-
-  def frequency
-    #probs = Hash.new(0)
-    #each do |e|
-    #  probs[e] += 1
-    #end
-    #probs
-    inject(Hash.new(0)){|h,v| h[v]+=1; h}
-  end
-
-end
-

data/lib/gems/facets-2.4.5/lib/core/facets/enumerable/group_by.rb

@@ -1,27 +0,0 @@
-module Enumerable
-
-  unless defined?(group_by) or defined?(::ActiveSupport)  # 1.9 or ActiveSupport
-
-    # #group_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.
-    #
-    #   (1..5).group_by { |n| n % 3 }
-    #        #=> { 0 => [3], 1 => [1, 4], 2 => [2,5] }
-    #
-    #   ["I had", 1, "dollar and", 50, "cents"].group_by { |e| e.class }
-    #        #=> { String => ["I had","dollar and","cents"], Fixnum => [1,50] }
-    #
-    #  CREDIT: Erik Veenstra
-
-    def group_by #:yield:
-      #h = k = e = nil
-      r = Hash.new
-      each{ |e| (r[yield(e)] ||= []) << e }
-      r
-    end
-
-  end
-
-end
-

data/lib/gems/facets-2.4.5/lib/core/facets/enumerable/inject.rb

@@ -1,31 +0,0 @@
-module Enumerable
-
-  # A small variation of #Inject that save one from having to 
-  # return the aggregating or memo argument.
-  #
-  # Say you want to count letters.
-  #
-  #    some_text.inject!(Hash.new(0)) {|h,l| h[l] += 1}
-  #
-  # vs
-  #
-  #    some_text.inject(Hash.new(0)) {|h,l| h[l] +=1; h}
-  #
-  #  CREDIT: David Black
-  #  CREDIT: Louis J Scoras
-
-  def inject!(s)
-    k = s
-    each { |i| yield(k, i) }
-    k
-  end
-
-  # HERE AS BACKUP, TO ENSURE THE ABOVE HAS THE SAME FUNCTIONALITY.
-  #def injecting(s)
-  #  inject(s) do |k, i|
-  #    yield(k, i); k
-  #  end
-  #end
-
-end
-

data/lib/gems/facets-2.4.5/lib/core/facets/enumerable/map_send.rb

@@ -1,12 +0,0 @@
-module Enumerable
-
-   # Send a message to each element and collect the result.
-   #
-   #  CREDIT: Sean O'Halpin
-
-  def map_send(meth, *args, &block)
-    map{|e| e.send(meth, *args, &block)}
-  end
-
-end
-

data/lib/gems/facets-2.4.5/lib/core/facets/enumerable/mash.rb

@@ -1,32 +0,0 @@
-module Enumerable
-
-  # Like <tt>#map</tt>/<tt>#collect</tt>, but generates a Hash.  The block
-  # is expected to return two values: the key and the value for the new hash.
-  #
-  #   numbers  = (1..3)
-  #   squares  = numbers.mash { |n| [n, n*n] }   # { 1=>1, 2=>4, 3=>9 }
-  #   sq_roots = numbers.mash { |n| [n*n, n] }   # { 1=>1, 4=>2, 9=>3 }
-  #
-  # CREDIT: Trans
-  # CREDIT: Andrew Dudzik (adudzik)
-  #
-  # NOTE: Would #correlate would be better?
-
-  def mash(&yld)
-    if yld
-      inject({}) do |h, *kv| # Used to be inject({}) do |h,kv|
-        r = *yld[*kv]        # The *-op works differnt from to_a on single element hash!!!
-        nk, nv = *r          # Used to be nk, nv = *yld[*kv].to_a.flatten
-        h[nk] = nv
-        h
-      end
-    else
-      Enumerator.new(self,:graph)  # Used to be Hash[*self.to_a] or Hash[*self.to_a.flatten]
-    end
-  end
-
-  # Alias for #mash. This is the original name for this method.
-  alias_method :graph, :mash
-
-end
-

data/lib/gems/facets-2.4.5/lib/core/facets/enumerable/mode.rb

@@ -1,16 +0,0 @@
-module Enumerable
-
-  # In Statistics mode is the value that occurs most
-  # frequently in a given set of data.
-  #
-  #  CREDIT: Robert Klemme
-
-  def mode
-    max = 0
-    c = Hash.new 0
-    each {|x| cc = c[x] += 1; max = cc if cc > max}
-    c.select {|k,v| v == max}.map {|k,v| k}
-  end
-
-end
-

data/lib/gems/facets-2.4.5/lib/core/facets/enumerable/modulate.rb

@@ -1,22 +0,0 @@
-module Enumerable
-
-  # Modulate. Divide an array into groups by modulo of the index.
-  #
-  # [2,4,6,8].modulate(2)  #=> [[2,6],[4,8]]
-  #
-  #  CREDIT: Trans
-  #
-  # NOTE: Would this be better named 'collate'?
-
-  def modulate(modulo)
-    return to_a if modulo == 1
-    raise ArgumentError, 'bad modulo' if size % modulo != 0
-    r = Array.new(modulo, [])
-    (0...size).each do |i|
-      r[i % modulo] += [self[i]]
-    end
-    r
-  end
-
-end
-

data/lib/gems/facets-2.4.5/lib/core/facets/enumerable/none.rb

@@ -1,31 +0,0 @@
-unless (RUBY_VERSION[0,3] == '1.9')
-
-  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
-    #
-    #   CREDIT: Gavin Sinclair
-
-    def none?  # :yield: e
-      if block_given?
-        not self.any? { |e| yield e }
-      else
-        not self.any?
-      end
-    end
-
-  end
-
-end

data/lib/gems/facets-2.4.5/lib/core/facets/enumerable/occur.rb

@@ -1,38 +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]
-  #
-  #   CREDIT: ?
-
-  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
-

data/lib/gems/facets-2.4.5/lib/core/facets/enumerable/one.rb

@@ -1,38 +0,0 @@
-unless (RUBY_VERSION[0,3] == '1.9')
-
-  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
-    #
-    #   CREDIT: Gavin Sinclair
-
-    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
-
-end

data/lib/gems/facets-2.4.5/lib/core/facets/enumerable/probability.rb

@@ -1,36 +0,0 @@
-module Enumerable
-
-  # Generates a hash mapping each unique element in the array
-  # to the relative frequency, i.e. the probablity, of
-  # it appearence.
-  #
-  #   CREDIT: Brian Schröder
-
-  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
-

data/lib/gems/facets-2.4.5/lib/core/facets/enumerable/split.rb

@@ -1,27 +0,0 @@
-module Enumerable
-
-  # Split on matching pattern. Unlike #divide this does not include matching elements.
-  #
-  #   ['a1','a2','b1','a3','b2','a4'].split(/^b/)
-  #   => [['a1','a2'],['a3'],['a4']]
-  #
-  # CREDIT: Trans
-
-  def split(pattern)
-    sect = []
-    memo = []
-    each do |obj|
-      if pattern === obj
-        memo << sect
-        sect = []
-      else
-        sect << obj
-      end
-    end
-    memo << sect #unless sect.empty?
-    memo.pop while memo.last.empty?
-    memo
-  end
-
-end
-