facets-glimmer 3.2.0

data/lib/core/facets/array/duplicates.rb

@@ -0,0 +1,24 @@
+class Array
+
+  # Return list of duplicate elements.
+  #
+  # min - The minimum number of duplication necessary for inclusion. [Integer]
+  #
+  # Examples:
+  #
+  #   [1,1,2,3].duplicates #=> [1]
+  #
+  #   [1,1,2,3,2,4,5,4,2].duplicates(3) #=> [2]
+  #
+  # CREDIT: Rebort Dober (current implementation)
+  # CREDIT: Thibaut Barrère
+
+  def duplicates(min=2)
+    h = Hash.new( 0 )
+    each {|i|
+      h[i] += 1
+    }
+    h.delete_if{|_,v| v < min}.keys
+  end
+
+end

data/lib/core/facets/array/each_overlap.rb

@@ -0,0 +1,25 @@
+class Array
+
+  # Iterate over each slice where the last n values of a preceding slice
+  # overlap with the first n values of the following slice. The value of n
+  # is specified by the second `overlap` argument.
+  #
+  #     a, r = [1,2,3,4,5], []
+  #     a.each_overlap(2,1) { |x,y| r << [x,y] } 
+  #     r # => [[1,2],[2,3],[3,4],[4,5]]
+  #
+  # Returns nothing.
+
+  def each_overlap(slice_size, overlap)
+    if block_given?
+		  i = 0
+		  while i + slice_size <= length
+		    yield slice(i...i+slice_size)
+		    i += (slice_size - overlap)
+		  end
+    else
+      to_enum(:each_overlap, slice_size, overlap)
+    end
+  end
+
+end

data/lib/core/facets/array/each_pair.rb

@@ -0,0 +1,11 @@
+class Array
+
+  # Iterate over index and value. The intention of this
+  # method is to provide polymorphism with Hash.
+  #
+  def each_pair #:yield:
+    each_with_index {|e, i| yield(i,e) }
+  end
+
+end
+

data/lib/core/facets/array/each_value.rb

@@ -0,0 +1,6 @@
+class Array
+  # Alias for #each. The intention of this method
+  # is to provide polymorphism with Hash.
+  alias :each_value :each
+end
+

data/lib/core/facets/array/entropy.rb

@@ -0,0 +1,39 @@
+require 'facets/array/probability'
+
+class Array
+
+  # 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.
+  #
+  #   e = %w{ a b c d e e e }.entropy
+  #
+  #   ("%.3f" % e)  #=> "2.128"
+  #
+  # CREDIT: Derek
+
+  def entropy
+    arr = self
+    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 = self
+    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/core/facets/array/extract_options.rb

@@ -0,0 +1,31 @@
+class Hash
+  # By default, only instances of Hash itself are extractable.
+  # Subclasses of Hash may implement this method and return
+  # true to declare themselves as extractable. If a Hash
+  # is extractable, Array#extract_options! pops it from
+  # the Array when it is the last element of the Array.
+  def extractable_options?
+    instance_of?(Hash)
+  end
+end
+
+class Array
+  # Extracts options from a set of arguments. Removes and returns the last
+  # element in the array if it's a hash, otherwise returns a blank hash.
+  #
+  #   def options(*args)
+  #     args.extract_options!
+  #   end
+  #
+  #   options(1, 2)           # => {}
+  #   options(1, 2, :a => :b) # => {:a=>:b}
+  #
+  def extract_options!
+    if Hash === last && last.extractable_options?
+      pop
+    else
+      {}
+    end
+  end
+end
+

data/lib/core/facets/array/first.rb

@@ -0,0 +1 @@
+require 'facets/array/indexable'

data/lib/core/facets/array/from.rb

