mdarray 0.5.0.pre-java → 0.5.3-java

data/lib/mdarray/access.rb

@@ -70,6 +70,14 @@ class MDArray
     @local_index.get(index)
   end
 
+  #------------------------------------------------------------------------------------
+  # 
+  #------------------------------------------------------------------------------------
+
+  def jget(index = nil)
+    @local_index.jget(index)
+  end
+
   #------------------------------------------------------------------------------------
   # Gets the next element of the local iterator
   #------------------------------------------------------------------------------------

data/lib/mdarray/counter.rb

@@ -178,6 +178,16 @@ class MDArray
       get_at_counter
     end
 
+    #------------------------------------------------------------------------------------
+    # Gets the element at the given counter.  Assumes that the counter is of the proper
+    # shape. Also, counter should be an int java array
+    #------------------------------------------------------------------------------------
+
+    def jget(counter)
+      jset_counter_fast(counter)
+      get_at_counter
+    end
+
     #------------------------------------------------------------------------------------
     # Gets element at current counter.  Can be done fast, as counter is always of the 
     # proper shape.
@@ -328,6 +338,21 @@ class MDArray
 
     end
 
+    #-------------------------------------------------------------------------------------
+    # Sets this index to point to the given counter.  Assumes that the counter respects 
+    # the shape constraints. Also, in this case, the counter should be an int java array.
+    #-------------------------------------------------------------------------------------
+
+    def jset_counter_fast(counter)
+
+      begin
+        @nc_index.set(counter)
+      rescue java.lang.ArrayIndexOutOfBoundsException
+        raise RangeError, "Invalid counter: #{counter}"
+      end
+
+    end
+
     #-------------------------------------------------------------------------------------
     # Sets this index to point to the given counter.  If given counter has negative values
     # then convert them to positive values, making sure that the counter respects the 
@@ -500,6 +525,15 @@ class MDArray
       @nc_index.getCurrentCounter().to_a
     end
 
+    #-------------------------------------------------------------------------------------
+    # Returns the current counter as a java array.  This is for performance improvement.
+    # Should be used carefully so that it doesn't permeate ruby code.
+    #-------------------------------------------------------------------------------------
+
+    def jget_current_counter
+      @nc_index.getCurrentCounter()
+    end
+
   end # Counter
 
   
@@ -545,6 +579,15 @@ class MDArray
       @iterator.getCurrentCounter().to_a
     end
 
+    #-------------------------------------------------------------------------------------
+    # Returns the current counter as a java array.  This is for performance improvement.
+    # Should be used carefully so that it doesn't permeate ruby code.
+    #-------------------------------------------------------------------------------------
+
+    def jget_current_counter
+      @iterator.getCurrentCounter()
+    end
+
     #------------------------------------------------------------------------------------
     #
     #------------------------------------------------------------------------------------
@@ -611,7 +654,6 @@ class MDArray
   #
   #---------------------------------------------------------------------------------------
 
-
   class IteratorFastByte < IteratorFast
 
     def get_current

data/lib/mdarray/creation.rb

@@ -25,13 +25,6 @@
 
 class MDArray
 
-  class << self
-    
-    attr_accessor :binary_operator
-    attr_accessor :unary_operator
-
-  end
-
   #------------------------------------------------------------------------------------
   # Given two types returns the upcasted one
   #------------------------------------------------------------------------------------
@@ -356,15 +349,17 @@ class MDArray
   end
   
   #------------------------------------------------------------------------------------
-  #
+  # fmap is an array with the following data: long_name, scope, function, return_type, 
+  # input1_type, input2_type
   #------------------------------------------------------------------------------------
 
-  def self.register_function(name, func)
+  def self.register_function(name, fmap, arity, helper_class)
     
     if ((list = MDArray.function_map[name]) == nil)
       list = (MDArray.function_map[name] = Array.new)
     end
-    list << FunctionMap.new(name, func[0], func[1], func[2], func[3], func[4], func[5])
+    list << FunctionMap.new(name, fmap[0], fmap[1], fmap[2], fmap[3], fmap[4], fmap[5],
+                            arity, helper_class)
 
   end
 

data/lib/mdarray/fast_operators.rb

