mdarray 0.5.3-java → 0.5.4-java

data/test/complete.rb

@@ -23,4 +23,12 @@ require 'env.rb'
 
 require 'mdarray/test_complete'
 require 'colt/test_complete'
-# require 'mdarray/test_lazy'
+require 'netcdf/test_complete'
+
+
+# Temporary tests.  Remove before shipping!
+
+# require 'colt/test_matrix'
+# require 'netcdf/test_netcdf'
+# require 'mdarray/test_sections'
+# require 'netcdf/netcdfwriter'

data/test/env.rb

@@ -19,6 +19,9 @@ $MDARRAY_TEST_DIR = "./mdarray"
 # Colt Test directory
 $COLT_TEST_DIR = "./colt"
 
+# Tmp directory
+$TMP_TEST_DIR = "./tmp"
+
 # Need to change this variable before publication
 # $MDARRAY_ENV = 'cygwin'
 
@@ -34,6 +37,7 @@ if $COVERAGE == 'true'
     @filters = []
     add_group "MDArray", "lib/mdarray"
     add_group "Colt", "lib/colt"
+    add_group "NetCDF", "lib/netcdf"
   end
 
 end
@@ -75,7 +79,13 @@ if $MDARRAY_ENV == 'cygwin'
 
   $MDARRAY_TEST_DIR = cygpath($MDARRAY_TEST_DIR)
   $COLT_TEST_DIR = cygpath($COLT_TEST_DIR)
-  
+
+else
+
+  def cygpath(path)
+    path
+  end
+
 end
 
 =begin

data/test/mdarray/test_complete.rb

@@ -50,6 +50,7 @@
 
 #=begin
 require_relative 'test_creation'
+require_relative 'test_non_numeric'
 require_relative 'test_access'
 require_relative 'test_operator'
 require_relative 'arithmetic_casting'
@@ -61,5 +62,6 @@ require_relative 'test_trigonometry'
 require_relative 'test_views'
 require_relative 'test_printing'
 require_relative 'test_lazy'
+require_relative 'test_sections'
 #require_relative 'test_performance'
 #=end

data/test/mdarray/test_creation.rb

@@ -316,45 +316,36 @@ class MDArrayTest < Test::Unit::TestCase
     end
 
     #-------------------------------------------------------------------------------------
-    #
+    # Creates a scalar array, i.e, array of size 0.  In general this is not necessary and
+    # should not be used as one can operate with scalars directly.  This is however needed 
+    # for writing scalar values on NetCDF-3 files.
     #-------------------------------------------------------------------------------------
 
-    should "create boolean arrays" do
-
-      bool = MDArray.boolean([2, 2])
-      bool[0, 0] = true
-      assert_raise ( RuntimeError ) { bool[0, 1] = 10.0 }
-      assert_equal(bool[0, 0], true)
-      bool[0, 1] = false
-      assert_equal(bool[0, 1], false)
+    should "create scalar arrays" do
 
-    end
+      scalar = MDArray.double([])
+      scalar.set_scalar(2.55)
+      assert_equal(2.55, scalar.get_scalar)
 
-    #-------------------------------------------------------------------------------------
-    #
-    #-------------------------------------------------------------------------------------
-
-    should "create string arrays" do
-
-      sarray = MDArray.string([2, 3], ["hello", "this", "is", "a", "string", "array"])
-      assert_equal(6, sarray.size)
-      assert_equal("hello", sarray.get([0, 0]))
-      assert_equal("hello this is a string array ", sarray.to_string)
+      scalar2 = MDArray.double([])
+      scalar2.set_scalar(5.55)
+      
+      scalar3 = scalar + scalar2
 
     end
 
     #-------------------------------------------------------------------------------------
-    # A struct array is an array of pointers to structures
+    # Creates a MDArray from a java array.  Needed for some internal methods. Not to be
+    # used in general
     #-------------------------------------------------------------------------------------
 
-    should "create struct arrays" do
+    should "creade arrays from java arrays" do
 
-      m = Hash.new
-      m[:hello] = "world"
-      m[:test] = 1.23
-
-      struct = MDArray.structure([10])
-      struct[0] = m
+      value = Array.new
+      (0...5).each do |val|
+        value << val.to_java(:float)
+      end
+      MDArray.from_jstorage("float", [1], value.to_java(:float))
 
     end
 

data/test/mdarray/test_non_numeric.rb

@@ -0,0 +1,97 @@
+# -*- 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 "Non-numeric Array Creation" do
+
+    #-------------------------------------------------------------------------------------
+    # array creation always requires the type and shape, differently from NumPy 
+    # narray in which the type and shape can be inferred from the initialization
+    # data.  MDArray can be numerical and non-numerical.  Numerical MDArrays can be of 
+    # type: byte, short, int, long, double.  Non-numerical MDArrays can be of type
+    # boolean, char, string.
+    #-------------------------------------------------------------------------------------
+
+    #-------------------------------------------------------------------------------------
+    #
+    #-------------------------------------------------------------------------------------
+
+    should "create boolean arrays" do
+
+      bool = MDArray.boolean([2, 2])
+      bool[0, 0] = true
+      assert_raise ( RuntimeError ) { bool[0, 1] = 10.0 }
+      assert_equal(bool[0, 0], true)
+      bool[0, 1] = false
+      assert_equal(bool[0, 1], false)
+
+    end
+
+    #-------------------------------------------------------------------------------------
+    #
+    #-------------------------------------------------------------------------------------
+
+    should "create string arrays" do
+
+      sarray = MDArray.string([2, 3], ["hello", "this", "is", "a", "string", "array"])
+      assert_equal(6, sarray.size)
+      assert_equal("hello", sarray.get([0, 0]))
+      assert_equal("hello this is a string array ", sarray.to_string)
+      sarray.print
+
+      sarray2 = MDArray.string([], ["hello, this is a string array"])
+      p sarray2.shape
+      sarray2.print
+
+      sarray3 = MDArray.string([3], 
+                               ["No pairs of ladies stockings!",
+                                "One pair of ladies stockings!",
+                                "Two pairs of ladies stockings!"])
+      p sarray3.shape
+      sarray3.print
+
+    end
+
+    #-------------------------------------------------------------------------------------
+    # A struct array is an array of pointers to structures
+    #-------------------------------------------------------------------------------------
+
+    should "create struct arrays" do
+
+      m = Hash.new
+      m[:hello] = "world"
+      m[:test] = 1.23
+
+      struct = MDArray.structure([10])
+      struct[0] = m
+
+    end
+
+  end
+
+end

data/test/mdarray/test_sections.rb

@@ -0,0 +1,94 @@
+# -*- 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 "Section Tests" do
+
+    setup do
+            
+    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 "create sections" do
+
+      #-----------------------------------------------------------------------------------
+      # create a section from a section spec
+      # Parse an index section String specification, return equivilent Section. A null 
+      # Range means "all" (i.e.":") indices in that dimension.
+      # The sectionSpec string uses fortran90 array section syntax, namely:
+      #
+      # sectionSpec := dims
+      # dims := dim | dim, dims
+      # dim := ':' | slice | start ':' end | start ':' end ':' stride
+      # slice := INTEGER
+      # start := INTEGER
+      # stride := INTEGER
+      # end := INTEGER
+      #
+      # where nonterminals are in lower case, terminals are in upper case, literals are in 
+      # single quotes.
+      #
+      # Meaning of index selector :
+      # ':' = all
+      # slice = hold index to that value
+      # start:end = all indices from start to end inclusive
+      # start:end:stride = all indices from start to end inclusive with given stride
+      #-----------------------------------------------------------------------------------
+
+      # creates a section from a spec
+      section = MDArray::Section.build(:spec => "0:0,0:5:5")
+      assert_equal("0:0,0:5:5", section.to_s)
+
+      section = MDArray::Section.build(:spec => ":,5:10,3:27:3")
+      assert_equal(":,5:10,3:27:3", section.to_s)
+
+      # cannot create a section with only the origin, we also need the size and stride
+      assert_raise ( RuntimeError ) { MDArray::Section.build(:origin => [0, 0]) }
+
+      # create a section with origin, size and stride
+      section = MDArray::Section.build(:origin => [0, 0], :size => [5, 10], 
+                                       :stride => [2, 3])
+      assert_equal("0:4:2,0:9:3", section.to_s)
+
+      # create a section with origin and shape
+      section = MDArray::Section.build(:origin => [5, 1, 2], :shape => [10, 3, 7])
+      section.print
+
+      # create a section from shape only
+      section = MDArray::Section.build(:shape => [10, 3, 7])
+      assert_equal("0:9,0:2,0:6", section.to_s)
+
+    end
+
+  end
+
+end

