multiarray 0.5.0 → 0.5.1

data/lib/multiarray/int.rb

@@ -60,6 +60,10 @@ module Hornetseye
         0
       end
 
+      def maxint
+        Hornetseye::INT [ 32, bits ].max, signed
+      end
+
       def coercion( other )
         if other < INT_
           Hornetseye::INT [ bits, other.bits ].max, ( signed or other.signed )
@@ -68,30 +72,28 @@ module Hornetseye
         end
       end
 
+      def coerce( other )
+        if other < INT_
+          return other, self
+        else
+          super other
+        end
+      end
+
       # Directive for packing/unpacking elements of this type
       #
       # @private
       def directive
-        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 directive for packing/unpacking #{inspect}"
-        end
+        retval = { [  8, true  ] => 'c',
+                   [  8, false ] => 'C',
+                   [ 16, true  ] => 's',
+                   [ 16, false ] => 'S',
+                   [ 32, true  ] => 'i',
+                   [ 32, false ] => 'I',
+                   [ 64, true  ] => 'q',
+                   [ 64, false ] => 'Q' }[ [ bits, signed ] ]
+        raise "No directive for packing/unpacking #{inspect}" unless retval
+        retval
       end
 
       # Get string with information about this class
@@ -99,26 +101,15 @@ module Hornetseye
       # @return [String] Returns string with information about this class.
       def inspect
         unless bits.nil? or signed.nil?
-          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.inspect},#{ signed ? 'SIGNED' : 'UNSIGNED' })"
-          end
+          retval = { [  8, true  ] => 'BYTE',
+                     [  8, false ] => 'UBYTE',
+                     [ 16, true  ] => 'SINT',
+                     [ 16, false ] => 'USINT',
+                     [ 32, true  ] => 'INT',
+                     [ 32, false ] => 'UINT',
+                     [ 64, true  ] => 'LONG',
+                     [ 64, false ] => 'ULONG' }[ [ bits, signed ] ] ||
+                   "INT(#{bits.inspect},#{ signed ? 'SIGNED' : 'UNSIGNED' })"
         else
           super
         end
@@ -133,28 +124,9 @@ module Hornetseye
       # @private
       def descriptor( hash )
         unless bits.nil? or signed.nil?
-          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
+          inspect
         else
-          super
+          super hash
         end
       end
 
@@ -178,6 +150,16 @@ module Hornetseye
 
     end
 
+    def times( &action )
+      get.times &action
+      self
+    end
+
+    def upto( other, &action )
+      get.upto other.get, &action
+      self
+    end
+
     # Namespace containing method for matching elements of type INT_
     #
     # @see INT_
@@ -225,27 +207,6 @@ module Hornetseye
 
   end
 
-  # Create a class deriving from +INT_+
-  #
-  # he aprameters +bits+ and +signed+ are assigned to the corresponding
-  # attributes of the resulting class.
-  #
-  # @param [Integer] bits Number of bits of native integer.
-  # @param [FalseClass,TrueClass] signed Specify +UNSIGNED+ or +SIGNED+ here.
-  # @return [Class] A class deriving from +INT_+.
-  #
-  # @see INT_
-  # @see INT_.bits
-  # @see INT_.signed
-  def INT( bits, signed )
-    retval = Class.new INT_
-    retval.bits = bits
-    retval.signed = signed
-    retval
-  end
-
-  module_function :INT
-
   # Boolean constant to use as a parameter for creating integer classes
   #
   # The value is +false+.
@@ -260,6 +221,35 @@ module Hornetseye
   # @see #INT
   SIGNED   = true
 
+  # Create a class deriving from +INT_+ or instantiate an +INT+ object
+  #
+  # @overload INT( bits, signed )
+  #   Create a class deriving from +INT_+. The aprameters +bits+ and +signed+
+  #   are assigned to the corresponding attributes of the resulting class.
+  #   @param [Integer] bits Number of bits of native integer.
+  #   @param [FalseClass,TrueClass] signed Specify +UNSIGNED+ or +SIGNED+ here.
+  #   @return [Class] A class deriving from +INT_+.
+  #
+  # @overload INT( value )
+  #   This is a shortcut for +INT.new( value )+.
+  #   @param [Integer] value Initial value for integer object.
+  #
+  # @see INT_
+  # @see INT_.bits
+  # @see INT_.signed
+  def INT( arg, signed = nil )
+    if signed.nil?
+      INT.new arg
+    else
+      retval = Class.new INT_
+      retval.bits = arg
+      retval.signed = signed
+      retval
+    end
+  end
+
+  module_function :INT
+
   # 8-bit signed integer
   BYTE  = INT  8, SIGNED
 
@@ -284,4 +274,41 @@ module Hornetseye
   # 64-bit unsigned integer
   ULONG = INT 64, UNSIGNED
 
+  def BYTE( value )
+    BYTE.new value
+  end
+
+  def UBYTE( value )
+    UBYTE.new value
+  end
+
+  def SINT( value )
+    SINT.new value
+  end
+
+  def USINT( value )
+    USINT.new value
+  end
+
+  def UINT( value )
+    UINT.new value
+  end
+
+  def LONG( value )
+    LONG.new value
+  end
+
+  def ULONG( value )
+    ULONG.new value
+  end
+
+  module_function :BYTE
+  module_function :UBYTE
+  module_function :SINT
+  module_function :USINT
+  module_function :UINT
+  module_function :LONG
+  module_function :ULONG
+
+
 end

data/lib/multiarray/lambda.rb

@@ -57,7 +57,7 @@ module Hornetseye
       meta_vars, meta_values, var = @index.strip
       vars, values, term = @term.subst( @index => var ).strip
       return vars + meta_vars, values + meta_values,