@@ -69,7 +69,9 @@ class FastBinaryOperator < BinaryOperator
   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)
@@ -78,13 +80,13 @@ class FastBinaryOperator < BinaryOperator
     get_args(*args) do |op1, op2, shape, *other_args|
       calc = MDArray.build(@type, shape)
       if (@coerced)
-        helper = Java::RbMdarrayLoopsBinops::CoerceBinaryOperator
+        helper = @helper::CoerceBinaryOperator
         helper.send("apply", calc.nc_array, op1, op2, @do_func)
       elsif (@op1.is_a? NumericalMDArray)
-        helper = Java::RbMdarrayLoopsBinops::DefaultBinaryOperator
+        helper = @helper::DefaultBinaryOperator
         helper.send("apply", calc.nc_array, op1, op2, @do_func)
       else
-        helper = Java::RbMdarrayLoopsBinops::DefaultBinaryOperator
+        helper = @helper::DefaultBinaryOperator
         helper.send("apply#{@op1.class}", calc.nc_array, op1, op2, @do_func)
       end
     end
@@ -93,13 +95,15 @@ class FastBinaryOperator < BinaryOperator
   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)
 
     get_args(*args) do |op1, op2, shape, *other_args|
-      helper = Java::RbMdarrayLoopsBinops::FillBinaryOperator
+      helper = @helper::FillBinaryOperator
       helper.send("apply", op1, op2)
     end
 
@@ -112,7 +116,7 @@ class FastBinaryOperator < BinaryOperator
   def in_place(*args)
 
     get_args(*args) do |op1, op2, shape, *other_args|
-      helper = Java::RbMdarrayLoopsBinops::InplaceBinaryOperator
+      helper = @helper::InplaceBinaryOperator
       helper.send("apply", op1, op2, @do_func)
     end
 
@@ -127,7 +131,7 @@ class FastBinaryOperator < BinaryOperator
     calc = nil
 
     get_args(*args) do |op1, op2, shape, *other_args|
-      helper = Java::RbMdarrayLoopsBinops::ReduceBinaryOperator
+      helper = @helper::ReduceBinaryOperator
       calc = @pre_condition_result
       calc = helper.send("apply", calc, op1, op2, @do_func)
     end
@@ -145,7 +149,7 @@ class FastBinaryOperator < BinaryOperator
     calc = nil
 
     get_args(*args) do |op1, op2, shape, *other_args|
-      helper = Java::RbMdarrayLoopsBinops::ComplexReduceBinaryOperator
+      helper = @helper::ComplexReduceBinaryOperator
       calc = @pre_condition_result
       calc = helper.send("apply", calc, op1, op2, @do_func)
     end
@@ -181,7 +185,7 @@ class FastUnaryOperator < UnaryOperator
 
     get_args(*args) do |op1, shape, *other_args|
       block = other_args[0]
-      helper = Java::RbMdarrayLoopsUnops::SetAll
+      helper = @helper::SetAll
       func = (shape.size <= 7)? "apply#{shape.size}" : "apply"
       helper.send(func, op1, &block) if block
     end
@@ -197,7 +201,7 @@ class FastUnaryOperator < UnaryOperator
     calc = nil
     get_args(*args) do |op1, shape, *other_args|
       calc = MDArray.build(@type, shape)
-      helper = Java::RbMdarrayLoopsUnops::DefaultUnaryOperator
+      helper = @helper::DefaultUnaryOperator
       helper.send("apply", calc.nc_array, op1, @do_func)
     end
     return calc
@@ -211,7 +215,7 @@ class FastUnaryOperator < UnaryOperator
   def in_place(*args)
 
     get_args(*args) do |op1, shape, *other_args|
-      helper = Java::RbMdarrayLoopsUnops::InplaceUnaryOperator
+      helper = @helper::InplaceUnaryOperator
       helper.send("apply", op1, @do_func)
     end
 
@@ -226,7 +230,7 @@ class FastUnaryOperator < UnaryOperator
     calc = nil
 
     get_args(*args) do |op1, shape, *other_args|
-      helper = Java::RbMdarrayLoopsUnops::ReduceUnaryOperator
+      helper = @helper::ReduceUnaryOperator
       calc = @pre_condition_result
       calc = helper.send("apply", calc, op1, @do_func)
     end

