nmatrix 0.1.0.rc4 → 0.1.0.rc5

data/ext/nmatrix/storage/yale/class.h

@@ -362,7 +362,7 @@ public:
    */
   void insert(SLICE* slice, VALUE right) {
 
-    NM_CONSERVATIVE(nm_register_value(right));
+    NM_CONSERVATIVE(nm_register_value(&right));
 
     std::pair<NMATRIX*,bool> nm_and_free =
       interpret_arg_as_dense_nmatrix(right, dtype());
@@ -410,7 +410,7 @@ public:
       }
     } else NM_FREE(v);
 
-    NM_CONSERVATIVE(nm_unregister_value(right));
+    NM_CONSERVATIVE(nm_unregister_value(&right));
   }
 
 
@@ -843,11 +843,11 @@ public:
    */
   template <typename E>
   VALUE map_merged_stored(VALUE klass, nm::YaleStorage<E>& t, VALUE r_init) const {
-    nm_register_value(r_init);
+    nm_register_value(&r_init);
     VALUE s_init    = const_default_value(),
           t_init    = t.const_default_value();
-    nm_register_value(s_init);
-    nm_register_value(t_init);
+    nm_register_value(&s_init);
+    nm_register_value(&t_init);
     
     // Make a reasonable approximation of the resulting capacity
     size_t s_ndnz   = count_copy_ndnz(),
@@ -861,9 +861,9 @@ public:
     YALE_STORAGE* rs= YaleStorage<nm::RubyObject>::create(xshape, reserve);
 
     if (r_init == Qnil) {
-      nm_unregister_value(r_init);
+      nm_unregister_value(&r_init);
       r_init       = rb_yield_values(2, s_init, t_init);
-      nm_register_value(r_init);
+      nm_register_value(&r_init);
     }
 
     nm::RubyObject r_init_obj(r_init);
@@ -874,13 +874,13 @@ public:
     nm_register_nmatrix(m);
     VALUE result   = Data_Wrap_Struct(klass, nm_mark, nm_delete, m);
     nm_unregister_nmatrix(m);
-    nm_register_value(result);
-    nm_unregister_value(r_init);
+    nm_register_value(&result);
+    nm_unregister_value(&r_init);
 
     RETURN_SIZED_ENUMERATOR_PRE
-    nm_unregister_value(result);
-    nm_unregister_value(t_init);
-    nm_unregister_value(s_init);
+    nm_unregister_value(&result);
+    nm_unregister_value(&t_init);
+    nm_unregister_value(&s_init);
     // No obvious, efficient way to pass a length function as the fourth argument here:
     RETURN_SIZED_ENUMERATOR(result, 0, 0, 0);
 
@@ -924,9 +924,9 @@ public:
         //RB_P(rb_funcall(result, rb_intern("yale_ija"), 0));
       }
     }
-    nm_unregister_value(result);
-    nm_unregister_value(t_init);
-    nm_unregister_value(s_init);
+    nm_unregister_value(&result);
+    nm_unregister_value(&t_init);
+    nm_unregister_value(&s_init);
 
     return result;
   }

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

@@ -891,13 +891,13 @@ public:
 // Helper function used only for the RETURN_SIZED_ENUMERATOR macro. Returns the length of
 // the matrix's storage.
 static VALUE nm_yale_stored_enumerator_length(VALUE nmatrix) {
-  NM_CONSERVATIVE(nm_register_value(nmatrix));
+  NM_CONSERVATIVE(nm_register_value(&nmatrix));
   YALE_STORAGE* s   = NM_STORAGE_YALE(nmatrix);
   YALE_STORAGE* src = s->src == s ? s : reinterpret_cast<YALE_STORAGE*>(s->src);
   size_t ia_size    = src->shape[0];
   // FIXME: This needs to be corrected for slicing.
   size_t len = std::min( s->shape[0] + s->offset[0], s->shape[1] + s->offset[1] ) + nm_yale_storage_get_size(src) -  ia_size;
-  NM_CONSERVATIVE(nm_unregister_value(nmatrix));
+  NM_CONSERVATIVE(nm_unregister_value(&nmatrix));
   return INT2FIX(len);
 }
 
