multiarray 0.5.0 → 0.5.1

data/lib/multiarray/{binary.rb → binaryop.rb}

@@ -18,7 +18,7 @@
 module Hornetseye
 
   # Class for representing binary operations on scalars and arrays
-  class Binary_ < Node
+  class BinaryOp_ < Node
 
     class << self
 
@@ -47,7 +47,7 @@ module Hornetseye
       #
       # @private
       def descriptor( hash )
-        operation.to_s
+        inspect
       end
 
     end
@@ -68,7 +68,8 @@ module Hornetseye
     #
     # @private
     def descriptor( hash )
-      "(#{@value1.descriptor( hash )}).#{self.class.descriptor( hash )}(#{@value2.descriptor( hash )})"
+      "(#{@value1.descriptor( hash )}).#{self.class.descriptor( hash )}" +
+        "(#{@value2.descriptor( hash )})"
     end
 
     # Array type of this term
@@ -128,6 +129,12 @@ module Hornetseye
       @value1.send self.class.operation, @value2
     end
 
+    def skip( index, start )
+      element1 = @value1.skip( index, start )
+      element2 = @value2.skip( index, start )
+      self.class.new( element1, element2 ).demand
+    end
+
     # Get element of unary operation
     #
     # @param [Integer,Node] i Index of desired element.
@@ -136,7 +143,15 @@ module Hornetseye
     def element( i )
       element1 = @value1.dimension == 0 ? @value1 : @value1.element( i )
       element2 = @value2.dimension == 0 ? @value2 : @value2.element( i )
-      element1.send self.class.operation, element2
+      self.class.new( element1, element2 ).demand
+    end
+
+    def slice( start, length )
+      element1 = @value1.dimension == 0 ? @value1 :
+                                          @value1.slice( start, length )
+      element2 = @value2.dimension == 0 ? @value2 :
+                                          @value2.slice( start, length )
+      self.class.new( element1, element2 ).demand
     end
 
     # Check whether this term is compilable
@@ -150,25 +165,25 @@ module Hornetseye
 
   end
 
-  # Create a class deriving from +Binary_+
+  # Create a class deriving from +BinaryOp_+
   #
   # @param [Symbol,String] operation Name of operation.
   # @param [Symbol,String] conversion Name of method for type conversion.
   #
-  # @return [Class] A class deriving from +Binary_+.
+  # @return [Class] A class deriving from +BinaryOp_+.
   #
-  # @see Binary_
-  # @see Binary_.operation
-  # @see Binary_.coercion
+  # @see BinaryOp_
+  # @see BinaryOp_.operation
+  # @see BinaryOp_.coercion
   #
   # @private
-  def Binary( operation, coercion = :coercion )
-    retval = Class.new Binary_
+  def BinaryOp( operation, coercion = :coercion )
+    retval = Class.new BinaryOp_
     retval.operation = operation
     retval.coercion = coercion
     retval
   end
 
-  module_function :Binary
+  module_function :BinaryOp
 
 end

data/lib/multiarray/bool.rb

@@ -36,7 +36,7 @@ module Hornetseye
       #
       # @private
       def descriptor( hash )
-        'BOOL'
+        inspect
       end
 
       # Retrieve element from memory
@@ -49,7 +49,7 @@ module Hornetseye
       #
       # @private
       def fetch( ptr )
-        new ptr.load( self ).ne( 0 )
+        new ptr.load( self ).first.ne( 0 )
       end
 
       # Memory type required to store elements of this type
@@ -135,4 +135,10 @@ module Hornetseye
 
   end
 
+  def BOOL( value )
+    BOOL.new value
+  end
+
+  module_function :BOOL
+
 end

data/lib/multiarray/diagonal.rb

@@ -24,7 +24,8 @@ module Hornetseye
     #
     # @param [Node] value Initial value of injection
     # @param [Node] index0 Index for 
-    def initialize( value, index0, index1, index2, initial, block, var1, var2 )
+    def initialize( value, index0, index1, index2, initial, block, var1,
+                    var2 )
       @value, @index0, @index1, @index2, @initial, @block, @var1, @var2 =
         value, index0, index1, index2, initial, block, var1, var2
     end
@@ -37,12 +38,14 @@ module Hornetseye
     #
     # @private
     def descriptor( hash )
