nmatrix 0.0.9 → 0.1.0.rc1

data/ext/nmatrix/storage/yale/iterators/base.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.
 //

data/ext/nmatrix/storage/yale/iterators/iterator.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.
 //

data/ext/nmatrix/storage/yale/iterators/row.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.
 //

data/ext/nmatrix/storage/yale/iterators/row_stored.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.
 //

data/ext/nmatrix/storage/yale/iterators/row_stored_nd.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.
 //
@@ -87,6 +87,7 @@ public:
     if (&r != &(rhs.r))
       throw std::logic_error("can't assign iterator from another row iterator");
     p_ = rhs.p_;
+    return *this;
   }
 
   virtual size_t p() const { return p_; }
@@ -164,4 +165,4 @@ public:
 
 } } // end of namespace nm::yale_storage
 
-#endif // YALE_ITERATORS_ROW_STORED_ND_H
+#endif // YALE_ITERATORS_ROW_STORED_ND_H

data/ext/nmatrix/storage/yale/iterators/stored_diagonal.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.
 //

data/ext/nmatrix/storage/yale/math/transpose.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.
 //

data/ext/nmatrix/storage/yale/yale.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.
 //
@@ -101,6 +101,7 @@ extern "C" {
   static VALUE nm_ia(VALUE self);
   static VALUE nm_ja(VALUE self);
   static VALUE nm_ija(int argc, VALUE* argv, VALUE self);
+  static VALUE nm_row_keys_intersection(VALUE m1, VALUE ii1, VALUE m2, VALUE ii2);
 
   static VALUE nm_nd_row(int argc, VALUE* argv, VALUE self);
 
@@ -208,8 +209,8 @@ YALE_STORAGE* create_from_old_yale(dtype_t dtype, size_t* shape, char* r_ia, cha
   s->ndnz     = ndnz;
 
   // Setup IJA and A arrays
-  s->ija = ALLOC_N( IType, s->capacity );
-  s->a   = ALLOC_N( LDType, s->capacity );
+  s->ija = NM_ALLOC_N( IType, s->capacity );
+  s->a   = NM_ALLOC_N( LDType, s->capacity );
   IType* ijl    = reinterpret_cast<IType*>(s->ija);
   LDType* al    = reinterpret_cast<LDType*>(s->a);
 
@@ -452,14 +453,14 @@ static void vector_grow(YALE_STORAGE* s) {
   if (s != s->src) {
     throw; // need to correct this quickly.
   }
-
+  nm_yale_storage_register(s);
   size_t new_capacity = s->capacity * GROWTH_CONSTANT;
   size_t max_capacity = YaleStorage<uint8_t>::max_size(s->shape);
 
   if (new_capacity > max_capacity) new_capacity = max_capacity;
 
-  IType* new_ija      = ALLOC_N(IType, new_capacity);
-  void* new_a         = ALLOC_N(char, DTYPE_SIZES[s->dtype] * new_capacity);
+  IType* new_ija      = NM_ALLOC_N(IType, new_capacity);
+  void* new_a         = NM_ALLOC_N(char, DTYPE_SIZES[s->dtype] * new_capacity);
 
   IType* old_ija      = s->ija;
   void* old_a         = s->a;
@@ -469,11 +470,18 @@ static void vector_grow(YALE_STORAGE* s) {
 
   s->capacity         = new_capacity;
 
-  xfree(old_ija);
-  xfree(old_a);
+  if (s->dtype == nm::RUBYOBJ)
+    nm_yale_storage_register_a(new_a, s->capacity * DTYPE_SIZES[s->dtype]);
+
+  NM_FREE(old_ija);
+  nm_yale_storage_unregister(s);
+  NM_FREE(old_a);
+  if (s->dtype == nm::RUBYOBJ)
+    nm_yale_storage_unregister_a(new_a, s->capacity * DTYPE_SIZES[s->dtype]);
 
   s->ija         = new_ija;
   s->a           = new_a;
+
 }
 
 
@@ -497,11 +505,13 @@ static char vector_insert_resize(YALE_STORAGE* s, size_t current_size, size_t po
   if (new_capacity < current_size + n)
   	new_capacity = current_size + n;
 
+  nm_yale_storage_register(s);
+
   // Allocate the new vectors.
-  IType* new_ija     = ALLOC_N( IType, new_capacity );
+  IType* new_ija     = NM_ALLOC_N( IType, new_capacity );
   NM_CHECK_ALLOC(new_ija);
 
-  DType* new_a       = ALLOC_N( DType, new_capacity );
+  DType* new_a       = NM_ALLOC_N( DType, new_capacity );
   NM_CHECK_ALLOC(new_a);
 
   IType* old_ija     = reinterpret_cast<IType*>(s->ija);
@@ -533,9 +543,15 @@ static char vector_insert_resize(YALE_STORAGE* s, size_t current_size, size_t po
   }
 
   s->capacity = new_capacity;
+  if (s->dtype == nm::RUBYOBJ)
+    nm_yale_storage_register_a(new_a, new_capacity);
 
-  xfree(s->ija);
-  xfree(s->a);
+  NM_FREE(s->ija);
+  nm_yale_storage_unregister(s);
+  NM_FREE(s->a);
+  
+  if (s->dtype == nm::RUBYOBJ)
+    nm_yale_storage_unregister_a(new_a, new_capacity);
 
   s->ija = new_ija;
   s->a   = reinterpret_cast<void*>(new_a);
@@ -566,12 +582,11 @@ static char vector_insert(YALE_STORAGE* s, size_t pos, size_t* j, void* val_, si
   DType* a   = reinterpret_cast<DType*>(s->a);
 
   if (size + n > s->capacity) {
-  	vector_insert_resize<DType>(s, size, pos, j, n, struct_only);
+    vector_insert_resize<DType>(s, size, pos, j, n, struct_only);
 
     // Need to get the new locations for ija and a.
   	ija = s->ija;
     a   = reinterpret_cast<DType*>(s->a);
-
   } else {
     /*
      * No resize required:
@@ -673,6 +688,8 @@ static STORAGE* matrix_multiply(const STORAGE_PAIR& casted_storage, size_t* resu
   YALE_STORAGE *left  = (YALE_STORAGE*)(casted_storage.left),
                *right = (YALE_STORAGE*)(casted_storage.right);
 
+  nm_yale_storage_register(left);
+  nm_yale_storage_register(right);
   // We can safely get dtype from the casted matrices; post-condition of binary_storage_cast_alloc is that dtype is the
   // same for left and right.
   // int8_t dtype = left->dtype;
@@ -704,6 +721,8 @@ static STORAGE* matrix_multiply(const STORAGE_PAIR& casted_storage, size_t* resu
   // Sort the columns
   nm::math::smmp_sort_columns<DType>(result->shape[0], ija, ija, reinterpret_cast<DType*>(result->a));
 
+  nm_yale_storage_unregister(right);
+  nm_yale_storage_unregister(left);
   return reinterpret_cast<STORAGE*>(result);
 }
 
@@ -872,11 +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));
   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));
   return INT2FIX(len);
 }
 
@@ -884,27 +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));
   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));
   return INT2FIX(len);
 }
 
 // Helper function for diagonal length.
 static VALUE nm_yale_stored_diagonal_enumerator_length(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));
   return INT2FIX(len);
 }
 
 
 // Helper function for full enumerator length.
 static VALUE nm_yale_enumerator_length(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));
   return INT2FIX(len);
 }
 
@@ -914,12 +940,21 @@ static VALUE nm_yale_enumerator_length(VALUE nmatrix) {
  */
 template <typename D>
 static VALUE map_stored(VALUE self) {
+  NM_CONSERVATIVE(nm_register_value(self));
   YALE_STORAGE* s = NM_STORAGE_YALE(self);
   YaleStorage<D> y(s);
+  
+  RETURN_SIZED_ENUMERATOR_PRE
+  NM_CONSERVATIVE(nm_unregister_value(self));
   RETURN_SIZED_ENUMERATOR(self, 0, 0, nm_yale_stored_enumerator_length);
+
   YALE_STORAGE* r = y.template alloc_copy<nm::RubyObject, true>();
+  nm_yale_storage_register(r);
   NMATRIX* m      = nm_create(nm::YALE_STORE, reinterpret_cast<STORAGE*>(r));
-  return Data_Wrap_Struct(CLASS_OF(self), nm_mark, nm_delete, m);
+  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));
+  return to_return;
 }
 
 
@@ -930,7 +965,8 @@ template <typename LD, typename RD>
 static VALUE map_merged_stored(VALUE left, VALUE right, VALUE init) {
   nm::YaleStorage<LD> l(NM_STORAGE_YALE(left));
   nm::YaleStorage<RD> r(NM_STORAGE_YALE(right));
-  return l.map_merged_stored(CLASS_OF(left), r, init);
+  VALUE to_return = l.map_merged_stored(CLASS_OF(left), r, init);
+  return to_return;
 }
 
 
@@ -939,10 +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));
   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));
   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) {
@@ -955,6 +994,8 @@ static VALUE each_stored_with_indices(VALUE nm) {
     }
   }
 
