multiarray 0.22.0 → 0.23.1

data/lib/multiarray/object.rb

@@ -1,5 +1,5 @@
 # multiarray - Lazy multi-dimensional arrays for Ruby
-# Copyright (C) 2010 Jan Wedekind
+# 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
@@ -77,11 +77,7 @@ module Hornetseye
       #
       # @private
       def coercion( other )
-        if other < Sequence_
-          other.coercion self
-        else
-          self
-        end
+        self
       end
 
       # Type coercion for native elements

data/lib/multiarray/operations.rb

@@ -1,5 +1,5 @@
 # multiarray - Lazy multi-dimensional arrays for Ruby
-# Copyright (C) 2010, 2011 Jan Wedekind
+# Copyright (C) 2010, 2011, 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
@@ -17,59 +17,59 @@
 # Namespace of Hornetseye computer vision library
 module Hornetseye
 
-  # Module providing the operations to manipulate array expressions
-  module Operations
+  # Base class for representing native datatypes and operations (terms)
+  class Node
 
-    # Meta-programming method to define a unary operation
-    #
-    # @param [Symbol,String] op Name of unary operation.
-    # @param [Symbol,String] conversion Name of method for type conversion.
-    #
-    # @return [Proc] The new method.
-    #
-    # @private
-    def define_unary_op( op, conversion = :identity )
-      define_method( op ) do
-        if dimension == 0 and variables.empty?
-          target = typecode.send conversion
-          target.new simplify.get.send( op )
-        else
-          Hornetseye::ElementWise( lambda { |x| x.send op }, op,
-                                   lambda { |t| t.send conversion } ).
-            new( self ).force
+    class << self
+
+      # Meta-programming method to define a unary operation
+      #
+      # @param [Symbol,String] op Name of unary operation.
+      # @param [Symbol,String] conversion Name of method for type conversion.
+      #
+      # @return [Proc] The new method.
+      #
+      # @private
+      def define_unary_op(op, conversion = :identity)
+        Node.class_eval do
+          define_method op do
+            if dimension == 0 and variables.empty?
+              target = typecode.send conversion
+              target.new simplify.get.send(op)
+            else
+              Hornetseye::ElementWise(lambda { |x| x.send op }, op,
+                                      lambda { |t| t.send conversion }).
+                new(self).force
+            end
+          end
         end
       end
-    end
-
-    module_function :define_unary_op
 
-    # Meta-programming method to define a binary operation
-    #
-    # @param [Symbol,String] op Name of binary operation.
-    # @param [Symbol,String] conversion Name of method for type conversion.
-    #
-    # @return [Proc] The new method.
-    #
-    # @private
-    def define_binary_op( op, coercion = :coercion )
-      define_method( op ) do |other|
-        unless other.is_a? Node
-          other = Node.match( other, typecode ).new other
-        end
-        if dimension == 0 and variables.empty? and
-            other.dimension == 0 and other.variables.empty?
-          target = array_type.send coercion, other.array_type
-          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 } ).
-            new( self, other ).force
+      # Meta-programming method to define a binary operation
+      #
+      # @param [Symbol,String] op Name of binary operation.
+      # @param [Symbol,String] conversion Name of method for type conversion.
+      #
+      # @return [Proc] The new method.
+      #
+      # @private
+      def define_binary_op(op, coercion = :coercion)
+        define_method op do |other|
+          other = Node.match(other, typecode).new other unless other.matched?
+          if dimension == 0 and variables.empty? and
+              other.dimension == 0 and other.variables.empty?
+            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 } ).
+              new(sexp, other.sexp).force
+          end
         end
       end
-    end
-
-    module_function :define_binary_op
 
+    end
+  
     define_unary_op :zero?, :bool
     define_unary_op :nonzero?, :bool
     define_unary_op :not, :bool
@@ -101,7 +101,6 @@ module Hornetseye
     define_binary_op :<, :coercion_bool
     define_binary_op :>=, :coercion_bool
     define_binary_op :>, :coercion_bool
-    define_binary_op :<=>, :coercion_byte
     define_binary_op :minor
     define_binary_op :major
 
@@ -121,9 +120,7 @@ module Hornetseye
     #
     # @return [Node] Array with result of operation.
     def fmod_with_float( other )
-      unless other.is_a? Node
-        other = Node.match( other, typecode ).new other
-      end
+      other = Node.match( other, typecode ).new other unless other.matched?
       if typecode < FLOAT_ or other.typecode < FLOAT_
         fmod other
       else
