multiarray 0.5.0 → 0.5.1

data/test/tc_int.rb

@@ -31,12 +31,16 @@ class TC_Int < Test::Unit::TestCase
   U32 = Hornetseye::UINT
   S32 = Hornetseye::INT
 
+  def I( *args )
+    Hornetseye::INT *args
+  end
+
   def UI( bits )
-    Hornetseye::INT Hornetseye::UNSIGNED, bits
+    I Hornetseye::UNSIGNED, bits
   end
 
   def SI( bits )
-    Hornetseye::INT Hornetseye::SIGNED, bits
+    I Hornetseye::SIGNED, bits
   end
 
   def sum( *args, &action )
@@ -71,6 +75,12 @@ class TC_Int < Test::Unit::TestCase
     assert_equal 0, I.new[]
   end
 
+  def test_int_indgen
+    assert_equal 0, I.indgen
+    assert_equal 1, I.indgen( 1 )
+    assert_equal 1, I.indgen( 1, 2 )
+  end
+
   def test_int_typecode
     assert_equal I, I.typecode
   end
@@ -78,17 +88,21 @@ class TC_Int < Test::Unit::TestCase
   def test_int_dimension
     assert_equal 0, I.dimension
   end
-
+!
   def test_int_shape
     assert_equal [], I.shape
   end
 
+  def test_int_size
+    assert_equal 1, I.size
+  end
+
   def test_inspect
-    assert_equal 'INT(42)', I.new( 42 ).inspect
+    assert_equal 'INT(42)', I( 42 ).inspect
   end
 
   def test_marshal
-    assert_equal I.new( 42 ), Marshal.load( Marshal.dump( I.new( 42 ) ) )
+    assert_equal I( 42 ), Marshal.load( Marshal.dump( I( 42 ) ) )
   end
 
   def test_typecode
@@ -103,26 +117,30 @@ class TC_Int < Test::Unit::TestCase
     assert_equal [], I.new.shape
   end
 
+  def test_size
+    assert_equal 1, I.new.size
+  end
+
   def test_at_assign
-    i = I.new 42
+    i = I 42
     assert_equal 42, i[]
     assert_equal 3, i[] = 3
     assert_equal 3, i[]
   end
 
   def test_equal
-    assert_not_equal I.new( 3 ), I.new( 4 )
-    assert_equal I.new( 3 ), I.new( 3 )
+    assert_not_equal I( 3 ), I( 4 )
+    assert_equal I( 3 ), I( 3 )
   end
 
   def test_inject
-    assert_equal 2, I.new( 2 ).inject { |a,b| a + b }[]
-    assert_equal 3, I.new( 2 ).inject( 1 ) { |a,b| a + b }[]
+    assert_equal 2, I( 2 ).inject { |a,b| a + b }[]
+    assert_equal 3, I( 2 ).inject( 1 ) { |a,b| a + b }[]
   end
 
   def test_not
-    assert !I.new( 0 ).not[]
-    assert !I.new( 3 ).not[]
+    assert !I( 0 ).not[]
+    assert !I( 3 ).not[]
   end
 
   def test_sum
@@ -130,45 +148,55 @@ class TC_Int < Test::Unit::TestCase
   end
 
   def test_zero
-    assert I.new( 0 ).zero?[]
-    assert !I.new( 3 ).zero?[]
+    assert I( 0 ).zero?[]
+    assert !I( 3 ).zero?[]
   end
 
   def test_nonzero
-    assert !I.new( 0 ).nonzero?[]
-    assert I.new( 3 ).nonzero?[]
+    assert !I( 0 ).nonzero?[]
+    assert I( 3 ).nonzero?[]
   end
 
   def test_bitwise_not
-    assert_equal I.new( -3 ), ~I.new( 2 )
+    assert_equal I( -3 ), ~I( 2 )
   end
 
   def test_bitwise_and
-    assert_equal I.new( 2 ), I.new( 3 ) & I.new( 6 )
+    assert_equal I( 2 ), I( 3 ) & I( 6 )
   end
 
   def test_bitwise_or
-    assert_equal I.new( 7 ), I.new( 3 ) | I.new( 6 )
+    assert_equal I( 7 ), I( 3 ) | I( 6 )
   end
 
   def test_bitwise_xor
-    assert_equal I.new( 1 ), I.new( 3 ) ^ I.new( 2 )
+    assert_equal I( 1 ), I( 3 ) ^ I( 2 )
   end
 
   def test_shl
