multiarray 0.4.1 → 0.5.0

data/test/tc_sequence.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,37 +23,17 @@ Kernel::require 'multiarray'
 
 class TC_Sequence < Test::Unit::TestCase
 
-  O   = Hornetseye::OBJECT
-  U8  = Hornetseye::UBYTE
-  S8  = Hornetseye::BYTE
-  U16 = Hornetseye::USINT
-  S16 = Hornetseye::SINT
-  U32 = Hornetseye::UINT
-  S32 = Hornetseye::INT
-  U64 = Hornetseye::ULONG
-  S64 = Hornetseye::LONG
-  S   = Hornetseye::Sequence
-
-  T = [ O, U8, S8, U16, S16, U32, S32 ]
-  INSPECT = {
-    O => 'OBJECT',
-    U8 => 'UBYTE', S8 => 'BYTE',
-    U16 => 'USINT', S16 => 'SINT',
-    U32 => 'UINT', S32 => 'INT'
-  }
-  SIGNED = {
-    O => true,
-    U8 => false, S8 => true,
-    U16 => false, S16 => true,
-    U32 => false, S32 => true
-  }
-
-  def lazy( &action )
-    Hornetseye::lazy &action
-  end
-
-  def eager( &action )
-    Hornetseye::eager &action
+  O = Hornetseye::OBJECT
+  B = Hornetseye::BOOL
+  I = Hornetseye::INT
+  S = Hornetseye::Sequence
+
+  def S( *args )
+    Hornetseye::Sequence *args
+  end
+  
+  def sum( *args, &action )
+    Hornetseye::sum *args, &action
   end
 
   def setup
@@ -46,41 +42,58 @@ class TC_Sequence < Test::Unit::TestCase
   def teardown
   end
 
-  def S( *args )
-    Hornetseye::Sequence *args
+  def test_sequence_inspect
+    assert_equal 'Sequence(OBJECT,3)', S( O, 3 ).inspect
+  end
+  
+  def test_sequence_to_s
+    assert_equal 'Sequence(OBJECT,3)', S( O, 3 ).to_s
   end
 
-  def test_default
-    T.each do |t|
-      s = S( t, 3 ).new
-      s[] = t.new[]
-      assert_equal [ t.new[] ] * 3, s.to_a
-    end
+  def test_sequence_default
+    assert_equal [ O.default ] * 3, S( O, 3 ).default.to_a
   end
 
-  def test_sequence_inspect
-    T.each do |t|
-      assert_equal "Sequence.#{t.inspect.downcase}(3)", S( t, 3 ).inspect
-    end
+  def test_sequence_indgen
+    assert_equal [ 0, 1, 2 ], S( O, 3 ).indgen.to_a
+    assert_equal [ 1, 2, 3 ], S( O, 3 ).indgen( 1 ).to_a
+    assert_equal [ 0, 2, 4 ], S( O, 3 ).indgen( 0, 2 ).to_a
+    assert_equal [ 1, 3, 5 ], S( O, 3 ).indgen( 1, 2 ).to_a
   end
 
-  def test_sequence_to_s
-    T.each do |t|
-      assert_equal "Sequence.#{t.to_s.downcase}(3)", S( t, 3 ).to_s
-    end
+  def test_sequence_at
+    assert_equal [ 1, 2, 3 ], S[ 1, 2, 3 ].to_a
+    assert_equal O, S[ :a ].typecode
+    assert_equal B, S[ false, true ].typecode
+    assert_equal I, S[ -2 ** 31, 2 ** 31 - 1 ].typecode
+  end
+
+  def test_sequence_typecode
+    assert_equal O, S( O, 3 ).typecode
   end
 
-  def test_sequence_assign
-    assert_equal [ :a, :b, :c ], S[ :a, :b, :c ].to_a
-    assert_equal [ :a, :b, [ :c ] ], S[ :a, :b, [ :c ] ].to_a
+  def test_sequence_dimension
+    assert_equal 1, S( O, 3 ).dimension
+  end
+
+  def test_sequence_shape
+    assert_equal [ 3 ], S( O, 3 ).shape
   end
 
   def test_inspect
-    assert_equal "Sequence.object(3):\n[ :a, :b, :c ]", S[ :a, :b, :c ].inspect
+    assert_equal "Sequence(OBJECT,3):\n[ :a, 2, 3 ]", S[ :a, 2, 3 ].inspect
   end
 
