multiarray 0.24.0 → 0.25.0

data/Rakefile

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

data/lib/multiarray.rb

@@ -808,33 +808,85 @@ module Hornetseye
 
   module_function :finalise
 
-  # Method for summing values
+  # Method for specifying injections in a different way
   #
-  # @param [Array<Integer>] *shape Optional shape of result. The method
-  # attempts to infer the shape if not specified.
-  # @yield Operation returning array elements.
+  # @overload inject(*shape, op, &action)
+  #   @param [Array<Integer>] *shape Optional shape of result.
+  #   @param [Proc] op Block of injection.
+  #   @yield Operation returning array elements.
   #
   # @return [Object,Node] Sum of values.
-  def sum( *shape, &action )
-    options = shape.last.is_a?( Hash ) ? shape.pop : {}
-    arity = options[ :arity ] || [ action.arity, shape.size ].max
+  #
+  # @private
+  def inject(*shape, &action)
+    op = shape.pop
+    options = shape.last.is_a?(Hash) ? shape.pop : {}
+    arity = options[:arity] || [action.arity, shape.size].max
     if arity <= 0
       term = action.call
       term.matched? ? term.to_type(term.typecode.maxint) : term
     else
-      index = Variable.new shape.empty? ? Hornetseye::INDEX( nil ) :
-                           Hornetseye::INDEX( shape.pop )
-      term = sum *( shape + [ :arity => arity - 1 ] ) do |*args|
-        action.call *( args + [ index ] )
+      index = Variable.new shape.empty? ? Hornetseye::INDEX(nil) :
+                           Hornetseye::INDEX(shape.pop)
+      term = inject *(shape + [:arity => arity - 1] + [op]) do |*args|
+        action.call *(args + [index])
       end
       var1 = Variable.new term.typecode
       var2 = Variable.new term.typecode
-      Inject.new( term, index, nil, var1 + var2, var1, var2 ).force
+      Inject.new(term, index, nil, op.call(var1, var2), var1, var2).force
     end
   end
 
+  module_function :inject
+
+  # Method for summing values
+  #
+  # @param [Array<Integer>] *shape Optional shape of result.
+  # @yield Operation returning array elements.
+  #
+  # @return [Object,Node] Sum of values.
+  def sum(*shape, &action)
+    inject *(shape + [proc { |a,b| a + b }]), &action
+  end
+
   module_function :sum
 
+  # Method for computing product of values
+  #
+  # @param [Array<Integer>] *shape Optional shape of result.
+  # @yield Operation returning array elements.
+  #
+  # @return [Object,Node] Product of values.
+  def prod(*shape, &action)
+    inject *(shape + [proc { |a,b| a * b }]), &action
+  end
+
+  module_function :prod
+
+  # Method for computing minimum of values
+  #
+  # @param [Array<Integer>] *shape Optional shape of result.
+  # @yield Operation returning array elements.
+  #
+  # @return [Object,Node] Minimum of values.
+  def min(*shape, &action)
+    inject *(shape + [proc { |a,b| a.minor b }]), &action
+  end
+
+  module_function :min
+
+  # Method for computing maximum of values
+  #
+  # @param [Array<Integer>] *shape Optional shape of result.
+  # @yield Operation returning array elements.
+  #
+  # @return [Object,Node] Maximum of values.
+  def max(*shape, &action)
+    inject *(shape + [proc { |a,b| a.major b }]), &action
+  end
+
+  module_function :max
+
   def argument(block, options = {}, &action)
     arity = options[:arity] || action.arity
     if arity > 0
@@ -859,8 +911,10 @@ module Hornetseye
       elsif sub_arg.first.is_a? Integer
         sub_arg + [lut[*sub_arg]]
       else
-        id = lazy(*sub_arg.first.shape) { |*i| i.last }
-        sub_arg + [lut.warp(*(sub_arg + [id]))]
+        id = (sub_arg.size ... lut.dimension).collect do |i|
+          lazy(*sub_arg.first.shape) { |*j| j[i - lut.dimension + sub_arg.first.dimension] }
+        end
+        sub_arg + [lut.warp(*(sub_arg + id))]
       end
     else
       []

data/lib/multiarray/operations.rb

@@ -438,6 +438,20 @@ module Hornetseye
       Hornetseye::lazy { to_type typecode.maxint }.inject :+
     end
 
+    # Compute product of array
+    #
+    # @return [Object] Product of array.
+    def prod
+      Hornetseye::lazy { to_type typecode.maxint }.inject :*
+    end
+
+    # Compute average of array
+    #
+    # @return [Object] Mean of array.
+    def mean
+      sum / size
+    end
+
     # Find range of values of array
     #
     # @return [Object] Range of values of array.
@@ -491,6 +505,29 @@ module Hornetseye
       collect { |x| x.major( range.begin ).minor range.end }
     end
 
+    # Stretch values from one range to another
+    #
+    # @param [Range] from Target range of values.
+    # @param [Range] to Source range of values.
+    #
+    # @return [Node] Array with stretched values.
+    def stretch(from = 0 .. 0xFF, to = 0 .. 0xFF)
+      if from.exclude_end?
+        raise "Stretching does not support ranges with end value " +
+              "excluded (such as #{from})"
+      end
+      if to.exclude_end?
+        raise "Stretching does not support ranges with end value " +
+              "excluded (such as #{to})"
+      end
+      if from.last != from.first
+        factor = (to.last - to.first).to_f / (from.last - from.first)
+        collect { |x| ((x - from.first) * factor).major(to.first).minor to.last }
+      else
+        (self <= from.first).conditional to.first, to.last
+      end
+    end
+
     # Fill array with a value
     #
     # @param [Object] value Value to fill array with.

data/lib/multiarray/rgb.rb