-    assert_equal I.new( 4 ), I.new( 2 ) << I.new( 1 )
+    assert_equal I( 4 ), I( 2 ) << I( 1 )
   end
 
   def test_shr
-    assert_equal I.new( 2 ), I.new( 4 ) >> I.new( 1 )
+    assert_equal I( 2 ), I( 4 ) >> I( 1 )
   end
 
   def test_negate
-    assert_equal I.new( -5 ), -I.new( 5 )
+    assert_equal I( -5 ), -I( 5 )
   end
 
   def test_plus
-    assert_equal I.new( 3 + 5 ), I.new( 3 ) + I.new( 5 )
+    assert_equal I( 3 + 5 ), I( 3 ) + I( 5 )
+  end
+
+  def test_major
+    assert_equal I( 4 ), I( 3 ).major( I( 4 ) )
+    assert_equal I( 5 ), I( 5 ).major( I( 3 ) )
+  end
+
+  def test_minor
+    assert_equal I( 3 ), I( 3 ).minor( I( 4 ) )
+    assert_equal I( 4 ), I( 5 ).minor( I( 4 ) )
   end
 
 end

data/test/tc_lazy.rb

@@ -0,0 +1,109 @@
+# multiarray - Lazy multi-dimensional arrays for Ruby
+# Copyright (C) 2010 Jan Wedekind
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+require 'test/unit'
+begin
+  require 'rubygems'
+rescue LoadError
+end
+Kernel::require 'multiarray'
+
+class TC_Lazy < Test::Unit::TestCase
+
+  O = Hornetseye::OBJECT
+  B = Hornetseye::BOOL
+  I = Hornetseye::INT
+  S = Hornetseye::Sequence
+  M = Hornetseye::MultiArray
+
+  def S( *args )
+    Hornetseye::Sequence *args
+  end
+
+  def M( *args )
+    Hornetseye::MultiArray *args
+  end
+
+  def lazy( *args, &action )
+    Hornetseye::lazy *args, &action
+  end
+
+  def sum( *args, &action )
+    Hornetseye::sum *args, &action
+  end
+
+  def setup
+    @s = S[ -1, 2, 3, 5, 7 ]
+    @m = M[ [ -1, 2, 3 ], [ 4, 5, 6 ] ]
+    @w = 2 * 10 ** 6
+    @h = 10 ** 6
+  end
+
+  def teardown
+  end
+
+  def test_const
+    assert_equal 0, lazy { 0 }
+    assert_equal [ 0, 0, 0 ], lazy( 3 ) { 0 }.to_a
+    assert_equal [ 0, 0, 0 ], lazy( 3 ) { |i| 0 }.to_a
+  end
+
+  def test_index
+    assert_equal [ 0, 1, 2 ], lazy( 3 ) { |i| i }.to_a
+    assert_equal [ [ 0, 1, 2 ], [ 0, 1, 2 ] ], lazy( 3, 2 ) { |i,j| i }.to_a
+    assert_equal [ [ 0, 0, 0 ], [ 1, 1, 1 ] ], lazy( 3, 2 ) { |i,j| j }.to_a
+  end
+
+  def test_minus_at
+    assert_equal -2, lazy { ( -@s )[ 1 ] } 
+  end
+
+  def test_minus_slice
+    assert_equal [ -2, -3, -5 ], lazy { ( -@s )[ 1 .. 3 ] }.to_a
+  end
+
+  def test_add_at
+    assert_equal 4, lazy { ( @s + @s )[ 1 ] }
+  end
+
+  def test_add_slice
+    assert_equal [ 6, 10, 14 ], lazy { ( @s + @s )[ 2 .. 4 ] }.to_a
+  end
+
+  def test_index_at
+    assert_equal 3, lazy { lazy( @h ) { |i| i }[ 3 ] }
+    assert_equal 5, lazy { lazy( @w, @h ) { |i,j| 2 * i + j }[ 2, 1 ] }
+  end
+
+  def test_index_slice
+    assert_equal [ 3, 4, 5 ], lazy { lazy( @h ) { |i| i }[ 3 .. 5 ] }.to_a
+    assert_equal [ [ 5, 7, 9 ], [ 6, 8, 10 ] ],
+      lazy { lazy( @w, @h ) { |i,j| 2 * i + j }[ 2 .. 4, 1 .. 2 ] }.to_a
+  end
+
+  def test_index_inject
+    assert_equal 10, lazy( 5 ) { |i| i }.inject { |a,b| a + b }
+    assert_equal [ 0, 3, 6, 9 ], sum { |k| lazy( 4, 3 ) { |i,j| i }[ k ] }.to_a
+    assert_equal [ 3, 3, 3, 3 ], sum { |k| lazy( 4, 3 ) { |i,j| j }[ k ] }.to_a
+  end
+
+  def test_indgen_diagonal
+    assert_equal [ 15, 18, 17 ],
+                 M( I, 4, 3 ).indgen.diagonal { |a,b| a + b }.to_a
+  end
+
+end
+

