multiarray 0.4.1 → 0.5.0

data/lib/multiarray/element.rb

@@ -0,0 +1,146 @@
+# 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
+
+  # Base class for representing native elements
+  class Element < Node
+
+    class << self
+
+      # Retrieve element from memory
+      #
+      # @param [Malloc,List] ptr Memory to load element from.
+      #
+      # @see Malloc#load
+      # @see List#load
+      def fetch( ptr )
+        new ptr.load( self )
+      end
+
+      # Type coercion for native elements
+      #
+      # @param [Node] other Other native datatype to coerce with.
+      #
+      # @return [Array<Node>] Result of coercion.
+      def coercion( other )
+        if self == other
+          self
+        else
+          x, y = other.coerce self
+          x.coercion y
+        end
+      end
+
+    end
+
+    # Constructor initialising element with a value
+    #
+    # @param [Object] value Initial value for element.
+    def initialize( value = self.class.default )
+      @value = value
+    end
+
+    # Get unique descriptor of this object
+    #
+    # @param [Hash] hash Labels for any variables.
+    #
+    # @return [String] Descriptor of this object,
+    #
+    # @private
+    def descriptor( hash )
+      "#{self.class.to_s}(#{@value.to_s})"
+    end
+
+    # Reevaluate computation
+    #
+    # @return [Node,Object] Result of computation
+    #
+    # @see #force
+    #
+    # @private
+    def dup
+      if @value.respond_to? :duplicate
+        self.class.new @value.duplicate( self.class )
+      else
+        self.class.new @value
+      end
+    end
+
+    # Strip of all values
+    #
+    # Split up into variables, values, and a term where all values have been
+    # replaced with variables.
+    #
+    # @return [Array<Array,Node>] Returns an array of variables, an array of
+    # values, and the term based on variables.
+    #
+    # @private
+    def strip
+      variable = Variable.new self.class
+      return [ variable ], [ self ], variable
+    end
+
+    # Check whether this term is compilable
+    #
+    # @return [FalseClass,TrueClass] Returns whether this term is compilable.
+    #
+    # @private
+    def compilable?
+      if @value.respond_to? :compilable?
+        @value.compilable?
+      else
+        super
+      end
+    end
+
+    # Get value of this native element
+    #
+    # @return [Object] Value of this native element.
+    def get
+      @value
+    end
+
+    # Store a value in this native element
+    #
+    # @param [Object] value New value for native element.
+    #
+    # @return [Object] Returns +value+.
+    def store( value )
+      if @value.respond_to? :store
+        @value.store value.simplify.get
+      else
+        @value = value.simplify.get
+      end
+      value
+    end
+
+    # Write element to memory
+    #
+    # @param [Malloc,List] ptr Memory to write element to.
+    #
+    # @see Malloc#save
+    # @see List#save
+    #
+    # @private
+    def write( ptr )
+      ptr.save self
+    end
+
+  end
+
+end

data/lib/multiarray/gcccache.rb

@@ -0,0 +1,23 @@
+# 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 GCCCache
+  end
+
+end

data/lib/multiarray/gcccontext.rb

