multiarray 0.5.2 → 0.6.0

data/lib/multiarray/object.rb

@@ -24,7 +24,7 @@ module Hornetseye
 
       # Get string with information about this class
       #
-      # @return [String] Returns +'OBJECT'+.
+      # @return [String] Returns 'OBJECT'.
       def inspect
         'OBJECT'
       end
@@ -69,6 +69,13 @@ module Hornetseye
         nil
       end
 
+      # Compute balanced type for binary operation
+      #
+      # @param [Class] other Other type to coerce with.
+      #
+      # @return [Class] Result of coercion.
+      #
+      # @private
       def coercion( other )
         if other < Sequence_
           other.coercion self
@@ -77,7 +84,7 @@ module Hornetseye
         end
       end
 
-      # Coerce with other object
+      # Type coercion for native elements
       #
       # @param [Node,Object] other Other object.
       #
@@ -86,17 +93,25 @@ module Hornetseye
         return self, self
       end
 
+      # Get corresponding boolean-based datatype
+      #
+      # @return [Class] Returns +self+.
       def bool
         self
       end
 
+      # Convert to type based on floating point numbers
+      #
+      # @return [Class] Corresponding type based on floating point numbers.
+      #
+      # @private
       def float
         OBJECT
       end
 
       # Check whether this term is compilable
       #
-      # @return [FalseClass,TrueClass] Returns +false+.
+      # @return [Boolean] Returns +false+.
       #
       # @private
       def compilable?
@@ -115,7 +130,7 @@ module Hornetseye
       # Method for matching elements of type OBJECT
       #
       # @param [Array<Object>] *values Values to find matching native element
-      # type for.
+      #        type for.
       #
       # @return [Class] Native type fitting all values.
       #
@@ -126,6 +141,14 @@ module Hornetseye
         OBJECT
       end
 
+      # Perform type alignment
+      #
+      # Align this type to another. This is used to prefer single-precision
+      # floating point in certain cases.
+      #
+      # @param [Class] context Other type to align with.
+      #
+      # @private
       def align( context )
         self
       end
@@ -136,6 +159,13 @@ module Hornetseye
 
   end
 
+  # Shortcut for constructor
+  #
+  # The method calls +OBJECT.new+.
+  #
+  # @param [Object] value Ruby object.
+  #
+  # @return [OBJECT] The wrapped Ruby object.
   def OBJECT( value )
     OBJECT.new value
   end

data/lib/multiarray/operations.rb

@@ -64,11 +64,6 @@ module Hornetseye
     define_unary_op :floor
     define_unary_op :ceil
     define_unary_op :round
-    define_unary_op :r, :scalar
-    define_unary_op :g, :scalar
-    define_unary_op :b, :scalar
-    define_unary_op :real, :scalar
-    define_unary_op :imag, :scalar
     define_binary_op :+
     define_binary_op :-
     define_binary_op :*
@@ -178,6 +173,8 @@ module Hornetseye
       Hornetseye::ElementWise( action, block.to_s, conversion ).new( self ).force
     end
 
+    alias_method :map, :collect
+
     def inject( initial = nil, options = {} )
       unless initial.nil?
         initial = Node.match( initial ).new initial unless initial.is_a? Node
@@ -204,7 +201,7 @@ module Hornetseye
 
     # Equality operator
     #
-    # @return [FalseClass,TrueClass] Returns result of comparison.
+    # @return [Boolean] Returns result of comparison.
     def eq_with_multiarray( other )
       if other.is_a? Node
         if variables.empty?
@@ -231,6 +228,19 @@ module Hornetseye
       inject { |a,b| a.major b }
     end
 
+    def sum
+      inject { |a,b| a + b }
+    end
+
+    def range
+      min .. max
+    end
+
+    def fill!( value = typecode.default )
+      self[] = value
+      self
+    end
+
     # Apply accumulative operation over elements diagonally
     #
     # This method is used internally to implement convolutions.
@@ -239,7 +249,7 @@ module Hornetseye
     # @option options [Variable] :var1 First variable defining operation.
     # @option options [Variable] :var2 Second variable defining operation.
     # @option options [Variable] :block (yield( var1, var2 )) The operation to
-    # apply diagonally.
+    #         apply diagonally.
     # @yield Optional operation to apply diagonally.
     #
     # @return [Node] Result of operation.
@@ -308,124 +318,106 @@ module Hornetseye
       product( filter ).diagonal { |s,x| s + x }
     end
 
