multiarray 0.5.0 → 0.5.1

data/test/tc_object.rb

@@ -25,6 +25,10 @@ class TC_Object < Test::Unit::TestCase
 
   O = Hornetseye::OBJECT
 
+  def O( *args )
+    Hornetseye::OBJECT *args
+  end
+
   def setup
   end
 
@@ -43,6 +47,12 @@ class TC_Object < Test::Unit::TestCase
     assert_nil O.new[]
   end
 
+  def test_object_indgen
+    assert_equal 0, O.indgen
+    assert_equal 1, O.indgen( 1 )
+    assert_equal 1, O.indgen( 1, 2 )
+  end
+
   def test_object_typecode
     assert_equal O, O.typecode
   end
@@ -55,12 +65,16 @@ class TC_Object < Test::Unit::TestCase
     assert_equal [], O.shape
   end
 
+  def test_object_size
+    assert_equal 1, O.size
+  end
+
   def test_inspect
-    assert_equal 'OBJECT(42)', O.new( 42 ).inspect
+    assert_equal 'OBJECT(42)', O( 42 ).inspect
   end
 
   def test_marshal
-    assert_equal O.new( 42 ), Marshal.load( Marshal.dump( O.new( 42 ) ) )
+    assert_equal O( 42 ), Marshal.load( Marshal.dump( O( 42 ) ) )
   end
 
   def test_typecode
@@ -75,34 +89,38 @@ class TC_Object < Test::Unit::TestCase
     assert_equal [], O.new.shape
   end
 
+  def test_size
+    assert_equal 1, O.new.size
+  end
+
   def test_at_assign
-    o = O.new 3
+    o = O 3
     assert_equal 3, o[]
     assert_equal 42, o[] = 42
     assert_equal 42, o[]
   end
 
   def test_equal
-    assert_not_equal O.new( 3 ), O.new( 4 )
-    assert_equal O.new( 3 ), O.new( 3 )
+    assert_not_equal O( 3 ), O( 4 )
+    assert_equal O( 3 ), O( 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 }[]
+    assert_equal 2, O( 2 ).inject { |a,b| a + b }[]
+    assert_equal 3, O( 2 ).inject( 1 ) { |a,b| a + b }[]
   end
 
   def test_zero
-    assert O.new( 0 ).zero?[]
-    assert !O.new( 3 ).zero?[]
+    assert O( 0 ).zero?[]
+    assert !O( 3 ).zero?[]
   end
 
   def test_negate
-    assert_equal O.new( -5 ), -O.new( 5 )
+    assert_equal O( -5 ), -O( 5 )
   end
 
   def test_plus
-    assert_equal O.new( 3 + 5 ), O.new( 3 ) + O.new( 5 )
+    assert_equal O( 3 + 5 ), O( 3 ) + O( 5 )
   end
 
 end

data/test/tc_rgb.rb

