mdarray 0.4.0-java → 0.4.2-java

data/README.md

@@ -19,3 +19,4 @@ second dimension has a length of 3.
 [[ 1., 0., 0.],
  [ 0., 1., 2.]]
 
+MDArray wiki can be found at: https://github.com/rbotafogo/mdarray/wiki

data/Rakefile

@@ -17,7 +17,7 @@ end
 
 desc 'Install the gem in the standard location'
 task :install_gem => [:make_gem] do
-  sh "gem install #{$gem_name}-#{$version}.gem"
+  sh "gem install #{$gem_name}-#{$version}-java.gem"
 end
 
 desc 'Make documentation'

data/lib/mdarray.rb

@@ -194,42 +194,13 @@ class MDArray
 
   #---------------------------------------------------------------------------------------
   # Checks to see if this array is compatible with another array.  Two arrays are
-  # compatible if they have the same shape
+  # compatible if they have the same shape and have operatable types.
   #---------------------------------------------------------------------------------------
 
   def compatible(array)
     (get_shape == array.get_shape)? true : false
   end
 
-  #---------------------------------------------------------------------------------------
-  # Returns the upcasted type between the type of this array and another array
-  # @param other_val [MDArray] the other array
-  # @param force_cast [Type] will return force_cast.  This is used when one wants to
-  #   force the resulting type on a new array.
-  # @return upcasted type between the two arrays or forced type
-  #---------------------------------------------------------------------------------------
-
-  def get_type(other_val, force_cast = nil)
-
-    if (force_cast != nil)
-      type = force_cast
-    elsif (other_val.is_a? Numeric)
-      # if type is integer, then make it the smaller possible integer and then let upcast
-      # do its work
-      if (other_val.integer?)
-        type = "short"
-      else
-        type = "double"
-      end
-      type = MDArray.upcast(@type, type)
-    else
-      type = MDArray.upcast(@type, other_val.type)
-    end
-
-    return type
-
-  end
-
   #---------------------------------------------------------------------------------------
   # Prints a list of all available functions know to MDArray.  Should be reimplemented.
   # For debuging only for now.
@@ -406,9 +377,8 @@ require_relative 'mdarray/function_creation'
 require_relative 'mdarray/ruby_functions'
 require_relative 'mdarray/operators'
 require_relative 'mdarray/ruby_operators'
-# require_relative 'mdarray/fast_non_numerical'
 require_relative 'mdarray/access'
-require_relative 'mdarray/slices'
+require_relative 'mdarray/views'
 require_relative 'mdarray/printing'
 require_relative 'mdarray/counter'
-# require_relative 'mdarray/statistics'
+require_relative 'mdarray/ruby_stats'

data/lib/mdarray/access.rb

@@ -188,30 +188,6 @@ class MDArray
 
   end
 
-  #------------------------------------------------------------------------------------
-  # 
-  #------------------------------------------------------------------------------------
-
-  def each_along_axes(axes)
-    
-    counter = Counter.new(self)
-
-    sizes = Array.new
-    (0..rank - 1).each do |axis|
-      if (axes.include?(axis))
-        sizes[axis] = 1
-      else
-        sizes[axis] = shape[axis]
-      end
-    end
-
-    counter.each_along_axes(axes) do |ct|
-      # yield ct, sizes if block_given?
-      yield section(ct, sizes, true) if block_given?
-    end
-
-  end
-
   #------------------------------------------------------------------------------------
   #
   #------------------------------------------------------------------------------------

data/lib/mdarray/hierarchy.rb

@@ -101,62 +101,6 @@ end
 ##########################################################################################
 
 class BooleanMDArray < NonNumericalMDArray
-  
-  #------------------------------------------------------------------------------------
-  #
-  #------------------------------------------------------------------------------------
-
-  def self.make_boolean_op(name, func)
-    define_method(name) do |other_val|
-      boolean_op(other_val, func)
-    end
-  end
-  
-  #---------------------------------------------------------------------------------------
-  # 
-  #---------------------------------------------------------------------------------------
-
-  def boolean_op(other_val, method)
-    result = MDArray.build("boolean", shape)
-    exec_boolean_op(result, other_val, method)
-  end
-
-  #======================================================================================
-  # Logical
-  #======================================================================================
-
-  def self.and(val1, val2)
-    val1 and val2
-  end
-
-  #------------------------------------------------------------------------------------
-  #
-  #------------------------------------------------------------------------------------
-
-  def self.or(val1, val2)
-    val1 or val2
-  end
-
-  #------------------------------------------------------------------------------------
-  #
-  #------------------------------------------------------------------------------------
-
-  def self.not(val1)
-    !val1
-  end
-
-  #------------------------------------------------------------------------------------
-  #
-  #------------------------------------------------------------------------------------
-
-  # make_binary_methods("and", BooleanMDArray.method(:and))
-  # make_binary_methods("or", BooleanMDArray.method(:or))
-
-  make_boolean_op("and", BooleanMDArray.method(:and))
-  make_boolean_op("or", BooleanMDArray.method(:or))
-
-  alias :| :or
-    alias :& :and
     
 end
 

data/lib/mdarray/operators.rb

@@ -123,6 +123,43 @@ class BinaryOperator < Operator
 
   private
   
+  #---------------------------------------------------------------------------------------
+  # Checks type compatibility for this operands.  If types are compatible then if needed
+  # returns the upcasted type.
+  # @returns proper type for the resulting array for the given operands
+  #---------------------------------------------------------------------------------------
+
+  def get_type
+
+    # if operation done in a numeric type then result is the upcast of this type and
+    # the other_val's type
+    if (@op1.is_a? NumericalMDArray)
+      if (@op2.is_a? Numeric)
+        # if type is integer, then make it the smaller possible integer and then let upcast
+        # do its work
+        if (@op2.integer?)
+          type = "short"
+        else
+          type = "double"
+        end
+      elsif (@op2.is_a? NumericalMDArray)
+        type = @op2.type
+      else
+        raise "Cannot operate numerical type (#{@op1.type}) with non-numerical type (#{@op2.class})"
+      end
+      type = MDArray.upcast(@op1.type, type)
+      
+      # It is a non-numerical type, so both types need to be the same
+    elsif ((@op2.is_a? MDArray) && (@op1.type == @op2.type))
+      type = @op1.type
+    else
+      raise "Cannot operate numerical type (#{@op1.type}) with non-numerical type (#{@op2.class})"
+    end
+    
+    return type
+    
+  end
+  
   #---------------------------------------------------------------------------------------
   #
   #---------------------------------------------------------------------------------------
@@ -131,9 +168,9 @@ class BinaryOperator < Operator
 
     @op1 = args.shift
     @op2 = args.shift
+
     requested_type = args.shift
-    @type = (@force_type)? @force_type : (requested_type)? requested_type : 
-      @op1.get_type(@op2)
+    @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)
@@ -152,27 +189,35 @@ class BinaryOperator < Operator
   def get_args(*args)
 
     parse_args(*args)
-    if (@op2.is_a? Numeric)
-      op2_iterator = Const.new(@op2)
-    elsif (@op2.is_a? NumericalMDArray)
-      if (@op1.compatible(@op2))
+
+    if (@op1.is_a? NumericalMDArray)
+      if (@op2.is_a? Numeric)
+        op2_iterator = Const.new(@op2)
+      elsif (@op2.is_a? NumericalMDArray)
+        if (!@op1.compatible(@op2))
+          raise "Invalid operation - arrays are incompatible"
+        end
         op2_iterator = @op2.get_iterator_fast
-      else
+      else # Operation with another user defined type
+        false
+        # *TODO: make it more general using coerce if other_val type is not recognized
+        # if (arg is not recognized)
+        #  self_equiv, arg_equiv = arg.coerce(self)
+        #  self_equiv * arg_equiv
+        # end
+      end
+      
+    else  # NonNumericalMDArray
+      if (!@op1.compatible(@op2))
         raise "Invalid operation - arrays are incompatible"
       end
-    else
-      false
-      # *TODO: make it more general using coerce if other_val type is not recognized
-      # if (arg is not recognized)
-      #  self_equiv, arg_equiv = arg.coerce(self)
-      #  self_equiv * arg_equiv
-      # end
+      op2_iterator = @op2.get_iterator_fast
     end
-
+    
     yield @op1.get_iterator_fast, op2_iterator, @op1.shape, *@other_args
-
+    
   end
-
+  
 end # BinaryOperator
 
 ##########################################################################################

data/lib/mdarray/ruby_boolean_functions.rb

@@ -0,0 +1,43 @@
+
+##########################################################################################
+#
+##########################################################################################
+
+module BooleanFunctions
+  extend FunctionCreation
+  extend RubyFunctions
+
+  @and = Proc.new { |val1, val2| val1 and val2 }
+  @or = Proc.new { |val1, val2| val1 or val2 }
+  @not = Proc.new { |val1| !val1}
+
+  @binary_methods = [:and, :or]
+  
+  @unary_methods = [:not]
+
+  @binary_methods.each do |method|
+    make_binary_operators(method.to_s,
+                          ruby_binary_function("#{method.to_s}_ruby", 
+                                               instance_variable_get("@#{method.to_s}")))
+  end
+  
+  @unary_methods.each do |method|
+    make_unary_operators(method.to_s,
+                         ruby_unary_function("#{method.to_s}_ruby", 
+                                             instance_variable_get("@#{method.to_s}")))
+  end
+  
+  alias :| :or
+    alias :& :and
+
+end # BooleanFunctions
+
+##########################################################################################
+#
+##########################################################################################
+
+class BooleanMDArray
+
+  include BooleanFunctions
+
+end # BooleanMDArray

data/lib/mdarray/ruby_functions.rb

@@ -75,4 +75,5 @@ end # UserFunction
 require_relative 'ruby_generic_functions'
 require_relative 'ruby_numeric_functions'
 require_relative 'ruby_math'
+require_relative 'ruby_boolean_functions'
 require_relative 'ruby_stats'

data/lib/mdarray/ruby_operators.rb

@@ -43,6 +43,7 @@ class RubyBinaryOperator < BinaryOperator
     get_args(*args) do |op1_iterator, op2_iterator, shape, *other_args|
       result = MDArray.build(@type, shape)
       res_iterator = result.get_iterator_fast
+
       if (@coerced)
         while (res_iterator.has_next?)
           res_iterator.set_next(@do_func.call(op2_iterator.get_next, 

data/lib/mdarray/ruby_stats.rb

@@ -10,7 +10,11 @@ module RubyStats
   # Statistics
   #======================================================================================
 
-=begin
+
+  #---------------------------------------------------------------------------------------
+  # Sums all values
+  #---------------------------------------------------------------------------------------
+
   func = ["ruby_sum", "RubyFunction", Proc.new { |sum, val| sum + val }, "*", "*", "void"] 
   make_unary_op("sum", "reduce", func, nil, Proc.new { 0 })
 
@@ -19,29 +23,25 @@ module RubyStats
   #---------------------------------------------------------------------------------------
 
   pre_calc = Proc.new { |arr1, *args| arr1[0] }
-
-  calc = Proc.new { |min, val| min = (min < val)? min : val } 
-
-  make_unary_op("min", :reduce, calc, nil, pre_calc)
+  calc = Proc.new { |min, val| min = ((min < val)? min : val) } 
+  func = ["ruby_min", "RubyFunction", calc, "*", "*", "void"] 
+  make_unary_op("min", :reduce, func, nil, pre_calc)
 
   #---------------------------------------------------------------------------------------
   # calculates the maximum
   #---------------------------------------------------------------------------------------
 
   pre_calc = Proc.new { |arr1, *args| arr1[0] }
-
   calc = Proc.new { |max, val| max = (max > val)? max : val }
-
-  make_unary_op("max", :reduce, calc, nil, pre_calc)
+  func = ["ruby_max", "RubyFunction", calc, "*", "*", "void"] 
+  make_unary_op("max", :reduce, func, nil, pre_calc)
 
   #---------------------------------------------------------------------------------------
   # calculates the mean
   #---------------------------------------------------------------------------------------
 
   pre_calc = Proc.new { 0 }
-
   calc = Proc.new { |start, val| start += val }
-
   post_calc = Proc.new do |result, *args|
     arr = args.shift
     if (arr.size == 0)
@@ -49,21 +49,19 @@ module RubyStats
     end
     result / arr.size
   end
-
-  make_unary_op("mean", :reduce, calc, nil, pre_calc, post_calc)
+  func = ["ruby_mean", "RubyFunction", calc, "*", "*", "void"] 
+  make_unary_op("mean", :reduce, func, nil, pre_calc, post_calc)
 
   #---------------------------------------------------------------------------------------
   # calculates the weighted mean
   #---------------------------------------------------------------------------------------
 
   pre_calc = Proc.new { [0, 0] }
-
   calc = Proc.new do |result, val, weight|
     result[0] += (val * weight)
     result[1] += weight
     result
   end
-
   post_calc = Proc.new do |result, *args|
     arr = args.shift
     if (arr.size == 0)
@@ -71,9 +69,24 @@ module RubyStats
     end
     [result[0] / result[1], arr.size] 
   end
+  func = ["ruby_weighted_mean", "RubyFunction", calc, "*", "*", "void"] 
+  make_binary_op("weighted_mean", :reduce, func, nil, pre_calc, post_calc)
+  
+end # RubyStats
+
+##########################################################################################
+#
+##########################################################################################
+
+class DoubleMDArray
+
+  include RubyStats
+  
+end
 
-  make_binary_op("weighted_mean", :reduce, calc, nil, pre_calc, post_calc)
 
+
+=begin
   #---------------------------------------------------------------------------------------
   # Expectation value
   #---------------------------------------------------------------------------------------
@@ -98,8 +111,10 @@ module RubyStats
     end
     result / arr.size
   end
-=end
-=begin
+
+  #---------------------------------------------------------------------------------------
+  #
+  #---------------------------------------------------------------------------------------
 
   def mean
     expectation_value(Proc.identity, Proc.everywhere)[0]
@@ -145,5 +160,3 @@ module RubyStats
   # calculates the mean
 
 =end
-
-end # RubyStats