multiarray 0.16.0 → 0.17.0

data/Rakefile

@@ -6,7 +6,7 @@ require 'rake/packagetask'
 require 'rbconfig'
 
 PKG_NAME = 'multiarray'
-PKG_VERSION = '0.16.0'
+PKG_VERSION = '0.17.0'
 RB_FILES = FileList[ 'lib/**/*.rb' ]
 TC_FILES = FileList[ 'test/tc_*.rb' ]
 TS_FILES = FileList[ 'test/ts_*.rb' ]

data/lib/multiarray.rb

@@ -176,6 +176,25 @@ class Object
     a.is_a?( Proc ) ? a.call : a
   end
 
+  # Conditional operation
+  #
+  # @param [Proc] action Action to perform if condition is +true+.
+  #
+  # @return [Object] The return value should be ignored.
+  def if( &action )
+    action.call
+  end
+
+  # Conditional operation
+  #
+  # @param [Proc] action1 Action to perform if condition is +true+.
+  # @param [Proc] action2 Action to perform if condition is +false+.
+  #
+  # @return [Object] The return value should be ignored.
+  def if_else( action1, action2 )
+    action1.call
+  end
+
 end
 
 # +NilClass+ is extended with a few methods
@@ -235,6 +254,24 @@ class NilClass
     b.is_a?( Proc ) ? b.call : b
   end
 
+  # Conditional operation
+  #
+  # @param [Proc] action Action to perform if condition is +true+.
+  #
+  # @return [Object] The return value should be ignored.
+  def if( &action )
+  end
+
+  # Conditional operation
+  #
+  # @param [Proc] action1 Action to perform if condition is +true+.
+  # @param [Proc] action2 Action to perform if condition is +false+.
+  #
+  # @return [Object] The return value should be ignored.
+  def if_else( action1, action2 )
+    action2.call
+  end
+
   # Check whether this term is compilable
   #
   # @return [FalseClass,TrueClass] Returns +false+
@@ -305,6 +342,24 @@ class FalseClass
     b.is_a?( Proc ) ? b.call : b
   end
 
+  # Conditional operation
+  #
+  # @param [Proc] action Action to perform if condition is +true+.
+  #
+  # @return [Object] The return value should be ignored.
+  def if( &action )
+  end
+
+  # Conditional operation
+  #
+  # @param [Proc] action1 Action to perform if condition is +true+.
+  # @param [Proc] action2 Action to perform if condition is +false+.
+  #
+  # @return [Object] The return value should be ignored.
+  def if_else( action1, action2 )
+    action2.call
+  end
+
 end
 
 # Some methods of +Fixnum+ are modified
@@ -603,6 +658,8 @@ require 'multiarray/diagonal'
 require 'multiarray/histogram'
 require 'multiarray/lut'
 require 'multiarray/integral'
+require 'multiarray/mask'
+require 'multiarray/unmask'
 require 'multiarray/operations'
 require 'multiarray/methods'
 require 'multiarray/rgb'

data/lib/multiarray/gccvalue.rb

@@ -333,6 +333,44 @@ module Hornetseye
 
     alias_method_chain :conditional, :complex
 
+    # Generate code for conditional statement
+    #
+    # @param [Proc] action Block of conditional.
+    #
+    # @return [Object] Returns +self+.
+    #
+    # @private
+    def if( &action )
+      @function << "#{@function.indent}if ( #{self} ) {\n"
+      @function.indent_offset +1
+      action.call
+      @function.indent_offset -1
+      @function << "#{@function.indent}};\n"
+      self
+    end
+
+    # Generate code for conditional statement
+    #
+    # @param [Proc] action1 Block to run when condition is fullfilled.
+    # @param [Proc] action2 Block to run otherwise.
+    #
+    # @return [Object] Returns +self+.
+    #
+    # @private
+    def if_else( action1, action2 )
+      @function << "#{@function.indent}if ( #{self} ) {\n"
+      @function.indent_offset +1
+      action1.call
+      @function.indent_offset -1
+      @function << "#{@function.indent}} else {\n"
+      @function.indent_offset +1
+      action2.call
+      @function.indent_offset -1
+      @function << "#{@function.indent}};\n"
+      self
+    end
+
+
     define_unary_op :not, '!'
     define_unary_op :~
     define_unary_op :-@, :-

data/lib/multiarray/mask.rb

@@ -0,0 +1,147 @@
+# 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 masking operations
+  class Mask < Node
+
+    class << self
+
+      # Check whether objects of this class are finalised computations
+      #
+      # @return [Boolean] Returns +false+.
+      #
+      # @private
+      def finalised?
+        false
+      end
+
+    end
+
+    # Constructor
+    #
+    # @param [Node] dest Target array to write histogram to.
+    # @param [Node] source Source array with values to apply mask to.
+    # @param [Node] m Boolean array with values of mask.
+    # @param [Node] index Counter for maintaining size of result.
+    #
+    # @private
+    def initialize( dest, source, m, index )
+      @dest, @source, @m, @index = dest, source, m, index
+    end
+
+    # Get unique descriptor of this object
+    #
+    # @param [Hash] hash Labels for any variables.
+    #
+    # @return [String] Descriptor of this object,
+    #
+    # @private
+    def descriptor( hash )
+      "Mask(#{@dest.descriptor( hash )},#{@source.descriptor( hash )}," +
+        "#{@m.descriptor( hash )},#{@index.descriptor( hash )})"
+    end
+
+    # Get type of result of delayed operation
+    #
+    # @return [Class] Type of result.
+    #
+    # @private
+    def array_type
+      @dest.array_type
+    end
+
+    # Perform masking operation
+    #
+    # @return [Node] Result of computation
+    #
+    # @private
+    def demand
+      if variables.empty?
+        index = @index.simplify
+        if @m.dimension > 0
+          @m.shape.last.times do |i|
+            m = @m.element INT.new( i )
+            source = @source.element INT.new( i )
+            Mask.new( @dest, source, m, index ).demand
+          end  
+        else
+          @m.simplify.get.if do
+            Store.new( @dest.element( index ), @source ).demand
+            index.store index + 1
+          end
+        end
+        @index.store index
+        @dest
+      else
+        super
+      end
+    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 @dest.subst( hash ), @source.subst( hash ), @m.subst( hash ),
+                     @index.subst( hash )
+    end
+
+    # Get variables contained in this term
+    #
+    # @return [Set] Returns list of variables.
+    #
+    # @private
+    def variables
+      @dest.variables + @source.variables + @m.variables + @index.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
+      stripped = [ @dest, @source, @m, @index ].collect { |value| value.strip }
+      return stripped.inject( [] ) { |vars,elem| vars + elem[ 0 ] },
+           stripped.inject( [] ) { |values,elem| values + elem[ 1 ] },
+           self.class.new( *stripped.collect { |elem| elem[ 2 ] } )
+    end
+
+    # Check whether this term is compilable
+    #
+    # @return [Boolean] Returns whether this term is compilable.
+    #
+    # @private
+    def compilable?
+      [ @dest, @source, @m, @index ].all? { |value| value.compilable? }
+    end
+
+  end
+
+end
+

data/lib/multiarray/multiarray.rb

@@ -24,11 +24,13 @@ module Hornetseye
 
       # Create new multi-dimensional array
       #
-      # @param [Class] typecode The type of elements
-      # @param [Array<Integer>] *shape The shape of the multi-dimensional array.
+      # @param [Class] element_type The type of the elements.
+      # @param [Array<Integer>] *array_shape The shape of the multi-dimensional array.
       #
       # @return [Node] Returns uninitialised native array.
-      def new( typecode, *shape )
+      def new( element_type, *array_shape )
+        typecode = element_type.typecode
+        shape = element_type.shape + array_shape
         options = shape.last.is_a?( Hash ) ? shape.pop : {}
         count = options[ :count ] || 1
         if shape.empty?

data/lib/multiarray/operations.rb

@@ -1,5 +1,5 @@
 # multiarray - Lazy multi-dimensional arrays for Ruby
-# Copyright (C) 2010 Jan Wedekind
+# Copyright (C) 2010, 2011 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
@@ -569,6 +569,59 @@ module Hornetseye
       left
     end
 
+    # Select values from array using a mask
+    #
+    # @param [Node] m Mask to apply to this array.
+    #
+    # @return [Node] The masked array.
+    def mask( m )
+      check_shape m
+      left = MultiArray.new typecode, *( shape.first( dimension - m.dimension ) +
+                                         [ m.size ] )
+      index = Hornetseye::Pointer( INT ).new
+      index.store INT.new( 0 )
+      block = Mask.new left, self, m, index
+      if block.compilable?
+        GCCFunction.run block
+      else
+        block.demand
+      end
+      left[ 0 ... index[] ].roll
+    end
+
+    # Distribute values in a new array using a mask
+    #
+    # @param [Node] m Mask for inverse masking operation.
+    # @option options [Object] :default (typecode.default) Default value for elements
+    #         where mask is +false+.
+    # @option options [Boolean] :safe (true) Ensure that the size of this size is
+    #         sufficient.
+    #
+    # @return [Node] The result of the inverse masking operation.
+    def unmask( m, options = {} )
+      options = { :safe => true, :default => typecode.default }.merge options
+      default = options[ :default ]
+      default = typecode.new default unless default.is_a? Node
+      m.check_shape default
+      if options[ :safe ]
+        if m.to_ubyte.sum > shape.last
+          raise "#{m.to_ubyte.sum} value(s) of the mask are true but the last " +
+            "dimension of the array for unmasking only has #{shape.last} value(s)"
+        end
+      end
+      left = Hornetseye::MultiArray( array_type.element_type, *m.shape ).
+             coercion( default.array_type ).new
+      index = Hornetseye::Pointer( INT ).new
+      index.store INT.new( 0 )
+      block = Unmask.new left, self, m, index, default
+      if block.compilable?
+        GCCFunction.run block
+      else
+        block.demand
+      end
+      left
+    end
+
     # Mirror the array
     #
     # @param [Array<Integer>] dimensions The dimensions which should be flipped.

data/lib/multiarray/sequence.rb

@@ -24,12 +24,12 @@ module Hornetseye
 
       # Allocate new uniform array
       #
-      # @param [Class] typecode Type of array elements.
+      # @param [Class] element_type Type of array elements.
       # @param [Integer] size Number of elements.
       #
       # @return [Node] Returns uninitialised native array.
-      def new( typecode, size )
-        MultiArray.new typecode, size
+      def new( element_type, size )
+        MultiArray.new element_type, size
       end
 
       # Import array from string
@@ -117,6 +117,13 @@ module Hornetseye
         end
       end
 
+      # Generate random number array
+      #
+      # Generate integer or floating point random numbers in the range 0 ... n.
+      #
+      # @param [Integer,Float] n Upper boundary for random numbers
+      #
+      # @return [Node] Array with random numbers.
       def random( n = 1 )
         n = typecode.maxint.new n unless n.is_a? Node
         retval = new

data/lib/multiarray/unmask.rb

@@ -0,0 +1,154 @@
+# multiarray - Lazy multi-dimensional arrays for Ruby
+# Copyright (C) 2011 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 inverse masking operations
+  class Unmask < Node
+
+    class << self
+
+      # Check whether objects of this class are finalised computations
+      #
+      # @return [Boolean] Returns +false+.
+      #
+      # @private
+      def finalised?
+        false
+      end
+
+    end
+
+    # Constructor
+    #
+    # @param [Node] dest Target array to write histogram to.
+    # @param [Node] source Source array with values to apply mask to.
+    # @param [Node] m Boolean array with values of mask.
+    # @param [Node] default Default value for unaffected elements.
+    #
+    # @private
+    def initialize( dest, source, m, index, default )
+      @dest, @source, @m, @index, @default = dest, source, m, index, default
+    end
+
+    # Get unique descriptor of this object
+    #
+    # @param [Hash] hash Labels for any variables.
+    #
+    # @return [String] Descriptor of this object,
+    #
+    # @private
+    def descriptor( hash )
+      "Unmask(#{@dest.descriptor( hash )},#{@source.descriptor( hash )}," +
+        "#{@m.descriptor( hash )},#{@index.descriptor( hash )}," +
+        "#{@default.descriptor( hash )})"
+    end
+
+    # Get type of result of delayed operation
+    #
+    # @return [Class] Type of result.
+    #
+    # @private
+    def array_type
+      @dest.array_type
+    end
+
+    # Perform masking operation
+    #
+    # @return [Node] Result of computation
+    #
+    # @private
+    def demand
+      if variables.empty?
+        index = @index.simplify
+        if @m.dimension > 0
+          @m.shape.last.times do |i|
+            m = @m.element INT.new( i )
+            dest = @dest.element INT.new( i )
+            default = @default.dimension > 0 ?
+                      @default.element( INT.new( i ) ) : @default
+            Unmask.new( dest, @source, m, index, default ).demand
+          end  
+        else
+          @m.simplify.get.if_else( proc do
+            Store.new( @dest, @source.element( index ) ).demand
+            index.store index + 1
+          end, proc do
+            Store.new( @dest, @default ).demand
+          end )
+        end
+        @index.store index
+        @dest
+      else
+        super
+      end
+    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 @dest.subst( hash ), @source.subst( hash ), @m.subst( hash ),
+                     @index.subst( hash ), @default.subst( hash )
+    end
+
+    # Get variables contained in this term
+    #
+    # @return [Set] Returns list of variables.
+    #
+    # @private
+    def variables
+      @dest.variables + @source.variables + @m.variables + @index.variables +
+        @default.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
+      stripped = [ @dest, @source, @m, @index, @default ].
+        collect { |value| value.strip }
+      return stripped.inject( [] ) { |vars,elem| vars + elem[ 0 ] },
+           stripped.inject( [] ) { |values,elem| values + elem[ 1 ] },
+           self.class.new( *stripped.collect { |elem| elem[ 2 ] } )
+    end
+
+    # Check whether this term is compilable
+    #
+    # @return [Boolean] Returns whether this term is compilable.
+    #
+    # @private
+    def compilable?
+      [ @dest, @source, @m, @index, @default ].all? { |value| value.compilable? }
+    end
+
+  end
+
+end
+

