nmatrix 0.0.5 → 0.0.6

data/ext/nmatrix/storage/dense.h

@@ -78,6 +78,9 @@ void						nm_dense_storage_mark(void*);
 // Accessors //
 ///////////////
 
+
+VALUE nm_dense_map_pair(VALUE self, VALUE right);
+VALUE nm_dense_map(VALUE self);
 VALUE nm_dense_each(VALUE nmatrix);
 VALUE nm_dense_each_with_indices(VALUE nmatrix);
 void*	nm_dense_storage_get(STORAGE* s, SLICE* slice);
@@ -96,7 +99,6 @@ bool nm_dense_storage_is_hermitian(const DENSE_STORAGE* mat, int lda);
 // Math //
 //////////
 
-STORAGE* nm_dense_storage_ew_op(nm::ewop_t op, const STORAGE* left, const STORAGE* right, VALUE scalar);
 STORAGE* nm_dense_storage_matrix_multiply(const STORAGE_PAIR& casted_storage, size_t* resulting_shape, bool vector);
 
 /////////////
@@ -112,7 +114,7 @@ void nm_dense_storage_coords(const DENSE_STORAGE* s, const size_t slice_pos, siz
 
 DENSE_STORAGE*  nm_dense_storage_copy(const DENSE_STORAGE* rhs);
 STORAGE*        nm_dense_storage_copy_transposed(const STORAGE* rhs_base);
-STORAGE*        nm_dense_storage_cast_copy(const STORAGE* rhs, nm::dtype_t new_dtype);
+STORAGE*        nm_dense_storage_cast_copy(const STORAGE* rhs, nm::dtype_t new_dtype, void*);
 
 } // end of extern "C" block
 

data/ext/nmatrix/storage/list.cpp

@@ -62,20 +62,189 @@ namespace nm { namespace list_storage {
  * Forward Declarations
  */
 
+class RecurseData {
+public:
+  // Note that providing init_obj argument does not override init.
+  RecurseData(const LIST_STORAGE* s, VALUE init_obj__ = Qnil) : ref(s), actual(s), shape_(s->shape), offsets(s->dim, 0), init_(s->default_val), init_obj_(init_obj__) {
+    while (actual->src != actual) {
+      for (size_t i = 0; i < s->dim; ++i) // update offsets as we recurse
+        offsets[i] += actual->offset[i];
+      actual = reinterpret_cast<LIST_STORAGE*>(actual->src);
+    }
+    actual_shape_ = actual->shape;
+
+    if (init_obj_ == Qnil) {
+      init_obj_ = s->dtype == nm::RUBYOBJ ? *reinterpret_cast<VALUE*>(s->default_val) : rubyobj_from_cval(s->default_val, s->dtype).rval;
+    }
+  }
+
+  dtype_t dtype() const { return ref->dtype; }
+
+
+  size_t dim() const { return ref->dim; }
+
+  size_t shape(size_t rec) const {
+    return shape_[ref->dim - rec - 1];
+  }
+
+  size_t* copy_alloc_shape() const {
+    size_t* new_shape = ALLOC_N(size_t, ref->dim);
+    memcpy(new_shape, shape_, sizeof(size_t)*ref->dim);
+    return new_shape;
+  }
+
+  size_t actual_shape(size_t rec) const {
+    return actual_shape_[ref->dim - rec - 1];
+  }
+
+  size_t offset(size_t rec) const {
+    return offsets[ref->dim - rec - 1];
+  }
+
+  void* init() const {
+    return init_;
+  }
+
+  VALUE init_obj() const { return init_obj_; }
+
+  LIST* top_level_list() const {
+    return reinterpret_cast<LIST*>(actual->rows);
+  }
+
+  const LIST_STORAGE* ref;
+  const LIST_STORAGE* actual;
+
+  size_t* shape_; // of ref
+  size_t* actual_shape_;
+protected:
+  std::vector<size_t> offsets; // relative to actual
+  void* init_;
+  VALUE init_obj_;
+
+};
+
+
 template <typename LDType, typename RDType>
 static LIST_STORAGE* cast_copy(const LIST_STORAGE* rhs, dtype_t new_dtype);
 
 template <typename LDType, typename RDType>
-static bool eqeq(const LIST_STORAGE* left, const LIST_STORAGE* right);
+static bool eqeq_r(RecurseData& left, RecurseData& right, const LIST* l, const LIST* r, size_t rec);
+
+template <typename SDType, typename TDType>
+static bool eqeq_empty_r(RecurseData& s, const LIST* l, size_t rec, const TDType* t_init);
+
+
+/*
+ * Recursive helper for map_merged_stored_r which handles the case where one list is empty and the other is not.
+ */
+static void map_empty_stored_r(RecurseData& result, RecurseData& s, LIST* x, const LIST* l, size_t rec, bool rev, const VALUE& t_init) {
+  NODE *curr  = l->first,
+       *xcurr = NULL;
 
-template <ewop_t op, typename LDType, typename RDType>
-static void* ew_op(LIST* dest, const LIST* left, const void* l_default, const LIST* right, const void* r_default, const size_t* shape, size_t dim);
+  // For reference matrices, make sure we start in the correct place.
+  size_t offset   = result.offset(rec);
+  size_t x_shape  = result.shape(rec);
 
-template <ewop_t op, typename LDType, typename RDType>
-static void ew_op_prime(LIST* dest, LDType d_default, const LIST* left, LDType l_default, const LIST* right, RDType r_default, const size_t* shape, size_t last_level, size_t level);
+  while (curr && curr->key < offset) {  curr = curr->next;  }
+  if (curr && curr->key - offset >= x_shape) curr = NULL;
+
+  if (rec) {
+    while (curr) {
+      LIST* val = nm::list::create();
+      map_empty_stored_r(result, s, val, reinterpret_cast<const LIST*>(curr->val), rec-1, rev, t_init);
+
+      if (!val->first) nm::list::del(val, 0);
+      else nm::list::insert_helper(x, xcurr, curr->key - offset, val);
+
+      curr = curr->next;
+      if (curr && curr->key - offset >= x_shape) curr = NULL;
+    }
+  } else {
+    while (curr) {
+      VALUE val, s_val = rubyobj_from_cval(curr->val, s.dtype()).rval;
+      if (rev) val = rb_yield_values(2, t_init, s_val);
+      else     val = rb_yield_values(2, s_val, t_init);
+
+      if (rb_funcall(val, rb_intern("!="), 1, result.init_obj()) == Qtrue)
+        xcurr = nm::list::insert_helper(x, xcurr, curr->key - offset, val);
+
+      curr = curr->next;
+      if (curr && curr->key - offset >= x_shape) curr = NULL;
+    }
+  }
+
+}
+
+
+/*
+ * Recursive helper function for nm_list_map_merged_stored
+ */
+static void map_merged_stored_r(RecurseData& result, RecurseData& left, RecurseData& right, LIST* x, const LIST* l, const LIST* r, size_t rec) {
+  NODE *lcurr = l->first,
+       *rcurr = r->first,
+       *xcurr = x->first;
+
+  // For reference matrices, make sure we start in the correct place.
+  while (lcurr && lcurr->key < left.offset(rec))  {  lcurr = lcurr->next;  }
+  while (rcurr && rcurr->key < right.offset(rec)) {  rcurr = rcurr->next;  }
+
+  if (rcurr && rcurr->key - right.offset(rec) >= result.shape(rec)) rcurr = NULL;
+  if (lcurr && lcurr->key - left.offset(rec) >= result.shape(rec))  lcurr = NULL;
+
+  if (rec) {
+    while (lcurr || rcurr) {
+      size_t key;
+      LIST*  val = nm::list::create();
+
+      if (!rcurr || (lcurr && (lcurr->key - left.offset(rec) < rcurr->key - right.offset(rec)))) {
+        map_empty_stored_r(result, left, val, reinterpret_cast<const LIST*>(lcurr->val), rec-1, false, right.init_obj());
+        key   = lcurr->key - left.offset(rec);
+        lcurr = lcurr->next;
+      } else if (!lcurr || (rcurr && (rcurr->key - right.offset(rec) < lcurr->key - left.offset(rec)))) {
+        map_empty_stored_r(result, right, val, reinterpret_cast<const LIST*>(rcurr->val), rec-1, true, left.init_obj());
+        key   = rcurr->key - right.offset(rec);
+        rcurr = rcurr->next;
+      } else { // == and both present
+        map_merged_stored_r(result, left, right, val, reinterpret_cast<const LIST*>(lcurr->val), reinterpret_cast<const LIST*>(rcurr->val), rec-1);
+        key   = lcurr->key - left.offset(rec);
+        lcurr = lcurr->next;
+        rcurr = rcurr->next;
+      }
+
+      if (!val->first) nm::list::del(val, 0); // empty list -- don't insert
+      else xcurr = nm::list::insert_helper(x, xcurr, key, val);
+
+      if (rcurr && rcurr->key - right.offset(rec) >= result.shape(rec)) rcurr = NULL;
+      if (lcurr && lcurr->key - left.offset(rec) >= result.shape(rec)) lcurr = NULL;
+    }
+  } else {
+    while (lcurr || rcurr) {
+      size_t key;
+      VALUE  val;
+
+      if (!rcurr || (lcurr && (lcurr->key - left.offset(rec) < rcurr->key - right.offset(rec)))) {
+        val   = rb_yield_values(2, rubyobj_from_cval(lcurr->val, left.dtype()).rval, right.init_obj());
+        key   = lcurr->key - left.offset(rec);
+        lcurr = lcurr->next;
+      } else if (!lcurr || (rcurr && (rcurr->key - right.offset(rec) < lcurr->key - left.offset(rec)))) {
+        val   = rb_yield_values(2, left.init_obj(), rubyobj_from_cval(rcurr->val, right.dtype()).rval);
+        key   = rcurr->key - right.offset(rec);
+        rcurr = rcurr->next;
+      } else { // == and both present
+        val   = rb_yield_values(2, rubyobj_from_cval(lcurr->val, left.dtype()).rval, rubyobj_from_cval(rcurr->val, right.dtype()).rval);
+        key   = lcurr->key - left.offset(rec);
+        lcurr = lcurr->next;
+        rcurr = rcurr->next;
+      }
+      if (rb_funcall(val, rb_intern("!="), 1, result.init_obj()) == Qtrue)
+        xcurr = nm::list::insert_helper(x, xcurr, key, val);
+
+      if (rcurr && rcurr->key - right.offset(rec) >= result.shape(rec)) rcurr = NULL;
+      if (lcurr && lcurr->key - left.offset(rec) >= result.shape(rec)) lcurr = NULL;
+    }
+  }
+}
 
-template <ewop_t op, typename LDType, typename RDType>
-static void ew_comp_prime(LIST* dest, uint8_t d_default, const LIST* left, LDType l_default, const LIST* right, RDType r_default, const size_t* shape, size_t last_level, size_t level);
 
 } // end of namespace list_storage
 
@@ -98,9 +267,7 @@ extern "C" {
  * new storage. You don't need to free them, and you shouldn't re-use them.
  */
 LIST_STORAGE* nm_list_storage_create(dtype_t dtype, size_t* shape, size_t dim, void* init_val) {
-  LIST_STORAGE* s;
-
-  s = ALLOC( LIST_STORAGE );
+  LIST_STORAGE* s = ALLOC( LIST_STORAGE );
 
   s->dim   = dim;
   s->shape = shape;
@@ -182,56 +349,199 @@ NODE* list_storage_get_single_node(LIST_STORAGE* s, SLICE* slice)
   return n;
 }
 
+
 /*
- * Each stored iterator, brings along the indices
+ * Recursive helper function for each_with_indices, based on nm_list_storage_count_elements_r.
+ * Handles empty/non-existent sublists.
  */
-VALUE nm_list_each_stored_with_indices(VALUE nmatrix) {
+static void each_empty_with_indices_r(nm::list_storage::RecurseData& s, size_t rec, VALUE& stack) {
+  VALUE empty  = s.dtype() == nm::RUBYOBJ ? *reinterpret_cast<VALUE*>(s.init()) : s.init_obj();
+
+  if (rec) {
+    for (long index = 0; index < s.shape(rec); ++index) {
+      // Don't do an unshift/shift here -- we'll let that be handled in the lowest-level iteration (recursions == 0)
+      rb_ary_push(stack, LONG2NUM(index));
+      each_empty_with_indices_r(s, rec-1, stack);
+      rb_ary_pop(stack);
+    }
+  } else {
+    rb_ary_unshift(stack, empty);
+    for (long index = 0; index < s.shape(rec); ++index) {
+      rb_ary_push(stack, LONG2NUM(index));
+      rb_yield_splat(stack);
+      rb_ary_pop(stack);
+    }
+    rb_ary_shift(stack);
+  }
+}
 
-  // If we don't have a block, return an enumerator.
-  RETURN_SIZED_ENUMERATOR(nmatrix, 0, 0, 0);
+/*
+ * Recursive helper function for each_with_indices, based on nm_list_storage_count_elements_r.
+ */
+static void each_with_indices_r(nm::list_storage::RecurseData& s, const LIST* l, size_t rec, VALUE& stack) {
+  NODE*  curr  = l->first;
 
-  LIST_STORAGE* s = NM_STORAGE_LIST(nmatrix);
-  // Create indices and initialize to zero
-  size_t* coords = ALLOCA_N(size_t, s->dim);
-  memset(coords, 0, sizeof(size_t) * s->dim);
+  size_t offset = s.offset(rec);
+  size_t shape  = s.shape(rec);
 
-  // Set up the LIST and NODE
-  LIST* l = s->rows;
-  NODE* curr = l->first;
+  while (curr && curr->key < offset) curr = curr->next;
+  if (curr && curr->key >= shape) curr = NULL;
 
-  // Levels...
-  while (curr) { // LOOPS through the rows
-    NODE* subnode = reinterpret_cast<LIST*>(curr->val)->first;
-    size_t row = curr->key;
-    // Iterate along each row, yielding the val, row, col for each non-default entry
-    while (subnode) {
-      VALUE ary = rb_ary_new();
-      size_t col = subnode->key;
-
-      // Conditional type handling
-      if (NM_DTYPE(nmatrix) == nm::RUBYOBJ) {
-        rb_ary_push(ary, *reinterpret_cast<VALUE*>(subnode->val));
+
+  if (rec) {
+    for (long index = 0; index < shape; ++index) {
+      rb_ary_push(stack, LONG2NUM(index));
+      if (!curr || index < curr->key - offset) {
+        each_empty_with_indices_r(s, rec-1, stack);
       } else {
-        rb_ary_push(ary, rubyobj_from_cval((char*)(subnode->val ) , NM_DTYPE(nmatrix)).rval);
+        each_with_indices_r(s, reinterpret_cast<const LIST*>(curr->val), rec-1, stack);
+        curr = curr->next;
       }
+      rb_ary_pop(stack);
+    }
+  } else {
+    for (long index = 0; index < shape; ++index) {
 
-      // Push the coordinate values into the ary
-      rb_ary_push(ary, INT2FIX(row));
-      rb_ary_push(ary, INT2FIX(col));
+      rb_ary_push(stack, LONG2NUM(index));
 
-      // Yield the ary
-      rb_yield(ary);
+      if (!curr || index < curr->key - offset) {
+        rb_ary_unshift(stack, s.dtype() == nm::RUBYOBJ ? *reinterpret_cast<VALUE*>(s.init()) : s.init_obj());
 
-      // Update the col position
-      subnode = subnode->next;
+      } else { // index == curr->key
+        rb_ary_unshift(stack, s.dtype() == nm::RUBYOBJ ? *reinterpret_cast<VALUE*>(curr->val) : rubyobj_from_cval(curr->val, s.dtype()).rval);
+
+        curr = curr->next;
+      }
+      rb_yield_splat(stack);
+
+      rb_ary_shift(stack);
+      rb_ary_pop(stack);
     }
-    // Update the row node
-    curr = curr->next;
   }
+
+}
+
+
+/*
+ * Recursive helper function for each_stored_with_indices, based on nm_list_storage_count_elements_r.
+ */
+static void each_stored_with_indices_r(nm::list_storage::RecurseData& s, const LIST* l, size_t rec, VALUE& stack) {
+  NODE* curr = l->first;
+
+  size_t offset = s.offset(rec);
+  size_t shape  = s.shape(rec);
+
+  while (curr && curr->key < offset) { curr = curr->next; }
+  if (curr && curr->key - offset >= shape) curr = NULL;
+
+  if (rec) {
+    while (curr) {
+
+      rb_ary_push(stack, LONG2NUM(static_cast<long>(curr->key - offset)));
+      each_stored_with_indices_r(s, reinterpret_cast<const LIST*>(curr->val), rec-1, stack);
+      rb_ary_pop(stack);
+
+      curr = curr->next;
+      if (curr && curr->key - offset >= shape) curr = NULL;
+    }
+  } else {
+    while (curr) {
+      rb_ary_push(stack, LONG2NUM(static_cast<long>(curr->key - offset))); // add index to end
+
+      // add value to beginning
+      rb_ary_unshift(stack, s.dtype() == nm::RUBYOBJ ? *reinterpret_cast<VALUE*>(curr->val) : rubyobj_from_cval(curr->val, s.dtype()).rval);
+      // yield to the whole stack (value, i, j, k, ...)
+      rb_yield_splat(stack);
+
+      // remove the value
+      rb_ary_shift(stack);
+
+      // remove the index from the end
+      rb_ary_pop(stack);
+
+      curr = curr->next;
+      if (curr && curr->key >= shape) curr = NULL;
+    }
+  }
+}
+
+
+
+/*
+ * Each/each-stored iterator, brings along the indices.
+ */
+VALUE nm_list_each_with_indices(VALUE nmatrix, bool stored) {
+
+  // If we don't have a block, return an enumerator.
+  RETURN_SIZED_ENUMERATOR(nmatrix, 0, 0, 0);
+
+  nm::list_storage::RecurseData sdata(NM_STORAGE_LIST(nmatrix));
+
+  VALUE stack = rb_ary_new();
+
+  if (stored) each_stored_with_indices_r(sdata, sdata.top_level_list(), sdata.dim() - 1, stack);
+  else        each_with_indices_r(sdata, sdata.top_level_list(), sdata.dim() - 1, stack);
+
   return nmatrix;
 }
 
 
+/*
+ * map merged stored iterator. Always returns a matrix containing RubyObjects which probably needs to be casted.
+ */
+VALUE nm_list_map_merged_stored(VALUE left, VALUE right, VALUE init) {
+
+  bool scalar = false;
+
+  LIST_STORAGE *s   = NM_STORAGE_LIST(left),
+               *t;
+
+  // For each matrix, if it's a reference, we want to deal directly with the original (with appropriate offsetting)
+  nm::list_storage::RecurseData sdata(s);
+
+  void* scalar_init = NULL;
+  size_t* shape;
+
+  // right might be a scalar, in which case this is a scalar operation.
+  if (TYPE(right) != T_DATA || (RDATA(right)->dfree != (RUBY_DATA_FUNC)nm_delete && RDATA(right)->dfree != (RUBY_DATA_FUNC)nm_delete_ref)) {
+    nm::dtype_t r_dtype = nm_dtype_min(right);
+
+    scalar_init         = rubyobj_to_cval(right, r_dtype); // make a copy of right
+
+    t                   = reinterpret_cast<LIST_STORAGE*>(nm_list_storage_create(r_dtype, sdata.copy_alloc_shape(), s->dim, scalar_init));
+    scalar              = true;
+  } else {
+    t                   = NM_STORAGE_LIST(right); // element-wise, not scalar.
+  }
+
+  //if (!rb_block_given_p()) {
+  //  rb_raise(rb_eNotImpError, "RETURN_SIZED_ENUMERATOR probably won't work for a map_merged since no merged object is created");
+  //}
+  // If we don't have a block, return an enumerator.
+  RETURN_SIZED_ENUMERATOR(left, 0, 0, 0); // FIXME: Test this. Probably won't work. Enable above code instead.
+
+  // Figure out default value if none provided by the user
+  nm::list_storage::RecurseData tdata(t);
+  if (init == Qnil) init = rb_yield_values(2, sdata.init_obj(), tdata.init_obj());
+
+	// Allocate a new shape array for the resulting matrix.
+  void* init_val = ALLOC(VALUE);
+  memcpy(init_val, &init, sizeof(VALUE));
+
+  NMATRIX* result = nm_create(nm::LIST_STORE, nm_list_storage_create(nm::RUBYOBJ, sdata.copy_alloc_shape(), s->dim, init_val));
+  LIST_STORAGE* r = reinterpret_cast<LIST_STORAGE*>(result->storage);
+  nm::list_storage::RecurseData rdata(r, init);
+
+  map_merged_stored_r(rdata, sdata, tdata, rdata.top_level_list(), sdata.top_level_list(), tdata.top_level_list(), sdata.dim() - 1);
+
+  // If we are working with a scalar operation
+  if (scalar) nm_list_storage_delete(t);
+
+  return Data_Wrap_Struct(CLASS_OF(left), nm_list_storage_mark, nm_delete, result);
+}
+
+
+
 static LIST* slice_copy(const LIST_STORAGE *src, LIST *src_rows, size_t *coords, size_t *lengths, size_t n) {
   NODE *src_node;
   LIST *dst_rows = NULL;
@@ -377,87 +687,18 @@ void* nm_list_storage_remove(STORAGE* storage, SLICE* slice) {
  * Comparison of contents for list storage.
  */
 bool nm_list_storage_eqeq(const STORAGE* left, const STORAGE* right) {
-	NAMED_LR_DTYPE_TEMPLATE_TABLE(ttable, nm::list_storage::eqeq, bool, const LIST_STORAGE* left, const LIST_STORAGE* right);
+	NAMED_LR_DTYPE_TEMPLATE_TABLE(ttable, nm::list_storage::eqeq_r, bool, nm::list_storage::RecurseData& left, nm::list_storage::RecurseData& right, const LIST* l, const LIST* r, size_t rec)
+
+  nm::list_storage::RecurseData ldata(reinterpret_cast<const LIST_STORAGE*>(left)),
+                                rdata(reinterpret_cast<const LIST_STORAGE*>(right));
 
-	return ttable[left->dtype][right->dtype]((const LIST_STORAGE*)left, (const LIST_STORAGE*)right);
+	return ttable[left->dtype][right->dtype](ldata, rdata, ldata.top_level_list(), rdata.top_level_list(), ldata.dim()-1);
 }
 
 //////////
 // Math //
 //////////
 
-/*
- * Element-wise operations for list storage.
- *
- * If a scalar is given, a temporary matrix is created with that scalar as a default value.
- */
-STORAGE* nm_list_storage_ew_op(nm::ewop_t op, const STORAGE* left, const STORAGE* right, VALUE scalar) {
-  // rb_raise(rb_eNotImpError, "elementwise operations for list storage currently broken");
-
-  bool cleanup = false;
-  LIST_STORAGE *r, *new_l;
-  const LIST_STORAGE* l = reinterpret_cast<const LIST_STORAGE*>(left);
-
-  if (!right) { // need to build a right-hand matrix temporarily, with default value of 'scalar'
-
-    dtype_t scalar_dtype  = nm_dtype_guess(scalar);
-    void* scalar_init     = rubyobj_to_cval(scalar, scalar_dtype);
-
-    size_t* shape         = ALLOC_N(size_t, l->dim);
-    memcpy(shape, left->shape, sizeof(size_t) * l->dim);
-
-    r = nm_list_storage_create(scalar_dtype, shape, l->dim, scalar_init);
-
-    cleanup = true;
-
-  } else {
-
-    r = reinterpret_cast<LIST_STORAGE*>(const_cast<STORAGE*>(right));
-
-  }
-
-  // We may need to upcast our arguments to the same type.
-  dtype_t new_dtype = Upcast[left->dtype][r->dtype];
-
-	// Make sure we allocate a byte-storing matrix for comparison operations; otherwise, use the argument dtype (new_dtype)
-	dtype_t result_dtype = static_cast<uint8_t>(op) < NUM_NONCOMP_EWOPS ? new_dtype : BYTE;
-
-	OP_LR_DTYPE_TEMPLATE_TABLE(nm::list_storage::ew_op, void*, LIST* dest, const LIST* left, const void* l_default, const LIST* right, const void* r_default, const size_t* shape, size_t dim);
-	
-	// Allocate a new shape array for the resulting matrix.
-	size_t* new_shape = ALLOC_N(size_t, l->dim);
-	memcpy(new_shape, left->shape, sizeof(size_t) * l->dim);
-	
-	// Create the result matrix.
-	LIST_STORAGE* result = nm_list_storage_create(result_dtype, new_shape, left->dim, NULL);
-	
-	/*
-	 * Call the templated elementwise multiplication function and set the default
-	 * value for the resulting matrix.
-	 */
-	if (new_dtype != left->dtype) {
-		// Upcast the left-hand side if necessary.
-		new_l = reinterpret_cast<LIST_STORAGE*>(nm_list_storage_cast_copy(l, new_dtype));
-		
-		result->default_val =
-			ttable[op][new_l->dtype][r->dtype](result->rows, new_l->rows, new_l->default_val, r->rows, r->default_val, result->shape, result->dim);
-		
-		// Delete the temporary left-hand side matrix.
-		nm_list_storage_delete(reinterpret_cast<STORAGE*>(new_l));
-
-	} else {
-		result->default_val =
-			ttable[op][left->dtype][r->dtype](result->rows, l->rows, l->default_val, r->rows, r->default_val, result->shape, result->dim);
-	}
-
-  // If we created a temporary scalar matrix (for matrix-scalar operations), we now need to delete it.
-	if (cleanup) {
-	  nm_list_storage_delete(reinterpret_cast<STORAGE*>(r));
-	}
-	
-	return result;
-}
-
 
 /*
  * List storage matrix multiplication.
@@ -564,7 +805,7 @@ LIST_STORAGE* nm_list_storage_copy(const LIST_STORAGE* rhs)
 /*
  * List storage copy constructor C access with casting.
  */
-STORAGE* nm_list_storage_cast_copy(const STORAGE* rhs, dtype_t new_dtype) {
+STORAGE* nm_list_storage_cast_copy(const STORAGE* rhs, dtype_t new_dtype, void* dummy) {
   NAMED_LR_DTYPE_TEMPLATE_TABLE(ttable, nm::list_storage::cast_copy, LIST_STORAGE*, const LIST_STORAGE* rhs, dtype_t new_dtype);
 
   return (STORAGE*)ttable[new_dtype][rhs->dtype]((LIST_STORAGE*)rhs, new_dtype);
@@ -587,8 +828,11 @@ STORAGE* nm_list_storage_copy_transposed(const STORAGE* rhs_base) {
 // Templated Functions //
 /////////////////////////
 
+
+
 namespace list_storage {
 
+
 /*
  * List storage copy constructor for changing dtypes.
  */
@@ -604,7 +848,7 @@ static LIST_STORAGE* cast_copy(const LIST_STORAGE* rhs, dtype_t new_dtype) {
   *default_val = *reinterpret_cast<RDType*>(rhs->default_val);
 
   LIST_STORAGE* lhs = nm_list_storage_create(new_dtype, shape, rhs->dim, default_val);
-  lhs->rows         = list::create();
+  //lhs->rows         = list::create();
 
   // TODO: Needs optimization. When matrix is reference it is copped twice.
   if (rhs->src == rhs) 
@@ -620,539 +864,126 @@ static LIST_STORAGE* cast_copy(const LIST_STORAGE* rhs, dtype_t new_dtype) {
 
 
 /*
- * Do these two dense matrices of the same dtype have exactly the same
- * contents?
+ * Recursive helper function for eqeq. Note that we use SDType and TDType instead of L and R because this function
+ * is a re-labeling. That is, it can be called in order L,R or order R,L; and we don't want to get confused. So we
+ * use S and T to denote first and second passed in.
  */
-template <typename LDType, typename RDType>
-bool eqeq(const LIST_STORAGE* left, const LIST_STORAGE* right) {
-  bool result;
-
-  // in certain cases, we need to keep track of the number of elements checked.
-  size_t num_checked  = 0,
-	max_elements = nm_storage_count_max_elements(left);
-  LIST_STORAGE *tmp1 = NULL, *tmp2 = NULL;
-
-  if (!left->rows->first) {
-    // Easy: both lists empty -- just compare default values
-    if (!right->rows->first) {
-    	return *reinterpret_cast<LDType*>(left->default_val) == *reinterpret_cast<RDType*>(right->default_val);
-    	
-    } else if (!list::eqeq_value<RDType,LDType>(right->rows, reinterpret_cast<LDType*>(left->default_val), left->dim-1, num_checked)) {
-    	// Left empty, right not empty. Do all values in right == left->default_val?
-    	return false;
-    	
-    } else if (num_checked < max_elements) {
-    	// If the matrix isn't full, we also need to compare default values.
-    	return *reinterpret_cast<LDType*>(left->default_val) == *reinterpret_cast<RDType*>(right->default_val);
-    }
+template <typename SDType, typename TDType>
+static bool eqeq_empty_r(RecurseData& s, const LIST* l, size_t rec, const TDType* t_init) {
+  NODE* curr  = l->first;
 
-  } else if (!right->rows->first) {
-    // fprintf(stderr, "!right->rows true\n");
-    // Right empty, left not empty. Do all values in left == right->default_val?
-    if (!list::eqeq_value<LDType,RDType>(left->rows, reinterpret_cast<RDType*>(right->default_val), left->dim-1, num_checked)) {
-    	return false;
-    	
-    } else if (num_checked < max_elements) {
-   		// If the matrix isn't full, we also need to compare default values.
-    	return *reinterpret_cast<LDType*>(left->default_val) == *reinterpret_cast<RDType*>(right->default_val);
-    }
+  // For reference matrices, make sure we start in the correct place.
+  while (curr && curr->key < s.offset(rec)) {  curr = curr->next;  }
+  if (curr && curr->key - s.offset(rec) >= s.shape(rec)) curr = NULL;
 
-  } else {
-    // fprintf(stderr, "both matrices have entries\n");
-    // Hardest case. Compare lists node by node. Let's make it simpler by requiring that both have the same default value
-    
-    // left is reference
-    if (left->src != left && right->src == right) {
-      tmp1 = nm_list_storage_copy(left);
-      result = list::eqeq<LDType,RDType>(tmp1->rows, right->rows, reinterpret_cast<LDType*>(left->default_val), reinterpret_cast<RDType*>(right->default_val), left->dim-1, num_checked);
-      nm_list_storage_delete(tmp1);
-    } 
-    // right is reference
-    if (left->src == left && right->src != right) {
-      tmp2 = nm_list_storage_copy(right);
-      result = list::eqeq<LDType,RDType>(left->rows, tmp2->rows, reinterpret_cast<LDType*>(left->default_val), reinterpret_cast<RDType*>(right->default_val), left->dim-1, num_checked);
-      nm_list_storage_delete(tmp2);
-    } 
-    // both are references
-    if (left->src != left && right->src != right) {
-      tmp1 = nm_list_storage_copy(left);
-      tmp2 = nm_list_storage_copy(right);
-      result = list::eqeq<LDType,RDType>(tmp1->rows, tmp2->rows, reinterpret_cast<LDType*>(left->default_val), reinterpret_cast<RDType*>(right->default_val), left->dim-1, num_checked);
-      nm_list_storage_delete(tmp1);
-      nm_list_storage_delete(tmp2);
+  if (rec) {
+    while (curr) {
+      if (!eqeq_empty_r<SDType,TDType>(s, reinterpret_cast<const LIST*>(curr->val), rec-1, t_init)) return false;
+      curr = curr->next;
+
+      if (curr && curr->key - s.offset(rec) >= s.shape(rec)) curr = NULL;
     }
-    // both are normal matricies
-    if (left->src == left && right->src == right) 
-      result = list::eqeq<LDType,RDType>(left->rows, right->rows, reinterpret_cast<LDType*>(left->default_val), reinterpret_cast<RDType*>(right->default_val), left->dim-1, num_checked);
-
-    if (!result){
-      return result;
-    } else if (num_checked < max_elements) {
-      return *reinterpret_cast<LDType*>(left->default_val) == *reinterpret_cast<RDType*>(right->default_val);
+  } else {
+    while (curr) {
+      if (*reinterpret_cast<SDType*>(curr->val) != *t_init) return false;
+      curr = curr->next;
+
+      if (curr && curr->key - s.offset(rec) >= s.shape(rec)) curr = NULL;
     }
   }
-
   return true;
 }
 
-/*
- * List storage element-wise operations (including comparisons).
- */
-template <ewop_t op, typename LDType, typename RDType>
-static void* ew_op(LIST* dest, const LIST* left, const void* l_default, const LIST* right, const void* r_default, const size_t* shape, size_t dim) {
-
-	if (static_cast<uint8_t>(op) < NUM_NONCOMP_EWOPS) {
-
-    /*
-     * Allocate space for, and calculate, the default value for the destination
-     * matrix.
-     */
-    LDType* d_default_mem = ALLOC(LDType);
-    *d_default_mem = ew_op_switch<op, LDType, RDType>(*reinterpret_cast<const LDType*>(l_default), *reinterpret_cast<const RDType*>(r_default));
-
-    // Now that setup is done call the actual elementwise operation function.
-    ew_op_prime<op, LDType, RDType>(dest, *reinterpret_cast<const LDType*>(d_default_mem),
-                                    left, *reinterpret_cast<const LDType*>(l_default),
-                                    right, *reinterpret_cast<const RDType*>(r_default),
-                                    shape, dim - 1, 0);
-
-    // Return a pointer to the destination matrix's default value.
-    return d_default_mem;
-
-	} else { // Handle comparison operations in a similar manner.
-    /*
-     * Allocate a byte for default, and set default value to 0.
-     */
-    uint8_t* d_default_mem = ALLOC(uint8_t);
-    *d_default_mem = 0;
-    switch (op) {
-      case EW_EQEQ:
-        *d_default_mem = *reinterpret_cast<const LDType*>(l_default) == *reinterpret_cast<const RDType*>(r_default);
-        break;
-
-      case EW_NEQ:
-        *d_default_mem = *reinterpret_cast<const LDType*>(l_default) != *reinterpret_cast<const RDType*>(r_default);
-        break;
-
-      case EW_LT:
-        *d_default_mem = *reinterpret_cast<const LDType*>(l_default) < *reinterpret_cast<const RDType*>(r_default);
-        break;
-
-      case EW_GT:
-        *d_default_mem = *reinterpret_cast<const LDType*>(l_default) > *reinterpret_cast<const RDType*>(r_default);
-        break;
-
-      case EW_LEQ:
-        *d_default_mem = *reinterpret_cast<const LDType*>(l_default) <= *reinterpret_cast<const RDType*>(r_default);
-        break;
-
-      case EW_GEQ:
-        *d_default_mem = *reinterpret_cast<const LDType*>(l_default) >= *reinterpret_cast<const RDType*>(r_default);
-        break;
-
-      default:
-        rb_raise(rb_eStandardError, "this should not happen");
-    }
-
-    // Now that setup is done call the actual elementwise comparison function.
-    ew_comp_prime<op, LDType, RDType>(dest, *reinterpret_cast<const uint8_t*>(d_default_mem),
-                                      left, *reinterpret_cast<const LDType*>(l_default),
-                                      right, *reinterpret_cast<const RDType*>(r_default),
-                                      shape, dim - 1, 0);
-
-    // Return a pointer to the destination matrix's default value.
-    return d_default_mem;
-	}
-}
 
 
 /*
- * List storage element-wise comparisons, recursive helper.
+ * Do these two list matrices of the same dtype have exactly the same contents (accounting for default_vals)?
+ *
+ * This function is recursive.
  */
-template <ewop_t op, typename LDType, typename RDType>
-static void ew_comp_prime(LIST* dest, uint8_t d_default, const LIST* left, LDType l_default, const LIST* right, RDType r_default, const size_t* shape, size_t last_level, size_t level) {
-
-	static LIST EMPTY_LIST = {NULL};
-
-	size_t index;
-
-	uint8_t tmp_result;
-
-	LIST* new_level = NULL;
-
-	NODE* l_node		= left->first,
-			* r_node		= right->first,
-			* dest_node	= NULL;
-
-	for (index = 0; index < shape[level]; ++index) {
-		if (l_node == NULL and r_node == NULL) {
-			/*
-			 * Both source lists are now empty.  Because the default value of the
-			 * destination is already set appropriately we can now return.
-			 */
-
-			return;
-
-		} else {
-			// At least one list still has entries.
-
-			if (l_node == NULL and r_node->key == index) {
-				/*
-				 * One source list is empty, but the index has caught up to the key of
-				 * the other list.
-				 */
-
-				if (level == last_level) {
-					switch (op) {
-						case EW_EQEQ:
-							tmp_result = (uint8_t)(l_default == *reinterpret_cast<RDType*>(r_node->val));
-							break;
-
-						case EW_NEQ:
-							tmp_result = (uint8_t)(l_default != *reinterpret_cast<RDType*>(r_node->val));
-							break;
-
-						case EW_LT:
-							tmp_result = (uint8_t)(l_default < *reinterpret_cast<RDType*>(r_node->val));
-							break;
-
-						case EW_GT:
-							tmp_result = (uint8_t)(l_default > *reinterpret_cast<RDType*>(r_node->val));
-							break;
-
-						case EW_LEQ:
-							tmp_result = (uint8_t)(l_default <= *reinterpret_cast<RDType*>(r_node->val));
-							break;
-
-						case EW_GEQ:
-							tmp_result = (uint8_t)(l_default >= *reinterpret_cast<RDType*>(r_node->val));
-							break;
-
-            default:
-              rb_raise(rb_eStandardError, "This should not happen.");
-					}
-
-					if (tmp_result != d_default) {
-						dest_node = nm::list::insert_helper(dest, dest_node, index, tmp_result);
-					}
-
-				} else {
-					new_level = nm::list::create();
-					dest_node = nm::list::insert_helper(dest, dest_node, index, new_level);
-
-					ew_comp_prime<op, LDType, RDType>(new_level, d_default, &EMPTY_LIST, l_default,
-                                            reinterpret_cast<LIST*>(r_node->val), r_default,
-                                            shape, last_level, level + 1);
-				}
-
-				r_node = r_node->next;
-
-			} else if (r_node == NULL and l_node->key == index) {
-				/*
-				 * One source list is empty, but the index has caught up to the key of
-				 * the other list.
-				 */
-
-				if (level == last_level) {
-					switch (op) {
-						case EW_EQEQ:
-							tmp_result = (uint8_t)(*reinterpret_cast<LDType*>(l_node->val) == r_default);
-							break;
-
-						case EW_NEQ:
-							tmp_result = (uint8_t)(*reinterpret_cast<LDType*>(l_node->val) != r_default);
-							break;
-
-						case EW_LT:
-							tmp_result = (uint8_t)(*reinterpret_cast<LDType*>(l_node->val) < r_default);
-							break;
-
-						case EW_GT:
-							tmp_result = (uint8_t)(*reinterpret_cast<LDType*>(l_node->val) > r_default);
-							break;
+template <typename LDType, typename RDType>
+static bool eqeq_r(RecurseData& left, RecurseData& right, const LIST* l, const LIST* r, size_t rec) {
+  NODE *lcurr = l->first,
+       *rcurr = r->first;
+
+  // For reference matrices, make sure we start in the correct place.
+  while (lcurr && lcurr->key < left.offset(rec)) {  lcurr = lcurr->next;  }
+  while (rcurr && rcurr->key < right.offset(rec)) {  rcurr = rcurr->next;  }
+  if (rcurr && rcurr->key - right.offset(rec) >= left.shape(rec)) rcurr = NULL;
+  if (lcurr && lcurr->key - left.offset(rec) >= left.shape(rec)) lcurr = NULL;
+
+  bool compared = false;
+
+  if (rec) {
+
+    while (lcurr || rcurr) {
+
+      if (!rcurr || (lcurr && (lcurr->key - left.offset(rec) < rcurr->key - right.offset(rec)))) {
+        if (!eqeq_empty_r<LDType,RDType>(left, reinterpret_cast<const LIST*>(lcurr->val), rec-1, reinterpret_cast<const RDType*>(right.init()))) return false;
+        lcurr   = lcurr->next;
+      } else if (!lcurr || (rcurr && (rcurr->key - right.offset(rec) < lcurr->key - left.offset(rec)))) {
+        if (!eqeq_empty_r<RDType,LDType>(right, reinterpret_cast<const LIST*>(rcurr->val), rec-1, reinterpret_cast<const LDType*>(left.init()))) return false;
+        rcurr   = rcurr->next;
+      } else { // keys are == and both present
+        if (!eqeq_r<LDType,RDType>(left, right, reinterpret_cast<const LIST*>(lcurr->val), reinterpret_cast<const LIST*>(rcurr->val), rec-1)) return false;
+        lcurr   = lcurr->next;
+        rcurr   = rcurr->next;
+      }
+      if (rcurr && rcurr->key - right.offset(rec) >= left.shape(rec)) rcurr = NULL;
+      if (lcurr && lcurr->key - left.offset(rec) >= left.shape(rec)) lcurr = NULL;
+      compared = true;
+    }
+  } else {
+    while (lcurr || rcurr) {
+
+      if (rcurr && rcurr->key - right.offset(rec) >= left.shape(rec)) rcurr = NULL;
+      if (lcurr && lcurr->key - left.offset(rec) >= left.shape(rec)) lcurr = NULL;
+
+      if (!rcurr || (lcurr && (lcurr->key - left.offset(rec) < rcurr->key - right.offset(rec)))) {
+        if (*reinterpret_cast<LDType*>(lcurr->val) != *reinterpret_cast<const RDType*>(right.init())) return false;
+        lcurr         = lcurr->next;
+      } else if (!lcurr || (rcurr && (rcurr->key - right.offset(rec) < lcurr->key - left.offset(rec)))) {
+        if (*reinterpret_cast<RDType*>(rcurr->val) != *reinterpret_cast<const LDType*>(left.init())) return false;
+        rcurr         = rcurr->next;
+      } else { // keys == and both left and right nodes present
+        if (*reinterpret_cast<LDType*>(lcurr->val) != *reinterpret_cast<RDType*>(rcurr->val)) return false;
+        lcurr         = lcurr->next;
+        rcurr         = rcurr->next;
+      }
+      if (rcurr && rcurr->key - right.offset(rec) >= left.shape(rec)) rcurr = NULL;
+      if (lcurr && lcurr->key - left.offset(rec) >= left.shape(rec)) lcurr = NULL;
+      compared = true;
+    }
+  }
 
-						case EW_LEQ:
-							tmp_result = (uint8_t)(*reinterpret_cast<LDType*>(l_node->val) <= r_default);
-							break;
-
-						case EW_GEQ:
-							tmp_result = (uint8_t)(*reinterpret_cast<LDType*>(l_node->val) >= r_default);
-							break;
-
-            default:
-              rb_raise(rb_eStandardError, "this should not happen");
-					}
-
-					if (tmp_result != d_default) {
-						dest_node = nm::list::insert_helper(dest, dest_node, index, tmp_result);
-					}
-
-				} else {
-					new_level = nm::list::create();
-					dest_node = nm::list::insert_helper(dest, dest_node, index, new_level);
-
-					ew_comp_prime<op, LDType, RDType>(new_level, d_default,
-                                            reinterpret_cast<LIST*>(l_node->val), l_default,
-                                            &EMPTY_LIST, r_default,
-                                            shape, last_level, level + 1);
-				}
-
-				l_node = l_node->next;
-
-			} else if (l_node != NULL and r_node != NULL and index == std::min(l_node->key, r_node->key)) {
-				/*
-				 * Neither list is empty and our index has caught up to one of the
-				 * source lists.
-				 */
-
-				if (l_node->key == r_node->key) {
-
-					if (level == last_level) {
-						switch (op) {
-							case EW_EQEQ:
-								tmp_result = (uint8_t)(*reinterpret_cast<LDType*>(l_node->val) == *reinterpret_cast<RDType*>(r_node->val));
-								break;
-
-							case EW_NEQ:
-								tmp_result = (uint8_t)(*reinterpret_cast<LDType*>(l_node->val) != *reinterpret_cast<RDType*>(r_node->val));
-								break;
-
-							case EW_LT:
-								tmp_result = (uint8_t)(*reinterpret_cast<LDType*>(l_node->val) < *reinterpret_cast<RDType*>(r_node->val));
-								break;
-
-							case EW_GT:
-								tmp_result = (uint8_t)(*reinterpret_cast<LDType*>(l_node->val) > *reinterpret_cast<RDType*>(r_node->val));
-								break;
-
-							case EW_LEQ:
-								tmp_result = (uint8_t)(*reinterpret_cast<LDType*>(l_node->val) <= *reinterpret_cast<RDType*>(r_node->val));
-								break;
-
-							case EW_GEQ:
-								tmp_result = (uint8_t)(*reinterpret_cast<LDType*>(l_node->val) >= *reinterpret_cast<RDType*>(r_node->val));
-								break;
-
-              default:
-                rb_raise(rb_eStandardError, "this should not happen");
-						}
-
-						if (tmp_result != d_default) {
-							dest_node = nm::list::insert_helper(dest, dest_node, index, tmp_result);
-						}
-
-					} else {
-						new_level = nm::list::create();
-						dest_node = nm::list::insert_helper(dest, dest_node, index, new_level);
-
-						ew_comp_prime<op, LDType, RDType>(new_level, d_default,
-							reinterpret_cast<LIST*>(l_node->val), l_default,
-							reinterpret_cast<LIST*>(r_node->val), r_default,
-							shape, last_level, level + 1);
-					}
-
-					l_node = l_node->next;
-					r_node = r_node->next;
-
-				} else if (l_node->key < r_node->key) {
-					// Advance the left node knowing that the default value is OK.
-
-					l_node = l_node->next;
-
-				} else /* if (l_node->key > r_node->key) */ {
-					// Advance the right node knowing that the default value is OK.
-
-					r_node = r_node->next;
-				}
-
-			} else {
-				/*
-				 * Our index needs to catch up but the default value is OK.  This
-				 * conditional is here only for documentation and should be optimized
-				 * out.
-				 */
-			}
-		}
-	}
+  // Final condition: both containers are empty, and have different default values.
+  if (!compared && !lcurr && !rcurr) return *reinterpret_cast<const LDType*>(left.init()) == *reinterpret_cast<const RDType*>(right.init());
+  return true;
 }
 
 
-
-/*
- * List storage element-wise operations, recursive helper.
- */
-template <ewop_t op, typename LDType, typename RDType>
-static void ew_op_prime(LIST* dest, LDType d_default, const LIST* left, LDType l_default, const LIST* right, RDType r_default, const size_t* shape, size_t last_level, size_t level) {
-	
-	static LIST EMPTY_LIST = {NULL};
-	
-	size_t index;
-	
-	LDType tmp_result;
-	
-	LIST* new_level = NULL;
-	
-	NODE* l_node		= left->first,
-			* r_node		= right->first,
-			* dest_node	= NULL;
-	
-	for (index = 0; index < shape[level]; ++index) {
-		if (l_node == NULL and r_node == NULL) {
-			/*
-			 * Both source lists are now empty.  Because the default value of the
-			 * destination is already set appropriately we can now return.
-			 */
-			
-			return;
-			
-		} else {
-			// At least one list still has entries.
-			
-			if (op == EW_MUL) {
-				// Special cases for multiplication.
-				
-				if (l_node == NULL and (l_default == 0 and d_default == 0)) {
-					/* 
-					 * The left hand list has run out of elements.  We don't need to add new
-					 * values to the destination if l_default and d_default are both 0.
-					 */
-				
-					return;
-			
-				} else if (r_node == NULL and (r_default == 0 and d_default == 0)) {
-					/*
-					 * The right hand list has run out of elements.  We don't need to add new
-					 * values to the destination if r_default and d_default are both 0.
-					 */
-				
-					return;
-				}
-				
-			} else if (op == EW_DIV) {
-				// Special cases for division.
-				
-				if (l_node == NULL and (l_default == 0 and d_default == 0)) {
-					/* 
-					 * The left hand list has run out of elements.  We don't need to add new
-					 * values to the destination if l_default and d_default are both 0.
-					 */
-				
-					return;
-			
-				} else if (r_node == NULL and (r_default == 0 and d_default == 0)) {
-					/*
-					 * The right hand list has run out of elements.  If the r_default
-					 * value is 0 any further division will result in a SIGFPE.
-					 */
-				
-					rb_raise(rb_eZeroDivError, "Cannot divide type by 0, would throw SIGFPE.");
-				}
-				
-				// TODO: Add optimizations for addition and subtraction.
-				
-			}
-			
-			// We need to continue processing the lists.
-			
-			if (l_node == NULL and r_node->key == index) {
-				/*
-				 * One source list is empty, but the index has caught up to the key of
-				 * the other list.
-				 */
-				
-				if (level == last_level) {
-				  tmp_result = ew_op_switch<op, LDType, RDType>(l_default, *reinterpret_cast<RDType*>(r_node->val));
-				  std::cerr << "1. tmp_result = " << tmp_result << std::endl;
-					
-					if (tmp_result != d_default) {
-						dest_node = nm::list::insert_helper(dest, dest_node, index, tmp_result);
-					}
-					
-				} else {
-					new_level = nm::list::create();
-					dest_node = nm::list::insert_helper(dest, dest_node, index, new_level);
-				
-					ew_op_prime<op, LDType, RDType>(new_level, d_default,	&EMPTY_LIST, l_default,
-						                              reinterpret_cast<LIST*>(r_node->val), r_default,
-						                              shape, last_level, level + 1);
-				}
-				
-				r_node = r_node->next;
-				
-			} else if (r_node == NULL and l_node->key == index) {
-				/*
-				 * One source list is empty, but the index has caught up to the key of
-				 * the other list.
-				 */
-				
-				if (level == last_level) {
-				  tmp_result = ew_op_switch<op, LDType, RDType>(*reinterpret_cast<LDType*>(l_node->val), r_default);
-				  std::cerr << "2. tmp_result = " << tmp_result << std::endl;
-
-					if (tmp_result != d_default) {
-						dest_node = nm::list::insert_helper(dest, dest_node, index, tmp_result);
-					}
-					
-				} else {
-					new_level = nm::list::create();
-					dest_node = nm::list::insert_helper(dest, dest_node, index, new_level);
-				
-					ew_op_prime<op, LDType, RDType>(new_level, d_default,	reinterpret_cast<LIST*>(l_node->val), l_default,
-						                              &EMPTY_LIST, r_default,	shape, last_level, level + 1);
-				}
-				
-				l_node = l_node->next;
-				
-			} else if (l_node != NULL and r_node != NULL and index == std::min(l_node->key, r_node->key)) {
-				/*
-				 * Neither list is empty and our index has caught up to one of the
-				 * source lists.
-				 */
-				
-				if (l_node->key == r_node->key) {
-					
-					if (level == last_level) {
-					  tmp_result = ew_op_switch<op, LDType, RDType>(*reinterpret_cast<LDType*>(l_node->val),*reinterpret_cast<RDType*>(r_node->val));
-					  std::cerr << "3. tmp_result = " << tmp_result << std::endl;
-						
-						if (tmp_result != d_default) {
-							dest_node = nm::list::insert_helper(dest, dest_node, index, tmp_result);
-						}
-						
-					} else {
-						new_level = nm::list::create();
-						dest_node = nm::list::insert_helper(dest, dest_node, index, new_level);
-					
-						ew_op_prime<op, LDType, RDType>(new_level, d_default,
-                                            reinterpret_cast<LIST*>(l_node->val), l_default,
-                                            reinterpret_cast<LIST*>(r_node->val), r_default,
-                                            shape, last_level, level + 1);
-					}
-				
-					l_node = l_node->next;
-					r_node = r_node->next;
-			
-				} else if (l_node->key < r_node->key) {
-					// Advance the left node knowing that the default value is OK.
-			
-					l_node = l_node->next;
-					 
-				} else /* if (l_node->key > r_node->key) */ {
-					// Advance the right node knowing that the default value is OK.
-			
-					r_node = r_node->next;
-				}
-				
-			} else {
-				/*
-				 * Our index needs to catch up but the default value is OK.  This
-				 * conditional is here only for documentation and should be optimized
-				 * out.
-				 */
-			}
-		}
-	}
-}
-
 }} // end of namespace nm::list_storage
 
+extern "C" {
+  /*
+   * call-seq:
+   *     __list_to_hash__ -> Hash
+   *
+   * Create a Ruby Hash from a list NMatrix.
+   *
+   * This is an internal C function which handles list stype only.
+   */
+  VALUE nm_to_hash(VALUE self) {
+    return nm_list_storage_to_hash(NM_STORAGE_LIST(self), NM_DTYPE(self));
+  }
+
+    /*
+     * call-seq:
+     *     __list_default_value__ -> ...
+     *
+     * Get the default_value property from a list matrix.
+     */
+    VALUE nm_list_default_value(VALUE self) {
+      return (NM_DTYPE(self) == nm::RUBYOBJ) ? *reinterpret_cast<VALUE*>(NM_DEFAULT_VAL(self)) : rubyobj_from_cval(NM_DEFAULT_VAL(self), NM_DTYPE(self)).rval;
+    }
+} // end of extern "C" block