@@ -949,5 +949,17 @@ module Math
   module_function :sqrt_without_rgb
   module_function :sqrt
 
+  def log_with_rgb(c)
+    if c.is_a? Hornetseye::RGB
+      Hornetseye::RGB.new log( c.r ), log( c.g ), log( c.b )
+    else
+      log_without_rgb c
+    end
+  end
+
+  alias_method_chain :log, :rgb
+  module_function :log_without_rgb
+  module_function :log
+
 end
 

data/test/tc_multiarray.rb

@@ -369,16 +369,16 @@ class TC_MultiArray < Test::Unit::TestCase
     assert_equal [ [ 1, 2, 3 ] , [ 4, 5, 6 ] ], sum { || m }.to_a
   end
 
-  def test_argmin
-    assert_equal [[0, 0, 1]],
-                 argmin { |i| M[[1, 2, 3], [4, 3, 2]][i] }.collect { |x| x.to_a }
-    assert_equal [2, 1], argmin { |i,j| M[[1, 2, 3], [4, 3, 0]][i,j] }
+  def test_argmax
+    assert_equal [[1, 1, 0]],
+                 argmax { |i| M[[1, 2, 3], [4, 3, 2]][i] }.collect { |x| x.to_a }
+    assert_equal [0, 1], argmax { |i,j| M[[1, 2, 3], [4, 3, 0]][i,j] }
     m = M[[[1,0,3,4],[5,4,3,2],[1,2,1,0]],[[3,2,4,1],[7,4,8,2],[2,1,9,1]]]
-    assert_equal [[[0, 0, 0, 1], [0, 0, 0, 0], [0, 1, 0, 0]]],
-                 argmin { |i| m[i] }.collect { |x| x.to_a }
-    assert_equal [[0, 0, 2, 2], [0, 0, 0, 0]],
-                 argmin { |i,j| m[i,j] }.collect { |x| x.to_a }
-    assert_equal [1, 0, 0], argmin { |i,j,k| m[i,j,k] }
+    assert_equal [[[1, 1, 1, 0], [1, 0, 1, 0], [1, 0, 1, 1]]],
+                 argmax { |i| m[i] }.collect { |x| x.to_a }
+    assert_equal [[1, 1, 2, 0], [1, 0, 1, 0]],
+                 argmax { |i,j| m[i,j] }.collect { |x| x.to_a }
+    assert_equal [2, 2, 1], argmax { |i,j,k| m[i,j,k] }
   end
 
   def test_min

data/test/tc_sequence.rb

@@ -48,6 +48,18 @@ class TC_Sequence < Test::Unit::TestCase
     Hornetseye::sum *args, &action
   end
 
+  def prod( *args, &action )
+    Hornetseye::prod *args, &action
+  end
+
+  def min( *args, &action )
+    Hornetseye::min *args, &action
+  end
+
+  def max( *args, &action )
+    Hornetseye::max *args, &action
+  end
+
   def argmin( *args, &action )
     Hornetseye::argmin *args, &action
   end
@@ -315,6 +327,17 @@ class TC_Sequence < Test::Unit::TestCase
     assert_equal 384, sum { |i| S[ 128, 128, 128 ][i] }
   end
 
+  def test_prod
+    [ S(O), S(I) ].each do |t|
+      assert_equal 6, t[ 1, 2, 3 ].prod
+      assert_equal 6, prod { |i| t[ 1, 2, 3 ][ i ] }
+    end
+  end
+ 
+  def test_mean
+    assert_equal 2, S(I)[1, 2, 3].mean
+  end
+
   def test_argmin
     [S(O), S(I)].each do |t|
       assert_equal [], argmin { t[1, 0, 2] }
@@ -334,6 +357,7 @@ class TC_Sequence < Test::Unit::TestCase
   def test_min
     [O, I].each do |t|
       assert_equal 2, S(t)[4, 2, 3].min
+      assert_equal 2, min { |i| S(t)[4, 2, 3][i] }
     end
     assert_equal C(1, 2, 1), S[C(1, 2, 3), C(3, 2, 1)].min
   end
@@ -341,6 +365,7 @@ class TC_Sequence < Test::Unit::TestCase
   def test_max
     [O, I].each do |t|
       assert_equal 4, S(t)[4, 2, 3].max
+      assert_equal 4, max { |i| S(t)[4, 2, 3][i] }
     end
     assert_equal C(3, 2, 3), S[C(1, 2, 3), C(3, 2, 1)].max
   end
@@ -359,6 +384,13 @@ class TC_Sequence < Test::Unit::TestCase
     assert_equal [ C( 3, 4, 5 ) ], S[ C( 2, 4, 6 ) ].clip( 3 .. 5 ).to_a
   end
 
+  def test_stretch
+    assert_equal [0.0, 127.5, 255.0], S[1, 2, 3].stretch(1 .. 3).to_a
+    assert_equal [0, 0, 255], S[1, 2, 3].stretch(2 .. 2).to_a
+    assert_equal [0.0, 0.5, 1.0], S[1, 2, 3].stretch(1 .. 3, 0 .. 1).to_a
+    assert_equal [0, 0, 1], S[1, 2, 3].stretch(2 .. 2, 0 .. 1).to_a
+  end
+
   def test_sum
     [ S(O), S(I) ].each do |t|
       assert_equal 9, t[ 4, 2, 3 ].sum
@@ -823,6 +855,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.log( C( 1, 2, 3 ) ), Math.log( C( 2, 4, 6 ) ) ].
+      zip( Math.log( 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_log10

metadata

@@ -2,7 +2,7 @@
 name: multiarray
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.24.0
+  version: 0.25.0
 platform: ruby
 authors: 
 - Jan Wedekind
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-07-01 00:00:00 Z
+date: 2011-09-06 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: malloc