nmatrix 0.0.5 → 0.0.6

data/ext/nmatrix/nmatrix.h

@@ -136,10 +136,10 @@
 
   #define NM_DEF_STORAGE_ELEMENTS    \
     NM_DECL_ENUM(dtype_t, dtype);    \
-    size_t  dim;                     \
-    size_t* shape;                   \
-    size_t* offset;                  \
-	  int			count;                   \
+    size_t      dim;                 \
+    size_t*     shape;               \
+    size_t*     offset;              \
+	  int			    count;               \
 	  STORAGE*		src;
 
   #define NM_DEF_STORAGE_CHILD_STRUCT_PRE(name)    struct name : STORAGE {
@@ -312,6 +312,7 @@ NM_DEF_STRUCT_POST(NMATRIX);  // };
 #define NM_SHAPE(val,i)         (NM_STORAGE(val)->shape[(i)])
 #define NM_SHAPE0(val)          (NM_STORAGE(val)->shape[0])
 #define NM_SHAPE1(val)          (NM_STORAGE(val)->shape[1])
+#define NM_DEFAULT_VAL(val)     (NM_STORAGE_LIST(val)->default_val)
 
 #define NM_DENSE_COUNT(val)     (storage_count_max_elements(NM_STORAGE_DENSE(val)))
 #define NM_SIZEOF_DTYPE(val)    (DTYPE_SIZES[NM_DTYPE(val)])
@@ -355,6 +356,12 @@ extern "C" {
 	VALUE rb_nvector_dense_create(NM_DECL_ENUM(dtype_t, dtype), void* elements, size_t length);
 
 	NM_DECL_ENUM(dtype_t, nm_dtype_guess(VALUE));   // (This is a function)
+	NM_DECL_ENUM(dtype_t, nm_dtype_min(VALUE));
+
+  // Non-API functions needed by other cpp files.
+	NMATRIX* nm_create(nm::stype_t stype, STORAGE* storage);
+	void     nm_delete(NMATRIX* mat);
+	void     nm_delete_ref(NMATRIX* mat);
 
 #ifdef __cplusplus
 }

data/ext/nmatrix/storage/common.cpp

