multiarray 0.5.0 → 0.5.1

data/lib/multiarray/unarymethod.rb

@@ -0,0 +1,185 @@
+# 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 applying a unary method to scalars and arrays
+  class UnaryMethod_ < 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 :conversion
+
+      # 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 unary operation
+    #
+    # @param [Node] value Value to apply operation to.
+    def initialize( value )
+      @value = value
+    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 )}(#{@value.descriptor( hash )})"
+    end
+
+    # Array type of this term
+    #
+    # @return [Class] Resulting array type.
+    #
+    # @private
+    def array_type
+      @value.array_type.send self.class.conversion
+    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 @value.subst( hash )
+    end
+
+    # Get variables contained in this term
+    #
+    # @return [Set] Returns set of variables.
+    #
+    # @private
+    def variables
+      @value.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
+      vars, values, term = @value.strip
+      return vars, values, self.class.new( term )
+    end
+
+    # Reevaluate computation
+    #
+    # @return [Node,Object] Result of computation
+    #
+    # @see #force
+    #
+    # @private
+    def demand
+      self.class.mod.send self.class.operation, @value
+    end
+
+    def skip( index, start )
+      self.class.new( @value.skip( index, start ) ).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 )
+      self.class.new( @value.element( i ) ).demand
+    end
+
+    def slice( start, length )
+      self.class.new( @value.slice( start, length ) ).demand
+    end
+
+    # Check whether this term is compilable
+    #
+    # @return [FalseClass,TrueClass] Returns whether this term is compilable.
+    #
+    # @private
+    def compilable?
+      @value.compilable?
+    end
+
+  end
+
+  # Create a class deriving from +UnaryMethod_+
+  #
+  # @param [Symbol,String] operation Name of operation.
+  # @param [Symbol,String] conversion Name of method for type conversion.
+  #
+  # @return [Class] A class deriving from +UnaryMethod_+.
+  #
+  # @see UnaryMethod_
+  # @see UnaryMethod_.operation
+  # @see UnaryMethod_.conversion
+  #
+  # @private
+  def UnaryMethod( mod, operation, conversion = :contiguous )
+    retval = Class.new UnaryMethod_
+    retval.mod = mod
+    retval.operation = operation
+    retval.conversion = conversion
+    retval
+  end
+
+  module_function :UnaryMethod
+
+end
+

data/lib/multiarray/{unary.rb → unaryop.rb}

@@ -18,7 +18,7 @@
 module Hornetseye
 
   # Class for representing unary operations on scalars and arrays
-  class Unary_ < Node
+  class UnaryOp_ < Node
 
     class << self
 
@@ -47,7 +47,7 @@ module Hornetseye
       #
       # @private
       def descriptor( hash )
-        operation.to_s
+        inspect
       end
 
     end
@@ -126,13 +126,21 @@ module Hornetseye
       @value.send self.class.operation
     end
 
+    def skip( index, start )
+      self.class.new( @value.skip( index, start ) ).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 )
-      @value.element( i ).send self.class.operation
+      self.class.new( @value.element( i ) ).demand
+    end
+
+    def slice( start, length )
+      self.class.new( @value.slice( start, length ) ).demand
     end
 
     # Check whether this term is compilable
@@ -146,25 +154,26 @@ module Hornetseye
 
   end
 
-  # Create a class deriving from +Unary_+
+  # Create a class deriving from +UnaryOp_+
   #
   # @param [Symbol,String] operation Name of operation.
   # @param [Symbol,String] conversion Name of method for type conversion.
   #
-  # @return [Class] A class deriving from +Unary_+.
+  # @return [Class] A class deriving from +UnaryOp_+.
   #
-  # @see Unary_
-  # @see Unary_.operation
-  # @see Unary_.conversion
+  # @see UnaryOp_
+  # @see UnaryOp_.operation
+  # @see UnaryOp_.conversion
   #
   # @private
-  def Unary( operation, conversion = :contiguous )
-    retval = Class.new Unary_
+  def UnaryOp( operation, conversion = :contiguous )
+    retval = Class.new UnaryOp_
     retval.operation = operation
     retval.conversion = conversion
     retval
   end
 
-  module_function :Unary
+  module_function :UnaryOp
 
 end
+

data/lib/multiarray/variable.rb

