nmatrix 0.0.2 → 0.0.3

data/ext/nmatrix/storage/storage.cpp

@@ -328,10 +328,10 @@ LIST_STORAGE* create_from_yale_storage(const YALE_STORAGE* rhs, dtype_t l_dtype)
 
   RIType* rhs_ija  = reinterpret_cast<RIType*>(rhs->ija);
 
-  NODE *last_added = NULL, *last_row_added = NULL;
-
+  NODE *last_row_added = NULL;
   // Walk through rows and columns as if RHS were a dense matrix
   for (RIType i = 0; i < rhs->shape[0]; ++i) {
+    NODE *last_added = NULL;
 
     // Get boundaries of beginning and end of row
     RIType ija      = rhs_ija[i],
@@ -385,8 +385,8 @@ LIST_STORAGE* create_from_yale_storage(const YALE_STORAGE* rhs, dtype_t l_dtype)
       }
 
       // Now add the list at the appropriate location
-      if (last_row_added)  	last_row_added = list::insert_after(last_row_added, i, curr_row);
-      else                 	last_row_added = list::insert(lhs->rows, false, i, curr_row);
+      if (last_row_added)   last_row_added = list::insert_after(last_row_added, i, curr_row);
+      else                  last_row_added = list::insert(lhs->rows, false, i, curr_row);
     }
 
 		// end of walk through rows
@@ -531,7 +531,7 @@ namespace yale_storage { // FIXME: Move to yale.cpp
    * Creation of yale storage from list storage.
    */
   template <typename LDType, typename RDType, typename LIType>
-  YALE_STORAGE* create_from_list_storage(const LIST_STORAGE* rhs, dtype_t l_dtype) {
+  YALE_STORAGE* create_from_list_storage(const LIST_STORAGE* rhs, nm::dtype_t l_dtype) {
     if (rhs->dim != 2) rb_raise(nm_eStorageTypeError, "can only convert matrices of dim 2 to yale");
 
     if ((rhs->dtype == RUBYOBJ and (*reinterpret_cast<RubyObject*>(rhs->default_val)) == RubyObject(INT2FIX(0)))
@@ -611,43 +611,43 @@ extern "C" {
 
 
 
-  STORAGE* nm_yale_storage_from_dense(const STORAGE* right, dtype_t l_dtype) {
-    NAMED_LRI_DTYPE_TEMPLATE_TABLE(ttable, nm::yale_storage::create_from_dense_storage, YALE_STORAGE*, const DENSE_STORAGE* rhs, dtype_t l_dtype);
+  STORAGE* nm_yale_storage_from_dense(const STORAGE* right, nm::dtype_t l_dtype) {
+    NAMED_LRI_DTYPE_TEMPLATE_TABLE(ttable, nm::yale_storage::create_from_dense_storage, YALE_STORAGE*, const DENSE_STORAGE* rhs, nm::dtype_t l_dtype);
 
-    itype_t itype = nm_yale_storage_itype((const YALE_STORAGE*)right);
+    nm::itype_t itype = nm_yale_storage_itype((const YALE_STORAGE*)right);
 
     return (STORAGE*)ttable[l_dtype][right->dtype][itype]((const DENSE_STORAGE*)right, l_dtype);
   }
 
-  STORAGE* nm_yale_storage_from_list(const STORAGE* right, dtype_t l_dtype) {
-    NAMED_LRI_DTYPE_TEMPLATE_TABLE(ttable, nm::yale_storage::create_from_list_storage, YALE_STORAGE*, const LIST_STORAGE* rhs, dtype_t l_dtype);
+  STORAGE* nm_yale_storage_from_list(const STORAGE* right, nm::dtype_t l_dtype) {
+    NAMED_LRI_DTYPE_TEMPLATE_TABLE(ttable, nm::yale_storage::create_from_list_storage, YALE_STORAGE*, const LIST_STORAGE* rhs, nm::dtype_t l_dtype);
 
-    itype_t itype = nm_yale_storage_itype((const YALE_STORAGE*)right);
+    nm::itype_t itype = nm_yale_storage_itype((const YALE_STORAGE*)right);
 
     return (STORAGE*)ttable[l_dtype][right->dtype][itype]((const LIST_STORAGE*)right, l_dtype);
   }
 
-  STORAGE* nm_dense_storage_from_list(const STORAGE* right, dtype_t l_dtype) {
-    NAMED_LR_DTYPE_TEMPLATE_TABLE(ttable, nm::dense_storage::create_from_list_storage, DENSE_STORAGE*, const LIST_STORAGE* rhs, dtype_t l_dtype);
+  STORAGE* nm_dense_storage_from_list(const STORAGE* right, nm::dtype_t l_dtype) {
+    NAMED_LR_DTYPE_TEMPLATE_TABLE(ttable, nm::dense_storage::create_from_list_storage, DENSE_STORAGE*, const LIST_STORAGE* rhs, nm::dtype_t l_dtype);
 
     return (STORAGE*)ttable[l_dtype][right->dtype]((const LIST_STORAGE*)right, l_dtype);
   }
 
-  STORAGE* nm_dense_storage_from_yale(const STORAGE* right, dtype_t l_dtype) {
-    NAMED_LRI_DTYPE_TEMPLATE_TABLE(ttable, nm::dense_storage::create_from_yale_storage, DENSE_STORAGE*, const YALE_STORAGE* rhs, dtype_t l_dtype);
+  STORAGE* nm_dense_storage_from_yale(const STORAGE* right, nm::dtype_t l_dtype) {
+    NAMED_LRI_DTYPE_TEMPLATE_TABLE(ttable, nm::dense_storage::create_from_yale_storage, DENSE_STORAGE*, const YALE_STORAGE* rhs, nm::dtype_t l_dtype);
 
     const YALE_STORAGE* casted_right = reinterpret_cast<const YALE_STORAGE*>(right);
     return reinterpret_cast<STORAGE*>(ttable[l_dtype][right->dtype][casted_right->itype](casted_right, l_dtype));
   }
 
-  STORAGE* nm_list_storage_from_dense(const STORAGE* right, dtype_t l_dtype) {
-    NAMED_LR_DTYPE_TEMPLATE_TABLE(ttable, nm::list_storage::create_from_dense_storage, LIST_STORAGE*, const DENSE_STORAGE*, dtype_t);
+  STORAGE* nm_list_storage_from_dense(const STORAGE* right, nm::dtype_t l_dtype) {
+    NAMED_LR_DTYPE_TEMPLATE_TABLE(ttable, nm::list_storage::create_from_dense_storage, LIST_STORAGE*, const DENSE_STORAGE*, nm::dtype_t);
 
     return (STORAGE*)ttable[l_dtype][right->dtype]((DENSE_STORAGE*)right, l_dtype);
   }
 
-  STORAGE* nm_list_storage_from_yale(const STORAGE* right, dtype_t l_dtype) {
-    NAMED_LRI_DTYPE_TEMPLATE_TABLE(ttable, nm::list_storage::create_from_yale_storage, LIST_STORAGE*, const YALE_STORAGE* rhs, dtype_t l_dtype);
+  STORAGE* nm_list_storage_from_yale(const STORAGE* right, nm::dtype_t l_dtype) {
+    NAMED_LRI_DTYPE_TEMPLATE_TABLE(ttable, nm::list_storage::create_from_yale_storage, LIST_STORAGE*, const YALE_STORAGE* rhs, nm::dtype_t l_dtype);
 
     const YALE_STORAGE* casted_right = reinterpret_cast<const YALE_STORAGE*>(right);
 

data/ext/nmatrix/storage/storage.h

@@ -53,11 +53,11 @@
  * Macros
  */
 
-#define NMATRIX_DTYPE_IS_COMPLEX(s)		((s->dtype == COMPLEX64) or (s->dtype == COMPLEX128))
-#define NMATRIX_DTYPE_IS_FLOAT(s)			((s->dtype == FLOAT32) or (s->dtype == FLOAT64))
-#define NMATRIX_DTYPE_IS_INTEGER(s)		(s->dtype <= INT64)
-#define NMATRIX_DTYPE_IS_RATIONAL(s)	((s->dtype == RATIONAL32) or (s->dtype == RATIONAL64) or (s->dtype == RATIONAL128))
-#define NMATRIX_DTYPE_IS_RUBYOBJ(s)		(s->dtype == RUBYOBJ)
+#define NMATRIX_DTYPE_IS_COMPLEX(s)		((s->dtype == nm::COMPLEX64) or (s->dtype == nm::COMPLEX128))
+#define NMATRIX_DTYPE_IS_FLOAT(s)			((s->dtype == nm::FLOAT32) or (s->dtype == nm::FLOAT64))
+#define NMATRIX_DTYPE_IS_INTEGER(s)		(s->dtype <= nm::INT64)
+#define NMATRIX_DTYPE_IS_RATIONAL(s)	((s->dtype == nm::RATIONAL32) or (s->dtype == nm::RATIONAL64) or (s->dtype == nm::RATIONAL128))
+#define NMATRIX_DTYPE_IS_RUBYOBJ(s)		(s->dtype == nm::RUBYOBJ)
 
 
 /*
@@ -86,12 +86,12 @@ extern "C" {
   // Copying and Casting //
   /////////////////////////
 
-  STORAGE*	  nm_dense_storage_from_list(const STORAGE* right, dtype_t l_dtype);
-  STORAGE*	  nm_dense_storage_from_yale(const STORAGE* right, dtype_t l_dtype);
-  STORAGE*		nm_list_storage_from_dense(const STORAGE* right, dtype_t l_dtype);
-  STORAGE*		nm_list_storage_from_yale(const STORAGE* right, dtype_t l_dtype);
-  STORAGE*		nm_yale_storage_from_list(const STORAGE* right, dtype_t l_dtype);
-  STORAGE*		nm_yale_storage_from_dense(const STORAGE* right, dtype_t l_dtype);
+  STORAGE*	  nm_dense_storage_from_list(const STORAGE* right, nm::dtype_t l_dtype);
+  STORAGE*	  nm_dense_storage_from_yale(const STORAGE* right, nm::dtype_t l_dtype);
+  STORAGE*		nm_list_storage_from_dense(const STORAGE* right, nm::dtype_t l_dtype);
+  STORAGE*		nm_list_storage_from_yale(const STORAGE* right,  nm::dtype_t l_dtype);
+  STORAGE*		nm_yale_storage_from_list(const STORAGE* right,  nm::dtype_t l_dtype);
+  STORAGE*		nm_yale_storage_from_dense(const STORAGE* right, nm::dtype_t l_dtype);
 
 } // end of extern "C" block
 

data/ext/nmatrix/storage/yale.cpp

@@ -76,8 +76,8 @@
  */
 
 extern "C" {
-  static YALE_STORAGE*  nm_copy_alloc_struct(const YALE_STORAGE* rhs, const dtype_t new_dtype, const size_t new_capacity, const size_t new_size);
-  static YALE_STORAGE*	alloc(dtype_t dtype, size_t* shape, size_t dim);
+  static YALE_STORAGE*  nm_copy_alloc_struct(const YALE_STORAGE* rhs, const nm::dtype_t new_dtype, const size_t new_capacity, const size_t new_size);
+  static YALE_STORAGE*	alloc(nm::dtype_t dtype, size_t* shape, size_t dim);
 
   /* Ruby-accessible functions */
   static VALUE nm_size(VALUE self);
@@ -112,9 +112,6 @@ static void						increment_ia_after(YALE_STORAGE* s, IType ija_size, IType i, IT
 template <typename IType>
 static IType				  insert_search(YALE_STORAGE* s, IType left, IType right, IType key, bool* found);
 
-template <typename IType>
-static inline size_t  get_size(const YALE_STORAGE* storage);
-
 template <typename DType, typename IType>
 static char           vector_insert(YALE_STORAGE* s, size_t pos, size_t* j, DType* val, size_t n, bool struct_only);
 
@@ -1227,8 +1224,8 @@ bool nm_yale_storage_eqeq(const STORAGE* left, const STORAGE* right) {
 /*
  * Copy constructor for changing dtypes. (C accessor)
  */
-STORAGE* nm_yale_storage_cast_copy(const STORAGE* rhs, dtype_t new_dtype) {
-  NAMED_LRI_DTYPE_TEMPLATE_TABLE(ttable, nm::yale_storage::cast_copy, YALE_STORAGE*, const YALE_STORAGE* rhs, dtype_t new_dtype);
+STORAGE* nm_yale_storage_cast_copy(const STORAGE* rhs, nm::dtype_t new_dtype) {
+  NAMED_LRI_DTYPE_TEMPLATE_TABLE(ttable, nm::yale_storage::cast_copy, YALE_STORAGE*, const YALE_STORAGE* rhs, nm::dtype_t new_dtype);
 
   const YALE_STORAGE* casted_rhs = reinterpret_cast<const YALE_STORAGE*>(rhs);
 
@@ -1238,7 +1235,7 @@ STORAGE* nm_yale_storage_cast_copy(const STORAGE* rhs, dtype_t new_dtype) {
 /*
  * Returns size of Yale storage as a size_t (no matter what the itype is). (C accessor)
  */
-inline size_t nm_yale_storage_get_size(const YALE_STORAGE* storage) {
+size_t nm_yale_storage_get_size(const YALE_STORAGE* storage) {
   NAMED_ITYPE_TEMPLATE_TABLE(ttable, nm::yale_storage::get_size, size_t, const YALE_STORAGE* storage);
 
   return ttable[storage->itype](storage);
@@ -1247,8 +1244,8 @@ inline size_t nm_yale_storage_get_size(const YALE_STORAGE* storage) {
 /*
  * C accessor for allocating a yale storage object for cast-copying. Copies the IJA vector, does not copy the A vector.
  */
-static YALE_STORAGE* nm_copy_alloc_struct(const YALE_STORAGE* rhs, const dtype_t new_dtype, const size_t new_capacity, const size_t new_size) {
-  NAMED_ITYPE_TEMPLATE_TABLE(ttable, nm::yale_storage::copy_alloc_struct, YALE_STORAGE*, const YALE_STORAGE* rhs, const dtype_t new_dtype, const size_t new_capacity, const size_t new_size);
+static YALE_STORAGE* nm_copy_alloc_struct(const YALE_STORAGE* rhs, const nm::dtype_t new_dtype, const size_t new_capacity, const size_t new_size) {
+  NAMED_ITYPE_TEMPLATE_TABLE(ttable, nm::yale_storage::copy_alloc_struct, YALE_STORAGE*, const YALE_STORAGE* rhs, const nm::dtype_t new_dtype, const size_t new_capacity, const size_t new_size);
 
   return ttable[rhs->itype](rhs, new_dtype, new_capacity, new_size);
 }
@@ -1291,15 +1288,15 @@ STORAGE* nm_yale_storage_matrix_multiply(const STORAGE_PAIR& casted_storage, siz
 /*
  * Documentation goes here.
  */
-STORAGE* nm_yale_storage_ew_op(nm::ewop_t op, const STORAGE* left, const STORAGE* right) {
-	OP_ITYPE_DTYPE_TEMPLATE_TABLE(nm::yale_storage::ew_op, YALE_STORAGE*, const YALE_STORAGE*, const YALE_STORAGE*, dtype_t);
+STORAGE* nm_yale_storage_ew_op(nm::ewop_t op, const STORAGE* left, const STORAGE* right, VALUE scalar) {
+	OP_ITYPE_DTYPE_TEMPLATE_TABLE(nm::yale_storage::ew_op, YALE_STORAGE*, const YALE_STORAGE*, const YALE_STORAGE*, nm::dtype_t);
 	
 	YALE_STORAGE* new_l = NULL, * new_r = NULL;
 	YALE_STORAGE* result;
 	
 	const YALE_STORAGE* casted_l, * casted_r;
 	
-	dtype_t new_dtype;
+	nm::dtype_t new_dtype;
 	
 	if (left->dtype != right->dtype) {
 		
@@ -1365,7 +1362,7 @@ STORAGE* nm_yale_storage_ew_op(nm::ewop_t op, const STORAGE* left, const STORAGE
  * create the storage.
  */
 
-YALE_STORAGE* nm_yale_storage_create(dtype_t dtype, size_t* shape, size_t dim, size_t init_capacity) {
+YALE_STORAGE* nm_yale_storage_create(nm::dtype_t dtype, size_t* shape, size_t dim, size_t init_capacity) {
   YALE_STORAGE* s;
   size_t max_capacity;
 
@@ -1427,9 +1424,9 @@ void nm_yale_storage_mark(void* storage_base) {
   YALE_STORAGE* storage = (YALE_STORAGE*)storage_base;
   size_t i;
 
-  if (storage && storage->dtype == RUBYOBJ) {
+  if (storage && storage->dtype == nm::RUBYOBJ) {
   	for (i = storage->capacity; i-- > 0;) {
-      rb_gc_mark(*((VALUE*)((char*)(storage->a) + i*DTYPE_SIZES[RUBYOBJ])));
+      rb_gc_mark(*((VALUE*)((char*)(storage->a) + i*DTYPE_SIZES[nm::RUBYOBJ])));
     }
   }
 }
@@ -1437,7 +1434,7 @@ void nm_yale_storage_mark(void* storage_base) {
 /*
  * Allocates and initializes the basic struct (but not the IJA or A vectors).
  */
-static YALE_STORAGE* alloc(dtype_t dtype, size_t* shape, size_t dim) {
+static YALE_STORAGE* alloc(nm::dtype_t dtype, size_t* shape, size_t dim) {
   YALE_STORAGE* s;
 
   s = ALLOC( YALE_STORAGE );
@@ -1451,14 +1448,14 @@ static YALE_STORAGE* alloc(dtype_t dtype, size_t* shape, size_t dim) {
   return s;
 }
 
-YALE_STORAGE* nm_yale_storage_create_from_old_yale(dtype_t dtype, size_t* shape, void* ia, void* ja, void* a, dtype_t from_dtype) {
+YALE_STORAGE* nm_yale_storage_create_from_old_yale(nm::dtype_t dtype, size_t* shape, void* ia, void* ja, void* a, nm::dtype_t from_dtype) {
 
-  NAMED_LRI_DTYPE_TEMPLATE_TABLE(ttable, nm::yale_storage::create_from_old_yale, YALE_STORAGE*, dtype_t dtype, size_t* shape, void* r_ia, void* r_ja, void* r_a);
+  NAMED_LRI_DTYPE_TEMPLATE_TABLE(ttable, nm::yale_storage::create_from_old_yale, YALE_STORAGE*, nm::dtype_t dtype, size_t* shape, void* r_ia, void* r_ja, void* r_a);
 
   // With C++ templates, we don't want to have a 4-parameter template. That would be LDType, RDType, LIType, RIType.
   // We can prevent that by copying ia and ja into the correct itype (if necessary) before passing them to the yale
   // copy constructor.
-  itype_t to_itype = nm_yale_storage_itype_by_shape(shape);
+  nm::itype_t to_itype = nm_yale_storage_itype_by_shape(shape);
 
   return ttable[dtype][from_dtype][to_itype](dtype, shape, ia, ja, a);
 

data/ext/nmatrix/storage/yale.h

@@ -86,8 +86,8 @@ extern "C" {
   // Lifecycle //
   ///////////////
 
-  YALE_STORAGE* nm_yale_storage_create(dtype_t dtype, size_t* shape, size_t dim, size_t init_capacity);
-  YALE_STORAGE* nm_yale_storage_create_from_old_yale(dtype_t dtype, size_t* shape, void* ia, void* ja, void* a, dtype_t from_dtype);
+  YALE_STORAGE* nm_yale_storage_create(nm::dtype_t dtype, size_t* shape, size_t dim, size_t init_capacity);
+  YALE_STORAGE* nm_yale_storage_create_from_old_yale(nm::dtype_t dtype, size_t* shape, void* ia, void* ja, void* a, nm::dtype_t from_dtype);
   YALE_STORAGE*	nm_yale_storage_create_merged(const YALE_STORAGE* merge_template, const YALE_STORAGE* other);
   void          nm_yale_storage_delete(STORAGE* s);
   void					nm_yale_storage_init(YALE_STORAGE* s);
@@ -101,7 +101,7 @@ extern "C" {
   void*	nm_yale_storage_ref(STORAGE* s, SLICE* slice);
   char  nm_yale_storage_set(STORAGE* storage, SLICE* slice, void* v);
 
-  inline size_t  nm_yale_storage_get_size(const YALE_STORAGE* storage);
+  size_t  nm_yale_storage_get_size(const YALE_STORAGE* storage);
 
   ///////////
   // Tests //
@@ -113,7 +113,7 @@ extern "C" {
   // Math //
   //////////
 	
-	STORAGE* nm_yale_storage_ew_op(nm::ewop_t op, const STORAGE* left, const STORAGE* right);
+	STORAGE* nm_yale_storage_ew_op(nm::ewop_t op, const STORAGE* left, const STORAGE* right, VALUE scalar);
   STORAGE* nm_yale_storage_matrix_multiply(const STORAGE_PAIR& casted_storage, size_t* resulting_shape, bool vector);
 
   /////////////
@@ -127,20 +127,20 @@ extern "C" {
    * Useful for creating Yale Storage by other means than NMatrix.new(:yale, ...),
    * e.g., from a MATLAB v5 .mat file.
    */
-  inline itype_t nm_yale_storage_itype_by_shape(const size_t* shape) {
+  inline nm::itype_t nm_yale_storage_itype_by_shape(const size_t* shape) {
     uint64_t yale_max_size = shape[0] * (shape[1]+1);
 
     if (yale_max_size < static_cast<uint64_t>(std::numeric_limits<uint8_t>::max()) - 2) {
-      return UINT8;
+      return nm::UINT8;
 
     } else if (yale_max_size < static_cast<uint64_t>(std::numeric_limits<uint16_t>::max()) - 2) {
-      return UINT16;
+      return nm::UINT16;
 
     } else if (yale_max_size < std::numeric_limits<uint32_t>::max() - 2) {
-      return UINT32;
+      return nm::UINT32;
 
     } else {
-      return UINT64;
+      return nm::UINT64;
     }
   }
 
@@ -150,7 +150,7 @@ extern "C" {
    * because UINTX_MAX and UINTX_MAX-1 are both reserved for sparse matrix
    * multiplication.
    */
-  inline itype_t nm_yale_storage_itype(const YALE_STORAGE* s) {
+  inline nm::itype_t nm_yale_storage_itype(const YALE_STORAGE* s) {
     return nm_yale_storage_itype_by_shape(s->shape);
   }
 
@@ -159,7 +159,7 @@ extern "C" {
   // Copying and Casting //
   /////////////////////////
 
-  STORAGE*      nm_yale_storage_cast_copy(const STORAGE* rhs, dtype_t new_dtype);
+  STORAGE*      nm_yale_storage_cast_copy(const STORAGE* rhs, nm::dtype_t new_dtype);
   STORAGE*      nm_yale_storage_copy_transposed(const STORAGE* rhs_base);
 
 
@@ -203,6 +203,8 @@ namespace nm { namespace yale_storage {
   template <typename DType, typename IType>
   void init(YALE_STORAGE* s);
 
+  template <typename IType>
+  size_t  get_size(const YALE_STORAGE* storage);
 }} // end of namespace nm::yale_storage
 
 #endif // YALE_H

data/ext/nmatrix/util/io.cpp

@@ -88,6 +88,8 @@ char* matlab_cstring_to_dtype_string(size_t& result_len, const char* str, size_t
   return result;
 }
 
+
+
 }} // end of namespace nm::io
 
 extern "C" {
@@ -99,11 +101,11 @@ extern "C" {
 /*
  * Converts a string to a data type.
  */
-dtype_t nm_dtype_from_rbstring(VALUE str) {
+nm::dtype_t nm_dtype_from_rbstring(VALUE str) {
 
   for (size_t index = 0; index < NM_NUM_DTYPES; ++index) {
   	if (!std::strncmp(RSTRING_PTR(str), DTYPE_NAMES[index], RSTRING_LEN(str))) {
-  		return static_cast<dtype_t>(index);
+  		return static_cast<nm::dtype_t>(index);
   	}
   }
 
@@ -114,11 +116,11 @@ dtype_t nm_dtype_from_rbstring(VALUE str) {
 /*
  * Converts a symbol to a data type.
  */
-dtype_t nm_dtype_from_rbsymbol(VALUE sym) {
+nm::dtype_t nm_dtype_from_rbsymbol(VALUE sym) {
 
   for (size_t index = 0; index < NM_NUM_DTYPES; ++index) {
     if (SYM2ID(sym) == rb_intern(DTYPE_NAMES[index])) {
-    	return static_cast<dtype_t>(index);
+    	return static_cast<nm::dtype_t>(index);
     }
   }
 
@@ -129,11 +131,11 @@ dtype_t nm_dtype_from_rbsymbol(VALUE sym) {
 /*
  * Converts a symbol to an index type.
  */
-itype_t nm_itype_from_rbsymbol(VALUE sym) {
+nm::itype_t nm_itype_from_rbsymbol(VALUE sym) {
 
   for (size_t index = 0; index < NM_NUM_ITYPES; ++index) {
     if (SYM2ID(sym) == rb_intern(ITYPE_NAMES[index])) {
-    	return static_cast<itype_t>(index);
+    	return static_cast<nm::itype_t>(index);
     }
   }
 
@@ -144,31 +146,31 @@ itype_t nm_itype_from_rbsymbol(VALUE sym) {
  * Converts a string to a storage type. Only looks at the first three
  * characters.
  */
-stype_t nm_stype_from_rbstring(VALUE str) {
+nm::stype_t nm_stype_from_rbstring(VALUE str) {
 
   for (size_t index = 0; index < NM_NUM_STYPES; ++index) {
     if (!std::strncmp(RSTRING_PTR(str), STYPE_NAMES[index], 3)) {
-    	return static_cast<stype_t>(index);
+    	return static_cast<nm::stype_t>(index);
     }
   }
 
   rb_raise(rb_eArgError, "Invalid storage type string specified");
-  return DENSE_STORE;
+  return nm::DENSE_STORE;
 }
 
 /*
  * Converts a symbol to a storage type.
  */
-stype_t nm_stype_from_rbsymbol(VALUE sym) {
+nm::stype_t nm_stype_from_rbsymbol(VALUE sym) {
 
   for (size_t index = 0; index < NM_NUM_STYPES; ++index) {
     if (SYM2ID(sym) == rb_intern(STYPE_NAMES[index])) {
-    	return static_cast<stype_t>(index);
+    	return static_cast<nm::stype_t>(index);
     }
   }
 
   rb_raise(rb_eArgError, "Invalid storage type symbol specified");
-  return DENSE_STORE;
+  return nm::DENSE_STORE;
 }
 
 
@@ -208,18 +210,18 @@ static VALUE nm_rbstring_matlab_repack(VALUE self, VALUE str, VALUE from, VALUE
 
   if (RB_HASH_HAS_SYMBOL_KEY(options, "dtype")) { // Hash#has_key?(:dtype)
 
-    dtype_t to_dtype  = nm_dtype_from_rbsymbol(rb_hash_aref(options, ID2SYM(rb_intern("dtype"))));
-    to_type           = static_cast<int8_t>(to_dtype);
+    nm::dtype_t to_dtype  = nm_dtype_from_rbsymbol(rb_hash_aref(options, ID2SYM(rb_intern("dtype"))));
+    to_type               = static_cast<int8_t>(to_dtype);
 
   } else if (RB_HASH_HAS_SYMBOL_KEY(options, "itype")) {
 
-    itype_t to_itype  = nm_itype_from_rbsymbol(rb_hash_aref(options, ID2SYM(rb_intern("itype"))));
+    nm::itype_t to_itype  = nm_itype_from_rbsymbol(rb_hash_aref(options, ID2SYM(rb_intern("itype"))));
 
     // we're going to cheat and use the DTYPE template table. To do this, we just act like uint8_t
     // is a dtype (both are 0, itype and dtype), or we add 1 to the other itypes and treat them as
     // signed.
     to_type           = static_cast<uint8_t>(to_itype);
-    if (to_itype != UINT8) to_type += 1;
+    if (to_itype != nm::UINT8) to_type += 1;
 
 
   } else {
@@ -227,7 +229,7 @@ static VALUE nm_rbstring_matlab_repack(VALUE self, VALUE str, VALUE from, VALUE
   }
 
   // For next few lines, see explanation above NM_MATLAB_DTYPE_TEMPLATE_TABLE definition in io.h.
-  if (to_type >= static_cast<uint8_t>(COMPLEX64)) {
+  if (to_type >= static_cast<uint8_t>(nm::COMPLEX64)) {
     rb_raise(rb_eArgError, "can only repack into a simple dtype, no complex/rational/VALUE");
   }
 
@@ -256,15 +258,15 @@ static VALUE nm_rbstring_merge(VALUE self, VALUE rb_real, VALUE rb_imaginary, VA
     rb_raise(rb_eArgError, "real and imaginary components do not have same length");
   }
 
-  dtype_t dtype = nm_dtype_from_rbsymbol(rb_dtype);
-  size_t len    = DTYPE_SIZES[dtype];
+  nm::dtype_t dtype = nm_dtype_from_rbsymbol(rb_dtype);
+  size_t len        = DTYPE_SIZES[dtype];
 
-  char *real    = RSTRING_PTR(rb_real),
-       *imag    = RSTRING_PTR(rb_imaginary);
+  char *real        = RSTRING_PTR(rb_real),
+       *imag        = RSTRING_PTR(rb_imaginary);
 
-  char* merge   = ALLOCA_N(char, RSTRING_LEN(rb_real)*2);
+  char* merge       = ALLOCA_N(char, RSTRING_LEN(rb_real)*2);
 
-  size_t merge_pos = 0;
+  size_t merge_pos  = 0;
 
   // Merge the two sequences
   for (size_t i = 0; i < RSTRING_LEN(rb_real); i += len) {