multiarray 0.4.1 → 0.5.0

data/lib/multiarray/lazy.rb

@@ -1,81 +0,0 @@
-module Hornetseye
-
-  class Lazy
-
-    def initialize( *values )
-      options = values.last.is_a?( Hash ) ? values.pop : {}
-      @values = values
-      if options[ :action ]
-        @action = options[ :action ]
-      else
-        unless @values.size == 1
-          raise "#{@values.size} value(s) where specified without defining " +
-            ":action"
-        end
-        @action = proc { |*x| x.first }
-      end
-    end
-
-    def inspect
-      '<delayed>'
-    end
-
-    def force
-      @action.call *@values.collect { |value| value.force }
-    end
-
-    def fetch( type )
-      type.new Lazy.new( self, :action => proc { |x| x.fetch } )
-    end
-
-    def element( index )
-      values = @values.collect { |value| value.element index }
-      Lazy.new( *( values + [ :action => @action ] ) )
-    end
-
-    def elements( range )
-      values = @values.collect { |value| value.elements range }
-      Lazy.new( *( values + [ :action => @action ] ) )
-    end
-
-    def -@
-      Lazy.new self, :action => proc { |x| -x }
-    end
-
-    def +@
-      self
-    end
-
-    def +( other )
-      Lazy.new self, other, :action => proc { |x,y| x + y }
-    end
-
-  end
-
-  def lazy
-    previous = Thread.current[ :lazy ]
-    Thread.current[ :lazy ] = true
-    begin
-      retval = yield
-    ensure
-      Thread.current[ :lazy ] = previous
-    end
-    retval
-  end
-
-  module_function :lazy
-
-  def eager
-    previous = Thread.current[ :lazy ]
-    Thread.current[ :lazy ] = false
-    begin
-      retval = yield
-    ensure
-      Thread.current[ :lazy ] = previous
-    end
-    retval
-  end
-
-  module_function :eager
-
-end

data/lib/multiarray/pointer_.rb

@@ -1,260 +0,0 @@
-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
-
-      def to_type( typecode, options = {} )
-        Hornetseye::Pointer primitive.to_type( typecode, options )
-      end
-
-      def coercion( other )
-        if other < Pointer_
-          Hornetseye::Pointer primitive.coercion( other.primitive )
-        else
-          Hornetseye::Pointer primitive.coercion( other )
-        end
-      end
-
-      def coerce( other )
-        if other < Pointer_
-          return other, self
-        else
-          super other
-        end
-      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
-        case index
-        when Range
-          elements( index )[ *args ]
-        else
-          element( index )[ *args ]
-        end
-      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 )
-      target = Hornetseye::Pointer self.class.primitive.element_type
-      if @value.is_a? Lazy
-        target.new @value.element( index )
-      else
-        pointer = @value + index * self.class.primitive.stride *
-          self.class.primitive.typecode.storage_size
-        target.new pointer
-      end
-    end
-
-    def elements( range )
-      target = Sequence self.class.primitive.element_type, range.size,
-                        self.class.primitive.stride
-      if @value.is_a? Lazy
-        target.new @value.elements( range )
-      else
-        pointer = @value + range.min * self.class.primitive.stride *
-          self.class.primitive.typecode.storage_size
-        target.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

@@ -1,155 +0,0 @@
-module Hornetseye
-
-  # Abstract class for representing multi-dimensional arrays
-  #
-  # @see #Sequence
-  # @see #MultiArray
-  # @see Sequence
-  # @see MultiArray
-  #
-  # @abstract
-  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 Malloc#+
-      #
-      # @private
-      attr_accessor :stride
-
-      # Get string with information about this type
-      #
-      # @return [String] Information about this array type.
-      def inspect
-        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 and num_elements
-          shortcut = element_type < Sequence_ ? 'MultiArray' : 'Sequence'
-          typename = typecode.to_s
-          if typename =~ /^[A-Z]+$/
-            "#{shortcut}.#{typename.downcase}(#{shape.join ','})"
-          else
-            "#{shortcut}(#{typename},#{shape.join ','})"
-          end
-        else
-          super
-        end
-      end
-
-      # Returns the element type of this array
-      #
-      # @return [Class] Returns +element_type.typecode+.
-      def typecode
-        element_type.typecode
-      end
-
-      def size
-        num_elements * element_type.size
-      end
-
-      def shape
-        element_type.shape + [ num_elements ]
-      end
-
-      def dimension
-        element_type.dimension.succ
-      end
-
-      def storage_size
-        element_type.storage_size * num_elements
-      end
-
-      def to_type( typecode, options = {} )
-        options = { :preserve_strides => false }.merge options
-        target_element = element_type.to_type typecode, options
-        target_stride = options[ :preserve_strides ] ?
-                        stride : target_element.size
-        Hornetseye::Sequence( target_element, num_elements,
-                              target_stride ).dereference
-      end
-
-      def coercion( other )
-        if other < Sequence_
-          Hornetseye::Sequence( element_type.coercion( other.element_type ),
-                                num_elements ).primitive
-        else
-          Hornetseye::Sequence( element_type.coercion( other ),
-                                num_elements ).primitive
-        end
-      end
-
-      def coerce( other )
-        if other < Sequence_
-          return other, self
-        else
-          return Hornetseye::Sequence( other, num_elements ), self
-        end
-      end
-
-    end
-
-    module RubyMatching
-
-      def fit( *values )
-        n = values.inject( 0 ) do |size,value|
-          value.is_a?( Array ) ? [ size, value.size ].max : size
-        end
-        if n > 0
-          subvalues = values.inject( [] ) do |flat,value|
-            flat + ( value.is_a?( Array ) ? value : [ value ] )
-          end
-          Hornetseye::Sequence fit( *subvalues ), n
-        else
-          super *values
-        end
-      end
-
-    end
-
-    Type.extend RubyMatching
-
-  end
-
-end