mdarray 0.5.0.pre-java → 0.5.3-java

data/lib/mdarray/ruby_numeric_functions.rb

@@ -5,10 +5,118 @@
 
 module NumericFunctions
   include_package "ucar.ma2.MAMath"
-
   extend FunctionCreation
   extend RubyFunctions
 
+  class Add
+    def self.apply(val1, val2)
+      val1 + val2
+    end
+  end
+
+  class Sub
+    def self.apply(val1, val2)
+      val1 - val2
+    end
+  end
+
+  class Mul
+    def self.apply(val1, val2)
+      val1 * val2
+    end
+  end
+
+  class Div
+    def self.apply(val1, val2)
+      val1 / val2
+    end
+  end
+
+  class Power
+    def self.apply(val1, val2)
+      val1 ** val2
+    end
+  end
+
+  class Abs
+    def self.apply(val)
+      val.abs
+    end
+  end
+
+  class Ceil
+    def self.apply(val)
+      val.ceil
+    end
+  end
+
+  class Floor
+    def self.apply(val)
+      val.floor
+    end
+  end
+
+  class Truncate
+    def self.apply(val)
+      val.truncate
+    end
+  end
+
+  class IsZero
+    def self.apply(val)
+      val.zero
+    end
+  end
+
+  class Square
+    def self.apply(val)
+      val * val
+    end
+  end
+
+  class Cube
+    def self.apply(val)
+      val1 * val * val
+    end
+  end
+
+  class Fourth
+    def self.apply(val)
+      val * val * val * val
+    end
+  end
+
+  class Min
+    def self.apply(val1, val2)
+      val1 < val2 ? val1 : val2
+    end
+  end
+
+  class Max
+    def self.apply(val1, val2)
+      val1 > val2 ? val1 : val2
+    end
+  end
+
+  @add = NumericFunctions::Add
+  @sub = NumericFunctions::Sub
+  @mul = NumericFunctions::Mul
+  @div = NumericFunctions::Div
+  @power = NumericFunctions::Power
+  @abs = NumericFunctions::Abs
+  @ceil = NumericFunctions::Ceil
+  @floor = NumericFunctions::Floor
+  @truncate = NumericFunctions::Truncate
+  @is_zero = NumericFunctions::IsZero
+  @square = NumericFunctions::Square
+  @cube = NumericFunctions::Cube
+  @fourth = NumericFunctions::Fourth
+  @min = NumericFunctions::Min
+  @max = NumericFunctions::Max
+
+=begin
+  Using Proc is much more inefficient than using classes as defined above
+
   @add = Proc.new { |val1, val2| val1 + val2 }
   @sub = Proc.new { |val1, val2| val1 - val2 }
   @mul = Proc.new { |val1, val2| val1 * val2 }
@@ -25,7 +133,8 @@ module NumericFunctions
   
   @min = Proc.new { |val1, val2| val1 < val2 ? val1 : val2 }
   @max = Proc.new { |val1, val2| val1 > val2 ? val1 : val2 }
-  
+=end
+
   #---------------------------------------------------------------------------------------
   #
   #---------------------------------------------------------------------------------------
@@ -92,18 +201,56 @@ module ComparisonOperators
   extend FunctionCreation
   extend RubyFunctions
 
+  class Ge
+    def self.apply(val1, val2)
+      val1 >= val2 ? true : false
+    end
+  end
+
+  class Gt
+    def self.apply(val1, val2)
+      val1 > val2 ? true : false
+    end
+  end
+
+  class Le
+    def self.apply(val1, val2)
+      val1 <= val2 ? true : false
+    end
+  end
+
+  class Lt
+    def self.apply(val1, val2)
+      val1 < val2 ? true : false
+    end
+  end
+
+  class Eq
+    def self.apply(val1, val2)
+      val1 == val2 ? true : false
+    end
+  end
+
+  @ge = ComparisonOperators::Ge
+  @gt = ComparisonOperators::Gt
+  @le = ComparisonOperators::Le
+  @lt = ComparisonOperators::Lt
+  @eq = ComparisonOperators::Eq
+
+=begin
   @ge = Proc.new { |val1, val2| val1 >= val2 ? true : false}
   @gt = Proc.new { |val1, val2| val1 > val2 ? true : false}
   @le = Proc.new { |val1, val2| val1 <= val2 ? true : false}
   @lt = Proc.new { |val1, val2| val1 < val2 ? true : false}
   @eq = Proc.new { |val1, val2| val1 == val2 ? true : false}