-      hash = hash.merge @index0 => ( ( hash.values.max || 0 ) + 1 )
       hash = hash.merge @index1 => ( ( hash.values.max || 0 ) + 1 )
       hash = hash.merge @index2 => ( ( hash.values.max || 0 ) + 1 )
       hash = hash.merge @var1 => ( ( hash.values.max || 0 ) + 1 )
       hash = hash.merge @var2 => ( ( hash.values.max || 0 ) + 1 )
-      "Diagonal(#{@value.descriptor( hash )},#{@initial ? @initial.descriptor( hash ) : 'nil'},#{@block.descriptor( hash )})"
+      "Diagonal(#{@value.descriptor( hash )},#{@index0.descriptor( hash )}," +
+        "#{@index1.descriptor( hash )},#{@index2.descriptor( hash )}," +
+        "#{@initial ? @initial.descriptor( hash ) : 'nil'}," +
+        "#{@block.descriptor( hash )})"
     end
 
     # Array type of this term
@@ -62,18 +65,21 @@ module Hornetseye
     #
     # @private
     def demand
-      retval = @initial
-      offset = @index2.size.get / 2
-      @index2.size.get.times do |j|
-        k = j - offset
-        i = @index0.get - k
-        if i >= 0 and i < @index1.size.get
-          sub = @value.subst( @index1 => INT.new( i ),
-                              @index2 => INT.new( j ) ).simplify
-          retval = retval ? @block.subst( @var1 => retval,
-                                          @var2 => sub ).simplify :
-            sub
-        end
+      s1 = @index2.size / 2
+      j0 = INT.new( 0 ).major( @index0 + s1 + 1 - @index1.size )
+      if @initial
+        retval = @initial.simplify
+      else
+        j = j0.get
+        i = @index0.get + s1.get - j
+        retval = @value.subst( @index1 => INT.new( i ),
+                               @index2 => INT.new( j ) ).simplify
+        j0 = ( j0 + 1 ).simplify
+      end
+      j0.upto( ( @index2.size - 1 ).minor( @index0 + s1 ) ) do |j|
+        i = @index0.get + s1.get - j
+        sub = @value.subst @index1 => INT.new( i ), @index2 => INT.new( j ) 
+        retval.store @block.subst( @var1 => retval, @var2 => sub )
       end
       retval
     end
@@ -95,13 +101,7 @@ module Hornetseye
     # @private
     def variables
       initial_variables = @initial ? @initial.variables : Set[]
-      @value.variables + initial_variables - 
-        ( @index1.variables + @index2.variables )
-    end
-
-    def variables
-      initial_variables = @initial ? @initial.variables : Set[]
-      @value.variables + initial_variables - 
+      @value.variables + initial_variables + @index0.variables - 
         ( @index1.variables + @index2.variables )
     end
 
@@ -115,9 +115,10 @@ module Hornetseye
     #
     # @private
     def strip
-      vars1, values1, term1 = @value.strip
       meta_vars1, meta_values1, var1 = @index1.strip
       meta_vars2, meta_values2, var2 = @index2.strip
+      vars1, values1, term1 =
+        @value.subst( @index1 => var1, @index2 => var2 ).strip
       if @initial
         vars2, values2, term2 = @initial.strip
       else
@@ -126,8 +127,7 @@ module Hornetseye
       vars3, values3, term3 = @block.strip
       return vars1 + meta_vars1 + meta_vars2 + vars2 + vars3,
         values1 + meta_values1 + meta_values2 + values2 + values3,
-        Diagonal.new( term1.subst( @index1 => var1, @index2 => var2 ),
-                      @index0, var1, var2, term2, term3, @var1, @var2 )
+        Diagonal.new( term1, @index0, var1, var2, term2, term3, @var1, @var2 )
     end
 
     # Substitute variables
@@ -145,7 +145,7 @@ module Hornetseye
       subst_var2 = @index2.subst hash
       value = @value.subst( @index0 => subst_var0, @index1 => subst_var1,
                             @index2 => subst_var2 ).subst hash
-      initial = @intial ? @initial.subst( hash ) : nil
+      initial = @initial ? @initial.subst( hash ) : nil
       block = @block.subst hash
       Diagonal.new value, subst_var0, subst_var1, subst_var2, initial,
         block, @var1, @var2
@@ -159,7 +159,6 @@ module Hornetseye
     def compilable?
       initial_compilable = @initial ? @initial.compilable? : true
       @value.compilable? and initial_compilable and @block.compilable?
-      false # !!!
     end
 
   end

data/lib/multiarray/element.rb

@@ -29,7 +29,11 @@ module Hornetseye
       # @see Malloc#load
       # @see List#load
       def fetch( ptr )
