nmatrix 0.1.0.rc4 → 0.1.0.rc5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7aab05ad51eae5a3ccba6312f79d75b624ccb6a2
-  data.tar.gz: d8a2d31cdf2290857458256724102588c4ef8da6
+  metadata.gz: 101aa626bcac374a9e9d435b01f81ce119df0589
+  data.tar.gz: 003a943f6e7a84371460c36cf7eec4b6e5edc732
 SHA512:
-  metadata.gz: b242f8f8603d5ff19c525c4f1ced681bf7766bff43d273e61de7497dc724867d74613da98fabe444dda4360d05bc4973d296422af62fe6013c75feec0f3c8f3c
-  data.tar.gz: ca9c9ac8ef252a35fcff3c3e9a405090711c47ecbc3ffe387e3e18861e6f1ddbf85654350e2c09616c11356705e8a2c234dd512fc9fb9780c60acb9dd08dd317
+  metadata.gz: 8caa3986e557c54d6040e86201537dce92c3db161a27d545059244a4e32b7dab2dd396962d1ac77724dffb499d9076aa6c9637dee688149fae7a072e2a03890e
+  data.tar.gz: 20fb3e32a7f7d59a02e20435ea80430ddddd20f6d479862ebc52e2dbc180ed17e0c1d35a3d9e7a7d65675ac0d382bed83b43a5cc3a1e9ea1478fbf66ba60dc52

data/Gemfile

@@ -2,8 +2,3 @@ source 'https://rubygems.org'
 gemspec
 
 gem 'packable', ">= 1.3.5"  # for Matlab IO
-
-group :development do
-  #gem 'narray', :path => "../narray"
-  #gem 'pry-debugger'
-end

data/History.txt

@@ -603,7 +603,7 @@
 
 * No major enhancements.
 
-* 1 minor enhancements:
+* 1 minor enhancement:
 
   * NMatrix#floor and #ceil implemented (by @v0dro)
 
@@ -612,3 +612,31 @@
   * Disallowed out-of-bounds rank calls (by @andrewcsmith)
 
   * Fixed rspec 3.0 conflict with rspec-longrun 1.0.1
+
+=== 0.1.0.rc5 / 2014-08-01
+
+* No major enhancements.
+
+* 1 minor enhancements:
+
+  * Added optional extension for generating homogeneous
+    transformation matrices for rotations and translations in three
+    dimensions
+
+* 3 bug fixes:
+
+  * Fixed rake install (by @duggiefresh)
+
+  * Fixed API problems which prevented NMatrix from working with
+    the SciRuby rb-gsl fork
+
+  * Fixed Yale #inject behavior (by @yoongkang)
+
+=== 0.1.0.rc6 / 2014-08-??
+
+* No major enhancements.
+
+* No minor enhancements.
+
+* No bug fixes.
+

data/Manifest.txt

@@ -16,6 +16,7 @@ lib/nmatrix/io/mat_reader.rb
 lib/nmatrix/io/point_cloud.rb
 lib/nmatrix/blas.rb
 lib/nmatrix/enumerate.rb
+lib/nmatrix/homogeneous.rb
 lib/nmatrix/lapack.rb
 lib/nmatrix/math.rb
 lib/nmatrix/monkeys.rb

data/README.rdoc

@@ -41,7 +41,7 @@ If you want to obtain the latest (development) code, you should generally do:
     bundle install
     bundle exec rake compile
     bundle exec rake repackage
-    gem install pkg/nmatrix-0.1.0.rc4.gem
+    gem install pkg/nmatrix-0.1.0.rc5.gem
 
 Detailed instructions are available for {Mac}[https://github.com/SciRuby/nmatrix/wiki/Installation#mac-os-x] and {Linux}[https://github.com/SciRuby/nmatrix/wiki/Installation#linux].
 We are currently working on Mavericks (Mac OS X) installation instructions, but in general, you'll need Homebrew and should

data/Rakefile

@@ -3,6 +3,9 @@
 require 'rubygems'
 require 'rubygems/package_task'
 require 'bundler'
+
+Bundler::GemHelper.install_tasks
+
 begin
   Bundler.setup(:default, :development)
 rescue Bundler::BundlerError => e
@@ -14,21 +17,16 @@ end
 require 'rake'
 require "rake/extensiontask"
 Rake::ExtensionTask.new do |ext|
-    ext.name = 'nmatrix'          
-    ext.ext_dir = 'ext/nmatrix' 
-    ext.lib_dir = 'lib/'             
-    ext.source_pattern = "**/*.{c,cpp, h}" 
+    ext.name = 'nmatrix'
+    ext.ext_dir = 'ext/nmatrix'
+    ext.lib_dir = 'lib/'
+    ext.source_pattern = "**/*.{c,cpp, h}"
 end
 
 gemspec = eval(IO.read("nmatrix.gemspec"))
 
 Gem::PackageTask.new(gemspec).define
 
-desc "install the gem locally"
-task :install => [:package] do
-  sh %{gem install pkg/nmatrix-#{NMatrix::VERSION}.gem}
-end
-
 require 'rspec/core/rake_task'
 require 'rspec/core'
 require 'rspec/core/rake_task'

data/ext/nmatrix/data/data.cpp

@@ -283,11 +283,11 @@ nm::RubyObject rubyobj_from_cval(void* val, nm::dtype_t dtype) {
  */
 void* rubyobj_to_cval(VALUE val, nm::dtype_t dtype) {
   size_t size =  DTYPE_SIZES[dtype];
-  NM_CONSERVATIVE(nm_register_value(val));
+  NM_CONSERVATIVE(nm_register_value(&val));
   void* ret_val = NM_ALLOC_N(char, size);
 
   rubyval_to_cval(val, dtype, ret_val);
-  NM_CONSERVATIVE(nm_unregister_value(val));
+  NM_CONSERVATIVE(nm_unregister_value(&val));
   return ret_val;
 }
 

data/ext/nmatrix/extconf.rb

@@ -86,7 +86,7 @@ end
 if RUBY_VERSION < '1.9'
   raise(NotImplementedError, "Sorry, you need at least Ruby 1.9!")
 else
-  $INSTALLFILES = [['nmatrix.h', '$(archdir)'], ['nmatrix.hpp', '$(archdir)'], ['nmatrix_config.h', '$(archdir)']]
+  $INSTALLFILES = [['nmatrix.h', '$(archdir)'], ['nmatrix.hpp', '$(archdir)'], ['nmatrix_config.h', '$(archdir)'], ['nm_memory.h', '$(archdir)']]
   if /cygwin|mingw/ =~ RUBY_PLATFORM
     $INSTALLFILES << ['libnmatrix.a', '$(archdir)']
   end

data/ext/nmatrix/math.cpp

@@ -586,8 +586,8 @@ static VALUE nm_cblas_rotg(VALUE self, VALUE ab) {
     return Qnil;
 
   } else {
-    NM_CONSERVATIVE(nm_register_value(self));
-    NM_CONSERVATIVE(nm_register_value(ab));
+    NM_CONSERVATIVE(nm_register_value(&self));
+    NM_CONSERVATIVE(nm_register_value(&ab));
     void *pC = NM_ALLOCA_N(char, DTYPE_SIZES[dtype]),
          *pS = NM_ALLOCA_N(char, DTYPE_SIZES[dtype]);
 
@@ -607,8 +607,8 @@ static VALUE nm_cblas_rotg(VALUE self, VALUE ab) {
       rb_ary_store(result, 0, rubyobj_from_cval(pC, dtype).rval);
       rb_ary_store(result, 1, rubyobj_from_cval(pS, dtype).rval);
     }
-    NM_CONSERVATIVE(nm_unregister_value(ab));
-    NM_CONSERVATIVE(nm_unregister_value(self));
+    NM_CONSERVATIVE(nm_unregister_value(&ab));
+    NM_CONSERVATIVE(nm_unregister_value(&self));
     return result;
   }
 }

data/ext/nmatrix/nmatrix.h

@@ -53,7 +53,9 @@
 	#endif
 #endif
 
-#include "nm_memory.h"
+#ifdef __cplusplus
+  #include "nm_memory.h"
+#endif
 
 /*
  * Macros
@@ -288,15 +290,15 @@ 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;
+NM_DEF_STRUCT_PRE(NM_GC_LL_NODE);       // struct NM_GC_LL_NODE {
+  VALUE* val;                           //   VALUE* val;
+  size_t n;                             //   size_t n;
+  NM_DECL_STRUCT(NM_GC_LL_NODE*, next); //   NM_GC_LL_NODE* next;
+NM_DEF_STRUCT_POST(NM_GC_LL_NODE);      // };
 
-typedef struct __NM_GC_HOLDER {
-  __NM_GC_LL_NODE* start;
-} nm_gc_holder;
+NM_DEF_STRUCT_PRE(NM_GC_HOLDER);        // struct NM_GC_HOLDER {
+  NM_DECL_STRUCT(NM_GC_LL_NODE*, start); //  NM_GC_LL_NODE* start;
+NM_DEF_STRUCT_POST(NM_GC_HOLDER);       // };
 
 #define NM_MAX_RANK 15
 
@@ -382,16 +384,17 @@ extern "C" {
 	void     nm_delete(NMATRIX* mat);
 	void     nm_delete_ref(NMATRIX* mat);
   void     nm_register_values(VALUE* vals, size_t n);
+  void     nm_register_value(VALUE* val);
+  void     nm_unregister_value(VALUE* val);
   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_storage(NM_DECL_ENUM(stype_t, stype), const STORAGE* storage);
+  void     nm_unregister_storage(NM_DECL_ENUM(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);
+  void	   nm_completely_unregister_value(VALUE* val);
 #ifdef __cplusplus
 }
+
 #endif
 
 #endif // NMATRIX_H

data/ext/nmatrix/ruby_nmatrix.c

@@ -428,7 +428,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));
+  NM_CONSERVATIVE(nm_register_value(&self));
   VALUE cap;
 
   switch(NM_STYPE(self)) {
@@ -497,15 +497,15 @@ void nm_delete_ref(NMATRIX* mat) {
  * 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
+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) {
+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;
+    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;
@@ -519,8 +519,8 @@ static void __nm_mark_value_container(nm_gc_holder* gc_value_holder_struct) {
  */
 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_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;
@@ -537,12 +537,12 @@ void nm_register_values(VALUE* values, size_t n) {
   if (!gc_value_holder_struct)
     __nm_initialize_value_container();
   if (values) {
-    nm_gc_ll_node* to_insert = NULL;
+    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 = NM_ALLOC_NONRUBY(NM_GC_LL_NODE);
     }
     to_insert->val = values;
     to_insert->n = n;
@@ -558,8 +558,8 @@ void nm_register_values(VALUE* values, size_t n) {
 void nm_unregister_values(VALUE* values, size_t n) {
   if (values) {
     if (gc_value_holder_struct) {
-      nm_gc_ll_node* curr = gc_value_holder_struct->start;
-      nm_gc_ll_node* last = NULL;
+      NM_GC_LL_NODE* curr = gc_value_holder_struct->start;
+      NM_GC_LL_NODE* last = NULL;
       while (curr) {
         if (curr->val == values) {
           if (last) {
@@ -580,18 +580,19 @@ void nm_unregister_values(VALUE* values, size_t n) {
   }
 }
 
+
 /**
  * Register a single VALUE as in use to avoid garbage collection.
  */
-void nm_register_value(VALUE& val) {
-  nm_register_values(&val, 1);
+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);
+void nm_unregister_value(VALUE* val) {
+  nm_unregister_values(val, 1);
 }
 
 /**
@@ -600,26 +601,26 @@ void nm_unregister_value(VALUE& val) {
  * freed and replaced so that and residual registrations won't access after
  * free.
  **/
-void nm_completely_unregister_value(VALUE& val) {
+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;
+    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;
+      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;
+        last = curr;
+        curr = curr->next;
       }
     }
   }
@@ -725,7 +726,7 @@ 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) {
-  NM_CONSERVATIVE(nm_register_value(nmatrix));
+  NM_CONSERVATIVE(nm_register_value(&nmatrix));
   VALUE to_return = Qnil;
 
   switch(NM_STYPE(nmatrix)) {
@@ -756,7 +757,7 @@ static VALUE nm_each_with_indices(VALUE nmatrix) {
  * i, j, ..., and the entry itself.
  */
 static VALUE nm_each_stored_with_indices(VALUE nmatrix) {
-  NM_CONSERVATIVE(nm_register_value(nmatrix));
+  NM_CONSERVATIVE(nm_register_value(&nmatrix));
   VALUE to_return = Qnil;
 
   switch(NM_STYPE(nmatrix)) {
@@ -788,7 +789,7 @@ static VALUE nm_each_stored_with_indices(VALUE nmatrix) {
  * i, j, ..., and the entry itself.
  */
 static VALUE nm_map_stored(VALUE nmatrix) {
-  NM_CONSERVATIVE(nm_register_value(nmatrix));
+  NM_CONSERVATIVE(nm_register_value(&nmatrix));
   VALUE to_return = Qnil;
 
   switch(NM_STYPE(nmatrix)) {
@@ -818,7 +819,7 @@ static VALUE nm_map_stored(VALUE nmatrix) {
  * than storage ordering, which only matters if your matrix is Yale.
  */
 static VALUE nm_each_ordered_stored_with_indices(VALUE nmatrix) {
-  NM_CONSERVATIVE(nm_register_value(nmatrix));
+  NM_CONSERVATIVE(nm_register_value(&nmatrix));
   VALUE to_return = Qnil;
 
   switch(NM_STYPE(nmatrix)) {
@@ -852,8 +853,8 @@ static VALUE nm_each_ordered_stored_with_indices(VALUE nmatrix) {
  * 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));
+  NM_CONSERVATIVE(nm_register_value(&left));
+  NM_CONSERVATIVE(nm_register_value(&right));
 
   NMATRIX *l, *r;
 
@@ -889,8 +890,8 @@ static VALUE nm_eqeq(VALUE left, VALUE right) {
     }
   }
 
-  NM_CONSERVATIVE(nm_unregister_value(left));
-  NM_CONSERVATIVE(nm_unregister_value(right));
+  NM_CONSERVATIVE(nm_unregister_value(&left));
+  NM_CONSERVATIVE(nm_unregister_value(&right));
 
   return result ? Qtrue : Qfalse;
 }
@@ -1104,7 +1105,7 @@ NMATRIX* nm_create(nm::stype_t stype, STORAGE* storage) {
  */
 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));
+  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
@@ -1126,9 +1127,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));
+  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);
@@ -1144,9 +1145,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));
+    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));
+    NM_CONSERVATIVE(nm_register_value(&default_val_num));
   }
 
   //     stype ||= :dense
@@ -1250,7 +1251,7 @@ static VALUE nm_init_new_version(int argc, VALUE* argv, VALUE self) {
     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);
+    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);
 
@@ -1262,7 +1263,7 @@ static VALUE nm_init_new_version(int argc, VALUE* argv, VALUE self) {
 
     // 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_value(&rb_tmp);
     nm_unregister_values(slice_argv, dim);
   }
 
@@ -1275,15 +1276,15 @@ static VALUE nm_init_new_version(int argc, VALUE* argv, VALUE self) {
   }
 
   if (!NIL_P(hash)) {
-    NM_CONSERVATIVE(nm_unregister_value(capacity_num));
-    NM_CONSERVATIVE(nm_unregister_value(default_val_num));
+    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(&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_value(&self));
   NM_CONSERVATIVE(nm_unregister_values(argv, argc));
   nm_unregister_storage(stype, nmatrix->storage);
 
@@ -1327,12 +1328,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_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));
+    NM_CONSERVATIVE(nm_unregister_value(&nm));
   	return nm_init_new_version(argc, argv, nm);
   }
 
@@ -1353,12 +1354,12 @@ static VALUE nm_init(int argc, VALUE* argv, VALUE nm) {
   if (argc == 7) {
     if (stype == nm::YALE_STORE) {
       NM_CONSERVATIVE(nm_unregister_values(argv, argc));
-      NM_CONSERVATIVE(nm_unregister_value(nm));
+      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 {
       NM_CONSERVATIVE(nm_unregister_values(argv, argc));
-      NM_CONSERVATIVE(nm_unregister_value(nm));
+      NM_CONSERVATIVE(nm_unregister_value(&nm));
       rb_raise(rb_eArgError, "Expected 2-4 arguments (or 7 for internal Yale creation)");
     }
   }
@@ -1440,7 +1441,7 @@ static VALUE nm_init(int argc, VALUE* argv, VALUE nm) {
   }
 
   NM_CONSERVATIVE(nm_unregister_values(argv, argc));
-  NM_CONSERVATIVE(nm_unregister_value(nm));
+  NM_CONSERVATIVE(nm_unregister_value(&nm));
 
   return nm;
 }
@@ -1474,8 +1475,8 @@ 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_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);
@@ -1494,8 +1495,8 @@ VALUE nm_cast(VALUE self, VALUE new_stype_symbol, VALUE new_dtype_symbol, VALUE
   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));
+  NM_CONSERVATIVE(nm_unregister_value(&self));
+  NM_CONSERVATIVE(nm_unregister_value(&init));
   return to_return;
 
 }
@@ -1504,7 +1505,7 @@ VALUE nm_cast(VALUE self, VALUE new_stype_symbol, VALUE new_dtype_symbol, VALUE
  * Copy constructor for transposing.
  */
 static VALUE nm_init_transposed(VALUE self) {
-  NM_CONSERVATIVE(nm_register_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,
@@ -1519,7 +1520,7 @@ static VALUE nm_init_transposed(VALUE self) {
   VALUE to_return = Data_Wrap_Struct(CLASS_OF(self), nm_mark, nm_delete, lhs);
 
   nm_unregister_nmatrix(lhs);
-  NM_CONSERVATIVE(nm_unregister_value(self));
+  NM_CONSERVATIVE(nm_unregister_value(&self));
   return to_return;
 }
 
@@ -1527,16 +1528,16 @@ static VALUE nm_init_transposed(VALUE self) {
  * 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));
+  NM_CONSERVATIVE(nm_register_value(&copy));
+  NM_CONSERVATIVE(nm_register_value(&original));
 
   NMATRIX *lhs, *rhs;
 
   CheckNMatrixType(original);
 
   if (copy == original) {
-    NM_CONSERVATIVE(nm_unregister_value(copy));
-    NM_CONSERVATIVE(nm_unregister_value(original));
+    NM_CONSERVATIVE(nm_unregister_value(&copy));
+    NM_CONSERVATIVE(nm_unregister_value(&original));
     return copy;
   }
 
@@ -1549,8 +1550,8 @@ 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));
+  NM_CONSERVATIVE(nm_unregister_value(&copy));
+  NM_CONSERVATIVE(nm_unregister_value(&original));
 
   return copy;
 }
@@ -1687,7 +1688,7 @@ static VALUE nm_write(int argc, VALUE* argv, VALUE self) {
   }
 
   NM_CONSERVATIVE(nm_register_values(argv, argc));
-  NM_CONSERVATIVE(nm_register_value(self));
+  NM_CONSERVATIVE(nm_register_value(&self));
 
   VALUE file = argv[0],
         symm = argc == 1 ? Qnil : argv[1];
@@ -1699,7 +1700,7 @@ static VALUE nm_write(int argc, VALUE* argv, VALUE self) {
 
   if (nmatrix->storage->dtype == nm::RUBYOBJ) {
     NM_CONSERVATIVE(nm_unregister_values(argv, argc));
-    NM_CONSERVATIVE(nm_unregister_value(self));
+    NM_CONSERVATIVE(nm_unregister_value(&self));
     rb_raise(rb_eNotImpError, "Ruby Object writing is not implemented yet");
   }
 
@@ -1714,12 +1715,12 @@ static VALUE nm_write(int argc, VALUE* argv, VALUE self) {
   // Check arguments before starting to write.
   if (nmatrix->stype == nm::LIST_STORE) {
     NM_CONSERVATIVE(nm_unregister_values(argv, argc));
-    NM_CONSERVATIVE(nm_unregister_value(self));
+    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));
+    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])
@@ -1768,7 +1769,7 @@ 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));
+  NM_CONSERVATIVE(nm_unregister_value(&self));
 
   return Qtrue;
 }
@@ -1788,7 +1789,7 @@ 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));
+  NM_CONSERVATIVE(nm_register_value(&self));
 
   VALUE file, force_;
 
@@ -1799,7 +1800,7 @@ 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));
+    NM_CONSERVATIVE(nm_unregister_value(&self));
     rb_raise(rb_get_errno_exc("ENOENT"), "%s", RSTRING_PTR(file));
   }
 
@@ -1821,7 +1822,7 @@ static VALUE nm_read(int argc, VALUE* argv, VALUE self) {
       fver = fmajor * 10000 + fminor * 100 + release;
   if (fver > ver && force == false) {
     NM_CONSERVATIVE(nm_unregister_values(argv, argc));
-    NM_CONSERVATIVE(nm_unregister_value(self));
+    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) rb_warn("nm_read: Expected zero padding was not zero (0)\n");
@@ -1868,7 +1869,7 @@ static VALUE nm_read(int argc, VALUE* argv, VALUE self) {
     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));
+    NM_CONSERVATIVE(nm_unregister_value(&self));
     rb_raise(nm_eStorageTypeError, "please convert to yale or dense before saving");
   }
 
@@ -1882,7 +1883,7 @@ static VALUE nm_read(int argc, VALUE* argv, VALUE self) {
 
   nm_unregister_nmatrix(nm);
   NM_CONSERVATIVE(nm_unregister_values(argv, argc));
-  NM_CONSERVATIVE(nm_unregister_value(self));
+  NM_CONSERVATIVE(nm_unregister_value(&self));
   nm_unregister_storage(stype, s);
 
   switch(stype) {
@@ -1987,7 +1988,7 @@ static VALUE nm_mset(int argc, VALUE* argv, VALUE self) {
   if ((size_t)(argc) > NM_DIM(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_value(&self));
     NM_CONSERVATIVE(nm_register_values(argv, argc));
 
     SLICE* slice = get_slice(dim, argc-1, argv, NM_STORAGE(self)->shape);
@@ -2004,7 +2005,7 @@ static VALUE nm_mset(int argc, VALUE* argv, VALUE self) {
 
     to_return = argv[argc-1];
 
-    NM_CONSERVATIVE(nm_unregister_value(self));
+    NM_CONSERVATIVE(nm_unregister_value(&self));
     NM_CONSERVATIVE(nm_unregister_values(argv, argc));
   }
 
@@ -2019,22 +2020,22 @@ 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));
+  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)) {
-    NM_CONSERVATIVE(nm_unregister_value(left_v));
-    NM_CONSERVATIVE(nm_unregister_value(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) {
-    NM_CONSERVATIVE(nm_unregister_value(left_v));
-    NM_CONSERVATIVE(nm_unregister_value(right_v));
+    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");
   }
 
@@ -2045,38 +2046,38 @@ static VALUE nm_multiply(VALUE left_v, VALUE right_v) {
     // work like vector dot product for 1dim
     if (left->storage->dim == 1 && right->storage->dim == 1) {
       if (left->storage->shape[0] != right->storage->shape[0]) {
-        NM_CONSERVATIVE(nm_unregister_value(left_v));
-        NM_CONSERVATIVE(nm_unregister_value(right_v));
+        NM_CONSERVATIVE(nm_unregister_value(&left_v));
+        NM_CONSERVATIVE(nm_unregister_value(&right_v));
         rb_raise(rb_eArgError, "The left- and right-hand sides of the operation must have the same dimensionality.");
       } else {
         VALUE result = elementwise_op(nm::EW_MUL, left_v, right_v);
         VALUE to_return = rb_funcall(result, rb_intern("sum"),0);
-        NM_CONSERVATIVE(nm_unregister_value(left_v));
-        NM_CONSERVATIVE(nm_unregister_value(right_v));
+        NM_CONSERVATIVE(nm_unregister_value(&left_v));
+        NM_CONSERVATIVE(nm_unregister_value(&right_v));
         return to_return;
       }
     }
 
     if (left->storage->shape[1] != right->storage->shape[0]) {
-      NM_CONSERVATIVE(nm_unregister_value(left_v));
-      NM_CONSERVATIVE(nm_unregister_value(right_v));
+      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) {
-      NM_CONSERVATIVE(nm_unregister_value(left_v));
-      NM_CONSERVATIVE(nm_unregister_value(right_v));
+      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));
+    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));
+  NM_CONSERVATIVE(nm_unregister_value(&left_v));
+  NM_CONSERVATIVE(nm_unregister_value(&right_v));
 
   return Qnil;
 }