@@ -138,14 +135,14 @@ module Hornetseye
     # @param [Class] dest Element type to convert to.
     #
     # @return [Node] Array based on the different element type.
-    def to_type( dest )
+    def to_type(dest)
       if dimension == 0 and variables.empty?
         target = typecode.to_type dest
-        target.new( simplify.get ).simplify
+        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
+                                 lambda { |t| t.to_type dest } ).new(self).force
       end
     end
 
@@ -156,12 +153,12 @@ module Hornetseye
     # @param [Class] dest Element type to convert to.
     #
     # @return [Node] Array based on the different element type.
-    def to_type_with_rgb( dest )
+    def to_type_with_rgb(dest)
       if typecode < RGB_
         if dest < FLOAT_
           lazy { r * 0.299 + g * 0.587 + b * 0.114 }.to_type dest
         elsif dest < INT_
-          lazy { ( r * 0.299 + g * 0.587 + b * 0.114 ).round }.to_type dest
+          lazy { (r * 0.299 + g * 0.587 + b * 0.114).round }.to_type dest
         else
           to_type_without_rgb dest
         end
@@ -197,13 +194,13 @@ module Hornetseye
     # @param [Array<Integer>] ret_shape Desired shape of return value
     #
     # @return [Node] Array with desired shape.
-    def reshape( *ret_shape )
-      target = Hornetseye::MultiArray( typecode, *ret_shape )
-      if target.size != size
-        raise "#{target.size} is of size #{target.size} but should be of size " +
-          "#{size}"
+    def reshape(*ret_shape)
+      target_size = ret_shape.inject { |a,b| a * b }
+      if target_size != size
+        raise "Target is of size #{target_size} but should be of size #{size}"
       end
-      target.new memorise.memory
+      Hornetseye::MultiArray(typecode, ret_shape.size).
+        new *(ret_shape + [:memory => memorise.memory])
     end
 
     # Element-wise conditional selection of values
@@ -212,24 +209,19 @@ module Hornetseye
     # @param [Node] b Second array of values.
     #
     # @return [Node] Array with selected values.
-    def conditional( a, b )
-      unless a.is_a? Node
-        a = Node.match( a, b.is_a?( Node ) ? b : nil ).new a
-      end
-      unless b.is_a? Node
-        b = Node.match( b, a.is_a?( Node ) ? a : nil ).new b
-      end
+    def conditional(a, b)
+      a = Node.match(a, b.matched? ? b : nil).new a unless a.matched?
+      b = Node.match(b, a.matched? ? a : nil).new b unless b.matched?
       if dimension == 0 and variables.empty? and
         a.dimension == 0 and a.variables.empty? and
         b.dimension == 0 and b.variables.empty?
-        target = array_type.cond a.array_type, b.array_type
-        #target.new simplify.get.conditional( a.simplify.get, b.simplify.get )
-        target.new simplify.get.conditional( proc { a.simplify.get },
-                                             proc { b.simplify.get } )
+        target = typecode.cond a.typecode, b.typecode
+        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 } ).
-          new( self, a, b ).force
+        Hornetseye::ElementWise(lambda { |x,y,z| x.conditional y, z }, :conditional,
+                                lambda { |t,u,v| t.cond u, v }).
+          new(self, a.sexp, b.sexp).force
       end
     end
 
@@ -266,10 +258,10 @@ module Hornetseye
     # @param [Node] other Array with values to compare with.
     #
     # @return [Node] Array with results.
-    def <=>( other )
-      Hornetseye::finalise do
-        ( self < other ).conditional -1, ( self > other ).conditional( 1, 0 )
-      end
+    def <=>(other)
+      Hornetseye::lazy do
+        (self < other).conditional -1, (self > other).conditional(1, 0)
+      end.force
     end
 
     # Lazy transpose of array
@@ -329,7 +321,7 @@ module Hornetseye
     def collect( &action )
       var = Variable.new typecode
       block = action.call var
-      conversion = lambda { |t| t.to_type action.call( Variable.new( t.typecode ) ) }
+      conversion = lambda { |t| t.to_type action.call(Variable.new(t.typecode)).typecode }
       Hornetseye::ElementWise( action, block.to_s, conversion ).new( self ).force
     end
 
@@ -351,7 +343,7 @@ module Hornetseye
     # @return [Object] Result of injection.
     def inject( initial = nil, options = {} )
       unless initial.nil?
