nmatrix 0.2.0 → 0.2.1

data/ext/nmatrix/storage/common.h

@@ -32,6 +32,7 @@
  * Standard Includes
  */
 
+#include <ruby.h>
 #include <cmath> // pow().
 
 /*
@@ -57,9 +58,9 @@ struct STORAGE_PAIR {
 };
 
 struct SLICE {
-  size_t*	coords; // Coordinate of first element
-  size_t*	lengths; // Lengths of slice
-  bool  	single; // true if all lengths equal to 1 (represents single matrix element)
+  size_t*  coords; // Coordinate of first element
+  size_t*  lengths; // Lengths of slice
+  bool    single; // true if all lengths equal to 1 (represents single matrix element)
 };
 
 /*

data/ext/nmatrix/storage/dense/dense.cpp

@@ -62,8 +62,8 @@ 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 <typename LDType, typename RDType>
+  bool eqeq(const DENSE_STORAGE* left, const DENSE_STORAGE* right);
 
   template <typename DType>
   static DENSE_STORAGE* matrix_multiply(const STORAGE_PAIR& casted_storage, size_t* resulting_shape, bool vector);
@@ -216,7 +216,7 @@ static DENSE_STORAGE* nm_dense_storage_create_dummy(nm::dtype_t dtype, size_t* s
   s->count      = 1;
   s->src        = s;
 
-	s->elements   = NULL;
+  s->elements   = NULL;
 
   return s;
 }
@@ -255,7 +255,7 @@ DENSE_STORAGE* nm_dense_storage_create(nm::dtype_t dtype, size_t* shape, size_t
       for (size_t i = 0; i < count; i += elements_length) {
 
         if (i + elements_length > count) {
-        	copy_length = count - i;
+          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]);
@@ -316,7 +316,7 @@ void nm_dense_storage_mark(STORAGE* storage_base) {
     if (els) {
       rb_gc_mark_locations(els, &(els[nm_storage_count_max_elements(storage)-1]));
     }
-  	//for (size_t index = nm_storage_count_max_elements(storage); index-- > 0;) {
+    //for (size_t index = nm_storage_count_max_elements(storage); index-- > 0;) {
     //  rb_gc_mark(els[index]);
     //}
   }
@@ -390,9 +390,9 @@ VALUE nm_dense_map_pair(VALUE self, VALUE right) {
     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 sval = NM_DTYPE(self) == nm::RUBYOBJ ? reinterpret_cast<VALUE*>(s->elements)[s_index] : nm::rubyobj_from_cval((char*)(s->elements) + s_index*DTYPE_SIZES[NM_DTYPE(self)], NM_DTYPE(self)).rval;
     nm_register_value(&sval);
-    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;
+    VALUE tval = NM_DTYPE(right) == nm::RUBYOBJ ? reinterpret_cast<VALUE*>(t->elements)[t_index] : nm::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);
     nm_unregister_value(&sval);
   }
@@ -442,7 +442,7 @@ VALUE nm_dense_map(VALUE self) {
     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);
+    result_elem[k] = rb_yield(NM_DTYPE(self) == nm::RUBYOBJ ? reinterpret_cast<VALUE*>(s->elements)[s_index] : nm::rubyobj_from_cval((char*)(s->elements) + s_index*DTYPE_SIZES[NM_DTYPE(self)], NM_DTYPE(self)).rval);
   }
 
   VALUE klass = CLASS_OF(self);
@@ -488,7 +488,7 @@ VALUE nm_dense_each_with_indices(VALUE nmatrix) {
     VALUE ary = rb_ary_new();
     nm_register_value(&ary);
     if (NM_DTYPE(nmatrix) == nm::RUBYOBJ) rb_ary_push(ary, reinterpret_cast<VALUE*>(s->elements)[slice_index]);
-    else rb_ary_push(ary, rubyobj_from_cval((char*)(s->elements) + slice_index*DTYPE_SIZES[NM_DTYPE(nmatrix)], NM_DTYPE(nmatrix)).rval);
+    else rb_ary_push(ary, nm::rubyobj_from_cval((char*)(s->elements) + slice_index*DTYPE_SIZES[NM_DTYPE(nmatrix)], NM_DTYPE(nmatrix)).rval);
 
     for (size_t p = 0; p < s->dim; ++p) {
       rb_ary_push(ary, INT2FIX(coords[p]));
@@ -547,7 +547,7 @@ VALUE nm_dense_each(VALUE nmatrix) {
     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);
-      VALUE v = rubyobj_from_cval((char*)(s->elements) + sliced_index*DTYPE_SIZES[NM_DTYPE(nmatrix)], NM_DTYPE(nmatrix)).rval;
+      VALUE v = nm::rubyobj_from_cval((char*)(s->elements) + sliced_index*DTYPE_SIZES[NM_DTYPE(nmatrix)], NM_DTYPE(nmatrix)).rval;
       rb_yield( v ); // yield to the copy we made
     }
   }
@@ -657,7 +657,7 @@ void nm_dense_storage_set(VALUE left, SLICE* slice, VALUE right) {
  *
  * TODO: Test the shape of the two matrices.
  * TODO: See if using memcmp is faster when the left- and right-hand matrices
- *				have the same dtype.
+ *        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*)
@@ -667,7 +667,7 @@ bool nm_dense_storage_eqeq(const STORAGE* left, const STORAGE* right) {
     return false;
   }
 
-	return ttable[left->dtype][right->dtype]((const DENSE_STORAGE*)left, (const DENSE_STORAGE*)right);
+  return ttable[left->dtype][right->dtype]((const DENSE_STORAGE*)left, (const DENSE_STORAGE*)right);
 }
 
 /*
@@ -675,24 +675,24 @@ bool nm_dense_storage_eqeq(const STORAGE* left, const STORAGE* right) {
  * dtype of Complex64 or Complex128 this is the same as testing for symmetry.
  */
 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);
