nmatrix 0.2.0 → 0.2.1

data/ext/nmatrix/nmatrix.h

@@ -57,6 +57,33 @@
   #include "nm_memory.h"
 #endif
 
+#ifndef FIX_CONST_VALUE_PTR
+# if defined(__fcc__) || defined(__fcc_version) || \
+    defined(__FCC__) || defined(__FCC_VERSION)
+/* workaround for old version of Fujitsu C Compiler (fcc) */
+#  define FIX_CONST_VALUE_PTR(x) ((const VALUE *)(x))
+# else
+#  define FIX_CONST_VALUE_PTR(x) (x)
+# endif
+#endif
+
+#ifndef HAVE_RB_ARRAY_CONST_PTR
+static inline const VALUE *
+rb_array_const_ptr(VALUE a)
+{
+  return FIX_CONST_VALUE_PTR((RBASIC(a)->flags & RARRAY_EMBED_FLAG) ?
+    RARRAY(a)->as.ary : RARRAY(a)->as.heap.ptr);
+}
+#endif
+
+#ifndef RARRAY_CONST_PTR
+# define RARRAY_CONST_PTR(a) rb_array_const_ptr(a)
+#endif
+
+#ifndef RARRAY_AREF
+# define RARRAY_AREF(a, i) (RARRAY_CONST_PTR(a)[i])
+#endif
+
 /*
  * Macros
  */
@@ -323,7 +350,10 @@ NM_DEF_STRUCT_POST(NM_GC_HOLDER);       // };
 #define NM_SHAPE1(val)          (NM_STORAGE(val)->shape[1])
 #define NM_DEFAULT_VAL(val)     (NM_STORAGE_LIST(val)->default_val)
 
+// Number of elements in a dense nmatrix.
 #define NM_DENSE_COUNT(val)     (nm_storage_count_max_elements(NM_STORAGE_DENSE(val)))
+
+// Get a pointer to the array that stores elements in a dense matrix.
 #define NM_DENSE_ELEMENTS(val)  (NM_STORAGE_DENSE(val)->elements)
 #define NM_SIZEOF_DTYPE(val)    (DTYPE_SIZES[NM_DTYPE(val)])
 #define NM_REF(val,slice)       (RefFuncs[NM_STYPE(val)]( NM_STORAGE(val), slice, NM_SIZEOF_DTYPE(val) ))

data/ext/nmatrix/ruby_constants.cpp

@@ -35,21 +35,21 @@
  * Global Variables
  */
 
-ID	nm_rb_dtype,
+ID  nm_rb_dtype,
     nm_rb_stype,
 
     nm_rb_capacity,
     nm_rb_default,
 
     nm_rb_real,
-		nm_rb_imag,
+    nm_rb_imag,
 
-		nm_rb_numer,
-		nm_rb_denom,
+    nm_rb_numer,
+    nm_rb_denom,
 
-		nm_rb_complex_conjugate,
-		nm_rb_transpose,
-		nm_rb_no_transpose,
+    nm_rb_complex_conjugate,
+    nm_rb_transpose,
+    nm_rb_no_transpose,
     nm_rb_left,
     nm_rb_right,
     nm_rb_upper,
@@ -57,41 +57,41 @@ ID	nm_rb_dtype,
     nm_rb_unit,
     nm_rb_nonunit,
 
-		nm_rb_dense,
-		nm_rb_list,
-		nm_rb_yale,
+    nm_rb_dense,
+    nm_rb_list,
+    nm_rb_yale,
 
-		nm_rb_row,
-		nm_rb_column,
-		nm_rb_add,
-		nm_rb_sub,
-		nm_rb_mul,
-		nm_rb_div,
+    nm_rb_row,
+    nm_rb_column,
+    nm_rb_add,
+    nm_rb_sub,
+    nm_rb_mul,
+    nm_rb_div,
     nm_rb_both,
     nm_rb_none,
 
-		nm_rb_negate,
+    nm_rb_negate,
 
-		nm_rb_percent,
-		nm_rb_gt,
-		nm_rb_lt,
-		nm_rb_eql,
-		nm_rb_neql,
-		nm_rb_gte,
-		nm_rb_lte,
+    nm_rb_percent,
+    nm_rb_gt,
+    nm_rb_lt,
+    nm_rb_eql,
+    nm_rb_neql,
+    nm_rb_gte,
+    nm_rb_lte,
 
-		nm_rb_hash;
+    nm_rb_hash;
 
 VALUE cNMatrix,
       cNMatrix_IO,
       cNMatrix_IO_Matlab,
-			cNMatrix_YaleFunctions,
+      cNMatrix_YaleFunctions,
 
       cNMatrix_GC_holder,
 
