multiarray 0.4.1 → 0.5.0

data/lib/multiarray/lambda.rb

@@ -0,0 +1,100 @@
+# 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 Lambda < Node
+
+    def initialize( index, term )
+      @index = index
+      @term = term
+    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 @index => ( ( hash.values.max || 0 ) + 1 )
+      "Lambda(#{@index.descriptor( hash )},#{@term.descriptor( hash )})"
+    end
+
+    def array_type
+      Hornetseye::Sequence @term.array_type, @index.size.get
+    end
+
+    def variables
+      @term.variables - @index.variables + @index.meta.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
+      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.subst( @index => var ) )
+    end
+
+    def subst( hash )
+      subst_var = @index.subst hash
+      Lambda.new subst_var, @term.subst( @index => subst_var ).subst( hash )
+    end
+
+    def store( value )
+      shape.last.times do |i|
+        node = value.dimension == 0 ? value : value.element( INT.new( i ) )
+        element( INT.new( i ) ).store node
+      end
+      value
+    end
+
+    # Lookup element of an array
+    #
+    # @param [Node] value Index of element.
+    # @param [Node] stride Stride for iterating over elements.
+    #
+    # @return [Lookup,Lambda] Result of lookup.
+    #
+    # @private
+    def lookup( value, stride )
+      if value.is_a? Variable
+        Lookup.new self, value, stride
+      else
+        Lambda.new @index, @term.lookup( value, stride )
+      end
+    end
+
+    def element( i )
+      i = Node.match( i ).new i unless i.is_a? Node
+      i.size.store @index.size if @index.size.get and i.is_a? Variable
+      @term.subst @index => i
+    end
+
+  end
+
+end

data/lib/multiarray/list.rb

@@ -1,71 +1,48 @@
+# 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 creating views on Ruby arrays
-  #
-  # @private
+
   class List
 
-    # Create view on a Ruby array
-    #
-    # @param [Integer] n Number of elements of the view.
-    # @option options [Array<Object>] :array ([nil] * n) The Ruby array.
-    # @option options [Integer] :offset (0) Offset of the view.
-    #
-    # @private
     def initialize( n, options = {} )
       @array = options[ :array ] || [ nil ] * n
       @offset = options[ :offset ] || 0
     end
 
-    # Display information about this object
-    #
-    # @return [String] A string with information about the size of this view.
     def inspect
       "List(#{@array.size - @offset})"
     end
 
-    # Retrieve and map element from the array
-    #
-    # @param [Class] type Native data type to create
-    # @return [Type] The mapped element.
-    def fetch( type )
-      type.new read
+    def to_s
+      "List(#{@array[ @offset .. -1 ]})"
     end
 
-    # Retrieve an element from the array
-    #
-    # @return [Object] The element from the array.
-    #
-    # @see #write
-    # @see Malloc#read
-    #
-    # @private
-    def read
-      @array[ @offset ]
+    def +( offset )
+      List.new 0, :array => @array, :offset => @offset + offset
     end
 
-    # Store an element in the array
-    #
-    # @param [Object] value The Ruby object to store.
-    # @return [Object] Returns the parameter +value+.
-    #
-    # @see #read
-    # @see Malloc#write
-    #
-    # @private
-    def write( value )
-      @array[ @offset ] = value
+    def load( typecode )
+      @array[ @offset ]
     end
 
-    # Create a new view with the specified offset
-    #
-    # @param [Integer] offset A non-negative offset.
-    # @return [List] A new view for the specified part of the array.
-    #
-    # @see Malloc#+
-    # @private
-    def +( offset )
-      List.new 0, :array => @array, :offset => @offset + offset
+    def save( value )
+      @array[ @offset ] = value.get
+      value
     end
 
   end

data/lib/multiarray/lookup.rb

@@ -0,0 +1,85 @@
+# 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 Lookup < Node
+
+    def initialize( p, index, stride )
+      @p, @index, @stride = p, index, stride
+    end
+
+    # Get unique descriptor of this object
+    #
+    # @param [Hash] hash Labels for any variables.
+    #
+    # @return [String] Descriptor of this object,
+    #
+    # @private
+    def descriptor( hash )
+      "Lookup(#{@p.descriptor( hash )},#{@index.descriptor( hash )},#{@stride.descriptor( hash )})"
+    end
+
+    def array_type
+      @p.array_type
+    end
+
+    def subst( hash )
+      @p.subst( hash ).lookup @index.subst( hash ), @stride.subst( hash )
+    end
+
+    def variables
+      @p.variables + @index.variables + @stride.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 = @p.strip
+      vars2, values2, term2 = @stride.strip
+      return vars1 + vars2, values1 + values2,
+        Lookup.new( term1, @index, term2 )
+    end
+
+    # Lookup element of an array
+    #
+    # @param [Node] value Index of element.
+    # @param [Node] stride Stride for iterating over elements.
+    #
+    # @private
+    def lookup( value, stride )
+      if value.is_a? Variable
+        Lookup.new self, value, stride
+      else
+        Lookup.new @p.lookup( value, stride ), @index, @stride
+      end
+    end
+
+    def element( i )
+      Lookup.new @p.element( i ), @index, @stride
+    end
+
+  end
+
+end

