nmatrix 0.1.0.rc5 → 0.1.0

data/ext/nmatrix/math/getri.h

@@ -68,7 +68,7 @@ inline int getri(const enum CBLAS_ORDER order, const int n, DType* a, const int
   return 0;
 }
 
-#ifdef HAVE_CLAPACK_H
+#if defined (HAVE_CLAPACK_H) || defined (HAVE_ATLAS_CLAPACK_H)
 template <>
 inline int getri(const enum CBLAS_ORDER order, const int n, float* a, const int lda, const int* ipiv) {
   return clapack_sgetri(order, n, a, lda, ipiv);
@@ -105,4 +105,4 @@ inline int clapack_getri(const enum CBLAS_ORDER order, const int n, void* a, con
 
 } } // end nm::math
 
-#endif // GETRI_H
+#endif // GETRI_H

data/ext/nmatrix/math/math.h

@@ -104,10 +104,10 @@ extern "C" {
    * C accessors.
    */
   void nm_math_det_exact(const int M, const void* elements, const int lda, nm::dtype_t dtype, void* result);
+  void nm_math_inverse(const int M, void* A_elements, nm::dtype_t dtype);
   void nm_math_inverse_exact(const int M, const void* A_elements, const int lda, void* B_elements, const int ldb, nm::dtype_t dtype);
   void nm_math_transpose_generic(const size_t M, const size_t N, const void* A, const int lda, void* B, const int ldb, size_t element_size);
   void nm_math_init_blas(void);
-
 }
 
 

data/ext/nmatrix/ruby_constants.cpp

@@ -148,7 +148,6 @@ void nm_init_ruby_constants(void) {
 	nm_rb_column            = rb_intern("column");
 	nm_rb_row               = rb_intern("row");
 
-  //Added by Ryan
   nm_rb_both              = rb_intern("both");
   nm_rb_none              = rb_intern("none");
 }

data/ext/nmatrix/ruby_nmatrix.c

@@ -134,6 +134,7 @@ 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)
@@ -154,7 +155,8 @@ 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_inverse_exact(VALUE self, VALUE inverse);
+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);
 static VALUE nm_complex_conjugate(VALUE self);
 static VALUE nm_reshape_bang(VALUE self, VALUE arg);
@@ -208,6 +210,7 @@ void Init_nmatrix() {
   nm_eNotInvertibleError = rb_define_class("NotInvertibleError", rb_eStandardError);
 
   /*
+   * :nodoc:
    * Class that holds values in use by the C code.
    */
   cNMatrix_GC_holder = rb_define_class("NMGCHolder", rb_cObject);
@@ -260,7 +263,8 @@ 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_exact__", (METHOD)nm_inverse_exact, 1);
+	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_protected_method(cNMatrix, "reshape_bang", (METHOD)nm_reshape_bang, 1);
@@ -316,6 +320,8 @@ 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, "=~", (METHOD)nm_ew_eqeq, 1);
 	rb_define_method(cNMatrix, "!~", (METHOD)nm_ew_neq, 1);
@@ -445,11 +451,11 @@ static VALUE nm_capacity(VALUE self) {
     break;
 
   default:
-    NM_CONSERVATIVE(nm_unregister_value(self));
+    NM_CONSERVATIVE(nm_unregister_value(&self));
     rb_raise(nm_eStorageTypeError, "unrecognized stype in nm_capacity()");
   }
 
-  NM_CONSERVATIVE(nm_unregister_value(self));
+  NM_CONSERVATIVE(nm_unregister_value(&self));
   return cap;
 }
 
@@ -740,11 +746,11 @@ static VALUE nm_each_with_indices(VALUE nmatrix) {
     to_return = nm_list_each_with_indices(nmatrix, false);
     break;
   default:
-    NM_CONSERVATIVE(nm_unregister_value(nmatrix));
+    NM_CONSERVATIVE(nm_unregister_value(&nmatrix));
     rb_raise(nm_eDataTypeError, "Not a proper storage type");
   }
 
-  NM_CONSERVATIVE(nm_unregister_value(nmatrix));
+  NM_CONSERVATIVE(nm_unregister_value(&nmatrix));
   return to_return;
 }
 
@@ -771,11 +777,11 @@ static VALUE nm_each_stored_with_indices(VALUE nmatrix) {
     to_return = nm_list_each_with_indices(nmatrix, true);
     break;
   default:
-    NM_CONSERVATIVE(nm_unregister_value(nmatrix));
+    NM_CONSERVATIVE(nm_unregister_value(&nmatrix));
     rb_raise(nm_eDataTypeError, "Not a proper storage type");
   }
 
-  NM_CONSERVATIVE(nm_unregister_value(nmatrix));
+  NM_CONSERVATIVE(nm_unregister_value(&nmatrix));
   return to_return;
 }
 
@@ -803,11 +809,11 @@ static VALUE nm_map_stored(VALUE nmatrix) {
     to_return = nm_list_map_stored(nmatrix, Qnil);
     break;
   default:
-    NM_CONSERVATIVE(nm_unregister_value(nmatrix));
+    NM_CONSERVATIVE(nm_unregister_value(&nmatrix));
     rb_raise(nm_eDataTypeError, "Not a proper storage type");
   }
 
-  NM_CONSERVATIVE(nm_unregister_value(nmatrix));
+  NM_CONSERVATIVE(nm_unregister_value(&nmatrix));
   return to_return;
 }
 
@@ -833,11 +839,11 @@ static VALUE nm_each_ordered_stored_with_indices(VALUE nmatrix) {
     to_return = nm_list_each_with_indices(nmatrix, true);
     break;
   default:
-    NM_CONSERVATIVE(nm_unregister_value(nmatrix));
+    NM_CONSERVATIVE(nm_unregister_value(&nmatrix));
     rb_raise(nm_eDataTypeError, "Not a proper storage type");
   }
 
-  NM_CONSERVATIVE(nm_unregister_value(nmatrix));
+  NM_CONSERVATIVE(nm_unregister_value(&nmatrix));
   return to_return;
 }
 
