mdarray 0.4.0-java

data/test/test_shape.rb

@@ -0,0 +1,96 @@
+# -*- coding: utf-8 -*-
+
+##########################################################################################
+# Copyright © 2013 Rodrigo Botafogo. All Rights Reserved. Permission to use, copy, modify, 
+# and distribute this software and its documentation, 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.
+#
+# 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 'rubygems'
+require "test/unit"
+require 'shoulda'
+
+require 'mdarray'
+
+class MDArrayTest < Test::Unit::TestCase
+
+  context "Shape Manipulation" do
+
+    setup do 
+
+      # create an int array with 15 elements and 1 dimension
+      # [0 1 2 3 4 5 6 7 8 9 10 11 12 13 14]
+      @a = MDArray.arange(15)
+      assert_equal([15], @a.shape)
+      assert_equal(1, @a.ndim)
+      assert_equal(1, @a.rank)
+      assert_equal(15, @a.size)
+      assert_equal("int", @a.dtype)
+
+    end
+
+    #-------------------------------------------------------------------------------------
+    #
+    #-------------------------------------------------------------------------------------
+
+    should "allow getting a section from an array" do
+
+      b = @a.reshape([3, 5])
+      c = b.section([0, 0], [3, 1])
+      # c.print
+      c = b.section([0, 1], [3, 1])
+      # c.print
+      c = b.section([0, 2], [3, 1])
+      # c.print
+
+    end
+
+    #-------------------------------------------------------------------------------------
+    #
+    #-------------------------------------------------------------------------------------
+
+    should "allow array reshaping" do
+
+      # reshape the array in place
+      # [[0 1 2 3 4]
+      # [5 6 7 8 9]
+      # [10 11 12 13 14]]
+      @a.reshape!([3, 5])
+      assert_equal(2, @a.ndim)
+      assert_equal([3, 5], @a.shape)
+      assert_equal(0, @a[0, 0])
+      assert_equal(5, @a[1, 0])
+      assert_equal(12, @a[2, 2])
+      assert_raise ( RuntimeError ) { @a[3, 4] }
+      
+      # reshape the array without copy
+      b = @a.reshape([15])
+      b[0] = 15
+      assert_equal(15, b[0])
+      assert_equal(15, @a[0, 0])
+
+      # reshape the array with copy
+      c = b.reshape([3, 5], true)
+      assert_equal(15, c[0, 0])
+      c[0, 1] = 20
+      assert_equal(20, c[0, 1])
+      assert_equal(1, b[1])
+
+    end
+
+  end
+
+end

data/test/test_slices.rb

@@ -0,0 +1,146 @@
+require 'rubygems'
+require "test/unit"
+require 'shoulda'
+
+require 'env'
+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])
+      
+    end
+
+    #-------------------------------------------------------------------------------------
+    #
+    #-------------------------------------------------------------------------------------
+=begin
+    should "get section with range" do
+
+      @b[/1:2:3/, /1:5/, /3:4/, 1]
+
+    end
+=end
+
+    #-------------------------------------------------------------------------------------
+    #
+    #-------------------------------------------------------------------------------------
+
+    should "slice array along axes" do
+
+      @a.each_along_axes([3]) do |slice|
+        slice.print
+        print "\n"
+      end
+
+      # each_along_axes returns sub-arrays (sections) of the original array. Each section
+      # is taken by walking along the given axis and getting the all elements of the
+      # axis that were not given.  For instance, array @a shape is [1, 20, 10, 7].  Slicing
+      # along axes [0, 2] will get the following sections of @a: 
+      # section([0, 0, 0, 0], [1, 20, 1, 7]), section ([0, 0, 1, 0], [1, 20, 1, 7]),
+      # section([0, 0, 2, 0], [1, 20, 1, 7])...
+      # This is actually getting all values for every security for the 20 days.
+
+      @a.each_along_axes([0, 2]) do |slice|
+        slice.print
+        p slice.cum_op(MDArray.method(:add))
+        print "\n"
+      end
+
+      # Here we are getting 7 arrays for "open", "close", "High", "Low", etc. each
+      # containing all the 20 days for each security.  So, the first array has 20 elements
+      # each with the "open" value for the first security. The second array returns 
+      # has 20 elements, each with the "close" value for the first security.
+      @a.each_along_axes([2, 3]) do |slice|
+        slice.print
+        print "\n"
+      end
+
+    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 a 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 3rd sec 
+      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
+    
+  end
+  
+end

data/test/test_speed.rb

@@ -0,0 +1,311 @@
+require 'rubygems'
+require "test/unit"
+require 'shoulda'
+require 'jruby/profiler'
+
+require 'env'
+require 'benchmark'
+
+require 'mdarray'
+
+class MDArrayTest < Test::Unit::TestCase
+
+  context "Speed Tests" do
+
+#=begin
+    setup do
+      
+      p "starting speed test"
+      
+    end
+
+    #-------------------------------------------------------------------------------------
+    #
+    #-------------------------------------------------------------------------------------
+
+    should "test addition" do
+
+      @a = MDArray.typed_arange("double", 10_000_000)
+      @b = MDArray.typed_arange("double", 10_000_000)
+
+      @c = MDArray.arange(10_000_000)
+      @d = MDArray.arange(10_000_000)
+
+      puts Benchmark.measure {
+        @a + @b
+        p @a[10]
+      }
+
+      puts Benchmark.measure {
+        @a - @b
+      }
+
+      puts Benchmark.measure {
+        @a + @b
+        p @a[10]
+      }
+
+      puts Benchmark.measure {
+        @a.plus(@b)
+        p @a[10]
+      }
+
+      puts Benchmark.measure {
+        @c.plus(@d)
+      }
+
+      puts Benchmark.measure {
+        @a.fast_add(@b)
+        p @a[10]
+      }
+
+    end
+
+
+=begin
+    should "test inner product" do
+
+      @a = MDArray.typed_arange("double", 10_000_000)
+      @b = MDArray.typed_arange("double", 10_000_000)
+
+      MDArray.make_binary_op("inner_product", "reduce", 
+                             Proc.new { |sum, val1, val2| sum + (val1 * val2) }, 
+                             nil, 
+                             Proc.new { 0 })
+
+      puts "measuring inner_product of two arrays of size: 10.000.000 in seconds"
+      @a.binary_operator = BinaryOperator
+      puts Benchmark.measure {
+        p @a.inner_product(@b)
+        # p (@a * @b).sum
+        
+      }
+      
+    end
+=end
+
+    #-------------------------------------------------------------------------------------
+    #
+    #-------------------------------------------------------------------------------------
+ 
+=begin
+   should "execute fromfunction" do
+
+      # creates an array from a function (actually a block).  The name fromfunction
+      # is preserved to maintain API compatibility with NumPy (is it necessary?)
+      # requires 105.981s to run the following block
+      # requires 92.343s to run the following block
+      # requires 34.096s to run the following block in Java 7 with invokedynamics
+      # requires 5s to run with loop transfered to java
+
+      puts "measuring fromfunction of size: #{7*500*20*320} in seconds"
+      puts Benchmark.measure {
+        @a = MDArray.fromfunction("double", [7, 500, 20, 320]) do |x, y, z, k|
+          # counter[0] + counter[1] + counter[2] + counter[3]
+          x + y + z + k
+        end
+      }
+
+    end
+=end
+
+=begin
+      @a = MDArray.double([7, 500, 20, 320])
+      # @a.unary_operator = UnaryOperator
+      @a.fill do |x, y, z, k|
+        # counter[0] + counter[1] + counter[2] + counter[3]
+        x + y + z + k
+      end
+
+      assert_equal(0, @a[0, 0, 0, 0])
+      assert_equal(50, @a[5, 10, 15, 20])
+
+    end
+=end
+
+
+=begin
+    should "do binary operations in place fast" do
+
+      # @a.fromfunction = 5s (fast), @b.fromfunction = 5s
+      # inplace add requires @a and @b loops each taking a little over 6s.
+      @a = MDArray.fromfunction("double", [7, 500, 20, 320]) do |x, y, z, k|
+      # @a = MDArray.fromfunction("double", [2, 2, 2, 2]) do |x, y, z, k|
+        (x + y + z + k) * -1.2345
+      end
+
+      @b = MDArray.fromfunction("double", [7, 500, 20, 320]) do |x, y, z, k|
+      # @b = MDArray.fromfunction("double", [2, 2, 2, 2]) do |x, y, z, k|
+        (x + y + z + k) * -1.2345
+      end
+      
+      @a.add!(@b)
+      # b = 100 + @a
+      # @a.print
+      # c.print
+
+    end
+
+=end
+
+    #-------------------------------------------------------------------------------------
+    #
+    #-------------------------------------------------------------------------------------
+
+=begin
+    should "iterate fast" do
+      @a = MDArray.double([7, 500, 20, 320])
+      @a.set_all do |counter| 
+        counter[0] + counter[1] + counter[2] + counter[3]
+      end
+
+      p @a[0, 0, 0, 0]
+      p @a[1, 120, 10, 300]
+
+    end
+
+=end
+
+=begin
+ 
+    # executes in 8.37s
+    should "iterate fast" do
+
+      profile_data = JRuby::Profiler.profile do
+        @a = MDArray.fromfunction("double", [7, 500, 20, 320]) do |counter|
+          counter[0] + counter[1] + counter[2] + counter[3]
+          # x + y + z + k
+        end
+      end
+        
+      profile_printer = JRuby::Profiler::FlatProfilePrinter.new(profile_data)
+      profile_printer.printProfile(STDOUT)
+
+      p @a[0, 0, 0, 0]
+      p @a[1, 120, 10, 300]
+
+    end
+
+=end
+
+=begin
+  
+    should "iterate fast" do
+
+      @a = MDArray.fromfunction("int", [7, 500, 20, 320]) do |x, y, z, k|
+        x + y + z + k
+      end
+
+      p @a[0, 0, 0, 0]
+      p @a[1, 120, 10, 300]
+
+
+      @a = MDArray.fromfunction("double", [7, 500, 20, 320]) do |x, y, z, k|
+        x + y + z + k
+      end
+
+      p @a[0, 0, 0, 0]
+      p @a[1, 120, 10, 300]
+
+    end
+
+=end
+
+=begin
+    should "do unary operations fast" do
+
+      # first test of unary operation 15.258s.  fromfunction takes 5.097s, so simple
+      # unary operation is taking 10s, should not take more than fromfunction!
+      # second test of unary operation 10.187s.  fromfunction takes 5.097s, so simple
+      # unary operation is taking 5s.  OK.
+      @a = MDArray.fromfunction("double", [7, 500, 20, 320]) do |x, y, z, k|
+      # @a = MDArray.fromfunction("double", [2, 2, 2, 2]) do |x, y, z, k|
+        (x + y + z + k) * -1.2345
+      end
+
+      b = @a.abs
+      # @a.print
+      # b.print
+
+    end
+=end
+
+=begin
+    should "do binary operations fast" do
+
+      # first test of unary operation 15.258s.  fromfunction takes 5.097s, so simple
+      # unary operation is taking 10s, should not take more than fromfunction!
+      # second test of unary operation 10.187s.  fromfunction takes 5.097s, so simple
+      # unary operation is taking 5s.  OK.
+      @a = MDArray.fromfunction("double", [7, 500, 20, 320]) do |x, y, z, k|
+      # @a = MDArray.fromfunction("double", [2, 2, 2, 2]) do |x, y, z, k|
+        (x + y + z + k) * -1.2345
+      end
+
+      @b = MDArray.fromfunction("double", [7, 500, 20, 320]) do |x, y, z, k|
+      # @b = MDArray.fromfunction("double", [2, 2, 2, 2]) do |x, y, z, k|
+        (x + y + z + k) * -1.2345
+      end
+      
+      c = @a + @b
+      # b = 100 + @a
+      # @a.print
+      # c.print
+
+    end
+=end
+
+=begin
+    should "do binary operations fast with arrays of different types" do
+
+      # first test of unary operation 15.258s.  fromfunction takes 5.097s, so simple
+      # unary operation is taking 10s, should not take more than fromfunction!
+      # second test of unary operation 10.187s.  fromfunction takes 5.097s, so simple
+      # unary operation is taking 5s.  OK.
+      @a = MDArray.fromfunction("double", [7, 500, 20, 320]) do |x, y, z, k|
+      # @a = MDArray.fromfunction("double", [2, 2, 2, 2]) do |x, y, z, k|
+        (x + y + z + k) * -1.2345
+      end
+
+      @b = MDArray.fromfunction("float", [7, 500, 20, 320]) do |x, y, z, k|
+      # @b = MDArray.fromfunction("double", [2, 2, 2, 2]) do |x, y, z, k|
+        (x + y + z + k) * -1.2345
+      end
+      
+      c = @a + @b
+      # b = 100 + @a
+      # @a.print
+      # c.print
+
+    end
+=end
+
+=begin
+    should "do comparison operations fast" do
+
+      # first test of unary operation 15.258s.  fromfunction takes 5.097s, so simple
+      # unary operation is taking 10s, should not take more than fromfunction!
+      # second test of unary operation 10.187s.  fromfunction takes 5.097s, so simple
+      # unary operation is taking 5s.  OK.
+      @a = MDArray.fromfunction("double", [7, 500, 20, 320]) do |x, y, z, k|
+      # @a = MDArray.fromfunction("double", [2, 2, 2, 2]) do |x, y, z, k|
+        (x + y + z + k) * -1.2345
+      end
+
+      @b = MDArray.fromfunction("double", [7, 500, 20, 320]) do |x, y, z, k|
+      # @b = MDArray.fromfunction("double", [2, 2, 2, 2]) do |x, y, z, k|
+        (x + y + z + k) * -1.2345
+      end
+      
+      c = @a > @b
+      # b = 100 + @a
+      # @a.print
+      # c.print
+
+    end
+=end
+
+  end
+  
+end
+