multiarray 0.20.0 → 0.21.0

data/Rakefile

@@ -6,7 +6,7 @@ require 'rake/packagetask'
 require 'rbconfig'
 
 PKG_NAME = 'multiarray'
-PKG_VERSION = '0.20.0'
+PKG_VERSION = '0.21.0'
 RB_FILES = FileList[ 'lib/**/*.rb' ]
 TC_FILES = FileList[ 'test/tc_*.rb' ]
 TS_FILES = FileList[ 'test/ts_*.rb' ]

data/lib/multiarray.rb

@@ -66,6 +66,18 @@ class Proc
 
   end
 
+  # An overloadable while loop
+  #
+  # @param [Proc] action The loop body
+  #
+  # @return [NilClass] Returns +nil+.
+  #
+  # @private
+  def while( &action )
+    action.call while call.get
+    nil
+  end
+
 end
 
 # +Object+ is extended with a few methods
@@ -698,6 +710,7 @@ require 'multiarray/lut'
 require 'multiarray/integral'
 require 'multiarray/mask'
 require 'multiarray/unmask'
+require 'multiarray/components'
 require 'multiarray/operations'
 require 'multiarray/methods'
 require 'multiarray/rgb'
@@ -793,3 +806,4 @@ module Hornetseye
   module_function :sum
 
 end
+

data/lib/multiarray/complex.rb

@@ -98,7 +98,7 @@ module Hornetseye
     # @return [Object] Returns +value+.
     #
     # @private
-    def store( value )
+    def assign( value )
       @real, @imag = value.real, value.imag
     end
 
@@ -862,8 +862,8 @@ module Hornetseye
       if Thread.current[ :function ]
         real = Thread.current[ :function ].variable self.class.element_type, 'v'
         imag = Thread.current[ :function ].variable self.class.element_type, 'v'
-        real.store @value.real
-        imag.store @value.imag
+        real.assign @value.real
+        imag.assign @value.imag
         self.class.new InternalComplex.new( real, imag )
       else
         self.class.new get
@@ -877,15 +877,15 @@ module Hornetseye
     # @return [Object] Returns +value+.
     #
     # @private
-    def store( value )
+    def assign( value )
       value = value.simplify
-      if @value.real.respond_to? :store
-        @value.real.store value.get.real
+      if @value.real.respond_to? :assign
+        @value.real.assign value.get.real
       else
         @value.real = value.get.real
       end
-      if @value.imag.respond_to? :store
-        @value.imag.store value.get.imag
+      if @value.imag.respond_to? :assign
+        @value.imag.assign value.get.imag
       else
         @value.imag = value.get.imag
       end

data/lib/multiarray/components.rb

