mdarray 0.5.0.pre-java → 0.5.3-java

data/test/complete.rb

@@ -23,3 +23,4 @@ require 'env.rb'
 
 require 'mdarray/test_complete'
 require 'colt/test_complete'
+# require 'mdarray/test_lazy'

data/test/env.rb

@@ -1,7 +1,17 @@
 require 'rbconfig'
 
-# Home directory for MDArray
-$MDARRAY_HOME_DIR = ".."
+=begin
+ENV.each do |val|
+  p val
+end
+=end
+
+# Home directory for MDArray.
+if $INSTALL_DIR
+  $MDARRAY_HOME_DIR = $INSTALL_DIR
+else
+  $MDARRAY_HOME_DIR = ".."
+end  
 
 # MDArray Test directory
 $MDARRAY_TEST_DIR = "./mdarray"
@@ -9,11 +19,14 @@ $MDARRAY_TEST_DIR = "./mdarray"
 # Colt Test directory
 $COLT_TEST_DIR = "./colt"
 
+# Need to change this variable before publication
+# $MDARRAY_ENV = 'cygwin'
+
 ##########################################################################################
 # If we need to test for coverage
 ##########################################################################################
 
-if ENV['COVERAGE'] == 'true'
+if $COVERAGE == 'true'
 
   require 'simplecov'
   
@@ -29,7 +42,7 @@ end
 # Prepare environment to work inside Cygwin
 ##########################################################################################
 
-if ENV['MDARRAY_ENV'] == 'cygwin'
+if $MDARRAY_ENV == 'cygwin'
 
   # RbConfig::CONFIG['host_os'] # returns mswin32 on Windows, for example
   # p Config::CONFIG

data/test/mdarray/arithmetic_casting.rb

@@ -174,12 +174,15 @@ class MDArrayTest < Test::Unit::TestCase
       # adding an int to a double, should cast to double
       res = @a + @c
       assert_equal("21.87 35.34 47.18 58.84 ", res.to_string)
+
       # adding an int array to a (ruby) float/double number, should cast to double
       res = @a + 10.55
       assert_equal("30.55 40.55 50.55 60.55 ", res.to_string)
+
       # adding two ints
       res = @a + @b
       assert_equal(res.to_string, "20 31 42 53 ")
+
       # unary operation on arrays
       res = @c.floor
       assert_equal(res.to_string, "1.0 5.0 7.0 8.0 ")

data/test/mdarray/test_boolean.rb

@@ -45,7 +45,7 @@ class MDArrayTest < Test::Unit::TestCase
       result = @bool2.and(@bool1)
       assert_equal("false false true false ", result.to_string)
 
-      # Cannot overload and, so using & as an alias to and
+      # Cannot overload 'and', so using '&' as an alias to 'and'
       result = @bool1 & @bool2
       assert_equal("false false true false ", result.to_string)
 

data/test/mdarray/test_complete.rb

@@ -60,5 +60,6 @@ require_relative 'test_counter'
 require_relative 'test_trigonometry'
 require_relative 'test_views'
 require_relative 'test_printing'
+require_relative 'test_lazy'
 #require_relative 'test_performance'
 #=end

data/test/mdarray/test_error.rb

@@ -2,7 +2,6 @@ require 'rubygems'
 require "test/unit"
 require 'shoulda'
 
-require 'env'
 require 'mdarray'
 
 class MDArrayTest < Test::Unit::TestCase
@@ -27,27 +26,28 @@ class MDArrayTest < Test::Unit::TestCase
       @f = MDArray.fromfunction("double", [4, 5, 6]) do |x, y, z|
         9.57 * x + y + z
       end
-      @bool = MDArray.boolean([4], [true, true, false, false])
+      @g = MDArray.byte([1], [60])
+      @h = MDArray.byte([1], [13])
+      @i = MDArray.double([4], [2.0, 6.0, 5.0, 9.0])
 
-      @trig = MDArray.typed_arange("double", 90)
-      @long = MDArray.typed_arange("long", 5)
-            
+      @bool1 = MDArray.boolean([4], [true, false, true, false])
+      @bool2 = MDArray.boolean([4], [false, false, true, true])
+      
     end # setup
 
     #-------------------------------------------------------------------------------------
     #
     #-------------------------------------------------------------------------------------
-
+    
     should "correct error!" do
 
-      arr = MDArray.double("VALE3_short.csv", true)
-      arr.print
-
-      arr = MDArray.float("VALE3_short.csv", true)
-      arr.print
+      # define inner_product for the whole hierarchy as it defines it for double
+      UserFunction.binary_operator("inner_product", "reduce", 
+                                   Proc.new { |sum, val1, val2| sum + (val1 * val2) }, 
+                                   "double", nil, Proc.new { 0 })
 
-      arr = MDArray.int("VALE3_short.csv", true)
-      arr.print
+      c = @a.inner_product(@c)
+      assert_equal(926.8, c)
 
     end
     

data/test/mdarray/test_lazy.rb

@@ -0,0 +1,306 @@
+# -*- 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 "Lazy operations" do
+
+    setup do
+
+      @a = MDArray.int([2, 3], [1, 2, 3, 4, 5, 6])
+      @b = MDArray.int([2, 3], [10, 20, 30, 40, 50, 60])
+      @c = MDArray.double([2, 3], [100, 200, 300, 400, 500, 600])
+      @d = MDArray.init_with("int", [2, 3], 4)
+      @e = MDArray.init_with("int", [2, 3], 5)
+      @f = MDArray.init_with("int", [2, 3], 6)
+      @g = MDArray.init_with("int", [2, 3], 7)
+
+      @h = MDArray.init_with("int", [3, 3], 7)
+      @i = MDArray.init_with("int", [3, 3], 7)
+
+      @float = MDArray.init_with("float", [2, 3], 10.5)
+      @long = MDArray.init_with("long", [2, 3], 10)
+      @byte = MDArray.init_with("byte", [2, 3], 10)
+
+      MDArray.lazy = true
+
+    end
+
+
+    #-------------------------------------------------------------------------------------
+    #
+    #-------------------------------------------------------------------------------------
+
+    should "execute lazy operations" do
+
+      p "2 a"
+      a_2 = (@a + @a)[]
+      a_2.print
+
+      c = 2 * @a
+
+      lazy_c = @a + @b
+      # calculate the value of the lazy array with []
+      c = lazy_c[]
+      c.print
+
+      c = (@c + @a)[]
+      c = (@a + @c)[]
+
+      c = (@c + @byte)[]
+      c = (@byte + @c)[]
+     
+      lazy_c = (@a * @d - @e) - (@b + @c)
+      lazy_c[].print
+
+      # evaluate the lazy expression with [] on the same line
+      d = ((@a * @d - @e) - (@b + @c))[]
+      d.print
+
+      # evaluate lazy expression with [] anywhere in the expression. (@a * @d - @e) is 
+      # done lazyly then evaluated then operated with a lazy (@b + @c).  The final 
+      # result is lazy
+      d = ((@a * @d - @e)[] - (@b + @c))
+      d.print
+
+      MDArray.lazy = false
+
+    end
+
+    #-------------------------------------------------------------------------------------
+    #
+    #-------------------------------------------------------------------------------------
+
+    should "check that lazy is contagious" do
+
+      # this is done lazyly as we have "MDArray.lazy = true" defined in the setup
+      l_c = @a + @b
+
+      # now operations are done eagerly
+      MDArray.lazy = false
+      e_e = @c + @b
+      # note that we do not require [] before printing e_e
+      e_e.print
+
+      # now operating a lazy array with an eager array... should be lazy even when 
+      # MDArray.lazy is false
+      l_f = l_c + e_e
+      l_f.print
+      # request the calculation and print
+      l_f[].print
+
+      MDArray.lazy = false
+
+    end
+
+    #-------------------------------------------------------------------------------------
+    #
+    #-------------------------------------------------------------------------------------
+
+    should "execute operations eagerly" do
+
+      MDArray.lazy = false
+
+      c = @a + @b
+      c.print
+
+      c = (@a * @d - @e) - (@b + @c)
+      c.print
+
+      MDArray.lazy = false
+
+    end
+
+    #-------------------------------------------------------------------------------------
+    #
+    #-------------------------------------------------------------------------------------
+
+    should "show that lazy is really lazy" do
+
+      # MDArray lazy operations are really lazy, i.e., there is not checking of any sort
+      # when parsing the expression.  Validation is only done when values are required.
+
+      a = MDArray.int([2, 3], [1, 2, 3, 4, 5, 6])
+      b = MDArray.double([3, 1], [1, 2, 3])
+
+
+      # arrays a and b are of different shape and cannot work together. Yet, there will
+      # be no error while parsing
+      l_c = a + b
+
+      # now we get an error
+      assert_raise ( RuntimeError ) { l_c[].print }
+
+      # now lets add correctly
+      p "calculating lazy c"
+      l_c = @a + @b
+      l_c[].print
+
+      # now lets change @b
+      @b[0, 0] = 1000
+      # and calculate again lazy c
+      p "calculating lazy c again"
+      l_c[].print
+
+      p "calculating expression"
+      @b[1, 0] = 2000
+      p1 = (@a * @d - @e)[]
+      p2 = (@b + @c)[]
+      (p1 - p2)[].print
+      p "@b is"
+      @b.print
+
+      # evaluate lazy expression with [] anywhere in the expression. (@a * @d - @e) is 
+      # done lazyly then evaluated then operated with a lazy (@b + @c).  The final 
+      # result is lazy
+      p "calculating lazy d"
+      d = ((@a * @d - @e)[] - (@b + @c))
+      d[].print
+      # lets now change the value of @a
+      @a[0, 0] = 1000
+      # no change in d... @a has being eagerly calculated
+      p "lazy d again after changing @a"
+      d[].print
+      # lets now change @b
+      @b[0, 0] = 1
+      @b[0, 1] = 150
+      @b[1, 1] = 1000
+      p "b is now:"
+      @b.print
+      # @b is still lazy on d calculation, so changing @b will change the value 
+      # of d[].
+      p "lazy d again after changing @b"
+      d[].print
+
+      p "calculating new expression"
+      p3 = (@b + @c)
+      (p1 - p3)[].print
+
+      MDArray.lazy = false
+
+    end
+
+    #-------------------------------------------------------------------------------------
+    #
+    #-------------------------------------------------------------------------------------
+
+    should "work with Numeric" do
+
+      l_c = @a + 2
+      l_c[].print
+
+      l_c = 2 + @a
+      l_c[].print
+
+      l_c = 2 - @a
+      l_c[].print
+
+      MDArray.lazy = false
+
+    end
+
+    #-------------------------------------------------------------------------------------
+    #
+    #-------------------------------------------------------------------------------------
+    should "work with unary operators" do
+
+      # MDArray.lazy = false
+
+      arr = MDArray.linspace("double", 0, 1, 100)
+      l_a = arr.sin
+      l_a.print
+
+      b = l_a[]
+      b.print
+
+      ((@a * @d - @e).sin - (@b + @c))[].print
+
+      sinh = (arr.sinh)[]
+      
+      MDArray.lazy = false
+
+    end
+
+    #-------------------------------------------------------------------------------------
+    #
+    #-------------------------------------------------------------------------------------
+
+=begin
+    should "convert expressions involving only arrays to RPN" do
+
+      lazy_c = @a + @b
+      assert_equal("int int add ", lazy_c.rpn)
+
+      lazy_d = @a * @b
+      assert_equal("int int mul ", lazy_d.rpn)
+
+      lazy_e = lazy_c / lazy_d
+      assert_equal("int int add int int mul div ", lazy_e.rpn)
+
+      lazy_c = @a - @b + (@c * @d / (@f + @g))
+      assert_equal("int int sub int int mul int int add div add ", lazy_c.rpn)
+
+      lazy_f = @a - @b + (@c * @d - @f / (@f + @g))
+      assert_equal("int int sub int int mul int int int add div sub add ", lazy_f.rpn)
+
+    end
+
+    #-------------------------------------------------------------------------------------
+    #
+    #-------------------------------------------------------------------------------------
+
+    should "validate operations" do
+
+      lazy_c = @a + @b
+      lazy_c.validate
+
+      # does not validate as shapes are different
+      lazy_e = @h + @a
+      assert_raise ( RuntimeError ) { lazy_e.validate }
+
+      lazy_f = @h + @i - @a + @b
+      assert_raise ( RuntimeError ) { lazy_f.validate }
+
+      lazy_g = @h + @i
+
+      lazy_k = lazy_g + lazy_c
+      assert_raise ( RuntimeError ) { lazy_k.validate }
+      
+    end
+
+    #-------------------------------------------------------------------------------------
+    #
+    #-------------------------------------------------------------------------------------
+
+    should "convert expressions involving numeric to RPN" do
+
+    end
+=end
+  end
+  
+end

data/test/mdarray/test_operator.rb

@@ -315,7 +315,7 @@ class MDArrayTest < Test::Unit::TestCase
       # Possible to create a new binary operator and force the final type of the resulting
       # MDArray.  Bellow, whenever addd is used the resulting array will be of type double
       func = MDArray.select_function("add")
-      UserFunction.binary_operator("addd", "default", func, "double", "double")
+      UserFunction.binary_operator("addd", "default", func.function, "double", "double")
       
       # @a and @b are int arrays, so result should be int, but since addd is used, resulting
       # array will be double