multiarray 0.4.1 → 0.5.0

data/test/tc_multiarray.rb

@@ -1,3 +1,19 @@
+# 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'
@@ -8,105 +24,230 @@ Kernel::require 'multiarray'
 class TC_MultiArray < Test::Unit::TestCase
 
   O = Hornetseye::OBJECT
+  B = Hornetseye::BOOL
+  I = Hornetseye::INT
+  S = Hornetseye::Sequence
   M = Hornetseye::MultiArray
 
-  def lazy( &action )
-    Hornetseye::lazy &action
+  def S( *args )
+    Hornetseye::Sequence *args
   end
 
-  def eager( &action )
-    Hornetseye::eager &action
+  def M( *args )
+    Hornetseye::MultiArray *args
   end
 
-  def setup
+  def sum( *args, &action )
+    Hornetseye::sum *args, &action
   end
 
-  def teardown
+  def eager( *args, &action )
+    Hornetseye::eager *args, &action
   end
 
-  def M( *args )
-    Hornetseye::MultiArray *args
+  def setup
   end
 
-  def test_default
-    assert_equal [ [ nil ] * 3 ] * 2, M( O, 3, 2 ).new.to_a
+  def teardown
   end
 
   def test_multiarray_inspect
-    assert_equal 'MultiArray.object(3,2)', M( O, 3, 2 ).inspect
+    assert_equal 'MultiArray(OBJECT,3,2)', M( O, 3, 2 ).inspect
   end
 
   def test_multiarray_to_s
-    assert_equal 'MultiArray.object(3,2)', M( O, 3, 2 ).to_s
+    assert_equal 'MultiArray(OBJECT,3,2)', M( O, 3, 2 ).to_s
+  end
+
+  def test_multiarray_default
+    assert_equal [ [ O.default ] * 3 ] * 2, M( O, 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 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_assign
-    assert_equal [ [ :a, :b, :c ], [ :d, :e, :f ] ],
-                 M[ [ :a, :b, :c ], [ :d, :e, :f ] ].to_a
-    assert_equal [ [ :a, nil ], [ :b, :c ] ],
-                 M[ [ :a ], [ :b, :c ] ].to_a
-    assert_equal [ [ :a, :b ], [ :c, :c ] ],
-                 M[ [ :a, :b ], :c ].to_a
+  def test_multiarray_typecode
+    assert_equal O, M( O, 3, 2 ).typecode
+  end
+
+  def test_multiarray_dimension
+    assert_equal 2, M( O, 3, 2 ).dimension
+  end
+
+  def test_multiarray_shape
+    assert_equal [ 3, 2 ], M( O, 3, 2 ).shape
   end
 
   def test_inspect
-    assert_equal "MultiArray.object(3,2):\n" + 
-                 "[ [ :a, :b, :c ],\n  [ :d, :e, :f ] ]",
-                 M[ [ :a, :b, :c ], [ :d, :e, :f ] ].inspect
+    assert_equal "MultiArray(OBJECT,3,2):\n[ [ :a, 2, 3 ],\n  [ 4, 5, 6 ] ]",
+                 M[ [ :a, 2, 3 ], [ 4, 5, 6 ] ].inspect
   end
 
-  def test_to_s
-    # !!!
+  def test_typecode
+    assert_equal O, M( O, 3, 2 ).new.typecode
+  end
+
+  def test_dimension
+    assert_equal 2, M( O, 3, 2 ).new.dimension
+  end
+
+  def test_shape
+    assert_equal [ 3, 2 ], M( O, 3, 2 ).new.shape
   end
 
   def test_at_assign
     m = M.new O, 3, 2
     for j in 0 ... 2
       for i in 0 ... 3
-        assert_equal i + j * 3 + 1, m[ j ][ i ] = i + j * 3 + 1
+        assert_equal j * 3 + i + 1, m[ j ][ i ] = j * 3 + i + 1
+        assert_equal j * 3 + i + 1, m[ i, j ] = j * 3 + i + 1
       end
     end
     for j in 0 ... 2
       for i in 0 ... 3
-        assert_equal i + j * 3 + 1, m[ j ][ i ]
+        assert_equal j * 3 + i + 1, m[ j ][ i ]
+        assert_equal j * 3 + i + 1, m[ i, j ]
       end
     end
-    assert_equal [ 4, 5, 6 ], m[ 1 ].to_a
-    assert_equal 7, m[ 1 ] = 7
-    assert_equal [ [ 1, 2, 3 ], [ 7, 7, 7 ] ], m.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 ] ],
+                     M[ [ 1, 2, 3 ], [ 4, 6, 5 ] ]
     # !!!
