multiarray 0.11.3 → 0.11.4

data/lib/multiarray/shortcuts.rb

@@ -17,52 +17,98 @@
 # Namespace of Hornetseye computer vision library
 module Hornetseye
 
+  # Module with meta-programming methods for creating constructor shortcut methods
   module MultiArrayConstructor
 
-    def method_missing( name, *args )
-      if name.to_s =~ /^[a-z]+$/
-        target = name.to_s.upcase
-        if Hornetseye.const_defined? target
-          target = Hornetseye.const_get target
-          if target.is_a? Class and target < Element
-            new target, *args
-          else
-            super name, *args
-          end
-        else
-          super name, *args
-        end
-      else
-        super name, *args
+    # Meta-programming method for creating constructor shortcut methods
+    #
+    # @param [Class] target Element-type to create constructor shortcut for.
+    #
+    # @return [Proc] The new method.
+    #
+    # @private
+    def constructor_shortcut( target )
+      define_method( target.to_s.downcase ) do |*args|
+        new target, *args
       end
     end
 
+    module_function :constructor_shortcut
+
+    constructor_shortcut OBJECT
+    constructor_shortcut BOOL
+    constructor_shortcut BYTE
+    constructor_shortcut UBYTE
+    constructor_shortcut SINT
+    constructor_shortcut USINT
+    constructor_shortcut INT
+    constructor_shortcut UINT
+    constructor_shortcut LONG
+    constructor_shortcut ULONG
+    constructor_shortcut SFLOAT
+    constructor_shortcut DFLOAT
+    constructor_shortcut SCOMPLEX
+    constructor_shortcut DCOMPLEX
+    constructor_shortcut BYTERGB
+    constructor_shortcut UBYTERGB
+    constructor_shortcut SINTRGB
+    constructor_shortcut USINTRGB
+    constructor_shortcut INTRGB
+    constructor_shortcut UINTRGB
+    constructor_shortcut LONGRGB
+    constructor_shortcut ULONGRGB
+    constructor_shortcut SFLOATRGB
+    constructor_shortcut DFLOATRGB
+
   end
 
   Sequence.extend MultiArrayConstructor
 
   MultiArray.extend MultiArrayConstructor
 
+  # Module with meta-programming methods for creating conversion shortcut methods
   module MultiArrayConversion
 
-    def method_missing( name, *args )
-      if name.to_s =~ /^to_[a-z]+$/
-        target = name.to_s[ 3 .. -1 ].upcase
-        if Hornetseye.const_defined? target
-          target = Hornetseye.const_get target
-          if target.is_a? Class and target < Element
-            to_type target, *args
-          else
-            super target, *args
-          end
-        else
-          super name, *args
-        end
-      else
-        super name, *args
+    # Meta-programming method for creating type conversion shortcut methods
+    #
+    # @param [Class] target Element-type to create type conversion shortcut for.
+    #
+    # @return [Proc] The new method.
+    #
+    # @private
+    def to_type_shortcut( target )
+      define_method( "to_#{target.to_s.downcase}" ) do
+        to_type target
       end
     end
 
+    module_function :to_type_shortcut
+
+    to_type_shortcut OBJECT
+    to_type_shortcut BOOL
+    to_type_shortcut BYTE
+    to_type_shortcut UBYTE
+    to_type_shortcut SINT
+    to_type_shortcut USINT
+    to_type_shortcut INT
+    to_type_shortcut UINT
+    to_type_shortcut LONG
+    to_type_shortcut ULONG
+    to_type_shortcut SFLOAT
+    to_type_shortcut DFLOAT
+    to_type_shortcut SCOMPLEX
+    to_type_shortcut DCOMPLEX
+    to_type_shortcut BYTERGB
+    to_type_shortcut UBYTERGB
+    to_type_shortcut SINTRGB
+    to_type_shortcut USINTRGB
+    to_type_shortcut INTRGB
+    to_type_shortcut UINTRGB
+    to_type_shortcut LONGRGB
+    to_type_shortcut ULONGRGB
+    to_type_shortcut SFLOATRGB
+    to_type_shortcut DFLOATRGB
+
   end
 
   Node.class_eval { include MultiArrayConversion }

data/lib/multiarray/store.rb

@@ -16,20 +16,46 @@
 
 module Hornetseye
 
+  # Class for computing the elements of an array and storing them
   class Store < Node
 
+    # Constructor
+    #
+    # @param [Node] dest Target array to write array to.
+    # @param [Node] source Expression to compute elements of array.
+    #
+    # @private
     def initialize( dest, source )
       @dest, @source = dest, source
     end
 
