multiarray 0.5.1 → 0.5.2

data/lib/multiarray/pointer.rb

@@ -68,6 +68,10 @@ module Hornetseye
         target
       end
 
+      def basetype
+        target.basetype
+      end
+
       def array_type
         target
       end
@@ -76,6 +80,10 @@ module Hornetseye
         self
       end
 
+      def finalised?
+        false
+      end
+
     end
 
     def initialize( value = self.class.default )
@@ -132,6 +140,17 @@ module Hornetseye
       end
     end
 
+    def decompose
+      if self.class.target < Composite
+        pointer = Hornetseye::Pointer( self.class.target.element_type ).new @value
+        num_elements = self.class.target.num_elements
+        var = Variable.new Hornetseye::INDEX( INT.new( num_elements ) )
+        Lambda.new var, Lookup.new( pointer, var, INT.new( 1 ) )
+      else
+        super
+      end
+    end
+
     def values
       [ @value ]
     end

data/lib/multiarray/rgb.rb

@@ -111,36 +111,26 @@ module Hornetseye
       end
     end
 
+    def decompose
+      Hornetseye::Sequence[ @r, @g, @b ]
+    end
+
   end
 
-  class RGB_ < Element
+  class RGB_ < Composite
 
     class << self
 
-      attr_accessor :element_type
-
-      def fetch( ptr )
-        construct *ptr.load( self )
+      def inherited( subclass )
+        subclass.num_elements = 3
       end
 
       def construct( r, g, b )
-        new Hornetseye::RGB( r, g, b )
-      end
-
-      def memory
-        element_type.memory
-      end
-
-      def storage_size
-        element_type.storage_size * 3
+        new RGB.new( r, g, b )
       end
 
       def default
-        Hornetseye::RGB 0, 0, 0
-      end
-
-      def directive
-        element_type.directive * 3
+        RGB.new 0, 0, 0
       end
 
       def inspect
@@ -161,22 +151,6 @@ module Hornetseye
         end
       end
 
-      def descriptor( hash )
-        unless element_type.nil?
-          inspect
-        else
-          super
-        end
-      end
-
-      def basetype
-        element_type
-      end
-
-      def typecodes
-        [ element_type ] * 3
-      end
-
       def maxint
         Hornetseye::RGB element_type.maxint
       end
@@ -218,10 +192,6 @@ module Hornetseye
         self == other
       end
 
-      #def compilable?
-      #  false # !!!
-      #end
-
     end
 
     def initialize( value = self.class.default )
@@ -230,8 +200,8 @@ module Hornetseye
         @value = value
       else
         r = GCCValue.new Thread.current[ :function ], value.r.to_s
-        g = GCCValue.new Thread.current[ :function ], value.r.to_s
-        b = GCCValue.new Thread.current[ :function ], value.r.to_s
+        g = GCCValue.new Thread.current[ :function ], value.g.to_s
+        b = GCCValue.new Thread.current[ :function ], value.b.to_s
         @value = RGB.new r, g, b
       end
     end
@@ -241,10 +211,10 @@ module Hornetseye
         r = Thread.current[ :function ].variable self.class.element_type, 'v'
         g = Thread.current[ :function ].variable self.class.element_type, 'v'
         b = Thread.current[ :function ].variable self.class.element_type, 'v'
-        r.get.store @value.r
-        g.get.store @value.g
-        b.get.store @value.b
-        self.class.new RGB.new( r.get, g.get, b.get )
+        r.store @value.r
+        g.store @value.g
+        b.store @value.b
+        self.class.new RGB.new( r, g, b )
       else
         self.class.new get
       end

data/lib/multiarray/sequence.rb

@@ -81,14 +81,14 @@ module Hornetseye
 
       def indgen( offset = 0, increment = 1 )
         Hornetseye::lazy( num_elements ) do |i|
-          element_type.size * increment * i +
-            element_type.indgen( offset, increment )
+          ( element_type.size * increment * i +
+            element_type.indgen( offset, increment ) ).to_type typecode
         end
       end
 
       def []( *args )
         retval = new
-        recursion = proc do |element,args|
+        recursion = lambda do |element,args|
           if element.dimension > 0
             args.each_with_index do |arg,i|
               recursion.call element.element( i ), arg
