multiarray 0.17.0 → 0.18.0

data/Rakefile

@@ -6,7 +6,7 @@ require 'rake/packagetask'
 require 'rbconfig'
 
 PKG_NAME = 'multiarray'
-PKG_VERSION = '0.17.0'
+PKG_VERSION = '0.18.0'
 RB_FILES = FileList[ 'lib/**/*.rb' ]
 TC_FILES = FileList[ 'test/tc_*.rb' ]
 TS_FILES = FileList[ 'test/ts_*.rb' ]
@@ -55,8 +55,7 @@ begin
   # For development just run it with "yard server --reload".
   require 'yard'
   YARD::Rake::YardocTask.new :yard do |y|
-    y.options << '--no-private'
-    y.files << FileList[ 'lib/**/*.rb' ]
+    y.files << RB_FILES
   end
 rescue LoadError
   STDERR.puts 'Please install \'yard\' if you want to generate documentation'

data/lib/multiarray.rb

@@ -552,34 +552,6 @@ end
 # The +Numeric+ class is extended with a few methods
 class Numeric
 
-  # Compute complex conjugate
-  #
-  # @return [Numeric] Returns +self+.
-  def conj
-    self
-  end
-
-  # Get red component
-  #
-  # @return [Numeric] Returns +self+.
-  def r
-    self
-  end
-
-  # Get green component
-  #
-  # @return [Numeric] Returns +self+.
-  def g
-    self
-  end
-
-  # Get blue component
-  #
-  # @return [Numeric] Returns +self+.
-  def b
-    self
-  end
-
   # Get larger number of two numbers
   #
   # @param [Numeric] other The other number.

data/lib/multiarray/complex.rb

@@ -673,6 +673,18 @@ module Math
 
 end
 
+# The +Numeric+ class is extended with a few methods
+class Numeric
+
+  # Compute complex conjugate
+  #
+  # @return [Numeric] Returns +self+.
+  def conj
+    self
+  end
+
+end
+
 module Hornetseye
 
   # Class for representing native complex values

data/lib/multiarray/lambda.rb

@@ -166,7 +166,7 @@ module Hornetseye
         end
         i = INT.new i
       end
-      i.size = @index.size if @index.size.get and i.is_a? Variable
+      i.size = @index.size if i.is_a?( Variable ) and @index.size.get
       @term.subst @index => i
     end
 

data/lib/multiarray/operations.rb

@@ -322,6 +322,9 @@ module Hornetseye
         value = element( index ).inject nil, :block => block,
                                         :var1 => var1, :var2 => var2
         value = typecode.new value unless value.is_a? Node
+        if initial.nil? and index.size.get == 0
+          raise "Array was empty and no initial value for injection was given"
+        end
         Inject.new( value, index, initial, block, var1, var2 ).force
       end
     end
@@ -349,16 +352,20 @@ module Hornetseye
 
     # Find minimum value of array
     #
+    # @param [Object] initial Only consider values less than this value.
+    #
     # @return [Object] Minimum value of array.
-    def min
-      inject { |a,b| a.minor b }
+    def min( initial = nil )
+      inject( initial ) { |a,b| a.minor b }
     end
 
     # Find maximum value of array
     #
+    # @param [Object] initial Only consider values greater than this value.
+    #
     # @return [Object] Maximum value of array.
-    def max
-      inject { |a,b| a.major b }
+    def max( initial = nil )
+      inject( initial ) { |a,b| a.major b }
     end
 
     # Compute sum of array
@@ -371,8 +378,8 @@ module Hornetseye
     # Find range of values of array
     #
     # @return [Object] Range of values of array.
-    def range
-      min .. max
+    def range( initial = nil )
+      min( initial ? initial.min : nil ) .. max( initial ? initial.max : nil )
     end
 
     # Normalise values of array
@@ -504,7 +511,11 @@ 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
         [ self ].histogram *( ret_shape + [ options ] )
       else
@@ -638,6 +649,11 @@ module Hornetseye
       warp *( field + [ :safe => false ] )
     end
 
+    # Create array with shifted elements
+    #
+    # @param [Array<Integer>] offset Array with amount of shift for each dimension.
+    #
+    # @return [Node] The result of the shifting operation.
     def shift( *offset )
       if offset.size != dimension
         raise "#{offset.size} offset(s) were given but array has " +
