mdarray 0.4.0-java → 0.4.2-java

data/lib/mdarray/{slices.rb → views.rb}

@@ -101,16 +101,15 @@ class MDArray
 
   end
 
-  #------------------------------------------------------------------------------------
+  #---------------------------------------------------------------------------------------
   # Create a new Array as a subsection of this Array, without rank reduction. No data 
   # is moved, so the new Array references the same backing store as the original.
-  # Parameters:
-  # origin - int array specifying the starting index. Must be same rank as original Array.
-  # shape - int array specifying the extents in each dimension. This becomes the shape 
-  # of the returned Array. Must be same rank as original Array.
-  # stride - int array specifying the strides in each dimension. If null, assume all ones.
-  # Returns:
-  # the new Array
+  # @param origin ruby array specifying the starting index. Must be same rank as original 
+  #   Array.
+  # @param shape ruby array specifying the extents in each dimension. This becomes the 
+  #   shape of the returned Array. Must be same rank as original Array.
+  # @param reduce true if the array should be reduced by removing dimensions of size 1
+  # @returns new Array
   # Throws:
   # InvalidRangeException - if ranges is invalid
   #------------------------------------------------------------------------------------
@@ -138,7 +137,18 @@ class MDArray
   end
 
   #------------------------------------------------------------------------------------
-  #
+  # Create a new Array as a subsection of this Array, without rank reduction. No data 
+  # is moved, so the new Array references the same backing store as the original.
+  # @param origin ruby array specifying the starting index. Must be same rank as 
+  #   original Array.
+  # @param shape ruby array specifying the extents in each dimension. This becomes the 
+  #   shape of the returned Array. Must be same rank as original Array.
+  # @param stride array specifying the strides in each dimension. If null, assume all 
+  #   ones.
+  # @param reduce true if the array should be reduced by removing dimensions of size 1
+  # @returns new Array
+  # Throws:
+  # InvalidRangeException - if ranges is invalid
   #------------------------------------------------------------------------------------
 
   def section_with_stride(origin, shape, stride, reduce = false)
@@ -168,6 +178,63 @@ class MDArray
     @section
   end
 
+  #------------------------------------------------------------------------------------
+  # Create a new Array using same backing store as this Array, by fixing the specified 
+  # dimension at the specified index value. This reduces rank by 1.
+  # @param dim dimension to fix
+  # @param val value in which to fix the dimension
+  # @return new array sliced at the given dimension on the specified value
+  #------------------------------------------------------------------------------------
+
+  def slice(dim, val)
+    
+    arr = @nc_array.slice(dim, val)
+    slice = MDArray.new(@type, arr, true)
+    copy_print_parameters(slice)
+    return slice
+
+  end
+
+  #------------------------------------------------------------------------------------
+  # 
+  #------------------------------------------------------------------------------------
+
+  def each_slice(axes, reduce = true)
+    
+    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 section(ct, sizes, reduce) if block_given?
+    end
+
+  end
+
+  #------------------------------------------------------------------------------------
+  # Create a new Array using same backing store as this Array, by transposing two of 
+  # the indices.
+  # @param dim1 first dimension index
+  # @param dim2 second dimension index
+  # @return new array with dimensions transposed
+  #------------------------------------------------------------------------------------
+
+  def transpose(dim1, dim2)
+
+    arr = @nc_array.transpose(dim1, dim2)
+    transpose = MDArray.new(@type, arr, true)
+    copy_print_parameters(transpose)
+    return transpose
+
+  end
+
   #------------------------------------------------------------------------------------
   #
   #------------------------------------------------------------------------------------

data/test/test_boolean.rb

@@ -2,9 +2,10 @@ require 'rubygems'
 require "test/unit"
 require 'shoulda'
 
-require 'env'
 require 'mdarray'
 
+require_relative 'env'
+
 class MDArrayTest < Test::Unit::TestCase
 
   context "Arithmetic Tests" do
@@ -57,8 +58,8 @@ class MDArrayTest < Test::Unit::TestCase
       result = @bool2 | @bool1
       assert_equal("true false true true ", result.to_string)
 
-      #result = !@bool1
-      #assert_equal("false true false true ", result.to_string)
+      result = @bool1.not
+      assert_equal("false true false true ", result.to_string)
       
     end
 

data/test/test_complete.rb

@@ -21,10 +21,12 @@
 
 require 'simplecov'
 
+#require_relative 'env'
+
 #=begin
 SimpleCov.start do
   @filters = []
-  add_group "MDArray", "F:/rbotafogo/cygwin/home/zxb3/Desenv/MDArray/src/lib"
+  add_group "MDArray", "F:/rbotafogo/cygwin/home/zxb3/Desenv/MDArray/lib"
 end
 #=end
 
