multiarray 0.5.2 → 0.6.0

data/lib/multiarray/gccvalue.rb

@@ -21,6 +21,14 @@ module Hornetseye
 
     class << self
 
+      # Check compatibility of other type.
+      #
+      # This method checks whether binary operations with the other Ruby object can
+      # be performed without requiring coercion.
+      #
+      # @param [Object] value The other Ruby object.
+      #
+      # @return [Boolean] Returns +false+ if Ruby object requires coercion.
       def generic?( value )
         value.is_a?( GCCValue ) or value.is_a?( Fixnum ) or
           value.is_a?( Float )
@@ -83,14 +91,25 @@ module Hornetseye
       @descriptor = descriptor
     end
 
+    # Display descriptor of this object
+    #
+    # @return [String] Returns the descriptor of this object.
     def inspect
       @descriptor
     end
 
+    # Get descriptor of this object
+    #
+    # @return [String] Returns the descriptor of this object.
     def to_s
       @descriptor
     end
 
+    # Store new value in this object
+    #
+    # @param [Object] value The new value.
+    #
+    # @return [Object] Returns +value+.
     def store( value )
       @function << "#{@function.indent}#{self} = #{value};\n"
       value
@@ -104,7 +123,7 @@ module Hornetseye
       offset = 0
       typecode.typecodes.collect do |t|
         value = GCCValue.new @function,
-          "*(#{GCCType.new( t ).identifiers.first} *)( #{self} + #{offset} )" # !!!
+          "*(#{GCCType.new( t ).identifier} *)( #{self} + #{offset} )"
         offset += t.storage_size
         value
       end
@@ -113,7 +132,7 @@ module Hornetseye
     def save( value )
       offset = 0
       value.class.typecodes.zip( value.values ).each do |t,v|
-        @function << "#{@function.indent}*(#{GCCType.new( t ).identifiers.first} *)( #{self} + #{offset} ) = #{v};\n" # !!!
+        @function << "#{@function.indent}*(#{GCCType.new( t ).identifier} *)( #{self} + #{offset} ) = #{v};\n"
         offset += t.storage_size
       end
     end
@@ -177,6 +196,7 @@ module Hornetseye
     define_binary_op :>=
     define_unary_method Math, :sqrt
     define_unary_method Math, :log
+    define_unary_method Math, :log10
     define_unary_method Math, :exp
     define_unary_method Math, :cos
     define_unary_method Math, :sin
@@ -187,6 +207,9 @@ module Hornetseye
     define_unary_method Math, :cosh
     define_unary_method Math, :sinh
     define_unary_method Math, :tanh
+    define_unary_method Math, :acosh
+    define_unary_method Math, :asinh
+    define_unary_method Math, :atanh
     define_binary_method Math, :atan2
     define_binary_method Math, :hypot
 

data/lib/multiarray/histogram.rb

@@ -0,0 +1,82 @@
+# 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/>.
+
+module Hornetseye
+
+  class Histogram < Node
+
+    class << self
+
+      def finalised?
+        false
+      end
+
+    end
+
+    def initialize( dest, source )
+      @dest, @source = dest, source
+    end
+
+    def descriptor( hash )
+      "Histogram(#{@dest.descriptor( hash )},#{@source.descriptor( hash )})"
+    end
+
+    def array_type
+      @dest.array_type
+    end
+
+    def demand
+      if variables.empty?
+        if @source.dimension > 1
+          @source.shape.last.times do |i|
+            source = @source.element INT.new( i )
+            Histogram.new( @dest, source ).demand
+          end
+        else
+          dest = @dest
+          ( @dest.dimension - 1 ).downto( 0 ) do |i|
+            dest = dest.element @source.element( INT.new( i ) ).demand
+          end
+          dest.store dest + 1
+        end
+        @dest
+      else
+        super
+      end
+    end
+
+    def subst( hash )
+      self.class.new @dest.subst( hash ), @source.subst( hash )
+    end
+
+    def variables
+      @dest.variables + @source.variables
+    end
+
+    def strip
+      vars1, values1, term1 = @dest.strip
+      vars2, values2, term2 = @source.strip
+      return vars1 + vars2, values1 + values2, self.class.new( term1, term2 )
+    end
+
+    def compilable?
+      @dest.compilable? and @source.compilable?
+    end
+
+  end
+
+end
+

