mdarray 0.5.4-java → 0.5.5-java

data/test/colt/test_complete.rb

@@ -22,4 +22,4 @@
 require_relative 'test_statistics'
 require_relative 'test_stat_list'
 require_relative 'test_math'
-require_relative 'test_matrix'
+require_relative 'matrix/test_complete'

data/test/complete.rb

@@ -21,14 +21,19 @@
 
 require 'env.rb'
 
-require 'mdarray/test_complete'
-require 'colt/test_complete'
-require 'netcdf/test_complete'
+ require 'mdarray/test_complete'
+ require 'colt/test_complete'
+ require 'netcdf/test_complete'
 
 
 # Temporary tests.  Remove before shipping!
 
-# require 'colt/test_matrix'
-# require 'netcdf/test_netcdf'
-# require 'mdarray/test_sections'
-# require 'netcdf/netcdfwriter'
+# require 'colt/matrix/test_complete'
+
+# require 'colt/matrix/test_matrix2d_floatingalgebra'
+# require 'colt/matrix/test_matrix2d_fixpointalgebra'
+
+# require 'colt/matrix/test_matrix1d_floatingalgebra'
+# require 'colt/matrix/test_matrix1d_fixpointalgebra'
+
+# require 'colt/matrix/test_properties'

data/test/mdarray/test_views.rb

@@ -179,6 +179,61 @@ class MDArrayTest < Test::Unit::TestCase
 
     end
     
+    #-------------------------------------------------------------------------------------
+    # Regions and sections are the same functionality with a different interface
+    #-------------------------------------------------------------------------------------
+  
+    should "get array regions" do
+
+      # 1 -> first year (only 1 year)
+      # 20 -> 20 days
+      # 10 -> number os secs
+      # 7 - > number of values
+      
+      # b is a section of @a, starting at position (0) and taking only the first two 
+      # elements of the first dimension.  Getting all values, for all secs for the first
+      # 2 days
+      # b = @a.section([0, 0, 0, 0], [1, 2, 10, 7])
+      b = @a.region(:spec => "0:0, 0:1, 0:9, 0:6")
+      assert_equal(true, b.section?)
+      assert_equal([1, 2, 10, 7], b.shape)
+      ind = b.get_index
+      ind.each do |elmt|
+        assert_equal(@a.get(elmt), b.get(elmt))
+      end
+
+
+      # getting "open" for the first 2 days of the 2nd sec.  Values are organized
+      # as follows:
+      # (open, close, high, low, volume, e1, e2).
+      # Start at: [0, 0, 3, 0] => 
+      #   0 -> first year, 0 -> first day, 3 -> 2nd sec, 0 -> first value 
+      # Specification: [1, 2, 1, 1] =>
+      #   1 -> get only first year, 2 -> take 2 days from day 0 to day 1, 
+      #   1 -> take one security, already selected the 2nd one, 1 -> only one value
+      #   in this case the first one was selected.
+      # b = @a.section([0, 0, 3, 0], [1, 2, 1, 1])
+      b = @a.region(:spec => "0:0, 0:1, 3:3, 0:0")
+      assert_equal(40.00, b[0, 0, 0, 0])
+      assert_equal(41.00, b[0, 1, 0, 0])
+
+
+      # getting "close" (2nd) value of the 3rd sec for the second day with 
+      # shape reduction. Note that in this case, with shape reduction, b is a 
+      # number and not an array any more
+      # b = @a.section([0, 1, 2, 1], [1, 1, 1, 1], true)
+      b = @a.region(:origin => [0, 1, 2, 1], :shape => [1, 1, 1, 1], :reduce => true)
+      assert_equal(@a[0, 1, 2, 1], b)
+
+      # getting the "close" (2nd) value of the 3rd sec for the second day without
+      # shape reduction
+      # b = @a.section([0, 1, 2, 1], [1, 1, 1, 1])
+      b = @a.region(:origin => [0, 1, 2, 1], :size => [1, 1, 1, 1], :stride => [1, 1, 1, 1])
+      assert_equal([1, 1, 1, 1], b.shape)
+      assert_equal(@a[0, 1, 2, 1], b[0, 0, 0, 0])
+
+    end
+
     #-------------------------------------------------------------------------------------
     # each_along_axes returns sub-arrays (sections) of the original array. Each section
     # is taken by walking along the given axis and getting all elements of the

data/version.rb

@@ -1,2 +1,2 @@
 $gem_name = "mdarray"
-$version="0.5.4"
+$version="0.5.5"

metadata

@@ -2,14 +2,14 @@
 name: mdarray
 version: !ruby/object:Gem::Version
   prerelease:
