multiarray 0.22.0 → 0.23.1

data/lib/multiarray/shortcuts.rb

@@ -1,5 +1,5 @@
 # multiarray - Lazy multi-dimensional arrays for Ruby
-# Copyright (C) 2010 Jan Wedekind
+# Copyright (C) 2010, 2011 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
@@ -28,7 +28,7 @@ module Hornetseye
     #
     # @private
     def constructor_shortcut( target )
-      define_method( target.to_s.downcase ) do |*args|
+      define_method target.to_s.downcase do |*args|
         new target, *args
       end
     end
@@ -77,7 +77,7 @@ module Hornetseye
     #
     # @private
     def to_type_shortcut( target )
-      define_method( "to_#{target.to_s.downcase}" ) do
+      define_method "to_#{target.to_s.downcase}" do
         to_type target
       end
     end
@@ -124,7 +124,7 @@ module Hornetseye
     #
     # @private
     def read_shortcut( target )
-      define_method( "read_#{target.to_s.downcase}" ) do
+      define_method "read_#{target.to_s.downcase}" do
         read.to_type target
       end
     end

data/lib/multiarray/store.rb

@@ -1,5 +1,5 @@
 # multiarray - Lazy multi-dimensional arrays for Ruby
-# Copyright (C) 2010 Jan Wedekind
+# Copyright (C) 2010, 2011 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
@@ -29,6 +29,10 @@ module Hornetseye
       @dest, @source = dest, source
     end
 
+    def sexp?
+      true
+    end
+
     # Get unique descriptor of this object
     #
     # @param [Hash] hash Labels for any variables.
@@ -40,13 +44,12 @@ module Hornetseye
       "Store(#{@dest.descriptor( hash )},#{@source.descriptor( hash )})"
     end
 
-    # Get type of result of delayed operation
-    #
-    # @return [Class] Type of result.
-    #
-    # @private
-    def array_type
-      @dest.array_type
+    def typecode
+      @dest.typecode
+    end
+
+    def shape
+      @dest.shape
     end
 
     # Reevaluate computation
@@ -60,10 +63,10 @@ module Hornetseye
       if variables.empty?
         if dimension > 0
           shape.last.times do |i|
-            dest = @dest.element INT.new( i )
+            dest = @dest.element INT.new(i)
             source = @source.dimension == 0 ? @source :
-                                              @source.element( INT.new( i ) )
-            Store.new( dest, source ).demand
+                                              @source.element(INT.new(i))
+            Store.new(dest, source).demand
           end  
         elsif @dest.class < Pointer_
           @dest.store @source.demand

data/lib/multiarray/unmask.rb

@@ -45,6 +45,10 @@ module Hornetseye
       @dest, @source, @m, @index, @default = dest, source, m, index, default
     end
 
+    def sexp?
+      true
+    end
+
     # Get unique descriptor of this object
     #
     # @param [Hash] hash Labels for any variables.
@@ -58,13 +62,12 @@ module Hornetseye
         "#{@default.descriptor( hash )})"
     end
 
-    # Get type of result of delayed operation
-    #
-    # @return [Class] Type of result.
-    #
-    # @private
-    def array_type
-      @dest.array_type
+    def typecode
+      @dest.typecode
+    end
+
+    def shape
+      @dest.shape
     end
 
     # Perform masking operation

data/lib/multiarray/variable.rb

@@ -1,5 +1,5 @@
 # multiarray - Lazy multi-dimensional arrays for Ruby
-# Copyright (C) 2010 Jan Wedekind
+# Copyright (C) 2010, 2011 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
@@ -38,6 +38,10 @@ module Hornetseye
       @meta = meta
     end
 
+    def sexp?
+      true
+    end
+
     # Display string with information about this object
     #
     # @return [String] String with information about this object (e.g.
@@ -90,8 +94,12 @@ module Hornetseye
     # @return [Class] Type of result.
     #
     # @private
