multiarray 0.2.4 → 0.4.0

data/lib/multiarray/type.rb

@@ -7,198 +7,170 @@ module Hornetseye
 
     class << self
 
-      # Allocate +Storage+ object for storing a value
+      # Returns the dereferenced type for pointers
       #
-      # @return [Storage] Object for storing a value of this type.
-      #
-      # @private
-      def alloc
-        storage.alloc bytesize
-      end
-
-      # Create new instance viewing the data of the indicated +Storage+ object
-      #
-      # @return [Type] Object of this class.
-      #
-      # @private
-      def wrap( storage )
-        new nil, :storage => storage
-      end
-
-      # Returns the element type for arrays. Otherwise it returns +self+
+      # Returns the dereferenced type for pointers.
+      # Otherwise it returns +self+.
       #
       # @return [Class] Returns +self+.
-      def typecode
+      def dereference
         self
       end
 
-      # Returns the element type for arrays and composite numbers
+      # Returns the element type for arrays
       #
-      # Otherwise it returns +self+.
+      # Returns +self+ if this is not an array.
       #
       # @return [Class] Returns +self+.
-      #
-      # @private
-      def basetype
+      def typecode
         self
       end
 
-      # Check whether an array is empty or not
-      #
-      # Returns +false+ if this is not an array.
-      #
-      # @return [FalseClass,TrueClass] Returns +false+.
-      def empty?
-        size == 0
-      end
-
-      # Get shape of multi-dimensional array
+      # Dimensions of arrays
       #
       # Returns +[]+ if this is not an array.
       #
-      # @return [Array<Integer>] Returns +[]+.
+      # @return [Array] Returns +[]+.
       def shape
         []
       end
 
-      # Get number of elements of multi-dimensional array
+      # Number of elements
       #
-      # Returns +1+ if this is not an array.
+      # @return [Integer] Number of elements
       #
-      # @return [Integer] Number of elements of array. +1+ if this is not an
-      # array.
+      # @return [Integer] Returns +1+.
       def size
         shape.inject( 1 ) { |a,b| a * b }
       end
 
-    end
+      def ===( other )
+        ( other == self ) or ( other.is_a? self ) or ( other.class == self )
+      end
 
-    # Get +Storage+ object used to store the data of this instance
-    #
-    # @return [Storage]
-    #
-    # @private
-    attr_accessor :storage
+    end
 
-    # Get number of bytes memory required to store the data of an instance
-    #
-    # @return [Integer] Number of bytes.
+    # Create new instance of this type
     #
-    # @private
-    def bytesize
-      self.class.bytesize
+    # @param [Object] value Optional initial value for this instance.
+    def initialize( value = self.class.default )
+      set value
     end
 
-    # Returns the element type for arrays
-    #
-    # Otherwise it returns +self.class+.
+    # Display type and value of this instance
     #
-    # @return [Class] Element type for arrays. Returns +self.class+ if this is
-    # not an array.
-    def typecode
-      self.class.typecode
+    # @return [String] Returns string with information about type and value.
+    def inspect
+      "#{self.class.inspect}(#{@value.inspect})"
     end
 
-    # Returns the element type for arrays and composite numbers
-    #
-    # Otherwise it returns +self.class+.
-    #
-    # @return [Class] Element type for arrays and composite numbers. Returns
-    # +self.class+ if this is not an array.
+    # Display value of this instance
     #
-    # @private
-    def basetype
-      self.class.basetype
+    # @return [String] Returns string with the value of this instance.
+    def to_s
+      get.to_s
     end
-    
-    # Check whether an array is empty or not
-    #
-    # Returns +false+ if this is not an array.
+
+    # Retrieve Ruby value of object
     #
-    # @return [FalseClass,TrueClass] Returns boolean indicating whether the
-    # array is empty or not. Returns +false+ if this is not an array.
-    def empty?
-      self.class.empty?
+    # @return [Object] Ruby value of native data type.
+    def []
+      get
     end
 
-    # Get shape of multi-dimensional array
+    # Set Ruby value of object
     #
-    # Returns +[]+ if this is not an array.
+    # @param [Object] value New Ruby value for native data type.
     #