-  version: 0.5.4
+  version: 0.5.5
 platform: java
 authors:
 - Rodrigo Botafogo
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2013-08-07 00:00:00.000000000 Z
+date: 2013-11-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: map
@@ -42,7 +42,7 @@ dependencies:
         version: '0'
     none: false
   prerelease: false
-  type: :runtime
+  type: :development
 - !ruby/object:Gem::Dependency
   name: simplecov
   version_requirements: !ruby/object:Gem::Requirement
@@ -94,10 +94,11 @@ dependencies:
 description: "\"MDArray is a multi dimensional array implemented for JRuby inspired\
   \ by NumPy (www.numpy.org) and \nMasahiro Tanaka´s Narray (narray.rubyforge.org).\
   \  MDArray stands on the shoulders of Java-NetCDF \nand Parallel Colt.  At this\
-  \ point MDArray has libraries for mathematical, trigonometric and \ndescriptive\
-  \ statistics methods.\n\nNetCDF-Java Library is a Java interface to NetCDF files,\
-  \ as well as to many other types of \nscientific data formats.  It is developed\
-  \ and distributed by Unidata (http://www.unidata.ucar.edu). \n\nParallel Colt (http://grepcode.com/snapshot/repo1.maven.org/maven2/net.sourceforge.parallelcolt/\n\
+  \ point MDArray has libraries for linear algebra, mathematical, \ntrigonometric\
+  \ and descriptive statistics methods.\n\nNetCDF-Java Library is a Java interface\
+  \ to NetCDF files, as well as to many other types of \nscientific data formats.\
+  \  It is developed and distributed by Unidata (http://www.unidata.ucar.edu). \n\n\
+  Parallel Colt (http://grepcode.com/snapshot/repo1.maven.org/maven2/net.sourceforge.parallelcolt/\n\
   parallelcolt/0.10.0/) is a multithreaded version of Colt (http://acs.lbl.gov/software/colt/).\
   \  \nColt provides a set of Open Source Libraries for High Performance Scientific\
   \ and Technical \nComputing in Java. Scientific and technical computing is characterized\
@@ -122,9 +123,11 @@ files:
 - lib/colt/double_descriptive.rb
 - lib/colt/probability.rb
 - lib/colt/stat_list.rb
+- lib/colt/matrix/algebra.rb
 - lib/colt/matrix/colt_matrix.rb
-- lib/colt/matrix/matrix2D_floating_algebra.rb
-- lib/colt/matrix/matrix_hierarchy.rb
+- lib/colt/matrix/creation.rb
+- lib/colt/matrix/hierarchy.rb
+- lib/colt/matrix/property.rb
 - lib/mdarray/access.rb
 - lib/mdarray/counter.rb
 - lib/mdarray/creation.rb
@@ -158,12 +161,16 @@ files:
 - test/complete.rb
 - test/env.rb
 - test/colt/test_complete.rb
-- test/colt/test_double_matrix2d.rb
-- test/colt/test_float_matrix2d.rb
 - test/colt/test_math.rb
-- test/colt/test_matrix.rb
 - test/colt/test_statistics.rb
 - test/colt/test_stat_list.rb
+- test/colt/matrix/test_complete.rb
+- test/colt/matrix/test_matrix1d_floatingalgebra.rb
+- test/colt/matrix/test_matrix2d_fixpointalgebra.rb
+- test/colt/matrix/test_matrix2d_floatingalgebra.rb
+- test/colt/matrix/test_operations.rb
+- test/colt/matrix/test_properties.rb
+- test/colt/matrix/test_creation.rb
 - test/mdarray/arithmetic_casting.rb
 - test/mdarray/test_access.rb
 - test/mdarray/test_boolean.rb
@@ -255,16 +262,15 @@ files:
 - doc/MDArray/IteratorFastInt.html
 - doc/MDArray/IteratorFastLong.html
 - doc/MDArray/IteratorFastShort.html
-- vendor/commons-compiler.jar
-- vendor/incanter.jar
-- vendor/janino.jar
 - vendor/netcdfAll-4.3.18.jar
+- vendor/mdarray.jar
 - target/helper.jar
 - README.md
 - LICENSE.txt
 - LICENSE.txt~
 homepage: http://github.com/rbotafogo/mdarray/wiki
-licenses: []
+licenses:
+- BSD 2-clause
 post_install_message:
 rdoc_options: []
 require_paths:

data/lib/colt/matrix/matrix2D_floating_algebra.rb