-    def array_type
-      @meta.array_type
+    def typecode
+      @meta.typecode
+    end
+
+    def shape
+      @meta.shape
     end
 
     # Strip of all values

data/test/tc_bool.rb

@@ -55,14 +55,6 @@ class TC_Bool < Test::Unit::TestCase
     assert_equal 0, B.dimension
   end
 
-  def test_bool_shape
-    assert_equal [], B.shape
-  end
-
-  def test_bool_size
-    assert_equal 1, B.size
-  end
-
   def test_inspect
     assert_equal 'BOOL(true)', B( true ).inspect
   end

data/test/tc_compile.rb

@@ -0,0 +1,72 @@
+# 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_Compile < Test::Unit::TestCase
+
+  B = Hornetseye::BYTE
+  W = Hornetseye::SINT
+  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 finalise( *args, &action )
+    Hornetseye::finalise *args, &action
+  end
+
+  def sum( *args, &action )
+    Hornetseye::sum *args, &action
+  end
+
+  def setup
+  end
+
+  def teardown
+  end
+
+  def test_unary
+    assert_equal S(W)[-1, -2, -3], -S(W)[1, 2, 3]
+    assert_equal S(W)[-1, -2, -3], -S(W)[1, 2, 3]
+    assert !lazy { -S(W)[1, 2, 3] }.finalised?
+  end
+
+  def test_binary
+    assert_equal S(W)[2, 3, 4], S(W)[1, 2, 3] + 1
+    assert_equal S(W)[2, 3, 4], S(W)[1, 2, 3] + 1
+    assert !lazy { S(W)[1, 2, 3] + 1 }.finalised?
+    assert_equal S(W)[257, 258, 259], S(W)[1, 2, 3] + 256
+    assert_equal S(W)[2, 4, 6], S(W)[1, 2, 3] + S(W)[1, 2, 3]
+  end
+
+end
+

data/test/tc_float.rb

@@ -73,14 +73,6 @@ class TC_Float < Test::Unit::TestCase
   def test_float_dimension
     assert_equal 0, F.dimension
   end
-!
-  def test_float_shape
-    assert_equal [], F.shape
-  end
-
-  def test_float_size
-    assert_equal 1, F.size
-  end
 
   def test_inspect
     assert_equal 'DFLOAT(42.0)', D( 42.0 ).inspect

data/test/tc_int.rb

@@ -88,14 +88,6 @@ 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( 42 ).inspect

data/test/tc_lazy.rb

@@ -37,6 +37,14 @@ class TC_Lazy < Test::Unit::TestCase
     Hornetseye::MultiArray *args
   end
 
+  def C( *args )
+    Hornetseye::RGB *args
+  end
+
+  def X( *args )
+    Complex *args
+  end
+
   def lazy( *args, &action )
     Hornetseye::lazy *args, &action
   end
@@ -115,12 +123,23 @@ class TC_Lazy < Test::Unit::TestCase
 
   def test_indgen_diagonal
     assert_equal [ 15, 18, 17 ],
-                 M( I, 4, 3 ).indgen.diagonal { |a,b| a + b }.to_a
+                 M(I, 2).indgen(4, 3).diagonal { |a,b| a + b }.to_a
   end
 
   def test_lut
-    assert_equal S( I, 4 )[ 4, 2, 3, 2 ],
-                 finalise { S( I, 4 )[ 0, 2, 1, 2 ].lut( S( I, 3 )[ 3, 2, 1 ] ) + 1 }
+    assert_equal S( I )[ 4, 2, 3, 2 ],
+                 finalise { S( I )[ 0, 2, 1, 2 ].lut( S( I )[ 3, 2, 1 ] ) + 1 }
+  end
+
+  def test_complex
+    assert_equal [1, 1], lazy(2) { X 1, 2 }.real.to_a
+    assert_equal [2, 2], lazy(2) { X 1, 2 }.imag.to_a
+  end
+
+  def test_rgb
+    assert_equal [1, 1], lazy(2) { C 1, 2, 3 }.r.to_a
+    assert_equal [2, 2], lazy(2) { C 1, 2, 3 }.g.to_a
+    assert_equal [3, 3], lazy(2) { C 1, 2, 3 }.b.to_a
   end
 
 end