@@ -54,16 +56,20 @@ end
 # * itemsize: ??
 # Differently from NumPy, it is not possible to get the internal buffer
 
+#=begin
+require_relative 'test_creation'
+require_relative 'test_access'
+require_relative 'test_operator'
+require_relative 'arithmetic_casting'
+require_relative 'test_comparison'
+require_relative 'test_boolean'
+require_relative 'test_shape'
+require_relative 'test_counter'
+require_relative 'test_trigonometry'
+require_relative 'test_views'
+require_relative 'test_printing'
+require_relative 'test_statistics'
+#=end
+
+# require_relative 'test_speed'
 
-require 'test_creation'
-require 'test_access'
-require 'test_operator'      # Fix user's operators contruction
-require 'arithmetic_casting'
-require 'test_comparison'
-# require 'test_boolean'
-require 'test_shape'
-require 'test_counter'
-require 'test_trigonometry'
-# require 'test_statistics'
-# require 'test_slices'
-# require 'test_speed'

data/test/test_counter.rb

@@ -119,13 +119,11 @@ class MDArrayTest < Test::Unit::TestCase
 
       counter = MDArray::Counter.new(@a)
       counter.each_along_axes([0, 2]) do |counter|
-        p counter
+        counter
       end
 
-      printf "\n"
-
       counter.each_along_axes([0, 1, 2]) do |counter|
-        p counter
+        counter
       end
 
     end
@@ -138,21 +136,6 @@ class MDArrayTest < Test::Unit::TestCase
   
 end
 
-=begin      
-    #-------------------------------------------------------------------------------------
-    #
-    #-------------------------------------------------------------------------------------
-
-    should "issue errors if range is used as index" do
-
-      index = MDArray::Index.new(@a)
-      index.set_start([/1:1/, /0:2/, 1, 1])
-
-    end
-
-=end
-
-
 =begin
     should "allow partial access to the array" do
 

data/test/test_creation.rb

@@ -355,7 +355,6 @@ class MDArrayTest < Test::Unit::TestCase
 
       struct = MDArray.structure([10])
       struct[0] = m
-      struct.print
 
     end
 

data/test/test_operator.rb

@@ -51,6 +51,9 @@ class MDArrayTest < Test::Unit::TestCase
       @h = MDArray.byte([1], [13])
       @i = MDArray.double([4], [2.0, 6.0, 5.0, 9.0])
 
+      @bool1 = MDArray.boolean([4], [true, false, true, false])
+      @bool2 = MDArray.boolean([4], [false, false, true, true])
+
     end # setup
 
     #-------------------------------------------------------------------------------------
@@ -242,6 +245,17 @@ class MDArrayTest < Test::Unit::TestCase
  
     end
 
+    #-------------------------------------------------------------------------------------
+    #
+    #-------------------------------------------------------------------------------------
+
+    should "not allow operation between numeric and non-numeric types" do
+      
+      assert_raise (RuntimeError) { result = @c + @bool1 }
+      assert_raise (RuntimeError) { result = @c + "this is a test" }
+
+    end
+
     #------------------------------------------------------------------------------------
     #
     #------------------------------------------------------------------------------------
@@ -306,29 +320,28 @@ class MDArrayTest < Test::Unit::TestCase
       # array will be double
       c = @a.addd(@b)
       assert_equal("double", c.type)
-      c.print
 
       # request that resulting array of type int is ignored when using addd
       c = @a.addd(@b, "int")
       assert_equal("double", c.type)
 
-=begin
-
-      MDArray.make_binary_operators("perc_inc", 
-                                    Proc.new { |val1, val2| (val2 - val1) / val1 })
+      # Crete method perc_inc and add it into the double MDArray.
+      UserFunction.binary_operator("perc_inc", :default, 
+                                   Proc.new { |val1, val2| (val2 - val1) / val1 },
+                                   "double")
 
       result = @c.perc_inc @i
       assert_equal("0.06951871657754005 0.12359550561797755 -0.3036211699164345 0.018099547511312233 ", result.to_string)
 
       # do it in place
-      # "0.06951871514320374 0.1235954761505127 -0.3036211431026459 0.018099529668688774 "
+      UserFunction.binary_operator("perc_inc!", :in_place, 
+                                   Proc.new { |val1, val2| (val2 - val1) / val1 },
+                                   "double")
 
-      # @c.binary_operator = FastBinaryOperator
-      # @c.binary_operator = BinaryOperator
+      # "0.06951871514320374 0.1235954761505127 -0.3036211431026459 0.018099529668688774 "
 
       @c.perc_inc! @i
       assert_equal("0.06951871657754005 0.12359550561797755 -0.3036211699164345 0.018099547511312233 ", @c.to_string)
-=end
 
     end
     

data/test/test_printing.rb

@@ -37,18 +37,13 @@ class MDArrayTest < Test::Unit::TestCase
     #
     #-------------------------------------------------------------------------------------
 
-
-    should "apply a method over axes" do
-      @e.apply_over_axes([0, 2])
-      # @e.section([0, 0, 0], [1, 5, 1])
-      # @e.print
-    end
-
-#=begin
     should "print 1D array" do
       @a.print
     end
-#=end
+
+    #-------------------------------------------------------------------------------------
+    #
+    #-------------------------------------------------------------------------------------
     
     should "print nD array" do
       @d.print
@@ -57,6 +52,10 @@ class MDArrayTest < Test::Unit::TestCase
       @g.print
     end
 
+    #-------------------------------------------------------------------------------------
+    #
+    #-------------------------------------------------------------------------------------
+
     should "print output to csv" do
       @e.to_csv
     end

data/test/test_statistics.rb

@@ -2,9 +2,7 @@ require 'rubygems'
 require "test/unit"
 require 'shoulda'
 
-require 'env'
 require 'mdarray'
-require 'benchmark'
 
 class MDArrayTest < Test::Unit::TestCase
 
@@ -27,16 +25,11 @@ class MDArrayTest < Test::Unit::TestCase
 
     should "do stats operations" do
 
-      # @a.unary_operator = FastUnaryOperator
       assert_equal(49995000, @a.sum)
       assert_equal(0, @a.min)
       assert_equal(9999, @a.max)
       assert_equal(4999.5, @a.mean)
-
-      # @a.binary_operator = BinaryOperator
-      puts Benchmark.measure {
-        assert_equal(6666.333333333333, @a.weighted_mean(@weight)[0])
-      }
+      assert_equal(6666.333333333333, @a.weighted_mean(@weight)[0])
 
     end
 

data/test/test_views.rb

