multiarray 0.5.1 → 0.5.2

data/Rakefile

@@ -6,7 +6,7 @@ require 'rake/packagetask'
 require 'rbconfig'
 
 PKG_NAME = 'multiarray'
-PKG_VERSION = '0.5.1'
+PKG_VERSION = '0.5.2'
 RB_FILES = FileList[ 'lib/**/*.rb' ]
 TC_FILES = FileList[ 'test/tc_*.rb' ]
 TS_FILES = FileList[ 'test/ts_*.rb' ]
@@ -86,7 +86,7 @@ begin
     s.has_rdoc = 'yard'
     s.extra_rdoc_files = []
     s.rdoc_options = %w{--no-private}
-    s.add_dependency %q<malloc>, [ '~> 1.0' ]
+    s.add_dependency %q<malloc>, [ '~> 1.1' ]
     s.add_development_dependency %q{rake}
   end
   GEM_SOURCE = "#{PKG_NAME}-#{PKG_VERSION}.gem"
@@ -107,7 +107,7 @@ begin
     s.has_rdoc = 'yard'
     s.extra_rdoc_files = []
     s.rdoc_options = %w{--no-private}
-    s.add_dependency %q<malloc>, [ '~> 1.0' ]
+    s.add_dependency %q<malloc>, [ '~> 1.1' ]
   end
   GEM_BINARY = "#{PKG_NAME}-#{PKG_VERSION}-#{$BINSPEC.platform}.gem"
   desc "Build the gem file #{GEM_SOURCE}"

data/TODO

@@ -1,18 +1,12 @@
-# type alignment for operators and methods, Math.sqrt( SFLOAT )
-# test floor, ceil, ..., factor out common stuff of UnaryOp and UnaryMethod
-# complex numbers, factor out composite numbers
-# Fast filling of arrays, duplication, type conversions
-# use descriptors ('c','f',...)?
+# use descriptors ('c','f',...)? GCCValue.identifiers is not modular
 # pointer-increments for better efficiency, optimize Node#diagonal
-# implement typecasts, how does contiguous work here?
-# documentation!
 
 # histogram (implement using injection)
-# inject: n-d clips for warp
+# random numbers
+# Geometric Hashing? Bounded Hough Transform!!! RANSAC? histogram weights?
+# each, multi_each, collect, multi_collect, zip?
+# inject: n-d masks for warp
 # block(var1,var2,...) with smart subst?
-# lazy( 3, 2 ) { |i,j| j.to_object }
-
-# RSpec
 
 # downsampling after correlation?
 # YARD documentation with pictures, demo video
@@ -27,19 +21,10 @@
 #  end
 #end
 
-
 # cache <-> demand/get? what about store?
-# Composite numbers?
-# change Convolve#demand to generate GCC code
-# inspect method (type method to get MultiArray( ... ) or Sequence( ... ))
-# put JIT-calls into 'force'-method, don't call JIT for OBJECT
-# -> multiarray gem
-# pointer-increments for better efficiency
-# use pid, allow creation of library for pre-loading cache
+# allow creation of library for pre-loading cache
 
-# histogram
-# binary operations, equality: ( a == b ).inject( true ) { |e,b| e && b }
-# inject: min, max, equal, n-d clips for warp
+# use inject for n-d clips for warp
 # block(var1,var2,...) with smart subst?
 
 # downsampling after correlation?
@@ -55,7 +40,6 @@
 #  end
 #end
 
-ranges (rolling, lazy rolling, lazy ranges)
 test type conversions
 
 a = lazy( 16, 32 ) { |i,j| Sequence[ i, j ] } # ???
@@ -75,11 +59,3 @@ combined histograms?
 circle:
 [ sin( i ) * r, cos( i ) * r ].hist
 
-Geometric Hashing? Bounded Hough Transform!!! RANSAC? histogram weights?
-
-array: lazy retrieval? jit code for address computation
-OBJECT: object with type information
-Lazy( Sequence( INT, 3 ) )
-
-interpretation: type coercion, actual operation, jit,
-collection of jit arguments (e.g. tensor)

data/lib/multiarray.rb

@@ -416,6 +416,10 @@ end
 
 class Numeric
 
+  def conj
+    self
+  end
+
   def r
     self
   end
@@ -456,6 +460,7 @@ class Array
 
 end
 
+require 'complex'
 require 'malloc'
 require 'rbconfig'
 require 'set'
@@ -464,20 +469,19 @@ require 'multiarray/malloc'
 require 'multiarray/list'
 require 'multiarray/node'
 require 'multiarray/element'