+  NM_CONSERVATIVE(nm_unregister_value(nm));
+
   return nm;
 }
 
@@ -964,16 +1005,22 @@ 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));
+
   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));
   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));
+
   return nm;
 }
 
@@ -983,10 +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));
+
   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));
   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) {
@@ -995,6 +1046,8 @@ static VALUE stored_nondiagonal_each_with_indices(VALUE nm) {
     }
   }
 
+  NM_CONSERVATIVE(nm_unregister_value(nm));
+
   return nm;
 }
 
@@ -1004,10 +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));
+
   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));
   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) {
@@ -1016,25 +1073,39 @@ static VALUE each_ordered_stored_with_indices(VALUE nm) {
     }
   }
 
+  NM_CONSERVATIVE(nm_unregister_value(nm));
+
   return nm;
 }
 
 
 template <typename DType>
 static VALUE each_with_indices(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));
   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));
+
   return nm;
 }
 
+template <typename D>
+static bool is_pos_default_value(YALE_STORAGE* s, size_t apos) {
+  YaleStorage<D> y(s);
+  return y.is_pos_default_value(apos);
+}
+
 
 } // end of namespace nm::yale_storage
 
@@ -1056,6 +1127,10 @@ void nm_init_yale_functions() {
 	 */
   cNMatrix_YaleFunctions = rb_define_module_under(cNMatrix, "YaleFunctions");
 
+  // Expert recommendation. Eventually this should go in a separate gem, or at least a separate module.
+  rb_define_method(cNMatrix_YaleFunctions, "yale_row_keys_intersection", (METHOD)nm_row_keys_intersection, 3);
+
+  // Debugging functions.
   rb_define_method(cNMatrix_YaleFunctions, "yale_ija", (METHOD)nm_ija, -1);
   rb_define_method(cNMatrix_YaleFunctions, "yale_a", (METHOD)nm_a, -1);
   rb_define_method(cNMatrix_YaleFunctions, "yale_size", (METHOD)nm_size, 0);
@@ -1162,7 +1237,7 @@ void* nm_yale_storage_get(const STORAGE* storage, SLICE* slice) {
 
     return elem_copy_table[casted_storage->dtype](casted_storage, slice);
   } else {
-
+    nm_yale_storage_register(casted_storage);
     //return reinterpret_cast<void*>(nm::YaleStorage<nm::dtype_enum_T<storage->dtype>::type>(casted_storage).alloc_ref(slice));
     NAMED_DTYPE_TEMPLATE_TABLE(ref_table, nm::yale_storage::ref, YALE_STORAGE*, YALE_STORAGE* storage, SLICE* slice)
 
@@ -1172,7 +1247,9 @@ void* nm_yale_storage_get(const STORAGE* storage, SLICE* slice) {
 
     YALE_STORAGE* ns = slice_copy_table[casted_storage->dtype][casted_storage->dtype](ref);
 
-    xfree(ref);
+    NM_FREE(ref);
+
+    nm_yale_storage_unregister(casted_storage);
 
     return ns;
   }
@@ -1339,11 +1416,11 @@ void nm_yale_storage_delete(STORAGE* s) {
   if (s) {
     YALE_STORAGE* storage = (YALE_STORAGE*)s;
     if (storage->count-- == 1) {
-      xfree(storage->shape);
-      xfree(storage->offset);
-      xfree(storage->ija);
-      xfree(storage->a);
-      xfree(storage);
+      NM_FREE(storage->shape);
+      NM_FREE(storage->offset);
+      NM_FREE(storage->ija);
+      NM_FREE(storage->a);
+      NM_FREE(storage);
     }
   }
 }
@@ -1355,9 +1432,9 @@ void nm_yale_storage_delete_ref(STORAGE* s) {
   if (s) {
     YALE_STORAGE* storage = (YALE_STORAGE*)s;
     nm_yale_storage_delete( reinterpret_cast<STORAGE*>(storage->src) );
-    xfree(storage->shape);
-    xfree(storage->offset);
-    xfree(s);
+    NM_FREE(storage->shape);
+    NM_FREE(storage->offset);
+    NM_FREE(s);
   }
 }
 
@@ -1378,15 +1455,35 @@ void nm_yale_storage_init(YALE_STORAGE* s, void* init_val) {
  */
 void nm_yale_storage_mark(STORAGE* storage_base) {
   YALE_STORAGE* storage = (YALE_STORAGE*)storage_base;
-  size_t i;
 
   if (storage && storage->dtype == nm::RUBYOBJ) {
 
     VALUE* a = (VALUE*)(storage->a);
-    rb_gc_mark_locations(a, a + storage->capacity * sizeof(VALUE));
+    rb_gc_mark_locations(a, &(a[storage->capacity-1]));
   }
 }
 
+void nm_yale_storage_register_a(void* a, size_t size) {
+  nm_register_values(reinterpret_cast<VALUE*>(a), size);
+}
+
+void nm_yale_storage_unregister_a(void* a, size_t size) {
+  nm_unregister_values(reinterpret_cast<VALUE*>(a), size);
+}
+
+void nm_yale_storage_register(const STORAGE* s) {
+  const YALE_STORAGE* y = reinterpret_cast<const YALE_STORAGE*>(s);
+  if (y->dtype == nm::RUBYOBJ) {
+    nm_register_values(reinterpret_cast<VALUE*>(y->a), nm::yale_storage::get_size(y));
+  }
+}
+
+void nm_yale_storage_unregister(const STORAGE* s) {
+  const YALE_STORAGE* y = reinterpret_cast<const YALE_STORAGE*>(s);
+  if (y->dtype == nm::RUBYOBJ) {
+    nm_unregister_values(reinterpret_cast<VALUE*>(y->a), nm::yale_storage::get_size(y));
+  }
+}
 
 /*
  * Allocates and initializes the basic struct (but not the IJA or A vectors).
@@ -1396,12 +1493,12 @@ void nm_yale_storage_mark(STORAGE* storage_base) {
 static YALE_STORAGE* alloc(nm::dtype_t dtype, size_t* shape, size_t dim) {
   YALE_STORAGE* s;
 
-  s = ALLOC( YALE_STORAGE );
+  s = NM_ALLOC( YALE_STORAGE );
 
   s->ndnz        = 0;
   s->dtype       = dtype;
   s->shape       = shape;
-  s->offset      = ALLOC_N(size_t, dim);
+  s->offset      = NM_ALLOC_N(size_t, dim);
   for (size_t i = 0; i < dim; ++i)
     s->offset[i] = 0;
   s->dim         = dim;
@@ -1432,7 +1529,110 @@ YALE_STORAGE* nm_yale_storage_create_from_old_yale(nm::dtype_t dtype, size_t* sh
  */
 static VALUE nm_size(VALUE self) {
   YALE_STORAGE* s = (YALE_STORAGE*)(NM_SRC(self));
-  return INT2FIX(nm::yale_storage::IJA(s)[s->shape[0]]);
+  VALUE to_return = INT2FIX(nm::yale_storage::IJA(s)[s->shape[0]]);
+  return to_return;
+}
+
+
+/*
+ * Determine if some pos in the diagonal is the default. No bounds checking!
+ */
+static bool is_pos_default_value(YALE_STORAGE* s, size_t apos) {
+  DTYPE_TEMPLATE_TABLE(nm::yale_storage::is_pos_default_value, bool, YALE_STORAGE*, size_t)
+  return ttable[s->dtype](s, apos);
+}
+
+
+/*
+ * call-seq:
+ *     yale_row_keys_intersection(i, m2, i2) -> Array
+ *
+ * This function is experimental.
+ *
+ * It finds the intersection of row i of the current matrix with row i2 of matrix m2.
+ * Both matrices must be Yale. They may not be slices.
+ *
+ * Only checks the stored indices; does not care about matrix default value.
+ */
+static VALUE nm_row_keys_intersection(VALUE m1, VALUE ii1, VALUE m2, VALUE ii2) {
+  
+  NM_CONSERVATIVE(nm_register_value(m1));
+  NM_CONSERVATIVE(nm_register_value(m2));
+
+  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));
+    rb_raise(rb_eNotImpError, "must be called on a real matrix and not a slice");
+  }
+
+  size_t i1 = FIX2INT(ii1),
+         i2 = FIX2INT(ii2);
+
+  YALE_STORAGE *s   = NM_STORAGE_YALE(m1),
+               *t   = NM_STORAGE_YALE(m2);
+
+  size_t pos1 = s->ija[i1],
+         pos2 = t->ija[i2];
+
+  size_t nextpos1 = s->ija[i1+1],
+         nextpos2 = t->ija[i2+1];
+
+  size_t diff1 = nextpos1 - pos1,
+         diff2 = nextpos2 - pos2;
+
+  // Does the diagonal have a nonzero in it?
+  bool diag1 = i1 < s->shape[0] && !is_pos_default_value(s, i1),
+       diag2 = i2 < t->shape[0] && !is_pos_default_value(t, i2);
+
+  // 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);
+
+  // Handle once the special case where both have the diagonal in exactly
+  // the same place.
+  if (diag1 && diag2 && i1 == i2) {
+    rb_ary_push(ret, INT2FIX(i1));
+    diag1 = false; diag2 = false; // no need to deal with diagonals anymore.
+  }
+
+  // Now find the intersection.
+  size_t idx1 = pos1, idx2 = pos2;
+  while (idx1 < nextpos1 && idx2 < nextpos2) {
+    if (s->ija[idx1] == t->ija[idx2]) {
+      rb_ary_push(ret, INT2FIX(s->ija[idx1]));
+      ++idx1; ++idx2;
+    } else if (diag1 && i1 == t->ija[idx2]) {
+      rb_ary_push(ret, INT2FIX(i1));
+      diag1 = false;
+      ++idx2;
+    } else if (diag2 && i2 == s->ija[idx1]) {
+      rb_ary_push(ret, INT2FIX(i2));
+      diag2 = false;
+      ++idx1;
+    } else if (s->ija[idx1] < t->ija[idx2]) {
+      ++idx1;
+    } else { // s->ija[idx1] > t->ija[idx2]
+      ++idx2;
+    }
+  }
+
+  // Past the end of row i2's stored entries; need to try to find diagonal
+  if (diag2 && idx1 < nextpos1) {
+    idx1 = nm::yale_storage::binary_search_left_boundary(s, idx1, nextpos1, i2);
+    if (s->ija[idx1] == i2) rb_ary_push(ret, INT2FIX(i2));
+  }
+
+  // Find the diagonal, if possible, in the other one.
+  if (diag1 && idx2 < nextpos2) {
+    idx2 = nm::yale_storage::binary_search_left_boundary(t, idx2, nextpos2, i1);
+    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));
+
+  return ret;
 }
 
 
@@ -1444,15 +1644,21 @@ static VALUE nm_size(VALUE self) {
  * 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));
+
   VALUE idx;
   rb_scan_args(argc, argv, "01", &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);
 
   if (idx == Qnil) {
-    VALUE* vals = ALLOCA_N(VALUE, size);
 
+    VALUE* vals = NM_ALLOCA_N(VALUE, size);
+
+    nm_register_values(vals, size);
+    
     if (NM_DTYPE(self) == nm::RUBYOBJ) {
       for (size_t i = 0; i < size; ++i) {
         vals[i] = reinterpret_cast<VALUE*>(s->a)[i];
@@ -1467,11 +1673,15 @@ static VALUE nm_a(int argc, VALUE* argv, VALUE self) {
     for (size_t i = size; i < s->capacity; ++i)
       rb_ary_push(ary, Qnil);
 
+    nm_unregister_values(vals, size);
+    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));
     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;
   }
 }
@@ -1485,13 +1695,17 @@ 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));
   VALUE idx;
   rb_scan_args(argc, argv, "01", &idx);
+  NM_CONSERVATIVE(nm_register_value(idx));
 
   YALE_STORAGE* s = reinterpret_cast<YALE_STORAGE*>(NM_SRC(self));
 
   if (idx == Qnil) {
-    VALUE* vals = ALLOCA_N(VALUE, s->shape[0]);
+    VALUE* vals = NM_ALLOCA_N(VALUE, s->shape[0]);
+
+    nm_register_values(vals, s->shape[0]);
 
     if (NM_DTYPE(self) == nm::RUBYOBJ) {
       for (size_t i = 0; i < s->shape[0]; ++i) {
@@ -1502,12 +1716,16 @@ static VALUE nm_d(int argc, VALUE* argv, VALUE self) {
         vals[i] = rubyobj_from_cval((char*)(s->a) + DTYPE_SIZES[s->dtype]*i, s->dtype).rval;
       }
     }
+    nm_unregister_values(vals, s->shape[0]);
+    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));
     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;
   }
 }