-    # @return [Array<Integer>] Returns shape of array or +[]+ if this is not
-    # an array.
-    def shape
-      self.class.shape
+    # @return [Object] The parameter +value+ or the default value.
+    def []=( value )
+      set value
     end
 
-    # Get number of elements of multi-dimensional array
+    # Retrieve Ruby value of object
     #
-    # Returns +1+ if this is not an array.
+    # @return [Object] Ruby value of native data type.
     #
-    # @return [Integer] Number of elements of array. +1+ if this is not an
-    # array.
-    def size
-      self.class.size
+    # @private
+    def get
+      delay.instance_exec { @value }
     end
 
-    # Create new instance of this type
+    # Set Ruby value of object
+    #
+    # Set to specified value.
     #
-    # @param value [Object] Optional initial value for this instance.
-    # @option options [Storage] :storage (self.class.alloc) Use specified
-    # +Storage+ object instead of creating a new one.
+    # @param [Object] value New Ruby value for native data type.
     #
-    # @see alloc
+    # @return [Object] The parameter +value+ or the default value.
     #
     # @private
-    def initialize( value = nil, options = {} )
-      @storage = options[ :storage ] ? options[ :storage ] : self.class.alloc
-      set value unless value.nil?
+    def set( value )
+      @value = value
     end
 
-    # Display type and value of this instance
-    #
-    # @return [String] Returns string with information about type and value.
-    def inspect
-      "#{self.class.inspect}(#{to_s})"
+    def fetch
+      self
     end
 
-    # Display value of this instance
-    #
-    # @return [String] Returns string with the value of this instance.
-    def to_s
-      get.to_s
+    def operation( *args, &action )
+      instance_exec *args.collect { |arg| arg.force.fetch.get }, &action
+      self
     end
 
-    # Convert value of this instance to array
-    #
-    # @return [Array] Result of calling +to_a+ on value of this instance.
-    def to_a
-      get.to_a
+    def delay
+      if not Thread.current[ :lazy ] or @value.is_a? Lazy
+        self
+      else
+        self.class.new Lazy.new( self )
+      end
     end
 
-    # Retrieve element of array
-    #
-    # @param *indices [Array<Integer>] Index/indices to access element.
-    # @return [Object,Type] Ruby object with value of element.
-    #
-    # @see #[]
-    def at( *indices )
-      sel( *indices ).get
+    def force
+      if Thread.current[ :lazy ] or not @value.is_a? Lazy
+        self
+      else
+        @value.force
+      end
     end
 
-    alias_method :[], :at
+    def -@
+      if is_a?( Pointer_ ) and self.class.primitive < Sequence_
+        retval = self.class.new
+      else
+        retval = self.class.dereference.new
+      end
+      retval.operation( self ) { |x| set -x }
+      retval
+    end
 
-    # Assign value to element of array
-    #
-    # @param *args [Array<Integer,Object>] Index/indices to access element.
-    # The last element of +args+ is the new value to store in the array.
-    #
-    # @return [Object] Returns +args.last+.
-    def assign( *args )
-      sel( *args[ 0 ... -1 ] ).set args.last
+    def +@
+      self
+    end
+
+    def +( other )
+      if is_a?( Pointer_ ) and self.class.primitive < Sequence_
+        retval = self.class.new
+      else
+        retval = self.class.dereference.new
+      end
+      retval.operation( self, other ) { |x,y| set x + y }
+      retval
     end
 
-    alias_method :[]=, :assign
+    def match( value, context = nil )
+      retval = fit value
+      retval = retval.align context if context
+      retval
+    end
+
+    def ==( other )
+      if other.class == self.class
+        other.get == get
+      else
+        false
+      end
+    end
 
   end
 

data/test/tc_int.rb

@@ -1,115 +1,117 @@
 require 'test/unit'
+begin
+  require 'rubygems'
+rescue LoadError
+end
 Kernel::require 'multiarray'
 
 class TC_Int < Test::Unit::TestCase
 
+  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 lazy( &action )
+    Hornetseye::lazy &action
+  end
+
+  def eager( &action )
+    Hornetseye::eager &action
+  end
+
   def setup
