multiarray 0.4.1 → 0.5.0

data/lib/multiarray/unary.rb

@@ -0,0 +1,170 @@
+# 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 unary operations on scalars and arrays
+  class Unary_ < Node
+
+    class << self
+
+      # 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
+        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 )
+        operation.to_s
+      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 )
+      "(#{@value.descriptor( hash )}).#{self.class.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
+      @value.send self.class.operation
+    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
+    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 +Unary_+
+  #
+  # @param [Symbol,String] operation Name of operation.
+  # @param [Symbol,String] conversion Name of method for type conversion.
+  #
+  # @return [Class] A class deriving from +Unary_+.
+  #
+  # @see Unary_
+  # @see Unary_.operation
+  # @see Unary_.conversion
+  #
+  # @private
+  def Unary( operation, conversion = :contiguous )
+    retval = Class.new Unary_
+    retval.operation = operation
+    retval.conversion = conversion
+    retval
+  end
+
+  module_function :Unary
+
+end

data/lib/multiarray/variable.rb

@@ -0,0 +1,120 @@
+# 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 Variable < Node
+
+    # Type information about this variable
+    #
+    # @return [Class] Returns type information about this variable.
+    attr_reader :meta
+
+    def initialize( meta )
+      @meta = meta
+    end
+
+    def inspect
+      "Variable(#{@meta.inspect})"
+    end
+
+    # Get unique descriptor of this object
+    #
+    # @param [Hash] hash Labels for any variables.
+    #
+    # @return [String] Descriptor of this object,
+    #
+    # @private
+    def descriptor( hash )
+      if hash[ self ]
+        "Variable#{hash[ self ]}(#{@meta.descriptor( hash )})"
+      else
+        "Variable(#{@meta.descriptor( hash )})"
+      end
+    end
+
+    def size
+      @meta.size
+    end
+
+    def size=( value )
+      @meta.size = value
+    end
+
+    def array_type
+      @meta.array_type
+    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
+      meta_vars, meta_values, meta_term = @meta.strip
+      if meta_vars.empty?
+        return [], [], self
+      else
+        return meta_vars, meta_values, Variable.new( meta_term )
+      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 )
+      if hash[ self ]
+        hash[ self ]
+      elsif not @meta.variables.empty? and hash[ @meta.variables.to_a.first ]
+        Variable.new @meta.subst( hash )
+      else
+        self
+      end
+    end
+
+    # Get variables contained in this object
+    #
+    # @return [Set] Returns +Set[ self ]+.
+    #
+    # @private
+    def variables
+      Set[ self ]
+    end
+
+    # Lookup element of an array
+    #
+    # @param [Node] value Index of element.
+    # @param [Node] stride Stride for iterating over elements.
+    #
+    # @private
+    def lookup( value, stride )
+      Lookup.new self, value, stride
+    end
+
+  end
+
+end

data/test/tc_bool.rb

@@ -0,0 +1,117 @@
+# 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_Bool < Test::Unit::TestCase
+
+  B = Hornetseye::BOOL
+
+  def setup
+  end
+
+  def teardown
+  end
+
+  def test_bool_inspect
+    assert_equal 'BOOL', B.inspect
+  end
+
+  def test_bool_to_s
+    assert_equal 'BOOL', B.to_s
+  end
+
+  def test_bool_default
+    assert_equal false, B.new[]
+  end
+
+  def test_bool_typecode
+    assert_equal B, B.typecode
+  end
+
+  def test_bool_dimension
+    assert_equal 0, B.dimension
+  end
+
+  def test_bool_shape
+    assert_equal [], B.shape
+  end
+
+  def test_inspect
+    assert_equal 'BOOL(true)', B.new( true ).inspect
+  end
+
+  def test_marshal
+    assert_equal B.new( true ), Marshal.load( Marshal.dump( B.new( true ) ) )
+  end
+
+  def test_typecode
+    assert_equal B, B.new.typecode
+  end
+
+  def test_dimension
+    assert_equal 0, B.new.dimension
+  end
+
+  def test_shape
+    assert_equal [], B.new.shape
+  end
+
+  def test_at_assign
+    b = B.new 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 )
+  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 }[]
+  end
+
+  def test_not
+    assert_equal B.new( true ), B.new( false ).not
+    assert_equal B.new( false ), B.new( 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 ) )
+  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 ) )
+  end
+
+end