@@ -0,0 +1,291 @@
+require 'rubygems'
+require "test/unit"
+require 'shoulda'
+
+require 'mdarray'
+
+class MDArrayTest < Test::Unit::TestCase
+
+  context "Slice Tests" do
+
+    setup do
+      
+      # creates an array from a function (actually a block).  The name fromfunction
+      # is preserved to maintain API compatibility with NumPy (is it necessary?)
+
+      # simulating financial data: 1 year, 20 days, 10 securities, 7 values (open, 
+      # close, high, low, volume, e1, e2)
+      @a = MDArray.fromfunction("double", [1, 20, 10, 7]) do |x, y, z, k|
+        0.5 * x + y + 10 * (z + 1) + Math.sin(k + x)
+      end
+
+      @b = MDArray.int([2, 2])
+      @c = MDArray.fromfunction("double", [2, 3, 4]) do |x, y, z|
+        x + y + z
+      end
+      
+    end
+
+    #-------------------------------------------------------------------------------------
+    # Create a new Array using same backing store as this Array, by fixing the specified 
+    # dimension at the specified index value. This reduces rank by 1.
+    #-------------------------------------------------------------------------------------
+
+    should "slice an array" do
+
+      # @c rank is [2, 3, 4]. @c is the following array
+      # [[[0.00 1.00 2.00 3.00]
+      #  [1.00 2.00 3.00 4.00]
+      #  [2.00 3.00 4.00 5.00]]
+      # 
+      # [[1.00 2.00 3.00 4.00]
+      #  [2.00 3.00 4.00 5.00]
+      #  [3.00 4.00 5.00 6.00]]]
+      
+      # take a slice of c on the first dimension (0) and taking only the first (0) index,
+      # we should get the following array:
+      # [[0.00 1.00 2.00 3.00]
+      #  [1.00 2.00 3.00 4.00]
+      #  [2.00 3.00 4.00 5.00]]
+      arr = @c.slice(0, 0)
+      assert_equal(1, arr[0, 1])
+      assert_equal(4, arr[2, 2])
+      assert_equal(5, arr[2, 3])
+
+      # take a slice of c on the first dimension (0) and taking only the second (1) index,
+      # we should get the following array:
+      # [[1.00 2.00 3.00 4.00]
+      #  [2.00 3.00 4.00 5.00]
+      #  [3.00 4.00 5.00 6.00]]
+      arr = @c.slice(0, 1)
+      assert_equal(2, arr[0, 1])
+      assert_equal(4, arr[0, 3])
+      assert_equal(5, arr[1, 3])
+
+      # take a slice of c on the second dimension (1) and taking only the second (1) index,
+      # we should get the following array:
+      # [[1.00 2.00 3.00 4.00]
+      #  [2.00 3.00 4.00 5.00]]
+      arr = @c.slice(1, 1)
+      assert_equal(2, arr[0, 1])
+      assert_equal(2, arr[1, 0])
+
+      # take a slice of c on the third dimension (2) and taking only the third (2) index,
+      # we should get the following array:
+      # [[2.00 3.00 4.00]
+      #  [3.00 4.00 5.00]]
+      arr = @c.slice(2, 2)
+      assert_equal(3, arr[0, 1])
+      assert_equal(5, arr[1, 2])
+
+    end
+
+    #-------------------------------------------------------------------------------------
+    #
+    #-------------------------------------------------------------------------------------
+  
+    should "get array section" do
+
+      # 1 -> first year (only 1 year)
+      # 20 -> 20 days
+      # 10 -> number os secs
+      # 7 - > number of values
+      
+      # b is a section of @a, starting at position (0) and taking only the first two 
+      # elements of the first dimension.  Getting all values, for all secs for the first
+      # 2 days
+      b = @a.section([0, 0, 0, 0], [1, 2, 10, 7])
+      assert_equal(true, b.section?)
+      assert_equal([1, 2, 10, 7], b.shape)
+      ind = b.get_index
+      ind.each do |elmt|
+        assert_equal(@a.get(elmt), b.get(elmt))
+      end
+      
+      # getting "open" for the first 2 days of the 2nd sec.  Values are organized
+      # as follows:
+      # (open, close, high, low, volume, e1, e2).
+      # Start at: [0, 0, 3, 0] => 
+      #   0 -> first year, 0 -> first day, 3 -> 2nd sec, 0 -> first value 
+      # Specification: [1, 2, 1, 1] =>
+      #   1 -> get only first year, 2 -> take 2 days from day 0 to day 1, 
+      #   1 -> take one security, already selected the 2nd one, 1 -> only one value
+      #   in this case the first one was selected.
+      b = @a.section([0, 0, 3, 0], [1, 2, 1, 1])
+      assert_equal(40.00, b[0, 0, 0, 0])
+      assert_equal(41.00, b[0, 1, 0, 0])
+
+      # getting "close" (2nd) value of the 3rd sec for the second day with 
+      # shape reduction. Note that in this case, with shape reduction, b is a 
+      # number and not an array any more
+      b = @a.section([0, 1, 2, 1], [1, 1, 1, 1], true)
+      assert_equal(@a[0, 1, 2, 1], b)
+
+      # getting the "close" (2nd) value of the 3rd sec for the second day without
+      # shape reduction
+      b = @a.section([0, 1, 2, 1], [1, 1, 1, 1])
+      assert_equal([1, 1, 1, 1], b.shape)
+      assert_equal(@a[0, 1, 2, 1], b[0, 0, 0, 0])
+
+      # getting the "open" (1rst) value of the second secs for two days
+      b = @a.section([0, 0, 0, 0], [1, 2, 1, 1])
+      assert_equal([1, 2, 1, 1], b.shape)
+      assert_equal(@a[0, 0, 0, 0], b[0, 0, 0, 0])
+      assert_equal(@a[0, 1, 0, 0], b[0, 1, 0, 0])
+
+      # getting the "open" (1rst) value of the second secs for two days with rank
+      # reduction
+      b = @a.section([0, 0, 0, 0], [1, 2, 1, 1], true)
+      assert_equal([2], b.shape)
+      assert_equal(@a[0, 0, 0, 0], b[0])
+      assert_equal(@a[0, 1, 0, 0], b[1])
+
+      # getting the first security, all values
+      b = @a.section([0, 0, 0, 0], [1, 1, 1, 7])
+      # b.print
+
+      # getting the 2 security, all values
+      b = @a.section([0, 0, 1, 0], [1, 1, 1, 7])
+      # b.print
+
+      # getting the 1 day, all then secs
+      b = @a.section([0, 0, 0, 0], [1, 1, 10, 7])
+      # b.print
+
+      # getting the "open" (1st) value of all secs for the first day
+      b = @a.section([0, 0, 0, 0], [1, 1, 10, 1])
+      # b.print
+
+    end
+    
+    #-------------------------------------------------------------------------------------
+    # each_along_axes returns sub-arrays (sections) of the original array. Each section
+    # is taken by walking along the given axis and getting all elements of the
+    # axis that were not given.
+    #-------------------------------------------------------------------------------------
+
+    should "split array in subarrays with or without reduction" do
+
+      # 1 -> first year (only 1 year)
+      # 20 -> 20 days
+      # 10 -> number os secs
+      # 7 - > number of values
+
+      # Should generate 1 array with all elements, since the first dimension has only 
+      # one element.  For this test cannot reduce the array as this would have @a and 
+      # slice have different dimensions
+      @a.each_slice([0], false) do |slice|
+        slice.each_with_counter do |value, counter|
+          assert_equal(value, @a.get(counter))
+        end
+      end
+ 
+      # Should generate 20 arrays one for each day.  Since slice uses the same backing
+      # store as @a, there isn't much of memory waist.
+      arrays = Array.new
+      @a.each_slice([1]) do |slice|
+        arrays << slice
+      end
+      
+      arrays[0].reset_traversal
+      @a.slice(1, 0).each do |val|
+        assert_equal(val, arrays[0].get_next)
+      end
+
+      # Should generate 10 arrays one for each security
+      arrays.clear
+      @a.each_slice([2]) do |slice|
+        arrays << slice
+      end
+
+      arrays[6].reset_traversal
+      @a.slice(2, 6).each do |val|
+        assert_equal(val, arrays[6].get_next)
+      end
+
+      # For instance, array @a shape is [1, 20, 10, 7].  Slicing along the fourth axes
+      # (index 3) will get the following sections of @a:
+      # section([0, 0, 0, 0], [1, 20, 10, 1], true), 
+      #   section([0, 0, 0, 1], [1, 20, 10, 1], true),
+      #   section([0, 0, 0, 2], [1, 20, 10, 1], true),
+      #   ...
+      #   section([0, 0, 0, 6], [1, 20, 10, 1], true),
+      
+      # In this case, we get 7 arrays.  First for all opens, sencond for all closes,
+      #  third for all highs, fourth for all closes, etc.
+      arrays.clear
+      @a.each_slice([3]) do |slice|
+        arrays << slice
+      end
+      assert_equal(7, arrays.size)
+
+
+      # Although method slice only slices on one dimension, we can each_slice on multiple
+      # dimensions
+
+      # For instance, array @a shape is [1, 20, 10, 7].  Slicing
+      # along axes [1, 2] will generate 200 arrays = 20 * 10. 20 days times 10 secs. In this
+      # case we will have one array for every day and every securities quote (open, close, etc.)
+      arrays.clear
+      @a.each_slice([1, 2]) do |slice|
+        arrays << slice
+      end
+
+      # We can get the equivalent of arrays[0] above by doing the following set of operations
+      # @a.slice(1,0);
+      # now slice it again at (1, 0), since now the second dimension has become the first
+      # reduce the array so that only 1 dimension is left
+      assert_equal(arrays[0].to_string, @a.slice(1, 0).slice(1, 0).reduce.to_string)
+
+
+      # Changing the order of axis in the parameter list does change the final result as 
+      # each_slice moves first the last axis in the array given.  In this example, it will
+      # first increment axis 1 and then axis 2.  On the prvious example, axis 2 was
+      # incremented prior to axis 1.
+      arr2 = Array.new
+      @a.each_slice([2, 1]) do |slice|
+        arr2 << slice
+      end
+
+    end
+
+    #-------------------------------------------------------------------------------------
+    #-------------------------------------------------------------------------------------
+
+    should "permute array indices" do
+
+      # c shape is [2, 3, 4]
+      # b is the same array as c... no permutation was done.
+      # b shape still is [2, 3, 4].  Both b and @c point to the same backing store
+      b = @c.permute([0, 1, 2])
+      assert_equal([2, 3, 4], b.shape)
+      # b shape is now [3, 2, 4]
+      b = @c.permute([1, 0, 2])
+      assert_equal([3, 2, 4], b.shape)
+      # b shape is now [3, 4, 2]
+      b = @c.permute([1, 2, 0])
+      assert_equal([3, 4, 2], b.shape)
+
+    end
+
+    #-------------------------------------------------------------------------------------
+    # Creates views of an array by transposing original arrays dimensions.  Uses the same
+    # backing store as the original array.
+    #-------------------------------------------------------------------------------------
+
+    should "permute array indices" do
+
+      # c shape is [2, 3, 4]
+      # b shape is now [3, 2, 4] by transposing the first two dimensions
+      b = @c.transpose(0, 1)
+      assert_equal([3, 2, 4], b.shape)
+
+      # b shape is now [2, 4, 3]
+      b = @c.transpose(1, 2)
+      assert_equal([2, 4, 3], b.shape)
+
+    end
+
+  end
+
+end