-    def r_with_decompose
-      if typecode < RGB_
-        decompose.roll.element 0
-      elsif typecode == OBJECT
-        r_without_decompose
-      else
-        self
-      end
-    end
-
-    alias_method_chain :r, :decompose
-
-    def r=( value )
-      if typecode < RGB_
-        decompose.roll[ 0 ] = value
-      elsif typecode == OBJECT
-        self[] = Hornetseye::lazy do
-          value * RGB.new( 1, 0, 0 ) + g * RGB.new( 0, 1, 0 ) + b * RGB.new( 0, 0, 1 )
+    def histogram( *ret_shape )
+      options = ret_shape.last.is_a?( Hash ) ? ret_shape.pop : {}
+      options = { :target => UINT, :safe => true }.merge options
+      if options[ :safe ]
+        if shape.first != 1 and ret_shape.size == 1
+          right = Hornetseye::lazy( 1 ) { |i| self }.unroll
+        else
+          if shape.first != ret_shape.size
+            raise "First dimension of array (#{shape.first}) differs from number of " +
+                  "dimensions of histogram (#{ret_shape.size})"
+          end
+          right = self
         end
       else
-        raise "Cannot assign red channel to object of type #{array_type.inspect}"
-      end
-    end
-
-    def g_with_decompose
-      if typecode < RGB_
-        decompose.roll.element 1
-      elsif typecode == OBJECT
-        g_without_decompose
-      else
-        self
+        right = self
       end
-    end
-
-    alias_method_chain :g, :decompose
-
-    def g=( value )
-      if typecode < RGB_
-        decompose.roll[ 1 ] = value
-      elsif typecode == OBJECT
-        self[] = Hornetseye::lazy do
-          r * RGB.new( 1, 0, 0 ) + value * RGB.new( 0, 1, 0 ) + b * RGB.new( 0, 0, 1 )
+      if options[ :safe ]
+        for i in 0 ... right.shape.first
+          range = right.roll[ i ].range
+          if range.begin < 0
+            raise "#{i+1}th dimension of index must be in 0 ... #{ret_shape[i]} " +
+                  "(but was #{range.begin})"
+          end
+          if range.end >= ret_shape[ i ]
+            raise "#{i+1}th dimension of index must be in 0 ... #{ret_shape[i]} " +
+                  "(but was #{range.end})"
+          end
         end
+      end
+      left = MultiArray.new options[ :target ], *ret_shape
+      left[] = 0
+      block = Histogram.new left, right
+      if block.compilable?
+        GCCFunction.run block
       else
-        raise "Cannot assign green channel to object of type #{array_type.inspect}"
+        block.demand
       end
+      left
     end
 
-    def b_with_decompose
-      if typecode < RGB_
-        decompose.roll.element 2
-      elsif typecode == OBJECT
-        b_without_decompose
-      else
-        self
-      end
+    def histogram_with_composite( *ret_shape )
+      decompose.histogram_without_composite *ret_shape
     end
 
-    alias_method_chain :b, :decompose
+    alias_method_chain :histogram, :composite
 
-    def b=( value )
-      if typecode < RGB_
-        decompose.roll[ 2 ] = value
-      elsif typecode == OBJECT
-        self[] = Hornetseye::lazy do
-          r * RGB.new( 1, 0, 0 ) + g * RGB.new( 0, 1, 0 ) + value * RGB.new( 0, 0, 1 )
+    def lut( table, options = {} )
+      options = { :safe => true }.merge options
+      if options[ :safe ]
+        if shape.first != 1 and table.dimension == 1
+          source = Hornetseye::lazy( 1 ) { |i| self }.unroll
+        else
+          if shape.first > table.dimension
+            raise "First dimension of array (#{shape.first}) is greater than the " +
+                  " number of dimensions of LUT (#{table.dimension})"
+          end
+          source = self
         end
       else
-        raise "Cannot assign blue channel to object of type #{array_type.inspect}"
+        source = self
       end
-    end
-
-    def real_with_decompose
-      if typecode < COMPLEX_
-        decompose.roll.element 0
-      elsif typecode == OBJECT
-        real_without_decompose
-      else
-        self
+      if options[ :safe ]
+        for i in 0 ... source.shape.first
+          range = source.roll[ i ].range
+          if range.begin < 0
+            raise "#{i+1}th dimension of index must be in 0 ... #{table.shape[i]} " +
+                  "(but was #{range.begin})"
+          end
+          if range.end >= table.shape[ i ]
+            raise "#{i+1}th dimension of index must be in 0 ... #{table.shape[i]} " +
+                  "(but was #{range.end})"
+          end
+        end
       end
-    end
-
-    alias_method_chain :real, :decompose
-
-    def real=( value )
-      if typecode < COMPLEX_
-        decompose.roll[ 0 ] = value
-      elsif typecode == OBJECT
-        self[] = Hornetseye::lazy do
-          value + imag * ::Complex::I
+      if source.dimension <= 1 and variables.empty?
+        result = table
+        ( table.dimension - 1 ).downto( 0 ) do |i|
+          result = result.element source.element( INT.new( i ) ).demand
         end
