multiarray 0.22.0 → 0.23.1

data/lib/multiarray/multiarray.rb

@@ -1,5 +1,5 @@
 # multiarray - Lazy multi-dimensional arrays for Ruby
-# Copyright (C) 2010 Jan Wedekind
+# Copyright (C) 2010, 2011 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
@@ -22,30 +22,8 @@ module Hornetseye
 
     class << self
 
-      # Create new multi-dimensional array
-      #
-      # @param [Class] element_type The type of the elements.
-      # @param [Array<Integer>] *array_shape The shape of the multi-dimensional array.
-      #
-      # @return [Node] Returns uninitialised native array.
-      def new( element_type, *array_shape )
-        typecode = element_type.typecode
-        shape = element_type.shape + array_shape
-        options = shape.last.is_a?( Hash ) ? shape.pop : {}
-        count = options[ :count ] || 1
-        if shape.empty?
-          memory = options[ :memory ] ||
-                   typecode.memory_type.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,
-                                                 :memory => options[ :memory ] ] )
-            Lookup.new pointer, index, INT.new( stride )
-          end
-        end
+      def new(typecode, *shape)
+        Hornetseye::MultiArray(typecode, shape.size).new *shape
       end
 
       # Import array from string
@@ -53,19 +31,19 @@ module Hornetseye
       # Create an array from raw data provided as a string.
       #
       # @param [Class] typecode Type of the elements in the string.
-      # @param [String] string String with raw data.
+      # @param [String,Malloc] data String or memory object with raw data.
       # @param [Array<Integer>] shape Array with dimensions of array.
       #
       # @return [Node] Multi-dimensional array with imported data.
-      def import( typecode, string, *shape )
-        t = Hornetseye::MultiArray typecode, *shape
-        if string.is_a? Malloc
-          memory = string
+      def import( typecode, data, *shape )
+        t = Hornetseye::MultiArray typecode, shape.size
+        if data.is_a? Malloc
+          memory = data
         else
-          memory = Malloc.new t.storage_size
-          memory.write string
+          memory = Malloc.new t.storage_size(*shape)
+          memory.write data
         end
-        t.new memory
+        t.new *(shape + [:memory => memory])
       end
 
       # Convert Ruby array to uniform multi-dimensional array
@@ -118,18 +96,11 @@ module Hornetseye
 
   end
 
-  # Create multi-dimensional array type
-  #
-  # @param [Class] element_type Type of elements.
-  # @param [Array<Integer>] *shape Shape of array type.
-  #
-  # @return [Class] The array type.
-  def MultiArray( element_type, *shape )
-    if shape.empty?
-      element_type
+  def MultiArray(typecode, dimension)
+    if dimension > 0
+      Field_.inherit typecode.typecode, typecode.dimension + dimension
     else
-      Hornetseye::Sequence MultiArray( element_type, *shape[ 0 ... -1 ] ),
-                           shape.last
+      Hornetseye::Pointer typecode
     end
   end
 

data/lib/multiarray/node.rb

@@ -1,5 +1,5 @@
 # multiarray - Lazy multi-dimensional arrays for Ruby
-# Copyright (C) 2010 Jan Wedekind
+# Copyright (C) 2010, 2011 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
@@ -84,20 +84,8 @@ module Hornetseye
         [ self ]
       end
 
-      # Get type of result of delayed operation
-      #
-      # @return [Class] Type of result.
-      #
-      # @private
-      def array_type
-        self
-      end
-
-      # Convert to pointer type
-      #
-      # @return [Class] Corresponding pointer type.
-      def pointer_type
-        Hornetseye::Pointer( self )
+      def shape
+        []
       end
 
       # Generate index array of this type
@@ -110,41 +98,6 @@ module Hornetseye
         offset
       end
 
-      # Get shape of this term
-      #
-      # @return [Array<Integer>] Returns +[]+.
-      def shape
-        []
-      end
-
-      # Get width of two-dimensional array
-      #
-      # @return [Integer] Width of array.
-      def width
-        shape[0]
-      end
-
-      # Get height of two-dimensional array
-      #
-      # @return [Integer] Height of array.
-      def height
-        shape[1]
-      end
-
-      # Get size (number of elements) of this value
-      #
-      # @return [Integer] Returns +1+.
-      def size
-        1
-      end
-
-      # Check whether the type is an empty array
-      #
-      # @return [Boolean] Returns whether this type represents an empty array.
-      def empty?
-        size == 0
-      end
-
       # Get dimension of this term
       #
       # @return [Array<Integer>] Returns +0+.
@@ -252,9 +205,8 @@ module Hornetseye
       # @param [Class] a The third type.
       #
       # @return [Class] Returns type based on bytes.
-      def cond( a, b )
-        t = a.coercion b
-        Hornetseye::MultiArray( t.typecode, *shape ).coercion t
+      def cond(a, b)
+        a.coercion b
       end
 
       # Convert to different element type
@@ -308,31 +260,6 @@ module Hornetseye
         hash[ self ] || self
       end
 
-      # Check arguments for compatible shape
-      #
-      # The method will throw an exception if one of the arguments has an incompatible
-      # shape.
-      #
-      # @param [Array<Class>] args Arguments to check for compatibility.
-      #
-      # @return [Object] The return value should be ignored.
-      def check_shape( *args )
-        _shape = shape
-        args.each do |arg|
-          _arg_shape = arg.shape
-          if _shape.size < _arg_shape.size
-            raise "#{arg.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_shape.size ) != _arg_shape
-              raise "#{arg.inspect} has shape #{arg.shape.inspect} " +
-                    "(does not match last value(s) of #{shape.inspect})"
-            end
-          end
-        end
-      end
-
       # Check whether this term is compilable
       #
       # @return [Boolean] Returns +true+.
@@ -353,69 +280,47 @@ module Hornetseye
 
     end
 
-    # Get type of result of delayed operation
-    #
-    # @return [Class] Type of result.
-    #
-    # @private
-    def array_type
-      self.class.array_type
+    def matched?
+      true
     end
 
-    # Convert to pointer type
-    #
-    # @return [Class] Corresponding pointer type.
-    def pointer_type
-      array_type.pointer_type
+    def allocate
+      Hornetseye::MultiArray(typecode, dimension).new *shape
     end
 
     # Element-type of this term
     #
     # @return [Class] Element-type of this datatype.
     def typecode
-      array_type.typecode
+      self.class.typecode
     end
 
     # Base-type of this term
     #
     # @return [Class] Base-type of this datatype.
     def basetype
-      array_type.basetype
-    end
-
-    # Get shape of this term
-    #
-    # @return [Array<Integer>] Returns +array_type.shape+.
-    def shape
-      array_type.shape
+      self.class.basetype
     end
 
     # Get width of two-dimensional array
     #
     # @return [Integer] Width of array.
     def width
-      array_type.width
+      shape[0]
     end
 
     # Get height of two-dimensional array
     #
     # @return [Integer] Height of array.
     def height
-      array_type.height
+      shape[1]
     end
 
     # Get size (number of elements) of this value
     #
-    # @return [Integer] Returns +array_type.size+.
+    # @return [Integer] Returns number of elements of this value.
     def size
-      array_type.size
-    end
-
-    # Get memory size of object
-    #
-    # @return [Integer] Returns required storage size of this array.
-    def storage_size
-      array_type.storage_size
+      shape.inject(1) { |a,b| a * b }
     end
 
     # Duplicate array expression if it is not in row-major format
@@ -423,8 +328,8 @@ module Hornetseye
     # @return [Node] Duplicate of array or +self+.
     def memorise
       if memory
-        contiguous_strides = ( 0 ... dimension ).collect do |i|
-          shape[ 0 ... i ].inject( 1 ) { |a,b| a * b }
+        contiguous_strides = (0 ... dimension).collect do |i|
+          shape[0 ... i].inject(1) { |a,b| a * b }
         end
         if strides == contiguous_strides
           self
@@ -465,21 +370,28 @@ module Hornetseye
     #
     # @return [Boolean] Returns whether this object is an empty array.
     def empty?
-      array_type.empty?
+      size == 0
+    end
+
+    # Get shape of this term
+    #
+    # @return [Array<Integer>] Returns +[]+.
+    def shape
+      self.class.shape
     end
 
     # Get dimension of this term
     #
-    # @return [Array<Integer>] Returns +array_type.dimension+.
+    # @return [Array<Integer>] Returns number of dimensions of this term.
     def dimension
-      array_type.dimension
+      shape.size
     end
 
     # Check whether this object is an RGB value
     #
     # @return [Boolean] Returns +false+.
     def rgb?
-      array_type.rgb?
+      typecode.rgb?
     end
 
     # Extract native value if this is an element
@@ -512,12 +424,12 @@ module Hornetseye
     def inspect( indent = nil, lines = nil )
       if variables.empty?
         if dimension == 0 and not indent
-          "#{array_type.inspect}(#{force.inspect})" # !!!
+          "#{typecode.inspect}(#{force.inspect})"
         else
           if indent
             prepend = ''
           else
-            prepend = "#{array_type.inspect}:\n"
+            prepend = "#{Hornetseye::MultiArray(typecode, dimension).inspect}:\n"
             indent = 0
             lines = 0
           end
@@ -525,7 +437,7 @@ module Hornetseye
             retval = '[]'
           else
             retval = '[ '
-            for i in 0 ... array_type.num_elements
+            for i in 0 ... shape.last
               x = element i
               if x.dimension > 0
                 if i > 0
@@ -546,7 +458,7 @@ module Hornetseye
                 end
               else
                 retval += ', ' if i > 0
-                str = x.force.inspect # !!!
+                str = x.force.inspect
                 if retval.size + str.size >= 74 - '...'.size -
                     '[  ]'.size * indent.succ
                   retval += '...'
@@ -593,7 +505,7 @@ module Hornetseye
     #
     # @return [Node] Duplicate of +self+.
     def dup
-      retval = array_type.new
+      retval = Hornetseye::MultiArray(typecode, dimension).new *shape
       retval[] = self
       retval
     end
@@ -652,14 +564,26 @@ module Hornetseye
     # The method will throw an exception if one of the arguments has an incompatible
     # shape.
     #
-    # @param [Array<Node>] args Arguments to check for compatibility.
+    # @param [Array<Class>] args Arguments to check for compatibility.
     #
     # @return [Object] The return value should be ignored.
-    def check_shape( *args )
-      array_type.check_shape *args.collect { |arg| arg.array_type }
+    def check_shape(*args)
+      _shape = shape
+      args.each do |arg|
+        _arg_shape = arg.shape
+        if _shape.size < _arg_shape.size
+          raise "#{arg.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_shape.size ) != _arg_shape
+            raise "#{arg.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 )
@@ -670,13 +594,13 @@ module Hornetseye
     # @return [Object,Node] Returns the value.
     def []=( *indices )
       value = indices.pop
-      value = typecode.new value unless value.is_a? Node
+      value = typecode.new value unless value.matched?
       if indices.empty?
         check_shape value
         unless compilable? and value.compilable? and dimension > 0
-          Store.new( self, value ).demand
+          Store.new(self, value.sexp).demand
         else
-          GCCFunction.run Store.new( self, value )
+          GCCFunction.run Store.new(self, value.sexp)
         end
         value
       else
@@ -685,7 +609,7 @@ module Hornetseye
         else
           view = element indices.last
         end
-        view[ *indices[ 0 ... -1 ] ] = value
+        view[*indices[0 ... -1]] = value
       end
     end
 
@@ -732,14 +656,16 @@ module Hornetseye
     def force
       if finalised?
         get
-      elsif ( dimension > 0 and Thread.current[ :lazy ] ) or not variables.empty?
+      elsif (dimension > 0 and Thread.current[:lazy]) or not variables.empty?
         self
       elsif compilable?
-        retval = pointer_type.new
-        GCCFunction.run Store.new( retval, self )
+        retval = allocate
+        GCCFunction.run Store.new(retval.sexp, self)
         retval.demand.get
       else
-        Store.new( array_type.new, self ).demand.get
+        retval = allocate
+        Store.new(retval.sexp, self).demand
+        retval.demand.get
       end
     end
 
@@ -756,16 +682,16 @@ module Hornetseye
 
     # Coerce with other object
     #
-    # @param [Node,Object] other Other object.
+    # @param [Object] other Other object.
     #
     # @return [Array<Node>] Result of coercion.
     #
     # @private
-    def coerce( other )
-      if other.is_a? Node
-        return other, self
+    def coerce(other)
+      if other.matched?
+        return other.sexp, self
       else
-        return Node.match( other, self ).new( other ), self
+        return Node.match(other, self).new(other), self
       end
     end