@@ -1,325 +0,0 @@
-# -*- 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 'jruby/core_ext'
-
-require 'java'
-
-##########################################################################################
-#
-##########################################################################################
-
-module Matrix2DFloatingAlgebra
-  include_package "cern.colt.matrix.tdouble.algo"
-  include_package "cern.colt.matrix.tfloat.algo"
-
-  #------------------------------------------------------------------------------------
-  # Solves the upper triangular system U*x=b;
-  #------------------------------------------------------------------------------------
-
-  def backward_solve(matrix1D)
-    result = @algebra.backwardSolve(@colt_matrix, matrix1D.colt_matrix)
-    MDMatrix.from_colt_matrix(result)
-  end
-
-  #------------------------------------------------------------------------------------
-  # Constructs and returns the cholesky-decomposition of the given matrix. For a 
-  # symmetric, positive definite matrix A, the Cholesky decomposition is a lower 
-  # triangular matrix L so that A = L*L'; If the matrix is not symmetric positive 
-  # definite, the IllegalArgumentException is thrown.
-  #------------------------------------------------------------------------------------
-
-  def chol
-    result = @algebra.chol(@colt_matrix).getL()
-    MDMatrix.from_colt_matrix(result)
-  end
-
-  #------------------------------------------------------------------------------------
-  # Returns the condition of matrix A, which is the ratio of largest to smallest 
-  # singular value.
-  #------------------------------------------------------------------------------------
-
-  def cond
-    @algebra.cond(@colt_matrix)
-  end
-
-  #------------------------------------------------------------------------------------
-  # Returns the determinant of matrix A.
-  #------------------------------------------------------------------------------------
-
-  def det
-    @algebra.det(@colt_matrix)
-  end
-
-  #------------------------------------------------------------------------------------
-  #
-  #------------------------------------------------------------------------------------
-
-  def eig
-    eig = @algebra.eig(@colt_matrix)
-    [MDMatrix.from_colt_matrix(eig.getD), 
-     MDMatrix.from_colt_matrix(eig.getImagEigenvalues),
-     MDMatrix.from_colt_matrix(eig.getRealEigenvalues),
-     MDMatrix.from_colt_matrix(eig.getV)]
-  end
-
-  #------------------------------------------------------------------------------------
-  # Solves the lower triangular system L*x=b;
-  #------------------------------------------------------------------------------------
-
-  def forward_solve(matrix1D)
-    result = @algebra.forwardSolve(@colt_matrix, matrix1D.colt_matrix)
-    MDMatrix.from_colt_matrix(result)
-  end
-
-  #------------------------------------------------------------------------------------
-  # Returns the inverse or pseudo-inverse of matrix A.
-  #------------------------------------------------------------------------------------
-
-  def inverse
-    result = @algebra.inverse(@colt_matrix)
-    MDMatrix.from_colt_matrix(result)
-  end
-
-  #------------------------------------------------------------------------------------
-  # Computes the Kronecker product of two real matrices.
-  #------------------------------------------------------------------------------------
-
-  def kron(matrix)
-
-    if (matrix.rank != 2)
-      raise "Rank should be 2"
-    end
-    result = @algebra.kron(@colt_matrix, matrix.colt_matrix)
-    MDMatrix.from_colt_matrix(result)
-
-  end
-
-  #------------------------------------------------------------------------------------
-  # Constructs and returns the LU-decomposition of the given matrix.
-  #------------------------------------------------------------------------------------
-
-  def lu
-    result = @algebra.lu(@colt_matrix)
-    [result.isNonsingular(), result.det(), result.getPivot.to_a(),
-     MDMatrix.from_colt_matrix(result.getL()),
-     MDMatrix.from_colt_matrix(result.getU())]
-  end
-
-  #------------------------------------------------------------------------------------
-  # Multiplies this matrix by another matrix
-  #------------------------------------------------------------------------------------
-
-  def mult(matrix)
-
-    if (matrix.rank > 2)
-      raise "Rank should be 1 or 2"
-    end
-
-    result = @colt_matrix.like
-    @colt_matrix.zMult(matrix.colt_matrix, result)
-    MDMatrix.from_colt_matrix(result)
-
-  end
-
-  alias :* :mult
-
-  #------------------------------------------------------------------------------------
-  # Returns the one-norm of vector x, which is Sum(abs(x[i])).
-  #------------------------------------------------------------------------------------
-
-  def norm1
-    @algebra.norm1(@colt_matrix)
-  end
-
-  #------------------------------------------------------------------------------------
-  # Returns the two-norm of matrix A, which is the maximum singular value; obtained 
-  # from SVD.
-  #------------------------------------------------------------------------------------
-
-  def norm2
-    @algebra.norm2(@colt_matrix)
-  end
-
-  #------------------------------------------------------------------------------------
-  # Returns the Frobenius norm of matrix A, which is Sqrt(Sum(A[i,j]^2))
-  #------------------------------------------------------------------------------------
-
-  def normF
-    @algebra.normF(@colt_matrix)
-  end
-
-  #------------------------------------------------------------------------------------
-  # Returns the infinity norm of matrix A, which is the maximum absolute row sum.
-  #------------------------------------------------------------------------------------
-
-  def norm_infinity
-    @algebra.normInfinity(@colt_matrix)
-  end
-
-  #------------------------------------------------------------------------------------
-  # Linear algebraic matrix power; B = A^k <==> B = A*A*...
-  #------------------------------------------------------------------------------------
-
-  def power(val)
-    result = @algebra.pow(@colt_matrix, val)
-    MDMatrix.from_colt_matrix(result)
-  end
-
-  alias :** :power
-
-  #------------------------------------------------------------------------------------
-  # Returns the effective numerical rank of matrix A, obtained from Singular Value 
-  # Decomposition.
-  #------------------------------------------------------------------------------------
-
-  def numerical_rank
-    @algebra.rank(@colt_matrix)
-  end
-
-  #------------------------------------------------------------------------------------
-  # Solves A*X = B
-  #------------------------------------------------------------------------------------
-  
-  def solve(matrix)
-    result = @algebra.solve(@colt_matrix, matrix.colt_matrix)
-    MDMatris.from_colt_matrix(resul)
-  end
-
-  #------------------------------------------------------------------------------------
-  # Solves X*A = B, which is also A'*X' = B'.
-  #------------------------------------------------------------------------------------
-
-  def solve_transpose(matrix)
-    result = @algebra.solveTranspose(@colt_matrix, matrix.colt_matrix)
-    MDMatris.from_colt_matrix(resul)
-  end
-
-  #------------------------------------------------------------------------------------
-  # Constructs and returns the SingularValue-decomposition of the given matrix.
-  #------------------------------------------------------------------------------------
-
-  def svd
-    result = @algebra.svd(@colt_matrix)
-    [result.getInfo().val, result.cond(), result.norm2(), result.rank(), 
-     result.getSingularValues().to_a(),
-     MDMatrix.from_colt_matrix(result.getS()),
-     MDMatrix.from_colt_matrix(result.getU()),
-     MDMatrix.from_colt_matrix(result.getV())]
-  end
-
-  #------------------------------------------------------------------------------------
-  # Returns the sum of the diagonal elements of matrix A; Sum(A[i,i]).
-  #------------------------------------------------------------------------------------
-
-  def trace
-    @algebra.trace(@colt_matrix)
-  end
-
-  #------------------------------------------------------------------------------------
-  # Modifies the matrix to be a lower trapezoidal matrix.
-  #------------------------------------------------------------------------------------
-
-  def trapezoidal_lower
-    result = @algebra.trapezoidalLower(@colt_matrix)
-    MDMatrix.from_colt_matrix(result)
-  end
-
-  #------------------------------------------------------------------------------------
-  # Returns the two-norm (aka euclidean norm) of vector X.vectorize();
-  #------------------------------------------------------------------------------------
-
-  def vector_norm2
-    @algebra.vectorNorm2(@colt_matrix)
-  end
-
-end # 
-
-##########################################################################################
-#
-##########################################################################################
-
-module Matrix2DDoubleAlgebra
-  include_package "cern.colt.matrix.tdouble.algo"
-
-  #------------------------------------------------------------------------------------
-  # Constructs and returns the QR-decomposition of the given matrix.
-  #------------------------------------------------------------------------------------
-
-  def qr(economy_size = true)
-    result = @algebra.qr(@colt_matrix)
-    [result.hasFullRank(), MDMatrix.from_colt_matrix(result.getQ(economy_size)),
-     MDMatrix.from_colt_matrix(result.getR(economy_size))]
-  end
-  
-end
-
-##########################################################################################
-#
-##########################################################################################
-
-module Matrix2DFloatAlgebra
-  include_package "cern.colt.matrix.tfloat.algo"
-
-  #------------------------------------------------------------------------------------
-  # Constructs and returns the QR-decomposition of the given matrix.
-  #------------------------------------------------------------------------------------
-
-  def qr
-    result = @algebra.qr(@colt_matrix)
-    [result.hasFullRank(), 
-     MDMatrix.from_colt_matrix(result.getH()),
-     MDMatrix.from_colt_matrix(result.getQ()),
-     MDMatrix.from_colt_matrix(result.getR())]
-  end
-  
-end
-
-##########################################################################################
-#
-##########################################################################################
-
-class FloatingMDMatrix2D
-
-  include Matrix2DFloatingAlgebra
-
-end # MDMatrix
-
-##########################################################################################
-#
-##########################################################################################
-
-class DoubleMDMatrix2D
-
-  include Matrix2DDoubleAlgebra
-
-end
-
-##########################################################################################
-#
-##########################################################################################
-
-class FloatMDMatrix2D
-
-  include Matrix2DFloatAlgebra
-
-end