multiarray 0.4.0 → 0.4.1

data/Rakefile

@@ -6,11 +6,11 @@ require 'rake/packagetask'
 require 'rbconfig'
 
 PKG_NAME = 'multiarray'
-PKG_VERSION = '0.4.0'
+PKG_VERSION = '0.4.1'
 RB_FILES = FileList[ 'lib/**/*.rb' ]
 TC_FILES = FileList[ 'test/tc_*.rb' ]
 TS_FILES = FileList[ 'test/ts_*.rb' ]
-PKG_FILES = [ 'Rakefile', 'README', 'COPYING', '.document' ] +
+PKG_FILES = [ 'Rakefile', 'README', 'COPYING', 'TODO', '.document' ] +
             RB_FILES + TS_FILES + TC_FILES
 SUMMARY = %q{Multi-dimensional and uniform Ruby arrays}
 DESCRIPTION = %q{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/TODO

@@ -0,0 +1,63 @@
+ranges (rolling, lazy rolling, lazy ranges)
+tensor indices to enable transpose of lazy array
+test lazyness
+sums/injections? nesting? tensors?
+JIT?
+test type conversions
+fancy README
+
+a = lazy( 16 ) { |i| i }
+a = lazy( 16 ) { |i| i }[ 4 ... 12 ]  # offsets: apply sel-operation to all
+                                        members; index array?
+a = lazy( 16, 32 ) { |i,j| Sequence[ i, j ] } # ???
+a = lazy( 8, 8 ) { |i,j| Sequence[ i, a[j] * sin( i + b[j] ) ] }.hist 8, 8
+a = b.class.new.op { |x| set -x }
+a = lazy { |i| -b[i] }
+a = lazy { -b }
+a = array { -b }
+a = array { |i| -b[i] }
+a = array( :dim => [ b.size ] ) { |i| -b[i] }
+a = -b
+array { |i| sum { |j| a[i,j] } }
+lazy { |i| sum { |j| a[i,j] } }
+parallel { ... }
+lazy { |i| lazy { |j| a[i,j] } }
+array { lazy { |i| sum { |j| a[i,j] } } }
+
+correlate?
+
+lines:
+[ i, a[j] * sin( i + b[j] ) ].hist
+
+lines:
+lazy { |i,j| i.zip( a[j] * sin( i + b[j] ) ) }.histogram 32, 20
+
+lines:
+lazy { |i,j| Sequence[ i, a[j] * sin( i + b[j] ) ] }.histogram 32, 20
+combined histograms?
+
+circle:
+[ sin( i ) * r, cos( i ) * r ].hist
+
+Geometric Hashing? Bounded Hough Transform!!! RANSAC? histogram weights?
+
+array: lazy retrieval? jit code for address computation
+OBJECT: object with type information
+Lazy( Sequence( INT, 3 ) )
+
+interpretation: type coercion, actual operation, jit,
+collection of jit arguments (e.g. tensor)
+
+proc { |i| proc { |j| i+j } }.call( 5 ).call 3
+
+gem install flay: http://ruby.sadi.st/Flay.html
+
+How to nest/cascade mode-environments?
+(how to specify nested modes for recursive algorithms and called algorithms?)
+ruby and jit compiles, lazy and parallel forwards
+
+* Ruby
+* Lazy (Lazy histogram -> hough transform, lazy transpose, unused indices?)
+* Multithreading
+* JIT
+* GCC

data/lib/multiarray.rb

@@ -37,6 +37,40 @@ class Object
 
 end
 
+# Range#min and Range#max are replaced for performance reasons
+class Range
+
+  public
+
+  alias_method :orig_min, :min
+
+  alias_method :orig_max, :max
+
+  # For performance reasons a specialised method for integers is added
+  def min
+    if self.begin.is_a? Integer
+      self.begin
+    else
+      orig_min
+    end
+  end
+
+  # For performance reasons a specialised method for integers is added.
+  def max
+    if self.end.is_a? Integer
+      exclude_end? ? self.end - 1 : self.end
+    else
+      orig_max
+    end
+  end
+
+  # Compute the size of a range.
+  def size
+    max + 1 - min
+  end
+
+end
+
 # Module#alias_method_chain is defined.
 #
 # @private

data/lib/multiarray/int_.rb

@@ -120,6 +120,22 @@ module Hornetseye
         ( bits + 7 ).div 8
       end
 
+      def coercion( other )
+        if other < INT_
+          Hornetseye::INT [ bits, other.bits ].max, ( signed or other.signed )
+        else
+          super other
+        end
+      end
+
+      def coerce( other )
+        if other < INT_
+          return other, self
+        else
+          super other
+        end
+      end
+
       def ==( other )
         if other.is_a? Class
           if other < INT_ and bits == other.bits and signed == other.signed
@@ -147,6 +163,36 @@ module Hornetseye
       self
     end
 
+    module RubyMatching
+
+      def fit( *values )
+        if values.all? { |value| value.is_a? Integer }
+          bits = 8
+          ubits = 8
+          signed = false
+          values.each do |value|
+            bits *= 2 until ( -2**(bits-1) ... 2**(bits-1) ).include? value
+            if value < 0
+              signed = true
+            else
+              ubits *= 2 until ( 0 ... 2**ubits ).include? value
+            end
+          end
+          bits = signed ? bits : ubits
+          if bits <= 64
+            Hornetseye::INT bits, signed
+          else
+            super *values
+          end
+        else
+          super *values
+        end
+      end
+
+    end
+
+    Type.extend RubyMatching
+
   end
 
 end

data/lib/multiarray/lazy.rb

@@ -29,8 +29,13 @@ module Hornetseye
     end
 
     def element( index )
-      elements = @values.collect { |value| value.element index }
-      Lazy.new( *( elements + [ :action => @action ] ) )
+      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 -@

data/lib/multiarray/multiarray.rb

@@ -22,19 +22,7 @@ module Hornetseye
       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 = Type.fit( args ).new
         retval[] = args
         retval
       end

data/lib/multiarray/object.rb

@@ -48,6 +48,18 @@ module Hornetseye
         1
       end
 
+      def coercion( other )
+        if other < Pointer_
+          other.coercion self
+        else
+          self
+        end
+      end
+
+      def coerce( other )
+        return self, self
+      end
+
     end
 
     def store( ptr )
@@ -55,16 +67,18 @@ module Hornetseye
       self
     end
 
-  end
+    raise '\'multiarray/object\' must be loaded first' if Type.respond_to? :fit
 
-  module RubyMatching
+    module RubyMatching
+
+      def fit( *values )
+        OBJECT
+      end
 
-    def fit( *value )
-      OBJECT
     end
 
-  end
+    Type.extend RubyMatching
 
-  Type.extend RubyMatching
+  end
 
 end

data/lib/multiarray/pointer_.rb

@@ -42,6 +42,26 @@ module Hornetseye
         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 )
@@ -119,7 +139,12 @@ module Hornetseye
         end
       else
         index = args.pop
-        element( index )[ *args ]
+        case index
+        when Range
+          elements( index )[ *args ]
+        else
+          element( index )[ *args ]
+        end
       end
     end
 
@@ -182,13 +207,25 @@ module Hornetseye
     end
 
     def element( index )
+      target = Hornetseye::Pointer self.class.primitive.element_type
       if @value.is_a? Lazy
-        Hornetseye::Pointer( self.class.primitive.element_type ).
-          new @value.element( index )
+        target.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
+        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
 

data/lib/multiarray/sequence.rb

@@ -21,7 +21,11 @@ module Hornetseye
       end
 
       def []( *args )
-        retval = Hornetseye::Sequence( OBJECT, args.size ).new
+        target = Type.fit args
+        if target.primitive.dimension > 1
+          target = Hornetseye::Sequence OBJECT, args.size
+        end
+        retval = target.new
         retval[] = args
         retval
       end

data/lib/multiarray/sequence_.rb

@@ -93,12 +93,63 @@ module Hornetseye
         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

data/lib/multiarray/type.rb

@@ -35,6 +35,10 @@ module Hornetseye
         []
       end
 
+      def dimension
+        0
+      end
+
       # Number of elements
       #
       # @return [Integer] Number of elements
@@ -44,6 +48,27 @@ module Hornetseye
         shape.inject( 1 ) { |a,b| a * b }
       end
 
+      def to_type( typecode, options = {} )
+        typecode
+      end
+
+      def coercion( other )
+        if self == other
+          self
+        else
+          x, y = other.coerce self
+          x.coercion y
+        end
+      end
+
+      def coerce( other )
+        if self == other
+          return other, self
+        else
+          raise "Cannot coerce #{self} and #{other.inspect}"
+        end
+      end
+
       def ===( other )
         ( other == self ) or ( other.is_a? self ) or ( other.class == self )
       end
@@ -134,6 +159,10 @@ module Hornetseye
       end
     end
 
+    def to_type( target, options = {} )
+      self.class.to_type( target, options ).new.operation( self ) { |x| set x }
+    end
+
     def -@
       if is_a?( Pointer_ ) and self.class.primitive < Sequence_
         retval = self.class.new
@@ -149,10 +178,11 @@ module Hornetseye
     end
 
     def +( other )
-      if is_a?( Pointer_ ) and self.class.primitive < Sequence_
-        retval = self.class.new
+      target = self.class.coercion( other.class )
+      if target < Pointer_ and target.primitive < Sequence_
+        retval = target.new
       else
-        retval = self.class.dereference.new
+        retval = target.dereference.new
       end
       retval.operation( self, other ) { |x,y| set x + y }
       retval

data/test/tc_int.rb

@@ -94,7 +94,15 @@ class TC_Int < Test::Unit::TestCase
     end
   end
 