-			nm_eDataTypeError,
+      nm_eDataTypeError,
       nm_eConvergenceError,
-			nm_eStorageTypeError,
+      nm_eStorageTypeError,
       nm_eShapeError,
       nm_eNotInvertibleError;
 
@@ -106,45 +106,45 @@ void nm_init_ruby_constants(void) {
   nm_rb_capacity          = rb_intern("capacity");
   nm_rb_default           = rb_intern("default");
 
-	nm_rb_real							= rb_intern("real");
-	nm_rb_imag							= rb_intern("imag");
-
-	nm_rb_numer							= rb_intern("numerator");
-	nm_rb_denom							= rb_intern("denominator");
-
-	nm_rb_complex_conjugate	= rb_intern("complex_conjugate");
-	nm_rb_transpose					= rb_intern("transpose");
-	nm_rb_no_transpose			= rb_intern("no_transpose");
-
-	nm_rb_dense 						= rb_intern("dense");
-	nm_rb_list							= rb_intern("list");
-	nm_rb_yale							= rb_intern("yale");
-
-	nm_rb_add								= rb_intern("+");
-	nm_rb_sub								= rb_intern("-");
-	nm_rb_mul								= rb_intern("*");
-	nm_rb_div								= rb_intern("/");
-
-	nm_rb_negate            = rb_intern("-@");
-
-	nm_rb_percent						= rb_intern("%");
-	nm_rb_gt								= rb_intern(">");
-	nm_rb_lt								= rb_intern("<");
-	nm_rb_eql								= rb_intern("==");
-	nm_rb_neql							= rb_intern("!=");
-	nm_rb_gte								= rb_intern(">=");
-	nm_rb_lte								= rb_intern("<=");
-
-	nm_rb_left              = rb_intern("left");
-	nm_rb_right             = rb_intern("right");
-	nm_rb_upper             = rb_intern("upper");
-	nm_rb_lower             = rb_intern("lower");
-	nm_rb_unit              = rb_intern("unit");
-	nm_rb_nonunit           = rb_intern("nonunit");
-	nm_rb_hash              = rb_intern("hash");
-
-	nm_rb_column            = rb_intern("column");
-	nm_rb_row               = rb_intern("row");
+  nm_rb_real              = rb_intern("real");
+  nm_rb_imag              = rb_intern("imag");
+
+  nm_rb_numer              = rb_intern("numerator");
+  nm_rb_denom              = rb_intern("denominator");
+
+  nm_rb_complex_conjugate  = rb_intern("complex_conjugate");
+  nm_rb_transpose          = rb_intern("transpose");
+  nm_rb_no_transpose      = rb_intern("no_transpose");
+
+  nm_rb_dense             = rb_intern("dense");
+  nm_rb_list              = rb_intern("list");
+  nm_rb_yale              = rb_intern("yale");
+
+  nm_rb_add                = rb_intern("+");
+  nm_rb_sub                = rb_intern("-");
+  nm_rb_mul                = rb_intern("*");
+  nm_rb_div                = rb_intern("/");
+
+  nm_rb_negate            = rb_intern("-@");
+
+  nm_rb_percent            = rb_intern("%");
+  nm_rb_gt                = rb_intern(">");
+  nm_rb_lt                = rb_intern("<");
+  nm_rb_eql                = rb_intern("==");
+  nm_rb_neql              = rb_intern("!=");
+  nm_rb_gte                = rb_intern(">=");
+  nm_rb_lte                = rb_intern("<=");
+
+  nm_rb_left              = rb_intern("left");
+  nm_rb_right             = rb_intern("right");
+  nm_rb_upper             = rb_intern("upper");
+  nm_rb_lower             = rb_intern("lower");
+  nm_rb_unit              = rb_intern("unit");
+  nm_rb_nonunit           = rb_intern("nonunit");
+  nm_rb_hash              = rb_intern("hash");
+
+  nm_rb_column            = rb_intern("column");
+  nm_rb_row               = rb_intern("row");
 
   nm_rb_both              = rb_intern("both");
   nm_rb_none              = rb_intern("none");

data/ext/nmatrix/ruby_constants.h

@@ -45,57 +45,57 @@ extern ID nm_rb_dtype,
           nm_rb_default,
 
           nm_rb_real,
-					nm_rb_imag,
+          nm_rb_imag,
 
-					nm_rb_numer,
-					nm_rb_denom,
+          nm_rb_numer,
+          nm_rb_denom,
 
-					nm_rb_complex_conjugate,
-					nm_rb_transpose,
-					nm_rb_no_transpose,
-					nm_rb_left,
-					nm_rb_right,
-					nm_rb_upper,
-					nm_rb_lower,
-					nm_rb_unit,
-					nm_rb_nonunit,
+          nm_rb_complex_conjugate,
+          nm_rb_transpose,
+          nm_rb_no_transpose,
+          nm_rb_left,
+          nm_rb_right,
+          nm_rb_upper,
+          nm_rb_lower,
+          nm_rb_unit,
+          nm_rb_nonunit,
 
-					nm_rb_dense,
-					nm_rb_list,
-					nm_rb_yale,
+          nm_rb_dense,
+          nm_rb_list,
+          nm_rb_yale,
 
           nm_rb_row,
           nm_rb_column,
 
-					nm_rb_add,
-					nm_rb_sub,
-					nm_rb_mul,
-					nm_rb_div,
+          nm_rb_add,
+          nm_rb_sub,
+          nm_rb_mul,
+          nm_rb_div,
 
-					nm_rb_negate,
+          nm_rb_negate,
 
-					nm_rb_percent,
-					nm_rb_gt,
-					nm_rb_lt,
-					nm_rb_eql,
-					nm_rb_neql,
-					nm_rb_gte,
-					nm_rb_lte,
+          nm_rb_percent,
+          nm_rb_gt,
+          nm_rb_lt,
+          nm_rb_eql,
+          nm_rb_neql,
+          nm_rb_gte,
+          nm_rb_lte,
 
-					nm_rb_hash;
+          nm_rb_hash;
 
-extern VALUE	cNMatrix,
+extern VALUE  cNMatrix,
               cNMatrix_IO,
               cNMatrix_IO_Matlab,
-							cNMatrix_YaleFunctions,
+              cNMatrix_YaleFunctions,
 
-							cNMatrix_GC_holder,
+              cNMatrix_GC_holder,
 
-							nm_eDataTypeError,
+              nm_eDataTypeError,
               nm_eConvergenceError,
-							nm_eStorageTypeError,
-							nm_eShapeError,
-							nm_eNotInvertibleError;
+              nm_eStorageTypeError,
+              nm_eShapeError,
+              nm_eNotInvertibleError;
 
 /*
  * Functions

data/ext/nmatrix/ruby_nmatrix.c

@@ -159,13 +159,12 @@ 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);
-static VALUE nm_complex_conjugate(VALUE self);
 static VALUE nm_reshape_bang(VALUE self, VALUE arg);
 
-static nm::dtype_t	interpret_dtype(int argc, VALUE* argv, nm::stype_t stype);
-static void*		interpret_initial_value(VALUE arg, nm::dtype_t dtype);
-static size_t*	interpret_shape(VALUE arg, size_t* dim);
-static nm::stype_t	interpret_stype(VALUE arg);
+static nm::dtype_t  interpret_dtype(int argc, VALUE* argv, nm::stype_t stype);
+static void*    interpret_initial_value(VALUE arg, nm::dtype_t dtype);
+static size_t*  interpret_shape(VALUE arg, size_t* dim);
+static nm::stype_t  interpret_stype(VALUE arg);
 
 /* Singleton methods */
 static VALUE nm_upcast(VALUE self, VALUE t1, VALUE t2);
@@ -182,28 +181,28 @@ static double get_time(void);
 void Init_nmatrix() {
 
 
-	///////////////////////
-	// Class Definitions //
-	///////////////////////
+  ///////////////////////
+  // Class Definitions //
+  ///////////////////////
 
-	cNMatrix = rb_define_class("NMatrix", rb_cObject);
+  cNMatrix = rb_define_class("NMatrix", rb_cObject);
 
-	// Special exceptions
+  // Special exceptions
 
-	/*
-	 * Exception raised when there's a problem with data.
-	 */
-	nm_eDataTypeError    = rb_define_class("DataTypeError", rb_eStandardError);
+  /*
+   * Exception raised when there's a problem with data.
+   */
+  nm_eDataTypeError    = rb_define_class("DataTypeError", rb_eStandardError);
 
-	/*
-	 * Exception raised when something goes wrong with the storage of a matrix.
-	 */
-	nm_eStorageTypeError = rb_define_class("StorageTypeError", rb_eStandardError);
+  /*
+   * Exception raised when something goes wrong with the storage of a matrix.
+   */
+  nm_eStorageTypeError = rb_define_class("StorageTypeError", rb_eStandardError);
 
-	/*
-	 * Exception raise when the matrix shape is not appropriate for a given operation.
-	 */
-	nm_eShapeError = rb_define_class("ShapeError", rb_eStandardError);
+  /*
+   * Exception raise when the matrix shape is not appropriate for a given operation.
+   */
+  nm_eShapeError = rb_define_class("ShapeError", rb_eStandardError);
 
   /*
    * Exception raise when an inverse is requested but the matrix is not invertible.
@@ -217,57 +216,56 @@ void Init_nmatrix() {
   cNMatrix_GC_holder = rb_define_class("NMGCHolder", rb_cObject);
 
 
-	///////////////////
-	// Class Methods //
-	///////////////////
+  ///////////////////
+  // Class Methods //
+  ///////////////////
 
-	rb_define_alloc_func(cNMatrix, nm_alloc);
+  rb_define_alloc_func(cNMatrix, nm_alloc);
 
-	///////////////////////
+  ///////////////////////
   // Singleton Methods //
   ///////////////////////
 
-	rb_define_singleton_method(cNMatrix, "upcast", (METHOD)nm_upcast, 2); /* in ext/nmatrix/nmatrix.cpp */
-	rb_define_singleton_method(cNMatrix, "guess_dtype", (METHOD)nm_guess_dtype, 1);
-	rb_define_singleton_method(cNMatrix, "min_dtype", (METHOD)nm_min_dtype, 1);
+  rb_define_singleton_method(cNMatrix, "upcast", (METHOD)nm_upcast, 2); /* in ext/nmatrix/nmatrix.cpp */
+  rb_define_singleton_method(cNMatrix, "guess_dtype", (METHOD)nm_guess_dtype, 1);
+  rb_define_singleton_method(cNMatrix, "min_dtype", (METHOD)nm_min_dtype, 1);
 
-	//////////////////////
-	// Instance Methods //
-	//////////////////////
+  //////////////////////
+  // Instance Methods //
+  //////////////////////
 
-	rb_define_method(cNMatrix, "initialize", (METHOD)nm_init, -1);
-	rb_define_method(cNMatrix, "initialize_copy", (METHOD)nm_init_copy, 1);
-	rb_define_singleton_method(cNMatrix, "read", (METHOD)nm_read, -1);
+  rb_define_method(cNMatrix, "initialize", (METHOD)nm_init, -1);
+  rb_define_method(cNMatrix, "initialize_copy", (METHOD)nm_init_copy, 1);
+  rb_define_singleton_method(cNMatrix, "read", (METHOD)nm_read, -1);
 
-	rb_define_method(cNMatrix, "write", (METHOD)nm_write, -1);
+  rb_define_method(cNMatrix, "write", (METHOD)nm_write, -1);
 
-	// Technically, the following function is a copy constructor.
-	rb_define_protected_method(cNMatrix, "clone_transpose", (METHOD)nm_init_transposed, 0);
+  // Technically, the following function is a copy constructor.
+  rb_define_protected_method(cNMatrix, "clone_transpose", (METHOD)nm_init_transposed, 0);
 
-	rb_define_method(cNMatrix, "dtype", (METHOD)nm_dtype, 0);
-	rb_define_method(cNMatrix, "stype", (METHOD)nm_stype, 0);
-	rb_define_method(cNMatrix, "cast_full",  (METHOD)nm_cast, 3);
-	rb_define_method(cNMatrix, "default_value", (METHOD)nm_default_value, 0);
-	rb_define_protected_method(cNMatrix, "__list_default_value__", (METHOD)nm_list_default_value, 0);
-	rb_define_protected_method(cNMatrix, "__yale_default_value__", (METHOD)nm_yale_default_value, 0);
+  rb_define_method(cNMatrix, "dtype", (METHOD)nm_dtype, 0);
+  rb_define_method(cNMatrix, "stype", (METHOD)nm_stype, 0);
+  rb_define_method(cNMatrix, "cast_full",  (METHOD)nm_cast, 3);
+  rb_define_method(cNMatrix, "default_value", (METHOD)nm_default_value, 0);
+  rb_define_protected_method(cNMatrix, "__list_default_value__", (METHOD)nm_list_default_value, 0);
+  rb_define_protected_method(cNMatrix, "__yale_default_value__", (METHOD)nm_yale_default_value, 0);
 
-	rb_define_method(cNMatrix, "[]", (METHOD)nm_mref, -1);
-	rb_define_method(cNMatrix, "slice", (METHOD)nm_mget, -1);
-	rb_define_method(cNMatrix, "[]=", (METHOD)nm_mset, -1);
-	rb_define_method(cNMatrix, "is_ref?", (METHOD)nm_is_ref, 0);
-	rb_define_method(cNMatrix, "dimensions", (METHOD)nm_dim, 0);
-	rb_define_method(cNMatrix, "effective_dimensions", (METHOD)nm_effective_dim, 0);
+  rb_define_method(cNMatrix, "[]", (METHOD)nm_mref, -1);
+  rb_define_method(cNMatrix, "slice", (METHOD)nm_mget, -1);
+  rb_define_method(cNMatrix, "[]=", (METHOD)nm_mset, -1);
+  rb_define_method(cNMatrix, "is_ref?", (METHOD)nm_is_ref, 0);
+  rb_define_method(cNMatrix, "dimensions", (METHOD)nm_dim, 0);
+  rb_define_method(cNMatrix, "effective_dimensions", (METHOD)nm_effective_dim, 0);
 
-	rb_define_protected_method(cNMatrix, "__list_to_hash__", (METHOD)nm_to_hash, 0); // handles list and dense, which are n-dimensional
+  rb_define_protected_method(cNMatrix, "__list_to_hash__", (METHOD)nm_to_hash, 0); // handles list and dense, which are n-dimensional
 
-	rb_define_method(cNMatrix, "shape", (METHOD)nm_shape, 0);
-	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_method(cNMatrix, "shape", (METHOD)nm_shape, 0);
+  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_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);
+  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);
@@ -276,22 +274,22 @@ void Init_nmatrix() {
   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_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);
-	rb_define_protected_method(cNMatrix, "__yale_map_stored__", (METHOD)nm_yale_map_stored, 0);
-	rb_define_protected_method(cNMatrix, "__yale_stored_diagonal_each_with_indices__", (METHOD)nm_yale_stored_diagonal_each_with_indices, 0);
-	rb_define_protected_method(cNMatrix, "__yale_stored_nondiagonal_each_with_indices__", (METHOD)nm_yale_stored_nondiagonal_each_with_indices, 0);
-
-	rb_define_method(cNMatrix, "==",	  (METHOD)nm_eqeq,				1);
-
-	rb_define_method(cNMatrix, "+",			(METHOD)nm_ew_add,			1);
-	rb_define_method(cNMatrix, "-",			(METHOD)nm_ew_subtract,	1);
-  rb_define_method(cNMatrix, "*",			(METHOD)nm_ew_multiply,	1);
-	rb_define_method(cNMatrix, "/",			(METHOD)nm_ew_divide,		1);
+  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_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);
+  rb_define_protected_method(cNMatrix, "__yale_map_stored__", (METHOD)nm_yale_map_stored, 0);
+  rb_define_protected_method(cNMatrix, "__yale_stored_diagonal_each_with_indices__", (METHOD)nm_yale_stored_diagonal_each_with_indices, 0);
+  rb_define_protected_method(cNMatrix, "__yale_stored_nondiagonal_each_with_indices__", (METHOD)nm_yale_stored_nondiagonal_each_with_indices, 0);
+
+  rb_define_method(cNMatrix, "==",    (METHOD)nm_eqeq,        1);
+
+  rb_define_method(cNMatrix, "+",      (METHOD)nm_ew_add,      1);
+  rb_define_method(cNMatrix, "-",      (METHOD)nm_ew_subtract,  1);
+  rb_define_method(cNMatrix, "*",      (METHOD)nm_ew_multiply,  1);
+  rb_define_method(cNMatrix, "/",      (METHOD)nm_ew_divide,    1);
   rb_define_method(cNMatrix, "**",    (METHOD)nm_ew_power,    1);
   rb_define_method(cNMatrix, "%",     (METHOD)nm_ew_mod,      1);
 
@@ -326,25 +324,25 @@ void Init_nmatrix() {
   rb_define_method(cNMatrix, "round", (METHOD)nm_unary_round, -1);
 
 
-	rb_define_method(cNMatrix, "=~", (METHOD)nm_ew_eqeq, 1);
-	rb_define_method(cNMatrix, "!~", (METHOD)nm_ew_neq, 1);
-	rb_define_method(cNMatrix, "<=", (METHOD)nm_ew_leq, 1);
-	rb_define_method(cNMatrix, ">=", (METHOD)nm_ew_geq, 1);
-	rb_define_method(cNMatrix, "<", (METHOD)nm_ew_lt, 1);
-	rb_define_method(cNMatrix, ">", (METHOD)nm_ew_gt, 1);
+  rb_define_method(cNMatrix, "=~", (METHOD)nm_ew_eqeq, 1);
+  rb_define_method(cNMatrix, "!~", (METHOD)nm_ew_neq, 1);
+  rb_define_method(cNMatrix, "<=", (METHOD)nm_ew_leq, 1);
+  rb_define_method(cNMatrix, ">=", (METHOD)nm_ew_geq, 1);
+  rb_define_method(cNMatrix, "<", (METHOD)nm_ew_lt, 1);
+  rb_define_method(cNMatrix, ">", (METHOD)nm_ew_gt, 1);
 
-	/////////////////////////////
-	// Helper Instance Methods //
-	/////////////////////////////
-	rb_define_protected_method(cNMatrix, "__yale_vector_set__", (METHOD)nm_vector_set, -1);
+  /////////////////////////////
+  // Helper Instance Methods //
+  /////////////////////////////
+  rb_define_protected_method(cNMatrix, "__yale_vector_set__", (METHOD)nm_vector_set, -1);
 
-	/////////////////////////
-	// Matrix Math Methods //
-	/////////////////////////
-	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);
+  /////////////////////////
+  // Matrix Math Methods //
+  /////////////////////////
+  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);
@@ -353,46 +351,46 @@ void Init_nmatrix() {
   // private methods
   rb_define_private_method(cNMatrix, "__hessenberg__", (METHOD)nm_hessenberg, 1);
 
-	/////////////////
-	// FFI Methods //
-	/////////////////
-	rb_define_method(cNMatrix, "data_pointer", (METHOD)nm_data_pointer, 0);
+  /////////////////
+  // FFI Methods //
+  /////////////////
+  rb_define_method(cNMatrix, "data_pointer", (METHOD)nm_data_pointer, 0);
 
-	/////////////
-	// Aliases //
-	/////////////
+  /////////////
+  // Aliases //
+  /////////////
 
-	rb_define_alias(cNMatrix, "dim", "dimensions");
-	rb_define_alias(cNMatrix, "effective_dim", "effective_dimensions");
-	rb_define_alias(cNMatrix, "equal?", "eql?");
+  rb_define_alias(cNMatrix, "dim", "dimensions");
+  rb_define_alias(cNMatrix, "effective_dim", "effective_dimensions");
+  rb_define_alias(cNMatrix, "equal?", "eql?");
 
-	///////////////////////
-	// Symbol Generation //
-	///////////////////////
+  ///////////////////////
+  // Symbol Generation //
+  ///////////////////////
 
-	nm_init_ruby_constants();
+  nm_init_ruby_constants();
 
-	//////////////////////////
-	// YaleFunctions module //
-	//////////////////////////
+  //////////////////////////
+  // YaleFunctions module //
+  //////////////////////////
 
-	nm_init_yale_functions();
+  nm_init_yale_functions();
 
-	/////////////////
-	// BLAS module //
-	/////////////////
+  /////////////////
+  // BLAS module //
+  /////////////////
 
-	nm_math_init_blas();
+  nm_math_init_blas();
 
-	///////////////
-	// IO module //
-	///////////////
-	nm_init_io();
+  ///////////////
+  // IO module //
+  ///////////////
+  nm_init_io();
 
-	/////////////////////////////////////////////////
-	// Force compilation of necessary constructors //
-	/////////////////////////////////////////////////
-	nm_init_data();
+  /////////////////////////////////////////////////
+  // Force compilation of necessary constructors //
+  /////////////////////////////////////////////////
+  nm_init_data();
 }
 
 
@@ -1083,19 +1081,6 @@ static VALUE nm_complex_conjugate_bang(VALUE self) {
   return self;
 }
 
-/*
- * call-seq:
- *     complex_conjugate -> NMatrix
- *
- * Transform the matrix (non-in-place) to its complex conjugate. Only works on complex matrices.
- *
- */
-static VALUE nm_complex_conjugate(VALUE self) {
-  VALUE copy;
-  return nm_complex_conjugate_bang(nm_init_copy(copy,self));
-}
-
-
 /*
  * call-seq:
  *     __reshape!__ -> NMatrix
@@ -1231,7 +1216,7 @@ static VALUE nm_init_new_version(int argc, VALUE* argv, VALUE self) {
 
   if (!NIL_P(initial_ary)) {
 
-    if (TYPE(initial_ary) == T_ARRAY) 	v_size = RARRAY_LEN(initial_ary);
+    if (TYPE(initial_ary) == T_ARRAY)   v_size = RARRAY_LEN(initial_ary);
     else                                v_size = 1;
 
     v = interpret_initial_value(initial_ary, dtype);
@@ -1373,7 +1358,7 @@ static VALUE nm_init(int argc, VALUE* argv, VALUE nm) {
   if (argc <= 3) { // Call the new constructor unless all four arguments are given (or the 7-arg version is given)
     NM_CONSERVATIVE(nm_unregister_values(argv, argc));
     NM_CONSERVATIVE(nm_unregister_value(&nm));
-  	return nm_init_new_version(argc, argv, nm);
+    return nm_init_new_version(argc, argv, nm);
   }
 
   /* First, determine stype (dense by default) */
@@ -1413,36 +1398,36 @@ static VALUE nm_init(int argc, VALUE* argv, VALUE nm) {
   size_t init_cap = 0, init_val_len = 0;
   void* init_val  = NULL;
   if (!SYMBOL_P(argv[1+offset]) || TYPE(argv[1+offset]) == T_ARRAY) {
-  	// Initial value provided (could also be initial capacity, if yale).
+    // Initial value provided (could also be initial capacity, if yale).
 
     if (stype == nm::YALE_STORE && NM_RUBYVAL_IS_NUMERIC(argv[1+offset])) {
       init_cap = FIX2UINT(argv[1+offset]);
 
     } else {
-    	// 4: initial value / dtype
+      // 4: initial value / dtype
       init_val = interpret_initial_value(argv[1+offset], dtype);
 
-      if (TYPE(argv[1+offset]) == T_ARRAY) 	init_val_len = RARRAY_LEN(argv[1+offset]);
+      if (TYPE(argv[1+offset]) == T_ARRAY)   init_val_len = RARRAY_LEN(argv[1+offset]);
       else                                  init_val_len = 1;
     }
 
   } else {
-  	// DType is RUBYOBJ.
+    // DType is RUBYOBJ.
 
     if (stype == nm::DENSE_STORE) {
-    	/*
-    	 * No need to initialize dense with any kind of default value unless it's
-    	 * an RUBYOBJ matrix.
-    	 */
+      /*
+       * No need to initialize dense with any kind of default value unless it's
+       * an RUBYOBJ matrix.
+       */
       if (dtype == nm::RUBYOBJ) {
-      	// Pretend [nil] was passed for RUBYOBJ.
-      	init_val = NM_ALLOC(VALUE);
+        // Pretend [nil] was passed for RUBYOBJ.
+        init_val = NM_ALLOC(VALUE);
         *(VALUE*)init_val = Qnil;
 
         init_val_len = 1;
 
       } else {
-      	init_val = NULL;
+        init_val = NULL;
       }
     } else if (stype == nm::LIST_STORE) {
       init_val = NM_ALLOC_N(char, DTYPE_SIZES[dtype]);
@@ -2281,7 +2266,7 @@ static VALUE nm_xslice(int argc, VALUE* argv, void* (*slice_func)(const STORAGE*
       };
 
       if (NM_DTYPE(self) == nm::RUBYOBJ)  result = *reinterpret_cast<VALUE*>( ttable[NM_STYPE(self)](s, slice) );
-      else                                result = rubyobj_from_cval( ttable[NM_STYPE(self)](s, slice), NM_DTYPE(self) ).rval;
+      else                                result = nm::rubyobj_from_cval( ttable[NM_STYPE(self)](s, slice), NM_DTYPE(self) ).rval;
 
     } else {
 
@@ -2471,9 +2456,9 @@ static VALUE noncom_elementwise_op(nm::noncom_ewop_t op, VALUE self, VALUE other
         sym = "__list_elementwise_" + nm::NONCOM_EWOP_NAMES[op] + "__";
         break;
       default:
-	NM_CONSERVATIVE(nm_unregister_value(&self));
-	NM_CONSERVATIVE(nm_unregister_value(&other));
-	rb_raise(rb_eNotImpError, "unknown storage type requested element-wise operation");
+  NM_CONSERVATIVE(nm_unregister_value(&self));
+  NM_CONSERVATIVE(nm_unregister_value(&other));
+  rb_raise(rb_eNotImpError, "unknown storage type requested element-wise operation");
       }
       NM_CONSERVATIVE(nm_unregister_value(&self));
       NM_CONSERVATIVE(nm_unregister_value(&other));
@@ -2645,13 +2630,13 @@ nm::dtype_t nm_dtype_guess(VALUE v) {
 #endif
 
   case T_ARRAY:
-  	/*
-  	 * May be passed for dense -- for now, just look at the first element.
+    /*
+     * May be passed for dense -- for now, just look at the first element.
      *
-  	 * TODO: Look at entire array for most specific type.
-  	 */
+     * TODO: Look at entire array for most specific type.
+     */
 
-    return nm_dtype_guess(RARRAY_PTR(v)[0]);
+    return nm_dtype_guess(RARRAY_AREF(v, 0));
 
   default:
     RB_P(v);
@@ -2772,30 +2757,30 @@ static nm::dtype_t interpret_dtype(int argc, VALUE* argv, nm::stype_t stype) {
   int offset;
 
   switch (argc) {
-  	case 1:
-  		offset = 0;
-  		break;
+    case 1:
+      offset = 0;
+      break;
 
-  	case 2:
-  		offset = 1;
-  		break;
+    case 2:
+      offset = 1;
+      break;
 
-  	default:
-  		rb_raise(rb_eArgError, "Need an initial value or a dtype.");
-  		break;
+    default:
+      rb_raise(rb_eArgError, "Need an initial value or a dtype.");
+      break;
   }
 
   if (SYMBOL_P(argv[offset])) {
-  	return nm_dtype_from_rbsymbol(argv[offset]);
+    return nm_dtype_from_rbsymbol(argv[offset]);
 
   } else if (TYPE(argv[offset]) == T_STRING) {
-  	return nm_dtype_from_rbstring(StringValue(argv[offset]));
+    return nm_dtype_from_rbstring(StringValue(argv[offset]));
 
   } else if (stype == nm::YALE_STORE) {
-  	rb_raise(rb_eArgError, "Yale storage class requires a dtype.");
+    rb_raise(rb_eArgError, "Yale storage class requires a dtype.");
 
   } else {
-  	return nm_dtype_guess(argv[0]);
+    return nm_dtype_guess(argv[0]);
   }
 }
 
@@ -2809,15 +2794,15 @@ static void* interpret_initial_value(VALUE arg, nm::dtype_t dtype) {
   void* init_val;
 
   if (TYPE(arg) == T_ARRAY) {
-  	// Array
+    // Array
     init_val = NM_ALLOC_N(char, DTYPE_SIZES[dtype] * RARRAY_LEN(arg));
     NM_CHECK_ALLOC(init_val);
     for (index = 0; index < RARRAY_LEN(arg); ++index) {
-    	rubyval_to_cval(RARRAY_PTR(arg)[index], dtype, (char*)init_val + (index * DTYPE_SIZES[dtype]));
+      rubyval_to_cval(RARRAY_AREF(arg, index), dtype, (char*)init_val + (index * DTYPE_SIZES[dtype]));
     }
 
   } else {
-  	// Single value
+    // Single value
     init_val = rubyobj_to_cval(arg, dtype);
   }
 
@@ -2840,7 +2825,7 @@ static size_t* interpret_shape(VALUE arg, size_t* dim) {
     shape = NM_ALLOC_N(size_t, *dim);
 
     for (size_t index = 0; index < *dim; ++index) {
-      shape[index] = FIX2UINT( RARRAY_PTR(arg)[index] );
+      shape[index] = FIX2UINT( RARRAY_AREF(arg, index) );
     }
 
   } else if (FIXNUM_P(arg)) {
@@ -2864,13 +2849,13 @@ static size_t* interpret_shape(VALUE arg, size_t* dim) {
  */
 static nm::stype_t interpret_stype(VALUE arg) {
   if (SYMBOL_P(arg)) {
-  	return nm_stype_from_rbsymbol(arg);
+    return nm_stype_from_rbsymbol(arg);
 
   } else if (TYPE(arg) == T_STRING) {
-  	return nm_stype_from_rbstring(StringValue(arg));
+    return nm_stype_from_rbstring(StringValue(arg));
 
   } else {
-  	rb_raise(rb_eArgError, "Expected storage type");
+    rb_raise(rb_eArgError, "Expected storage type");
   }
 }
 
@@ -3062,7 +3047,7 @@ static VALUE nm_det_exact(VALUE self) {
   if (dtype == nm::RUBYOBJ) {
     nm_register_values(reinterpret_cast<VALUE*>(result), 1);
   }
-  VALUE to_return = rubyobj_from_cval(result, NM_DTYPE(self)).rval;
+  VALUE to_return = nm::rubyobj_from_cval(result, NM_DTYPE(self)).rval;
   if (dtype == nm::RUBYOBJ) {
     nm_unregister_values(reinterpret_cast<VALUE*>(result), 1);
   }
@@ -3116,14 +3101,14 @@ VALUE rb_nmatrix_dense_create(nm::dtype_t dtype, size_t* shape, size_t dim, void
 
   // Do not allow a dim of 1. Treat it as a column or row matrix.
   if (dim == 1) {
-    nm_dim				= 2;
-    shape_copy		= NM_ALLOC_N(size_t, nm_dim);
-    shape_copy[0]	= shape[0];
-    shape_copy[1]	= 1;
+    nm_dim        = 2;
+    shape_copy    = NM_ALLOC_N(size_t, nm_dim);
+    shape_copy[0]  = shape[0];
+    shape_copy[1]  = 1;
 
   } else {
-    nm_dim			= dim;
-    shape_copy	= NM_ALLOC_N(size_t, nm_dim);
+    nm_dim      = dim;
+    shape_copy  = NM_ALLOC_N(size_t, nm_dim);
     memcpy(shape_copy, shape, sizeof(size_t)*nm_dim);
   }