mdarray 0.5.0.pre-java → 0.5.3-java

data/lib/colt/cern_int_functions.rb

@@ -0,0 +1,152 @@
+# -*- 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.
+##########################################################################################
+
+require 'java'
+
+##########################################################################################
+#
+##########################################################################################
+
+class Java::CernJetMathTint::IntFunctions
+  include_package "cern.jet.math.tint"
+
+  cern_methods = [:abs, :compare, :div, :divNeg, :equals, :isEqual, :isGreater, :isLess,
+                  :max, :min, :minus, :mod, :mult, :multNeg, :multSquare, :neg, :plus, 
+                  :plusAbs, :pow, :sign, :square,
+                  :and, :dec, :factorial, :inc, :not, :or, :shiftLeft,
+                  :shiftRightSigned, :shiftRightUnsigned, :xor]
+
+  # methods that also exist for types double and float
+  java_alias :unary_compare, :compare, [Java::int]
+  java_alias :unary_div, :div, [Java::int]
+  java_alias :unary_equals, :equals, [Java::int]
+  java_alias :unary_isEqual, :isEqual, [Java::int]
+  java_alias :unary_isGreater, :isGreater, [Java::int]
+  java_alias :unary_isLess, :isLess, [Java::int]
+  java_alias :unary_max, :max, [Java::int]
+  java_alias :unary_min, :min, [Java::int]
+  java_alias :unary_minus, :minus, [Java::int]
+  java_alias :unary_mod, :mod, [Java::int]
+  java_alias :unary_mult, :mult, [Java::int]
+  java_alias :unary_plus, :plus, [Java::int]
+  java_alias :unary_pow, :pow, [Java::int]
+
+  # methods that only exist for types long and int
+  java_alias :unary_and, :and, [Java::int]
+  java_alias :unary_or, :or, [Java::int]
+  java_alias :unary_shiftLeft, :shiftLeft, [Java::int]
+  java_alias :unary_shiftRightSigned, :shiftRightSigned, [Java::int]
+  java_alias :unary_shiftRightUnsigned, :shiftRightUnsigned, [Java::int]
+  java_alias :unary_xor, :xor, [Java::int]
+
+  
+  cern_methods.each do |method|
+    field_reader(method)
+    attr_reader(":#{method}")
+  end
+  
+end
+
+##########################################################################################
+#
+##########################################################################################
+
+module CernIntFunctions
+  include_package "cern.jet.math.tint"
+  extend FunctionCreation
+  extend CernFunctions
+  
+  binary_methods = [:compare, :div, :divNeg, :equals, :minus, :mod, :mult, :multNeg, 
+                    :multSquare, :plus, :plusAbs, :pow, 
+                    :and, :or, :shiftLeft, :shiftRightSigned, :shiftRightUnsigned, :xor]
+
+  unary_methods = [:abs, :neg, :sign, :square, :dec, :factorial, :inc, :not]
+
+  comparison_methods = [:isEqual, :isGreater, :isLess]
+
+  binary_conflict_methods = [:max, :min]
+
+  binary_methods.each do |method|
+    make_binary_operators(method.to_s,
+                          cern_binary_function(method.to_s, "#{method}_int", 
+                                               Java::CernJetMathTint.IntFunctions,
+                                               "int"))
+  end
+
+  unary_methods.each do |method|
+    make_unary_operators(method.to_s, 
+                         cern_unary_function(method.to_s, "#{method}_int", 
+                                             Java::CernJetMathTint.IntFunctions,
+                                             "int"))
+  end
+
+  comparison_methods.each do |method|
+    make_comparison_operator(method.to_s, 
+                             cern_comparison_function(method.to_s, "#{method}_double", 
+                                                      Java::CernJetMathTint.IntFunctions,
+                                                      "int"))
+  end
+  
+  binary_conflict_methods.each do |method|
+    make_binary_operators("cern_#{method}",
+                          cern_binary_function(method.to_s, "cern_#{method}_double", 
+                                               Java::CernJetMathTint.IntFunctions,
+                                               "int"))
+  end
+  
+  def self.register(als, name, int_name, type)
+    map = cern_binary_function(name, int_name, Java::CernJetMathTint.IntFunctions,
+                               type)
+    MDArray.register_function(als, map, 2, CernFunctions.binary_helper)
+  end
+
+  alias :div_neg :divNeg
+  alias :is_equal :isEqual
+  alias :is_greater :isGreater
+  alias :is_less :isLess
+  alias :mult_neg :multNeg
+  alias :mult_square :multSquare
+  alias :plus_abs :plusAbs
+  alias :shift_left :shiftLeft
+  alias :shift_right_signed :shiftRightSigned
+  alias :shift_right_unsigned :shiftRightUnsigned
+
+  register(:add, :plus, :plus_int, "int")
+  register(:sub, :minus, :minus_int, "int")
+  register(:mul, :mult, :mult_int, "int")
+  register(:power, :pow, :pow_int, "int")
+  register(:eq, :equals, :equals_int, "int")
+  register(:gt, :isGreater, :is_greater_int, "int")
+  register(:lt, :isLess, :is_less_int, "int")
+  register(:binary_left_shift, :shiftLeft, :shift_left_int, "int")
+  register(:binary_right_shift, :shiftRightSigned, :shift_right_int, "int")
+
+end
+
+##########################################################################################
+#
+##########################################################################################
+
+class IntMDArray
+
+  include CernIntFunctions
+      
+end # IntMDArray