@@ -141,18 +141,34 @@ module Hornetseye
         Hornetseye::Sequence element_type.bool, num_elements
       end
 
-      def bool_binary( other )
+      def coercion_bool( other )
         coercion( other ).bool
       end
 
+      def scalar
+        Hornetseye::Sequence element_type.scalar, num_elements
+      end
+
+      def float_scalar
+        Hornetseye::Sequence element_type.float_scalar, num_elements
+      end
+
       def maxint
         Hornetseye::Sequence element_type.maxint, num_elements
       end
 
-      def largeint( other )
+      def coercion_maxint( other )
         coercion( other ).maxint
       end
 
+      def byte
+        Hornetseye::Sequence element_type.byte, num_elements
+      end
+
+      def coercion_byte( other )
+        coercion( other ).byte
+      end
+
       def float
         Hornetseye::Sequence element_type.float, num_elements
       end
@@ -161,6 +177,15 @@ module Hornetseye
         coercion( other ).float
       end
 
+      def cond( a, b )
+        t = a.coercion b
+        Hornetseye::MultiArray( t.typecode, *shape ).coercion t
+      end
+
+      def to_type( dest )
+        Hornetseye::Sequence element_type.to_type( dest ), num_elements
+      end
+
       def inspect
         if dimension == 1
           "Sequence(#{typecode.inspect},#{num_elements.inspect})"
@@ -216,6 +241,10 @@ module Hornetseye
         MultiArray.new typecode, *shape
       end
 
+      def compilable?
+        element_type.compilable?
+      end
+
     end
 
     # Namespace containing method for matching elements of type Sequence_

data/test/tc_float.rb

@@ -118,75 +118,54 @@ class TC_Float < Test::Unit::TestCase
     assert_equal D( 3.0 ), D( 3.0 )
   end
 
-if false
+  def test_r_g_b
+    assert_equal D( 3.5 ), D( 3.5 ).r
+    assert_equal D( 3.5 ), D( 3.5 ).g
+    assert_equal D( 3.5 ), D( 3.5 ).b
+  end
 
   def test_inject
-    assert_equal 2, I( 2 ).inject { |a,b| a + b }[]
-    assert_equal 3, I( 2 ).inject( 1 ) { |a,b| a + b }[]
+    assert_equal 2.5, D( 2.5 ).inject { |a,b| a + b }[]
+    assert_equal 4.0, D( 2.5 ).inject( 1.5 ) { |a,b| a + b }[]
   end
 
   def test_not
-    assert !I( 0 ).not[]
-    assert !I( 3 ).not[]
+    assert !D( 0.0 ).not[]
+    assert !D( 3.0 ).not[]
   end
 
   def test_sum
-    assert_equal 3, sum { || 3 }
+    assert_equal 3.5, sum { || 3.5 }
   end
 
   def test_zero
-    assert I( 0 ).zero?[]
-    assert !I( 3 ).zero?[]
+    assert D( 0.0 ).zero?[]
+    assert !D( 3.0 ).zero?[]
   end
 
   def test_nonzero
-    assert !I( 0 ).nonzero?[]
-    assert I( 3 ).nonzero?[]
-  end
-
-  def test_bitwise_not
-    assert_equal I( -3 ), ~I( 2 )
-  end
-
-  def test_bitwise_and
-    assert_equal I( 2 ), I( 3 ) & I( 6 )
-  end
-
-  def test_bitwise_or
-    assert_equal I( 7 ), I( 3 ) | I( 6 )
+    assert !D( 0.0 ).nonzero?[]
+    assert D( 3.0 ).nonzero?[]
   end
 
-  def test_bitwise_xor
-    assert_equal I( 1 ), I( 3 ) ^ I( 2 )
-  end
-
-  def test_shl
-    assert_equal I( 4 ), I( 2 ) << I( 1 )
-  end
-
-  def test_shr
-    assert_equal I( 2 ), I( 4 ) >> I( 1 )
-  end
 
   def test_negate
-    assert_equal I( -5 ), -I( 5 )
+    assert_equal D( -3.5 ), -D( 3.5 )
   end
 
   def test_plus
-    assert_equal I( 3 + 5 ), I( 3 ) + I( 5 )
+    assert_equal D( 3.5 + 1.5 ), D( 3.5 ) + D( 1.5 )
   end
 
   def test_major
