multiarray 0.23.1 → 0.23.2

data/Rakefile

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

data/lib/multiarray/complex.rb

@@ -933,7 +933,7 @@ module Hornetseye
         if values.all? { |value| value.is_a? InternalComplex or value.is_a? Complex or
                                  value.is_a? Float or value.is_a? Integer }
           if values.any? { |value| value.is_a? InternalComplex or value.is_a? Complex }
-            elements = values.inject( [] ) do |arr,value|
+            elements = values.inject([]) do |arr,value|
               if value.is_a? InternalComplex or value.is_a? Complex
                 arr + [ value.real, value.imag ]
               else

data/lib/multiarray/components.rb

@@ -215,9 +215,9 @@ module Hornetseye
     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 ] } )
+      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

data/lib/multiarray/elementwise.rb

@@ -130,7 +130,7 @@ module Hornetseye
     #
     # @private
     def variables
-      @values.inject( Set[] ) { |vars,value| vars + value.variables }
+      @values.inject(Set[]) { |vars,value| vars + value.variables }
     end
 
     # Strip of all values
@@ -144,9 +144,9 @@ module Hornetseye
     # @private
     def strip
       stripped = @values.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 ] } )
+      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
@@ -227,7 +227,7 @@ module Hornetseye
   # @see ElementWise_.conversion
   #
   # @private
-  def ElementWise( operation, key, conversion = lambda { |t| t.send :identity } )
+  def ElementWise( operation, key, conversion = proc { |t| t.send :identity } )
     retval = Class.new ElementWise_
     retval.operation = operation
     retval.key = key

data/lib/multiarray/gcctype.rb

@@ -93,14 +93,14 @@ module Hornetseye
     def r2c
       case @typecode
       when BOOL
-        [ lambda { |expr| "( #{expr} ) != Qfalse" } ]
+        [ proc { |expr| "( #{expr} ) != Qfalse" } ]
       when BYTE, UBYTE, SINT, USINT, INT, UINT
-        [ lambda { |expr| "NUM2INT( #{expr} )" } ]
+        [ proc { |expr| "NUM2INT( #{expr} )" } ]
       when SFLOAT, DFLOAT
-        [ lambda { |expr| "NUM2DBL( #{expr} )" } ]
+        [ proc { |expr| "NUM2DBL( #{expr} )" } ]
       else
         if @typecode < Pointer_
-          [ lambda { |expr| "(#{identifier})mallocToPtr( #{expr} )" } ]
+          [ proc { |expr| "(#{identifier})mallocToPtr( #{expr} )" } ]
         elsif @typecode < Composite
           GCCType.new( @typecode.element_type ).r2c * @typecode.num_elements
         else

data/lib/multiarray/histogram.rb

@@ -120,7 +120,7 @@ module Hornetseye
     #
     # @private
     def variables
-      @sources.inject( @dest.variables + @weight.variables ) { |a,b| a + b.variables }
+      @sources.inject(@dest.variables + @weight.variables) { |a,b| a + b.variables }
     end
 
     # Strip of all values
@@ -134,9 +134,9 @@ module Hornetseye
     # @private
     def strip
       stripped = ( [ @dest, @weight ] + @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 ] } )
+      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

data/lib/multiarray/lut.rb

@@ -101,7 +101,7 @@ module Hornetseye
     #
     # @private
     def variables
-      @sources.inject( @table.variables ) { |a,b| a + b.variables }
+      @sources.inject(@table.variables) { |a,b| a + b.variables }
     end
 
     # Strip of all values
@@ -115,9 +115,9 @@ module Hornetseye
     # @private
     def strip
       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 ] } )
+      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

data/lib/multiarray/mask.rb

@@ -134,9 +134,9 @@ module Hornetseye
     # @private
     def strip
       stripped = [ @dest, @source, @m, @index ].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 ] } )
+      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

data/lib/multiarray/methods.rb

@@ -63,9 +63,9 @@ module Hornetseye
               target = a.typecode.send conversion
               target.new mod.send( op, a.simplify.get )
             else
-              Hornetseye::ElementWise( lambda { |x| mod.send op, x },
+              Hornetseye::ElementWise( proc { |x| mod.send op, x },
                                        "#{mod}.#{op}",
-                                       lambda { |x| x.send conversion } ).
+                                       proc { |x| x.send conversion } ).
                 new(a.sexp).force
             end
           else
@@ -99,9 +99,9 @@ module Hornetseye
               target = a.typecode.send coercion, b.typecode
               target.new mod.send(op, a.simplify.get, b.simplify.get)
             else
-              Hornetseye::ElementWise( lambda { |x,y| mod.send op, x, y },
+              Hornetseye::ElementWise( proc { |x,y| mod.send op, x, y },
                                        "#{mod}.#{op}",
-                                       lambda { |t,u| t.send coercion, u } ).
+                                       proc { |t,u| t.send coercion, u } ).
                 new(a.sexp, b.sexp).force
             end
           else

data/lib/multiarray/node.rb

@@ -320,7 +320,7 @@ module Hornetseye
     #
     # @return [Integer] Returns number of elements of this value.
     def size