@@ -115,6 +115,14 @@ module Hornetseye
       Lookup.new self, value, stride
     end
 
+    def skip( index, start )
+      if index == self
+        self + start
+      else
+        self
+      end
+    end
+
   end
 
 end

data/test/tc_bool.rb

@@ -25,6 +25,10 @@ class TC_Bool < Test::Unit::TestCase
 
   B = Hornetseye::BOOL
 
+  def B( *args )
+    Hornetseye::BOOL *args
+  end
+
   def setup
   end
 
@@ -55,12 +59,16 @@ class TC_Bool < Test::Unit::TestCase
     assert_equal [], B.shape
   end
 
+  def test_bool_size
+    assert_equal 1, B.size
+  end
+
   def test_inspect
-    assert_equal 'BOOL(true)', B.new( true ).inspect
+    assert_equal 'BOOL(true)', B( true ).inspect
   end
 
   def test_marshal
-    assert_equal B.new( true ), Marshal.load( Marshal.dump( B.new( true ) ) )
+    assert_equal B( true ), Marshal.load( Marshal.dump( B( true ) ) )
   end
 
   def test_typecode
@@ -75,43 +83,47 @@ class TC_Bool < Test::Unit::TestCase
     assert_equal [], B.new.shape
   end
 
+  def test_size
+    assert_equal 1, B.new.size
+  end
+
   def test_at_assign
-    b = B.new false
+    b = B false
     assert !b[]
     assert b[] = true
     assert b[]
   end
 
   def test_equal
-    assert_equal B.new( false ), B.new( false )
-    assert_not_equal B.new( false ), B.new( true )
-    assert_not_equal B.new( true ), B.new( false )
-    assert_equal B.new( true ), B.new( true )
+    assert_equal B( false ), B( false )
+    assert_not_equal B( false ), B( true )
+    assert_not_equal B( true ), B( false )
+    assert_equal B( true ), B( true )
   end
 
   def test_inject
-    assert B.new( true ).inject { |a,b| a.and b }[]
-    assert !B.new( false ).inject( true ) { |a,b| a.and b }[]
-    assert !B.new( true ).inject( false ) { |a,b| a.and b }[]
+    assert B( true ).inject { |a,b| a.and b }[]
+    assert !B( false ).inject( true ) { |a,b| a.and b }[]
+    assert !B( true ).inject( false ) { |a,b| a.and b }[]
   end
 
   def test_not
-    assert_equal B.new( true ), B.new( false ).not
-    assert_equal B.new( false ), B.new( true ).not
+    assert_equal B( true ), B( false ).not
+    assert_equal B( false ), B( true ).not
   end
 
   def test_and
-    assert_equal B.new( false ), B.new( false ).and( B.new( false ) )
-    assert_equal B.new( false ), B.new( false ).and( B.new( true ) )
-    assert_equal B.new( false ), B.new( true ).and( B.new( false ) )
-    assert_equal B.new( true ), B.new( true ).and( B.new( true ) )
+    assert_equal B( false ), B( false ).and( B( false ) )
+    assert_equal B( false ), B( false ).and( B( true ) )
+    assert_equal B( false ), B( true ).and( B( false ) )
+    assert_equal B( true ), B( true ).and( B( true ) )
   end
 
   def test_or
-    assert_equal B.new( false ), B.new( false ).or( B.new( false ) )
-    assert_equal B.new( true ), B.new( false ).or( B.new( true ) )
-    assert_equal B.new( true ), B.new( true ).or( B.new( false ) )
-    assert_equal B.new( true ), B.new( true ).or( B.new( true ) )
+    assert_equal B( false ), B( false ).or( B( false ) )
+    assert_equal B( true ), B( false ).or( B( true ) )
+    assert_equal B( true ), B( true ).or( B( false ) )
+    assert_equal B( true ), B( true ).or( B( true ) )
   end
 
 end

data/test/tc_float.rb

