mdarray 0.5.0.pre-java → 0.5.3-java

data/lib/mdarray/lazy_operators.rb

@@ -0,0 +1,166 @@
+# -*- coding: utf-8 -*-
+
+##########################################################################################
+# Copyright © 2013 Rodrigo Botafogo. All Rights Reserved. Permission to use, copy, modify, 
+# and distribute this software and its documentation for educational, research, and 
+# not-for-profit purposes, without fee and without a signed licensing agreement, is hereby 
+# granted, provided that the above copyright notice, this paragraph and the following two 
+# paragraphs appear in all copies, modifications, and distributions. Contact Rodrigo
+# Botafogo - rodrigo.a.botafogo@gmail.com for commercial licensing opportunities.
+#
+# IN NO EVENT SHALL RODRIGO BOTAFOGO BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT, SPECIAL, 
+# INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING LOST PROFITS, ARISING OUT OF THE USE OF 
+# THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF RODRIGO BOTAFOGO HAS BEEN ADVISED OF THE 
+# POSSIBILITY OF SUCH DAMAGE.
+#
+# RODRIGO BOTAFOGO SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT LIMITED TO, 
+# THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE 
+# SOFTWARE AND ACCOMPANYING DOCUMENTATION, IF ANY, PROVIDED HEREUNDER IS PROVIDED "AS IS". 
+# RODRIGO BOTAFOGO HAS NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, 
+# OR MODIFICATIONS.
+##########################################################################################
+
+##########################################################################################
+#
+##########################################################################################
+
+class LazyBinaryOperator < BinaryOperator
+
+  #---------------------------------------------------------------------------------------
+  #
+  #---------------------------------------------------------------------------------------
+
+  def get_args(*args)
+
+    @op1 = args.shift
+    @op2 = args.shift
+    @other_args = args
+
+  end
+
+  #---------------------------------------------------------------------------------------
+  # A default binary operator takes two arrays where one array can be degenerated (a 
+  # number and loops through all elements of the arrays applying a given method to them.  
+  # For instance, operator '+' in a + b is a default binary operator.
+  #---------------------------------------------------------------------------------------
+
+  def default(*args)
+
+    get_args(*args)
+    lazy = @op1
+
+    if (@op1.is_a? LazyMDArray)
+      lazy.push(@op2)
+      lazy.push(self)
+    else
+      lazy = LazyMDArray.new
+      lazy.push(@op1)
+      lazy.push(@op2)
+      lazy.push(self)
+    end
+
+    return lazy
+
+  end
+
+  #---------------------------------------------------------------------------------------
+  # A fill binary operator takes two arrays where one array can be degenerated (a number)
+  # and loops through all elements of the arrays, setting the value of the first array
+  # to the values of the second.
+  #---------------------------------------------------------------------------------------
+
+  def fill(*args)
+    raise "Cannot fill array lazyly"
+  end
+
+  #---------------------------------------------------------------------------------------
+  #
+  #---------------------------------------------------------------------------------------
+
+  def in_place(*args)
+    raise "Cannot operate in_place lazyly"
+  end
+
+  #---------------------------------------------------------------------------------------
+  #
+  #---------------------------------------------------------------------------------------
+
+  def reduce(*args)
+    raise "Cannot reduce array in lazy operation"
+  end
+  
+  #---------------------------------------------------------------------------------------
+  #
+  #---------------------------------------------------------------------------------------
+
+  def complex_reduce(*args)
+    raise "Cannot reduce array in lazy operation"
+  end
+
+end # LazyBinaryOperator
+
+##########################################################################################
+#
+##########################################################################################
+
+class LazyUnaryOperator < UnaryOperator
+
+  #---------------------------------------------------------------------------------------
+  #
+  #---------------------------------------------------------------------------------------
+
+  def get_args(*args)
+
+    @op = args.shift
+    @other_args = args
+
+  end
+
+  #---------------------------------------------------------------------------------------
+  # A default unary operator takes one arrays and loops through all elements of the array
+  # applying a given method to it.  For instance, operator 'log' in a.log is a default 
+  # unary operator.
+  #---------------------------------------------------------------------------------------
+
+  def default(*args)
+
+    get_args(*args)
+    lazy = @op
+
+    if (@op.is_a? LazyMDArray)
+      lazy.push(self)
+    else
+      lazy = LazyMDArray.new
+      lazy.push(@op)
+      lazy.push(self)
+    end
+
+    return lazy
+
+  end
+
+  #---------------------------------------------------------------------------------------
+  #
+  #---------------------------------------------------------------------------------------
+
+  def in_place(*args)
+    raise "Cannot operate in_place lazyly"
+  end
+
+  #---------------------------------------------------------------------------------------
+  #
+  #---------------------------------------------------------------------------------------
+
+  def reduce(*args)
+    raise "Cannot reduce array in lazy operation"
+  end
+  
+  #---------------------------------------------------------------------------------------
+  #
+  #---------------------------------------------------------------------------------------
+
+  def complex_reduce(*args)
+    raise "Cannot reduce array in lazy operation"
+  end
+
+end # LazyUnaryOperator