data/lib/multiarray/malloc.rb

@@ -1,9 +1,35 @@
+# 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 Malloc
 
-    def fetch( type )
-      type.import read( type.storage_size )
+    def load( typecode )
+      read( typecode.storage_size ).unpack( typecode.directive ).first
+    end
+
+    def save( value )
+      write [ value.get ].pack( value.typecode.directive )
+      value
+    end
+
+    def to_s
+      inspect
     end
 
   end

data/lib/multiarray/multiarray.rb

@@ -1,29 +1,54 @@
+# 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 MultiArray
 
     class << self
 
-      # Create a multi-dimensional array
-      #
-      # Creates a multi-dimensional array with elements of type
-      # +element_type+ and dimensions +*shape+.
-      #
-      # @param [Class] element_type Element type of the array. Should derive
-      # from +Type+.
-      # @param [Array<Integer>] *shape The dimensions of the array.
-      # @return [Type,Sequence_] An array with the specified element type and
-      # the specified dimensions.
-      #
-      # @see #MultiArray
-      # @see Sequence.new
-      def new( element_type, *shape )
-        Hornetseye::MultiArray( element_type, *shape ).new
+      def new( typecode, *shape )
+        options = shape.last.is_a?( Hash ) ? shape.pop : {}
+        count = options[ :count ] || 1
+        if shape.empty?
+          memory = typecode.memory.new typecode.storage_size * count
+          Hornetseye::Pointer( typecode ).new memory
+        else
+          size = shape.pop
+          stride = shape.inject( 1 ) { |a,b| a * b }
+          Hornetseye::lazy( size ) do |index|
+            pointer = new typecode, *( shape + [ :count => count * size ] )
+            Lookup.new pointer, index, INT.new( stride )
+          end
+        end
       end
 
       def []( *args )
-        retval = Type.fit( args ).new
-        retval[] = args
+        retval = Node.fit( args ).new
+        recursion = proc do |element,args|
+          if element.dimension > 0
+            args.each_with_index do |arg,i|
+              recursion.call element.element( i ), arg
+            end
+          else
+            element[] = args
+          end
+        end
+        recursion.call retval, args
         retval
       end
 
@@ -31,23 +56,12 @@ module Hornetseye
 
   end
 
-  # Create a multi-dimensional array class
-  #
-  # Creates a multi-dimensional array class with elements of type
-  # +element_type+ and dimensions +*shape+.
-  #
-  # @param [Class] element_type Element type of the array type. Should derive
-  # from +Type+.
-  # @param [Array<Integer>] *shape The dimensions of the array type.
-  # @return [Class] A class deriving from +Pointer_+.
-  #
-  # @see MultiArray.new
-  # @see #Sequence
   def MultiArray( element_type, *shape )
     if shape.empty?
       element_type
     else
-      MultiArray Sequence( element_type, shape.first ), *shape[ 1 .. -1 ]
+      Hornetseye::Sequence MultiArray( element_type, *shape[ 0 ... -1 ] ),
+                           shape.last
     end
   end
 

data/lib/multiarray/node.rb

