multiarray 0.5.0 → 0.5.1

data/lib/multiarray/gccfunction.rb

@@ -27,8 +27,8 @@ module Hornetseye
         retval = block.pointer_type.new
         retval_keys, retval_values, retval_term = retval.strip
         method_name = '_' + term.descriptor( labels ).
-                      tr( '(),+\-*/.@?~&|^<>',
-                          '0123\456789ABCDEF' )
+                      tr( '(),+\-*/.@?~&|^<=>',
+                          '0123\456789ABCDEFG' )
         unless GCCCache.respond_to? method_name
           GCCContext.build do |context|
             function = new context, method_name,
@@ -39,14 +39,16 @@ module Hornetseye
             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
             Hornetseye::lazy do
               retval_term.subst( retval_subst ).store term.subst( term_subst )
             end
+            Thread.current[ :function ] = nil
             function.insn_return
             function.compile
           end
         end
-        args = ( retval_values + values ).collect { |arg| arg.get }
+        args = ( retval_values + values ).collect { |arg| arg.values }.flatten
         GCCCache.send method_name, *args
         retval.simplify
       end
@@ -74,9 +76,19 @@ module Hornetseye
     end
 
     def variable( typecode, prefix )
-      retval = typecode.new GCCValue.new( self, id( prefix ) )
-      self << "#{indent}#{GCCType.new( typecode ).identifier} #{retval.get};\n"
-      retval
+      #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
     end
 
     def indent
@@ -88,7 +100,12 @@ module Hornetseye
     end
 
     def param( i )
-      @param_types[ i ].new GCCValue.new( self, "param#{i}" )
+      offset = ( 0 ... i ).inject( 0 ) do |s,idx|
+        s + GCCType.new( @param_types[ idx ] ).identifiers.size
+      end
+      args = ( 0 ... GCCType.new( @param_types[ i ] ).identifiers.size ).
+        collect { |idx| GCCValue.new self, "param#{ offset + idx }" }
+      @param_types[ i ].construct *args
     end
 
     def call( *args )

data/lib/multiarray/gcctype.rb

@@ -23,44 +23,54 @@ module Hornetseye
       @typecode = typecode
     end
 
-    def identifier
+    def identifiers
       case @typecode
       when nil
-        'void'
+        [ 'void' ]
       when BOOL
-        'char'
+        [ 'char' ]
       when BYTE
-        'char'
+        [ 'char' ]
       when UBYTE
-        'unsigned char'
+        [ 'unsigned char' ]
       when SINT
-        'short int'
+        [ 'short int' ]
       when USINT
-        'unsigned short int'
+        [ 'unsigned short int' ]
       when INT
-        'int'
+        [ 'int' ]
       when UINT
-        'unsigned int'
+        [ 'unsigned int' ]
+      when SFLOAT
+        [ 'float' ]
+        when DFLOAT
+        [ 'double' ]
       else
         if @typecode < Pointer_
-          'void *'
+          [ 'void *' ]
         elsif @typecode < INDEX_
-          'int'
+          [ 'int' ]
+        elsif @typecode < RGB_
+          GCCType.new( @typecode.element_type ).identifiers * 3
         else
           raise "No identifier available for #{@typecode.inspect}"
         end
       end
     end
 
-    def r2c( expr )
+    def r2c
       case @typecode
       when BOOL
-        "( #{expr} ) != Qfalse"
+        [ proc { |expr| "( #{expr} ) != Qfalse" } ]
       when BYTE, UBYTE, SINT, USINT, INT, UINT
-        "NUM2INT( #{expr} )"
+        [ proc { |expr| "NUM2INT( #{expr} )" } ]
+      when SFLOAT, DFLOAT
+        [ proc { |expr| "NUM2DBL( #{expr} )" } ]
       else
         if @typecode < Pointer_
-          "(#{identifier})mallocToPtr( #{expr} )"
+          [ proc { |expr| "(#{identifiers.first})mallocToPtr( #{expr} )" } ] # !!!
+        elsif @typecode < RGB_
+          GCCType.new( @typecode.element_type ).r2c * 3
         else
           raise "No conversion available for #{@typecode.inspect}"
         end
@@ -70,4 +80,4 @@ module Hornetseye
   end
 
 end
-  
+ 

data/lib/multiarray/gccvalue.rb

@@ -19,6 +19,64 @@ module Hornetseye
   
   class GCCValue
 