@@ -1519,11 +1737,15 @@ 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));
+
   YALE_STORAGE* s = reinterpret_cast<YALE_STORAGE*>(NM_SRC(self));
 
   size_t size = nm_yale_storage_get_size(s);
 
-  VALUE* vals = ALLOCA_N(VALUE, size - s->shape[0] - 1);
+  VALUE* vals = NM_ALLOCA_N(VALUE, size - s->shape[0] - 1);
+
+  nm_register_values(vals, size - s->shape[0] - 1);
 
   if (NM_DTYPE(self) == nm::RUBYOBJ) {
     for (size_t i = 0; i < size - s->shape[0] - 1; ++i) {
@@ -1540,6 +1762,9 @@ static VALUE nm_lu(VALUE self) {
   for (size_t i = size; i < s->capacity; ++i)
     rb_ary_push(ary, Qnil);
 
+  nm_unregister_values(vals, size - s->shape[0] - 1);
+  NM_CONSERVATIVE(nm_unregister_value(self));
+
   return ary;
 }
 
@@ -1551,14 +1776,18 @@ 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));
+
   YALE_STORAGE* s = reinterpret_cast<YALE_STORAGE*>(NM_SRC(self));
 
-  VALUE* vals = ALLOCA_N(VALUE, s->shape[0] + 1);
+  VALUE* vals = NM_ALLOCA_N(VALUE, s->shape[0] + 1);
 
   for (size_t i = 0; i < s->shape[0] + 1; ++i) {
     vals[i] = INT2FIX(s->ija[i]);
   }
 