@@ -673,6 +689,13 @@ module Hornetseye
       retval
     end
 
+    # Downsampling of arrays
+    #
+    # @overload downsample( *rate, options = {} )
+    #   @param [Array<Integer>] rate The sampling rates for each dimension.
+    #   @option options [Array<Integer>] :offset Sampling offsets for each dimension.
+    #
+    # @return [Node] The downsampled data.
     def downsample( *rate )
       options = rate.last.is_a?( Hash ) ? rate.pop : {}
       options = { :offset => rate.collect { |r| r - 1 } }.merge options
@@ -728,7 +751,11 @@ class Array
   # @return [Node] The histogram.
   def histogram( *ret_shape )
     options = ret_shape.last.is_a?( Hash ) ? ret_shape.pop : {}
-    options = { :weight => Hornetseye::UINT.new( 1 ), :safe => true }.merge options
+    options = { :weight => Hornetseye::UINT. new( 1 ), :safe => true }.merge options
+    unless options[ :weight ].is_a? Hornetseye::Node
+      options[ :weight ] =
+        Hornetseye::Node.match( options[ :weight ] ).maxint.new options[ :weight ]
+    end
     weight = options[ :weight ]
     if options[ :safe ]
       if size != ret_shape.size
@@ -740,7 +767,7 @@ class Array
       source_type.check_shape *array_types
       source_type.check_shape options[ :weight ]
       for i in 0 ... size
-        range = self[ i ].range
+        range = self[ i ].range 0 ... ret_shape[ i ]
         if range.begin < 0
           raise "#{i+1}th dimension of index must be in 0 ... #{ret_shape[i]} " +
                 "(but was #{range.begin})"
@@ -780,12 +807,12 @@ class Array
       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
+        offset = table.dimension - size
+        range = self[ i ].range 0 ... table.shape[ i + offset ]
         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})"

data/lib/multiarray/rgb.rb

@@ -146,9 +146,7 @@ module Hornetseye
 
     # This operation has no effect
     #
-    # @return [InternalComplex] Returns +self+.
-    #
-    # @private
+    # @return [RGB] Returns +self+.
     def +@
       self
     end
@@ -175,8 +173,6 @@ module Hornetseye
     # Check whether value is equal to zero
     #
     # @return [Boolean,GCCValue] The result.
-    #
-    # @private
     def zero?
       @r.zero?.and( @g.zero? ).and( @b.zero? )
     end
@@ -184,20 +180,23 @@ module Hornetseye
     # Check whether value is not equal to zero
     #
     # @return [Boolean,GCCValue] The result.
-    #
-    # @private
     def nonzero?
       @r.nonzero?.or( @g.nonzero? ).or( @b.nonzero? )
     end
 
+    # Swap colour channels
+    #
+    # @return [RGB] The result.
+    def swap_rgb
+      RGB.new @b, @g, @r
+    end
+
     # Test on equality
     #
     # @param [Object] other Object to compare with.
     #
     # @return [Boolean] Returns boolean indicating whether objects are
     #         equal or not.
-    #
-    # @private
     def ==( other )
       if other.is_a? RGB
         @r.eq( other.r ).and( @g.eq( other.g ) ).and( @b.eq( other.b ) )
@@ -213,6 +212,8 @@ module Hornetseye
     # This method decomposes the RGB value into an array.
     #
     # @return [Node] An array with the three channel values as elements.
+    #
+    # @private
     def decompose( i )
       [ @r, @g, @b ][ i ]
     end
@@ -520,6 +521,7 @@ module Hornetseye
     define_unary_op :r, :scalar
     define_unary_op :g, :scalar
     define_unary_op :b, :scalar
+    define_unary_op :swap_rgb
 
     # Fast extraction for red channel of RGB array
     #
@@ -617,7 +619,31 @@ module Hornetseye
       end
     end
 