@@ -2104,7 +2105,7 @@ 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));
+  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.
@@ -2114,7 +2115,7 @@ static VALUE nm_shape(VALUE self) {
     shape[index] = INT2FIX(s->shape[index]);
 
   nm_unregister_values(shape, s->dim);
-  NM_CONSERVATIVE(nm_unregister_value(self));
+  NM_CONSERVATIVE(nm_unregister_value(&self));
   return rb_ary_new4(s->dim, shape);
 }
 
@@ -2126,7 +2127,7 @@ 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));
+  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.
@@ -2136,7 +2137,7 @@ static VALUE nm_offset(VALUE self) {
     offset[index] = INT2FIX(s->offset[index]);
 
   nm_unregister_values(offset, s->dim);
-  NM_CONSERVATIVE(nm_unregister_value(self));
+  NM_CONSERVATIVE(nm_unregister_value(&self));
   return rb_ary_new4(s->dim, offset);
 }
 
@@ -2155,7 +2156,7 @@ static VALUE nm_supershape(VALUE self) {
   }
   else s = s->src;
 
-  NM_CONSERVATIVE(nm_register_value(self));
+  NM_CONSERVATIVE(nm_register_value(&self));
 
   VALUE* shape = NM_ALLOCA_N(VALUE, s->dim);
   nm_register_values(shape, s->dim);
