casegen 1.3.0

data/src/agents/sets/enum/cluster.rb

@@ -0,0 +1,164 @@
+#!/usr/bin/env ruby
+
+module Enumerable
+  
+  def each_cluster n = 2
+    tuple = [nil] * n
+    
+    count = n-1
+    each { |x|
+      tuple.shift
+      tuple.push x
+      if count == 0
+        yield tuple
+      else
+        count -= 1
+      end
+    }
+  end
+
+  def each_with_neighbors n = 1, empty = nil
+    nbrs = [empty] * (2 * n + 1)
+    offset = n
+    
+    each { |x|
+      nbrs.shift
+      nbrs.push x
+      if offset == 0  # offset is now the offset of the first element, x0,
+        yield nbrs    #   of the sequence from the center of nbrs, or 0,
+      else            #   if x0 has already passed the center.
+        offset -= 1
+      end
+    }
+    
+    n.times {
+      nbrs.shift
+      nbrs.push empty
+      if offset == 0
+        yield nbrs
+      else
+        offset -= 1
+      end
+    }
+        
+    self
+  end
+
+end
+
+
+=begin
+
+==module Enumerable
+===instance methods
+---Enumerable#each_cluster n = 2
+---Enumerable#each_with_neighbors n = 1, empty = nil
+
+Both methods iterate over a collection of arrays whose elements are drawn
+in sequence from the original collection.
+
+In the case of (({each_cluster})), the iteration yields all contiguous
+subsequences of length ((|n|)). If the argument to (({each_cluster})) is 0
+or larger than the size of the collection, the iteration yields no values.
+
+In the case of (({each_with_neighbors})), the iteration yields one
+sequence for each element ((|x|)) of the collection. The yielded sequence
+includes the ((|n|)) elements before and after ((|x|)). Elements out of
+bounds are filled with ((|empty|)). The first argument can be any
+nonnegative integer.
+
+===examples
+
+  require 'enum/cluster'
+  
+  (0..5).each_with_neighbors { |x| p x }
+
+  # prints: 
+  # [nil, 0, 1]
+  # [0, 1, 2]
+  # [1, 2, 3]
+  # [2, 3, 4]
+  # [3, 4, 5]
+  # [4, 5, nil]
+
+  [1,2,3,4].each_with_neighbors(8, 0) { |x| p x }
+  
+  # prints: 
+  # [0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 0, 0, 0, 0, 0]
+  # [0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 0, 0, 0, 0, 0, 0]
+  # [0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0]
+  # [0, 0, 0, 0, 0, 1, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0]
+
+  ('a'..'g').each_cluster(5) { |x| p x.join '' }
+
+  # prints: 
+  # "abcde"
+  # "bcdef"
+  # "cdefg"
+
+See the end of the source file for more examples.
+
+==version
+
+Enumerable tools 1.6
+
+The current version of this software can be found at 
+((<"http://redshift.sourceforge.net/enum
+"|URL:http://redshift.sourceforge.net/enum>)).
+
+==license
+This software is distributed under the Ruby license.
+See ((<"http://www.ruby-lang.org"|URL:http://www.ruby-lang.org>)).
+
+==author
+Joel VanderWerf,
+((<vjoel@users.sourceforge.net|URL:mailto:vjoel@users.sourceforge.net>))
+
+=end
+
+
+if __FILE__ == $0
+
+  (0..5).each_with_neighbors { |x| p x }
+  
+  puts
+  
+  [1,2,3,4].each_with_neighbors(8, 0) { |x| p x }
+  
+  puts
+  
+  ('a'..'g').each_cluster(5) { |x| p x.join '' }
+  
+  puts
+  
+  begin
+    require 'enum/by'
+    
+    # each_with_neighbors is useful for successive comparisons:
+    2.by {|x| x<10000 && x**2}.each_with_neighbors(1, 1) {
+      |prev_x, x, next_x|
+      printf "%d - %d = %d\n", x, prev_x, x - prev_x
+    }
+    puts
+
+    # Construct a doubly linked list:
+    Node = Struct.new "Node", :value, :prev_node, :next_node
+    
+    list = (1..10).collect { |i| Node.new i }
+    
+    list.each_with_neighbors { |prev_node, node, next_node|
+      node.prev_node = prev_node
+      node.next_node = next_node
+    }
+    
+    list[0].by(:next_node).each { |node| print node.value, " " }
+    puts
+    
+    # We constructed the list and interated over it without ever
+    # explicitly mentioning nil.
+    
+  rescue LoadError
+    puts "File enum/by.rb not available. You're missing the best part!"
+  end
+
+end

data/src/agents/sets/enum/inject.rb

@@ -0,0 +1,50 @@
+#!/usr/bin/env ruby
+
+=begin
+---Enumerable#inject
+---Enumerable#sum [block]
+
+Code adapted from Pickaxe book, p.102.
+See source file for examples.
+
+==version
+
+Enumerable tools 1.6
+
+=end
+
+module Enumerable
+
+  def inject n
+    each { |i|
+      n = yield n, i
+    }
+    n
+  end
+  alias :accumulate :inject
+  
+  def sum
+    if block_given?
+      inject(0) { |n, i| n + yield(i) }
+    else
+      inject(0) { |n, i| n + i }
+    end
+  end
+  
+  def product
+    if block_given?
+      inject(1) { |n, i| n * yield(i) }
+    else
+      inject(1) { |n, i| n * i }
+    end
+  end
+  
+end
+
+if __FILE__ == $0
+
+  x = (0..9).collect { |i| [i, i*i] }
+  p x
+  p x.sum { |v| v[1] }
+
+end

data/src/agents/sets/enum/install.rb

@@ -0,0 +1,73 @@
+#!/usr/bin/env ruby
+
+require 'rbconfig'
+require 'getoptlong'
+require 'ftools'
+
+destdir = Config::CONFIG['sitedir']
+noharm = false
+
+Usage = <<END
+  Usage: ruby install.rb [options]
+  
+      option      argument  action
+      ------      --------  ------
+      --destdir   dir       Destination dir
+      -d                    (default is #{destdir})
+      
+      --help                Print this help
+      -h
+      
+      --noharm              Do not install, just print commands
+      -n
+
+  Installs all .rb files from current dir and below, preserving
+  directory structure, into a subdir of the destination dir. The name
+  of this subdir is formed by stripping the version number off the end
+  of the current dir. The version number is the largest suffix that
+  contains no dashes.
+
+END
+
+opts = GetoptLong.new(
+  [ "--destdir",    "-d",            GetoptLong::REQUIRED_ARGUMENT ],
+  [ "--help",       "-h",            GetoptLong::NO_ARGUMENT       ],
+  [ "--noharm",     "-n",            GetoptLong::NO_ARGUMENT       ]
+)
+
+opts.each do |opt, arg|
+  case opt
+  when '--destdir', '-d'
+    destdir = arg
+  when '--help', '-h'
+    print Usage, "\n"
+    exit
+  when '--noharm', '-n'
+    noharm = true
+  else
+    raise "unrecognized option: ", opt
+  end
+end
+
+raise ArgumentError,
+  "unrecognized arguments #{ARGV.join(' ')}" unless ARGV == []
+
+basedir = (File.split(Dir.getwd))[1].sub(/-[^-]*\z/, "")
+files = Dir.glob("**/*.rb").map { |file| file.sub(/\A\.\//, "") }
+files = files.reject {|file| file == __FILE__ }
+files.map! { |file|
+  [file,
+    File.join(destdir, basedir, file)]
+}
+
+dirs = {}
+for src, dest in files
+  d = File.dirname dest
+  unless dirs[d]
+    puts "File.makedir #{d}"
+    File.makedirs d unless noharm
+    dirs[d] = true
+  end
+  puts "File.install #{src}, #{dest}, 0644, true"
+  File.install(src, dest, 0644, true) unless noharm
+end

data/src/agents/sets/enum/nest.rb

@@ -0,0 +1,117 @@
+#!/usr/bin/env ruby
+
+module Enumerable
+
+  def nest(&compare)
+    ary = to_a
+    s = ary.size
+    i = 0
+    
+    # wrap into Array::Iterator?
+    items_left  = proc { i < s }
+    get_cur     = proc { ary[i] }
+    go_next     = proc { i += 1 }
+    
+    result = nil
+    while items_left[]
+      level_ary = Enumerable.nest items_left, get_cur, go_next, compare
+      result = result ? level_ary.unshift(result) : level_ary
+    end
+    result || []
+  end
+
+  # Handles a single level, recursing when the depth increases and
+  # backing out when the depth decreases.
+  def Enumerable.nest items_left, get_cur, go_next, compare
+    # should handle compare.arity == 2 like a <=> proc
+    result = []; item = depth = nil
+    while items_left[]
+      item = get_cur[]
+      depth = compare[item]
+      base_depth ||= depth
+        
+      if depth < base_depth
+        break
+      elsif depth > base_depth
+        result << nest(items_left, get_cur, go_next, compare)
+      else
+        result << item; go_next[]
+      end
+    end
+    return result
+  end
+  
+  def group(&test)
+    nest { |x| test[x] ? 1 : 0 }
+  end
+end
+
+=begin
+
+=module Enumerable
+==instance methods
+---Enumerable#nest &compare
+
+(({nest})) is an inverse for (({Array#flatten})). (Well, actually only a right
+inverse since (({flatten})) is not injective.) You give it a proc that
+calculates the depth of each item, and it returns a nesting of arrays in which
+each item has the desired depth. It can be used to parse strings with
+Python-like indentation syntax, but it isn't limited to strings.
+
+The main improvement in this version is that the compare block can return
+a lower value for an element after the first, with the expected effect. See the first example at the end of the source file.
+
+===version
+
+Enumerable tools 1.6
+
+The current version of this software can be found at 
+((<"http://redshift.sourceforge.net/enum
+"|URL:http://redshift.sourceforge.net/enum>)).
+
+===license
+This software is distributed under the Ruby license.
+See ((<"http://www.ruby-lang.org"|URL:http://www.ruby-lang.org>)).
+
+===author
+Joel VanderWerf,
+((<vjoel@users.sourceforge.net|URL:mailto:vjoel@users.sourceforge.net>))
+
+=end
+
+if __FILE__ == $0
+
+str = <<END
+  a
+   aa
+   ab
+    aba
+    abb
+     abba
+      abbaa
+     abbb
+   ac
+   ad
+    ada
+     adaa
+    adb
+  b
+   ba
+   bb
+  c
+   ca
+X
+ Y
+  Z
+END
+
+lines = str.split "\n"
+nested = lines.nest { |line| /\S/ =~ line }
+p nested
+flat = nested.flatten
+p flat
+p flat == lines
+
+p [1, 2, "three", "four", 5, "six"].group { |x| x.is_a? String }
+
+end

data/src/agents/sets/enum/op.rb

@@ -0,0 +1,283 @@
+#!/usr/bin/env ruby
+
+require 'enum/inject'
+
+module EnumerableOperator
+
+  class Product
+    include Enumerable
+
+    attr_reader :factors, :dim
+
+    def initialize(*factors)
+      @factors = factors
+      @dim = @factors.length
+    end
+
+    def each tuple = [nil]*@dim, i = 0, &block
+      if i == @dim - 1 then
+        @factors[i].each { |x| tuple[i] = x; yield tuple.dup }
+      elsif i > 0
+        @factors[i].each { |x| tuple[i] = x; each tuple, i + 1, &block }
+      else
+        @factors[i].each { |x| tuple[i] = x; each tuple, i + 1, &block }
+        self
+      end
+    end
+
+    def size
+      @factors.product { |enum| enum.size }
+    end
+
+  end
+
+  class Sum
+    include Enumerable
+
+    attr_reader :summands
+
+    def initialize(*summands)
+      @summands = summands
+    end
+
+    def each(&block)
+      @summands.each { |enum| enum.each(&block) }
+      self
+    end
+    
+    def size
+      @summands.sum { |enum| enum.size }
+    end
+
+  end
+
+  class Diagonal
+    include Enumerable
+  
+    attr_reader :factors, :dim
+
+    def initialize(*factors)
+      @factors = factors
+      @dim = @factors.length
+    end
+    
+    def each
+      factors = @factors.map { |factor|
+        if factor.kind_of? Array then factor else factor.entries end
+      }
+      minlength = factors.min { |f, g| f.length <=> g.length }.length
+      for i in 0..(minlength-1)
+        yield factors.map { |factor| factor[i] }
+      end
+      self
+    end
+  end
+
+
+  def product(*factors, &block)
+    if block
+      Product.new(*factors).each(&block)
+    else
+      Product.new(*factors)
+    end
+  end
+  alias :tuples :product
+
+  def sum(*summands, &block)
+    if block
+      Sum.new(*summands).each(&block)
+    else
+      Sum.new(*summands)
+    end
+  end
+  alias :concatenation :sum
+  alias :cat :sum
+
+  def diagonal(*factors, &block)
+    if block
+      Diagonal.new(*factors).each(&block)
+    else
+      Diagonal.new(*factors)
+    end
+  end
+
+  module_function :product, :sum, :diagonal
+end
+
+=begin
+
+==module EnumerableOperator
+===instance methods and module methods
+---EnumerableOperator#product *factors, &block
+---EnumerableOperator#sum *summands, &block
+
+The (({product})) operator iterates over the Cartesian product of the factors,
+each of which must be (({Enumerable})).
+
+The (({sum})) operator iterates over the concatenation of the summands, each of
+which must be (({Enumerable})).
+
+Both operators have aliases: (({tuples})) for (({product}));
+(({concatenation})) and (({cat})) for (({sum})).
+
+Called with a block, the operators yield one element of the sequence at a time
+to the block.
+
+With or without a block, the operators return an (({Enumerable})) which
+delegates to the original (({Enumerables})), but does not explicitly construct
+the entire collection. Calling another (({Enumerable})) method, such as
+(({select})) or (({collect})), on this return value is an efficient way of
+chaining these operators with other methods. Simply call (({entries})) to get
+the whole collection. Also, because the operators return an (({Enumerable})),
+they can be used with the (({for})) syntax; see the examples.
+
+---EnumerableOperator#diagonal *factors, &block
+
+The (({diagonal})) operator iterates over the diagonal of the Cartesian product
+of the factors, each of which must be (({Enumerable})). In other words, the
+n-th entry of the diagonal is an array of the n-th entries of each factor. The
+resulting sequence terminates when any one factor terminates. Hence the
+sequence has the same length as the shortest factor.
+
+Called with a block, (({diagonal})) yields one element of the sequence at a
+time to the block.
+
+With or without a block, (({diagonal})) returns an (({Enumerable})) object
+which is ((*independent*)) of the original (({Enumerables})). As with
+(({product})) and (({sum})), this allows chaining with other iterators and
+using the (({for})) syntax. Unlike (({product})) and (({sum})), however, the
+entire collection is generated and stored in the object returned by
+(({diagonal})).
+
+Internally, (({diagonal})) does not enumerate the sequences in parallel, but in
+the order in which they are given. If the sequences have side-effects of
+enumeration, this may result in different behavior than if the sequences were
+truly enumerated in parallel (e.g., see matz's approach using threads in the
+Ruby FAQ:  ((<"http://www.rubycentral.com/faq/rubyfaq-5.html#ss5.5
+"|URL:http://www.rubycentral.com/faq/rubyfaq-5.html#ss5.5>))).
+
+===usage
+
+  include EnumerableOperator
+  diagonal enum0, enum1, ...
+or
+  EnumerableOperator.diagonal enum0, enum1, ...
+and similarly for product and sum.
+
+===examples
+
+  require 'enum/op'
+  include EnumerableOperator
+  
+  # using the 'for ... in ... end' construct:
+  for i, j in product 1..4, "bar".."baz"
+    printf "%6s", i.to_s + j; puts if j == "baz"
+  end
+  puts
+  
+  # prints:
+  #  1bar  1bas  1bat  1bau  1bav  1baw  1bax  1bay  1baz
+  #  2bar  2bas  2bat  2bau  2bav  2baw  2bax  2bay  2baz
+  #  3bar  3bas  3bat  3bau  3bav  3baw  3bax  3bay  3baz
+  
+  # directly passing a block:
+  sum 1..5, 'a'..'c', 90..92 do |i|
+    printf "%4s", i.to_s
+  end
+  puts "\n\n"
+  
+  # prints:
+  #   1   2   3   4   5   a   b   c  90  91  92
+
+  for i, j, k in diagonal 1..4, 'a'..'d', ?a..?d
+    printf "%4d. %s is 0x%x\n", i, j, k
+  end
+  puts
+
+  # prints:
+  #   1. a is 0x61
+  #   2. b is 0x62
+  #   3. c is 0x63
+  #   4. d is 0x64
+
+  # chaining with other iterators:
+  names = %w{ Ludwig Rudolf Bertrand Willard }
+  more_names = %w{ Jean-Paul Albert Martin Soren }
+  puts sum(names, more_names).sort.join ', '
+  puts
+
+  # prints:
+  #   Albert, Bertrand, Jean-Paul, Ludwig, Martin, Rudolf, Soren, Willard
+  
+  # note that chaining avoids constructing the intermediate collection:
+  big_product = product 1..10, 1..10, 1..10
+  big_product.select { |x, y, z|
+    x <= y and x**2 + y**2 == z**2
+  }.each { |x, y, z|
+    printf "#{x}**2 + #{y}**2 == #{z}**2\n"
+  }
+  
+  # prints:
+  #   3**2 + 4**2 == 5**2
+  #   6**2 + 8**2 == 10**2
+  
+==version
+
+Enumerable tools 1.6
+
+The current version of this software can be found at 
+((<"http://redshift.sourceforge.net/enum
+"|URL:http://redshift.sourceforge.net/enum>)).
+
+==license
+This software is distributed under the Ruby license.
+See ((<"http://www.ruby-lang.org"|URL:http://www.ruby-lang.org>)).
+
+==author
+Joel VanderWerf,
+((<vjoel@users.sourceforge.net|URL:mailto:vjoel@users.sourceforge.net>))
+
+=end
+
+
+if __FILE__ == $0
+
+  include EnumerableOperator
+
+  # using the 'for ... in ... end' construct:
+  for i, j in product 1..4, "bar".."baz"
+    printf "%6s", i.to_s + j; puts if j == "baz"
+  end
+  puts
+  
+  # directly passing a block:
+  sum 1..5, 'a'..'c', 90..92 do |i|
+    printf "%4s", i.to_s
+  end
+  puts "\n\n"
+  
+  for i, j, k in diagonal 1..4, 'a'..'d', ?a..?d
+    printf "%4d. %s is 0x%x\n", i, j, k
+  end
+  puts
+  
+  # chaining with other iterators:
+  names = %w{ Ludwig Rudolf Bertrand Willard }
+  more_names = %w{ Jean-Paul Albert Martin Soren }
+  puts sum(names, more_names).sort.join(', ')
+  puts
+  
+  # note that chaining avoids constructing the intermediate collection:
+  big_product = product 1..10, 1..10, 1..10
+  big_product.select { |x, y, z|
+    x <= y and x**2 + y**2 == z**2
+  }.each { |x, y, z|
+    printf "#{x}**2 + #{y}**2 == #{z}**2\n"
+  }
+  puts
+  
+  # size
+  puts "sum(1..10,11..20).size     = #{sum(1..10,11..20).size}"
+  puts "product(1..10,11..20).size = #{product(1..10,11..20).size}"
+  puts "product([1,2,3],[]).size   = #{product([1,2,3],[]).size}"
+end