multiarray 0.2.4 → 0.4.0

data/lib/multiarray/malloc.rb

@@ -0,0 +1,11 @@
+module Hornetseye
+
+  class Malloc
+
+    def fetch( type )
+      type.import read( type.storage_size )
+    end
+
+  end
+
+end

data/lib/multiarray/multiarray.rb

@@ -21,6 +21,24 @@ module Hornetseye
         Hornetseye::MultiArray( element_type, *shape ).new
       end
 
+      def []( *args )
+        probe = proc do |s,a|
+          if a.is_a? Array
+            if s.empty?
+              a.inject( [], &probe ) + [ a.size ]
+            else
+              a.inject( s[ 0 ... -1 ], &probe ) + [ [ a.size, s.last ].max ]
+            end
+          else
+            s
+          end
+        end
+        shape = probe.call [], args
+        retval = MultiArray.new OBJECT, *shape
+        retval[] = args
+        retval
+      end
+
     end
 
   end
@@ -33,7 +51,7 @@ module Hornetseye
   # @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 +Type+ or +Sequence_+.
+  # @return [Class] A class deriving from +Pointer_+.
   #
   # @see MultiArray.new
   # @see #Sequence

data/lib/multiarray/object.rb

@@ -5,49 +5,66 @@ module Hornetseye
 
     class << self
 
-      # Returns the type of storage object for storing values
+      # Get memory type for storing objects of this type
       #
       # @return [Class] Returns +List+.
       #
+      # @see List
+      #
       # @private
-      def storage
+      def memory
         List
       end
 
-      # Number of storage elements for storing an object of this type
+      # Get string with information about this type
       #
-      # @return [Integer] Returns +1+.
+      # @return [String] Returns +'OBJECT'+.
+      def to_s
+        'OBJECT'
+      end
+
+      # Get string with information about this type
       #
-      # @private
-      def bytesize
-        1
+      # @return [String] Returns +'OBJECT'+.
+      def inspect
+        to_s
       end
 
-      # Default value for Ruby objects.
+      # Default value for Ruby objects
       #
-      # @return [Object] Returns +nil+. 
+      # @return [Object] Returns +nil+.
       #
       # @private
       def default
         nil
       end
 
-      # Get string with information about this type
+      # Size of storage required 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] Size of storage required. Returns +1+.
       #
-      # @return [String] Returns +'OBJECT'+.
-      def inspect
-        to_s
+      # @private
+      def storage_size
+        1
       end
 
     end
 
+    def store( ptr )
+      ptr.write @value
+      self
+    end
+
+  end
+
+  module RubyMatching
+
+    def fit( *value )
+      OBJECT
+    end
+
   end
 
+  Type.extend RubyMatching
+
 end

data/lib/multiarray/pointer.rb

@@ -0,0 +1,11 @@
+module Hornetseye
+
+  def Pointer( primitive )
+    retval = Class.new Pointer_
+    retval.primitive = primitive
+    retval
+  end
+
+  module_function :Pointer
+
+end

data/lib/multiarray/pointer_.rb

@@ -0,0 +1,223 @@
+module Hornetseye
+
+  class Pointer_ < Type
+
+    class << self
+
+      attr_accessor :primitive
+
+      def inspect
+        if primitive
+          if primitive < Sequence_
+            primitive.inspect
+          else
+            "Pointer(#{primitive.inspect})"
+          end
+        else
+          super
+        end
+      end
+
+      def to_s
+        if primitive
+          if primitive < Sequence_
+            primitive.to_s
+          else
+            "Pointer(#{primitive.to_s})"
+          end
+        else
+          super
+        end
+      end
+      
+      def default
+        if Thread.current[ :lazy ]
+          Lazy.new :action => proc { self.class.primitive.typecode.new }
+        else
+          primitive.memory.new primitive.storage_size
+        end
+      end
+
+      def dereference
+        primitive.dereference
+      end
+
+    end
+
+    def inspect( indent = nil, lines = nil )
+      if self.class.primitive < Sequence_
+        if @value.is_a? Lazy
+          "#{self.class.primitive.inspect}:#{@value.inspect}"
+        else
+          if indent
+            prepend = ''
+          else
+            prepend = "#{self.class.inspect}:\n"
+            indent = 0
+            lines = 0
+          end
+          if empty?
+            retval = '[]'
+          else
+            retval = '[ '
+            for i in 0 ... self.class.primitive.num_elements
+              x = self[i]
+              if x.is_a? Pointer_
+                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.inspect
+                if retval.size + str.size >= 74 - '...'.size -
+                    '[  ]'.size * indent.succ
+                  retval += '...'
+                  break
+                else
+                  retval += str
+                end
+              end
+            end
+            retval += ' ]' unless lines >= 10
+          end
+          prepend + retval
+        end
+      else
+        super()
+      end
+    end
+
+    def to_a
+      if self.class.primitive < Sequence_
+        ( 0 ... self.class.primitive.num_elements ).collect do |i|
+          element( i ).to_a
+        end
+      else
+        force.fetch.get
+      end
+    end
+
+    def []( *args )
+      if args.empty?
+        if self.class.primitive < Sequence_
+          self
+        else
+          fetch[]
+        end
+      else
+        index = args.pop
+        element( index )[ *args ]
+      end
+    end
+
+    def []=( *args )
+      value = args.pop
+      if args.empty?
+        if self.class.primitive < Sequence_
+          if value.is_a? Array
+            for i in 0 ... self.class.primitive.num_elements
+              if i < value.size
+                element( i )[] = value[ i ]
+              else
+                element( i )[] = self.class.primitive.typecode.default
+              end
+            end
+          else
+            operation( self.class.primitive.new( value ) ) { |x| set x }
+          end
+        else
+          store self.class.primitive.new( value )
+        end
+      else
+        index = args.pop
+        element( index )[ *args ] = value
+      end
+    end
+
+    def set( value )
+      unless value.is_a?( List ) or value.is_a?( Malloc ) or
+          value.is_a?( Lazy )
+        store self.class.primitive.new( value )
+      else
+        super value
+      end
+      value
+    end
+
+    def fetch
+      if self.class.primitive < Sequence_
+        delay
+      else
+        get.fetch self.class.primitive
+      end
+    end
+
+    def force
+      if Thread.current[ :lazy ] or not @value.is_a? Lazy
+        self
+      else
+        if self.class.primitive < Sequence_ and @value.is_a? Lazy
+          self.class.new.operation( self ) { |x| set x }
+        else
+          super
+        end
+      end
+    end
+
+    def store( value )
+      value.force.store @value
+    end
+
+    def element( index )
+      if @value.is_a? Lazy
+        Hornetseye::Pointer( self.class.primitive.element_type ).
+          new @value.element( index )
+      else
+        pointer = @value + index * self.class.primitive.stride *
+          self.class.primitive.typecode.storage_size
+        Hornetseye::Pointer( self.class.primitive.element_type ).new pointer
+      end
+    end
+
+    def empty?
+      self.class.primitive.size == 0
+    end
+
+    def operation( *args, &action )
+      if self.class.primitive < Sequence_
+        if Thread.current[ :lazy ]
+          super *args.collect { |arg| arg.delay }, &action
+        else
+          for i in 0 ... self.class.primitive.num_elements
+            subargs = args.collect do |arg|
+              if arg.is_a?( Pointer_ ) and arg.class.primitive < Sequence_
+                arg.element( i ).fetch
+              else
+                arg.force.fetch
+              end
+            end
+            element( i ).operation *subargs, &action
+          end
+          self
+        end
+      else
+        super *args, &action
+      end
+    end
+
+  end
+
+end

data/lib/multiarray/sequence.rb

@@ -20,11 +20,17 @@ module Hornetseye
         Hornetseye::Sequence( element_type, num_elements ).new
       end
 
+      def []( *args )
+        retval = Hornetseye::Sequence( OBJECT, args.size ).new
+        retval[] = args
+        retval
+      end
+
     end
 
   end
 
-  # Create a class deriving from +Sequence_+
+  # Create an array class
   #
   # The parameters +element_type+, +num_elements+, and +stride+ are assigned
   # to the corresponding attributes of the resulting class.
@@ -34,19 +40,17 @@ module Hornetseye
   # @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] A class deriving from +Sequence_+.
+  # @return [Class] An array class deriving from +Pointer_+.
   #
   # @see Sequence.new
   # @see #MultiArray
-  # @see CompositeType.element_type
-  # @see CompositeType.num_elements
   def Sequence( element_type, num_elements,
-                stride = element_type.size )
-    retval = Class.new Sequence_
-    retval.element_type = element_type
-    retval.num_elements = num_elements
-    retval.stride = stride
-    retval
+                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
   end
 
   module_function :Sequence

data/lib/multiarray/sequence_.rb

@@ -8,17 +8,38 @@ module Hornetseye
   # @see MultiArray
   #
   # @abstract
-  class Sequence_ < CompositeType
+  class Sequence_ < Type
 
     class << self
 
+      # Get memory type for storing objects of this type
+      #
+      # @return [Class] Returns +element_type.memory+.
+      #
+      # @see Malloc
+      #
+      # @private
+      def memory
+        element_type.memory
+      end
+
+      # Type of elements this type is composed of
+      #
+      # @return [Type,Sequence_] The element type of this type.
+      attr_accessor :element_type
+
+      # Number of elements this type is composed of
+      #
+      # @return [Integer] The number of elements this type is composed of.
+      attr_accessor :num_elements
+
       # Distance of two consecutive elements divided by size of single element
       #
       # @return [Integer] Stride size to iterate over array.
       #
       # @see #Sequence
       # @see List#+
-      # @see Memory#+
+      # @see Malloc#+
       #
       # @private
       attr_accessor :stride
@@ -27,26 +48,24 @@ module Hornetseye
       #
       # @return [String] Information about this array type.
       def inspect
-        to_s
-      end
-
-      # Get default value for this array type.
-      #
-      # @return [Object] Returns a multi-dimensional array filled with the
-      # default value of the element type.
-      #
-      # @private
-      def default
-        retval = new
-        retval.set
-        retval
+        if element_type and num_elements
+          shortcut = element_type < Sequence_ ? 'MultiArray' : 'Sequence'
+          typename = typecode.inspect
+          if typename =~ /^[A-Z]+$/
+            "#{shortcut}.#{typename.downcase}(#{shape.join ','})"
+          else
+            "#{shortcut}(#{typename},#{shape.join ','})"
+          end
+        else
+          super
+        end
       end
 
       # Get string with information about this type
       #
       # @return [String] Information about this array type.
       def to_s
-        if element_type
+        if element_type and num_elements
           shortcut = element_type < Sequence_ ? 'MultiArray' : 'Sequence'
           typename = typecode.to_s
           if typename =~ /^[A-Z]+$/
@@ -55,7 +74,7 @@ module Hornetseye
             "#{shortcut}(#{typename},#{shape.join ','})"
           end
         else
-          'Sequence_'
+          super
         end
       end
 
@@ -66,103 +85,18 @@ module Hornetseye
         element_type.typecode
       end
 
-      # Check whether arrays of this type are empty or not
-      #
-      # @return [FalseClass,TrueClass] Returns boolean indicating whether
-      # arrays of this type are empty or not.
-      def empty?
-        num_elements == 0
+      def size
+        num_elements * element_type.size
       end
 
-      # Get shape of multi-dimensional array
-      #
-      # @return [Array<Integer>] Ruby array with the shape of this array type.
       def shape
         element_type.shape + [ num_elements ]
       end
 
-    end
-
-    # Distance of two consecutive elements divided by size of single element
-    #
-    # @return [Integer] Stride size to iterate over array.
-    #
-    # @see #Sequence
-    # @see List#+
-    # @see Memory#+
-    #
-    # @private
-    def stride
-      self.class.stride
-    end
-
-    # Display type and values of this array
-    #
-    # @return [String] Returns string with information about the type and the
-    # values of this array.
-    def inspect( indent = nil, lines = nil )
-      if indent
-        prepend = ''
-      else
-        prepend = "#{self.class.inspect}:\n"
-        indent = 0
-        lines = 0
-      end
-      if empty?
-        retval = '[]'
-      else
-        retval = '[ '
-        for i in 0 ... num_elements
-          x = at i
-          if x.is_a? Sequence_
-            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.inspect
-            if retval.size + str.size >= 74 - '...'.size -
-                '[  ]'.size * indent.succ
-              retval += '...'
-              break
-            else
-              retval += str
-            end
-          end
-        end
-        retval += ' ]' unless lines >= 10
+      def storage_size
+        element_type.storage_size * num_elements
       end
-      prepend + retval
-    end
-
-    # Display values of this array
-    #
-    # @return [String] Returns string with the values of this array.
-    def to_s
-      to_a.to_s
-    end
 
-    # Convert to Ruby array
-    #
-    # @return [Array<Object>] Result of the conversion.
-    def to_a
-      ( 0 ... num_elements ).collect do |i|
-        x = at i
-        x.is_a?( Sequence_ ) ? x.to_a : x
-      end
     end
 
   end