+    class << self
+
+      def generic?( value )
+        value.is_a?( GCCValue ) or value.is_a?( Fixnum ) or
+          value.is_a?( Float )
+      end
+
+      def define_unary_op( op, opcode = op )
+        define_method( op ) do
+          GCCValue.new @function, "#{opcode}( #{self} )"
+        end
+      end
+
+      def define_unary_method( mod, op, opcode = op )
+        mod.module_eval do
+          define_method( "#{op}_with_gcc" ) do |a|
+            if a.is_a? GCCValue
+              GCCValue.new a.function, "#{opcode}( #{a} )"
+            else
+              send "#{op}_without_gcc", a
+            end
+          end
+          alias_method_chain op, :gcc
+          module_function "#{op}_without_gcc"
+          module_function op
+        end
+      end
+
+      def define_binary_op( op, opcode = op )
+        define_method( op ) do |other|
+          if GCCValue.generic? other
+            GCCValue.new @function, "( #{self} ) #{opcode} ( #{other} )"
+          else
+            x, y = other.coerce self
+            x.send op, y
+          end
+        end
+      end
+
+      def define_binary_method( mod, op, opcode = op )
+        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} )"
+            else
+              send "#{op}_without_gcc", a, b
+            end
+          end
+          alias_method_chain op, :gcc
+          module_function "#{op}_without_gcc"
+          module_function op
+        end
+      end
+
+    end
+
+    attr_reader :function
+
     def initialize( function, descriptor ) 
       @function = function
       @descriptor = descriptor
@@ -32,19 +90,6 @@ module Hornetseye
       @descriptor
     end
 
-    # Store result of computation in new variable
-    #
-    # @return [Node,Object] Result of computation
-    #
-    # @see #force
-    #
-    # @private
-    def duplicate( typecode )
-      result = @function.variable( typecode, 'v' ).get
-      result.store self
-      result
-    end
-
     def store( value )
       @function << "#{@function.indent}#{self} = #{value};\n"
       value
@@ -55,79 +100,83 @@ module Hornetseye
     end
 
     def load( typecode )
-      GCCValue.new @function, "*(#{GCCType.new( typecode ).identifier} *)( #{self} )"
+      offset = 0
+      typecode.typecodes.collect do |t|
+        value = GCCValue.new @function,
+          "*(#{GCCType.new( t ).identifiers.first} *)( #{self} + #{offset} )" # !!!
+        offset += t.storage_size
+        value
+      end
     end
 
     def save( value )
-      @function << "#{@function.indent}*(#{GCCType.new( value.typecode ).identifier} *)( #{self} ) = #{value.get};\n"
-    end
-
-    def eq( other )
-      GCCValue.new @function, "( #{self} ) == ( #{other} )"
-    end
-
-    def ne( other )
-      GCCValue.new @function, "( #{self} ) != ( #{other} )"
-    end
-
-    def conditional( a, b )
-      GCCValue.new @function, "( #{self} ) ? ( #{a} ) : ( #{b} )"
-    end
-
-    def not
-      GCCValue.new @function, "!( #{self} )"
-    end
-
-    def ~
-      GCCValue.new @function, "~( #{self} )"
-    end
-
-    def and( other )
-      GCCValue.new @function, "( #{self} ) && ( #{other} )"
-    end
-
-    def or( other )
-      GCCValue.new @function, "( #{self} ) || ( #{other} )"
-    end
-
-    def &( other )
-      GCCValue.new @function, "( #{self} ) & ( #{other} )"
-    end
-
-    def |( other )
-      GCCValue.new @function, "( #{self} ) | ( #{other} )"
-    end
-
-    def ^( other )
-      GCCValue.new @function, "( #{self} ) ^ ( #{other} )"
+      offset = 0
+      value.class.typecodes.zip( value.values ).each do |t,v|
+        @function << "#{@function.indent}*(#{GCCType.new( t ).identifiers.first} *)( #{self} + #{offset} ) = #{v};\n" # !!!
+        offset += t.storage_size
+      end
     end
 
-    def <<( other )
-      GCCValue.new @function, "( #{self} ) << ( #{other} )"
+    def r
+      self
     end
 
-    def >>( other )
-      GCCValue.new @function, "( #{self} ) >> ( #{other} )"
+    def g
+      self
     end
 
-    def -@
-      GCCValue.new @function, "-( #{self} )"
+    def b
+      self
     end
 
-    def +( other )
-      GCCValue.new @function, "( #{self} ) + ( #{other} )"
-    end
-
-    def -( other )
-      GCCValue.new @function, "( #{self} ) - ( #{other} )"
-    end
-
-    def *( other )
-      GCCValue.new @function, "( #{self} ) * ( #{other} )"
+    def conditional( a, b )
+      GCCValue.new @function, "( #{self} ) ? ( #{a} ) : ( #{b} )"
     end
 
