multiarray 0.5.0 → 0.5.1

data/lib/multiarray/node.rb

@@ -22,13 +22,6 @@ module Hornetseye
 
     class << self
 
-      # Get string with information about this class
-      #
-      # @return [String] Returns +'Node'+.
-      def inspect
-        'Node'
-      end
-
       # Get unique descriptor of this class
       #
       # The method calls +descriptor( {} )+.
@@ -62,21 +55,10 @@ module Hornetseye
       # @private
       def match( value, context = nil )
         retval = fit value
-        retval = retval.align context if context
+        retval = retval.align context.basetype if context
         retval
       end
 
-      # Align this native datatype with another
-      #
-      # @param [Class] Native datatype to align with.
-      #
-      # @return [Class] Aligned native datatype.
-      #
-      # @private
-      def align( context )
-        self
-      end
-
       # Element-type of this term
       #
       # @return [Class] Element-type of this datatype.
@@ -84,6 +66,14 @@ module Hornetseye
         self
       end
 
+      def basetype
+        self
+      end
+
+      def typecodes
+        [ self ]
+      end
+
       # Array type of this term
       #
       # @return [Class] Resulting array type.
@@ -100,6 +90,10 @@ module Hornetseye
         Hornetseye::Pointer( self )
       end
 
+      def indgen( offset = 0, increment = 1 )
+        offset
+      end
+
       # Get shape of this term
       #
       # @return [Array<Integer>] Returns +[]+.
@@ -107,6 +101,17 @@ module Hornetseye
         []
       end
 
+      # Get size (number of elements) of this value
+      #
+      # @return [Integer] Returns +1+.
+      def size
+        1
+      end
+
+      def empty?
+        size == 0
+      end
+
       # Get dimension of this term
       #
       # @return [Array<Integer>] Returns +0+.
@@ -137,6 +142,25 @@ module Hornetseye
         other.coercion( self ).bool
       end
 
+      def maxint
+        self
+      end
+
+      def largeint( other )
+        coercion( other ).maxint
+      end
+
+      # Get corresponding floating-point datatype
+      #
+      # @return [Class] Returns +DFLOAT+.
+      def float
+        DFLOAT
+      end
+
+      def floating( other )
+        other.coercion( self ).float
+      end
+
       # Get variables contained in this datatype
       #
       # @return [Set] Returns +Set[]+.
@@ -218,6 +242,17 @@ module Hornetseye
       array_type.shape
     end
 
+    # Get size (number of elements) of this value
+    #
+    # @return [Integer] Returns +array_type.size+.
+    def size
+      array_type.size
+    end
+
+    def empty?
+      array_type.empty?
+    end
+
     # Get dimension of this term
     #
     # @return [Array<Integer>] Returns +array_type.dimension+.
@@ -257,42 +292,50 @@ module Hornetseye
         if dimension == 0 and not indent
           "#{array_type.inspect}(#{force.inspect})" # !!!
         else
-          prepend = indent ? '' : "#{array_type.inspect}:\n"
-          indent = 0
-          lines = 0
-          retval = '[ '
-          for i in 0 ... array_type.num_elements
-            x = Hornetseye::lazy { element i }
-            if x.dimension > 0
-              if i > 0
-                retval += ",\n  "
-                lines += 1
+          if indent
+            prepend = ''
+          else
+            prepend = "#{array_type.inspect}:\n"
+            indent = 0
+            lines = 0
+          end
+          if empty?
+            retval = '[]'
+          else
+            retval = '[ '
+            for i in 0 ... array_type.num_elements
+              x = Hornetseye::lazy { element i }
+              if x.dimension > 0
+                if i > 0
+                  retval += ",\n  "
+                  lines += 1
+                  if lines >= 10
+                    retval += '...' if indent == 0
+                    break
+                  end
+                  retval += '  ' * indent
+                end
+                str = x.inspect indent + 1, lines
+                lines += str.count "\n"
+                retval += str
                 if lines >= 10
                   retval += '...' if indent == 0
                   break
                 end
-                retval += '  ' * indent
-              end
-              str = x.inspect indent + 1, lines
-              lines += str.count "\n"
-              retval += str
-              if lines >= 10
-                retval += '...' if indent == 0
-                break
-              end
-            else
-              retval += ', ' if i > 0
-              str = x.force.inspect # !!!
-              if retval.size + str.size >= 74 - '...'.size -
-                  '[  ]'.size * indent.succ
-                retval += '...'
-                break
               else
