multiarray 0.11.3 → 0.11.4

data/lib/multiarray/index.rb

@@ -17,6 +17,7 @@
 # Namespace of Hornetseye computer vision library
 module Hornetseye
 
+  # Class for representing native array index types
   class INDEX_ < Element
 
     class << self
@@ -96,12 +97,22 @@ module Hornetseye
 
     end
 
+    # This value must not be instantiated
+    #
+    # The method throws an exception.
+    #
+    # @private
     def initialize
       raise "#{self.class.inspect} must not be instantiated"
     end
 
   end
 
+  # Instantiate the type of an array index
+  #
+  # @param [INT_,Variable] size Dimension of array.
+  #
+  # @return [Class] Returns a class deriving from +INDEX_+.
   def INDEX( size )
     retval = Class.new INDEX_
     size = INT.new( size ) unless size.is_a? Node

data/lib/multiarray/inject.rb

@@ -17,6 +17,7 @@
 # Namespace of Hornetseye computer vision library
 module Hornetseye
 
+  # Class for representing injections
   class Inject < Node
 
     class << self
@@ -32,6 +33,18 @@ module Hornetseye
 
     end
 
+    # Constructor
+    #
+    # @param [Node] value Initial value of injection.
+    # @param [Node] index Index to iterate over +value+.
+    # @param [Node,NilClass] initial Initial value for injection.
+    # @param [Node] block Expression with body of injection.
+    # @param [Variable] var1 Variable for performing substitutions on body of
+    #        injection.
+    # @param [Variable] var2 Variable for performing substitutions on body of
+    #        injection.
+    #
+    # @private
     def initialize( value, index, initial, block, var1, var2 )
       @value, @index, @initial, @block, @var1, @var2 =
         value, index, initial, block, var1, var2
@@ -59,7 +72,11 @@ module Hornetseye
     #
     # @private
     def array_type
-      @value.to_type( @block.typecode ).array_type
+      retval = @value.to_type( @block.typecode ).array_type
+      ( class << self; self; end ).instance_eval do
+        define_method( :array_type ) { retval }
+      end
+      retval
     end
 
     # Reevaluate computation

data/lib/multiarray/int.rb

@@ -60,7 +60,7 @@ module Hornetseye
         0
       end
 
-      # Get corresponding maximal integer type.
+      # Get corresponding maximal integer type
       #
       # @return [Class] Returns 32 bit integer or self whichever has more bits.
       #
@@ -99,37 +99,51 @@ module Hornetseye
         end
       end
 
+      # Hash table used internally
+      #
+      # @private
+      DIRECTIVES = { [  8, true  ] => 'c',
+                     [  8, false ] => 'C',
+                     [ 16, true  ] => 's',
+                     [ 16, false ] => 'S',
+                     [ 32, true  ] => 'i',
+                     [ 32, false ] => 'I',
+                     [ 64, true  ] => 'q',
+                     [ 64, false ] => 'Q' }
+
       # Directive for packing/unpacking elements of this type
       #
       # @private
       def directive
-        retval = { [  8, true  ] => 'c',
-                   [  8, false ] => 'C',
-                   [ 16, true  ] => 's',
-                   [ 16, false ] => 'S',
-                   [ 32, true  ] => 'i',
-                   [ 32, false ] => 'I',
-                   [ 64, true  ] => 'q',
-                   [ 64, false ] => 'Q' }[ [ bits, signed ] ]
+        retval = DIRECTIVES[ [ bits, signed ] ]
         raise "No directive for packing/unpacking #{inspect}" unless retval
         retval
       end
 
-      # Get string with information about this class
+      # Hash table used internally
       #