+  NM_CONSERVATIVE(nm_unregister_value(self)); 
+
   return rb_ary_new4(s->shape[0]+1, vals);
 }
 
@@ -1570,11 +1799,16 @@ static VALUE nm_ia(VALUE self) {
  * positions in the LU portion of the A array.
  */
 static VALUE nm_ja(VALUE self) {
+
+  NM_CONSERVATIVE(nm_register_value(self));
+
   YALE_STORAGE* s = reinterpret_cast<YALE_STORAGE*>(NM_SRC(self));
 
   size_t size = nm_yale_storage_get_size(s);
 
-  VALUE* vals = ALLOCA_N(VALUE, size - s->shape[0] - 1);
+  VALUE* vals = NM_ALLOCA_N(VALUE, size - s->shape[0] - 1);
+
+  nm_register_values(vals, size - s->shape[0] - 1);
 
   for (size_t i = 0; i < size - s->shape[0] - 1; ++i) {
     vals[i] = INT2FIX(s->ija[s->shape[0] + 1 + i]);
@@ -1585,6 +1819,9 @@ static VALUE nm_ja(VALUE self) {
   for (size_t i = size; i < s->capacity; ++i)
     rb_ary_push(ary, Qnil);
 
+  nm_unregister_values(vals, size - s->shape[0] - 1);
+  NM_CONSERVATIVE(nm_unregister_value(self));
+
   return ary;
 }
 
@@ -1596,15 +1833,20 @@ 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));
+
   VALUE idx;
   rb_scan_args(argc, argv, "01", &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);
 
   if (idx == Qnil) {
 
-    VALUE* vals = ALLOCA_N(VALUE, size);
+    VALUE* vals = NM_ALLOCA_N(VALUE, size);
+
+    nm_register_values(vals, size);
 
     for (size_t i = 0; i < size; ++i) {
       vals[i] = INT2FIX(s->ija[i]);
@@ -1615,12 +1857,17 @@ static VALUE nm_ija(int argc, VALUE* argv, VALUE self) {
     for (size_t i = size; i < s->capacity; ++i)
       rb_ary_push(ary, Qnil);
 
+    nm_unregister_values(vals, size);
+    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));
     return INT2FIX(s->ija[index]);
   }
 }
