mdarray-sol 0.1.0-java

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 85ee125673b2dafbeecb843794c40f11ce9e63ed
+  data.tar.gz: 5ce8f5b6aed244c78585cfbfd2f39275c54a7bb0
+SHA512:
+  metadata.gz: ec0ec33f60f03a8437616a7e488db354546e2de9fc5486f4d66bd190a0056eddcf7ca714ad40281e7166a2fca3fce4c7138b07bba64b94d1b087ed1c6be6852c
+  data.tar.gz: b0b37d08fbb71472b56800f111506145e4da74312c643ea68670ef43801585716171728d88af9e7030b545cfbc394164cb2cdb200b0afee700e039aa2115f506

data/LICENSE.txt

@@ -0,0 +1,35 @@
+# -*- coding: utf-8 -*-
+
+##########################################################################################
+This version of MDArray-sol is licensed under the BSD 2-clause license. MDArray-sol uses
+JxBrowser http://www.teamdev.com/jxbrowser, which is a proprietary software. The use of
+JxBrowser is governed by JxBrowser Product Licence Agreement
+http://www.teamdev.com/jxbrowser-licence-agreement. If you would like to use JxBrowser
+in your development, please contact TeamDev.
+##########################################################################################
+
+-----
+
+Copyright (c) 2016, Rodrigo Botafogo
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted 
+provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this list of conditions 
+and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice, this list of 
+conditions and the following disclaimer in the documentation and/or other materials provided 
+with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY 
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL 
+THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT 
+OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+##########################################################################################

data/LICENSE.txt~

@@ -0,0 +1,73 @@
+# -*- coding: utf-8 -*-
+
+##########################################################################################
+#
+# Copyright 1998-2008 University Corporation for Atmospheric Research/Unidata
+# 
+# Portions of this software were developed by the Unidata Program at the 
+# University Corporation for Atmospheric Research.
+# 
+# Access and use of this software shall impose the following obligations
+# and understandings on the user. The user is granted the right, without
+# any fee or cost, to use, copy, modify, alter, enhance and distribute
+# this software, and any derivative works thereof, and its supporting
+# documentation for any purpose whatsoever, provided that this entire
+# notice appears in all copies of the software, derivative works and
+# supporting documentation.  Further, UCAR requests that the user credit
+# UCAR/Unidata in any publications that result from the use of this
+# software or in any product that includes this software. The names UCAR
+# and/or Unidata, however, may not be used in any advertising or publicity
+# to endorse or promote any products or commercial entity unless specific
+# written permission is obtained from UCAR/Unidata. The user also
+# understands that UCAR/Unidata is not obligated to provide the user with
+# any support, consulting, training or assistance of any kind with regard
+# to the use, operation and performance of this software nor to provide
+# the user with any updates, revisions, new versions or "bug fixes."
+# 
+# THIS SOFTWARE IS PROVIDED BY UCAR/UNIDATA "AS IS" AND ANY EXPRESS OR
+# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL UCAR/UNIDATA BE LIABLE FOR ANY SPECIAL,
+# INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING
+# FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+# NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+# WITH THE ACCESS, USE OR PERFORMANCE OF THIS SOFTWARE.
+##########################################################################################
+
+
+##########################################################################################
+This version of MDArray is licensed under the BSD 2-clause license.
+
+* http://sciruby.com
+* http://github.com/sciruby/sciruby/wiki/License
+
+You *must* read the Contributor Agreement before contributing code to the SciRuby Project. 
+This is available online:
+
+* http://github.com/sciruby/sciruby/wiki/Contributor-Agreement
+
+-----
+
+Copyright (c) 2010 - 2013, Rodrigo Botafogo and Ruby Science Foundation
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted 
+provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this list of conditions 
+and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice, this list of 
+conditions and the following disclaimer in the documentation and/or other materials provided 
+with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY 
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL 
+THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT 
+OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+##########################################################################################

data/README.md