-                retval += str
+                retval += ', ' if i > 0
+                str = x.force.inspect # !!!
+                if retval.size + str.size >= 74 - '...'.size -
+                    '[  ]'.size * indent.succ
+                  retval += '...'
+                  break
+                else
+                  retval += str
+                end
               end
             end
+            retval += ' ]' unless lines >= 10
           end
-          retval += ' ]' unless lines >= 10
           prepend + retval
         end
       else
@@ -346,25 +389,6 @@ module Hornetseye
       typecode.compilable?
     end
 
-    # Lazy transpose of array
-    #
-    # Lazily compute transpose by swapping indices according to the specified
-    # order.
-    #
-    # @param [Array<Integer>] order New order of indices.
-    #
-    # @return [Node] Returns the transposed array.
-    def transpose( *order )
-      term = self
-      variables = shape.reverse.collect do |i|
-        var = Variable.new INDEX( i )
-        term = term.element var
-        var
-      end.reverse
-      order.collect { |o| variables[o] }.
-        inject( term ) { |retval,var| Lambda.new var, retval }
-    end
-
     # Retrieve value of array element(s)
     #
     # @param [Array<Integer>] *indices Index/indices to select element.
@@ -374,7 +398,12 @@ module Hornetseye
       if indices.empty?
         force
       else
-        element( indices.last )[ *indices[ 0 ... -1 ] ]
+        if indices.last.is_a? Range
+          view = slice indices.last.min, indices.last.size
+        else
+          view = element indices.last
+        end
+        view[ *indices[ 0 ... -1 ] ]
       end
     end
 
@@ -392,7 +421,12 @@ module Hornetseye
       if indices.empty?
         store value
       else
-        element( indices.last )[ *indices[ 0 ... -1 ] ] = value
+        if indices.last.is_a? Range
+          view = slice indices.last.min, indices.last.size
+        else
+          view = element indices.last
+        end
+        view[ *indices[ 0 ... -1 ] ] = value
       end
     end
 
@@ -465,7 +499,7 @@ module Hornetseye
     #
     # @return [Node,Object] Result of simplification
     #
-    # @See @demand
+    # @see demand
     #
     # @private
     def simplify
@@ -487,110 +521,6 @@ module Hornetseye
       end
     end
 
-    def inject( initial = nil, options = {} )
-      unless initial.nil?
-        initial = Node.match( initial ).new initial unless initial.is_a? Node
-        initial_typecode = initial.typecode
-      else
-        initial_typecode = typecode
-      end
-      var1 = options[ :var1 ] || Variable.new( initial_typecode )
-      var2 = options[ :var2 ] || Variable.new( typecode )
-      block = options[ :block ] || yield( var1, var2 )
-      if dimension == 0
-        if initial
-          block.subst( var1 => initial, var2 => self ).simplify
-        else
-          demand
-        end
-      else
-        index = Variable.new Hornetseye::INDEX( nil )
-        value = element( index ).
-          inject nil, :block => block, :var1 => var1, :var2 => var2
-        Inject.new( value, index, initial, block, var1, var2 ).force
-      end
-    end
-
-    # Equality operator
-    #
-    # @return [FalseClass,TrueClass] Returns result of comparison.
-    def ==( other )
-      if other.is_a? Node and other.array_type == array_type
-        Hornetseye::eager { eq( other ).inject( true ) { |a,b| a.and b } }
-      else
-        false
-      end
-    end
-
-    # Apply accumulative operation over elements diagonally
-    #
-    # This method is used internally to implement convolutions.
-    #
-    # @param [Object,Node] initial Initial value.
-    # @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.
-    # @yield Optional operation to apply diagonally.
-    #
-    # @return [Node] Result of operation.
-    #
-    # @see #convolve
-    #
-    # @private
-    def diagonal( initial = nil, options = {} )
-      if dimension == 0
-        demand
-      else
-        if initial
-          initial = Node.match( initial ).new initial unless initial.is_a? Node
-          initial_typecode = initial.typecode
-        else
-          initial_typecode = typecode
-        end
-        index0 = Variable.new Hornetseye::INDEX( nil )
-        index1 = Variable.new Hornetseye::INDEX( nil )
-        index2 = Variable.new Hornetseye::INDEX( nil )
-        var1 = options[ :var1 ] || Variable.new( initial_typecode )
-        var2 = options[ :var2 ] || Variable.new( typecode )
-        block = options[ :block ] || yield( var1, var2 )
-        value = element( index1 ).element( index2 ).
-          diagonal initial, :block => block, :var1 => var1, :var2 => var2
-        term = Diagonal.new( value, index0, index1, index2, initial,
-                             block, var1, var2 )
-        index0.size[] ||= index1.size[]
-        Lambda.new( index0, term ).force
-      end
-    end
-
-    # Compute product table from two arrays
-    #
-    # Used internally to implement convolutions.
-    #
-    # @param [Node] filter Filter to form product table with.
-    #
-    # @return [Node] Result of operation.
-    #
-    # @see #convolve
-    #
-    # @private
-    def product( filter )
-      if dimension == 0
-        self * filter
-      else
-        Hornetseye::lazy { |i,j| self[j].product filter[i] }
-      end
-    end
-
-    # Convolution with other array of same dimension
-    #
-    # @param [Node] filter Filter to convolve with.
-    #
-    # @return [Node] Result of convolution.
-    def convolve( filter )
-      product( filter ).diagonal { |s,x| s + x }
-    end
-
   end
 
 end

data/lib/multiarray/object.rb

@@ -37,7 +37,7 @@ module Hornetseye
       #
       # @private
       def descriptor( hash )
-        'OBJECT'
+        inspect
       end
 
       # Get memory type required to store elements of this type
@@ -86,6 +86,14 @@ module Hornetseye
         return self, self
       end
 
+      def bool
+        self
+      end
+
+      def float
+        OBJECT
+      end
+
       # Check whether this term is compilable
       #
       # @return [FalseClass,TrueClass] Returns +false+.
@@ -118,10 +126,20 @@ module Hornetseye
         OBJECT
       end
 
+      def align( context )
+        self
+      end
+
     end
 
     Node.extend Match
 
   end
 
+  def OBJECT( value )
+    OBJECT.new value
+  end
+
+  module_function :OBJECT
+
 end

data/lib/multiarray/operations.rb

@@ -25,7 +25,7 @@ module Hornetseye
           target = typecode.send conversion
           target.new simplify.get.send( op )
         else
-          Hornetseye::Unary( op, conversion ).new( self ).force
+          Hornetseye::UnaryOp( op, conversion ).new( self ).force
         end
       end
     end
@@ -34,27 +34,33 @@ module Hornetseye
 
     def define_binary_op( op, coercion = :coercion )
       define_method( op ) do |other|
-        other = Node.match( other, typecode ).new other unless other.is_a? Node
+        unless other.is_a? Node
+          other = Node.match( other, typecode ).new other
+        end
         if dimension == 0 and variables.empty? and
             other.dimension == 0 and other.variables.empty?
           target = array_type.send coercion, other.array_type
-          target.new demand.get.send( op, other.simplify.get )
+          target.new simplify.get.send( op, other.simplify.get )
         else
-          Hornetseye::Binary( op, coercion ).new( self, other ).force
+          Hornetseye::BinaryOp( op, coercion ).new( self, other ).force
         end
       end
     end
 
     module_function :define_binary_op
 
-    define_unary_op  :zero?   , :bool
-    define_unary_op  :nonzero?, :bool
-    define_unary_op  :not, :bool
-    define_unary_op  :~
-    define_unary_op  :-@
+    define_unary_op :zero?, :bool
+    define_unary_op :nonzero?, :bool
+    define_unary_op :not, :bool
+    define_unary_op :~
+    define_unary_op :-@
+    define_unary_op :floor
+    define_unary_op :ceil
+    define_unary_op :round
     define_binary_op :+
     define_binary_op :-
     define_binary_op :*
+    define_binary_op :**, :largeint
     define_binary_op :/
     define_binary_op :%
     define_binary_op :and, :bool_binary
@@ -66,6 +72,180 @@ module Hornetseye
     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 :minor