@@ -2163,7 +2164,7 @@ static VALUE nm_supershape(VALUE self) {
     shape[index] = INT2FIX(s->shape[index]);
 
   nm_unregister_values(shape, s->dim);
-  NM_CONSERVATIVE(nm_unregister_value(self));
+  NM_CONSERVATIVE(nm_unregister_value(&self));
   return rb_ary_new4(s->dim, shape);
 }
 
@@ -2174,9 +2175,9 @@ 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) {
-  NM_CONSERVATIVE(nm_register_value(self));
+  NM_CONSERVATIVE(nm_register_value(&self));
   VALUE stype = ID2SYM(rb_intern(STYPE_NAMES[NM_STYPE(self)]));
-  NM_CONSERVATIVE(nm_unregister_value(self));
+  NM_CONSERVATIVE(nm_unregister_value(&self));
   return stype;
 }
 
@@ -2227,9 +2228,9 @@ static VALUE nm_xslice(int argc, VALUE* argv, void* (*slice_func)(const STORAGE*
   } else {
 
     NM_CONSERVATIVE(nm_register_values(argv, argc));
-    NM_CONSERVATIVE(nm_register_value(self));
+    NM_CONSERVATIVE(nm_register_value(&self));
 
-    nm_register_value(result);
+    nm_register_value(&result);
 
     SLICE* slice = get_slice(NM_DIM(self), argc, argv, s->shape);
 
@@ -2256,9 +2257,9 @@ static VALUE nm_xslice(int argc, VALUE* argv, void* (*slice_func)(const STORAGE*
     free_slice(slice);
   }
 
-  nm_unregister_value(result);
+  nm_unregister_value(&result);
   NM_CONSERVATIVE(nm_unregister_values(argv, argc));
-  NM_CONSERVATIVE(nm_unregister_value(self));
+  NM_CONSERVATIVE(nm_unregister_value(&self));
 
   return result;
 }
@@ -2268,7 +2269,7 @@ static VALUE nm_xslice(int argc, VALUE* argv, void* (*slice_func)(const STORAGE*
 //////////////////////
 
 static VALUE unary_op(nm::unaryop_t op, VALUE self) {
-  NM_CONSERVATIVE(nm_register_value(self));
+  NM_CONSERVATIVE(nm_register_value(&self));
   NMATRIX* left;
   UnwrapNMatrix(self, left);
   std::string sym;
@@ -2285,7 +2286,7 @@ static VALUE unary_op(nm::unaryop_t op, VALUE self) {
     break;
   }
 
-  NM_CONSERVATIVE(nm_unregister_value(self));
+  NM_CONSERVATIVE(nm_unregister_value(&self));
   return rb_funcall(self, rb_intern(sym.c_str()), 0);
 }
 
@@ -2302,8 +2303,8 @@ static void check_dims_and_shape(VALUE left_val, VALUE right_val) {
 
 static VALUE elementwise_op(nm::ewop_t op, VALUE left_val, VALUE right_val) {
 
-  NM_CONSERVATIVE(nm_register_value(left_val));
-  NM_CONSERVATIVE(nm_register_value(right_val));
+  NM_CONSERVATIVE(nm_register_value(&left_val));
+  NM_CONSERVATIVE(nm_register_value(&right_val));
 
   NMATRIX* left;
   NMATRIX* result;
@@ -2325,13 +2326,13 @@ 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));
+      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");
     }
     VALUE symv = rb_intern(sym.c_str());
-    NM_CONSERVATIVE(nm_unregister_value(left_val));
-    NM_CONSERVATIVE(nm_unregister_value(right_val));
+    NM_CONSERVATIVE(nm_unregister_value(&left_val));
+    NM_CONSERVATIVE(nm_unregister_value(&right_val));
     return rb_funcall(left_val, symv, 1, right_val);
 
   } else {
@@ -2355,32 +2356,32 @@ 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));
+        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");
       }
 
       VALUE symv = rb_intern(sym.c_str());
-      NM_CONSERVATIVE(nm_unregister_value(left_val));
-      NM_CONSERVATIVE(nm_unregister_value(right_val));
+      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));
+      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.");
     }
   }
 
-  NM_CONSERVATIVE(nm_unregister_value(left_val));
-  NM_CONSERVATIVE(nm_unregister_value(right_val));
+  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));
+  NM_CONSERVATIVE(nm_register_value(&self));
+  NM_CONSERVATIVE(nm_register_value(&other));
 
   NMATRIX* self_nm;
   NMATRIX* result;