-  def test_lazy
+  def test_plus
+    T.each do |t1|
+      T.each do |t2|
+        assert_equal 5, ( t1.new( 3 ) + t2.new( 2 ) )[]
+      end
+    end
+  end
+
+  def test_lazy_unary
     T.select { |t| SIGNED[ t ] }.each do |t|
       i = lazy { -t.new( 3 ) }
       assert_not_equal t.new( -3 ), i
@@ -115,4 +123,16 @@ class TC_Int < Test::Unit::TestCase
     end
   end
 
+  def test_lazy_binary
+    a = U16.new 3
+    b = S8.new -5
+    i = lazy { a + b }
+    assert_not_equal a + b, i
+    assert_equal 'SINT(<delayed>)', i.inspect
+    assert_equal S16.new( -2 ), i.force
+    assert_equal S32.new( -1 ), i + S32.new( 1 )
+    assert_equal S32.new( -1 ), S32.new( 1 ) + i
+  end
+
+
 end

data/test/tc_multiarray.rb

@@ -81,12 +81,12 @@ class TC_MultiArray < Test::Unit::TestCase
   end
 
   def test_negate
-    m = M[ [ 1, 2, 3 ], [ 4, 5, 6 ] ]
+    m = M[ [ 1, 2, 3 ], [ 4, 5, 6 ] ].to_type O
     assert_equal [ [ -1, -2, -3 ], [ -4, -5, -6 ] ], ( -m ).to_a
   end
 
   def test_lazy
-    m = M[ [ 1, 2, 3 ], [ 4, 5, 6 ] ]
+    m = M[ [ 1, 2, 3 ], [ 4, 5, 6 ] ].to_type O
     u = lazy { -m }
     assert_equal 'MultiArray.object(3,2):<delayed>', u.inspect
     assert_equal [ [ -1, -2, -3 ], [ -4, -5, -6 ] ], u.force.to_a

data/test/tc_object.rb

@@ -64,7 +64,13 @@ class TC_Object < Test::Unit::TestCase
     assert_equal O.new( -5 ), -o
   end
 
-  def test_lazy
+  def test_plus
+    v = O.new 3
+    w = O.new 5
+    assert_equal O.new( 3 + 5 ), v + w
+  end
+
+  def test_lazy_unary
     o = lazy { -O.new( 3 ) }
     assert_not_equal O.new( -3 ), o
     assert_equal 'OBJECT(<delayed>)', o.inspect
@@ -83,4 +89,15 @@ class TC_Object < Test::Unit::TestCase
     assert_equal O.new( 3 ), o
   end
 
+  def test_lazy_binary
+    v = O.new 3
+    w = O.new 5
+    o = lazy { v + w }
+    assert_not_equal v + w, o
+    assert_equal 'OBJECT(<delayed>)', o.inspect
+    assert_equal O.new( 8 ), o.force
+    assert_equal O.new( 9 ), o + O.new( 1 )
+    assert_equal O.new( 9 ), O.new( 1 ) + o
+  end
+
 end

data/test/tc_sequence.rb

@@ -72,6 +72,7 @@ class TC_Sequence < Test::Unit::TestCase
 
   def test_sequence_assign
     assert_equal [ :a, :b, :c ], S[ :a, :b, :c ].to_a
+    assert_equal [ :a, :b, [ :c ] ], S[ :a, :b, [ :c ] ].to_a
   end
 
   def test_inspect
@@ -98,12 +99,19 @@ class TC_Sequence < Test::Unit::TestCase
   end
 
   def test_negate
-    s = S[ 1, 2, 3 ]
+    s = S[ 1, 2, 3 ].to_type O
     assert_equal [ -1, -2, -3 ], ( -s ).to_a
   end
 
-  def test_lazy
-    s = S[ 1, 2, 3 ]
+  def test_plus
+    s = S[ 1, 2, 3 ].to_type O
+    assert_equal [ 2, 4, 6 ], ( s + s ).to_a
+    assert_equal [ 2, 3, 4 ], ( s + O.new( 1 ) ).to_a
+    assert_equal [ 2, 3, 4 ], ( O.new( 1 ) + s ).to_a
+  end
+
+  def test_lazy_unary
+    s = S[ 1, 2, 3 ].to_type O
     u = lazy { -s }
     assert_equal 'Sequence.object(3):<delayed>', u.inspect
     assert_equal [ -1, -2, -3 ], u.force.to_a

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: multiarray
 version: !ruby/object:Gem::Version 
-  version: 0.4.0
+  version: 0.4.1
 platform: ruby
 authors: 
 - Jan Wedekind
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-01-26 00:00:00 +00:00
+date: 2010-01-28 00:00:00 +00:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -34,6 +34,7 @@ files:
 - Rakefile
 - README
 - COPYING
+- TODO
 - .document
 - lib/multiarray.rb
 - lib/multiarray/sequence_.rb