nmatrix 0.0.6 → 0.0.7

data/ext/nmatrix/storage/storage.cpp

@@ -139,7 +139,8 @@ DENSE_STORAGE* create_from_yale_storage(const YALE_STORAGE* rhs, dtype_t l_dtype
 
   // Allocate and set shape.
   size_t* shape = ALLOC_N(size_t, rhs->dim);
-  memcpy(shape, rhs->shape, rhs->dim * sizeof(size_t));
+  shape[0] = rhs->shape[0];
+  shape[1] = rhs->shape[1];
 
   DENSE_STORAGE* lhs = nm_dense_storage_create(l_dtype, shape, rhs->dim, NULL, 0);
   LDType* lhs_elements = reinterpret_cast<LDType*>(lhs->elements);
@@ -147,45 +148,49 @@ DENSE_STORAGE* create_from_yale_storage(const YALE_STORAGE* rhs, dtype_t l_dtype
   // Position in dense to write to.
   size_t pos = 0;
 
-  LDType LCAST_ZERO = rhs_a[rhs->shape[0]];
+  LDType LCAST_ZERO = rhs_a[rhs->src->shape[0]];
 
   // Walk through rows. For each entry we set in dense, increment pos.
-  for (RIType i = 0; i < rhs->shape[0]; ++i) {
-
-    // Position in yale array
-    RIType ija = rhs_ija[i];
+  for (size_t i = 0; i < shape[0]; ++i) {
+    RIType ri = i + rhs->offset[0];
 
-    if (ija == rhs_ija[i+1]) { // Check boundaries of row: is row empty?
+    if (rhs_ija[ri] == rhs_ija[ri+1]) { // Check boundaries of row: is row empty? (Yes.)
 
 			// Write zeros in each column.
-			for (RIType j = 0; j < rhs->shape[1]; ++j) { // Move to next dense position.
+			for (size_t j = 0; j < shape[1]; ++j) { // Move to next dense position.
 
-        // Fill in zeros (except for diagonal)
-        if (i == j) lhs_elements[pos] = static_cast<LDType>(rhs_a[i]);
-				else        lhs_elements[pos] = LCAST_ZERO;
+        // Fill in zeros and copy the diagonal entry for this empty row.
+        if (ri == j + rhs->offset[1]) lhs_elements[pos] = static_cast<LDType>(rhs_a[ri]);
+				else                          lhs_elements[pos] = LCAST_ZERO;
 
 				++pos;
       }
 
-    } else {
-      // Row contains entries: write those in each column, interspersed with zeros.
-      RIType jj = rhs_ija[ija];
+    } else {  // Row contains entries: write those in each column, interspersed with zeros.
+
+      // Get the first ija position of the row (as sliced)
+      RIType ija = nm::yale_storage::binary_search_left_boundary<RIType>(rhs, rhs_ija[ri], rhs_ija[ri+1]-1, rhs->offset[1]);
+
+      // What column is it?
+      RIType next_stored_rj = rhs_ija[ija];
 
-			for (size_t j = 0; j < rhs->shape[1]; ++j) {
-        if (i == j) {
-          lhs_elements[pos] = static_cast<LDType>(rhs_a[i]);
+			for (size_t j = 0; j < shape[1]; ++j) {
+			  RIType rj = j + rhs->offset[1];
 
-        } else if (j == jj) {
+        if (rj == ri) { // at a diagonal in RHS
+          lhs_elements[pos] = static_cast<LDType>(rhs_a[ri]);
+
+        } else if (rj == next_stored_rj) { // column ID was found in RHS
           lhs_elements[pos] = static_cast<LDType>(rhs_a[ija]); // Copy from rhs.
 
           // Get next.
           ++ija;
 
           // Increment to next column ID (or go off the end).
-          if (ija < rhs_ija[i+1]) jj = rhs_ija[ija];
-          else               	    jj = rhs->shape[1];
+          if (ija < rhs_ija[ri+1]) next_stored_rj = rhs_ija[ija];
+          else               	     next_stored_rj = rhs->src->shape[1];
 
-        } else { // j < jj
+        } else { // rj < next_stored_rj
 
           // Insert zero.
           lhs_elements[pos] = LCAST_ZERO;
@@ -319,7 +324,7 @@ LIST_STORAGE* create_from_yale_storage(const YALE_STORAGE* rhs, dtype_t l_dtype)
   shape[0] = rhs->shape[0]; shape[1] = rhs->shape[1];
 
   RDType* rhs_a    = reinterpret_cast<RDType*>(rhs->a);
-  RDType R_ZERO    = rhs_a[ rhs->shape[0] ];
+  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);
@@ -333,35 +338,43 @@ LIST_STORAGE* create_from_yale_storage(const YALE_STORAGE* rhs, dtype_t l_dtype)
 
   NODE *last_row_added = NULL;
   // Walk through rows and columns as if RHS were a dense matrix
-  for (RIType i = 0; i < rhs->shape[0]; ++i) {
+  for (RIType i = 0; i < shape[0]; ++i) {
+    RIType ri = i + rhs->offset[0];
+
     NODE *last_added = NULL;
 
     // Get boundaries of beginning and end of row
-    RIType ija      = rhs_ija[i],
-           ija_next = rhs_ija[i+1];
+    RIType ija      = rhs_ija[ri],
+           ija_next = rhs_ija[ri+1];
 
     // Are we going to need to add a diagonal for this row?
     bool add_diag = false;
-    if (rhs_a[i] != R_ZERO) add_diag = true;
+    if (rhs_a[ri] != R_ZERO) add_diag = true; // non-zero and located within the bounds of the slice
 
     if (ija < ija_next || add_diag) {
+      ija = nm::yale_storage::binary_search_left_boundary<RIType>(rhs, ija, ija_next-1, rhs->offset[1]);
 
       LIST* curr_row = list::create();
 
       LDType* insert_val;
 
       while (ija < ija_next) {
-        RIType jj = rhs_ija[ija]; // what column number is this?
+        // Find first column in slice
+        RIType rj = rhs_ija[ija];
+        RIType j  = rj - rhs->offset[1];
 
         // Is there a nonzero diagonal item between the previously added item and the current one?
-        if (jj > i && add_diag) {
+        if (rj > ri && add_diag) {
           // Allocate and copy insertion value
           insert_val  = ALLOC_N(LDType, 1);
-          *insert_val = static_cast<LDType>(rhs_a[i]);
+          *insert_val = static_cast<LDType>(rhs_a[ri]);
 
-          // insert the item in the list at the appropriate location
-          if (last_added) 	last_added = list::insert_after(last_added, i, insert_val);
-          else            	last_added = list::insert(curr_row, false, i, insert_val);
+          // Insert the item in the list at the appropriate location.
+          // What is the appropriate key? Well, it's definitely right(i)==right(j), but the
+          // rj index has already been advanced past ri. So we should treat ri as the column and
+          // subtract offset[1].
+          if (last_added) 	last_added = list::insert_after(last_added, ri - rhs->offset[1], insert_val);
+          else            	last_added = list::insert(curr_row, false,  ri - rhs->offset[1], insert_val);
 
 					// don't add again!
           add_diag = false;
@@ -371,20 +384,23 @@ LIST_STORAGE* create_from_yale_storage(const YALE_STORAGE* rhs, dtype_t l_dtype)
         insert_val  = ALLOC_N(LDType, 1);
         *insert_val = static_cast<LDType>(rhs_a[ija]);
 
-        if (last_added)    	last_added = list::insert_after(last_added, jj, insert_val);
-        else              	last_added = list::insert(curr_row, false, jj, insert_val);
+        if (last_added)    	last_added = list::insert_after(last_added, j, insert_val);
+        else              	last_added = list::insert(curr_row, false, j, insert_val);
 
         ++ija; // move to next entry in Yale matrix
       }
 
       if (add_diag) {
+
       	// still haven't added the diagonal.
         insert_val         = ALLOC_N(LDType, 1);
-        *insert_val        = static_cast<LDType>(rhs_a[i]);
+        *insert_val        = static_cast<LDType>(rhs_a[ri]);
 
         // insert the item in the list at the appropriate location
-        if (last_added)    	last_added = list::insert_after(last_added, i, insert_val);
-        else              	last_added = list::insert(curr_row, false, i, insert_val);
+        if (last_added)    	last_added = list::insert_after(last_added, ri - rhs->offset[1], insert_val);
+        else              	last_added = list::insert(curr_row, false, ri - rhs->offset[1], insert_val);
+
+        // no need to set add_diag to false because it'll be reset automatically in next iteration.
       }
 
       // Now add the list at the appropriate location
@@ -458,6 +474,7 @@ namespace yale_storage { // FIXME: Move to yale.cpp
    */
   template <typename LDType, typename RDType, typename LIType>
   YALE_STORAGE* create_from_dense_storage(const DENSE_STORAGE* rhs, dtype_t l_dtype, void* init) {
+
     if (rhs->dim != 2) rb_raise(nm_eStorageTypeError, "can only convert matrices of dim 2 to yale");
 
     LIType pos = 0;
@@ -504,16 +521,15 @@ namespace yale_storage { // FIXME: Move to yale.cpp
 
     // Start just after the zero position.
     LIType ija = shape[0]+1;
-    LIType i;
     pos        = 0;
 
     // Copy contents
-    for (i = 0; i < rhs->shape[0]; ++i) {
+    for (LIType i = 0; i < rhs->shape[0]; ++i) {
       // indicate the beginning of a row in the IJA array
-      lhs_ija[i]= ija;
+      lhs_ija[i] = ija;
 
       for (LIType j = 0; j < rhs->shape[1];  ++j) {
-        pos = rhs->stride[0]*(i + rhs->offset[0]) + rhs->stride[1]*(j + rhs->offset[1]); // calc position with offsets
+        pos = rhs->stride[0] * (i + rhs->offset[0]) + rhs->stride[1] * (j + rhs->offset[1]); // calc position with offsets
 
         if (i == j) { // copy to diagonal
           lhs_a[i]     = static_cast<LDType>(rhs_elements[pos]);
@@ -570,13 +586,13 @@ namespace yale_storage { // FIXME: Move to yale.cpp
     // Copy contents 
     for (NODE* i_curr = rhs->rows->first; i_curr; i_curr = i_curr->next) {
 
-      // Shrink refernce
+      // Shrink reference
       int i = i_curr->key - rhs->offset[0];
       if (i < 0 || i >= (int)rhs->shape[0]) continue;
 
       for (NODE* j_curr = ((LIST*)(i_curr->val))->first; j_curr; j_curr = j_curr->next) {
         
-        // Shrink refernce
+        // Shrink reference
         int j = j_curr->key - rhs->offset[1];
         if (j < 0 || j >= (int)rhs->shape[1]) continue;
 

data/ext/nmatrix/storage/yale.cpp

@@ -44,6 +44,7 @@
 #include <cstdio>     // std::fprintf
 #include <iostream>
 #include <array>
+#include <typeinfo>
 
 #define RB_P(OBJ) \
 	rb_funcall(rb_stderr, rb_intern("print"), 1, rb_funcall(OBJ, rb_intern("object_id"), 0)); \
@@ -54,9 +55,8 @@
  */
 
 // #include "types.h"
-#include "util/math.h"
-
 #include "data/data.h"
+#include "math/math.h"
 
 #include "common.h"
 #include "yale.h"
@@ -86,8 +86,11 @@ extern "C" {
   static YALE_STORAGE*  nm_copy_alloc_struct(const YALE_STORAGE* rhs, const nm::dtype_t new_dtype, const size_t new_capacity, const size_t new_size);
   static YALE_STORAGE*	alloc(nm::dtype_t dtype, size_t* shape, size_t dim, nm::itype_t min_itype);
 
+  static size_t yale_count_slice_copy_ndnz(const YALE_STORAGE* s, size_t*, size_t*);
+
   static void* default_value_ptr(const YALE_STORAGE* s);
   static VALUE default_value(const YALE_STORAGE* s);
+  static VALUE obj_at(YALE_STORAGE* s, size_t k);
 
   /* Ruby-accessible functions */
   static VALUE nm_size(VALUE self);
@@ -100,6 +103,9 @@ extern "C" {
 
   static VALUE nm_nd_row(int argc, VALUE* argv, VALUE self);
 
+  static inline size_t src_ndnz(const YALE_STORAGE* s) {
+    return reinterpret_cast<YALE_STORAGE*>(s->src)->ndnz;
+  }
 
 } // end extern "C" block
 
@@ -241,72 +247,6 @@ YALE_STORAGE* create_from_old_yale(dtype_t dtype, size_t* shape, void* r_ia, voi
 }
 
 
-/*
- * Take two Yale storages and merge them into a new Yale storage.
- *
- * Uses the left as a template for the creation of a new one.
- */
-template <typename DType, typename IType>
-YALE_STORAGE* create_merged__(const YALE_STORAGE* left, const YALE_STORAGE* right) {
-  char ins_type;
-
-  size_t size = get_size<IType>(left);
-
-  // s represents the resulting storage
-  YALE_STORAGE* s = copy_alloc_struct<IType>(left, left->dtype, NM_MAX(left->capacity, right->capacity), size);
-
-  IType* sija = reinterpret_cast<IType*>(s->ija);
-  IType* rija = reinterpret_cast<IType*>(right->ija);
-
-  // set the element between D and LU (the boundary in A), which should be 0.
-  reinterpret_cast<DType*>(s->a)[s->shape[0]] = reinterpret_cast<DType*>(left->a)[left->shape[0]];
-
-  if (right && right != left) {
-  	// some operations are unary and don't need this; others are x+x and don't need this
-
-  	for (IType i = 0; i < s->shape[0]; ++i) {
-
-      IType ija       = sija[i];
-      IType ija_next  = sija[i+1];
-
-      for (IType r_ija = rija[i]; r_ija < rija[i+1]; ++r_ija) {
-
-        size_t ja = sija[ija]; // insert expects a size_t
-
-        if (ija == ija_next) {
-        	// destination row is empty
-          ins_type = vector_insert<DType,IType>(s, ija, &ja, NULL, 1, true);
-          increment_ia_after<IType>(s, s->shape[0], i, 1);
-          ++(s->ndnz);
-          ++ija;
-
-          if (ins_type == 'i') ++ija_next;
-
-        } else {
-          bool found;
-
-        	// merge positions into destination row
-          IType pos = insert_search<IType>(s, ija, ija_next-1, sija[ija], &found);
-
-          if (!found) {
-            vector_insert<DType,IType>(s, pos, &ja, NULL, 1, true);
-            increment_ia_after<IType>(s, s->shape[0], i, 1);
-            ++(s->ndnz);
-
-            if (ins_type == 'i') ++ija_next;
-          }
-
-          // can now set a left boundary for the next search
-          ija = pos + 1;
-        }
-      }
-    }
-  }
-
-  return s;
-}
-
-
 /*
  * Empty the matrix by initializing the IJA vector and setting the diagonal to 0.
  *
@@ -332,29 +272,27 @@ size_t max_size(YALE_STORAGE* s) {
 
   return result;
 }
+
+
 ///////////////
 // Accessors //
 ///////////////
 
+
 /*
- * Returns a slice of YALE_STORAGE object by copy
+ * Determine the number of non-diagonal non-zeros in a not-yet-created copy of a slice or matrix.
  */
-template <typename DType,typename IType>
-void* get(YALE_STORAGE* storage, SLICE* slice) {
-  
-  size_t *offset = slice->coords;
-  // Copy shape for yale construction
-  size_t* shape = ALLOC_N(size_t, 2);
-  shape[0] = slice->lengths[0];
-  shape[1] = slice->lengths[1];
+template <typename DType, typename IType>
+static size_t count_slice_copy_ndnz(const YALE_STORAGE* s, size_t* offset, size_t* shape) {
+  IType* ija = reinterpret_cast<IType*>(s->ija);
+  DType* a   = reinterpret_cast<DType*>(s->a);
 
-  IType* src_ija = reinterpret_cast<IType*>(storage->ija);
-  DType* src_a   = reinterpret_cast<DType*>(storage->a);
+  DType ZERO(*reinterpret_cast<DType*>(default_value_ptr(s)));
 
   // Calc ndnz for the destination
   size_t ndnz  = 0;
-  size_t i,j; // indexes of destination matrix
-  size_t k,l; // indexes of source matrix
+  size_t i, j; // indexes of destination matrix
+  size_t k, l; // indexes of source matrix
   for (i = 0; i < shape[0]; i++) {
     k = i + offset[0];
     for (j = 0; j < shape[1]; j++) {
@@ -363,42 +301,54 @@ void* get(YALE_STORAGE* storage, SLICE* slice) {
       if (j == i)  continue;
 
       if (k == l) { // for diagonal element of source
-        if (src_a[k] != 0) ++ndnz;
+        if (a[k] != ZERO) ++ndnz;
       } else { // for non-diagonal element
-        for (size_t c = src_ija[k]; c < src_ija[k+1]; c++) {
-          if (src_ija[c] == l) {
+        for (size_t c = ija[k]; c < ija[k+1]; c++) {
+          if (ija[c] == l) {
             ++ndnz;
             break;
           }
         }
       }
-
     }
   }
 
-  size_t request_capacity = shape[0] + ndnz + 1;
-  //fprintf(stderr, "yale get copy: shape0=%d, shape1=%d, ndnz=%d, request_capacity=%d\n", shape[0], shape[1], ndnz, request_capacity);
-  YALE_STORAGE* ns = nm_yale_storage_create(storage->dtype, shape, 2, request_capacity, storage->itype);
+  return ndnz;
+}
+
+
+
+/*
+ * Copy some portion of a matrix into a new matrix.
+ */
+template <typename LDType, typename RDType, typename IType>
+static void slice_copy(YALE_STORAGE* ns, const YALE_STORAGE* s, size_t* offset, size_t* lengths, dtype_t new_dtype) {
+
+  IType* src_ija = reinterpret_cast<IType*>(s->ija);
+  RDType* src_a  = reinterpret_cast<RDType*>(s->a);
 
-  if (ns->capacity < request_capacity)
-    rb_raise(nm_eStorageTypeError, "conversion failed; capacity of %ld requested, max allowable is %ld", request_capacity, ns->capacity);
+  RDType RZERO(*reinterpret_cast<RDType*>(default_value_ptr(s)));
 
    // Initialize the A and IJA arrays
-  init<DType,IType>(ns, default_value_ptr(storage));
-  IType* dst_ija = reinterpret_cast<IType*>(ns->ija);
-  DType* dst_a   = reinterpret_cast<DType*>(ns->a);
- 
-  size_t ija = shape[0] + 1;
-  DType val = src_a[storage->shape[0]]; // use 0 as the default for copy
-  for (i = 0; i < shape[0]; ++i) {
+  LDType val(RZERO); // need default value for init. Can't use ns default value because it's not initialized yet
+  init<LDType,IType>(ns, &val);
+  IType*  dst_ija = reinterpret_cast<IType*>(ns->ija);
+  LDType* dst_a   = reinterpret_cast<LDType*>(ns->a);
+
+  size_t ija  = lengths[0] + 1;
+
+  size_t i, j; // indexes of destination matrix
+  size_t k, l; // indexes of source matrix
+
+  for (i = 0; i < lengths[0]; ++i) {
     k = i + offset[0];
-    for (j = 0; j < shape[1]; ++j) {
+    for (j = 0; j < lengths[1]; ++j) {
       bool found = false;
       l = j + offset[1];
-    
+
       // Get value from source matrix
       if (k == l) { // source diagonal
-        if (src_a[k] != 0) { // don't bother copying non-zero values from the diagonal
+        if (src_a[k] != RZERO) { // don't bother copying non-zero values from the diagonal
           val = src_a[k];
           found = true;
         }
@@ -420,9 +370,8 @@ void* get(YALE_STORAGE* storage, SLICE* slice) {
           // copy non-diagonal element
           dst_ija[ija] = j;
           dst_a[ija]   = val;
-
           ++ija;
-          for (size_t c = i + 1; c <= shape[0]; ++c) {
+          for (size_t c = i + 1; c <= lengths[0]; ++c) {
             dst_ija[c] = ija;
           }
         }
@@ -430,39 +379,71 @@ void* get(YALE_STORAGE* storage, SLICE* slice) {
     }
   }
 
-  dst_ija[shape[0]] = ija; // indicate the end of the last row
-  ns->ndnz = ndnz;
-  return ns;
+  dst_ija[lengths[0]] = ija; // indicate the end of the last row
+  ns->ndnz            = ija - lengths[0] - 1; // update ndnz count
+}
+
+
+/*
+ * Get a single element of a yale storage object
+ */
+template <typename DType, typename IType>
+static void* get_single(YALE_STORAGE* storage, SLICE* slice) {
+
+  DType* a   = reinterpret_cast<DType*>(storage->a);
+  IType* ija = reinterpret_cast<IType*>(storage->ija);
+
+  size_t coord0 = storage->offset[0] + slice->coords[0];
+  size_t coord1 = storage->offset[1] + slice->coords[1];
+
+  if (coord0 == coord1)
+    return &(a[ coord0 ]); // return diagonal entry
+
+  if (ija[coord0] == ija[coord0+1])
+    return &(a[ storage->src->shape[0] ]); // return zero pointer
+
+  // binary search for the column's location
+  int pos = binary_search<IType>(storage, ija[coord0], ija[coord0+1]-1, coord1);
+
+  if (pos != -1 && ija[pos] == coord1)
+    return &(a[pos]); // found exact value
+
+  return &(a[ storage->src->shape[0] ]); // return a pointer that happens to be zero
 }
+
+
 /*
  * Returns a pointer to the correct location in the A vector of a YALE_STORAGE object, given some set of coordinates
  * (the coordinates are stored in slice).
  */
 template <typename DType,typename IType>
-void* ref(YALE_STORAGE* storage, SLICE* slice) {
-  size_t* coords = slice->coords;
+void* ref(YALE_STORAGE* s, SLICE* slice) {
 
-  if (!slice->single) rb_raise(rb_eNotImpError, "This type slicing not supported yet.");
+  YALE_STORAGE* ns = ALLOC( YALE_STORAGE );
 
-  DType* a = reinterpret_cast<DType*>(storage->a);
-  IType* ija = reinterpret_cast<IType*>(storage->ija);
+  ns->dim     = s->dim;
+  ns->offset  = ALLOC_N(size_t, ns->dim);
+  ns->shape   = ALLOC_N(size_t, ns->dim);
 
-  if (coords[0] == coords[1])
-    return &(a[ coords[0] ]); // return diagonal entry
+  for (size_t i = 0; i < ns->dim; ++i) {
+    ns->offset[i]   = slice->coords[i] + s->offset[i];
+    ns->shape[i]    = slice->lengths[i];
+  }
 
-  if (ija[coords[0]] == ija[coords[0]+1])
-    return &(a[ storage->shape[0] ]); // return zero pointer
+  ns->dtype   = s->dtype;
+  ns->itype   = s->itype; // or should we go by shape?
 
-	// binary search for the column's location
-  int pos = binary_search<IType>(storage,
-                                          ija[coords[0]],
-                                          ija[coords[0]+1]-1,
-                                          coords[1]);
+  ns->a       = s->a;
+  ns->ija     = s->ija;
 
-  if (pos != -1 && ija[pos] == coords[1])
-    return &(a[pos]); // found exact value
+  ns->src     = s->src;
+  s->src->count++;
+
+  ns->ndnz    = 0;
+  ns->capacity= 0;
+
+  return ns;
 
-  return &(a[ storage->shape[0] ]); // return a pointer that happens to be zero
 }
 
 /*
@@ -472,22 +453,23 @@ void* ref(YALE_STORAGE* storage, SLICE* slice) {
 template <typename DType, typename IType>
 char set(YALE_STORAGE* storage, SLICE* slice, void* value) {
   DType* v = reinterpret_cast<DType*>(value);
-  size_t* coords = slice->coords;
+  size_t coord0 = storage->offset[0] + slice->coords[0],
+         coord1 = storage->offset[1] + slice->coords[1];
 
   bool found = false;
   char ins_type;
 
-  if (coords[0] == coords[1]) {
-    reinterpret_cast<DType*>(storage->a)[coords[0]] = *v; // set diagonal
+  if (coord0 == coord1) {
+    reinterpret_cast<DType*>(storage->a)[coord0] = *v; // set diagonal
     return 'r';
   }
 
   // Get IJA positions of the beginning and end of the row
-  if (reinterpret_cast<IType*>(storage->ija)[coords[0]] == reinterpret_cast<IType*>(storage->ija)[coords[0]+1]) {
+  if (reinterpret_cast<IType*>(storage->ija)[coord0] == reinterpret_cast<IType*>(storage->ija)[coord0+1]) {
   	// empty row
-    ins_type = vector_insert<DType,IType>(storage, reinterpret_cast<IType*>(storage->ija)[coords[0]], &(coords[1]), v, 1, false);
-    increment_ia_after<IType>(storage, storage->shape[0], coords[0], 1);
-    storage->ndnz++;
+    ins_type = vector_insert<DType,IType>(storage, reinterpret_cast<IType*>(storage->ija)[coord0], &(coord1), v, 1, false);
+    increment_ia_after<IType>(storage, storage->shape[0], coord0, 1);
+    reinterpret_cast<YALE_STORAGE*>(storage->src)->ndnz++;
 
     return ins_type;
   }
@@ -498,19 +480,19 @@ char set(YALE_STORAGE* storage, SLICE* slice, void* value) {
 
   // Do a binary search for the column
   size_t pos = insert_search<IType>(storage,
-                                    reinterpret_cast<IType*>(storage->ija)[coords[0]],
-                                    reinterpret_cast<IType*>(storage->ija)[coords[0]+1]-1,
-                                    coords[1], &found);
+                                    reinterpret_cast<IType*>(storage->ija)[coord0],
+                                    reinterpret_cast<IType*>(storage->ija)[coord0+1]-1,
+                                    coord1, &found);
 
   if (found) { // replace
-    reinterpret_cast<IType*>(storage->ija)[pos] = coords[1];
+    reinterpret_cast<IType*>(storage->ija)[pos] = coord1;
     reinterpret_cast<DType*>(storage->a)[pos]   = *v;
   	return 'r';
   }
 
-  ins_type = vector_insert<DType,IType>(storage, pos, &(coords[1]), v, 1, false);
-  increment_ia_after<IType>(storage, storage->shape[0], coords[0], 1);
-  storage->ndnz++;
+  ins_type = vector_insert<DType,IType>(storage, pos, &(coord1), v, 1, false);
+  increment_ia_after<IType>(storage, storage->shape[0], coord0, 1);
+  reinterpret_cast<YALE_STORAGE*>(storage->src)->ndnz++;
 
   return ins_type;
 }
@@ -682,6 +664,31 @@ static bool ndrow_is_empty(const YALE_STORAGE* s, IType ija, const IType ija_nex
 // Utility //
 /////////////
 
+
+/*
+ * Binary search for finding the beginning of a slice. Returns the position of the first element which is larger than
+ * bound.
+ */
+template <typename IType>
+IType binary_search_left_boundary(const YALE_STORAGE* s, IType left, IType right, IType bound) {
+  if (left > right) return -1;
+
+  IType* ija  = reinterpret_cast<IType*>(s->ija);
+
+  if (ija[left] >= bound) return left; // shortcut
+
+  IType mid   = (left + right) / 2;
+  IType mid_j = ija[mid];
+
+  if (mid_j == bound)
+    return mid;
+  else if (mid_j > bound) { // eligible! don't exclude it.
+    return binary_search_left_boundary<IType>(s, left, mid, bound);
+  } else // (mid_j < bound)
+    return binary_search_left_boundary<IType>(s, mid + 1, right, bound);
+}
+
+
 /*
  * Binary search for returning stored values. Returns a non-negative position, or -1 for not found.
  */
@@ -710,6 +717,8 @@ int binary_search(YALE_STORAGE* s, IType left, IType right, IType key) {
  * Resize yale storage vectors A and IJA, copying values.
  */
 static void vector_grow(YALE_STORAGE* s) {
+  if (s->src != s) throw; // need to correct this quickly.
+
   size_t new_capacity = s->capacity * GROWTH_CONSTANT;
   size_t max_capacity = max_size(s);
 
@@ -742,6 +751,8 @@ static void vector_grow(YALE_STORAGE* s) {
  */
 template <typename DType, typename IType>
 static char vector_insert_resize(YALE_STORAGE* s, size_t current_size, size_t pos, size_t* j, size_t n, bool struct_only) {
+  if (s != s->src) throw;
+
   // Determine the new capacity for the IJA and A vectors.
   size_t new_capacity = s->capacity * GROWTH_CONSTANT;
   size_t max_capacity = max_size(s);
@@ -916,15 +927,30 @@ static IType insert_search(YALE_STORAGE* s, IType left, IType right, IType key,
 template <typename LDType, typename RDType, typename IType>
 YALE_STORAGE* cast_copy(const YALE_STORAGE* rhs, dtype_t new_dtype) {
 
-  // Allocate a new structure
-  size_t size = get_size<IType>(rhs);
-  YALE_STORAGE* lhs = copy_alloc_struct<IType>(rhs, new_dtype, rhs->capacity, size);
+  YALE_STORAGE* lhs;
 
-  if (rhs->dtype == new_dtype) {  // FIXME: Test if this condition is actually faster; second condition should work just as well.
+  if (rhs->src != rhs) { // copy the reference
+    // Copy shape for yale construction
+    size_t* shape           = ALLOC_N(size_t, 2);
+    shape[0]                = rhs->shape[0];
+    shape[1]                = rhs->shape[1];
+    size_t ndnz             = src_ndnz(rhs);
+    if (shape[0] != rhs->src->shape[0] || shape[1] != rhs->src->shape[1])
+      ndnz                  = count_slice_copy_ndnz<RDType,IType>(rhs, rhs->offset, rhs->shape); // expensive, avoid if possible
+    size_t request_capacity = shape[0] + ndnz + 1;
+    // FIXME: Should we use a different itype? Or same?
+    lhs                     = nm_yale_storage_create(new_dtype, shape, 2, request_capacity, rhs->itype);
 
-    memcpy(lhs->a, rhs->a, size * DTYPE_SIZES[new_dtype]);
+    // This check probably isn't necessary.
+    if (lhs->capacity < request_capacity)
+      rb_raise(nm_eStorageTypeError, "conversion failed; capacity of %ld requested, max allowable is %ld", request_capacity, lhs->capacity);
 
-  } else {
+    slice_copy<LDType, RDType, IType>(lhs, rhs, rhs->offset, rhs->shape, new_dtype);
+  } else { // regular copy
+
+    // Allocate a new structure
+    size_t size = get_size<IType>(rhs);
+    lhs = copy_alloc_struct<IType>(rhs, new_dtype, rhs->capacity, size);
 
     LDType* la = reinterpret_cast<LDType*>(lhs->a);
     RDType* ra = reinterpret_cast<RDType*>(rhs->a);
@@ -932,7 +958,6 @@ YALE_STORAGE* cast_copy(const YALE_STORAGE* rhs, dtype_t new_dtype) {
     for (size_t index = 0; index < size; ++index) {
       la[index] = ra[index];
     }
-
   }
 
   return lhs;
@@ -958,7 +983,10 @@ static YALE_STORAGE* copy_alloc_struct(const YALE_STORAGE* rhs, const dtype_t ne
   lhs->shape        = ALLOC_N( size_t, lhs->dim );
   lhs->offset       = ALLOC_N( size_t, lhs->dim );
   memcpy(lhs->shape, rhs->shape, lhs->dim * sizeof(size_t));
-  memcpy(lhs->shape, rhs->shape, lhs->dim * sizeof(size_t));
+  //memcpy(lhs->offset, rhs->offset, lhs->dim * sizeof(size_t));
+  lhs->offset[0]    = 0;
+  lhs->offset[1]    = 0;
+
   lhs->itype        = rhs->itype;
   lhs->capacity     = new_capacity;
   lhs->dtype        = new_dtype;
@@ -967,12 +995,16 @@ static YALE_STORAGE* copy_alloc_struct(const YALE_STORAGE* rhs, const dtype_t ne
   lhs->ija          = ALLOC_N( IType, lhs->capacity );
   lhs->a            = ALLOC_N( char, DTYPE_SIZES[new_dtype] * lhs->capacity );
   lhs->src          = lhs;
+  lhs->count        = 1;
 
   // Now copy the contents -- but only within the boundaries set by the size. Leave
   // the rest uninitialized.
-  for (size_t i = 0; i < get_size<IType>(rhs); ++i)
-    reinterpret_cast<IType*>(lhs->ija)[i] = reinterpret_cast<IType*>(rhs->ija)[i]; // copy indices
-
+  if (!rhs->offset[0] && !rhs->offset[1]) {
+    for (size_t i = 0; i < get_size<IType>(rhs); ++i)
+      reinterpret_cast<IType*>(lhs->ija)[i] = reinterpret_cast<IType*>(rhs->ija)[i]; // copy indices
+  } else {
+    rb_raise(rb_eNotImpError, "cannot copy struct due to different offsets");
+  }
   return lhs;
 }
 
@@ -1045,13 +1077,6 @@ static std::array<size_t,2> get_offsets(YALE_STORAGE* x) {
 }
 
 
-static VALUE obj_at(YALE_STORAGE* s, size_t k) {
-  if (s->dtype == nm::RUBYOBJ)  return reinterpret_cast<VALUE*>(s->a)[k];
-  else  return rubyobj_from_cval(reinterpret_cast<void*>(reinterpret_cast<char*>(s->a) + k * DTYPE_SIZES[s->dtype]), s->dtype).rval;
-}
-
-
-
 template <typename IType>
 class IJAManager {
 protected:
@@ -1127,10 +1152,6 @@ public:
   }
 
   inline IType proper_j() const {
-    //if (!diag && k >= s->capacity) {
-    //  std::cerr << "proper_j(): Warning: (nondiag) k exceeded capacity at row " << int(i) << ": k=" << int(k) << ", cap=" << s->capacity << std::endl;
-    //  throw;
-    //}
     return diag ? i : ija[k];
   }
 
@@ -1193,7 +1214,6 @@ public:
     } else if (!row_has_diag()) {                           // row has no diagonal entries
       if (row_has_no_nd() || k_is_last_nd()) End = true;    // row is totally empty, or we're at last entry
       else k++;                                             // still entries to visit
-//    } else if (row_has_no_nd()) { // in this case we started at diag, so don't check it
     } else { // not at diag but it exists somewhere in the row, and row has at least one nd entry
       if (diag_is_ahead()) { // diag is ahead
         if (k_is_last_nd()) diag = true; // diag is next and last
@@ -1207,9 +1227,6 @@ public:
       }
     }
 
-    //if (k >= s->capacity)
-    //  std::cerr << "operator++: Warning: k has exceeded capacity for row " << int(i) << "; k=" << int(k) << ", cap=" << s->capacity << std::endl;
-
     return *this;
   }
 
@@ -1222,6 +1239,7 @@ public:
 };
 
 
+
 template <typename IType>
 static VALUE map_stored(VALUE self) {
 
@@ -1236,7 +1254,15 @@ static VALUE map_stored(VALUE self) {
   RETURN_SIZED_ENUMERATOR(self, 0, 0, nm_yale_enumerator_length);
   VALUE init      = rb_yield(default_value(s));
 
-  YALE_STORAGE* r = nm_yale_storage_create(nm::RUBYOBJ, shape, 2, s->capacity, NM_ITYPE(self));
+  // Try to find a reasonable capacity to request when creating the matrix
+  size_t ndnz     = src_ndnz(s);
+  if (s->src != s) // need to guess capacity
+    ndnz = yale_count_slice_copy_ndnz(s, s->offset, s->shape);
+  size_t request_capacity = s->shape[0] + ndnz + 1;
+
+  YALE_STORAGE* r = nm_yale_storage_create(nm::RUBYOBJ, shape, 2, request_capacity, NM_ITYPE(self));
+  if (r->capacity < request_capacity)
+    rb_raise(nm_eStorageTypeError, "conversion failed; capacity of %ld requested, max allowable is %ld", request_capacity, r->capacity);
   nm_yale_storage_init(r, &init);
 
   for (IType ri = 0; ri < shape[0]; ++ri) {
@@ -1314,7 +1340,16 @@ static VALUE map_merged_stored(VALUE left, VALUE right, VALUE init, nm::itype_t
   if (init == Qnil)
     init          = rb_yield_values(2, s_init, t_init);
 
-  YALE_STORAGE* r = nm_yale_storage_create(nm::RUBYOBJ, shape, 2, NM_MAX(s->capacity, t->capacity), itype);
+  // Make a reasonable approximation of the resulting capacity
+  size_t s_ndnz = src_ndnz(s), t_ndnz = src_ndnz(t);
+  if (s->src != s) s_ndnz = yale_count_slice_copy_ndnz(s, s->offset, s->shape);
+  if (t->src != t) t_ndnz = yale_count_slice_copy_ndnz(t, t->offset, t->shape);
+  size_t request_capacity = shape[0] + NM_MAX(s_ndnz, t_ndnz) + 1;
+
+  YALE_STORAGE* r = nm_yale_storage_create(nm::RUBYOBJ, shape, 2, request_capacity, itype);
+  if (r->capacity < request_capacity)
+    rb_raise(nm_eStorageTypeError, "conversion failed; capacity of %ld requested, max allowable is %ld", request_capacity, r->capacity);
+
   nm_yale_storage_init(r, &init);
 
   IJAManager<IType> sm(s, itype),
@@ -1325,7 +1360,7 @@ static VALUE map_merged_stored(VALUE left, VALUE right, VALUE init, nm::itype_t
     RowIterator<IType> tit(t, tm.ija, ri + t_offsets[0], shape[1], t_offsets[1]);
 
     RowIterator<IType> rit(r, reinterpret_cast<IType*>(r->ija), ri, shape[1]);
-    while (!rit.end() && (!sit.end() || !tit.end())) {
+    while (!sit.end() || !tit.end()) {
       VALUE rv;
       IType rj;
 
@@ -1360,179 +1395,99 @@ static VALUE map_merged_stored(VALUE left, VALUE right, VALUE init, nm::itype_t
 }
 
 
-} // end of namespace nm::yale_storage
-
-
-// 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) {
-  long len = nm_yale_storage_get_size(NM_STORAGE_YALE(nmatrix));
-  return LONG2NUM(len);
-}
-
-
-
+/*
+ * This function and the two helper structs enable us to use partial template specialization.
+ * See also: http://stackoverflow.com/questions/6623375/c-template-specialization-on-functions
+ */
 template <typename DType, typename IType>
-struct yale_iteration_helper {
-
-  static VALUE iterate_with_indices(VALUE nm) {
-    YALE_STORAGE* s = NM_STORAGE_YALE(nm);
-    DType* a        = reinterpret_cast<DType*>(s->a);
-    IType* ija      = reinterpret_cast<IType*>(s->ija);
-
-    // If we don't have a block, return an enumerator.
-    RETURN_SIZED_ENUMERATOR(nm, 0, 0, nm_yale_enumerator_length);
+static VALUE each_stored_with_indices(VALUE nm) {
+  YALE_STORAGE* s = NM_STORAGE_YALE(nm);
+  DType* a        = reinterpret_cast<DType*>(s->a);
+  IType* ija      = reinterpret_cast<IType*>(s->ija);
 
-    // Iterate in two dimensions.
-    for (long i = 0; i < s->shape[0]; ++i) {
-      VALUE ii = LONG2NUM(i);
+  // If we don't have a block, return an enumerator.
+  RETURN_SIZED_ENUMERATOR(nm, 0, 0, nm_yale_stored_enumerator_length);
 
-      IType k = ija[i], k_next = ija[i+1];
-
-      for (long j = 0; j < s->shape[1]; ++j) {
-        VALUE v, jj = LONG2NUM(j);
-
-        // zero is stored in s->shape[0]
-        if (i == j) {
-          v = rubyobj_from_cval(&(a[i]), NM_DTYPE(nm)).rval;
-        } else {
-          // Walk through the row until we find the correct location.
-          while (ija[k] < j && k < k_next) ++k;
-          if (k < k_next && ija[k] == j) {
-            v = rubyobj_from_cval(&(a[k]), NM_DTYPE(nm)).rval;
-            ++k;
-          } else v = rubyobj_from_cval(&(a[s->shape[0]]), NM_DTYPE(nm)).rval;
-        }
-        rb_yield_values(3, v, ii, jj);
-      }
-    }
+  // Iterate along diagonal
+  for (size_t sk = NM_MAX(s->offset[0], s->offset[1]); sk < NM_MIN(s->shape[0] + s->offset[0], s->shape[1] + s->offset[1]); ++sk) {
+    VALUE ii = LONG2NUM(sk - s->offset[0]),
+          jj = LONG2NUM(sk - s->offset[1]);
 
-    return nm;
+    rb_yield_values(3, obj_at(s, sk), ii, jj);
   }
 
+  // Iterate through non-diagonal elements, row by row
+  for (long ri = 0; ri < s->shape[0]; ++ri) {
+    long si      = ri + s->offset[0];
+    IType p      = ija[si],
+          next_p = ija[si+1];
 
-  static VALUE iterate_stored_with_indices(VALUE nm) {
-
-    YALE_STORAGE* s = NM_STORAGE_YALE(nm);
-    DType* a        = reinterpret_cast<DType*>(s->a);
-    IType* ija      = reinterpret_cast<IType*>(s->ija);
-
-    // If we don't have a block, return an enumerator.
-    RETURN_SIZED_ENUMERATOR(nm, 0, 0, nm_yale_stored_enumerator_length);
-
-    // Iterate along diagonal
-    for (size_t k = 0; k < s->shape[0]; ++k) {
-      VALUE ii = LONG2NUM(k),
-            jj = LONG2NUM(k);
+    // if this is a reference to another matrix, we should find the left boundary of the slice
+    if (s != s->src && p < next_p)
+      p = binary_search_left_boundary<IType>(s, p, next_p-1, s->offset[1]);
 
-      VALUE v = rubyobj_from_cval(&(a[k]), NM_DTYPE(nm)).rval;
-      rb_yield_values(3, v, ii, jj );
-    }
-
-    // Iterate through non-diagonal elements, row by row
-    for (long i = 0; i < s->shape[0]; ++i) {
-      long p      = static_cast<long>( ija[i]   ),
-           next_p = static_cast<long>( ija[i+1] );
+    for (; p < next_p; ++p) {
+      long sj = static_cast<long>(ija[p]),
+           rj = sj - s->offset[1];
+      if (rj < 0) continue;
 
-      for (; p < next_p; ++p) {
-        long j = static_cast<long>(ija[p]);
-        VALUE ii = LONG2NUM(i),
-              jj = LONG2NUM(j);
+      if (rj >= s->shape[1]) break;
 
-        VALUE v = rubyobj_from_cval(&(a[p]), NM_DTYPE(nm)).rval;
-        rb_yield_values(3, v, ii, jj);
-      }
+      rb_yield_values(3, obj_at(s, p), LONG2NUM(ri), LONG2NUM(rj));
     }
-
-    return nm;
   }
-};
 
+  return nm;
+}
 
-template <typename IType>
-struct yale_iteration_helper<RubyObject, IType> {
-  static VALUE iterate_with_indices(VALUE nm) {
-    YALE_STORAGE* s = NM_STORAGE_YALE(nm);
-    RubyObject* a   = reinterpret_cast<RubyObject*>(s->a);
-    IType* ija      = reinterpret_cast<IType*>(s->ija);
+template <typename DType, typename IType>
+static VALUE each_with_indices(VALUE nm) {
+  YALE_STORAGE* s = NM_STORAGE_YALE(nm);
+  DType* a        = reinterpret_cast<DType*>(s->a);
+  IType* ija      = reinterpret_cast<IType*>(s->ija);
 
-    // If we don't have a block, return an enumerator.
-    RETURN_SIZED_ENUMERATOR(nm, 0, 0, nm_yale_enumerator_length);
+  // If we don't have a block, return an enumerator.
+  RETURN_SIZED_ENUMERATOR(nm, 0, 0, nm_yale_enumerator_length);
 
-    // Iterate in two dimensions.
-    for (long i = 0; i < s->shape[0]; ++i) {
-      VALUE ii = LONG2NUM(i);
+  // Iterate in two dimensions.
+  // s stands for src, r stands for ref (for ri, rj, si, sj)
+  for (long ri = 0; ri < s->shape[0]; ++ri) {
+    long si  = ri + s->offset[0];
+    VALUE ii = LONG2NUM(ri + s->offset[0]);
 
-      IType k = ija[i], k_next = ija[i+1];
+    IType k = ija[si], k_next = ija[si+1];
 
-      for (long j = 0; j < s->shape[1]; ++j) {
-        VALUE v, jj = LONG2NUM(j);
+    for (long rj = 0; rj < s->shape[1]; ++rj) {
+      long sj     = rj + s->offset[1];
+      VALUE v, jj = LONG2NUM(rj);
 
-        // zero is stored in s->shape[0]
-        if (i == j) {
-          v = a[i].rval;
-        } else {
-          // Walk through the row until we find the correct location.
-          while (ija[k] < j && k < k_next) ++k;
-          if (k < k_next && ija[k] == j) {
-            v = a[k].rval;
-            ++k;
-          } else v = a[s->shape[0]].rval;
-        }
-        rb_yield_values(3, v, ii, jj);
+      // zero is stored in s->shape[0]
+      if (si == sj) {
+        v = obj_at(s, si);
+      } else {
+        // Walk through the row until we find the correct location.
+        while (ija[k] < sj && k < k_next) ++k;
+        if (k < k_next && ija[k] == sj) {
+          v = obj_at(s, k);
+          ++k;
+        } else v = default_value(s); // rubyobj_from_cval(&(a[s->shape[0]]), NM_DTYPE(nm)).rval;
       }
+      rb_yield_values(3, v, ii, jj);
     }
-
-    return nm;
   }
 
-  static VALUE iterate_stored_with_indices(VALUE nm) {
-
-    YALE_STORAGE* s = NM_STORAGE_YALE(nm);
-    RubyObject* a   = reinterpret_cast<RubyObject*>(s->a);
-    IType* ija      = reinterpret_cast<IType*>(s->ija);
-
-    // If we don't have a block, return an enumerator.
-    RETURN_SIZED_ENUMERATOR(nm, 0, 0, nm_yale_stored_enumerator_length);
-
-    // Iterate along diagonal
-    for (size_t k = 0; k < s->shape[0]; ++k) {
-      VALUE ii = LONG2NUM(k),
-            jj = LONG2NUM(k);
-      rb_yield_values(3, a[k].rval, ii, jj );  // yield element, i, j
-    }
-
-    // Iterate through non-diagonal elements, row by row
-    for (long i = 0; i < s->shape[0]; ++i) {
-      IType p      = ija[i],
-            next_p = ija[i+1];
-
-      for (; p < next_p; ++p) {
-        long j = static_cast<long>(ija[p]);
-        VALUE ii = LONG2NUM(i),
-              jj = LONG2NUM(j);
-
-        rb_yield_values(3, a[p].rval, ii, jj );
-      }
-    }
+  return nm;
+}
 
-    return nm;
-  }
-};
 
+} // end of namespace nm::yale_storage
 
-/*
- * This function and the two helper structs enable us to use partial template specialization.
- * See also: http://stackoverflow.com/questions/6623375/c-template-specialization-on-functions
- */
-template <typename DType, typename IType>
-static VALUE yale_each_stored_with_indices(VALUE nm) {
-  return yale_iteration_helper<DType, IType>::iterate_stored_with_indices(nm);
-}
 
-template <typename DType, typename IType>
-static VALUE yale_each_with_indices(VALUE nm) {
-  return yale_iteration_helper<DType, IType>::iterate_with_indices(nm);
+// 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) {
+  long len = nm_yale_storage_get_size(NM_STORAGE_YALE(nmatrix));
+  return LONG2NUM(len);
 }
 
 
@@ -1577,7 +1532,7 @@ VALUE nm_yale_each_with_indices(VALUE nmatrix) {
   nm::dtype_t d = NM_DTYPE(nmatrix);
   nm::itype_t i = NM_ITYPE(nmatrix);
 
-  NAMED_LI_DTYPE_TEMPLATE_TABLE(ttable, nm::yale_each_with_indices, VALUE, VALUE)
+  NAMED_LI_DTYPE_TEMPLATE_TABLE(ttable, nm::yale_storage::each_with_indices, VALUE, VALUE)
 
   return ttable[d][i](nmatrix);
 }
@@ -1588,7 +1543,7 @@ VALUE nm_yale_each_stored_with_indices(VALUE nmatrix) {
   nm::dtype_t d = NM_DTYPE(nmatrix);
   nm::itype_t i = NM_ITYPE(nmatrix);
 
-  NAMED_LI_DTYPE_TEMPLATE_TABLE(ttable, nm::yale_each_stored_with_indices, VALUE, VALUE)
+  NAMED_LI_DTYPE_TEMPLATE_TABLE(ttable, nm::yale_storage::each_stored_with_indices, VALUE, VALUE)
 
   return ttable[d][i](nmatrix);
 }
@@ -1606,18 +1561,53 @@ char nm_yale_storage_set(STORAGE* storage, SLICE* slice, void* v) {
   return ttable[casted_storage->dtype][casted_storage->itype](casted_storage, slice, v);
 }
 
+
+/*
+ * Determine the number of non-diagonal non-zeros in a not-yet-created copy of a slice or matrix.
+ */
+static size_t yale_count_slice_copy_ndnz(const YALE_STORAGE* s, size_t* offset, size_t* shape) {
+  NAMED_LI_DTYPE_TEMPLATE_TABLE(ttable, nm::yale_storage::count_slice_copy_ndnz, size_t, const YALE_STORAGE*, size_t*, size_t*)
+
+  return ttable[s->dtype][s->itype](s, offset, shape);
+}
+
+
 /*
- * C accessor for yale_storage::get, which returns a slice of YALE_STORAGE object by coppy
+ * C accessor for yale_storage::get, which returns a slice of YALE_STORAGE object by copy
  *
  * Slicing-related.
  */
 void* nm_yale_storage_get(STORAGE* storage, SLICE* slice) {
-  NAMED_LI_DTYPE_TEMPLATE_TABLE(ttable, nm::yale_storage::get, void*, YALE_STORAGE* storage, SLICE* slice);
-  YALE_STORAGE* s = (YALE_STORAGE*)storage;
+  YALE_STORAGE* casted_storage = (YALE_STORAGE*)storage;
 
+  if (slice->single) {
+    NAMED_LI_DTYPE_TEMPLATE_TABLE(elem_copy_table,  nm::yale_storage::get_single, void*, YALE_STORAGE*, SLICE*)
 
-  YALE_STORAGE* casted_storage = (YALE_STORAGE*)storage;
-  return ttable[casted_storage->dtype][casted_storage->itype](casted_storage, slice);
+    return elem_copy_table[casted_storage->dtype][casted_storage->itype](casted_storage, slice);
+  } else {
+    // Copy shape for yale construction
+    size_t* shape           = ALLOC_N(size_t, 2);
+    shape[0]                = slice->lengths[0];
+    shape[1]                = slice->lengths[1];
+
+    // only count ndnz if our slice is smaller, otherwise use the given value
+    size_t ndnz             = src_ndnz(casted_storage);
+    if (shape[0] != casted_storage->shape[0] || shape[1] != casted_storage->shape[1])
+      ndnz = yale_count_slice_copy_ndnz(casted_storage, slice->coords, shape); // expensive operation
+
+    size_t request_capacity = shape[0] + ndnz + 1; // capacity of new matrix
+    YALE_STORAGE* ns        = nm_yale_storage_create(casted_storage->dtype, shape, 2, request_capacity, casted_storage->itype);
+
+    // This check probably isn't necessary.
+    if (ns->capacity < request_capacity)
+      rb_raise(nm_eStorageTypeError, "conversion failed; capacity of %ld requested, max allowable is %ld", request_capacity, ns->capacity);
+
+    NAMED_LRI_DTYPE_TEMPLATE_TABLE(slice_copy_table, nm::yale_storage::slice_copy, void, YALE_STORAGE* ns, const YALE_STORAGE* s, size_t*, size_t*, nm::dtype_t)
+
+    slice_copy_table[ns->dtype][casted_storage->dtype][casted_storage->itype](ns, casted_storage, slice->coords, slice->lengths, casted_storage->dtype);
+
+    return ns;
+  }
 }
 
 /*
@@ -1644,10 +1634,15 @@ static void nm_yale_storage_increment_ia_after(YALE_STORAGE* s, size_t ija_size,
  * for some set of coordinates.
  */
 void* nm_yale_storage_ref(STORAGE* storage, SLICE* slice) {
-  NAMED_LI_DTYPE_TEMPLATE_TABLE(ttable, nm::yale_storage::ref, void*, YALE_STORAGE* storage, SLICE* slice);
-
   YALE_STORAGE* casted_storage = (YALE_STORAGE*)storage;
-  return ttable[casted_storage->dtype][casted_storage->itype](casted_storage, slice);
+
+  if (slice->single) {
+    NAMED_LI_DTYPE_TEMPLATE_TABLE(elem_copy_table,  nm::yale_storage::get_single, void*, YALE_STORAGE*, SLICE*)
+    return elem_copy_table[casted_storage->dtype][casted_storage->itype](casted_storage, slice);
+  } else {
+    NAMED_LI_DTYPE_TEMPLATE_TABLE(ref_table, nm::yale_storage::ref, void*, YALE_STORAGE* storage, SLICE* slice)
+    return ref_table[casted_storage->dtype][casted_storage->itype](casted_storage, slice);
+  }
 }
 
 
@@ -1685,11 +1680,20 @@ size_t nm_yale_storage_get_size(const YALE_STORAGE* storage) {
 }
 
 
+
 /*
  * Return a void pointer to the matrix's default value entry.
  */
 static void* default_value_ptr(const YALE_STORAGE* s) {
-  return reinterpret_cast<void*>(reinterpret_cast<char*>(s->a) + (s->shape[0] * DTYPE_SIZES[s->dtype]));
+  return reinterpret_cast<void*>(reinterpret_cast<char*>(s->a) + (s->src->shape[0] * DTYPE_SIZES[s->dtype]));
+}
+
+/*
+ * Return the Ruby object at a given location in storage.
+ */
+static VALUE obj_at(YALE_STORAGE* s, size_t k) {
+  if (s->dtype == nm::RUBYOBJ)  return reinterpret_cast<VALUE*>(s->a)[k];
+  else  return rubyobj_from_cval(reinterpret_cast<void*>(reinterpret_cast<char*>(s->a) + k * DTYPE_SIZES[s->dtype]), s->dtype).rval;
 }
 
 
@@ -1816,11 +1820,26 @@ YALE_STORAGE* nm_yale_storage_create(nm::dtype_t dtype, size_t* shape, size_t di
 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);
+    }
+  }
+}
+
+/*
+ * Destructor for the yale storage ref
+ */
+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(storage->ija);
-    xfree(storage->a);
-    xfree(storage);
+    xfree(s);
   }
 }
 
@@ -1850,6 +1869,7 @@ void nm_yale_storage_mark(void* storage_base) {
   }
 }
 
+
 /*
  * Allocates and initializes the basic struct (but not the IJA or A vectors).
  */
@@ -1867,6 +1887,7 @@ static YALE_STORAGE* alloc(nm::dtype_t dtype, size_t* shape, size_t dim, nm::ity
   s->dim         = dim;
   s->itype       = nm_yale_storage_itype_by_shape(shape);
   s->src         = reinterpret_cast<STORAGE*>(s);
+  s->count       = 1;
 
   // See if a higher itype has been requested.
   if (static_cast<int8_t>(s->itype) < static_cast<int8_t>(min_itype))
@@ -1935,7 +1956,7 @@ static VALUE nm_a(int argc, VALUE* argv, VALUE self) {
     }
     VALUE ary = rb_ary_new4(size, vals);
 
-    for (size_t i = size; i < s->capacity; ++i)
+    for (size_t i = size; i < reinterpret_cast<YALE_STORAGE*>(s->src)->capacity; ++i)
       rb_ary_push(ary, Qnil);
 
     return ary;
@@ -2008,7 +2029,7 @@ static VALUE nm_lu(VALUE self) {
 
   VALUE ary = rb_ary_new4(size - s->shape[0] - 1, vals);
 
-  for (size_t i = size; i < s->capacity; ++i)
+  for (size_t i = size; i < reinterpret_cast<YALE_STORAGE*>(s->src)->capacity; ++i)
     rb_ary_push(ary, Qnil);
 
   return ary;
@@ -2053,7 +2074,7 @@ static VALUE nm_ja(VALUE self) {
 
   VALUE ary = rb_ary_new4(size - s->shape[0] - 1, vals);
 
-  for (size_t i = size; i < s->capacity; ++i)
+  for (size_t i = size; i < reinterpret_cast<YALE_STORAGE*>(s->src)->capacity; ++i)
     rb_ary_push(ary, Qnil);
 
   return ary;
@@ -2083,7 +2104,7 @@ static VALUE nm_ija(int argc, VALUE* argv, VALUE self) {
 
    VALUE ary = rb_ary_new4(size, vals);
 
-    for (size_t i = size; i < s->capacity; ++i)
+    for (size_t i = size; i < reinterpret_cast<YALE_STORAGE*>(s->src)->capacity; ++i)
       rb_ary_push(ary, Qnil);
 
     return ary;
@@ -2127,9 +2148,7 @@ static VALUE nm_nd_row(int argc, VALUE* argv, VALUE self) {
   size_t nextpos = FIX2INT(rubyobj_from_cval_by_itype((char*)(s->ija) + ITYPE_SIZES[itype]*(i+1), itype).rval);
   size_t diff = nextpos - pos;
 
-  //std::cerr << "diff = " << diff << "\tpos = " << pos << "\tnextpos = " << nextpos << std::endl;
-
-  VALUE ret; // HERE
+  VALUE ret;
   if (keys) {
     ret = rb_ary_new3(diff);
 
@@ -2212,7 +2231,7 @@ VALUE nm_vector_set(int argc, VALUE* argv, VALUE self) { //, VALUE i_, VALUE jv,
 
   char ins_type = nm_yale_storage_vector_insert(s, pos, j, vals, len, false, dtype, itype);
   nm_yale_storage_increment_ia_after(s, s->shape[0], i, len, itype);
-  s->ndnz += len;
+  reinterpret_cast<YALE_STORAGE*>(s->src)->ndnz += len;
 
   // Return the updated position
   pos += len;