@@ -0,0 +1,192 @@
+# 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/>.
+
+require 'test/unit'
+begin
+  require 'rubygems'
+rescue LoadError
+end
+Kernel::require 'multiarray'
+
+class TC_Float < Test::Unit::TestCase
+
+  F = Hornetseye::SFLOAT
+  D = Hornetseye::DFLOAT
+
+  def F( *args )
+    Hornetseye::SFLOAT *args
+  end
+
+  def D( *args )
+    Hornetseye::DFLOAT *args
+  end
+
+  def sum( *args, &action )
+    Hornetseye::sum *args, &action
+  end
+
+  def setup
+  end
+
+  def teardown
+  end
+
+  def test_float_inspect
+    assert_equal 'SFLOAT', F.inspect
+    assert_equal 'DFLOAT', D.inspect
+  end
+
+  def test_float_to_s
+    assert_equal 'SFLOAT', F.to_s
+    assert_equal 'DFLOAT', D.to_s
+  end
+
+  def test_float_default
+    assert_equal 0.0, F.new[]
+    assert_equal 0.0, D.new[]
+  end
+
+  def test_float_indgen
+    assert_equal 0, F.indgen
+    assert_equal 1, F.indgen( 1 )
+    assert_equal 1, F.indgen( 1, 2 )
+  end
+
+  def test_float_typecode
+    assert_equal F, F.typecode
+    assert_equal D, D.typecode
+  end
+
+  def test_float_dimension
+    assert_equal 0, F.dimension
+  end
+!
+  def test_float_shape
+    assert_equal [], F.shape
+  end
+
+  def test_float_size
+    assert_equal 1, F.size
+  end
+
+  def test_inspect
+    assert_equal 'DFLOAT(42.0)', D( 42.0 ).inspect
+  end
+
+  def test_marshal
+    assert_equal D( 42.0 ), Marshal.load( Marshal.dump( D( 42.0 ) ) )
+  end
+
+  def test_typecode
+    assert_equal D, D.new.typecode
+  end
+
+  def test_dimension
+    assert_equal 0.0, D.new.dimension
+  end
+
+  def test_shape
+    assert_equal [], D.new.shape
+  end
+
+  def test_size
+    assert_equal 1, D.new.size
+  end
+
+  def test_at_assign
+    d = D 42.0
+    assert_equal 42.0, d[]
+    assert_equal 3.0, d[] = 3
+    assert_equal 3.0, d[]
+  end
+
+  def test_equal
+    assert_not_equal D( 3.0 ), D( 4.0 )
+    assert_equal D( 3.0 ), D( 3.0 )
+  end
+
+if false
+
+  def test_inject
+    assert_equal 2, I( 2 ).inject { |a,b| a + b }[]
+    assert_equal 3, I( 2 ).inject( 1 ) { |a,b| a + b }[]
+  end
+
+  def test_not
+    assert !I( 0 ).not[]
+    assert !I( 3 ).not[]
+  end
+
+  def test_sum
+    assert_equal 3, sum { || 3 }
+  end
+
+  def test_zero
+    assert I( 0 ).zero?[]
+    assert !I( 3 ).zero?[]
+  end
+
+  def test_nonzero
+    assert !I( 0 ).nonzero?[]
+    assert I( 3 ).nonzero?[]
+  end
+
+  def test_bitwise_not
+    assert_equal I( -3 ), ~I( 2 )
+  end
+
+  def test_bitwise_and
+    assert_equal I( 2 ), I( 3 ) & I( 6 )
+  end
+
+  def test_bitwise_or
+    assert_equal I( 7 ), I( 3 ) | I( 6 )
+  end
+
+  def test_bitwise_xor
+    assert_equal I( 1 ), I( 3 ) ^ I( 2 )
+  end
+
+  def test_shl
+    assert_equal I( 4 ), I( 2 ) << I( 1 )
+  end
+
+  def test_shr
+    assert_equal I( 2 ), I( 4 ) >> I( 1 )
+  end
+
+  def test_negate
+    assert_equal I( -5 ), -I( 5 )
+  end
+
+  def test_plus
+    assert_equal I( 3 + 5 ), I( 3 ) + I( 5 )
+  end
+
+  def test_major
+    assert_equal I( 4 ), I( 3 ).major( I( 4 ) )
+    assert_equal I( 5 ), I( 5 ).major( I( 3 ) )
+  end
+
+  def test_minor
+    assert_equal I( 3 ), I( 3 ).minor( I( 4 ) )
+    assert_equal I( 4 ), I( 5 ).minor( I( 4 ) )
+  end
+
+end
+
+end
+