nmatrix 0.0.9 → 0.1.0.rc1

data/ext/nmatrix/storage/{list.h → list/list.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.
 //
@@ -34,14 +34,14 @@
  */
 
 #include <stdlib.h>
-
+#include <list>
 /*
  * Project Includes
  */
 
 #include "types.h"
 #include "data/data.h"
-#include "common.h"
+#include "../common.h"
 #include "util/sl_list.h"
 #include "nmatrix.h"
 
@@ -73,7 +73,13 @@ extern "C" {
   void					nm_list_storage_delete(STORAGE* s);
   void					nm_list_storage_delete_ref(STORAGE* s);
   void					nm_list_storage_mark(STORAGE*);
-
+  void          nm_list_storage_register(const STORAGE* s);
+  void          nm_list_storage_unregister(const STORAGE* s);
+  void          nm_list_storage_register_list(const LIST* l, size_t recursions);
+  void          nm_list_storage_unregister_list(const LIST* l, size_t recursions);
+  void          nm_list_storage_register_node(const NODE* n);
+  void          nm_list_storage_unregister_node(const NODE* n);
+  void		      nm_list_storage_completely_unregister_node(const NODE* curr);
   ///////////////
   // Accessors //
   ///////////////
@@ -82,7 +88,7 @@ extern "C" {
   void* nm_list_storage_ref(const STORAGE* s, SLICE* slice);
   void* nm_list_storage_get(const STORAGE* s, SLICE* slice);
   NODE* nm_list_storage_insert(STORAGE* s, SLICE* slice, void* val);
-  void nm_list_storage_set(VALUE left, SLICE* slice, VALUE right);
+  void  nm_list_storage_set(VALUE left, SLICE* slice, VALUE right);
   void  nm_list_storage_remove(STORAGE* s, SLICE* slice);
 
   ///////////
@@ -124,6 +130,7 @@ extern "C" {
   // Exposed functions
   VALUE nm_to_hash(VALUE self);
   VALUE nm_list_map_merged_stored(VALUE left, VALUE right, VALUE init);
+  VALUE nm_list_map_stored(VALUE left, VALUE init);
   VALUE nm_list_default_value(VALUE self);
 } // end of extern "C" block
 

data/ext/nmatrix/storage/storage.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.
 //
@@ -87,9 +87,9 @@ static void cast_copy_list_default(LDType* lhs, RDType* default_val, size_t& pos
  */
 template <typename LDType, typename RDType>
 DENSE_STORAGE* create_from_list_storage(const LIST_STORAGE* rhs, dtype_t l_dtype) {
-
+  nm_list_storage_register(rhs);
   // allocate and copy shape
-  size_t* shape = ALLOC_N(size_t, rhs->dim);
+  size_t* shape = NM_ALLOC_N(size_t, rhs->dim);
   memcpy(shape, rhs->shape, rhs->dim * sizeof(size_t));
 
   DENSE_STORAGE* lhs = nm_dense_storage_create(l_dtype, shape, rhs->dim, NULL, 0);
@@ -114,6 +114,7 @@ DENSE_STORAGE* create_from_list_storage(const LIST_STORAGE* rhs, dtype_t l_dtype
     nm_list_storage_delete(tmp);
 
   }
+  nm_list_storage_unregister(rhs);
 
   return lhs;
 }
@@ -127,12 +128,13 @@ DENSE_STORAGE* create_from_list_storage(const LIST_STORAGE* rhs, dtype_t l_dtype
 template <typename LDType, typename RDType>
 DENSE_STORAGE* create_from_yale_storage(const YALE_STORAGE* rhs, dtype_t l_dtype) {
 
+  nm_yale_storage_register(rhs);
   // Position in rhs->elements.
   IType*  rhs_ija = reinterpret_cast<YALE_STORAGE*>(rhs->src)->ija;
   RDType* rhs_a   = reinterpret_cast<RDType*>(reinterpret_cast<YALE_STORAGE*>(rhs->src)->a);
 
   // Allocate and set shape.
-  size_t* shape = ALLOC_N(size_t, rhs->dim);
+  size_t* shape = NM_ALLOC_N(size_t, rhs->dim);
   shape[0] = rhs->shape[0];
   shape[1] = rhs->shape[1];
 
@@ -195,6 +197,7 @@ DENSE_STORAGE* create_from_yale_storage(const YALE_STORAGE* rhs, dtype_t l_dtype
       }
     }
   }
+  nm_yale_storage_unregister(rhs);
 
   return lhs;
 }
@@ -209,7 +212,9 @@ static void cast_copy_list_contents(LDType* lhs, const LIST* rhs, RDType* defaul
   NODE *curr = rhs->first;
   int last_key = -1;
 
-	for (size_t i = 0; i < shape[dim - 1 - recursions]; ++i, ++pos) {
+  nm_list_storage_register_list(rhs, recursions);
+
+  for (size_t i = 0; i < shape[dim - 1 - recursions]; ++i, ++pos) {
 
     if (!curr || (curr->key > (size_t)(last_key+1))) {
 
@@ -229,6 +234,8 @@ static void cast_copy_list_contents(LDType* lhs, const LIST* rhs, RDType* defaul
     }
   }
 
+  nm_list_storage_unregister_list(rhs, recursions);
+
   --pos;
 }
 
@@ -237,7 +244,7 @@ static void cast_copy_list_contents(LDType* lhs, const LIST* rhs, RDType* defaul
  */
 template <typename LDType,typename RDType>
 static void cast_copy_list_default(LDType* lhs, RDType* default_val, size_t& pos, const size_t* shape, size_t dim, size_t max_elements, size_t recursions) {
-	for (size_t i = 0; i < shape[dim - 1 - recursions]; ++i, ++pos) {
+  for (size_t i = 0; i < shape[dim - 1 - recursions]; ++i, ++pos) {
 
     if (recursions == 0)    lhs[pos] = static_cast<LDType>(*default_val);
     else                  	cast_copy_list_default<LDType,RDType>(lhs, default_val, pos, shape, dim, max_elements, recursions-1);
@@ -261,13 +268,14 @@ static bool cast_copy_contents_dense(LIST* lhs, const RDType* rhs, RDType* zero,
  */
 template <typename LDType, typename RDType>
 LIST_STORAGE* create_from_dense_storage(const DENSE_STORAGE* rhs, dtype_t l_dtype, void* init) {
+  nm_dense_storage_register(rhs);
 
-  LDType* l_default_val = ALLOC_N(LDType, 1);
-  RDType* r_default_val = ALLOCA_N(RDType, 1); // clean up when finished with this function
+  LDType* l_default_val = NM_ALLOC_N(LDType, 1);
+  RDType* r_default_val = NM_ALLOCA_N(RDType, 1); // clean up when finished with this function
 
   // allocate and copy shape and coords
-  size_t *shape  = ALLOC_N(size_t, rhs->dim),
-         *coords = ALLOC_N(size_t, rhs->dim);
+  size_t *shape  = NM_ALLOC_N(size_t, rhs->dim),
+         *coords = NM_ALLOC_N(size_t, rhs->dim);
 
   memcpy(shape, rhs->shape, rhs->dim * sizeof(size_t));
   memset(coords, 0, rhs->dim * sizeof(size_t));
@@ -286,6 +294,8 @@ LIST_STORAGE* create_from_dense_storage(const DENSE_STORAGE* rhs, dtype_t l_dtyp
 
   LIST_STORAGE* lhs = nm_list_storage_create(l_dtype, shape, rhs->dim, l_default_val);
 
+  nm_list_storage_register(lhs);
+
   size_t pos = 0;
 
   if (rhs->src == rhs)
@@ -303,6 +313,9 @@ LIST_STORAGE* create_from_dense_storage(const DENSE_STORAGE* rhs, dtype_t l_dtyp
     nm_dense_storage_delete(tmp);
   }
 
+  nm_list_storage_unregister(lhs);
+  nm_dense_storage_unregister(rhs);
+
   return lhs;
 }
 
@@ -314,14 +327,16 @@ LIST_STORAGE* create_from_dense_storage(const DENSE_STORAGE* rhs, dtype_t l_dtyp
 template <typename LDType, typename RDType>
 LIST_STORAGE* create_from_yale_storage(const YALE_STORAGE* rhs, dtype_t l_dtype) {
   // allocate and copy shape
-  size_t *shape = ALLOC_N(size_t, rhs->dim);
+  nm_yale_storage_register(rhs);
+
+  size_t *shape = NM_ALLOC_N(size_t, rhs->dim);
   shape[0] = rhs->shape[0]; shape[1] = rhs->shape[1];
 
   RDType* rhs_a    = reinterpret_cast<RDType*>(reinterpret_cast<YALE_STORAGE*>(rhs->src)->a);
   RDType R_ZERO    = rhs_a[ rhs->src->shape[0] ];
 
   // copy default value from the zero location in the Yale matrix
-  LDType* default_val = ALLOC_N(LDType, 1);
+  LDType* default_val = NM_ALLOC_N(LDType, 1);
   *default_val        = static_cast<LDType>(R_ZERO);
 
   LIST_STORAGE* lhs = nm_list_storage_create(l_dtype, shape, rhs->dim, default_val);
@@ -360,7 +375,7 @@ LIST_STORAGE* create_from_yale_storage(const YALE_STORAGE* rhs, dtype_t l_dtype)
         // Is there a nonzero diagonal item between the previously added item and the current one?
         if (rj > ri && add_diag) {
           // Allocate and copy insertion value
-          insert_val  = ALLOC_N(LDType, 1);
+          insert_val  = NM_ALLOC_N(LDType, 1);
           *insert_val = static_cast<LDType>(rhs_a[ri]);
 
           // Insert the item in the list at the appropriate location.
@@ -375,7 +390,7 @@ LIST_STORAGE* create_from_yale_storage(const YALE_STORAGE* rhs, dtype_t l_dtype)
         }
 
         // now allocate and add the current item
-        insert_val  = ALLOC_N(LDType, 1);
+        insert_val  = NM_ALLOC_N(LDType, 1);
         *insert_val = static_cast<LDType>(rhs_a[ija]);
 
         if (last_added)    	last_added = list::insert_after(last_added, j, insert_val);
@@ -387,7 +402,7 @@ LIST_STORAGE* create_from_yale_storage(const YALE_STORAGE* rhs, dtype_t l_dtype)
       if (add_diag) {
 
       	// still haven't added the diagonal.
-        insert_val         = ALLOC_N(LDType, 1);
+        insert_val         = NM_ALLOC_N(LDType, 1);
         *insert_val        = static_cast<LDType>(rhs_a[ri]);
 
         // insert the item in the list at the appropriate location
@@ -405,6 +420,8 @@ LIST_STORAGE* create_from_yale_storage(const YALE_STORAGE* rhs, dtype_t l_dtype)
 		// end of walk through rows
   }
 
+  nm_yale_storage_unregister(rhs);
+
   return lhs;
 }
 
@@ -415,6 +432,9 @@ LIST_STORAGE* create_from_yale_storage(const YALE_STORAGE* rhs, dtype_t l_dtype)
  */
 template <typename LDType, typename RDType>
 static bool cast_copy_contents_dense(LIST* lhs, const RDType* rhs, RDType* zero, size_t& pos, size_t* coords, const size_t* shape, size_t dim, size_t recursions) {
+
+  nm_list_storage_register_list(lhs, recursions);
+
   NODE *prev = NULL;
   LIST *sub_list;
   bool added = false, added_list = false;
@@ -429,7 +449,7 @@ static bool cast_copy_contents_dense(LIST* lhs, const RDType* rhs, RDType* zero,
       	// is not zero
 
         // Create a copy of our value that we will insert in the list
-        LDType* insert_value = ALLOC_N(LDType, 1);
+        LDType* insert_value = NM_ALLOC_N(LDType, 1);
         *insert_value        = static_cast<LDType>(rhs[pos]);
 
         if (!lhs->first)    prev = list::insert(lhs, false, coords[dim-1-recursions], insert_value);
@@ -453,6 +473,8 @@ static bool cast_copy_contents_dense(LIST* lhs, const RDType* rhs, RDType* zero,
     }
   }
 
+  nm_list_storage_unregister_list(lhs, recursions);
+
   coords[dim-1-recursions] = 0;
   --pos;
 
@@ -471,6 +493,8 @@ namespace yale_storage { // FIXME: Move to yale.cpp
 
     if (rhs->dim != 2) rb_raise(nm_eStorageTypeError, "can only convert matrices of dim 2 to yale");
 
+    nm_dense_storage_register(rhs);
+
     IType pos = 0;
     IType ndnz = 0;
 
@@ -495,7 +519,7 @@ namespace yale_storage { // FIXME: Move to yale.cpp
     }
 
     // Copy shape for yale construction
-    size_t* shape = ALLOC_N(size_t, 2);
+    size_t* shape = NM_ALLOC_N(size_t, 2);
     shape[0] = rhs->shape[0];
     shape[1] = rhs->shape[1];
 
@@ -539,6 +563,8 @@ namespace yale_storage { // FIXME: Move to yale.cpp
     lhs_ija[shape[0]] = ija; // indicate the end of the last row
     lhs->ndnz = ndnz;
 
+    nm_dense_storage_unregister(rhs);
+
     return lhs;
   }
 
@@ -556,10 +582,11 @@ namespace yale_storage { // FIXME: Move to yale.cpp
     } else if (strncmp(reinterpret_cast<const char*>(rhs->default_val), "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0", DTYPE_SIZES[rhs->dtype]))
       rb_raise(nm_eStorageTypeError, "list matrix of non-Ruby objects must have default value of 0 to convert to yale");
 
+    nm_list_storage_register(rhs);
 
     size_t ndnz = nm_list_storage_count_nd_elements(rhs);
     // Copy shape for yale construction
-    size_t* shape = ALLOC_N(size_t, 2);
+    size_t* shape = NM_ALLOC_N(size_t, 2);
     shape[0] = rhs->shape[0];
     shape[1] = rhs->shape[1];
 
@@ -612,6 +639,8 @@ namespace yale_storage { // FIXME: Move to yale.cpp
     lhs_ija[rhs->shape[0]] = ija; // indicate the end of the last row
     lhs->ndnz = ndnz;
 
+    nm_list_storage_unregister(rhs);
+
     return lhs;
   }
 

data/ext/nmatrix/storage/storage.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.
 //
@@ -45,8 +45,8 @@
 #include "data/data.h"
 
 #include "common.h"
-#include "dense.h"
-#include "list.h"
+#include "dense/dense.h"
+#include "list/list.h"
 #include "yale/yale.h"
 
 /*

data/ext/nmatrix/storage/yale/class.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.
 //
@@ -29,8 +29,9 @@
 #ifndef YALE_CLASS_H
 # define YALE_CLASS_H
 
-#include "../dense.h"
+#include "../dense/dense.h"
 #include "math/transpose.h"
+#include "yale.h"
 
 namespace nm {
 
@@ -50,14 +51,22 @@ public:
      slice(storage != storage->src),
      slice_shape(storage->shape),
      slice_offset(storage->offset)
-  { }
+  {
+    nm_yale_storage_register(storage->src);
+  }
 
   YaleStorage(const STORAGE* storage)
    : s(reinterpret_cast<YALE_STORAGE*>(storage->src)),
      slice(storage != storage->src),
      slice_shape(storage->shape),
      slice_offset(storage->offset)
-  { }
+  {
+    nm_yale_storage_register(reinterpret_cast<STORAGE*>(storage->src));
+  }
+
+  ~YaleStorage() {
+    nm_yale_storage_unregister(s);
+  }
 
   /* Allows us to do YaleStorage<uint8>::dtype() to get an nm::dtype_t */
   static nm::dtype_t dtype() {
@@ -72,6 +81,7 @@ public:
   inline const D& default_obj() const { return a(s->shape[0]); }
   inline const D& const_default_obj() const { return a(s->shape[0]); }
 
+
   /*
    * Return a Ruby VALUE representation of default_obj()
    */
@@ -98,6 +108,14 @@ public:
   inline size_t  size() const { return ija(real_shape(0));         }
 
 
+  /*
+   * Returns true if the value at apos is the default value.
+   * Mainly used for determining if the diagonal contains zeros.
+   */
+  bool is_pos_default_value(size_t apos) const {
+    return (a(apos) == const_default_obj());
+  }
+
   /*
    * Given a size-2 array of size_t, representing the shape, determine
    * the maximum size of YaleStorage arrays.
@@ -328,7 +346,7 @@ public:
 
       // Make the necessary modifications, which hopefully can be done in-place.
       size_t v_offset = 0;
-      int accum       = 0;
+      //int accum       = 0;
       for (size_t ii = 0; ii < lengths[0]; ++ii, ++i) {
         i.insert(row_stored_nd_iterator(i, p.pos[ii]), j, lengths[1], v, v_size, v_offset);
       }
@@ -344,6 +362,8 @@ public:
    */
   void insert(SLICE* slice, VALUE right) {
 
+    NM_CONSERVATIVE(nm_register_value(right));
+
     std::pair<NMATRIX*,bool> nm_and_free =
       interpret_arg_as_dense_nmatrix(right, dtype());
     // Map the data onto D* v
@@ -358,10 +378,17 @@ public:
 
     } else if (TYPE(right) == T_ARRAY) {
       v_size = RARRAY_LEN(right);
-      v      = ALLOC_N(D, v_size);
+      v      = NM_ALLOC_N(D, v_size);
+      if (dtype() == nm::RUBYOBJ) {
+       nm_register_values(reinterpret_cast<VALUE*>(v), v_size);
+      }
       for (size_t m = 0; m < v_size; ++m) {
         rubyval_to_cval(rb_ary_entry(right, m), s->dtype, &(v[m]));
       }
+      if (dtype() == nm::RUBYOBJ) {
+       nm_unregister_values(reinterpret_cast<VALUE*>(v), v_size);
+      }
+
     } else {
       v = reinterpret_cast<D*>(rubyobj_to_cval(right, dtype()));
     }
@@ -381,7 +408,9 @@ public:
       if (nm_and_free.second) {
         nm_delete(nm_and_free.first);
       }
-    } else xfree(v);
+    } else NM_FREE(v);
+
+    NM_CONSERVATIVE(nm_unregister_value(right));
   }
 
 
@@ -489,15 +518,15 @@ public:
    * Allocate a reference pointing to s. Note that even if +this+ is a reference,
    * we can create a reference within it.
    *
-   * Note: Make sure you xfree() the result of this call. You can't just cast it
+   * Note: Make sure you NM_FREE() the result of this call. You can't just cast it
    * directly into a YaleStorage<D> class.
    */
   YALE_STORAGE* alloc_ref(SLICE* slice) {
-    YALE_STORAGE* ns  = ALLOC( YALE_STORAGE );
+    YALE_STORAGE* ns  = NM_ALLOC( YALE_STORAGE );
 
     ns->dim           = s->dim;
-    ns->offset        = ALLOC_N(size_t, ns->dim);
-    ns->shape         = ALLOC_N(size_t, ns->dim);
+    ns->offset        = NM_ALLOC_N(size_t, ns->dim);
+    ns->shape         = NM_ALLOC_N(size_t, ns->dim);
 
     for (size_t d = 0; d < ns->dim; ++d) {
       ns->offset[d]   = slice->coords[d]  + offset(d);
@@ -522,12 +551,12 @@ public:
    * Allocates and initializes the basic struct (but not IJA or A vectors).
    */
   static YALE_STORAGE* alloc(size_t* shape, size_t dim = 2) {
-    YALE_STORAGE* s = ALLOC( YALE_STORAGE );
+    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 d = 0; d < dim; ++d)
       s->offset[d]  = 0;
     s->dim          = dim;
@@ -556,8 +585,8 @@ public:
       s->capacity = reserve;
     }
 
-    s->ija = ALLOC_N( size_t, s->capacity );
-    s->a   = ALLOC_N( D,      s->capacity );
+    s->ija = NM_ALLOC_N( size_t, s->capacity );
+    s->a   = NM_ALLOC_N( D,      s->capacity );
 
     return s;
   }
@@ -608,14 +637,14 @@ public:
    template <typename E>
    YALE_STORAGE* alloc_basic_copy(size_t new_capacity, size_t new_ndnz) const {
      nm::dtype_t new_dtype = nm::ctype_to_dtype_enum<E>::value_type;
-     YALE_STORAGE* lhs     = ALLOC( YALE_STORAGE );
+     YALE_STORAGE* lhs     = NM_ALLOC( YALE_STORAGE );
      lhs->dim              = s->dim;
-     lhs->shape            = ALLOC_N( size_t, lhs->dim );
+     lhs->shape            = NM_ALLOC_N( size_t, lhs->dim );
 
      lhs->shape[0]         = shape(0);
      lhs->shape[1]         = shape(1);
 
-     lhs->offset           = ALLOC_N( size_t, lhs->dim );
+     lhs->offset           = NM_ALLOC_N( size_t, lhs->dim );
 
      lhs->offset[0]        = 0;
      lhs->offset[1]        = 0;
@@ -623,8 +652,8 @@ public:
      lhs->capacity         = new_capacity;
      lhs->dtype            = new_dtype;
      lhs->ndnz             = new_ndnz;
-     lhs->ija              = ALLOC_N( size_t, new_capacity );
-     lhs->a                = ALLOC_N( E,      new_capacity );
+     lhs->ija              = NM_ALLOC_N( size_t, new_capacity );
+     lhs->a                = NM_ALLOC_N( E,      new_capacity );
      lhs->src              = lhs;
      lhs->count            = 1;
 
@@ -633,7 +662,7 @@ public:
 
 
   /*
-   * Make a full matrix structure copy (entries remain uninitialized). Remember to xfree()!
+   * Make a full matrix structure copy (entries remain uninitialized). Remember to NM_FREE()!
    */
   template <typename E>
   YALE_STORAGE* alloc_struct_copy(size_t new_capacity) const {
@@ -655,7 +684,7 @@ public:
    */
   template <typename E, bool Yield=false>
   void copy(YALE_STORAGE& ns) const {
-    nm::dtype_t new_dtype = nm::ctype_to_dtype_enum<E>::value_type;
+    //nm::dtype_t new_dtype = nm::ctype_to_dtype_enum<E>::value_type;
     // get the default value for initialization (we'll re-use val for other copies after this)
     E val = static_cast<E>(const_default_obj());
 
@@ -665,6 +694,7 @@ public:
 
     E* ns_a    = reinterpret_cast<E*>(ns.a);
     size_t sz  = shape(0) + 1; // current used size of ns
+    nm_yale_storage_register(&ns);
 
     // FIXME: If diagonals line up, it's probably faster to do this with stored diagonal and stored non-diagonal iterators
     for (const_row_iterator it = cribegin(); it != criend(); ++it) {
@@ -681,6 +711,7 @@ public:
       }
       ns.ija[it.i()+1]  = sz;
     }
+    nm_yale_storage_unregister(&ns);
 
     //ns.ija[shape(0)] = sz;                // indicate end of last row
     ns.ndnz          = sz - shape(0) - 1; // update ndnz count
@@ -688,17 +719,17 @@ public:
 
 
   /*
-   * Allocate a casted copy of this matrix/reference. Remember to xfree() the result!
+   * Allocate a casted copy of this matrix/reference. Remember to NM_FREE() the result!
    *
    * If Yield is true, E must be nm::RubyObject, and it will call an rb_yield upon the stored value.
    */
   template <typename E, bool Yield = false>
   YALE_STORAGE* alloc_copy() const {
-    nm::dtype_t new_dtype = nm::ctype_to_dtype_enum<E>::value_type;
+    //nm::dtype_t new_dtype = nm::ctype_to_dtype_enum<E>::value_type;
 
     YALE_STORAGE* lhs;
     if (slice) {
-      size_t* xshape    = ALLOC_N(size_t, 2);
+      size_t* xshape    = NM_ALLOC_N(size_t, 2);
       xshape[0]         = shape(0);
       xshape[1]         = shape(1);
       size_t ndnz       = count_copy_ndnz();
@@ -708,6 +739,7 @@ public:
 
       lhs               = YaleStorage<E>::create(xshape, reserve);
 
+      // FIXME: This should probably be a throw which gets caught outside of the object.
       if (lhs->capacity < reserve)
         rb_raise(nm_eStorageTypeError, "conversion failed; capacity of %lu requested, max allowable is %lu", reserve, lhs->capacity);
 
@@ -718,10 +750,15 @@ public:
       lhs               = alloc_struct_copy<E>(s->capacity);
 
       E* la = reinterpret_cast<E*>(lhs->a);
+
+      nm_yale_storage_register(lhs);
       for (size_t m = 0; m < size(); ++m) {
-        if (Yield) la[m] = rb_yield(nm::yale_storage::nm_rb_dereference(a(m)));
+        if (Yield) {
+	  la[m] = rb_yield(nm::yale_storage::nm_rb_dereference(a(m)));
+	}
         else       la[m] = static_cast<E>(a(m));
       }
+      nm_yale_storage_unregister(lhs);
 
     }
 
@@ -732,7 +769,7 @@ public:
    * Allocate a transposed copy of the matrix
    */
   /*
-   * Allocate a casted copy of this matrix/reference. Remember to xfree() the result!
+   * Allocate a casted copy of this matrix/reference. Remember to NM_FREE() the result!
    *
    * If Yield is true, E must be nm::RubyObject, and it will call an rb_yield upon the stored value.
    */
@@ -743,7 +780,7 @@ public:
       rb_raise(rb_eNotImpError, "please make a copy before transposing");
     } else {
       // Copy the structure and setup the IJA structure.
-      size_t* xshape    = ALLOC_N(size_t, 2);
+      size_t* xshape    = NM_ALLOC_N(size_t, 2);
       xshape[0]         = shape(1);
       xshape[1]         = shape(0);
 
@@ -806,30 +843,44 @@ public:
    */
   template <typename E>
   VALUE map_merged_stored(VALUE klass, nm::YaleStorage<E>& t, VALUE r_init) const {
+    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);
+    
     // Make a reasonable approximation of the resulting capacity
     size_t s_ndnz   = count_copy_ndnz(),
            t_ndnz   = t.count_copy_ndnz();
     size_t reserve  = shape(0) + std::max(s_ndnz, t_ndnz) + 1;
 
-    size_t* xshape  = ALLOC_N(size_t, 2);
+    size_t* xshape  = NM_ALLOC_N(size_t, 2);
     xshape[0]       = shape(0);
     xshape[1]       = shape(1);
 
     YALE_STORAGE* rs= YaleStorage<nm::RubyObject>::create(xshape, reserve);
 
-    if (r_init == Qnil)
+    if (r_init == Qnil) {
+      nm_unregister_value(r_init);
       r_init       = rb_yield_values(2, s_init, t_init);
+      nm_register_value(r_init);
+    }
 
     nm::RubyObject r_init_obj(r_init);
 
     // Prepare the matrix structure
     YaleStorage<nm::RubyObject>::init(*rs, &r_init_obj);
     NMATRIX* m     = nm_create(nm::YALE_STORE, reinterpret_cast<STORAGE*>(rs));
+    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);
+
+    RETURN_SIZED_ENUMERATOR_PRE
+    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);
 
@@ -873,6 +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);
 
     return result;
   }
@@ -900,12 +954,16 @@ protected:
     size_t new_cap = sz + p.total_change;
 
     if (new_cap > real_max_size()) {
-      xfree(v);
+      NM_FREE(v);
       rb_raise(rb_eStandardError, "resize caused by insertion of size %d (on top of current size %lu) would have caused yale matrix size to exceed its maximum (%lu)", p.total_change, sz, real_max_size());
     }
 
-    size_t* new_ija     = ALLOC_N( size_t,new_cap );
-    D* new_a            = ALLOC_N( D,     new_cap );
+    if (s->dtype == nm::RUBYOBJ) {
+      nm_register_values(reinterpret_cast<VALUE*>(v), v_size);
+    }
+
+    size_t* new_ija     = NM_ALLOC_N( size_t,new_cap );
+    D* new_a            = NM_ALLOC_N( D,     new_cap );
 
     // Copy unchanged row pointers first.
     size_t m = 0;
@@ -967,8 +1025,12 @@ protected:
 
     s->capacity = new_cap;
 
-    xfree(s->ija);
-    xfree(s->a);
+    NM_FREE(s->ija);
+    NM_FREE(s->a);
+
+    if (s->dtype == nm::RUBYOBJ) {
+      nm_unregister_values(reinterpret_cast<VALUE*>(v), v_size);
+    }   
 
     s->ija      = new_ija;
     s->a        = reinterpret_cast<void*>(new_a);
@@ -994,8 +1056,8 @@ protected:
 
     if (new_cap < sz + n) new_cap = sz + n;
 
-    size_t* new_ija     = ALLOC_N( size_t,new_cap );
-    D* new_a            = ALLOC_N( D,     new_cap );
+    size_t* new_ija     = NM_ALLOC_N( size_t,new_cap );
+    D* new_a            = NM_ALLOC_N( D,     new_cap );
 
     // Copy unchanged row pointers first.
     for (size_t m = 0; m <= real_i; ++m) {
@@ -1024,11 +1086,18 @@ protected:
       new_a[m+n]        = a(m);
     }
 
+    if (s->dtype == nm::RUBYOBJ) {
+      nm_yale_storage_register_a(new_a, new_cap);
+    }
 
     s->capacity = new_cap;
 
-    xfree(s->ija);
-    xfree(s->a);
+    NM_FREE(s->ija);
+    NM_FREE(s->a);
+
+    if (s->dtype == nm::RUBYOBJ) {
+      nm_yale_storage_unregister_a(new_a, new_cap);
+    }
 
     s->ija      = new_ija;
     s->a        = reinterpret_cast<void*>(new_a);
@@ -1067,4 +1136,4 @@ protected:
 
 } // end of nm namespace
 
-#endif // YALE_CLASS_H
+#endif // YALE_CLASS_H