multiarray 0.5.1 → 0.5.2

data/lib/multiarray/inject.rb

@@ -19,6 +19,14 @@ module Hornetseye
 
   class Inject < Node
 
+    class << self
+
+      def finalised?
+        false
+      end
+
+    end
+
     def initialize( value, index, initial, block, var1, var2 )
       @value, @index, @initial, @block, @var1, @var2 =
         value, index, initial, block, var1, var2
@@ -41,7 +49,7 @@ module Hornetseye
     end
 
     def array_type
-      @value.array_type
+      @value.to_type( @block.typecode ).array_type
     end
 
     # Reevaluate computation
@@ -53,7 +61,7 @@ module Hornetseye
     # @private
     def demand
       if @initial
-        retval = @initial.simplify # !!!
+        retval = @initial.to_type( typecode ).simplify # !!!
         offset = INT.new 0
       else
         retval = @value.subst( @index => INT.new( 0 ) ).simplify # !!!

data/lib/multiarray/lambda.rb

@@ -56,8 +56,7 @@ module Hornetseye
     def strip
       meta_vars, meta_values, var = @index.strip
       vars, values, term = @term.subst( @index => var ).strip
-      return vars + meta_vars, values + meta_values,
-        Lambda.new( var, term )
+      return vars + meta_vars, values + meta_values, Lambda.new( var, term )
     end
 
     def subst( hash )
@@ -100,12 +99,23 @@ module Hornetseye
     #
     # @return [Node,Object] Result of inserting +i+ for lambda argument.
     def element( i )
-      i = Node.match( i ).new i unless i.is_a? Node
+      unless i.is_a? Node
+        unless ( 0 ... shape.last ).member? i
+          raise "Index must be in 0 ... #{shape.last} (was #{i})"
+        end
+        i = Node.match( i ).new i
+      end
       i.size.store @index.size if @index.size.get and i.is_a? Variable
       @term.subst @index => i
     end
 
     def slice( start, length )
+      unless start.is_a?( Node ) or length.is_a?( Node )
+        if start < 0 or start + length > shape.last
+          raise "Range must be in 0 ... #{shape.last} " +
+                "(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
       index = Variable.new Hornetseye::INDEX( length )
@@ -113,10 +123,18 @@ module Hornetseye
                          skip( index, start ) ).unroll
     end
 
+    def decompose
+      Lambda.new @index, @term.decompose
+    end
+
     def compilable?
       @term.compilable?
     end
 
+    def finalised?
+      @term.finalised?
+    end
+
   end
 
 end

data/lib/multiarray/lookup.rb

@@ -93,6 +93,14 @@ module Hornetseye
       Lookup.new @p.slice( start, length ), @index, @stride
     end
 
+    def decompose
+      if typecode < Composite
+        Lookup.new @p.decompose, @index, @stride * typecode.num_elements
+      else
+        Lookup.new @p.decompose, @index, @stride
+      end
+    end
+
   end
 
 end

data/lib/multiarray/methods.rb

@@ -44,7 +44,10 @@ module Hornetseye
               target = a.typecode.send conversion
               target.new mod.send( op, a.simplify.get )
             else
-              Hornetseye::UnaryMethod( mod, op, conversion ).new( a ).force
+              Hornetseye::ElementWise( lambda { |x| mod.send op, x },
+                                       "#{mod}.#{op}",
+                                       lambda { |x| x.send conversion } ).
+                new( a ).force
             end
           else
             send "#{op}_without_hornetseye", a
@@ -62,14 +65,17 @@ module Hornetseye
       mod.module_eval do
         define_method( "#{op}_with_hornetseye" ) do |a,b|
           if a.is_a? Node or b.is_a? Node