-        initial = Node.match( initial ).new initial unless initial.is_a? Node
+        initial = Node.match( initial ).new initial unless initial.matched?
         initial_typecode = initial.typecode
       else
         initial_typecode = typecode
@@ -369,7 +361,7 @@ module Hornetseye
         index = Variable.new Hornetseye::INDEX( nil )
         value = element( index ).inject nil, :block => block,
                                         :var1 => var1, :var2 => var2
-        value = typecode.new value unless value.is_a? Node
+        value = typecode.new value unless value.matched?
         if initial.nil? and index.size.get == 0
           raise "Array was empty and no initial value for injection was given"
         end
@@ -388,11 +380,11 @@ module Hornetseye
     # Equality operator
     #
     # @return [Boolean] Returns result of comparison.
-    def eq_with_multiarray( other )
-      if other.is_a? Node
+    def eq_with_multiarray(other)
+      if other.matched?
         if variables.empty?
-          if other.array_type == array_type
-            Hornetseye::finalise { eq( other ).inject( true ) { |a,b| a.and b } }
+          if other.typecode == typecode and other.shape == shape
+            Hornetseye::finalise { eq(other).inject( true ) { |a,b| a.and b } }
           else
             false
           end
@@ -515,9 +507,7 @@ module Hornetseye
         demand
       else
         if initial
-          unless initial.is_a? Node
-            initial = Node.match( initial ).new initial
-          end
+          initial = Node.match( initial ).new initial unless initial.matched?
           initial_typecode = initial.typecode
         else
           initial_typecode = typecode
@@ -532,7 +522,7 @@ module Hornetseye
           diagonal initial, :block => block, :var1 => var1, :var2 => var2
         term = Diagonal.new( value, index0, index1, index2, initial,
                              block, var1, var2 )
-        index0.size[] ||= index1.size[]
+        index0.size = index1.size
         Lambda.new( index0, term ).force
       end
     end
@@ -550,7 +540,7 @@ module Hornetseye
     #
     # @private
     def table( filter, &action )
-      filter = Node.match( filter, typecode ).new filter unless filter.is_a? Node
+      filter = Node.match( filter, typecode ).new filter unless filter.matched?
       if filter.dimension > dimension
         raise "Filter has #{filter.dimension} dimension(s) but should " +
               "not have more than #{dimension}"
@@ -569,10 +559,10 @@ module Hornetseye
     #
     # @return [Node] Result of convolution.
     def convolve( filter )
-      filter = Node.match( filter, typecode ).new filter unless filter.is_a? Node
+      filter = Node.match( filter, typecode ).new filter unless filter.matched?
       array = self
-      ( dimension - filter.dimension ).times { array = array.roll }
-      array.table( filter ) { |a,b| a* b }.diagonal { |s,x| s + x }
+      (dimension - filter.dimension).times { array = array.roll }
+      array.table(filter.sexp) { |a,b| a * b }.diagonal { |s,x| s + x }
     end
 
     # Erosion
@@ -606,8 +596,8 @@ module Hornetseye
     # @return [Node] Result of Sobel operator.
     def sobel( direction )
       ( dimension - 1 ).downto( 0 ).inject self do |retval,i|
-        filter = i == direction ? Hornetseye::Sequence( SINT, 3 )[ 1, 0, -1 ] :
-                                  Hornetseye::Sequence( SINT, 3 )[ 1, 2, 1 ]
+        filter = i == direction ? Hornetseye::Sequence(SINT)[1, 0, -1] :
+                                  Hornetseye::Sequence(SINT)[1, 2,  1]
         Hornetseye::lazy { retval.convolve filter }
       end.force
     end
@@ -660,9 +650,8 @@ module Hornetseye
     def histogram( *ret_shape )
       options = ret_shape.last.is_a?( Hash ) ? ret_shape.pop : {}
       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 ]
+      unless options[:weight].matched?
+        options[:weight] = Node.match(options[:weight]).maxint.new options[:weight]
       end
       if ( shape.first != 1 or dimension == 1 ) and ret_shape.size == 1
         [ self ].histogram *( ret_shape + [ options ] )
@@ -718,8 +707,8 @@ module Hornetseye
     #
     # @return [Node] The integral image of this array.
     def integral
-      left = pointer_type.new
-      block = Integral.new left, self
+      left = allocate
+      block = Integral.new left.sexp, self
       if block.compilable?
         GCCFunction.run block
       else