@@ -0,0 +1,28 @@
+class Array
+
+  # Returns elements from `index` until the end.
+  #
+  #   %w{W o r l d}.from(3)  #=> ["l", "d"]
+  #   %w{W o r l d}.from(9)  #=> []
+  #
+  def from(index)
+    return [] if index >= size
+    self[index..-1]
+  end unless method_defined?(:from)
+
+  # Fetch values from a start index thru an end index.
+  #
+  #   [1,2,3,4,5].thru(2)  #=> [1,2,3]
+  #   [1,2,3,4,5].thru(4)  #=> [1,2,3,4,5]
+  #
+  #   [1,2,3,4,5].thru(0,2)  #=> [1,2,3]
+  #   [1,2,3,4,5].thru(2,4)  #=> [3,4,5]
+  #
+  def thru(from, to=nil)
+    from, to = 0, from unless to
+    return [] if from >= size
+    self[from..to]
+  end unless method_defined?(:thru)
+
+end
+

data/lib/core/facets/array/indexable.rb

@@ -0,0 +1,31 @@
+require 'facets/indexable'
+require 'facets/array/splice'
+
+class Array
+
+  include Indexable
+
+  # Alias for shift, which removes and returns
+  # the first element in an array.
+  #
+  #   a = ["a","y","z"]
+  #   a.first!      #=> "a"
+  #   a             #=> ["y","z"]
+  #
+  # CREDIT: Trans
+
+  alias_method :first!, :shift
+
+  # Alias for pop, which removes and returns
+  # the last element in an array.
+  #
+  #   a = [1,2,3]
+  #   a.last!       #=> 3
+  #   a             #=> [1,2]
+  #
+  # CREDIT: Trans
+
+  alias_method :last!, :pop
+
+end
+

data/lib/core/facets/array/intersection.rb

@@ -0,0 +1,25 @@
+class Array
+
+	# Returns the values in common for an array set (nil, single value/object, or range).
+  #
+  # CREDIT: monocle
+
+	def intersection
+		array = uniq.sort_by { |e| Range === e ? e.first : e }
+		array.inject() do |c, e|
+			f = (Range === c ? c.last  : c)
+			v = (Range === e ? e.first : e)
+			case f <=> v
+			when -1 then return nil
+			when  0 then f
+			else
+				if Range === e
+					v..([f, e.last].min)
+				else
+					v
+				end
+			end
+		end
+	end
+
+end

data/lib/core/facets/array/last.rb

@@ -0,0 +1 @@
+require 'facets/array/indexable'

data/lib/core/facets/array/median.rb

@@ -0,0 +1,32 @@
+class Array
+
+  # Determines the _sorted_ middle element.
+  #
+  #   a = %w{a a b b c c c}
+  #   a.median     #=> "b"
+  #
+  # When there are an even number of elements, the greater
+  # of the two middle elements is given.
+  #
+  #   a = %w{a a b b c c c d}
+  #   a.median     #=> "c"
+  #
+  # An offset can be supplied to get an element relative
+  # to the middle.
+  #
+  #   a = %w{a a b b c c c d}
+  #   a.median(-1) #=> "b"
+  #
+  # The the array is empty, +nil+ is returned.
+  #
+  # @return [Object] sorted middle element
+  def median(offset=0)
+    return nil if self.size == 0
+
+    tmp = self.sort
+    mid = (tmp.size / 2).to_i + offset
+
+    tmp[mid]
+  end
+
+end

data/lib/core/facets/array/merge.rb

@@ -0,0 +1,22 @@
+class Array
+
+  # In place #merge.
+  #
+  #   a = [1,2]
+  #   a.merge! [2,3]
+  #   a #=> [1,2,3]
+  #
+  # CREDIT: Trans
+
+  def merge!( other )
+    self.replace(self.merge(other))
+  end
+
+  # Alias for <tt>|</tt>.
+  #
+  #   [1,2].merge([2,3])  #=> [1,2,3]
+  #
+  alias_method :merge, :|
+
+end
+

data/lib/core/facets/array/missing.rb

@@ -0,0 +1,29 @@
+require 'facets/array/arrange'
+
+class Array
+
+  # Determine the "holes" in the values of an array.
+  #
+  # TODO: Better name?
+  #
+	# Returns the missing elements in an array set.
+  #
+  # CREDIT: monocle
+
+	def missing
+		missing, array = [], arrange
+		i, length = 0, array.size - 1
+		while i < length 
+      x0 = array[i]
+      x1 = array[i+1]
+			c = (Range === x0 ? x0.last  : x0)
+			n = (Range === x1 ? x1.first : x1)
+			missing << (
+        c.succ.succ == n ? c.succ : ((c.succ)..(n.pred))
+      )
+			i += 1
+		end
+    return missing
+	end
+
+end

data/lib/core/facets/array/mode.rb

@@ -0,0 +1,22 @@
+class Array
+
+  # In Statistics. mode is the value that occurs most frequently
+  # in a given set of data. This method returns an array in case
+  # there is a tie.
+  #
+  #   [:a, :b, :c, :b, :d].mode  #=> [:b]
+  #   [:a, :b, :c, :b, :a].mode  #=> [:a, :b]
+  #
+  # Returns an Array of most common elements.
+  #
+  # @author 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/core/facets/array/nonuniq.rb

@@ -0,0 +1,28 @@
+class Array
+
+  # Returns a list of non-unique elements.
+  #
+  # Examples
+  #
+  #   [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
+
+  # Same as `#nonuniq` but acts in place.
+
+  def nonuniq!
+    self.replace(self.nonuniq)
+  end
+
+end
+

data/lib/core/facets/array/not_empty.rb

@@ -0,0 +1,13 @@
+class Array
+
+  # Not empty?
+  #
+  #   [].not_empty?     #=> false
+  #   [1,2].not_empty?  #=> true
+
+  def not_empty?
+    !empty?
+  end
+
+end
+

data/lib/core/facets/array/occur.rb

@@ -0,0 +1,38 @@
+class Array
+
+  # Returns a list of elements that occur +n+ times.
+  #
+  # If +n+ is a Range then returns elements that occur a number
+  # of time within the range.
+  #
+  # Examples
+  #
+  #  [0,1,1,1,3,0,1,2,4].occur(3) #=> [1]
+  #
+  #  [0,1,1,1,3,0,1,2,4].occur(2..4) #=> [0,1]
+  #
+  # Returns [Array] of reoccurring elements.
+  #
+  # CREDIT: Robert Dober
+
+  def occur(n=nil) #:yield:
+    h = Hash.new(0)
+
+    each do |i|
+      h[i] += 1
+    end
+
+    case n
+    when nil
+      h.delete_if{ |_,v| ! yield(v) }.keys
+    when Range
+      h.delete_if{ |_,v| ! n.include?(v) }.keys
+    else
+      h.delete_if{|_,v| v != n}.keys
+    end
+  end
+
+  # Plural alias of #occur.
+  alias :occurs :occur
+
+end

data/lib/core/facets/array/occurrence.rb

@@ -0,0 +1,29 @@
+class Array
+
+  # Create a hash of each uniq element of the array
+  # and how many time each appears.
+  #
+  # Examples
+  #
+  #   [:a,:a,:b,:c,:c,:c].occurrence
+  #   #=> { :a => 2, :b => 1, :c => 3 }
+  #
+  #   [2,2,3,4,4,4].occurrence{|i| i % 2}
+  #   #=> { 0 => 5, 1 => 1 }
+  #
+  def occurrence
+    h = Hash.new(0)
+    if block_given?
+      each do |e|
+        h[yield(e)] += 1
+      end
+    else
+      each do |e|
+        h[e] += 1
+      end
+    end
+    h
+  end
+
+end
+

data/lib/core/facets/array/only.rb

@@ -0,0 +1,37 @@
+class Array
+
+  # Returns the _only_ element in the array.  Raises an IndexError if
+  # the array's size is not 1.
+  #
+  #   [5].only      # => 5
+  #
+  #   expect IndexError do
+  #     [1,2,3].only
+  #   end
+  #
+  #   expect IndexError do
+  #     [].only
+  #   end
+  #
+  # CREDIT: Gavin Sinclair, Noah Gibbs
+
+  def only
+    unless size == 1
+      raise IndexError, "not the only element of array"
+    end
+    first
+  end
+
+  # Does this Array have only one element?
+  # 
+  # TODO: While clearly this goes along with the regular #only method,
+  # the name doesn't seem quite right. Perhaps rename to #lonely.
+  #
+  # CREDIT: Lavir the Whiolet
+  #
+  def only?
+    size == 1
+  end
+ 
+end
+