data/test/tc_int.rb

@@ -1,3 +1,19 @@
+# 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'
@@ -7,33 +23,24 @@ Kernel::require 'multiarray'
 
 class TC_Int < Test::Unit::TestCase
 
-  U8  = Hornetseye::UBYTE
-  S8  = Hornetseye::BYTE
+  I = Hornetseye::INT
+  U8 = Hornetseye::UBYTE
+  S8 = Hornetseye::BYTE
   U16 = Hornetseye::USINT
   S16 = Hornetseye::SINT
   U32 = Hornetseye::UINT
   S32 = Hornetseye::INT
-  U64 = Hornetseye::ULONG
-  S64 = Hornetseye::LONG
 
-  T = [ U8, S8, U16, S16, U32, S32 ]
-  INSPECT = {
-    U8 => 'UBYTE', S8 => 'BYTE',
-    U16 => 'USINT', S16 => 'SINT',
-    U32 => 'UINT', S32 => 'INT'
-  }
-  SIGNED = {
-    U8 => false, S8 => true,
-    U16 => false, S16 => true,
-    U32 => false, S32 => true
-  }
+  def UI( bits )
+    Hornetseye::INT Hornetseye::UNSIGNED, bits
+  end
 
-  def lazy( &action )
-    Hornetseye::lazy &action
+  def SI( bits )
+    Hornetseye::INT Hornetseye::SIGNED, bits
   end
 
-  def eager( &action )
-    Hornetseye::eager &action
+  def sum( *args, &action )
+    Hornetseye::sum *args, &action
   end
 
   def setup
@@ -42,97 +49,127 @@ class TC_Int < Test::Unit::TestCase
   def teardown
   end
 
+  def test_int_inspect
+    assert_equal 'UBYTE', U8.inspect
+    assert_equal 'BYTE', S8.inspect
+    assert_equal 'USINT', U16.inspect
+    assert_equal 'SINT', S16.inspect
+    assert_equal 'UINT', U32.inspect
+    assert_equal 'INT', S32.inspect
+  end
+
+  def test_int_to_s
+    assert_equal 'UBYTE', U8.to_s
+    assert_equal 'BYTE', S8.to_s
+    assert_equal 'USINT', U16.to_s
+    assert_equal 'SINT', S16.to_s
+    assert_equal 'UINT', U32.to_s
+    assert_equal 'INT', S32.to_s
+  end
+
   def test_int_default
-    T.each { |t| assert_equal 0, t.new[] }
+    assert_equal 0, I.new[]
   end
 
+  def test_int_typecode
+    assert_equal I, I.typecode
+  end
 
-  def test_int_inspect
-    T.each { |t| assert_equal INSPECT[ t ], t.inspect }
+  def test_int_dimension
+    assert_equal 0, I.dimension
   end
 
-  def test_int_to_s
-    T.each { |t| assert_equal INSPECT[ t ], t.to_s }
+  def test_int_shape
+    assert_equal [], I.shape
   end
 
   def test_inspect
-    T.each { |t| assert_equal "#{t}(42)", t.new( 42 ).inspect }
+    assert_equal 'INT(42)', I.new( 42 ).inspect
   end
 
-  def test_to_s
-    T.each { |t| assert_equal '42', t.new( 42 ).to_s }
+  def test_marshal
+    assert_equal I.new( 42 ), Marshal.load( Marshal.dump( I.new( 42 ) ) )
   end
 
-  def test_marshal
-    T.each do |t|
-      assert_equal t.new( 42 ),
-                   Marshal.load( Marshal.dump( t.new( 42 ) ) )
-    end
+  def test_typecode
+    assert_equal I, I.new.typecode
+  end
+
+  def test_dimension
+    assert_equal 0, I.new.dimension
+  end
+
+  def test_shape
+    assert_equal [], I.new.shape
   end
 
   def test_at_assign
