nmatrix 0.0.9 → 0.1.0.rc1

data/ext/nmatrix/nm_memory.h

@@ -0,0 +1,60 @@
+/////////////////////////////////////////////////////////////////////
+// = NMatrix
+//
+// A linear algebra library for scientific computation in Ruby.
+// NMatrix is part of SciRuby.
+//
+// NMatrix was originally inspired by and derived from NArray, by
+// Masahiro Tanaka: http://narray.rubyforge.org
+//
+// == Copyright Information
+//
+// 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.
+//
+// == Contributing
+//
+// By contributing source code to SciRuby, you agree to be bound by
+// our Contributor Agreement:
+//
+// * https://github.com/SciRuby/sciruby/wiki/Contributor-Agreement
+//
+// == nm_memory.h
+//
+// Macros for memory allocation and freeing
+
+/**
+ * We define these macros, which just call the ruby ones, as this makes 
+ * debugging memory issues (particularly those involving interaction with
+ * the ruby GC) easier, as it's posssible to add debugging code temporarily.
+ */
+#ifndef __NM_MEMORY_H__
+#define __NM_MEMORY_H__
+
+#include <ruby.h>
+
+#define NM_ALLOC(type) (ALLOC(type))
+
+#define NM_ALLOC_N(type, n) (ALLOC_N(type, n))
+
+#define NM_REALLOC_N(var, type, n) (REALLOC_N(var, type, n))
+
+#define NM_ALLOCA_N(type, n) (ALLOCA_N(type, n))
+
+#define NM_FREE(var) (xfree(var))
+
+#define NM_ALLOC_NONRUBY(type) ((type*) malloc(sizeof(type)))
+
+//Defines whether to do conservative gc registrations, i.e. those
+//registrations that we're not that sure are necessary.
+//#define NM_GC_CONSERVATIVE
+
+#ifdef NM_GC_CONSERVATIVE
+#define NM_CONSERVATIVE(statement) (statement)
+#else
+#define NM_CONSERVATIVE(statement)
+#endif //NM_GC_CONSERVATIVE
+
+#endif

data/ext/nmatrix/nmatrix.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.
 //
@@ -31,12 +31,19 @@
  * Standard Includes
  */
 
-#include <cblas.h>
-#ifdef HAVE_CLAPACK_H
 extern "C" {
+#if defined HAVE_CBLAS_H
+  #include <cblas.h>
+#elif defined HAVE_ATLAS_CBLAS_H
+  #include <atlas/cblas.h>
+#endif
+
+#if defined HAVE_CLAPACK_H
   #include <clapack.h>
-}
+#elif defined HAVE_ATLAS_CLAPACK_H
+  #include <atlas/clapack.h>
 #endif
+}
 
 #include <ruby.h>
 #include <algorithm> // std::min
@@ -52,7 +59,7 @@ extern "C" {
 #include "math/math.h"
 #include "util/io.h"
 #include "storage/storage.h"
-#include "storage/list.h"
+#include "storage/list/list.h"
 #include "storage/yale/yale.h"
 
 #include "nmatrix.h"
@@ -75,47 +82,6 @@ extern "C" {
 
 namespace nm {
 
-  /*
-   * Read the shape from a matrix storage file, and ignore any padding.
-   *
-   * shape should already be allocated before calling this.
-   */
-  void read_padded_shape(std::ifstream& f, size_t dim, size_t* shape) {
-    size_t bytes_read = 0;
-
-    // Read shape
-    for (size_t i = 0; i < dim; ++i) {
-      IType s;
-      f.read(reinterpret_cast<char*>(&s), sizeof(IType));
-      shape[i] = s;
-
-      bytes_read += sizeof(IType);
-    }
-
-    // Ignore padding
-    f.ignore(bytes_read % 8);
-  }
-
-  void write_padded_shape(std::ofstream& f, size_t dim, size_t* shape) {
-    size_t bytes_written = 0;
-
-    // Write shape
-    for (size_t i = 0; i < dim; ++i) {
-      IType s = shape[i];
-      f.write(reinterpret_cast<const char*>(&s), sizeof(IType));
-
-      bytes_written += sizeof(IType);
-    }
-
-    // Pad with zeros
-    while (bytes_written % 8) {
-      IType zero = 0;
-      f.write(reinterpret_cast<const char*>(&zero), sizeof(IType));
-
-      bytes_written += sizeof(IType);
-    }
-  }
-
   /*
    * This function is pulled out separately so it can be called for hermitian matrix writing, which also uses it.
    */

data/ext/nmatrix/nmatrix.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.
 //
@@ -53,6 +53,8 @@
 	#endif
 #endif
 
+#include "nm_memory.h"
+
 /*
  * Macros
  */
@@ -113,21 +115,27 @@
    *      return enumerator_init(enumerator_allocate(rb_cEnumerator), obj, meth, argc, argv);
    *    }
    */
+
+//opening portion -- this allows unregistering any objects in use before returning
+ #define RETURN_SIZED_ENUMERATOR_PRE do { \
+   if (!rb_block_given_p()) {
+
+//remaining portion
  #ifdef RUBY_2
   #ifndef RETURN_SIZED_ENUMERATOR
    #undef RETURN_SIZED_ENUMERATOR
    // Ruby 2.0 and higher has rb_enumeratorize_with_size instead of rb_enumeratorize.
    // We want to support both in the simplest way possible.
-   #define RETURN_SIZED_ENUMERATOR(obj, argc, argv, size_fn) do {   \
-    if (!rb_block_given_p())                                        \
-      return rb_enumeratorize_with_size((obj), ID2SYM(rb_frame_this_func()), (argc), (argv), (size_fn));  \
+   #define RETURN_SIZED_ENUMERATOR(obj, argc, argv, size_fn) \
+        return rb_enumeratorize_with_size((obj), ID2SYM(rb_frame_this_func()), (argc), (argv), (size_fn));  \
+      } \
     } while (0)
   #endif
  #else
    #undef RETURN_SIZED_ENUMERATOR
-   #define RETURN_SIZED_ENUMERATOR(obj, argc, argv, size_fn) do {				            \
-    if (!rb_block_given_p())					                                              \
-      return rb_enumeratorize((obj), ID2SYM(rb_frame_this_func()), (argc), (argv));	\
+   #define RETURN_SIZED_ENUMERATOR(obj, argc, argv, size_fn) \
+        return rb_enumeratorize((obj), ID2SYM(rb_frame_this_func()), (argc), (argv));	\
+      } \
     } while (0)
  #endif
 
@@ -278,6 +286,18 @@ NM_DEF_STRUCT_PRE(NMATRIX);   // struct NMATRIX {
   NM_DECL_STRUCT(STORAGE*, storage);  // STORAGE* storage;  // Pointer to storage struct.
 NM_DEF_STRUCT_POST(NMATRIX);  // };
 
+/* Structs for dealing with VALUEs in use so that they don't get GC'd */
+
+typedef struct __NM_GC_LL_NODE {
+  VALUE* val;
+  size_t n;
+  __NM_GC_LL_NODE* next;
+} nm_gc_ll_node;
+
+typedef struct __NM_GC_HOLDER {
+  __NM_GC_LL_NODE* start;
+} nm_gc_holder;
+
 #define NM_MAX_RANK 15
 
 #define UnwrapNMatrix(obj,var)  Data_Get_Struct(obj, NMATRIX, var)
@@ -355,16 +375,21 @@ extern "C" {
 	NM_DECL_ENUM(dtype_t, nm_dtype_min(VALUE));
 
   // Non-API functions needed by other cpp files.
-	NMATRIX* nm_create(nm::stype_t stype, STORAGE* storage);
-  NMATRIX* nm_cast_with_ctype_args(NMATRIX* self, nm::stype_t new_stype, nm::dtype_t new_dtype, void* init_ptr);
+	NMATRIX* nm_create(NM_DECL_ENUM(stype_t, stype), STORAGE* storage);
+  NMATRIX* nm_cast_with_ctype_args(NMATRIX* self, NM_DECL_ENUM(stype_t, new_stype), NM_DECL_ENUM(dtype_t, new_dtype), void* init_ptr);
 	VALUE    nm_cast(VALUE self, VALUE new_stype_symbol, VALUE new_dtype_symbol, VALUE init);
 	void     nm_mark(NMATRIX* mat);
 	void     nm_delete(NMATRIX* mat);
 	void     nm_delete_ref(NMATRIX* mat);
-  void     nm_mark(NMATRIX* mat);
   void     nm_register_values(VALUE* vals, size_t n);
   void     nm_unregister_values(VALUE* vals, size_t n);
-
+  void     nm_register_value(VALUE& val);
+  void     nm_unregister_value(VALUE& val);
+  void     nm_register_storage(nm::stype_t stype, const STORAGE* storage);
+  void     nm_unregister_storage(nm::stype_t stype, const STORAGE* storage);
+  void     nm_register_nmatrix(NMATRIX* nmatrix);
+  void     nm_unregister_nmatrix(NMATRIX* nmatrix);
+  void	   nm_completely_unregister_value(VALUE& val);
 #ifdef __cplusplus
 }
 #endif

data/ext/nmatrix/ruby_constants.cpp

@@ -9,8 +9,8 @@
 //
 // == Copyright Information
 //
-// SciRuby is Copyright (c) 2010 - 2012, Ruby Science Foundation
-// NMatrix is Copyright (c) 2012, 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.
 //
@@ -89,6 +89,8 @@ VALUE cNMatrix,
 			cNMatrix_YaleFunctions,
 			cNMatrix_BLAS,
 			cNMatrix_LAPACK,
+
+      cNMatrix_GC_holder,
 			
 			nm_eDataTypeError,
       nm_eConvergenceError,

data/ext/nmatrix/ruby_constants.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.
 //
@@ -91,6 +91,8 @@ extern VALUE	cNMatrix,
 							cNMatrix_YaleFunctions,
 							cNMatrix_BLAS,
 							cNMatrix_LAPACK,
+
+							cNMatrix_GC_holder,
 			
 							nm_eDataTypeError,
               nm_eConvergenceError,

data/ext/nmatrix/ruby_nmatrix.c

@@ -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.
 //
@@ -51,6 +51,7 @@ static VALUE nm_capacity(VALUE self);
 static VALUE nm_each_with_indices(VALUE nmatrix);
 static VALUE nm_each_stored_with_indices(VALUE nmatrix);
 static VALUE nm_each_ordered_stored_with_indices(VALUE nmatrix);
+static VALUE nm_map_stored(VALUE nmatrix);
 
 static SLICE* get_slice(size_t dim, int argc, VALUE* arg, size_t* shape);
 static VALUE nm_xslice(int argc, VALUE* argv, void* (*slice_func)(const STORAGE*, SLICE*), void (*delete_func)(NMATRIX*), VALUE self);
@@ -74,10 +75,27 @@ static VALUE nm_ew_##name(VALUE left_val, VALUE right_val) {  \
   return elementwise_op(nm::EW_##oper, left_val, right_val);  \
 }
 
+#define DEF_UNARY_RUBY_ACCESSOR(oper, name)                 \
+static VALUE nm_unary_##name(VALUE self) {  \
+  return unary_op(nm::UNARY_##oper, self);  \
+}
+
+#define DEF_NONCOM_ELEMENTWISE_RUBY_ACCESSOR(oper, name) \
+static VALUE nm_noncom_ew_##name(int argc, VALUE* argv, VALUE self) { \
+  if (argc > 1) { \
+    return noncom_elementwise_op(nm::NONCOM_EW_##oper, self, argv[0], argv[1]); \
+  } else { \
+    return noncom_elementwise_op(nm::NONCOM_EW_##oper, self, argv[0], Qfalse); \
+  } \
+}
+
+
 /*
  * Macro declares a corresponding accessor function prototype for some element-wise operation.
  */
 #define DECL_ELEMENTWISE_RUBY_ACCESSOR(name)    static VALUE nm_ew_##name(VALUE left_val, VALUE right_val);
+#define DECL_UNARY_RUBY_ACCESSOR(name)          static VALUE nm_unary_##name(VALUE self);
+#define DECL_NONCOM_ELEMENTWISE_RUBY_ACCESSOR(name)    static VALUE nm_noncom_ew_##name(int argc, VALUE* argv, VALUE self);
 
 DECL_ELEMENTWISE_RUBY_ACCESSOR(add)
 DECL_ELEMENTWISE_RUBY_ACCESSOR(subtract)
@@ -91,8 +109,36 @@ DECL_ELEMENTWISE_RUBY_ACCESSOR(lt)
 DECL_ELEMENTWISE_RUBY_ACCESSOR(gt)
 DECL_ELEMENTWISE_RUBY_ACCESSOR(leq)
 DECL_ELEMENTWISE_RUBY_ACCESSOR(geq)
+DECL_UNARY_RUBY_ACCESSOR(sin)
+DECL_UNARY_RUBY_ACCESSOR(cos)
+DECL_UNARY_RUBY_ACCESSOR(tan)
+DECL_UNARY_RUBY_ACCESSOR(asin)
+DECL_UNARY_RUBY_ACCESSOR(acos)
+DECL_UNARY_RUBY_ACCESSOR(atan)
+DECL_UNARY_RUBY_ACCESSOR(sinh)
+DECL_UNARY_RUBY_ACCESSOR(cosh)
+DECL_UNARY_RUBY_ACCESSOR(tanh)
+DECL_UNARY_RUBY_ACCESSOR(asinh)
+DECL_UNARY_RUBY_ACCESSOR(acosh)
+DECL_UNARY_RUBY_ACCESSOR(atanh)
+DECL_UNARY_RUBY_ACCESSOR(exp)
+DECL_UNARY_RUBY_ACCESSOR(log2)
+DECL_UNARY_RUBY_ACCESSOR(log10)
+DECL_UNARY_RUBY_ACCESSOR(sqrt)
+DECL_UNARY_RUBY_ACCESSOR(erf)
+DECL_UNARY_RUBY_ACCESSOR(erfc)
+DECL_UNARY_RUBY_ACCESSOR(cbrt)
+DECL_UNARY_RUBY_ACCESSOR(gamma)
+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
+static VALUE nm_unary_log(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);
+static VALUE noncom_elementwise_op(nm::noncom_ewop_t op, VALUE self, VALUE other, VALUE orderflip);
 
 static VALUE nm_symmetric(VALUE self);
 static VALUE nm_hermitian(VALUE self);
@@ -144,6 +190,12 @@ void Init_nmatrix() {
 	 */
 	nm_eStorageTypeError = rb_define_class("StorageTypeError", rb_eStandardError);
 
+  /*
+   * Class that holds values in use by the C code.
+   */
+  cNMatrix_GC_holder = rb_define_class("NMGCHolder", rb_cObject);
+
+
 	///////////////////
 	// Class Methods //
 	///////////////////
@@ -169,7 +221,7 @@ void Init_nmatrix() {
 	rb_define_method(cNMatrix, "write", (METHOD)nm_write, -1);
 
 	// Technically, the following function is a copy constructor.
-	rb_define_method(cNMatrix, "transpose", (METHOD)nm_init_transposed, 0);
+	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);
@@ -198,8 +250,10 @@ void Init_nmatrix() {
 	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);
 	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);
@@ -214,6 +268,32 @@ void Init_nmatrix() {
   rb_define_method(cNMatrix, "**",    (METHOD)nm_ew_power,    1);
   rb_define_method(cNMatrix, "%",     (METHOD)nm_ew_mod,      1);
 
+  rb_define_method(cNMatrix, "atan2", (METHOD)nm_noncom_ew_atan2, -1);
+  rb_define_method(cNMatrix, "ldexp", (METHOD)nm_noncom_ew_ldexp, -1);
+  rb_define_method(cNMatrix, "hypot", (METHOD)nm_noncom_ew_hypot, -1);
+
+  rb_define_method(cNMatrix, "sin",   (METHOD)nm_unary_sin,   0);
+  rb_define_method(cNMatrix, "cos",   (METHOD)nm_unary_cos,   0);
+  rb_define_method(cNMatrix, "tan",   (METHOD)nm_unary_tan,   0);
+  rb_define_method(cNMatrix, "asin",  (METHOD)nm_unary_asin,  0);
+  rb_define_method(cNMatrix, "acos",  (METHOD)nm_unary_acos,  0);
+  rb_define_method(cNMatrix, "atan",  (METHOD)nm_unary_atan,  0);
+  rb_define_method(cNMatrix, "sinh",  (METHOD)nm_unary_sinh,  0);
+  rb_define_method(cNMatrix, "cosh",  (METHOD)nm_unary_cosh,  0);
+  rb_define_method(cNMatrix, "tanh",  (METHOD)nm_unary_tanh,  0);
+  rb_define_method(cNMatrix, "asinh", (METHOD)nm_unary_asinh, 0);
+  rb_define_method(cNMatrix, "acosh", (METHOD)nm_unary_acosh, 0);
+  rb_define_method(cNMatrix, "atanh", (METHOD)nm_unary_atanh, 0);
+  rb_define_method(cNMatrix, "exp",   (METHOD)nm_unary_exp,   0);
+  rb_define_method(cNMatrix, "log2",  (METHOD)nm_unary_log2,  0);
+  rb_define_method(cNMatrix, "log10", (METHOD)nm_unary_log10, 0);
+  rb_define_method(cNMatrix, "sqrt",  (METHOD)nm_unary_sqrt,  0);
+  rb_define_method(cNMatrix, "erf",   (METHOD)nm_unary_erf,   0);
+  rb_define_method(cNMatrix, "erfc",  (METHOD)nm_unary_erfc,  0);
+  rb_define_method(cNMatrix, "cbrt",  (METHOD)nm_unary_cbrt,  0);
+  rb_define_method(cNMatrix, "gamma", (METHOD)nm_unary_gamma, 0);
+  rb_define_method(cNMatrix, "log",   (METHOD)nm_unary_log,  -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);
@@ -283,9 +363,9 @@ void Init_nmatrix() {
  * 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);
+  SLICE* slice = NM_ALLOC(SLICE);
+  slice->coords = NM_ALLOC_N(size_t, dim);
+  slice->lengths = NM_ALLOC_N(size_t, dim);
   return slice;
 }
 
@@ -294,9 +374,9 @@ static SLICE* alloc_slice(size_t dim) {
  * Slice destructor.
  */
 static void free_slice(SLICE* slice) {
-  xfree(slice->coords);
-  xfree(slice->lengths);
-  xfree(slice);
+  NM_FREE(slice->coords);
+  NM_FREE(slice->lengths);
+  NM_FREE(slice);
 }
 
 
@@ -304,7 +384,7 @@ static void free_slice(SLICE* slice) {
  * Allocator.
  */
 static VALUE nm_alloc(VALUE klass) {
-  NMATRIX* mat = ALLOC(NMATRIX);
+  NMATRIX* mat = NM_ALLOC(NMATRIX);
   mat->storage = NULL;
 
   // DO NOT MARK This STRUCT. It has no storage allocated, and no stype, so mark will do an invalid something.
@@ -320,6 +400,7 @@ static VALUE nm_alloc(VALUE klass) {
  * just return the original matrix's capacity.
  */
 static VALUE nm_capacity(VALUE self) {
+  NM_CONSERVATIVE(nm_register_value(self));
   VALUE cap;
 
   switch(NM_STYPE(self)) {
@@ -336,9 +417,11 @@ static VALUE nm_capacity(VALUE self) {
     break;
 
   default:
+    NM_CONSERVATIVE(nm_unregister_value(self));
     rb_raise(nm_eStorageTypeError, "unrecognized stype in nm_capacity()");
   }
 
+  NM_CONSERVATIVE(nm_unregister_value(self));
   return cap;
 }
 
@@ -363,7 +446,7 @@ void nm_delete(NMATRIX* mat) {
   };
   ttable[mat->stype](mat->storage);
 
-  xfree(mat);
+  NM_FREE(mat);
 }
 
 /*
@@ -377,33 +460,186 @@ void nm_delete_ref(NMATRIX* mat) {
   };
   ttable[mat->stype](mat->storage);
 
-  xfree(mat);
+  NM_FREE(mat);
+}
+
+
+/**
+ * These variables hold a linked list of VALUEs that are registered to be in
+ * use by nmatrix so that they can be marked when GC runs.
+ */
+static VALUE* gc_value_holder = NULL;
+static nm_gc_holder* gc_value_holder_struct = NULL;
+static nm_gc_holder* allocated_pool = NULL; // an object pool for linked list nodes; using pooling is in some cases a substantial performance improvement
+
+/**
+ * GC Marking function for the values that have been registered.
+ */
+static void __nm_mark_value_container(nm_gc_holder* gc_value_holder_struct) {
+  if (gc_value_holder_struct && gc_value_holder_struct->start) {
+    nm_gc_ll_node* curr = gc_value_holder_struct->start;
+    while (curr) {
+      rb_gc_mark_locations(curr->val, curr->val + curr->n);
+      curr = curr->next;
+    }
+  }
+}
+
+/**
+ * Initilalizes the linked list of in-use VALUEs if it hasn't been done
+ * already.
+ */
+static void __nm_initialize_value_container() {
+  if (gc_value_holder == NULL) {
+    gc_value_holder_struct = NM_ALLOC_NONRUBY(nm_gc_holder);
+    allocated_pool = NM_ALLOC_NONRUBY(nm_gc_holder);
+    gc_value_holder = NM_ALLOC_NONRUBY(VALUE);
+    gc_value_holder_struct->start = NULL;
+    allocated_pool->start = NULL;
+    *gc_value_holder = Data_Wrap_Struct(cNMatrix_GC_holder, __nm_mark_value_container, NULL, gc_value_holder_struct);
+    rb_global_variable(gc_value_holder); 
+  }
 }
 
 /*
- * Register the addresses of an array of VALUEs with the gc to avoid collection
+ * Register an array of VALUEs to avoid their collection
  * while using them internally.
  */
 void nm_register_values(VALUE* values, size_t n) {
+  if (!gc_value_holder_struct)
+    __nm_initialize_value_container();
   if (values) {
-    for (size_t i = n; i-- > 0;) {
-      rb_gc_register_address(values + i);
+    nm_gc_ll_node* to_insert = NULL;
+    if (allocated_pool->start) {
+      to_insert = allocated_pool->start;
+      allocated_pool->start = to_insert->next;
+    } else {
+      to_insert = NM_ALLOC_NONRUBY(nm_gc_ll_node);
     }
+    to_insert->val = values;
+    to_insert->n = n;
+    to_insert->next = gc_value_holder_struct->start;
+    gc_value_holder_struct->start = to_insert;
   }
 }
 
 /*
- * Unregister the addresses of an array of VALUEs with the gc to allow normal
+ * Unregister an array of VALUEs with the gc to allow normal
  * garbage collection to occur again.
  */
 void nm_unregister_values(VALUE* values, size_t n) {
   if (values) {
-    for (size_t i = n; i-- > 0;) {
-      rb_gc_unregister_address(values + i);
+    if (gc_value_holder_struct) {
+      nm_gc_ll_node* curr = gc_value_holder_struct->start;
+      nm_gc_ll_node* last = NULL;
+      while (curr) {
+        if (curr->val == values) {
+          if (last) {
+            last->next = curr->next;
+          } else {
+            gc_value_holder_struct->start = curr->next;
+          }
+          curr->next = allocated_pool->start;
+          curr->val = NULL;
+          curr->n = 0;
+          allocated_pool->start = curr;
+          break;
+        }
+        last = curr;
+        curr = curr->next;
+      }
+    }
+  }
+}
+
+/**
+ * Register a single VALUE as in use to avoid garbage collection.
+ */
+void nm_register_value(VALUE& val) {
+  nm_register_values(&val, 1);
+}
+
+/**
+ * Unregister a single VALUE to allow normal garbage collection.
+ */
+void nm_unregister_value(VALUE& val) {
+  nm_unregister_values(&val, 1);
+}
+
+/**
+ * Removes all instances of a single VALUE in the gc list.  This can be
+ * dangerous.  Primarily used when something is about to be
+ * freed and replaced so that and residual registrations won't access after
+ * free.
+ **/
+void nm_completely_unregister_value(VALUE& val) {
+  if (gc_value_holder_struct) {
+    nm_gc_ll_node* curr = gc_value_holder_struct->start;
+    nm_gc_ll_node* last = NULL;
+    while (curr) {
+      if (curr->val == &val) {
+	if (last) {
+	  last->next = curr->next;
+	} else {
+	  gc_value_holder_struct->start = curr->next;
+	}
+	nm_gc_ll_node* temp_next = curr->next;
+	curr->next = allocated_pool->start;
+	curr->val = NULL;
+	curr->n = 0;
+	allocated_pool->start = curr;
+	curr = temp_next;
+      } else {
+	last = curr;
+	curr = curr->next;
+      }
     }
   }
 }
 
+
+
+/**
+ * Register a STORAGE struct of the supplied stype to avoid garbage collection
+ * of its internals.
+ *
+ * Delegates to the storage-specific methods.  They will check dtype and ignore
+ * non-rubyobject dtypes, so it's safe to pass any storage in.
+ */
+void nm_register_storage(nm::stype_t stype, const STORAGE* storage) {
+  STYPE_REGISTER_TABLE(ttable);
+  ttable[stype](storage);
+}
+
+/**
+ * Unregister a STORAGE struct of the supplied stype to allow normal garbage collection
+ * of its internals.
+ *
+ * Delegates to the storage-specific methods.  They will check dtype and ignore
+ * non-rubyobject dtypes, so it's safe to pass any storage in.
+ *
+ */
+void nm_unregister_storage(nm::stype_t stype, const STORAGE* storage) {
+  STYPE_UNREGISTER_TABLE(ttable);
+  ttable[stype](storage);
+}
+
+/**
+ * Registers an NMATRIX struct to avoid garbage collection of its internals.
+ */
+void nm_register_nmatrix(NMATRIX* nmatrix) {
+  if (nmatrix)
+    nm_register_storage(nmatrix->stype, nmatrix->storage);
+}
+
+/**
+ * Unregisters an NMATRIX struct to avoid garbage collection of its internals.
+ */
+void nm_unregister_nmatrix(NMATRIX* nmatrix) {
+  if (nmatrix)
+    nm_unregister_storage(nmatrix->stype, nmatrix->storage);
+}
+
 /*
  * call-seq:
  *     dtype -> Symbol
@@ -427,7 +663,6 @@ static VALUE nm_dtype(VALUE self) {
  * This is a singleton method on NMatrix, e.g., NMatrix.upcast(:int32, :int64)
  */
 static VALUE nm_upcast(VALUE self, VALUE t1, VALUE t2) {
-
   nm::dtype_t d1    = nm_dtype_from_rbsymbol(t1),
               d2    = nm_dtype_from_rbsymbol(t2);
 
@@ -462,18 +697,26 @@ static VALUE nm_default_value(VALUE self) {
  * Iterate over all entries of any matrix in standard storage order (as with #each), and include the indices.
  */
 static VALUE nm_each_with_indices(VALUE nmatrix) {
-  volatile VALUE nm = nmatrix;
+  NM_CONSERVATIVE(nm_register_value(nmatrix));
+  VALUE to_return = Qnil;
 
-  switch(NM_STYPE(nm)) {
+  switch(NM_STYPE(nmatrix)) {
   case nm::YALE_STORE:
-    return nm_yale_each_with_indices(nm);
+    to_return = nm_yale_each_with_indices(nmatrix);
+    break;
   case nm::DENSE_STORE:
-    return nm_dense_each_with_indices(nm);
+    to_return = nm_dense_each_with_indices(nmatrix);
+    break;
   case nm::LIST_STORE:
-    return nm_list_each_with_indices(nm, false);
+    to_return = nm_list_each_with_indices(nmatrix, false);
+    break;
   default:
+    NM_CONSERVATIVE(nm_unregister_value(nmatrix));
     rb_raise(nm_eDataTypeError, "Not a proper storage type");
   }
+
+  NM_CONSERVATIVE(nm_unregister_value(nmatrix));
+  return to_return;
 }
 
 /*
@@ -485,21 +728,60 @@ static VALUE nm_each_with_indices(VALUE nmatrix) {
  * i, j, ..., and the entry itself.
  */
 static VALUE nm_each_stored_with_indices(VALUE nmatrix) {
-  volatile VALUE nm = nmatrix;
+  NM_CONSERVATIVE(nm_register_value(nmatrix));
+  VALUE to_return = Qnil;
 
-  switch(NM_STYPE(nm)) {
+  switch(NM_STYPE(nmatrix)) {
   case nm::YALE_STORE:
-    return nm_yale_each_stored_with_indices(nm);
+    to_return = nm_yale_each_stored_with_indices(nmatrix);
+    break;
   case nm::DENSE_STORE:
-    return nm_dense_each_with_indices(nm);
+    to_return = nm_dense_each_with_indices(nmatrix);
+    break;
   case nm::LIST_STORE:
-    return nm_list_each_with_indices(nm, true);
+    to_return = nm_list_each_with_indices(nmatrix, true);
+    break;
   default:
+    NM_CONSERVATIVE(nm_unregister_value(nmatrix));
     rb_raise(nm_eDataTypeError, "Not a proper storage type");
   }
+
+  NM_CONSERVATIVE(nm_unregister_value(nmatrix));
+  return to_return;
 }
 
 
+/*
+ * call-seq:
+ *     map_stored -> Enumerator
+ *
+ * Iterate over the stored entries of any matrix. For dense and yale, this iterates over non-zero
+ * entries; for list, this iterates over non-default entries. Yields dim+1 values for each entry:
+ * i, j, ..., and the entry itself.
+ */
+static VALUE nm_map_stored(VALUE nmatrix) {
+  NM_CONSERVATIVE(nm_register_value(nmatrix));
+  VALUE to_return = Qnil;
+
+  switch(NM_STYPE(nmatrix)) {
+  case nm::YALE_STORE:
+    to_return = nm_yale_map_stored(nmatrix);
+    break;
+  case nm::DENSE_STORE:
+    to_return = nm_dense_map(nmatrix);
+    break;
+  case nm::LIST_STORE:
+    to_return = nm_list_map_stored(nmatrix, Qnil);
+    break;
+  default:
+    NM_CONSERVATIVE(nm_unregister_value(nmatrix));
+    rb_raise(nm_eDataTypeError, "Not a proper storage type");
+  }
+
+  NM_CONSERVATIVE(nm_unregister_value(nmatrix));
+  return to_return;
+}
+
 /*
  * call-seq:
  *     each_ordered_stored_with_indices -> Enumerator
@@ -508,18 +790,26 @@ static VALUE nm_each_stored_with_indices(VALUE nmatrix) {
  * than storage ordering, which only matters if your matrix is Yale.
  */
 static VALUE nm_each_ordered_stored_with_indices(VALUE nmatrix) {
-  volatile VALUE nm = nmatrix;
+  NM_CONSERVATIVE(nm_register_value(nmatrix));
+  VALUE to_return = Qnil;
 
-  switch(NM_STYPE(nm)) {
+  switch(NM_STYPE(nmatrix)) {
   case nm::YALE_STORE:
-    return nm_yale_each_ordered_stored_with_indices(nm);
+    to_return = nm_yale_each_ordered_stored_with_indices(nmatrix);
+    break;
   case nm::DENSE_STORE:
-    return nm_dense_each_with_indices(nm);
+    to_return = nm_dense_each_with_indices(nmatrix);
+    break;
   case nm::LIST_STORE:
-    return nm_list_each_with_indices(nm, true);
+    to_return = nm_list_each_with_indices(nmatrix, true);
+    break;
   default:
+    NM_CONSERVATIVE(nm_unregister_value(nmatrix));
     rb_raise(nm_eDataTypeError, "Not a proper storage type");
   }
+
+  NM_CONSERVATIVE(nm_unregister_value(nmatrix));
+  return to_return;
 }
 
 
@@ -530,8 +820,13 @@ static VALUE nm_each_ordered_stored_with_indices(VALUE nmatrix) {
  * For elementwise, use =~ instead.
  *
  * This method will raise an exception if dimensions do not match.
+ *
+ * When stypes differ, this function calls a protected Ruby method.
  */
 static VALUE nm_eqeq(VALUE left, VALUE right) {
+  NM_CONSERVATIVE(nm_register_value(left));
+  NM_CONSERVATIVE(nm_register_value(right));
+
   NMATRIX *l, *r;
 
   CheckNMatrixType(left);
@@ -540,23 +835,35 @@ static VALUE nm_eqeq(VALUE left, VALUE right) {
   UnwrapNMatrix(left, l);
   UnwrapNMatrix(right, r);
 
-  if (l->stype != r->stype)
-    rb_raise(rb_eNotImpError, "comparison between different matrix stypes not yet implemented");
-
   bool result = false;
 
-  switch(l->stype) {
-  case nm::DENSE_STORE:
-    result = nm_dense_storage_eqeq(l->storage, r->storage);
-    break;
-  case nm::LIST_STORE:
-    result = nm_list_storage_eqeq(l->storage, r->storage);
-    break;
-  case nm::YALE_STORE:
-    result = nm_yale_storage_eqeq(l->storage, r->storage);
-    break;
+  if (l->stype != r->stype) { // DIFFERENT STYPES
+
+    if (l->stype == nm::DENSE_STORE)
+      result = rb_funcall(left, rb_intern("dense_eql_sparse?"), 1, right);
+    else if (r->stype == nm::DENSE_STORE)
+      result = rb_funcall(right, rb_intern("dense_eql_sparse?"), 1, left);
+    else
+      result = rb_funcall(left, rb_intern("sparse_eql_sparse?"), 1, right);
+
+  } else {
+
+    switch(l->stype) {       // SAME STYPES
+    case nm::DENSE_STORE:
+      result = nm_dense_storage_eqeq(l->storage, r->storage);
+      break;
+    case nm::LIST_STORE:
+      result = nm_list_storage_eqeq(l->storage, r->storage);
+      break;
+    case nm::YALE_STORE:
+      result = nm_yale_storage_eqeq(l->storage, r->storage);
+      break;
+    }
   }
 
+  NM_CONSERVATIVE(nm_unregister_value(left));
+  NM_CONSERVATIVE(nm_unregister_value(right));
+
   return result ? Qtrue : Qfalse;
 }
 
@@ -573,6 +880,60 @@ DEF_ELEMENTWISE_RUBY_ACCESSOR(GEQ, geq)
 DEF_ELEMENTWISE_RUBY_ACCESSOR(LT, lt)
 DEF_ELEMENTWISE_RUBY_ACCESSOR(GT, gt)
 
+DEF_UNARY_RUBY_ACCESSOR(SIN, sin)
+DEF_UNARY_RUBY_ACCESSOR(COS, cos)
+DEF_UNARY_RUBY_ACCESSOR(TAN, tan)
+DEF_UNARY_RUBY_ACCESSOR(ASIN, asin)
+DEF_UNARY_RUBY_ACCESSOR(ACOS, acos)
+DEF_UNARY_RUBY_ACCESSOR(ATAN, atan)
+DEF_UNARY_RUBY_ACCESSOR(SINH, sinh)
+DEF_UNARY_RUBY_ACCESSOR(COSH, cosh)
+DEF_UNARY_RUBY_ACCESSOR(TANH, tanh)
+DEF_UNARY_RUBY_ACCESSOR(ASINH, asinh)
+DEF_UNARY_RUBY_ACCESSOR(ACOSH, acosh)
+DEF_UNARY_RUBY_ACCESSOR(ATANH, atanh)
+DEF_UNARY_RUBY_ACCESSOR(EXP, exp)
+DEF_UNARY_RUBY_ACCESSOR(LOG2, log2)
+DEF_UNARY_RUBY_ACCESSOR(LOG10, log10)
+DEF_UNARY_RUBY_ACCESSOR(SQRT, sqrt)
+DEF_UNARY_RUBY_ACCESSOR(ERF, erf)
+DEF_UNARY_RUBY_ACCESSOR(ERFC, erfc)
+DEF_UNARY_RUBY_ACCESSOR(CBRT, cbrt)
+DEF_UNARY_RUBY_ACCESSOR(GAMMA, gamma)
+
+DEF_NONCOM_ELEMENTWISE_RUBY_ACCESSOR(ATAN2, atan2)
+DEF_NONCOM_ELEMENTWISE_RUBY_ACCESSOR(LDEXP, ldexp)
+DEF_NONCOM_ELEMENTWISE_RUBY_ACCESSOR(HYPOT, hypot)
+
+static VALUE nm_unary_log(int argc, VALUE* argv, VALUE self) {
+  NM_CONSERVATIVE(nm_register_values(argv, argc));
+  const double default_log_base = exp(1.0);
+  NMATRIX* left;
+  UnwrapNMatrix(self, left);
+  std::string sym;
+
+  switch(left->stype) {
+  case nm::DENSE_STORE:
+    sym = "__dense_unary_log__";
+    break;
+  case nm::YALE_STORE:
+    sym = "__yale_unary_log__";
+    break;
+  case nm::LIST_STORE:
+    sym = "__list_unary_log__";
+    break;
+  }
+  NM_CONSERVATIVE(nm_unregister_values(argv, argc));
+  if (argc > 0) { //supplied a base
+    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_log_base).rval);
+}
+
+//DEF_ELEMENTWISE_RUBY_ACCESSOR(ATAN2, atan2)
+//DEF_ELEMENTWISE_RUBY_ACCESSOR(LDEXP, ldexp)
+//DEF_ELEMENTWISE_RUBY_ACCESSOR(HYPOT, hypot)
+
 /*
  * call-seq:
  *     hermitian? -> Boolean
@@ -598,6 +959,7 @@ static VALUE nm_hermitian(VALUE self) {
  * Bang should imply that no copy is being made, even temporarily.
  */
 static VALUE nm_complex_conjugate_bang(VALUE self) {
+
   NMATRIX* m;
   void* elem;
   size_t size, p;
@@ -643,11 +1005,13 @@ static VALUE nm_complex_conjugate_bang(VALUE self) {
  * need to worry about deleting it.
  */
 NMATRIX* nm_create(nm::stype_t stype, STORAGE* storage) {
-  NMATRIX* mat = ALLOC(NMATRIX);
+  nm_register_storage(stype, storage);
+  NMATRIX* mat = NM_ALLOC(NMATRIX);
 
   mat->stype   = stype;
   mat->storage = storage;
 
+  nm_unregister_storage(stype, storage);
   return mat;
 }
 
@@ -655,6 +1019,8 @@ NMATRIX* nm_create(nm::stype_t stype, STORAGE* storage) {
  * @see nm_init
  */
 static VALUE nm_init_new_version(int argc, VALUE* argv, VALUE self) {
+  NM_CONSERVATIVE(nm_register_values(argv, argc));
+  NM_CONSERVATIVE(nm_register_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
@@ -676,7 +1042,9 @@ static VALUE nm_init_new_version(int argc, VALUE* argv, VALUE self) {
     }
   }
 #endif
-
+  NM_CONSERVATIVE(nm_register_value(shape_ary));
+  NM_CONSERVATIVE(nm_register_value(initial_ary));
+  NM_CONSERVATIVE(nm_register_value(hash));
   // Get the shape.
   size_t  dim;
   size_t* shape = interpret_shape(shape_ary, &dim);
@@ -692,7 +1060,9 @@ static VALUE nm_init_new_version(int argc, VALUE* argv, VALUE self) {
     dtype_sym       = rb_hash_aref(hash, ID2SYM(nm_rb_dtype));
     stype_sym       = rb_hash_aref(hash, ID2SYM(nm_rb_stype));
     capacity_num    = rb_hash_aref(hash, ID2SYM(nm_rb_capacity));
+    NM_CONSERVATIVE(nm_register_value(capacity_num));
     default_val_num = rb_hash_aref(hash, ID2SYM(nm_rb_default));
+    NM_CONSERVATIVE(nm_register_value(default_val_num));
   }
 
   //     stype ||= :dense
@@ -724,6 +1094,10 @@ static VALUE nm_init_new_version(int argc, VALUE* argv, VALUE self) {
       init = RARRAY_LEN(initial_ary) == 1 ? rubyobj_to_cval(rb_ary_entry(initial_ary, 0), dtype) : NULL;
     else
       init = rubyobj_to_cval(initial_ary, dtype);
+    
+    if (dtype == nm::RUBYOBJ) {
+      nm_register_values(reinterpret_cast<VALUE*>(init), 1);
+    }
   }
 
   // capacity = h[:capacity] || 0
@@ -732,47 +1106,55 @@ static VALUE nm_init_new_version(int argc, VALUE* argv, VALUE self) {
   }
 
   if (!NIL_P(initial_ary)) {
-    v = interpret_initial_value(initial_ary, dtype);
-
+    
     if (TYPE(initial_ary) == T_ARRAY) 	v_size = RARRAY_LEN(initial_ary);
     else                                v_size = 1;
+
+    v = interpret_initial_value(initial_ary, dtype);
+
+    if (dtype == nm::RUBYOBJ) {
+      nm_register_values(reinterpret_cast<VALUE*>(v), v_size);
+    }
   }
 
   // :object matrices MUST be initialized.
   else if (stype == nm::DENSE_STORE && dtype == nm::RUBYOBJ) {
     // Pretend [nil] was passed for RUBYOBJ.
-    v          = ALLOC(VALUE);
+    v          = NM_ALLOC(VALUE);
     *(VALUE*)v = Qnil;
 
     v_size = 1;
 
   }
 
-	NMATRIX* nmatrix;
+  NMATRIX* nmatrix;
   UnwrapNMatrix(self, nmatrix);
 
   nmatrix->stype = stype;
 
   switch (stype) {
-  	case nm::DENSE_STORE:
-  		nmatrix->storage = (STORAGE*)nm_dense_storage_create(dtype, shape, dim, v, v_size);
-  		break;
+    case nm::DENSE_STORE:
+      nmatrix->storage = (STORAGE*)nm_dense_storage_create(dtype, shape, dim, v, v_size);
+      break;
 
-  	case nm::LIST_STORE:
-  		nmatrix->storage = (STORAGE*)nm_list_storage_create(dtype, shape, dim, init);
-  		break;
+    case nm::LIST_STORE:
+      nmatrix->storage = (STORAGE*)nm_list_storage_create(dtype, shape, dim, init);
+      break;
 
-  	case nm::YALE_STORE:
-  		nmatrix->storage = (STORAGE*)nm_yale_storage_create(dtype, shape, dim, capacity);
-  		nm_yale_storage_init((YALE_STORAGE*)(nmatrix->storage), init);
-  		break;
+    case nm::YALE_STORE:
+      nmatrix->storage = (STORAGE*)nm_yale_storage_create(dtype, shape, dim, capacity);
+      nm_yale_storage_init((YALE_STORAGE*)(nmatrix->storage), init);
+      break;
   }
 
+  nm_register_storage(stype, nmatrix->storage);
+
   // If we're not creating a dense, and an initial array was provided, use that and multi-slice-set
   // to set the contents of the matrix right now.
   if (stype != nm::DENSE_STORE && v_size > 1) {
-    VALUE* slice_argv = ALLOCA_N(VALUE, dim);
-    size_t* tmp_shape = ALLOC_N(size_t, dim);
+    VALUE* slice_argv = NM_ALLOCA_N(VALUE, dim);
+    nm_register_values(slice_argv, dim);
+    size_t* tmp_shape = NM_ALLOC_N(size_t, dim);
     for (size_t m = 0; m < dim; ++m) {
       slice_argv[m] = ID2SYM(nm_rb_mul); // :* -- full range
       tmp_shape[m]  = shape[m];
@@ -780,20 +1162,47 @@ static VALUE nm_init_new_version(int argc, VALUE* argv, VALUE self) {
 
     SLICE* slice = get_slice(dim, dim, slice_argv, shape);
     // Create a temporary dense matrix and use it to do a slice assignment on self.
-    NMATRIX* tmp          = nm_create(nm::DENSE_STORE, (STORAGE*)nm_dense_storage_create(dtype, tmp_shape, dim, v, v_size));
-    volatile VALUE rb_tmp = Data_Wrap_Struct(CLASS_OF(self), nm_mark, nm_delete, tmp);
+    NMATRIX* tmp = nm_create(nm::DENSE_STORE, (STORAGE*)nm_dense_storage_create(dtype, tmp_shape, dim, v, v_size));
+    nm_register_nmatrix(tmp);
+    VALUE rb_tmp = Data_Wrap_Struct(CLASS_OF(self), nm_mark, nm_delete, tmp);
+    nm_unregister_nmatrix(tmp);
+    nm_register_value(rb_tmp);
     if (stype == nm::YALE_STORE)  nm_yale_storage_set(self, slice, rb_tmp);
     else                          nm_list_storage_set(self, slice, rb_tmp);
 
     free_slice(slice);
 
     // We need to free v if it's not the same size as tmp -- because tmp will have made a copy instead.
-    if (nm_storage_count_max_elements(tmp->storage) != v_size)
-      xfree(v);
+    //if (nm_storage_count_max_elements(tmp->storage) != v_size)
+    //  NM_FREE(v);
 
     // nm_delete(tmp); // This seems to enrage the garbage collector (because rb_tmp is still available). It'd be better if we could force it to free immediately, but no sweat.
+
+    nm_unregister_value(rb_tmp);
+    nm_unregister_values(slice_argv, dim);
+  }
+
+  if (!NIL_P(initial_ary) && dtype == nm::RUBYOBJ) {
+    nm_unregister_values(reinterpret_cast<VALUE*>(v), v_size);
   }
 
+  if (stype != nm::DENSE_STORE && dtype == nm::RUBYOBJ) {
+    nm_unregister_values(reinterpret_cast<VALUE*>(init), 1);
+  }
+
+  if (!NIL_P(hash)) {
+    NM_CONSERVATIVE(nm_unregister_value(capacity_num));
+    NM_CONSERVATIVE(nm_unregister_value(default_val_num));
+  }
+
+  NM_CONSERVATIVE(nm_unregister_value(shape_ary));
+  NM_CONSERVATIVE(nm_unregister_value(initial_ary));
+  NM_CONSERVATIVE(nm_unregister_value(hash));
+
+  NM_CONSERVATIVE(nm_unregister_value(self));
+  NM_CONSERVATIVE(nm_unregister_values(argv, argc));
+  nm_unregister_storage(stype, nmatrix->storage);
+
   return self;
 }
 
@@ -834,8 +1243,12 @@ static VALUE nm_init_new_version(int argc, VALUE* argv, VALUE self) {
  * shortcuts.rb.
  */
 static VALUE nm_init(int argc, VALUE* argv, VALUE nm) {
-
+  NM_CONSERVATIVE(nm_register_value(nm));
+  NM_CONSERVATIVE(nm_register_values(argv, argc));
+  
   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);
   }
 
@@ -854,16 +1267,20 @@ static VALUE nm_init(int argc, VALUE* argv, VALUE nm) {
 
   // If there are 7 arguments and Yale, refer to a different init function with fewer sanity checks.
   if (argc == 7) {
-  	if (stype == nm::YALE_STORE) {
-			return nm_init_yale_from_old_yale(argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], nm);
+    if (stype == nm::YALE_STORE) {
+      NM_CONSERVATIVE(nm_unregister_values(argv, argc));
+      NM_CONSERVATIVE(nm_unregister_value(nm));
+      return nm_init_yale_from_old_yale(argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], nm);
 
-		} else {
-			rb_raise(rb_eArgError, "Expected 2-4 arguments (or 7 for internal Yale creation)");
-		}
+    } else {
+      NM_CONSERVATIVE(nm_unregister_values(argv, argc));
+      NM_CONSERVATIVE(nm_unregister_value(nm));
+      rb_raise(rb_eArgError, "Expected 2-4 arguments (or 7 for internal Yale creation)");
+    }
   }
 
-	// 1: Array or Fixnum
-	size_t dim;
+  // 1: Array or Fixnum
+  size_t dim;
   size_t* shape = interpret_shape(argv[offset], &dim);
 
   // 2-3: dtype
@@ -895,7 +1312,7 @@ static VALUE nm_init(int argc, VALUE* argv, VALUE nm) {
     	 */
       if (dtype == nm::RUBYOBJ) {
       	// Pretend [nil] was passed for RUBYOBJ.
-      	init_val = ALLOC(VALUE);
+      	init_val = NM_ALLOC(VALUE);
         *(VALUE*)init_val = Qnil;
 
         init_val_len = 1;
@@ -904,32 +1321,43 @@ static VALUE nm_init(int argc, VALUE* argv, VALUE nm) {
       	init_val = NULL;
       }
     } else if (stype == nm::LIST_STORE) {
-    	init_val = ALLOC_N(char, DTYPE_SIZES[dtype]);
+      init_val = NM_ALLOC_N(char, DTYPE_SIZES[dtype]);
       std::memset(init_val, 0, DTYPE_SIZES[dtype]);
     }
   }
 
+  if (dtype == nm::RUBYOBJ) {
+    nm_register_values(reinterpret_cast<VALUE*>(init_val), init_val_len);
+  }
+
   // TODO: Update to allow an array as the initial value.
-	NMATRIX* nmatrix;
+  NMATRIX* nmatrix;
   UnwrapNMatrix(nm, nmatrix);
 
   nmatrix->stype = stype;
 
   switch (stype) {
-  	case nm::DENSE_STORE:
-  		nmatrix->storage = (STORAGE*)nm_dense_storage_create(dtype, shape, dim, init_val, init_val_len);
-  		break;
+    case nm::DENSE_STORE:
+      nmatrix->storage = (STORAGE*)nm_dense_storage_create(dtype, shape, dim, init_val, init_val_len);
+      break;
 
-  	case nm::LIST_STORE:
-  		nmatrix->storage = (STORAGE*)nm_list_storage_create(dtype, shape, dim, init_val);
-  		break;
+    case nm::LIST_STORE:
+      nmatrix->storage = (STORAGE*)nm_list_storage_create(dtype, shape, dim, init_val);
+      break;
 
-  	case nm::YALE_STORE:
-  		nmatrix->storage = (STORAGE*)nm_yale_storage_create(dtype, shape, dim, init_cap);
-  		nm_yale_storage_init((YALE_STORAGE*)(nmatrix->storage), NULL);
-  		break;
+    case nm::YALE_STORE:
+      nmatrix->storage = (STORAGE*)nm_yale_storage_create(dtype, shape, dim, init_cap);
+      nm_yale_storage_init((YALE_STORAGE*)(nmatrix->storage), NULL);
+      break;
+  }
+
+  if (dtype == nm::RUBYOBJ) {
+    nm_unregister_values(reinterpret_cast<VALUE*>(init_val), init_val_len);
   }
 
+  NM_CONSERVATIVE(nm_unregister_values(argv, argc));
+  NM_CONSERVATIVE(nm_unregister_value(nm));
+
   return nm;
 }
 
@@ -938,13 +1366,18 @@ static VALUE nm_init(int argc, VALUE* argv, VALUE nm) {
  * Helper for nm_cast which uses the C types instead of the Ruby objects. Called by nm_cast.
  */
 NMATRIX* nm_cast_with_ctype_args(NMATRIX* self, nm::stype_t new_stype, nm::dtype_t new_dtype, void* init_ptr) {
-  NMATRIX* lhs = ALLOC(NMATRIX);
+
+  nm_register_nmatrix(self);
+
+  NMATRIX* lhs = NM_ALLOC(NMATRIX);
   lhs->stype   = new_stype;
 
   // Copy the storage
   CAST_TABLE(cast_copy);
   lhs->storage = cast_copy[lhs->stype][self->stype](self->storage, new_dtype, init_ptr);
 
+  nm_unregister_nmatrix(self);
+
   return lhs;
 }
 
@@ -957,6 +1390,9 @@ NMATRIX* nm_cast_with_ctype_args(NMATRIX* self, nm::stype_t new_stype, nm::dtype
  * Copy constructor for changing dtypes and stypes.
  */
 VALUE nm_cast(VALUE self, VALUE new_stype_symbol, VALUE new_dtype_symbol, VALUE init) {
+  NM_CONSERVATIVE(nm_register_value(self));
+  NM_CONSERVATIVE(nm_register_value(init));
+
   nm::dtype_t new_dtype = nm_dtype_from_rbsymbol(new_dtype_symbol);
   nm::stype_t new_stype = nm_stype_from_rbsymbol(new_stype_symbol);
 
@@ -965,16 +1401,27 @@ VALUE nm_cast(VALUE self, VALUE new_stype_symbol, VALUE new_dtype_symbol, VALUE
 
   UnwrapNMatrix( self, rhs );
 
-  void* init_ptr = ALLOCA_N(char, DTYPE_SIZES[new_dtype]);
+  void* init_ptr = NM_ALLOCA_N(char, DTYPE_SIZES[new_dtype]);
   rubyval_to_cval(init, new_dtype, init_ptr);
 
-  return Data_Wrap_Struct(CLASS_OF(self), nm_mark, nm_delete, nm_cast_with_ctype_args(rhs, new_stype, new_dtype, init_ptr));
+  NMATRIX* m = nm_cast_with_ctype_args(rhs, new_stype, new_dtype, init_ptr);
+  nm_register_nmatrix(m);
+
+  VALUE to_return = Data_Wrap_Struct(CLASS_OF(self), nm_mark, nm_delete, m);
+  
+  nm_unregister_nmatrix(m);
+  NM_CONSERVATIVE(nm_unregister_value(self));
+  NM_CONSERVATIVE(nm_unregister_value(init));
+  return to_return;
+
 }
 
 /*
  * Copy constructor for transposing.
  */
 static VALUE nm_init_transposed(VALUE self) {
+  NM_CONSERVATIVE(nm_register_value(self));
+
   static STORAGE* (*storage_copy_transposed[nm::NUM_STYPES])(const STORAGE* rhs_base) = {
     nm_dense_storage_copy_transposed,
     nm_list_storage_copy_transposed,
@@ -984,19 +1431,30 @@ static VALUE nm_init_transposed(VALUE self) {
   NMATRIX* lhs = nm_create( NM_STYPE(self),
                             storage_copy_transposed[NM_STYPE(self)]( NM_STORAGE(self) )
                           );
+  nm_register_nmatrix(lhs);
+  VALUE to_return = Data_Wrap_Struct(CLASS_OF(self), nm_mark, nm_delete, lhs);
 
-  return Data_Wrap_Struct(CLASS_OF(self), nm_mark, nm_delete, lhs);
+  nm_unregister_nmatrix(lhs);
+  NM_CONSERVATIVE(nm_unregister_value(self));
+  return to_return;
 }
 
 /*
  * Copy constructor for no change of dtype or stype (used for #initialize_copy hook).
  */
 static VALUE nm_init_copy(VALUE copy, VALUE original) {
+  NM_CONSERVATIVE(nm_register_value(copy));
+  NM_CONSERVATIVE(nm_register_value(original));
+
   NMATRIX *lhs, *rhs;
 
   CheckNMatrixType(original);
 
-  if (copy == original) return copy;
+  if (copy == original) {
+    NM_CONSERVATIVE(nm_unregister_value(copy));
+    NM_CONSERVATIVE(nm_unregister_value(original));
+    return copy;
+  }
 
   UnwrapNMatrix( original, rhs );
   UnwrapNMatrix( copy,     lhs );
@@ -1007,25 +1465,24 @@ static VALUE nm_init_copy(VALUE copy, VALUE original) {
   CAST_TABLE(ttable);
   lhs->storage = ttable[lhs->stype][rhs->stype](rhs->storage, rhs->storage->dtype, NULL);
 
+  NM_CONSERVATIVE(nm_unregister_value(copy));
+  NM_CONSERVATIVE(nm_unregister_value(original));
+
   return copy;
 }
 
 /*
- * Get major, minor, and release components of NMatrix::VERSION. Store in function parameters.
+ * Get major, minor, and release components of NMatrix::VERSION. Store in function parameters. Doesn't get
+ * the "pre" field currently (beta1/rc1/etc).
  */
 static void get_version_info(uint16_t& major, uint16_t& minor, uint16_t& release) {
   // Get VERSION and split it on periods. Result is an Array.
-  VALUE version = rb_funcall(rb_const_get(cNMatrix, rb_intern("VERSION")), rb_intern("split"), 1, rb_str_new_cstr("."));
-  VALUE* ary    = RARRAY_PTR(version); // major, minor, and release
+  VALUE cVersion = rb_const_get(cNMatrix, rb_intern("VERSION"));
 
   // Convert each to an integer
-  VALUE  maj    = rb_funcall(ary[0], rb_intern("to_i"), 0);
-  VALUE  min    = rb_funcall(ary[1], rb_intern("to_i"), 0);
-  VALUE  rel    = rb_funcall(ary[2], rb_intern("to_i"), 0);
-
-  major   = static_cast<uint16_t>(nm::RubyObject(maj));
-  minor   = static_cast<uint16_t>(nm::RubyObject(min));
-  release = static_cast<uint16_t>(nm::RubyObject(rel));
+  major   = FIX2INT(rb_const_get(cVersion, rb_intern("MAJOR")));
+  minor   = FIX2INT(rb_const_get(cVersion, rb_intern("MINOR")));
+  release = FIX2INT(rb_const_get(cVersion, rb_intern("TINY")));
 }
 
 
@@ -1055,12 +1512,40 @@ static nm::symm_t interpret_symm(VALUE symm) {
 
 
 void read_padded_shape(std::ifstream& f, size_t dim, size_t* shape) {
-  nm::read_padded_shape(f, dim, shape);
+  size_t bytes_read = 0;
+
+  // Read shape
+  for (size_t i = 0; i < dim; ++i) {
+    size_t s;
+    f.read(reinterpret_cast<char*>(&s), sizeof(size_t));
+    shape[i] = s;
+
+    bytes_read += sizeof(size_t);
+  }
+
+  // Ignore padding
+  f.ignore(bytes_read % 8);
 }
 
 
 void write_padded_shape(std::ofstream& f, size_t dim, size_t* shape) {
-  nm::write_padded_shape(f, dim, shape);
+  size_t bytes_written = 0;
+
+  // Write shape
+  for (size_t i = 0; i < dim; ++i) {
+    size_t s = shape[i];
+    f.write(reinterpret_cast<const char*>(&s), sizeof(size_t));
+
+    bytes_written += sizeof(size_t);
+  }
+
+  // Pad with zeros
+  size_t zero = 0;
+  while (bytes_written % 8) {
+    f.write(reinterpret_cast<const char*>(&zero), sizeof(size_t));
+
+    bytes_written += sizeof(IType);
+  }
 }
 
 
@@ -1116,6 +1601,10 @@ static VALUE nm_write(int argc, VALUE* argv, VALUE self) {
   if (argc < 1 || argc > 2) {
     rb_raise(rb_eArgError, "Expected one or two arguments");
   }
+
+  NM_CONSERVATIVE(nm_register_values(argv, argc));
+  NM_CONSERVATIVE(nm_register_value(self));
+
   VALUE file = argv[0],
         symm = argc == 1 ? Qnil : argv[1];
 
@@ -1125,6 +1614,8 @@ static VALUE nm_write(int argc, VALUE* argv, VALUE self) {
   nm::symm_t symm_ = interpret_symm(symm);
 
   if (nmatrix->storage->dtype == nm::RUBYOBJ) {
+    NM_CONSERVATIVE(nm_unregister_values(argv, argc));
+    NM_CONSERVATIVE(nm_unregister_value(self));
     rb_raise(rb_eNotImpError, "Ruby Object writing is not implemented yet");
   }
 
@@ -1137,8 +1628,15 @@ static VALUE nm_write(int argc, VALUE* argv, VALUE self) {
   //FIXME: Cast the matrix to the smallest possible index type. Write that in the place of IType.
 
   // Check arguments before starting to write.
-  if (nmatrix->stype == nm::LIST_STORE) rb_raise(nm_eStorageTypeError, "cannot save list matrix; cast to yale or dense first");
+  if (nmatrix->stype == nm::LIST_STORE) {
+    NM_CONSERVATIVE(nm_unregister_values(argv, argc));
+    NM_CONSERVATIVE(nm_unregister_value(self));
+    rb_raise(nm_eStorageTypeError, "cannot save list matrix; cast to yale or dense first");
+  }
   if (symm_ != nm::NONSYMM) {
+    NM_CONSERVATIVE(nm_unregister_values(argv, argc));
+    NM_CONSERVATIVE(nm_unregister_value(self));
+
     if (dim != 2) rb_raise(rb_eArgError, "symmetry/triangularity not defined for a non-2D matrix");
     if (nmatrix->storage->shape[0] != nmatrix->storage->shape[1])
       rb_raise(rb_eArgError, "symmetry/triangularity not defined for a non-square matrix");
@@ -1185,6 +1683,9 @@ static VALUE nm_write(int argc, VALUE* argv, VALUE self) {
 
   f.close();
 
+  NM_CONSERVATIVE(nm_unregister_values(argv, argc));
+  NM_CONSERVATIVE(nm_unregister_value(self));
+
   return Qtrue;
 }
 
@@ -1202,6 +1703,9 @@ static VALUE nm_write(int argc, VALUE* argv, VALUE self) {
 static VALUE nm_read(int argc, VALUE* argv, VALUE self) {
   using std::ifstream;
 
+  NM_CONSERVATIVE(nm_register_values(argv, argc));
+  NM_CONSERVATIVE(nm_register_value(self));
+
   VALUE file, force_;
 
   // Read the arguments
@@ -1210,6 +1714,8 @@ static VALUE nm_read(int argc, VALUE* argv, VALUE self) {
 
 
   if (!RB_FILE_EXISTS(file)) { // FIXME: Errno::ENOENT
+    NM_CONSERVATIVE(nm_unregister_values(argv, argc));
+    NM_CONSERVATIVE(nm_unregister_value(self));
     rb_raise(rb_get_errno_exc("ENOENT"), "%s", RSTRING_PTR(file));
   }
 
@@ -1230,9 +1736,11 @@ static VALUE nm_read(int argc, VALUE* argv, VALUE self) {
   int ver  = major * 10000 + minor * 100 + release,
       fver = fmajor * 10000 + fminor * 100 + release;
   if (fver > ver && force == false) {
-    rb_raise(rb_eIOError, "File was created in newer version of NMatrix than current");
+    NM_CONSERVATIVE(nm_unregister_values(argv, argc));
+    NM_CONSERVATIVE(nm_unregister_value(self));
+    rb_raise(rb_eIOError, "File was created in newer version of NMatrix than current (%u.%u.%u)", fmajor, fminor, frelease);
   }
-  if (null16 != 0) fprintf(stderr, "Warning: Expected zero padding was not zero\n");
+  if (null16 != 0) rb_warn("nm_read: Expected zero padding was not zero (0)\n");
 
   uint8_t dt, st, it, sm;
   uint16_t dim;
@@ -1245,19 +1753,20 @@ static VALUE nm_read(int argc, VALUE* argv, VALUE self) {
   f.read(reinterpret_cast<char*>(&null16), sizeof(uint16_t));
   f.read(reinterpret_cast<char*>(&dim), sizeof(uint16_t));
 
-  if (null16 != 0) fprintf(stderr, "Warning: Expected zero padding was not zero\n");
+  if (null16 != 0) rb_warn("nm_read: Expected zero padding was not zero (1)");
   nm::stype_t stype = static_cast<nm::stype_t>(st);
   nm::dtype_t dtype = static_cast<nm::dtype_t>(dt);
   nm::symm_t  symm  = static_cast<nm::symm_t>(sm);
   //nm::itype_t itype = static_cast<nm::itype_t>(it);
 
   // READ NEXT FEW 64-BIT BLOCKS
-  size_t* shape = ALLOC_N(size_t, dim);
+  size_t* shape = NM_ALLOC_N(size_t, dim);
   read_padded_shape(f, dim, shape);
 
   STORAGE* s;
   if (stype == nm::DENSE_STORE) {
     s = nm_dense_storage_create(dtype, shape, dim, NULL, 0);
+    nm_register_storage(stype, s);
 
     read_padded_dense_elements(f, reinterpret_cast<DENSE_STORAGE*>(s), symm, dtype);
 
@@ -1270,8 +1779,12 @@ static VALUE nm_read(int argc, VALUE* argv, VALUE self) {
 
     s = nm_yale_storage_create(dtype, shape, dim, length); // set length as init capacity
 
+    nm_register_storage(stype, s);
+
     read_padded_yale_elements(f, reinterpret_cast<YALE_STORAGE*>(s), length, symm, dtype);
   } else {
+    NM_CONSERVATIVE(nm_unregister_values(argv, argc));
+    NM_CONSERVATIVE(nm_unregister_value(self));
     rb_raise(nm_eStorageTypeError, "please convert to yale or dense before saving");
   }
 
@@ -1280,10 +1793,18 @@ static VALUE nm_read(int argc, VALUE* argv, VALUE self) {
   // Return the appropriate matrix object (Ruby VALUE)
   // FIXME: This should probably return CLASS_OF(self) instead of cNMatrix, but I don't know how that works for
   // FIXME: class methods.
+  nm_register_nmatrix(nm);
+  VALUE to_return = Data_Wrap_Struct(cNMatrix, nm_mark, nm_delete, nm);
+
+  nm_unregister_nmatrix(nm);
+  NM_CONSERVATIVE(nm_unregister_values(argv, argc));
+  NM_CONSERVATIVE(nm_unregister_value(self));
+  nm_unregister_storage(stype, s);
+
   switch(stype) {
   case nm::DENSE_STORE:
   case nm::YALE_STORE:
-    return Data_Wrap_Struct(cNMatrix, nm_mark, nm_delete, nm);
+    return to_return;
   default: // this case never occurs (due to earlier rb_raise)
     return Qnil;
   }
@@ -1321,7 +1842,7 @@ static VALUE nm_init_yale_from_old_yale(VALUE shape, VALUE dtype, VALUE ia, VALU
  */
 static VALUE nm_is_ref(VALUE self) {
   if (NM_SRC(self) == NM_STORAGE(self)) return Qfalse;
-  else                                  return Qtrue;
+  return Qtrue;
 }
 
 /*
@@ -1340,7 +1861,8 @@ static VALUE nm_mget(int argc, VALUE* argv, VALUE self) {
     nm_list_storage_get,
     nm_yale_storage_get
   };
-  return nm_xslice(argc, argv, ttable[NM_STYPE(self)], nm_delete, self);
+  nm::stype_t stype = NM_STYPE(self);
+  return nm_xslice(argc, argv, ttable[stype], nm_delete, self);
 }
 
 /*
@@ -1359,7 +1881,8 @@ static VALUE nm_mref(int argc, VALUE* argv, VALUE self) {
     nm_list_storage_ref,
     nm_yale_storage_ref
   };
-  return nm_xslice(argc, argv, ttable[NM_STYPE(self)], nm_delete_ref, self);
+  nm::stype_t stype = NM_STYPE(self);
+  return nm_xslice(argc, argv, ttable[stype], nm_delete_ref, self);
 }
 
 /*
@@ -1372,11 +1895,17 @@ static VALUE nm_mref(int argc, VALUE* argv, VALUE self) {
  *     n[3,3] = n[2,3] = 5.0
  */
 static VALUE nm_mset(int argc, VALUE* argv, VALUE self) {
+  
   size_t dim = NM_DIM(self); // last arg is the value
 
+  VALUE to_return = Qnil;
+
   if ((size_t)(argc) > NM_DIM(self)+1) {
-    rb_raise(rb_eArgError, "wrong number of arguments (%d for %u)", argc, effective_dim(NM_STORAGE(self))+1);
+    rb_raise(rb_eArgError, "wrong number of arguments (%d for %lu)", argc, effective_dim(NM_STORAGE(self))+1);
   } else {
+    NM_CONSERVATIVE(nm_register_value(self));
+    NM_CONSERVATIVE(nm_register_values(argv, argc));
+
     SLICE* slice = get_slice(dim, argc-1, argv, NM_STORAGE(self)->shape);
 
     static void (*ttable[nm::NUM_STYPES])(VALUE, SLICE*, VALUE) = {
@@ -1389,9 +1918,13 @@ static VALUE nm_mset(int argc, VALUE* argv, VALUE self) {
 
     free_slice(slice);
 
-    return argv[argc-1];
+    to_return = argv[argc-1];
+
+    NM_CONSERVATIVE(nm_unregister_value(self));
+    NM_CONSERVATIVE(nm_unregister_values(argv, argc));
   }
-  return Qnil;
+
+  return to_return;
 }
 
 /*
@@ -1402,30 +1935,50 @@ static VALUE nm_mset(int argc, VALUE* argv, VALUE self) {
  * The two matrices must be of the same stype (for now). If dtype differs, an upcast will occur.
  */
 static VALUE nm_multiply(VALUE left_v, VALUE right_v) {
+  NM_CONSERVATIVE(nm_register_value(left_v));
+  NM_CONSERVATIVE(nm_register_value(right_v));
+
   NMATRIX *left, *right;
 
   UnwrapNMatrix( left_v, left );
 
-  if (NM_RUBYVAL_IS_NUMERIC(right_v))
+  if (NM_RUBYVAL_IS_NUMERIC(right_v)) {
+    NM_CONSERVATIVE(nm_unregister_value(left_v));
+    NM_CONSERVATIVE(nm_unregister_value(right_v));
     return matrix_multiply_scalar(left, right_v);
+  }
 
-  else if (TYPE(right_v) == T_ARRAY)
+  else if (TYPE(right_v) == T_ARRAY) {
+    NM_CONSERVATIVE(nm_unregister_value(left_v));
+    NM_CONSERVATIVE(nm_unregister_value(right_v));
     rb_raise(rb_eNotImpError, "please convert array to nx1 or 1xn NMatrix first");
+  }
 
   else { // both are matrices (probably)
     CheckNMatrixType(right_v);
     UnwrapNMatrix( right_v, right );
 
-    if (left->storage->shape[1] != right->storage->shape[0])
+    if (left->storage->shape[1] != right->storage->shape[0]) {
+      NM_CONSERVATIVE(nm_unregister_value(left_v));
+      NM_CONSERVATIVE(nm_unregister_value(right_v));
       rb_raise(rb_eArgError, "incompatible dimensions");
+    }
 
-    if (left->stype != right->stype)
+    if (left->stype != right->stype) {
+      NM_CONSERVATIVE(nm_unregister_value(left_v));
+      NM_CONSERVATIVE(nm_unregister_value(right_v));
       rb_raise(rb_eNotImpError, "matrices must have same stype");
+    }
 
+    NM_CONSERVATIVE(nm_unregister_value(left_v));
+    NM_CONSERVATIVE(nm_unregister_value(right_v));
     return matrix_multiply(left, right);
 
   }
 
+  NM_CONSERVATIVE(nm_unregister_value(left_v));
+  NM_CONSERVATIVE(nm_unregister_value(right_v));
+
   return Qnil;
 }
 
@@ -1452,13 +2005,17 @@ static VALUE nm_dim(VALUE self) {
  * Get the shape (dimensions) of a matrix.
  */
 static VALUE nm_shape(VALUE self) {
+  NM_CONSERVATIVE(nm_register_value(self));
   STORAGE* s   = NM_STORAGE(self);
 
   // Copy elements into a VALUE array and then use those to create a Ruby array with rb_ary_new4.
-  VALUE* shape = ALLOCA_N(VALUE, s->dim);
+  VALUE* shape = NM_ALLOCA_N(VALUE, s->dim);
+  nm_register_values(shape, s->dim);
   for (size_t index = 0; index < s->dim; ++index)
     shape[index] = INT2FIX(s->shape[index]);
-
+  
+  nm_unregister_values(shape, s->dim);
+  NM_CONSERVATIVE(nm_unregister_value(self));
   return rb_ary_new4(s->dim, shape);
 }
 
@@ -1470,13 +2027,17 @@ static VALUE nm_shape(VALUE self) {
  * Get the offset (slice position) of a matrix. Typically all zeros, unless you have a reference slice.
  */
 static VALUE nm_offset(VALUE self) {
+  NM_CONSERVATIVE(nm_register_value(self));
   STORAGE* s   = NM_STORAGE(self);
 
   // Copy elements into a VALUE array and then use those to create a Ruby array with rb_ary_new4.
-  VALUE* offset = ALLOCA_N(VALUE, s->dim);
+  VALUE* offset = NM_ALLOCA_N(VALUE, s->dim);
+  nm_register_values(offset, s->dim);
   for (size_t index = 0; index < s->dim; ++index)
     offset[index] = INT2FIX(s->offset[index]);
 
+  nm_unregister_values(offset, s->dim);
+  NM_CONSERVATIVE(nm_unregister_value(self));
   return rb_ary_new4(s->dim, offset);
 }
 
@@ -1490,13 +2051,20 @@ static VALUE nm_offset(VALUE self) {
 static VALUE nm_supershape(VALUE self) {
 
   STORAGE* s   = NM_STORAGE(self);
-  if (s->src == s) return nm_shape(self); // easy case (not a slice)
+  if (s->src == s) {
+    return nm_shape(self); // easy case (not a slice)
+  } 
   else s = s->src;
 
-  VALUE* shape = ALLOCA_N(VALUE, s->dim);
+  NM_CONSERVATIVE(nm_register_value(self));
+  
+  VALUE* shape = NM_ALLOCA_N(VALUE, s->dim);
+  nm_register_values(shape, s->dim);
   for (size_t index = 0; index < s->dim; ++index)
     shape[index] = INT2FIX(s->shape[index]);
 
+  nm_unregister_values(shape, s->dim);
+  NM_CONSERVATIVE(nm_unregister_value(self));
   return rb_ary_new4(s->dim, shape);
 }
 
@@ -1507,8 +2075,10 @@ static VALUE nm_supershape(VALUE self) {
  * Get the storage type (stype) of a matrix, e.g., :yale, :dense, or :list.
  */
 static VALUE nm_stype(VALUE self) {
-  ID stype = rb_intern(STYPE_NAMES[NM_STYPE(self)]);
-  return ID2SYM(stype);
+  NM_CONSERVATIVE(nm_register_value(self));
+  VALUE stype = ID2SYM(rb_intern(STYPE_NAMES[NM_STYPE(self)]));
+  NM_CONSERVATIVE(nm_unregister_value(self));
+  return stype;
 }
 
 /*
@@ -1550,11 +2120,18 @@ static VALUE nm_effective_dim(VALUE self) {
  */
 static VALUE nm_xslice(int argc, VALUE* argv, void* (*slice_func)(const STORAGE*, SLICE*), void (*delete_func)(NMATRIX*), VALUE self) {
   VALUE result = Qnil;
+
   STORAGE* s = NM_STORAGE(self);
 
   if (NM_DIM(self) < (size_t)(argc)) {
-    rb_raise(rb_eArgError, "wrong number of arguments (%d for %u)", argc, effective_dim(s));
+    rb_raise(rb_eArgError, "wrong number of arguments (%d for %lu)", argc, effective_dim(s));
   } else {
+
+    NM_CONSERVATIVE(nm_register_values(argv, argc));
+    NM_CONSERVATIVE(nm_register_value(self));
+
+    nm_register_value(result);
+
     SLICE* slice = get_slice(NM_DIM(self), argc, argv, s->shape);
 
     if (slice->single) {
@@ -1569,16 +2146,21 @@ static VALUE nm_xslice(int argc, VALUE* argv, void* (*slice_func)(const STORAGE*
 
     } else {
 
-      NMATRIX* mat  = ALLOC(NMATRIX);
+      NMATRIX* mat  = NM_ALLOC(NMATRIX);
       mat->stype    = NM_STYPE(self);
       mat->storage  = (STORAGE*)((*slice_func)( s, slice ));
-
+      nm_register_nmatrix(mat);
       result        = Data_Wrap_Struct(CLASS_OF(self), nm_mark, delete_func, mat);
+      nm_unregister_nmatrix(mat);
     }
 
     free_slice(slice);
   }
 
+  nm_unregister_value(result);
+  NM_CONSERVATIVE(nm_unregister_values(argv, argc));
+  NM_CONSERVATIVE(nm_unregister_value(self));
+
   return result;
 }
 
@@ -1586,13 +2168,49 @@ static VALUE nm_xslice(int argc, VALUE* argv, void* (*slice_func)(const STORAGE*
 // Helper Functions //
 //////////////////////
 
+static VALUE unary_op(nm::unaryop_t op, VALUE self) {
+  NM_CONSERVATIVE(nm_register_value(self));
+  NMATRIX* left;
+  UnwrapNMatrix(self, left);
+  std::string sym;
+
+  switch(left->stype) {
+  case nm::DENSE_STORE:
+    sym = "__dense_unary_" + nm::UNARYOPS[op] + "__";
+    break;
+  case nm::YALE_STORE:
+    sym = "__yale_unary_" + nm::UNARYOPS[op]  + "__";
+    break;
+  case nm::LIST_STORE:
+    sym = "__list_unary_" + nm::UNARYOPS[op]  + "__";
+    break;
+  }
+
+  NM_CONSERVATIVE(nm_unregister_value(self));
+  return rb_funcall(self, rb_intern(sym.c_str()), 0);
+}
+
+static void check_dims_and_shape(VALUE left_val, VALUE right_val) {
+    // Check that the left- and right-hand sides have the same dimensionality.
+    if (NM_DIM(left_val) != NM_DIM(right_val)) {
+      rb_raise(rb_eArgError, "The left- and right-hand sides of the operation must have the same dimensionality.");
+    }
+    // Check that the left- and right-hand sides have the same shape.
+    if (memcmp(&NM_SHAPE(left_val, 0), &NM_SHAPE(right_val, 0), sizeof(size_t) * NM_DIM(left_val)) != 0) {
+      rb_raise(rb_eArgError, "The left- and right-hand sides of the operation must have the same shape.");
+    }
+}
+
 static VALUE elementwise_op(nm::ewop_t op, VALUE left_val, VALUE right_val) {
 
-	NMATRIX* left;
-	NMATRIX* result;
+  NM_CONSERVATIVE(nm_register_value(left_val));
+  NM_CONSERVATIVE(nm_register_value(right_val));
 
-	CheckNMatrixType(left_val);
-	UnwrapNMatrix(left_val, left);
+  NMATRIX* left;
+  NMATRIX* result;
+
+  CheckNMatrixType(left_val);
+  UnwrapNMatrix(left_val, left);
 
   if (TYPE(right_val) != T_DATA || (RDATA(right_val)->dfree != (RUBY_DATA_FUNC)nm_delete && RDATA(right_val)->dfree != (RUBY_DATA_FUNC)nm_delete_ref)) {
     // This is a matrix-scalar element-wise operation.
@@ -1608,21 +2226,18 @@ static VALUE elementwise_op(nm::ewop_t op, VALUE left_val, VALUE right_val) {
       sym = "__list_scalar_" + nm::EWOP_NAMES[op] + "__";
       break;
     default:
+      NM_CONSERVATIVE(nm_unregister_value(left_val));
+      NM_CONSERVATIVE(nm_unregister_value(right_val));
       rb_raise(rb_eNotImpError, "unknown storage type requested scalar element-wise operation");
     }
-    return rb_funcall(left_val, rb_intern(sym.c_str()), 1, right_val);
+    VALUE symv = rb_intern(sym.c_str());
+    NM_CONSERVATIVE(nm_unregister_value(left_val));
+    NM_CONSERVATIVE(nm_unregister_value(right_val));
+    return rb_funcall(left_val, symv, 1, right_val);
 
   } else {
 
-    // Check that the left- and right-hand sides have the same dimensionality.
-    if (NM_DIM(left_val) != NM_DIM(right_val)) {
-      rb_raise(rb_eArgError, "The left- and right-hand sides of the operation must have the same dimensionality.");
-    }
-
-    // Check that the left- and right-hand sides have the same shape.
-    if (memcmp(&NM_SHAPE(left_val, 0), &NM_SHAPE(right_val, 0), sizeof(size_t) * NM_DIM(left_val)) != 0) {
-      rb_raise(rb_eArgError, "The left- and right-hand sides of the operation must have the same shape.");
-    }
+    check_dims_and_shape(left_val, right_val);
 
     NMATRIX* right;
     UnwrapNMatrix(right_val, right);
@@ -1641,16 +2256,99 @@ static VALUE elementwise_op(nm::ewop_t op, VALUE left_val, VALUE right_val) {
         sym = "__list_elementwise_" + nm::EWOP_NAMES[op] + "__";
         break;
       default:
+        NM_CONSERVATIVE(nm_unregister_value(left_val));
+        NM_CONSERVATIVE(nm_unregister_value(right_val));
         rb_raise(rb_eNotImpError, "unknown storage type requested element-wise operation");
       }
-      return rb_funcall(left_val, rb_intern(sym.c_str()), 1, right_val);
+
+      VALUE symv = rb_intern(sym.c_str());
+      NM_CONSERVATIVE(nm_unregister_value(left_val));
+      NM_CONSERVATIVE(nm_unregister_value(right_val));
+      return rb_funcall(left_val, symv, 1, right_val);
 
     } else {
+      NM_CONSERVATIVE(nm_unregister_value(left_val));
+      NM_CONSERVATIVE(nm_unregister_value(right_val));
       rb_raise(rb_eArgError, "Element-wise operations are not currently supported between matrices with differing stypes.");
     }
   }
 
-	return Data_Wrap_Struct(CLASS_OF(left_val), nm_mark, nm_delete, result);
+  NM_CONSERVATIVE(nm_unregister_value(left_val));
+  NM_CONSERVATIVE(nm_unregister_value(right_val));
+  return Data_Wrap_Struct(CLASS_OF(left_val), nm_mark, nm_delete, result);
+}
+
+static VALUE noncom_elementwise_op(nm::noncom_ewop_t op, VALUE self, VALUE other, VALUE flip) {
+
+  NM_CONSERVATIVE(nm_register_value(self));
+  NM_CONSERVATIVE(nm_register_value(other));
+
+  NMATRIX* self_nm;
+  NMATRIX* result;
+
+  CheckNMatrixType(self);
+  UnwrapNMatrix(self, self_nm);
+
+  if (TYPE(other) != T_DATA || (RDATA(other)->dfree != (RUBY_DATA_FUNC)nm_delete && RDATA(other)->dfree != (RUBY_DATA_FUNC)nm_delete_ref)) {
+    // This is a matrix-scalar element-wise operation.
+    std::string sym;
+    switch(self_nm->stype) {
+    case nm::DENSE_STORE:
+      sym = "__dense_scalar_" + nm::NONCOM_EWOP_NAMES[op] + "__";
+      break;
+    case nm::YALE_STORE:
+      sym = "__yale_scalar_" + nm::NONCOM_EWOP_NAMES[op] + "__";
+      break;
+    case nm::LIST_STORE:
+      sym = "__list_scalar_" + 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 scalar element-wise operation");
+    }
+    NM_CONSERVATIVE(nm_unregister_value(self));
+    NM_CONSERVATIVE(nm_unregister_value(other));
+    return rb_funcall(self, rb_intern(sym.c_str()), 2, other, flip);
+
+  } else {
+
+    check_dims_and_shape(self, other);
+
+    NMATRIX* other_nm;
+    UnwrapNMatrix(other, other_nm);
+
+    if (self_nm->stype == other_nm->stype) {
+      std::string sym;
+
+      switch(self_nm->stype) {
+      case nm::DENSE_STORE:
+        sym = "__dense_elementwise_" + nm::NONCOM_EWOP_NAMES[op] + "__";
+        break;
+      case nm::YALE_STORE:
+        sym = "__yale_elementwise_" + nm::NONCOM_EWOP_NAMES[op] + "__";
+        break;
+      case nm::LIST_STORE:
+        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));
+      return rb_funcall(self, rb_intern(sym.c_str()), 2, other, flip);
+
+    } else {
+      nm_unregister_value(self);
+      nm_unregister_value(other);
+      rb_raise(rb_eArgError, "Element-wise operations are not currently supported between matrices with differing stypes.");
+    }
+  }
+  NM_CONSERVATIVE(nm_unregister_value(self));
+  NM_CONSERVATIVE(nm_unregister_value(other));
+  return Data_Wrap_Struct(CLASS_OF(self), nm_mark, nm_delete, result);
 }
 
 /*
@@ -1664,11 +2362,13 @@ bool is_ref(const NMATRIX* matrix) {
  * Helper function for nm_symmetric and nm_hermitian.
  */
 static VALUE is_symmetric(VALUE self, bool hermitian) {
+  NM_CONSERVATIVE(nm_register_value(self));
+
   NMATRIX* m;
   UnwrapNMatrix(self, m);
 
   if (m->storage->shape[0] == m->storage->shape[1] and m->storage->dim == 2) {
-		if (NM_STYPE(self) == nm::DENSE_STORE) {
+    if (NM_STYPE(self) == nm::DENSE_STORE) {
       if (hermitian) {
         nm_dense_storage_is_hermitian((DENSE_STORAGE*)(m->storage), m->storage->shape[0]);
 
@@ -1678,11 +2378,12 @@ static VALUE is_symmetric(VALUE self, bool hermitian) {
 
     } else {
       // TODO: Implement, at the very least, yale_is_symmetric. Model it after yale/transp.template.c.
+      NM_CONSERVATIVE(nm_unregister_value(self));
       rb_raise(rb_eNotImpError, "symmetric? and hermitian? only implemented for dense currently");
     }
 
   }
-
+  NM_CONSERVATIVE(nm_unregister_value(self));
   return Qfalse;
 }
 
@@ -1724,9 +2425,10 @@ 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::Rational128* v = ALLOCA_N(nm::Rational128, 1);
+  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;
@@ -1848,6 +2550,8 @@ nm::dtype_t nm_dtype_guess(VALUE v) {
  * accessing some part of a matrix.
  */
 static SLICE* get_slice(size_t dim, int argc, VALUE* arg, size_t* shape) {
+  NM_CONSERVATIVE(nm_register_values(arg, argc));
+
   VALUE beg, end;
   int excl;
 
@@ -1875,15 +2579,17 @@ static SLICE* get_slice(size_t dim, int argc, VALUE* arg, size_t* shape) {
       slice->coords[r]  = 0;
       slice->lengths[r] = shape[r];
       slice->single     = false;
+      t++;
 
     } else if (TYPE(arg[t]) == T_HASH) { // 3:5 notation (inclusive)
       VALUE begin_end   = rb_funcall(v, rb_intern("shift"), 0); // rb_hash_shift
+      nm_register_value(begin_end);
       slice->coords[r]  = FIX2UINT(rb_ary_entry(begin_end, 0));
       slice->lengths[r] = FIX2UINT(rb_ary_entry(begin_end, 1)) - slice->coords[r];
 
       if (RHASH_EMPTY_P(v)) t++; // go on to the next
-
       slice->single = false;
+      nm_unregister_value(begin_end);
 
     } else if (CLASS_OF(v) == rb_cRange) {
       rb_range_values(arg[t], &beg, &end, &excl);
@@ -1896,13 +2602,17 @@ static SLICE* get_slice(size_t dim, int argc, VALUE* arg, size_t* shape) {
       t++;
 
     } else {
+      NM_CONSERVATIVE(nm_unregister_values(arg, argc));
       rb_raise(rb_eArgError, "expected Fixnum, Range, or Hash for slice component instead of %s", rb_obj_classname(v));
     }
 
-    if (slice->coords[r] > shape[r] || slice->coords[r] + slice->lengths[r] > shape[r])
-      rb_raise(rb_eRangeError, "slice is larger than matrix in dimension %u (slice component %u)", r, t);
+    if (slice->coords[r] > shape[r] || slice->coords[r] + slice->lengths[r] > shape[r]) {
+      NM_CONSERVATIVE(nm_unregister_values(arg, argc));
+      rb_raise(rb_eRangeError, "slice is larger than matrix in dimension %lu (slice component %lu)", r, t);
+    }
   }
 
+  NM_CONSERVATIVE(nm_unregister_values(arg, argc));
   return slice;
 }
 
@@ -1960,12 +2670,14 @@ static nm::dtype_t interpret_dtype(int argc, VALUE* argv, nm::stype_t stype) {
  * Convert an Ruby value or an array of Ruby values into initial C values.
  */
 static void* interpret_initial_value(VALUE arg, nm::dtype_t dtype) {
+  NM_CONSERVATIVE(nm_register_value(arg));
+
   unsigned int index;
   void* init_val;
 
   if (TYPE(arg) == T_ARRAY) {
   	// Array
-    init_val = ALLOC_N(char, DTYPE_SIZES[dtype] * RARRAY_LEN(arg));
+    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]));
@@ -1976,6 +2688,7 @@ static void* interpret_initial_value(VALUE arg, nm::dtype_t dtype) {
     init_val = rubyobj_to_cval(arg, dtype);
   }
 
+  NM_CONSERVATIVE(nm_unregister_value(arg));
   return init_val;
 }
 
@@ -1986,11 +2699,12 @@ static void* interpret_initial_value(VALUE arg, nm::dtype_t dtype) {
  * array describing the shape, which must be freed manually.
  */
 static size_t* interpret_shape(VALUE arg, size_t* dim) {
+  NM_CONSERVATIVE(nm_register_value(arg));
   size_t* shape;
 
   if (TYPE(arg) == T_ARRAY) {
     *dim = RARRAY_LEN(arg);
-    shape = ALLOC_N(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] );
@@ -1998,15 +2712,17 @@ static size_t* interpret_shape(VALUE arg, size_t* dim) {
 
   } else if (FIXNUM_P(arg)) {
     *dim = 2;
-    shape = ALLOC_N(size_t, *dim);
+    shape = NM_ALLOC_N(size_t, *dim);
 
     shape[0] = FIX2UINT(arg);
     shape[1] = FIX2UINT(arg);
 
   } else {
+    nm_unregister_value(arg);
     rb_raise(rb_eArgError, "Expected an array of numbers or a single Fixnum for matrix shape");
   }
 
+  NM_CONSERVATIVE(nm_unregister_value(arg));
   return shape;
 }
 
@@ -2038,12 +2754,20 @@ STORAGE* matrix_storage_cast_alloc(NMATRIX* matrix, nm::dtype_t new_dtype) {
 }
 
 STORAGE_PAIR binary_storage_cast_alloc(NMATRIX* left_matrix, NMATRIX* right_matrix) {
+  nm_register_nmatrix(left_matrix);
+  nm_register_nmatrix(right_matrix);
+
   STORAGE_PAIR casted;
   nm::dtype_t new_dtype = Upcast[left_matrix->storage->dtype][right_matrix->storage->dtype];
 
   casted.left  = matrix_storage_cast_alloc(left_matrix, new_dtype);
+  nm_register_storage(left_matrix->stype, casted.left);
   casted.right = matrix_storage_cast_alloc(right_matrix, new_dtype);
 
+  nm_unregister_nmatrix(left_matrix);
+  nm_unregister_nmatrix(right_matrix);
+  nm_unregister_storage(left_matrix->stype, casted.left);
+
   return casted;
 }
 
@@ -2053,12 +2777,16 @@ static VALUE matrix_multiply_scalar(NMATRIX* left, VALUE scalar) {
 }
 
 static VALUE matrix_multiply(NMATRIX* left, NMATRIX* right) {
+  nm_register_nmatrix(left);
+  nm_register_nmatrix(right);
   ///TODO: multiplication for non-dense and/or non-decimal matrices
 
   // Make sure both of our matrices are of the correct type.
   STORAGE_PAIR casted = binary_storage_cast_alloc(left, right);
+  nm_register_storage(left->stype, casted.left);
+  nm_register_storage(right->stype, casted.right);
 
-  size_t*  resulting_shape   = ALLOC_N(size_t, 2);
+  size_t*  resulting_shape   = NM_ALLOC_N(size_t, 2);
   resulting_shape[0] = left->storage->shape[0];
   resulting_shape[1] = right->storage->shape[1];
 
@@ -2074,6 +2802,7 @@ static VALUE matrix_multiply(NMATRIX* left, NMATRIX* right) {
 
   STORAGE* resulting_storage = storage_matrix_multiply[left->stype](casted, resulting_shape, vector);
   NMATRIX* result = nm_create(left->stype, resulting_storage);
+  nm_register_nmatrix(result);
 
   // Free any casted-storage we created for the multiplication.
   // TODO: Can we make the Ruby GC take care of this stuff now that we're using it?
@@ -2085,11 +2814,19 @@ static VALUE matrix_multiply(NMATRIX* left, NMATRIX* right) {
     nm_yale_storage_delete
   };
 
+  nm_unregister_storage(left->stype, casted.left);
   if (left->storage != casted.left)   free_storage[result->stype](casted.left);
+
+  nm_unregister_storage(right->stype, casted.right);
   if (right->storage != casted.right) free_storage[result->stype](casted.right);
 
-  if (result) return Data_Wrap_Struct(cNMatrix, nm_mark, nm_delete, result);
-  return Qnil; // Only if we try to multiply list matrices should we return Qnil.
+  VALUE to_return = result ? Data_Wrap_Struct(cNMatrix, nm_mark, nm_delete, result) : Qnil; // Only if we try to multiply list matrices should we return Qnil.
+
+  nm_unregister_nmatrix(left);
+  nm_unregister_nmatrix(right);
+  nm_unregister_nmatrix(result);
+
+  return to_return;
 }
 
 /*
@@ -2100,15 +2837,31 @@ static VALUE matrix_multiply(NMATRIX* left, NMATRIX* right) {
  * Note: Currently only implemented for 2x2 and 3x3 matrices.
  */
 static VALUE nm_det_exact(VALUE self) {
-  if (NM_STYPE(self) != nm::DENSE_STORE) rb_raise(nm_eStorageTypeError, "can only calculate exact determinant for dense matrices");
 
-  if (NM_DIM(self) != 2 || NM_SHAPE0(self) != NM_SHAPE1(self)) return Qnil;
+  if (NM_STYPE(self) != nm::DENSE_STORE) {
+    rb_raise(nm_eStorageTypeError, "can only calculate exact determinant for dense matrices");
+  }
+  if (NM_DIM(self) != 2 || NM_SHAPE0(self) != NM_SHAPE1(self)) {
+    return Qnil;
+  }
+
+  NM_CONSERVATIVE(nm_register_value(self));
 
   // Calculate the determinant and then assign it to the return value
-  void* result = ALLOCA_N(char, DTYPE_SIZES[NM_DTYPE(self)]);
+  void* result = NM_ALLOCA_N(char, DTYPE_SIZES[NM_DTYPE(self)]);
+  nm::dtype_t dtype = NM_DTYPE(self);
   nm_math_det_exact(NM_SHAPE0(self), NM_STORAGE_DENSE(self)->elements, NM_SHAPE0(self), NM_DTYPE(self), result);
 
-  return rubyobj_from_cval(result, NM_DTYPE(self)).rval;
+  if (dtype == nm::RUBYOBJ) {
+    nm_register_values(reinterpret_cast<VALUE*>(result), 1);
+  }
+  VALUE to_return = rubyobj_from_cval(result, NM_DTYPE(self)).rval;
+  if (dtype == nm::RUBYOBJ) {
+    nm_unregister_values(reinterpret_cast<VALUE*>(result), 1);
+  }
+  NM_CONSERVATIVE(nm_unregister_value(self));
+
+  return to_return;
 }
 
 /////////////////
@@ -2127,6 +2880,11 @@ static VALUE nm_det_exact(VALUE self) {
  * TODO: Add a column-major option for libraries that use column-major matrices.
  */
 VALUE rb_nmatrix_dense_create(nm::dtype_t dtype, size_t* shape, size_t dim, void* elements, size_t length) {
+
+  if (dtype == nm::RUBYOBJ) {
+    nm_register_values(reinterpret_cast<VALUE*>(elements), length);
+  }
+
   NMATRIX* nm;
   size_t nm_dim;
   size_t* shape_copy;
@@ -2134,25 +2892,34 @@ 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		= ALLOC_N(size_t, nm_dim);
+    shape_copy		= NM_ALLOC_N(size_t, nm_dim);
     shape_copy[0]	= shape[0];
     shape_copy[1]	= 1;
 
   } else {
     nm_dim			= dim;
-    shape_copy	= ALLOC_N(size_t, nm_dim);
+    shape_copy	= NM_ALLOC_N(size_t, nm_dim);
     memcpy(shape_copy, shape, sizeof(size_t)*nm_dim);
   }
 
   // Copy elements
-  void* elements_copy = ALLOC_N(char, DTYPE_SIZES[dtype]*length);
+  void* elements_copy = NM_ALLOC_N(char, DTYPE_SIZES[dtype]*length);
   memcpy(elements_copy, elements, DTYPE_SIZES[dtype]*length);
 
   // allocate and create the matrix and its storage
   nm = nm_create(nm::DENSE_STORE, nm_dense_storage_create(dtype, shape_copy, dim, elements_copy, length));
 
+  nm_register_nmatrix(nm);
+
+  VALUE to_return = Data_Wrap_Struct(cNMatrix, nm_mark, nm_delete, nm);
+
+  nm_unregister_nmatrix(nm);
+  if (dtype == nm::RUBYOBJ) {
+    nm_unregister_values(reinterpret_cast<VALUE*>(elements), length);
+  }
+
   // tell Ruby about the matrix and its storage, particularly how to garbage collect it.
-  return Data_Wrap_Struct(cNMatrix, nm_mark, nm_delete, nm);
+  return to_return;
 }
 
 /*