nmatrix 0.0.3 → 0.0.4

data/ext/nmatrix/storage/dense.h

@@ -9,8 +9,8 @@
 //
 // == Copyright Information
 //
-// SciRuby is Copyright (c) 2010 - 2012, Ruby Science Foundation
-// NMatrix is Copyright (c) 2012, Ruby Science Foundation
+// SciRuby is Copyright (c) 2010 - 2013, Ruby Science Foundation
+// NMatrix is Copyright (c) 2013, Ruby Science Foundation
 //
 // Please see LICENSE.txt for additional copyright notices.
 //
@@ -78,6 +78,8 @@ void						nm_dense_storage_mark(void*);
 // Accessors //
 ///////////////
 
+VALUE nm_dense_each(VALUE nmatrix);
+VALUE nm_dense_each_with_indices(VALUE nmatrix);
 void*	nm_dense_storage_get(STORAGE* s, SLICE* slice);
 void*	nm_dense_storage_ref(STORAGE* s, SLICE* slice);
 void	nm_dense_storage_set(STORAGE* s, SLICE* slice, void* val);
@@ -102,6 +104,7 @@ STORAGE* nm_dense_storage_matrix_multiply(const STORAGE_PAIR& casted_storage, si
 /////////////
 
 size_t nm_dense_storage_pos(const DENSE_STORAGE* s, const size_t* coords);
+void nm_dense_storage_coords(const DENSE_STORAGE* s, const size_t slice_pos, size_t* coords_out);
 
 /////////////////////////
 // Copying and Casting //

data/ext/nmatrix/storage/list.cpp

@@ -9,8 +9,8 @@
 //
 // == Copyright Information
 //
-// SciRuby is Copyright (c) 2010 - 2012, Ruby Science Foundation
-// NMatrix is Copyright (c) 2012, Ruby Science Foundation
+// SciRuby is Copyright (c) 2010 - 2013, Ruby Science Foundation
+// NMatrix is Copyright (c) 2013, Ruby Science Foundation
 //
 // Please see LICENSE.txt for additional copyright notices.
 //
@@ -182,9 +182,57 @@ NODE* list_storage_get_single_node(LIST_STORAGE* s, SLICE* slice)
   return n;
 }
 