-    T.each do |t|
-      i = t.new 3
-      assert_equal 3, i[]
-      assert_equal 42, i[] = 42
-      assert_equal 42, i[]
-    end
+    i = I.new 42
+    assert_equal 42, i[]
+    assert_equal 3, i[] = 3
+    assert_equal 3, i[]
   end
 
   def test_equal
-    T.each do |t1|
-      T.each do |t2|
-        assert_not_equal t1.new( 3 ), t2.new( 4 )
-        assert_equal t1 == t2, t1.new( 3 ) == t2.new( 3 )
-      end
-    end
+    assert_not_equal I.new( 3 ), I.new( 4 )
+    assert_equal I.new( 3 ), I.new( 3 )
+  end
+
+  def test_inject
+    assert_equal 2, I.new( 2 ).inject { |a,b| a + b }[]
+    assert_equal 3, I.new( 2 ).inject( 1 ) { |a,b| a + b }[]
+  end
+
+  def test_not
+    assert !I.new( 0 ).not[]
+    assert !I.new( 3 ).not[]
+  end
+
+  def test_sum
+    assert_equal 3, sum { || 3 }
+  end
+
+  def test_zero
+    assert I.new( 0 ).zero?[]
+    assert !I.new( 3 ).zero?[]
+  end
+
+  def test_nonzero
+    assert !I.new( 0 ).nonzero?[]
+    assert I.new( 3 ).nonzero?[]
+  end
+
+  def test_bitwise_not
+    assert_equal I.new( -3 ), ~I.new( 2 )
+  end
+
+  def test_bitwise_and
+    assert_equal I.new( 2 ), I.new( 3 ) & I.new( 6 )
+  end
+
+  def test_bitwise_or
+    assert_equal I.new( 7 ), I.new( 3 ) | I.new( 6 )
+  end
+
+  def test_bitwise_xor
+    assert_equal I.new( 1 ), I.new( 3 ) ^ I.new( 2 )
+  end
+
+  def test_shl
+    assert_equal I.new( 4 ), I.new( 2 ) << I.new( 1 )
+  end
+
+  def test_shr
+    assert_equal I.new( 2 ), I.new( 4 ) >> I.new( 1 )
   end
 
   def test_negate
-    T.select { |t| SIGNED[ t ] }.each do |t|
-      assert_equal t.new( -5 ), -t.new( 5 )
-    end
+    assert_equal I.new( -5 ), -I.new( 5 )
   end
 
   def test_plus
-    T.each do |t1|
-      T.each do |t2|
-        assert_equal 5, ( t1.new( 3 ) + t2.new( 2 ) )[]
-      end
-    end
-  end
-
-  def test_lazy_unary
-    T.select { |t| SIGNED[ t ] }.each do |t|
-      i = lazy { -t.new( 3 ) }
-      assert_not_equal t.new( -3 ), i
-      assert_equal "#{t}(<delayed>)", i.inspect
-      assert_equal t.new( -3 ), i.force
-      i = lazy { --t.new( 3 ) }
-      assert_equal "#{t}(<delayed>)", i.inspect
-      assert_equal t.new( 3 ), i.force
-      i = -lazy { -t.new( 3 ) }
-      assert_equal t.new( 3 ), i
-      i = lazy { -lazy { -t.new( 3 ) } }
-      assert_equal "#{t}(<delayed>)", i.inspect
-      assert_equal t.new( 3 ), i.force
-      i = eager { lazy { -t.new( 3 ) } }
-      assert_equal "#{t}(<delayed>)", i.inspect
-      i = lazy { eager { -lazy { -t.new( 3 ) } } }
-      assert_equal t.new( 3 ), i
-    end
-  end
-
-  def test_lazy_binary
-    a = U16.new 3
-    b = S8.new -5
-    i = lazy { a + b }
-    assert_not_equal a + b, i
-    assert_equal 'SINT(<delayed>)', i.inspect
-    assert_equal S16.new( -2 ), i.force
-    assert_equal S32.new( -1 ), i + S32.new( 1 )
-    assert_equal S32.new( -1 ), S32.new( 1 ) + i
+    assert_equal I.new( 3 + 5 ), I.new( 3 ) + I.new( 5 )
   end
 
-
 end
+