data/test/tc_multiarray.rb

@@ -26,9 +26,14 @@ class TC_MultiArray < Test::Unit::TestCase
   O = Hornetseye::OBJECT
   B = Hornetseye::BOOL
   I = Hornetseye::INT
+  C = Hornetseye::INTRGB
   S = Hornetseye::Sequence
   M = Hornetseye::MultiArray
 
+  def C( *args )
+    Hornetseye::RGB *args
+  end
+
   def S( *args )
     Hornetseye::Sequence *args
   end
@@ -60,19 +65,39 @@ class TC_MultiArray < Test::Unit::TestCase
   end
 
   def test_multiarray_default
-    assert_equal [ [ O.default ] * 3 ] * 2, M( O, 3, 2 ).default.to_a
+    assert_equal [ [ nil ] * 3 ] * 2, M( O, 3, 2 ).default.to_a
+    assert_equal [ [ 0 ] * 3 ] * 2, M( I, 3, 2 ).default.to_a
+    assert_equal [ [ C( 0, 0, 0 ) ] * 3 ] * 2, M( C, 3, 2 ).default.to_a
   end
 
   def test_multiarray_at
     assert_equal [ [ 1, 2, 3 ], [ 4, 5, 6 ] ],
                  M[ [ 1, 2, 3 ], [ 4, 5, 6 ] ].to_a
+    assert_equal [ [ 1, 2, 3 ], [ 4, 5, 6 ] ],
+                 M( O, 3, 2 )[ [ 1, 2, 3 ], [ 4, 5, 6 ] ].to_a
     assert_equal O, M[ [ :a ] ].typecode
     assert_equal B, M[ [ false ], [ true ] ].typecode
     assert_equal I, M[ [ -2 ** 31, 2 ** 31 - 1 ] ].typecode
   end
 
+  def test_multiarray_indgen
+    assert_equal [ [ 0, 1, 2 ], [ 3, 4, 5 ] ],
+                 M( I, 3, 2 ).indgen.to_a
+    assert_equal [ [ 1, 2, 3 ], [ 4, 5, 6 ] ],
+                 M( I, 3, 2 ).indgen( 1 ).to_a
+    assert_equal [ [ 0, 2, 4 ], [ 6, 8, 10 ] ],
+                 M( I, 3, 2 ).indgen( 0, 2 ).to_a
+    assert_equal [ [ 1, 3, 5 ], [ 7, 9, 11 ] ],
+                 M( I, 3, 2 ).indgen( 1, 2 ).to_a
+    assert_equal [ [ C( 1, 2, 3 ), C( 2, 2, 2 ) ],
+                   [ C( 3, 2, 1 ), C( 4, 2, 0 ) ] ],
+                 M( C, 2, 2 ).indgen( C( 1, 2, 3 ), C( 1, 0, -1 ) ).to_a
+  end
+
   def test_multiarray_typecode
     assert_equal O, M( O, 3, 2 ).typecode
+    assert_equal I, M( I, 3, 2 ).typecode
+    assert_equal C, M( C, 3, 2 ).typecode
   end
 
   def test_multiarray_dimension
@@ -83,23 +108,50 @@ class TC_MultiArray < Test::Unit::TestCase
     assert_equal [ 3, 2 ], M( O, 3, 2 ).shape
   end
 
+  def test_multiarray_size
+    assert_equal 6, M( O, 3, 2 ).size
+    assert_equal 6, M( I, 3, 2 ).size
+    assert_equal 6, M( C, 3, 2 ).size
+  end
+
   def test_inspect
     assert_equal "MultiArray(OBJECT,3,2):\n[ [ :a, 2, 3 ],\n  [ 4, 5, 6 ] ]",
                  M[ [ :a, 2, 3 ], [ 4, 5, 6 ] ].inspect
