cartesian 0.5.0

data/History.txt

@@ -0,0 +1,42 @@
+=== 0.5.0 2011-01-03
+
+* 1 major enhancements:
+  * Workaround for weird splat behaviour on Ruby <= 1.8.7, so now all tests (100% coverage)
+    now run with 100% pass with the following Ruby versions:
+    * MRI 1.8.6-p399, 1.8.7-p22, 1.8.7-p330, 1.9.1-p378, and 1.9.2-p136
+    * JRuby 1.5.3, 1.5.5, and 1.5.6
+    * Ruby Enterprise Edition 1.8.7-2010.02
+    * rubinius 1.2.0
+
+* 5 minor enhancements:
+  * gem "renamed" (changed from Cartesian to cartesian)
+  * removed unused alias to CartesianIterator#to_a method (#to_ary)
+  * removed own #to_a implementation
+    + #to_a and others are now provided by Enumerable mixin
+  * removed unused Iterable#start alias for #restart (conflicted with Array#start provided by Rubinius)
+  * now build with newgem 1.5.3
+
+=== 0.4.1 04-11-2008 03:18
+
+* 1 major enhancement:
+  * mainly bugfixes and some refactoring. new features: left_product and non-destructive #product methods
+
+=== 0.3.0 29-10-2007 05:49
+
+[undocumented changes]
+
+=== 0.2.3 13-01-2007 20:50
+
+* 1 minor enhancement:
+  * power! (aliased as "**") method added
+
+=== 0.2.1 13-01-2007 01:44
+
+* 1 major enhancement:
+  * Method ".x(enum)" added, which has constant memory requirements, in contrast with the exponential memory usage of the conventional approach.
+
+=== 0.1.0 24-11-2006 05:35
+
+* 1 major enhancement:
+  * first public release
+

data/Manifest.txt

@@ -0,0 +1,25 @@
+History.txt
+Manifest.txt
+PostInstall.txt
+README.rdoc
+Rakefile
+Wishlist.txt
+config/hoe.rb
+config/requirements.rb
+lib/cartesian.rb
+lib/cartesian/grid_search.rb
+lib/cartesian/version.rb
+lib/cartesian_iterator.rb
+lib/grid_search.rb
+lib/recursive.rb
+script/console
+script/destroy
+script/generate
+test/benchmark.rb
+test/extensions.rb
+test/test_cartesian.rb
+test/test_cartesian_iterator.rb
+test/test_extensions.rb
+test/test_grid_search.rb
+test/test_helper.rb
+test/test_suite.rb

data/PostInstall.txt

@@ -0,0 +1,7 @@
+
+For more information on cartesian, see http://cartesian.rubyforge.org
+
+NOTE: Change this information in PostInstall.txt 
+You can also delete it if you don't want it.
+
+

data/README.rdoc