@@ -1638,11 +1885,18 @@ static VALUE nm_ija(int argc, VALUE* argv, VALUE self) {
  * range.
  */
 static VALUE nm_nd_row(int argc, VALUE* argv, VALUE self) {
-  if (NM_SRC(self) != NM_STORAGE(self))
+
+  NM_CONSERVATIVE(nm_register_value(self));
+  
+  if (NM_SRC(self) != NM_STORAGE(self)) {
+    NM_CONSERVATIVE(nm_unregister_value(self));
     rb_raise(rb_eNotImpError, "must be called on a real matrix and not a slice");
+  }  
 
   VALUE i_, as;
   rb_scan_args(argc, argv, "11", &i_, &as);
+  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;
@@ -1650,7 +1904,14 @@ static VALUE nm_nd_row(int argc, VALUE* argv, VALUE self) {
   size_t i = FIX2INT(i_);
 
   YALE_STORAGE* s   = NM_STORAGE_YALE(self);
-  nm::dtype_t dtype = NM_DTYPE(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_));
+    rb_raise(rb_eRangeError, "out of range (%lu >= %lu)", i, s->shape[0]);
+  }
 
   size_t pos = s->ija[i];
   size_t nextpos = s->ija[i+1];
@@ -1671,7 +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));
   return ret;
 }
 