data/lib/mdarray/operators.rb

@@ -52,6 +52,14 @@ class Const
   #
   #---------------------------------------------------------------------------------------
 
+  def get(index)
+    @value
+  end
+
+  #---------------------------------------------------------------------------------------
+  #
+  #---------------------------------------------------------------------------------------
+
   def get_next
     @value
   end
@@ -73,12 +81,15 @@ end # Const
 class Operator
 
   attr_reader :name
-  attr_reader :type  # resulting type of the operation
-  attr_reader :arity # number of arguments to the operator
+  attr_reader :type            # resulting type of the operation
+  attr_reader :arity           # number of arguments to the operator
   attr_reader :exec_type # type of operator execution, e.g., default, in_place, numeric
-  attr_reader :force_type  # force this type as the result type
-  attr_reader :pre_condition  # proc to be executed before the operator's execution
+  attr_reader :helper          # helper method for this operator
+  attr_reader :fmap            # function map for this operator
+  attr_reader :force_type      # force this type as the result type
+  attr_reader :pre_condition   # proc to be executed before the operator's execution
   attr_reader :post_condition  # proc to be executed after the operator's execution
+  attr_reader :other_args      # list of arguments to the operator other than the operands
 
   #---------------------------------------------------------------------------------------
   #
@@ -90,6 +101,7 @@ class Operator
     @name = name
     @arity = arity
     @exec_type = exec_type
+    @helper = nil
     @force_type = force_type
     @pre_condition = pre_condition  # proc to be executed before the main loop
     @pre_condition_result = nil
@@ -181,12 +193,23 @@ class BinaryOperator < Operator
     requested_type = args.shift
     @type = (@force_type)? @force_type : (requested_type)? requested_type : get_type
     @coerced = @op1.coerced
-    func = MDArray.select_function(@name, MDArray.functions, @type)
-    if (func.is_a? Proc)
-      @do_func = func.dup
+
+    # select_function could use information about the input1 and input2 arguments
+    # but if the operation is cast to the higher type @type and we don't have yet
+    # functions that have different types of arguments for operators, then just
+    # use the higher type.  This is different for comparison operators in which the
+    # return type is boolean and the input types are numeric.
+    if (MDArray.numerical.include?(@type))
+      fmap = MDArray.select_function(@name, MDArray.functions, @type, @type, @type)
     else
-      @do_func = func
+      fmap = MDArray.select_function(@name, MDArray.functions, @type, @op1.type, @op1.type)
     end
+
+    # func = fmap.function
+    @helper = fmap.helper
+    @fmap = fmap
+    # @do_func = func.dup
+    @do_func = (fmap.function).dup
     @other_args = args
 
   end
@@ -257,14 +280,20 @@ class UnaryOperator < Operator
   def parse_args(*args)
 
     @op = args.shift
+
     requested_type = args.shift
     @type = (@force_type)? @force_type : (requested_type)? requested_type : @op.type
-    func = MDArray.select_function(@name, MDArray.functions, @type)
+
+    fmap = MDArray.select_function(@name, MDArray.functions, @type, @type, "void")
+    func = fmap.function
+    @helper = fmap.helper
+
     if (func.is_a? Proc)
       @do_func = func.dup
     else
       @do_func = func
     end
+
     @other_args = args
 
   end

data/lib/mdarray/proc_util.rb

@@ -154,6 +154,8 @@ class Proc
     lambda { |arg| return arg }
   end
 
+  alias :apply :call
+
 end # Proc
 
 

data/lib/mdarray/ruby_boolean_functions.rb

@@ -7,9 +7,33 @@ module BooleanFunctions
   extend FunctionCreation
   extend RubyFunctions
 
+  class And
+    def self.apply(val1, val2)
+      val1 and val2
+    end
+  end
+
+  class Or
+    def self.apply(val1, val2)
+      val1 or val2
+    end
+  end
+
+  class Not
+    def self.apply(val)
+      !val
+    end
+  end
+
+  @and = BooleanFunctions::And
+  @or = BooleanFunctions::Or
+  @not = BooleanFunctions::Not
+
+=begin
   @and = Proc.new { |val1, val2| val1 and val2 }
   @or = Proc.new { |val1, val2| val1 or val2 }
   @not = Proc.new { |val1| !val1}
+=end
 
   @binary_methods = [:and, :or]
   

data/lib/mdarray/ruby_functions.rb

@@ -25,10 +25,80 @@
 
 module RubyFunctions
 