@@ -0,0 +1,81 @@
+= cartesian
+
+* http://github.com/adrianomitre/cartesian
+
+== DESCRIPTION:
+
+Provides methods for the calculation of the cartesian producted between two
+or more enumerable objects. Includes grid search optimization methods.
+It can also be easily and conveniently mixed in into any enumerable class.
+
+== FEATURES:
+
+The module is automatically mixed in Array class, but the names of the methods for mixin are different.
+
+Module:
+  Cartesian::product(foo, bar)
+Mixin:
+  foo.cartesian( bar )
+
+== SYNOPSIS:
+
+One can use the Cartesian module directly
+    require 'cartesian'
+    foo = [1, 2]
+    bar = ["a", "b"]
+    Cartesian::product(foo, bar) #=> [[1, "a"], [1, "b"], [2, "a"], [2, "b"]]
+
+or use the methods provided by the mixin in the Array classees
+    require 'cartesian'
+    foo = [1, 2]
+    bar = ["a", "b"]
+    foo.cartesian(bar)  #=> [[1, "a"], [1, "b"], [2, "a"], [2, "b"]]
+
+which include the short and sweet _x_ method
+    v = [] #=> []
+    for a,b in [1,2].x [3,4]
+      v << [a,b]
+    end #=> true
+    v #=> [[1, 3], [1, 4], [2, 3], [2, 4]]
+
+The '**' operator provides a convenient way of iterating multi-dimensionally over the same array or range
+    v = [0,1]**3 #=> #<CartesianIterator:0x7f2fb8e54978 @tot_iter=8, @lists=[[0, 1], [0, 1], [0, 1]]>
+    v.to_a #=> [[0, 0, 0], [0, 0, 1], [0, 1, 0], [0, 1, 1], [1, 0, 0], [1, 0, 1], [1, 1, 0], [1, 1, 1]]
+
+Finally, the grid search methods
+    require 'grid_search'
+    [-1, 0, 1, 2].argmax {|x| x**2 } #=> 2
+    [-1, 0, 1, 2].argmin {|x| x.abs } #=> 0
+
+== REQUIREMENTS:
+
+* None, besides the Ruby interpreter and standard library. This gems was successfully tested on all relevant Ruby versions: MRI/YARV, JRuby, Rubinius, and REE. For details, see History.txt.
+
+== INSTALL:
+
+* sudo gem install cartesian
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2011 Adriano Mitre <adriano.mitre@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,26 @@
+require 'rubygems'
+gem 'hoe', '>= 2.1.0'
+require 'hoe'
+require 'fileutils'
+require './lib/cartesian'
+
+Hoe.plugin :newgem
+# Hoe.plugin :website
+# Hoe.plugin :cucumberfeatures
+
+# Generate all the Rake tasks
+# Run 'rake -T' to see list of generated tasks (from gem root directory)
+$hoe = Hoe.spec 'cartesian' do
+  self.developer 'Adriano Mitre', 'adriano.mitre@gmail.com'
+  self.post_install_message = 'PostInstall.txt' # TODO remove if post-install message not required
+  self.rubyforge_name       = self.name # TODO this is default value
+  # self.extra_deps         = [['activesupport','>= 2.0.2']]
+
+end
+
+require 'newgem/tasks'
+Dir['tasks/**/*.rake'].each { |t| load t }
+
+# TODO - want other tests/tasks run by default? Add them to the list
+# remove_task :default
+# task :default => [:spec, :features]

data/Wishlist.txt

@@ -0,0 +1 @@
+* Release GridSearch as a separate, independent gem. Note that 'lib/grid_search.rb' is already independent.

data/config/hoe.rb

