nmatrix 0.1.0 → 0.2.0

data/ext/nmatrix/ruby_constants.cpp

@@ -86,8 +86,6 @@ VALUE cNMatrix,
       cNMatrix_IO,
       cNMatrix_IO_Matlab,
 			cNMatrix_YaleFunctions,
-			cNMatrix_BLAS,
-			cNMatrix_LAPACK,
 
       cNMatrix_GC_holder,
 

data/ext/nmatrix/ruby_constants.h

@@ -88,8 +88,6 @@ extern VALUE	cNMatrix,
               cNMatrix_IO,
               cNMatrix_IO_Matlab,
 							cNMatrix_YaleFunctions,
-							cNMatrix_BLAS,
-							cNMatrix_LAPACK,
 
 							cNMatrix_GC_holder,
 

data/ext/nmatrix/ruby_nmatrix.c

@@ -134,13 +134,13 @@ DECL_UNARY_RUBY_ACCESSOR(gamma)
 DECL_UNARY_RUBY_ACCESSOR(negate)
 DECL_UNARY_RUBY_ACCESSOR(floor)
 DECL_UNARY_RUBY_ACCESSOR(ceil)
-DECL_UNARY_RUBY_ACCESSOR(round)
 DECL_NONCOM_ELEMENTWISE_RUBY_ACCESSOR(atan2)
 DECL_NONCOM_ELEMENTWISE_RUBY_ACCESSOR(ldexp)
 DECL_NONCOM_ELEMENTWISE_RUBY_ACCESSOR(hypot)
 
-//log can be unary, but also take a base argument, as with Math.log
+//log/round can be unary, but also take a base argument, as with Math.log
 static VALUE nm_unary_log(int argc, VALUE* argv, VALUE self);
+static VALUE nm_unary_round(int argc, VALUE* argv, VALUE self);
 
 static VALUE elementwise_op(nm::ewop_t op, VALUE left_val, VALUE right_val);
 static VALUE unary_op(nm::unaryop_t op, VALUE self);
@@ -155,6 +155,7 @@ static VALUE matrix_multiply_scalar(NMATRIX* left, VALUE scalar);
 static VALUE matrix_multiply(NMATRIX* left, NMATRIX* right);
 static VALUE nm_multiply(VALUE left_v, VALUE right_v);
 static VALUE nm_det_exact(VALUE self);
+static VALUE nm_hessenberg(VALUE self, VALUE a);
 static VALUE nm_inverse(VALUE self, VALUE inverse, VALUE bang);
 static VALUE nm_inverse_exact(VALUE self, VALUE inverse, VALUE lda, VALUE ldb);
 static VALUE nm_complex_conjugate_bang(VALUE self);
