multiarray 0.2.0

data/Makefile

@@ -0,0 +1,73 @@
+.SUFFIXES:
+.SUFFIXES: .gem .o .cc .hh .rb .tar .gz .bz2
+
+RUBY_VERSION = 1.8
+MULTIARRAY_VERSION = 0.2.0
+
+CP = cp
+RM = rm -f
+MKDIR = mkdir -p
+GEM = gem$(RUBY_VERSION)
+RUBY = ruby$(RUBY_VERSION)
+TAR = tar
+GIT = git
+SITELIBDIR = $(shell $(RUBY) -r mkmf -e "puts \"\#{Config::CONFIG['sitelibdir']}\"")
+
+MAIN = Makefile source.gemspec README COPYING
+LIB = $(wildcard lib/*.rb)
+PKG_LIB = $(wildcard lib/multiarray/*.rb)
+TEST = $(wildcard test/*.rb)
+DOC = $(wildcard doc/*.rb)
+SOURCES = $(MAIN) $(LIB) $(PKG_LIB) $(TEST) $(DOC)
+
+all:: target
+
+target::
+
+gem:: multiarray-$(MULTIARRAY_VERSION).gem
+
+install:: $(LIB) $(PKG_LIB)
+	$(MKDIR) $(SITELIBDIR)
+	$(MKDIR) $(SITELIBDIR)/multiarray
+	$(CP) $(LIB) $(SITELIBDIR)
+	$(CP) $(PKG_LIB) $(SITELIBDIR)/multiarray
+
+uninstall::
+	$(RM) $(addprefix $(SITELIBDIR)/,$(notdir $(LIB))) $(addprefix $(SITELIBDIR)/multiarray/,$(notdir $(PKG_LIB)))
+
+install-gem:: multiarray-$(MULTIARRAY_VERSION).gem
+	$(GEM) install --local $<
+
+uninstall-gem::
+	$(GEM) uninstall multiarray || echo Nothing to uninstall
+
+check:: $(LIB) $(PKG_LIB) $(TEST)
+	$(RUBY) -rrubygems -Ilib -Itest test/ts_multiarray.rb
+
+push-gem:: multiarray-$(MULTIARRAY_VERSION).gem
+	echo Pushing $< in 3 seconds!
+	sleep 3
+	$(GEM) push $<
+
+push-git::
+	echo Pushing to origin in 3 seconds!
+	sleep 3
+	$(GIT) push origin master
+
+dist:: dist-gzip
+
+dist-gzip:: multiarray-$(MULTIARRAY_VERSION).tar.gz
+
+dist-bzip2:: multiarray-$(MULTIARRAY_VERSION).tar.bz2
+
+multiarray-$(MULTIARRAY_VERSION).gem: $(SOURCES)
+	$(GEM) build source.gemspec
+
+multiarray-$(MULTIARRAY_VERSION).tar.gz: $(SOURCES)
+	$(TAR) czf $@ $(SOURCES)
+
+multiarray-$(MULTIARRAY_VERSION).tar.bz2: $(SOURCES)
+	$(TAR) cjf $@ $(SOURCES)
+
+clean::
+	rm -f *~ lib/*~ lib/multiarray/*~ test/*~ doc/*~ *.gem

data/README

@@ -0,0 +1 @@
+This Ruby-extension defines Hornetseye::MultiArray and other native datatypes. Hornetseye::MultiArray provides multi-dimensional Ruby arrays with elements of same type. The extension is designed to be mostly compatible with Masahiro Tanaka's NArray. However it allows the definition of custom element types and operations on them. This work was also inspired by Ronald Garcia's boost::multi_array and by Todd Veldhuizen's Blitz++.

data/lib/multiarray.rb

@@ -0,0 +1,39 @@
+require 'malloc'
+require 'multiarray/storage'
+require 'multiarray/list'
+require 'multiarray/memory'
+require 'multiarray/type_operation'
+require 'multiarray/type'
+require 'multiarray/descriptortype'
+require 'multiarray/int'
+require 'multiarray/composite_type'
+require 'multiarray/sequence_operation'
+require 'multiarray/sequence'
+require 'multiarray/multiarray'
+
+class Proc
+
+  unless method_defined? :bind
+    def bind( object )
+      block, time = self, Time.now
+      ( class << object; self end ).class_eval do
+        method_name = "__bind_#{time.to_i}_#{time.usec}"
+        define_method method_name, &block
+        method = instance_method method_name
+        remove_method method_name
+        method
+      end.bind object
+    end
+  end
+
+end
+
+class Object
+
+  unless method_defined? :instance_exec
+    def instance_exec( *arguments, &block )
+      block.bind( self )[ *arguments ]
+    end
+  end
+
+end

data/lib/multiarray/composite_type.rb

@@ -0,0 +1,34 @@
+module Hornetseye
+
+  class CompositeType < Type
+
+    class << self
+
+      attr_accessor :element_type
+      attr_accessor :num_elements
+
+      def memory
+        element_type.memory
+      end
+
+      def bytesize
+        element_type.bytesize * num_elements
+      end
+
+      def basetype
+        element_type.basetype
+      end
+
+    end
+
+    def element_type
+      self.class.element_type
+    end
+
+    def num_elements
+      self.class.num_elements
+    end
+
+  end
+
+end

data/lib/multiarray/descriptortype.rb

@@ -0,0 +1,19 @@
+module Hornetseye
+
+  class DescriptorType < Type
+
+    class << self
+
+      def pack( value )
+        [ value ].pack descriptor
+      end
+
+      def unpack( value )
+        value.unpack( descriptor ).first
+      end
+
+    end
+
+  end
+
+end

data/lib/multiarray/int.rb

@@ -0,0 +1,97 @@
+module Hornetseye
+
+  class INT_ < DescriptorType
+
+    class << self
+
+      attr_accessor :bits
+      attr_accessor :signed
+
+      def memory
+        Memory
+      end
+
+      def bytesize
+        bits / 8
+      end
+
+      def default
+        0
+      end
+
+      def inspect
+        to_s
+      end
+
+      def to_s
+        case [ bits, signed ]
+        when [  8, true  ]
+          'BYTE'
+        when [  8, false ]
+          'UBYTE'
+        when [ 16, true  ]
+          'SINT'
+        when [ 16, false ]
+          'USINT'
+        when [ 32, true  ]
+          'INT'
+        when [ 32, false ]
+          'UINT'
+        when [ 64, true  ]
+          'LONG'
+        when [ 64, false ]
+          'ULONG'
+        else
+          "INT(#{bits.to_s},#{ signed ? "SIGNED" : "UNSIGNED" })"
+        end
+      end
+
+      def descriptor
+        case [ bits, signed ]
+        when [  8, true  ]
+          'c'
+        when [  8, false ]
+          'C'
+        when [ 16, true  ]
+          's'
+        when [ 16, false ]
+          'S'
+        when [ 32, true  ]
+          'i'
+        when [ 32, false ]
+          'I'
+        when [ 64, true  ]
+          'q'
+        when [ 64, false ]
+          'Q'
+        else
+          raise "No descriptor for packing/unpacking #{self}"
+        end
+      end
+
+    end
+
+  end
+
+  UNSIGNED = false
+  SIGNED   = true
+
+  def INT( bits, signed )
+    retval = Class.new INT_
+    retval.bits   = bits
+    retval.signed = signed
+    retval
+  end
+
+  module_function :INT
+
+  BYTE  = INT  8, SIGNED
+  UBYTE = INT  8, UNSIGNED
+  SINT  = INT 16, SIGNED
+  USINT = INT 16, UNSIGNED
+  INT   = INT 32, SIGNED
+  UINT  = INT 32, UNSIGNED
+  LONG  = INT 64, SIGNED
+  ULONG = INT 64, UNSIGNED
+
+end

data/lib/multiarray/list.rb

@@ -0,0 +1,48 @@
+module Hornetseye
+
+  class List < Storage
+
+    class << self
+
+      def alloc( size )
+        List.new Array.new( size )
+      end
+
+      def import( arr )
+        List.new arr
+      end
+
+    end
+
+    attr_accessor :offset
+
+    def initialize( arr )
+      super arr
+      @offset = 0
+    end
+
+    def load( typecode )
+      @data[ @offset ]
+    end
+
+    def store( typecode, value )
+      @data[ @offset ] = value
+    end
+
+    def import( data )
+      @data[ @offset ... @offset + data.size ] = data
+    end
+
+    def export( size )
+      @data[ @offset ... @offset + size ]
+    end
+
+    def +( offset )
+      retval = List.new @data
+      retval.offset = @offset + offset
+      retval
+    end
+
+  end
+
+end

data/lib/multiarray/memory.rb

@@ -0,0 +1,45 @@
+module Hornetseye
+
+  class Memory < Storage
+
+    class << self
+
+      def alloc( bytesize )
+        Memory.new Malloc.new( bytesize )
+      end
+
+      def import( str )
+        retval = alloc str.bytesize
+        retval.import str
+        retval
+      end
+
+    end
+
+    def initialize( ptr )
+      super ptr
+    end
+
+    def load( typecode )
+      typecode.unpack export( typecode.bytesize )
+    end
+
+    def store( typecode, value )
+      import typecode.pack( value )
+    end
+
+    def import( data )
+      @data.write data
+    end
+
+    def export( bytesize )
+      @data.read bytesize
+    end
+
+    def +( offset )
+      Memory.new @data + offset
+    end
+
+  end
+
+end

data/lib/multiarray/multiarray.rb

@@ -0,0 +1,13 @@
+module Hornetseye
+
+  def MultiArray( element_type, *shape )
+    if shape.empty?
+      element_type
+    else
+      MultiArray Sequence( element_type, shape.first ), *shape[ 1 .. -1 ]
+    end
+  end
+
+  module_function :MultiArray
+
+end

data/lib/multiarray/sequence.rb

@@ -0,0 +1,139 @@
+module Hornetseye
+
+  class Sequence_ < CompositeType
+
+    class << self
+
+      attr_accessor :stride
+
+      def inspect
+        to_s
+      end
+
+      def default
+        retval = new
+        retval.set
+        retval
+      end
+
+      def to_s
+        "Sequence(#{element_type.to_s},#{num_elements.to_s})"
+      end
+
+      def typecode
+        element_type.typecode
+      end
+
+      def empty?
+        num_elements == 0
+      end
+
+      def shape
+        element_type.shape + [ num_elements ]
+      end
+
+    end
+
+    def stride
+      self.class.stride
+    end
+
+    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
+      end
+      prepend + retval
+    end
+
+    def to_a
+      ( 0 ... num_elements ).collect do |i|
+        x = at i
+        x.is_a?( Sequence_ ) ? x.to_a : x
+      end
+    end
+
+    def set( value = typecode.default )
+      if value.is_a? Array
+        for i in 0 ... num_elements
+          assign i, i < value.size ? value[ i ] : typecode.default
+        end
+      else
+        op( value ) { |x| set x }
+      end
+      value
+    end
+
+    def get
+      self
+    end
+
+    def sel( *indices )
+      if indices.empty?
+        super *indices
+      else
+        unless ( 0 ... num_elements ).member? indices.last
+          raise "Index must be in 0 ... #{num_elements} " +
+                "(was #{indices.last.inspect})"
+        end
+        element_memory = @memory + indices.last * stride * typecode.bytesize
+        element_type.new( :memory => element_memory ).sel *indices[ 0 ... -1 ]
+      end
+    end
+
+  end
+
+  Sequence_.class_eval { include SequenceOperation }
+
+  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
+  end
+
+  module_function :Sequence
+
+end