-    def /( other )
-      GCCValue.new @function, "( #{self} ) / ( #{other} )"
+    define_unary_op :not, '!'
+    define_unary_op :~
+    define_unary_op :-@, :-
+    define_binary_op :and, '&&'
+    define_binary_op :or, '||'
+    define_binary_op :&
+    define_binary_op :|
+    define_binary_op :^
+    define_binary_op :<<
+    define_binary_op :>>
+    define_binary_op :+
+    define_binary_op :-
+    define_binary_op :*
+    define_binary_op :/
+    define_binary_op :eq, :==
+    define_binary_op :ne, '!='
+    define_binary_op :<
+    define_binary_op :<=
+    define_binary_op :>
+    define_binary_op :>=
+    define_unary_method Math, :sqrt
+    define_unary_method Math, :log
+    define_unary_method Math, :exp
+    define_unary_method Math, :cos
+    define_unary_method Math, :sin
+    define_unary_method Math, :tan
+    define_unary_method Math, :acos
+    define_unary_method Math, :asin
+    define_unary_method Math, :atan
+    define_unary_method Math, :cosh
+    define_unary_method Math, :sinh
+    define_unary_method Math, :tanh
+    define_binary_method Math, :atan2
+    define_binary_method Math, :hypot
+
+
+    def major( other )
+      GCCValue.new @function,
+        "( ( #{self} ) >= ( #{other} ) ) ? ( #{self} ) : ( #{other} )"
+    end
+
+    def minor( other )
+      GCCValue.new @function,
+        "( ( #{self} ) <= ( #{other} ) ) ? ( #{self} ) : ( #{other} )"
     end
 
     def zero?
@@ -140,11 +189,32 @@ module Hornetseye
 
     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.get} = 0; " +
+                   "#{i.get} != #{self}; #{i.get}++ ) {\n"
+      @function.indent_offset +1
+      action.call i.get
+      @function.indent_offset -1
+      @function << "#{@function.indent}};\n"
+      self
+    end
+
+    def upto( other, &action )
+      i = @function.variable INT, 'i'
+      @function << "#{@function.indent}for ( #{i.get} = #{self}; " +
+                   "#{i.get} != #{ other + 1 }; #{i.get}++ ) {\n"
       @function.indent_offset +1
       action.call i.get
       @function.indent_offset -1
       @function << "#{@function.indent}};\n"
+      self
+    end
+
+    def coerce( other )
+      if other.is_a? GCCValue
+        return other, self
+      else
+        return GCCValue.new( @function, "( #{other} )" ), self
+      end
     end
 
   end

data/lib/multiarray/inject.rb

@@ -35,7 +35,9 @@ module Hornetseye
       hash = hash.merge @index => ( ( hash.values.max || 0 ) + 1 )
       hash = hash.merge @var1 => ( ( hash.values.max || 0 ) + 1 )
       hash = hash.merge @var2 => ( ( hash.values.max || 0 ) + 1 )
-      "Inject(#{@value.descriptor( hash )},#{@initial ? @initial.descriptor( hash ) : 'nil'},#{@index.descriptor( hash )},#{@block.descriptor( hash )})"
+      "Inject(#{@value.descriptor( hash )}," +
+         "#{@initial ? @initial.descriptor( hash ) : 'nil'}," +
+         "#{@index.descriptor( hash )},#{@block.descriptor( hash )})"
     end
 
     def array_type
@@ -52,18 +54,14 @@ module Hornetseye
     def demand
       if @initial
         retval = @initial.simplify # !!!
-        @index.size.get.times do |i|
-          sub = @value.subst( @index => INT.new( i ) ).simplify # !!!
-          retval.store @block.subst( @var1 => retval,
-                                     @var2 => sub ).simplify
-        end
+        offset = INT.new 0
       else
         retval = @value.subst( @index => INT.new( 0 ) ).simplify # !!!
-        ( @index.size - 1 ).get.times do |i|
-          sub = @value.subst( @index => INT.new( i ) + 1 ).simplify # !!!
-          retval.store @block.subst( @var1 => retval,
-                                     @var2 => sub ).simplify
-        end
+        offset = INT.new 1
+      end
+      offset.upto @index.size - 1 do |i|
+        sub = @value.subst @index => INT.new( i )
+        retval.store @block.subst( @var1 => retval, @var2 => sub )
       end
       retval
     end
@@ -97,18 +95,17 @@ module Hornetseye
     #
     # @private
     def strip
-      vars1, values1, term1 = @value.strip
+      meta_vars, meta_values, var = @index.strip
+      vars1, values1, term1 = @value.subst( @index => var ).strip
       if @initial
         vars2, values2, term2 = @initial.strip
       else
         vars2, values2 = [], [], nil
       end
       vars3, values3, term3 = @block.strip
-      meta_vars, meta_values, var = @index.strip
       return vars1 + vars2 + vars3 + meta_vars,
         values1 + values2 + values3 + meta_values,
-        Inject.new( term1.subst( @index => var ),
-                    var, term2, term3, @var1, @var2 )
+        Inject.new( term1, var, term2, term3, @var1, @var2 )
     end
  
     # Substitute variables