multiarray 0.5.1 → 0.5.2

data/lib/multiarray/composite.rb

@@ -0,0 +1,65 @@
+# multiarray - Lazy multi-dimensional arrays for Ruby
+# Copyright (C) 2010 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
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+# Namespace of Hornetseye computer vision library
+module Hornetseye
+
+  class Composite < Element
+
+    class << self
+
+      attr_accessor :element_type
+
+      attr_accessor :num_elements
+
+      def memory
+        element_type.memory
+      end
+
+      def storage_size
+        element_type.storage_size * num_elements
+      end
+
+      def directive
+        element_type.directive * num_elements
+      end
+
+      def descriptor( hash )
+        unless element_type.nil?
+          inspect
+        else
+          super
+        end
+      end
+
+      def basetype
+        element_type
+      end
+
+      def typecodes
+        [ element_type ] * num_elements
+      end
+
+      def scalar
+        element_type
+      end
+
+    end
+
+  end
+
+end
+

data/lib/multiarray/diagonal.rb

@@ -20,6 +20,14 @@ module Hornetseye
   # Class for representing diagonal injections
   class Diagonal < Node
 
+    class << self
+
+      def finalised?
+        false
+      end
+
+    end
+
     # Constructor
     #
     # @param [Node] value Initial value of injection

data/lib/multiarray/element.rb

@@ -56,7 +56,7 @@ module Hornetseye
     #
     # @param [Object] value Initial value for element.
     def initialize( value = self.class.default )
-      if Thread.current[ :function ].nil? or value.is_a? GCCValue
+      if Thread.current[ :function ].nil?
         @value = value
       else
         @value = GCCValue.new Thread.current[ :function ], value.to_s
@@ -84,8 +84,8 @@ module Hornetseye
     def dup
       if Thread.current[ :function ]
         value = Thread.current[ :function ].variable self.class, 'v'
-        value.get.store get
-        value
+        value.store get
+        self.class.new value
       else
         self.class.new get
       end

data/lib/multiarray/{unarymethod.rb → elementwise.rb}

@@ -17,31 +17,30 @@
 # Namespace of Hornetseye computer vision library
 module Hornetseye
 
-  # Class for applying a unary method to scalars and arrays
-  class UnaryMethod_ < Node
+  class ElementWise_ < Node
 
     class << self
 
-      # Name of module
-      #
-      # @return [Module] The module with the method.
-      attr_accessor :mod
-
       # Name of operation
       #
-      # @return [Symbol,String] The name of this operation.
+      # @return [Proc] A closure with the operation.
       attr_accessor :operation
 
+      # Unique key to identify operation.
+      #
+      # @return [Symbol,String] A unique key to identify this operation.
+      attr_accessor :key
+
       # Name of method for type conversion
       #
-      # @return [Symbol,String] The name of the method for type conversion.
+      # @return [Proc] A closure for doing the type conversion.
       attr_accessor :conversion
 
       # Get string with information about this class
       #
       # @return [String] Return string with information about this class.
       def inspect
-        "#{mod.to_s}.#{operation.to_s}"
+        key.to_s
       end
 
       # Get unique descriptor of this class
@@ -55,13 +54,18 @@ module Hornetseye
         inspect
       end
 
+      def finalised?
+        false
+      end
+
     end
 
     # Initialise unary operation
     #
     # @param [Node] value Value to apply operation to.
-    def initialize( value )
-      @value = value
+    def initialize( *values )
+      @values = values
+      check_shape *values
     end
 
     # Get unique descriptor of this object
@@ -72,7 +76,8 @@ module Hornetseye
     #
     # @private
     def descriptor( hash )
-      "#{self.class.descriptor( hash )}(#{@value.descriptor( hash )})"
+      "#{self.class.descriptor( hash )}" +
+        "(#{@values.collect { |value| value.descriptor( hash ) }.join ','})"
     end
 
     # Array type of this term
@@ -81,7 +86,19 @@ module Hornetseye
     #
     # @private
     def array_type