@@ -0,0 +1,217 @@
+# 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_RGB < Test::Unit::TestCase
+
+  BYTERGB   = Hornetseye::BYTERGB
+  UBYTERGB  = Hornetseye::UBYTERGB
+  SINTRGB   = Hornetseye::SINTRGB
+  USINTRGB  = Hornetseye::USINTRGB
+  INTRGB    = Hornetseye::INTRGB
+  UINTRGB   = Hornetseye::UINTRGB
+  LONGRGB   = Hornetseye::LONGRGB
+  ULONGRGB  = Hornetseye::ULONGRGB
+  SFLOATRGB = Hornetseye::SFLOATRGB
+  DFLOATRGB = Hornetseye::DFLOATRGB
+
+  def RGB( *args )
+    Hornetseye::RGB *args
+  end
+
+  def INTRGB( value )
+    Hornetseye::INTRGB value
+  end
+
+  def sum( *args, &action )
+    Hornetseye::sum *args, &action
+  end
+
+  def setup
+  end
+
+  def teardown
+  end
+
+  def test_rgb_inspect
+    assert_equal 'BYTERGB', BYTERGB.inspect
+    assert_equal 'UBYTERGB', UBYTERGB.inspect
+    assert_equal 'SINTRGB', SINTRGB.inspect
+    assert_equal 'USINTRGB', USINTRGB.inspect
+    assert_equal 'INTRGB', INTRGB.inspect
+    assert_equal 'UINTRGB', UINTRGB.inspect
+    assert_equal 'LONGRGB', LONGRGB.inspect
+    assert_equal 'ULONGRGB', ULONGRGB.inspect
+    assert_equal 'SFLOATRGB', SFLOATRGB.inspect
+    assert_equal 'DFLOATRGB', DFLOATRGB.inspect
+  end
+
+  def test_rgb_to_s
+    assert_equal 'BYTERGB', BYTERGB.to_s
+    assert_equal 'UBYTERGB', UBYTERGB.to_s
+    assert_equal 'SINTRGB', SINTRGB.to_s
+    assert_equal 'USINTRGB', USINTRGB.to_s
+    assert_equal 'INTRGB', INTRGB.to_s
+    assert_equal 'UINTRGB', UINTRGB.to_s
+    assert_equal 'LONGRGB', LONGRGB.to_s
+    assert_equal 'ULONGRGB', ULONGRGB.to_s
+    assert_equal 'SFLOATRGB', SFLOATRGB.to_s
+    assert_equal 'DFLOATRGB', DFLOATRGB.to_s
+  end
+
+  def test_rgb_default
+    assert_equal RGB( 0, 0, 0 ), INTRGB.new[]
+  end
+
+  def test_rgb_indgen
+    assert_equal 0, INTRGB.indgen
+    assert_equal RGB( 1, 2, 3 ), INTRGB.indgen( RGB( 1, 2, 3 ) )
+    assert_equal RGB( 1, 2, 3 ), INTRGB.indgen( RGB( 1, 2, 3 ), 1 )
+  end
+
+  def test_rgb_typecode
+    assert_equal BYTERGB, BYTERGB.typecode
+  end
+
+  def test_rgb_dimension
+    assert_equal 0, SFLOATRGB.dimension
+  end
+
+  def test_rgb_shape
+    assert_equal [], SFLOATRGB.shape
+  end
+
+  def test_rgb_size
+    assert_equal 1, SINTRGB.size
+  end
+
+  def test_inspect
+    assert_equal 'RGB(1,2,3)', RGB( 1, 2, 3 ).inspect
+  end
+
+  def test_marshal
+    assert_equal RGB( 1, 2, 3 ), Marshal.load( Marshal.dump( RGB( 1, 2, 3 ) ) )
+  end
+
+  def test_typecode
+    assert_equal INTRGB, INTRGB.new.typecode
+  end
+
+  def test_dimension
+    assert_equal 0, INTRGB.new.dimension
+  end
+
+  def test_shape
+    assert_equal [], INTRGB.new.shape
+  end
+  
+  def test_size
+    assert_equal 1, UBYTERGB.new.size
+  end
+
+  def test_at_assign
+    c = INTRGB RGB( 1, 2, 3 )
+    assert_equal RGB( 1, 2, 3 ), c[]
+    assert_equal RGB( 4, 5, 6 ), c[] = RGB( 4, 5, 6 )
+    assert_equal RGB( 4, 5, 6 ), c[]
+  end
+
+  def test_equal
+    assert_not_equal RGB( 1, 2, 3 ), RGB( 2, 2, 3 )
+    assert_not_equal RGB( 1, 2, 3 ), RGB( 1, 3, 3 )
+    assert_not_equal RGB( 1, 2, 3 ), RGB( 1, 2, 2 )
+    assert_equal RGB( 1, 2, 3 ), RGB( 1, 2, 3 )
+    assert_equal RGB( 3, 3, 3 ), 3
+    assert_not_equal RGB( 3, 3, 3 ), 4
+  end
+
+  def test_inject
+    assert_equal RGB( 1, 2, 3 ), INTRGB( RGB( 1, 2, 3 ) ).
+                 inject { |a,b| a + b }[]
+    assert_equal RGB( 3, 5, 7 ), INTRGB( RGB( 1, 2, 3 ) ).
+                 inject( RGB( 2, 3, 4 ) ) { |a,b| a + b }[]
+  end
+
+  def test_not
+    assert !RGB( 0, 0, 0 ).not
+    assert !RGB( 1, 2, 3 ).not
+  end
+
+  def test_sum
+    assert_equal RGB( 1, 2, 3 ), sum { || RGB 1, 2, 3 }
+  end
+
+  def test_zero
+    assert RGB( 0, 0, 0 ).zero?
+    assert !RGB( 1, 0, 0 ).zero?
+    assert !RGB( 0, 1, 0 ).zero?
+    assert !RGB( 0, 0, 1 ).zero?
+  end
+
+  def test_nonzero
+    assert !RGB( 0, 0, 0 ).nonzero?
+    assert RGB( 1, 0, 0 ).nonzero?
+    assert RGB( 0, 1, 0 ).nonzero?
+    assert RGB( 0, 0, 1 ).nonzero?
+  end
+
+  def test_bitwise_not
+    assert_equal RGB( -2, -3, -4 ), ~RGB( 1, 2, 3 )
+  end
+
+  def test_bitwise_and
+    assert_equal RGB( 1, 2, 1 ), RGB( 1, 2, 3 ) & RGB( 3, 2, 1 )
+    assert_equal RGB( 2, 2, 0 ), 2 & RGB( 3, 2, 1 )
+    assert_equal RGB( 0, 2, 2 ), RGB( 1, 2, 3 ) & 2
+  end
+
+  def test_bitwise_or
+    assert_equal RGB( 3, 2, 3 ), RGB( 1, 2, 3 ) | RGB( 3, 2, 1 )
+  end
+
+  def test_shl
+    assert_equal RGB( 2, 4, 6 ), RGB( 1, 2, 3 ) << 1
+  end
+
+  def test_shr
+    assert_equal RGB( 1, 2, 3 ), RGB( 2, 4, 6 ) >> 1
+  end
+
+  def test_negate
+    assert_equal RGB( -1, -2, -3 ), -RGB( 1, 2, 3 )
+  end
+
+  def test_plus
+    assert_equal RGB( 5, 7, 9 ), RGB( 1, 2, 3 ) + RGB( 4, 5, 6 )
+    assert_equal RGB( 2, 3, 4 ), RGB( 1, 2, 3 ) + 1
+    assert_equal RGB( 2, 3, 4 ), 1 + RGB( 1, 2, 3 )
+  end
+
+  def test_major
+    assert_equal RGB( 4, 3, 3 ), RGB( 1, 2, 3 ).major( RGB( 4, 3, 2 ) )
+  end
+
+  def test_minor
+    assert_equal RGB( 1, 2, 2 ), RGB( 1, 2, 3 ).minor( RGB( 4, 3, 2 ) )
+  end
+
+end

data/test/tc_sequence.rb

@@ -27,10 +27,15 @@ class TC_Sequence < Test::Unit::TestCase
   B = Hornetseye::BOOL
   I = Hornetseye::INT
   S = Hornetseye::Sequence
+  C = Hornetseye::INTRGB
 
   def S( *args )
     Hornetseye::Sequence *args
   end
+
+  def C( *args )
+    Hornetseye::RGB *args
+  end
   
   def sum( *args, &action )
     Hornetseye::sum *args, &action
@@ -51,25 +56,42 @@ class TC_Sequence < Test::Unit::TestCase
   end
 
   def test_sequence_default
-    assert_equal [ O.default ] * 3, S( O, 3 ).default.to_a
+    assert_equal [ nil ] * 3, S( O, 3 ).default.to_a
+    assert_equal [ 0 ] * 3, S( I, 3 ).default.to_a
+    assert_equal [ C( 0, 0, 0 ) ] * 3, S( C, 3 ).default.to_a
   end
 
   def test_sequence_indgen
-    assert_equal [ 0, 1, 2 ], S( O, 3 ).indgen.to_a
-    assert_equal [ 1, 2, 3 ], S( O, 3 ).indgen( 1 ).to_a
-    assert_equal [ 0, 2, 4 ], S( O, 3 ).indgen( 0, 2 ).to_a
-    assert_equal [ 1, 3, 5 ], S( O, 3 ).indgen( 1, 2 ).to_a
+    assert_equal [ 0, 1, 2 ], S( I, 3 ).indgen.to_a
+    assert_equal [ 1, 2, 3 ], S( I, 3 ).indgen( 1 ).to_a
+    assert_equal [ 0, 2, 4 ], S( I, 3 ).indgen( 0, 2 ).to_a
+    assert_equal [ 1, 3, 5 ], S( I, 3 ).indgen( 1, 2 ).to_a
+    assert_equal [ C( 1, 2, 3 ), C( 3, 5, 7 ) ],
+                 S( C, 2 ).indgen( C( 1, 2, 3 ), C( 2, 3, 4 ) ).to_a
   end
 
   def test_sequence_at
+    assert_equal "Sequence(INT,3):\n[ 1, 2, 3 ]",
+                 S( I, 3 )[ 1, 2, 3 ].inspect
+    assert_equal "Sequence(OBJECT,3):\n[ 1, 2, 3 ]",
+                 S( O, 3 )[ 1, 2, 3 ].inspect
+    assert_equal "Sequence(INTRGB,2):\n[ RGB(1,2,3), RGB(4,5,6) ]",
+                 S( C, 2 )[ C( 1, 2, 3 ), C( 4, 5, 6 ) ].inspect
+  end
+
+  def test_sequence_match
     assert_equal [ 1, 2, 3 ], S[ 1, 2, 3 ].to_a
     assert_equal O, S[ :a ].typecode
     assert_equal B, S[ false, true ].typecode
     assert_equal I, S[ -2 ** 31, 2 ** 31 - 1 ].typecode
+    assert_equal C, S[ C( -2 ** 31, 2 ** 31 - 1, 0 ) ].typecode
   end
 
   def test_sequence_typecode
     assert_equal O, S( O, 3 ).typecode
+    assert_equal B, S( B, 3 ).typecode
+    assert_equal I, S( I, 3 ).typecode
+    assert_equal C, S( C, 3 ).typecode
   end
 
   def test_sequence_dimension
@@ -80,29 +102,59 @@ class TC_Sequence < Test::Unit::TestCase
     assert_equal [ 3 ], S( O, 3 ).shape
   end
 
+  def test_sequence_size
+    assert_equal 3, S( O, 3 ).size
+    assert_equal 3, S( C, 3 ).size
+  end
+
   def test_inspect
+    assert_equal "Sequence(OBJECT,0):\n[]", S[].inspect
     assert_equal "Sequence(OBJECT,3):\n[ :a, 2, 3 ]", S[ :a, 2, 3 ].inspect
   end
 
   def test_typecode
     assert_equal O, S.new( O, 3 ).typecode
+    assert_equal I, S.new( I, 3 ).typecode
   end
 
   def test_dimension
     assert_equal 1, S[ 1, 2, 3 ].dimension
+    assert_equal 1, S[ C( 1, 2, 3 ) ].dimension
   end
 
   def test_shape
     assert_equal [ 3 ], S[ 1, 2, 3 ].shape
   end
 
+  def test_size
+    assert_equal 3, S[ 1, 2, 3 ].size
+  end
+
   def test_at_assign
-    s = S.new O, 3
-    for i in 0 ... 3
-      assert_equal i + 1, s[ i ] = i + 1
+    [ S( O, 3 ), S( I, 3 ) ].each do |t|
+      s = t.new
+      for i in 0 ... 3
+        assert_equal i + 1, s[ i ] = i + 1
+      end
+      for i in 0 ... 3
+        assert_equal i + 1, s[ i ]
+      end
     end
-    for i in 0 ... 3
-      assert_equal i + 1, s[ i ]
+  end
+
+  def test_slice
+    [ S( O, 4 ), S( I, 4 ) ].each do |t|
+      s = t.indgen( 1 )[]
+      assert_equal [ 2, 3 ], s[ 1 .. 2 ].to_a
+      assert_equal [ 2, 3 ], s[ 1 ... 3 ].to_a
+      s[ 1 .. 2 ] = 0
+      assert_equal [ 1, 0, 0, 4 ], s.to_a
+      s[ 1 ... 3 ] = 5
+      assert_equal [ 1, 5, 5, 4 ], s.to_a
+      s[ 1 .. 2 ] = S[ 6, 7 ]
+      assert_equal [ 1, 6, 7, 4 ], s.to_a
+      s[ 1 ... 3 ] = S[ 8, 9 ]
+      assert_equal [ 1, 8, 9, 4 ], s.to_a
     end
   end
 
@@ -117,38 +169,74 @@ class TC_Sequence < Test::Unit::TestCase
   def test_inject
     assert_equal 6, S[ 1, 2, 3 ].inject { |a,b| a + b }
     assert_equal 10, S[ 1, 2, 3 ].inject( 4 ) { |a,b| a + b }
+    assert_equal 'abc', S[ 'a', 'b', 'c' ].inject { |a,b| a + b }
+    assert_equal 'abcd', S[ 'b', 'c', 'd' ].inject( 'a' ) { |a,b| a + b }
+    assert_equal C( 3, 5, 8 ), S[ C( 1, 2, 3 ), C( 2, 3, 5 ) ].inject { |a,b| a + b }
+    assert_equal C( 5, 6, 8 ), S[ C( 1, 2, 3 ), C( 2, 3, 5 ) ].
+                               inject( C( 2, 1, 0 ) ) { |a,b| a + b }
   end
 
   def test_sum
-    assert_equal 6, sum { |i| S[ 1, 2, 3 ][ i ] }
-    assert_equal [ 1, 2, 3 ], sum { || S[ 1, 2, 3 ] }.to_a
+    [ S( O, 3 ), S( I, 3 ) ].each do |t|
+      assert_equal 6, sum { |i| t[ 1, 2, 3 ][ i ] }
+      assert_equal [ 1, 2, 3 ], sum { || t[ 1, 2, 3 ] }.to_a
+    end
+    assert_equal C( 3, 5, 8 ), sum { |i| S[ C( 1, 2, 3 ), C( 2, 3, 5 ) ][i] }
   end
 
-  def dont_test_convolve
-    assert_equal S[ 2, 3, 0, 0, 0 ],
-                 S[ 1, 0, 0, 0, 0 ].convolve( S[ 1, 2, 3 ] )
-    assert_equal S[ 1, 2, 3, 0, 0 ],
-                 S[ 0, 1, 0, 0, 0 ].convolve( S[ 1, 2, 3 ] )
-    assert_equal S[ 0, 1, 2, 3, 0 ],
-                 S[ 0, 0, 1, 0, 0 ].convolve( S[ 1, 2, 3 ] )
-    assert_equal S[ 0, 0, 1, 2, 3 ],
-                 S[ 0, 0, 0, 1, 0 ].convolve( S[ 1, 2, 3 ] )
-    assert_equal S[ 0, 0, 0, 1, 2 ],
-                 S[ 0, 0, 0, 0, 1 ].convolve( S[ 1, 2, 3 ] )
-    assert_equal S[ 1, 2, 3, 0 ],
-                 S[ 0, 1, 0, 0 ].convolve( S[ 1, 2, 3 ] )
+  def test_min
+    [ S( O, 3 ), S( I, 3 ) ].each do |t|
+      assert_equal 2, t[ 4, 2, 3 ].min
+    end
+    assert_equal C( 1, 2, 1 ), S[ C( 1, 2, 3 ), C( 3, 2, 1 ) ].min
+  end
+
+  def test_max
+    [ S( O, 3 ), S( I, 3 ) ].each do |t|
+      assert_equal 4, t[ 4, 2, 3 ].max
+    end
+    assert_equal C( 3, 2, 3 ), S[ C( 1, 2, 3 ), C( 3, 2, 1 ) ].max
+  end
+
+  def test_convolve
+    [ O, I ].each do |t|
+      assert_equal S( t, 5 )[ 2, 3, 0, 0, 0 ],
+                   S( t, 5 )[ 1, 0, 0, 0, 0 ].convolve( S( t, 3 )[ 1, 2, 3 ] )
+      assert_equal S( t, 5 )[ 1, 2, 3, 0, 0 ],
+                   S( t, 5 )[ 0, 1, 0, 0, 0 ].convolve( S( t, 3 )[ 1, 2, 3 ] )
+      assert_equal S( t, 5 )[ 0, 1, 2, 3, 0 ],
+                   S( t, 5 )[ 0, 0, 1, 0, 0 ].convolve( S( t, 3 )[ 1, 2, 3 ] )
+      assert_equal S( t, 5 )[ 0, 0, 1, 2, 3 ],
+                   S( t, 5 )[ 0, 0, 0, 1, 0 ].convolve( S( t, 3 )[ 1, 2, 3 ] )
+      assert_equal S( t, 5 )[ 0, 0, 0, 1, 2 ],
+                   S( t, 5 )[ 0, 0, 0, 0, 1 ].convolve( S( t, 3 )[ 1, 2, 3 ] )
+      assert_equal S( t, 4 )[ 1, 2, 3, 0 ],
+                   S( t, 4 )[ 0, 1, 0, 0 ].convolve( S( t, 3 )[ 1, 2, 3 ] )
+    end
+    assert_equal S[ C( 1, 0, 0 ), C( 2, 1, 0 ), C( 3, 2, 1 ), C( 0, 3, 2 ),
+                    C( 0, 0, 3 ) ],
+                 S[ 0, 1, 2, 3, 0 ].
+                 convolve( S[ C( 1, 0, 0 ), C( 0, 1, 0 ), C( 0, 0, 1 ) ] )
   end
 
   def test_zero