-  def test_to_s
-    # !!!
+  def test_typecode
+    assert_equal O, S.new( O, 3 ).typecode
+  end
+
+  def test_dimension
+    assert_equal 1, S[ 1, 2, 3 ].dimension
+  end
+
+  def test_shape
+    assert_equal [ 3 ], S[ 1, 2, 3 ].shape
   end
 
   def test_at_assign
@@ -88,48 +101,129 @@ class TC_Sequence < Test::Unit::TestCase
     for i in 0 ... 3
       assert_equal i + 1, s[ i ] = i + 1
     end
-    assert_equal [ 1, 2, 3 ], s[].to_a
     for i in 0 ... 3
       assert_equal i + 1, s[ i ]
     end
   end
 
   def test_equal
-    # !!!
+    assert_equal S[ 2, 3, 5 ], S[ 2, 3, 5 ]
+    assert_not_equal S[ 2, 3, 5 ], S[ 2, 3, 7 ]
+    #assert_not_equal S[ 2, 3, 5 ], S[ 2, 3 ] # !!!
+    #assert_not_equal S[ 2, 3, 5 ], S[ 2, 3, 5, 7 ]
+    assert_not_equal S[ 2, 2, 2 ], 2
+  end
+
+  def test_inject
+    assert_equal 6, S[ 1, 2, 3 ].inject { |a,b| a + b }
+    assert_equal 10, S[ 1, 2, 3 ].inject( 4 ) { |a,b| a + b }
+  end
+
+  def test_sum
+    assert_equal 6, sum { |i| S[ 1, 2, 3 ][ i ] }
+    assert_equal [ 1, 2, 3 ], sum { || S[ 1, 2, 3 ] }.to_a
+  end
+
+  def dont_test_convolve
+    assert_equal S[ 2, 3, 0, 0, 0 ],
+                 S[ 1, 0, 0, 0, 0 ].convolve( S[ 1, 2, 3 ] )
+    assert_equal S[ 1, 2, 3, 0, 0 ],
+                 S[ 0, 1, 0, 0, 0 ].convolve( S[ 1, 2, 3 ] )
+    assert_equal S[ 0, 1, 2, 3, 0 ],
+                 S[ 0, 0, 1, 0, 0 ].convolve( S[ 1, 2, 3 ] )
+    assert_equal S[ 0, 0, 1, 2, 3 ],
+                 S[ 0, 0, 0, 1, 0 ].convolve( S[ 1, 2, 3 ] )
+    assert_equal S[ 0, 0, 0, 1, 2 ],
+                 S[ 0, 0, 0, 0, 1 ].convolve( S[ 1, 2, 3 ] )
+    assert_equal S[ 1, 2, 3, 0 ],
+                 S[ 0, 1, 0, 0 ].convolve( S[ 1, 2, 3 ] )
+  end
+
+  def test_zero
+    assert_equal S[ false, true, false ], S[ -1, 0, 1 ].zero?
+  end
+
+  def test_nonzero
+    assert_equal S[ true, false, true ], S[ -1, 0, 1 ].nonzero?
+  end
+
+  def test_not
+    assert_equal [ true, false ], S[ false, true ].not.to_a
+    assert_equal [ true, false, false ], S[ 0, 1, 2 ].not.to_a
+  end
+
+  def test_and
+    assert_equal [ false, false ], S[ false, true ].and( false ).to_a
+    assert_equal [ false, false ], false.and( S[ false, true ] ).to_a
+    assert_equal [ false, true ], S[ false, true ].and( true ).to_a
+    assert_equal [ false, true ], true.and( S[ false, true ] ).to_a
+    assert_equal [ false, false, false, true ], S[ false, true, false, true ].
+                 and( S[ false, false, true, true ] ).to_a
+  end
+
+  def test_or
+    assert_equal [ false, true ], S[ false, true ].or( false ).to_a
+    assert_equal [ false, true ], false.or( S[ false, true ] ).to_a
+    assert_equal [ true, true ], S[ false, true ].or( true ).to_a
+    assert_equal [ true, true ], true.or( S[ false, true ] ).to_a
+    assert_equal [ false, true, true, true ], S[ false, true, false, true ].
+                 or( S[ false, false, true, true ] ).to_a
+  end
+
+  def test_bitwise_not
+    assert_equal [ 255, 254, 253 ], ( ~S[ 0, 1, 2 ] ).to_a
+    assert_equal [ 0, -1, -2, -3 ], ( ~S[ -1, 0, 1, 2 ] ).to_a
+  end
+
+  def test_bitwise_and
+    assert_equal [ 0, 1, 0 ], ( S[ 0, 1, 2 ] & 1 ).to_a
+    assert_equal [ 0, 1, 0 ], ( 1 & S[ 0, 1, 2 ] ).to_a
+    assert_equal [ 0, 1, 0, 2 ], ( S[ 0, 1, 2, 3 ] & S[ 4, 3, 1, 2 ] ).to_a
+  end
+
+  def test_bitwise_or
+    assert_equal [ 1, 1, 3 ], ( S[ 0, 1, 2 ] | 1 ).to_a
+    assert_equal [ 1, 1, 3 ], ( 1 | S[ 0, 1, 2 ] ).to_a
+    assert_equal [ 4, 3, 3, 3 ], ( S[ 0, 1, 2, 3 ] | S[ 4, 3, 1, 2 ] ).to_a
+  end
+
+  def test_bitwise_xor
+    assert_equal [ 1, 0, 3 ], ( S[ 0, 1, 2 ] ^ 1 ).to_a
+    assert_equal [ 1, 0, 3 ], ( 1 ^ S[ 0, 1, 2 ] ).to_a
+    assert_equal [ 4, 2, 3, 1 ], ( S[ 0, 1, 2, 3 ] ^ S[ 4, 3, 1, 2 ] ).to_a
+  end
+
+  def test_shl
+    assert_equal [ 2, 4, 6 ], ( S[ 1, 2, 3 ] << 1 ).to_a
+    assert_equal [ 6, 12, 24 ], ( 3 << S[ 1, 2, 3 ] ).to_a
+    assert_equal [ 8, 8, 6 ], ( S[ 1, 2, 3 ] << S[ 3, 2, 1 ] ).to_a
+  end
+
+  def test_shr
+    assert_equal [ 1, 2, 3 ], ( S[ 2, 4, 6 ] >> 1 ).to_a
+    assert_equal [ 12, 6, 3 ], ( 24 >> S[ 1, 2, 3 ] ).to_a
+    assert_equal [ 2, 1, 3 ], ( S[ 16, 4, 6 ] >> S[ 3, 2, 1 ] ).to_a
   end
 
   def test_negate