@@ -0,0 +1,236 @@
+# multiarray - Lazy multi-dimensional arrays for Ruby
+# 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
+# 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/>.
+
+# Namespace of Hornetseye computer vision library
+module Hornetseye
+
+  # Class for representing connected component analysis
+  class Components < Node
+
+    class << self
+
+      # Check whether objects of this class are finalised computations
+      #
+      # @return [Boolean] Returns +false+.
+      #
+      # @private
+      def finalised?
+        false
+      end
+
+    end
+
+    # Constructor
+    #
+    # @param [Node] dest Target array to write component labels to.
+    # @param [Node] source Array to extract components from.
+    # @param [Node] default Value of background pixel.
+    # @param [Node] zero Zero is used to aid compilation.
+    # @param [Node] labels Array to store label correspondences.
+    # @param [Node] rank Array to store number of indirections for each label.
+    # @param [Node] n Pointer to return number of components.
+    def initialize( dest, source, default, zero, labels, rank, n )
+      @dest, @source, @default, @zero, @labels, @rank, @n =
+        dest, source, default, zero, labels, rank, n
+    end
+
+    # Get unique descriptor of this object
+    #
+    # @param [Hash] hash Labels for any variables.
+    #
+    # @return [String] Descriptor of this object,
+    #
+    # @private
+    def descriptor( hash )
+      "Components(#{@dest.descriptor( hash )},#{@source.descriptor( hash )}," +
+        "#{@default.descriptor( hash )},#{@zero.descriptor( hash )}," +
+        "#{@labels.descriptor( hash )},#{@rank.descriptor( hash )}," +
+        "#{@n.descriptor( hash )})"
+    end
+
+    # Get type of result of delayed operation
+    #
+    # @return [Class] Type of result.
+    def array_type
+      retval = @dest.array_type
+      ( class << self; self; end ).instance_eval do
+        define_method( :array_type ) { retval }
+      end
+      retval
+    end
+
+    # Reevaluate computation
+    #
+    # @return [Node,Object] Result of computation
+    #
+    # @see #force
+    #
+    # @private
+    def demand
+      knot [], []
+      @dest
+    end
+
+    # Recursive function to perform connected component labelling
+    #
+    # @param [Array<Proc>] args Array with functions for locating neighbouring elements.
+    # @param [Array<Proc>] comp Array with functions for locating neighbouring labels.
+    #
+    # @private
+    def knot( args, comp )
+      n = @n.simplify
+      if dimension > 0
+        subargs1, subargs2, subargs3 = [], [], []
+        subcomp1, subcomp2, subcomp3 = [], [], []
+        args.each do |arg|
+          subargs1.push proc { |i| arg.element( i - 1 ).demand }
+          subargs2.push proc { |i| arg.element( i     ).demand }
+          subargs3.push proc { |i| arg.element( i + 1 ).demand }
+        end
+        comp.each do |c|
+          subcomp1.push proc { |i| c.element( i - 1 ) }
+          subcomp2.push proc { |i| c.element( i     ) }
+          subcomp3.push proc { |i| c.element( i + 1 ) }
+        end
+        self.class.new( @dest.element( INT.new( 0 ) ),
+                        @source.element( INT.new( 0 ) ).demand, @default, @zero,
+                        @labels, @rank, n ).
+          knot( ( subargs2 + subargs3 ).collect { |p| p.call INT.new( 0 ) },
+                ( subcomp2 + subcomp3 ).collect { |p| p.call INT.new( 0 ) } )
+        INT.new( 1 ).upto INT.new( @source.shape.last ) - 2 do |i|
+          self.class.new( @dest.element( INT.new( i ) ),
+                          @source.element( INT.new( i ) ).demand, @default, @zero,
+                          @labels, @rank, n ).
+            knot( ( subargs1 + subargs2 + subargs3 ).collect { |p| p.call INT.new( i ) } +
+                  [ @source.element( INT.new( i ) - 1 ) ],
+                  ( subcomp1 + subcomp2 + subcomp3 ).collect { |p| p.call INT.new( i ) } +
+                  [ @dest.element( INT.new( i ) - 1 ) ] )
+        end
+        i = @source.shape.last - 1
+        self.class.new( @dest.element( INT.new( i ) ),
+                        @source.element( INT.new( i ) ).demand, @default, @zero,
+                        @labels, @rank, n ).
+          knot( ( subargs1 + subargs2 ).collect { |p| p.call INT.new( i ) } +
+                [ @source.element( INT.new( i ) - 1 ) ],
+                ( subcomp1 + subcomp2 ).collect { |p| p.call INT.new( i ) } +
+                [ @dest.element( INT.new( i ) - 1 ) ] )
+      else
+        @source.ne( @default ).if_else( proc do
+          label = @zero.simplify
+          args.zip( comp ).each do |arg,other|
+            @source.eq( arg ).if do
+              other = other.simplify
+              proc { other.ne( @labels.element( other ).demand ) }.while do
+                other.assign @labels.element( other ).demand
+              end
+              label.eq( @zero ).if_else( proc do
+                label.assign other
+              end, proc do
+                label.ne( other ).if do
+                  ( @rank.element( label ).demand <= @rank.element( other ).demand ).if_else( proc do
+                    @labels[ other ] = label
+                    @rank.element( label ).demand.eq( @rank.element( other ).demand ).if do
+                      @rank[ label ] = @rank.element( other ).demand + 1
+                    end
+                  end, proc do
+                    @labels[ label ] = other
+                    label.assign other
+                  end )
+                end
+              end )
+            end
+          end
+          label.eq( @zero ).if do
+            n.assign n + 1
+            @labels[ n ] = n
+            @rank[ n ] = 0
+            label.assign n
+          end
+          @dest.store label
+        end, proc do
+          @dest.store INT.new( 0 )
+        end )
+      end
+      if @n.is_a? Pointer_
+        INT.new( 0 ).upto n do |i|
+          l = UINT.new( i ).simplify
+          proc { l.ne( @labels.element( l ).demand ) }.while do
+            l.assign @labels.element( l ).demand
+          end
+          @labels[ INT.new( i ) ] = l
+        end
+        @n.store n
+      else
+        @n.assign n
+      end
+    end
+
+    # Substitute variables
+    #
+    # Substitute the variables with the values given in the hash.
+    #
+    # @param [Hash] hash Substitutions to apply.
+    #
+    # @return [Node] Term with substitutions applied.
+    #
+    # @private
+    def subst( hash )
+      self.class.new @dest.subst( hash ), @source.subst( hash ), @default.subst( hash ),
+        @zero.subst( hash ), @labels.subst( hash ), @rank.subst( hash ), @n.subst( hash )
+    end
+
+    # Get variables contained in this term
+    #
+    # @return [Set] Returns list of variables.
+    #
+    # @private
+    def variables
+      @dest.variables + @source.variables + @default.variables + @zero.variables +
+        @labels.variables + @rank.variables + @n.variables
+    end
+
+    # Strip of all values
+    #
+    # Split up into variables, values, and a term where all values have been
+    # replaced with variables.
+    #
+    # @return [Array<Array,Node>] Returns an array of variables, an array of
+    # values, and the term based on variables.
+    #
+    # @private
+    def strip
+      stripped = [ @dest, @source, @default, @zero, @labels, @rank, @n ].
+        collect { |value| value.strip }
+      return stripped.inject( [] ) { |vars,elem| vars + elem[ 0 ] },
+        stripped.inject( [] ) { |values,elem| values + elem[ 1 ] },
+        self.class.new( *stripped.collect { |elem| elem[ 2 ] } )
+    end
+
+    # Get variables contained in this term
+    #
+    # @return [Set] Returns list of variables.
+    #
+    # @private
+    def compilable?
+      [ @dest, @source, @default, @zero, @labels, @rank, @n ].all? do |value|
+        value.compilable?
+      end
+    end
+
+  end
+
+end
+