data/lib/multiarray/index.rb

@@ -26,6 +26,10 @@ module Hornetseye
       # @return [Object] Size of range for this index.
       attr_accessor :size
 
+      # Display information about this class
+      #
+      # @return [String] Returns string with information about this class (e.g.
+      #         "INDEX(INT(5))").
       def inspect
         "INDEX(#{size.inspect})"
       end
@@ -41,6 +45,11 @@ module Hornetseye
         "INDEX(#{size.descriptor( hash )})"
       end
 
+      # Get type of result of delayed operation
+      #
+      # @return [Class] Type of result.
+      #
+      # @private
       def array_type
         INT
       end
@@ -63,10 +72,24 @@ module Hornetseye
         end
       end
 
+      # Substitute variables
+      #
+      # Substitute the variables with the values given in the hash.
+      #
+      # @param [Hash] hash Substitutions to apply.
+      #
+      # @return [Class] Class with substitutions applied.
+      #
+      # @private
       def subst( hash )
         Hornetseye::INDEX size.subst( hash )
       end
 
+      # Get variables contained in this class
+      #
+      # @return [Set] Returns set of variables.
+      #
+      # @private
       def variables
         size.variables
       end

data/lib/multiarray/inject.rb

@@ -21,6 +21,11 @@ module Hornetseye
 
     class << self
 
+      # Check whether objects of this class are finalised computations
+      #
+      # @return [Boolean] Returns +false+.
+      #
+      # @private
       def finalised?
         false
       end
@@ -48,6 +53,11 @@ module Hornetseye
          "#{@index.descriptor( hash )},#{@block.descriptor( hash )})"
     end
 
+    # Get type of result of delayed operation
+    #
+    # @return [Class] Type of result.
+    #
+    # @private
     def array_type
       @value.to_type( @block.typecode ).array_type
     end
@@ -79,6 +89,8 @@ module Hornetseye
     # @param [Integer,Node] i Index of desired element.
     #
     # @return [Node,Object] Element of injection.
+    #
+    # @private
     def element( i )
       Inject.new @value.element( i ), @index, @initial, @block, @var1, @var2
     end
@@ -135,7 +147,7 @@ module Hornetseye
 
     # Check whether this term is compilable
     #
-    # @return [FalseClass,TrueClass] Returns whether this term is compilable.
+    # @return [Boolean] Returns whether this term is compilable.
     #
     # @private
     def compilable?

data/lib/multiarray/int.rb

@@ -29,7 +29,7 @@ module Hornetseye
 
       # Boolean indicating whether this is a signed integer or not
       #
-      # @return [FalseClass,TrueClass] Boolean indicating whether this is a
+      # @return [Boolean] Boolean indicating whether this is a
       # signed integer or not.
       attr_accessor :signed
 
@@ -53,17 +53,29 @@ module Hornetseye
 
       # Get default value for elements of this type
       #
-      # @return [Object] Returns +false+.
+      # @return [Object] Returns +0+.
       #
       # @private
       def default
         0
       end
 
+      # Get corresponding maximal integer type.
+      #
+      # @return [Class] Returns 32 bit integer or self whichever has more bits.
+      #
+      # @private
       def maxint
         Hornetseye::INT [ 32, bits ].max, signed
       end
 
+      # Compute balanced type for binary operation
+      #
+      # @param [Class] other Other native datatype to coerce with.
+      #
+      # @return [Class] Result of coercion.
+      #
+      # @private
       def coercion( other )
         if other < INT_
           Hornetseye::INT [ bits, other.bits ].max, ( signed or other.signed )
@@ -72,6 +84,13 @@ module Hornetseye
         end
       end
 
+      # Type coercion for native elements
+      #
+      # @param [Class] other Other type to coerce with.
+      #
+      # @return [Array<Class>] Result of coercion.
+      #
+      # @private
       def coerce( other )
         if other < INT_
           return other, self
@@ -98,7 +117,8 @@ module Hornetseye
 
       # Get string with information about this class
       #