data/lib/colt/cern_long_functions.rb

@@ -0,0 +1,152 @@
+# -*- 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.
+##########################################################################################
+
+require 'java'
+
+##########################################################################################
+#
+##########################################################################################
+
+class Java::CernJetMathTlong::LongFunctions
+  include_package "cern.jet.math.tlong"
+
+  cern_methods = [:abs, :compare, :div, :divNeg, :equals, :isEqual, :isGreater, :isLess,
+                  :max, :min, :minus, :mod, :mult, :multNeg, :multSquare, :neg, :plus, 
+                  :plusAbs, :pow, :sign, :square,
+                  :and, :dec, :factorial, :inc, :not, :or, :shiftLeft,
+                  :shiftRightSigned, :shiftRightUnsigned, :xor]
+
+  # methods that also exist for types double and float
+  java_alias :unary_compare, :compare, [Java::long]
+  java_alias :unary_div, :div, [Java::long]
+  java_alias :unary_equals, :equals, [Java::long]
+  java_alias :unary_isEqual, :isEqual, [Java::long]
+  java_alias :unary_isGreater, :isGreater, [Java::long]
+  java_alias :unary_isLess, :isLess, [Java::long]
+  java_alias :unary_max, :max, [Java::long]
+  java_alias :unary_min, :min, [Java::long]
+  java_alias :unary_minus, :minus, [Java::long]
+  java_alias :unary_mod, :mod, [Java::long]
+  java_alias :unary_mult, :mult, [Java::long]
+  java_alias :unary_plus, :plus, [Java::long]
+  java_alias :unary_pow, :pow, [Java::long]
+
+  # methods that only exist for types long and int
+  java_alias :unary_and, :and, [Java::long]
+  java_alias :unary_or, :or, [Java::long]
+  java_alias :unary_shiftLeft, :shiftLeft, [Java::long]
+  java_alias :unary_shiftRightSigned, :shiftRightSigned, [Java::long]
+  java_alias :unary_shiftRightUnsigned, :shiftRightUnsigned, [Java::long]
+  java_alias :unary_xor, :xor, [Java::long]
+
+  
+  cern_methods.each do |method|
+    field_reader(method)
+    attr_reader(":#{method}")
+  end
+  
+end
+
+##########################################################################################
+#
+##########################################################################################
+
+module CernLongFunctions
+  include_package "cern.jet.math.tlong"
+  extend FunctionCreation
+  extend CernFunctions
+    
+  binary_methods = [:compare, :div, :divNeg, :equals, :minus, :mod, :mult, :multNeg, 
+                    :multSquare, :plus, :plusAbs, :pow, 
+                    :and, :or, :shiftLeft, :shiftRightSigned, :shiftRightUnsigned, :xor]
+
+  unary_methods = [:abs, :neg, :sign, :square, :dec, :factorial, :inc, :not]
+
+  comparison_methods = [:isEqual, :isGreater, :isLess]
+
+  binary_conflict_methods = [:max, :min]
+
+  binary_methods.each do |method|
+    make_binary_operators(method.to_s,
+                          cern_binary_function(method.to_s, "#{method}_long", 
+                                               Java::CernJetMathTlong.LongFunctions,
+                                               "long"))
+  end
+
+  unary_methods.each do |method|
+    make_unary_operators(method.to_s, 
+                         cern_unary_function(method.to_s, "#{method}_long", 
+                                             Java::CernJetMathTlong.LongFunctions,
+                                             "long"))
+  end
+
+  comparison_methods.each do |method|
+    make_comparison_operator(method.to_s, 
+                             cern_comparison_function(method.to_s, "#{method}_double", 
+                                                      Java::CernJetMathTlong.LongFunctions,
+                                                      "long"))
+  end
+  
+  binary_conflict_methods.each do |method|
+    make_binary_operators("cern_#{method}",
+                          cern_binary_function(method.to_s, "cern_#{method}_double", 
+                                               Java::CernJetMathTlong.LongFunctions,
+                                               "long"))
+  end
+  
+  def self.register(als, name, long_name, type)
+    map = cern_binary_function(name, long_name, Java::CernJetMathTlong.LongFunctions,
+                               type)
+    MDArray.register_function(als, map, 2, CernFunctions.binary_helper)
+  end
+
+  alias :div_neg :divNeg
+  alias :is_equal :isEqual
+  alias :is_greater :isGreater
+  alias :is_less :isLess
+  alias :mult_neg :multNeg
+  alias :mult_square :multSquare
+  alias :plus_abs :plusAbs
+  alias :shift_left :shiftLeft
+  alias :shift_right_signed :shiftRightSigned
+  alias :shift_right_unsigned :shiftRightUnsigned
+
+  register(:add, :plus, :plus_long, "long")
+  register(:sub, :minus, :minus_long, "long")
+  register(:mul, :mult, :mult_long, "long")
+  register(:power, :pow, :pow_long, "long")
+  register(:eq, :equals, :equals_long, "long")
+  register(:gt, :isGreater, :is_greater_long, "long")
+  register(:lt, :isLess, :is_less_long, "long")
+  register(:binary_left_shift, :shiftLeft, :shift_left_long, "long")
+  register(:binary_right_shift, :shiftRightSigned, :shift_right_long, "long")
+
+end
+
+##########################################################################################
+#
+##########################################################################################
+
+class LongMDArray
+
+  include CernLongFunctions
+      
+end # LongMDArray