-      shape.inject(1) { |a,b| a * b }
+      shape.inject 1, :*
     end
 
     # Duplicate array expression if it is not in row-major format
@@ -329,7 +329,7 @@ module Hornetseye
     def memorise
       if memory
         contiguous_strides = (0 ... dimension).collect do |i|
-          shape[0 ... i].inject(1) { |a,b| a * b }
+          shape[0 ... i].inject 1, :*
         end
         if strides == contiguous_strides
           self

data/lib/multiarray/operations.rb

@@ -37,8 +37,8 @@ module Hornetseye
               target = typecode.send conversion
               target.new simplify.get.send(op)
             else
-              Hornetseye::ElementWise(lambda { |x| x.send op }, op,
-                                      lambda { |t| t.send conversion }).
+              Hornetseye::ElementWise(proc { |x| x.send op }, op,
+                                      proc { |t| t.send conversion }).
                 new(self).force
             end
           end
@@ -61,8 +61,8 @@ module Hornetseye
             target = typecode.send coercion, other.typecode
             target.new simplify.get.send(op, other.simplify.get)
           else
-            Hornetseye::ElementWise(lambda { |x,y| x.send op, y }, op,
-                                    lambda { |t,u| t.send coercion, u } ).
+            Hornetseye::ElementWise(proc { |x,y| x.send op, y }, op,
+                                    proc { |t,u| t.send coercion, u } ).
               new(sexp, other.sexp).force
           end
         end
@@ -141,8 +141,8 @@ module Hornetseye
         target.new(simplify.get).simplify
       else
         key = "to_#{dest.to_s.downcase}"
-        Hornetseye::ElementWise( lambda { |x| x.to_type dest }, key,
-                                 lambda { |t| t.to_type dest } ).new(self).force
+        Hornetseye::ElementWise( proc { |x| x.to_type dest }, key,
+                                 proc { |t| t.to_type dest } ).new(self).force
       end
     end
 
@@ -195,7 +195,7 @@ module Hornetseye
     #
     # @return [Node] Array with desired shape.
     def reshape(*ret_shape)
-      target_size = ret_shape.inject { |a,b| a * b }
+      target_size = ret_shape.inject 1, :*
       if target_size != size
         raise "Target is of size #{target_size} but should be of size #{size}"
       end
@@ -219,8 +219,8 @@ module Hornetseye
         target.new simplify.get.conditional(proc { a.simplify.get },
                                             proc { b.simplify.get })
       else
-        Hornetseye::ElementWise(lambda { |x,y,z| x.conditional y, z }, :conditional,
-                                lambda { |t,u,v| t.cond u, v }).
+        Hornetseye::ElementWise(proc { |x,y,z| x.conditional y, z }, :conditional,
+                                proc { |t,u,v| t.cond u, v }).
           new(self, a.sexp, b.sexp).force
       end
     end
@@ -280,7 +280,7 @@ module Hornetseye
         var
       end.reverse
       order.collect { |o| variables[o] }.
-        inject( term ) { |retval,var| Lambda.new var, retval }
+        inject(term) { |retval,var| Lambda.new var, retval }
     end
 
     # Cycle indices of array
@@ -318,10 +318,10 @@ module Hornetseye
     # @param [Proc] action Operation(s) to perform on elements.
     #
     # @return [Node] The resulting array.
-    def collect( &action )
+    def collect(&action)
       var = Variable.new typecode
       block = action.call var
-      conversion = lambda { |t| t.to_type action.call(Variable.new(t.typecode)).typecode }
+      conversion = proc { |t| t.to_type action.call(Variable.new(t.typecode)).typecode }
       Hornetseye::ElementWise( action, block.to_s, conversion ).new( self ).force
     end
 
@@ -334,14 +334,29 @@ module Hornetseye
 
     # Perform cummulative operation on array
     #
-    # @param [Object] initial Initial value for cummulative operation.
-    # @option options [Variable] :var1 First variable defining operation.
-    # @option options [Variable] :var1 Second variable defining operation.
-    # @option options [Variable] :block (yield( var1, var2 )) The operation to
-    #         apply.
+    # @overload inject(initial = nil, options = {}, &action)
+    #   @param [Object] initial Initial value for cummulative operation.
+    #   @option options [Variable] :var1 First variable defining operation.
+    #   @option options [Variable] :var1 Second variable defining operation.
+    #   @option options [Variable] :block (action.call(var1, var2)) The operation to apply.
+    #
+    # @overload inject(initial = nil, symbol)
+    #   @param [Object] initial Initial value for cummulative operation.
+    #   @param [Symbol,String] symbol The operation to apply.
     #
     # @return [Object] Result of injection.
-    def inject( initial = nil, options = {} )
+    def inject(*args, &action)
+      options = args.last.is_a?(Hash) ? args.pop : {}
+      unless action or options[:block]
+        unless [1, 2].member? args.size
+          raise "Inject expected 1 or 2 arguments but got #{args.size}" 
+        end
+        initial, symbol = args[-2], args[-1]
+        action = proc { |a,b| a.send symbol, b }
+      else
+        raise "Inject expected 0 or 1 arguments but got #{args.size}" if args.size > 1
+        initial = args.empty? ? nil : args.first
+      end
       unless initial.nil?
         initial = Node.match( initial ).new initial unless initial.matched?
         initial_typecode = initial.typecode