+    assert_equal "MultiArray(UBYTE,4,3,2):\n" +
+                 "[ [ [ 0, 1, 2, 3 ],\n" +
+                 "    [ 4, 5, 6, 7 ],\n" +
+                 "    [ 8, 9, 10, 11 ] ],\n" +
+                 "  [ [ 12, 13, 14, 15 ],\n" +
+                 "    [ 16, 17, 18, 19 ],\n" +
+                 "    [ 20, 21, 22, 23 ] ] ]",
+                 M[ [ [ 0, 1, 2, 3 ],
+                      [ 4, 5, 6, 7 ],
+                      [ 8, 9, 10, 11 ] ],
+                    [ [ 12, 13, 14, 15 ],
+                      [ 16, 17, 18, 19 ],
+                      [ 20, 21, 22, 23 ] ] ].inspect
   end
 
   def test_typecode
     assert_equal O, M( O, 3, 2 ).new.typecode
+    assert_equal I, M( I, 3, 2 ).new.typecode
+    assert_equal C, M( C, 3, 2 ).new.typecode
   end
 
   def test_dimension
     assert_equal 2, M( O, 3, 2 ).new.dimension
+    assert_equal 2, M( I, 3, 2 ).new.dimension
+    assert_equal 2, M( C, 3, 2 ).new.dimension
   end
 
   def test_shape
     assert_equal [ 3, 2 ], M( O, 3, 2 ).new.shape
   end
 
+  def test_size
+    assert_equal 6, M( O, 3, 2 ).new.size
+  end
+
   def test_at_assign
     m = M.new O, 3, 2
     for j in 0 ... 2
@@ -116,6 +168,48 @@ class TC_MultiArray < Test::Unit::TestCase
     end
   end
 
+  def test_slice
+    m = M( I, 5, 4 ).indgen[]
+    assert_equal [ [ 5, 10 ], [ 6, 11 ], [ 7, 12 ], [ 8, 13 ], [ 9, 14 ] ],
+                 m[ 1 .. 2 ].to_a
+    assert_equal [ [ 6, 7, 8 ], [ 11, 12, 13 ] ],
+                 m[ 1 .. 2 ][ 1 .. 3 ].to_a
+    assert_equal [ [ 6, 7, 8 ], [ 11, 12, 13 ] ],
+                 m[ 1 .. 3, 1 .. 2 ].to_a
+    m[ 1 .. 2 ] = 0
+    assert_equal [ [ 0, 1, 2, 3, 4 ], [ 0, 0, 0, 0, 0 ],
+                   [ 0, 0, 0, 0, 0 ], [ 15, 16, 17, 18, 19 ] ], m.to_a
+    m[ 1 ... 3 ] = 1
+    assert_equal [ [ 0, 1, 2, 3, 4 ], [ 1, 1, 1, 1, 1 ],
+                   [ 1, 1, 1, 1, 1 ], [ 15, 16, 17, 18, 19 ] ], m.to_a
+    m[ 1 .. 2 ] = S[ 2, 3, 4, 5, 6 ]
+    assert_equal [ [ 0, 1, 2, 3, 4 ], [ 2, 3, 4, 5, 6 ],
+                   [ 2, 3, 4, 5, 6 ], [ 15, 16, 17, 18, 19 ] ], m.to_a
+    m[ 1 ... 3 ] = S[ 3, 4, 5, 6, 7 ]
+    assert_equal [ [ 0, 1, 2, 3, 4 ], [ 3, 4, 5, 6, 7 ],
+                   [ 3, 4, 5, 6, 7 ], [ 15, 16, 17, 18, 19 ] ], m.to_a
+    m[ 1 .. 3, 1 .. 2 ] = 0
+    assert_equal [ [ 0, 1, 2, 3, 4 ], [ 3, 0, 0, 0, 7 ],
+                   [ 3, 0, 0, 0, 7 ], [ 15, 16, 17, 18, 19 ] ], m.to_a
+    m[ 1 ... 4, 1 ... 3 ] = 1
+    assert_equal [ [ 0, 1, 2, 3, 4 ], [ 3, 1, 1, 1, 7 ],
+                   [ 3, 1, 1, 1, 7 ], [ 15, 16, 17, 18, 19 ] ], m.to_a
+  end
+
+  def test_transpose
+    assert_equal [ [ 1, 4 ], [ 2, 5 ], [ 3, 6 ] ],
+                 M[ [ 1, 2, 3 ], [ 4, 5, 6 ] ].transpose( 1, 0 ).to_a
+    assert_equal [ [ [ 0, 3 ], [ 1, 4 ], [ 2, 5 ] ] ],
+                 M( I, 3, 2, 1 ).indgen.transpose( 1, 0, 2 ).to_a
+  end
+
+  def test_roll_unroll
+    assert_equal [ [ [ 0 ], [ 1 ], [ 2 ] ], [ [ 3 ], [ 4 ], [ 5 ] ] ],
+                 M( I, 3, 2, 1 ).indgen.unroll.to_a
+    assert_equal [ [ [ 0, 3 ] ], [ [ 1, 4 ] ], [ [ 2, 5 ] ] ],
+                 M( I, 3, 2, 1 ).indgen.roll.to_a
+  end
+
   def test_equal
     assert_equal M[ [ 1, 2, 3 ], [ 4, 5, 6 ] ], M[ [ 1, 2, 3 ], [ 4, 5, 6 ] ]
     assert_not_equal M[ [ 1, 2, 3 ], [ 4, 5, 6 ] ],