+  class << self
+    attr_reader :binary_helper
+    attr_reader :unary_helper
+  end
+
+  @binary_helper = Java::RbMdarrayLoopsBinops
+  @unary_helper = Java::RbMdarrayLoopsUnops
+
+  #------------------------------------------------------------------------------------
+  #
+  #------------------------------------------------------------------------------------
+
+  def make_binary_operators(name, func, default = true, in_place = true)
+
+    if (default)
+      make_binary_op(name, :default, func, RubyFunctions.binary_helper)
+    end
+    if (in_place)
+      make_binary_op(name + "!", :in_place, func, RubyFunctions.binary_helper)
+    end
+
+  end
+
+  #------------------------------------------------------------------------------------
+  #
+  #------------------------------------------------------------------------------------
+
+  def make_binary_operator(name, type, func)
+    make_binary_op(name, type, func, RubyFunctions.binary_helper)
+  end
+
+  #------------------------------------------------------------------------------------
+  #
+  #------------------------------------------------------------------------------------
+
+  def make_unary_operators(name, func, default = true, in_place = true)
+
+    if (default)
+      make_unary_op(name, :default, func, RubyFunctions.unary_helper)
+    end
+    if (in_place)
+      make_unary_op(name + "!", :in_place, func, RubyFunctions.unary_helper)
+    end
+
+  end
+
+  #------------------------------------------------------------------------------------
+  #
+  #------------------------------------------------------------------------------------
+
+  def make_unary_operator(name, type, func)
+    make_unary_op(name, type, func, RubyFunctions.unary_helper)
+  end
+
+  #------------------------------------------------------------------------------------
+  #
+  #------------------------------------------------------------------------------------
+
+  def make_comparison_operator(name, func)
+    make_binary_op(name, "default", func, RubyFunctions.binary_helper, "boolean")
+  end
+
+  #------------------------------------------------------------------------------------
+  #
+  #------------------------------------------------------------------------------------
+
   def ruby_binary_function(long_name, proc)
     [long_name, "RubyFunctions", proc, "*", "*", "*"]
   end
 
+  #------------------------------------------------------------------------------------
+  #
+  #------------------------------------------------------------------------------------
+
   def ruby_unary_function(long_name, proc)
     [long_name, "RubyFunctions", proc, "*", "*", "*"]
   end
@@ -52,7 +122,8 @@ module UserFunction
 
     function = ruby_binary_function("#{name}_user", func)
     klass = Object.const_get("#{where.capitalize}MDArray")
-    klass.make_binary_op(name, exec_type, function, force_type, pre_condition, post_condition)
+    klass.make_binary_op(name, exec_type, function, RubyFunctions.binary_helper, 
+                         force_type, pre_condition, post_condition)
 
   end
 
@@ -66,7 +137,8 @@ module UserFunction
 
     function = ruby_unary_function("#{name}_user", func)
     klass = Object.const_get("#{where.capitalize}MDArray")
-    klass.make_unary_op(name, exec_type, function, force_type, pre_condition, post_condition)
+    klass.make_unary_op(name, exec_type, function, RubyFunctions.unary_helper, force_type, 
+                        pre_condition, post_condition)
 
   end
 
@@ -77,3 +149,5 @@ require_relative 'ruby_numeric_functions'
 require_relative 'ruby_math'
 require_relative 'ruby_boolean_functions'
 require_relative 'ruby_stats'
+
+MDArray.functions = "RubyFunctions"

data/lib/mdarray/ruby_generic_functions.rb

@@ -7,22 +7,30 @@ module GenericFunctions
   extend FunctionCreation
   extend RubyFunctions
 
+  class Null
+    def self.apply
+    end
+  end
+
+  @null = GenericFunctions::Null
+
+=begin
   @null = Proc.new { }
+=end
 
   #---------------------------------------------------------------------------------------
   #
   #---------------------------------------------------------------------------------------
 