-    assert_equal I( 4 ), I( 3 ).major( I( 4 ) )
-    assert_equal I( 5 ), I( 5 ).major( I( 3 ) )
+    assert_equal D( 4.3 ), D( 3.1 ).major( D( 4.3 ) )
+    assert_equal D( 5.1 ), D( 5.1 ).major( D( 3.5 ) )
   end
 
   def test_minor
-    assert_equal I( 3 ), I( 3 ).minor( I( 4 ) )
-    assert_equal I( 4 ), I( 5 ).minor( I( 4 ) )
+    assert_equal D( 3.1 ), D( 3.1 ).minor( D( 4.3 ) )
+    assert_equal D( 3.5 ), D( 5.1 ).minor( D( 3.5 ) )
   end
 
 end
 
-end
-

data/test/tc_int.rb

@@ -133,11 +133,21 @@ class TC_Int < Test::Unit::TestCase
     assert_equal I( 3 ), I( 3 )
   end
 
+  def test_r_g_b
+    assert_equal I( 3 ), I( 3 ).r
+    assert_equal I( 3 ), I( 3 ).g
+    assert_equal I( 3 ), I( 3 ).b
+  end
+
   def test_inject
     assert_equal 2, I( 2 ).inject { |a,b| a + b }[]
     assert_equal 3, I( 2 ).inject( 1 ) { |a,b| a + b }[]
   end
 
+  def test_collect
+    assert_equal 3, I( 2 ).collect { |x| x + 1 }
+  end
+
   def test_not
     assert !I( 0 ).not[]
     assert !I( 3 ).not[]

data/test/tc_multiarray.rb

@@ -27,6 +27,7 @@ class TC_MultiArray < Test::Unit::TestCase
   B = Hornetseye::BOOL
   I = Hornetseye::INT
   C = Hornetseye::INTRGB
+  X = Hornetseye::DCOMPLEX
   S = Hornetseye::Sequence
   M = Hornetseye::MultiArray
 
@@ -34,6 +35,10 @@ class TC_MultiArray < Test::Unit::TestCase
     Hornetseye::RGB *args
   end
 
+  def X( *args )
+    Complex *args
+  end
+  
   def S( *args )
     Hornetseye::Sequence *args
   end
@@ -58,10 +63,12 @@ class TC_MultiArray < Test::Unit::TestCase
 
   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
   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
@@ -81,17 +88,17 @@ class TC_MultiArray < Test::Unit::TestCase
   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
+    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
@@ -132,6 +139,13 @@ class TC_MultiArray < Test::Unit::TestCase
                       [ 20, 21, 22, 23 ] ] ].inspect
   end
 
+  def test_dup
+    m = M[ [ 1, 2, 3 ], [ 4, 5, 6 ] ]
+    v = m.dup
+    v[ 2, 1 ] = 0
+    assert_equal M[ [ 1, 2, 3 ], [ 4, 5, 6 ] ], m
+  end
+
   def test_typecode
     assert_equal O, M( O, 3, 2 ).new.typecode
     assert_equal I, M( I, 3, 2 ).new.typecode
@@ -153,50 +167,144 @@ class TC_MultiArray < Test::Unit::TestCase
   end
 
   def test_at_assign
-    m = M.new O, 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
-        assert_equal j * 3 + i + 1, m[ i, j ] = j * 3 + i + 1
+    [ M( O, 3, 2 ), M( I, 3, 2 ) ].each do |t|
+      m = t.new
+      for j in 0 ... 2
+        for i in 0 ... 3
+          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
-    end
-    for j in 0 ... 2
-      for i in 0 ... 3
-        assert_equal j * 3 + i + 1, m[ j ][ i ]
-        assert_equal j * 3 + i + 1, m[ i, j ]
+      for j in 0 ... 2
+        for i in 0 ... 3
+          assert_equal j * 3 + i + 1, m[ j ][ i ]
+          assert_equal j * 3 + i + 1, m[ i, j ]
+        end
       end
+      assert_raise( RuntimeError ) { m[ -1 ] }
+      assert_raise( RuntimeError ) { m[ 2 ] }
+      assert_nothing_raised { m[ 0 ] }
+      assert_nothing_raised { m[ 1 ] }
+      assert_raise( RuntimeError ) { m[ -1 ] = 0 }
+      assert_raise( RuntimeError ) { m[ 2 ] = 0 }
+      assert_raise( RuntimeError ) { m[ 3, 1 ] }
+      assert_raise( RuntimeError ) { m[ 3, 1 ]  = 0 }
+      assert_raise( RuntimeError ) { m[ -1, 1 ] }
+      assert_raise( RuntimeError ) { m[ -1, 1 ]  = 0 }
+      assert_raise( RuntimeError ) { m[ 2, -1 ] }
+      assert_raise( RuntimeError ) { m[ 2, -1 ]  = 0 }
+      assert_raise( RuntimeError ) { m[ 2, 2 ] }
+      assert_raise( RuntimeError ) { m[ 2, 2 ]  = 0 }
+      assert_nothing_raised { m[ 0, 0 ] }
+      assert_nothing_raised { m[ 2, 1 ] }
+      assert_raise( RuntimeError ) { m[ 0 ] = m }
+      assert_raise( RuntimeError ) { m[ 0 ] = S[ 0, 1 ] }
+      assert_nothing_raised { m[ 0 ] = 0 }
+      assert_nothing_raised { m[ 1 ] = 0 }
+      assert_nothing_raised { m[ 0 ] = m[ 1 ] }
     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
