multiarray 0.5.0 → 0.5.1

data/lib/multiarray/pointer.rb

@@ -25,6 +25,10 @@ module Hornetseye
       # @return [Node] Type of object the pointer is pointing at.
       attr_accessor :target
 
+      def construct( *args )
+        new *args
+      end
+
       def inspect
         "*(#{target.inspect})"
       end
@@ -37,7 +41,7 @@ module Hornetseye
       #
       # @private
       def descriptor( hash )
-        "*(#{target.to_s})"
+        inspect
       end
 
       # Get default value for elements of this type
@@ -128,6 +132,10 @@ module Hornetseye
       end
     end
 
+    def values
+      [ @value ]
+    end
+
   end
 
   def Pointer( target )

data/lib/multiarray/rgb.rb

@@ -0,0 +1,401 @@
+# 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 RGB
+
+    class << self
+
+      def generic?( value )
+        value.is_a?( Numeric ) or value.is_a?( GCCValue )
+      end
+
+      def define_unary_op( op )
+        define_method( op ) do
+          RGB.new r.send( op ), g.send( op ), b.send( op )
+        end
+      end
+
+      def define_binary_op( op )
+        define_method( op ) do |other|
+          if other.is_a? RGB
+            RGB.new r.send( op, other.r ), g.send( op, other.g ),
+                    b.send( op, other.b )
+          elsif RGB.generic? other
+            RGB.new r.send( op, other ), g.send( op, other ),
+                    b.send( op, other )
+          else
+            x, y = other.coerce self
+            x.send op, y
+          end
+        end
+      end
+
+    end
+
+    attr_accessor :r, :g, :b
+
+    def initialize( r, g, b )
+      @r, @g, @b = r, g, b
+    end
+
+    def inspect
+      "RGB(#{@r.inspect},#{@g.inspect},#{@b.inspect})"
+    end
+
+    def to_s
+      "RGB(#{@r.to_s},#{@g.to_s},#{@b.to_s})"
+    end
+
+    def store( value )
+      @r, @g, @b = value.r, value.g, value.b
+    end
+
+    def coerce( other )
+      if other.is_a? RGB
+        return other, self
+      else
+        return RGB.new( other, other, other ), self
+      end
+    end
+
+    def +@
+      self
+    end
+
+    define_unary_op  :~
+    define_unary_op  :-@
+    define_binary_op :+
+    define_binary_op :-
+    define_binary_op :*
+    define_binary_op :/
+    define_binary_op :%
+    define_binary_op :&
+    define_binary_op :|
+    define_binary_op :^
+    define_binary_op :<<
+    define_binary_op :>>
+    define_binary_op :minor
+    define_binary_op :major
+
+    def zero?
+      @r.zero?.and( @g.zero? ).and( @b.zero? )
+    end
+
+    def nonzero?
+      @r.nonzero?.or( @g.nonzero? ).or( @b.nonzero? )
+    end
+
+    def ==( other )
+      if other.is_a? RGB
+        @r.eq( other.r ).and( @g.eq( other.g ) ).and( @b.eq( other.b ) )
+      elsif RGB.generic? other
+        @r.eq( other ).and( @g.eq( other ) ).and( @b.eq( other ) )
+      else
+        false
+      end
+    end
+
+  end
+
+  class RGB_ < Element
+
+    class << self
+
+      attr_accessor :element_type
+
+      def fetch( ptr )
+        construct *ptr.load( self )
+      end
+
+      def construct( r, g, b )
+        new Hornetseye::RGB( r, g, b )
+      end
+
+      def memory
+        element_type.memory
+      end
+
+      def storage_size
+        element_type.storage_size * 3
+      end
+
+      def default
+        Hornetseye::RGB 0, 0, 0
+      end
+
+      def directive
+        element_type.directive * 3
+      end
+
+      def inspect
+        unless element_type.nil?
+          { BYTE    => 'BYTERGB',
+            UBYTE   => 'UBYTERGB',
+            SINT    => 'SINTRGB',
+            USINT   => 'USINTRGB',
+            INT     => 'INTRGB',
+            UINT    => 'UINTRGB',
+            LONG    => 'LONGRGB',
+            ULONG   => 'ULONGRGB',
+            SFLOAT  => 'SFLOATRGB',
+            DFLOAT  => 'DFLOATRGB' }[ element_type ] ||
+            "RGB(#{element_type.inspect})"
+        else
+          super
+        end
+      end
+
+      def descriptor( hash )
+        unless element_type.nil?
+          inspect
+        else
+          super
+        end
+      end
+
+      def basetype
+        element_type
+      end
+
+      def typecodes
+        [ element_type ] * 3
+      end
+
+      def maxint
+        Hornetseye::RGB element_type.maxint
+      end
+
+      def float
+        Hornetseye::RGB element_type.float
+      end
+
+      def coercion( other )
+        if other < RGB_
+          Hornetseye::RGB element_type.coercion( other.element_type )
+        elsif other < INT_ or other < FLOAT_
+          Hornetseye::RGB element_type.coercion( other )
+        else
+          super other
+        end
+      end
+
+      def coerce( other )
+        if other < RGB_
+          return other, self
+        elsif other < INT_ or other < FLOAT_
+          return Hornetseye::RGB( other ), self
+        else
+          super other
+        end
+      end
+
+      def ==( other )
+        other.is_a? Class and other < RGB_ and
+          element_type == other.element_type
+      end
+
+      def hash
+        [ :RGB_, element_type ].hash
+      end
+
+      def eql?( other )
+        self == other
+      end
+
+      #def compilable?
+      #  false # !!!
+      #end
+
+    end
+
+    def initialize( value = self.class.default )
+      if Thread.current[ :function ].nil? or
+         [ value.r, value.g, value.b ].all? { |c| c.is_a? GCCValue }
+        @value = value
+      else
+        r = GCCValue.new Thread.current[ :function ], value.r.to_s
+        g = GCCValue.new Thread.current[ :function ], value.r.to_s
+        b = GCCValue.new Thread.current[ :function ], value.r.to_s
+        @value = RGB.new r, g, b
+      end
+    end
+
+    def dup
+      if Thread.current[ :function ]
+        r = Thread.current[ :function ].variable self.class.element_type, 'v'
+        g = Thread.current[ :function ].variable self.class.element_type, 'v'
+        b = Thread.current[ :function ].variable self.class.element_type, 'v'
+        r.get.store @value.r
+        g.get.store @value.g
+        b.get.store @value.b
+        self.class.new RGB.new( r.get, g.get, b.get )
+      else
+        self.class.new get
+      end
+    end
+
+    def store( value )
+      value = value.simplify
+      if @value.r.respond_to? :store
+        @value.r.store value.get.r
+      else
+        @value.r = value.get.r
+      end
+      if @value.g.respond_to? :store
+        @value.g.store value.get.g
+      else
+        @value.g = value.get.g
+      end
+      if @value.b.respond_to? :store
+        @value.b.store value.get.b
+      else
+        @value.b = value.get.b
+      end
+      value
+    end
+
+    def values
+      [ @value.r, @value.g, @value.b ]
+    end
+
+    module Match
+
+      def fit( *values )
+        if values.all? { |value| value.is_a? RGB or value.is_a? Float or
+                                 value.is_a? Integer }
+          if values.any? { |value| value.is_a? RGB }
+            elements = values.inject( [] ) do |arr,value|
+              if value.is_a? RGB
+                arr + [ value.r, value.g, value.b ]
+              else
+                arr + [ value ]
+              end
+            end
+            element_fit = fit *elements
+            if element_fit == OBJECT
+              super *values
+            else
+              Hornetseye::RGB element_fit
+            end
+          else
+            super *values
+          end
+        else
+          super *values
+        end
+      end
+
+      def align( context )
+        if self < RGB_
+          Hornetseye::RGB element_type.align( context )
+        else
+          super context
+        end
+      end
+
+    end
+
+    Node.extend Match
+
+  end
+
+  def RGB( arg, g = nil, b = nil )
+    if g.nil? and b.nil?
+      retval = Class.new RGB_
+      retval.element_type = arg
+      retval
+    else
+      RGB.new arg, g, b
+    end
+  end
+
+  module_function :RGB
+
+  BYTERGB   = RGB BYTE
+
+  UBYTERGB  = RGB UBYTE
+
+  SINTRGB   = RGB SINT
+
+  USINTRGB  = RGB USINT
+
+  INTRGB    = RGB INT
+
+  UINTRGB   = RGB UINT
+
+  LONGRGB   = RGB LONG
+
+  ULONGRGB  = RGB ULONG
+
+  SFLOATRGB = RGB SFLOAT
+
+  DFLOATRGB = RGB DFLOAT
+
+  def BYTERGB( value )
+    BYTERGB.new value
+  end
+
+  def UBYTERGB( value )
+    UBYTERGB.new value
+  end
+
+  def SINTRGB( value )
+    SINTRGB.new value
+  end
+
+  def USINTRGB( value )
+    USINTRGB.new value
+  end
+
+  def INTRGB( value )
+    INTRGB.new value
+  end
+
+  def UINTRGB( value )
+    UINTRGB.new value
+  end
+
+  def LONGRGB( value )
+    LONGRGB.new value
+  end
+
+  def ULONGRGB( value )
+    ULONGRGB.new value
+  end
+
+  def SFLOATRGB( value )
+    SFLOATRGB.new value
+  end
+
+  def DFLOATRGB( value )
+    DFLOATRGB.new value
+  end
+
+  module_function :BYTERGB
+  module_function :UBYTERGB
+  module_function :SINTRGB
+  module_function :USINTRGB
+  module_function :INTRGB
+  module_function :UINTRGB
+  module_function :LONGRGB
+  module_function :ULONGRGB
+  module_function :SFLOATRGB
+  module_function :DFLOATRGB
+
+end