@@ -2402,12 +2403,12 @@ static VALUE noncom_elementwise_op(nm::noncom_ewop_t op, VALUE self, VALUE other
       sym = "__list_scalar_" + nm::NONCOM_EWOP_NAMES[op] + "__";
       break;
     default:
-      NM_CONSERVATIVE(nm_unregister_value(self));
-      NM_CONSERVATIVE(nm_unregister_value(other));
+      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));
+    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 {
@@ -2431,22 +2432,22 @@ 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));
+	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));
+      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);
+      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));
+  NM_CONSERVATIVE(nm_unregister_value(&self));
+  NM_CONSERVATIVE(nm_unregister_value(&other));
   return Data_Wrap_Struct(CLASS_OF(self), nm_mark, nm_delete, result);
 }
 
@@ -2461,7 +2462,7 @@ 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));
+  NM_CONSERVATIVE(nm_register_value(&self));
 
   NMATRIX* m;
   UnwrapNMatrix(self, m);
@@ -2477,12 +2478,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));
+      NM_CONSERVATIVE(nm_unregister_value(&self));
       rb_raise(rb_eNotImpError, "symmetric? and hermitian? only implemented for dense currently");
     }
 
   }
-  NM_CONSERVATIVE(nm_unregister_value(self));
+  NM_CONSERVATIVE(nm_unregister_value(&self));
   return Qfalse;
 }
 
@@ -2524,10 +2525,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_CONSERVATIVE(nm_register_value(vv));
+  NM_CONSERVATIVE(nm_register_value(&vv));
   nm::Rational128* v = NM_ALLOCA_N(nm::Rational128, 1);
   rubyval_to_cval(vv, nm::RATIONAL128, v);
-  NM_CONSERVATIVE(nm_unregister_value(vv));
+  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;
@@ -2685,7 +2686,7 @@ static SLICE* get_slice(size_t dim, int argc, VALUE* arg, size_t* shape) {
 
     } 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);
+      nm_register_value(&begin_end);
 
       if (rb_ary_entry(begin_end, 0) >= 0)
         slice->coords[r]  = FIX2INT(rb_ary_entry(begin_end, 0));
@@ -2698,7 +2699,7 @@ static SLICE* get_slice(size_t dim, int argc, VALUE* arg, size_t* shape) {
 
       if (RHASH_EMPTY_P(v)) t++; // go on to the next
       slice->single = false;
-      nm_unregister_value(begin_end);
+      nm_unregister_value(&begin_end);
 
     } else if (CLASS_OF(v) == rb_cRange) {
       rb_range_values(arg[t], &beg, &end, &excl);
@@ -2786,7 +2787,7 @@ 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));
+  NM_CONSERVATIVE(nm_register_value(&arg));
 
   unsigned int index;
   void* init_val;
@@ -2804,7 +2805,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));
+  NM_CONSERVATIVE(nm_unregister_value(&arg));
   return init_val;
 }
 
@@ -2815,7 +2816,7 @@ 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));
+  NM_CONSERVATIVE(nm_register_value(&arg));
   size_t* shape;
 
   if (TYPE(arg) == T_ARRAY) {
@@ -2834,11 +2835,11 @@ static size_t* interpret_shape(VALUE arg, size_t* dim) {
     shape[1] = FIX2UINT(arg);
 
   } else {
-    nm_unregister_value(arg);
+    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));
+  NM_CONSERVATIVE(nm_unregister_value(&arg));
   return shape;
 }
 
@@ -2987,7 +2988,7 @@ static VALUE nm_det_exact(VALUE self) {
     return Qnil;
   }
 
-  NM_CONSERVATIVE(nm_register_value(self));
+  NM_CONSERVATIVE(nm_register_value(&self));
 
   // Calculate the determinant and then assign it to the return value
   void* result = NM_ALLOCA_N(char, DTYPE_SIZES[NM_DTYPE(self)]);
@@ -3001,7 +3002,7 @@ static VALUE nm_det_exact(VALUE self) {
   if (dtype == nm::RUBYOBJ) {
     nm_unregister_values(reinterpret_cast<VALUE*>(result), 1);
   }
-  NM_CONSERVATIVE(nm_unregister_value(self));
+  NM_CONSERVATIVE(nm_unregister_value(&self));
 
   return to_return;
 }