+  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 if (mat->dtype == nm::COMPLEX128) {
+    return nm::dense_storage::is_hermitian<nm::Complex128>(mat, lda);
 
-	} else {
-		return nm_dense_storage_is_symmetric(mat, lda);
-	}
+  } else {
+    return nm_dense_storage_is_symmetric(mat, lda);
+  }
 }
 
 /*
  * Is this dense matrix symmetric about the diagonal?
  */
 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);
+  DTYPE_TEMPLATE_TABLE(nm::dense_storage::is_symmetric, bool, const DENSE_STORAGE*, int);
 
-	return ttable[mat->dtype](mat, lda);
+  return ttable[mat->dtype](mat, lda);
 }
 
 //////////
@@ -798,7 +798,7 @@ DENSE_STORAGE* nm_dense_storage_copy(const DENSE_STORAGE* rhs) {
   count = nm_storage_count_max_elements(lhs);
 
 
-	// Ensure that allocation worked before copying.
+  // Ensure that allocation worked before copying.
   if (lhs && count) {
     if (rhs == rhs->src) // not a reference
       memcpy(lhs->elements, rhs->elements, DTYPE_SIZES[rhs->dtype] * count);
@@ -941,7 +941,7 @@ DENSE_STORAGE* cast_copy(const DENSE_STORAGE* rhs, dtype_t new_dtype) {
 
   nm_dense_storage_register(lhs);
 
-	// Ensure that allocation worked before copying.
+  // 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      = NM_ALLOCA_N(size_t, rhs->dim);
@@ -956,7 +956,7 @@ DENSE_STORAGE* cast_copy(const DENSE_STORAGE* rhs, dtype_t new_dtype) {
       LDType* lhs_els          = reinterpret_cast<LDType*>(lhs->elements);
 
       for (size_t i = 0; i < count; ++i)
-    	  lhs_els[i] = rhs_els[i];
+        lhs_els[i] = rhs_els[i];
     }
   }
 
@@ -977,7 +977,7 @@ bool eqeq(const DENSE_STORAGE* left, const DENSE_STORAGE* right) {
   bool result = true;
   /* FIXME: Very strange behavior! The GC calls the method directly with non-initialized data. */
 
-  LDType* left_elements	  = (LDType*)left->elements;
+  LDType* left_elements    = (LDType*)left->elements;
   RDType* right_elements  = (RDType*)right->elements;
 
   // Copy elements in temp matrix if you have reference to the right.
@@ -1017,39 +1017,39 @@ bool eqeq(const DENSE_STORAGE* left, const DENSE_STORAGE* right) {
 
 template <typename DType>
 bool is_hermitian(const DENSE_STORAGE* mat, int lda) {
-	unsigned int i, j;
-	register DType complex_conj;
+  unsigned int i, j;
+  register DType complex_conj;
 
-	const DType* els = (DType*) mat->elements;
+  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 + i];
-			complex_conj.i	= -complex_conj.i;
+  for (i = mat->shape[0]; i-- > 0;) {
+    for (j = i + 1; j < mat->shape[1]; ++j) {
+      complex_conj    = els[j*lda + i];
+      complex_conj.i  = -complex_conj.i;
 
-			if (els[i*lda+j] != complex_conj) {
-	      return false;
-	    }
-		}
-	}
+      if (els[i*lda+j] != complex_conj) {
+        return false;
+      }
+    }
+  }
 
-	return true;
+  return true;
 }
 
 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]) {
-	      return false;
-	    }
-		}
-	}
-
-	return true;
+  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]) {
+        return false;
+      }
+    }
+  }
+
+  return true;
 }
 
 

data/ext/nmatrix/storage/dense/dense.h

@@ -32,7 +32,8 @@
  * Standard Includes
  */
 
-#include <stdlib.h>
+#include <ruby.h>
+#include <cstdlib>
 
 /*
  * Project Includes
@@ -69,10 +70,10 @@ extern "C" {
 // Lifecycle //
 ///////////////
 
-DENSE_STORAGE*	nm_dense_storage_create(nm::dtype_t dtype, size_t* shape, size_t dim, void* elements, size_t elements_length);
-void						nm_dense_storage_delete(STORAGE* s);
-void						nm_dense_storage_delete_ref(STORAGE* s);
-void						nm_dense_storage_mark(STORAGE*);
+DENSE_STORAGE*  nm_dense_storage_create(nm::dtype_t dtype, size_t* shape, size_t dim, void* elements, size_t elements_length);
+void            nm_dense_storage_delete(STORAGE* s);
+void            nm_dense_storage_delete_ref(STORAGE* s);
+void            nm_dense_storage_mark(STORAGE*);
 void            nm_dense_storage_register(const STORAGE* s);
 void            nm_dense_storage_unregister(const STORAGE* s);
 
@@ -86,8 +87,8 @@ 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(const STORAGE* s, SLICE* slice);
-void*	nm_dense_storage_ref(const STORAGE* s, SLICE* slice);
+void*  nm_dense_storage_get(const STORAGE* s, SLICE* slice);
+void*  nm_dense_storage_ref(const STORAGE* s, SLICE* slice);
 void  nm_dense_storage_set(VALUE left, SLICE* slice, VALUE right);
 
 ///////////

data/ext/nmatrix/storage/list/list.cpp

@@ -85,7 +85,7 @@ public:
     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;
+      init_obj_ = s->dtype == nm::RUBYOBJ ? *reinterpret_cast<VALUE*>(s->default_val) : nm::rubyobj_from_cval(s->default_val, s->dtype).rval;
     }
     nm_register_value(&init_obj_);
   }
@@ -181,7 +181,7 @@ static void map_empty_stored_r(RecurseData& result, RecurseData& s, LIST* x, con
       if (!val->first) nm::list::del(val, 0);
       else {
         nm_list_storage_register_list(val, rec-1);
-	temp_vals.push_front(val);
+  temp_vals.push_front(val);
         nm::list::insert_helper(x, xcurr, curr->key - offset, val);
       }
       curr = curr->next;
@@ -193,7 +193,7 @@ static void map_empty_stored_r(RecurseData& result, RecurseData& s, LIST* x, con
     while (curr) {
       VALUE val, s_val;
       if (s.dtype() == nm::RUBYOBJ) s_val = (*reinterpret_cast<nm::RubyObject*>(curr->val)).rval;
-      else                          s_val = rubyobj_from_cval(curr->val, s.dtype()).rval;
+      else                          s_val = nm::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);
@@ -265,7 +265,7 @@ static void map_stored_r(RecurseData& result, RecurseData& left, LIST* x, const
       size_t key;
       VALUE  val;
 
-      val   = rb_yield_values(1, left.dtype() == nm::RUBYOBJ ? *reinterpret_cast<VALUE*>(lcurr->val) : rubyobj_from_cval(lcurr->val, left.dtype()).rval);
+      val   = rb_yield_values(1, left.dtype() == nm::RUBYOBJ ? *reinterpret_cast<VALUE*>(lcurr->val) : nm::rubyobj_from_cval(lcurr->val, left.dtype()).rval);
       key   = lcurr->key - left.offset(rec);
       lcurr = lcurr->next;
 
@@ -355,15 +355,15 @@ static void map_merged_stored_r(RecurseData& result, RecurseData& left, RecurseD
       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());
+        val   = rb_yield_values(2, nm::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);
+        val   = rb_yield_values(2, left.init_obj(), nm::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);
+        val   = rb_yield_values(2, nm::rubyobj_from_cval(lcurr->val, left.dtype()).rval, nm::rubyobj_from_cval(rcurr->val, right.dtype()).rval);
         key   = lcurr->key - left.offset(rec);
         lcurr = lcurr->next;
         rcurr = rcurr->next;
@@ -855,7 +855,7 @@ static void each_with_indices_r(nm::list_storage::RecurseData& s, const LIST* l,
         rb_ary_unshift(stack, s.dtype() == nm::RUBYOBJ ? *reinterpret_cast<VALUE*>(s.init()) : s.init_obj());
 
       } 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);
+        rb_ary_unshift(stack, s.dtype() == nm::RUBYOBJ ? *reinterpret_cast<VALUE*>(curr->val) : nm::rubyobj_from_cval(curr->val, s.dtype()).rval);
 
         curr = curr->next;
       }
@@ -902,7 +902,7 @@ static void each_stored_with_indices_r(nm::list_storage::RecurseData& s, const L
       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);
+      rb_ary_unshift(stack, s.dtype() == nm::RUBYOBJ ? *reinterpret_cast<VALUE*>(curr->val) : nm::rubyobj_from_cval(curr->val, s.dtype()).rval);
       // yield to the whole stack (value, i, j, k, ...)
       rb_yield_splat(stack);
 
@@ -975,7 +975,7 @@ VALUE nm_list_map_stored(VALUE left, VALUE init) {
     init = rb_yield_values(1, sdata.init_obj());
     nm_register_value(&init);
   }
-	// Allocate a new shape array for the resulting matrix.
+  // Allocate a new shape array for the resulting matrix.
   void* init_val = NM_ALLOC(VALUE);
   memcpy(init_val, &init, sizeof(VALUE));
   nm_register_value(&*reinterpret_cast<VALUE*>(init_val));
@@ -1316,12 +1316,12 @@ 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_r, bool, nm::list_storage::RecurseData& left, nm::list_storage::RecurseData& right, const LIST* l, const LIST* r, size_t rec)
+  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](ldata, rdata, ldata.top_level_list(), rdata.top_level_list(), ldata.dim()-1);
+  return ttable[left->dtype][right->dtype](ldata, rdata, ldata.top_level_list(), rdata.top_level_list(), ldata.dim()-1);
 }
 
 //////////
@@ -1349,7 +1349,7 @@ STORAGE* nm_list_storage_matrix_multiply(const STORAGE_PAIR& casted_storage, siz
 VALUE nm_list_storage_to_hash(const LIST_STORAGE* s, const nm::dtype_t dtype) {
   nm_list_storage_register(s);
   // Get the default value for the list storage.
-  VALUE default_value = rubyobj_from_cval(s->default_val, dtype).rval;
+  VALUE default_value = nm::rubyobj_from_cval(s->default_val, dtype).rval;
   nm_list_storage_unregister(s);
   // Recursively copy each dimension of the matrix into a nested hash.
   return nm_list_copy_to_hash(s->rows, dtype, s->dim - 1, default_value);
@@ -1390,7 +1390,7 @@ size_t nm_list_storage_count_nd_elements(const LIST_STORAGE* s) {
   size_t count = 0;
 
   if (s->dim != 2) {
-  	rb_raise(rb_eNotImpError, "non-diagonal element counting only defined for dim = 2");
+    rb_raise(rb_eNotImpError, "non-diagonal element counting only defined for dim = 2");
   }
 
   for (i_curr = s->rows->first; i_curr; i_curr = i_curr->next) {
@@ -1401,7 +1401,7 @@ size_t nm_list_storage_count_nd_elements(const LIST_STORAGE* s) {
       int j = j_curr->key - s->offset[1];
       if (j < 0 || j >= (int)s->shape[1]) continue;
 
-      if (i != j)  	++count;
+      if (i != j)    ++count;
     }
   }
 
@@ -1621,7 +1621,7 @@ extern "C" {
    */
   VALUE nm_list_default_value(VALUE self) {
     NM_CONSERVATIVE(nm_register_value(&self));
-    VALUE to_return = (NM_DTYPE(self) == nm::RUBYOBJ) ? *reinterpret_cast<VALUE*>(NM_DEFAULT_VAL(self)) : rubyobj_from_cval(NM_DEFAULT_VAL(self), NM_DTYPE(self)).rval;
+    VALUE to_return = (NM_DTYPE(self) == nm::RUBYOBJ) ? *reinterpret_cast<VALUE*>(NM_DEFAULT_VAL(self)) : nm::rubyobj_from_cval(NM_DEFAULT_VAL(self), NM_DTYPE(self)).rval;
     NM_CONSERVATIVE(nm_unregister_value(&self));
     return to_return;
   }

data/ext/nmatrix/storage/list/list.h

@@ -33,7 +33,8 @@
  * Standard Includes
  */
 
-#include <stdlib.h>
+#include <ruby.h>
+#include <cstdlib>
 #include <list>
 /*
  * Project Includes
@@ -69,17 +70,17 @@ extern "C" {
   // Lifecycle //
   ///////////////
 
-  LIST_STORAGE*	nm_list_storage_create(nm::dtype_t dtype, size_t* shape, size_t dim, void* init_val);
-  void					nm_list_storage_delete(STORAGE* s);
-  void					nm_list_storage_delete_ref(STORAGE* s);
-  void					nm_list_storage_mark(STORAGE*);
+  LIST_STORAGE*  nm_list_storage_create(nm::dtype_t dtype, size_t* shape, size_t dim, void* init_val);
+  void          nm_list_storage_delete(STORAGE* s);
+  void          nm_list_storage_delete_ref(STORAGE* s);
+  void          nm_list_storage_mark(STORAGE*);
   void          nm_list_storage_register(const STORAGE* s);
   void          nm_list_storage_unregister(const STORAGE* s);
   void          nm_list_storage_register_list(const LIST* l, size_t recursions);
   void          nm_list_storage_unregister_list(const LIST* l, size_t recursions);
   void          nm_list_storage_register_node(const NODE* n);
   void          nm_list_storage_unregister_node(const NODE* n);
-  void		      nm_list_storage_completely_unregister_node(const NODE* curr);
+  void          nm_list_storage_completely_unregister_node(const NODE* curr);
   ///////////////
   // Accessors //
   ///////////////

data/ext/nmatrix/storage/storage.cpp

@@ -50,9 +50,9 @@
 extern "C" {
 
 const char* const STYPE_NAMES[nm::NUM_STYPES] = {
-	"dense",
-	"list",
-	"yale"
+  "dense",
+  "list",
+  "yale"
 };
 
 } // end extern "C" block
@@ -152,14 +152,14 @@ DENSE_STORAGE* create_from_yale_storage(const YALE_STORAGE* rhs, dtype_t l_dtype
 
     if (rhs_ija[ri] == rhs_ija[ri+1]) { // Check boundaries of row: is row empty? (Yes.)
 
-			// Write zeros in each column.
-			for (size_t j = 0; j < shape[1]; ++j) { // Move to next dense position.
+      // Write zeros in each column.
+      for (size_t j = 0; j < shape[1]; ++j) { // Move to next dense position.
 
         // 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;
+        else                          lhs_elements[pos] = LCAST_ZERO;
 
-				++pos;
+        ++pos;
       }
 
     } else {  // Row contains entries: write those in each column, interspersed with zeros.
@@ -170,8 +170,8 @@ DENSE_STORAGE* create_from_yale_storage(const YALE_STORAGE* rhs, dtype_t l_dtype
       // What column is it?
       IType next_stored_rj = rhs_ija[ija];
 
-			for (size_t j = 0; j < shape[1]; ++j) {
-			  IType rj = j + rhs->offset[1];
+      for (size_t j = 0; j < shape[1]; ++j) {
+        IType rj = j + rhs->offset[1];
 
         if (rj == ri) { // at a diagonal in RHS
           lhs_elements[pos] = static_cast<LDType>(rhs_a[ri]);
@@ -184,7 +184,7 @@ DENSE_STORAGE* create_from_yale_storage(const YALE_STORAGE* rhs, dtype_t l_dtype
 
           // Increment to next column ID (or go off the end).
           if (ija < rhs_ija[ri+1]) next_stored_rj = rhs_ija[ija];
-          else               	     next_stored_rj = rhs->src->shape[1];
+          else                      next_stored_rj = rhs->src->shape[1];
 
         } else { // rj < next_stored_rj
 
@@ -219,14 +219,14 @@ static void cast_copy_list_contents(LDType* lhs, const LIST* rhs, RDType* defaul
     if (!curr || (curr->key > (size_t)(last_key+1))) {
 
       if (recursions == 0)  lhs[pos] = static_cast<LDType>(*default_val);
-      else               		cast_copy_list_default<LDType,RDType>(lhs, default_val, pos, shape, dim, max_elements, recursions-1);
+      else                   cast_copy_list_default<LDType,RDType>(lhs, default_val, pos, shape, dim, max_elements, recursions-1);
 
       ++last_key;
 
     } else {
 
       if (recursions == 0)  lhs[pos] = static_cast<LDType>(*reinterpret_cast<RDType*>(curr->val));
-      else                	cast_copy_list_contents<LDType,RDType>(lhs, (const LIST*)(curr->val),
+      else                  cast_copy_list_contents<LDType,RDType>(lhs, (const LIST*)(curr->val),
                                                                                          default_val, pos, shape, dim, max_elements, recursions-1);
 
       last_key = curr->key;
@@ -247,7 +247,7 @@ static void cast_copy_list_default(LDType* lhs, RDType* default_val, size_t& pos
   for (size_t i = 0; i < shape[dim - 1 - recursions]; ++i, ++pos) {
 
     if (recursions == 0)    lhs[pos] = static_cast<LDType>(*default_val);
-    else                  	cast_copy_list_default<LDType,RDType>(lhs, default_val, pos, shape, dim, max_elements, recursions-1);
+    else                    cast_copy_list_default<LDType,RDType>(lhs, default_val, pos, shape, dim, max_elements, recursions-1);
 
   }
 
@@ -283,13 +283,13 @@ LIST_STORAGE* create_from_dense_storage(const DENSE_STORAGE* rhs, dtype_t l_dtyp
   // set list default_val to 0
   if (init) *l_default_val = *reinterpret_cast<LDType*>(init);
   else {
-    if (l_dtype == RUBYOBJ)  	*l_default_val = INT2FIX(0);
-    else    	                *l_default_val = 0;
+    if (l_dtype == RUBYOBJ)    *l_default_val = INT2FIX(0);
+    else                      *l_default_val = 0;
   }
 
   // need test default value for comparing to elements in dense matrix
   if (rhs->dtype == l_dtype || rhs->dtype != RUBYOBJ) *r_default_val = static_cast<RDType>(*l_default_val);
-  else                                                *r_default_val = rubyobj_from_cval(l_default_val, l_dtype);
+  else                                                *r_default_val = nm::rubyobj_from_cval(l_default_val, l_dtype);
 
 
   LIST_STORAGE* lhs = nm_list_storage_create(l_dtype, shape, rhs->dim, l_default_val);
@@ -382,10 +382,10 @@ LIST_STORAGE* create_from_yale_storage(const YALE_STORAGE* rhs, dtype_t l_dtype)
           // 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);
+          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!
+          // don't add again!
           add_diag = false;
         }
 
@@ -393,21 +393,21 @@ LIST_STORAGE* create_from_yale_storage(const YALE_STORAGE* rhs, dtype_t l_dtype)
         insert_val  = NM_ALLOC_N(LDType, 1);
         *insert_val = static_cast<LDType>(rhs_a[ija]);
 
-        if (last_added)    	last_added = list::insert_after(last_added, j, insert_val);
-        else              	last_added = list::insert(curr_row, false, j, 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.
+        // still haven't added the diagonal.
         insert_val         = NM_ALLOC_N(LDType, 1);
         *insert_val        = static_cast<LDType>(rhs_a[ri]);
 
         // insert the item in the list at the appropriate location
-        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);
+        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.
       }
@@ -417,7 +417,7 @@ LIST_STORAGE* create_from_yale_storage(const YALE_STORAGE* rhs, dtype_t l_dtype)
       else                  last_row_added = list::insert(lhs->rows, false, i, curr_row);
     }
 
-		// end of walk through rows
+    // end of walk through rows
   }
 
   nm_yale_storage_unregister(rhs);
@@ -443,17 +443,17 @@ static bool cast_copy_contents_dense(LIST* lhs, const RDType* rhs, RDType* zero,
   for (coords[dim-1-recursions] = 0; coords[dim-1-recursions] < shape[dim-1-recursions]; ++coords[dim-1-recursions], ++pos) {
 
     if (recursions == 0) {
-    	// create nodes
+      // create nodes
 
       if (rhs[pos] != *zero) {
-      	// is not zero
+        // is not zero
 
         // Create a copy of our value that we will insert in the list
         LDType* insert_value = NM_ALLOC_N(LDType, 1);
         *insert_value        = static_cast<LDType>(rhs[pos]);
 
         if (!lhs->first)    prev = list::insert(lhs, false, coords[dim-1-recursions], insert_value);
-        else               	prev = list::insert_after(prev, coords[dim-1-recursions], insert_value);
+        else                 prev = list::insert_after(prev, coords[dim-1-recursions], insert_value);
 
         added = true;
       }
@@ -465,9 +465,9 @@ static bool cast_copy_contents_dense(LIST* lhs, const RDType* rhs, RDType* zero,
 
       added_list = list_storage::cast_copy_contents_dense<LDType,RDType>(sub_list, rhs, zero, pos, coords, shape, dim, recursions-1);
 
-      if (!added_list)      	list::del(sub_list, recursions-1);
-      else if (!lhs->first)  	prev = list::insert(lhs, false, coords[dim-1-recursions], sub_list);
-      else                  	prev = list::insert_after(prev, coords[dim-1-recursions], sub_list);
+      if (!added_list)        list::del(sub_list, recursions-1);
+      else if (!lhs->first)    prev = list::insert(lhs, false, coords[dim-1-recursions], sub_list);
+      else                    prev = list::insert_after(prev, coords[dim-1-recursions], sub_list);
 
       // added = (added || added_list);
     }
@@ -512,7 +512,7 @@ namespace yale_storage { // FIXME: Move to yale.cpp
     for (size_t i = rhs->shape[0]; i-- > 0;) {
       for (size_t j = rhs->shape[1]; j-- > 0;) {
         pos = rhs->stride[0]*(i + rhs->offset[0]) + rhs->stride[1]*(j + rhs->offset[1]);
-        if (i != j && rhs_elements[pos] != R_INIT)	++ndnz;
+        if (i != j && rhs_elements[pos] != R_INIT)  ++ndnz;
 
         // move forward 1 position in dense matrix elements array
       }