@@ -0,0 +1,596 @@
+# 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
+
+  # Base class for representing native datatypes and operations (terms)
+  class Node
+
+    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( {} )+.
+      #
+      # @return [String] Descriptor of this class.
+      #
+      # @see #descriptor
+      #
+      # @private
+      def to_s
+        descriptor( {} )
+      end
+
+      # Get unique descriptor of this class
+      #
+      # @param [Hash] hash Labels for any variables.
+      #
+      # @return [String] Descriptor of this class.
+      #
+      # @private
+      def descriptor( hash )
+        'Node'
+      end
+
+      # Find matching native datatype to a Ruby value
+      #
+      # @param [Object] value Value to find native datatype for.
+      #
+      # @return [Class] Matching native datatype.
+      #
+      # @private
+      def match( value, context = nil )
+        retval = fit value
+        retval = retval.align context 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.
+      def typecode
+        self
+      end
+
+      # Array type of this term
+      #
+      # @return [Class] Resulting array type.
+      #
+      # @private
+      def array_type
+        self
+      end
+
+      # Convert to pointer type
+      #
+      # @return [Class] Corresponding pointer type.
+      def pointer_type
+        Hornetseye::Pointer( self )
+      end
+
+      # Get shape of this term
+      #
+      # @return [Array<Integer>] Returns +[]+.
+      def shape
+        []
+      end
+
+      # Get dimension of this term
+      #
+      # @return [Array<Integer>] Returns +0+.
+      def dimension
+        0
+      end
+
+      # Get corresponding contiguous datatype
+      #
+      # @return [Class] Returns +self+.
+      #
+      # @private
+      def contiguous
+        self
+      end
+
+      # Get corresponding boolean-based datatype
+      #
+      # @return [Class] Returns +BOOL+.
+      def bool
+        BOOL
+      end
+
+      # Get boolean-based datatype for binary operation
+      #
+      # @return [Class] Returns +BOOL+.
+      def bool_binary( other )
+        other.coercion( self ).bool
+      end
+
+      # Get variables contained in this datatype
+      #
+      # @return [Set] Returns +Set[]+.
+      #
+      # @private
+      def variables
+        Set[]
+      end
+
+      # Category operator
+      #
+      # @return [FalseClass,TrueClass] Check for equality or kind.
+      def ===( other )
+        ( other == self ) or ( other.is_a? self ) or ( other.class == self )
+      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
+        return [], [], self
+      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 )
+        hash[ self ] || self
+      end
+
+      # Check whether this term is compilable
+      #
+      # @return [FalseClass,TrueClass] Returns +true+.
+      #
+      # @private
+      def compilable?
+        true
+      end
+
+    end
+
+    # Array type of this term
+    #
+    # @return [Class] Resulting array type.
+    def array_type
+      self.class.array_type
+    end
+
+    # Convert to pointer type
+    #
+    # @return [Class] Corresponding pointer type.
+    def pointer_type
+      array_type.pointer_type
+    end
+
+    # Element-type of this term
+    #
+    # @return [Class] Element-type of this datatype.
+    def typecode
+      array_type.typecode
+    end
+
+    # Get shape of this term
+    #
+    # @return [Array<Integer>] Returns +array_type.shape+.
+    def shape
+      array_type.shape
+    end
+
+    # Get dimension of this term
+    #
+    # @return [Array<Integer>] Returns +array_type.dimension+.
+    def dimension
+      array_type.dimension
+    end
+
+    # Extract native value if this is an element
+    #
+    # @return [Node,Object] Returns +self+.
+    #
+    # @private
+    def get
+      self
+    end
+
+    # Convert to Ruby array of objects
+    #
+    # Perform pending computations and convert native array to Ruby array of
+    # objects.
+    #
+    # @return [Array<Object>] Array of objects.
+    def to_a
+      if dimension == 0
+        force
+      else
+        n = shape.last
+        ( 0 ... n ).collect { |i| element( i ).to_a }
+      end
+    end
+
+    # Display information about this object
+    #
+    # @return [String] String with information about this object.
+    def inspect( indent = nil, lines = nil )
+      if variables.empty?
+        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 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
+              end
+            end
+          end
+          retval += ' ]' unless lines >= 10
+          prepend + retval
+        end
+      else
+        to_s
+      end
+    end
+
+    # Get unique descriptor of this object
+    #
+    # The method calls +descriptor( {} )+.
+    #
+    # @return [String] Descriptor of this object.
+    #
+    # @see #descriptor
+    #
+    # @private
+    def to_s
+      descriptor( {} )
+    end
+
+    # Get unique descriptor of this object
+    #
+    # @param [Hash] hash Labels for any variables.
+    #
+    # @return [String] Descriptor of this object.
+    #
+    # @private
+    def descriptor( hash )
+      'Node()'
+    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 )
+      hash[ self ] || self
+    end
+
+    # Check whether this term is compilable
+    #
+    # @return [FalseClass,TrueClass] Returns +typecode.compilable?+.
+    #
+    # @private
+    def compilable?
+      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.
+    #
+    # @return [Object,Node] Value of array element or a sub-element.
+    def []( *indices )
+      if indices.empty?
+        force
+      else
+        element( indices.last )[ *indices[ 0 ... -1 ] ]
+      end
+    end
+
+    # Assign value to array element(s)
+    # 
+    # @overload []=( *indices, value )
+    #   Assign a value to an element of an array
+    #   @param [Array<Integer>] *indices Index/indices to select the element.
+    #   @param [Object,Node] value Ruby object with new value.
+    #
+    # @return [Object,Node] Returns the value.
+    def []=( *indices )
+      value = indices.pop
+      value = Node.match( value ).new value unless value.is_a? Node
+      if indices.empty?
+        store value
+      else
+        element( indices.last )[ *indices[ 0 ... -1 ] ] = value
+      end
+    end
+
+    # Get variables contained in this object
+    #
+    # @return [Set] Returns +Set[]+.
+    #
+    # @private
+    def variables
+      Set[]
+    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
+      return [], [], self
+    end
+
+    # Reevaluate computation
+    #
+    # @return [Node,Object] Result of computation
+    #
+    # @see #force
+    #
+    # @private
+    def demand
+      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
+    #
+    # @see #demand
+    #
+    # @private
+    def force
+      if lazy?
+        self
+      else
+        unless compilable?
+          Hornetseye::lazy do
+            retval = array_type.new
+            retval[] = self
+            retval.get
+          end
+        else
+          GCCFunction.run( self ).get
+        end
+      end
+    end
+
+    # Reevaluate term
+    #
+    # @return [Node,Object] Result of simplification
+    #
+    # @See @demand
+    #
+    # @private
+    def simplify
+      dimension == 0 ? demand.dup : demand
+    end
+
+    # Coerce with other object
+    #
+    # @param [Node,Object] other Other object.
+    #
+    # @return [Array<Node>] Result of coercion.
+    #
+    # @private
+    def coerce( other )
+      if other.is_a? Node
+        return other, self
+      else
+        return Node.match( other, typecode ).new( other ), self
+      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