data/test/tc_multiarray.rb

@@ -63,69 +63,43 @@ class TC_MultiArray < Test::Unit::TestCase
   end
 
   def test_multiarray_inspect
-    assert_equal 'MultiArray(OBJECT,3,2)', M( O, 3, 2 ).inspect
-    assert_equal 'MultiArray(OBJECT,3,2)', S( S( O, 3 ), 2 ).inspect
+    assert_equal 'MultiArray(OBJECT,2)', M(O,2).inspect
+    assert_equal 'MultiArray(OBJECT,2)', S(S(O)).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)', S( S( O, 3 ), 2 ).to_s
-  end
-
-  def test_multiarray_default
-    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
+    assert_equal 'MultiArray(OBJECT,2)', M(O,2).to_s
+    assert_equal 'MultiArray(OBJECT,2)', S(S(O)).to_s
   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
+                 M(O, 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 M( I, 3, 2 )[ [ 0, 1, 2 ], [ 3, 4, 5 ] ],
-                 M( I, 3, 2 ).indgen
-    assert_equal M( I, 3, 2 )[ [ 1, 2, 3 ], [ 4, 5, 6 ] ],
-                 M( I, 3, 2 ).indgen( 1 )
-    assert_equal M( I, 3, 2 )[ [ 0, 2, 4 ], [ 6, 8, 10 ] ],
-                 M( I, 3, 2 ).indgen( 0, 2 )
-    assert_equal M( I, 3, 2 )[ [ 1, 3, 5 ], [ 7, 9, 11 ] ],
-                 M( I, 3, 2 ).indgen( 1, 2 )
-    assert_equal M( C, 2, 2 )[ [ 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 ) )
-  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
-    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_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
+    assert_equal M(I, 2)[ [ 0, 1, 2 ], [ 3, 4, 5 ] ],
+                 M(I, 2).indgen(3, 2)
+    assert_equal M(I, 2)[ [ 1, 2, 3 ], [ 4, 5, 6 ] ],
+                 M(I, 2).indgen(3, 2, 1)
+    assert_equal M(I, 2)[ [ 0, 2, 4 ], [ 6, 8, 10 ] ],
+                 M(I, 2).indgen(3, 2, 0, 2)
+    assert_equal M(I, 2)[ [ 1, 3, 5 ], [ 7, 9, 11 ] ],
+                 M(I, 2).indgen(3, 2, 1, 2)
+    assert_equal M(C, 2)[ [ C( 1, 2, 3 ), C( 2, 2, 2 ) ],
+                          [ C( 3, 2, 1 ), C( 4, 2, 0 ) ] ],
+                 M(C, 2).indgen(2, 2, C( 1, 2, 3 ), C( 1, 0, -1 ))
   end
 
   def test_inspect
-    assert_equal "MultiArray(OBJECT,3,2):\n[ [ :a, 2, 3 ],\n  [ 4, 5, 6 ] ]",
+    assert_equal "MultiArray(OBJECT,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" +
+    assert_equal "MultiArray(UBYTE,3):\n" +
                  "[ [ [ 0, 1, 2, 3 ],\n" +
                  "    [ 4, 5, 6, 7 ],\n" +
                  "    [ 8, 9, 10, 11 ] ],\n" +
@@ -148,23 +122,23 @@ class TC_MultiArray < Test::Unit::TestCase
   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
+    assert_equal O, M(O, 2).new(3, 2).typecode
+    assert_equal I, M(I, 2).new(3, 2).typecode
+    assert_equal C, M(C, 2).new(3, 2).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
+    assert_equal 2, M(O, 2).new(3, 2).dimension
+    assert_equal 2, M(I, 2).new(3, 2).dimension
+    assert_equal 2, M(C, 2).new(3, 2).dimension
   end
 
   def test_shape
-    assert_equal [ 3, 2 ], M( O, 3, 2 ).new.shape
+    assert_equal [ 3, 2 ], M(O, 2).new(3, 2).shape
   end
 
   def test_size
-    assert_equal 6, M( O, 3, 2 ).new.size
+    assert_equal 6, M(O, 2).new(3, 2).size
   end
 
   def test_import
@@ -177,8 +151,8 @@ class TC_MultiArray < Test::Unit::TestCase
   end
 
   def test_at_assign
-    [ M( O, 3, 2 ), M( I, 3, 2 ) ].each do |t|
-      m = t.new
+    [ M(O, 2), M(I, 2) ].each do |t|
+      m = t.new 3, 2
       for j in 0 ... 2
         for i in 0 ... 3
           assert_equal j * 3 + i + 1, m[ j ][ i ] = j * 3 + i + 1
@@ -216,8 +190,8 @@ class TC_MultiArray < Test::Unit::TestCase
   end
 
   def test_slice
-    [ M( O, 5, 4 ), M( I, 5, 4 ) ].each do |t|
-      m = t.indgen[]
+    [ M(O, 2), M(I, 2) ].each do |t|
+      m = t.indgen(5, 4)[]
       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 ] ],
