multiarray 0.5.0 → 0.5.1

data/Rakefile

@@ -6,12 +6,14 @@ require 'rake/packagetask'
 require 'rbconfig'
 
 PKG_NAME = 'multiarray'
-PKG_VERSION = '0.5.0'
+PKG_VERSION = '0.5.1'
 RB_FILES = FileList[ 'lib/**/*.rb' ]
 TC_FILES = FileList[ 'test/tc_*.rb' ]
 TS_FILES = FileList[ 'test/ts_*.rb' ]
 PKG_FILES = [ 'Rakefile', 'README.md', 'COPYING', 'TODO', '.document' ] +
             RB_FILES + TS_FILES + TC_FILES
+BIN_FILES = [ 'README.md', 'COPYING', '.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++.}
 AUTHOR = %q{Jan Wedekind}
@@ -88,16 +90,48 @@ begin
     s.add_development_dependency %q{rake}
   end
   GEM_SOURCE = "#{PKG_NAME}-#{PKG_VERSION}.gem"
+  $BINSPEC = Gem::Specification.new do |s|
+    s.name = PKG_NAME
+    s.version = PKG_VERSION
+    s.platform = Gem::Platform::CURRENT
+    s.date = Date.today.to_s
+    s.summary = SUMMARY
+    s.description = DESCRIPTION
+    s.author = AUTHOR
+    s.email = EMAIL
+    s.homepage = HOMEPAGE
+    s.files = BIN_FILES
+    s.test_files = TC_FILES
+    s.require_paths = [ 'lib' ]
+    s.rubyforge_project = %q{hornetseye}
+    s.has_rdoc = 'yard'
+    s.extra_rdoc_files = []
+    s.rdoc_options = %w{--no-private}
+    s.add_dependency %q<malloc>, [ '~> 1.0' ]
+  end
+  GEM_BINARY = "#{PKG_NAME}-#{PKG_VERSION}-#{$BINSPEC.platform}.gem"
   desc "Build the gem file #{GEM_SOURCE}"
   task :gem => [ "pkg/#{GEM_SOURCE}" ]
   file "pkg/#{GEM_SOURCE}" => [ 'pkg' ] + $SPEC.files do
-    Gem::Builder.new( $SPEC ).build
-    verbose true do
-      FileUtils.mv GEM_SOURCE, "pkg/#{GEM_SOURCE}"
+    when_writing 'Creating GEM' do
+      Gem::Builder.new( $SPEC ).build
+      verbose true do
+        FileUtils.mv GEM_SOURCE, "pkg/#{GEM_SOURCE}"
+      end
+    end
+  end
+  desc "Build the gem file #{GEM_BINARY}"
+  task :gem_binary => [ "pkg/#{GEM_BINARY}" ]
+  file "pkg/#{GEM_BINARY}" => [ 'pkg' ] + $BINSPEC.files do
+    when_writing 'Creating binary GEM' do
+      Gem::Builder.new( $BINSPEC ).build
+      verbose true do
+        FileUtils.mv GEM_BINARY, "pkg/#{GEM_BINARY}"
+      end
     end
   end
 rescue LoadError
   STDERR.puts 'Please install \'rubygems\' if you want to create Gem packages'
 end
 
-CLOBBER.include 'doc'
+CLOBBER.include 'doc', '.yardoc'

data/TODO

@@ -1,25 +1,22 @@
-# test for multiarray-indgen
-# accept ranges for element access
-# compile Convolve#demand
-# inject without initial is [ 1 .. -1 ].inject with [ 0 ] as initial value
-# Composite numbers?
-# pointer-increments for better efficiency
-# How does contiguous work here? typecasts?
-# separate secondary operations like equality
-# preload cache
-# Sequence( UBYTE, 3 )[ ... ]
+# type alignment for operators and methods, Math.sqrt( SFLOAT )
+# test floor, ceil, ..., factor out common stuff of UnaryOp and UnaryMethod
+# complex numbers, factor out composite numbers
+# Fast filling of arrays, duplication, type conversions
+# use descriptors ('c','f',...)?
+# pointer-increments for better efficiency, optimize Node#diagonal
+# implement typecasts, how does contiguous work here?
+# documentation!
 
 # histogram (implement using injection)
-# inject: min, max, equal, n-d clips for warp
+# inject: n-d clips for warp
 # block(var1,var2,...) with smart subst?
-# lazy( 5 ) { |i| 0 } # but lazy { 0 }
-# lazy( 3, 2 ) { |i,j| i }
 # lazy( 3, 2 ) { |i,j| j.to_object }
 
 # RSpec
 
 # downsampling after correlation?
-# README.rdoc, YARD documentation with pictures, demo video
+# YARD documentation with pictures, demo video
+# CK_Thesis.pdf: tensor voting
 
 # f(g(i)) # g(i), f(g(i)) all can be vectors and all can be lazy
 # lut(g(i))
@@ -44,9 +41,6 @@
 # binary operations, equality: ( a == b ).inject( true ) { |e,b| e && b }
 # inject: min, max, equal, n-d clips for warp
 # block(var1,var2,...) with smart subst?
-# lazy( 5 ) { |i| 0 }
-# lazy( 3, 2 ) { |i,j| i }
-# lazy( 3, 2 ) { |i,j| j }
 
 # downsampling after correlation?
 # ruby -Ilib -rrubygems -rmultiarray -rtest test/tc_sequence.rb
@@ -61,45 +55,12 @@
 #  end
 #end
 
-
-lazy { a * b } -> lazy { |i,j| lazy { |i,j| a[i,j] * b[i,j] }[i,j] } # ?
-lazy { s } -> s
-lazy { -s } -> lazy { |i| -s[i] }
-lazy { |i,j| s[i,j] }
-lazy { |i| lazy { |j| s[i,j] } }
-lazy( n ) { |i| i }
-lazy( n, m ) { |i,j| i + j }
-lazy( n ) { |i| lazy( m ) { |j| i + j } }
-eager( n ) { |i| i }
-...
-
-tensor indices to enable transpose of lazy array
 ranges (rolling, lazy rolling, lazy ranges)
-test lazyness
-sums/injections (equality for arrays)? 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
@@ -122,19 +83,3 @@ 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
-
-# donate to yardoc
-
-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

@@ -375,36 +375,36 @@ end
 # +Range+ is extended with a few methods
 class Range
 
-  alias_method :orig_min, :min
-
-  alias_method :orig_max, :max
-
   # For performance reasons a specialised method for integers is added
   #
   # @return [Object] Minimum value of range.
   #
   # @private
-  def min
+  def min_with_hornetseye
     if self.begin.is_a? Integer
       self.begin
     else
-      orig_min
+      min_without_hornetseye
     end
   end
 
+  alias_method_chain :min, :hornetseye
+
   # For performance reasons a specialised method for integers is added
   #
   # @return [Object] Maximum value of range.
   #
   # @private
-  def max
+  def max_with_hornetseye
     if self.end.is_a? Integer
       exclude_end? ? self.end - 1 : self.end
     else
-      orig_max
+      max_without_hornetseye
     end
   end
 
+  alias_method_chain :max, :hornetseye
+
   # Compute the size of a range
   #
   # @return [Integer] Number of discrete values within range.
@@ -414,6 +414,48 @@ class Range
 
 end
 
+class Numeric
+
+  def r
+    self
+  end
+
+  def g
+    self
+  end
+
+  def b
+    self
+  end
+
+  def major( other )
+    if other.is_a? Numeric
+      ( self >= other ).conditional self, other
+    else
+      x, y = other.coerce self
+      x.major other
+    end
+  end
+
+  def minor( other )
+    if other.is_a? Numeric
+      ( self <= other ).conditional self, other
+    else
+      x, y = other.coerce self
+      x.minor other
+    end
+  end
+
+end
+
+class Array
+
+  def collect_with_index( &action )
+    zip( ( 0 ... size ).to_a ).collect &action
+  end
+
+end
+
 require 'malloc'
 require 'rbconfig'
 require 'set'
@@ -426,13 +468,18 @@ require 'multiarray/object'
 require 'multiarray/index'
 require 'multiarray/bool'
 require 'multiarray/int'
+require 'multiarray/float'
+require 'multiarray/rgb'
 require 'multiarray/pointer'
 require 'multiarray/variable'
 require 'multiarray/lambda'
 require 'multiarray/lookup'
-require 'multiarray/unary'
-require 'multiarray/binary'
+require 'multiarray/unaryop'
+require 'multiarray/unarymethod'
+require 'multiarray/binaryop'
+require 'multiarray/binarymethod'
 require 'multiarray/operations'
+require 'multiarray/methods'
 require 'multiarray/inject'
 require 'multiarray/diagonal'
 require 'multiarray/sequence'
@@ -458,7 +505,7 @@ module Hornetseye
     Thread.current[ :lazy ] = true
     begin
       options = shape.last.is_a?( Hash ) ? shape.pop : {}
-      arity = options[ :arity ] || action.arity
+      arity = options[ :arity ] || [ action.arity, shape.size ].max
       if arity <= 0
         action.call
       else
@@ -506,7 +553,7 @@ module Hornetseye
   # @return [Object,Node] Sum of values.
   def sum( *shape, &action )
     options = shape.last.is_a?( Hash ) ? shape.pop : {}
-    arity = options[ :arity ] || action.arity
+    arity = options[ :arity ] || [ action.arity, shape.size ].max
     if arity <= 0
       action.call
     else

data/lib/multiarray/binarymethod.rb

@@ -0,0 +1,195 @@
+# multiarray - Lazy multi-dimensional arrays for Ruby
+# Copyright (C) 2010 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
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+# Namespace of Hornetseye computer vision library
+module Hornetseye
+
+  # Class for representing binary operations on scalars and arrays
+  class BinaryMethod_ < Node
+
+    class << self
+
+      # Name of module
+      #
+      # @return [Module] The module with the method.
+      attr_accessor :mod
+
+      # Name of operation
+      #
+      # @return [Symbol,String] The name of this operation.
+      attr_accessor :operation
+
+      # Name of method for type conversion
+      #
+      # @return [Symbol,String] The name of the method for type conversion.
+      attr_accessor :coercion
+
+      # Get string with information about this class
+      #
+      # @return [String] Return string with information about this class.
+      def inspect
+        "#{mod.to_s}.#{operation.to_s}"
+      end
+
+      # Get unique descriptor of this class
+      #
+      # @param [Hash] hash Labels for any variables.
+      #
+      # @return [String] Descriptor of this class.
+      #
+      # @private
+      def descriptor( hash )
+        inspect
+      end
+
+    end
+
+    # Initialise binary operation
+    #
+    # @param [Node] value1 First operand to apply operation to.
+    # @param [Node] value2 Second operand to apply operation to.
+    def initialize( value1, value2 )
+      @value1, @value2 = value1, value2
+    end
+
+    # Get unique descriptor of this object
+    #
+    # @param [Hash] hash Labels for any variables.
+    #
+    # @return [String] Descriptor of this object,
+    #
+    # @private
+    def descriptor( hash )
+      "#{self.class.descriptor( hash )}(#{@value1.descriptor( hash )})," +
+        "(#{@value2.descriptor( hash )})"
+    end
+
+    # Array type of this term
+    #
+    # @return [Class] Resulting array type.
+    #
+    # @private
+    def array_type
+      @value1.array_type.send self.class.coercion, @value2.array_type
+    end
+
+    # Substitute variables
+    #
+    # Substitute the variables with the values given in the hash.
+    #
+    # @param [Hash] hash Substitutions to apply.
+    #
+    # @return [Node] Term with substitutions applied.
+    #
+    # @private
+    def subst( hash )
+      self.class.new @value1.subst( hash ), @value2.subst( hash )
+    end
+
+    # Get variables contained in this term
+    #
+    # @return [Set] Returns set of variables.
+    #
+    # @private
+    def variables
+      @value1.variables + @value2.variables
+    end
+
+    # Strip of all values
+    #
+    # Split up into variables, values, and a term where all values have been
+    # replaced with variables.
+    #
+    # @return [Array<Array,Node>] Returns an array of variables, an array of
+    # values, and the term based on variables.
+    #
+    # @private
+    def strip
+      vars1, values1, term1 = @value1.strip
+      vars2, values2, term2 = @value2.strip
+      return vars1 + vars2, values1 + values2, self.class.new( term1, term2 )
+    end
+
+    # Reevaluate computation
+    #
+    # @return [Node,Object] Result of computation
+    #
+    # @see #force
+    #
+    # @private
+    def demand
+      self.class.mod.send self.class.operation, @value1, @value2
+    end
+
+    def skip( index, start )
+      element1 = @value1.skip( index, start )
+      element2 = @value2.skip( index, start )
+      self.class.new( element1, element2 ).demand
+    end
+
+    # Get element of unary operation
+    #
+    # @param [Integer,Node] i Index of desired element.
+    #
+    # @return [Node,Object] Element of unary operation.
+    def element( i )
+      element1 = @value1.dimension == 0 ? @value1 : @value1.element( i )
+      element2 = @value2.dimension == 0 ? @value2 : @value2.element( i )
+      self.class.new( element1, element2 ).demand
+    end
+
+    def slice( start, length )
+      element1 = @value1.dimension == 0 ? @value1 :
+                                          @value1.slice( start, length )
+      element2 = @value2.dimension == 0 ? @value2 :
+                                          @value2.slice( start, length )
+      self.class.new( element1, element2 ).demand
+    end
+
+    # Check whether this term is compilable
+    #
+    # @return [FalseClass,TrueClass] Returns whether this term is compilable.
+    #
+    # @private
+    def compilable?
+      @value1.compilable? and @value2.compilable?
+    end
+
+  end
+
+  # Create a class deriving from +BinaryMethod_+
+  #
+  # @param [Symbol,String] operation Name of operation.
+  # @param [Symbol,String] conversion Name of method for type conversion.
+  #
+  # @return [Class] A class deriving from +BinaryMethod_+.
+  #
+  # @see BinaryMethod_
+  # @see BinaryMethod_.operation
+  # @see BinaryMethod_.coercion
+  #
+  # @private
+  def BinaryMethod( mod, operation, coercion = :coercion )
+    retval = Class.new BinaryMethod_
+    retval.mod = mod
+    retval.operation = operation
+    retval.coercion = coercion
+    retval
+  end
+
+  module_function :BinaryMethod
+
+end