+/*
+ * Each stored iterator, brings along the indices
+ */
+VALUE nm_list_each_stored_with_indices(VALUE nmatrix) {
 
-static LIST* slice_copy(const LIST_STORAGE *src, LIST *src_rows, size_t *coords, size_t *lengths, size_t n)
-{
+  // If we don't have a block, return an enumerator.
+  RETURN_SIZED_ENUMERATOR(nmatrix, 0, 0, 0);
+
+  LIST_STORAGE* s = NM_STORAGE_LIST(nmatrix);
+  // Create indices and initialize to zero
+  size_t* coords = ALLOCA_N(size_t, s->dim);
+  memset(coords, 0, sizeof(size_t) * s->dim);
+
+  // Set up the LIST and NODE
+  LIST* l = s->rows;
+  NODE* curr = l->first;
+
+  // Levels...
+  while (curr) { // LOOPS through the rows
+    NODE* subnode = reinterpret_cast<LIST*>(curr->val)->first;
+    size_t row = curr->key;
+    // Iterate along each row, yielding the val, row, col for each non-default entry
+    while (subnode) {
+      VALUE ary = rb_ary_new();
+      size_t col = subnode->key;
+
+      // Conditional type handling
+      if (NM_DTYPE(nmatrix) == nm::RUBYOBJ) {
+        rb_ary_push(ary, *reinterpret_cast<VALUE*>(subnode->val));
+      } else {
+        rb_ary_push(ary, rubyobj_from_cval((char*)(subnode->val ) , NM_DTYPE(nmatrix)).rval);
+      }
+
+      // Push the coordinate values into the ary
+      rb_ary_push(ary, INT2FIX(row));
+      rb_ary_push(ary, INT2FIX(col));
+
+      // Yield the ary
+      rb_yield(ary);
+
+      // Update the col position
+      subnode = subnode->next;
+    }
+    // Update the row node
+    curr = curr->next;
+  }
+  return nmatrix;
+}
+
+
+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;

data/ext/nmatrix/storage/list.h

@@ -9,8 +9,8 @@
 //
 // == Copyright Information
 //
-// SciRuby is Copyright (c) 2010 - 2012, Ruby Science Foundation
-// NMatrix is Copyright (c) 2012, Ruby Science Foundation
+// SciRuby is Copyright (c) 2010 - 2013, Ruby Science Foundation
+// NMatrix is Copyright (c) 2013, Ruby Science Foundation
 //
 // Please see LICENSE.txt for additional copyright notices.
 //
@@ -82,6 +82,7 @@ extern "C" {
   // Accessors //
   ///////////////
 
+  VALUE nm_list_each_stored_with_indices(VALUE nmatrix);
   void* nm_list_storage_ref(STORAGE* s, SLICE* slice);
   void* nm_list_storage_get(STORAGE* s, SLICE* slice);
   void* nm_list_storage_insert(STORAGE* s, SLICE* slice, void* val);

data/ext/nmatrix/storage/storage.cpp

@@ -9,8 +9,8 @@
 //
 // == Copyright Information
 //
-// SciRuby is Copyright (c) 2010 - 2012, Ruby Science Foundation
-// NMatrix is Copyright (c) 2012, Ruby Science Foundation
+// SciRuby is Copyright (c) 2010 - 2013, Ruby Science Foundation
+// NMatrix is Copyright (c) 2013, Ruby Science Foundation
 //
 // Please see LICENSE.txt for additional copyright notices.
 //
@@ -485,7 +485,7 @@ namespace yale_storage { // FIXME: Move to yale.cpp
     size_t request_capacity = shape[0] + ndnz + 1;
 
     // Create with minimum possible capacity -- just enough to hold all of the entries
-    YALE_STORAGE* lhs = nm_yale_storage_create(l_dtype, shape, 2, request_capacity);
+    YALE_STORAGE* lhs = nm_yale_storage_create(l_dtype, shape, 2, request_capacity, UINT8);
 
     if (lhs->capacity < request_capacity)
       rb_raise(nm_eStorageTypeError, "conversion failed; capacity of %ld requested, max allowable is %ld", (unsigned long)request_capacity, (unsigned long)(lhs->capacity));
@@ -546,7 +546,7 @@ namespace yale_storage { // FIXME: Move to yale.cpp
     shape[1] = rhs->shape[1];
 
     size_t request_capacity = shape[0] + ndnz + 1;
-    YALE_STORAGE* lhs = nm_yale_storage_create(l_dtype, shape, 2, request_capacity);
+    YALE_STORAGE* lhs = nm_yale_storage_create(l_dtype, shape, 2, request_capacity, UINT8);
 
     if (lhs->capacity < request_capacity)
       rb_raise(nm_eStorageTypeError, "conversion failed; capacity of %ld requested, max allowable is %ld", (unsigned long)request_capacity, (unsigned long)(lhs->capacity));
@@ -614,7 +614,7 @@ extern "C" {
   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);
 
-    nm::itype_t itype = nm_yale_storage_itype((const YALE_STORAGE*)right);
+    nm::itype_t itype = nm_yale_storage_default_itype((const YALE_STORAGE*)right);
 
     return (STORAGE*)ttable[l_dtype][right->dtype][itype]((const DENSE_STORAGE*)right, l_dtype);
   }
@@ -622,7 +622,7 @@ extern "C" {
   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);
 
-    nm::itype_t itype = nm_yale_storage_itype((const YALE_STORAGE*)right);
+    nm::itype_t itype = nm_yale_storage_default_itype((const YALE_STORAGE*)right);
 
     return (STORAGE*)ttable[l_dtype][right->dtype][itype]((const LIST_STORAGE*)right, l_dtype);
   }

data/ext/nmatrix/storage/storage.h

@@ -9,8 +9,8 @@
 //
 // == Copyright Information
 //
-// SciRuby is Copyright (c) 2010 - 2012, Ruby Science Foundation
-// NMatrix is Copyright (c) 2012, Ruby Science Foundation
+// SciRuby is Copyright (c) 2010 - 2013, Ruby Science Foundation
+// NMatrix is Copyright (c) 2013, Ruby Science Foundation
 //
 // Please see LICENSE.txt for additional copyright notices.
 //

data/ext/nmatrix/storage/yale.cpp

@@ -9,8 +9,8 @@
 //
 // == Copyright Information
 //
-// SciRuby is Copyright (c) 2010 - 2012, Ruby Science Foundation
-// NMatrix is Copyright (c) 2012, Ruby Science Foundation
+// SciRuby is Copyright (c) 2010 - 2013, Ruby Science Foundation
+// NMatrix is Copyright (c) 2013, Ruby Science Foundation
 //
 // Please see LICENSE.txt for additional copyright notices.
 //
@@ -42,6 +42,7 @@
 #include <ruby.h>
 #include <algorithm>  // std::min
 #include <cstdio>     // std::fprintf
+#include <iostream>
 
 /*
  * Project Includes
@@ -61,23 +62,19 @@
 /*
  * Macros
  */
+
 #ifndef NM_MAX
 #define NM_MAX(a,b) (((a)>(b))?(a):(b))
 #define NM_MIN(a,b) (((a)<(b))?(a):(b))
 #endif
 
-
-/*
- * Global Variables
- */
-
 /*
  * Forward Declarations
  */
 
 extern "C" {
   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);
+  static YALE_STORAGE*	alloc(nm::dtype_t dtype, size_t* shape, size_t dim, nm::itype_t min_itype);
 
   /* Ruby-accessible functions */
   static VALUE nm_size(VALUE self);
@@ -90,8 +87,6 @@ extern "C" {
 
 } // end extern "C" block
 
-
-
 namespace nm { namespace yale_storage {
 
 template <typename DType, typename IType>
@@ -149,7 +144,7 @@ YALE_STORAGE* create_from_old_yale(dtype_t dtype, size_t* shape, void* r_ia, voi
   }
 
   // Having walked through the matrix, we now go about allocating the space for it.
-  YALE_STORAGE* s = alloc(dtype, shape, 2);
+  YALE_STORAGE* s = alloc(dtype, shape, 2, UINT8);
 
   s->capacity = shape[0] + ndnz + 1;
   s->ndnz     = ndnz;
@@ -299,9 +294,7 @@ size_t max_size(YALE_STORAGE* s) {
 ///////////////
 
 /*
- * Returns a slice of YALE_STORAGE object by coppy
- *
- * Slicing-related.
+ * Returns a slice of YALE_STORAGE object by copy
  */
 template <typename DType,typename IType>
 void* get(YALE_STORAGE* storage, SLICE* slice) {
@@ -312,10 +305,10 @@ void* get(YALE_STORAGE* storage, SLICE* slice) {
   shape[0] = slice->lengths[0];
   shape[1] = slice->lengths[1];
 
-  IType *src_ija = reinterpret_cast<IType*>(storage->ija);
-  DType *src_a = reinterpret_cast<DType*>(storage->a);
+  IType* src_ija = reinterpret_cast<IType*>(storage->ija);
+  DType* src_a   = reinterpret_cast<DType*>(storage->a);
 
-  // Calc ndnz
+  // Calc ndnz for the destination
   size_t ndnz  = 0;
   size_t i,j; // indexes of destination matrix
   size_t k,l; // indexes of source matrix
@@ -326,54 +319,71 @@ void* get(YALE_STORAGE* storage, SLICE* slice) {
 
       if (j == i)  continue;
 
-      if (k == l && src_a[k] != 0) ndnz++; // for diagonal element of source         
-      else { // for non-diagonal element 
-        for (size_t c = src_ija[k]; c < src_ija[k+1]; c++) 
-          if (src_ija[c] == l) { ndnz++; break; }
+      if (k == l) { // for diagonal element of source
+        if (src_a[k] != 0) ++ndnz;
+      } else { // for non-diagonal element
+        for (size_t c = src_ija[k]; c < src_ija[k+1]; c++) {
+          if (src_ija[c] == l) {
+            ++ndnz;
+            break;
+          }
+        }
       }
 
     }
   }
 
   size_t request_capacity = shape[0] + ndnz + 1;
-  YALE_STORAGE* ns = nm_yale_storage_create(storage->dtype, shape, 2, request_capacity);
+  //fprintf(stderr, "yale get copy: shape0=%d, shape1=%d, ndnz=%d, request_capacity=%d\n", shape[0], shape[1], ndnz, request_capacity);
+  YALE_STORAGE* ns = nm_yale_storage_create(storage->dtype, shape, 2, request_capacity, storage->itype);
 
   if (ns->capacity < request_capacity)
-      rb_raise(nm_eStorageTypeError, "conversion failed; capacity of %ld requested, max allowable is %ld", request_capacity, ns->capacity);
+    rb_raise(nm_eStorageTypeError, "conversion failed; capacity of %ld requested, max allowable is %ld", request_capacity, ns->capacity);
 
    // Initialize the A and IJA arrays
   init<DType,IType>(ns);
-  IType *dst_ija = reinterpret_cast<IType*>(ns->ija);
-  DType *dst_a = reinterpret_cast<DType*>(ns->a);
+  IType* dst_ija = reinterpret_cast<IType*>(ns->ija);
+  DType* dst_a   = reinterpret_cast<DType*>(ns->a);
  
   size_t ija = shape[0] + 1;
-  DType val; 
+  DType val = src_a[storage->shape[0]]; // use 0 as the default for copy
   for (i = 0; i < shape[0]; ++i) {
     k = i + offset[0];
     for (j = 0; j < shape[1]; ++j) {
+      bool found = false;
       l = j + offset[1];
     
       // Get value from source matrix
-      if (k == l) val = src_a[k];
-      else {
-        // copy non-diagonal element
-        for (size_t c = src_ija[k]; c < src_ija[k+1]; ++c) {
-          if (src_ija[c] == l) val = src_a[c];
+      if (k == l) { // source diagonal
+        if (src_a[k] != 0) { // don't bother copying non-zero values from the diagonal
+          val = src_a[k];
+          found = true;
+        }
+      } else {
+        // copy one non-diagonal element
+        for (size_t c = src_ija[k]; !found && c < src_ija[k+1]; ++c) {
+          if (src_ija[c] == l) {
+            val   = src_a[c];
+            found = true;
+          }
         }
       }
 
-      // Set value to destination matrix
-      if (i == j)  dst_a[i] = val; 
-      else { 
-        // copy non-diagonal element
-        dst_ija[ija] = j;
-        dst_a[ija] = val;
+      if (found) {
+        // Set value in destination matrix
+        if (i == j) {
+          dst_a[i] = val;
+        } else {
+          // copy non-diagonal element
+          dst_ija[ija] = j;
+          dst_a[ija]   = val;
 
-        ++ija;
-        for (size_t c = i + 1; c <= shape[0]; ++c) {
-          dst_ija[c] = ija;
+          ++ija;
+          for (size_t c = i + 1; c <= shape[0]; ++c) {
+            dst_ija[c] = ija;
+          }
         }
-      } 
+      }
     }
   }
 
@@ -643,7 +653,7 @@ YALE_STORAGE* ew_op(const YALE_STORAGE* left, const YALE_STORAGE* right, dtype_t
 	
 	init_capacity = std::min(left->ndnz + right->ndnz + new_shape[0], new_shape[0] * new_shape[1]);
 	
-	dest	= nm_yale_storage_create(dtype, new_shape, 2, init_capacity);
+	dest	= nm_yale_storage_create(dtype, new_shape, 2, init_capacity, left->itype);
 	da		= reinterpret_cast<DType*>(dest->a);
 	
 	// Calculate diagonal values.
@@ -838,7 +848,7 @@ YALE_STORAGE* ew_op(const YALE_STORAGE* left, const YALE_STORAGE* right, dtype_t
 	// Set the number of non-diagonal non-zero entries in the destination matrix.
 	dest->ndnz = da_index;
 	
-	printf("Number of non-diagonal non-zero entires: %ld\n\n", (unsigned long)(dest->ndnz));
+	printf("Number of non-diagonal non-zero entries: %ld\n\n", (unsigned long)(dest->ndnz));
 	
 	// Set the capacity of the destination matrix.
 	dest->capacity = dest->shape[0] + dest->ndnz + 1;
@@ -940,6 +950,8 @@ static char vector_insert_resize(YALE_STORAGE* s, size_t current_size, size_t po
   s->ija = reinterpret_cast<void*>(new_ija);
   s->a   = reinterpret_cast<void*>(new_a);
 
+  fprintf(stderr, "resize\n");
+
   return 'i';
 }
 
@@ -1122,7 +1134,8 @@ static STORAGE* matrix_multiply(const STORAGE_PAIR& casted_storage, size_t* resu
   // int8_t dtype = left->dtype;
 
   // Create result storage.
-  YALE_STORAGE* result = nm_yale_storage_create(left->dtype, resulting_shape, 2, left->capacity + right->capacity);
+  nm::itype_t result_itype = static_cast<uint8_t>(left->itype) < static_cast<uint8_t>(right->itype) ? right->itype : left->itype;
+  YALE_STORAGE* result = nm_yale_storage_create(left->dtype, resulting_shape, 2, left->capacity + right->capacity, result_itype);
   init<DType,IType>(result);
 
   IType* ijl = reinterpret_cast<IType*>(left->ija);
@@ -1144,7 +1157,106 @@ static STORAGE* matrix_multiply(const STORAGE_PAIR& casted_storage, size_t* resu
   return reinterpret_cast<STORAGE*>(result);
 }
 
-}} // end of namespace nm::yale_storage.
+
+} // end of namespace nm::yale_storage
+
+
+// Helper function used only for the RETURN_SIZED_ENUMERATOR macro. Returns the length of
+// the matrix's storage.
+static VALUE nm_yale_enumerator_length(VALUE nmatrix) {
+  long len = nm_yale_storage_get_size(NM_STORAGE_YALE(nmatrix));
+  return LONG2NUM(len);
+}
+
+
+template <typename DType, typename IType>
+struct yale_each_stored_with_indices_helper {
+  static VALUE iterate(VALUE nm) {
+
+    YALE_STORAGE* s = NM_STORAGE_YALE(nm);
+    DType* a    = reinterpret_cast<DType*>(s->a);
+    IType* ija  = reinterpret_cast<IType*>(s->ija);
+
+    // If we don't have a block, return an enumerator.
+    RETURN_SIZED_ENUMERATOR(nm, 0, 0, nm_yale_enumerator_length);
+
+    // Iterate along diagonal
+    for (size_t k = 0; k < s->shape[0]; ++k) {
+      VALUE ii = LONG2NUM(k),
+            jj = LONG2NUM(k);
+
+      VALUE v = rubyobj_from_cval(&(a[k]), NM_DTYPE(nm)).rval;
+      rb_yield_values(3, v, ii, jj );
+    }
+
+    // Iterate through non-diagonal elements, row by row
+    for (long i = 0; i < s->shape[0]; ++i) {
+      long p      = static_cast<long>( ija[i]   ),
+           next_p = static_cast<long>( ija[i+1] );
+
+      for (; p < next_p; ++p) {
+        long j = static_cast<long>(ija[p]);
+        VALUE ii = LONG2NUM(i),
+              jj = LONG2NUM(j);
+
+        VALUE v = rubyobj_from_cval(&(a[p]), NM_DTYPE(nm)).rval;
+        rb_yield_values(3, v, ii, jj );
+      }
+    }
+
+    return nm;
+  }
+};
+
+
+template <typename IType>
+struct yale_each_stored_with_indices_helper<RubyObject, IType> {
+  static VALUE iterate(VALUE nm) {
+
+    YALE_STORAGE* s = NM_STORAGE_YALE(nm);
+    RubyObject* a   = reinterpret_cast<RubyObject*>(s->a);
+    IType* ija      = reinterpret_cast<IType*>(s->ija);
+
+    // If we don't have a block, return an enumerator.
+    RETURN_SIZED_ENUMERATOR(nm, 0, 0, nm_yale_enumerator_length);
+
+    // Iterate along diagonal
+    for (size_t k = 0; k < s->shape[0]; ++k) {
+      VALUE ii = LONG2NUM(k),
+            jj = LONG2NUM(k);
+      rb_yield_values(3, a[k].rval, ii, jj );  // yield element, i, j
+    }
+
+    // Iterate through non-diagonal elements, row by row
+    for (long i = 0; i < s->shape[0]; ++i) {
+      long p      = static_cast<long>( ija[i]   ),
+           next_p = static_cast<long>( ija[i+1] );
+
+      for (; p < next_p; ++p) {
+        long j = static_cast<long>(ija[p]);
+        VALUE ii = LONG2NUM(i),
+              jj = LONG2NUM(j);
+
+        rb_yield_values(3, a[p].rval, ii, jj );
+      }
+    }
+
+    return nm;
+  }
+};
+
+
+/*
+ * This function and the two helper structs enable us to use partial template specialization.
+ * See also: http://stackoverflow.com/questions/6623375/c-template-specialization-on-functions
+ */
+template <typename DType, typename IType>
+static VALUE yale_each_stored_with_indices(VALUE nm) {
+  return yale_each_stored_with_indices_helper<DType, IType>::iterate(nm);
+}
+
+
+} // end of namespace nm.
 
 ///////////////////
 // Ruby Bindings //
@@ -1155,6 +1267,10 @@ static STORAGE* matrix_multiply(const STORAGE_PAIR& casted_storage, size_t* resu
 extern "C" {
 
 void nm_init_yale_functions() {
+	/*
+	 * This module stores methods that are useful for debugging Yale matrices,
+	 * i.e. the ones with +:yale+ stype.	
+	 */
   cNMatrix_YaleFunctions = rb_define_module_under(cNMatrix, "YaleFunctions");
 
   rb_define_method(cNMatrix_YaleFunctions, "yale_ija", (METHOD)nm_ija, 0);
@@ -1172,6 +1288,18 @@ void nm_init_yale_functions() {
 // C ACCESSORS //
 /////////////////
 
+
+
+VALUE nm_yale_each_stored_with_indices(VALUE nmatrix) {
+  nm::dtype_t d = NM_DTYPE(nmatrix);
+  nm::itype_t i = NM_ITYPE(nmatrix);
+
+  NAMED_LI_DTYPE_TEMPLATE_TABLE(ttable, nm::yale_each_stored_with_indices, VALUE, VALUE)
+
+  return ttable[d][i](nmatrix);
+}
+
+
 /*
  * C accessor for inserting some value in a matrix (or replacing an existing cell).
  */
@@ -1262,7 +1390,7 @@ STORAGE* nm_yale_storage_copy_transposed(const STORAGE* rhs_base) {
 
   size_t size   = nm_yale_storage_get_size(rhs);
 
-  YALE_STORAGE* lhs = nm_yale_storage_create(rhs->dtype, shape, 2, size);
+  YALE_STORAGE* lhs = nm_yale_storage_create(rhs->dtype, shape, 2, size, nm::UINT8);
   nm_yale_storage_init(lhs);
 
   NAMED_LI_DTYPE_TEMPLATE_TABLE(transp, nm::math::transpose_yale, void, const size_t n, const size_t m, const void* ia_, const void* ja_, const void* a_, const bool diaga, void* ib_, void* jb_, void* b_, const bool move);
@@ -1362,7 +1490,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(nm::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, nm::itype_t min_itype) {
   YALE_STORAGE* s;
   size_t max_capacity;
 
@@ -1371,7 +1499,7 @@ YALE_STORAGE* nm_yale_storage_create(nm::dtype_t dtype, size_t* shape, size_t di
    	rb_raise(rb_eNotImpError, "Can only support 2D matrices");
   }
 
-  s = alloc(dtype, shape, dim);
+  s = alloc(dtype, shape, dim, min_itype);
   max_capacity = nm::yale_storage::max_size(s);
 
   // Set matrix capacity (and ensure its validity)
@@ -1434,7 +1562,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(nm::dtype_t dtype, size_t* shape, size_t dim) {
+static YALE_STORAGE* alloc(nm::dtype_t dtype, size_t* shape, size_t dim, nm::itype_t min_itype) {
   YALE_STORAGE* s;
 
   s = ALLOC( YALE_STORAGE );
@@ -1445,6 +1573,10 @@ static YALE_STORAGE* alloc(nm::dtype_t dtype, size_t* shape, size_t dim) {
   s->dim         = dim;
   s->itype       = nm_yale_storage_itype_by_shape(shape);
 
+  // See if a higher itype has been requested.
+  if (static_cast<int8_t>(s->itype) < static_cast<int8_t>(min_itype))
+    s->itype    = min_itype;
+
   return s;
 }
 
@@ -1466,6 +1598,9 @@ YALE_STORAGE* nm_yale_storage_create_from_old_yale(nm::dtype_t dtype, size_t* sh
 //////////////////////////////////////////////
 
 /*
+ * call-seq:
+ *     yale_size -> Integer
+ *
  * Get the size of a Yale matrix (the number of elements actually stored).
  *
  * For capacity (the maximum number of elements that can be stored without a resize), use capacity instead.
@@ -1478,6 +1613,9 @@ static VALUE nm_size(VALUE self) {
 
 
 /*
+ * call-seq:
+ *     yale_a -> Array
+ *
  * Get the A array of a Yale matrix (which stores the diagonal and the LU portions of the matrix).
  */
 static VALUE nm_a(VALUE self) {
@@ -1499,6 +1637,9 @@ static VALUE nm_a(VALUE self) {
 
 
 /*
+ * call-seq:
+ *     yale_d -> Array
+ *
  * Get the diagonal ("D") portion of the A array of a Yale matrix.
  */
 static VALUE nm_d(VALUE self) {
@@ -1513,6 +1654,9 @@ static VALUE nm_d(VALUE self) {
 }
 
 /*
+ * call-seq:
+ *     yale_lu -> Array
+ *
  * Get the non-diagonal ("LU") portion of the A array of a Yale matrix.
  */
 static VALUE nm_lu(VALUE self) {
@@ -1535,6 +1679,9 @@ static VALUE nm_lu(VALUE self) {
 }
 
 /*
+ * call-seq:
+ *     yale_ia -> Array
+ *
  * Get the IA portion of the IJA array of a Yale matrix. This gives the start and end positions of rows in the
  * JA and LU portions of the IJA and A arrays, respectively.
  */
@@ -1551,6 +1698,9 @@ static VALUE nm_ia(VALUE self) {
 }
 
 /*
+ * call-seq:
+ *     yale_ja -> Array
+ *
  * Get the JA portion of the IJA array of a Yale matrix. This gives the column indices for entries in corresponding
  * positions in the LU portion of the A array.
  */
@@ -1574,6 +1724,9 @@ static VALUE nm_ja(VALUE self) {
 }
 
 /*
+ * call-seq:
+ *     yale_ija -> Array
+ *
  * Get the IJA array of a Yale matrix.
  */
 static VALUE nm_ija(VALUE self) {