-            a = Node.match( a, b.typecode ).new a unless a.is_a? Node
-            b = Node.match( b, a.typecode ).new b unless b.is_a? Node
+            a = Node.match( a, b ).new a unless a.is_a? Node
+            b = Node.match( b, a ).new b unless b.is_a? Node
             if a.dimension == 0 and a.variables.empty? and
                b.dimension == 0 and b.variables.empty?
               target = a.typecode.send coercion, b.typecode
               target.new mod.send( op, a.simplify.get, b.simplify.get )
             else
-              Hornetseye::BinaryMethod( mod, op, coercion ).new( a, b ).force
+              Hornetseye::ElementWise( lambda { |x,y| mod.send op, x, y },
+                                       "#{mod}.#{op}",
+                                       lambda { |t,u| t.send coercion, u } ).
+                new( a, b ).force
             end
           else
             send "#{op}_without_hornetseye", a, b

data/lib/multiarray/node.rb

@@ -135,10 +135,18 @@ module Hornetseye
         BOOL
       end
 
+      def scalar
+        self
+      end
+
+      def float_scalar
+        float.scalar
+      end
+
       # Get boolean-based datatype for binary operation
       #
       # @return [Class] Returns +BOOL+.
-      def bool_binary( other )
+      def coercion_bool( other )
         other.coercion( self ).bool
       end
 
@@ -146,7 +154,7 @@ module Hornetseye
         self
       end
 
-      def largeint( other )
+      def coercion_maxint( other )
         coercion( other ).maxint
       end
 
@@ -161,6 +169,23 @@ module Hornetseye
         other.coercion( self ).float
       end
 
+      def byte
+        BYTE
+      end
+
+      def coercion_byte( other )
+        coercion( other ).byte
+      end
+
+      def cond( a, b )
+        t = a.coercion b
+        Hornetseye::MultiArray( t.typecode, *shape ).coercion t
+      end
+
+      def to_type( dest )
+        dest
+      end
+
       # Get variables contained in this datatype
       #
       # @return [Set] Returns +Set[]+.
@@ -212,6 +237,10 @@ module Hornetseye
         true
       end
 
+      def finalised?
+        true
+      end
+
     end
 
     # Array type of this term
@@ -235,6 +264,10 @@ module Hornetseye
       array_type.typecode
     end
 
+    def basetype
+      array_type.basetype
+    end
+
     # Get shape of this term
     #
     # @return [Array<Integer>] Returns +array_type.shape+.
@@ -367,6 +400,12 @@ module Hornetseye
       'Node()'
     end
 
+    def dup
+      retval = array_type.new
+      retval[] = self
+      retval
+    end
+
     # Substitute variables
     #
     # Substitute the variables with the values given in the hash.
@@ -389,6 +428,10 @@ module Hornetseye
       typecode.compilable?
     end
 
+    def finalised?
+      self.class.finalised?
+    end
+
     # Retrieve value of array element(s)
     #
     # @param [Array<Integer>] *indices Index/indices to select element.
@@ -407,6 +450,21 @@ module Hornetseye
       end
     end
 
+    def check_shape( *args )
+      args.each do |arg|
+        if dimension < arg.dimension
+          raise "#{arg.array_type.inspect} has #{arg.dimension} dimension(s) " +
+                "but should not have more than #{dimension}"
+        end
+        if ( shape + arg.shape ).all? { |s| s.is_a? Integer }
+          if shape.last( arg.dimension ) != arg.shape
+            raise "#{arg.array_type.inspect} has shape #{arg.shape.inspect} " +
+                  "(does not match last value(s) of #{shape.inspect})"
+          end
+        end
+      end
+    end
+
     # Assign value to array element(s)
     # 
     # @overload []=( *indices, value )
@@ -419,7 +477,12 @@ module Hornetseye
       value = indices.pop
       value = Node.match( value ).new value unless value.is_a? Node
       if indices.empty?
-        store value
+        check_shape value
+        unless compilable? and value.compilable? and dimension > 0
+          store value
+        else
+          GCCFunction.run self, value
+        end
       else
         if indices.last.is_a? Range
           view = slice indices.last.min, indices.last.size