data/lib/mdarray/function_creation.rb

@@ -29,16 +29,20 @@ module FunctionCreation
   #
   #------------------------------------------------------------------------------------
 
-  def make_binary_op(name, exec_type, func, force_type = nil, pre_condition = nil,
-                     post_condition = nil)
+  def make_binary_op(name, exec_type, func, helper_class, force_type = nil, 
+                     pre_condition = nil, post_condition = nil)
 
     define_method(name) do |op2, requested_type = nil, *args|
-      binary_op = get_binary_op
+      if (@type == "lazy" || ((op2.is_a? MDArray) && op2.type == "lazy"))
+        binary_op = LazyBinaryOperator
+      else
+        binary_op = get_binary_op
+      end
       op = binary_op.new(name, exec_type, force_type, pre_condition, post_condition)
       op.exec(self, op2, requested_type, *args)
     end
 
-    MDArray.register_function(name, func)
+    MDArray.register_function(name, func, 2, helper_class)
 
   end
 
@@ -46,23 +50,8 @@ module FunctionCreation
   #
   #------------------------------------------------------------------------------------
 
-  def make_binary_operators(name, func, default = true, in_place = true)
-
-    if (default)
-      make_binary_op(name, "default", func)
-    end
-    if (in_place)
-      make_binary_op(name + "!", "in_place", func)
-    end
-
-  end
-
-  #------------------------------------------------------------------------------------
-  #
-  #------------------------------------------------------------------------------------
-
-  def make_unary_op(name, exec_type, func, force_type = nil, pre_condition = nil,
-                    post_condition = nil)
+  def make_unary_op(name, exec_type, func, helper_class, force_type = nil, 
+                    pre_condition = nil, post_condition = nil)
     
     define_method(name) do |requested_type = nil, *args|
       unary_op = get_unary_op
@@ -70,31 +59,8 @@ module FunctionCreation
       op.exec(self, requested_type, *args)
     end
 
-    MDArray.register_function(name, func)
-
-  end
-
-  #------------------------------------------------------------------------------------
-  #
-  #------------------------------------------------------------------------------------
-
-  def make_unary_operators(name, func, default = true, in_place = true)
-
-    if (default)
-      make_unary_op(name, "default", func)
-    end
-    if (in_place)
-      make_unary_op(name + "!", "in_place", func)
-    end
-
-  end
-
-  #------------------------------------------------------------------------------------
-  #
-  #------------------------------------------------------------------------------------
+    MDArray.register_function(name, func, 1, helper_class)
 
-  def make_comparison_op(name, func)
-    make_binary_op(name, "default", func, "boolean")
   end
 
 end # FunctionCreation

data/lib/mdarray/function_map.rb

@@ -25,30 +25,38 @@
 
 class FunctionMap
 
-  attr_reader :short_name
-  attr_reader :long_name
-  attr_reader :scope
-  attr_reader :function
+  attr_reader :short_name      # short name of the function
+  attr_reader :long_name       # long name of the function
+  attr_reader :package         # package where the function was implemented
+  attr_reader :function        # function to be applied to elmts
   attr_reader :return_type
   attr_reader :input1_type
   attr_reader :input2_type
-
+  attr_reader :arity            # arity of the function: 1 or 2
+  attr_reader :helper           # Helper method to perform the function
+  attr_reader :is_global        # set to true if function applies to all elmts of the
+                                # array.  By default set to false
+  attr_reader :elmtwise         # works elementwise
   attr_accessor :description
 
   #------------------------------------------------------------------------------------
   #
   #------------------------------------------------------------------------------------
 
-  def initialize(short_name, long_name, scope, function, return_type, input1_type,
-                 input2_type)
+  def initialize(short_name, long_name, package, function, return_type, input1_type,
+                 input2_type, arity, helper, elmtwise = true, is_global = false)
 
     @short_name = short_name
     @long_name = long_name
-    @scope = scope
+    @package = package
     @function = function
     @return_type = return_type
     @input1_type = input1_type
     @input2_type = input2_type
+    @arity = arity
+    @helper = helper
+    @elmtwise = elmtwise
+    @is_global = is_global
 
   end # initialize
 