-        new ptr.load( self )
+        construct *ptr.load( self )
+      end
+
+      def construct( *args )
+        new *args
       end
 
       # Type coercion for native elements
@@ -52,7 +56,11 @@ module Hornetseye
     #
     # @param [Object] value Initial value for element.
     def initialize( value = self.class.default )
-      @value = value
+      if Thread.current[ :function ].nil? or value.is_a? GCCValue
+        @value = value
+      else
+        @value = GCCValue.new Thread.current[ :function ], value.to_s
+      end
     end
 
     # Get unique descriptor of this object
@@ -74,10 +82,12 @@ module Hornetseye
     #
     # @private
     def dup
-      if @value.respond_to? :duplicate
-        self.class.new @value.duplicate( self.class )
+      if Thread.current[ :function ]
+        value = Thread.current[ :function ].variable self.class, 'v'
+        value.get.store get
+        value
       else
-        self.class.new @value
+        self.class.new get
       end
     end
 
@@ -108,6 +118,10 @@ module Hornetseye
       end
     end
 
+    def skip( index, start )
+      self
+    end
+
     # Get value of this native element
     #
     # @return [Object] Value of this native element.
@@ -141,6 +155,10 @@ module Hornetseye
       ptr.save self
     end
 
+    def values
+      [ @value ]
+    end
+
   end
 
 end

data/lib/multiarray/float.rb

@@ -0,0 +1,142 @@
+# 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 FLOAT_ < Element
+
+    class << self
+
+      attr_accessor :double
+
+      def memory
+        Malloc
+      end
+
+      def storage_size
+        double ? 8 : 4
+      end
+
+      def default
+        0.0
+      end
+
+      def coercion( other )
+        if other < FLOAT_
+          Hornetseye::FLOAT( ( double or other.double ) )
+        elsif other < INT_
+          self
+        else
+          super other
+        end
+      end
+
+      def coerce( other )
+        if other < FLOAT_
+          return other, self
+        elsif other < INT_
+          return self, self
+        else
+          super other
+        end
+      end
+
+      def float
+        self
+      end
+
+      def directive
+        double ? 'd' : 'f'
+      end
+
+      def inspect
+        "#{ double ? 'D' : 'S' }FLOAT"
+      end
+
+      def descriptor( hash )
+        inspect
+      end
+
+      def ==( other )
+        other.is_a? Class and other < FLOAT_ and double == other.double
+      end
+
+      def hash
+        [ :FLOAT_, double ].hash
+      end
+
+      def eql?( other )
+        self == other
+      end
+
+    end
+
+  end
+
+  module Match
+
+    def fit( *values )
+      if values.all? { |value| value.is_a? Float or value.is_a? Integer }
+        if values.any? { |value| value.is_a? Float }
+          DFLOAT
+        else
+          super *values
+        end
+      else
+        super *values
+      end
+    end
+
+    def align( context )
+      if self < FLOAT_ and context < FLOAT_
+        context
+      else
+        super context
+      end
+    end
+
+  end
+
+  Node.extend Match
+
+  SINGLE = false
+  DOUBLE = true
+
+  def FLOAT( double )
+    retval = Class.new FLOAT_
+    retval.double = double
+    retval
+  end
+
+  module_function :FLOAT
+
+  SFLOAT = FLOAT SINGLE
+  DFLOAT = FLOAT DOUBLE
+
+  def SFLOAT( value )
+    SFLOAT.new value
+  end
+
+  module_function :SFLOAT
+
+  def DFLOAT( value )
+    DFLOAT.new value
+  end
+
+  module_function :DFLOAT
+
+end

data/lib/multiarray/gcccontext.rb

@@ -26,20 +26,23 @@ module Hornetseye
       "-I#{Config::CONFIG['rubyhdrdir']}/#{Config::CONFIG['arch']}" :
       "-I#{Config::CONFIG['archdir']}"
     LIBRUBYARG = Config::CONFIG[ 'LIBRUBYARG' ]
-    DIRNAME = "#{Dir.tmpdir}/hornetseye-ruby#{RUBY_VERSION}-#{ENV[ 'USER' ]}"
+    DIRNAME = "#{Dir.tmpdir}/hornetseye-ruby#{RUBY_VERSION}-" +
+              "#{ENV[ 'USER' ] || ENV[ 'USERNAME' ]}"
+    LOCKFILE = "#{DIRNAME}/lock"
     Dir.mkdir DIRNAME, 0700 unless File.exist? DIRNAME