-      @value.array_type.send self.class.conversion
+      array_types = @values.collect { |value| value.array_type }
+      self.class.conversion.call *array_types
+    end
+
+    # Reevaluate computation
+    #
+    # @return [Node,Object] Result of computation
+    #
+    # @see #force
+    #
+    # @private
+    def demand
+      self.class.operation.call *@values
     end
 
     # Substitute variables
@@ -94,7 +111,7 @@ module Hornetseye
     #
     # @private
     def subst( hash )
-      self.class.new @value.subst( hash )
+      self.class.new *@values.collect { |value| value.subst( hash ) }
     end
 
     # Get variables contained in this term
@@ -103,7 +120,7 @@ module Hornetseye
     #
     # @private
     def variables
-      @value.variables
+      @values.inject( Set[] ) { |vars,value| vars + value.variables }
     end
 
     # Strip of all values
@@ -116,23 +133,15 @@ module Hornetseye
     #
     # @private
     def strip
-      vars, values, term = @value.strip
-      return vars, values, self.class.new( term )
-    end
-
-    # Reevaluate computation
-    #
-    # @return [Node,Object] Result of computation
-    #
-    # @see #force
-    #
-    # @private
-    def demand
-      self.class.mod.send self.class.operation, @value
+      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 ] } )
     end
 
     def skip( index, start )
-      self.class.new( @value.skip( index, start ) ).demand
+      skipped = *@values.collect { |value| value.skip( index, start ) }
+      self.class.new( *skipped ).demand
     end
 
     # Get element of unary operation
@@ -141,11 +150,22 @@ module Hornetseye
     #
     # @return [Node,Object] Element of unary operation.
     def element( i )
-      self.class.new( @value.element( i ) ).demand
+      values = @values.collect do |value|
+        value.dimension == 0 ? value : value.element( i )
+      end
+      self.class.new( *values ).demand
     end
 
     def slice( start, length )
-      self.class.new( @value.slice( start, length ) ).demand
+      values = @values.collect do |value|
+        value.dimension == 0 ? value : value.slice( start, length )
+      end
+      self.class.new( *values ).demand
+    end
+
+    def decompose
+      values = @values.collect { |value| value.decompose }
+      self.class.new( *values ).demand
     end
 
     # Check whether this term is compilable
@@ -154,32 +174,34 @@ module Hornetseye
     #
     # @private
     def compilable?
-      @value.compilable?
+      array_type.compilable? and @values.all? { |value| value.compilable? }
     end
 
   end
 
-  # Create a class deriving from +UnaryMethod_+
+  # Create a class deriving from +ElementWise_+
   #
-  # @param [Symbol,String] operation Name of operation.
-  # @param [Symbol,String] conversion Name of method for type conversion.
+  # @param [Proc] operation A closure with the operation to perform.
+  # @param [Symbol,String] key A unique descriptor to identify this operation.
+  # @param [Proc] conversion A closure for performing the type conversion.
   #
-  # @return [Class] A class deriving from +UnaryMethod_+.
+  # @return [Class] A class deriving from +ElementWise_+.
   #
-  # @see UnaryMethod_
-  # @see UnaryMethod_.operation
-  # @see UnaryMethod_.conversion
+  # @see ElementWise_
+  # @see ElementWise_.operation
+  # @see ElementWise_.key
+  # @see ElementWise_.conversion
   #
   # @private
-  def UnaryMethod( mod, operation, conversion = :contiguous )
-    retval = Class.new UnaryMethod_
-    retval.mod = mod
+  def ElementWise( operation, key, conversion = lambda { |t| t.send :contiguous } )
+    retval = Class.new ElementWise_
     retval.operation = operation
+    retval.key = key
     retval.conversion = conversion
     retval
   end
 
-  module_function :UnaryMethod
+  module_function :ElementWise
 
 end
 

data/lib/multiarray/gccfunction.rb

@@ -21,25 +21,29 @@ module Hornetseye
 
     class << self
 
-      def run( block )
+      def run( retval, block )
         keys, values, term = block.strip