data/lib/multiarray/diagonal.rb

@@ -106,7 +106,7 @@ module Hornetseye
       j0.upto( ( @index2.size - 1 ).minor( @index0 + s1 ) ) do |j|
         i = @index0.get + s1.get - j
         sub = @value.subst @index1 => INT.new( i ), @index2 => INT.new( j ) 
-        retval.store @block.subst( @var1 => retval, @var2 => sub )
+        retval.assign @block.subst( @var1 => retval, @var2 => sub )
       end
       retval
     end

data/lib/multiarray/element.rb

@@ -93,7 +93,7 @@ module Hornetseye
     def dup
       if Thread.current[ :function ]
         value = Thread.current[ :function ].variable self.class, 'v'
-        value.store get
+        value.assign get
         self.class.new value
       else
         self.class.new get
@@ -155,9 +155,9 @@ module Hornetseye
     # @return [Object] Returns +value+.
     #
     # @private
-    def store( value )
-      if @value.respond_to? :store
-        @value.store value.simplify.get
+    def assign( value )
+      if @value.respond_to? :assign
+        @value.assign value.simplify.get
       else
         @value = value.simplify.get
       end

data/lib/multiarray/gccfunction.rb

@@ -196,3 +196,32 @@ module Hornetseye
   end
   
 end
+
+class Proc
+
+  # Overloaded while loop for handling compilation
+  #
+  # @param [Proc] action The loop body
+  #
+  # @return [NilClass] Returns +nil+.
+  #
+  # @private
+  def while_with_gcc( &action )
+    function = Thread.current[ :function ]
+    if function
+      function << "#{function.indent}while ( 1 ) {\n"
+      function.indent_offset +1
+      function << "#{function.indent}if ( !( #{call.get}) ) break;\n"
+      action.call
+      function.indent_offset -1
+      function << "#{function.indent}}\n"
+      nil
+    else
+      while_without_gcc &action
+    end
+  end
+
+  alias_method_chain :while, :gcc
+
+end
+

data/lib/multiarray/gccvalue.rb

@@ -163,7 +163,7 @@ module Hornetseye
     # @return [Object] Returns +value+.
     #
     # @private
-    def store( value )
+    def assign( value )
       @function << "#{@function.indent}#{self} = #{value};\n"
       value
     end
@@ -370,7 +370,6 @@ module Hornetseye
       self
     end
 
-
     define_unary_op :not, '!'
     define_unary_op :~
     define_unary_op :-@, :-

data/lib/multiarray/inject.rb

@@ -96,7 +96,7 @@ module Hornetseye
       end
       offset.upto @index.size - 1 do |i|
         sub = @value.subst @index => INT.new( i )
-        retval.store @block.subst( @var1 => retval, @var2 => sub )
+        retval.assign @block.subst( @var1 => retval, @var2 => sub )
       end
       retval
     end
@@ -109,7 +109,7 @@ module Hornetseye
     #
     # @private
     def element( i )
-      Inject.new @value.element( i ), @index, @initial, @block, @var1, @var2
+      self.class.new @value.element( i ), @index, @initial, @block, @var1, @var2
     end
 
     # Get variables contained in this term
@@ -142,7 +142,7 @@ module Hornetseye
       vars3, values3, term3 = @block.strip
       return vars1 + vars2 + vars3 + meta_vars,
         values1 + values2 + values3 + meta_values,
-        Inject.new( term1, var, term2, term3, @var1, @var2 )
+        self.class.new( term1, var, term2, term3, @var1, @var2 )
     end
  
     # Substitute variables
@@ -159,7 +159,7 @@ module Hornetseye
       value = @value.subst( @index => subst_var ).subst hash
       initial = @initial ? @initial.subst( hash ) : nil
       block = @block.subst hash
-      Inject.new value, subst_var, initial, block, @var1, @var2
+      self.class.new value, subst_var, initial, block, @var1, @var2
     end
 
     # Check whether this term is compilable

data/lib/multiarray/mask.rb

@@ -81,12 +81,16 @@ module Hornetseye
             Mask.new( @dest, source, m, index ).demand
           end  
         else
-          @m.simplify.get.if do
+          @m.if do
             Store.new( @dest.element( index ), @source ).demand
-            index.store index + 1
+            index.assign index + 1
           end
         end
-        @index.store index
+        if @index.is_a? Pointer_
+          @index.store index
+        else
+          @index.assign index
+        end
         @dest
       else
         super

data/lib/multiarray/operations.rb

@@ -213,6 +213,34 @@ module Hornetseye
       end
     end
 
+    # Generate code for memory allocation
+    #
+    # @return [GCCValue] C value referring to result.
+    #
+    # @private
+    def malloc
+      get.malloc 
+    end
+
+    # Conditional operation
+    #
+    # @param [Proc] action Action to perform if condition is +true+.
+    #
+    # @return [Object] The return value should be ignored.
+    def if( &action )
+      simplify.get.if &action
+    end
+
+    # Conditional operation
+    #
+    # @param [Proc] action1 Action to perform if condition is +true+.
+    # @param [Proc] action2 Action to perform if condition is +false+.
+    #
+    # @return [Object] The return value should be ignored.
+    def if_else( action1, action2 )
+      simplify.get.if_else action1, action2
+    end
+
     # Element-wise comparison of values
     #
     # @param [Node] other Array with values to compare with.
@@ -390,6 +418,13 @@ module Hornetseye
       min( initial ? initial.min : nil ) .. max( initial ? initial.max : nil )
     end
 
+    # Check values against boundaries
+    #
+    # @return [Node] Boolean array with result.
+    def between?( a, b )
+      Hornetseye::lazy { ( self >= a ).and self <= b }.force
+    end
+
     # Normalise values of array
     #
     # @param [Range] range Target range of normalisation.
@@ -621,12 +656,12 @@ module Hornetseye
     # @return [Node] The histogram.
     def histogram( *ret_shape )
       options = ret_shape.last.is_a?( Hash ) ? ret_shape.pop : {}
-      options = { :weight => UINT. new( 1 ), :safe => true }.merge options
+      options = { :weight => UINT.new( 1 ), :safe => true }.merge options
       unless options[ :weight ].is_a? Node
         options[ :weight ] =
           Node.match( options[ :weight ] ).maxint.new options[ :weight ]
       end
-      if shape.first != 1 and ret_shape.size == 1
+      if ( shape.first != 1 or dimension == 1 ) and ret_shape.size == 1
         [ self ].histogram *( ret_shape + [ options ] )
       else
         ( 0 ... shape.first ).collect { |i| unroll[i] }.