@@ -138,7 +232,37 @@ class TC_MultiArray < Test::Unit::TestCase
     assert_equal [ [ 1, 2, 3 ] , [ 4, 5, 6 ] ], sum { || m }.to_a
   end
 
-  def dont_test_convolve
+  def test_min
+    assert_equal 1, M[ [ 5, 3, 7 ], [ 2, 1, 6 ] ].min
+  end
+
+  def test_max
+    assert_equal 7, M[ [ 5, 3, 7 ], [ 2, 1, 6 ] ].max
+  end
+
+  def test_diagonal
+    assert_equal S[ 'b1a2', 'c1b2a3', 'c2b3' ],
+                 M[ [ 'a1', 'a2', 'a3' ],
+                    [ 'b1', 'b2', 'b3' ],
+                    [ 'c1', 'c2', 'c3' ] ].diagonal { |a,b| a + b }
+    assert_equal S[ 'c1b2a3', 'c2b3a4', 'c3b4' ],
+                 M[ [ 'a1', 'a2', 'a3', 'a4' ],
+                    [ 'b1', 'b2', 'b3', 'b4' ],
+                    [ 'c1', 'c2', 'c3', 'c4' ] ].diagonal { |a,b| a + b }
+    assert_equal S[ 'xb1a2', 'xc1b2a3', 'xd1c2b3', 'xd2c3' ],
+                 M[ [ 'a1', 'a2', 'a3' ],
+                    [ 'b1', 'b2', 'b3' ],
+                    [ 'c1', 'c2', 'c3' ],
+                    [ 'd1', 'd2', 'd3' ] ].diagonal( 'x' ) { |a,b| a + b }
+    assert_equal S( I, 4 )[ 4, 12, 21, 18 ],
+                 M( I, 3, 4 ).indgen.diagonal { |a,b| a + b }
+    assert_equal S( I, 3 )[ 4, 12, 12 ],
+                 M( I, 3, 3 ).indgen.diagonal { |a,b| a + b }
+    assert_equal S( I, 2 )[ 4, 6 ],
+                 M( I, 3, 2 ).indgen.diagonal { |a,b| a + b }
+  end
+
+  def test_convolve
     f = M[ [ 1, 2, 3 ], [ 4, 5, 6 ], [ 7, 8, 9 ] ]
     assert_equal M[ [ 5, 6, 0 ], [ 8, 9, 0 ], [ 0, 0, 0 ] ],
                  M[ [ 1, 0, 0 ], [ 0, 0, 0 ], [ 0, 0, 0 ] ].convolve( f )
@@ -250,4 +374,14 @@ class TC_MultiArray < Test::Unit::TestCase
                  M[ [ -1, 2, 3 ], [ 4, 5, 6 ] ]
   end
 
+  def test_major
+    assert_equal M[ [ 4, 2 ], [ 3, 4 ] ],
+                 M[ [ 1, 2 ], [ 3, 4 ] ].major( M[ [ 4, 1 ], [ 3, 2 ] ] )
+  end
+
+  def test_minor
+    assert_equal M[ [ 1, 1 ], [ 3, 2 ] ],
+                 M[ [ 1, 2 ], [ 3, 4 ] ].minor( M[ [ 4, 1 ], [ 3, 2 ] ] )
+  end
+
 end