-    # Histograms
+    # Swapping colour channels for scalar values
+    #
+    # @return [Node] Array with swapped colour channels.
+    def swap_rgb_with_scalar
+      if typecode == OBJECT or typecode < RGB_
+        swap_rgb_without_scalar
+      else
+        self
+      end
+    end
+
+    alias_method_chain :swap_rgb, :scalar
+
+    # Compute colour histogram of this array
+    #
+    # The array is decomposed to its colour channels and a histogram is computed.
+    #
+    # @overload histogram( *ret_shape, options = {} )
+    #   @param [Array<Integer>] ret_shape Dimensions of resulting histogram.
+    #   @option options [Node] :weight (Hornetseye::UINT(1)) Weights for computing the
+    #           histogram.
+    #   @option options [Boolean] :safe (true) Do a boundary check before creating the
+    #           histogram.
+    #
+    # @return [Node] The histogram.
     def histogram_with_rgb( *ret_shape )
       if typecode < RGB_
         [ r, g, b ].histogram *ret_shape
@@ -628,6 +654,13 @@ module Hornetseye
 
     alias_method_chain :histogram, :rgb
 
+    # Perform element-wise lookup with colour values
+    #
+    # @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_with_rgb( table, options = {} )
       if typecode < RGB_
         [ r, g, b ].lut table, options
@@ -844,6 +877,39 @@ module Hornetseye
 
 end
 
+# The +Numeric+ class is extended with a few methods
+class Numeric
+
+  # Get red component
+  #
+  # @return [Numeric] Returns +self+.
+  def r
+    self
+  end
+
+  # Get green component
+  #
+  # @return [Numeric] Returns +self+.
+  def g
+    self
+  end
+
+  # Get blue component
+  #
+  # @return [Numeric] Returns +self+.
+  def b
+    self
+  end
+
+  # Swap colour channels
+  #
+  # @return [Numeric] Returns +self+.
+  def swap_rgb
+    self
+  end
+
+end
+
 class Fixnum
 
   if method_defined? :rpower

data/test/tc_multiarray.rb

@@ -341,6 +341,8 @@ class TC_MultiArray < Test::Unit::TestCase
     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
+    assert_equal M[ [ C( 3, 2, 1 ), 4 ], [ 5, 6 ] ],
+                 M[ [ C( 1, 2, 3 ), 4 ], [ 5, 6 ] ].swap_rgb
     assert_equal M[ [ 1, 4 ], [ 5, 6 ] ],
                  M[ [ C( 1, 2, 3 ), 4 ], [ 5, 6 ] ].collect { |x| x.r }
     assert_equal M[ [ 2, 4 ], [ 5, 6 ] ],
@@ -431,17 +433,17 @@ class TC_MultiArray < Test::Unit::TestCase
   end
 
   def test_histogram
-    assert_equal S( I, 5 )[ 0, 1, 1, 2, 0 ],
-                 M[ [ 1, 2 ], [ 3, 3 ] ].histogram( 5, :weight => I.new( 1 ) )
-    assert_equal M( I, 2, 2 )[ [ 1, 0 ], [ 1, 1 ] ],
+    assert_equal [ 0, 1, 1, 2, 0 ],
+                 M[ [ 1, 2 ], [ 3, 3 ] ].histogram( 5, :weight => 1 ).to_a
+    assert_equal [ [ 1, 0 ], [ 1, 1 ] ],
                  M[ [ 0, 0 ], [ 0, 1 ], [ 1, 1 ] ].
-                 histogram( 2, 2, :weight => I.new( 1 ) )
-    assert_equal M( I, 2, 2 )[ [ 1, 0 ], [ 1, 1 ] ],
+                 histogram( 2, 2, :weight => 1 ).to_a
+    assert_equal [ [ 1, 0 ], [ 1, 1 ] ],
                  [ S[ 0, 0, 1 ], S[ 0, 1, 1 ] ].
-                 histogram( 2, 2, :weight => I.new( 1 ) )
-    assert_equal M( I, 2, 2, 1 )[ [ [ 0, 1 ], [ 1, 0 ] ] ],
+                 histogram( 2, 2, :weight => 1 ).to_a
+    assert_equal [ [ [ 0, 1 ], [ 1, 0 ] ] ],
                  S[ C( 1, 0, 0 ), C( 0, 1, 0 ) ].
-                 histogram( 2, 2, 1, :weight => I.new( 1 ) )
+                 histogram( 2, 2, 1, :weight => 1 ).to_a
     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 }