@@ -642,7 +677,7 @@ module Hornetseye
     #
     # @return [Node] The result of the lookup operation.
     def lut( table, options = {} )
-      if shape.first != 1 and table.dimension == 1
+      if ( shape.first != 1 or dimension == 1 ) and table.dimension == 1
         [ self ].lut table, options
       else
         ( 0 ... shape.first ).collect { |i| unroll[i] }.lut table, options
@@ -690,6 +725,35 @@ module Hornetseye
       left
     end
 
+    # Perform connected component labelling
+    #
+    # @option options [Object] :default (typecode.default) Value of background elements.
+    # @option options [Class] :target (UINT) Typecode of labels.
+    #
+    # @return [Node] Array with labels of connected components.
+    def components( options = {} )
+      if shape.any? { |x| x <= 1 }
+        raise "Every dimension must be greater than 1 (shape was #{shape})"
+      end
+      options = { :target => UINT, :default => typecode.default }.merge options
+      target = options[ :target ]
+      default = options[ :default ]
+      default = typecode.new default unless default.is_a? Node
+      left = Hornetseye::MultiArray( target, *shape ).new
+      labels = Sequence.new target, size; labels[0] = 0
+      rank = Sequence.uint size; rank[0] = 0
+      n = Hornetseye::Pointer( INT ).new; n.store INT.new( 0 )
+      block = Components.new left, self, default, target.new( 0 ), labels, rank, n
+      if block.compilable?
+        Hornetseye::GCCFunction.run block
+      else
+        block.demand
+      end
+      labels = labels[ 0 .. n.demand.get ]
+      left.lut labels.lut( labels.histogram( labels.size, :weight => target.new( 1 ) ).
+                           minor( 1 ).integral - 1 )
+    end
+
     # Select values from array using a mask
     #
     # @param [Node] m Mask to apply to this array.

data/lib/multiarray/pointer.rb

@@ -184,6 +184,22 @@ module Hornetseye
       "#{self.class.to_s}(#{@value.to_s})"
     end
 
+    # Store a value in this native element
+    #
+    # @param [Object] value New value for native element.
+    #
+    # @return [Object] Returns +value+.
+    #
+    # @private
+    def assign( value )
+      if @value.respond_to? :assign
+        @value.assign value.simplify.get
+      else
+        @value = value.simplify.get
+      end
+      value
+    end
+
     # Store new value in this pointer
     #
     # @param [Object] value New value for this pointer object.

data/lib/multiarray/rgb.rb

@@ -125,7 +125,7 @@ module Hornetseye
     # @return [Object] Returns +value+.
     #
     # @private
-    def store( value )
+    def assign( value )
       @r, @g, @b = value.r, value.g, value.b
     end
 
@@ -407,9 +407,9 @@ 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.store @value.r
-        g.store @value.g
-        b.store @value.b
+        r.assign @value.r
+        g.assign @value.g
+        b.assign @value.b
         self.class.new RGB.new( r, g, b )
       else
         self.class.new get
@@ -423,20 +423,20 @@ module Hornetseye
     # @return [Object] Returns +value+.
     #
     # @private
-    def store( value )
+    def assign( value )
       value = value.simplify
-      if @value.r.respond_to? :store
-        @value.r.store value.get.r
+      if @value.r.respond_to? :assign
+        @value.r.assign value.get.r
       else
         @value.r = value.get.r
       end
-      if @value.g.respond_to? :store
-        @value.g.store value.get.g
+      if @value.g.respond_to? :assign
+        @value.g.assign value.get.g
       else
         @value.g = value.get.g
       end
-      if @value.b.respond_to? :store
-        @value.b.store value.get.b
+      if @value.b.respond_to? :assign
+        @value.b.assign value.get.b
       else
         @value.b = value.get.b
       end
@@ -935,3 +935,19 @@ class Fixnum
 
 end
 
+module Math
+
+  def sqrt_with_rgb( c )
+    if c.is_a? Hornetseye::RGB
+      Hornetseye::RGB.new sqrt( c.r ), sqrt( c.g ), sqrt( c.b )
+    else
+      sqrt_without_rgb c
+    end
+  end
+
+  alias_method_chain :sqrt, :rgb
+  module_function :sqrt_without_rgb
+  module_function :sqrt
+
+end
+

data/lib/multiarray/store.rb