data/lib/colt/colt.rb

@@ -49,8 +49,110 @@ class Colt
   
 end # Colt
 
+##########################################################################################
+#
+##########################################################################################
+
+module CernFunctions
+
+  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, CernFunctions.binary_helper)
+    end
+    if (in_place)
+      make_binary_op(name + "!", :in_place, func, CernFunctions.binary_helper)
+    end
+
+  end
+
+  #------------------------------------------------------------------------------------
+  #
+  #------------------------------------------------------------------------------------
+
+  def make_binary_operator(name, type, func)
+    make_binary_op(name, type, func, CernFunctions.binary_helper)
+  end
+
+  #------------------------------------------------------------------------------------
+  #
+  #------------------------------------------------------------------------------------
+
+  def make_unary_operators(name, func, default = true, in_place = true)
+
+    if (default)
+      make_unary_op(name, :default, func, CernFunctions.unary_helper)
+    end
+    if (in_place)
+      make_unary_op(name + "!", :in_place, func, CernFunctions.unary_helper)
+    end
+
+  end
+
+  #------------------------------------------------------------------------------------
+  #
+  #------------------------------------------------------------------------------------
+
+  def make_unary_operator(name, type, func)
+    make_unary_op(name, type, func, CernFunctions.unary_helper)
+  end
+
+  #------------------------------------------------------------------------------------
+  #
+  #------------------------------------------------------------------------------------
+
+  def make_comparison_operator(name, func)
+    make_binary_op(name, "default", func, CernFunctions.binary_helper, "boolean")
+  end
+
+  #------------------------------------------------------------------------------------
+  #
+  #------------------------------------------------------------------------------------
+
+  def cern_binary_function(short_name, long_name, module_name, type)
+    [long_name, "CernFunctions", module_name.send(short_name), type, type, type]
+  end
+
+  #------------------------------------------------------------------------------------
+  #
+  #------------------------------------------------------------------------------------
+
+  def cern_unary_function(short_name, long_name, module_name, type)
+    [long_name, "CernFunctions", module_name.send(short_name), type, type, "void"]
+  end
+
+  #------------------------------------------------------------------------------------
+  #
+  #------------------------------------------------------------------------------------
+
+  def cern_comparison_function(short_name, long_name, module_name, type)
+    [long_name, "CernFunctions", module_name.send(short_name), "boolean", type, type]
+  end
+
+end # CernFunctions
+
+##########################################################################################
+#
+##########################################################################################
+
 require_relative 'stat_list'
 require_relative 'colt_mdarray'
+require_relative 'cern_double_functions'
+require_relative 'cern_float_functions'
+require_relative 'cern_long_functions'
+require_relative 'cern_int_functions'
 
-# MDArray.functions = "CernFunctions"
+MDArray.functions = "CernFunctions"
 

data/lib/mdarray.rb

@@ -77,19 +77,22 @@ class MDArray
   attr_accessor :unary_operator 
   attr_accessor :coerced
   
