nmatrix 0.0.6 → 0.0.7

data/ext/nmatrix/nmatrix.h

@@ -303,8 +303,7 @@ NM_DEF_STRUCT_POST(NMATRIX);  // };
   #define NM_STORAGE_DENSE(val)       ((struct NM_DENSE_STORAGE*)(NM_STORAGE(val)))
 #endif
 
-#define NM_DENSE_SRC(val)       (NM_STORAGE_DENSE(val)->src)
-#define NM_LIST_SRC(val)        (NM_STORAGE_LIST(val)->src)
+#define NM_SRC(val)             (NM_STORAGE(val)->src)
 #define NM_DIM(val)             (NM_STORAGE(val)->dim)
 #define NM_DTYPE(val)           (NM_STORAGE(val)->dtype)
 #define NM_ITYPE(val)           (NM_STORAGE_YALE(val)->itype)

data/ext/nmatrix/ruby_constants.cpp

@@ -9,8 +9,8 @@
 //
 // == Copyright Information
 //
-// SciRuby is Copyright (c) 2010 - 2013, Ruby Science Foundation
-// NMatrix is Copyright (c) 2013, Ruby Science Foundation
+// SciRuby is Copyright (c) 2010 - 2012, Ruby Science Foundation
+// NMatrix is Copyright (c) 2012, Ruby Science Foundation
 //
 // Please see LICENSE.txt for additional copyright notices.
 //
@@ -57,11 +57,12 @@ ID	nm_rb_real,
 
 		nm_rb_row,
 		nm_rb_column,
-
 		nm_rb_add,
 		nm_rb_sub,
 		nm_rb_mul,
 		nm_rb_div,
+    nm_rb_both,
+    nm_rb_none,
 
 		nm_rb_negate,
 
@@ -84,6 +85,7 @@ VALUE cNMatrix,
 			cNMatrix_LAPACK,
 			
 			nm_eDataTypeError,
+      nm_eConvergenceError,
 			nm_eStorageTypeError;
 
 /*
@@ -127,9 +129,12 @@ void nm_init_ruby_constants(void) {
 	nm_rb_lower             = rb_intern("lower");
 	nm_rb_unit              = rb_intern("unit");
 	nm_rb_nonunit           = rb_intern("nonunit");
-
 	nm_rb_hash              = rb_intern("hash");
 
 	nm_rb_column            = rb_intern("column");
 	nm_rb_row               = rb_intern("row");
+
+  //Added by Ryan
+  nm_rb_both              = rb_intern("both");
+  nm_rb_none              = rb_intern("none");
 }

data/ext/nmatrix/ruby_constants.h

@@ -87,6 +87,7 @@ extern VALUE	cNMatrix,
 							cNMatrix_LAPACK,
 			
 							nm_eDataTypeError,
+              nm_eConvergenceError,
 							nm_eStorageTypeError;
 
 /*

data/ext/nmatrix/storage/dense.cpp

@@ -35,9 +35,11 @@
  * Project Includes
  */
 // #include "types.h"
-#include "util/math.h"
-
 #include "data/data.h"
+#include "math/long_dtype.h"
+#include "math/gemm.h"
+#include "math/gemv.h"
+#include "math/math.h"
 #include "common.h"
 #include "dense.h"
 
@@ -73,6 +75,30 @@ namespace nm { namespace dense_storage {
   template <typename DType>
   bool is_symmetric(const DENSE_STORAGE* mat, int lda);
 
+
+  /*
+   * Recursive slicing for N-dimensional matrix.
+   */
+  template <typename LDType, typename RDType>
+  static void slice_copy(DENSE_STORAGE *dest, const DENSE_STORAGE *src, size_t* lengths, size_t pdest, size_t psrc, size_t n) {
+    if (src->dim - n > 1) {
+      for (size_t i = 0; i < lengths[n]; ++i) {
+        slice_copy<LDType,RDType>(dest, src, lengths,
+                   pdest + dest->stride[n]*i,
+                   psrc + src->stride[n]*i,
+                   n + 1);
+      }
+    } else {
+      for (size_t p = 0; p < dest->shape[n]; ++p) {
+        reinterpret_cast<LDType*>(dest->elements)[p+pdest] = reinterpret_cast<RDType*>(src->elements)[p+psrc];
+      }
+      /*memcpy((char*)dest->elements + pdest*DTYPE_SIZES[dest->dtype],
+          (char*)src->elements + psrc*DTYPE_SIZES[src->dtype],
+          dest->shape[n]*DTYPE_SIZES[dest->dtype]); */
+    }
+
+  }
+
 }} // end of namespace nm::dense_storage
 
 
@@ -163,12 +189,12 @@ void nm_dense_storage_delete(STORAGE* s) {
   if (s) {
     DENSE_STORAGE* storage = (DENSE_STORAGE*)s;
     if(storage->count-- == 1) {
-      free(storage->shape);
-      free(storage->offset);
-      free(storage->stride);
+      xfree(storage->shape);
+      xfree(storage->offset);
+      xfree(storage->stride);
       if (storage->elements != NULL) // happens with dummy objects
-        free(storage->elements);
-      free(storage);
+        xfree(storage->elements);
+      xfree(storage);
     }
   }
 }
@@ -181,9 +207,9 @@ void nm_dense_storage_delete_ref(STORAGE* s) {
   if (s) {
     DENSE_STORAGE* storage = (DENSE_STORAGE*)s;
     nm_dense_storage_delete( reinterpret_cast<STORAGE*>(storage->src) );
-    free(storage->shape);
-    free(storage->offset);
-    free(storage);
+    xfree(storage->shape);
+    xfree(storage->offset);
+    xfree(storage);
   }
 }
 
@@ -367,6 +393,16 @@ VALUE nm_dense_each(VALUE nmatrix) {
 }
 
 
+/*
+ * Non-templated version of nm::dense_storage::slice_copy
+ */
+static void slice_copy(DENSE_STORAGE *dest, const DENSE_STORAGE *src, size_t* lengths, size_t pdest, size_t psrc, size_t n) {
+  NAMED_LR_DTYPE_TEMPLATE_TABLE(slice_copy_table, nm::dense_storage::slice_copy, void, DENSE_STORAGE*, const DENSE_STORAGE*, size_t*, size_t, size_t, size_t)
+
+  slice_copy_table[dest->dtype][src->dtype](dest, src, lengths, pdest, psrc, n);
+}
+
+
 /*
  * Get a slice or one element, using copying.
  *
@@ -374,17 +410,16 @@ VALUE nm_dense_each(VALUE nmatrix) {
  */
 void* nm_dense_storage_get(STORAGE* storage, SLICE* slice) {
   DENSE_STORAGE* s = (DENSE_STORAGE*)storage;
-  DENSE_STORAGE* ns;
 
   if (slice->single)
     return (char*)(s->elements) + nm_dense_storage_pos(s, slice->coords) * DTYPE_SIZES[s->dtype];
-  else { // Make references
+  else {
     size_t *shape      = ALLOC_N(size_t, s->dim);
     for (size_t i = 0; i < s->dim; ++i) {
       shape[i]  = slice->lengths[i];
     }
 
-    ns = nm_dense_storage_create(s->dtype, shape, s->dim, NULL, 0);
+    DENSE_STORAGE* ns = nm_dense_storage_create(s->dtype, shape, s->dim, NULL, 0);
 
     slice_copy(ns,
         reinterpret_cast<const DENSE_STORAGE*>(s->src),
@@ -392,6 +427,7 @@ void* nm_dense_storage_get(STORAGE* storage, SLICE* slice) {
         0,
         nm_dense_storage_pos(s, slice->coords),
         0);
+
     return ns;
   }
 }
@@ -552,24 +588,6 @@ static size_t* stride(size_t* shape, size_t dim) {
   return stride;
 }
 
-/*
- * Recursive slicing for N-dimensional matrix.
- */
-static void slice_copy(DENSE_STORAGE *dest, const DENSE_STORAGE *src, size_t* lengths, size_t pdest, size_t psrc, size_t n) {
-  if (src->dim - n > 1) {
-    for (size_t i = 0; i < lengths[n]; ++i) {
-      slice_copy(dest, src, lengths,
-                                    pdest + dest->stride[n]*i,
-                                    psrc + src->stride[n]*i,
-                                    n + 1);
-    }
-  } else {
-    memcpy((char*)dest->elements + pdest*DTYPE_SIZES[dest->dtype],
-        (char*)src->elements + psrc*DTYPE_SIZES[src->dtype],
-        dest->shape[n]*DTYPE_SIZES[dest->dtype]);
-  }
-
-}
 
 /////////////////////////
 // Copying and Casting //
@@ -694,22 +712,20 @@ DENSE_STORAGE* cast_copy(const DENSE_STORAGE* rhs, dtype_t new_dtype) {
 
   DENSE_STORAGE* lhs			= nm_dense_storage_create(new_dtype, shape, rhs->dim, NULL, 0);
 
-  RDType*	rhs_els         = reinterpret_cast<RDType*>(rhs->elements);
-  LDType* lhs_els	        = reinterpret_cast<LDType*>(lhs->elements);
-
 	// Ensure that allocation worked before copying.
   if (lhs && count) {
     if (rhs->src != rhs) { // Make a copy of a ref to a matrix.
+      size_t* offset      = ALLOCA_N(size_t, rhs->dim);
+      memset(offset, 0, sizeof(size_t) * rhs->dim);
 
-      DENSE_STORAGE* tmp = nm_dense_storage_copy(rhs);
-
-      RDType* tmp_els    = reinterpret_cast<RDType*>(tmp->elements);
-      while (count-- > 0)   {
-        lhs_els[count] = tmp_els[count];
-      }
-      nm_dense_storage_delete(tmp);
+      slice_copy(lhs, reinterpret_cast<const DENSE_STORAGE*>(rhs->src),
+                 rhs->shape, 0,
+                 nm_dense_storage_pos(rhs, offset), 0);
 
     } else {              // Make a regular copy.
+      RDType*	rhs_els         = reinterpret_cast<RDType*>(rhs->elements);
+      LDType* lhs_els	        = reinterpret_cast<LDType*>(lhs->elements);
+
     	while (count-- > 0)     		lhs_els[count] = rhs_els[count];
     }
   }

data/ext/nmatrix/storage/list.cpp

@@ -33,6 +33,7 @@
 #include <ruby.h>
 #include <algorithm> // std::min
 #include <iostream>
+#include <vector>
 
 /*
  * Project Includes
@@ -45,7 +46,7 @@
 #include "common.h"
 #include "list.h"
 
-#include "util/math.h"
+#include "math/math.h"
 #include "util/sl_list.h"
 
 /*
@@ -83,7 +84,7 @@ public:
 
   size_t dim() const { return ref->dim; }
 
-  size_t shape(size_t rec) const {
+  size_t ref_shape(size_t rec) const {
     return shape_[ref->dim - rec - 1];
   }
 
@@ -143,7 +144,7 @@ static void map_empty_stored_r(RecurseData& result, RecurseData& s, LIST* x, con
 
   // For reference matrices, make sure we start in the correct place.
   size_t offset   = result.offset(rec);
-  size_t x_shape  = result.shape(rec);
+  size_t x_shape  = result.ref_shape(rec);
 
   while (curr && curr->key < offset) {  curr = curr->next;  }
   if (curr && curr->key - offset >= x_shape) curr = NULL;
@@ -188,8 +189,8 @@ static void map_merged_stored_r(RecurseData& result, RecurseData& left, RecurseD
   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 (rcurr && rcurr->key - right.offset(rec) >= result.ref_shape(rec)) rcurr = NULL;
+  if (lcurr && lcurr->key - left.offset(rec) >= result.ref_shape(rec))  lcurr = NULL;
 
   if (rec) {
     while (lcurr || rcurr) {
@@ -214,8 +215,8 @@ static void map_merged_stored_r(RecurseData& result, RecurseData& left, RecurseD
       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;
+      if (rcurr && rcurr->key - right.offset(rec) >= result.ref_shape(rec)) rcurr = NULL;
+      if (lcurr && lcurr->key - left.offset(rec) >= result.ref_shape(rec)) lcurr = NULL;
     }
   } else {
     while (lcurr || rcurr) {
@@ -239,8 +240,8 @@ static void map_merged_stored_r(RecurseData& result, RecurseData& left, RecurseD
       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;
+      if (rcurr && rcurr->key - right.offset(rec) >= result.ref_shape(rec)) rcurr = NULL;
+      if (lcurr && lcurr->key - left.offset(rec) >= result.ref_shape(rec)) lcurr = NULL;
     }
   }
 }
@@ -293,10 +294,10 @@ void nm_list_storage_delete(STORAGE* s) {
     if (storage->count-- == 1) {
       list::del( storage->rows, storage->dim - 1 );
 
-      free(storage->shape);
-      free(storage->offset);
-      free(storage->default_val);
-      free(s);
+      xfree(storage->shape);
+      xfree(storage->offset);
+      xfree(storage->default_val);
+      xfree(s);
     }
   }
 }
@@ -309,9 +310,9 @@ void nm_list_storage_delete_ref(STORAGE* s) {
     LIST_STORAGE* storage = (LIST_STORAGE*)s;
 
     nm_list_storage_delete( reinterpret_cast<STORAGE*>(storage->src ) );
-    free(storage->shape);
-    free(storage->offset);
-    free(s);
+    xfree(storage->shape);
+    xfree(storage->offset);
+    xfree(s);
   }
 }
 
@@ -334,7 +335,7 @@ void nm_list_storage_mark(void* storage_base) {
 /*
  * Documentation goes here.
  */
-NODE* list_storage_get_single_node(LIST_STORAGE* s, SLICE* slice)
+static NODE* list_storage_get_single_node(LIST_STORAGE* s, SLICE* slice)
 {
   size_t r;
   LIST*  l = s->rows;
@@ -358,7 +359,7 @@ static void each_empty_with_indices_r(nm::list_storage::RecurseData& s, size_t r
   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) {
+    for (long index = 0; index < s.ref_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);
@@ -366,7 +367,7 @@ static void each_empty_with_indices_r(nm::list_storage::RecurseData& s, size_t r
     }
   } else {
     rb_ary_unshift(stack, empty);
-    for (long index = 0; index < s.shape(rec); ++index) {
+    for (long index = 0; index < s.ref_shape(rec); ++index) {
       rb_ary_push(stack, LONG2NUM(index));
       rb_yield_splat(stack);
       rb_ary_pop(stack);
@@ -382,18 +383,18 @@ static void each_with_indices_r(nm::list_storage::RecurseData& s, const LIST* l,
   NODE*  curr  = l->first;
 
   size_t offset = s.offset(rec);
-  size_t shape  = s.shape(rec);
+  size_t shape  = s.ref_shape(rec);
 
   while (curr && curr->key < offset) curr = curr->next;
-  if (curr && curr->key >= shape) curr = NULL;
+  if (curr && curr->key - offset >= shape) curr = NULL;
 
 
   if (rec) {
-    for (long index = 0; index < shape; ++index) {
+    for (long index = 0; index < shape; ++index) { // index in reference
       rb_ary_push(stack, LONG2NUM(index));
       if (!curr || index < curr->key - offset) {
         each_empty_with_indices_r(s, rec-1, stack);
-      } else {
+      } else { // index == curr->key - offset
         each_with_indices_r(s, reinterpret_cast<const LIST*>(curr->val), rec-1, stack);
         curr = curr->next;
       }
@@ -407,7 +408,7 @@ static void each_with_indices_r(nm::list_storage::RecurseData& s, const LIST* l,
       if (!curr || index < curr->key - offset) {
         rb_ary_unshift(stack, s.dtype() == nm::RUBYOBJ ? *reinterpret_cast<VALUE*>(s.init()) : s.init_obj());
 
-      } else { // index == curr->key
+      } else { // index == curr->key - offset
         rb_ary_unshift(stack, s.dtype() == nm::RUBYOBJ ? *reinterpret_cast<VALUE*>(curr->val) : rubyobj_from_cval(curr->val, s.dtype()).rval);
 
         curr = curr->next;
@@ -429,7 +430,7 @@ static void each_stored_with_indices_r(nm::list_storage::RecurseData& s, const L
   NODE* curr = l->first;
 
   size_t offset = s.offset(rec);
-  size_t shape  = s.shape(rec);
+  size_t shape  = s.ref_shape(rec);
 
   while (curr && curr->key < offset) { curr = curr->next; }
   if (curr && curr->key - offset >= shape) curr = NULL;
@@ -460,7 +461,7 @@ static void each_stored_with_indices_r(nm::list_storage::RecurseData& s, const L
       rb_ary_pop(stack);
 
       curr = curr->next;
-      if (curr && curr->key >= shape) curr = NULL;
+      if (curr && curr->key - offset >= shape) curr = NULL;
     }
   }
 }
@@ -500,7 +501,6 @@ VALUE nm_list_map_merged_stored(VALUE left, VALUE right, VALUE init) {
   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)) {
@@ -541,8 +541,11 @@ VALUE nm_list_map_merged_stored(VALUE left, VALUE right, VALUE init) {
 }
 
 
-
+/*
+ * Copy a slice of a list matrix into a regular list matrix.
+ */
 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;
   void *val = NULL;
@@ -586,10 +589,9 @@ void* nm_list_storage_get(STORAGE* storage, SLICE* slice) {
   NODE* n;
 
   if (slice->single) {
-    n = list_storage_get_single_node(s, slice); 
+    n = list_storage_get_single_node(s, slice);
     return (n ? n->val : s->default_val);
-  } 
-  else {
+  } else {
     void *init_val = ALLOC_N(char, DTYPE_SIZES[s->dtype]);
     memcpy(init_val, s->default_val, DTYPE_SIZES[s->dtype]);
 
@@ -597,7 +599,7 @@ void* nm_list_storage_get(STORAGE* storage, SLICE* slice) {
     memcpy(shape, slice->lengths, sizeof(size_t) * s->dim);
 
     ns = nm_list_storage_create(s->dtype, shape, s->dim, init_val);
-    
+
     ns->rows = slice_copy(s, s->rows, slice->coords, slice->lengths, 0);
     return ns;
   }
@@ -618,23 +620,23 @@ void* nm_list_storage_ref(STORAGE* storage, SLICE* slice) {
     return (n ? n->val : s->default_val);
   } 
   else {
-    ns = ALLOC( LIST_STORAGE );
+    ns              = ALLOC( LIST_STORAGE );
     
-    ns->dim = s->dim;
-    ns->dtype = s->dtype;
-    ns->offset     = ALLOC_N(size_t, ns->dim);
-    ns->shape      = ALLOC_N(size_t, ns->dim);
+    ns->dim         = s->dim;
+    ns->dtype       = s->dtype;
+    ns->offset      = ALLOC_N(size_t, ns->dim);
+    ns->shape       = ALLOC_N(size_t, ns->dim);
 
     for (size_t i = 0; i < ns->dim; ++i) {
       ns->offset[i] = slice->coords[i] + s->offset[i];
       ns->shape[i]  = slice->lengths[i];
     }
 
-    ns->rows = s->rows;
+    ns->rows        = s->rows;
     ns->default_val = s->default_val;
     
     s->src->count++;
-    ns->src = s->src;
+    ns->src         = s->src;
     
     return ns;
   }
@@ -874,21 +876,21 @@ static bool eqeq_empty_r(RecurseData& s, const LIST* l, size_t rec, const TDType
 
   // 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;
+  if (curr && curr->key - s.offset(rec) >= s.ref_shape(rec)) curr = NULL;
 
   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;
+      if (curr && curr->key - s.offset(rec) >= s.ref_shape(rec)) curr = NULL;
     }
   } 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;
+      if (curr && curr->key - s.offset(rec) >= s.ref_shape(rec)) curr = NULL;
     }
   }
   return true;
@@ -909,8 +911,8 @@ static bool eqeq_r(RecurseData& left, RecurseData& right, const LIST* l, const L
   // 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;
+  if (rcurr && rcurr->key - right.offset(rec) >= left.ref_shape(rec)) rcurr = NULL;
+  if (lcurr && lcurr->key - left.offset(rec) >= left.ref_shape(rec)) lcurr = NULL;
 
   bool compared = false;
 
@@ -929,15 +931,15 @@ static bool eqeq_r(RecurseData& left, RecurseData& right, const LIST* l, const L
         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;
+      if (rcurr && rcurr->key - right.offset(rec) >= right.ref_shape(rec)) rcurr = NULL;
+      if (lcurr && lcurr->key - left.offset(rec)  >= left.ref_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 && rcurr->key - right.offset(rec) >= left.ref_shape(rec)) rcurr = NULL;
+      if (lcurr && lcurr->key - left.offset(rec) >= left.ref_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;
@@ -950,8 +952,8 @@ static bool eqeq_r(RecurseData& left, RecurseData& right, const LIST* l, const L
         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;
+      if (rcurr && rcurr->key - right.offset(rec) >= right.ref_shape(rec)) rcurr = NULL;
+      if (lcurr && lcurr->key - left.offset(rec)  >= left.ref_shape(rec)) lcurr = NULL;
       compared = true;
     }
   }