nano 0.8.1

data/lib/nano/enumerable.rb

@@ -0,0 +1,32 @@
+require 'nano/enumerable/%25'
+require 'nano/enumerable/%2A%2A'
+require 'nano/enumerable/%3A%3Acombinations'
+require 'nano/enumerable/%3A%3Across'
+require 'nano/enumerable/collect_with_counter'
+require 'nano/enumerable/collect_with_index'
+require 'nano/enumerable/commonality'
+require 'nano/enumerable/compact_collect'
+require 'nano/enumerable/compact_map'
+require 'nano/enumerable/cross'
+require 'nano/enumerable/eF'
+require 'nano/enumerable/each_by'
+require 'nano/enumerable/each_combination'
+require 'nano/enumerable/each_permutation'
+require 'nano/enumerable/each_slice'
+require 'nano/enumerable/each_unique_pair'
+require 'nano/enumerable/entropy'
+require 'nano/enumerable/filter_collect'
+require 'nano/enumerable/filter_map'
+require 'nano/enumerable/find_collisions'
+require 'nano/enumerable/frequency'
+require 'nano/enumerable/graph'
+require 'nano/enumerable/ideal_entropy'
+require 'nano/enumerable/map_with_counter'
+require 'nano/enumerable/map_with_index'
+require 'nano/enumerable/none%3F'
+require 'nano/enumerable/occur'
+require 'nano/enumerable/one%3F'
+require 'nano/enumerable/partition_by'
+require 'nano/enumerable/probability'
+require 'nano/enumerable/to_h'
+require 'nano/enumerable/unique_by'

data/lib/nano/enumerable/%25.rb

@@ -0,0 +1,17 @@
+
+require 'nano/enumerable/eF'
+
+module Enumerable
+
+  # Operator alias for #ea.
+  #
+  #   a = [1,2,3]
+  #   b = [4,5]
+  #
+  #   p a.% + 3       => [4,5,6]
+  #   p a.% + b       => [5,7]
+  #   p a.%.+(b,2)    => [[5,7],[3,4,5]]
+  #
+  alias_method( :%, :eF )
+
+end

data/lib/nano/enumerable/%2A%2A.rb

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

data/lib/nano/enumerable/%3A%3Acombinations.rb

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

data/lib/nano/enumerable/%3A%3Across.rb

@@ -0,0 +1,52 @@
+#--
+# Cross product adapted from code by Michael Neuman.
+#++
+require 'generator'
+
+module Enumerable
+
+  #  Provides the cross-product of two or more Enumerables.
+  #  This is the class-level method. The instance method
+  #  calls on this.
+  #
+  #    Enumerable.cross([1,2], [4], ["apple", "banana"])
+  #    #=> [[1, 4, "apple"], [1, 4, "banana"], [2, 4, "apple"], [2, 4, "banana"]]
+  #
+  #    Enumerable.cross([1,2], [3,4])
+  #    #=> [[1, 3], [1, 4], [2, 3], [2, 4]]
+  #
+  def self.cross(*enums, &block)
+    raise if enums.empty?
+    gens = enums.map{|e| Generator.new(e)}
+    return [] if gens.any? {|g| g.end?}
+    sz = gens.size
+    res = []
+    tuple = Array.new(sz)
+
+    loop do
+      # fill tuple
+      (0 ... sz).each { |i| 
+        tuple[i] = gens[i].current 
+      }
+      if block.nil?
+        res << tuple.dup
+      else
+        block.call(tuple.dup)
+      end
+
+      # step forward
+      gens[-1].next
+      (sz-1).downto(0) { |i|
+        if gens[i].end?
+          if i > 0
+            gens[i].rewind
+            gens[i-1].next
+          else
+            return res
+          end
+        end
+      }
+    end
+  end
+
+end

data/lib/nano/enumerable/collect_with_counter.rb

@@ -0,0 +1,20 @@
+module Enumerable
+  # Same as #collect but with an iteration counter.
+  #
+  #   a = [1,2,3].collect_with_counter{ |e,i| e*i }
+  #   a  #=> [0,2,6]
+  #
+  #--
+  # Why the term counter? There may be a change in Ruby 2.0
+  # to use this word instead of index. Index will
+  # still be used for Array, since that is the proper meaning
+  # in that context. In the mean time, aliases are provided.
+  #++
+  def collect_with_counter
+    r = []
+    each_index do |i|
+      r << yield(self[i], i)
+    end
+    r
+  end
+end