data/lib/core/facets/array/op_pow.rb

@@ -0,0 +1,12 @@
+class Array
+  # Array#** is an alias for Array#product.
+  #
+  # NOTE: This method is not a common core extension and is not
+  # loaded automatically when using <code>require 'facets'</code>.
+  #
+  # @uncommon
+  #   require 'facets/array/op_pow'
+  #
+  alias_method :**, :product
+end
+

data/lib/core/facets/array/pad.rb

@@ -0,0 +1,41 @@
+class Array
+
+  # Pad an array with a given <tt>value</tt> up to a given <tt>length</tt>.
+  #
+  #   [0,1,2].pad(6,"a")  #=> [0,1,2,"a","a","a"]
+  #
+  # If <tt>length</tt> is a negative number padding will be added
+  # to the beginning of the array.
+  #
+  #   [0,1,2].pad(-6,"a")  #=> ["a","a","a",0,1,2]
+  #
+  # CREDIT: Richard Laugesen
+
+  def pad(len, val=nil)
+    return dup if self.size >= len.abs
+    if len < 0
+      Array.new((len+size).abs,val) + self
+    else
+      self + Array.new(len-size,val)
+    end
+  end
+
+  # Like #pad but changes the array in place.
+  #
+  #    a = [0,1,2]
+  #    a.pad!(6,"x")
+  #    a  #=> [0,1,2,"x","x","x"]
+  #
+  # CREDIT: Richard Laugesen
+
+  def pad!(len, val=nil)
+    return self if self.size >= len.abs
+    if len < 0
+      replace Array.new((len+size).abs,val) + self
+    else
+      concat Array.new(len-size,val)
+    end
+  end
+
+end
+

data/lib/core/facets/array/peek.rb

@@ -0,0 +1 @@
+require 'facets/array/pull'

data/lib/core/facets/array/poke.rb

@@ -0,0 +1 @@
+require 'facets/array/pull'

data/lib/core/facets/array/probability.rb

@@ -0,0 +1,39 @@
+class Array
+
+  # Generates a hash mapping each unique element in the array to the
+  # relative frequency, i.e. the probability, of it appearance.
+  #
+  #   [:a, :b, :c, :c].probability  #=> {:a=> 0.25, :b=>0.25, :c=>0.5}
+  #
+  # 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 Definition ...
+  #
+  #   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/core/facets/array/pull.rb

@@ -0,0 +1,30 @@
+class Array
+
+  # Alias for shift which removes an object off first slot of an array.
+  # This is the opposite of pop.
+  alias_method :pull, :shift
+
+  # Peek at the top of the stack (the end of the array).
+  #
+  #   a = [1, 2, 3]
+  #   a.peek          #=> 3
+  #   a               #=> [1, 2, 3]
+  #
+  # Or provide an index to inspect the array from back to front.
+  def peek(i=0)
+    i = -(i + 1)
+    fetch(i)
+  end
+
+  # Put an object on the bottom of the stack (front of the array).
+  #
+  #   a = [2, 3]
+  #   a.poke(1)
+  #   a               #=> [1, 2, 3]
+  #
+  # Or supply an index and #poke works like #insert.
+  def poke(x, i=0)
+    insert(i,x)
+  end
+
+end

data/lib/core/facets/array/recurse.rb

@@ -0,0 +1,29 @@
+class Array
+
+  # Apply a block to array, and recursively apply that block
+  # to each sub-array or +types+.
+  #
+  #   arr = ["a", ["b", "c", nil], nil]
+  #   arr.recurse{ |a| a.compact! }
+  #   #=> ["a", ["b", "c"]]
+  #
+  def recurse(*types, &block)
+    types = [self.class] if types.empty?
+    a = inject([]) do |array, value|
+      case value
+      when *types
+        array << value.recurse(*types, &block)
+      else
+        array << value
+      end
+      array
+    end
+    yield a
+  end
+
+  # In place form of #recurse.
+  def recurse!(&block)
+    replace(recurse(&block))
+  end
+
+end