@@ -52,19 +52,26 @@
  */
 
 extern "C" {
-/*
- * Calculate the number of elements in the dense storage structure, based on
- * shape and dim.
- */
-size_t nm_storage_count_max_elements(const STORAGE* storage) {
-  unsigned int i;
-  size_t count = 1;
-  
-  for (i = storage->dim; i-- > 0;) {
-		count *= storage->shape[i];
+  /*
+   * Calculate the number of elements in the dense storage structure, based on
+   * shape and dim.
+   */
+  size_t nm_storage_count_max_elements(const STORAGE* storage) {
+    unsigned int i;
+    size_t count = 1;
+
+    for (i = storage->dim; i-- > 0;) {
+      count *= storage->shape[i];
+    }
+
+    return count;
+  }
+
+  // Helper function used only for the RETURN_SIZED_ENUMERATOR macro. Returns the length of
+  // the matrix's storage.
+  VALUE nm_enumerator_length(VALUE nmatrix) {
+    long len = nm_storage_count_max_elements(NM_STORAGE_DENSE(nmatrix));
+    return LONG2NUM(len);
   }
-  
-  return count;
-}
 
 } // end of extern "C" block

data/ext/nmatrix/storage/common.h

@@ -32,6 +32,8 @@
  * Standard Includes
  */
 
+#include <cmath> // pow().
+
 /*
  * Project Includes
  */
@@ -41,7 +43,7 @@
 /*
  * Macros
  */
- 
+
 extern "C" {
 
 /*
@@ -69,6 +71,7 @@ struct SLICE {
  */
 
   size_t nm_storage_count_max_elements(const STORAGE* storage);
+  VALUE nm_enumerator_length(VALUE nmatrix);
 
 } // end of extern "C" block
 
@@ -78,19 +81,22 @@ namespace nm {
    * Templated helper function for element-wise operations, used by dense, yale, and list.
    */
   template <ewop_t op, typename LDType, typename RDType>
-  inline LDType ew_op_switch(LDType left, RDType right) {
+  inline VALUE ew_op_switch(LDType left, RDType right) {
     switch (op) {
       case EW_ADD:
-        return left + right;
+        return RubyObject(left + right).rval;
 
       case EW_SUB:
-        return left - right;
+        return RubyObject(left - right).rval;
 
       case EW_MUL:
-        return left * right;
+        return RubyObject(left * right).rval;
 
       case EW_DIV:
-        return left / right;
+        return RubyObject(left / right).rval;
+
+      case EW_POW:
+        return RubyObject(pow(left, right)).rval;
 
       case EW_MOD:
         rb_raise(rb_eNotImpError, "Element-wise modulo is currently not supported.");
@@ -99,11 +105,11 @@ namespace nm {
       default:
         rb_raise(rb_eStandardError, "This should not happen.");
     }
-    return 0;
+    return Qnil;
   }
 
   #define EWOP_INT_INT_DIV(ltype, rtype)       template <>       \
-  inline ltype ew_op_switch<EW_DIV>( ltype left, rtype right) { \
+  inline VALUE ew_op_switch<EW_DIV>( ltype left, rtype right) { \
     if (right == 0) rb_raise(rb_eZeroDivError, "cannot divide type by 0, would throw SIGFPE");  \
     if ((left > 0 && right > 0) || (left < 0 && right < 0)) \
       return left / right;  \
@@ -112,27 +118,27 @@ namespace nm {
   }
 
   #define EWOP_UINT_UINT_DIV(ltype, rtype)       template <>       \
-  inline ltype ew_op_switch<EW_DIV>( ltype left, rtype right) { \
+  inline VALUE ew_op_switch<EW_DIV>( ltype left, rtype right) { \
     if (right == 0) rb_raise(rb_eZeroDivError, "cannot divide type by 0, would throw SIGFPE");  \
     return left / right;  \
   }
 
   #define EWOP_INT_UINT_DIV(ltype, rtype)       template <>       \
-  inline ltype ew_op_switch<EW_DIV>( ltype left, rtype right) { \
+  inline VALUE ew_op_switch<EW_DIV>( ltype left, rtype right) { \
     if (right == 0) rb_raise(rb_eZeroDivError, "cannot divide type by 0, would throw SIGFPE");  \
     if (left > 0 )  return left / right;  \
     else            return ( ltype )(std::floor((double)(left) / (double)(right)));  \
   }
 
   #define EWOP_UINT_INT_DIV(ltype, rtype)       template <>       \
-  inline ltype ew_op_switch<EW_DIV>( ltype left, rtype right) { \
+  inline VALUE ew_op_switch<EW_DIV>( ltype left, rtype right) { \
     if (right == 0) rb_raise(rb_eZeroDivError, "cannot divide type by 0, would throw SIGFPE");  \
     if (right > 0)  return left / right;  \
     else            return ( ltype )(std::floor((double)(left) / (double)(right)));  \
   }
 
   #define EWOP_FLOAT_INT_DIV(ltype, rtype)       template <>       \
-  inline ltype ew_op_switch<EW_DIV>( ltype left, rtype right) { \
+  inline VALUE ew_op_switch<EW_DIV>( ltype left, rtype right) { \
     return left / (ltype)(right);  \
   }
 

data/ext/nmatrix/storage/dense.cpp

@@ -60,12 +60,9 @@ namespace nm { namespace dense_storage {
 
   template <typename LDType, typename RDType>
   DENSE_STORAGE* cast_copy(const DENSE_STORAGE* rhs, nm::dtype_t new_dtype);
-	
+
 	template <typename LDType, typename RDType>
 	bool eqeq(const DENSE_STORAGE* left, const DENSE_STORAGE* right);
-	
-	template <ewop_t op, typename LDType, typename RDType>
-	static DENSE_STORAGE* ew_op(const DENSE_STORAGE* left, const DENSE_STORAGE* right, const void* rscalar);
 
   template <typename DType>
   static DENSE_STORAGE* matrix_multiply(const STORAGE_PAIR& casted_storage, size_t* resulting_shape, bool vector);
@@ -132,7 +129,7 @@ DENSE_STORAGE* nm_dense_storage_create(nm::dtype_t dtype, size_t* shape, size_t
 
   if (elements_length == count) {
   	s->elements = elements;
-    
+
   } else {
     s->elements = ALLOC_N(char, DTYPE_SIZES[dtype]*count);
 
@@ -145,12 +142,12 @@ DENSE_STORAGE* nm_dense_storage_create(nm::dtype_t dtype, size_t* shape, size_t
         if (i + elements_length > count) {
         	copy_length = count - i;
         }
-        
+
         memcpy((char*)(s->elements)+i*DTYPE_SIZES[dtype], (char*)(elements)+(i % elements_length)*DTYPE_SIZES[dtype], copy_length*DTYPE_SIZES[dtype]);
       }
 
       // Get rid of the init_val.
-      free(elements);
+      xfree(elements);
     }
   }
 
@@ -210,20 +207,85 @@ void nm_dense_storage_mark(void* storage_base) {
 ///////////////
 
 
-// Helper function used only for the RETURN_SIZED_ENUMERATOR macro. Returns the length of
-// the matrix's storage.
-static VALUE nm_dense_enumerator_length(VALUE nmatrix) {
-  long len = nm_storage_count_max_elements(NM_STORAGE_DENSE(nmatrix));
-  return LONG2NUM(len);
+
+/*
+ * map_pair iterator for dense matrices (for element-wise operations)
+ */
+VALUE nm_dense_map_pair(VALUE self, VALUE right) {
+  DENSE_STORAGE *s = NM_STORAGE_DENSE(self),
+                *t = NM_STORAGE_DENSE(right);
+
+  RETURN_SIZED_ENUMERATOR(self, 0, 0, nm_enumerator_length);
+
+  size_t* coords = ALLOCA_N(size_t, s->dim);
+  memset(coords, 0, sizeof(size_t) * s->dim);
+
+  size_t *shape_copy = ALLOC_N(size_t, s->dim);
+  memcpy(shape_copy, s->shape, sizeof(size_t) * s->dim);
+
+  size_t count = nm_storage_count_max_elements(s);
+
+  DENSE_STORAGE* result = nm_dense_storage_create(nm::RUBYOBJ, shape_copy, s->dim, NULL, 0);
+  VALUE* result_elem = reinterpret_cast<VALUE*>(result->elements);
+
+  for (size_t k = 0; k < count; ++k) {
+    nm_dense_storage_coords(result, k, coords);
+    size_t s_index = nm_dense_storage_pos(s, coords),
+           t_index = nm_dense_storage_pos(t, coords);
+
+    VALUE sval = NM_DTYPE(self) == nm::RUBYOBJ ? reinterpret_cast<VALUE*>(s->elements)[s_index] : rubyobj_from_cval((char*)(s->elements) + s_index*DTYPE_SIZES[NM_DTYPE(self)], NM_DTYPE(self)).rval;
+    VALUE tval = NM_DTYPE(right) == nm::RUBYOBJ ? reinterpret_cast<VALUE*>(t->elements)[t_index] : rubyobj_from_cval((char*)(t->elements) + t_index*DTYPE_SIZES[NM_DTYPE(right)], NM_DTYPE(right)).rval;
+
+    result_elem[k] = rb_yield_values(2, sval, tval);
+  }
+
+  NMATRIX* m = nm_create(nm::DENSE_STORE, reinterpret_cast<STORAGE*>(result));
+
+  return Data_Wrap_Struct(CLASS_OF(self), nm_dense_storage_mark, nm_delete, m);
+}
+
+
+/*
+ * map enumerator for dense matrices.
+ */
+VALUE nm_dense_map(VALUE self) {
+  DENSE_STORAGE *s = NM_STORAGE_DENSE(self);
+
+  RETURN_SIZED_ENUMERATOR(self, 0, 0, nm_enumerator_length);
+
+  size_t* coords = ALLOCA_N(size_t, s->dim);
+  memset(coords, 0, sizeof(size_t) * s->dim);
+
+  size_t *shape_copy = ALLOC_N(size_t, s->dim);
+  memcpy(shape_copy, s->shape, sizeof(size_t) * s->dim);
+
+  size_t count = nm_storage_count_max_elements(s);
+
+  DENSE_STORAGE* result = nm_dense_storage_create(nm::RUBYOBJ, shape_copy, s->dim, NULL, 0);
+  VALUE* result_elem = reinterpret_cast<VALUE*>(result->elements);
+
+  for (size_t k = 0; k < count; ++k) {
+    nm_dense_storage_coords(result, k, coords);
+    size_t s_index = nm_dense_storage_pos(s, coords);
+
+    result_elem[k] = rb_yield(NM_DTYPE(self) == nm::RUBYOBJ ? reinterpret_cast<VALUE*>(s->elements)[s_index] : rubyobj_from_cval((char*)(s->elements) + s_index*DTYPE_SIZES[NM_DTYPE(self)], NM_DTYPE(self)).rval);
+  }
+
+  NMATRIX* m = nm_create(nm::DENSE_STORE, reinterpret_cast<STORAGE*>(result));
+
+  return Data_Wrap_Struct(CLASS_OF(self), nm_dense_storage_mark, nm_delete, m);
 }
 
 
+/*
+ * each_with_indices iterator for dense matrices.
+ */
 VALUE nm_dense_each_with_indices(VALUE nmatrix) {
   volatile VALUE nm = nmatrix;
 
   DENSE_STORAGE* s = NM_STORAGE_DENSE(nm);
 
-  RETURN_SIZED_ENUMERATOR(nm, 0, 0, nm_dense_enumerator_length); // fourth argument only used by Ruby2+
+  RETURN_SIZED_ENUMERATOR(nm, 0, 0, nm_enumerator_length); // fourth argument only used by Ruby2+
 
   // Create indices and initialize them to zero
   size_t* coords = ALLOCA_N(size_t, s->dim);
@@ -269,7 +331,7 @@ VALUE nm_dense_each(VALUE nmatrix) {
   volatile VALUE nm = nmatrix; // Not sure this actually does anything.
   DENSE_STORAGE* s = NM_STORAGE_DENSE(nm);
 
-  RETURN_SIZED_ENUMERATOR(nm, 0, 0, nm_storage_count_max_elements(s));
+  RETURN_SIZED_ENUMERATOR(nm, 0, 0, nm_enumerator_length);
 
   size_t* temp_coords = ALLOCA_N(size_t, s->dim);
   size_t sliced_index;
@@ -280,10 +342,11 @@ VALUE nm_dense_each(VALUE nmatrix) {
   if (NM_DTYPE(nm) == nm::RUBYOBJ) {
 
     // matrix of Ruby objects -- yield those objects directly
-    for (size_t i = 0; i < nm_storage_count_max_elements(s); ++i)
+    for (size_t i = 0; i < nm_storage_count_max_elements(s); ++i) {
       nm_dense_storage_coords(sliced_dummy, i, temp_coords);
       sliced_index = nm_dense_storage_pos(s, temp_coords);
       rb_yield( reinterpret_cast<VALUE*>(s->elements)[sliced_index] );
+    }
 
   } else {
 
@@ -300,7 +363,7 @@ VALUE nm_dense_each(VALUE nmatrix) {
   nm_dense_storage_delete(sliced_dummy);
 
   return nmatrix;
-  
+
 }
 
 
@@ -321,13 +384,13 @@ void* nm_dense_storage_get(STORAGE* storage, SLICE* slice) {
       shape[i]  = slice->lengths[i];
     }
 
-    ns = nm_dense_storage_create(s->dtype, shape, s->dim, NULL, 0); 
+    ns = nm_dense_storage_create(s->dtype, shape, s->dim, NULL, 0);
 
-    slice_copy(ns, 
-        reinterpret_cast<const DENSE_STORAGE*>(s->src), 
-        slice->lengths, 
-        0, 
-        nm_dense_storage_pos(s, slice->coords), 
+    slice_copy(ns,
+        reinterpret_cast<const DENSE_STORAGE*>(s->src),
+        slice->lengths,
+        0,
+        nm_dense_storage_pos(s, slice->coords),
         0);
     return ns;
   }
@@ -343,7 +406,7 @@ void* nm_dense_storage_ref(STORAGE* storage, SLICE* slice) {
 
   if (slice->single)
     return (char*)(s->elements) + nm_dense_storage_pos(s, slice->coords) * DTYPE_SIZES[s->dtype];
-    
+
   else {
     DENSE_STORAGE* ns = ALLOC( DENSE_STORAGE );
     ns->dim        = s->dim;
@@ -358,7 +421,7 @@ void* nm_dense_storage_ref(STORAGE* storage, SLICE* slice) {
 
     ns->stride     = s->stride;
     ns->elements   = s->elements;
-    
+
     s->src->count++;
     ns->src = s->src;
 
@@ -387,8 +450,13 @@ void nm_dense_storage_set(STORAGE* storage, SLICE* slice, void* val) {
  *				have the same dtype.
  */
 bool nm_dense_storage_eqeq(const STORAGE* left, const STORAGE* right) {
-	LR_DTYPE_TEMPLATE_TABLE(nm::dense_storage::eqeq, bool, const DENSE_STORAGE*, const DENSE_STORAGE*);
-	
+	LR_DTYPE_TEMPLATE_TABLE(nm::dense_storage::eqeq, bool, const DENSE_STORAGE*, const DENSE_STORAGE*)
+
+  if (!ttable[left->dtype][right->dtype]) {
+    rb_raise(nm_eDataTypeError, "comparison between these dtypes is undefined");
+    return false;
+  }
+
 	return ttable[left->dtype][right->dtype]((const DENSE_STORAGE*)left, (const DENSE_STORAGE*)right);
 }
 
@@ -399,10 +467,10 @@ bool nm_dense_storage_eqeq(const STORAGE* left, const STORAGE* right) {
 bool nm_dense_storage_is_hermitian(const DENSE_STORAGE* mat, int lda) {
 	if (mat->dtype == nm::COMPLEX64) {
 		return nm::dense_storage::is_hermitian<nm::Complex64>(mat, lda);
-		
+
 	} else if (mat->dtype == nm::COMPLEX128) {
 		return nm::dense_storage::is_hermitian<nm::Complex128>(mat, lda);
-		
+
 	} else {
 		return nm_dense_storage_is_symmetric(mat, lda);
 	}
@@ -413,7 +481,7 @@ bool nm_dense_storage_is_hermitian(const DENSE_STORAGE* mat, int lda) {
  */
 bool nm_dense_storage_is_symmetric(const DENSE_STORAGE* mat, int lda) {
 	DTYPE_TEMPLATE_TABLE(nm::dense_storage::is_symmetric, bool, const DENSE_STORAGE*, int);
-	
+
 	return ttable[mat->dtype](mat, lda);
 }
 
@@ -421,24 +489,6 @@ bool nm_dense_storage_is_symmetric(const DENSE_STORAGE* mat, int lda) {
 // Math //
 //////////
 
-/*
- * Dense matrix-matrix and matrix-scalar element-wise operations.
- *
- * right or rscalar should be NULL; they should not both be initialized. If right is NULL, it'll use the scalar value instead.
- */
-STORAGE* nm_dense_storage_ew_op(nm::ewop_t op, const STORAGE* left, const STORAGE* right, VALUE scalar) {
-	OP_LR_DTYPE_TEMPLATE_TABLE(nm::dense_storage::ew_op, DENSE_STORAGE*, const DENSE_STORAGE* left, const DENSE_STORAGE* right, const void*);
-
-	if (right)
-	  return ttable[op][left->dtype][right->dtype](reinterpret_cast<const DENSE_STORAGE*>(left), reinterpret_cast<const DENSE_STORAGE*>(right), NULL);
-	else {
-	  nm::dtype_t r_dtype = nm_dtype_guess(scalar);
-	  void* r_scalar  = ALLOCA_N(char, DTYPE_SIZES[r_dtype]);
-	  rubyval_to_cval(scalar, r_dtype, r_scalar);
-
-    return ttable[op][left->dtype][r_dtype](reinterpret_cast<const DENSE_STORAGE*>(left), NULL, r_scalar);
-	}
-}
 
 /*
  * Dense matrix-matrix multiplication.
@@ -468,9 +518,9 @@ size_t nm_dense_storage_pos(const DENSE_STORAGE* s, const size_t* coords) {
 }
 
 /*
- * Determine the a set of slice coordinates from linear array position (in elements 
+ * Determine the a set of slice coordinates from linear array position (in elements
  * of s) of some set of coordinates (given by slice).  (Inverse of
- * nm_dense_storage_pos).  
+ * nm_dense_storage_pos).
  *
  * The parameter coords_out should be a pre-allocated array of size equal to s->dim.
  */
@@ -510,7 +560,7 @@ static void slice_copy(DENSE_STORAGE *dest, const DENSE_STORAGE *src, size_t* le
     for (size_t i = 0; i < lengths[n]; ++i) {
       slice_copy(dest, src, lengths,
                                     pdest + dest->stride[n]*i,
-                                    psrc + src->stride[n]*i, 
+                                    psrc + src->stride[n]*i,
                                     n + 1);
     }
   } else {
@@ -528,9 +578,14 @@ static void slice_copy(DENSE_STORAGE *dest, const DENSE_STORAGE *src, size_t* le
 /*
  * Copy dense storage, changing dtype if necessary.
  */
-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* dummy) {
 	NAMED_LR_DTYPE_TEMPLATE_TABLE(ttable, nm::dense_storage::cast_copy, DENSE_STORAGE*, const DENSE_STORAGE* rhs, nm::dtype_t new_dtype);
 
+  if (!ttable[new_dtype][rhs->dtype]) {
+    rb_raise(nm_eDataTypeError, "cast between these dtypes is undefined");
+    return NULL;
+  }
+
 	return (STORAGE*)ttable[new_dtype][rhs->dtype]((DENSE_STORAGE*)rhs, new_dtype);
 }
 
@@ -538,7 +593,7 @@ STORAGE* nm_dense_storage_cast_copy(const STORAGE* rhs, nm::dtype_t new_dtype) {
  * Copy dense storage without a change in dtype.
  */
 DENSE_STORAGE* nm_dense_storage_copy(const DENSE_STORAGE* rhs) {
-  size_t  count = 0;  
+  size_t  count = 0;
   size_t *shape  = ALLOC_N(size_t, rhs->dim);
 
   // copy shape and offset
@@ -593,6 +648,10 @@ STORAGE* nm_dense_storage_copy_transposed(const STORAGE* rhs_base) {
     nm_math_transpose_generic(rhs->shape[0], rhs->shape[1], rhs->elements, rhs->shape[1], lhs->elements, lhs->shape[1], DTYPE_SIZES[rhs->dtype]);
   } else {
     NAMED_LR_DTYPE_TEMPLATE_TABLE(ttable, nm::dense_storage::ref_slice_copy_transposed, void, const DENSE_STORAGE* rhs, DENSE_STORAGE* lhs);
+
+    if (!ttable[lhs->dtype][rhs->dtype])
+      rb_raise(nm_eDataTypeError, "transposition between these dtypes is undefined");
+
     ttable[lhs->dtype][rhs->dtype](rhs, lhs);
   }
 
@@ -640,8 +699,7 @@ DENSE_STORAGE* cast_copy(const DENSE_STORAGE* rhs, dtype_t new_dtype) {
 
 	// Ensure that allocation worked before copying.
   if (lhs && count) {
-    if (rhs->src != rhs) {
-      /* Make a copy of a ref to a matrix. */
+    if (rhs->src != rhs) { // Make a copy of a ref to a matrix.
 
       DENSE_STORAGE* tmp = nm_dense_storage_copy(rhs);
 
@@ -650,13 +708,12 @@ DENSE_STORAGE* cast_copy(const DENSE_STORAGE* rhs, dtype_t new_dtype) {
         lhs_els[count] = tmp_els[count];
       }
       nm_dense_storage_delete(tmp);
-    } else {
-      /* Make a regular copy. */
 
+    } else {              // Make a regular copy.
     	while (count-- > 0)     		lhs_els[count] = rhs_els[count];
     }
   }
-	
+
   return lhs;
 }
 
@@ -673,7 +730,7 @@ bool eqeq(const DENSE_STORAGE* left, const DENSE_STORAGE* right) {
 	LDType* left_elements	  = (LDType*)left->elements;
   RDType* right_elements	= (RDType*)right->elements;
 
-  // Copy elements in temp matrix if you have refernce to the right.
+  // Copy elements in temp matrix if you have reference to the right.
   if (left->src != left) {
     tmp1 = nm_dense_storage_copy(left);
     left_elements = (LDType*)tmp1->elements;
@@ -682,7 +739,7 @@ bool eqeq(const DENSE_STORAGE* left, const DENSE_STORAGE* right) {
     tmp2 = nm_dense_storage_copy(right);
     right_elements = (RDType*)tmp2->elements;
   }
-  
+
 
 
 	for (index = nm_storage_count_max_elements(left); index-- > 0;) {
@@ -704,20 +761,20 @@ template <typename DType>
 bool is_hermitian(const DENSE_STORAGE* mat, int lda) {
 	unsigned int i, j;
 	register DType complex_conj;
-	
+
 	const DType* els = (DType*) mat->elements;
-	
+
 	for (i = mat->shape[0]; i-- > 0;) {
 		for (j = i + 1; j < mat->shape[1]; ++j) {
 			complex_conj		= els[j*lda + 1];
 			complex_conj.i	= -complex_conj.i;
-			
+
 			if (els[i*lda+j] != complex_conj) {
 	      return false;
 	    }
 		}
 	}
-	
+
 	return true;
 }
 
@@ -725,7 +782,7 @@ template <typename DType>
 bool is_symmetric(const DENSE_STORAGE* mat, int lda) {
 	unsigned int i, j;
 	const DType* els = (DType*) mat->elements;
-	
+
 	for (i = mat->shape[0]; i-- > 0;) {
 		for (j = i + 1; j < mat->shape[1]; ++j) {
 			if (els[i*lda+j] != els[j*lda+i]) {
@@ -733,137 +790,10 @@ bool is_symmetric(const DENSE_STORAGE* mat, int lda) {
 	    }
 		}
 	}
-	
+
 	return true;
 }
 
-/*
- * Templated dense storage element-wise operations which return the same DType.
- */
-template <ewop_t op, typename LDType, typename RDType>
-static DENSE_STORAGE* ew_op(const DENSE_STORAGE* left, const DENSE_STORAGE* right, const void* rscalar) {
-	unsigned int count;
-  size_t l_count;
-  size_t r_count;
-
-	size_t* temp_coords = ALLOCA_N(size_t, left->dim);
-
-	size_t* new_shape = ALLOC_N(size_t, left->dim);
-	memcpy(new_shape, left->shape, sizeof(size_t) * left->dim);
-
-  // Determine the return dtype. This depends on the type of operation we're doing. Usually, it's going to be
-  // set by the left matrix, but for comparisons, we'll use BYTE (in lieu of boolean).
-  dtype_t new_dtype = static_cast<uint8_t>(op) < NUM_NONCOMP_EWOPS ? left->dtype : BYTE;
-
-	DENSE_STORAGE* result = nm_dense_storage_create(new_dtype, new_shape, left->dim, NULL, 0);
-	
-	LDType* l_elems = reinterpret_cast<LDType*>(left->elements);
-
-	if (right) { // matrix-matrix operation
-	  RDType* r_elems = reinterpret_cast<RDType*>(right->elements);
-
-    if (static_cast<uint8_t>(op) < NUM_NONCOMP_EWOPS) { // use left-dtype
-
-      for (count = nm_storage_count_max_elements(result); count-- > 0;) {
-        nm_dense_storage_coords(result, count, temp_coords);
-        l_count = nm_dense_storage_pos(left, temp_coords);
-        r_count = nm_dense_storage_pos(right, temp_coords);
-        
-        reinterpret_cast<LDType*>(result->elements)[count] = ew_op_switch<op,LDType,RDType>(l_elems[l_count], r_elems[r_count]);
-      }
-
-    } else { // new_dtype is BYTE: comparison operators
-      uint8_t* res_elems = reinterpret_cast<uint8_t*>(result->elements);
-
-      for (count = nm_storage_count_max_elements(result); count-- > 0;) {
-        nm_dense_storage_coords(result, count, temp_coords);
-        l_count = nm_dense_storage_pos(left, temp_coords);
-        r_count = nm_dense_storage_pos(right, temp_coords);
-
-        switch (op) {
-          case EW_EQEQ:
-            res_elems[count] = l_elems[l_count] == r_elems[r_count];
-            break;
-
-          case EW_NEQ:
-            res_elems[count] = l_elems[l_count] != r_elems[r_count];
-            break;
-
-          case EW_LT:
-            res_elems[count] = l_elems[l_count] < r_elems[r_count];
-            break;
-
-          case EW_GT:
-            res_elems[count] = l_elems[l_count] > r_elems[r_count];
-            break;
-
-          case EW_LEQ:
-            res_elems[count] = l_elems[l_count] <= r_elems[r_count];
-            break;
-
-          case EW_GEQ:
-            res_elems[count] = l_elems[l_count] >= r_elems[r_count];
-            break;
-
-          default:
-            rb_raise(rb_eStandardError, "this should not happen");
-        }
-      }
-    }
-
-  } else { // matrix-scalar operation
-    const RDType* r_elem = reinterpret_cast<const RDType*>(rscalar);
-
-    if (static_cast<uint8_t>(op) < NUM_NONCOMP_EWOPS) { // use left-dtype
-
-      for (count = nm_storage_count_max_elements(result); count-- > 0;) {
-        nm_dense_storage_coords(result, count, temp_coords);
-        l_count = nm_dense_storage_pos(left, temp_coords);
-
-        reinterpret_cast<LDType*>(result->elements)[count] = ew_op_switch<op,LDType,RDType>(l_elems[l_count], *r_elem);
-      }
-
-    } else {
-      uint8_t* res_elems = reinterpret_cast<uint8_t*>(result->elements);
-
-      for (count = nm_storage_count_max_elements(result); count-- > 0;) {
-        nm_dense_storage_coords(result, count, temp_coords);
-        l_count = nm_dense_storage_pos(left, temp_coords);
-        
-        switch (op) {
-          case EW_EQEQ:
-            res_elems[count] = l_elems[l_count] == *r_elem;
-            break;
-
-          case EW_NEQ:
-            res_elems[count] = l_elems[l_count] != *r_elem;
-            break;
-
-          case EW_LT:
-            res_elems[count] = l_elems[l_count] < *r_elem;
-            break;
-
-          case EW_GT:
-            res_elems[count] = l_elems[l_count] > *r_elem;
-            break;
-
-          case EW_LEQ:
-            res_elems[count] = l_elems[l_count] <= *r_elem;
-            break;
-
-          case EW_GEQ:
-            res_elems[count] = l_elems[l_count] >= *r_elem;
-            break;
-
-          default:
-            rb_raise(rb_eStandardError, "this should not happen");
-        }
-      }
-
-    }
-  }
-	return result;
-}
 
 
 /*