multiarray 0.4.1 → 0.5.0

data/lib/multiarray/object.rb

@@ -1,11 +1,46 @@
+# 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 representing Ruby objects
-  class OBJECT < Type
+  class OBJECT < Element
 
     class << self
 
-      # Get memory type for storing objects of this type
+      # Get string with information about this class
+      #
+      # @return [String] Returns +'OBJECT'+.
+      def inspect
+        'OBJECT'
+      end
+
+      # Get unique descriptor of this class
+      #
+      # @param [Hash] hash Labels for any variables.
+      #
+      # @return [String] Descriptor of this class.
+      #
+      # @private
+      def descriptor( hash )
+        'OBJECT'
+      end
+
+      # Get memory type required to store elements of this type
       #
       # @return [Class] Returns +List+.
       #
@@ -16,21 +51,16 @@ module Hornetseye
         List
       end
 
-      # Get string with information about this type
+      # Get storage size to store an element of this type
       #
-      # @return [String] Returns +'OBJECT'+.
-      def to_s
-        'OBJECT'
-      end
-
-      # Get string with information about this type
+      # @return [Integer] Returns +1+.
       #
-      # @return [String] Returns +'OBJECT'+.
-      def inspect
-        to_s
+      # @private
+      def storage_size
+        1
       end
 
-      # Default value for Ruby objects
+      # Get default value for elements of this type
       #
       # @return [Object] Returns +nil+.
       #
@@ -39,45 +69,58 @@ module Hornetseye
         nil
       end
 
-      # Size of storage required to store an element of this type
-      #
-      # @return [Integer] Size of storage required. Returns +1+.
-      #
-      # @private
-      def storage_size
-        1
-      end
-
       def coercion( other )
-        if other < Pointer_
+        if other < Sequence_
           other.coercion self
         else
           self
         end
       end
 
+      # Coerce with other object
+      #
+      # @param [Node,Object] other Other object.
+      #
+      # @return [Array<Node>] Result of coercion.
       def coerce( other )
         return self, self
       end
 
-    end
+      # Check whether this term is compilable
+      #
+      # @return [FalseClass,TrueClass] Returns +false+.
+      #
+      # @private
+      def compilable?
+        false
+      end
 
-    def store( ptr )
-      ptr.write @value
-      self
     end
 
-    raise '\'multiarray/object\' must be loaded first' if Type.respond_to? :fit
-
-    module RubyMatching
+    # Namespace containing method for matching elements of type OBJECT
+    #
+    # @see OBJECT
+    #
+    # @private
+    module Match
 
+      # Method for matching elements of type OBJECT
+      #
+      # @param [Array<Object>] *values Values to find matching native element
+      # type for.
+      #
+      # @return [Class] Native type fitting all values.
+      #
+      # @see OBJECT
+      #
+      # @private
       def fit( *values )
         OBJECT
       end
 
     end
 
-    Type.extend RubyMatching
+    Node.extend Match
 
   end
 

data/lib/multiarray/operations.rb

@@ -0,0 +1,78 @@
+# 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
+
+  module Operations
+
+    def define_unary_op( op, conversion = :contiguous )
+      define_method( op ) do
+        if dimension == 0 and variables.empty?
+          target = typecode.send conversion
+          target.new simplify.get.send( op )
+        else
+          Hornetseye::Unary( op, conversion ).new( self ).force
+        end
+      end
+    end
+
+    module_function :define_unary_op
+
+    def define_binary_op( op, coercion = :coercion )
+      define_method( op ) do |other|
+        other = Node.match( other, typecode ).new other unless other.is_a? Node
+        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 )
+        else
+          Hornetseye::Binary( 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_binary_op :+
+    define_binary_op :-
+    define_binary_op :*
+    define_binary_op :/
+    define_binary_op :%
+    define_binary_op :and, :bool_binary
+    define_binary_op :or, :bool_binary
+    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
+
+  end
+
+  class Node
+
+    include Operations
+
+  end
+
+end

data/lib/multiarray/pointer.rb

@@ -1,9 +1,139 @@
+# 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/>.
+
 module Hornetseye
 
-  def Pointer( primitive )
-    retval = Class.new Pointer_
-    retval.primitive = primitive
-    retval
+  class Pointer_ < Node
+
+    class << self
+
+      # Target type of pointer
+      #
+      # @return [Node] Type of object the pointer is pointing at.
+      attr_accessor :target
+
+      def inspect
+        "*(#{target.inspect})"
+      end
+
+      # Get unique descriptor of this class
+      #
+      # @param [Hash] hash Labels for any variables.
+      #
+      # @return [String] Descriptor of this class.
+      #
+      # @private
+      def descriptor( hash )
+        "*(#{target.to_s})"
+      end
+
+      # Get default value for elements of this type
+      #
+      # @return [Memory,List] Memory for storing object of type +target+.
+      def default
+        target.memory.new target.storage_size
+      end
+
+      def ==( other )
+        other.is_a? Class and other < Pointer_ and
+          target == other.target
+      end
+
+      def hash
+        [ :Pointer_, target ].hash
+      end
+
+      def eql?
+        self == other
+      end
+
+      def typecode
+        target
+      end
+
+      def array_type
+        target
+      end
+
+      def pointer_type
+        self
+      end
+
+    end
+
+    def initialize( value = self.class.default )
+      @value = value
+    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
+      variable = Variable.new self.class
+      return [ variable ], [ self ], variable
+    end
+
+    def descriptor( hash )
+      "#{self.class.to_s}(#{@value.to_s})"
+    end
+
+    def store( value )
+      result = value.simplify
+      self.class.target.new( result.get ).write @value
+      result
+    end
+
+    # Reevaluate computation
+    #
+    # @return [Node,Object] Result of computation
+    #
+    # @see #force
+    #
+    # @private
+    def demand
+      self.class.target.fetch( @value ).simplify
+    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
+        self.class.new @value + ( stride.get *
+                                  self.class.target.storage_size ) * value.get
+      end
+    end
+
+  end
+
+  def Pointer( target )
+    p = Class.new Pointer_
+    p.target = target
+    p
   end
 
   module_function :Pointer

data/lib/multiarray/sequence.rb

@@ -1,32 +1,50 @@
+# 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 representing uniform arrays
   class Sequence
 
     class << self
 
-      # Create a one-dimensional array
-      #
-      # Create an array with +num_elements+ elements of type +element_type+.
+      # Allocate new uniform array
       #
-      # @param [Class] element_type Element type of the array. Should derive
-      # from +Type+.
-      # @param [Integer] num_elements Number of elements of the array.
-      # @return [Sequence_] An array with the specified element type and the
-      # specified number of elements.
+      # @param [Class] typecode Type of array elements.
+      # @param [Integer] size Number of elements.
       #
-      # @see #Sequence
-      # @see MultiArray.new
-      def new( element_type, num_elements )
-        Hornetseye::Sequence( element_type, num_elements ).new
+      # @return [Node] Returns uninitialised native array.
+      def new( typecode, size )
+        MultiArray.new typecode, size
       end
 
+      # Convert array to uniform array
+      #
+      # A native type which fits all elements is determined and used to create
+      # a uniform array of those elements.
+      #
+      # @param [Array<Object>] *args Elements of array.
+      #
+      # @return [Node] Returns native array with values.
       def []( *args )
-        target = Type.fit args
-        if target.primitive.dimension > 1
-          target = Hornetseye::Sequence OBJECT, args.size
-        end
+        target = Node.fit args
+        target = Hornetseye::Sequence OBJECT, args.size if target.dimension > 1
         retval = target.new
-        retval[] = args
+        args.each_with_index { |arg,i| retval[ i ] = arg }
         retval
       end
 
@@ -34,27 +52,180 @@ module Hornetseye
 
   end
 
-  # Create an array class
-  #
-  # The parameters +element_type+, +num_elements+, and +stride+ are assigned
-  # to the corresponding attributes of the resulting class.
-  #
-  # @param [Class] element_type Element type of the array type. Should derive
-  # from +Type+.
-  # @param [Integer] num_elements Number of elements of the array type.
-  # @param [Integer] stride Optional stride size for transposed or
-  # non-contiguous array types.
-  # @return [Class] An array class deriving from +Pointer_+.
-  #
-  # @see Sequence.new
-  # @see #MultiArray
-  def Sequence( element_type, num_elements,
-                stride = element_type.dereference.size )
-    sequence = Class.new Sequence_
-    sequence.element_type = element_type.dereference
-    sequence.num_elements = num_elements
-    sequence.stride = stride
-    Pointer sequence
+  # Class for representing n-dimensional native arrays
+  class Sequence_
+
+    class << self
+
+      # Type of array elements
+      #
+      # @return [Class] element_type Type of array elements.
+      attr_accessor :element_type
+
+      # Number of array elements
+      #
+      # @return [Integer] num_elements Number of elements.
+      attr_accessor :num_elements
+
+      def default
+        Hornetseye::lazy( num_elements ) do |i|
+          if element_type.dimension > 0
+            element = element_type.default
+          else
+            element = element_type.new
+          end
+        end
+      end
+
+      def indgen( offset = 0, increment = 1 )
+        Hornetseye::lazy( num_elements ) do |i|
+          if offset == 0
+            if increment == 1
+              i
+            else
+              increment * i
+            end
+          else
+            if increment == 1
+              offset + i
+            else
+              offset + increment * i
+            end
+          end
+        end
+      end
+
+      def shape
+        element_type.shape + [ num_elements ]
+      end
+
+      def typecode
+        element_type.typecode
+      end
+
+      def array_type
+        self
+      end
+
+      def pointer_type
+        self
+      end
+
+      def dimension
+        element_type.dimension + 1
+      end
+
+      def contiguous
+        self
+      end
+
+      def bool
+        Hornetseye::Sequence element_type.bool, num_elements
+      end
+
+      def bool_binary( other )
+        coercion( other ).bool
+      end
+
+      def inspect
+        if dimension == 1
+          "Sequence(#{typecode.inspect},#{num_elements.inspect})"
+        else
+          "MultiArray(#{typecode.inspect},#{shape.join ','})"
+        end
+      end
+
+      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 )
+        if dimension == 1
+          "Sequence(#{typecode.descriptor( hash )},#{num_elements.to_s})"
+        else
+          "MultiArray(#{typecode.descriptor( hash )},#{shape.join ','})"
+        end
+      end
+
+      def ==( other )
+        other.is_a? Class and other < Sequence_ and
+          other.element_type == element_type and
+          other.num_elements == num_elements
+      end
+
+      def coercion( other )
+        if other < Sequence_
+          Hornetseye::Sequence element_type.coercion( other.element_type ),
+                               num_elements
+        else
+          Hornetseye::Sequence element_type.coercion( other ),
+                               num_elements
+        end
+      end
+
+      def coerce( other )
+        if other < Sequence_
+          return other, self
+        else
+          return Hornetseye::Sequence( other, num_elements ), self
+        end
+      end
+
+      def new
+        MultiArray.new typecode, *shape
+      end
+
+    end
+
+    # Namespace containing method for matching elements of type Sequence_
+    #
+    # @see Sequence_
+    #
+    # @private
+    module Match
+
+      # Method for matching elements of type Sequence_
+      #
+      # 'param [Array<Object>] *values Values to find matching native element
+      # type for.
+      #
+      # @return [Class] Native type fitting all values.
+      #
+      # @see Sequence_
+      #
+      # @private
+      def fit( *values )
+        n = values.inject 0 do |size,value|
+          value.is_a?( Array ) ? [ size, value.size ].max : size
+        end
+        if n > 0
+          elements = values.inject [] do |flat,value|
+            flat + ( value.is_a?( Array ) ? value : [ value ] )
+          end
+          Hornetseye::Sequence fit( *elements ), n
+        else
+          super *values
+        end
+      end
+
+    end
+
+    Node.extend Match
+
+  end
+
+  def Sequence( element_type, num_elements )
+    retval = Class.new Sequence_
+    retval.element_type = element_type
+    retval.num_elements = num_elements
+    retval
   end
 
   module_function :Sequence