@@ -350,7 +365,7 @@ module Hornetseye
       end
       var1 = options[ :var1 ] || Variable.new( initial_typecode )
       var2 = options[ :var2 ] || Variable.new( typecode )
-      block = options[ :block ] || yield( var1, var2 )
+      block = options[ :block ] || action.call( var1, var2 )
       if dimension == 0
         if initial
           block.subst( var1 => initial, var2 => self ).simplify
@@ -384,7 +399,7 @@ module Hornetseye
       if other.matched?
         if variables.empty?
           if other.typecode == typecode and other.shape == shape
-            Hornetseye::finalise { eq(other).inject( true ) { |a,b| a.and b } }
+            Hornetseye::finalise { eq(other).inject true, :and }
           else
             false
           end
@@ -404,7 +419,7 @@ module Hornetseye
     #
     # @return [Object] Minimum value of array.
     def min( initial = nil )
-      inject( initial ) { |a,b| a.minor b }
+      inject initial, :minor
     end
 
     # Find maximum value of array
@@ -413,14 +428,14 @@ module Hornetseye
     #
     # @return [Object] Maximum value of array.
     def max( initial = nil )
-      inject( initial ) { |a,b| a.major b }
+      inject initial, :major
     end
 
     # Compute sum of array
     #
     # @return [Object] Sum of array.
     def sum
-      Hornetseye::lazy { to_type typecode.maxint }.inject { |a,b| a + b }
+      Hornetseye::lazy { to_type typecode.maxint }.inject :+
     end
 
     # Find range of values of array
@@ -696,7 +711,7 @@ module Hornetseye
         Hornetseye::lazy do
           ( 0 ... field.size ).
             collect { |i| ( field[i] >= 0 ).and( field[i] < shape[i] ) }.
-            inject { |a,b| a.and b }
+            inject :and
         end.conditional Lut.new( *( field + [ self ] ) ), options[ :default ]
       else
         field.lut self, :safe => false

data/lib/multiarray/rgb.rb

@@ -475,7 +475,7 @@ module Hornetseye
         if values.all? { |value| value.is_a? RGB or value.is_a? Float or
                                  value.is_a? Integer }
           if values.any? { |value| value.is_a? RGB }
-            elements = values.inject( [] ) do |arr,value|
+            elements = values.inject([]) do |arr,value|
               if value.is_a? RGB
                 arr + [ value.r, value.g, value.b ]
               else

data/lib/multiarray/unmask.rb

@@ -141,9 +141,9 @@ module Hornetseye
     def strip
       stripped = [ @dest, @source, @m, @index, @default ].
         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 ] } )
+      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

data/test/tc_multiarray.rb

@@ -336,7 +336,9 @@ class TC_MultiArray < Test::Unit::TestCase
 
   def test_inject
     assert_equal 21, M[[1, 2, 3], [4, 5, 6]].inject { |a,b| a + b }
+    assert_equal 21, M[[1, 2, 3], [4, 5, 6]].inject(:+)
     assert_equal 28, M[[1, 2, 3], [4, 5, 6]].inject(7) { |a,b| a + b }
+    assert_equal 28, M[[1, 2, 3], [4, 5, 6]].inject(7, :+)
   end
 
   def test_collect

data/test/tc_sequence.rb

@@ -265,7 +265,9 @@ 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 6, S[ 1, 2, 3 ].inject(:+)
+    assert_equal 10, S[ 1, 2, 3 ].inject(4) { |a,b| a + b }
+    assert_equal 10, S[ 1, 2, 3 ].inject(4, :+)
     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 }

metadata

@@ -1,12 +1,8 @@
 --- !ruby/object:Gem::Specification 
 name: multiarray
 version: !ruby/object:Gem::Version 
-  prerelease: false
-  segments: 
-  - 0
-  - 23
-  - 1
-  version: 0.23.1
+  prerelease: 
+  version: 0.23.2
 platform: ruby
 authors: 
 - Jan Wedekind
@@ -14,8 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-06-29 00:00:00 +01:00
-default_executable: 
+date: 2011-06-29 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: malloc
@@ -25,9 +20,6 @@ dependencies:
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        segments: 
-        - 1
-        - 1
         version: "1.1"
   type: :runtime
   version_requirements: *id001
@@ -39,8 +31,6 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        segments: 
-        - 0
         version: "0"
   type: :development
   version_requirements: *id002
@@ -106,7 +96,6 @@ files:
 - test/tc_bool.rb
 - test/tc_rgb.rb
 - test/tc_sequence.rb
-has_rdoc: yard
 homepage: http://wedesoft.github.com/multiarray/
 licenses: []
 
@@ -120,21 +109,17 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      segments: 
-      - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      segments: 
-      - 0
       version: "0"
 requirements: []
 
 rubyforge_project: hornetseye
-rubygems_version: 1.3.7
+rubygems_version: 1.8.5
 signing_key: 
 specification_version: 3
 summary: Multi-dimensional and uniform Ruby arrays