+=end
 
   @binary_methods = [:ge, :gt, :le, :lt, :eq]
 
   @binary_methods.each do |method|
-    make_comparison_op(method.to_s,
-                       ruby_binary_function("#{method.to_s}_ruby", 
-                                            instance_variable_get("@#{method.to_s}")))
+    make_comparison_operator(method.to_s,
+                             ruby_binary_function("#{method.to_s}_ruby", 
+                                                  instance_variable_get("@#{method.to_s}")))
   end
 
   alias :>= :ge
@@ -122,14 +269,58 @@ module BitwiseOperators
   extend FunctionCreation
   extend RubyFunctions
 
+  class BinaryAnd
+    def self.apply(val1, val2)
+      val1 & val2
+    end
+  end
+
+  class BinaryOr
+    def self.apply(val1, val2)
+      val1 | val2
+    end
+  end
+
+  class BinaryXor
+    def self.apply(val1, val2)
+      val1 ^ val2
+    end
+  end
+
+  class BinaryLeftShift
+    def self.apply(val1, val2)
+      val1 << val2
+    end
+  end
+
+  class BinaryRightShift
+    def self.apply(val1, val2)
+      val1 >> val2
+    end
+  end
+
+  class BinaryOnesComplement
+    def self.apply(val)
+      ~val1
+    end
+  end
+
+  @binary_and = BitwiseOperators::BinaryAnd
+  @binary_or = BitwiseOperators::BinaryOr
+  @binary_xor = BitwiseOperators::BinaryXor
+  @binary_left_shift = BitwiseOperators::BinaryLeftShift
+  @binary_right_shift = BitwiseOperators::BinaryRightShift
+  @binary_ones_complement = BitwiseOperators::BinaryOnesComplement
+
+=begin
   @binary_and = Proc.new { |val1, val2| val1 & val2 }
   @binary_or = Proc.new { |val1, val2| val1 | val2 }
   @binary_xor = Proc.new { |val1, val2| val1 ^ val2 }
   @binary_left_shift = Proc.new { |val1, val2| val1 << val2 }
   @binary_right_shift = Proc.new { |val1, val2| val1 >> val2 }
-
   @binary_ones_complement = Proc.new { |val| ~val }
-  
+=end
+
   #---------------------------------------------------------------------------------------
   #
   #---------------------------------------------------------------------------------------

data/test/colt/test_complete.rb

@@ -22,4 +22,5 @@
 #=begin
 require_relative 'test_statistics'
 require_relative 'test_stat_list'
+require_relative 'test_math'
 #=end

data/test/colt/test_math.rb