+    define_binary_op :major
+
+    def +@
+      self
+    end
+
+    # Lazy transpose of array
+    #
+    # Lazily compute transpose by swapping indices according to the specified
+    # order.
+    #
+    # @param [Array<Integer>] order New order of indices.
+    #
+    # @return [Node] Returns the transposed array.
+    def transpose( *order )
+      term = self
+      variables = shape.reverse.collect do |i|
+        var = Variable.new Hornetseye::INDEX( i )
+        term = term.element var
+        var
+      end.reverse
+      order.collect { |o| variables[o] }.
+        inject( term ) { |retval,var| Lambda.new var, retval }
+    end
+
+    def roll( n = 1 )
+      if n < 0
+        unroll -n
+      else
+        order = ( 0 ... dimension ).to_a
+        n.times { order = order[ 1 .. -1 ] + [ order.first ] }
+        transpose *order
+      end
+    end
+
+    def unroll( n = 1 )
+      if n < 0
+        roll -n
+      else
+        order = ( 0 ... dimension ).to_a
+        n.times { order = [ order.last ] + order[ 0 ... -1 ] }
+        transpose *order
+      end
+    end
+
+    def inject( initial = nil, options = {} )
+      unless initial.nil?
+        initial = Node.match( initial ).new initial unless initial.is_a? Node
+        initial_typecode = initial.typecode
+      else
+        initial_typecode = typecode
+      end
+      var1 = options[ :var1 ] || Variable.new( initial_typecode )
+      var2 = options[ :var2 ] || Variable.new( typecode )
+      block = options[ :block ] || yield( var1, var2 )
+      if dimension == 0
+        if initial
+          block.subst( var1 => initial, var2 => self ).simplify
+        else
+          demand
+        end
+      else
+        index = Variable.new Hornetseye::INDEX( nil )
+        value = element( index ).
+          inject nil, :block => block, :var1 => var1, :var2 => var2
+        Inject.new( value, index, initial, block, var1, var2 ).force
+      end
+    end
+
+    # Equality operator
+    #
+    # @return [FalseClass,TrueClass] Returns result of comparison.
+    def eq_with_multiarray( other )
+      if other.is_a? Node
+        if variables.empty?
+          if other.array_type == array_type
+            Hornetseye::eager { eq( other ).inject( true ) { |a,b| a.and b } }
+          else
+            false
+          end
+        else
+          eq_without_multiarray other
+        end
+      else
+        false
+      end
+    end
+
+    alias_method_chain :==, :multiarray, :eq
+
+    def min
+      inject { |a,b| a.minor b }
+    end
+
+    def max
+      inject { |a,b| a.major b }
+    end
+
+    # Apply accumulative operation over elements diagonally
+    #
+    # This method is used internally to implement convolutions.
+    #
+    # @param [Object,Node] initial Initial value.
+    # @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.
+    # @yield Optional operation to apply diagonally.
+    #
+    # @return [Node] Result of operation.
+    #
+    # @see #convolve
+    #
+    # @private
+    def diagonal( initial = nil, options = {} )
+      if dimension == 0
+        demand
+      else
+        if initial
+          unless initial.is_a? Node
+            initial = Node.match( initial ).new initial
+          end
+          initial_typecode = initial.typecode
+        else
+          initial_typecode = typecode
+        end
+        index0 = Variable.new Hornetseye::INDEX( nil )
+        index1 = Variable.new Hornetseye::INDEX( nil )
+        index2 = Variable.new Hornetseye::INDEX( nil )
+        var1 = options[ :var1 ] || Variable.new( initial_typecode )
+        var2 = options[ :var2 ] || Variable.new( typecode )
+        block = options[ :block ] || yield( var1, var2 )
+        value = element( index1 ).element( index2 ).
+          diagonal initial, :block => block, :var1 => var1, :var2 => var2
+        term = Diagonal.new( value, index0, index1, index2, initial,
+                             block, var1, var2 )
+        index0.size[] ||= index1.size[]
+        Lambda.new( index0, term ).force
+      end
+    end
+
+    # Compute product table from two arrays
+    #
+    # Used internally to implement convolutions.
+    #
+    # @param [Node] filter Filter to form product table with.
+    #
+    # @return [Node] Result of operation.
+    #
+    # @see #convolve
+    #
+    # @private
+    def product( filter )
+      if dimension == 0
+        self * filter
+      else
+        Hornetseye::lazy { |i,j| self[j].product filter[i] }
+      end
+    end
+
+    # Convolution with other array of same dimension
+    #
+    # @param [Node] filter Filter to convolve with.
+    #
+    # @return [Node] Result of convolution.
+    def convolve( filter )
+      product( filter ).diagonal { |s,x| s + x }
+    end
 
   end