@@ -0,0 +1,81 @@
+require 'cartesian/version'
+
+AUTHOR = 'Adriano Mitre'  # can also be an array of Authors
+EMAIL = "adriano@mitre.com.br"
+DESCRIPTION = <<EOS
+Provides methods for the calculation of the cartesian producted between two
+or more enumerable objects. Includes grid search optimization methods.
+It can also be easily and conveniently mixed in into any enumerable class.
+EOS
+GEM_NAME = 'cartesian' # what ppl will type to install your gem
+RUBYFORGE_PROJECT = 'cartesian' # The unix name for your project
+HOMEPATH = "http://adrianomitre.github.com/cartesian/website/index.html"
+DOWNLOAD_PATH = "https://github.com/adrianomitre/cartesian/archives/master"
+EXTRA_DEPENDENCIES = [
+#  ['activesupport', '>= 1.3.1']
+]    # An array of rubygem dependencies [name, version]
+
+@config_file = "~/.rubyforge/user-config.yml"
+@config = nil
+RUBYFORGE_USERNAME = "unknown"
+def rubyforge_username
+  unless @config
+    begin
+      @config = YAML.load(File.read(File.expand_path(@config_file)))
+    rescue
+      puts <<-EOS
+ERROR: No rubyforge config file found: #{@config_file}
+Run 'rubyforge setup' to prepare your env for access to Rubyforge
+ - See http://newgem.rubyforge.org/rubyforge.html for more details
+      EOS
+      exit
+    end
+  end
+  RUBYFORGE_USERNAME.replace @config["username"]
+end
+
+
+REV = nil
+# UNCOMMENT IF REQUIRED:
+# REV = YAML.load(`svn info`)['Revision']
+VERS = Cartesian::VERSION::STRING + (REV ? ".#{REV}" : "")
+RDOC_OPTS = ['--quiet', '--title', 'cartesian documentation',
+    "--opname", "index.html",
+    "--line-numbers",
+    "--main", "README",
+    "--inline-source"]
+
+class Hoe
+  def extra_deps
+    @extra_deps.reject! { |x| Array(x).first == 'hoe' }
+    @extra_deps
+  end
+end
+
+# Generate all the Rake tasks
+# Run 'rake -T' to see list of generated tasks (from gem root directory)
+$hoe = Hoe.new(GEM_NAME, VERS) do |p|
+  p.developer(AUTHOR, EMAIL)
+  p.description = DESCRIPTION
+  p.summary = DESCRIPTION
+  p.url = HOMEPATH
+  p.rubyforge_name = RUBYFORGE_PROJECT if RUBYFORGE_PROJECT
+  p.test_globs = ["test/**/test_*.rb", "test/**/tc_*.rb"]
+  p.clean_globs |= ['**/.*.sw?', '*.gem', '.config', '**/.DS_Store']  #An array of file patterns to delete on clean.
+
+  #~ p.files = FileList["{tests,lib}/**/*"].exclude("rdoc").to_a 
+
+
+  # == Optional
+  p.changes = p.paragraphs_of("History.txt", 0..1).join("\n\n")
+  #p.extra_deps = EXTRA_DEPENDENCIES
+
+    #p.spec_extras = {}    # A hash of extra values to set in the gemspec.
+  p.spec_extras = {:files => FileList["{tests,lib}/**/*"].exclude("rdoc").to_a}
+  end
+
+CHANGES = $hoe.paragraphs_of('History.txt', 0..1).join("\\n\\n")
+PATH    = (RUBYFORGE_PROJECT == GEM_NAME) ? RUBYFORGE_PROJECT : "#{RUBYFORGE_PROJECT}/#{GEM_NAME}"
+$hoe.remote_rdoc_dir = File.join(PATH.gsub(/^#{RUBYFORGE_PROJECT}\/?/,''), 'rdoc')
+$hoe.rsync_args = '-av --delete --ignore-errors'
+#~ $hoe.spec.post_install_message = File.open(File.dirname(__FILE__) + "/../PostInstall.txt").read rescue ""

data/config/requirements.rb

@@ -0,0 +1,15 @@
+require 'fileutils'
+include FileUtils
+
+require 'rubygems'
+%w[rake hoe newgem rubigen].each do |req_gem|
+  begin
+    require req_gem
+  rescue LoadError
+    puts "This Rakefile requires the '#{req_gem}' RubyGem."
+    puts "Installation: gem install #{req_gem} -y"
+    exit
+  end
+end
+
+$:.unshift(File.join(File.dirname(__FILE__), %w[.. lib]))

data/lib/cartesian.rb

@@ -0,0 +1,166 @@
+#
+# The CartesianProduct module provide methods for the calculation
+# of the cartesian producted between two enumerable objects.
+#
+# It can also be easily mixed in into any enumerable class,
+# i.e. any class with Enumerable module mixed in.
+# Notice that the names of the methods for mixin are different.
+#
+# Module:
+#   Cartesian::product(foo, bar)
+#
+# Mixin:
+#   foo.cartesian( bar )
+#
+# The module is automatically mixed in Array class.
+#
+# == Author
+# Adriano MITRE <adriano.mitre@gmail.com>
+#
+# == Example
+#
+# as module
+#   require 'cartesian'
+#   foo = [1, 2]
+#   bar = ["a", "b"]
+#   Cartesian::product(foo, bar) #=> [[1, "a"], [1, "b"], [2, "a"], [2, "b"]]
+# as mixin
+#   require 'cartesian'
+#   foo = [1, 2]
+#   bar = ["a", "b"]
+#   foo.cartesian(bar)  #=> [[1, "a"], [1, "b"], [2, "a"], [2, "b"]]
+#
+
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'cartesian_iterator'
+
+module Cartesian
+
+  VERSION = '0.5.0'
+
+  # Produces the cartesian product of self and other.
+  # The result is an array of pairs (i.e. two-element arrays).
+  #
+  #   Cartesian::product( [1,2], %w(A B) ) #=> [[1, "A"], [1, "B"], [2, "A"], [2, "B"]]
+  #
+  # or, if mixed in into Array,
+  #
+  #   [1,2].cartesian %w(A B) #=> [[1, "A"], [1, "B"], [2, "A"], [2, "B"]]
+  #
+  def Cartesian.product(first, second)
+    first.x(second).to_a
+  end
+
+  # Behaves as product, except for the elements are joined.
+  #
+  #   Cartesian::joined_cartesian( [1,2], %w(A B) ) #=> ["1A", "1B", "2A", "2B"]
+  #
+  # or, if mixed in into Array,
+  #
+  #   [1,2].joined_cartesian %w(A B) #=> ["1A", "1B", "2A", "2B"]
+  #
+  def Cartesian.joined_product(first, second)
+    product(first, second).map {|pair| pair.join }
+  end
+
+  # Cartesian.joined_product for mixin.
+  #
+  def joined_cartesian(other)
+    Cartesian.joined_product(self, other)
+  end
+
+  # Convenient way of iterating over the elements.
+  # Preferable when the cartesian product array
+  # is not needed, for the consumption of memory
+  # is fixed and very small, in contrast with the
+  # exponential memory requirements of the
+  # conventional approach.
+  #
+  #   for row, col in (1..10).x(1..30)
+  #     Matrix[row, col] = row**2 + col**3
+  #   end
+  #
+  # Of course, calls can be chained as in
+  #
+  #   for x, y, z in (1..10).x(1..10).x(1..10)
+  #     # ... do something ...
+  #   end
+  #
+  #--
+  #   for letter, number in %w{a b c}.x(1..3)
+  #     ... do something ...
+  #   end
+  #++
+  #
+  # Beware that both +self+ and +other+ must implement
+  # +to_a+, i.e., be convertible to array.
+  #
+  def x(other)
+    case other
+    when CartesianIterator
+      other.left_product(self)
+    else
+      CartesianIterator.new(self, other)
+    end
+  end
+  alias cartesian x
+  alias right_product x
+  
+  def left_product(other)
+    case other
+    when CartesianIterator
+      other.right_product(self)
+    else
+      CartesianIterator.new(other, self)
+    end
+  end
+
+  # Concise way of iterating multi-dimensionally
+  # over the same array or range.
+  #
+  # For instance,
+  #
+  #   for x,y,z in [0,1]**3
+  #     puts [x, y, z].join(',')
+  #   end
+  #
+  # produces the following output
+  #
+  #   0,0,0
+  #   0,0,1
+  #   0,1,0
+  #   0,1,1
+  #   1,0,0
+  #   1,0,1
+  #   1,1,0
+  #   1,1,1
+  #
+  # It also works with Range objects.
+  #
+  def **(fixnum)
+    if fixnum < 0
+      raise ArgumentError, "negative power"
+    elsif fixnum == 0
+      return []
+    elsif fixnum == 1
+      return self
+    else
+      iter = CartesianIterator.new(self, self)
+      (fixnum-2).times do
+        iter.product!(self)
+      end
+      iter
+    end
+  end
+  alias :power! :**
+end
+
+class Array
+  include Cartesian
+end
+
+class Range
+  include Cartesian
+end

data/lib/cartesian/grid_search.rb

@@ -0,0 +1,10 @@
+$:.unshift(File.join(File.dirname(__FILE__), '..'))
+
+require 'cartesian'
+require 'grid_search'
+
+class CartesianIterator
+  include GridSearch
+end
+  
+

data/lib/cartesian/version.rb

@@ -0,0 +1,9 @@
+module Cartesian #:nodoc:
+  module VERSION #:nodoc:
+    MAJOR = 0
+    MINOR = 5
+    TINY  = 0
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end

data/lib/cartesian_iterator.rb

@@ -0,0 +1,99 @@
+class CartesianIterator
+
+  def initialize(foo, bar)
+    @lists = []
+    @tot_iter = 1
+    product!(foo)
+    product!(bar)
+  end
+  
+  def dup
+    Marshal.load(Marshal.dump(self))
+  end
+  
+  def equal(other)
+    self.instance_variables.each do |var_name|
+      return false if self.instance_variable_get(var_name) != other.instance_variable_get(var_name)
+    end
+    true
+  end
+  alias == equal
+
+  def product!(other)
+    @lists << other.to_a.dup
+    @tot_iter *= @lists[-1].size
+    self
+  end
+  alias right_product! product!
+  alias x! product!
+  
+  def left_product!(other)
+    @lists.unshift other.to_a.dup
+    @tot_iter *= @lists[-1].size
+    self
+  end
+  
+  def product(other)
+    (result = self.dup).product!(other)
+    result
+  end
+  alias right_product product
+  alias x product
+
+  def left_product(other)
+    (result = self.dup).left_product!(other)
+    result
+  end
+
+  def each
+    return false if @tot_iter < 1
+
+    elems = []
+    for list in @lists
+      elems << list.restart_and_raw_next
+    end
+    if RUBY_VERSION <= '1.9.1'; yield *elems.map {|x| x }; else; yield *elems; end
+
+    last_list_index = @lists.size-1
+    n = last_list_index
+    loop do
+      if elems[n] = @lists[n].raw_next
+        if RUBY_VERSION <= '1.9.1'; yield *elems.map {|x| x }; else; yield *elems; end
+        n = last_list_index
+        next
+      elsif n > 0
+        elems[n] = @lists[n].restart_and_raw_next
+        n -= 1
+      else
+        return true
+      end
+    end
+  end
+
+  include Enumerable
+
+end
+
+module Iterable
+  def restart
+    @next_index = -1
+    true
+  end
+
+  def next
+    restart unless @next_index
+    raw_next
+  end
+
+  def raw_next
+    self[@next_index += 1]
+  end
+
+  def restart_and_raw_next
+    self[@next_index = 0]
+  end
+end
+
+class Array
+  include Iterable
+end

data/lib/grid_search.rb

@@ -0,0 +1,40 @@
+module GridSearch
+
+  # Finds the argument which maximizes the function given in the block trhu grid-search maximization.
+  #   [-1,0,1,2].argmax {|x| x**2 } #=> 2
+  #
+  def argmax(&block)
+    argbest(:>, &block)
+  end
+  
+  # Finds the argument which minimizes the function given in the block trhu grid-search minimization.
+  #   [-1,0,1,2].argmin {|x| x**2 } #=> 0
+  #
+  def argmin(&block)
+    argbest(:<, &block)
+  end
+
+  private
+  
+  def argbest(cmp)
+    best_arg, best_val = nil, nil
+    self.each do |*curr_arg|
+      curr_val = yield(*curr_arg)
+      if best_val.nil? || curr_val.send(cmp, best_val)
+        best_val = curr_val
+        best_arg = curr_arg
+      end
+    end
+    best_arg
+  end
+
+end
+
+module Enumerable
+  include GridSearch
+end
+
+class Array
+  include GridSearch
+end
+

data/lib/recursive.rb

@@ -0,0 +1,8 @@
+# Code by Brian Schröäer
+# source: http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/151857
+#
+def cartprod(base, *others)
+  return base.map { |a| [a] } if others.empty?
+  others = cartprod(*others)
+  base.inject([]) { | r, a | others.inject(r) { | r, b | r << ([a,*b]) } }
+end

data/script/console

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+# File: script/console
+irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
+
+libs =  " -r irb/completion"
+# Perhaps use a console_lib to store any extra methods I may want available in the cosole
+# libs << " -r #{File.dirname(__FILE__) + '/../lib/console_lib/console_logger.rb'}"
+libs <<  " -r #{File.dirname(__FILE__) + '/../lib/cartesian.rb'}"
+puts "Loading cartesian gem"
+exec "#{irb} #{libs} --simple-prompt"

data/script/destroy

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/destroy'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Destroy.new.run(ARGV)

data/script/generate

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/generate'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Generate.new.run(ARGV)

data/test/benchmark.rb

@@ -0,0 +1,26 @@
+require 'cartesian'
+require 'benchmark'
+
+MULTIPLIER = 3
+letras = ("a"*MULTIPLIER.."z"*MULTIPLIER).to_a
+numeros = (0..10**1).to_a
+
+Benchmark.bmbm do |x|
+  letras_numeros = nil
+  x.report("product") { letras_numeros = Cartesian.product(letras, numeros) }
+  x.report("product 2") { for x,y in letras_numeros; end }
+
+  x.report(".x") { letras_numeros = letras.x(numeros) }
+  x.report(".x 2") { for x,y in letras_numeros; end }
+end
+
+#~ x.report("productZip") { Cartesian.productZip(letras, numeros) }
+
+  #~ def Cartesian.productZip(first, second)
+    #~ result = []
+    #~ first.each do |a|
+      #~ aaa = Array.new(second.size) { a }
+      #~ result += aaa.zip(second)
+    #~ end
+    #~ result
+  #~ end

data/test/extensions.rb

@@ -0,0 +1,12 @@
+class Object
+
+  # Syntax sugar for "is this object among this array?"
+  #
+  #   1.among? [1,2,3] #=> true
+  #   0.among? [4,5] #=> false
+  #
+  def among?(ary)
+    ary.include? self
+  end
+
+end

data/test/test_cartesian.rb

@@ -0,0 +1,67 @@
+require File.join(File.dirname(__FILE__), 'test_helper.rb')
+require 'cartesian'
+
+class TestCartesian < Test::Unit::TestCase
+  
+  def test_arrays
+    foo = [1,2,3]
+    bar = %w{a b c}
+    expected = [[1, "a"], [1, "b"], [1, "c"], [2, "a"], [2, "b"],
+                [2, "c"], [3, "a"], [3, "b"], [3, "c"]]
+    assert(foo.x(bar).to_a == expected)
+    assert(Cartesian.product(foo,bar) == expected)
+  end
+
+  def test_ranges
+    foo = 1..3
+    bar = 4..6
+    expected = [[1, 4], [1, 5], [1, 6], [2, 4], [2, 5],
+                [2, 6], [3, 4], [3, 5], [3, 6]]
+    assert(foo.x(bar).to_a == expected)
+    assert(Cartesian.product(foo,bar) == expected)
+  end
+  
+  def test_product
+    c = [1].x([2])
+    c.x([3])
+    assert_equal [1].x([2]), c
+  end
+  
+  def test_left_product
+    c = [1].right_product([2])
+    d = [1].left_product([2])
+    e = [2].left_product([1])
+    assert_not_equal c, d
+    assert_equal c, e
+    c = [1].x([2]).right_product([3])
+    d = [1].x([2]).left_product([3])
+    e = [2].x([3]).left_product([1])
+    assert_not_equal c, d
+    assert_equal c, e
+  end
+
+  def test_mixed
+    foo = 1..3
+    bar = %w{a b c}
+    expected = [[1, "a"], [1, "b"], [1, "c"], [2, "a"], [2, "b"],
+                [2, "c"], [3, "a"], [3, "b"], [3, "c"]]
+    assert(foo.x(bar).to_a == expected)
+    assert(Cartesian.product(foo,bar) == expected) ##################
+  end
+  
+  def test_power
+    ary = [1,2,3]
+    assert_raise(ArgumentError) { ary**(-1) }
+    assert_equal [], ary**0
+    assert_equal ary, ary**1
+    expected = [[0, 0, 0], [0, 0, 1], [0, 1, 0],\
+                [0, 1, 1], [1, 0, 0], [1, 0, 1],\
+                [1, 1, 0], [1, 1, 1]]
+    assert_equal expected, ([0,1]**3).to_a
+  end
+  
+  def test_joined_cartesian
+    assert_equal ["1A", "1B", "2A", "2B"], [1,2].joined_cartesian(%w<A B>)
+  end
+
+end

data/test/test_cartesian_iterator.rb

@@ -0,0 +1,29 @@
+require File.join(File.dirname(__FILE__), 'test_helper.rb')
+require 'cartesian'
+
+class TestCartesianIterator < Test::Unit::TestCase
+  
+  def test_equal
+    assert_equal [1].x([2]), [1].x([2])
+    assert_not_equal [1].x([2]), [1].x([3])
+  end
+  
+  
+  def test_dup
+    c = [1,2].x([3,4])
+    d = c.dup
+    e = d.x([5,6])
+    assert_not_equal(e, c)
+    assert_equal(c, d)
+  end
+  
+  def test_iterator_next_and_restart
+    foo = [1,2]
+    assert_equal 1, foo.next
+    assert_equal 2, foo.next
+    assert_equal nil, foo.next
+    foo.restart
+    assert_equal 1, foo.next
+  end
+
+end

data/test/test_extensions.rb

@@ -0,0 +1,10 @@
+require File.join(File.dirname(__FILE__), 'test_helper.rb')
+require File.join(File.dirname(__FILE__), 'extensions.rb')
+
+class TestExtensions < Test::Unit::TestCase
+  def test_among?
+    assert 1.among?([1,2,3])
+    assert ! 7.among?([1,2,3])
+    assert (3.0).among?([1,2,3])
+  end
+end

data/test/test_grid_search.rb

@@ -0,0 +1,21 @@
+require File.join(File.dirname(__FILE__), 'test_helper.rb')
+require File.join(File.dirname(__FILE__), 'extensions.rb')
+
+require 'cartesian/grid_search'
+
+class TestCartesian < Test::Unit::TestCase
+  def test_argmin
+    assert_equal 0, *[-1,0,1].argmin {|x| x**2 }
+    assert_equal [0,0], ((-3..3)**2).argmin {|x,y| x**2+y**2 }
+  end
+
+  def test_argmax
+    assert_equal 0, *[-2,-1,0].argmax {|x| x**3 }
+    values = []
+    -3.step(3, 0.25) {|val| values << val }
+    x, y = (values**2).argmax {|x,y| x**2+y**2 }
+    assert x.among?([-3,3])
+    assert y.among?([-3,3])
+  end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,5 @@
+require 'test/unit'
+
+require 'rubygems'
+
+$:.unshift(File.join(File.dirname(__FILE__), '../lib/'))

data/test/test_suite.rb

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+
+Dir.chdir(File.dirname(__FILE__))
+
+class String
+  def same_file?(other)
+    File.expand_path(self) == File.expand_path(other)
+  end
+end
+
+candidates = Dir.glob('test_*.rb')
+to_exclude = [__FILE__, 'test_helper.rb']
+
+test_files = candidates.reject {|f| to_exclude.any? {|ex| f.same_file?(ex) } }
+
+test_files.each do |tf|
+  system "ruby #{tf}"
+end
+

metadata

@@ -0,0 +1,119 @@
+--- !ruby/object:Gem::Specification 
+name: cartesian
+version: !ruby/object:Gem::Version 
+  hash: 11
+  prerelease: false
+  segments: 
+  - 0
+  - 5
+  - 0
+  version: 0.5.0
+platform: ruby
+authors: 
+- Adriano Mitre
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-01-04 00:00:00 -02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 47
+        segments: 
+        - 2
+        - 8
+        - 0
+        version: 2.8.0
+  type: :development
+  version_requirements: *id001
+description: |-
+  Provides methods for the calculation of the cartesian producted between two
+  or more enumerable objects. Includes grid search optimization methods.
+  It can also be easily and conveniently mixed in into any enumerable class.
+email: 
+- adriano.mitre@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- PostInstall.txt
+- Wishlist.txt
+files: 
+- History.txt
+- Manifest.txt
+- PostInstall.txt
+- README.rdoc
+- Rakefile
+- Wishlist.txt
+- config/hoe.rb
+- config/requirements.rb
+- lib/cartesian.rb
+- lib/cartesian/grid_search.rb
+- lib/cartesian/version.rb
+- lib/cartesian_iterator.rb
+- lib/grid_search.rb
+- lib/recursive.rb
+- script/console
+- script/destroy
+- script/generate
+- test/benchmark.rb
+- test/extensions.rb
+- test/test_cartesian.rb
+- test/test_cartesian_iterator.rb
+- test/test_extensions.rb
+- test/test_grid_search.rb
+- test/test_helper.rb
+- test/test_suite.rb
+has_rdoc: true
+homepage: http://github.com/adrianomitre/cartesian
+licenses: []
+
+post_install_message: PostInstall.txt
+rdoc_options: 
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: cartesian
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Provides methods for the calculation of the cartesian producted between two or more enumerable objects
+test_files: 
+- test/test_helper.rb
+- test/test_extensions.rb
+- test/test_suite.rb
+- test/test_cartesian_iterator.rb
+- test/test_cartesian.rb
+- test/test_grid_search.rb