-      # @return [String] Returns string with information about this class.
+      # @return [String] Returns string with information about this class (e.g.
+      #         "BYTE").
       def inspect
         unless bits.nil? or signed.nil?
           retval = { [  8, true  ] => 'BYTE',
@@ -130,20 +150,32 @@ module Hornetseye
         end
       end
 
-      # Comparison operator
+      # Test equality of classes
       #
-      # @param [Object] other Other object to compare with.
+      # @param [Object] other Object to compare with.
       #
-      # @return [FalseClass,TrueClass] Result of comparison.
+      # @return [Boolean] Boolean indicating whether classes are equal.
       def ==( other )
         other.is_a? Class and other < INT_ and
           bits == other.bits and signed == other.signed
       end
 
+      # Compute hash value for this class.
+      #
+      # @return [Fixnum] Hash value
+      #
+      # @private
       def hash
         [ :INT_, bits, signed ].hash
       end
 
+      # Equality for hash operations
+      #
+      # @param [Object] other Object to compare with.
+      #
+      # @return [Boolean] Returns +true+ if objects are equal.
+      #
+      # @private
       def eql?( other )
         self == other
       end
@@ -169,8 +201,8 @@ module Hornetseye
 
       # Method for matching elements of type INT_
       #
-      # 'param [Array<Object>] *values Values to find matching native element
-      # type for.
+      # @param [Array<Object>] *values Values to find matching native element
+      #        type for.
       #
       # @return [Class] Native type fitting all values.
       #
@@ -227,12 +259,13 @@ module Hornetseye
   #   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.
+  #   @param [Boolean] 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.
+  #   @return [INT] Wrapped integer value.
   #
   # @see INT_
   # @see INT_.bits
@@ -274,30 +307,93 @@ module Hornetseye
   # 64-bit unsigned integer
   ULONG = INT 64, UNSIGNED
 
+  # Shortcut for constructor
+  #
+  # The method calls +BYTE.new+.
+  #
+  # @param [Integer] value Integer value.
+  #
+  # @return [BYTE] The wrapped integer value.
+  #
+  # @private
   def BYTE( value )
     BYTE.new value
   end
 
+  # Shortcut for constructor
+  #
+  # The method calls +UBYTE.new+.
+  #
+  # @param [Integer] value Integer value.
+  #
+  # @return [UBYTE] The wrapped integer value.
+  #
+  # @private
   def UBYTE( value )
     UBYTE.new value
   end
 
+  # Shortcut for constructor
+  #
+  # The method calls +SINT.new+.
+  #
+  # @param [Integer] value Integer value.
+  #
+  # @return [SINT] The wrapped integer value.
+  #
+  # @private
   def SINT( value )
     SINT.new value
   end
 
+  # Shortcut for constructor
+  #
+  # The method calls +USINT.new+.
+  #
+  # @param [Integer] value Integer value.
+  #
+  # @return [USINT] The wrapped integer value.
+  #
+  # @private
   def USINT( value )
     USINT.new value
   end
 
+  # Shortcut for constructor
+  #
+  # The method calls +UINT.new+.
+  #
+  # @param [Integer] value Integer value.
+  #
+  # @return [UINT] The wrapped integer value.
+  #
+  # @private
   def UINT( value )
     UINT.new value
   end
 
+  # Shortcut for constructor
+  #
+  # The method calls +LONG.new+.
+  #
+  # @param [Integer] value Integer value.
+  #
+  # @return [LONG] The wrapped integer value.
+  #
+  # @private
   def LONG( value )
     LONG.new value
   end
 
+  # Shortcut for constructor
+  #
+  # The method calls +ULONG.new+.
+  #
+  # @param [Integer] value Integer value.
+  #
+  # @return [ULONG] The wrapped integer value.
+  #
+  # @private
   def ULONG( value )
     ULONG.new value
   end

data/lib/multiarray/integral.rb

@@ -0,0 +1,82 @@
+# 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/>.
+
+module Hornetseye
+
+  class Integral < Node
+
+    class << self
+
+      def finalised?
+        false
+      end
+
+    end
+
+    def initialize( dest, source )
+      @dest, @source = dest, source
+    end
+
+    def descriptor( hash )
+      "Integral(#{@dest.descriptor( hash )},#{@source.descriptor( hash )})"
+    end
+
+    def array_type
+      @dest.array_type
+    end
+
+    def demand
+      if variables.empty?
+        if @source.dimension > 0
+          self.class.new( @dest.element( INT.new( 0 ) ),
+                          @source.element( INT.new( 0 ) ) ).demand
+          INT.new( 1 ).upto INT.new( @source.shape.last ) - 1 do |i|
+            dest = @dest.element INT.new( i )
+            source = @source.element INT.new( i )
+            self.class.new( dest, source ).demand
+            Store.new( dest, dest + @dest.element( INT.new( i ) - 1 ) ).demand
+          end
+        else
+          Store.new( @dest, @source ).demand
+        end
+        @dest
+      else
+        super
+      end
+    end
+
+    def subst( hash )
+      self.class.new @dest.subst( hash ), @source.subst( hash )
+    end
+
+    def variables
+      @dest.variables + @source.variables
+    end
+
+    def strip
+      vars1, values1, term1 = @dest.strip
+      vars2, values2, term2 = @source.strip
+      return vars1 + vars2, values1 + values2, self.class.new( term1, term2 )
+    end
+
+    def compilable?
+      @dest.compilable? and @source.compilable?
+    end
+
+  end
+
+end
+

data/lib/multiarray/lambda.rb

@@ -24,6 +24,10 @@ module Hornetseye
       @term = term
     end
 
+    def memory
+      @term.memory
+    end
+
     # Get unique descriptor of this object
     #
     # @param [Hash] hash Labels for any variables.
@@ -36,10 +40,20 @@ module Hornetseye
       "Lambda(#{@index.descriptor( hash )},#{@term.descriptor( hash )})"
     end
 
+    # Get type of result of delayed operation
+    #
+    # @return [Class] Type of result.
+    #
+    # @private
     def array_type
       Hornetseye::Sequence @term.array_type, @index.size.get
     end
 
+    # Get variables contained in this term
+    #
+    # @return [Set] Returns list of variables.
+    #
+    # @private
     def variables
       @term.variables - @index.variables + @index.meta.variables
     end
@@ -59,19 +73,20 @@ module Hornetseye
       return vars + meta_vars, values + meta_values, Lambda.new( var, term )
     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 )
       subst_var = @index.subst hash
       Lambda.new subst_var, @term.subst( @index => subst_var ).subst( hash )
     end
 