+    assert_not_equal M[ [ 1, 1 ], [ 1, 1 ] ], 1
+    assert_not_equal M[ [ 1, 1 ], [ 1, 1 ] ], S[ 1, 1 ]
+  end
+
+  def test_inject
+    assert_equal 21, M[ [ 1, 2, 3 ], [ 4, 5, 6 ] ].inject { |a,b| a + b }
+    assert_equal 28, M[ [ 1, 2, 3 ], [ 4, 5, 6 ] ].inject( 7 ) { |a,b| a + b }
+  end
+
+  def test_sum
+    m = M[ [ 1, 2, 3 ], [ 4, 5, 6 ] ]
+    assert_equal 21, sum { |i,j| m[ i, j ] }
+    assert_equal [ 5, 7, 9 ], sum { |i| m[ i ] }.to_a
+    assert_equal [ 6, 15 ], eager { |j| sum { |i| m[ i, j ] } }.to_a
+    assert_equal [ [ 1, 2, 3 ] , [ 4, 5, 6 ] ], sum { || m }.to_a
+  end
+
+  def dont_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 )
+    assert_equal M[ [ 1, 2, 3 ], [ 4, 5, 6 ], [ 7, 8, 9 ] ],
+                 M[ [ 0, 0, 0 ], [ 0, 1, 0 ], [ 0, 0, 0 ] ].convolve( f )
+    assert_equal M[ [ 0, 0, 0 ], [ 1, 2, 3 ], [ 4, 5, 6 ] ],
+                 M[ [ 0, 0, 0 ], [ 0, 0, 0 ], [ 0, 1, 0 ] ].convolve( f )
+  end
+
+  def test_zero
+    assert_equal M[ [ false, true ], [ true, false ] ],
+                 M[ [ -1, 0 ], [ 0, 1 ] ].zero?
+  end
+
+  def test_nonzero
+    assert_equal M[ [ true, false ], [ false, true ] ],
+                 M[ [ -1, 0 ], [ 0, 1 ] ].nonzero?
+  end
+
+  def test_not
+    assert_equal [ [ true, false ], [ false, true ] ],
+                 M[ [ false, true ], [ true, false ] ].not.to_a
+    assert_equal [ [ true, false ], [ false, true ] ],
+                 M[ [ 0, 1 ], [ 2, 0 ] ].not.to_a
+  end
+
+  def test_and
+    assert_equal [ [ false, false ] ], M[ [ false, true ] ].and( false ).to_a
+    assert_equal [ [ false, false ] ], false.and( M[ [ false, true ] ] ).to_a
+    assert_equal [ [ false, true ] ], M[ [ false, true ] ].and( true ).to_a
+    assert_equal [ [ false, true ] ], true.and( M[ [ false, true ] ] ).to_a
+    assert_equal [ [ false, false ], [ false, true ] ],
+                 M[ [ false, true ], [ false, true ] ].
+                 and( M[ [ false, false ], [ true, true ] ] ).to_a
+    assert_equal [ [ false, false ], [ true, false ] ],
+                 M[ [ false, true ], [ true, false ] ].
+                 and( S[ false, true ] ).to_a
+  end
+
+  def test_or
+    assert_equal [ [ false, true ] ], M[ [ false, true ] ].or( false ).to_a
+    assert_equal [ [ false, true ] ], false.or( M[ [ false, true ] ] ).to_a
+    assert_equal [ [ true, true ] ], M[ [ false, true ] ].or( true ).to_a
+    assert_equal [ [ true, true ] ], true.or( M[ [ false, true ] ] ).to_a
+    assert_equal [ [ false, true ], [ true, true ] ],
+                 M[ [ false, true ], [ false, true ] ].
+                 or( M[ [ false, false ], [ true, true ] ] ).to_a
+    assert_equal [ [ false, true ], [ true, true ] ],
+                 M[ [ false, true ], [ true, false ] ].
+                 or( S[ false, true ] ).to_a
+  end
+
+  def test_bitwise_not
+    assert_equal [ [ 255, 254 ], [ 253, 252 ] ],
+                 ( ~M[ [ 0, 1 ], [ 2, 3 ] ] ).to_a
+    assert_equal [ [ 0, -1 ], [ -2, -3 ] ],
+                 ( ~M[ [ -1, 0 ], [ 1, 2 ] ] ).to_a
+  end
+
+  def test_bitwise_and
+    assert_equal [ [ 0, 1 ], [ 0, 1 ] ], ( M[ [ 0, 1 ], [ 2, 3 ] ] & 1 ).to_a
+    assert_equal [ [ 0, 1 ], [ 0, 1 ] ], ( 1 & M[ [ 0, 1 ], [ 2, 3 ] ] ).to_a
+    assert_equal [ [ 0, 1 ], [ 0, 2 ] ], ( M[ [ 0, 1 ], [ 2, 3 ] ] &
+                                           M[ [ 4, 3 ], [ 1, 2 ] ] ).to_a
+  end
+
+  def test_bitwise_or
+    assert_equal [ [ 1, 1 ], [ 3, 3 ] ], ( M[ [ 0, 1 ], [ 2, 3 ] ] | 1 ).to_a
+    assert_equal [ [ 1, 1 ], [ 3, 3 ] ], ( 1 | M[ [ 0, 1 ], [ 2, 3 ] ] ).to_a
+    assert_equal [ [ 4, 3 ], [ 3, 3 ] ], ( M[ [ 0, 1 ], [ 2, 3 ] ] |
+                                           M[ [ 4, 3 ], [ 1, 2 ] ] ).to_a
+  end
+
+  def test_bitwise_xor
+    assert_equal [ [ 1, 0 ], [ 3, 2 ] ], ( M[ [ 0, 1 ], [ 2, 3 ] ] ^ 1 ).to_a
+    assert_equal [ [ 1, 0 ], [ 3, 2 ] ], ( 1 ^ M[ [ 0, 1 ], [ 2, 3 ] ] ).to_a
+    assert_equal [ [ 4, 2 ], [ 3, 1 ] ], ( M[ [ 0, 1 ], [ 2, 3 ] ] ^
+                                           M[ [ 4, 3 ], [ 1, 2 ] ] ).to_a
+  end
+
+  def test_shl
+    assert_equal [ [ 2, 4 ], [ 6, 8 ] ], ( M[ [ 1, 2 ], [ 3, 4 ] ] << 1 ).to_a
+    assert_equal [ [ 6, 12 ], [ 24, 48 ] ],
+                 ( 3 << M[ [ 1, 2 ], [ 3, 4 ] ] ).to_a
+    assert_equal [ [ 8, 8 ], [ 6, 4 ] ],
+                 ( M[ [ 1, 2 ], [ 3, 4 ] ] << M[ [ 3, 2 ], [ 1, 0 ] ] ).to_a
+  end
+
+  def test_shr
+    assert_equal [ [ 1, 2 ], [ 3, 4 ] ], ( M[ [ 2, 4 ], [ 6, 8 ] ] >> 1 ).to_a
+    assert_equal [ [ 24, 12 ], [ 6, 3 ] ],
+                 ( 48 >> M[ [ 1, 2 ], [ 3, 4 ] ] ).to_a
+    assert_equal [ [ 2, 1 ], [ 3, 2 ] ],
+                 ( M[ [ 16, 4 ], [ 6, 2 ] ] >> M[ [ 3, 2 ], [ 1, 0 ] ] ).to_a
   end
 
   def test_negate
-    m = M[ [ 1, 2, 3 ], [ 4, 5, 6 ] ].to_type O
-    assert_equal [ [ -1, -2, -3 ], [ -4, -5, -6 ] ], ( -m ).to_a
-  end
-
-  def test_lazy
-    m = M[ [ 1, 2, 3 ], [ 4, 5, 6 ] ].to_type O
-    u = lazy { -m }
-    assert_equal 'MultiArray.object(3,2):<delayed>', u.inspect
-    assert_equal [ [ -1, -2, -3 ], [ -4, -5, -6 ] ], u.force.to_a
-    u = lazy { --m }
-    assert_equal 'MultiArray.object(3,2):<delayed>', u.inspect
-    assert_equal [ [ 1, 2, 3 ], [ 4, 5, 6 ] ], u.force.to_a
-    u = -lazy { -m }
-    assert_equal "MultiArray.object(3,2):\n[ [ 1, 2, 3 ],\n  [ 4, 5, 6 ] ]",
-                 u.inspect
-    assert_equal [ [ 1, 2, 3 ], [ 4, 5, 6 ] ], u.to_a
-    u = lazy { -lazy { -m } }
-    assert_equal 'MultiArray.object(3,2):<delayed>', u.inspect
-    assert_equal [ [ 1, 2, 3 ], [ 4, 5, 6 ] ], u.force.to_a
-    u = eager { lazy { -m } }
-    assert_equal 'MultiArray.object(3,2):<delayed>', u.inspect
-    assert_equal [ [ -1, -2, -3 ], [ -4, -5, -6 ] ], u.force.to_a
-    u = lazy { eager { -lazy { -m } } }
-    assert_equal "MultiArray.object(3,2):\n[ [ 1, 2, 3 ],\n  [ 4, 5, 6 ] ]",
-      u.inspect
-    assert_equal [ [ 1, 2, 3 ], [ 4, 5, 6 ] ], u.to_a
+    assert_equal M[ [ -1, 2, -3 ], [ 4, -5, 6 ] ],
+                 -M[ [ 1, -2, 3 ], [ -4, 5, -6 ] ]
+  end
+
+  def test_plus
+    assert_equal M[ [ 2, 3, 5 ], [ 3, 5, 7 ] ],
+                 M[ [ 1, 2, 4 ], [ 2, 4, 6 ] ] + 1
+    assert_equal M[ [ 2, 3, 5 ], [ 3, 5, 7 ] ],
+                 1 + M[ [ 1, 2, 4 ], [ 2, 4, 6 ] ]
+    assert_equal M[ [ -3, 2, 1 ], [ 8, 6, 4 ] ] +
+                 M[ [ 2, 0, 2 ], [ -4, -1, 2 ] ],
+                 M[ [ -1, 2, 3 ], [ 4, 5, 6 ] ]
   end
 
 end