-        Lambda.new( var, term.subst( @index => var ) )
+        Lambda.new( var, term )
     end
 
     def subst( hash )
@@ -89,12 +89,34 @@ module Hornetseye
       end
     end
 
+    def skip( index, start )
+      Lambda.new @index, @term.skip( index, start )
+    end
+
+    # Get element of this term
+    # Pass +i+ as argument to this lambda object.
+    #
+    # @param [Integer,Node] i Index of desired element.
+    #
+    # @return [Node,Object] Result of inserting +i+ for lambda argument.
     def element( i )
       i = Node.match( i ).new i unless i.is_a? Node
       i.size.store @index.size if @index.size.get and i.is_a? Variable
       @term.subst @index => i
     end
 
+    def slice( start, length )
+      start = Node.match( start ).new start unless start.is_a? Node
+      length = Node.match( length ).new length unless length.is_a? Node
+      index = Variable.new Hornetseye::INDEX( length )
+      Lambda.new( index, @term.subst( @index => index ).
+                         skip( index, start ) ).unroll
+    end
+
+    def compilable?
+      @term.compilable?
+    end
+
   end
 
 end

data/lib/multiarray/lookup.rb

@@ -31,7 +31,8 @@ module Hornetseye
     #
     # @private
     def descriptor( hash )
-      "Lookup(#{@p.descriptor( hash )},#{@index.descriptor( hash )},#{@stride.descriptor( hash )})"
+      "Lookup(#{@p.descriptor( hash )},#{@index.descriptor( hash )}," +
+        "#{@stride.descriptor( hash )})"
     end
 
     def array_type
@@ -76,10 +77,22 @@ module Hornetseye
       end
     end
 
+    def skip( index, start )
+      if @index == index
+        Lookup.new @p.lookup( start, @stride ), @index, @stride
+      else
+        Lookup.new @p.skip( index, start ), @index, @stride
+      end
+    end
+
     def element( i )
       Lookup.new @p.element( i ), @index, @stride
     end
 
+    def slice( start, length )
+      Lookup.new @p.slice( start, length ), @index, @stride
+    end
+
   end
 
 end

data/lib/multiarray/malloc.rb

@@ -20,11 +20,11 @@ module Hornetseye
   class Malloc
 
     def load( typecode )
-      read( typecode.storage_size ).unpack( typecode.directive ).first
+      read( typecode.storage_size ).unpack( typecode.directive )
     end
 
     def save( value )
-      write [ value.get ].pack( value.typecode.directive )
+      write value.values.pack( value.typecode.directive )
       value
     end
 

data/lib/multiarray/methods.rb

@@ -0,0 +1,93 @@
+# 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
+
+  module Methods
+
+    def Methods.included( mod )
+      define_unary_method  mod, :sqrt , :float
+      define_unary_method  mod, :log  , :float
+      define_unary_method  mod, :exp  , :float
+      define_unary_method  mod, :cos  , :float
+      define_unary_method  mod, :sin  , :float
+      define_unary_method  mod, :tan  , :float
+      define_unary_method  mod, :acos , :float
+      define_unary_method  mod, :asin , :float
+      define_unary_method  mod, :atan , :float
+      define_unary_method  mod, :cosh , :float
+      define_unary_method  mod, :sinh , :float
+      define_unary_method  mod, :tanh , :float
+      define_binary_method mod, :atan2, :floating
+      define_binary_method mod, :hypot, :floating
+    end
+
+    def define_unary_method( mod, op, conversion = :contiguous )
+      mod.module_eval do
+        define_method( "#{op}_with_hornetseye" ) do |a|
+          if a.is_a? Node
+            if a.dimension == 0 and a.variables.empty?
+              target = a.typecode.send conversion
+              target.new mod.send( op, a.simplify.get )
+            else
+              Hornetseye::UnaryMethod( mod, op, conversion ).new( a ).force
+            end
+          else
+            send "#{op}_without_hornetseye", a
+          end
+        end
+        alias_method_chain op, :hornetseye
+        module_function "#{op}_without_hornetseye"
+        module_function op
+      end
+    end
+
+    module_function :define_unary_method
+
+    def define_binary_method( mod, op, coercion = :coercion )
+      mod.module_eval do
+        define_method( "#{op}_with_hornetseye" ) do |a,b|
+          if a.is_a? Node or b.is_a? Node
+            a = Node.match( a, b.typecode ).new a unless a.is_a? Node
+            b = Node.match( b, a.typecode ).new b unless b.is_a? Node
+            if a.dimension == 0 and a.variables.empty? and
+               b.dimension == 0 and b.variables.empty?
+              target = a.typecode.send coercion, b.typecode
+              target.new mod.send( op, a.simplify.get, b.simplify.get )
+            else
+              Hornetseye::BinaryMethod( mod, op, coercion ).new( a, b ).force
+            end
+          else
+            send "#{op}_without_hornetseye", a, b
+          end
+        end
+        alias_method_chain op, :hornetseye
+        module_function "#{op}_without_hornetseye"
+        module_function op
+      end
+    end
+
+    module_function :define_binary_method
+
+  end
+
+end
+
+module Math
+  include Hornetseye::Methods
+end
+

data/lib/multiarray/multiarray.rb

@@ -38,18 +38,8 @@ module Hornetseye
       end
 
       def []( *args )
-        retval = Node.fit( args ).new
-        recursion = proc do |element,args|
-          if element.dimension > 0
-            args.each_with_index do |arg,i|
-              recursion.call element.element( i ), arg
-            end
-          else
-            element[] = args
-          end
-        end
-        recursion.call retval, args
-        retval
+        target = Node.fit args
+        target[ *args ]
       end
 
     end