data/test/tc_multiarray.rb

@@ -705,4 +705,31 @@ class TC_MultiArray < Test::Unit::TestCase
                  M( I, 3, 2 )[ [ 1, 2, 3 ], [ 4, 5, 6 ] ].integral
   end
 
+  def test_mask
+    [ O, I ].each do |t|
+      assert_equal M( O, 2, 2 )[ [ 1, 2 ], [ 5, 7 ] ],
+                   M( O, 2, 3 )[ [ 1, 2 ], [ 3, 4 ], [ 5, 7 ] ].
+                   mask( S[ true, false, true ] )
+      assert_equal S( O, 3 )[ 2, 5, 7 ], M( O, 3, 2 )[ [ 1, 2, 3 ], [ 4, 5, 7 ] ].
+                   mask( M[ [ false, true, false ], [ false, true, true ] ] )
+      assert_raise( RuntimeError ) do
+        M( O, 2, 3 )[ [ 1, 2 ], [ 3, 4 ], [ 5, 7 ] ].mask S[ false, true ]
+      end
+    end
+  end
+
+  def test_unmask
+    [ O, I ].each do |t|
+      assert_equal M( t, 2, 3 )[ [ 1, 2 ], [ 4, 4 ], [ 5, 7 ] ],
+                   M( t, 2, 2 )[ [ 1, 2 ], [ 5, 7 ] ].
+                   unmask( S[ true, false, true ], :default => S[ 3, 4, 5 ] )
+      assert_equal M( t, 3, 2 )[ [ 0, 2, 0 ], [ 0, 5, 7 ] ],
+                   S( t, 3 )[ 2, 5, 7 ].
+                   unmask( M[ [ false, true, false ], [ false, true, true ] ],
+                           :default => 0 )
+      assert_raise( RuntimeError ) { S( t, 1 )[ 1 ].unmask M[ [ true, true ] ] }
+    end
+  end
+
 end
+

data/test/tc_sequence.rb

@@ -893,4 +893,27 @@ class TC_Sequence < Test::Unit::TestCase
     assert_equal S( I, 3 )[ 1, 3, 6 ], S( I, 3 )[ 1, 2, 3 ].integral
   end
 
+  def test_mask
+    assert_equal S( O, 2 )[ 2, 5 ], S( O, 3 )[ 2, 3, 5 ].
+                 mask( S[ true, false, true ] )
+    assert_equal S( I, 2 )[ 2, 5 ], S( I, 3 )[ 2, 3, 5 ].
+                 mask( S[ true, false, true ] )
+    assert_raise( RuntimeError ) { S[ 1, 2 ].mask S[ true ] }
+  end
+
+  def test_unmask
+    [ O, I ].each do |t|
+      assert_equal S( t, 3 )[ 2, 3, 5 ],
+                   S( t, 2 )[ 2, 5 ].unmask( S[ true, false, true ], :default => 3 )
+      assert_equal S( t, 3 )[ 2, 3, 5 ],
+                   S( t, 2 )[ 2, 5 ].unmask( S[ true, false, true ],
+                                             :default => S[ 2, 3, 4 ] )
+      assert_raise( RuntimeError ) do
+        S( t, 1 )[ 1 ].unmask S[ true ], :default => S[ 1, 2 ]
+      end
+      assert_raise( RuntimeError ) { S( t, 1 )[ 1 ].unmask S[ true, true ] }
+    end
+  end
+
 end
+

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 16
+  - 17
   - 0
-  version: 0.16.0
+  version: 0.17.0
 platform: ruby
 authors: 
 - Jan Wedekind
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-12-21 00:00:00 +00:00
+date: 2011-01-02 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -77,8 +77,10 @@ files:
 - lib/multiarray/methods.rb
 - lib/multiarray/integral.rb
 - lib/multiarray/multiarray.rb
+- lib/multiarray/unmask.rb
 - lib/multiarray/node.rb
 - lib/multiarray/histogram.rb
+- lib/multiarray/mask.rb
 - lib/multiarray/malloc.rb
 - lib/multiarray/index.rb
 - lib/multiarray/rgb.rb