@@ -305,27 +279,27 @@ class TC_MultiArray < Test::Unit::TestCase
     end
   end
 
-  def test_view
-    [ M( O, 3, 2 ), M( I, 3, 2 ) ].each do |t|
-      m = t[ [ 1, 2, 3 ], [ 4, 5, 6 ] ]
-      v = m[ 1, 0 ... 2 ]
+   def test_view
+    [ M(O, 2), M(I, 2) ].each do |t|
+      m = t[[1, 2, 3], [4, 5, 6]]
+      v = m[1, 0 ... 2]
       v[] = 0
-      assert_equal [ [ 1, 0, 3 ], [ 4, 0, 6 ] ], m.to_a
+      assert_equal [[1, 0, 3], [4, 0, 6]], m.to_a
     end
    end
 
    def test_transpose
     assert_equal [ [ 1, 4 ], [ 2, 5 ], [ 3, 6 ] ],
-                 M[ [ 1, 2, 3 ], [ 4, 5, 6 ] ].transpose( 1, 0 ).to_a
+                 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
+                 M(I, 3).indgen(3, 2, 1).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
+                 M(I, 3).indgen(3, 2, 1).unroll.to_a
     assert_equal [ [ [ 0, 3 ] ], [ [ 1, 4 ] ], [ [ 2, 5 ] ] ],
-                 M( I, 3, 2, 1 ).indgen.roll.to_a
+                 M(I, 3).indgen(3, 2, 1).roll.to_a
   end
 
   def test_equal
@@ -361,8 +335,8 @@ class TC_MultiArray < Test::Unit::TestCase
   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 }