+require 'multiarray/composite'
 require 'multiarray/object'
 require 'multiarray/index'
 require 'multiarray/bool'
 require 'multiarray/int'
 require 'multiarray/float'
 require 'multiarray/rgb'
+require 'multiarray/complex'
 require 'multiarray/pointer'
 require 'multiarray/variable'
 require 'multiarray/lambda'
 require 'multiarray/lookup'
-require 'multiarray/unaryop'
-require 'multiarray/unarymethod'
-require 'multiarray/binaryop'
-require 'multiarray/binarymethod'
+require 'multiarray/elementwise'
 require 'multiarray/operations'
 require 'multiarray/methods'
 require 'multiarray/inject'

data/lib/multiarray/complex.rb

@@ -0,0 +1,360 @@
+# 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 Complex
+
+    class << self
+
+      def generic?( value )
+        value.is_a?( Numeric ) or value.is_a?( GCCValue )
+      end
+
+      def polar( r, theta )
+        new r * Math.cos( theta ), r * Math.sin( theta )
+      end
+
+    end
+
+    attr_accessor :real, :imag
+
+    def initialize( real, imag )
+      @real, @imag = real, imag
+    end
+
+    def inspect
+      "Hornetseye::Complex(#{@real.inspect},#{@imag.inspect})"
+    end
+
+    def to_s
+      "Complex(#{@real.to_s},#{@imag.to_s})"
+    end
+
+    def store( value )
+      @real, @imag = value.real, value.imag
+    end
+
+    def coerce( other )
+      if other.is_a? Complex
+        return other, self
+      elsif other.is_a? ::Complex
+        return Complex.new( other.real, other.imag ), self
+      else
+        return Complex.new( other, 0 ), self
+      end
+    end
+
+    def conj
+      Complex.new @real, -@imag
+    end
+
+    def abs
+      Math.hypot @real, @imag
+    end
+
+    def arg
+      Math.atan2 @imag, @real
+    end
+
+    def polar
+      return abs, arg
+    end
+
+    def +@
+      self
+    end
+
+    def -@
+      Complex.new -@real, -@imag
+    end
+
+    def +( other )
+      if other.is_a?( Complex ) or other.is_a?( ::Complex )
+        Complex.new @real + other.real, @imag + other.imag
+      elsif Complex.generic? other
+        Complex.new @real + other, @imag
+      else
+        x, y = other.coerce self
+        x + y
+      end
+    end
+
+    def -( other )
+      if other.is_a?( Complex ) or other.is_a?( ::Complex )
+        Complex.new @real - other.real, @imag - other.imag
+      elsif Complex.generic? other
+        Complex.new @real - other, @imag
+      else
+        x, y = other.coerce self
+        x - y
+      end
+    end
+
+    def *( other )
+      if other.is_a?( Complex ) or other.is_a?( ::Complex )
+        Complex.new @real * other.real - @imag * other.imag,
+                    @real * other.imag + @imag * other.real
+      elsif Complex.generic? other
+        Complex.new @real * other, @imag * other
+      else
+        x, y = other.coerce self
+        x * y
+      end
+    end
+
+    def /( other )
+      if other.is_a?( Complex ) or other.is_a?( ::Complex )
+        self * other.conj / other.abs2
+      elsif Complex.generic? other
+        Complex.new @real / other, @imag / other
+      else
+        x, y = other.coerce self
+        x / y
+      end
+    end
+
+    def **( other )
+      if other.is_a?( Complex ) or other.is_a?( ::Complex )
+        r, theta = polar
+        ore = other.real
+        oim = other.imag
+        nr = Math.exp ore * Math.log( r ) - oim * theta
+        ntheta = theta * ore + oim * Math.log( r )
+        Complex.polar nr, ntheta
+      elsif Complex.generic? other
+        r, theta = polar
+        Complex.polar r ** other, theta * other
+      else
+        x, y = other.coerce self
+        x ** y
+      end
+    end
+
+    def zero?
+      @real.zero?.and @imag.zero?
+    end
+
+    def nonzero?
+      @real.nonzero?.or @imag.nonzero?
+    end
+
+    def abs2
+      @real * @real + @imag * @imag
+    end
+
+    def ==( other )
+      if other.is_a?( Complex ) or other.is_a?( ::Complex )
+        @real.eq( other.real ).and( @imag.eq( other.imag ) )
+      elsif Complex.generic? other
+        @real.eq( other ).and( @imag.eq( 0 ) )
+      else
+        false
+      end
+    end
+
+    def decompose
+      Hornetseye::Sequence[ @real, @imag ]
+    end
+
+  end
+
+  class COMPLEX_ < Composite
+
+    class << self
+
+      def inherited( subclass )
+        subclass.num_elements = 2
+      end
+
+      def construct( real, imag )
+        if Thread.current[ :function ]
+          new Complex.new( real, imag )
+        else
+          new Complex( real, imag )
+        end
+      end
+
+      def default
+        if Thread.current[ :function ]
+          Complex.new 0, 0
+        else
+          Kernel::Complex 0, 0
+        end
+      end
+
+      def inspect
+        unless element_type.nil?
+          { SFLOAT => 'SCOMPLEX',
+            DFLOAT => 'DCOMPLEX' }[ element_type ] ||
+          "COMPLEX(#{element_type.inspect})"
+        else
+          super
+        end
+      end
+
+      def maxint
+        Hornetseye::COMPLEX element_type.maxint
+      end
+
+      def float
+        Hornetseye::COMPLEX element_type.float
+      end
+
+      def coercion( other )
+        if other < COMPLEX_
+          Hornetseye::COMPLEX element_type.coercion( other.element_type )
+        elsif other < INT_ or other < FLOAT_
+          Hornetseye::COMPLEX element_type.coercion( other )
+        else
+          super other
+        end
+      end
+
+      def coerce( other )
+        if other < COMPLEX_
+          return other, self
+        elsif other < INT_ or other < FLOAT_
+          return Hornetseye::COMPLEX( other ), self
+        else
+          super other
+        end        
+      end
+
+      def ==( other )
+        other.is_a? Class and other < COMPLEX_ and
+          element_type == other.element_type
+      end
+
+      def hash
+        [ :COMPLEX_, element_type ].hash
+      end
+
+      def eql?( other )
+        self == other
+      end
+
+    end
+
+    def initialize( value = self.class.default )
+      if Thread.current[ :function ].nil? or
+        [ value.real, value.imag ].all? { |c| c.is_a? GCCValue }
+        @value = value
+      else
+        real = GCCValue.new Thread.current[ :function ], value.real.to_s
+        imag = GCCValue.new Thread.current[ :function ], value.imag.to_s
+        @value = Complex.new real, imag
+      end
+    end
+
+    def dup
+      if Thread.current[ :function ]
+        real = Thread.current[ :function ].variable self.class.element_type, 'v'
+        imag = Thread.current[ :function ].variable self.class.element_type, 'v'
+        real.store @value.real
+        imag.store @value.imag
+        self.class.new Complex.new( real, imag )
+      else
+        self.class.new get
+      end
+    end
+
+    def store( value )
+      value = value.simplify
+      if @value.real.respond_to? :store
+        @value.real.store value.get.real
+      else
+        @value.real = value.get.real
+      end
+      if @value.imag.respond_to? :store
+        @value.imag.store value.get.imag
+      else
+        @value.imag = value.get.imag
+      end
+      value
+    end
+
+    def values
+      [ @value.real, @value.imag ]
+    end
+
+    module Match
+
+      def fit( *values )
+        if values.all? { |value| value.is_a? Complex or value.is_a? ::Complex or
+                                 value.is_a? Float or value.is_a? Integer }
+          if values.any? { |value| value.is_a? Complex or value.is_a? ::Complex }
+            elements = values.inject( [] ) do |arr,value|
+              if value.is_a? Complex or value.is_a? ::Complex
+                arr + [ value.real, value.imag ]
+              else
+                arr + [ value ]
+              end
+            end
+            element_fit = fit *elements
+            if element_fit == OBJECT
+              super *values
+            else
+              Hornetseye::COMPLEX element_fit
+            end
+          else
+            super *values
+          end
+        else
+          super *values
+        end
+      end
+
+      def align( context )
+        if self < COMPLEX_
+          Hornetseye::COMPLEX element_type.align( context )
+        else
+          super context
+        end
+      end
+
+    end
+
+    Node.extend Match
+
+  end
+
+  def COMPLEX( arg )
+    retval = Class.new COMPLEX_
+    retval.element_type = arg
+    retval
+  end
+
+  module_function :COMPLEX
+
+  SCOMPLEX = COMPLEX SFLOAT
+
+  DCOMPLEX = COMPLEX DFLOAT
+
+  def SCOMPLEX( value )
+    SCOMPLEX.new value
+  end
+
+  def DCOMPLEX( value )
+    DCOMPLEX.new value
+  end
+
+  module_function :SCOMPLEX
+  module_function :DCOMPLEX
+
+end
+