multiarray 0.11.4 → 0.12.0

data/Rakefile

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

data/lib/multiarray.rb

@@ -523,7 +523,7 @@ class Numeric
 
 end
 
-# The +Array+ class is extended
+# The +Array+ class is extended with a few methods
 class Array
 
   # Element-wise operation based on element and its index

data/lib/multiarray/gccfunction.rb

@@ -56,9 +56,7 @@ module Hornetseye
             function = GCCFunction.new context, method_name,
                                        *keys.collect { |var| var.meta }
             Thread.current[ :function ] = function
-            term_subst = ( 0 ... keys.size ).collect do |i|
-              { keys[i] => function.param( i ) }
-            end.inject( {} ) { |a,b| a.merge b }
+            term_subst = Hash[ *keys.zip( function.params ).flatten ]
             Hornetseye::lazy do
               term.subst( term_subst ).demand
             end
@@ -144,20 +142,21 @@ module Hornetseye
       @indent += offset
     end
 
-    # Retrieve a parameter
+    # Retrieve all parameters
     #
-    # @param [Integer] i Parameter to retrieve.
-    #
-    # @return [Node] Object for handling the parameter.
+    # @return [Array<Node>] Objects for handling the parameters.
     #
     # @private
-    def param( i )
-      offset = ( 0 ... i ).inject( 0 ) do |s,idx|
-        s + GCCType.new( @param_types[ idx ] ).identifiers.size
+    def params
+      idx = 0
+      @param_types.collect do |param_type|
+        args = GCCType.new( param_type ).identifiers.collect do
+          arg = GCCValue.new self, "param#{idx}"
+          idx += 1
+          arg
+        end
+        param_type.construct *args
       end
-      args = ( 0 ... GCCType.new( @param_types[ i ] ).identifiers.size ).
-        collect { |idx| GCCValue.new self, "param#{ offset + idx }" }
-      @param_types[ i ].construct *args
     end
 
     # Call the native method

data/lib/multiarray/histogram.rb

@@ -36,11 +36,11 @@ module Hornetseye
     # Constructor
     #
     # @param [Node] dest Target array to write histogram to.
-    # @param [Node] source Expression to compute histogram of.
+    # @param [Array<Node>] sources Arrays with elements to compute histogram of.
     #
     # @private
-    def initialize( dest, source )
-      @dest, @source = dest, source
+    def initialize( dest, *sources )
+      @dest, @sources = dest, sources
     end
 
     # Get unique descriptor of this object
@@ -51,7 +51,8 @@ module Hornetseye
     #
     # @private
     def descriptor( hash )
-      "Histogram(#{@dest.descriptor( hash )},#{@source.descriptor( hash )})"
+      "Histogram(#{@dest.descriptor( hash )}," +
+        "#{@sources.collect { |source| source.descriptor( hash ) }.join ','})"
     end
 
     # Get type of result of delayed operation
@@ -76,15 +77,19 @@ module Hornetseye
     # @private
     def demand
       if variables.empty?
-        if @source.dimension > 1
-          @source.shape.last.times do |i|
-            source = @source.element INT.new( i )
-            Histogram.new( @dest, source ).demand
+        if @sources.any? { |source| source.dimension > 0 }
+          source_type = @sources.collect { |source| source.array_type }.
+            inject { |a,b| a.coercion b }
+          source_type.shape.last.times do |i|
+            sources = @sources.collect do |source|
+              source.dimension > 0 ? source.element( INT.new( i ) ) : source
+            end
+            Histogram.new( @dest, *sources ).demand
           end
         else
           dest = @dest
           ( @dest.dimension - 1 ).downto( 0 ) do |i|
-            dest = dest.element @source.element( INT.new( i ) ).demand
+            dest = dest.element @sources[ i ].demand
           end
           dest.store dest + 1
         end
@@ -104,7 +109,8 @@ module Hornetseye
     #
     # @private
     def subst( hash )