@@ -905,32 +905,32 @@ static VALUE nm_yale_stored_enumerator_length(VALUE nmatrix) {
 // Helper function used only for the RETURN_SIZED_ENUMERATOR macro. Returns the length of
 // the matrix's storage.
 static VALUE nm_yale_stored_nondiagonal_enumerator_length(VALUE nmatrix) {
-  NM_CONSERVATIVE(nm_register_value(nmatrix));
+  NM_CONSERVATIVE(nm_register_value(&nmatrix));
   YALE_STORAGE* s = NM_STORAGE_YALE(nmatrix);
   if (s->src != s) s = reinterpret_cast<YALE_STORAGE*>(s->src);  // need to get the original storage shape
 
   size_t ia_size = s->shape[0];
   size_t len     = nm_yale_storage_get_size(NM_STORAGE_YALE(nmatrix)) - ia_size;
-  NM_CONSERVATIVE(nm_unregister_value(nmatrix));
+  NM_CONSERVATIVE(nm_unregister_value(&nmatrix));
   return INT2FIX(len);
 }
 
 // Helper function for diagonal length.
 static VALUE nm_yale_stored_diagonal_enumerator_length(VALUE nmatrix) {
-  NM_CONSERVATIVE(nm_register_value(nmatrix));
+  NM_CONSERVATIVE(nm_register_value(&nmatrix));
   YALE_STORAGE* s = NM_STORAGE_YALE(nmatrix);
   size_t len = std::min( s->shape[0] + s->offset[0], s->shape[1] + s->offset[1] );
-  NM_CONSERVATIVE(nm_unregister_value(nmatrix));
+  NM_CONSERVATIVE(nm_unregister_value(&nmatrix));
   return INT2FIX(len);
 }
 
 
 // Helper function for full enumerator length.
 static VALUE nm_yale_enumerator_length(VALUE nmatrix) {
-  NM_CONSERVATIVE(nm_register_value(nmatrix));
+  NM_CONSERVATIVE(nm_register_value(&nmatrix));
   YALE_STORAGE* s = NM_STORAGE_YALE(nmatrix);
   size_t len = s->shape[0] * s->shape[1];
-  NM_CONSERVATIVE(nm_unregister_value(nmatrix));
+  NM_CONSERVATIVE(nm_unregister_value(&nmatrix));
   return INT2FIX(len);
 }
 
@@ -940,12 +940,12 @@ static VALUE nm_yale_enumerator_length(VALUE nmatrix) {
  */
 template <typename D>
 static VALUE map_stored(VALUE self) {
-  NM_CONSERVATIVE(nm_register_value(self));
+  NM_CONSERVATIVE(nm_register_value(&self));
   YALE_STORAGE* s = NM_STORAGE_YALE(self);
   YaleStorage<D> y(s);
   
   RETURN_SIZED_ENUMERATOR_PRE
-  NM_CONSERVATIVE(nm_unregister_value(self));
+  NM_CONSERVATIVE(nm_unregister_value(&self));
   RETURN_SIZED_ENUMERATOR(self, 0, 0, nm_yale_stored_enumerator_length);
 
   YALE_STORAGE* r = y.template alloc_copy<nm::RubyObject, true>();
@@ -953,7 +953,7 @@ static VALUE map_stored(VALUE self) {
   NMATRIX* m      = nm_create(nm::YALE_STORE, reinterpret_cast<STORAGE*>(r));
   VALUE to_return = Data_Wrap_Struct(CLASS_OF(self), nm_mark, nm_delete, m);
   nm_yale_storage_unregister(r);
-  NM_CONSERVATIVE(nm_unregister_value(self));
+  NM_CONSERVATIVE(nm_unregister_value(&self));
   return to_return;
 }
 
@@ -975,13 +975,13 @@ static VALUE map_merged_stored(VALUE left, VALUE right, VALUE init) {
  */
 template <typename DType>
 static VALUE each_stored_with_indices(VALUE nm) {
-  NM_CONSERVATIVE(nm_register_value(nm));
+  NM_CONSERVATIVE(nm_register_value(&nm));
   YALE_STORAGE* s = NM_STORAGE_YALE(nm);
   YaleStorage<DType> y(s);
 
   // If we don't have a block, return an enumerator.
   RETURN_SIZED_ENUMERATOR_PRE
-  NM_CONSERVATIVE(nm_unregister_value(nm));
+  NM_CONSERVATIVE(nm_unregister_value(&nm));
   RETURN_SIZED_ENUMERATOR(nm, 0, 0, nm_yale_stored_enumerator_length);
 
   for (typename YaleStorage<DType>::const_stored_diagonal_iterator d = y.csdbegin(); d != y.csdend(); ++d) {
@@ -994,7 +994,7 @@ static VALUE each_stored_with_indices(VALUE nm) {
     }
   }
 
-  NM_CONSERVATIVE(nm_unregister_value(nm));
+  NM_CONSERVATIVE(nm_unregister_value(&nm));
 
   return nm;
 }
@@ -1005,21 +1005,21 @@ static VALUE each_stored_with_indices(VALUE nm) {
  */
 template <typename DType>
 static VALUE stored_diagonal_each_with_indices(VALUE nm) {
-  NM_CONSERVATIVE(nm_register_value(nm));
+  NM_CONSERVATIVE(nm_register_value(&nm));
 
   YALE_STORAGE* s = NM_STORAGE_YALE(nm);
   YaleStorage<DType> y(s);
 
   // If we don't have a block, return an enumerator.
   RETURN_SIZED_ENUMERATOR_PRE
-  NM_CONSERVATIVE(nm_unregister_value(nm));
+  NM_CONSERVATIVE(nm_unregister_value(&nm));
   RETURN_SIZED_ENUMERATOR(nm, 0, 0, nm_yale_stored_diagonal_length); // FIXME: need diagonal length
   
   for (typename YaleStorage<DType>::const_stored_diagonal_iterator d = y.csdbegin(); d != y.csdend(); ++d) {
     rb_yield_values(3, ~d, d.rb_i(), d.rb_j());
   }
 
-  NM_CONSERVATIVE(nm_unregister_value(nm));
+  NM_CONSERVATIVE(nm_unregister_value(&nm));
 
   return nm;
 }
@@ -1030,14 +1030,14 @@ static VALUE stored_diagonal_each_with_indices(VALUE nm) {
  */
 template <typename DType>
 static VALUE stored_nondiagonal_each_with_indices(VALUE nm) {
-  NM_CONSERVATIVE(nm_register_value(nm));
+  NM_CONSERVATIVE(nm_register_value(&nm));
 
   YALE_STORAGE* s = NM_STORAGE_YALE(nm);
   YaleStorage<DType> y(s);
 
   // If we don't have a block, return an enumerator.
   RETURN_SIZED_ENUMERATOR_PRE
-  NM_CONSERVATIVE(nm_unregister_value(nm));
+  NM_CONSERVATIVE(nm_unregister_value(&nm));
   RETURN_SIZED_ENUMERATOR(nm, 0, 0, 0); // FIXME: need diagonal length
 
   for (typename YaleStorage<DType>::const_row_iterator it = y.cribegin(); it != y.criend(); ++it) {
@@ -1046,7 +1046,7 @@ static VALUE stored_nondiagonal_each_with_indices(VALUE nm) {
     }
   }
 
-  NM_CONSERVATIVE(nm_unregister_value(nm));
+  NM_CONSERVATIVE(nm_unregister_value(&nm));
 
   return nm;
 }
@@ -1057,14 +1057,14 @@ static VALUE stored_nondiagonal_each_with_indices(VALUE nm) {
  */
 template <typename DType>
 static VALUE each_ordered_stored_with_indices(VALUE nm) {
-  NM_CONSERVATIVE(nm_register_value(nm));
+  NM_CONSERVATIVE(nm_register_value(&nm));
 
   YALE_STORAGE* s = NM_STORAGE_YALE(nm);
   YaleStorage<DType> y(s);
 
   // If we don't have a block, return an enumerator.
   RETURN_SIZED_ENUMERATOR_PRE
-  NM_CONSERVATIVE(nm_unregister_value(nm));
+  NM_CONSERVATIVE(nm_unregister_value(&nm));
   RETURN_SIZED_ENUMERATOR(nm, 0, 0, nm_yale_stored_enumerator_length);
 
   for (typename YaleStorage<DType>::const_row_iterator it = y.cribegin(); it != y.criend(); ++it) {
@@ -1073,7 +1073,7 @@ static VALUE each_ordered_stored_with_indices(VALUE nm) {
     }
   }
 
-  NM_CONSERVATIVE(nm_unregister_value(nm));
+  NM_CONSERVATIVE(nm_unregister_value(&nm));
 
   return nm;
 }
@@ -1081,21 +1081,21 @@ static VALUE each_ordered_stored_with_indices(VALUE nm) {
 
 template <typename DType>
 static VALUE each_with_indices(VALUE nm) {
-  NM_CONSERVATIVE(nm_register_value(nm));
+  NM_CONSERVATIVE(nm_register_value(&nm));
 
   YALE_STORAGE* s = NM_STORAGE_YALE(nm);
   YaleStorage<DType> y(s);
 
   // If we don't have a block, return an enumerator.
   RETURN_SIZED_ENUMERATOR_PRE
-  NM_CONSERVATIVE(nm_unregister_value(nm));
+  NM_CONSERVATIVE(nm_unregister_value(&nm));
   RETURN_SIZED_ENUMERATOR(nm, 0, 0, nm_yale_enumerator_length);
 
   for (typename YaleStorage<DType>::const_iterator iter = y.cbegin(); iter != y.cend(); ++iter) {
     rb_yield_values(3, ~iter, iter.rb_i(), iter.rb_j());
   }
 
-  NM_CONSERVATIVE(nm_unregister_value(nm));
+  NM_CONSERVATIVE(nm_unregister_value(&nm));
 
   return nm;
 }
@@ -1556,12 +1556,12 @@ static bool is_pos_default_value(YALE_STORAGE* s, size_t apos) {
  */
 static VALUE nm_row_keys_intersection(VALUE m1, VALUE ii1, VALUE m2, VALUE ii2) {
   
-  NM_CONSERVATIVE(nm_register_value(m1));
-  NM_CONSERVATIVE(nm_register_value(m2));
+  NM_CONSERVATIVE(nm_register_value(&m1));
+  NM_CONSERVATIVE(nm_register_value(&m2));
 
   if (NM_SRC(m1) != NM_STORAGE(m1) || NM_SRC(m2) != NM_STORAGE(m2)) {
-    NM_CONSERVATIVE(nm_unregister_value(m2));
-    NM_CONSERVATIVE(nm_unregister_value(m1));
+    NM_CONSERVATIVE(nm_unregister_value(&m2));
+    NM_CONSERVATIVE(nm_unregister_value(&m1));
     rb_raise(rb_eNotImpError, "must be called on a real matrix and not a slice");
   }
 
@@ -1586,7 +1586,7 @@ static VALUE nm_row_keys_intersection(VALUE m1, VALUE ii1, VALUE m2, VALUE ii2)
 
   // Reserve max(diff1,diff2) space -- that's the max intersection possible.
   VALUE ret = rb_ary_new2(std::max(diff1,diff2)+1);
-  nm_register_value(ret);
+  nm_register_value(&ret);
 
   // Handle once the special case where both have the diagonal in exactly
   // the same place.
@@ -1628,9 +1628,9 @@ static VALUE nm_row_keys_intersection(VALUE m1, VALUE ii1, VALUE m2, VALUE ii2)
     if (t->ija[idx2] == i1) rb_ary_push(ret, INT2FIX(i1));
   }
 
-  nm_unregister_value(ret);
-  NM_CONSERVATIVE(nm_unregister_value(m1));
-  NM_CONSERVATIVE(nm_unregister_value(m2));
+  nm_unregister_value(&ret);
+  NM_CONSERVATIVE(nm_unregister_value(&m1));
+  NM_CONSERVATIVE(nm_unregister_value(&m2));
 
   return ret;
 }
@@ -1644,11 +1644,11 @@ static VALUE nm_row_keys_intersection(VALUE m1, VALUE ii1, VALUE m2, VALUE ii2)
  * Get the A array of a Yale matrix (which stores the diagonal and the LU portions of the matrix).
  */
 static VALUE nm_a(int argc, VALUE* argv, VALUE self) {
-  NM_CONSERVATIVE(nm_register_value(self));
+  NM_CONSERVATIVE(nm_register_value(&self));
 
   VALUE idx;
   rb_scan_args(argc, argv, "01", &idx);
-  NM_CONSERVATIVE(nm_register_value(idx));
+  NM_CONSERVATIVE(nm_register_value(&idx));
 
   YALE_STORAGE* s = reinterpret_cast<YALE_STORAGE*>(NM_SRC(self));
   size_t size = nm_yale_storage_get_size(s);
@@ -1674,13 +1674,13 @@ static VALUE nm_a(int argc, VALUE* argv, VALUE self) {
       rb_ary_push(ary, Qnil);
 
     nm_unregister_values(vals, size);
-    NM_CONSERVATIVE(nm_unregister_value(idx));
-    NM_CONSERVATIVE(nm_unregister_value(self));
+    NM_CONSERVATIVE(nm_unregister_value(&idx));
+    NM_CONSERVATIVE(nm_unregister_value(&self));
     return ary;
   } else {
     size_t index = FIX2INT(idx);
-    NM_CONSERVATIVE(nm_unregister_value(idx));
-    NM_CONSERVATIVE(nm_unregister_value(self));
+    NM_CONSERVATIVE(nm_unregister_value(&idx));
+    NM_CONSERVATIVE(nm_unregister_value(&self));
     if (index >= size) rb_raise(rb_eRangeError, "out of range");
     return rubyobj_from_cval((char*)(s->a) + DTYPE_SIZES[s->dtype] * index, s->dtype).rval;
   }
@@ -1695,10 +1695,10 @@ static VALUE nm_a(int argc, VALUE* argv, VALUE self) {
  * Get the diagonal ("D") portion of the A array of a Yale matrix.
  */
 static VALUE nm_d(int argc, VALUE* argv, VALUE self) {
-  NM_CONSERVATIVE(nm_register_value(self));
+  NM_CONSERVATIVE(nm_register_value(&self));
   VALUE idx;
   rb_scan_args(argc, argv, "01", &idx);
-  NM_CONSERVATIVE(nm_register_value(idx));
+  NM_CONSERVATIVE(nm_register_value(&idx));
 
   YALE_STORAGE* s = reinterpret_cast<YALE_STORAGE*>(NM_SRC(self));
 
@@ -1717,14 +1717,14 @@ static VALUE nm_d(int argc, VALUE* argv, VALUE self) {
       }
     }
     nm_unregister_values(vals, s->shape[0]);
-    NM_CONSERVATIVE(nm_unregister_value(idx));
-    NM_CONSERVATIVE(nm_unregister_value(self));
+    NM_CONSERVATIVE(nm_unregister_value(&idx));
+    NM_CONSERVATIVE(nm_unregister_value(&self));
 
     return rb_ary_new4(s->shape[0], vals);
   } else {
     size_t index = FIX2INT(idx);
-    NM_CONSERVATIVE(nm_unregister_value(idx));
-    NM_CONSERVATIVE(nm_unregister_value(self));
+    NM_CONSERVATIVE(nm_unregister_value(&idx));
+    NM_CONSERVATIVE(nm_unregister_value(&self));
     if (index >= s->shape[0]) rb_raise(rb_eRangeError, "out of range");
     return rubyobj_from_cval((char*)(s->a) + DTYPE_SIZES[s->dtype] * index, s->dtype).rval;
   }
@@ -1737,7 +1737,7 @@ static VALUE nm_d(int argc, VALUE* argv, VALUE self) {
  * Get the non-diagonal ("LU") portion of the A array of a Yale matrix.
  */
 static VALUE nm_lu(VALUE self) {
-  NM_CONSERVATIVE(nm_register_value(self));
+  NM_CONSERVATIVE(nm_register_value(&self));
 
   YALE_STORAGE* s = reinterpret_cast<YALE_STORAGE*>(NM_SRC(self));
 
@@ -1763,7 +1763,7 @@ static VALUE nm_lu(VALUE self) {
     rb_ary_push(ary, Qnil);
 
   nm_unregister_values(vals, size - s->shape[0] - 1);
-  NM_CONSERVATIVE(nm_unregister_value(self));
+  NM_CONSERVATIVE(nm_unregister_value(&self));
 
   return ary;
 }
@@ -1776,7 +1776,7 @@ static VALUE nm_lu(VALUE self) {
  * JA and LU portions of the IJA and A arrays, respectively.
  */
 static VALUE nm_ia(VALUE self) {
-  NM_CONSERVATIVE(nm_register_value(self));
+  NM_CONSERVATIVE(nm_register_value(&self));
 
   YALE_STORAGE* s = reinterpret_cast<YALE_STORAGE*>(NM_SRC(self));
 
@@ -1786,7 +1786,7 @@ static VALUE nm_ia(VALUE self) {
     vals[i] = INT2FIX(s->ija[i]);
   }
 
-  NM_CONSERVATIVE(nm_unregister_value(self)); 
+  NM_CONSERVATIVE(nm_unregister_value(&self)); 
 
   return rb_ary_new4(s->shape[0]+1, vals);
 }
@@ -1800,7 +1800,7 @@ static VALUE nm_ia(VALUE self) {
  */
 static VALUE nm_ja(VALUE self) {
 
-  NM_CONSERVATIVE(nm_register_value(self));
+  NM_CONSERVATIVE(nm_register_value(&self));
 
   YALE_STORAGE* s = reinterpret_cast<YALE_STORAGE*>(NM_SRC(self));
 
@@ -1820,7 +1820,7 @@ static VALUE nm_ja(VALUE self) {
     rb_ary_push(ary, Qnil);
 
   nm_unregister_values(vals, size - s->shape[0] - 1);
-  NM_CONSERVATIVE(nm_unregister_value(self));
+  NM_CONSERVATIVE(nm_unregister_value(&self));
 
   return ary;
 }
@@ -1833,11 +1833,11 @@ static VALUE nm_ja(VALUE self) {
  * Get the IJA array of a Yale matrix (or a component of the IJA array).
  */
 static VALUE nm_ija(int argc, VALUE* argv, VALUE self) {
-  NM_CONSERVATIVE(nm_register_value(self));
+  NM_CONSERVATIVE(nm_register_value(&self));
 
   VALUE idx;
   rb_scan_args(argc, argv, "01", &idx);
-  NM_CONSERVATIVE(nm_register_value(idx));
+  NM_CONSERVATIVE(nm_register_value(&idx));
 
   YALE_STORAGE* s = reinterpret_cast<YALE_STORAGE*>(NM_SRC(self));
   size_t size = nm_yale_storage_get_size(s);
@@ -1858,16 +1858,16 @@ static VALUE nm_ija(int argc, VALUE* argv, VALUE self) {
       rb_ary_push(ary, Qnil);
 
     nm_unregister_values(vals, size);
-    NM_CONSERVATIVE(nm_unregister_value(idx));
-    NM_CONSERVATIVE(nm_unregister_value(self));
+    NM_CONSERVATIVE(nm_unregister_value(&idx));
+    NM_CONSERVATIVE(nm_unregister_value(&self));
 
     return ary;
 
   } else {
     size_t index = FIX2INT(idx);
     if (index >= size) rb_raise(rb_eRangeError, "out of range");
-    NM_CONSERVATIVE(nm_unregister_value(self));
-    NM_CONSERVATIVE(nm_unregister_value(idx));
+    NM_CONSERVATIVE(nm_unregister_value(&self));
+    NM_CONSERVATIVE(nm_unregister_value(&idx));
     return INT2FIX(s->ija[index]);
   }
 }
@@ -1886,17 +1886,17 @@ static VALUE nm_ija(int argc, VALUE* argv, VALUE self) {
  */
 static VALUE nm_nd_row(int argc, VALUE* argv, VALUE self) {
 
-  NM_CONSERVATIVE(nm_register_value(self));
+  NM_CONSERVATIVE(nm_register_value(&self));
   
   if (NM_SRC(self) != NM_STORAGE(self)) {
-    NM_CONSERVATIVE(nm_unregister_value(self));
+    NM_CONSERVATIVE(nm_unregister_value(&self));
     rb_raise(rb_eNotImpError, "must be called on a real matrix and not a slice");
   }  
 
   VALUE i_, as;
   rb_scan_args(argc, argv, "11", &i_, &as);
-  NM_CONSERVATIVE(nm_register_value(as));
-  NM_CONSERVATIVE(nm_register_value(i_));
+  NM_CONSERVATIVE(nm_register_value(&as));
+  NM_CONSERVATIVE(nm_register_value(&i_));
 
   bool keys = false;
   if (as != Qnil && rb_to_id(as) != nm_rb_hash) keys = true;
@@ -1907,9 +1907,9 @@ static VALUE nm_nd_row(int argc, VALUE* argv, VALUE self) {
   //nm::dtype_t dtype = NM_DTYPE(self);
 
   if (i >= s->shape[0]) {
-    NM_CONSERVATIVE(nm_unregister_value(self));
-    NM_CONSERVATIVE(nm_unregister_value(as));
-    NM_CONSERVATIVE(nm_unregister_value(i_));
+    NM_CONSERVATIVE(nm_unregister_value(&self));
+    NM_CONSERVATIVE(nm_unregister_value(&as));
+    NM_CONSERVATIVE(nm_unregister_value(&i_));
     rb_raise(rb_eRangeError, "out of range (%lu >= %lu)", i, s->shape[0]);
   }
 
@@ -1932,9 +1932,9 @@ static VALUE nm_nd_row(int argc, VALUE* argv, VALUE self) {
       rb_hash_aset(ret, INT2FIX(s->ija[idx]), rubyobj_from_cval((char*)(s->a) + DTYPE_SIZES[s->dtype]*idx, s->dtype).rval);
     }
   }
-  NM_CONSERVATIVE(nm_unregister_value(as));
-  NM_CONSERVATIVE(nm_unregister_value(i_));
-  NM_CONSERVATIVE(nm_unregister_value(self));
+  NM_CONSERVATIVE(nm_unregister_value(&as));
+  NM_CONSERVATIVE(nm_unregister_value(&i_));
+  NM_CONSERVATIVE(nm_unregister_value(&self));
   return ret;
 }
 
@@ -1969,30 +1969,30 @@ static VALUE nm_nd_row(int argc, VALUE* argv, VALUE self) {
  */
 VALUE nm_vector_set(int argc, VALUE* argv, VALUE self) { //, VALUE i_, VALUE jv, VALUE vv, VALUE pos_) {
 
-  NM_CONSERVATIVE(nm_register_value(self));
+  NM_CONSERVATIVE(nm_register_value(&self));
 
   if (NM_SRC(self) != NM_STORAGE(self)) {
-    NM_CONSERVATIVE(nm_unregister_value(self));
+    NM_CONSERVATIVE(nm_unregister_value(&self));
     rb_raise(rb_eNotImpError, "must be called on a real matrix and not a slice");
   }
 
   // i, jv, vv are mandatory; pos is optional; thus "31"
   VALUE i_, jv, vv, pos_;
   rb_scan_args(argc, argv, "31", &i_, &jv, &vv, &pos_);
-  NM_CONSERVATIVE(nm_register_value(i_));
-  NM_CONSERVATIVE(nm_register_value(jv));
-  NM_CONSERVATIVE(nm_register_value(vv));
-  NM_CONSERVATIVE(nm_register_value(pos_));
+  NM_CONSERVATIVE(nm_register_value(&i_));
+  NM_CONSERVATIVE(nm_register_value(&jv));
+  NM_CONSERVATIVE(nm_register_value(&vv));
+  NM_CONSERVATIVE(nm_register_value(&pos_));
 
   size_t len   = RARRAY_LEN(jv); // need length in order to read the arrays in
   size_t vvlen = RARRAY_LEN(vv);
 
   if (len != vvlen) {
-    NM_CONSERVATIVE(nm_unregister_value(pos_));
-    NM_CONSERVATIVE(nm_unregister_value(vv));
-    NM_CONSERVATIVE(nm_unregister_value(jv));
-    NM_CONSERVATIVE(nm_unregister_value(i_));
-    NM_CONSERVATIVE(nm_unregister_value(self));
+    NM_CONSERVATIVE(nm_unregister_value(&pos_));
+    NM_CONSERVATIVE(nm_unregister_value(&vv));
+    NM_CONSERVATIVE(nm_unregister_value(&jv));
+    NM_CONSERVATIVE(nm_unregister_value(&i_));
+    NM_CONSERVATIVE(nm_unregister_value(&self));
     rb_raise(rb_eArgError, "lengths must match between j array (%lu) and value array (%lu)", len, vvlen);
   }
 
@@ -2023,11 +2023,11 @@ VALUE nm_vector_set(int argc, VALUE* argv, VALUE self) { //, VALUE i_, VALUE jv,
     nm_unregister_values(reinterpret_cast<VALUE*>(vals), len);
   }
 
-  NM_CONSERVATIVE(nm_unregister_value(pos_));
-  NM_CONSERVATIVE(nm_unregister_value(vv));
-  NM_CONSERVATIVE(nm_unregister_value(jv));
-  NM_CONSERVATIVE(nm_unregister_value(i_));
-  NM_CONSERVATIVE(nm_unregister_value(self));
+  NM_CONSERVATIVE(nm_unregister_value(&pos_));
+  NM_CONSERVATIVE(nm_unregister_value(&vv));
+  NM_CONSERVATIVE(nm_unregister_value(&jv));
+  NM_CONSERVATIVE(nm_unregister_value(&i_));
+  NM_CONSERVATIVE(nm_unregister_value(&self));
 
   // Return the updated position
   pos += len;