-    def store( value )
-      shape.last.times do |i|
-        node = value.dimension == 0 ? value : value.element( INT.new( i ) )
-        element( INT.new( i ) ).store node
-      end
-      value
-    end
-
     # Lookup element of an array
     #
     # @param [Node] value Index of element.
@@ -88,16 +103,27 @@ module Hornetseye
       end
     end
 
+    # Skip elements of an array
+    #
+    # @param [Variable] index Variable identifying index of array.
+    # @param [Node] start Wrapped integer with number of elements to skip.
+    #
+    # @return [Node] Return lambda expression with elements skipped.
+    #
+    # @private
     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.
+    #
+    # @private
     def element( i )
       unless i.is_a? Node
         unless ( 0 ... shape.last ).member? i
@@ -109,6 +135,14 @@ module Hornetseye
       @term.subst @index => i
     end
 
+    # Extract array view with part of array
+    #
+    # @param [Integer,Node] start Number of elements to skip.
+    # @param [Integer,Node] length Size of array view.
+    #
+    # @return [Node] Array view with the specified elements.
+    #
+    # @private
     def slice( start, length )
       unless start.is_a?( Node ) or length.is_a?( Node )
         if start < 0 or start + length > shape.last
@@ -123,14 +157,30 @@ module Hornetseye
                          skip( index, start ) ).unroll
     end
 
+    # Decompose composite elements
+    #
+    # This method decomposes composite elements into array.
+    #
+    # @return [Node] Result of decomposition.
     def decompose
       Lambda.new @index, @term.decompose
     end
 
+    # Check whether this term is compilable
+    #
+    # @return [Boolean] Returns whether this term is compilable.
+    #
+    # @private
     def compilable?
       @term.compilable?
     end
 
+    # Check whether this object is a finalised computation
+    #
+    # @return [Boolean] Returns boolean indicating whether the lambda
+    #         term is finalised or not.
+    #
+    # @private
     def finalised?
       @term.finalised?
     end