-    assert_equal S[ false, true, false ], S[ -1, 0, 1 ].zero?
+    [ S( O, 3 ), S( I, 3 ) ].each do |t|
+      assert_equal [ false, true, false ], t[ -1, 0, 1 ].zero?.to_a
+    end
+    assert_equal S[ false, false, false, true ],
+                 S[ C( 1, 0, 0 ), C( 0, 1, 0 ), C( 0, 0, 1 ), C( 0, 0, 0 ) ].zero?
   end
 
   def test_nonzero
-    assert_equal S[ true, false, true ], S[ -1, 0, 1 ].nonzero?
+    assert_equal S[ true, false, true ], S( I, 3 )[ -1, 0, 1 ].nonzero?
+    assert_equal S[ -1, nil, 1 ], S( O, 3 )[ -1, 0, 1 ].nonzero?
+    assert_equal S[ true, true, true, false ],
+                 S[ C( 1, 0, 0 ), C( 0, 1, 0 ), C( 0, 0, 1 ), C( 0, 0, 0 ) ].nonzero?
   end
 
   def test_not
-    assert_equal [ true, false ], S[ false, true ].not.to_a
+    assert_equal [ true, false ], S( O, 2 )[ false, true ].not.to_a
+    assert_equal [ true, false ], S( B, 2 )[ false, true ].not.to_a
     assert_equal [ true, false, false ], S[ 0, 1, 2 ].not.to_a
   end
 
@@ -171,42 +259,68 @@ class TC_Sequence < Test::Unit::TestCase
   end
 
   def test_bitwise_not
-    assert_equal [ 255, 254, 253 ], ( ~S[ 0, 1, 2 ] ).to_a
-    assert_equal [ 0, -1, -2, -3 ], ( ~S[ -1, 0, 1, 2 ] ).to_a
+    [ S( O, 4 ), S( I, 4 ) ].each do |t|
+      assert_equal [ 0, -1, -2, -3 ], ( ~t[ -1, 0, 1, 2 ] ).to_a
+    end
+    assert_equal [ C( -2, -3, -4 ), C( -5, -6, -7 ) ],
+                 ( ~S( C, 2 )[ C( 1, 2, 3 ), C( 4, 5, 6 ) ] ).to_a
   end
 
   def test_bitwise_and
-    assert_equal [ 0, 1, 0 ], ( S[ 0, 1, 2 ] & 1 ).to_a
-    assert_equal [ 0, 1, 0 ], ( 1 & S[ 0, 1, 2 ] ).to_a
-    assert_equal [ 0, 1, 0, 2 ], ( S[ 0, 1, 2, 3 ] & S[ 4, 3, 1, 2 ] ).to_a
+    [ S( O, 3 ), S( I, 3 ) ].each do |t|
+      assert_equal [ 0, 1, 0 ], ( t[ 0, 1, 2 ] & 1 ).to_a
+      assert_equal [ 0, 1, 0 ], ( 1 & t[ 0, 1, 2 ] ).to_a
+      assert_equal [ 0, 1, 2 ], ( t[ 0, 1, 3 ] & t[ 4, 3, 2 ] ).to_a
+    end
+    assert_equal [ C( 0, 2, 2 ) ], ( S( C, 1 )[ C( 1, 2, 3 ) ] & 2 ).to_a
+    assert_equal [ C( 1, 0, 1 ) ], ( 1 & S( C, 1 )[ C( 1, 2, 3 ) ] ).to_a
+    assert_equal [ C( 1, 2, 1 ) ], ( S( C, 1 )[ C( 1, 2, 3 ) ] & C( 3, 2, 1 ) ).to_a
   end
 
   def test_bitwise_or