+        result
       else
-        self[] = value
+        Lut.new( source, table, options[ :n ] ).force
       end
     end
 
-    def imag_with_decompose
-      if typecode < COMPLEX_
-        decompose.roll.element 1
-      elsif typecode == OBJECT
-        imag_without_decompose
-      else
-        Hornetseye::lazy( *shape ) { typecode.new( 0 ) }
-      end
+    def lut_with_composite( table, options = {} )
+      decompose.lut_without_composite table, options
     end
 
-    alias_method_chain :imag, :decompose
+    alias_method_chain :lut, :composite
 
-    def imag=( value )
-      if typecode < COMPLEX_
-        decompose.roll[ 1 ] = value
-      elsif typecode == OBJECT
-        self[] = Hornetseye::lazy do
-          real + value * ::Complex::I
-        end
+    def integral
+      left = pointer_type.new
+      block = Integral.new left, self
+      if block.compilable?
+        GCCFunction.run block
       else
-        raise "Cannot assign imaginary values to object of type #{array_type.inspect}"
+        block.demand
       end
+      left
     end
 
   end

data/lib/multiarray/pointer.rb

@@ -25,10 +25,20 @@ module Hornetseye
       # @return [Node] Type of object the pointer is pointing at.
       attr_accessor :target
 
+      # Construct new object from arguments
+      #
+      # @param [Array<Object>] *args Arguments for constructor.
+      #
+      # @return [Element] New object of this type.
+      #
+      # @private
       def construct( *args )
         new *args
       end
 
+      # Display string with information about this class
+      #
+      # @return [String] String with information about this class (e.g. '*(UBYTE)').
       def inspect
         "*(#{target.inspect})"
       end
@@ -46,40 +56,78 @@ module Hornetseye
 
       # Get default value for elements of this type
       #
-      # @return [Memory,List] Memory for storing object of type +target+.
+      # @return [Memory,List] Memory for storing one object of type +target+.
       def default
         target.memory.new target.storage_size
       end
 
+      # Test equality of classes
+      #
+      # @param [Object] other Object to compare with.
+      #
+      # @return [Boolean] Boolean indicating whether classes are equal.
       def ==( other )
         other.is_a? Class and other < Pointer_ and
           target == other.target
       end
 
+      # Compute hash value for this class.
+      #
+      # @return [Fixnum] Hash value
+      #
+      # @private
       def hash
         [ :Pointer_, target ].hash
       end
 
+      # Equality for hash operations
+      #
+      # @param [Object] other Object to compare with.
+      #
+      # @return [Boolean] Returns +true+ if objects are equal.
+      #
+      # @private
       def eql?
         self == other
       end
 
+      # Get element type
+      #
+      # @return [Class] Returns the corresponding element type.
       def typecode
         target
       end
 
+      # Base type of this data type
+      #
+      # @return [Class] Returns +element_type+.
+      #
+      # @private
       def basetype
         target.basetype
       end
 
+      # Get type of result of delayed operation
+      #
+      # @return [Class] Type of result.
+      #
+      # @private
       def array_type
         target
       end
 
+      # Get corresponding pointer type
+      #
+      # @return [Class] Returns +self+.
       def pointer_type
         self
       end
 
+      # Check whether objects of this class are finalised computations
+      #
+      # @return [Boolean] Returns +false+.
+      #
+      # @private
       def finalised?
         false
       end
@@ -90,6 +138,10 @@ module Hornetseye
       @value = value
     end
 
+    def memory
+      @value
+    end
+
     # Strip of all values
     #
     # Split up into variables, values, and a term where all values have been
@@ -108,6 +160,13 @@ module Hornetseye
       "#{self.class.to_s}(#{@value.to_s})"
     end
 
+    # Store new value in this pointer
+    #
+    # @param [Object] value New value for this pointer object.
+    #
+    # @return [Object] Returns +value+.
+    #
+    # @private
     def store( value )
       result = value.simplify
       self.class.target.new( result.get ).write @value
@@ -140,6 +199,15 @@ module Hornetseye
       end
     end
 
+    def skip( index, start )
+      self
+    end
+
+    # Decompose composite elements
+    #
+    # This method decomposes composite elements into array.
+    #
+    # @return [Node] Result of decomposition.
     def decompose
       if self.class.target < Composite
         pointer = Hornetseye::Pointer( self.class.target.element_type ).new @value
@@ -151,6 +219,11 @@ module Hornetseye
       end
     end
 
+    # Get array with components of this value
+    #
+    # @return [Array<Object>] Get array with value of this object as single element.
+    #
+    # @private
     def values
       [ @value ]
     end