@@ -463,15 +526,6 @@ module Hornetseye
       self
     end
 
-    # Check whether mode of computation is lazy
-    #
-    # @see #lazy
-    #
-    # @private
-    def lazy?
-      ( dimension > 0 and Thread.current[ :lazy ] ) or not variables.empty?
-    end
-
     # Force delayed computation unless in lazy mode
     #
     # @return [Node,Object] Result of computation
@@ -480,8 +534,10 @@ module Hornetseye
     #
     # @private
     def force
-      if lazy?
+      if ( dimension > 0 and Thread.current[ :lazy ] ) or not variables.empty?
         self
+      elsif finalised?
+        get
       else
         unless compilable?
           Hornetseye::lazy do
@@ -490,7 +546,7 @@ module Hornetseye
             retval.get
           end
         else
-          GCCFunction.run( self ).get
+          GCCFunction.run( pointer_type.new, self ).get
         end
       end
     end
@@ -503,6 +559,11 @@ module Hornetseye
     #
     # @private
     def simplify
+      #if Thread.current[ :function ] and dimension == 0
+      #  demand.dup
+      #else
+      #  demand
+      #end
       dimension == 0 ? demand.dup : demand
     end
 
@@ -517,10 +578,14 @@ module Hornetseye
       if other.is_a? Node
         return other, self
       else
-        return Node.match( other, typecode ).new( other ), self
+        return Node.match( other, self ).new( other ), self
       end
     end
 
+    def decompose
+      self
+    end
+
   end
 
 end

data/lib/multiarray/operations.rb

@@ -25,7 +25,9 @@ module Hornetseye
           target = typecode.send conversion
           target.new simplify.get.send( op )
         else
-          Hornetseye::UnaryOp( op, conversion ).new( self ).force
+          Hornetseye::ElementWise( lambda { |x| x.send op }, op,
+                                   lambda { |t| t.send conversion } ).
+            new( self ).force
         end
       end
     end
@@ -42,7 +44,9 @@ module Hornetseye
           target = array_type.send coercion, other.array_type
           target.new simplify.get.send( op, other.simplify.get )
         else
-          Hornetseye::BinaryOp( op, coercion ).new( self, other ).force
+          Hornetseye::ElementWise( lambda { |x,y| x.send op, y }, op,
+                                   lambda { |t,u| t.send coercion, u } ).
+            new( self, other ).force
         end
       end
     end
@@ -54,29 +58,37 @@ module Hornetseye
     define_unary_op :not, :bool
     define_unary_op :~
     define_unary_op :-@
+    define_unary_op :conj
+    define_unary_op :abs, :scalar
+    define_unary_op :arg, :float_scalar
     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 :*
-    define_binary_op :**, :largeint
+    define_binary_op :**, :coercion_maxint
     define_binary_op :/
     define_binary_op :%
-    define_binary_op :and, :bool_binary
-    define_binary_op :or, :bool_binary
+    define_binary_op :and, :coercion_bool
+    define_binary_op :or, :coercion_bool
     define_binary_op :&
     define_binary_op :|
     define_binary_op :^
     define_binary_op :<<
     define_binary_op :>>
-    define_binary_op :eq, :bool_binary
-    define_binary_op :ne, :bool_binary
-    define_binary_op :<=, :bool_binary
-    define_binary_op :<, :bool_binary
-    define_binary_op :>=, :bool_binary
-    define_binary_op :>, :bool_binary
-    define_binary_op :<=>, :byteval
+    define_binary_op :eq, :coercion_bool
+    define_binary_op :ne, :coercion_bool
+    define_binary_op :<=, :coercion_bool
+    define_binary_op :<, :coercion_bool
+    define_binary_op :>=, :coercion_bool
+    define_binary_op :>, :coercion_bool
+    define_binary_op :<=>, :coercion_byte
     define_binary_op :minor
     define_binary_op :major
 