-      # @return [String] Returns string with information about this class (e.g.
-      #         "BYTE").
-      def inspect
-        unless bits.nil? or signed.nil?
-          retval = { [  8, true  ] => 'BYTE',
+      # @private
+      IDENTIFIER = { [  8, true  ] => 'BYTE',
                      [  8, false ] => 'UBYTE',
                      [ 16, true  ] => 'SINT',
                      [ 16, false ] => 'USINT',
                      [ 32, true  ] => 'INT',
                      [ 32, false ] => 'UINT',
                      [ 64, true  ] => 'LONG',
-                     [ 64, false ] => 'ULONG' }[ [ bits, signed ] ] ||
+                     [ 64, false ] => 'ULONG' }
+
+      # Get string with information about this class
+      #
+      # @return [String] Returns string with information about this class (e.g.
+      #         "BYTE").
+      def inspect
+        unless bits.nil? or signed.nil?
+          retval = IDENTIFIER[ [ bits, signed ] ] ||
                    "INT(#{bits.inspect},#{ signed ? 'SIGNED' : 'UNSIGNED' })"
+          ( class << self; self; end ).instance_eval do
+            define_method( :inspect ) { retval }
+          end
+          retval
         else
           super
         end
@@ -160,7 +174,7 @@ module Hornetseye
           bits == other.bits and signed == other.signed
       end
 
-      # Compute hash value for this class.
+      # Compute hash value for this class
       #
       # @return [Fixnum] Hash value
       #
@@ -182,11 +196,26 @@ module Hornetseye
 
     end
 
+    # Loop statement
+    #
+    # @param [Proc] action Loop body.
+    #
+    # @return [GCCValue] Returns +self+.
+    #
+    # @private
     def times( &action )
       get.times &action
       self
     end
 
+    # Loop statement
+    #
+    # @param [Node] other Upper limit for loop.
+    # @param [Proc] action Loop body.
+    #
+    # @return [GCCValue] Returns +self+.
+    #
+    # @private
     def upto( other, &action )
       get.upto other.get, &action
       self
@@ -256,7 +285,7 @@ module Hornetseye
   # Create a class deriving from +INT_+ or instantiate an +INT+ object
   #
   # @overload INT( bits, signed )
-  #   Create a class deriving from +INT_+. The aprameters +bits+ and +signed+
+  #   Create a class deriving from +INT_+. The parameters +bits+ and +signed+
   #   are assigned to the corresponding attributes of the resulting class.
   #   @param [Integer] bits Number of bits of native integer.
   #   @param [Boolean] signed Specify +UNSIGNED+ or +SIGNED+ here.
@@ -267,6 +296,8 @@ module Hornetseye
   #   @param [Integer] value Initial value for integer object.
   #   @return [INT] Wrapped integer value.
   #
+  # @return [Class,INT] A class deriving from +INT_+ or a wrapped integer value.
+  #
   # @see INT_
   # @see INT_.bits
   # @see INT_.signed

data/lib/multiarray/integral.rb

@@ -14,30 +14,66 @@
 # 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 integral image computations
   class Integral < Node
 
     class << self
 
+      # Check whether objects of this class are finalised computations
+      #
+      # @return [Boolean] Returns +false+.
+      #
+      # @private
       def finalised?
         false
       end
 
     end
 
+    # Constructor
+    #
+    # @param [Node] dest Target array to write histogram to.
+    # @param [Node] source Expression to compute histogram of.
+    #
+    # @private
     def initialize( dest, source )
       @dest, @source = dest, source
     end
 
+    # Get unique descriptor of this object
+    #
+    # @param [Hash] hash Labels for any variables.
+    #
+    # @return [String] Descriptor of this object,
+    #
+    # @private
     def descriptor( hash )
       "Integral(#{@dest.descriptor( hash )},#{@source.descriptor( hash )})"
     end
 
+    # Get type of result of delayed operation
+    #
+    # @return [Class] Type of result.
+    #
+    # @private
     def array_type
-      @dest.array_type
+      retval = @dest.array_type
+      ( class << self; self; end ).instance_eval do
+        define_method( :array_type ) { retval }
+      end
+      retval
     end
 