data/lib/nano/enumerable/collect_with_index.rb

@@ -0,0 +1,4 @@
+require 'nano/enumerable/collect_with_counter'
+module Enumerable
+  alias_method( :collect_with_index, :collect_with_counter )
+end #Enumerable

data/lib/nano/enumerable/commonality.rb

@@ -0,0 +1,37 @@
+
+module Enumerable
+
+  # Returns all items that are equal in terms of the supplied block.
+  # If no block is given objects are considered to be equal if they return the
+  # same value for Object#hash and if obj1 == obj2.
+  # No guarantee about the order of the elements in the resulting array is made.
+  #
+  # Note: The result will be an array if you supply no block and a hash otherwise.
+  #
+  #   [1, 2, 2, 3, 4, 4].commonality # => { 2 => [2], 4 => [4] }
+  #
+  #   ["foo", "bar", "a"].commonality { |str| str.length }
+  #   # => { 2 => ["foo, "bar"] }
+  #
+  #   # Returns all persons that share their last name with another person.
+  #   persons.collisions { |person| person.last_name }
+  #
+  #--
+  # Credit goes to Florian Gross
+  #++
+  def commonality( &block )
+    had_no_block = !block
+    block ||= lambda { |item| item }
+    result = Hash.new { |hash, key| hash[key] = Array.new }
+    self.each do |item|
+      key = block.call(item)
+      result[key] << item
+    end
+    result.reject! do |key, values|
+      values.size <= 1
+    end
+    #return had_no_block ? result.values.flatten : result
+    return result
+  end
+
+end

data/lib/nano/enumerable/compact_collect.rb

@@ -0,0 +1,25 @@
+#--
+# Credit goes to Florian Gross.
+#++
+require 'nano/enumerable/filter_collect'
+
+module Enumerable
+
+  # Collects/Maps and compacts items in one single step.
+  # The items for which the supplied block returns +nil+ will not
+  # end up in the resulting array.
+  #
+  #   # Return telephone numbers of all persons that have a telephone number.
+  #   persons.compact_collect { |person| person.telephone_no }
+  #
+  # Also see Enumerable#collect, Enumerable#map, Array#compact.
+  #
+  def compact_collect #:yield:
+    filter_collect do |item|
+      new_item = yield(item)
+      throw(:skip) if new_item.nil?
+      new_item
+    end
+  end
+
+end

data/lib/nano/enumerable/compact_map.rb

@@ -0,0 +1,7 @@
+#--
+# Credit goes to Florian Gross.
+#++
+require 'nano/enumerable/compact_collect'
+module Enumerable
+  alias_method :compact_map, :compact_collect
+end

data/lib/nano/enumerable/cross.rb

@@ -0,0 +1,18 @@
+#--
+# Cross product adapted from code by Michael Neuman.
+#++
+require 'nano/enumerable/%3A%3Across'
+
+module Enumerable
+
+  # The instance level cross-product method.
+  #
+  #   a = []
+  #   [1,2].cross([4,5]){|elem| a << elem }
+  #   a  #=> [[1, 4],[1, 5],[2, 4],[2, 5]]
+  #
+  def cross(*enums, &block)
+    Enumerable.cross(self, *enums, &block)
+  end
+
+end

data/lib/nano/enumerable/eF.rb

@@ -0,0 +1,51 @@
+
+begin
+  require 'mega/functor'
+rescue LoadError
+#--
+  class Functor
+    def initialize(&func) ; @func = func ; end
+    def method_missing(op, *args) ; @func.call(op, *args) ; end
+  end
+#++
+end
+
+
+module Enumerable
+
+  # Returns an elementwise Functor. This makes R-like
+  # elementwise operations possible.
+  #
+  #   a = [1,2,3]
+  #   b = [4,5]
+  #
+  #   p a.eF + 3       => [4,5,6]
+  #   p a.eF + b       => [5,7]
+  #   p a.eF.+(b,2)    => [[5,7],[3,4,5]]
+  #
+  # NOTE: This method is still undergoing some fine tuning.
+  # It is questionable as to whether different sized arrays should
+  # be padded with nil (or a parameter) and whether multiple parameters
+  # are a good idea (eg. <tt>a.%.+(b,2,...)</tt>).
+  #
+  #--
+  # Special thanks to Martin DeMello for helping to develop this.
+  #++
+  def eF
+    #Functor.new(self) do |op,*args|
+    Functor.new do |op,*args|
+      a = args.collect do |arg|
+        if arg.kind_of?(Enumerable)
+          ln = ( arg.length > self.length ? self.length : arg.length )
+          self[0...ln].zip(arg[0...ln]).collect{ |a,b| a.send(op,b) }
+          #self[0...ln].zip(arg[0...1n]).collect{ |a,b| b ? a.send(op,b) : nil }
+        else
+          self.collect{ |a| a.send(op,arg) }
+        end
+      end
+      a.flatten! if args.length == 1
+      a
+    end
+  end
+
+end