@@ -84,6 +96,42 @@ module Hornetseye
       self
     end
 
+    def to_type( dest )
+      if dimension == 0 and variables.empty?
+        target = typecode.to_type dest
+        target.new simplify.get
+      else
+        key = "to_#{dest.to_s.downcase}"
+        Hornetseye::ElementWise( lambda { |x| x.to_type dest }, key,
+                                 lambda { |t| t.to_type dest } ).new( self ).force
+      end
+    end
+
+    def conditional( a, b )
+      unless a.is_a? Node
+        a = Node.match( a, b.is_a?( Node ) ? b : nil ).new a
+      end
+      unless b.is_a? Node
+        b = Node.match( b, a.is_a?( Node ) ? a : nil ).new b
+      end
+      if dimension == 0 and variables.empty? and
+        a.dimension == 0 and a.variables.empty? and
+        b.dimension == 0 and b.variables.empty?
+        target = array_type.cond a.array_type, b.array_type
+        target.new simplify.get.conditional( a.simplify.get, b.simplify.get )
+      else
+        Hornetseye::ElementWise( lambda { |x,y,z| x.conditional y, z }, :conditional,
+                                 lambda { |t,u,v| t.cond u, v } ).
+          new( self, a, b ).force
+      end
+    end
+
+    def <=>( other )
+      Hornetseye::lazy do
+        ( self < other ).conditional -1, ( self > other ).conditional( 1, 0 )
+      end
+    end
+
     # Lazy transpose of array
     #
     # Lazily compute transpose by swapping indices according to the specified
@@ -123,6 +171,13 @@ module Hornetseye
       end
     end
 
+    def collect( &action )
+      var = Variable.new typecode
+      block = action.call var
+      conversion = lambda { |t| t.to_type action.call( Variable.new( t.typecode ) ) }
+      Hornetseye::ElementWise( action, block.to_s, conversion ).new( self ).force
+    end
+
     def inject( initial = nil, options = {} )
       unless initial.nil?
         initial = Node.match( initial ).new initial unless initial.is_a? Node
@@ -231,6 +286,11 @@ module Hornetseye
     #
     # @private
     def product( filter )
+      filter = Node.match( filter, typecode ).new filter unless filter.is_a? Node
+      if dimension != filter.dimension
+        raise "Filter has #{filter.dimension} dimension(s) but should " +
+              "have #{dimension}"
+      end
       if dimension == 0
         self * filter
       else
@@ -244,9 +304,130 @@ module Hornetseye
     #
     # @return [Node] Result of convolution.
     def convolve( filter )
+      filter = Node.match( filter, typecode ).new filter unless filter.is_a? Node
       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 )
+        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
+      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 )
+        end
+      else
+        raise "Cannot assign green channel to object of type #{array_type.inspect}"
+      end
+    end
+
+    def b_with_decompose
+      if typecode < RGB_
+        decompose.roll.element 2
+      elsif typecode == OBJECT
+        b_without_decompose
+      else
+        self
+      end
+    end
+
+    alias_method_chain :b, :decompose
+
+    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 )
+        end
+      else
+        raise "Cannot assign blue channel to object of type #{array_type.inspect}"
+      end
+    end
+
+    def real_with_decompose
+      if typecode < COMPLEX_
+        decompose.roll.element 0
+      elsif typecode == OBJECT
+        real_without_decompose
+      else
+        self
+      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
+        end
+      else
+        self[] = value
+      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
+    end
+
+    alias_method_chain :imag, :decompose
+
+    def imag=( value )
+      if typecode < COMPLEX_
+        decompose.roll[ 1 ] = value
+      elsif typecode == OBJECT
+        self[] = Hornetseye::lazy do
+          real + value * ::Complex::I
+        end
+      else
+        raise "Cannot assign imaginary values to object of type #{array_type.inspect}"
+      end
+    end
+
   end
 
   class Node