@@ -0,0 +1,140 @@
+Announcement
+============
+
+MDArray-sol version 0.1.0 has ben release.  MDArray-sol, Sol for short, is a front-end
+platform for desktop application development based on the proprietary (yet free for
+open source) jxBrowser - https://www.teamdev.com/jxbrowser, a Chromium-based browser.
+
+In a sense, Sol is similar to Opal in that it allows Ruby developers to code for the
+browser; however, differently from Opal, Sol does not compile its code to javascript,
+it implements a DSL that interfaces with javascript through jxBrowser java interface,
+more in line with what is provided by the javascript node-webkit, now called NW.js.
+To the Ruby developer, no javascript is ever required.  Also, since there is no
+compilation there is no need to 'send' data from Ruby to Javascript.  Data in Ruby,
+for instance, in a Ruby array or hash, is made available directly to the browser. 
+
+This is an initial version that focus on the integration of Ruby with the D3.js library.
+In order to test this integration we have implemented many of the examples of the
+excellent and highly recommended book by Scott Murray, "Interactive Data Visualization
+for the Web".  As can be seen in the examples directory and on the MDArray-sol wiki at
+https://github.com/rbotafogo/mdarray-sol/wiki, quite complex behaviour is already
+possible in this version.
+
+This version was tested on Cygwin, Windows and Linux64.  It has not yet been tested on
+Linux32 nor Mac.  
+
+Bellow is an example of the integration of D3.js with Ruby that plots the US States map:
+    
+
+    require 'json'
+    require 'mdarray-sol'
+
+    class Map
+
+      attr_reader :path
+      attr_reader :svg
+      attr_reader :us_states
+    
+      #------------------------------------------------------------------------------------
+      # @param width [Number]: width of the chart
+      # @param height [Number]: height of the chart
+      #------------------------------------------------------------------------------------
+
+      def initialize(width, height)
+      
+        @width = width
+        @height = height
+
+        # Create svg for the map
+        @svg = $d3.select("body")
+                  .append("svg")
+                  .attr("width", @width)
+                  .attr("height", @height)
+    
+      end
+  
+      #------------------------------------------------------------------------------------
+      # Parses a file in GeoJson format and saves it as @us_states
+      # @param filename [String] the name of the file to parse
+      #------------------------------------------------------------------------------------
+
+      def json(filename)
+        
+        dir = File.expand_path(File.dirname(__FILE__))
+        file_name = dir + "/#{filename}"
+        file = File.read(file_name)
+    
+        # parse the json file
+        @us_states = JSON.parse(file)
+
+      end
+  
+      #------------------------------------------------------------------------------------
+      #
+      #------------------------------------------------------------------------------------
+
+      def plot(projection)
+    
+        proj = projection
+                 .translate([@width/2, @height/2])
+                 .scale(500)
+		 
+        @path = $d3.geo.path[].projection(proj);    
+        
+        @svg.selectAll("path")
+            .data(@us_states["features"])
+            .enter[]
+            .append("path")
+            .attr("d", @path)
+            .style("fill", "steelblue")
+        
+      end
+      
+    end
+
+    map = Map.new(500, 500)
+    map.json("us-states.json")
+    map.plot($d3.geo.albersUsa[])
+
+
+![US States Map](https://github.com/rbotafogo/mdarray-sol/blob/master/images/Map.JPG)
+
+
+LICENSE
+=======
+
+MDArray-sol is distributed with the BSD 2-clause license; however, MDArray-sol uses JxBrowser
+http://www.teamdev.com/jxbrowser, which is a proprietary software. The use of JxBrowser
+is governed by JxBrowser Product Licence Agreement
+http://www.teamdev.com/jxbrowser-licence-agreement. If you would like to use JxBrowser
+in your development, please contact TeamDev.
+
+
+MDArray-sol main properties are:
+============================
+
+  + Integration of Ruby and Javascript transparantly to the Ruby developer
+  + Data sharing between Ruby and Javascript
+  + Embedded browser
+
+MDArray-sol installation and download:
+==================================
+
+  + Install Jruby
+  + jruby –S gem install mdarray-sol
+
+MDArray-sol Homepages:
+==================
+
+  + http://rubygems.org/gems/mdarray-sol
+  + https://github.com/rbotafogo/mdarray-sol/wiki
+
+Contributors:
+=============
+Contributors are welcome.
+
+
+MDArray-sol History:
+================
+
+  + 2017/01/06: Initial release

data/README.md~

@@ -0,0 +1,290 @@
+Announcement
+============
+
+MDArray version 0.5.5 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 linear algebra, mathematical, trigonometric and descriptive statistics methods.
+
+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).
+ 
+Parallel Colt (https://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.
+
+
+What´s new:
+===========
+
+Class MDMatrix and Linear Algebra Methods
+-----------------------------------------
+
+This version of MDArray introduces class MDMatrix.  MDMatrix is a matrix class wrapping many 
+linear algebra methods from Parallel Colt (see below).  MDMatrix support only the following 
+types: i) int; ii) long; iii) float and iv) double.
+
+Differently from other libraries, in which matrix is a subclass of array, MDMatrix is a 
+twin class of MDArray.  MDMatrix is a twin class of MDArray as every time an MDMatrix is 
+instantiated, an MDArray class is also instantiated.  In reality, there is only one backing 
+store that can be viewed by either MDMatrix or MDArray. 
+ 
+Creation of MDMatrix follows the same API as MDArray API.  For instance, creating a double 
+square matrix of size 5 x 5 can be done by:
+ 
+    matrix = MDMatrix.double([5, 5], [2.0, 0.0, 8.0, 6.0, 0.0,\
+                                      1.0, 6.0, 0.0, 1.0, 7.0,\
+                                      5.0, 0.0, 7.0, 4.0, 0.0,\
+                                      7.0, 0.0, 8.0, 5.0, 0.0,\
+                                      0.0, 10.0, 0.0, 0.0, 7.0])
+
+Creating an int matrix filled with zero can be done by:
+
+    matrix = MDMatrix.int([4, 3])
+
+MDMatrix also supports creation based on methods such as fromfunction, linspace, init_with, 
+arange, typed_arange and ones:
+
+
+    array = MDArray.typed_arange("double", 0, 15)
+    array = MDMatrix.fromfunction("double", [4, 4]) { |x, y| x + y }
+
+An MDMatrix can also be created from an MDArray as follows:
+
+    d2 = MDArray.typed_arange("double", 0, 15)
+    double_matrix = MDMatrix.from_mdarray(d2)
+
+An MDMatrix can only be created from MDArrays of one, two or three dimensions.  However, 
+one can take a view from an MDArray to create an MDMatrix, as long as the view is at most 
+three dimensional:
+
+    # Instantiate an MDArray and shape it with 4 dimensions
+    > d1 = MDArray.typed_arange("double", 0, 420)
+    > d1.reshape!([5, 4, 3, 7])
+    # slice the array, getting a three dimensional array and from that, make a matrix
+    > matrix = MDMatrix.from_mdarray(d1.slice(0, 0))
+    # get a region from the array, with the first two dimensions of size 0, reduce it to a
+    # size two array and then build a two dimensional matrix
+    > matrix = MDMatrix.from_mdarray(d1.region(:spec => "0:0, 0:0, 0:2, 0:6").reduce)
+
+printing the above two dimensional matrix gives us:
+
+    > matrix.print
+    3 x 7 matrix
+    0,00000 1,00000 2,00000 3,00000 4,00000 5,00000 6,00000
+    7,00000 8,00000 9,00000 10,0000 11,0000 12,0000 13,0000
+    14,0000 15,0000 16,0000 17,0000 18,0000 19,0000 20,0000
+
+Every MDMatrix instance has a twin MDArray instance that uses the same backing store.  This 
+allows the user to treat the data as either a matrix or an array and use methods either from 
+matrix or array.  The above matrix can be printed as an array:
+
+
+    > matrix.mdarray.print
+    [[0.00 1.00 2.00 3.00 4.00 5.00 6.00]
+     [7.00 8.00 9.00 10.00 11.00 12.00 13.00]
+     [14.00 15.00 16.00 17.00 18.00 19.00 20.00]]
+
+With an MDMatrix, many linear algebra methods can be easily calculated:
+
+    # basic operations on matrix can be done, such as, ‘+’, ‘-‘, ´*’, ‘/’
+    # make a 4 x 4 matrix and fill it with ´double´ 2.5
+    > a = MDMatrix.double([4, 4])
+    > a.fill(2.5)
+    > make a 4 x 4 matrix ´b´ from a given function (block)
+    > b = MDMatrix.fromfunction("double", [4, 4]) { |x, y| x + y }
+    # add both matrices
+    > c = a + b
+    # multiply by scalar
+    > c = a * 2
+    # divide two matrices.  Matrix ´b´ has to be non-singular, otherwise an exception is
+    # raised.
+    # generate a non-singular matrix from a given matrix
+    > b.generate_non_singular!
+    > c = a / b
+
+Linear algebra methods:
+
+    # create a matrix with the given data
+    > pos = MDArray.double([3, 3], [4, 12, -16, 12, 37, -43, -16, -43, 98])
+    > matrix = MDMatrix.from_mdarray(pos)
+    # Cholesky decomposition from wikipedia example
+    > chol = matrix.chol
+    > assert_equal(2, chol[0, 0])
+    > assert_equal(6, chol[1, 0])
+    > assert_equal(-8, chol[2, 0])
+    > assert_equal(5, chol[2, 1])
+    > assert_equal(3, chol[2, 2])
+
+All other linear algebra methods are called the same way.
+
+
+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.”
+
+MDArray main properties are:
+============================
+
+ + Homogeneous multidimensional array, a table of elements (usually numbers), all of the 
+     same type, indexed by a tuple of positive integers;
+ + Support for many linear algebra methods (see bellow);
+ + 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).
+
+Supported linear algebra methods:
+=================================
+
+  + backwardSolve:  Solves the upper triangular system U*x=b;
+  + chol: Constructs and returns the cholesky-decomposition of the given matrix.
+  + cond: Returns the condition of matrix A, which is the ratio of largest to smallest singular value.
+  + det: Returns the determinant of matrix A.
+  + eig: Constructs and returns the Eigenvalue-decomposition of the given matrix.
+  + forwardSolve:  Solves the lower triangular system L*x=b;
+  + inverse: Returns the inverse or pseudo-inverse of matrix A.
+  + kron: Computes the Kronecker product of two real matrices.
+  + lu: Constructs and returns the LU-decomposition of the given matrix.
+  + mult: Inner product of two vectors; Sum(x[i] * y[i]).
+  + mult: Linear algebraic matrix-vector multiplication; z = A * y.
+  + mult: Linear algebraic matrix-matrix multiplication; C = A x B.
+  + multOuter: Outer product of two vectors; Sets A[i,j] = x[i] * y[j].
+  + norm1: Returns the one-norm of vector x, which is Sum(abs(x[i])).
+  + norm1: Returns the one-norm of matrix A, which is the maximum absolute column sum.
+  + norm2: Returns the two-norm (aka euclidean norm) of vector x; equivalent to Sqrt(mult(x,x)).
+  + norm2: Returns the two-norm of matrix A, which is the maximum singular value; obtained from SVD.
+  + normF: Returns the Frobenius norm of matrix A, which is Sqrt(Sum(A[i]2)).
+  + normF: Returns the Frobenius norm of matrix A, which is Sqrt(Sum(A[i,j]2)).
+  + normInfinity: Returns the infinity norm of vector x, which is Max(abs(x[i])).
+  + normInfinity: Returns the infinity norm of matrix A, which is the maximum absolute row sum.
+  + pow: Linear algebraic matrix power; B = Ak <==> B = A*A*...*A.
+  + qr: Constructs and returns the QR-decomposition of the given matrix.
+  + rank: Returns the effective numerical rank of matrix A, obtained from Singular Value Decomposition.
+  + solve: Solves A*x = b.
+  + solve: Solves A*X = B.
+  + solveTranspose: Solves X*A = B, which is also A'*X' = B'.
+  + svd: Constructs and returns the SingularValue-decomposition of the given matrix.
+  + trace: Returns the sum of the diagonal elements of matrix A; Sum(A[i,i]).
+  + trapezoidalLower: Modifies the matrix to be a lower trapezoidal matrix.
+  + vectorNorm2: Returns the two-norm (aka euclidean norm) of vector X.vectorize();
+  + xmultOuter: Outer product of two vectors; Returns a matrix with A[i,j] = x[i] * y[j].
+  + xpowSlow: Linear algebraic matrix power; B = Ak <==> B = A*A*...*A.
+
+Properties´ methods tested on matrices:
+=======================================
+
+  + density: Returns the matrix's fraction of non-zero cells; A.cardinality() / A.size().
+  + generate_non_singular!: Modifies the given square matrix A such that it is diagonally dominant by row and column, hence non-singular, hence invertible.
+  + diagonal?: A matrix A is diagonal if A[i,j] == 0 whenever i != j.
+  + diagonally_dominant_by_column?: A matrix A is diagonally dominant by column if the absolute value of each diagonal element is larger than the sum of the absolute values of the off-diagonal elements in the corresponding column.
+  + diagonally_dominant_by_row?: A matrix A is diagonally dominant by row if the absolute value of each diagonal element is larger than the sum of the absolute values of the off-diagonal elements in the corresponding row.
+  + identity?: A matrix A is an identity matrix if A[i,i] == 1 and all other cells are zero.
+  + lower_bidiagonal?: A matrix A is lower bidiagonal if A[i,j]==0 unless i==j || i==j+1.
+  + lower_triangular?: A matrix A is lower triangular if A[i,j]==0 whenever i < j.
+  + nonnegative?: A matrix A is non-negative if A[i,j] >= 0 holds for all cells.
+  + orthogonal?: A square matrix A is orthogonal if A*transpose(A) = I.
+  + positive?: A matrix A is positive if A[i,j] > 0 holds for all cells.
+  + singular?: A matrix A is singular if it has no inverse, that is, iff det(A)==0.
+  + skew_symmetric?: A square matrix A is skew-symmetric if A = -transpose(A), that is A[i,j] == -A[j,i].
+  + square?: A matrix A is square if it has the same number of rows and columns.
+  + strictly_lower_triangular?: A matrix A is strictly lower triangular if A[i,j]==0 whenever i <= j.
+  + strictly_triangular?: A matrix A is strictly triangular if it is triangular and its diagonal elements all equal 0.
+  + strictly_upper_triangular?: A matrix A is strictly upper triangular if A[i,j]==0 whenever i >= j.
+  + symmetric?: A matrix A is symmetric if A = tranpose(A), that is A[i,j] == A[j,i].
+  + triangular?: A matrix A is triangular iff it is either upper or lower triangular.
+  + tridiagonal?: A matrix A is tridiagonal if A[i,j]==0 whenever Math.abs(i-j) > 1.
+  + unit_triangular?: A matrix A is unit triangular if it is triangular and its diagonal elements all equal 1.
+  + upper_bidiagonal?: A matrix A is upper bidiagonal if A[i,j]==0 unless i==j || i==j-1.
+  + upper_triangular?: A matrix A is upper triangular if A[i,j]==0 whenever i > j.
+  + zero?: A matrix A is zero if all its cells are zero.
+  + lower_bandwidth: The lower bandwidth of a square matrix A is the maximum i-j for which A[i,j] is nonzero and i > j.
+  + semi_bandwidth: Returns the semi-bandwidth of the given square matrix A.
+  + upper_bandwidth: The upper bandwidth of a square matrix A is the maximum j-i for which A[i,j] is nonzero and j > i.
+
+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.
+
+Double and Float methods from Parallel Colt:
+============================================
+
+  + 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:
+================
+
+  + 14/11/2013: Version 0.5.5 - Support for linear algebra methods
+  + 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.
+