multiarray 0.4.1 → 0.5.0

data/lib/multiarray/gccvalue.rb

@@ -0,0 +1,152 @@
+# 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 GCCValue
+
+    def initialize( function, descriptor ) 
+      @function = function
+      @descriptor = descriptor
+    end
+
+    def inspect
+      @descriptor
+    end
+
+    def to_s
+      @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
+    end
+
+    def compilable?
+      false
+    end
+
+    def load( typecode )
+      GCCValue.new @function, "*(#{GCCType.new( typecode ).identifier} *)( #{self} )"
+    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} )"
+    end
+
+    def <<( other )
+      GCCValue.new @function, "( #{self} ) << ( #{other} )"
+    end
+
+    def >>( other )
+      GCCValue.new @function, "( #{self} ) >> ( #{other} )"
+    end
+
+    def -@
+      GCCValue.new @function, "-( #{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} )"
+    end
+
+    def /( other )
+      GCCValue.new @function, "( #{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.indent_offset +1
+      action.call i.get
+      @function.indent_offset -1
+      @function << "#{@function.indent}};\n"
+    end
+
+  end
+
+end

data/lib/multiarray/index.rb

@@ -0,0 +1,91 @@
+# 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 INDEX_ < Element
+
+    class << self
+
+      # Size of range for this index
+      #
+      # @return [Object] Size of range for this index.
+      attr_accessor :size
+
+      def inspect
+        "INDEX(#{size.inspect})"
+      end
+
+      # Get unique descriptor of this class
+      #
+      # @param [Hash] hash Labels for any variables.
+      #
+      # @return [String] Descriptor of this class.
+      #
+      # @private
+      def descriptor( hash )
+        "INDEX(#{size.descriptor( hash )})"
+      end
+
+      def array_type
+        INT
+      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
+        meta_vars, meta_values = size.strip
+        if meta_vars.empty?
+          return [], [], self
+        else
+          return meta_vars, meta_values, Hornetseye::INDEX( meta_vars.first )
+        end
+      end
+
+      def subst( hash )
+        Hornetseye::INDEX size.subst( hash )
+      end
+
+      def variables
+        size.variables
+      end
+
+    end
+
+    def initialize
+      raise "#{self.class.inspect} must not be instantiated"
+    end
+
+  end
+
+  def INDEX( size )
+    retval = Class.new INDEX_
+    size = INT.new( size ) unless size.is_a? Node
+    retval.size = size
+    retval
+  end
+
+  module_function :INDEX
+
+end

data/lib/multiarray/inject.rb

@@ -0,0 +1,143 @@
+# 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 Inject < Node
+
+    def initialize( value, index, initial, block, var1, var2 )
+      @value, @index, @initial, @block, @var1, @var2 =
+        value, index, initial, block, var1, var2
+    end
+
+    # Get unique descriptor of this object
+    #
+    # @param [Hash] hash Labels for any variables.
+    #
+    # @return [String] Descriptor of this object,
+    #
+    # @private
+    def descriptor( hash )
+      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 )})"
+    end
+
+    def array_type
+      @value.array_type
+    end
+
+    # Reevaluate computation
+    #
+    # @return [Node,Object] Result of computation
+    #
+    # @see #force
+    #
+    # @private
+    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
+      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
+      end
+      retval
+    end
+
+    # Get element of injection
+    #
+    # @param [Integer,Node] i Index of desired element.
+    #
+    # @return [Node,Object] Element of injection.
+    def element( i )
+      Inject.new @value.element( i ), @index, @initial, @block, @var1, @var2
+    end
+
+    # Get variables contained in this term
+    #
+    # @return [Set] Returns set of variables.
+    #
+    # @private
+    def variables
+      initial_variables = @initial ? @initial.variables : Set[]
+      ( @value.variables + initial_variables ) - @index.variables
+    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
+      vars1, values1, term1 = @value.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 )
+    end
+ 
+    # Substitute variables
+    #
+    # Substitute the variables with the values given in the hash.
+    #
+    # @param [Hash] hash Substitutions to apply.
+    #
+    # @return [Node] Term with substitutions applied.
+    #
+    # @private
+    def subst( hash )
+      subst_var = @index.subst hash
+      value = @value.subst( @index => subst_var ).subst hash
+      initial = @initial ? @initial.subst( hash ) : nil
+      block = @block.subst hash
+      Inject.new value, subst_var, initial, block, @var1, @var2
+    end
+
+    # Check whether this term is compilable
+    #
+    # @return [FalseClass,TrueClass] Returns whether this term is compilable.
+    #
+    # @private
+    def compilable?
+      initial_compilable = @initial ? @initial.compilable? : true
+      @value.compilable? and initial_compilable and @block.compilable?
+    end
+
+  end
+
+end

data/lib/multiarray/int.rb

@@ -1,22 +1,233 @@
+# 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
 
-  # Boolean constant to use as a parameter for creating integer classes
-  #
-  # The value is +false+.
-  #
-  # @see #INT
-  UNSIGNED = false
+  # Class for representing native integers
+  class INT_ < Element
 