@@ -65,8 +65,10 @@ module Hornetseye
                                               @source.element( INT.new( i ) )
             Store.new( dest, source ).demand
           end  
-        else
+        elsif @dest.class < Pointer_
           @dest.store @source.demand
+        else
+          @dest.assign @source.demand
         end
         @dest
       else

data/lib/multiarray/unmask.rb

@@ -84,14 +84,18 @@ module Hornetseye
             Unmask.new( dest, @source, m, index, default ).demand
           end  
         else
-          @m.simplify.get.if_else( proc do
+          @m.if_else( proc do
             Store.new( @dest, @source.element( index ) ).demand
-            index.store index + 1
+            index.assign index + 1
           end, proc do
             Store.new( @dest, @default ).demand
           end )
         end
-        @index.store index
+        if @index.is_a? Pointer_
+          @index.store index
+        else
+          @index.assign index
+        end
         @dest
       else
         super

data/test/tc_multiarray.rb

@@ -731,6 +731,11 @@ class TC_MultiArray < Test::Unit::TestCase
                  M( I, 3, 2 )[ [ 1, 2, 3 ], [ 4, 5, 6 ] ].integral
   end
 
+  def test_components
+    assert_equal [ [ 1, 0, 2 ], [ 0, 0, 2 ], [ 2, 2, 2 ] ],
+                 M[ [ 1, 0, 1 ], [ 0, 0, 1 ], [ 1, 1, 1 ] ].components.to_a
+  end
+
   def test_mask
     [ O, I ].each do |t|
       assert_equal M( O, 2, 2 )[ [ 1, 2 ], [ 5, 7 ] ],

data/test/tc_sequence.rb

@@ -334,6 +334,10 @@ class TC_Sequence < Test::Unit::TestCase
     assert_equal C( 3, 2, 3 ), S[ C( 1, 2, 3 ), C( 3, 2, 1 ) ].max
   end
 
+  def test_between
+    assert_equal S[ false, true, true, false ], S[ 1, 2, 3, 4 ].between?( 2, 3 )
+  end
+
   def test_normalise
     assert_equal [ 0.0, 85.0, 255.0 ], S[ 1, 2, 4 ].normalise.to_a
     assert_equal [ C( 0.0, 85.0, 255.0 ) ], S[ C( 1, 2, 4 ) ].normalise.to_a
@@ -713,6 +717,12 @@ class TC_Sequence < Test::Unit::TestCase
       assert_in_delta x.real, y.real, 1.0e-5
       assert_in_delta x.imag, y.imag, 1.0e-5
     end
+    [ Math.sqrt( C( 1, 2, 3 ) ), Math.sqrt( C( 2, 4, 6 ) ) ].
+      zip( Math.sqrt( S[ C( 1, 2, 3 ), C( 2, 4, 6 ) ] ).to_a ).each do |x,y|
+      assert_in_delta x.r, y.r, 1.0e-5
+      assert_in_delta x.g, y.g, 1.0e-5
+      assert_in_delta x.b, y.b, 1.0e-5
+    end
   end
 
   def test_exp
@@ -928,6 +938,11 @@ class TC_Sequence < Test::Unit::TestCase
     assert_equal S( I, 3 )[ 1, 3, 6 ], S( I, 3 )[ 1, 2, 3 ].integral
   end
 
+  def test_components
+    assert_equal [ 0, 1, 1, 0, 2 ], S[ 0, 1, 1, 0, 1 ].components.to_a
+    assert_equal [ 0, 1, 1, 0, 2 ], S[ nil, 1, 1, nil, 1 ].components.to_a
+  end
+
   def test_mask
     assert_equal S( O, 2 )[ 2, 5 ], S( O, 3 )[ 2, 3, 5 ].
                  mask( S[ true, false, true ] )

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 20
+  - 21
   - 0
-  version: 0.20.0
+  version: 0.21.0
 platform: ruby
 authors: 
 - Jan Wedekind
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-01-26 00:00:00 +00:00
+date: 2011-02-27 00:00:00 +00:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -66,6 +66,7 @@ files:
 - lib/multiarray/gcccontext.rb
 - lib/multiarray/unmask.rb
 - lib/multiarray/elementwise.rb
+- lib/multiarray/components.rb
 - lib/multiarray/diagonal.rb
 - lib/multiarray/index.rb
 - lib/multiarray/variable.rb