+    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_collect
@@ -415,12 +389,12 @@ class TC_MultiArray < Test::Unit::TestCase
                     [ '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 }
+    assert_equal S(I)[ 4, 12, 21, 18 ],
+                 M(I, 2).indgen(3, 4).diagonal { |a,b| a + b }
+    assert_equal S(I)[ 4, 12, 12 ],
+                 M(I, 2).indgen(3, 3).diagonal { |a,b| a + b }
+    assert_equal S(I)[ 4, 6 ],
+                 M(I, 2).indgen(3, 2).diagonal { |a,b| a + b }
   end
 
   def test_convolve
@@ -506,41 +480,41 @@ class TC_MultiArray < Test::Unit::TestCase
   end
 
   def test_warp
-    [ O, I ].each do |t1|
-      [ O, I ].each do |t2|
+    [O, I].each do |t1|
+      [O, I].each do |t2|
         z = t1.default
-        assert_equal M( t1, 3, 3 )[ [ 1, 2, z ], [ 3, 4, z ], [ z, z, z ] ],
-                     M( t1, 2, 2 )[ [ 1, 2 ], [ 3, 4 ] ].
-                     warp( M( t2, 3, 3 )[ [ 0, 1, 2 ], [ 0, 1, 2 ], [ 0, 1, 2 ] ],
-                           M( t2, 3, 3 )[ [ 0, 0, 0 ], [ 1, 1, 1 ], [ 2, 2, 2 ] ] )
+        assert_equal M(t1, 2)[ [ 1, 2, z ], [ 3, 4, z ], [ z, z, z ] ],
+                     M(t1, 2)[ [ 1, 2 ], [ 3, 4 ] ].
+                     warp( M(t2, 2)[ [ 0, 1, 2 ], [ 0, 1, 2 ], [ 0, 1, 2 ] ],
+                           M(t2, 2)[ [ 0, 0, 0 ], [ 1, 1, 1 ], [ 2, 2, 2 ] ] )
       end
     end
   end
 
   def test_flip
     [ O, I ].each do |t|
-      assert_equal M( t, 3, 2 )[ [ 3, 2, 1 ], [ 6, 5, 4 ] ],
-                   M( t, 3, 2 )[ [ 1, 2, 3 ], [ 4, 5, 6 ] ].flip( 0 )
-      assert_equal M( t, 3, 2 )[ [ 4, 5, 6 ], [ 1, 2, 3 ] ],
-                   M( t, 3, 2 )[ [ 1, 2, 3 ], [ 4, 5, 6 ] ].flip( 1 )
-      assert_equal M( t, 3, 2 )[ [ 6, 5, 4 ], [ 3, 2, 1 ] ],
-                   M( t, 3, 2 )[ [ 1, 2, 3 ], [ 4, 5, 6 ] ].flip( 0, 1 )
+      assert_equal M(t, 2)[ [ 3, 2, 1 ], [ 6, 5, 4 ] ],
+                   M(t, 2)[ [ 1, 2, 3 ], [ 4, 5, 6 ] ].flip( 0 )
+      assert_equal M(t, 2)[ [ 4, 5, 6 ], [ 1, 2, 3 ] ],
+                   M(t, 2)[ [ 1, 2, 3 ], [ 4, 5, 6 ] ].flip( 1 )
+      assert_equal M(t, 2)[ [ 6, 5, 4 ], [ 3, 2, 1 ] ],
+                   M(t, 2)[ [ 1, 2, 3 ], [ 4, 5, 6 ] ].flip( 0, 1 )
     end
   end
 
   def test_shift
     [ O, I ].each do |t|
-      assert_equal M( t, 2, 2 )[ [ 4, 3 ], [ 2, 1 ] ],
-                   M( t, 2, 2 )[ [ 1, 2 ], [ 3, 4 ] ].shift( 1, 1 )
+      assert_equal M(t, 2)[ [ 4, 3 ], [ 2, 1 ] ],
+                   M(t, 2)[ [ 1, 2 ], [ 3, 4 ] ].shift( 1, 1 )
     end
   end
 
   def test_downsample
     [ O, I ].each do |t|
-      assert_equal M( t, 1, 2 )[ [ 2 ], [ 6 ] ],
-                   M( t, 3, 2 )[ [ 1, 2, 3 ], [ 5, 6, 7 ] ].downsample( 2, 1 )
-      assert_equal M( t, 2, 2 )[ [ 1, 3 ], [ 5, 7 ] ],
-                   M( t, 3, 2 )[ [ 1, 2, 3 ], [ 5, 6, 7 ] ].
+      assert_equal M(t, 2)[ [ 2 ], [ 6 ] ],
+                   M(t, 2)[ [ 1, 2, 3 ], [ 5, 6, 7 ] ].downsample( 2, 1 )
+      assert_equal M(t, 2)[ [ 1, 3 ], [ 5, 7 ] ],
+                   M(t, 2)[ [ 1, 2, 3 ], [ 5, 6, 7 ] ].
                    downsample( 2, 1, :offset => [ 0, 0 ] )
     end
   end
@@ -642,9 +616,9 @@ class TC_MultiArray < Test::Unit::TestCase
                  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 ] ]
+    assert_equal M[ [ -1, 2, 3 ], [ 4, 5, 6 ] ],
+                 M[ [ -3, 2, 1 ], [ 8, 6, 4 ] ] +
+                 M[ [ 2, 0, 2 ], [ -4, -1, 2 ] ]
     assert_equal M[ [ 2, 3, 4 ], [ 6, 7, 8 ] ],
                  M[ [ 1, 2, 3 ], [ 4, 5, 6 ] ] + S[ 1, 2 ]
     assert_equal M[ [ 2, 3, 4 ], [ 6, 7, 8 ] ],
@@ -702,33 +676,33 @@ class TC_MultiArray < Test::Unit::TestCase
   end
 
   def test_fill
-    m = M( I, 3, 2 )[ [ 1, 2, 3 ], [ 4, 5, 6 ] ]
-    assert_equal M( I, 3, 2 )[ [ 1, 1, 1 ], [ 1, 1, 1 ] ], m.fill!( 1 )
-    assert_equal M( I, 3, 2 )[ [ 1, 1, 1 ], [ 1, 1, 1 ] ], m
+    m = M(I, 2)[ [ 1, 2, 3 ], [ 4, 5, 6 ] ]
+    assert_equal M(I, 2)[ [ 1, 1, 1 ], [ 1, 1, 1 ] ], m.fill!( 1 )
+    assert_equal M(I, 2)[ [ 1, 1, 1 ], [ 1, 1, 1 ] ], m
   end
 
   def test_to_type
-    assert_equal M( C, 2, 2 )[ [ 1, 2 ], [ 3, 4 ] ],
-                 M( I, 2, 2 )[ [ 1, 2 ], [ 3, 4 ] ].to_intrgb
+    assert_equal M(C, 2)[ [ 1, 2 ], [ 3, 4 ] ],
+                 M(I, 2)[ [ 1, 2 ], [ 3, 4 ] ].to_intrgb
   end
 
   def test_reshape
-    [ O, I ].each do |t|
-      assert_equal M( t, 3, 2 )[ [ 1, 2, 3 ], [ 4, 5, 6 ] ],
-                   S( t, 6 )[ 1, 2, 3, 4, 5, 6 ].reshape( 3, 2 )
-      assert_equal S( t, 6 )[ 1, 2, 3, 4, 5, 6 ],
-                   M( t, 3, 2 )[ [ 1, 2, 3 ], [ 4, 5, 6 ] ].reshape( 6 )
-      assert_equal M( t, 2, 3 )[ [ 1, 2 ], [ 3, 4 ], [ 5, 6 ] ],
-                   M( t, 3, 2 )[ [ 1, 2, 3 ], [ 4, 5, 6 ] ].reshape( 2, 3 )
-      assert_raise( RuntimeError ) { M( t, 2, 2 )[ [ 1, 2 ], [ 3, 4 ] ].reshape 3 }
+    [O, I].each do |t|
+      assert_equal M(t, 2)[[1, 2, 3], [4, 5, 6]],
+                   S(t)[1, 2, 3, 4, 5, 6].reshape(3, 2)
+      assert_equal S(t)[1, 2, 3, 4, 5, 6],
+                   M(t, 2)[[1, 2, 3], [4, 5, 6]].reshape(6)
+      assert_equal M(t, 2)[[1, 2], [3, 4], [5, 6]],
+                   M(t, 2)[[1, 2, 3], [4, 5, 6]].reshape(2, 3)
+      assert_raise( RuntimeError ) { M(t, 2)[[1, 2], [3, 4]].reshape 3 }
     end
   end
 
   def test_integral