data/lib/multiarray/sequence.rb

@@ -42,10 +42,12 @@ module Hornetseye
       # @return [Node] Returns native array with values.
       def []( *args )
         target = Node.fit args
-        target = Hornetseye::Sequence OBJECT, args.size if target.dimension > 1
-        retval = target.new
-        args.each_with_index { |arg,i| retval[ i ] = arg }
-        retval
+        if target.dimension == 0
+          target = Hornetseye::Sequence target, 0
+        elsif target.dimension > 1
+          target = Hornetseye::Sequence OBJECT, args.size
+        end
+        target[ *args ]
       end
 
     end
@@ -79,30 +81,46 @@ module Hornetseye
 
       def indgen( offset = 0, increment = 1 )
         Hornetseye::lazy( num_elements ) do |i|
-          if offset == 0
-            if increment == 1
-              i
-            else
-              increment * i
+          element_type.size * increment * i +
+            element_type.indgen( offset, increment )
+        end
+      end
+
+      def []( *args )
+        retval = new
+        recursion = proc do |element,args|
+          if element.dimension > 0
+            args.each_with_index do |arg,i|
+              recursion.call element.element( i ), arg
             end
           else
-            if increment == 1
-              offset + i
-            else
-              offset + increment * i
-            end
+            element[] = args
           end
         end
+        recursion.call retval, args
+        retval
       end
 
       def shape
         element_type.shape + [ num_elements ]
       end
 
+      def size
+        num_elements * element_type.size
+      end
+
+      def empty?
+        size == 0
+      end
+
       def typecode
         element_type.typecode
       end
 
+      def basetype
+        element_type.basetype
+      end
+
       def array_type
         self
       end
@@ -127,6 +145,22 @@ module Hornetseye
         coercion( other ).bool
       end
 
+      def maxint
+        Hornetseye::Sequence element_type.maxint, num_elements
+      end
+
+      def largeint( other )
+        coercion( other ).maxint
+      end
+
+      def float
+        Hornetseye::Sequence element_type.float, num_elements
+      end
+
+      def floating( other )
+        coercion( other ).float
+      end
+
       def inspect
         if dimension == 1
           "Sequence(#{typecode.inspect},#{num_elements.inspect})"
@@ -215,6 +249,14 @@ module Hornetseye
         end
       end
 
+      def align( context )
+        if self < Sequence_
+          Hornetseye::Sequence element_type.align( context ), num_elements
+        else
+          super context
+        end
+      end
+
     end
 
     Node.extend Match