+    [ M( O, 5, 4 ), M( I, 5, 4 ) ].each do |t|
+      m = t.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
+      assert_raise( RuntimeError ) { m[ 2 .. 4 ] }
+      assert_raise( RuntimeError ) { m[ 2 .. 4 ] = 0 }
+      assert_raise( RuntimeError ) { m[ 2 .. 4 ] = m[ 1 .. 3 ] }
+      assert_raise( RuntimeError ) { m[ 2 .. 3 ] = m[ 1 .. 3 ] }
+      assert_raise( RuntimeError ) { m[ 2 ... 5 ] }
+      assert_raise( RuntimeError ) { m[ 2 ... 5 ] = 0 }
+      assert_raise( RuntimeError ) { m[ 2 ... 5 ] = m[ 1 ... 4 ] }
+      assert_raise( RuntimeError ) { m[ 2 ... 4 ] = m[ 1 ... 4 ] }
+      assert_raise( RuntimeError ) { m[ -1 .. 0 ] }
+      assert_raise( RuntimeError ) { m[ -1 .. 0 ] = 0 }
+      assert_raise( RuntimeError ) { m[ -1 .. 0 ] = m[ 0 .. 1 ] }
+      assert_raise( RuntimeError ) { m[ -1 ... 1 ] }
+      assert_raise( RuntimeError ) { m[ -1 ... 1 ] = 0 }
+      assert_raise( RuntimeError ) { m[ -1 ... 1 ] = m[ 0 ... 2 ] }
+      assert_nothing_raised { m[ 0 .. 3 ] }
+      assert_nothing_raised { m[ 0 .. 3 ] = 0 }
+      assert_nothing_raised { m[ 0 .. 3 ] = m[ 0 .. 3 ] }
+      assert_nothing_raised { m[ 0 ... 4 ] }
+      assert_nothing_raised { m[ 0 ... 4 ] = 0 }
+      assert_nothing_raised { m[ 0 ... 4 ] = m[ 0 ... 4 ] }
+      assert_raise( RuntimeError ) { m[ 1 .. 5, 1 ] }
+      assert_raise( RuntimeError ) { m[ 1 .. 5, 1 ] = 0 }
+      assert_raise( RuntimeError ) { m[ 1 .. 5, 1 ] = m[ 0 .. 4, 1 ] }
+      assert_raise( RuntimeError ) { m[ 1 .. 4, 1 ] = m[ 0 .. 4, 1 ] }
+      assert_raise( RuntimeError ) { m[ 1 ... 6, 1 ] }
+      assert_raise( RuntimeError ) { m[ 1 ... 6, 1 ] = 0 }
+      assert_raise( RuntimeError ) { m[ 1 ... 6, 1 ] = m[ 0 ... 5, 1 ] }
+      assert_raise( RuntimeError ) { m[ 1 ... 5, 1 ] = m[ 0 ... 5, 1 ] }
+      assert_raise( RuntimeError ) { m[ -1 .. 3, 1 ] }
+      assert_raise( RuntimeError ) { m[ -1 .. 3, 1 ] = 0 }
+      assert_raise( RuntimeError ) { m[ -1 .. 3, 1 ] = m[ 0 .. 4, 1 ] }
+      assert_raise( RuntimeError ) { m[ -1 ... 3, 1 ] }
+      assert_raise( RuntimeError ) { m[ -1 ... 3, 1 ] = 0 }
+      assert_raise( RuntimeError ) { m[ -1 ... 3, 1 ] = m[ 0 ... 4, 1 ] }
+      assert_nothing_raised { m[ 0 .. 4, 1 ] }
+      assert_nothing_raised { m[ 0 .. 4, 1 ] = 0 }
+      assert_nothing_raised { m[ 0 .. 4, 1 ] = m[ 0 .. 4, 0 ] }
+      assert_nothing_raised { m[ 0 ... 5, 1 ] }
+      assert_nothing_raised { m[ 0 ... 5, 1 ] = 0 }
+      assert_nothing_raised { m[ 0 ... 5, 1 ] = m[ 0 ... 5, 0 ] }
+      assert_raise( RuntimeError ) { m[ 1, 1 .. 4 ] }
+      assert_raise( RuntimeError ) { m[ 1, 1 .. 4 ] = 0 }
+      assert_raise( RuntimeError ) { m[ 1, 1 .. 4 ] = m[ 1, 0 .. 3 ] }
+      assert_raise( RuntimeError ) { m[ 1, 1 .. 3 ] = m[ 1, 0 .. 3 ] }
+      assert_raise( RuntimeError ) { m[ 1, 1 ... 5 ] }
+      assert_raise( RuntimeError ) { m[ 1, 1 ... 5 ] = 0 }
+      assert_raise( RuntimeError ) { m[ 1, 1 ... 5 ] = m[ 1, 0 ... 4 ] }
+      assert_raise( RuntimeError ) { m[ 1, 1 ... 4 ] = m[ 1, 0 ... 4 ] }
+      assert_raise( RuntimeError ) { m[ 1, -1 .. 2 ] }
+      assert_raise( RuntimeError ) { m[ 1, -1 .. 2 ] = 0 }
+      assert_raise( RuntimeError ) { m[ 1, -1 .. 2 ] = m[ 1, 0 .. 3 ] }
+      assert_raise( RuntimeError ) { m[ 1, -1 ... 2 ] }
+      assert_raise( RuntimeError ) { m[ 1, -1 ... 2 ] = 0 }
+      assert_raise( RuntimeError ) { m[ 1, -1 ... 2 ] = m[ 1, 0 ... 3 ] }
+      assert_nothing_raised { m[ 1, 0 .. 3 ] }
+      assert_nothing_raised { m[ 1, 0 .. 3 ] = 0 }
+      assert_nothing_raised { m[ 1, 0 .. 3 ] = m[ 0, 0 .. 3 ] }
+      assert_nothing_raised { m[ 1, 0 ... 4 ] }
+      assert_nothing_raised { m[ 1, 0 ... 4 ] = 0 }
+      assert_nothing_raised { m[ 1, 0 ... 4 ] = m[ 0, 0 ... 4 ] }
+    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 ]
+      v[] = 0
+      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
     assert_equal [ [ [ 0, 3 ], [ 1, 4 ], [ 2, 5 ] ] ],
@@ -219,11 +327,27 @@ class TC_MultiArray < Test::Unit::TestCase
     assert_not_equal M[ [ 1, 1 ], [ 1, 1 ] ], S[ 1, 1 ]
   end
 
+  def test_r_g_b
+    assert_equal M[ [ 1, 4 ], [ 5, 6 ] ], M[ [ C( 1, 2, 3 ), 4 ], [ 5, 6 ] ].r
+    assert_equal M[ [ 2, 4 ], [ 5, 6 ] ], M[ [ C( 1, 2, 3 ), 4 ], [ 5, 6 ] ].g
+    assert_equal M[ [ 3, 4 ], [ 5, 6 ] ], M[ [ C( 1, 2, 3 ), 4 ], [ 5, 6 ] ].b
+  end
+
+  def test_real_imag
+    assert_equal M[ [ 1, 3 ], [ 4, 5 ] ], M[ [ X( 1, 2 ), 3 ], [ 4, 5 ] ].real
+    assert_equal M[ [ 2, 0 ], [ 0, 0 ] ], M[ [ X( 1, 2 ), 3 ], [ 4, 5 ] ].imag
+  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_collect
+    assert_equal M[ [ 2, 3, 4 ], [ 5, 6, 7 ] ], 
+                 M[ [ 1, 2, 3 ], [ 4, 5, 6 ] ].collect { |x| x + 1 }
+  end
+
   def test_sum
     m = M[ [ 1, 2, 3 ], [ 4, 5, 6 ] ]
     assert_equal 21, sum { |i,j| m[ i, j ] }
@@ -270,6 +394,8 @@ class TC_MultiArray < Test::Unit::TestCase
                  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 )
+    assert_raise( RuntimeError ) { S[ 1, 2, 3 ].convolve f }
+    assert_raise( RuntimeError ) { M[ [ 1, 2, 3 ], [ 4, 5, 6 ] ].convolve S[ 1, 2 ] }
   end
 
   def test_zero
@@ -372,6 +498,28 @@ class TC_MultiArray < Test::Unit::TestCase
     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[ [ 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 ] ],
+                 S[ 1, 2 ] + M[ [ 1, 2, 3 ], [ 4, 5, 6 ] ]
+    assert_raise( RuntimeError ) do
+      M[ [ 1, 2, 3 ], [ 4, 5, 6 ] ] + M[ [ 1, 2 ], [ 3, 4 ] ]
+    end
+    assert_raise( RuntimeError ) do
+      M[ [ 1, 2, 3 ], [ 4, 5, 6 ] ] + M[ [ 1, 2, 3 ] ]
+    end
+    assert_raise( RuntimeError ) do
+      M[ [ 1, 2 ], [ 3, 4 ] ] + M[ [ 1, 2, 3 ], [ 4, 5, 6 ] ] 
+    end
+    assert_raise( RuntimeError ) do
+      M[ [ 1, 2, 3 ] ] + M[ [ 1, 2, 3 ], [ 4, 5, 6 ] ]
+    end
+    assert_raise( RuntimeError ) do
+      M[ [ 1, 2, 3 ], [ 4, 5, 6 ] ] + S[ 1, 2, 3 ]
+    end
+    assert_raise( RuntimeError ) do
+      S[ 1, 2, 3 ] + M[ [ 1, 2, 3 ], [ 4, 5, 6 ] ]
+    end
   end
 
   def test_major
@@ -384,4 +532,32 @@ class TC_MultiArray < Test::Unit::TestCase
                  M[ [ 1, 2 ], [ 3, 4 ] ].minor( M[ [ 4, 1 ], [ 3, 2 ] ] )
   end
 
+  def test_cond
+    assert_equal M[ [ -1, 2 ], [ 3, -4 ] ],
+                 M[ [ false, true ], [ true, false ] ].
+                 conditional( M[ [ 1, 2 ], [ 3, 4 ] ],
+                              M[ [ -1, -2 ], [ -3, -4 ] ] )
+    assert_equal M[ [ -1, -2 ], [ 3, 4 ] ],
+                 S[ false, true ].
+                 conditional( M[ [ 1, 2 ], [ 3, 4 ] ],
+                              M[ [ -1, -2 ], [ -3, -4 ] ] )
+    assert_equal M[ [ -1, -1 ], [ 3, 4 ] ],
+                 S[ false, true ].
+                 conditional( M[ [ 1, 2 ], [ 3, 4 ] ], -1 )
+    assert_equal M[ [ -1, -1 ], [ 3, 4 ] ],
+                 S[ false, true ].
+                 conditional( M[ [ 1, 2 ], [ 3, 4 ] ], S[ -1, -2 ] )
+  end
+
+  def test_cmp
+    assert_equal M[ [ -1, -1 ], [ 0, 1 ] ], M[ [ 1, 2 ], [ 3, 4 ] ] <=> 3
+    assert_equal M[ [ 1, 1 ], [ 0, -1 ] ], 3 <=> M[ [ 1, 2 ], [ 3, 4 ] ]
+  end
+
+  def test_to_type
+    assert_equal M( C, 2, 2 )[ [ 1, 2 ], [ 3, 4 ] ],
+                 M( I, 2, 2 )[ [ 1, 2 ], [ 3, 4 ] ].to_type( C )
+  end
+
+
 end