-    s = S[ 1, 2, 3 ].to_type O
-    assert_equal [ -1, -2, -3 ], ( -s ).to_a
+    assert_equal S[ -1, 2, -3 ], -S[ 1, -2, 3 ]
   end
 
   def test_plus
-    s = S[ 1, 2, 3 ].to_type O
-    assert_equal [ 2, 4, 6 ], ( s + s ).to_a
-    assert_equal [ 2, 3, 4 ], ( s + O.new( 1 ) ).to_a
-    assert_equal [ 2, 3, 4 ], ( O.new( 1 ) + s ).to_a
-  end
-
-  def test_lazy_unary
-    s = S[ 1, 2, 3 ].to_type O
-    u = lazy { -s }
-    assert_equal 'Sequence.object(3):<delayed>', u.inspect
-    assert_equal [ -1, -2, -3 ], u.force.to_a
-    u = lazy { --s }
-    assert_equal 'Sequence.object(3):<delayed>', u.inspect
-    assert_equal [ 1, 2, 3 ], u.force.to_a
-    u = -lazy { -s }
-    assert_equal "Sequence.object(3):\n[ 1, 2, 3 ]", u.inspect
-    assert_equal [ 1, 2, 3 ], u.to_a
-    u = lazy { -lazy { -s } }
-    assert_equal 'Sequence.object(3):<delayed>', u.inspect
-    assert_equal [ 1, 2, 3 ], u.force.to_a
-    u = eager { lazy { -s } }
-    assert_equal 'Sequence.object(3):<delayed>', u.inspect
-    assert_equal [ -1, -2, -3 ], u.force.to_a
-    u = lazy { eager { -lazy { -s } } }
-    assert_equal "Sequence.object(3):\n[ 1, 2, 3 ]", u.inspect
-    assert_equal [ 1, 2, 3 ], u.to_a
+    assert_equal S[ 'ax', 'bx' ], S[ 'a', 'b' ] + 'x'
+    assert_equal S[ 'xa', 'xb' ], O.new( 'x' ) + S[ 'a', 'b' ]
+    assert_equal S[ 'ac', 'bd' ], S[ 'a', 'b' ] + S[ 'c', 'd' ]
+    assert_equal S[ 2, 3, 5 ], S[ 1, 2, 4 ] + 1
+    assert_equal S[ 2, 3, 5 ], 1 + S[ 1, 2, 4 ]
+    assert_equal S[ 2, 3, 5 ], S[ 1, 2, 3 ] + S[ 1, 1, 2 ]
+  end
+
+  def test_indgen
+    assert_equal [ 0, 1, 2 ], S( I, 3 ).indgen.to_a
+    assert_equal [ 1, 2, 3 ], ( S( I, 3 ).indgen + 1 ).to_a
+    assert_equal [ 1, 2, 3 ], S( I, 3 ).indgen( 1 ).to_a
+    assert_equal [ 1, 3, 5 ], ( 2 * S( I, 3 ).indgen + 1 ).to_a
+    assert_equal [ 1, 3, 5 ], S( I, 3 ).indgen( 1, 2 ).to_a
   end
 
 end