-      self.class.new @dest.subst( hash ), @source.subst( hash )
+      self.class.new @dest.subst( hash ),
+                     *@sources.collect { |source| source.subst hash }
     end
 
     # Get variables contained in this term
@@ -113,7 +119,7 @@ module Hornetseye
     #
     # @private
     def variables
-      @dest.variables + @source.variables
+      @sources.inject( @dest.variables ) { |a,b| a + b.variables }
     end
 
     # Strip of all values
@@ -126,9 +132,10 @@ module Hornetseye
     #
     # @private
     def strip
-      vars1, values1, term1 = @dest.strip
-      vars2, values2, term2 = @source.strip
-      return vars1 + vars2, values1 + values2, self.class.new( term1, term2 )
+      stripped = ( [ @dest ] + @sources ).collect { |source| source.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
 
     # Check whether this term is compilable
@@ -137,7 +144,7 @@ module Hornetseye
     #
     # @private
     def compilable?
-      @dest.compilable? and @source.compilable?
+      @dest.compilable? and @sources.all? { |source| source.compilable? }
     end
 
   end

data/lib/multiarray/lut.rb

@@ -35,14 +35,13 @@ module Hornetseye
 
     # Constructor
     #
-    # @param [Node] dest Target array to write histogram to.
-    # @param [Node] source Expression to compute histogram of.
-    # @param [Integer] n Number of dimensions of lookup.
+    # @overload initialize( *sources, table )
+    #   @param [Array<Node>] sources Arrays with elements for lookup
+    #   @param [Node] table Lookup table
     #
     # @private
-    def initialize( source, table, n = nil )
-      @source, @table = source, table
-      @n = n || @source.shape.first
+    def initialize( *args )
+      @sources, @table = args[ 0 ... -1 ], args.last
     end
 
     # Get unique descriptor of this object
@@ -53,7 +52,8 @@ module Hornetseye
     #
     # @private
     def descriptor( hash )
-      "Lut(#{@source.descriptor( hash )},#{@table.descriptor( hash )},#{@n})"
+      "Lut(#{@sources.collect { |source| source.descriptor( hash ) }.join ','}," +
+        "#{@table.descriptor( hash )})"
     end
 
     # Get type of result of delayed operation
@@ -62,7 +62,10 @@ module Hornetseye
     #
     # @private
     def array_type
-      shape = @table.shape.first( @table.dimension - @n ) + @source.shape[ 1 .. -1 ]
+      source_type = @sources.collect { |source| source.array_type }.
+        inject { |a,b| a.coercion b }
+      shape = @table.shape.first( @table.dimension - @sources.size ) +
+        source_type.shape
       retval = Hornetseye::MultiArray @table.typecode, *shape
       ( class << self; self; end ).instance_eval do
         define_method( :array_type ) { retval }
@@ -78,7 +81,7 @@ module Hornetseye
     #
     # @private
     def demand
-      @source.lut @table, :n => @n, :safe => false
+      @sources.lut @table, :safe => false
     end
 
     # Substitute variables
@@ -91,7 +94,8 @@ module Hornetseye
     #
     # @private
     def subst( hash )
-      self.class.new @source.subst( hash ), @table.subst( hash ), @n
+      self.class.new *( @sources.collect { |source| source.subst hash } +
+                        [ @table.subst( hash ) ] )
     end
 
     # Get variables contained in this term
@@ -100,7 +104,7 @@ module Hornetseye
     #
     # @private
     def variables
-      @source.variables + @table.variables
+      @sources.inject( @table.variables ) { |a,b| a + b.variables }
     end
 
     # Strip of all values
@@ -113,9 +117,10 @@ module Hornetseye
     #
     # @private
     def strip
-      vars1, values1, term1 = @source.strip
-      vars2, values2, term2 = @table.strip
-      return vars1 + vars2, values1 + values2, self.class.new( term1, term2, @n )
+      stripped = ( @sources + [ @table ] ).collect { |source| source.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
 
     # Skip elements of an array
@@ -128,7 +133,8 @@ module Hornetseye
     #
     # @private
     def skip( index, start )
-      self.class.new @source.skip( index, start ), @table.skip( index, start ), @n
+      self.class.new *( @sources.skip( index, start ) +
+                        [ @table.skip( index, start ) ] )
     end
 
     # Get element of unary operation
@@ -139,12 +145,14 @@ module Hornetseye
     #
     # @private
     def element( i )
-      source, table = @source, @table
-      if source.dimension > 1
-        source = source.element i
-        self.class.new source, table, @n
-      elsif table.dimension > @n
-        self.class.new source, table.unroll( @n ).element( i ).roll( @n ), @n
+      sources, table = @sources, @table
+      if sources.any? { |source| source.dimension > 0 }
+        sources = sources.
+          collect { |source| source.dimension > 0 ? source.element( i ) : source }
+        self.class.new *( sources + [ table ] )
+      elsif table.dimension > sources.size
+        n = sources.size
+        self.class.new *( sources + [ table.unroll( n ).element( i ).roll( n ) ] )
       else
         super i
       end
@@ -178,7 +186,7 @@ module Hornetseye
     #
     # @return [Node] Result of decomposition.
     def decompose( i )
-      self.class.new @source, @table.decompose( i ), @n
+      self.class.new *( @sources + [ @table.decompose( i ) ] )
     end
 
     # Check whether this term is compilable
@@ -187,7 +195,7 @@ module Hornetseye
     #
     # @private
     def compilable?
-      @source.compilable? and @table.compilable?
+      @sources.all? { |source| source.compilable? } and @table.compilable?
     end
 
   end

data/lib/multiarray/node.rb

@@ -308,6 +308,31 @@ module Hornetseye
         hash[ self ] || self
       end
 
+      # Check arguments for compatible shape
+      #
+      # The method will throw an exception if one of the arguments has an incompatible
+      # shape.
+      #
+      # @param [Array<Class>] args Arguments to check for compatibility.
+      #
+      # @return [Object] The return value should be ignored.
+      def check_shape( *args )
+        _shape = shape
+        args.each do |arg|
+          _arg_shape = arg.shape
+          if _shape.size < _arg_shape.size
+            raise "#{arg.inspect} has #{arg.dimension} dimension(s) " +
+                  "but should not have more than #{dimension}"
+          end
+          if ( _shape + _arg_shape ).all? { |s| s.is_a? Integer }
+            if _shape.last( _arg_shape.size ) != _arg_shape
+              raise "#{arg.inspect} has shape #{arg.shape.inspect} " +
+                    "(does not match last value(s) of #{shape.inspect})"
+            end
+          end
+        end
+      end
+
       # Check whether this term is compilable
       #
       # @return [Boolean] Returns +true+.
@@ -595,22 +620,10 @@ module Hornetseye
     #
     # @return [Object] The return value should be ignored.
     def check_shape( *args )
-      _shape = shape
-      args.each do |arg|
-        _arg_shape = arg.shape
-        if _shape.size < _arg_shape.size
-          raise "#{arg.array_type.inspect} has #{arg.dimension} dimension(s) " +
-                "but should not have more than #{dimension}"
-        end
-        if ( _shape + _arg_shape ).all? { |s| s.is_a? Integer }
-          if _shape.last( _arg_shape.size ) != _arg_shape
-            raise "#{arg.array_type.inspect} has shape #{arg.shape.inspect} " +
-                  "(does not match last value(s) of #{shape.inspect})"
-          end
-        end
-      end
+      array_type.check_shape *args.collect { |arg| arg.array_type }
     end
 
+
     # Assign value to array element(s)
     # 
     # @overload []=( *indices, value )

data/lib/multiarray/operations.rb

@@ -121,7 +121,7 @@ module Hornetseye
     def to_type( dest )
       if dimension == 0 and variables.empty?
         target = typecode.to_type dest
-        target.new simplify.get
+        target.new( simplify.get ).simplify
       else
         key = "to_#{dest.to_s.downcase}"
         Hornetseye::ElementWise( lambda { |x| x.to_type dest }, key,
@@ -456,6 +456,7 @@ module Hornetseye
     #
     # @overload histogram( *ret_shape, options = {} )
     #   @param [Array<Integer>] ret_shape Dimensions of resulting histogram.
+    #   @option options [Class] :target (UINT) Element-type of resulting histogram.
     #   @option options [Boolean] :safe (true) Do a boundary check before creating the
     #           histogram.
     #
@@ -463,41 +464,12 @@ module Hornetseye
     def histogram( *ret_shape )
       options = ret_shape.last.is_a?( Hash ) ? ret_shape.pop : {}
       options = { :target => UINT, :safe => true }.merge options
-      if options[ :safe ]
-        if shape.first != 1 and ret_shape.size == 1
-          right = Hornetseye::lazy( 1 ) { self }.unroll
-        else
-          if shape.first != ret_shape.size
-            raise "First dimension of array (#{shape.first}) differs from number of " +
-                  "dimensions of histogram (#{ret_shape.size})"
-          end
-          right = self
-        end
-      else
-        right = self
-      end
-      if options[ :safe ]
-        for i in 0 ... right.shape.first
-          range = right.roll[ i ].range
-          if range.begin < 0
-            raise "#{i+1}th dimension of index must be in 0 ... #{ret_shape[i]} " +
-                  "(but was #{range.begin})"
-          end
-          if range.end >= ret_shape[ i ]
-            raise "#{i+1}th dimension of index must be in 0 ... #{ret_shape[i]} " +
-                  "(but was #{range.end})"
-          end
-        end
-      end
-      left = MultiArray.new options[ :target ], *ret_shape
-      left[] = 0
-      block = Histogram.new left, right
-      if block.compilable?
-        GCCFunction.run block
+      if shape.first != 1 and ret_shape.size == 1
+        [ self ].histogram *( ret_shape + [ options ] )
       else
-        block.demand
+        ( 0 ... shape.first ).collect { |i| unroll[i] }.
+          histogram *( ret_shape + [ options ] )
       end
-      left
     end
 
     # Perform element-wise lookup
@@ -508,42 +480,10 @@ module Hornetseye
     #
     # @return [Node] The result of the lookup operation.
     def lut( table, options = {} )
-      options = { :safe => true }.merge options
-      if options[ :safe ]
-        if shape.first != 1 and table.dimension == 1
-          source = Hornetseye::lazy( 1 ) { |i| self }.unroll
-        else
-          if shape.first > table.dimension
-            raise "First dimension of array (#{shape.first}) is greater than the " +
-                  " number of dimensions of LUT (#{table.dimension})"
-          end
-          source = self
-        end
+      if shape.first != 1 and table.dimension == 1
+        [ self ].lut table, options
       else
-        source = self
-      end
-      if options[ :safe ]
-        for i in 0 ... source.shape.first
-          range = source.roll[ i ].range
-          if range.begin < 0
-            raise "#{i+1}th dimension of index must be in 0 ... #{table.shape[i]} " +
-                  "(but was #{range.begin})"
-          end
-          offset = table.dimension - source.shape.first
-          if range.end >= table.shape[ i + offset ]
-            raise "#{i+1}th dimension of index must be in 0 ... " +
-                  "#{table.shape[ i + offset ]} (but was #{range.end})"
-          end
-        end
-      end
-      if source.dimension <= 1 and variables.empty?
-        result = table
-        ( table.dimension - 1 ).downto( 0 ) do |i|
-          result = result.element source.element( INT.new( i ) ).demand
-        end
-        result
-      else
-        Lut.new( source, table, options[ :n ] ).force
+        ( 0 ... shape.first ).collect { |i| unroll[i] }.lut table, options
       end
     end
 
@@ -570,3 +510,94 @@ module Hornetseye
   end
 
 end
+
+# The +Array+ class is extended with a few methods
+class Array
+
+  # Compute histogram of this array
+  #
+  # @overload histogram( *ret_shape, options = {} )
+  #   @param [Array<Integer>] ret_shape Dimensions of resulting histogram.
+  #   @option options [Class] :target (Hornetseye::UINT) Element-type of resulting
+  #           histogram.
+  #   @option options [Boolean] :safe (true) Do a boundary check before creating the
+  #           histogram.
+  #
+  # @return [Node] The histogram.
+  def histogram( *ret_shape )
+    options = ret_shape.last.is_a?( Hash ) ? ret_shape.pop : {}
+    options = { :target => Hornetseye::UINT, :safe => true }.merge options
+    if options[ :safe ]
+      if size != ret_shape.size
+        raise "Number of arrays for histogram (#{size}) differs from number of " +
+              "dimensions of histogram (#{ret_shape.size})"
+      end
+      array_types = collect { |source| source.array_type }
+      source_type = array_types.inject { |a,b| a.coercion b }
+      source_type.check_shape *array_types
+      for i in 0 ... size
+        range = self[ i ].range
+        if range.begin < 0
+          raise "#{i+1}th dimension of index must be in 0 ... #{ret_shape[i]} " +
+                "(but was #{range.begin})"
+        end
+        if range.end >= ret_shape[ i ]
+          raise "#{i+1}th dimension of index must be in 0 ... #{ret_shape[i]} " +
+                "(but was #{range.end})"
+        end
+      end
+    end
+    left = Hornetseye::MultiArray.new options[ :target ], *ret_shape
+    left[] = 0
+    block = Hornetseye::Histogram.new left, *self
+    if block.compilable?
+      Hornetseye::GCCFunction.run block
+    else
+      block.demand
+    end
+    left
+  end
+
+  # Perform element-wise lookup
+  #
+  # @param [Node] table The lookup table (LUT).
+  # @option options [Boolean] :safe (true) Do a boundary check before creating the
+  #         element-wise lookup.
+  #
+  # @return [Node] The result of the lookup operation.
+  def lut( table, options = {} )
+    options = { :safe => true }.merge options
+    if options[ :safe ]
+      if size > table.dimension
+        raise "Number of arrays for lookup (#{size}) is greater than the " +
+              " number of dimensions of LUT (#{table.dimension})"
+      end
+      array_types = collect { |source| source.array_type }
+      source_type = array_types.inject { |a,b| a.coercion b }
+      source_type.check_shape *array_types
+      for i in 0 ... size
+        range = self[ i ].range
+        if range.begin < 0
+          raise "#{i+1}th index must be in 0 ... #{table.shape[i]} " +
+                "(but was #{range.begin})"
+        end
+        offset = table.dimension - size
+        if range.end >= table.shape[ i + offset ]
+          raise "#{i+1}th index must be in 0 ... " +
+                "#{table.shape[ i + offset ]} (but was #{range.end})"
+        end
+      end
+    end
+    if all? { |source| source.dimension == 0 and source.variables.empty? }
+      result = table
+      ( table.dimension - 1 ).downto( 0 ) do |i|
+        result = result.element self[ i ].demand
+      end
+      result
+    else
+      Hornetseye::Lut.new( *( self + [ table ] ) ).force
+    end
+  end
+
+end
+

data/lib/multiarray/rgb.rb

@@ -617,6 +617,27 @@ module Hornetseye
       end
     end
 
+    # Histograms
+    def histogram_with_rgb( *ret_shape )
+      if typecode < RGB_
+        [ r, g, b ].histogram *ret_shape
+      else
+        histogram_without_rgb *ret_shape
+      end
+    end
+
+    alias_method_chain :histogram, :rgb
+
+    def lut_with_rgb( table, options = {} )
+      if typecode < RGB_
+        [ r, g, b ].lut table, options
+      else
+        lut_without_rgb table, options
+      end
+    end
+
+    alias_method_chain :lut, :rgb
+
   end
 
   # Create a class deriving from +RGB_+ or instantiate an +RGB+ object

data/lib/multiarray/sequence.rb

@@ -220,6 +220,31 @@ module Hornetseye
         element_type.dimension + 1
       end
 
+      # Check arguments for compatible shape
+      #
+      # The method will throw an exception if one of the arguments has an incompatible
+      # shape.
+      #
+      # @param [Array<Class>] args Arguments to check for compatibility.
+      #
+      # @return [Object] The return value should be ignored.
+      def check_shape( *args )
+        _shape = shape
+        args.each do |arg|
+          _arg_shape = arg.shape
+          if _shape.size < _arg_shape.size
+            raise "#{arg.inspect} has #{arg.dimension} dimension(s) " +
+                  "but should not have more than #{dimension}"
+          end
+          if ( _shape + _arg_shape ).all? { |s| s.is_a? Integer }
+            if _shape.last( _arg_shape.size ) != _arg_shape
+              raise "#{arg.inspect} has shape #{arg.shape.inspect} " +
+                    "(does not match last value(s) of #{shape.inspect})"
+            end
+          end
+        end
+      end
+
       # Check whether delayed operation will have colour
       #
       # @return [Boolean] Boolean indicating whether the array has elements of type

data/test/tc_multiarray.rb

@@ -432,13 +432,19 @@ class TC_MultiArray < Test::Unit::TestCase
                  M[ [ 1, 2 ], [ 3, 3 ] ].histogram( 5, :target => I )
     assert_equal M( I, 2, 2 )[ [ 1, 0 ], [ 1, 1 ] ],
                  M[ [ 0, 0 ], [ 0, 1 ], [ 1, 1 ] ].histogram( 2, 2, :target => I )
-    #assert_equal M( I, 2, 2, 1 )[ [ [ 0, 1 ], [ 1, 0 ] ] ],
-    #             S[ C( 1, 0, 0 ), C( 0, 1, 0 ) ].histogram( 2, 2, 1, :target => I )
+    assert_equal M( I, 2, 2 )[ [ 1, 0 ], [ 1, 1 ] ],
+                 [ S[ 0, 0, 1 ], S[ 0, 1, 1 ] ].histogram( 2, 2, :target => I )
+    assert_equal M( I, 2, 2, 1 )[ [ [ 0, 1 ], [ 1, 0 ] ] ],
+                 S[ C( 1, 0, 0 ), C( 0, 1, 0 ) ].histogram( 2, 2, 1, :target => I )
     assert_raise( RuntimeError ) { S[ 1, 2, 3 ].histogram 4, 4 }
     assert_raise( RuntimeError ) { M[ [ -1, 0 ] ].histogram 3, 2 }
     assert_raise( RuntimeError ) { M[ [ 0, -1 ] ].histogram 3, 2 }
     assert_raise( RuntimeError ) { M[ [ 3, 0 ] ].histogram 3, 2 }
     assert_raise( RuntimeError ) { M[ [ 0, 2 ] ].histogram 3, 2 }
+    assert_raise( RuntimeError ) { [ S[ -1, 0 ], S[ 0, 1 ] ].histogram 3, 2 }
+    assert_raise( RuntimeError ) { [ S[ 0, 3 ], S[ 0, 1 ] ].histogram 3, 2 }
+    assert_raise( RuntimeError ) { [ S[ 0, 0, 1 ], S[ 0, 1 ] ].histogram 3, 2 }
+    assert_raise( RuntimeError ) { [ S[ 0, 1 ], S[ 0, 1 ] ].histogram 3 }
   end
 
   def test_lut
@@ -446,14 +452,25 @@ class TC_MultiArray < Test::Unit::TestCase
                  M[ [ 0, 1 ], [ 2, 0 ] ].lut( S[ 1, 2, 3, 4 ] )
     assert_equal M[ 1, 3, 4 ],
                  M[ [ 0, 0 ], [ 0, 1 ], [ 1, 1 ] ].lut( M[ [ 1, 2 ], [ 3, 4 ] ] )
+    assert_equal M[ 1, 3, 4 ],
+                 [ S[ 0, 0, 1 ], S[ 0, 1, 1 ] ].lut( M[ [ 1, 2 ], [ 3, 4 ] ] )
     assert_equal M[ [ 3, 4 ], [ 1, 2 ] ],
                  M[ [ 1 ], [ 0 ] ].lut( M[ [ 1, 2 ], [ 3, 4 ] ] )
+    assert_equal S[ 2, 3 ], S[ C( 1, 0, 0 ), C( 0, 1, 0 ) ].
+                 lut( M[ [ [ 1, 2 ], [ 3, 4 ] ] ] )
     assert_raise( RuntimeError ) { S[ 0, 1, 2 ].lut M[ [ 1, 2 ], [ 3, 4 ] ] }
     assert_raise( RuntimeError ) { M[ [ -1, 0 ] ].lut M[ [ 1, 2 ] ] }
     assert_raise( RuntimeError ) { M[ [ 0, -1 ] ].lut M[ [ 1, 2 ] ] }
     assert_raise( RuntimeError ) { M[ [ 2, 0 ] ].lut M[ [ 1, 2 ] ] }
     assert_raise( RuntimeError ) { M[ [ 0, 1 ] ].lut M[ [ 1, 2 ] ] }
     assert_raise( RuntimeError ) { M[ [ 1 ], [ 2 ] ].lut M[ [ 1, 2 ], [ 3, 4 ] ] }
+    assert_raise( RuntimeError ) { [ S[ -1, 0 ], S[ 0, 1 ] ].
+                                   lut M[ [ 1, 2 ], [ 3, 4 ] ] }
+    assert_raise( RuntimeError ) { [ S[ 0, 0 ], S[ 0, 2 ] ].
+                                   lut M[ [ 1, 2 ], [ 3, 4 ] ] }
+    assert_raise( RuntimeError ) { [ S[ 0, 0, 1 ], S[ 0, 1 ] ].
+                                   lut M[ [ 1, 2 ], [ 3, 4 ] ] }
+    assert_raise( RuntimeError ) { [ S[ 0, 1 ], S[ 0, 1 ] ].lut S[ 1, 2 ] }
   end
 
   def test_zero

data/test/tc_sequence.rb

@@ -345,6 +345,8 @@ class TC_Sequence < Test::Unit::TestCase
     [ O, I ].each do |t|
       assert_equal S( t, 5 )[ 0, 1, 2, 1, 1 ],
                    S( t, 5 )[ 1, 2, 2, 3, 4 ].histogram( 5, :target => t )
+      assert_equal S( t, 4 )[ 0, 1, 1, 0 ],
+                   S( t, 2 )[ 1.0, 2.0 ].histogram( 4, :target => t )
     end
     assert_raise( RuntimeError ) { S[ -1, 0, 1 ].histogram 3 }
     assert_raise( RuntimeError ) { S[ 1, 2, 3 ].histogram 3 }
@@ -355,6 +357,8 @@ class TC_Sequence < Test::Unit::TestCase
     [ O, I ].each do |t|
       assert_equal S( t, 4 )[ 3, 1, 2, 1 ],
                    S( t, 4 )[ 0, 2, 1, 2 ].lut( S( t, 3 )[ 3, 2, 1 ] )
+      assert_equal S( t, 2 )[ 2, 1 ],
+                   S( t, 2 )[ 1.0, 2.0 ].lut( S( t, 3 )[ 3, 2, 1 ] )
     end
     assert_raise( RuntimeError ) { S[ -1, 0 ].lut S[ 0, 1 ] }
     assert_raise( RuntimeError ) { S[ 1, 2 ].lut S[ 0, 1 ] }

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 11
-  - 4
-  version: 0.11.4
+  - 12
+  - 0
+  version: 0.12.0
 platform: ruby
 authors: 
 - Jan Wedekind
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-11-18 00:00:00 +00:00
+date: 2010-12-05 00:00:00 +00:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency