Cartesian 0.1.0 → 0.2.1

data/lib/cartesian.rb

@@ -30,16 +30,18 @@
 #   bar = ["a", "b"]
 #   foo.cartesian(bar)  #=> [[1, "a"], [1, "b"], [2, "a"], [2, "b"]]
 
+require 'cartesian_iterator'
+
 module Cartesian
 
   # Produces the cartesian product of self and other.
   # The result is an array of pairs (i.e. two-element arrays).
   #
-  # cartesian( [1,2], %w(A B) ) #=> [[1, "A"], [1, "B"], [2, "A"], [2, "B"]]
+  #   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"]]
+  #   [1,2].cartesian %w(A B) #=> [[1, "A"], [1, "B"], [2, "A"], [2, "B"]]
   #
   def Cartesian.product(first, second)
     result = []
@@ -59,11 +61,11 @@ module Cartesian
 
   # Behaves as product, except for the elements are joined.
   #
-  # joined_cartesian( [1,2], %w(A B) ) #=> ["1A", "1B", "2A", "2B"]
+  #   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"]
+  #   [1,2].joined_cartesian %w(A B) #=> ["1A", "1B", "2A", "2B"]
   #
   def Cartesian.joined_product(first, second)
     product(first, second).map {|pair| pair.join }
@@ -74,8 +76,42 @@ module Cartesian
   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)
+    CartesianIterator.new(self, other)
+  end
 end
 
 class Array
   include Cartesian
 end
+
+class Range
+  include Cartesian
+end

data/lib/cartesian_iterator.rb

@@ -0,0 +1,70 @@
+class CartesianIterator
+  def initialize(foo, bar)
+    @lists = []
+    @tot_iter = 1
+    x(foo)
+    x(bar)
+  end
+
+  def x(other)
+    @lists << other.to_a
+    @tot_iter *= @lists[-1].size
+    self
+  end
+
+  def each
+    return false if @tot_iter < 1
+
+    elems = []
+    for list in @lists
+      elems << list.restart_and_raw_next
+    end
+    yield *elems
+
+    last_list_index = @lists.size-1
+    n = last_list_index
+    loop do
+      if elems[n] = @lists[n].raw_next
+        yield *elems
+        n = last_list_index
+        next
+      elsif n > 0
+        elems[n] = @lists[n].restart_and_raw_next
+        n -= 1
+      else
+        return true
+      end
+    end
+  end
+
+  def to_a
+    array = []
+    self.each {|*element| array << element }
+    array
+  end
+end
+
+module Iterable
+  def start
+    @next_index = -1
+    true
+  end
+  alias :restart :start
+
+  def next
+    @next_index or restart
+    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/tests/benchmark.rb

@@ -1,4 +1,4 @@
-require '../lib/cartesian'
+require 'cartesian'
 require 'benchmark'
 
 MULTIPLIER = 3
@@ -6,11 +6,15 @@ letras = ("a"*MULTIPLIER.."z"*MULTIPLIER).to_a
 numeros = (0..10**1).to_a
 
 Benchmark.bmbm do |x|
-  x.report("product") { Cartesian.product(letras, numeros) }
-  x.report("productZip") { Cartesian.productZip(letras, numeros) }
-end
+  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 = []
@@ -20,4 +24,3 @@ end
     #~ end
     #~ result
   #~ end
-

data/tests/tc_cartesian.rb

@@ -1,23 +1,30 @@
-require '../lib/cartesian'
-require 'benchmark'
+require 'test/unit'
 
-MULTIPLIER = 3
-letras = ("a"*MULTIPLIER.."z"*MULTIPLIER).to_a
-numeros = (0..10**1).to_a
-
-Benchmark.bmbm do |x|
-  x.report("product") { Cartesian.product(letras, numeros) }
-  x.report("productZip") { Cartesian.productZip(letras, numeros) }
-end
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+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)
+  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)
+  end
 
-  #~ def Cartesian.productZip(first, second)
-    #~ result = []
-    #~ first.each do |a|
-      #~ aaa = Array.new(second.size) { a }
-      #~ result += aaa.zip(second)
-    #~ end
-    #~ result
-  #~ 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)
+  end
+end

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.0
 specification_version: 1
 name: Cartesian
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
-date: 2006-11-24 00:00:00 -03:00
+  version: 0.2.1
+date: 2007-01-07 00:00:00 -03:00
 summary: The Cartesian module provide methods for the calculation of the cartesian producted between two enumberable objects. It can also be easily mixed in into any enumberable class, i.e. any class with Enumerable module mixed in.
 require_paths: 
 - lib
@@ -32,6 +32,7 @@ files:
 - tests/benchmark.rb
 - tests/tc_cartesian.rb
 - lib/cartesian.rb
+- lib/cartesian_iterator.rb
 test_files: 
 - tests/tc_cartesian.rb
 rdoc_options: []