-    @@dir = File.new DIRNAME
-    unless @@dir.flock File::LOCK_EX | File::LOCK_NB
-      raise "Could not lock directory #{DIRNAME}"
+    @@lock = File.new LOCKFILE, 'w', 0600
+    unless @@lock.flock File::LOCK_EX | File::LOCK_NB
+      raise "Could not lock file \"#{LOCKFILE}\""
     end
-    @@dir.chmod 0700
 
     @@lib_name = 'hornetseye_aaaaaaaa'
 
-    # while File.exist? "#{DIRNAME}/#{@@lib_name}.so"
-    #   require "#{DIRNAME}/#{@@lib_name}.so"        
-    #   @@lib_name = @@lib_name.succ
-    # end
+    if ENV[ 'HORNETSEYE_PRELOAD_CACHE' ]
+      while File.exist? "#{DIRNAME}/#{@@lib_name}.so"
+        require "#{DIRNAME}/#{@@lib_name}.so"        
+        @@lib_name = @@lib_name.succ
+      end
+    end
 
     class << self
 
@@ -67,26 +70,26 @@ void #{descriptor}(#{
 if param_types.empty?
   ''
 else
-  ' ' + ( 0 ... param_types.size ).collect do |i|
-    "#{param_types[ i ].identifier} param#{i}"
+  ' ' + param_types.collect do |t|
+    t.identifiers
+  end.flatten.collect_with_index do |ident,i|
+    "#{ident} param#{i}"
   end.join( ', ' ) + ' '
 end
 }) {
 EOS
 
       @wrappers << <<EOS
-VALUE wrap#{descriptor.capitalize}( VALUE rbSelf#{
-( 0 ... param_types.size ).inject '' do |s,i|
-   s << ", VALUE rbParam#{i}"
-end
-} )
+VALUE wrap#{descriptor.capitalize}( int argc, VALUE *argv, VALUE rbSelf )
 {
   #{descriptor}(#{
 if param_types.empty?
   ''
 else
-  s = ' ' + ( 0 ... param_types.size ).collect do |i|
-    param_types[ i ].r2c "rbParam#{i}"
+  s = ' ' + param_types.collect do |t|
+    t.r2c
+  end.flatten.collect_with_index do |conv,i|
+    conv.call "argv[ #{i} ]"
   end.join( ', ' ) + ' '
 end
 });
@@ -96,18 +99,17 @@ EOS
 
       @registrations << <<EOS
   rb_define_singleton_method( cGCCCache, "#{descriptor}",
-                              RUBY_METHOD_FUNC( wrap#{descriptor.capitalize} ),
-                              #{param_types.size} ); 
+                    RUBY_METHOD_FUNC( wrap#{descriptor.capitalize} ), -1 ); 
 EOS
     end
     def compile
       template = <<EOS
 #include <ruby.h>
+#include <math.h>
 
 inline void *mallocToPtr( VALUE rbMalloc )
 {
-  VALUE rbValue = rb_iv_get( rbMalloc, "@value" );
-  void *retVal; Data_Get_Struct( rbValue, void, retVal );
+  void *retVal; Data_Get_Struct( rbMalloc, void, retVal );
   return retVal;
 }
 
@@ -117,7 +119,8 @@ inline void *mallocToPtr( VALUE rbMalloc )
 void Init_#{@lib_name}(void)
 {
   VALUE mHornetseye = rb_define_module( "Hornetseye" );
-  VALUE cGCCCache = rb_define_class_under( mHornetseye, "GCCCache", rb_cObject );
+  VALUE cGCCCache = rb_define_class_under( mHornetseye, "GCCCache",
+                                           rb_cObject );
 #{@registrations}
 }
 EOS
@@ -125,8 +128,9 @@ EOS
       File.open "#{DIRNAME}/#{@lib_name}.c", 'w', 0600 do |f|
         f << template
       end
-      gcc = "#{LDSHARED} -fPIC #{RUBYHDRDIR} -o #{DIRNAME}/#{@lib_name}.so " +
-        "#{DIRNAME}/#{@lib_name}.c #{LIBRUBYARG}"
+      gcc = "#{LDSHARED} -fPIC #{RUBYHDRDIR} -O " +
+            "-o #{DIRNAME}/#{@lib_name}.so " +
+            "#{DIRNAME}/#{@lib_name}.c #{LIBRUBYARG}"
       strip = "#{STRIP} #{DIRNAME}/#{@lib_name}.so"
       # puts template
       raise "Error compiling #{DIRNAME}/#{@lib_name}.c" unless system gcc