data/lib/mdarray/lazy_mdarray.rb

@@ -0,0 +1,311 @@
+# -*- 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 LazyMDArray < ByteMDArray
+  include_package "ucar.ma2"
+  include_package "org.codehaus.janino"
+
+  attr_reader :stack
+
+  #=======================================================================================
+  # Class BinaryComp applies a function f to two arguments.  The arguments can be
+  # functions on their own right
+  #=======================================================================================
+
+  class BinaryComp
+
+    def initialize(f, x, y, *args)
+      @x = x
+      @y = y
+      @f = f
+      @other_args = args
+    end
+    
+    def apply
+      @f.apply(@x.apply, @y.apply)
+    end
+
+  end # BinaryComp
+
+  #=======================================================================================
+  # Class UnaryComp applies a function f to one arguments.  The arguments can be a
+  # function on its own right
+  #=======================================================================================
+
+  class UnaryComp
+
+    def initialize(f, x, *args)
+      @x = x
+      @f = f
+      @other_args = args
+    end
+    
+    def apply
+      @f.apply(@x.apply)
+    end
+
+  end # UnaryComp
+
+  #=======================================================================================
+  #
+  #=======================================================================================
+
+
+  #---------------------------------------------------------------------------------------
+  #
+  #---------------------------------------------------------------------------------------
+
+  def initialize
+
+    @stack = Array.new
+    @type = "lazy"
+    @previous_binary_operator = nil
+    @previous_unary_operator = nil
+
+  end
+
+  #---------------------------------------------------------------------------------------
+  #
+  #---------------------------------------------------------------------------------------
+
+  def push(elmt)
+    @stack << elmt
+  end
+
+  #---------------------------------------------------------------------------------------
+  #
+  #---------------------------------------------------------------------------------------
+
+  def pop
+    @stack.pop
+  end
+
+  #---------------------------------------------------------------------------------------
+  #
+  #---------------------------------------------------------------------------------------
+
+  def test_janino_function
+    $exp = ExpressionEvaluator.new
+    $exp.setExpressionType(Java::CernColtFunctionTdouble::DoubleFunction.java_class)
+    class_type = Java::JavaLang::Class.forName("java.lang.Class")
+    array = Java::JavaLangReflect::Array.newInstance(class_type, 2)
+    array[0] = Java::double.java_class
+    array[1] = Java::double.java_class
+    $exp.setParameters(["a", "b"].to_java(:string), 
+                       array)
+    $exp.cook("a + b")
+  end
+
+  #---------------------------------------------------------------------------------------
+  #
+  #---------------------------------------------------------------------------------------
+
+  def apply(*args)
+
+    type, shape, function = validate_fast(args)
+
+    result = MDArray.build(type, shape)
+    helper = Java::RbMdarrayLoopsLazy::DefaultLazyOperator
+    helper.send("apply", result.nc_array, function)
+    result
+
+  end
+
+  alias :[] :apply
+
+  #---------------------------------------------------------------------------------------
+  # Shows this LazyMDArray in Reverse Polish Notation. Mainly for debugging purposes.
+  #---------------------------------------------------------------------------------------
+
+  def rpn(nl = true)
+ 
+    exp = String.new
+
+    @stack.each do |elmt|
+
+      if (elmt.is_a? LazyMDArray)
+        exp << elmt.rpn(false)
+      elsif (elmt.is_a? Numeric)
+        exp << elmt << " "
+      elsif (elmt.is_a? Operator)
+        exp << elmt.name << " "
+      elsif (elmt.is_a? MDArray)
+        exp << elmt.type << " "
+      else
+        raise "Wrong element type in Array"
+      end
+
+    end
+
+    exp
+
+  end
+
+  #---------------------------------------------------------------------------------------
+  #
+  #---------------------------------------------------------------------------------------
+
+  def print
+    Kernel.print "[Lazy MDArray]\n"
+    p rpn
+  end
+
+  #---------------------------------------------------------------------------------------
+  # Validates the expression checking if it can be performed: all dimensions need to be
+  # compatible
+  #---------------------------------------------------------------------------------------
+
+  protected
+
+  def validate_fast(*args)
+
+    # test_janino_function
+    # p "validade_fast compile janino expression:"
+    # $exp.apply(100, 100)
+
+    helper_stack = Array.new
+
+    @stack.each do |elmt|
+
+      if (elmt.is_a? LazyMDArray)
+        helper_stack << elmt.validate_fast(*args)
+      elsif (elmt.is_a? MDArray)
+        # helper_stack << [elmt.type, elmt.shape, index_func(elmt)]
+        # iterator = elmt.nc_array.getIndexIterator
+        java_proc = Java::RbMdarrayUtil::Util.getIterator(elmt.nc_array)
+        helper_stack << [elmt.type, elmt.shape, java_proc]
+      elsif (elmt.is_a? Numeric)
+        # const_func is inefficient... fix!!!
+        helper_stack << ["numeric", 1, const_func(elmt)]
+      elsif (elmt.is_a? Operator)
+        case elmt.arity
+        when 1
+          top = helper_stack.pop
+          fmap = MDArray.select_function(elmt.name, MDArray.functions, top[0],
+                                         top[0], "void")
+          helper_stack << 
+            [top[0], top[1], 
+             # UnaryComp.new(top[2], fmap.function, elmt.other_args)]
+             Java::RbMdarrayUtil::Util.compose(fmap.function, top[2])]
+        when 2
+          top1, top2 = helper_stack.pop(2)
+          if (top1[1] != top2[1] && top1[0] != "numeric" && top2[0] != "numeric")
+            raise "Expression involves incopatible arrays. #{top1[1]} != #{top2[1]}"
+          end
+          type = MDArray.upcast(top1[0], top2[0])
+          fmap = MDArray.select_function(elmt.name, MDArray.functions, type, type, type)
+          helper_stack << 
+            [type, top1[1], 
+             Java::RbMdarrayUtil::Util.compose(fmap.function, top1[2], top2[2])]
+        end
+      else
+        raise "Expression is invalid: element #{elmt} is not valid in this position."
+      end
+      
+    end
+    
+    helper_stack[0]
+
+  end
+
+  #---------------------------------------------------------------------------------------
+  #
+  #---------------------------------------------------------------------------------------
+
+  private
+
+  #---------------------------------------------------------------------------------------
+  #
+  #---------------------------------------------------------------------------------------
+
+  def const_func(val)
+    Proc.new { |index| val }
+  end
+
+  #---------------------------------------------------------------------------------------
+  #
+  #---------------------------------------------------------------------------------------
+
+  def index_func(a)
+    Proc.new { |index| a.jget(index) }
+  end
+
+  #---------------------------------------------------------------------------------------
+  #
+  #---------------------------------------------------------------------------------------
+
+  def get_next_func(a)
+    Proc.new { a.getObjectNext() }
+  end
+
+  #---------------------------------------------------------------------------------------
+  #
+  #---------------------------------------------------------------------------------------
+  
+  def binary_function_next(proc1, proc2, f, *args)
+    Proc.new { f.call(proc1.apply, proc2.apply, *args) }
+  end
+
+end # LazyMDArray
+
+##########################################################################################
+#
+##########################################################################################
+
+class MDArray
+
+  #---------------------------------------------------------------------------------------
+  # 
+  #---------------------------------------------------------------------------------------
+
+  def self.set_lazy(flag = true)
+
+    if (flag)
+      if (MDArray.binary_operator != LazyBinaryOperator)
+        MDArray.previous_binary_operator = MDArray.binary_operator
+        MDArray.previous_unary_operator = MDArray.unary_operator
+      end
+      MDArray.binary_operator = LazyBinaryOperator
+      MDArray.unary_operator = LazyUnaryOperator
+    else
+      MDArray.binary_operator = MDArray.previous_binary_operator if MDArray.previous_binary_operator != nil
+      MDArray.unary_operator = MDArray.previous_unary_operator if MDArray.previous_unary_operator != nil
+    end
+
+  end
+
+  #---------------------------------------------------------------------------------------
+  # 
+  #---------------------------------------------------------------------------------------
+
+  def self.lazy=(flag)
+    set_lazy(flag)
+  end
+
+end
+
+require_relative 'lazy_operators'