-    @@types = [ Hornetseye::UBYTE,
-                Hornetseye::BYTE,
-                Hornetseye::USINT,
-                Hornetseye::SINT,
-                Hornetseye::UINT,
-                Hornetseye::INT,
-                Hornetseye::ULONG,
-                Hornetseye::LONG ]
   end
 
   def teardown
-    @@types = nil
   end
 
   def test_int_default
-    for t in @@types
-      assert_equal 0, t.default
-    end
+    T.each { |t| assert_equal 0, t.new[] }
   end
 
-  def test_int_to_s
-    assert_equal 'UBYTE', Hornetseye::UBYTE.to_s
-    assert_equal 'BYTE' , Hornetseye::BYTE.to_s
-    assert_equal 'USINT', Hornetseye::USINT.to_s
-    assert_equal 'SINT' , Hornetseye::SINT.to_s
-    assert_equal 'UINT' , Hornetseye::UINT.to_s
-    assert_equal 'INT'  , Hornetseye::INT.to_s
-    assert_equal 'ULONG', Hornetseye::ULONG.to_s
-    assert_equal 'LONG' , Hornetseye::LONG.to_s
-  end
 
   def test_int_inspect
-    for t in @@types
-      assert_equal t.to_s, t.inspect
-    end
-  end
-
-  def test_bytesize
-    for i in [ 8, 16, 32, 64 ]
-      assert_equal i, 8 * Hornetseye::INT( i, Hornetseye::UNSIGNED ).bytesize
-      assert_equal i, 8 * Hornetseye::INT( i, Hornetseye::SIGNED   ).bytesize
-    end
+    T.each { |t| assert_equal INSPECT[ t ], t.inspect }
   end
 
-  def test_typecode
-    for t in @@types
-      assert_equal t, t.typecode
-    end
+  def test_int_to_s
+    T.each { |t| assert_equal INSPECT[ t ], t.to_s }
   end
 
-  def test_shape
-    for t in @@types
-      assert_equal [], t.shape
-    end
+  def test_inspect
+    T.each { |t| assert_equal "#{t}(42)", t.new( 42 ).inspect }
   end
 
-  def test_size
-    for t in @@types
-      assert_equal 1, t.size
-    end
+  def test_to_s
+    T.each { |t| assert_equal '42', t.new( 42 ).to_s }
   end
 
-  def test_to_s
-    for t in @@types
-      assert_equal '42', t.new( 42 ).to_s
+  def test_marshal
+    T.each do |t|
+      assert_equal t.new( 42 ),
+                   Marshal.load( Marshal.dump( t.new( 42 ) ) )
     end
   end
 
-  def test_inspect
-    for t in @@types
-      assert_equal "#{t.inspect}(42)", t.new( 42 ).inspect
+  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
   end
 
-  def test_get_set
-    for t in @@types
-      i = t.new 0
-      assert_equal 0, i.get
-      assert_equal 42, i.set( 42 )
-      assert_equal 42, i.get
-      assert_equal 0, i.set
-      assert_equal 0, i.get
+  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
   end
 
-  def test_at_assign
-    for t in @@types
-      i = t.new 0
-      assert_equal 0, i.at
-      assert_equal 42, i.assign( 42 )
-      assert_equal 42, i.at
-      assert_raise( ArgumentError ) { i.at 0 }
-      assert_raise( ArgumentError ) { i.assign 0, 0 }
-      i = t.new 0
-      assert_equal 0, i[]
-      assert_equal 42, i[] = 42 
-      assert_equal 42, i[]
-      assert_raise( ArgumentError ) { i[ 0 ] }
-      assert_raise( ArgumentError ) { i[ 0 ] = 0 }
+  def test_negate
+    T.select { |t| SIGNED[ t ] }.each do |t|
+      assert_equal t.new( -5 ), -t.new( 5 )
     end
   end
 
-  def test_op
-    for t in @@types
-      i = t.new 1
-      assert_equal 3, i.op( 2 ) { |x| set get + x }.get
+  def test_lazy
+    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