-  @numerical = ["byte", "short", "int", "long", "float", "double"]
+  @numerical = ["numeric", "byte", "short", "int", "long", "float", "double"]
   @non_numerical = ["boolean", "char", "string", "sequence"]
 
   class << self
     
     attr_accessor :functions
     attr_accessor :function_map
-
     attr_reader :numerical
     attr_reader :non_numerical
-
+    attr_accessor :binary_operator
+    attr_accessor :unary_operator
+    attr_accessor :previous_binary_operator
+    attr_accessor :previous_unary_operator
+        
   end
-
+  
   MDArray.function_map = Map.new
 
   #------------------------------------------------------------------------------------
@@ -214,7 +217,7 @@ class MDArray
 
       value.each do |func|
 
-        p "scope: #{func.scope}, short name: #{key}, long name: #{func.long_name}, return type: #{func.return_type}, input1 type: #{func.input1_type}, input2 type: #{func.input2_type}"
+        p "package: #{func.package}, short name: #{key}, long name: #{func.long_name}, return type: #{func.return_type}, input1 type: #{func.input1_type}, input2 type: #{func.input2_type}"
 
       end
 
@@ -255,16 +258,20 @@ class MDArray
   # @param post_condition Proc to be executed after the operator's execution
   #------------------------------------------------------------------------------------
 
-  def self.make_binary_op(name, exec_type, func, force_type = nil, pre_condition = nil,
-                          post_condition = nil)
+  def self.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
 
@@ -284,8 +291,8 @@ class MDArray
   # @param post_condition Proc to be executed after the operator's execution
   #------------------------------------------------------------------------------------
 
-  def self.make_unary_op(name, exec_type, func, force_type = nil, pre_condition = nil,
-                         post_condition = nil)
+  def self.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
@@ -293,7 +300,23 @@ class MDArray
       op.exec(self, requested_type, *args)
     end
 
-    MDArray.register_function(name, func)
+    MDArray.register_function(name, func, 1, helper_class)
+
+  end
+
+  #---------------------------------------------------------------------------------------
+  #
+  #---------------------------------------------------------------------------------------
+
+  def self.calc_value(given_type, function_type, match, partial_match, no_match)
+
+    if (given_type == function_type)
+      match
+    elsif ((function_type == "*") || (given_type == "*"))
+      partial_match
+    else
+      no_match
+    end
 
   end
 
@@ -311,28 +334,52 @@ class MDArray
   # @param input2_type the type of the second argument to the function
   #---------------------------------------------------------------------------------------
 
-  def self.select_function(name, scope = nil, return_type = nil, input1_type = nil, 
+  def self.select_function(name, package = nil, return_type = nil, input1_type = nil, 
                            input2_type = nil)
 
+
+=begin
+    p "selecting function: #{name}"
+    p "return_type: #{return_type}"
+    p "input1_type: #{input1_type}"
+    p "input2_type: #{input2_type}"
+=end
+
     list = MDArray.function_map[name]
     best_value = -1
     func = nil
 
     list.each do |function|
-
-      value = 0
-      value += (scope == function.scope)? 8 : 0
-      value += (return_type == function.return_type)? 4 : 0
-      value += (input1_type == function.input1_type)? 2 : 0
-      value += (input2_type == function.input2_type)? 1 : 0
-      if (value > best_value)
-        func = function.function
+      value = (package == function.package)? 2 : 1
+      # p "package: #{package}; function package: #{function.package}"
+      # p value
+      value *= calc_value(return_type, function.return_type, 32, 16, 0)
+      # p "return_type: #{return_type}; func_ret_type: #{function.return_type}"
+      # p value
+      value *= calc_value(input1_type, function.input1_type, 8, 4, 0)
+      # p "input1_type: #{input1_type}; func_input1_type: #{function.input1_type}"
+      # p value
+      value *= calc_value(input2_type, function.input2_type, 2, 1, 0)
+      # p "input2_type: #{input2_type}; func_input2_type: #{function.input2_type}"
+      # p value
+      if (value == 0)
+        next
+      elsif (value > best_value)
+        func = function
         best_value = value
-        # p "best value: #{best_value}, func: #{func}"
       end
     end
 
-    func
+=begin
+    p "MDArray.select_function"
+    p "selected function #{func.function}"
+=end
+
+    if (best_value > 0)
+      func
+    else
+      raise "No method to process operator: #{name}"
+    end
 
   end
 
@@ -385,5 +432,6 @@ require_relative 'mdarray/views'
 require_relative 'mdarray/printing'
 require_relative 'mdarray/counter'
 require_relative 'mdarray/ruby_stats'
+require_relative 'mdarray/lazy_mdarray'
 require_relative 'mdarray/csv'
 require_relative 'colt/colt'