nmatrix 0.0.9 → 0.1.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3c50cbab8bbd44023c4e72abd2592b3412e47710
-  data.tar.gz: b5dafe0a32a6547e2b723b36f463c5eed8840293
+  metadata.gz: fbe2c20e1a86c29f525cda90fd74b6e916b8e406
+  data.tar.gz: 0f50913f5df2579d6d7acb8986f5c5321bdf3bec
 SHA512:
-  metadata.gz: 1adaef4aaf34a6c24e3c3e815fc18305a174f781ec648b12942b54bc2ba40314558b4e900e6128af2fe13a921d4255e25dca2af278603a1e9b8c9d270c681061
-  data.tar.gz: ac48bdf4e1f3ff45386a02dc43a0ab2f379e39541f7eb60b6f304d7706d1829b15c8d282ead396a47d9644a6984dc64d8549534c8e1ceb150c9e422566643e42
+  metadata.gz: 0aa8a2a396a4c88b0ed73a7674d95ccafd63fe8394cad06319531e0465a12628851dfb796454c6c41b52d102d5688b413f114b4b3a8560de566ea69089da32e7
+  data.tar.gz: 44ec7c62e47ccd107e584500124019a0847ab67a8f88495d376416e491745d7f8550f0aba10d9f5dea6bc90ecd3e8adc23eba5a28fea42b05c22d061a1e103a2

data/Gemfile

@@ -7,5 +7,6 @@ gem 'packable', ">= 1.3.5"  # for Matlab IO
 group :development do
   gem 'pry'
   gem 'rspec-longrun'
+  #gem 'narray', :path => "../narray"
   #gem 'pry-debugger'
 end

data/History.txt

@@ -426,4 +426,98 @@
   * nil values in matrices are now pretty printed as "nil"
 
   * Casting from dense to Yale now properly accepts the default
-     value option
+    value option
+
+=== 0.1.0.rc1 / 2014-12-28
+
+* 4 major enhancements:
+
+  * Improved garbage collection strategy for partial object creation
+    (i.e., when VALUEs are allocated but not registered right away),
+    which in addition to fixing numerous bugs should prevent some new
+    bugs from arising in the future (by @cjfuller)
+
+  * Implemented list storage transpose
+
+  * Implemented generic n-dimensional transpose
+
+  * Implemented == comparison between differing matrix stypes
+
+* 9 minor enhancements:
+
+  * User-friendly #gesvd and #gesdd updates (by @ryanmt)
+
+  * Added experimental #yale_row_key_intersection function for expert
+    recommendation problems
+
+  * Added additional *indgen shortcuts and changed behavior for some;
+    now, #cindgen for :complex64, #zindgen for :complex128, #findgen
+    for :float32, #dindgen for :float64, #rindgen for :rational128,
+    and #rbindgen for Ruby objects (which contain integers); also,
+    removed code repetition
+
+  * Changed #stddev to use elementwise #sqrt instead of a manual map
+    block (by @cjfuller)
+
+  * Added alias from MATLAB `load_mat` method to `load` for
+    consistency with the MatrixMarket loader
+
+  * Improved organization by moving list and yale code into storage/
+    subdirectories
+
+  * Added NMatrix#potrf! and NMatrix#getrf, which are instance methods
+    for calling CLAPACK functions (NMatrix#getrf! already existed)
+
+  * Added GCC installation instructions for Mac OS X Mavericks, and
+    updated the old installation instructions for Mac OS X (both
+    found in scripts/)
+
+  * Switched NMatrix::VERSION to work more like Rails::VERSION, with
+    support for MAJOR, MINOR, TINY, and PRE
+
+  * Added #concat, #hconcat, #vconcat, and #dconcat for joining
+    matrices together
+
+* 16 bug fixes:
+
+  * Spec revisions for lapack_gesdd and lapack_gesvd (by @ryanmt)
+
+  * Fixed two double-free problems (by @cjfuller and @mohawkjohn)
+
+  * Fixed contiguous array marking fencepost error
+
+  * Fixed C/C++ API compatibility problem preventing rb/gsl linking
+
+  * Resolved a number of compiler warnings, including one return-type
+    problem that would likely have become a garbage collection error
+    (if it wasn't already)
+
+  * Fixed -O3 optimization problems
+
+  * Restored NMatrix#asum, #nrm2, #binned_sorted_indices,
+    #sorted_indices which were inadvertantly removed by NVector
+    deprecation; have not tested
+
+  * Experimental #yale_nd_row and functions which call it now checks
+    range of argument to prevent segfault
+
+  * Fixed :* shortcut for a full list dimension (by @cjfuller)
+
+  * Fixed list construction problem which occurred when an initial
+    value array was provided (by @cjfuller)
+
+  * Fixed #inject issue with list and yale matrices of two dimensions
+    (by @cjfuller)
+
+  * Fixed several garbage collection problems (also listed under
+    enhancements) (by @cjfuller)
+
+  * Updated object cleaning target in extconf.rb
+
+  * Fixed possible compilation problem on Mavericks with Xcode 5.02
+
+  * Fixed errors involving undefined symbols, unresolved symbols, and
+    lazy symbol binding
+
+  * Improved LAPACK and BLAS header selection for Ubuntu/Debian
+    systems with ATLAS (by @mvz)

data/LICENSE.txt

@@ -1,4 +1,4 @@
-This version of SciRuby is licensed under the BSD 2-clause license.
+This version of NMatrix is licensed under the BSD 2-clause license.
 
 * http://sciruby.com
 * http://github.com/sciruby/sciruby/wiki/License
@@ -9,7 +9,7 @@ You *must* read the Contributor Agreement before contributing code to the SciRub
 
 -----
 
-Copyright (c) 2010 - 2013, Ruby Science Foundation
+Copyright (c) 2010 - 2014, 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:

data/README.rdoc

@@ -7,6 +7,8 @@ Fast Numerical Linear Algebra Library for Ruby
 * {NMatrix Installation wiki}[https://github.com/SciRuby/nmatrix/wiki/Installation]
 * {SciRuby Installation guide}[http://sciruby.com/docs#installation]
 
+{<img src=https://travis-ci.org/SciRuby/nmatrix.png>}[https://travis-ci.org/SciRuby/nmatrix]
+
 == Description
 
 NMatrix is a fast numerical linear algebra library for Ruby, with dense and sparse matrices, written mostly in C and
@@ -24,8 +26,7 @@ However, you will need to install {ATLAS}[http://math-atlas.sourceforge.net/] wi
 {BLAS}[http://en.wikipedia.org/wiki/Basic_Linear_Algebra_Subprograms]) first. Detailed directions can be found
 {here}[https://github.com/SciRuby/nmatrix/wiki/Installation]. The requirements for NMatrix are:
 
-* ATLAS
-* LAPACK, probably ({see here for details}[https://github.com/SciRuby/nmatrix/wiki/Installation])
+* ATLAS, preferably with CLAPACK ({see here for details}[https://github.com/SciRuby/nmatrix/wiki/Installation])
 * a version of GCC or clang which supports C++0x or C++11
 * Ruby 1.9.3+
 * {packable}[http://github.com/marcandre/packable] 1.3.5 (used for I/O)
@@ -37,9 +38,11 @@ If you want to obtain the latest (development) code, you should generally do:
     bundle install
     bundle exec rake compile
     bundle exec rake repackage
-    gem install pkg/nmatrix-0.1.0.gem
+    gem install pkg/nmatrix-0.1.0-rc1.gem
 
 Detailed instructions are available for {Mac}[https://github.com/SciRuby/nmatrix/wiki/Installation#mac-os-x] and {Linux}[https://github.com/SciRuby/nmatrix/wiki/Installation#linux].
+We are currently working on Mavericks (Mac OS X) installation instructions, but in general, you'll need Homebrew and should
+probably use +brew install gcc48+ instead of using the install script.
 
 == Documentation
 
@@ -52,21 +55,27 @@ You can find the complete API documentation {on our website}[http://sciruby.com/
 
 == Examples
 
-Create a new NMatrix from a ruby array: 
+Create a new NMatrix from a ruby Array: 
 
     >> require 'nmatrix'
-    >> NMatrix.new([2, 3], [0, 1, 2, 3, 4, 5], dtype: :int64).pp
-      [0, 1, 2]
-      [3, 4, 5]
-    => nil
+    >> NMatrix.new([2, 3], [0, 1, 2, 3, 4, 5], dtype: :int64)
+    => [
+        [0, 1, 2],
+        [3, 4, 5]
+       ]
 
 Create a new NMatrix using the +N+ shortcut:
 
     >> m = N[ [2, 3, 4], [7, 8, 9] ]
+    => [
+        [2, 3, 4],
+        [7, 8, 9]
+       ]
+    >> m.inspect
     => #<NMatrix:0x007f8e121b6cf8shape:[2,3] dtype:int32 stype:dense>
-    >> m.pp
-       [2, 3, 4]
-       [7, 8, 9]
+
+The above output requires that you have a pretty-print-enabled console such as Pry; otherwise, you'll
+see the output given by +inspect+.
 
 If you want to learn more about how to create a
 matrix, {read the guide in our wiki}[https://github.com/SciRuby/nmatrix/wiki/How-to-create-a-NMatrix].
@@ -79,7 +88,7 @@ Read the instructions in +CONTRIBUTING.md+ if you want to help NMatrix.
 
 == Features
 
-The following features exist in the current version of NMatrix (0.0.8):
+The following features exist in the current version of NMatrix (0.1.0.rc1):
 
 * Matrix and vector storage containers: dense, yale, list (more to come)
 * Data types: byte (uint8), int8, int16, int32, int64, float32, float64, complex64, complex128, rational64, rational128,
@@ -114,6 +123,8 @@ The following features exist in the current version of NMatrix (0.0.8):
 * Determinant calculation for BLAS dtypes
 * Vector 2-norms
 * Ruby/GSL interoperability (requires {SciRuby's fork of rb-gsl}(http://github.com/SciRuby/rb-gsl))
+* slice assignments, e.g.,
+    x[1..3,0..4] = some_other_matrix
 
 === Planned Features (Short-to-Medium Term)
 
@@ -121,29 +132,16 @@ We are nearly the release of NMatrix 0.1.0, our first beta.
 
 These are features planned for NMatrix 0.2.0:
 
-* slice assignments, e.g.,
-    x[1..3,0..4] = some_other_matrix
 * LAPACK-free calculation of determinant, trace, and eigenvalues (characteristic polynomial)
 * LAPACK-free matrix inversions
 * tensor products
-* principal component analysis (PCA)
 * improved file I/O
   * compression of yale symmetries in I/O
 * optimization of non-BLAS data types on BLAS-like operations (e.g., matrix multiplication for rational numbers)
 
-=== Warning
-
-Please be aware that SciRuby and NMatrix are *alpha* status. If you're thinking of using SciRuby/NMatrix to write
-mission-critical code, such as for driving a car or flying a space shuttle, you may wish to choose other software for
-now.
-
-You should also be aware that NMatrix and NArray are incompatible with one another; you should not try to require both
-at the same time. Unfortunately, that causes problems with Ruby/GSL, which currently depends upon NArray. As such, we
-have a {fork of Ruby/GSL}[https://github.com/SciRuby/rb-gsl].
-
 == License
 
-Copyright (c) 2010--13, The Ruby Science Foundation.
+Copyright (c) 2012--14, John Woods and the Ruby Science Foundation.
 
 All rights reserved.
 

data/Rakefile

@@ -41,18 +41,26 @@ BASEDIR = Pathname( __FILE__ ).dirname.relative_path_from( Pathname.pwd )
 SPECDIR = BASEDIR + 'spec'
 
 VALGRIND_OPTIONS = [
-        "--tool=memcheck",
-        #"--leak-check=yes",
-        "--num-callers=15",
-        #"--error-limit=no",
-        "--partial-loads-ok=yes",
-        "--undef-value-errors=no" #,
-        #"--dsymutil=yes"
+    "--tool=memcheck",
+    #"--leak-check=yes",
+    "--num-callers=15",
+    #"--error-limit=no",
+    "--partial-loads-ok=yes",
+    "--undef-value-errors=no" #,
+    #"--dsymutil=yes"
 ]
+
+CALLGRIND_OPTIONS = [
+    "--tool=callgrind",
+    "--dump-instr=yes",
+    "--simulate-cache=yes",
+    "--collect-jumps=yes"
+]
+
 VALGRIND_MEMORYFILL_OPTIONS = [
-        "--freelist-vol=100000000",
-        "--malloc-fill=6D",
-        "--free-fill=66 ",
+    "--freelist-vol=100000000",
+    "--malloc-fill=6D",
+    "--free-fill=66 ",
 ]
 
 GDB_OPTIONS = []
@@ -125,17 +133,25 @@ namespace :spec do
   desc "Run specs under cgdb."
   task :cgdb => [ :compile ] do |task|
     cmd = [ 'cgdb' ] + GDB_OPTIONS
-          cmd += [ '--args' ]
-          cmd += RSPEC_CMD
-          run( *cmd )
+    cmd += [ '--args' ]
+    cmd += RSPEC_CMD
+    run( *cmd )
   end
 
   desc "Run specs under Valgrind."
   task :valgrind => [ :compile ] do |task|
-          cmd = [ 'valgrind' ] + VALGRIND_OPTIONS
-          cmd += RSPEC_CMD
-          run( *cmd )
+    cmd = [ 'valgrind' ] + VALGRIND_OPTIONS
+    cmd += RSPEC_CMD
+    run( *cmd )
+  end
+
+  desc "Run specs under Callgrind."
+  task :callgrind => [ :compile ] do |task|
+    cmd = [ 'valgrind' ] + CALLGRIND_OPTIONS
+    cmd += RSPEC_CMD
+    run( *cmd )
   end
+
 end
 
 

data/ext/nmatrix/data/complex.h

@@ -9,8 +9,8 @@
 //
 // == Copyright Information
 //
-// SciRuby is Copyright (c) 2010 - 2013, Ruby Science Foundation
-// NMatrix is Copyright (c) 2013, Ruby Science Foundation
+// SciRuby is Copyright (c) 2010 - 2014, Ruby Science Foundation
+// NMatrix is Copyright (c) 2012 - 2014, John Woods and the Ruby Science Foundation
 //
 // Please see LICENSE.txt for additional copyright notices.
 //

data/ext/nmatrix/data/data.cpp

@@ -9,8 +9,8 @@
 //
 // == Copyright Information
 //
-// SciRuby is Copyright (c) 2010 - 2013, Ruby Science Foundation
-// NMatrix is Copyright (c) 2013, Ruby Science Foundation
+// SciRuby is Copyright (c) 2010 - 2014, Ruby Science Foundation
+// NMatrix is Copyright (c) 2012 - 2014, John Woods and the Ruby Science Foundation
 //
 // Please see LICENSE.txt for additional copyright notices.
 //
@@ -73,50 +73,24 @@ namespace nm {
     "geq"
   };
 
+  const std::string NONCOM_EWOP_NAMES[nm::NUM_NONCOM_EWOPS] = {
+    "atan2",
+    "ldexp",
+    "hypot"
+  };
 
-  template <typename Type>
-  Complex<Type>::Complex(const RubyObject& other) {
-    switch(TYPE(other.rval)) {
-    case T_COMPLEX:
-      r = NUM2DBL(rb_funcall(other.rval, rb_intern("real"), 0));
-      i = NUM2DBL(rb_funcall(other.rval, rb_intern("imag"), 0));
-      break;
-    case T_FLOAT:
-    case T_RATIONAL:
-    case T_FIXNUM:
-    case T_BIGNUM:
-      r = NUM2DBL(other.rval);
-      i = 0.0;
-      break;
-    default:
-      rb_raise(rb_eTypeError, "not sure how to convert this type of VALUE to a complex");
-    }
-  }
-
-
-  template <typename Type>
-  Rational<Type>::Rational(const RubyObject& other) {
-    switch (TYPE(other.rval)) {
-    case T_RATIONAL:
-      n = NUM2LONG(rb_funcall(other.rval, rb_intern("numerator"), 0));
-      d = NUM2LONG(rb_funcall(other.rval, rb_intern("denominator"), 0));
-      break;
-    case T_FIXNUM:
-    case T_BIGNUM:
-      n = NUM2LONG(other.rval);
-      d = 1;
-      break;
-    case T_COMPLEX:
-    case T_FLOAT:
-      rb_raise(rb_eTypeError, "cannot convert float to a rational");
-      break;
-    default:
-      rb_raise(rb_eTypeError, "not sure how to convert this type of VALUE to a rational");
-    }
-  }
-
+  const std::string UNARYOPS[nm::NUM_UNARYOPS] = {
+    "sin", "cos", "tan",
+    "asin", "acos", "atan",
+    "sinh", "cosh", "tanh",
+    "asinh", "acosh", "atanh",
+    "exp", "log2", 
+    "log10", "sqrt", "erf", 
+    "erfc", "cbrt", "gamma"
+  };
 
 } // end of namespace nm
+
 extern "C" {
 
 const char* const DTYPE_NAMES[nm::NUM_DTYPES] = {
@@ -301,21 +275,23 @@ nm::RubyObject rubyobj_from_cval(void* val, nm::dtype_t dtype) {
  */
 void* rubyobj_to_cval(VALUE val, nm::dtype_t dtype) {
   size_t size =  DTYPE_SIZES[dtype];
-  void* ret_val = ALLOC_N(char, size);
+  NM_CONSERVATIVE(nm_register_value(val));
+  void* ret_val = NM_ALLOC_N(char, size);
 
   rubyval_to_cval(val, dtype, ret_val);
-
+  NM_CONSERVATIVE(nm_unregister_value(val));
   return ret_val;
 }
 
 
 void nm_init_data() {
-    nm::RubyObject obj(INT2FIX(1));
-    nm::Rational32 x(obj);
-    nm::Rational64 y(obj);
-    nm::Rational128 z(obj);
-    nm::Complex64 a(obj);
-    nm::Complex128 b(obj);
+  volatile VALUE t = INT2FIX(1);
+  volatile nm::RubyObject obj(t);
+  volatile nm::Rational32 x(const_cast<nm::RubyObject&>(obj));
+  volatile nm::Rational64 y(const_cast<nm::RubyObject&>(obj));
+  volatile nm::Rational128 z(const_cast<nm::RubyObject&>(obj));
+  volatile nm::Complex64 a(const_cast<nm::RubyObject&>(obj));
+  volatile nm::Complex128 b(const_cast<nm::RubyObject&>(obj));
 }
 
 

data/ext/nmatrix/data/data.h

@@ -9,8 +9,8 @@
 //
 // == Copyright Information
 //
-// SciRuby is Copyright (c) 2010 - 2013, Ruby Science Foundation
-// NMatrix is Copyright (c) 2013, Ruby Science Foundation
+// SciRuby is Copyright (c) 2010 - 2014, Ruby Science Foundation
+// NMatrix is Copyright (c) 2012 - 2014, John Woods and the Ruby Science Foundation
 //
 // Please see LICENSE.txt for additional copyright notices.
 //
@@ -55,7 +55,8 @@ namespace nm {
 	const int NUM_DTYPES = 13;
 	const int NUM_ITYPES = 4;
 	const int NUM_EWOPS = 12;
-	const int NUM_NONCOMP_EWOPS = 6;
+	const int NUM_UNARYOPS = 21;
+	const int NUM_NONCOM_EWOPS = 3;
 
   enum ewop_t {
     EW_ADD,
@@ -69,12 +70,85 @@ namespace nm {
     EW_LT,
     EW_GT,
     EW_LEQ,
-    EW_GEQ
+    EW_GEQ,
+  };
+
+  enum noncom_ewop_t {
+    NONCOM_EW_ATAN2,
+    NONCOM_EW_LDEXP,
+    NONCOM_EW_HYPOT
+  };
+
+  enum unaryop_t {
+    UNARY_SIN,
+    UNARY_COS,
+    UNARY_TAN,
+    UNARY_ASIN,
+    UNARY_ACOS,
+    UNARY_ATAN,
+    UNARY_SINH,
+    UNARY_COSH,
+    UNARY_TANH,
+    UNARY_ASINH,
+    UNARY_ACOSH,
+    UNARY_ATANH,
+    UNARY_EXP,
+    UNARY_LOG2,
+    UNARY_LOG10,
+    UNARY_SQRT,
+    UNARY_ERF,
+    UNARY_ERFC,
+    UNARY_CBRT,
+    UNARY_GAMMA
   };
 
   // element-wise and scalar operators
   extern const char* const  EWOP_OPS[nm::NUM_EWOPS];
   extern const std::string  EWOP_NAMES[nm::NUM_EWOPS];
+  extern const std::string  UNARYOPS[nm::NUM_UNARYOPS];
+  extern const std::string  NONCOM_EWOP_NAMES[nm::NUM_NONCOM_EWOPS];
+
+
+  template <typename Type>
+  Complex<Type>::Complex(const RubyObject& other) {
+    switch(TYPE(other.rval)) {
+    case T_COMPLEX:
+      r = NUM2DBL(rb_funcall(other.rval, rb_intern("real"), 0));
+      i = NUM2DBL(rb_funcall(other.rval, rb_intern("imag"), 0));
+      break;
+    case T_FLOAT:
+    case T_RATIONAL:
+    case T_FIXNUM:
+    case T_BIGNUM:
+      r = NUM2DBL(other.rval);
+      i = 0.0;
+      break;
+    default:
+      rb_raise(rb_eTypeError, "not sure how to convert this type of VALUE to a complex");
+    }
+  }
+
+
+  template <typename Type>
+  Rational<Type>::Rational(const RubyObject& other) {
+    switch (TYPE(other.rval)) {
+    case T_RATIONAL:
+      n = NUM2LONG(rb_funcall(other.rval, rb_intern("numerator"), 0));
+      d = NUM2LONG(rb_funcall(other.rval, rb_intern("denominator"), 0));
+      break;
+    case T_FIXNUM:
+    case T_BIGNUM:
+      n = NUM2LONG(other.rval);
+      d = 1;
+      break;
+    case T_COMPLEX:
+    case T_FLOAT:
+      rb_raise(rb_eTypeError, "cannot convert float to a rational");
+      break;
+    default:
+      rb_raise(rb_eTypeError, "not sure how to convert this type of VALUE to a rational");
+    }
+  }
 
 
 } // end of namespace nm
@@ -90,6 +164,20 @@ namespace nm {
     nm_yale_storage_mark												\
   };
 
+#define STYPE_REGISTER_TABLE(name)              \
+  static void (*(name)[nm::NUM_STYPES])(const STORAGE*) = { \
+    nm_dense_storage_register,                  \
+    nm_list_storage_register,                   \
+    nm_yale_storage_register                    \
+  };
+
+#define STYPE_UNREGISTER_TABLE(name)              \
+  static void (*(name)[nm::NUM_STYPES])(const STORAGE*) = { \
+    nm_dense_storage_unregister,                \
+    nm_list_storage_unregister,                 \
+    nm_yale_storage_unregister                  \
+  };
+
 #define CAST_TABLE(name)                                                   \
   static STORAGE* (*(name)[nm::NUM_STYPES][nm::NUM_STYPES])(const STORAGE*, nm::dtype_t, void*) = {      \
     { nm_dense_storage_cast_copy,  nm_dense_storage_from_list,  nm_dense_storage_from_yale },  \