@@ -0,0 +1,144 @@
+# 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 GCCContext
+
+    LDSHARED = Config::CONFIG[ 'LDSHARED' ] # c:\mingw\bin\gcc
+    STRIP = Config::CONFIG[ 'STRIP' ]
+    RUBYHDRDIR = Config::CONFIG.member?( 'rubyhdrdir' ) ?
+      "-I#{Config::CONFIG['rubyhdrdir']} " +
+      "-I#{Config::CONFIG['rubyhdrdir']}/#{Config::CONFIG['arch']}" :
+      "-I#{Config::CONFIG['archdir']}"
+    LIBRUBYARG = Config::CONFIG[ 'LIBRUBYARG' ]
+    DIRNAME = "#{Dir.tmpdir}/hornetseye-ruby#{RUBY_VERSION}-#{ENV[ 'USER' ]}"
+    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}"
+    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
+
+    class << self
+
+      def build( &action )
+        lib_name, @@lib_name = @@lib_name, @@lib_name.succ
+        new( lib_name ).build &action
+      end
+
+    end
+
+    def initialize( lib_name )
+      @lib_name = lib_name
+      @instructions = ''
+      @wrappers = ''
+      @registrations = ''
+    end
+
+    def build( &action )
+      action.call self
+    end
+
+    def function( descriptor, *param_types )
+      @instructions << <<EOS
+void #{descriptor}(#{
+if param_types.empty?
+  ''
+else
+  ' ' + ( 0 ... param_types.size ).collect do |i|
+    "#{param_types[ i ].identifier} 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
+} )
+{
+  #{descriptor}(#{
+if param_types.empty?
+  ''
+else
+  s = ' ' + ( 0 ... param_types.size ).collect do |i|
+    param_types[ i ].r2c "rbParam#{i}"
+  end.join( ', ' ) + ' '
+end
+});
+  return Qnil;
+}
+EOS
+
+      @registrations << <<EOS
+  rb_define_singleton_method( cGCCCache, "#{descriptor}",
+                              RUBY_METHOD_FUNC( wrap#{descriptor.capitalize} ),
+                              #{param_types.size} ); 
+EOS
+    end
+    def compile
+      template = <<EOS
+#include <ruby.h>
+
+inline void *mallocToPtr( VALUE rbMalloc )
+{
+  VALUE rbValue = rb_iv_get( rbMalloc, "@value" );
+  void *retVal; Data_Get_Struct( rbValue, void, retVal );
+  return retVal;
+}
+
+#{@instructions}
+
+#{@wrappers}
+void Init_#{@lib_name}(void)
+{
+  VALUE mHornetseye = rb_define_module( "Hornetseye" );
+  VALUE cGCCCache = rb_define_class_under( mHornetseye, "GCCCache", rb_cObject );
+#{@registrations}
+}
+EOS
+      # File::EXCL no overwrite
+      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}"
+      strip = "#{STRIP} #{DIRNAME}/#{@lib_name}.so"
+      # puts template
+      raise "Error compiling #{DIRNAME}/#{@lib_name}.c" unless system gcc
+      raise "Error stripping #{DIRNAME}/#{@lib_name}.so" unless system strip
+      require "#{DIRNAME}/#{@lib_name}.so"
+    end
+
+    def <<( str )
+      @instructions << str
+      self
+    end
+
+  end
+
+end

data/lib/multiarray/gccfunction.rb

@@ -0,0 +1,109 @@
+# 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 GCCFunction
+
+    class << self
+
+      def run( block )
+        keys, values, term = block.strip
+        labels = Hash[ *keys.zip( ( 0 ... keys.size ).to_a ).flatten ]
+        retval = block.pointer_type.new
+        retval_keys, retval_values, retval_term = retval.strip
+        method_name = '_' + term.descriptor( labels ).
+                      tr( '(),+\-*/.@?~&|^<>',
+                          '0123\456789ABCDEF' )
+        unless GCCCache.respond_to? method_name
+          GCCContext.build do |context|
+            function = new context, method_name,
+                           *( retval_keys + keys ).collect { |var| var.meta }
+            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 }
+            Hornetseye::lazy do
+              retval_term.subst( retval_subst ).store term.subst( term_subst )
+            end
+            function.insn_return
+            function.compile
+          end
+        end
+        args = ( retval_values + values ).collect { |arg| arg.get }
+        GCCCache.send method_name, *args
+        retval.simplify
+      end
+
+    end
+
+    def initialize( context, method_name, *param_types )
+      context.function method_name, *param_types.collect { |t| GCCType.new t }
+      @context = context
+      @method_name = method_name
+      @param_types = param_types
+      @indent = 1
+      @ids = 0
+    end
+
+    def compile
+      self << '}'
+      @context.compile
+      self
+    end
+
+    def id( prefix )
+      @ids += 1
+      "%s%02d"% [ prefix, @ids ]
+    end
+
+    def variable( typecode, prefix )
+      retval = typecode.new GCCValue.new( self, id( prefix ) )
+      self << "#{indent}#{GCCType.new( typecode ).identifier} #{retval.get};\n"
+      retval
+    end
+
+    def indent
+      '  ' * @indent
+    end
+
+    def indent_offset( offset )
+      @indent += offset
+    end
+
+    def param( i )
+      @param_types[ i ].new GCCValue.new( self, "param#{i}" )
+    end
+
+    def call( *args )
+      @context.send @method_name, *args.collect { |v| v.get }
+    end
+
+    def insn_return( value = nil )
+      self << "#{indent}return#{ value ? ' ' + value.get.to_s : '' };\n"
+    end
+
+    def <<( str )
+      @context << str
+      self
+    end
+
+  end
+  
+end

data/lib/multiarray/gcctype.rb

@@ -0,0 +1,73 @@
+# 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 GCCType
+
+    def initialize( typecode )
+      @typecode = typecode
+    end
+
+    def identifier
+      case @typecode
+      when nil
+        'void'
+      when BOOL
+        'char'
+      when BYTE
+        'char'
+      when UBYTE
+        'unsigned char'
+      when SINT
+        'short int'
+      when USINT
+        'unsigned short int'
+      when INT
+        'int'
+      when UINT
+        'unsigned int'
+      else
+        if @typecode < Pointer_
+          'void *'
+        elsif @typecode < INDEX_
+          'int'
+        else
+          raise "No identifier available for #{@typecode.inspect}"
+        end
+      end
+    end
+
+    def r2c( expr )
+      case @typecode
+      when BOOL
+        "( #{expr} ) != Qfalse"
+      when BYTE, UBYTE, SINT, USINT, INT, UINT
+        "NUM2INT( #{expr} )"
+      else
+        if @typecode < Pointer_
+          "(#{identifier})mallocToPtr( #{expr} )"
+        else
+          raise "No conversion available for #{@typecode.inspect}"
+        end
+      end
+    end
+
+  end
+
+end
+