-    assert_equal M( O, 3, 2 )[ [ 1, 3, 6 ], [ 5, 12, 21 ] ],
-                 M( O, 3, 2 )[ [ 1, 2, 3 ], [ 4, 5, 6 ] ].integral
-    assert_equal M( I, 3, 2 )[ [ 1, 3, 6 ], [ 5, 12, 21 ] ],
-                 M( I, 3, 2 )[ [ 1, 2, 3 ], [ 4, 5, 6 ] ].integral
+    assert_equal M(O, 2)[[1, 3, 6], [5, 12, 21]],
+                 M(O, 2)[[1, 2, 3], [4, 5, 6]].integral
+    assert_equal M(I, 2)[[1, 3, 6], [5, 12, 21]],
+                 M(I, 2)[[1, 2, 3], [4, 5, 6]].integral
   end
 
   def test_components
@@ -737,28 +711,28 @@ class TC_MultiArray < Test::Unit::TestCase
   end
 
   def test_mask
-    [ O, I ].each do |t|
-      assert_equal M( O, 2, 2 )[ [ 1, 2 ], [ 5, 7 ] ],
-                   M( O, 2, 3 )[ [ 1, 2 ], [ 3, 4 ], [ 5, 7 ] ].
-                   mask( S[ true, false, true ] )
-      assert_equal S( O, 3 )[ 2, 5, 7 ], M( O, 3, 2 )[ [ 1, 2, 3 ], [ 4, 5, 7 ] ].
-                   mask( M[ [ false, true, false ], [ false, true, true ] ] )
+    [O, I].each do |t|
+      assert_equal M(t, 2)[[1, 2], [5, 7]],
+                   M(t, 2)[[1, 2], [3, 4], [5, 7]].
+                   mask(S[true, false, true])
+      assert_equal S(t)[2, 5, 7], M(t, 2)[[1, 2, 3], [4, 5, 7]].
+                   mask( M[[false, true, false], [false, true, true]])
       assert_raise( RuntimeError ) do
-        M( O, 2, 3 )[ [ 1, 2 ], [ 3, 4 ], [ 5, 7 ] ].mask S[ false, true ]
+        M(t, 2)[[1, 2], [3, 4], [5, 7]].mask S[false, true]
       end
     end
   end
 
   def test_unmask
     [ O, I ].each do |t|
-      assert_equal M( t, 2, 3 )[ [ 1, 2 ], [ 4, 4 ], [ 5, 7 ] ],
-                   M( t, 2, 2 )[ [ 1, 2 ], [ 5, 7 ] ].
-                   unmask( S[ true, false, true ], :default => S[ 3, 4, 5 ] )
-      assert_equal M( t, 3, 2 )[ [ 0, 2, 0 ], [ 0, 5, 7 ] ],
-                   S( t, 3 )[ 2, 5, 7 ].
-                   unmask( M[ [ false, true, false ], [ false, true, true ] ],
+      assert_equal M(t, 2)[[1, 2], [4, 4], [5, 7]],
+                   M(t, 2)[[1, 2], [5, 7]].
+                   unmask( S[true, false, true], :default => S[3, 4, 5] )
+      assert_equal M(t, 2)[[0, 2, 0], [0, 5, 7]],
+                   S(t)[2, 5, 7].
+                   unmask( M[[false, true, false], [false, true, true]],
                            :default => 0 )
-      assert_raise( RuntimeError ) { S( t, 1 )[ 1 ].unmask M[ [ true, true ] ] }
+      assert_raise( RuntimeError ) { S(t)[1].unmask M[[true, true]] }
     end
   end