data/test/tc_object.rb

@@ -1,3 +1,19 @@
+# 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'
@@ -9,44 +25,56 @@ class TC_Object < Test::Unit::TestCase
 
   O = Hornetseye::OBJECT
 
-  def lazy( &action )
-    Hornetseye::lazy &action
+  def setup
   end
 
-  def eager( &action )
-    Hornetseye::eager &action
+  def teardown
   end
 
-  def setup
+  def test_object_inspect
+    assert_equal 'OBJECT', O.inspect
   end
 
-  def teardown
+  def test_object_to_s
+    assert_equal 'OBJECT', O.to_s
   end
 
   def test_object_default
     assert_nil O.new[]
   end
 
-  def test_object_inspect
-    assert_equal 'OBJECT', O.inspect
+  def test_object_typecode
+    assert_equal O, O.typecode
   end
 
-  def test_object_to_s
-    assert_equal 'OBJECT', O.to_s
+  def test_object_dimension
+    assert_equal 0, O.dimension
   end
 
-  def test_inspect
-    assert_equal 'OBJECT(42)', O.new( 42 ).inspect
+  def test_object_shape
+    assert_equal [], O.shape
   end
 
-  def test_to_s
-    assert_equal '42', O.new( 42 ).to_s
+  def test_inspect
+    assert_equal 'OBJECT(42)', O.new( 42 ).inspect
   end
 
   def test_marshal
     assert_equal O.new( 42 ), Marshal.load( Marshal.dump( O.new( 42 ) ) )
   end
 
+  def test_typecode
+    assert_equal O, O.new.typecode
+  end
+
+  def test_dimension
+    assert_equal 0, O.new.dimension
+  end
+
+  def test_shape
+    assert_equal [], O.new.shape
+  end
+
   def test_at_assign
     o = O.new 3
     assert_equal 3, o[]
@@ -59,45 +87,22 @@ class TC_Object < Test::Unit::TestCase
     assert_equal O.new( 3 ), O.new( 3 )
   end
 
+  def test_inject
+    assert_equal 2, O.new( 2 ).inject { |a,b| a + b }[]
+    assert_equal 3, O.new( 2 ).inject( 1 ) { |a,b| a + b }[]
+  end
+
+  def test_zero
+    assert O.new( 0 ).zero?[]
+    assert !O.new( 3 ).zero?[]
+  end
+
   def test_negate
-    o = O.new 5
-    assert_equal O.new( -5 ), -o
+    assert_equal O.new( -5 ), -O.new( 5 )
   end
 
   def test_plus
-    v = O.new 3
-    w = O.new 5
-    assert_equal O.new( 3 + 5 ), v + w
-  end
-
-  def test_lazy_unary
-    o = lazy { -O.new( 3 ) }
-    assert_not_equal O.new( -3 ), o
-    assert_equal 'OBJECT(<delayed>)', o.inspect
-    assert_equal O.new( -3 ), o.force
-    o = lazy { --O.new( 3 ) }
-    assert_equal 'OBJECT(<delayed>)', o.inspect
-    assert_equal O.new( 3 ), o.force
-    o = -lazy { -O.new( 3 ) }
-    assert_equal O.new( 3 ), o
-    o = lazy { -lazy { -O.new( 3 ) } }
-    assert_equal 'OBJECT(<delayed>)', o.inspect
-    assert_equal O.new( 3 ), o.force
-    o = eager { lazy { -O.new( 3 ) } }
-    assert_equal 'OBJECT(<delayed>)', o.inspect
-    o = lazy { eager { -lazy { -O.new( 3 ) } } }
-    assert_equal O.new( 3 ), o
-  end
-
-  def test_lazy_binary
-    v = O.new 3
-    w = O.new 5
-    o = lazy { v + w }
-    assert_not_equal v + w, o
-    assert_equal 'OBJECT(<delayed>)', o.inspect
-    assert_equal O.new( 8 ), o.force
-    assert_equal O.new( 9 ), o + O.new( 1 )
-    assert_equal O.new( 9 ), O.new( 1 ) + o
+    assert_equal O.new( 3 + 5 ), O.new( 3 ) + O.new( 5 )
   end
 
 end