-  make_unary_op("dim_set", :set_block, 
+  make_unary_operator("dim_set", :set_block, 
                 ["ruby_dim_set", "RubyFunctions", @null, "*", "*", "void"])
 
   #---------------------------------------------------------------------------------------
   #
   #---------------------------------------------------------------------------------------
 
-  make_binary_op("fill", :fill, 
-                 ["ruby_fill", "RubyFunctions", @null, "*", "*", "void"])
-
+  make_binary_operator("fill", :fill, 
+                       ["ruby_fill", "RubyFunctions", @null, "*", "*", "*"])
 
 end # GenericFunctions
 

data/lib/mdarray/ruby_math.rb

@@ -5,7 +5,184 @@
 module RubyMath
   extend FunctionCreation
   extend RubyFunctions
-  
+
+  class Acos
+    def self.apply(val)
+      Math.acos(val)
+    end
+  end
+
+  class Acosh
+    def self.apply(val)
+      Math.acosh(val)
+    end
+  end
+
+  class Asin
+    def self.apply(val)
+      Math.asin(val)
+    end
+  end
+
+  class Asinh
+    def self.apply(val)
+      Math.asinh(val)
+    end
+  end
+
+  class Atan
+    def self.apply(val)
+      Math.atan(val)
+    end
+  end
+
+  class Atan2
+    def self.apply(val)
+      Math.atan2(val)
+    end
+  end
+
+  class Atanh
+    def self.apply(val)
+      Math.atanh(val)
+    end
+  end
+
+  class Cbrt
+    def self.apply(val)
+      Math.cbrt(val)
+    end
+  end
+
+  class Cos
+    def self.apply(val)
+      Math.cos(val)
+    end
+  end
+
+  class Cosh
+    def self.apply(val)
+      Math.cosh(val)
+    end
+  end
+
+  class Erf
+    def self.apply(val)
+      Math.erf(val)
+    end
+  end
+
+  class Erfc
+    def self.apply(val)
+      Math.erfc(val)
+    end
+  end
+
+  class Exp
+    def self.apply(val)
+      Math.exp(val)
+    end
+  end
+
+  class Gamma
+    def self.apply(val)
+      Math.gamma(val)
+    end
+  end
+
+  class Hypot
+    def self.apply(val)
+      Math.hypot(val)
+    end
+  end
+
+  class Ldexp
+    def self.apply(val)
+      Math.ldexp(val)
+    end
+  end
+
+  class Log
+    def self.apply(val)
+      Math.log(val)
+    end
+  end
+
+  class Log10
+    def self.apply(val)
+      Math.log10(val)
+    end
+  end
+
+  class Log2
+    def self.apply(val)
+      Math.log2(val)
+    end
+  end
+
+  class Sin
+    def self.apply(val)
+      Math.sin(val)
+    end
+  end
+
+  class Sinh
+    def self.apply(val)
+      Math.sinh(val)
+    end
+  end
+
+  class Sqrt
+    def self.apply(val)
+      Math.sqrt(val)
+    end
+  end
+
+  class Tan
+    def self.apply(val)
+      Math.tan(val)
+    end
+  end
+
+  class Tanh
+    def self.apply(val)
+      Math.tanh(val)
+    end
+  end
+
+  class Neg
+    def self.apply(val)
+      -1 * val
+    end
+  end
+
+  @acos = RubyMath::Acos
+  @acosh = RubyMath::Acosh
+  @asin = RubyMath::Asin
+  @asinh = RubyMath::Asinh
+  @atan = RubyMath::Atan
+  @atan2 = RubyMath::Atan2
+  @atanh = RubyMath::Atanh
+  @cbrt = RubyMath::Cbrt
+  @cos = RubyMath::Cos
+  @cosh = RubyMath::Cosh
+  @erf = RubyMath::Erf
+  @erfc = RubyMath::Erfc
+  @exp = RubyMath::Exp
+  @gamma = RubyMath::Gamma
+  @hypot = RubyMath::Hypot
+  @ldexp = RubyMath::Ldexp
+  @log = RubyMath::Log
+  @log10 = RubyMath::Log10
+  @log2 = RubyMath::Log2
+  @sin = RubyMath::Sin
+  @sinh = RubyMath::Sinh
+  @sqrt = RubyMath::Sqrt
+  @tan = RubyMath::Tan
+  @tanh = RubyMath::Tanh
+  @neg = RubyMath::Neg
+
+=begin
   @acos = Proc.new { |val| Math.acos(val) }
   @acosh = Proc.new { |val| Math.acosh(val) }
   @asin = Proc.new { |val| Math.asin(val) }
@@ -20,7 +197,7 @@ module RubyMath
   @erfc = Proc.new { |val| Math.erfc(val) }
   @exp = Proc.new { |val| Math.exp(val) }
   @gamma = Proc.new { |val| Math.gamma(val) }
-  @hypot = Proc.new { |val| Math.hypotn(val) }
+  @hypot = Proc.new { |val| Math.hypot(val) }
   @ldexp = Proc.new { |val| Math.ldexp(val) }
   @log = Proc.new { |val| Math.log(val) }
   @log10 = Proc.new { |val| Math.log10(val) }
@@ -31,6 +208,7 @@ module RubyMath
   @tan = Proc.new { |val| Math.tan(val) }
   @tanh = Proc.new { |val| Math.tanh(val) }
   @neg = Proc.new { |val| -1 * val }
+=end
 
   @unary_methods = [:acos, :acosh, :asin, :asinh, :atan, :atan2, 
                     :atanh, :cbrt, :cos, :erf, :exp, :gamma, :hypot, :ldexp,