mack-facets 0.8.1 → 0.8.2

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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