+    # Reevaluate computation
+    #
+    # @return [Node,Object] Result of computation
+    #
+    # @see #force
+    #
+    # @private
     def demand
       if variables.empty?
         if @source.dimension > 0
@@ -58,20 +94,48 @@ module Hornetseye
       end
     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 @dest.subst( hash ), @source.subst( hash )
     end
 
+    # Get variables contained in this term
+    #
+    # @return [Set] Returns list of variables.
+    #
+    # @private
     def variables
       @dest.variables + @source.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 = @dest.strip
       vars2, values2, term2 = @source.strip
       return vars1 + vars2, values1 + values2, self.class.new( term1, term2 )
     end
 
+    # Check whether this term is compilable
+    #
+    # @return [Boolean] Returns whether this term is compilable.
+    #
+    # @private
     def compilable?
       @dest.compilable? and @source.compilable?
     end

data/lib/multiarray/lambda.rb

@@ -17,13 +17,23 @@
 # Namespace of Hornetseye computer vision library
 module Hornetseye
 
+  # Class for representing lambda expressions
   class Lambda < Node
 
+    # Construct lambda term
+    #
+    # @param [Variable] index Variable to bind.
+    # @param [Node] term The term based on that variable.
+    #
+    # @return [Lambda] Lambda object.
     def initialize( index, term )
       @index = index
       @term = term
     end
 
+    # Get storage object if there is any
+    #
+    # @return [Malloc,List,NilClass] Object storing the data.
     def memory
       @term.memory
     end
@@ -46,7 +56,11 @@ module Hornetseye
     #
     # @private
     def array_type
-      Hornetseye::Sequence @term.array_type, @index.size.get
+      retval = Hornetseye::Sequence @term.array_type, @index.size.get
+      ( class << self; self; end ).instance_eval do
+        define_method( :array_type ) { retval }
+      end
+      retval
     end
 
     # Get variables contained in this term
@@ -131,9 +145,9 @@ module Hornetseye
         unless ( 0 ... shape.last ).member? i
           raise "Index must be in 0 ... #{shape.last} (was #{i})"
         end
-        i = Node.match( i ).new i
+        i = INT.new i
       end
-      i.size.store @index.size if @index.size.get and i.is_a? Variable
+      i.size = @index.size if @index.size.get and i.is_a? Variable
       @term.subst @index => i
     end
 
@@ -152,8 +166,8 @@ module Hornetseye
                 "(was #{start} ... #{start + length})"
         end
       end
-      start = Node.match( start ).new start unless start.is_a? Node
-      length = Node.match( length ).new length unless length.is_a? Node
+      start = INT.new start unless start.is_a? Node
+      length = INT.new length unless length.is_a? Node
       index = Variable.new Hornetseye::INDEX( length )
       Lambda.new( index, @term.subst( @index => index ).
                          skip( index, start ) ).unroll

data/lib/multiarray/list.rb

@@ -59,6 +59,10 @@ module Hornetseye
     # Retrieve value of specified typecode
     #
     # @param [Class] typecode The type of the value.
+    #
+    # @return [Object] The referenced value.
+    #
+    # @private
     def load( typecode )
       @array[ @offset ]
     end
@@ -66,6 +70,10 @@ module Hornetseye
     # Store value
     #
     # @param [Node] value Value to store.
+    #
+    # @return [Object] Returns +value+.
+    #
+    # @private
     def save( value )
       @array[ @offset ] = value.get
       value

data/lib/multiarray/lookup.rb

@@ -29,6 +29,9 @@ module Hornetseye
       @p, @index, @stride = p, index, stride
     end
 
+    # Get storage object if there is any
+    #
+    # @return [Malloc,List,NilClass] Object storing the data.
     def memory
       #if array_type.storage_size != @stride.get * typecode.storage_size
       #  raise 'Memory is not contiguous'
@@ -54,7 +57,11 @@ module Hornetseye
     #
     # @private
     def array_type