@@ -263,19 +264,21 @@ void Init_nmatrix() {
 	rb_define_method(cNMatrix, "supershape", (METHOD)nm_supershape, 0);
 	rb_define_method(cNMatrix, "offset", (METHOD)nm_offset, 0);
 	rb_define_method(cNMatrix, "det_exact", (METHOD)nm_det_exact, 0);
-	rb_define_protected_method(cNMatrix, "__inverse__", (METHOD)nm_inverse, 2);
-  rb_define_protected_method(cNMatrix, "__inverse_exact__", (METHOD)nm_inverse_exact, 3);
-	rb_define_method(cNMatrix, "complex_conjugate!", (METHOD)nm_complex_conjugate_bang, 0);
-	rb_define_method(cNMatrix, "complex_conjugate", (METHOD)nm_complex_conjugate, 0);
+  rb_define_method(cNMatrix, "complex_conjugate!", (METHOD)nm_complex_conjugate_bang, 0);
+  rb_define_method(cNMatrix, "complex_conjugate", (METHOD)nm_complex_conjugate, 0);
+
 	rb_define_protected_method(cNMatrix, "reshape_bang", (METHOD)nm_reshape_bang, 1);
 
+  // Iterators public methods
+  rb_define_method(cNMatrix, "each_with_indices", (METHOD)nm_each_with_indices, 0);
+  rb_define_method(cNMatrix, "each_stored_with_indices", (METHOD)nm_each_stored_with_indices, 0);
+  rb_define_method(cNMatrix, "map_stored", (METHOD)nm_map_stored, 0);
+  rb_define_method(cNMatrix, "each_ordered_stored_with_indices", (METHOD)nm_each_ordered_stored_with_indices, 0);
+
+  // Iterators protected methods
 	rb_define_protected_method(cNMatrix, "__dense_each__", (METHOD)nm_dense_each, 0);
 	rb_define_protected_method(cNMatrix, "__dense_map__", (METHOD)nm_dense_map, 0);
 	rb_define_protected_method(cNMatrix, "__dense_map_pair__", (METHOD)nm_dense_map_pair, 1);
-	rb_define_method(cNMatrix, "each_with_indices", (METHOD)nm_each_with_indices, 0);
-	rb_define_method(cNMatrix, "each_stored_with_indices", (METHOD)nm_each_stored_with_indices, 0);
-	rb_define_method(cNMatrix, "map_stored", (METHOD)nm_map_stored, 0);
-	rb_define_method(cNMatrix, "each_ordered_stored_with_indices", (METHOD)nm_each_ordered_stored_with_indices, 0);
 	rb_define_protected_method(cNMatrix, "__list_map_merged_stored__", (METHOD)nm_list_map_merged_stored, 2);
 	rb_define_protected_method(cNMatrix, "__list_map_stored__", (METHOD)nm_list_map_stored, 1);
 	rb_define_protected_method(cNMatrix, "__yale_map_merged_stored__", (METHOD)nm_yale_map_merged_stored, 2);
@@ -320,7 +323,7 @@ void Init_nmatrix() {
   rb_define_method(cNMatrix, "-@",    (METHOD)nm_unary_negate,0);
   rb_define_method(cNMatrix, "floor", (METHOD)nm_unary_floor, 0);
   rb_define_method(cNMatrix, "ceil", (METHOD)nm_unary_ceil, 0);
-  rb_define_method(cNMatrix, "round", (METHOD)nm_unary_round, 0);
+  rb_define_method(cNMatrix, "round", (METHOD)nm_unary_round, -1);
 
 
 	rb_define_method(cNMatrix, "=~", (METHOD)nm_ew_eqeq, 1);
@@ -338,13 +341,18 @@ void Init_nmatrix() {
 	/////////////////////////
 	// Matrix Math Methods //
 	/////////////////////////
-	rb_define_method(cNMatrix, "dot",		(METHOD)nm_multiply,		1);
-
+	rb_define_method(cNMatrix, "dot", (METHOD)nm_multiply, 1);
 	rb_define_method(cNMatrix, "symmetric?", (METHOD)nm_symmetric, 0);
 	rb_define_method(cNMatrix, "hermitian?", (METHOD)nm_hermitian, 0);
-
 	rb_define_method(cNMatrix, "capacity", (METHOD)nm_capacity, 0);
 
+  // protected methods
+  rb_define_protected_method(cNMatrix, "__inverse__", (METHOD)nm_inverse, 2);
+  rb_define_protected_method(cNMatrix, "__inverse_exact__", (METHOD)nm_inverse_exact, 3);
+
+  // private methods
+  rb_define_private_method(cNMatrix, "__hessenberg__", (METHOD)nm_hessenberg, 1);
+
 	/////////////////
 	// FFI Methods //
 	/////////////////
@@ -680,8 +688,8 @@ void nm_unregister_nmatrix(NMATRIX* nmatrix) {
  *     dtype -> Symbol
  *
  * Get the data type (dtype) of a matrix, e.g., :byte, :int8, :int16, :int32,
- * :int64, :float32, :float64, :complex64, :complex128, :rational32,
- * :rational64, :rational128, or :object (the last is a Ruby object).
+ * :int64, :float32, :float64, :complex64, :complex128,
+ * or :object (the last is a Ruby object).
  */
 static VALUE nm_dtype(VALUE self) {
   ID dtype = rb_intern(DTYPE_NAMES[NM_DTYPE(self)]);
@@ -872,6 +880,22 @@ static VALUE nm_eqeq(VALUE left, VALUE right) {
 
   bool result = false;
 
+  // Check that the shapes match before going any further.
+  if (l->storage->dim != r->storage->dim) {
+    NM_CONSERVATIVE(nm_unregister_value(&left));
+    NM_CONSERVATIVE(nm_unregister_value(&right));
+    rb_raise(nm_eShapeError, "cannot compare matrices with different dimension");
+  }
+
+  size_t dim = l->storage->dim;
+  for (size_t i=0; i<dim; i++) {
+    if (l->storage->shape[i] != r->storage->shape[i]) {
+      NM_CONSERVATIVE(nm_unregister_value(&left));
+      NM_CONSERVATIVE(nm_unregister_value(&right));
+      rb_raise(nm_eShapeError, "cannot compare matrices with different shapes");
+    }
+  }
+
   if (l->stype != r->stype) { // DIFFERENT STYPES
 
     if (l->stype == nm::DENSE_STORE)
@@ -938,7 +962,6 @@ DEF_UNARY_RUBY_ACCESSOR(GAMMA, gamma)
 DEF_UNARY_RUBY_ACCESSOR(NEGATE, negate)
 DEF_UNARY_RUBY_ACCESSOR(FLOOR, floor)
 DEF_UNARY_RUBY_ACCESSOR(CEIL, ceil)
-DEF_UNARY_RUBY_ACCESSOR(ROUND, round)
 
 DEF_NONCOM_ELEMENTWISE_RUBY_ACCESSOR(ATAN2, atan2)
 DEF_NONCOM_ELEMENTWISE_RUBY_ACCESSOR(LDEXP, ldexp)
@@ -969,6 +992,31 @@ static VALUE nm_unary_log(int argc, VALUE* argv, VALUE self) {
   return rb_funcall(self, rb_intern(sym.c_str()), 1, nm::RubyObject(default_log_base).rval);
 }
 
+static VALUE nm_unary_round(int argc, VALUE* argv, VALUE self) {
+  NM_CONSERVATIVE(nm_register_values(argv, argc));
+  const int default_precision = 0;
+  NMATRIX* left;
+  UnwrapNMatrix(self, left);
+  std::string sym;
+
+  switch(left->stype) {
+  case nm::DENSE_STORE:
+    sym = "__dense_unary_round__";
+    break;
+  case nm::YALE_STORE:
+    sym = "__yale_unary_round__";
+    break;
+  case nm::LIST_STORE:
+    sym = "__list_unary_round__";
+    break;
+  }
+  NM_CONSERVATIVE(nm_unregister_values(argv, argc));
+  if (argc > 0) { //supplied precision
+    return rb_funcall(self, rb_intern(sym.c_str()), 1, argv[0]);
+  }
+  return rb_funcall(self, rb_intern(sym.c_str()), 1, nm::RubyObject(default_precision).rval);
+}
+
 //DEF_ELEMENTWISE_RUBY_ACCESSOR(ATAN2, atan2)
 //DEF_ELEMENTWISE_RUBY_ACCESSOR(LDEXP, ldexp)
 //DEF_ELEMENTWISE_RUBY_ACCESSOR(HYPOT, hypot)
@@ -1306,7 +1354,7 @@ static VALUE nm_init_new_version(int argc, VALUE* argv, VALUE self) {
  * default.
  *
  * The data type, or dtype, can be one of: :byte, :int8, :int16, :int32, :int64, :float32, :float64, :complex64,
- * :complex128, :rational128, or :object. The constructor will attempt to guess it from the initial value/array/default
+ * :complex128, or :object. The constructor will attempt to guess it from the initial value/array/default
  * provided, if any. Otherwise, the default is :object, which stores any type of Ruby object.
  *
  * In addition to the above, there is a legacy constructor from the alpha version. To use that version, you must be
@@ -2457,14 +2505,15 @@ static VALUE is_symmetric(VALUE self, bool hermitian) {
 
   NMATRIX* m;
   UnwrapNMatrix(self, m);
+  bool is_symmetric = false;
 
   if (m->storage->shape[0] == m->storage->shape[1] and m->storage->dim == 2) {
     if (NM_STYPE(self) == nm::DENSE_STORE) {
       if (hermitian) {
-        nm_dense_storage_is_hermitian((DENSE_STORAGE*)(m->storage), m->storage->shape[0]);
+        is_symmetric = nm_dense_storage_is_hermitian((DENSE_STORAGE*)(m->storage), m->storage->shape[0]);
 
       } else {
-      	nm_dense_storage_is_symmetric((DENSE_STORAGE*)(m->storage), m->storage->shape[0]);
+        is_symmetric = nm_dense_storage_is_symmetric((DENSE_STORAGE*)(m->storage), m->storage->shape[0]);
       }
 
     } else {
@@ -2475,7 +2524,7 @@ static VALUE is_symmetric(VALUE self, bool hermitian) {
 
   }
   NM_CONSERVATIVE(nm_unregister_value(&self));
-  return Qfalse;
+  return is_symmetric ? Qtrue : Qfalse;
 }
 
 ///////////////////////
@@ -2512,20 +2561,6 @@ nm::dtype_t nm_dtype_min_fixnum(int64_t v) {
   }
 }
 
-/*
- * Helper for nm_dtype_min(), handling rationals.
- */
-nm::dtype_t nm_dtype_min_rational(VALUE vv) {
-  NM_CONSERVATIVE(nm_register_value(&vv));
-  nm::Rational128* v = NM_ALLOCA_N(nm::Rational128, 1);
-  rubyval_to_cval(vv, nm::RATIONAL128, v);
-  NM_CONSERVATIVE(nm_unregister_value(&vv));
-  int64_t i = std::max(std::abs(v->n), v->d);
-  if (i <= SHRT_MAX) return nm::INT16;
-  else if (i <= INT_MAX) return nm::INT32;
-  else return nm::INT64;
-}
-
 /*
  * Return the minimum dtype required to store a given value.
  *
@@ -2548,8 +2583,6 @@ nm::dtype_t nm_dtype_min(VALUE v) {
     return nm::FLOAT32;
   case T_COMPLEX:
     return nm::COMPLEX64;
-  case T_RATIONAL:
-    return nm_dtype_min_rational(v);
   case T_STRING:
     return RSTRING_LEN(v) == 1 ? nm::BYTE : nm::RUBYOBJ;
   case T_TRUE:
@@ -2579,23 +2612,15 @@ nm::dtype_t nm_dtype_guess(VALUE v) {
   case T_FIXNUM:
     return nm::INT64;
 
-  case T_RATIONAL:
-    return nm::RATIONAL128;
-
 #else
 # if SIZEOF_INT == 4
   case T_FIXNUM:
     return nm::INT32;
 
-  case T_RATIONAL:
-    return nm::RATIONAL64;
-
 #else
   case T_FIXNUM:
     return nm::INT16;
 
-  case T_RATIONAL:
-    return nm::RATIONAL32;
 # endif
 #endif
 
@@ -2937,6 +2962,22 @@ static VALUE matrix_multiply(NMATRIX* left, NMATRIX* right) {
   return to_return;
 }
 
+/*
+ * Reduce a matrix to hessenberg form.
+ *
+ * == Arguments
+ *
+ * a - The NMatrix to be reduced. This matrix is replaced with the hessenberg form.
+ *
+ * == Notes 
+ *
+ * LAPACK free.
+ */
+static VALUE nm_hessenberg(VALUE self, VALUE a) {
+  nm_math_hessenberg(a);
+  
+  return a;
+}
 
 /*
  * Calculate the inverse of a matrix with in-place Gauss-Jordan elimination.

data/ext/nmatrix/storage/dense/dense.cpp

@@ -976,12 +976,6 @@ bool eqeq(const DENSE_STORAGE* left, const DENSE_STORAGE* right) {
   tmp1 = NULL; tmp2 = NULL;
   bool result = true;
   /* FIXME: Very strange behavior! The GC calls the method directly with non-initialized data. */
-  if (left->dim != right->dim) {
-    nm_dense_storage_unregister(right);
-    nm_dense_storage_unregister(left);
-
-    return false;
-  }
 
   LDType* left_elements	  = (LDType*)left->elements;
   RDType* right_elements  = (RDType*)right->elements;
@@ -1030,7 +1024,7 @@ bool is_hermitian(const DENSE_STORAGE* mat, int lda) {
 
 	for (i = mat->shape[0]; i-- > 0;) {
 		for (j = i + 1; j < mat->shape[1]; ++j) {
-			complex_conj		= els[j*lda + 1];
+			complex_conj		= els[j*lda + i];
 			complex_conj.i	= -complex_conj.i;
 
 			if (els[i*lda+j] != complex_conj) {

data/ext/nmatrix/storage/storage.h

@@ -56,7 +56,6 @@
 #define NMATRIX_DTYPE_IS_COMPLEX(s)		((s->dtype == nm::COMPLEX64) or (s->dtype == nm::COMPLEX128))
 #define NMATRIX_DTYPE_IS_FLOAT(s)			((s->dtype == nm::FLOAT32) or (s->dtype == nm::FLOAT64))
 #define NMATRIX_DTYPE_IS_INTEGER(s)		(s->dtype <= nm::INT64)
-#define NMATRIX_DTYPE_IS_RATIONAL(s)	((s->dtype == nm::RATIONAL32) or (s->dtype == nm::RATIONAL64) or (s->dtype == nm::RATIONAL128))
 #define NMATRIX_DTYPE_IS_RUBYOBJ(s)		(s->dtype == nm::RUBYOBJ)
 
 

data/ext/nmatrix/ttable_helper.rb

@@ -12,9 +12,6 @@ DTYPES = [
           :float64_t,
           :'nm::Complex64',
           :'nm::Complex128',
-          :'nm::Rational32',
-          :'nm::Rational64',
-          :'nm::Rational128',
           :'nm::RubyObject'
          ]
 
@@ -54,9 +51,6 @@ LR_ALLOWED = {
   :float64_t		=> DTYPES,
   :'nm::Complex64'		=> DTYPES,
   :'nm::Complex128'		=> DTYPES,
-  :'nm::Rational32'		=> nullify([:float32_t, :float64_t, :'nm::Complex64', :'nm::Complex128']),
-  :'nm::Rational64'		=> nullify([:float32_t, :float64_t, :'nm::Complex64', :'nm::Complex128']),
-  :'nm::Rational128'	=> nullify([:float32_t, :float64_t, :'nm::Complex64', :'nm::Complex128']),
   :'nm::RubyObject'		=> DTYPES
 }
 

data/ext/nmatrix/util/io.cpp

@@ -212,7 +212,7 @@ static VALUE nm_rbstring_matlab_repack(VALUE self, VALUE str, VALUE from, VALUE
 
   // For next few lines, see explanation above NM_MATLAB_DTYPE_TEMPLATE_TABLE definition in io.h.
   if (to_type >= static_cast<uint8_t>(nm::COMPLEX64)) {
-    rb_raise(rb_eArgError, "can only repack into a simple dtype, no complex/rational/VALUE");
+    rb_raise(rb_eArgError, "can only repack into a simple dtype, no complex/VALUE");
   }
 
   // Do the actual repacking -- really simple!

data/lib/nmatrix.rb

@@ -22,25 +22,7 @@
 #
 # == nmatrix.rb
 #
-# This file loads the C extension for NMatrix and all the ruby files.
+# This file is a stub that only loads the main NMatrix file.
 #
 
-# For some reason nmatrix.so ends up in a different place during gem build.
-if File.exist?("lib/nmatrix/nmatrix.so") #|| File.exist?("lib/nmatrix/nmatrix.bundle")
-  # Development
-  require "nmatrix/nmatrix.so"
-else
-  # Gem
-  require "nmatrix.so"
-end
-
-require 'nmatrix/io/mat_reader'
-require 'nmatrix/io/mat5_reader'
-require 'nmatrix/io/market'
-require 'nmatrix/io/point_cloud'
-
 require 'nmatrix/nmatrix.rb'
-require 'nmatrix/version.rb'
-require 'nmatrix/blas.rb'
-require 'nmatrix/monkeys'
-require "nmatrix/shortcuts.rb"

data/lib/nmatrix/blas.rb

@@ -28,6 +28,14 @@
 #++
 
 module NMatrix::BLAS
+
+  #Add functions from C extension to main BLAS module
+  class << self
+    NMatrix::Internal::BLAS.singleton_methods.each do |m|
+      define_method m, NMatrix::Internal::BLAS.method(m).to_proc
+    end
+  end
+
   class << self
     #
     # call-seq:
@@ -137,21 +145,20 @@ module NMatrix::BLAS
       raise(ArgumentError, 'Expected nil or dense NMatrix as third argument.') unless y.nil? or (y.is_a?(NMatrix) and y.stype == :dense)
       raise(ArgumentError, 'NMatrix dtype mismatch.')													 unless a.dtype == x.dtype and (y ? a.dtype == y.dtype : true)
 
-      m ||= transpose_a ? a.shape[1] : a.shape[0]
-      n ||= transpose_a ? a.shape[0] : a.shape[1]
+      m ||= transpose_a == :transpose ? a.shape[1] : a.shape[0]
+      n ||= transpose_a == :transpose ? a.shape[0] : a.shape[1]
+      raise(ArgumentError, "dimensions don't match") unless x.shape[0] == n && x.shape[1] == 1
+
+      if y
+        raise(ArgumentError, "dimensions don't match") unless y.shape[0] == m && y.shape[1] == 1
+      else
+        y = NMatrix.new([m,1], dtype: a.dtype)
+      end
 
       lda		||= a.shape[1]
       incx	||= 1
       incy	||= 1
 
-      # NM_COMPLEX64 and NM_COMPLEX128 both require complex alpha and beta.
-      if a.dtype == :complex64 or a.dtype == :complex128
-        alpha = Complex(1.0, 0.0) if alpha == 1.0
-        beta  = Complex(0.0, 0.0) if beta  == 0.0
-      end
-
-      y ||= NMatrix.new([m, n], dtype: a.dtype)
-
       ::NMatrix::BLAS.cblas_gemv(transpose_a, m, n, alpha, a, lda, x, incx, beta, y, incy)
 
       return y
@@ -218,7 +225,7 @@ module NMatrix::BLAS
     #
     # Apply givens plane rotation to the coordinates (a,b), returning the cosine and sine of the angle theta.
     #
-    # Since the givens rotation includes a square root, integers and rationals are disallowed.
+    # Since the givens rotation includes a square root, integers are disallowed.
     #
     # * *Arguments* :
     #   - +ab+ -> NMatrix with two elements
@@ -279,5 +286,20 @@ module NMatrix::BLAS
       raise(RangeError, "n out of range") if n*incx > x.size || n*incx <= 0 || n <= 0
       ::NMatrix::BLAS.cblas_nrm2(n, x, incx)
     end
+
+    # The following are functions that used to be implemented in C, but
+    # now require nmatrix-atlas or nmatrix-lapcke to run properly, so we can just
+    # implemented their stubs in Ruby.
+    def cblas_trmm(order, side, uplo, trans_a, diag, m, n, alpha, a, lda, b, ldb)
+      raise(NotImplementedError,"cblas_trmm requires either the nmatrix-lapacke or nmatrix-atlas gem")
+    end
+
+    def cblas_syrk(order, uplo, trans, n, k, alpha, a, lda, beta, c, ldc)
+      raise(NotImplementedError,"cblas_syrk requires either the nmatrix-lapacke or nmatrix-atlas gem")
+    end
+
+    def cblas_herk(order, uplo, trans, n, k, alpha, a, lda, beta, c, ldc)
+      raise(NotImplementedError,"cblas_herk requires either the nmatrix-lapacke or nmatrix-atlas gem")
+    end
   end
 end

data/lib/nmatrix/io/market.rb

@@ -94,15 +94,15 @@ module NMatrix::IO::Market
     #   - +matrix+ -> NMatrix with the data to be saved.
     #   - +filename+ -> String with the filename to be saved.
     # * *Raises* :
-    #   - +DataTypeError+ -> MatrixMarket does not support rational or Ruby objects.
+    #   - +DataTypeError+ -> MatrixMarket does not support Ruby objects.
     #   - +ArgumentError+ -> Expected two-dimensional NMatrix.
     def save(matrix, filename, options = {})
       options = {:pattern => false,
         :symmetry => :general}.merge(options)
 
       mode = matrix.stype == :dense ? :array : :coordinate
-      if [:rational32,:rational64,:rational128,:object].include?(matrix.dtype)
-        raise(DataTypeError, "MatrixMarket does not support rational or Ruby objects")
+      if [:object].include?(matrix.dtype)
+        raise(DataTypeError, "MatrixMarket does not support Ruby objects")
       end
       entry_type = options[:pattern] ? :pattern : ENTRY_TYPE[matrix.dtype]