@@ -1706,18 +1969,32 @@ 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_) {
 
-  if (NM_SRC(self) != NM_STORAGE(self))
+  NM_CONSERVATIVE(nm_register_value(self));
+
+  if (NM_SRC(self) != NM_STORAGE(self)) {
+    NM_CONSERVATIVE(nm_unregister_value(self));
     rb_raise(rb_eNotImpError, "must be called on a real matrix and not a slice");
+  }
 
   // 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_));
 
   size_t len   = RARRAY_LEN(jv); // need length in order to read the arrays in
   size_t vvlen = RARRAY_LEN(vv);
 
-  if (len != vvlen)
-    rb_raise(rb_eArgError, "lengths must match between j array (%d) and value array (%d)", len, vvlen);
+  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));
+    rb_raise(rb_eArgError, "lengths must match between j array (%lu) and value array (%lu)", len, vvlen);
+  }
 
   YALE_STORAGE* s   = NM_STORAGE_YALE(self);
   nm::dtype_t dtype = NM_DTYPE(self);
@@ -1726,8 +2003,11 @@ VALUE nm_vector_set(int argc, VALUE* argv, VALUE self) { //, VALUE i_, VALUE jv,
   size_t pos = s->ija[i];
 
   // Allocate the j array and the values array
-  size_t* j  = ALLOCA_N(size_t, len);
-  void* vals = ALLOCA_N(char, DTYPE_SIZES[dtype] * len);
+  size_t* j  = NM_ALLOCA_N(size_t, len);
+  void* vals = NM_ALLOCA_N(char, DTYPE_SIZES[dtype] * len);
+  if (dtype == nm::RUBYOBJ){
+    nm_register_values(reinterpret_cast<VALUE*>(vals), len);
+  }
 
   // Copy array contents
   for (size_t idx = 0; idx < len; ++idx) {
@@ -1739,6 +2019,16 @@ VALUE nm_vector_set(int argc, VALUE* argv, VALUE self) { //, VALUE i_, VALUE jv,
   nm_yale_storage_increment_ia_after(s, s->shape[0], i, len);
   s->ndnz += len;
 
+  if (dtype == nm::RUBYOBJ){
+    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));
+
   // Return the updated position
   pos += len;
   return INT2FIX(pos);
@@ -1754,7 +2044,8 @@ VALUE nm_vector_set(int argc, VALUE* argv, VALUE self) { //, VALUE i_, VALUE jv,
  * Get the default_value property from a yale matrix.
  */
 VALUE nm_yale_default_value(VALUE self) {
-  return default_value(NM_STORAGE_YALE(self));
+  VALUE to_return = default_value(NM_STORAGE_YALE(self));
+  return to_return;
 }