-      @p.array_type
+      retval = @p.array_type
+      ( class << self; self; end ).instance_eval do
+        define_method( :array_type ) { retval }
+      end
+      retval
     end
 
     # Substitute variables

data/lib/multiarray/lut.rb

@@ -14,54 +14,130 @@
 # 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 lookup operations
   class Lut < Node
 
     class << self
 
+      # Check whether objects of this class are finalised computations
+      #
+      # @return [Boolean] Returns +false+.
+      #
+      # @private
       def finalised?
         false
       end
 
     end
 
-    def initialize( source, table, n )
+    # Constructor
+    #
+    # @param [Node] dest Target array to write histogram to.
+    # @param [Node] source Expression to compute histogram of.
+    # @param [Integer] n Number of dimensions of lookup.
+    #
+    # @private
+    def initialize( source, table, n = nil )
       @source, @table = source, table
       @n = n || @source.shape.first
     end
 
+    # Get unique descriptor of this object
+    #
+    # @param [Hash] hash Labels for any variables.
+    #
+    # @return [String] Descriptor of this object,
+    #
+    # @private
     def descriptor( hash )
       "Lut(#{@source.descriptor( hash )},#{@table.descriptor( hash )},#{@n})"
     end
 
+    # Get type of result of delayed operation
+    #
+    # @return [Class] Type of result.
+    #
+    # @private
     def array_type
       shape = @table.shape.first( @table.dimension - @n ) + @source.shape[ 1 .. -1 ]
-      Hornetseye::MultiArray @table.typecode, *shape
+      retval = Hornetseye::MultiArray @table.typecode, *shape
+      ( class << self; self; end ).instance_eval do
+        define_method( :array_type ) { retval }
+      end
+      retval
     end
 
+    # Reevaluate computation
+    #
+    # @return [Node,Object] Result of computation
+    #
+    # @see #force
+    #
+    # @private
     def demand
       @source.lut @table, :n => @n, :safe => false
     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 @source.subst( hash ), @table.subst( hash ), @n
     end
 
+    # Get variables contained in this term
+    #
+    # @return [Set] Returns list of variables.
+    #
+    # @private
     def variables
       @source.variables + @table.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 = @source.strip
       vars2, values2, term2 = @table.strip
       return vars1 + vars2, values1 + values2, self.class.new( term1, term2, @n )
     end
 
+    # Skip elements of an array
+    #
+    # @param [Variable] index Variable identifying index of array.
+    # @param [Node] start Wrapped integer with number of elements to skip.
+    #
+    # @return [Node] Returns element-wise operation with elements skipped on each
+    #         operand.
+    #
+    # @private
     def skip( index, start )
       self.class.new @source.skip( index, start ), @table.skip( index, start ), @n
     end
 
+    # Get element of unary operation
+    #
+    # @param [Integer,Node] i Index of desired element.
+    #
+    # @return [Node,Object] Element of unary operation.
+    #
+    # @private
     def element( i )
       source, table = @source, @table
       if source.dimension > 1
@@ -74,6 +150,14 @@ module Hornetseye
       end
     end
 
+    # Extract array view with part of array
+    #
+    # @param [Integer,Node] start Number of elements to skip.
+    # @param [Integer,Node] length Size of array view.
+    #
+    # @return [Node] Array view with the specified elements.
+    #
+    # @private
     def slice( start, length )
       source, table = @source, @table
       if source.dimension > 1
@@ -88,10 +172,20 @@ module Hornetseye
       end
     end
 
+    # Decompose composite elements
+    #
+    # This method decomposes composite elements into array.
+    #
+    # @return [Node] Result of decomposition.
     def decompose( i )
       self.class.new @source, @table.decompose( i ), @n
     end
 
+    # Check whether this term is compilable
+    #
+    # @return [Boolean] Returns whether this term is compilable.
+    #
+    # @private
     def compilable?
       @source.compilable? and @table.compilable?
     end