@@ -0,0 +1,249 @@
+require 'rubygems'
+require "test/unit"
+require 'shoulda'
+
+require 'mdarray'
+
+class MDArrayTest < Test::Unit::TestCase
+
+  context "Colt Functions Tests" do
+
+    setup do
+
+      @byte = MDArray.typed_arange("byte", 1, 10)
+      @short = MDArray.typed_arange("short", 1, 10)
+      @int = MDArray.typed_arange("int", 1, 10)
+      @long = MDArray.typed_arange("long", 1, 10)
+      @float = MDArray.typed_arange("float", 1, 10)
+      @double = MDArray.linspace("double", 0, 1, 10)
+
+    end
+
+    #-------------------------------------------------------------------------------------
+    #
+    #-------------------------------------------------------------------------------------
+=begin
+    should "math operations with colt methods" do
+
+      @byte + @short
+      @double + @double
+      @double * @double
+      @double * @int
+      @double - @double
+      @double - @byte
+      @int - @int
+      @int - @double
+
+    end
+=end
+    #-------------------------------------------------------------------------------------
+    #
+    #-------------------------------------------------------------------------------------
+
+    should "work with Parallel Colt double methods" do
+
+      p "testing Parallel Colt double methods" 
+
+      (@double.abs).print
+      (@double.acos).print
+      (@double.asin).print
+      (@double.atan).print
+      (@double.atan2(@double)).print
+      (@double.ceil).print
+      (@double.compare(@double)).print
+      @double.cos
+      @double.div(@double)
+      @double.div_neg(@double)
+      @double.equals(@double)
+      @double.exp
+      @double.floor
+      @double.greater(@double)
+      @double.identity
+      @double.ieee_remainder(@double)
+      @double.inv
+      @double.is_equal(@double)
+      @double == @double
+      @double.is_less(@double)
+      @double < @double
+      @double.is_greater(@double)
+      @double > @double
+      @double.less(@double)
+      @double.lg(@double)
+      @double.log
+      @double.cern_log2
+      @double.minus(@double)
+      @double - @double
+      @double.mod(@double)
+      @double * @double
+      @double.mult_neg(@double)
+      @double.mult_square(@double)
+      @double.neg
+      @double + @double
+      @double.plus_abs(@double)
+      @double.pow(@double)
+      @double.rint
+      @double.sign
+      @double.sin
+      @double.sqrt
+      @double.square
+      @double.tan
+      
+    end
+
+    #-------------------------------------------------------------------------------------
+    #
+    #-------------------------------------------------------------------------------------
+
+    should "work with Parallel Colt float methods" do
+
+      p "testing Parallel Colt float methods" 
+
+      (@float.abs).print
+      (@float.acos).print
+      (@float.asin).print
+      (@float.atan).print
+      (@float.atan2(@float)).print
+      (@float.ceil).print
+      (@float.compare(@float)).print
+      @float.cos
+      @float.div(@float)
+      @float.div_neg(@float)
+      @float.equals(@float)
+      @float.exp
+      @float.floor
+      @float.greater(@float)
+      @float.identity
+      @float.ieee_remainder(@float)
+      @float.inv
+      @float.is_equal(@float)
+      @float == @float
+      @float.is_less(@float)
+      @float < @float
+      @float.is_greater(@float)
+      @float > @float
+      @float.less(@float)
+      @float.lg(@float)
+      @float.log
+      @float.cern_log2
+      @float.minus(@float)
+      @float - @float
+      @float.mod(@float)
+      @float * @float
+      @float.mult_neg(@float)
+      @float.mult_square(@float)
+      @float.neg
+      @float + @float
+      @float.plus_abs(@float)
+      @float.pow(@float)
+      @float.rint
+      @float.sign
+      @float.sin
+      @float.sqrt
+      @float.square
+      @float.tan
+      
+    end
+
+    #-------------------------------------------------------------------------------------
+    #
+    #-------------------------------------------------------------------------------------
+
+    should "work with Parallel Colt long methods" do
+
+      p "testing Parallel Colt long methods" 
+
+      (@long.abs).print
+      (@long.compare(@long)).print
+      @long.div(@long)
+      @long.div_neg(@long)
+      @long.equals(@long)
+      @long.is_equal(@long)
+      @long == @long
+      @long.is_less(@long)
+      @long < @long
+      @long.is_greater(@long)
+      @long > @long
+      @long.cern_max(@long)
+      @long.cern_min(@long)
+      @long.minus(@long)
+      @long - @long
+      @long.mod(@long)
+      @long * @long
+      @long.mult_neg(@long)
+      @long.mult_square(@long)
+      @long.neg
+      @long + @long
+      @long.plus(@long)
+      @long.plus_abs(@long)
+      @long.pow(@long)
+      @long.sign
+      @long.square
+
+      @long.and(@long)
+      @long.dec
+      @long.factorial
+      @long.inc
+      @long.not
+        @long.or(@long)
+      @long.shift_left(@long)
+      @long.shift_right_signed(@long)
+      @long.binary_right_shift(@long)
+      @long.binary_left_shift(@long)
+      @long.shift_right_unsigned(@long)
+      @long.xor(@long)
+      
+    end
+
+    #-------------------------------------------------------------------------------------
+    #
+    #-------------------------------------------------------------------------------------
+
+    should "work with Parallel Colt int methods" do
+
+      p "testing Parallel Colt int methods" 
+
+      (@int.abs).print
+      (@int.compare(@int)).print
+      @int.div(@int)
+      @int.div_neg(@int)
+      @int.equals(@int)
+      @int.is_equal(@int)
+      @int == @int
+      @int.is_less(@int)
+      @int < @int
+      @int.is_greater(@int)
+      @int > @int
+      @int.cern_max(@int)
+      @int.cern_min(@int)
+      @int.minus(@int)
+      @int - @int
+      @int.mod(@int)
+      @int * @int
+      @int.mult_neg(@int)
+      @int.mult_square(@int)
+      @int.neg
+      @int + @int
+      @int.plus(@int)
+      @int.plus_abs(@int)
+      @int.pow(@int)
+      @int.sign
+      @int.square
+
+      @int.and(@int)
+      @int.dec
+      @int.factorial
+      @int.inc
+      @int.not
+        @int.or(@int)
+      @int.shift_left(@int)
+      @int.shift_right_signed(@int)
+      @int.binary_right_shift(@int)
+      @int.binary_left_shift(@int)
+      @int.shift_right_unsigned(@int)
+      @int.xor(@int)
+      
+    end
+
+  end
+
+end