@@ -741,20 +730,21 @@ module Hornetseye
       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
+      default = typecode.new default unless default.matched?
+      left = Hornetseye::MultiArray(target, dimension).new *shape
       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
+      block = Components.new left.sexp, self, default.sexp, target.new(0),
+                             labels.sexp, rank.sexp, 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 )
+      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
@@ -768,13 +758,13 @@ module Hornetseye
                                          [ m.size ] )
       index = Hornetseye::Pointer( INT ).new
       index.store INT.new( 0 )
-      block = Mask.new left, self, m, index
+      block = Mask.new left.sexp, self, m.sexp, index
       if block.compilable?
         GCCFunction.run block
       else
         block.demand
       end
-      left[ 0 ... index[] ].roll
+      left[0 ... index[]].roll
     end
 
     # Distribute values in a new array using a mask
@@ -788,8 +778,8 @@ module Hornetseye
     # @return [Node] The result of the inverse masking operation.
     def unmask( m, options = {} )
       options = { :safe => true, :default => typecode.default }.merge options
-      default = options[ :default ]
-      default = typecode.new default unless default.is_a? Node
+      default = options[:default]
+      default = typecode.new default unless default.matched?
       m.check_shape default
       if options[ :safe ]
         if m.to_ubyte.sum > shape.last
@@ -797,11 +787,11 @@ module Hornetseye
             "dimension of the array for unmasking only has #{shape.last} value(s)"
         end
       end
-      left = Hornetseye::MultiArray( array_type.element_type, *m.shape ).
-             coercion( default.array_type ).new
-      index = Hornetseye::Pointer( INT ).new
-      index.store INT.new( 0 )
-      block = Unmask.new left, self, m, index, default
+      left = Hornetseye::MultiArray(typecode, dimension - 1 + m.dimension).
+        coercion(default.typecode).new *(shape[1 .. -1] + m.shape)
+      index = Hornetseye::Pointer(INT).new
+      index.store INT.new(0)
+      block = Unmask.new left.sexp, self, m.sexp, index, default.sexp
       if block.compilable?
         GCCFunction.run block
       else
@@ -836,7 +826,7 @@ module Hornetseye
         raise "#{offset.size} offset(s) were given but array has " +
               "#{dimension} dimension(s)"
       end
-      retval = array_type.new
+      retval = Hornetseye::MultiArray(typecode, dimension).new *shape
       target, source, open, close = [], [], [], []
       ( shape.size - 1 ).step( 0, -1 ) do |i|
         callcc do |pass|
@@ -905,12 +895,6 @@ module Hornetseye
 
   end
 
-  class Node
-
-    include Operations
-
-  end
-
 end
 
 # The +Array+ class is extended with a few methods
@@ -929,8 +913,8 @@ class Array
   def histogram( *ret_shape )
     options = ret_shape.last.is_a?( Hash ) ? ret_shape.pop : {}
     options = { :weight => Hornetseye::UINT. new( 1 ), :safe => true }.merge options
-    unless options[ :weight ].is_a? Hornetseye::Node
-      options[ :weight ] =
+    unless options[:weight].matched?
+      options[:weight] =
         Hornetseye::Node.match( options[ :weight ] ).maxint.new options[ :weight ]
     end
     weight = options[ :weight ]
@@ -939,9 +923,8 @@ class Array
         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
+      source_type = inject { |a,b| a.dimension > b.dimension ? a : b }
+      source_type.check_shape *self
       source_type.check_shape options[ :weight ]
       for i in 0 ... size
         range = self[ i ].range 0 ... ret_shape[ i ]
@@ -955,9 +938,9 @@ class Array
         end
       end
     end
-    left = Hornetseye::MultiArray.new weight.typecode, *ret_shape
+    left = Hornetseye::MultiArray(weight.typecode, ret_shape.size).new *ret_shape
     left[] = 0
-    block = Hornetseye::Histogram.new left, weight, *self
+    block = Hornetseye::Histogram.new left.sexp, weight.sexp, *self
     if block.compilable?
       Hornetseye::GCCFunction.run block
     else
@@ -980,9 +963,8 @@ class Array
         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
+      source_type = inject { |a,b| a.dimension > b.dimension ? a : b }
+      source_type.check_shape *self
       for i in 0 ... size
         offset = table.dimension - size
         range = self[ i ].range 0 ... table.shape[ i + offset ]