+    # Get unique descriptor of this object
+    #
+    # @param [Hash] hash Labels for any variables.
+    #
+    # @return [String] Descriptor of this object,
+    #
+    # @private
     def descriptor( hash )
       "Store(#{@dest.descriptor( hash )},#{@source.descriptor( hash )})"
     end
 
+    # Get type of result of delayed operation
+    #
+    # @return [Class] Type of result.
+    #
+    # @private
     def array_type
       @dest.array_type
     end
 
+    # Reevaluate computation
+    #
+    # @return [Node,Object] Result of computation
+    #
+    # @see #force
+    #
+    # @private
     def demand
       if variables.empty?
         if dimension > 0
@@ -48,20 +74,48 @@ module Hornetseye
       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 )
     end
 
+    # Get variables contained in this term
+    #
+    # @return [Set] Returns list of variables.
+    #
+    # @private
     def variables
       @dest.variables + @source.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 = @dest.strip
       vars2, values2, term2 = @source.strip
       return vars1 + vars2, values1 + values2, Store.new( term1, term2 )
     end
   
+    # Check whether this term is compilable
+    #
+    # @return [Boolean] Returns whether this term is compilable.
+    #
+    # @private
     def compilable?
       @dest.compilable? and @source.compilable?
     end

data/lib/multiarray/variable.rb

@@ -17,13 +17,23 @@
 # Namespace of Hornetseye computer vision library
 module Hornetseye
 
+  # Clas for representing variables
+  #
+  # @private
   class Variable < Node
 
     # Type information about this variable
     #
     # @return [Class] Returns type information about this variable.
+    #
+    # @private
     attr_reader :meta
 
+    # Constructor creating a variable
+    #
+    # @param [Class] meta The type of this variable.
+    #
+    # @private
     def initialize( meta )
       @meta = meta
     end
@@ -32,6 +42,8 @@ module Hornetseye
     #
     # @return [String] String with information about this object (e.g.
     #         'Variable(INT)').
+    #
+    # @private
     def inspect
       "Variable(#{@meta.inspect})"
     end
@@ -54,6 +66,8 @@ module Hornetseye
     # Get array size for index variable
     #
     # @return [Node] Get the dimension of the array if this is an index variable.
+    #
+    # @private
     def size
       @meta.size
     end
@@ -63,6 +77,10 @@ module Hornetseye
     # Set the dimension of the array assuming this is an index variable.
     #
     # @param [Node] value The new size.
+    #
+    # @return [Node] Returns +value+.
+    #
+    # @private
     def size=( value )
       @meta.size = value
     end
@@ -151,3 +169,4 @@ module Hornetseye
   end
 
 end
+

data/test/tc_lazy.rb

@@ -67,6 +67,13 @@ class TC_Lazy < Test::Unit::TestCase
     assert_equal [ [ 0, 0, 0 ], [ 1, 1, 1 ] ], lazy( 3, 2 ) { |i,j| j }.to_a
   end
 
+  def test_at
+    assert_equal [ [ -1, 4 ], [ 2, 5 ], [ 3, 6 ] ],
+                 lazy { |i| lazy { |j| @m[i,j] } }.to_a
+    assert_equal [ [ -1, 4 ], [ 2, 5 ], [ 3, 6 ] ],
+                 lazy { |i,j| @m[j,i] }.to_a
+  end
+
   def test_minus_at
     assert_equal -2, lazy { ( -@s )[ 1 ] } 
   end
@@ -98,6 +105,8 @@ class TC_Lazy < Test::Unit::TestCase
     assert_equal 10, lazy( 5 ) { |i| i }.inject { |a,b| a + b }
     assert_equal [ 0, 3, 6, 9 ], sum { |k| lazy( 4, 3 ) { |i,j| i }[ k ] }.to_a
     assert_equal [ 3, 3, 3, 3 ], sum { |k| lazy( 4, 3 ) { |i,j| j }[ k ] }.to_a
+    assert_equal 0, lazy( 3 ) { 0 }.inject { |a,b| a.minor b }
+    assert_equal 0, lazy( 3, 2 ) { 0 }.inject { |a,b| a.minor b }
   end
 
   def test_indgen_diagonal

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 11
-  - 3
-  version: 0.11.3
+  - 4
+  version: 0.11.4
 platform: ruby
 authors: 
 - Jan Wedekind
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-10-28 00:00:00 +01:00
+date: 2010-11-18 00:00:00 +00:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency