nmatrix 0.0.4 → 0.0.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 80c122ef6be8531eccdf14ff07426f8302660a14
+  data.tar.gz: 74335afd35279bcb817691e94c3017883ae3fed5
+SHA512:
+  metadata.gz: 2d1573ca2c204fb33897870fc350779db8800c0ce41b263c3ae0628647ebd85e31ff5080e7a02bdf76f043a184274c5d197384d6322827250583d68c743d0ca6
+  data.tar.gz: 07446f0f43a91fed625330975a6f9d443b9b497ddc694bd6d7b54cb5e54da191a98444fb8d4c6097d594862e57e76c24d84133daac84eda68688699428920c7d

data/History.txt

@@ -78,7 +78,7 @@
   * Now requires packable-1.3.5 or higher, fixing a problem with MATLAB
     .mat v5 file I/O (specific to doubles)
 
-=== 0.0.4 / 2013-??-??
+=== 0.0.4 / 2013-05-17
 
 * 3 major enhancements
 
@@ -122,4 +122,70 @@
 
   * Fixed gem install command in Rakefile (by @jpmckinney)
 
-  * Fixed Spanish language compile issue (by @imcsk8 and @agarie)
+  * Fixed Spanish language compile issue (by @imcsk8 and @agarie)
+
+=== 0.0.5 / 2013-??-??
+
+* 4 major enhancements
+
+  * NVector orientation is now controlled by its shape, not by the
+    @orientation property
+
+  * NVector default orientation is now a row vector rather than a
+    column, as this is more efficient for Yale storage
+
+  * NVector objects may now be created with dtypes other than dense
+
+  * Exposure of additional ATLAS-implemented BLAS functions,
+    including native rational and Ruby object support, for xANUM (sum
+    of the absolute values of a vector) and xNRM2 (2-norm of a
+    vector); and Ruby helper functions BLAS::anum and BLAS::nrm2
+    which should do more careful argument sanity checking
+
+* 9 minor enhancements
+
+  * Added #yale_vector_insert to NMatrix::YaleFunctions, to speed up
+    insertion of multiple items into a Yale matrix
+
+  * Added #yale_nd_row, #yale_nd_row_as_hash, #yale_nd_row_as_array,
+    #yale_nd_row_as_set, #yale_nd_row_as_sorted_set, #yale_row,
+    #yale_row_as_hash, #yale_row_as_array, #yale_row_as_set,
+    #yale_row_as_sorted_set, #yale_nd_row_size to
+    NMatrix::YaleFunctions in order to speed up getting multiple
+    items from some row of a Yale matrix
+
+  * Improved #yale_ija, #yale_a, #yale_d by allowing an optional
+    index argument, which returns a single array value instead of
+    copying and returning the entire array
+
+  * Improved sorting algorithm for Yale matrix multiplication;
+    instead of selection sort, now uses quicksort; and subs in
+    insertion sort for small partitions
+
+  * Slicing a single row or column now returns an NVector instead
+    of an NMatrix (does not yet work for n-dimensional matrices)
+
+  * Improved function documentation for NVector and NMatrix
+
+  * Added #min, #max, #to_a, #shuffle, #shuffle!, #absolute_sum,
+    #norm2 functions to NVector
+
+  * Aliased missing dimension of NVector#each_stored_with_indices to
+    #each_stored_with_index, which only yields a value and i or j
+    (not both i and j) depending on the vector orientation
+
+  * Added #each_row, #each_column to NMatrix
+
+* 5 bug fixes:
+
+  * Dense iterators now return self (an NMatrix) in order to be
+    consistent with Ruby Array behavior (by @cjfuller)
+
+  * Fixed Yale resize problem (by @v0dro)
+
+  * Fixed Yale nx1 times 1xn multiplication problem
+
+  * Fixed Yale sorting-following-multiplication problem
+
+  * NMatrix::read() now raises an exception when asked to read a file 
+    that does not exist

data/Manifest.txt

@@ -30,6 +30,7 @@ lib/nmatrix/nmatrix.rb
 lib/nmatrix/nvector.rb
 lib/nmatrix/shortcuts.rb
 lib/nmatrix/version.rb
+lib/nmatrix/yale_functions.rb
 ext/nmatrix/data/complex.h
 ext/nmatrix/data/data.cpp
 ext/nmatrix/data/data.h

data/README.rdoc

@@ -52,10 +52,10 @@ Finally, try compiling again.
 
 == Documentation
 
-Carlos Agarie (@agarie) is currently working to improve the documentation. The best way to get help is by
-posting {issues}[https://github.com/SciRuby/nmatrix/issues] or sending e-mails to
-our {mailing list}[https://groups.google.com/forum/?fromgroups#!forum/sciruby-dev]. You may also email @agarie, or look
-for `agarie` on #sciruby at chat.freenode.net if you want to ask questions or offer suggestions.
+Carlos Agarie (@agarie) is currently working to improve the documentation. The best way to get help is by posting
+{issues}[https://github.com/SciRuby/nmatrix/issues] or sending e-mails to our
+{mailing list}[https://groups.google.com/forum/?fromgroups#!forum/sciruby-dev]. You may also email @agarie, or look for
+`agarie` on #sciruby at chat.freenode.net if you want to ask questions or offer suggestions.
 
 You can find the complete API documentation {on our website}[http://sciruby.com/nmatrix/docs/].
 
@@ -89,7 +89,7 @@ Read the instructions in +CONTRIBUTING.md+ if you want to help NMatrix.
 
 The following features exist in the current version of NMatrix (0.0.4):
 
-* Matrix storage containers: dense, yale, list (more to come)
+* Matrix and vector storage containers: dense, yale, list (more to come)
 * Data types: uint8, int8, int16, int32, int64, float32, float64, complex64, complex128, rational64, rational128
   (incomplete)
 * Conversion between storage and data types (except from-complex, and from-float-to-rational)
@@ -102,7 +102,7 @@ The following features exist in the current version of NMatrix (0.0.4):
 * Matlab .MAT v5 file input
 * C and C++ API
 * BLAS internal implementations (no library) and ATLAS (with library) access:
-  * Level 1: xROT, xROTG (BLAS dtypes only)
+  * Level 1: xROT, xROTG (BLAS dtypes only), xASUM, xNRM2
   * Level 2: xGEMV
   * Level 3: xGEMM, xTRSM
 * LAPACK ATLAS access:
@@ -116,6 +116,7 @@ The following features exist in the current version of NMatrix (0.0.4):
 * LU decomposition
 * Matrix inversions (requires LAPACK; BLAS dtypes only)
 * Determinant calculation for BLAS dtypes
+* Vector 2-norms
 * Ruby/GSL interoperability (requires [SciRuby's fork of rb-gsl](http://github.com/SciRuby/rb-gsl))
 
 === Planned Features (Short-to-Medium Term)
@@ -126,7 +127,7 @@ These are features planned for NMatrix 0.1.0, our first beta.
 * exponentials and square roots
 * matrix inversions (LAPACK-free)
 * matrix decomposition/factorization
-* calculation of norms
+* calculation of additional norms
 * tensor products
 * principal component analysis (PCA)
 * improved file I/O

data/Rakefile

@@ -40,8 +40,10 @@ BASEDIR = Pathname( __FILE__ ).dirname.relative_path_from( Pathname.pwd )
 SPECDIR = BASEDIR + 'spec'
 
 VALGRIND_OPTIONS = [
-        "--num-callers=50",
-        "--error-limit=no",
+        "--tool=memcheck",
+        "--leak-check=yes",
+        "--num-callers=15",
+        #"--error-limit=no",
         "--partial-loads-ok=yes",
         "--undef-value-errors=no" #,
         #"--dsymutil=yes"
@@ -128,6 +130,15 @@ namespace :spec do
 end
 
 
+LEAKCHECK_CMD = [ 'ruby', '-Ilib:ext', "#{SPECDIR}/leakcheck.rb" ]
+
+desc "Run leakcheck script."
+task :leakcheck => [ :compile ] do |task|
+  cmd = [ 'valgrind' ] + VALGRIND_OPTIONS
+  cmd += LEAKCHECK_CMD
+  run( *cmd )
+end
+
 namespace :clean do
   task :so do |task|
     tmp_path = "tmp/#{RUBY_PLATFORM}/nmatrix/#{RUBY_VERSION}"

data/ext/nmatrix/data/complex.h

@@ -34,6 +34,7 @@
 
 #include <type_traits>
 #include <iostream>
+#include <cmath>
 
 /*
  * Project Includes
@@ -363,10 +364,27 @@ inline std::ostream& operator<<(std::ostream& out, const Complex<Type>& rhs) {
 
 namespace std {
   template <typename FloatType, typename = typename std::enable_if<std::is_floating_point<FloatType>::value>::type>
-  nm::Complex<FloatType> abs(const nm::Complex<FloatType>& value) {
+  nm::Complex<FloatType> piecewise_abs(const nm::Complex<FloatType>& value) {
     return nm::Complex<FloatType>(value.r < 0 ? -value.r : value.r,
                                   value.i < 0 ? -value.i : value.i);
   }
+
+  template <typename FloatType, typename = typename std::enable_if<std::is_floating_point<FloatType>::value>::type>
+  nm::Complex<FloatType> real_abs(const nm::Complex<FloatType>& value) {
+    return nm::Complex<FloatType>(value.r < 0 ? -value.r : value.r,
+                                  value.i);
+  }
+
+  template <typename FloatType, typename = typename std::enable_if<std::is_floating_point<FloatType>::value>::type>
+  nm::Complex<FloatType> imag_abs(const nm::Complex<FloatType>& value) {
+    return nm::Complex<FloatType>(value.r,
+                                  value.i < 0 ? -value.i : value.i);
+  }
+
+  template <typename FloatType, typename = typename std::enable_if<std::is_floating_point<FloatType>::value>::type>
+  double abs(const nm::Complex<FloatType>& value) {
+    return std::sqrt(double(value.r)*double(value.r) + double(value.i)*double(value.i));
+  }
 }
 
 #endif // COMPLEX_H

data/ext/nmatrix/data/data.h

@@ -143,6 +143,14 @@ namespace nm {
 
 #define ITYPE_TEMPLATE_TABLE(fun, ret, ...) NAMED_ITYPE_TEMPLATE_TABLE(ttable, fun, ret, __VA_ARGS__)
 
+#define NAMED_LR_ITYPE_TEMPLATE_TABLE(name, fun, ret, ...) \
+  static ret (*(name)[nm::NUM_ITYPES][nm::NUM_ITYPES])(__VA_ARGS__) = { \
+    { fun<uint8_t,uint8_t>, fun<uint8_t, uint16_t>, fun<uint8_t, uint32_t>, fun<uint8_t, uint64_t> }, \
+    { fun<uint16_t,uint8_t>, fun<uint16_t, uint16_t>, fun<uint16_t, uint32_t>, fun<uint16_t, uint64_t> }, \
+    { fun<uint32_t,uint8_t>, fun<uint32_t, uint16_t>, fun<uint32_t, uint32_t>, fun<uint32_t, uint64_t> }, \
+    { fun<uint64_t,uint8_t>, fun<uint64_t, uint16_t>, fun<uint64_t, uint32_t>, fun<uint64_t, uint64_t> } \
+  };
+
 /*
  * Same as DTYPE_TEMPLATE_TABLE but for functions that have two template
  * parameters.

data/ext/nmatrix/data/ruby_object.h

@@ -440,6 +440,7 @@ namespace std {
     return obj.abs();
   }
 
+
   inline nm::RubyObject sqrt(const nm::RubyObject& obj) {
     VALUE cMath = rb_const_get(rb_cObject, rb_intern("Math"));
     return nm::RubyObject(rb_funcall(cMath, rb_intern("sqrt"), 1, obj.rval));

data/ext/nmatrix/extconf.rb

@@ -131,11 +131,11 @@ $srcs = [
 # (substituting in the path of your cblas.h and clapack.h for the path I used). -- JW 8/27/12
 
 
-unless have_library("lapack")
+unless have_library("lapack") # && have_header("clapack.h")
   dir_config("lapack", ["/usr/include/atlas"], ["/usr/local/lib", "/usr/local/atlas/lib"])
 end
 
-unless have_library("cblas")
+unless have_library("cblas") # && have_header("cblas.h")
   dir_config("cblas", ["/usr/local/atlas/include", "/usr/include/atlas"], ["/usr/local/lib", "/usr/local/atlas/lib"])
 end
 
@@ -198,8 +198,10 @@ else
 end
 
 # For release, these next two should both be changed to -O3.
-$CFLAGS += " -O0 -g "
-$CPPFLAGS += " -O0 -g -std=#{$CPP_STANDARD} " #-fmax-errors=10 -save-temps
+$CFLAGS += " -O3 " #" -O0 -g "
+# $CFLAGS += " -static -O0 -g "
+$CPPFLAGS += " -O3 -std=#{$CPP_STANDARD} " #" -O0 -g -std=#{$CPP_STANDARD} " #-fmax-errors=10 -save-temps
+# $CPPFLAGS += " -static -O0 -g -std=#{$CPP_STANDARD} "
 
 CONFIG['warnflags'].gsub!('-Wshorten-64-to-32', '') # doesn't work except in Mac-patched gcc (4.2)
 CONFIG['warnflags'].gsub!('-Wdeclaration-after-statement', '')

data/ext/nmatrix/nmatrix.cpp

@@ -544,6 +544,28 @@ void Init_nmatrix() {
 // Ruby Methods //
 //////////////////
 
+
+/*
+ * Slice constructor.
+ */
+static SLICE* alloc_slice(size_t dim) {
+  SLICE* slice = ALLOC(SLICE);
+  slice->coords = ALLOC_N(size_t, dim);
+  slice->lengths = ALLOC_N(size_t, dim);
+  return slice;
+}
+
+
+/*
+ * Slice destructor.
+ */
+static void free_slice(SLICE* slice) {
+  free(slice->coords);
+  free(slice->lengths);
+  free(slice);
+}
+
+
 /*
  * Allocator.
  */
@@ -596,6 +618,8 @@ static void nm_delete(NMATRIX* mat) {
     nm_yale_storage_delete
   };
   ttable[mat->stype](mat->storage);
+
+  free(mat);
 }
 
 /*
@@ -608,6 +632,8 @@ static void nm_delete_ref(NMATRIX* mat) {
     nm_yale_storage_delete
   };
   ttable[mat->stype](mat->storage);
+
+  free(mat);
 }
 
 /*
@@ -671,7 +697,7 @@ static VALUE nm_upcast(VALUE self, VALUE t1, VALUE t2) {
 
 /*
  * call-seq:
- *     each -> 
+ *     each -> Enumerator
  *
  * Iterate over the matrix as you would an Enumerable (e.g., Array).
  *
@@ -842,34 +868,51 @@ NMATRIX* nm_create(nm::stype_t stype, STORAGE* storage) {
  *
  * Create a new NMatrix.
  *
- * There are several ways to do this. At a minimum, dimensions and either a dtype or initial values are needed, e.g.,
+ * There are several ways to do this. In every case, the constructor needs to know the dtype, the dimensions, the stype,
+ * and either an initial capacity (:yale) or some number of initial values (:list needs exactly one initial value, but
+ * :dense can accept an array). In many cases, the parameters can be guessed from other parameters.
+ *
+ * Here is the full form for a :dense 3x4 :float64 matrix initialized to alternate the values 0.0, 1.0, and 2.0:
+ *
+ *     NMatrix.new(:dense, [3,4], [0.0, 1.0, 2.0], :float64)
  *
- *     NMatrix.new(3, :int64)       # square 3x3 dense matrix
- *     NMatrix.new([3,4], :float32) # 3x4 matrix
- *     NMatrix.new(3, 0)            # 3x3 dense matrix initialized to all zeros
- *     NMatrix.new([3,3], [1,2,3])  # [[1,2,3],[1,2,3],[1,2,3]]
+ * Since :dense is the default, we can actually leave that out. Additionally, the constructor will parse 0.0 and
+ * interpret that to be a :float64. So we can actually short-hand this as follows:
  *
- * NMatrix will try to guess the dtype from the first value in the initial values array.
+ *     NMatrix.new([3,4], [0.0,1,2])
  *
- * You can also provide the stype prior to the dimensions. However, non-dense matrices cannot take initial values, and
- * require a dtype (e.g., :int64):
+ * Note that :list and :yale matrices will not accept a default value array. For list storage, a single default value
+ * is permissible, which will be treated as the background for the sparse matrix and defaults to 0:
  *
- *     NMatrix.new(:yale, [4,3], :int64)
- *     NMatrix.new(:list, 5, :rational128)
+ *     NMatrix.new(:list, [3,4], 0)     # standard :int64 sparse matrix
+ *     NMatrix.new(:list, [2,3], 1.0)   # :float64 sparse matrix: [[1,1,1],[1,1,1]] (no storage used)
+ *     NMatrix.new(:list, [3,4], [0,1]) # undefined behavior, will probably fill matrix with 0. Avoid this.
  *
- * For Yale, you can also give an initial size for the non-diagonal component of the matrix:
+ * For Yale storage, the default value must always be 0. Thus, if you provide an initial value, it will be interpreted
+ * as the initial matrix capacity.
  *
- *     NMatrix.new(:yale, [4,3], 2, :int64)
+ *     NMatrix.new(:yale, [4,3], :rational128) # Use default initial capacity. Most common.
+ *     NMatrix.new(:yale, [3,4], 1000) # Error! Needs a dtype!
+ *     NMatrix.new(:yale, [3,4], 1000, :int64) # Silly! Why would a 3x4 sparse matrix need storage space of 1,000?
+ *     NMatrix.new(:yale, [3,4], 0.0, :float64) # Totally ignores non-sensical 3rd arg and creates 7 storage instead.
+ *     NMatrix.new(:yale, [3,4], 8, :rational128) # Initial capacity of 8 rationals.
  *
- * Finally, you can be extremely specific, and define a matrix very exactly:
+ * That leaves only two other notes. First of all, if your matrix is square, you don't need to type [3,3] for 3x3.
+ * Instead, just do 3:
  *
- *     NMatrix.new(:dense, [2,2,2], [0,1,2,3,4,5,6,7], :int8)
+ *     NMatrix.new(3, [0,1,2], :rational128)  # dense 3x3 rational matrix consisting of columns of 0s, 1s, and 2s
  *
- * There is one additional constructor for advanced users, which takes seven arguments and is only for creating Yale matrices
- * with known IA, JA, and A arrays. This is used primarily internally for IO, e.g., reading Matlab matrices, which are
- * stored in old Yale format.
+ * Secondly, if you create a dense matrix without initial values, you may see unpredictable results! It'll fill the
+ * matrix with whatever is already in memory, not with zeros.
  *
- * Just be careful! There are no overflow warnings in NMatrix.
+ *     NMatrix.new(:dense, 4, :int64)
+ *        # => [8, 140486578196280, 0, 0]  [0, 0, 0, 0]  [0, 0, 0, 140486608794928]  [140486577962496, -4294967280, 1, 140734734392208]
+ *
+ * There is one additional constructor for advanced users, which takes seven arguments and is only for creating Yale
+ * matrices with known IA, JA, and A arrays. This is used primarily internally for IO, e.g., reading Matlab matrices,
+ * which are stored in old Yale (not our Yale) format. But be careful; there are no overflow warnings. All of these
+ * constructors are defined for power-users. Everyone else should probably resort to the shortcut functions defined in
+ * shortcuts.rb.
  */
 static VALUE nm_init(int argc, VALUE* argv, VALUE nm) {
 
@@ -1139,6 +1182,16 @@ void write_padded_dense_elements(std::ofstream& f, DENSE_STORAGE* storage, nm::s
 }
 
 
+/*
+ * Helper function to get exceptions in the module Errno (e.g., ENOENT). Example:
+ *
+ *     rb_raise(rb_get_errno_exc("ENOENT"), RSTRING_PTR(filename));
+ */
+static VALUE rb_get_errno_exc(const char* which) {
+  return rb_const_get(rb_const_get(rb_cObject, rb_intern("Errno")), rb_intern(which));
+}
+
+
 
 /*
  * Binary file writer for NMatrix standard format. file should be a path, which we aren't going to
@@ -1238,12 +1291,16 @@ static VALUE nm_write(int argc, VALUE* argv, VALUE self) {
 static VALUE nm_read(int argc, VALUE* argv, VALUE self) {
   using std::ifstream;
 
+  VALUE file, force_;
+
   // Read the arguments
-  if (argc < 1 || argc > 2) {
-    rb_raise(rb_eArgError, "expected one or two arguments");
+  rb_scan_args(argc, argv, "11", &file, &force_);
+  bool force   = (force_ != Qnil && force_ != Qfalse);
+
+
+  if (!RB_FILE_EXISTS(file)) { // FIXME: Errno::ENOENT
+    rb_raise(rb_get_errno_exc("ENOENT"), RSTRING_PTR(file));
   }
-  VALUE file   = argv[0];
-  bool force   = argc == 1 ? false : argv[1];
 
   // Open a file stream
   ifstream f(RSTRING_PTR(file), std::ios::in | std::ios::binary);
@@ -1387,7 +1444,7 @@ static VALUE nm_mget(int argc, VALUE* argv, VALUE self) {
 
 /*
  * call-seq:
- *     matrix[indexes] -> ...
+ *     matrix[indices] -> ...
  *
  * Access the contents of an NMatrix at given coordinates by reference.
  *
@@ -1430,6 +1487,7 @@ static VALUE nm_mset(int argc, VALUE* argv, VALUE self) {
     switch(NM_STYPE(self)) {
     case nm::DENSE_STORE:
       nm_dense_storage_set(NM_STORAGE(self), slice, value);
+      free(value);
       break;
     case nm::LIST_STORE:
       // Remove if it's a zero, insert otherwise
@@ -1439,12 +1497,15 @@ static VALUE nm_mset(int argc, VALUE* argv, VALUE self) {
         free(value);
       } else {
         nm_list_storage_insert(NM_STORAGE(self), slice, value);
+        // no need to free value here since it was inserted directly into the list.
       }
       break;
     case nm::YALE_STORE:
       nm_yale_storage_set(NM_STORAGE(self), slice, value);
+      free(value);
       break;
     }
+    free_slice(slice);
 
     return argv[dim];
 
@@ -1620,15 +1681,21 @@ static VALUE nm_xslice(int argc, VALUE* argv, void* (*slice_func)(STORAGE*, SLIC
       NMATRIX* mat = ALLOC(NMATRIX);
       mat->stype = NM_STYPE(self);
       mat->storage = (STORAGE*)((*slice_func)( NM_STORAGE(self), slice ));
-      result = Data_Wrap_Struct(cNMatrix, mark_table[mat->stype], delete_func, mat);
+
+      // Do we want an NVector instead of an NMatrix?
+      VALUE klass = cNMatrix, orient = Qnil;
+      // FIXME: Generalize for n dimensional slicing somehow
+      if (mat->storage->shape[0] == 1 || mat->storage->shape[1] == 1) klass  = cNVector;
+
+      result = Data_Wrap_Struct(klass, mark_table[mat->stype], delete_func, mat);
     }
 
-    free(slice);
+    free_slice(slice);
 
   } else if (NM_DIM(self) < (size_t)(argc)) {
     rb_raise(rb_eArgError, "Coordinates given exceed number of matrix dimensions");
   } else {
-    rb_raise(rb_eNotImpError, "This type slicing not supported yet");
+    rb_raise(rb_eNotImpError, "This type of slicing not supported yet");
   }
 
   return result;
@@ -1689,11 +1756,6 @@ static VALUE elementwise_op(nm::ewop_t op, VALUE left_val, VALUE right_val) {
 
 	VALUE result_val = Data_Wrap_Struct(CLASS_OF(left_val), mark[result->stype], nm_delete, result);
 
-	// If we're dealing with a vector, need to make sure the @orientation matches.
-	// FIXME: Eventually we probably need to make this an internal property of NVector.
-	if (CLASS_OF(left_val) == cNVector)
-	  rb_iv_set(result_val, "@orientation", rb_iv_get(left_val, "@orientation"));
-
 	return result_val;
 }
 
@@ -1817,6 +1879,8 @@ nm::dtype_t nm_dtype_guess(VALUE v) {
   }
 }
 
+
+
 /*
  * Documentation goes here.
  */
@@ -1825,9 +1889,7 @@ static SLICE* get_slice(size_t dim, VALUE* c, VALUE self) {
   VALUE beg, end;
   int exl;
 
-  SLICE* slice = ALLOC(SLICE);
-  slice->coords = ALLOC_N(size_t,dim);
-  slice->lengths = ALLOC_N(size_t, dim);
+  SLICE* slice = alloc_slice(dim);
   slice->single = true;
 
   for (r = 0; r < dim; ++r) {