-  # Boolean constant to use as a parameter for creating integer classes
-  #
-  # The value is +true+.
-  #
-  # @see #INT
-  SIGNED   = true
+    class << self
+
+      # Number of bits of this integer
+      #
+      # @return [Integer] Number of bits of this integer.
+      attr_accessor :bits
+
+      # Boolean indicating whether this is a signed integer or not
+      #
+      # @return [FalseClass,TrueClass] Boolean indicating whether this is a
+      # signed integer or not.
+      attr_accessor :signed
+
+      # Memory type required to store elements of this type
+      #
+      # @return [Class] Returns +Malloc+.
+      #
+      # @private
+      def memory
+        Malloc
+      end
+
+      # Get storage size to store an element of this type
+      #
+      # @return [Integer] Returns +1+.
+      #
+      # @private
+      def storage_size
+        ( bits + 7 ).div 8
+      end
+
+      # Get default value for elements of this type
+      #
+      # @return [Object] Returns +false+.
+      #
+      # @private
+      def default
+        0
+      end
+
+      def coercion( other )
+        if other < INT_
+          Hornetseye::INT [ bits, other.bits ].max, ( signed or other.signed )
+        else
+          super other
+        end
+      end
+
+      # Directive for packing/unpacking elements of this type
+      #
+      # @private
+      def directive
+        case [ bits, signed ]
+        when [  8, true  ]
+          'c'
+        when [  8, false ]
+          'C'
+        when [ 16, true  ]
+          's'
+        when [ 16, false ]
+          'S'
+        when [ 32, true  ]
+          'i'
+        when [ 32, false ]
+          'I'
+        when [ 64, true  ]
+          'q'
+        when [ 64, false ]
+          'Q'
+        else
+          raise "No directive for packing/unpacking #{inspect}"
+        end
+      end
+
+      # Get string with information about this class
+      #
+      # @return [String] Returns string with information about this class.
+      def inspect
+        unless bits.nil? or signed.nil?
+          case [ bits, signed ]
+          when [  8, true  ]
+            'BYTE'
+          when [  8, false ]
+            'UBYTE'
+          when [ 16, true  ]
+            'SINT'
+          when [ 16, false ]
+            'USINT'
+          when [ 32, true  ]
+            'INT'
+          when [ 32, false ]
+            'UINT'
+          when [ 64, true  ]
+            'LONG'
+          when [ 64, false ]
+            'ULONG'
+          else
+            "INT(#{bits.inspect},#{ signed ? 'SIGNED' : 'UNSIGNED' })"
+          end
+        else
+          super
+        end
+      end
+
+      # Get unique descriptor of this class
+      #
+      # @param [Hash] hash Labels for any variables.
+      #
+      # @return [String] Descriptor of this class.
+      #
+      # @private
+      def descriptor( hash )
+        unless bits.nil? or signed.nil?
+          case [ bits, signed ]
+          when [  8, true  ]
+            'BYTE'
+          when [  8, false ]
+            'UBYTE'
+          when [ 16, true  ]
+            'SINT'
+          when [ 16, false ]
+            'USINT'
+          when [ 32, true  ]
+            'INT'
+          when [ 32, false ]
+            'UINT'
+          when [ 64, true  ]
+            'LONG'
+          when [ 64, false ]
+            'ULONG'
+          else
+            "INT(#{bits.to_s},#{ signed ? 'SIGNED' : 'UNSIGNED' })"
+          end
+        else
+          super
+        end
+      end
+
+      # Comparison operator
+      #
+      # @param [Object] other Other object to compare with.
+      #
+      # @return [FalseClass,TrueClass] Result of comparison.
+      def ==( other )
+        other.is_a? Class and other < INT_ and
+          bits == other.bits and signed == other.signed
+      end
+
+      def hash
+        [ :INT_, bits, signed ].hash
+      end
+
+      def eql?( other )
+        self == other
+      end
+
+    end
+
+    # Namespace containing method for matching elements of type INT_
+    #
+    # @see INT_
+    #
+    # @private
+    module Match
+
+      # Method for matching elements of type INT_
+      #
+      # 'param [Array<Object>] *values Values to find matching native element
+      # type for.
+      #
+      # @return [Class] Native type fitting all values.
+      #
+      # @see INT_
+      #
+      # @private
+      def fit( *values )
+        if values.all? { |value| value.is_a? Integer }
+          bits = 8
+          ubits = 8
+          signed = false
+          values.each do |value|
+            bits *= 2 until ( -2**(bits-1) ... 2**(bits-1) ).include? value
+            if value < 0
+              signed = true
+            else
+              ubits *= 2 until ( 0 ... 2**ubits ).include? value
+            end
+          end
+          bits = signed ? bits : ubits
+          if bits <= 64
+            Hornetseye::INT bits, signed
+          else
+            super *values
+          end
+        else
+          super *values
+        end
+      end
+
+    end
+
+    Node.extend Match
+
+  end
 
   # Create a class deriving from +INT_+
   #
-  # The parameters +bits+ and +signed+ are assigned to the corresponding
+  # he aprameters +bits+ and +signed+ are assigned to the corresponding
   # attributes of the resulting class.
   #
   # @param [Integer] bits Number of bits of native integer.
@@ -35,6 +246,20 @@ module Hornetseye
 
   module_function :INT
 
+  # Boolean constant to use as a parameter for creating integer classes
+  #
+  # The value is +false+.
+  #
+  # @see #INT
+  UNSIGNED = false
+
+  # Boolean constant to use as a parameter for creating integer classes
+  #
+  # The value is +true+.
+  #
+  # @see #INT
+  SIGNED   = true
+
   # 8-bit signed integer
   BYTE  = INT  8, SIGNED