multiarray 0.4.1 → 0.5.0

data/lib/multiarray/binary.rb

@@ -0,0 +1,174 @@
+# 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 for representing binary operations on scalars and arrays
+  class Binary_ < Node
+
+    class << self
+
+      # Name of operation
+      #
+      # @return [Symbol,String] The name of this operation.
+      attr_accessor :operation
+
+      # Name of method for type conversion
+      #
+      # @return [Symbol,String] The name of the method for type conversion.
+      attr_accessor :coercion
+
+      # Get string with information about this class
+      #
+      # @return [String] Return string with information about this class.
+      def inspect
+        operation.to_s
+      end
+
+      # Get unique descriptor of this class
+      #
+      # @param [Hash] hash Labels for any variables.
+      #
+      # @return [String] Descriptor of this class.
+      #
+      # @private
+      def descriptor( hash )
+        operation.to_s
+      end
+
+    end
+
+    # Initialise binary operation
+    #
+    # @param [Node] value1 First operand to apply operation to.
+    # @param [Node] value2 Second operand to apply operation to.
+    def initialize( value1, value2 )
+      @value1, @value2 = value1, value2
+    end
+
+    # Get unique descriptor of this object
+    #
+    # @param [Hash] hash Labels for any variables.
+    #
+    # @return [String] Descriptor of this object,
+    #
+    # @private
+    def descriptor( hash )
+      "(#{@value1.descriptor( hash )}).#{self.class.descriptor( hash )}(#{@value2.descriptor( hash )})"
+    end
+
+    # Array type of this term
+    #
+    # @return [Class] Resulting array type.
+    #
+    # @private
+    def array_type
+      @value1.array_type.send self.class.coercion, @value2.array_type
+    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 )
+      self.class.new @value1.subst( hash ), @value2.subst( hash )
+    end
+
+    # Get variables contained in this term
+    #
+    # @return [Set] Returns set of variables.
+    #
+    # @private
+    def variables
+      @value1.variables + @value2.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 = @value1.strip
+      vars2, values2, term2 = @value2.strip
+      return vars1 + vars2, values1 + values2, self.class.new( term1, term2 )
+    end
+
+    # Reevaluate computation
+    #
+    # @return [Node,Object] Result of computation
+    #
+    # @see #force
+    #
+    # @private
+    def demand
+      @value1.send self.class.operation, @value2
+    end
+
+    # Get element of unary operation
+    #
+    # @param [Integer,Node] i Index of desired element.
+    #
+    # @return [Node,Object] Element of unary operation.
+    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
+    end
+
+    # Check whether this term is compilable
+    #
+    # @return [FalseClass,TrueClass] Returns whether this term is compilable.
+    #
+    # @private
+    def compilable?
+      @value1.compilable? and @value2.compilable?
+    end
+
+  end
+
+  # Create a class deriving from +Binary_+
+  #
+  # @param [Symbol,String] operation Name of operation.
+  # @param [Symbol,String] conversion Name of method for type conversion.
+  #
+  # @return [Class] A class deriving from +Binary_+.
+  #
+  # @see Binary_
+  # @see Binary_.operation
+  # @see Binary_.coercion
+  #
+  # @private
+  def Binary( operation, coercion = :coercion )
+    retval = Class.new Binary_
+    retval.operation = operation
+    retval.coercion = coercion
+    retval
+  end
+
+  module_function :Binary
+
+end

data/lib/multiarray/bool.rb

@@ -0,0 +1,138 @@
+# 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 BOOL < Element
+
+    class << self
+
+      # Get string with information about this class
+      #
+      # @return [String] Returns +'BOOL'+
+      def inspect
+        'BOOL'
+      end
+
+      # Get unique descriptor of this class
+      #
+      # @param [Hash] hash Labels for any variables.
+      #
+      # @return [String] Descriptor of this class.
+      #
+      # @private
+      def descriptor( hash )
+        'BOOL'
+      end
+
+      # Retrieve element from memory
+      #
+      # @param [Malloc] ptr Memory to load element from.
+      #
+      # @see Malloc#load
+      #
+       # @return [BOOL] Result of fetch operation.
+      #
+      # @private
+      def fetch( ptr )
+        new ptr.load( self ).ne( 0 )
+      end
+
+      # 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
+        1
+      end
+
+      # Get default value for elements of this type
+      #
+      # @return [Object] Returns +false+.
+      #
+      # @private
+      def default
+        false
+      end
+
+      # Directive for packing/unpacking elements of this type
+      #
+      # @return [String] Returns +'c'+.
+      #
+      # @private
+      def directive
+        'c'
+      end
+
+    end
+
+    # Write element to memory
+    #
+    # @param [Malloc] ptr Memory to write element to.
+    #
+    # @return [BOOL] Returns +self+.
+    #
+    # @see Malloc#save
+    #
+    # @private
+    def write( ptr )
+      ptr.save UBYTE.new( get.conditional( 1, 0 ) )
+      self
+    end
+
+    # Namespace containing method for matching elements of type BOOL
+    #
+    # @see BOOL
+    #
+    # @private
+    module Match
+
+      # Method for matching elements of type BOOL
+      #
+      # @param [Array<Object>] *values Values to find matching native element
+      # type for.
+      #
+      # @return [Class] Native type fitting all values.
+      #
+      # @see BOOL
+      #
+      # @private
+      def fit( *values )
+        if values.all? { |value| [ false, true ].member? value }
+          BOOL
+        else
+          super *values
+        end
+      end
+
+    end
+
+    Node.extend Match
+
+  end
+
+end

data/lib/multiarray/diagonal.rb

@@ -0,0 +1,167 @@
+# 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 for representing diagonal injections
+  class Diagonal < Node
+
+    # Constructor
+    #
+    # @param [Node] value Initial value of injection
+    # @param [Node] index0 Index for 
+    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
+
+    # 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 @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 )})"
+    end
+
+    # Array type of this term
+    #
+    # @return [Class] Resulting array type.
+    #
+    # @private
+    def array_type
+      Hornetseye::MultiArray @block.typecode, *@value.shape
+    end
+
+    # Reevaluate computation
+    #
+    # @return [Node,Object] Result of computation
+    #
+    # @see #force
+    #
+    # @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
+      end
+      retval
+    end
+
+    # Get element of diagonal injection
+    #
+    # @param [Integer,Node] i Index of desired element.
+    #
+    # @return [Node,Object] Element of diagonal injection.
+    def element( i )
+      Diagonal.new @value.element( i ), @index0, @index1, @index2, @initial,
+        @block, @var1, @var2
+    end
+
+    # Get variables contained in this term
+    #
+    # @return [Set] Returns list of variables.
+    #
+    # @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 - 
+        ( @index1.variables + @index2.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
+      meta_vars1, meta_values1, var1 = @index1.strip
+      meta_vars2, meta_values2, var2 = @index2.strip
+      if @initial
+        vars2, values2, term2 = @initial.strip
+      else
+        vars2, values2, term2 = [], [], nil
+      end
+      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 )
+    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_var0 = @index0.subst hash
+      subst_var1 = @index1.subst hash
+      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
+      block = @block.subst hash
+      Diagonal.new value, subst_var0, subst_var1, subst_var2, 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?
+      false # !!!
+    end
+
+  end
+
+end