-        labels = Hash[ *keys.zip( ( 0 ... keys.size ).to_a ).flatten ]
-        retval = block.pointer_type.new
+        labels = Hash[ *keys.
+                       zip( ( 0 ... keys.size ).to_a ).flatten ]
         retval_keys, retval_values, retval_term = retval.strip
-        method_name = '_' + term.descriptor( labels ).
-                      tr( '(),+\-*/.@?~&|^<=>',
-                          '0123\456789ABCDEFG' )
+        retval_labels = Hash[ *retval_keys.
+                              zip( ( 0 ... retval_keys.size ).to_a ).flatten ]
+        method_name = ( '_' + retval_term.descriptor( retval_labels ) +
+                        '_' + term.descriptor( labels ) ).
+                      tr( '(),+\-*/%.@?~&|^<=>',
+                          '0123\456789ABCDEFGH' )
         unless GCCCache.respond_to? method_name
           GCCContext.build do |context|
             function = new context, method_name,
                            *( retval_keys + keys ).collect { |var| var.meta }
+            Thread.current[ :function ] = function
             term_subst = ( 0 ... keys.size ).collect do |i|
               { keys[i] => function.param( i + retval_keys.size ) }
             end.inject( {} ) { |a,b| a.merge b }
             retval_subst = ( 0 ... retval_keys.size ).collect do |i|
               { retval_keys[ i ] => function.param( i ) }
             end.inject( {} ) { |a,b| a.merge b }
-            Thread.current[ :function ] = function
+            # Thread.current[ :function ] = function
             Hornetseye::lazy do
               retval_term.subst( retval_subst ).store term.subst( term_subst )
             end
@@ -76,19 +80,9 @@ module Hornetseye
     end
 
     def variable( typecode, prefix )
-      #if typecode == INTRGB
-      #  r = GCCValue.new( self, id( prefix ) )
-      #  g = GCCValue.new( self, id( prefix ) )
-      #  b = GCCValue.new( self, id( prefix ) )
-      #  self << "#{indent}#{GCCType.new( INT ).identifier} #{r};\n"
-      #  self << "#{indent}#{GCCType.new( INT ).identifier} #{g};\n"
-      #  self << "#{indent}#{GCCType.new( INT ).identifier} #{b};\n"
-      #  INTRGB.new RGB.new( r, g, b )
-      #else
-        retval = typecode.new GCCValue.new( self, id( prefix ) )
-        self << "#{indent}#{GCCType.new( typecode ).identifiers.first} #{retval.get};\n" # !!!
-        retval
-      #end
+      retval = GCCValue.new( self, id( prefix ) )
+      self << "#{indent}#{GCCType.new( typecode ).identifiers.first} #{retval};\n" # !!!
+      retval
     end
 
     def indent

data/lib/multiarray/gcctype.rb

@@ -50,8 +50,8 @@ module Hornetseye
           [ 'void *' ]
         elsif @typecode < INDEX_
           [ 'int' ]
-        elsif @typecode < RGB_
-          GCCType.new( @typecode.element_type ).identifiers * 3
+        elsif @typecode < Composite
+          GCCType.new( @typecode.element_type ).identifiers * @typecode.num_elements
         else
           raise "No identifier available for #{@typecode.inspect}"
         end
@@ -61,16 +61,16 @@ module Hornetseye
     def r2c
       case @typecode
       when BOOL
-        [ proc { |expr| "( #{expr} ) != Qfalse" } ]
+        [ lambda { |expr| "( #{expr} ) != Qfalse" } ]
       when BYTE, UBYTE, SINT, USINT, INT, UINT
-        [ proc { |expr| "NUM2INT( #{expr} )" } ]
+        [ lambda { |expr| "NUM2INT( #{expr} )" } ]
       when SFLOAT, DFLOAT
-        [ proc { |expr| "NUM2DBL( #{expr} )" } ]
+        [ lambda { |expr| "NUM2DBL( #{expr} )" } ]
       else
         if @typecode < Pointer_