-    assert_equal [ 1, 1, 3 ], ( S[ 0, 1, 2 ] | 1 ).to_a
-    assert_equal [ 1, 1, 3 ], ( 1 | S[ 0, 1, 2 ] ).to_a
-    assert_equal [ 4, 3, 3, 3 ], ( S[ 0, 1, 2, 3 ] | S[ 4, 3, 1, 2 ] ).to_a
+    [ S( O, 3 ), S( I, 3 ) ].each do |t|
+      assert_equal [ 1, 1, 3 ], ( t[ 0, 1, 2 ] | 1 ).to_a
+      assert_equal [ 1, 1, 3 ], ( 1 | t[ 0, 1, 2 ] ).to_a
+      assert_equal [ 4, 3, 3 ], ( t[ 0, 1, 2 ] | t[ 4, 3, 1 ] ).to_a
+    end
+    assert_equal [ C( 3, 2, 3 ) ], ( S( C, 1 )[ C( 1, 2, 3 ) ] | 2 ).to_a
+    assert_equal [ C( 1, 3, 3 ) ], ( 1 | S( C, 1 )[ C( 1, 2, 3 ) ] ).to_a
+    assert_equal [ C( 3, 2, 3 ) ], ( S( C, 1 )[ C( 1, 2, 3 ) ] | C( 3, 2, 1 ) ).to_a
   end
 
   def test_bitwise_xor
-    assert_equal [ 1, 0, 3 ], ( S[ 0, 1, 2 ] ^ 1 ).to_a
-    assert_equal [ 1, 0, 3 ], ( 1 ^ S[ 0, 1, 2 ] ).to_a
-    assert_equal [ 4, 2, 3, 1 ], ( S[ 0, 1, 2, 3 ] ^ S[ 4, 3, 1, 2 ] ).to_a
+    [ S( O, 3 ), S( I, 3 ) ].each do |t|
+      assert_equal [ 1, 0, 3 ], ( t[ 0, 1, 2 ] ^ 1 ).to_a
+      assert_equal [ 1, 0, 3 ], ( 1 ^ t[ 0, 1, 2 ] ).to_a
+      assert_equal [ 4, 2, 3 ], ( t[ 0, 1, 2 ] ^ t[ 4, 3, 1 ] ).to_a
+    end
+    assert_equal [ C( 3, 0, 1 ) ], ( S( C, 1 )[ C( 1, 2, 3 ) ] ^ 2 ).to_a
+    assert_equal [ C( 0, 3, 2 ) ], ( 1 ^ S( C, 1 )[ C( 1, 2, 3 ) ] ).to_a
+    assert_equal [ C( 2, 0, 2 ) ], ( S( C, 1 )[ C( 1, 2, 3 ) ] ^ C( 3, 2, 1 ) ).to_a
   end
 
   def test_shl
-    assert_equal [ 2, 4, 6 ], ( S[ 1, 2, 3 ] << 1 ).to_a
-    assert_equal [ 6, 12, 24 ], ( 3 << S[ 1, 2, 3 ] ).to_a
-    assert_equal [ 8, 8, 6 ], ( S[ 1, 2, 3 ] << S[ 3, 2, 1 ] ).to_a
+    [ S( O, 3 ), S( I, 3 ) ].each do |t|
+      assert_equal [ 2, 4, 6 ], ( t[ 1, 2, 3 ] << 1 ).to_a
+      assert_equal [ 6, 12, 24 ], ( 3 << t[ 1, 2, 3 ] ).to_a
+      assert_equal [ 8, 8, 6 ], ( t[ 1, 2, 3 ] << t[ 3, 2, 1 ] ).to_a
+    end
   end
 
   def test_shr