@@ -932,6 +938,7 @@ 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)
@@ -1109,24 +1116,8 @@ static VALUE nm_init_new_version(int argc, VALUE* argv, VALUE self) {
   VALUE shape_ary, initial_ary, hash;
   //VALUE shape_ary, default_val, capacity, initial_ary, dtype_sym, stype_sym;
   // Mandatory args: shape, dtype, stype
-  // FIXME: This is the one line of code standing between Ruby 1.9.2 and 1.9.3.
-#ifndef OLD_RB_SCAN_ARGS // Ruby 1.9.3 and higher
   rb_scan_args(argc, argv, "11:", &shape_ary, &initial_ary, &hash); // &stype_sym, &dtype_sym, &default_val, &capacity);
-#else // Ruby 1.9.2 and lower
-  if (argc == 3)
-    rb_scan_args(argc, argv, "12", &shape_ary, &initial_ary, &hash);
-  else if (argc == 2) {
-    VALUE unknown_arg;
-    rb_scan_args(argc, argv, "11", &shape_ary, &unknown_arg);
-    if (!NIL_P(unknown_arg) && TYPE(unknown_arg) == T_HASH) {
-      hash        = unknown_arg;
-      initial_ary = Qnil;
-    } else {
-      initial_ary  = unknown_arg;
-      hash        = Qnil;
-    }
-  }
-#endif
+
   NM_CONSERVATIVE(nm_register_value(&shape_ary));
   NM_CONSERVATIVE(nm_register_value(&initial_ary));
   NM_CONSERVATIVE(nm_register_value(&hash));
@@ -2947,12 +2938,43 @@ static VALUE matrix_multiply(NMATRIX* left, NMATRIX* right) {
 }
 
 
+/*
+ * Calculate the inverse of a matrix with in-place Gauss-Jordan elimination.
+ * Inverse will fail if the largest element in any column in zero. 
+ *
+ * LAPACK free.
+ */
+static VALUE nm_inverse(VALUE self, VALUE inverse, VALUE bang) {
+
+  if (NM_STYPE(self) != nm::DENSE_STORE) {
+    rb_raise(rb_eNotImpError, "needs exact determinant implementation for this matrix stype");
+    return Qnil;
+  }
+
+  if (NM_DIM(self) != 2 || NM_SHAPE0(self) != NM_SHAPE1(self)) {
+    rb_raise(nm_eShapeError, "matrices must be square to have an inverse defined");
+    return Qnil;
+  }
+
+  if (bang == Qtrue) {
+    nm_math_inverse(NM_SHAPE0(self), NM_STORAGE_DENSE(self)->elements, 
+      NM_DTYPE(self));
+          
+    return self;
+  }
+
+  nm_math_inverse(NM_SHAPE0(inverse), NM_STORAGE_DENSE(inverse)->elements, 
+    NM_DTYPE(inverse));
+
+  return inverse;
+}
+
 /*
  * Calculate the exact inverse of a 2x2 or 3x3 matrix.
  *
  * Does not test for invertibility!
  */
-static VALUE nm_inverse_exact(VALUE self, VALUE inverse) {
+static VALUE nm_inverse_exact(VALUE self, VALUE inverse, VALUE lda, VALUE ldb) {
 
   if (NM_STYPE(self) != nm::DENSE_STORE) {
     rb_raise(rb_eNotImpError, "needs exact determinant implementation for this matrix stype");
@@ -2964,8 +2986,9 @@ static VALUE nm_inverse_exact(VALUE self, VALUE inverse) {
     return Qnil;
   }
 
-  // Calculate the exact inverse.
-  nm_math_inverse_exact(NM_SHAPE0(self), NM_STORAGE_DENSE(self)->elements, NM_SHAPE0(self), NM_STORAGE_DENSE(inverse)->elements, NM_SHAPE0(inverse), NM_DTYPE(self));
+  nm_math_inverse_exact(NM_SHAPE0(self), 
+    NM_STORAGE_DENSE(self)->elements, FIX2INT(lda), 
+    NM_STORAGE_DENSE(inverse)->elements, FIX2INT(ldb), NM_DTYPE(self));
 
   return inverse;
 }

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

@@ -979,6 +979,7 @@ bool eqeq(const DENSE_STORAGE* left, const DENSE_STORAGE* right) {
   if (left->dim != right->dim) {
     nm_dense_storage_unregister(right);
     nm_dense_storage_unregister(left);
+
     return false;
   }
 

data/ext/nmatrix/storage/yale/yale.cpp

@@ -549,7 +549,7 @@ static char vector_insert_resize(YALE_STORAGE* s, size_t current_size, size_t po
   NM_FREE(s->ija);
   nm_yale_storage_unregister(s);
   NM_FREE(s->a);
-  
+
   if (s->dtype == nm::RUBYOBJ)
     nm_yale_storage_unregister_a(new_a, new_capacity);
 
@@ -943,7 +943,7 @@ static VALUE map_stored(VALUE self) {
   NM_CONSERVATIVE(nm_register_value(&self));
   YALE_STORAGE* s = NM_STORAGE_YALE(self);
   YaleStorage<D> y(s);
-  
+
   RETURN_SIZED_ENUMERATOR_PRE
   NM_CONSERVATIVE(nm_unregister_value(&self));
   RETURN_SIZED_ENUMERATOR(self, 0, 0, nm_yale_stored_enumerator_length);
@@ -1014,7 +1014,7 @@ static VALUE stored_diagonal_each_with_indices(VALUE nm) {
   RETURN_SIZED_ENUMERATOR_PRE
   NM_CONSERVATIVE(nm_unregister_value(&nm));
   RETURN_SIZED_ENUMERATOR(nm, 0, 0, nm_yale_stored_diagonal_length); // FIXME: need diagonal length
-  
+
   for (typename YaleStorage<DType>::const_stored_diagonal_iterator d = y.csdbegin(); d != y.csdend(); ++d) {
     rb_yield_values(3, ~d, d.rb_i(), d.rb_j());
   }
@@ -1106,10 +1106,8 @@ static bool is_pos_default_value(YALE_STORAGE* s, size_t apos) {
   return y.is_pos_default_value(apos);
 }
 
-
 } // end of namespace nm::yale_storage
 
-
 } // end of namespace nm.
 
 ///////////////////
@@ -1123,7 +1121,7 @@ extern "C" {
 void nm_init_yale_functions() {
 	/*
 	 * This module stores methods that are useful for debugging Yale matrices,
-	 * i.e. the ones with +:yale+ stype.	
+	 * i.e. the ones with +:yale+ stype.
 	 */
   cNMatrix_YaleFunctions = rb_define_module_under(cNMatrix, "YaleFunctions");
 
@@ -1141,10 +1139,13 @@ void nm_init_yale_functions() {
 
   rb_define_method(cNMatrix_YaleFunctions, "yale_nd_row", (METHOD)nm_nd_row, -1);
 
+  /* Document-const:
+   * Defines the growth rate of the sparse NMatrix's size. Default is 1.5.
+   */
   rb_define_const(cNMatrix_YaleFunctions, "YALE_GROWTH_CONSTANT", rb_float_new(nm::yale_storage::GROWTH_CONSTANT));
 
   // This is so the user can easily check the IType size, mostly for debugging.
-  size_t itype_size        = sizeof(IType);
+  size_t itype_size = sizeof(IType);
   VALUE itype_dtype;
   if (itype_size == sizeof(uint64_t)) {
     itype_dtype = ID2SYM(rb_intern("int64"));
@@ -1158,12 +1159,10 @@ void nm_init_yale_functions() {
   rb_define_const(cNMatrix, "INDEX_DTYPE", itype_dtype);
 }
 
-
 /////////////////
 // C ACCESSORS //
 /////////////////
 
-
 /* C interface for NMatrix#each_with_indices (Yale) */
 VALUE nm_yale_each_with_indices(VALUE nmatrix) {
   NAMED_DTYPE_TEMPLATE_TABLE(ttable, nm::yale_storage::each_with_indices, VALUE, VALUE)
@@ -1555,7 +1554,7 @@ static bool is_pos_default_value(YALE_STORAGE* s, size_t apos) {
  * Only checks the stored indices; does not care about matrix default value.
  */
 static VALUE nm_row_keys_intersection(VALUE m1, VALUE ii1, VALUE m2, VALUE ii2) {
-  
+
   NM_CONSERVATIVE(nm_register_value(&m1));
   NM_CONSERVATIVE(nm_register_value(&m2));
 
@@ -1658,7 +1657,7 @@ static VALUE nm_a(int argc, VALUE* argv, VALUE self) {
     VALUE* vals = NM_ALLOCA_N(VALUE, size);
 
     nm_register_values(vals, size);
-    
+
     if (NM_DTYPE(self) == nm::RUBYOBJ) {
       for (size_t i = 0; i < size; ++i) {
         vals[i] = reinterpret_cast<VALUE*>(s->a)[i];
@@ -1786,7 +1785,7 @@ static VALUE nm_ia(VALUE self) {
     vals[i] = INT2FIX(s->ija[i]);
   }
 
-  NM_CONSERVATIVE(nm_unregister_value(&self)); 
+  NM_CONSERVATIVE(nm_unregister_value(&self));
 
   return rb_ary_new4(s->shape[0]+1, vals);
 }
@@ -1887,11 +1886,10 @@ static VALUE nm_ija(int argc, VALUE* argv, VALUE self) {
 static VALUE nm_nd_row(int argc, VALUE* argv, VALUE self) {
 
   NM_CONSERVATIVE(nm_register_value(&self));
-  
   if (NM_SRC(self) != NM_STORAGE(self)) {
     NM_CONSERVATIVE(nm_unregister_value(&self));
     rb_raise(rb_eNotImpError, "must be called on a real matrix and not a slice");
-  }  
+  }
 
   VALUE i_, as;
   rb_scan_args(argc, argv, "11", &i_, &as);

data/ext/nmatrix/ttable_helper.rb

@@ -2,7 +2,6 @@
 
 # A helper file for generating and maintaining template tables.
 
-
 DTYPES = [
           :uint8_t,
           :int8_t,

data/lib/nmatrix.rb

@@ -34,6 +34,11 @@ else
   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'

data/lib/nmatrix/homogeneous.rb

@@ -140,4 +140,102 @@ class NMatrix
       n
     end
   end
+
+  #
+  # call-seq:
+  #     quaternion -> NMatrix
+  #
+  # Find the quaternion for a 3D rotation matrix.
+  #
+  # Code borrowed from: http://courses.cms.caltech.edu/cs171/quatut.pdf
+  #
+  # * *Returns* :
+  #   - A length-4 NMatrix representing the corresponding quaternion.
+  #
+  # Examples:
+  #
+  #    n.quaternion # => [1, 0, 0, 0]
+  #
+  def quaternion
+    raise(ShapeError, "Expected square matrix") if self.shape[0] != self.shape[1]
+    raise(ShapeError, "Expected 3x3 rotation (or 4x4 homogeneous) matrix") if self.shape[0] > 4 || self.shape[0] < 3
+
+    q = NMatrix.new([4], dtype: self.dtype == :float32 ? :float32: :float64)
+    rotation_trace = self[0,0] + self[1,1] + self[2,2]
+    if rotation_trace >= 0
+      self_w = self.shape[0] == 4 ? self[3,3] : 1.0
+      root_of_homogeneous_trace = Math.sqrt(rotation_trace + self_w)
+      q[0] = root_of_homogeneous_trace * 0.5
+      s = 0.5 / root_of_homogeneous_trace
+      q[1] = (self[2,1] - self[1,2]) * s
+      q[2] = (self[0,2] - self[2,0]) * s
+      q[3] = (self[1,0] - self[0,1]) * s
+    else
+      h = 0
+      h = 1 if self[1,1] > self[0,0]
+      h = 2 if self[2,2] > self[h,h]
+
+      case_macro = Proc.new do |i,j,k,ii,jj,kk|
+        qq = NMatrix.new([4], dtype: :float64)
+        self_w = self.shape[0] == 4 ? self[3,3] : 1.0
+        s = Math.sqrt( (self[ii,ii] - (self[jj,jj] + self[kk,kk])) + self_w)
+        qq[i] = s*0.5
+        s = 0.5 / s
+        qq[j] = (self[ii,jj] + self[jj,ii]) * s
+        qq[k] = (self[kk,ii] + self[ii,kk]) * s
+        qq[0] = (self[kk,jj] - self[jj,kk]) * s
+        qq
+      end
+
+      case h
+      when 0
+        q = case_macro.call(1,2,3, 0,1,2)
+      when 1
+        q = case_macro.call(2,3,1, 1,2,0)
+      when 2
+        q = case_macro.call(3,1,2, 2,0,1)
+      end
+
+      self_w = self.shape[0] == 4 ? self[3,3] : 1.0
+      if self_w != 1
+        s = 1.0 / Math.sqrt(self_w)
+        q[0] *= s
+        q[1] *= s
+        q[2] *= s
+        q[3] *= s
+      end
+    end
+
+    q
+  end
+
+  #
+  # call-seq:
+  #     angle_vector -> [angle, about_vector]
+  #
+  # Find the angle vector for a quaternion. Assumes the quaternion has unit length.
+  #
+  # Source: http://www.euclideanspace.com/maths/geometry/rotations/conversions/quaternionToAngle/
+  #
+  # * *Returns* :
+  #   - An angle (in radians) describing the rotation about the +about_vector+.
+  #   - A length-3 NMatrix representing the corresponding quaternion.
+  #
+  # Examples:
+  #
+  #    q.angle_vector # => [1, 0, 0, 0]
+  #
+  def angle_vector
+    raise(ShapeError, "Expected length-4 vector or matrix (quaternion)") if self.shape[0] != 4
+    raise("Expected unit quaternion") if self[0] > 1
+
+    xyz = NMatrix.new([3], dtype: self.dtype)
+
+    angle = 2 * Math.acos(self[0])
+    s = Math.sqrt(1.0 - self[0]*self[0])
+
+    xyz[0..2] = self[1..3]
+    xyz /= s if s >= 0.001 # avoid divide by zero
+    return [angle, xyz]
+  end
 end