data/test/ts_multiarray.rb

@@ -1,4 +1,21 @@
 #!/usr/bin/env ruby
+# 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 'tc_object'
+require 'tc_bool'
+require 'tc_int'
 require 'tc_sequence'
 require 'tc_multiarray'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: multiarray
 version: !ruby/object:Gem::Version 
-  version: 0.4.1
+  version: 0.5.0
 platform: ruby
 authors: 
 - Jan Wedekind
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-01-28 00:00:00 +00:00
+date: 2010-06-18 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -20,7 +20,17 @@ dependencies:
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        version: "0.2"
+        version: "1.0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: rake
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
     version: 
 description: This Ruby-extension defines Hornetseye::MultiArray and other native datatypes. Hornetseye::MultiArray provides multi-dimensional Ruby arrays with elements of same type. The extension is designed to be mostly compatible with Masahiro Tanaka's NArray. However it allows the definition of custom element types and operations on them. This work was also inspired by Ronald Garcia's boost::multi_array and by Todd Veldhuizen's Blitz++.
 email: jan@wedesoft.de
@@ -32,28 +42,41 @@ extra_rdoc_files: []
 
 files: 
 - Rakefile
-- README
+- README.md
 - COPYING
 - TODO
 - .document
-- lib/multiarray.rb
-- lib/multiarray/sequence_.rb
+- lib/multiarray/object.rb
+- lib/multiarray/operations.rb
+- lib/multiarray/variable.rb
+- lib/multiarray/gcctype.rb
+- lib/multiarray/bool.rb
+- lib/multiarray/element.rb
+- lib/multiarray/unary.rb
+- lib/multiarray/gcccache.rb
+- lib/multiarray/int.rb
+- lib/multiarray/gccfunction.rb
+- lib/multiarray/diagonal.rb
+- lib/multiarray/inject.rb
+- lib/multiarray/list.rb
 - lib/multiarray/pointer.rb
-- lib/multiarray/multiarray.rb
-- lib/multiarray/lazy.rb
+- lib/multiarray/lambda.rb
 - lib/multiarray/sequence.rb
-- lib/multiarray/list.rb
+- lib/multiarray/multiarray.rb
+- lib/multiarray/node.rb
 - lib/multiarray/malloc.rb
-- lib/multiarray/int.rb
-- lib/multiarray/pointer_.rb
-- lib/multiarray/type.rb
-- lib/multiarray/object.rb
-- lib/multiarray/int_.rb
+- lib/multiarray/binary.rb
+- lib/multiarray/index.rb
+- lib/multiarray/gcccontext.rb
+- lib/multiarray/lookup.rb
+- lib/multiarray/gccvalue.rb
+- lib/multiarray.rb
 - test/ts_multiarray.rb
+- test/tc_sequence.rb
 - test/tc_multiarray.rb
+- test/tc_bool.rb
 - test/tc_object.rb
 - test/tc_int.rb
-- test/tc_sequence.rb
 has_rdoc: yard
 homepage: http://wedesoft.github.com/multiarray/
 licenses: []
@@ -83,7 +106,8 @@ signing_key:
 specification_version: 3
 summary: Multi-dimensional and uniform Ruby arrays
 test_files: 
+- test/tc_sequence.rb
 - test/tc_multiarray.rb
+- test/tc_bool.rb
 - test/tc_object.rb
 - test/tc_int.rb
-- test/tc_sequence.rb

data/README

@@ -1 +0,0 @@
-This Ruby-extension defines Hornetseye::MultiArray and other native datatypes. Hornetseye::MultiArray provides multi-dimensional Ruby arrays with elements of same type. The extension is designed to be mostly compatible with Masahiro Tanaka's NArray. However it allows the definition of custom element types and operations on them. This work was also inspired by Ronald Garcia's boost::multi_array and by Todd Veldhuizen's Blitz++.

data/lib/multiarray/int_.rb

@@ -1,198 +0,0 @@
-module Hornetseye
-
-  # Abstract class for representing native integers
-  #
-  # @see #INT
-  #
-  # @abstract
-  class INT_ < Type
-
-    class << self
-
-      # Get memory type for storing objects of this type
-      #
-      # @return [Class] Returns +Malloc+.
-      #
-      # @see Malloc
-      #
-      # @private
-      def memory
-        Malloc
-      end
-
-      def import( str )
-        new str.unpack( descriptor ).first
-      end
-
-      # The number of bits of native integers represented by this class
-      #
-      # @return [Integer] Number of bits of native integer.
-      #
-      # @see signed
-      #
-      # @private
-      attr_accessor :bits
-
-      # A boolean indicating whether this is a signed integer or not
-      #
-      # @return [FalseClass,TrueClass] Boolean indicating whether this is a
-      # signed integer.
-      #
-      # @see bits
-      #
-      # @private
-      attr_accessor :signed
-
-      # Get string with information about this type
-      #
-      # @return [String] Information about this integer type.
-      def to_s
-        if bits and 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
-        else
-          super
-        end
-      end
-
-      def descriptor
-        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 descriptor for packing/unpacking #{self}"
-        end
-      end
-
-      # Get string with information about this type
-      #
-      # @return [String] Information about this integer type.
-      def inspect
-        to_s
-      end
-
-      # Default value for Ruby objects
-      #
-      # @return [Integer] Returns +0+.
-      #
-      # @private
-      def default
-        0
-      end
-
-      #def fetch( ptr )
-      #  new ptr.read( storage_size ).unpack( descriptor ).first
-      #end
-
-      def storage_size
-        ( bits + 7 ).div 8
-      end
-
-      def coercion( other )
-        if other < INT_
-          Hornetseye::INT [ bits, other.bits ].max, ( signed or other.signed )
-        else
-          super other
-        end
-      end
-
-      def coerce( other )
-        if other < INT_
-          return other, self
-        else
-          super other
-        end
-      end
-
-      def ==( other )
-        if other.is_a? Class
-          if other < INT_ and bits == other.bits and signed == other.signed
-            true
-          else
-            false
-          end
-        else
-          false
-        end
-      end
-
-      def hash
-        [ :INT_, bits, signed ].hash
-      end
-
-      def eql?( other )
-        self == other
-      end
-      
-    end
-
-    def store( ptr )
-      ptr.write [ @value ].pack( self.class.descriptor )
-      self
-    end
-
-    module RubyMatching
-
-      def fit( *values )
-        if values.all? { |value| value.is_a? Integer }
-          bits = 8
-          ubits = 8
-          signed = false
-          values.each do |value|
-            bits *= 2 until ( -2**(bits-1) ... 2**(bits-1) ).include? value
-            if value < 0
-              signed = true
-            else
-              ubits *= 2 until ( 0 ... 2**ubits ).include? value
-            end
-          end
-          bits = signed ? bits : ubits
-          if bits <= 64
-            Hornetseye::INT bits, signed
-          else
-            super *values
-          end
-        else
-          super *values
-        end
-      end
-
-    end
-
-    Type.extend RubyMatching
-
-  end
-
-end