-    assert_equal [ 1, 2, 3 ], ( S[ 2, 4, 6 ] >> 1 ).to_a
-    assert_equal [ 12, 6, 3 ], ( 24 >> S[ 1, 2, 3 ] ).to_a
-    assert_equal [ 2, 1, 3 ], ( S[ 16, 4, 6 ] >> S[ 3, 2, 1 ] ).to_a
+    [ S( O, 3 ), S( I, 3 ) ].each do |t|
+      assert_equal [ 1, 2, 3 ], ( t[ 2, 4, 6 ] >> 1 ).to_a
+      assert_equal [ 12, 6, 3 ], ( 24 >> t[ 1, 2, 3 ] ).to_a
+      assert_equal [ 2, 1, 3 ], ( t[ 16, 4, 6 ] >> t[ 3, 2, 1 ] ).to_a
+    end
   end
 
   def test_negate
-    assert_equal S[ -1, 2, -3 ], -S[ 1, -2, 3 ]
+    [ S( O, 3 ), S( I, 3 ) ].each do |t|
+      assert_equal t[ -1, 2, -3 ], -t[ 1, -2, 3 ]
+    end
+    assert_equal S( C, 2 )[ C( -1, -2, -3 ), C( -2, -1, 0 ) ],
+                 -S( C, 2 )[ C( 1, 2, 3 ), C( 2, 1, 0 ) ]
   end
 
   def test_plus
@@ -216,14 +330,32 @@ class TC_Sequence < Test::Unit::TestCase
     assert_equal S[ 2, 3, 5 ], S[ 1, 2, 4 ] + 1
     assert_equal S[ 2, 3, 5 ], 1 + S[ 1, 2, 4 ]
     assert_equal S[ 2, 3, 5 ], S[ 1, 2, 3 ] + S[ 1, 1, 2 ]
+    assert_equal S[ C( 2, 3, 4 ), C( 5, 6, 7 ) ], S[ C( 1, 2, 3 ), C( 4, 5, 6 ) ] + 1
+    assert_equal S[ C( 2, 3, 4 ), C( 5, 6, 7 ) ], 1 + S[ C( 1, 2, 3 ), C( 4, 5, 6 ) ]
+    assert_equal S[ C( 2, 3, 4 ), C( 3, 4, 5 ) ], S[ 1, 2 ] + C( 1, 2, 3 )
   end
 
-  def test_indgen
-    assert_equal [ 0, 1, 2 ], S( I, 3 ).indgen.to_a
-    assert_equal [ 1, 2, 3 ], ( S( I, 3 ).indgen + 1 ).to_a
-    assert_equal [ 1, 2, 3 ], S( I, 3 ).indgen( 1 ).to_a
-    assert_equal [ 1, 3, 5 ], ( 2 * S( I, 3 ).indgen + 1 ).to_a
-    assert_equal [ 1, 3, 5 ], S( I, 3 ).indgen( 1, 2 ).to_a
+  def test_sqrt
+    assert_equal S( O, 3 )[ 1, 2, 3 ], Math.sqrt( S( O, 3 )[ 1, 4, 9 ] )
+    assert_equal S[ 1.0, 2.0, 3.0 ], Math.sqrt( S[ 1.0, 4.0, 9.0 ] )
+  end
+
+  def test_major
+    assert_equal [ 2, 2, 3 ], S[ 1, 2, 3 ].major( 2 ).to_a
+    assert_equal [ 2, 2, 3 ], 2.major( S[ 1, 2, 3 ] ).to_a
+    assert_equal [ 3, 2, 3 ], S[ 1, 2, 3 ].major( S[ 3, 2, 1 ] ).to_a
+    assert_equal [ C( 2, 2, 3 ) ], S[ C( 1, 2, 3 ) ].major( 2 ).to_a
+  end
+
+  def test_minor
+    assert_equal [ 1, 2, 2 ], S[ 1, 2, 3 ].minor( 2 ).to_a
+    assert_equal [ 1, 2, 2 ], 2.minor( S[ 1, 2, 3 ] ).to_a
+    assert_equal [ 1, 2, 1 ], S[ 1, 2, 3 ].minor( S[ 3, 2, 1 ] ).to_a
+    assert_equal [ C( 1, 2, 2 ) ], S[ C( 1, 2, 3 ) ].minor( 2 ).to_a
+  end
+
+  def test_hypot
+    assert_equal S[ 5.0, 5.0 ], Math.hypot( S[ 3, 4 ], S[ 4, 3 ] )
   end
 
 end