data/lib/nano/enumerable/each_by.rb

@@ -0,0 +1,9 @@
+require 'nano/enumerable/each_slice'
+
+module Enumerable
+  alias_method( :each_by, :each_slice )
+end
+
+class Array
+  alias_method( :each_by, :each_slice )
+end

data/lib/nano/enumerable/each_combination.rb

@@ -0,0 +1,34 @@
+
+class Array
+
+  # Yields the block to each unique combination of _n_ elements.
+  #
+  #   a = %w|a b c d|
+  #   a.each_combination(3) do |c|
+  #     p c
+  #   end
+  #
+  # produces
+  #
+  #   ["a", "b", "c"]
+  #   ["a", "b", "d"]
+  #   ["a", "c", "d"]
+  #   ["b", "c", "d"]
+  #
+  def each_combination(k=2)
+    s = self.to_a
+    n = s.size
+    return unless (1..n) === k
+    idx = (0...k).to_a
+    loop do
+      yield s.values_at(*idx)
+      i = k - 1
+      i -= 1 while idx[i] == n - k + i
+      break if i < 0
+      idx[i] += 1
+      (i + 1 ... k).each {|j| idx[j] = idx[i] + j - i}
+    end
+  end
+
+end
+

data/lib/nano/enumerable/each_permutation.rb

@@ -0,0 +1,33 @@
+
+class Array
+
+  # Applys a block to each possible permutation of an array.
+  #
+  #   %w[a b c].each_permutation { |x| puts(x.join('')) }
+  #
+  # produces
+  #
+  #   abc
+  #   acb
+  #   bac
+  #   bca
+  #   cab
+  #   cba
+  #
+  #--
+  # Credit goes to Paul Battley.
+  #++
+  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]).permute(prefixed+[e]) { |a| yield a }
+      end
+    end
+  end
+
+end

data/lib/nano/enumerable/each_slice.rb

@@ -0,0 +1,57 @@
+
+module Enumerable
+
+  # Iterate through slices. If slicing _step_ is not
+  # given, the the arity if the block is used.
+  #
+  #   x = []
+  #   [1,2,3,4].each_slice(2){ |a,b| x << [a,b] }
+  #   x  #=> [ [1,2], [3,4] ]
+  #
+  #   x = []
+  #   [1,2,3,4,5,6].each_slice(3){ |a| x << a }
+  #   x  #=> [ [1,2,3], [4,5,6] ]
+  #
+  def each_slice(step=nil, &yld)
+    if step
+      cnt = step
+      n = length / cnt
+      n += 1 if length % cnt > 0
+      n.times { |i|
+        yld.call(*self.slice(i*cnt,cnt))
+      }
+      return cnt
+    else
+      cnt = yld.arity.abs
+      n = length / cnt
+      n += 1 if length % cnt > 0
+      n.times { |i|
+        yld.call(*self.slice(i*cnt,cnt))
+      }
+      return cnt
+    end
+  end
+
+end
+
+
+class Array
+
+  # Iterates over +n+ elements at a time. If +n+ is
+  # not given then the arity of the block determines the 
+  # slicing quantity.
+  #
+  #   [1, 2, 3, 4].each_slice(2){ |a,b| ... }
+  #
+  # This is a specialized version Enumerable#each_slice
+  # but optimized specifically for Array.
+  def each_slice(n=nil, &yld)
+    n = yld.arity.abs unless n
+    i=0
+    while i < self.length
+      yld.call(*self.slice(i,n))
+      i+=n
+    end
+  end
+
+end