data/test/tc_sequence.rb

@@ -240,6 +240,7 @@ class TC_Sequence < Test::Unit::TestCase
       assert_equal [ 1, 4, 5 ], t[ C( 1, 2, 3 ), 4, 5 ].collect { |x| x.r }.to_a
       assert_equal [ 2, 4, 5 ], t[ C( 1, 2, 3 ), 4, 5 ].collect { |x| x.g }.to_a
       assert_equal [ 3, 4, 5 ], t[ C( 1, 2, 3 ), 4, 5 ].collect { |x| x.b }.to_a
+      assert_equal t[ C( 3, 2, 1 ), 4, 5 ], t[ C( 1, 2, 3 ), 4, 5 ].swap_rgb
       s = t[ 0, 0, 0 ]
       assert_equal 1, s.r = 1
       assert_equal S[ 1, 2, 3 ], s.g = S[ 1, 2, 3 ]
@@ -289,6 +290,8 @@ class TC_Sequence < Test::Unit::TestCase
     assert_equal C( 4, 6, 9 ), S[ C( 1, 2, 3 ), C( 2, 3, 5 ) ].
                                inject( 1 ) { |a,b| a + b }
     assert_equal X( -5, 10 ), S( X, 2 )[ X( 1, 2 ), X( 3, 4 ) ].inject { |a,b| a * b }
+    assert_raise( RuntimeError ) { S[].inject { |a,b| a + b } }
+    assert_equal 0, S[].inject( 0 ) { |a,b| a + b }
   end
 
   def test_collect
@@ -312,15 +315,15 @@ class TC_Sequence < Test::Unit::TestCase
   end
 
   def test_min
-    [ S( O, 3 ), S( I, 3 ) ].each do |t|
-      assert_equal 2, t[ 4, 2, 3 ].min
+    [ O, I ].each do |t|
+      assert_equal 2, S( t, 3 )[ 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
+    [ O, I ].each do |t|
+      assert_equal 4, S( t, 3 )[ 4, 2, 3 ].max
     end
     assert_equal C( 3, 2, 3 ), S[ C( 1, 2, 3 ), C( 3, 2, 1 ) ].max
   end
@@ -360,12 +363,12 @@ class TC_Sequence < Test::Unit::TestCase
 
   def test_histogram
     [ 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, :weight => t.new( 1 ) )
+      assert_equal [ 0, 1, 2, 1, 1 ],
+                   S( t, 5 )[ 1, 2, 2, 3, 4 ].histogram( 5, :weight => 1 ).to_a
       assert_equal S( t, 5 )[ 0, 1, 2, 3, 0 ],
                    S( t, 3 )[ 1, 3, 2 ].histogram( 5, :weight => S( t, 3 )[ 1, 3, 2 ] )
-      assert_equal S( t, 4 )[ 0, 1, 1, 0 ],
-                   S( t, 2 )[ 1.0, 2.0 ].histogram( 4, :weight => t.new( 1 ) )
+      assert_equal [ 0, 1, 1, 0 ],
+                   S( t, 2 )[ 1.0, 2.0 ].histogram( 4, :weight => 1 ).to_a
     end
     assert_raise( RuntimeError ) { S[ -1, 0, 1 ].histogram 3 }
     assert_raise( RuntimeError ) { S[ 1, 2, 3 ].histogram 3 }
@@ -550,7 +553,8 @@ class TC_Sequence < Test::Unit::TestCase
   end
 
   def test_conj
-    assert_equal S[ 1.5, 2.5 ], S[ 1.5, 2.5 ].conj
+    assert_equal S( O, 2 )[ 1.5, 2.5 ], S( O, 2 )[ 1.5, 2.5 ].conj
+    assert_equal S( F, 2 )[ 1.5, 2.5 ], S( F, 2 )[ 1.5, 2.5 ].conj
     assert_equal S[ X( 1.5, -2.5 ) ], S[ X( 1.5, 2.5 ) ].conj
   end
 

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 17
+  - 18
   - 0
-  version: 0.17.0
+  version: 0.18.0
 platform: ruby
 authors: 
 - Jan Wedekind
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-01-02 00:00:00 +01:00
+date: 2011-01-11 00:00:00 +00:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency