mdarray 0.5.3-java → 0.5.4-java

data/README.md

@@ -1,89 +1,344 @@
-MDArray
-=======
+Announcement
+============
+
+MDArray version 0.5.4 has Just been released. MDArray is a multi dimensional array implemented 
+for JRuby inspired by NumPy (www.numpy.org) and Masahiro Tanaka´s Narray (narray.rubyforge.org).
+MDArray stands on the shoulders of Java-NetCDF and Parallel Colt.  At this point MDArray has 
+libraries for mathematical, trigonometric and descriptive statistics methods.
 
-MDArray is a multi dimensional array implemented for JRuby inspired by NumPy (www.numpy.org) 
-and Narray (narray.rubyforge.org) by Masahiro Tanaka.  MDArray stands on the shoulders of 
-Java-NetCDF and Parallel Colt.
- 
 NetCDF-Java Library is a Java interface to NetCDF files, as well as to many other types of 
-scientific data formats.  It is developed and distributed by Unidata (http://www.unidata.ucar.edu). 
+scientific data formats.  It is developed and distributed by Unidata 
+(http://www.unidata.ucar.edu).
+
+Parallel Colt (http://grepcode.com/snapshot/repo1.maven.org/maven2/net.sourceforge.parallelcolt/
+parallelcolt/0.10.0/) is a multithreaded version of Colt (http://acs.lbl.gov/software/colt/).  
+Colt provides a set of Open Source Libraries for High Performance Scientific and Technical 
+Computing in Java. Scientific and technical computing is characterized by demanding problem 
+sizes and a need for high performance at reasonably small memory footprint.
+
+For more information and (some) documentation please go to: https://github.com/rbotafogo/mdarray/wiki
+
+What´s new:
+===========
+
+NetCDF-3 File Support
+---------------------
+
+From Wikipedia, the free encyclopedia:
+
+"NetCDF (Network Common Data Form) is a set of software libraries and self-describing, 
+machine-independent data formats that support the creation, access, and sharing of array-oriented 
+scientific data. The project homepage is hosted by the Unidata program at the University 
+Corporation for Atmospheric Research (UCAR). They are also the chief source of netCDF software, 
+standards development, updates, etc. The format is an open standard. NetCDF Classic and 64-bit 
+Offset Format are an international standard of the Open Geospatial Consortium.
 
-Parallel Colt (sites.google.com/site/piotrwendykier/software/parallelcolt) is a multithreaded 
-version of Colt (http://acs.lbl.gov/software/colt/).  Colt provides a set of Open Source 
-Libraries for High Performance Scientific and Technical Computing in Java. Scientific 
-and technical computing is characterized by demanding problem sizes and a need for high 
-performance at reasonably small memory footprint.
+The project is actively supported by UCAR. Version 4.0 (released in 2008) allows the use of the 
+HDF5 data file format. Version 4.1 (2010) adds support for C and Fortran client access to 
+specified subsets of remote data via OPeNDAP.
 
-MDArray and SciRuby
-===================
+The format was originally based on the conceptual model of the Common Data Format developed by 
+NASA, but has since diverged and is not compatible with it."
 
-MDArray subscribes fully to the SciRuby Manifesto (http://sciruby.com/).  
+This version of MDArray implements NetCDF-3 file support only.  NetCDF-4 is not yet supported.  At
+the end of this announcement we show the MDArray implementation of the NetCDF-3 writing from the
+tutorial at: http://www.unidata.ucar.edu/software/netcdf-java/tutorial/NetcdfWriting.html
 
-Ruby has for some time had no equivalent to the beautifully constructed NumPy, SciPy, 
-and matplotlib libraries for Python. 
+
+MDArray and SciRuby:
+====================
+
+MDArray subscribes fully to the SciRuby Manifesto (http://sciruby.com/). 
+
+“Ruby has for some time had no equivalent to the beautifully constructed NumPy, SciPy, and 
+matplotlib libraries for Python. 
 
 We believe that the time for a Ruby science and visualization package has come. Sometimes 
 when a solution of sugar and water becomes super-saturated, from it precipitates a pure, 
-delicious, and diabetes-inducing crystal of sweetness, induced by no more than the tap 
-of a finger. So is occurring now, we believe, with numeric and visualization libraries for Ruby.”
-
-Main properties
-===============
-
-  + Homogeneous multidimensional array, a table of elements (usually numbers), all of the 
-      same type, indexed by a tuple of positive integers;
-  + Easy calculation for large numerical multi dimensional arrays;
-  + Basic types are: boolean, byte, short, int, long, float, double, string, structure;
-  + Based on JRuby, which allows importing Java libraries;
-  + Operator: +,-,*,/,%,**, >, >=, etc.
-  + Functions: abs, ceil, floor, truncate, is_zero, square, cube, fourth;
-  + Binary Operators: &, |, ^, ~ (binary_ones_complement), <<, >>;
-  + Ruby Math functions: acos, acosh, asin, asinh, atan, atan2, atanh, cbrt, cos, erf, exp, 
-      gamma, hypot, ldexp, log, log10, log2, sin, sinh, sqrt, tan, tanh, neg;
-  + Boolean operations on boolean arrays: and, or, not;
-  + Fast descriptive statistics from Parallel Colt (complete list found bellow);
-  + Easy manipulation of arrays: reshape, reduce dimension, permute, section, slice, etc.
-  + Reading of two dimensional arrays from CSV files (mainly for debugging and simple 
-      testing purposes);
-  + StatList: a list that can grow/shrink and that can compute Parallel Colt descriptive 
-      statistics. 
-
-Descriptive statistics methods
-==============================
-
-auto_correlation, correlation, covariance, durbin_watson, frequencies, geometric_mean, 
-harmonic_mean, kurtosis, lag1, max, mean, mean_deviation, median, min, moment, moment3, 
-moment4, pooled_mean, pooled_variance, product, quantile, quantile_inverse, 
-rank_interpolated, rms, sample_covariance, sample_kurtosis, 
-sample_kurtosis_standard_error, sample_skew, sample_skew_standard_error, 
-sample_standard_deviation, sample_variance, sample_weighted_variance, skew, split,  
-standard_deviation, standard_error, sum, sum_of_inversions, sum_of_logarithms, 
-sum_of_powers, sum_of_power_deviations, sum_of_squares, sum_of_squared_deviations, 
-trimmed_mean, variance, weighted_mean, weighted_rms, weighted_sums, winsorized_mean.
-
-Installation and download
-=========================
+delicious, and diabetes-inducing crystal of sweetness, induced by no more than the tap of a 
+finger. So is occurring now, we believe, with numeric and visualization libraries for Ruby.”
 
-  + Install Jruby
-  + jruby –S gem install mdarray
+MDArray main properties are:
+============================
 
-Contributors
-============
+ + Homogeneous multidimensional array, a table of elements (usually numbers), all of the 
+     same type, indexed by a tuple of positive integers;
+ + Easy calculation for large numerical multi dimensional arrays;
+ + Basic types are: boolean, byte, short, int, long, float, double, string, structure;
+ + Based on JRuby, which allows importing Java libraries;
+ + Operator: +,-,*,/,%,**, >, >=, etc.;
+ + Functions: abs, ceil, floor, truncate, is_zero, square, cube, fourth;
+ + Binary Operators: &, |, ^, ~ (binary_ones_complement), <<, >>;
+ + Ruby Math functions: acos, acosh, asin, asinh, atan, atan2, atanh, cbrt, cos, erf, exp, 
+     gamma, hypot, ldexp, log, log10, log2, sin, sinh, sqrt, tan, tanh, neg;
+ + Boolean operations on boolean arrays: and, or, not;
+ + Fast descriptive statistics from Parallel Colt (complete list found bellow);
+ + Easy manipulation of arrays: reshape, reduce dimension, permute, section, slice, etc.;
+ + Support for reading and writing NetCDF-3 files;
+ + Reading of two dimensional arrays from CSV files (mainly for debugging and simple testing 
+     purposes);
+ + StatList: a list that can grow/shrink and that can compute Parallel Colt descriptive 
+     statistics;
+ + Experimental lazy evaluation (still slower than eager evaluation).
+
+Descriptive statistics methods imported from Parallel Colt:
+===========================================================
+
+  + auto_correlation, correlation, covariance, durbin_watson, frequencies, geometric_mean, 
+  + harmonic_mean, kurtosis, lag1, max, mean, mean_deviation, median, min, moment, moment3, 
+  + moment4, pooled_mean, pooled_variance, product, quantile, quantile_inverse, 
+  + rank_interpolated, rms, sample_covariance, sample_kurtosis, sample_kurtosis_standard_error, 
+  + sample_skew, sample_skew_standard_error, sample_standard_deviation, sample_variance, 
+  + sample_weighted_variance, skew, split,  standard_deviation, standard_error, sum, 
+  + sum_of_inversions, sum_of_logarithms, sum_of_powers, sum_of_power_deviations, 
+  + sum_of_squares, sum_of_squared_deviations, trimmed_mean, variance, weighted_mean, 
+  + weighted_rms, weighted_sums, winsorized_mean.
 
-  + Contributors are welcome.
+Double and Float methods from Parallel Colt:
+============================================
 
-Homepages
-=========
+  + acos, asin, atan, atan2, ceil, cos, exp, floor, greater, IEEEremainder, inv, less, lg, 
+  + log, log2, rint, sin, sqrt, tan.
+
+Double, Float, Long and Int methods from Parallel Colt:
+=======================================================
+
+  + abs, compare, div, divNeg, equals, isEqual (is_equal), isGreater (is_greater), 
+  + isles (is_less), max, min, minus, mod, mult, multNeg (mult_neg), multSquare (mult_square), 
+  + neg, plus (add), plusAbs (plus_abs), pow (power), sign, square.
+
+Long and Int methods from Parallel Colt
+=======================================
+
+  + and, dec, factorial, inc, not, or, shiftLeft (shift_left), shiftRightSigned 
+      (shift_right_signed), shiftRightUnsigned (shift_right_unsigned), xor.
+
+MDArray installation and download:
+==================================
+
+  + Install Jruby
+  + jruby –S gem install mdarray
+
+MDArray Homepages:
+==================
 
   + http://rubygems.org/gems/mdarray
   + https://github.com/rbotafogo/mdarray/wiki
 
+Contributors:
+=============
+Contributors are welcome.
+
+MDArray History:
+================
+
+  + 07/08/2013: Version 0.5.4 - Support for reading and writing NetCDF-3 files
+  + 24/06/2013: Version 0.5.3 – Over 90% Performance improvements for methods imported 
+      from Parallel Colt and over 40% performance improvements for all other methods 
+      (implemented in Ruby); 
+  + 16/05/2013: Version 0.5.0 - All loops transferred to Java with over 50% performance 
+      improvements.  Descriptive statistics from Parallel Colt;
+  + 19/04/2013: Version 0.4.3 - Fixes a simple, but fatal bug in 0.4.2.  No new features;
+  + 17/04/2013: Version 0.4.2 - Adds simple statistics and boolean operators;
+  + 05/04/2013: Version 0.4.0 – Initial release.
+
+NetCDF-3 Writing with MDArray API
+=================================
+
+require 'mdarray'
+
+class NetCDF
+
+  attr_reader :dir, :filename, :max_strlen
+
+  #---------------------------------------------------------------------------------------
+  #
+  #---------------------------------------------------------------------------------------
+
+  def initialize
+    @dir = "~/tmp"
+    @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
 
-HISTORY
-=======
+end
 
-  + 16/05/2013: Version 0.5.0: All loops transfered to Java with over 50% performance 
-      improvement.  Descriptive statistics from Parallel Colt.
-  + 19/04/2013: Version 0.4.3: Fixes a simple (but fatal bug).  No new features
-  + 17/04/2013: Version 0.4.2: Adds simple statistics and boolean operators
-  + 05/05/2013: Version 0.4.0: Initial release
+netcdf = NetCDF.new
+netcdf.define_file
+netcdf.write_file
+netcdf.define_one_at_time
+netcdf.write_one_at_time

data/lib/colt/colt.rb

@@ -154,5 +154,7 @@ require_relative 'cern_float_functions'
 require_relative 'cern_long_functions'
 require_relative 'cern_int_functions'
 
+require_relative 'matrix/colt_matrix'
+
 MDArray.functions = "CernFunctions"
 

data/lib/colt/matrix/colt_matrix.rb

@@ -0,0 +1,365 @@
+# -*- coding: utf-8 -*-
+
+##########################################################################################
+# Copyright © 2013 Rodrigo Botafogo. All Rights Reserved. Permission to use, copy, modify, 
+# and distribute this software and its documentation for educational, research, and 
+# not-for-profit purposes, 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. Contact Rodrigo
+# Botafogo - rodrigo.a.botafogo@gmail.com for commercial licensing opportunities.
+#
+# 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 'java'
+
+class MDMatrix
+  include_package "cern.colt.matrix.tdouble.impl"
+  include_package "cern.colt.matrix.tdouble.algo"
+
+  include_package "cern.colt.matrix.tfloat.impl"
+  include_package "cern.colt.matrix.tfloat.algo"
+
+  include_package "cern.colt.matrix.tlong.impl"
+  include_package "cern.colt.matrix.tlong.algo"
+
+  include_package "cern.colt.matrix.tint.impl"
+  include_package "cern.colt.matrix.tint.algo"
+
+
+  attr_reader :colt_matrix
+  attr_reader :mdarray
+  attr_reader :rank
+
+  #------------------------------------------------------------------------------------
+  # 
+  #------------------------------------------------------------------------------------
+  
+  def initialize(mdarray, colt_matrix)
+    @mdarray = mdarray
+    @colt_matrix = colt_matrix
+    @rank = @mdarray.rank
+    @algebra = nil
+  end
+
+  #------------------------------------------------------------------------------------
+  # 
+  #------------------------------------------------------------------------------------
+
+  def self.build(type, shape, storage = nil)
+    if (shape.size > 3)
+      raise "Cannot create MDMatrix of size greater than 3"
+    end
+    self.from_mdarray(MDArray.build(type, shape, storage))
+  end
+
+  #------------------------------------------------------------------------------------
+  # 
+  #------------------------------------------------------------------------------------
+
+  def self.double(shape, storage = nil)
+    self.build("double", shape, storage)
+  end
+
+  #------------------------------------------------------------------------------------
+  # 
+  #------------------------------------------------------------------------------------
+
+  def self.float(shape, storage = nil)
+    self.build("float", shape, storage)
+  end
+
+  #------------------------------------------------------------------------------------
+  # 
+  #------------------------------------------------------------------------------------
+
+  def self.long(shape, storage = nil)
+    self.build("long", shape, storage)
+  end
+
+  #------------------------------------------------------------------------------------
+  # 
+  #------------------------------------------------------------------------------------
+
+  def self.int(shape, storage = nil)
+    self.build("int", shape, storage)
+  end
+
+  #------------------------------------------------------------------------------------
+  # Creates a MDMatrix from an MDArray.
+  # (int rows, int columns, double[] elements, int rowZero, int columnZero, 
+  # int rowStride, int columnStride, boolean isView)
+  #------------------------------------------------------------------------------------
+
+  def self.from_mdarray(mdarray)
+
+    case mdarray.rank
+
+    when 1
+      dense1D(mdarray)
+    when 2
+      dense2D(mdarray)
+    when 3
+      dense3D(mdarray)
+    else
+      raise "Cannot create MDMatrix of rank greater than 3"
+    end
+
+  end
+
+  #------------------------------------------------------------------------------------
+  # Creates a new MDMatrix from a given colt_matrix
+  #------------------------------------------------------------------------------------
+
+  def self.from_colt_matrix(colt_matrix)
+
+    if (colt_matrix.is_a? DenseDoubleMatrix3D)
+      mdarray = MDArray.from_jstorage("double", 
+                                      [colt_matrix.slices, colt_matrix.rows, 
+                                       colt_matrix.columns], colt_matrix.elements)
+      return DoubleMDMatrix3D.from_mdarray(mdarray)
+    elsif (colt_matrix.is_a? DenseFloatMatrix3D)
+      mdarray = MDArray.from_jstorage("float", 
+                                      [colt_matrix.slices, colt_matrix.rows, 
+                                       colt_matrix.columns], colt_matrix.elements)
+      return FloatMDMatrix3D.from_mdarray(mdarray)
+    elsif (colt_matrix.is_a? DenseLongMatrix3D)
+      mdarray = MDArray.from_jstorage("long", 
+                                      [colt_matrix.slices, colt_matrix.rows, 
+                                       colt_matrix.columns], colt_matrix.elements)
+      return LongMDMatrix3D.from_mdarray(mdarray)
+    elsif (colt_matrix.is_a? DenseIntMatrix3D)
+      mdarray = MDArray.from_jstorage("int", 
+                                      [colt_matrix.slices, colt_matrix.rows, 
+                                       colt_matrix.columns], colt_matrix.elements)
+      return IntMDMatrix3D.from_mdarray(mdarray)
+    elsif (colt_matrix.is_a? DenseDoubleMatrix2D)
+      mdarray = MDArray.from_jstorage("double", [colt_matrix.rows, colt_matrix.columns], 
+                                      colt_matrix.elements)
+      return DoubleMDMatrix2D.from_mdarray(mdarray)
+    elsif (colt_matrix.is_a? DenseFloatMatrix2D)
+      mdarray = MDArray.from_jstorage("float", [colt_matrix.rows, colt_matrix.columns], 
+                                      colt_matrix.elements)
+      return FloatMDMatrix2D.from_mdarray(mdarray)
+    elsif (colt_matrix.is_a? DenseLongMatrix2D)
+      mdarray = MDArray.from_jstorage("long", [colt_matrix.rows, colt_matrix.columns], 
+                                      colt_matrix.elements)
+      return LongMDMatrix2D.from_mdarray(mdarray)
+    elsif (colt_matrix.is_a? DenseIntMatrix2D)
+      mdarray = MDArray.from_jstorage("int", [colt_matrix.rows, colt_matrix.columns], 
+                                      colt_matrix.elements)
+      return IntMDMatrix2D.from_mdarray(mdarray)
+    elsif (colt_matrix.is_a? DenseDoubleMatrix1D)
+      mdarray = MDArray.from_jstorage("double", [colt_matrix.size], colt_matrix.elements)
+      return DoubleMDMatrix1D.from_mdarray(mdarray)
+    elsif (colt_matrix.is_a? DenseFloatMatrix1D)
+      mdarray = MDArray.from_jstorage("float", [colt_matrix.size], colt_matrix.elements)
+      return FloatMDMatrix1D.from_mdarray(mdarray)
+    elsif (colt_matrix.is_a? DenseLongMatrix1D)
+      mdarray = MDArray.from_jstorage("long", [colt_matrix.size], colt_matrix.elements)
+      return LongMDMatrix1D.from_mdarray(mdarray)
+    elsif (colt_matrix.is_a? DenseIntMatrix1D)
+      mdarray = MDArray.from_jstorage("int", [colt_matrix.size], colt_matrix.elements)
+      return IntMDMatrix1D.from_mdarray(mdarray)
+    end
+
+  end
+
+  #------------------------------------------------------------------------------------
+  # 
+  #------------------------------------------------------------------------------------
+
+  def normalize!
+    @colt_matrix.normalize
+  end
+
+  #------------------------------------------------------------------------------------
+  # 
+  #------------------------------------------------------------------------------------
+  
+  def sum
+    @colt_matrix.zSum
+  end
+
+  #------------------------------------------------------------------------------------
+  # 
+  #------------------------------------------------------------------------------------
+
+  def print
+
+    case mdarray.type
+
+    when "double"
+      formatter = DoubleFormatter.new
+    when "float"
+      formatter = FloatFormatter.new
+    when "long"
+      formatter = LongFormatter.new
+    when "int"
+      formatter = IntFormatter.new
+
+    end
+
+    printf(formatter.toString(@colt_matrix))
+
+  end
+
+  #------------------------------------------------------------------------------------
+  # 
+  #------------------------------------------------------------------------------------
+
+  private
+
+  #------------------------------------------------------------------------------------
+  # 
+  #------------------------------------------------------------------------------------
+
+  def self.dense1D(mdarray)
+
+    storage = mdarray.nc_array.getStorage()
+    index = mdarray.nc_array.getIndex()
+    size = index.size
+
+    klass = index.getClass
+    field = klass.getDeclaredField("stride0")
+    field.setAccessible true
+    stride0 = field.get(index)
+    # p stride0
+
+    klass = klass.getSuperclass()
+    field = klass.getDeclaredField("offset")
+    field.setAccessible true
+    offset = field.get(index)
+    # p offset
+
+    case mdarray.type
+    when "double"
+      colt_matrix = DenseDoubleMatrix1D.new(size, storage, offset, stride0, false)
+      DoubleMDMatrix1D.new(mdarray, colt_matrix)
+    when "float"
+      colt_matrix = DenseFloatMatrix1D.new(size, storage, offset, stride0, false)
+      FloatMDMatrix1D.new(mdarray, colt_matrix)
+    when "long"
+      colt_matrix = DenseLongMatrix1D.new(size, storage, offset, stride0, false)
+      LongMDMatrix1D.new(mdarray, colt_matrix)
+    when "int"
+      colt_matrix = DenseIntMatrix1D.new(size, storage, offset, stride0, false)
+      IntMDMatrix1D.new(mdarray, colt_matrix)
+    end
+
+  end
+
+  #------------------------------------------------------------------------------------
+  # 
+  #------------------------------------------------------------------------------------
+
+  def self.dense2D(mdarray)
+
+    storage = mdarray.nc_array.getStorage()
+    index = mdarray.nc_array.getIndex()
+    shape = index.getShape()
+
+    klass = index.getClass
+    field = klass.getDeclaredField("stride0")
+    field.setAccessible true
+    stride0 = field.get(index)
+    # p stride0
+
+    field = klass.getDeclaredField("stride1")
+    field.setAccessible true
+    stride1 = field.get(index)
+    # p stride1
+
+    klass = klass.getSuperclass()
+    field = klass.getDeclaredField("offset")
+    field.setAccessible true
+    offset = field.get(index)
+    # p offset
+
+    case mdarray.type
+    when "double"
+      colt_matrix = DenseDoubleMatrix2D.new(shape[0], shape[1], storage, offset, 0, 
+                                            stride0, stride1, false)
+      DoubleMDMatrix2D.new(mdarray, colt_matrix)
+    when "float"
+      colt_matrix = DenseFloatMatrix2D.new(shape[0], shape[1], storage, offset, 0, 
+                                           stride0, stride1, false)
+      FloatMDMatrix2D.new(mdarray, colt_matrix)
+    when "long"
+      colt_matrix = DenseLongMatrix2D.new(shape[0], shape[1], storage, offset, 0, 
+                                          stride0, stride1, false)
+      LongMDMatrix2D.new(mdarray, colt_matrix)
+    when "int"
+      colt_matrix = DenseIntMatrix2D.new(shape[0], shape[1], storage, offset, 0, 
+                                         stride0, stride1, false)
+      IntMDMatrix2D.new(mdarray, colt_matrix)
+    end
+
+  end
+
+  #------------------------------------------------------------------------------------
+  # 
+  #------------------------------------------------------------------------------------
+
+  def self.dense3D(mdarray)
+
+    storage = mdarray.nc_array.getStorage()
+    index = mdarray.nc_array.getIndex()
+    shape = index.getShape()
+
+    klass = index.getClass
+    field = klass.getDeclaredField("stride0")
+    field.setAccessible true
+    stride0 = field.get(index)
+    # p stride0
+
+    field = klass.getDeclaredField("stride1")
+    field.setAccessible true
+    stride1 = field.get(index)
+    # p stride1
+
+    field = klass.getDeclaredField("stride2")
+    field.setAccessible true
+    stride2 = field.get(index)
+    # p stride2
+
+    klass = klass.getSuperclass()
+    field = klass.getDeclaredField("offset")
+    field.setAccessible true
+    offset = field.get(index)
+    # p offset
+
+    case mdarray.type
+    when "double"
+      colt_matrix = DenseDoubleMatrix3D.new(shape[0], shape[1], shape[2], storage, 
+                                            offset, 0, 0, stride0, stride1, stride2, false)
+      DoubleMDMatrix3D.new(mdarray, colt_matrix)
+    when "float"
+      colt_matrix = DenseFloatMatrix3D.new(shape[0], shape[1], shape[2], storage, 
+                                           offset, 0, 0, stride0, stride1, stride2, false)
+      FloatMDMatrix3D.new(mdarray, colt_matrix)
+    when "long"
+      colt_matrix = DenseLongMatrix3D.new(shape[0], shape[1], shape[2], storage, 
+                                          offset, 0, 0, stride0, stride1, stride2, false)
+      LongMDMatrix3D.new(mdarray, colt_matrix)
+    when "int"
+      colt_matrix = DenseIntMatrix3D.new(shape[0], shape[1], shape[2], storage, 
+                                         offset, 0, 0, stride0, stride1, stride2, false)
+      IntMDMatrix3D.new(mdarray, colt_matrix)
+    end
+
+  end
+
+end # MDMatrix
+
+require_relative 'matrix_hierarchy'
+require_relative 'matrix2D_floating_algebra'