data/test/mdarray/test_views.rb

@@ -1,3 +1,24 @@
+# -*- 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'
@@ -250,6 +271,7 @@ class MDArrayTest < Test::Unit::TestCase
     end
 
     #-------------------------------------------------------------------------------------
+    #
     #-------------------------------------------------------------------------------------
 
     should "permute array indices" do
@@ -273,7 +295,7 @@ class MDArrayTest < Test::Unit::TestCase
     # backing store as the original array.
     #-------------------------------------------------------------------------------------
 
-    should "permute array indices" do
+    should "transpose array indices" do
 
       # c shape is [2, 3, 4]
       # b shape is now [3, 2, 4] by transposing the first two dimensions

data/test/netcdf/netcdfwriter.rb

@@ -0,0 +1,197 @@
+require 'mdarray'
+
+class NetCDF
+
+  attr_reader :dir, :filename, :max_strlen
+
+  #---------------------------------------------------------------------------------------
+  #
+  #---------------------------------------------------------------------------------------
+
+  def initialize
+    @dir = $TMP_TEST_DIR
+    @filename1 = "testWriter"
+    @filename2 = "testWriteRecord2"
+    @max_strlen = 80
+  end
+    
+  #---------------------------------------------------------------------------------------
+  # Define the NetCDF-3 file
+  #---------------------------------------------------------------------------------------
+
+  def define_file
+      
+    # We pass the directory, filename, filetype and optionaly the outside_scope.  
+    #
+    # I'm implementing in cygwin, so the need for method cygpath that converts the 
+    # directory name to a Windows name.  In another environment, just pass the directory
+    # name.
+    # 
+    # Inside a block we have another scope, so the block cannot access any variables, etc. 
+    # from the ouside scope. If we pass the outside scope, in this case we are passing self,
+    # we can access variables in the outside scope by using @outside_scope.<variable>.
+    NetCDF.define(cygpath(@dir), @filename1, "netcdf3", self) do
+      
+      # add dimensions
+      dimension "lat", 64
+      dimension "lon", 128
+      
+      # add variables and attributes
+      # add Variable double temperature(lat, lon)
+      variable "temperature", "double", [@dim_lat, @dim_lon]
+      variable_att @var_temperature, "units", "K"
+      variable_att @var_temperature, "scale", [1, 2, 3]
+      
+      # add a string-value variable: char svar(80)
+      # note that this is created as a scalar variable although in NetCDF-3 there is no
+      # string type and the string has to be represented as a char type.
+      variable "svar", "string", [], {:max_strlen => @outside_scope.max_strlen}
+      
+      # add a 2D string-valued variable: char names(names, 80)
+      dimension "names", 3
+      variable "names", "string", [@dim_names], {:max_strlen => @outside_scope.max_strlen}
+      
+      # add a scalar variable
+      variable "scalar", "double", []
+      
+      # add global attributes
+      global_att "yo", "face"
+      global_att "versionD", 1.2, "double"
+      global_att "versionF", 1.2, "float"
+      global_att "versionI", 1, "int"
+      global_att "versionS", 2, "short"
+      global_att "versionB", 3, "byte"
+      
+    end
+
+  end
+
+  #---------------------------------------------------------------------------------------
+  # write data on the above define file
+  #---------------------------------------------------------------------------------------
+
+  def write_file
+
+    NetCDF.write(cygpath(@dir), @filename1, self) do
+
+      temperature = find_variable("temperature")
+      shape = temperature.shape
+      data = MDArray.fromfunction("double", shape) do |i, j|
+        i * 1_000_000 + j * 1_000
+      end
+      write(temperature, data)
+
+      svar = find_variable("svar")
+      write_string(svar, "Two pairs of ladies stockings!")
+
+      names = find_variable("names")
+      # careful here with the shape of a string variable.  A string variable has one
+      # more dimension than it should as there is no string type in NetCDF-3.  As such,
+      # if we look as names' shape it has 2 dimensions, be we need to create a one
+      # dimension string array.
+      data = MDArray.string([3], ["No pairs of ladies stockings!",
+                                  "One pair of ladies stockings!",
+                                  "Two pairs of ladies stockings!"])
+      write_string(names, data)
+
+      # write scalar data
+      scalar = find_variable("scalar")
+      write(scalar, 222.333 )
+
+    end
+
+  end
+
+  #---------------------------------------------------------------------------------------
+  # Define a file for writing one record at a time
+  #---------------------------------------------------------------------------------------
+
+  def define_one_at_time
+
+    NetCDF.define(cygpath(@dir), @filename2, "netcdf3", self) do
+      
+      dimension "lat", 3
+      dimension "lon", 4
+      # zero sized dimension is an unlimited dimension
+      dimension "time", 0
+      
+      variable "lat", "float", [@dim_lat]
+      variable_att @var_lat, "units", "degree_north"
+
+      variable "lon", "float", [@dim_lon]
+      variable_att @var_lon, "units", "degree_east"
+
+      variable "rh", "int", [@dim_time, @dim_lat, @dim_lon]
+      variable_att @var_rh, "long_name", "relative humidity"
+      variable_att @var_rh, "units", "percent"
+      
+      variable "T", "double", [@dim_time, @dim_lat, @dim_lon]
+      variable_att @var_t, "long_name", "surface temperature"
+      variable_att @var_t, "units", "degC"
+
+      variable "time", "int", [@dim_time]
+      variable_att @var_time, "units", "hours since 1990-01-01"
+
+    end
+
+  end
+
+  #---------------------------------------------------------------------------------------
+  # Define a file for writing one record at a time
+  #---------------------------------------------------------------------------------------
+
+  def write_one_at_time
+
+    NetCDF.write(cygpath(@dir), @filename2, self) do
+
+      lat = find_variable("lat")
+      lon = find_variable("lon")
+      write(lat, MDArray.float([3], [41, 40, 39]))
+      write(lon, MDArray.float([4], [-109, -107, -105, -103]))
+
+      # get variables from file
+      rh = find_variable("rh")
+      time = find_variable("time")
+      t = find_variable("T")
+
+      # there is no method find_dimension for NetcdfFileWriter, so we need to get the
+      # dimension from a variable.
+      rh_shape = rh.shape
+      dim_lat = rh_shape[1]
+      dim_lon = rh_shape[2]
+
+      (0...10).each do |time_idx|
+
+        # fill rh_data array
+        rh_data = MDArray.fromfunction("int", [dim_lat, dim_lon]) do |lat, lon|
+          time_idx * lat * lon
+        end
+        # reshape rh_data so that it has the same shape as rh variable
+        # Method reshape! reshapes the array in-place without data copying.
+        rh_data.reshape!([1, dim_lat, dim_lon])
+
+        # fill temp_data array
+        temp_data = MDArray.fromfunction("double", [dim_lat, dim_lon]) do |lat, lon|
+          time_idx * lat * lon / 3.14159
+        end
+        # reshape temp_data array so that it has the same shape as temp variable.
+        temp_data.reshape!([1, dim_lat, dim_lon])
+        
+        # write the variables
+        write(time, MDArray.int([1], [time_idx * 12]), [time_idx])
+        write(rh, rh_data, [time_idx, 0, 0])
+        write(t, temp_data, [time_idx, 0, 0])
+
+      end # End time_idx loop
+      
+    end
+
+  end
+
+end
+
+netcdf = NetCDF.new
+netcdf.define_file
+netcdf.write_file
+netcdf.define_one_at_time
+netcdf.write_one_at_time