-          [ proc { |expr| "(#{identifiers.first})mallocToPtr( #{expr} )" } ] # !!!
-        elsif @typecode < RGB_
-          GCCType.new( @typecode.element_type ).r2c * 3
+          [ lambda { |expr| "(#{identifiers.first})mallocToPtr( #{expr} )" } ] # !!!
+        elsif @typecode < Composite
+          GCCType.new( @typecode.element_type ).r2c * @typecode.num_elements
         else
           raise "No conversion available for #{@typecode.inspect}"
         end

data/lib/multiarray/gccvalue.rb

@@ -62,7 +62,8 @@ module Hornetseye
         mod.module_eval do
           define_method( "#{op}_with_gcc" ) do |a,b|
             if a.is_a? GCCValue or b.is_a? GCCValue
-              GCCValue.new a.function, "#{opcode}( #{a}, #{b} )"
+              function = a.is_a?( GCCValue ) ? a.function : b.function
+              GCCValue.new function, "#{opcode}( #{a}, #{b} )"
             else
               send "#{op}_without_gcc", a, b
             end
@@ -117,6 +118,18 @@ module Hornetseye
       end
     end
 
+    def conj
+      self
+    end
+
+    def abs
+      ( self >= 0 ).conditional self, -self
+    end
+
+    def arg
+      ( self >= 0 ).conditional 0, Math::PI
+    end
+
     def r
       self
     end
@@ -129,6 +142,14 @@ module Hornetseye
       self
     end
 
+    def real
+      self
+    end
+
+    def imag
+      0
+    end
+
     def conditional( a, b )
       GCCValue.new @function, "( #{self} ) ? ( #{a} ) : ( #{b} )"
     end
@@ -147,6 +168,7 @@ module Hornetseye
     define_binary_op :-
     define_binary_op :*
     define_binary_op :/
+    define_binary_op :%
     define_binary_op :eq, :==
     define_binary_op :ne, '!='
     define_binary_op :<
@@ -168,6 +190,34 @@ module Hornetseye
     define_binary_method Math, :atan2
     define_binary_method Math, :hypot
 
+    def zero?
+      GCCValue.new @function, "( #{self} ) == 0"
+    end
+
+    def nonzero?
+      GCCValue.new @function, "( #{self} ) != 0"
+    end
+
+    def floor
+      GCCValue.new @function, "floor( #{self} )"
+    end
+
+    def ceil
+      GCCValue.new @function, "ceil( #{self} )"
+    end
+
+    def round
+      GCCValue.new @function, "round( #{self} )"
+    end
+
+    def **( other )
+      if GCCValue.generic? other
+        GCCValue.new @function, "pow( #{self}, #{other} )"
+      else
+        x, y = other.coerce self
+        x ** y
+      end
+    end
 
     def major( other )
       GCCValue.new @function,
@@ -179,20 +229,12 @@ module Hornetseye
         "( ( #{self} ) <= ( #{other} ) ) ? ( #{self} ) : ( #{other} )"
     end
 
-    def zero?
-      GCCValue.new @function, "( #{self} ) == 0"
-    end
-
-    def nonzero?
-      GCCValue.new @function, "( #{self} ) != 0"
-    end
-
     def times( &action )
       i = @function.variable INT, 'i'
-      @function << "#{@function.indent}for ( #{i.get} = 0; " +
-                   "#{i.get} != #{self}; #{i.get}++ ) {\n"
+      @function << "#{@function.indent}for ( #{i} = 0; " +
+                   "#{i} != #{self}; #{i}++ ) {\n"
       @function.indent_offset +1
-      action.call i.get
+      action.call i
       @function.indent_offset -1
       @function << "#{@function.indent}};\n"
       self
@@ -200,10 +242,10 @@ module Hornetseye
 
     def upto( other, &action )
       i = @function.variable INT, 'i'
-      @function << "#{@function.indent}for ( #{i.get} = #{self}; " +
-                   "#{i.get} != #{ other + 1 }; #{i.get}++ ) {\n"
+      @function << "#{@function.indent}for ( #{i} = #{self}; " +
+                   "#{i} != #{ other + 1 }; #{i}++ ) {\n"
       @function.indent_offset +1
-      action.call i.get
+      action.call i
       @function.indent_offset -1
       @function << "#{@function.indent}};\n"
       self