nmatrix 0.0.6 → 0.0.7

data/ext/nmatrix/nmatrix.cpp

@@ -47,7 +47,7 @@ extern "C" {
 
 #include "types.h"
 #include "data/data.h"
-#include "util/math.h"
+#include "math/math.h"
 #include "util/io.h"
 #include "storage/storage.h"
 #include "storage/list.h"
@@ -340,13 +340,17 @@ static VALUE nm_dtype(VALUE self);
 static VALUE nm_itype(VALUE self);
 static VALUE nm_stype(VALUE self);
 static VALUE nm_default_value(VALUE self);
+static size_t effective_dim(STORAGE* s);
+static VALUE nm_effective_dim(VALUE self);
 static VALUE nm_dim(VALUE self);
+static VALUE nm_offset(VALUE self);
 static VALUE nm_shape(VALUE self);
+static VALUE nm_supershape(int argc, VALUE* argv, VALUE self);
 static VALUE nm_capacity(VALUE self);
 static VALUE nm_each_with_indices(VALUE nmatrix);
 static VALUE nm_each_stored_with_indices(VALUE nmatrix);
 
-static SLICE* get_slice(size_t dim, VALUE* c, VALUE self);
+static SLICE* get_slice(size_t dim, int argc, VALUE* arg, size_t* shape);
 static VALUE nm_xslice(int argc, VALUE* argv, void* (*slice_func)(STORAGE*, SLICE*), void (*delete_func)(NMATRIX*), VALUE self);
 static VALUE nm_mset(int argc, VALUE* argv, VALUE self);
 static VALUE nm_mget(int argc, VALUE* argv, VALUE self);
@@ -396,7 +400,6 @@ static VALUE nm_eqeq(VALUE left, VALUE right);
 static VALUE matrix_multiply_scalar(NMATRIX* left, VALUE scalar);
 static VALUE matrix_multiply(NMATRIX* left, NMATRIX* right);
 static VALUE nm_multiply(VALUE left_v, VALUE right_v);
-static VALUE nm_factorize_lu(VALUE self);
 static VALUE nm_det_exact(VALUE self);
 static VALUE nm_complex_conjugate_bang(VALUE self);
 
@@ -419,12 +422,14 @@ static double get_time(void);
 ///////////////////
 
 void Init_nmatrix() {
+
+
 	///////////////////////
 	// Class Definitions //
 	///////////////////////
 
 	cNMatrix = rb_define_class("NMatrix", rb_cObject);
-	cNVector = rb_define_class("NVector", cNMatrix);
+	//cNVector = rb_define_class("NVector", cNMatrix);
 
 	// Special exceptions
 
@@ -479,12 +484,14 @@ void Init_nmatrix() {
 	rb_define_method(cNMatrix, "[]=", (METHOD)nm_mset, -1);
 	rb_define_method(cNMatrix, "is_ref?", (METHOD)nm_is_ref, 0);
 	rb_define_method(cNMatrix, "dimensions", (METHOD)nm_dim, 0);
+	rb_define_method(cNMatrix, "effective_dimensions", (METHOD)nm_effective_dim, 0);
 
 	rb_define_protected_method(cNMatrix, "__list_to_hash__", (METHOD)nm_to_hash, 0); // handles list and dense, which are n-dimensional
 
 	rb_define_method(cNMatrix, "shape", (METHOD)nm_shape, 0);
+	rb_define_method(cNMatrix, "supershape", (METHOD)nm_supershape, -1);
+	rb_define_method(cNMatrix, "offset", (METHOD)nm_offset, 0);
 	rb_define_method(cNMatrix, "det_exact", (METHOD)nm_det_exact, 0);
-	//rb_define_method(cNMatrix, "transpose!", (METHOD)nm_transpose_self, 0);
 	rb_define_method(cNMatrix, "complex_conjugate!", (METHOD)nm_complex_conjugate_bang, 0);
 
 	rb_define_protected_method(cNMatrix, "__dense_each__", (METHOD)nm_dense_each, 0);
@@ -521,8 +528,6 @@ void Init_nmatrix() {
 	// Matrix Math Methods //
 	/////////////////////////
 	rb_define_method(cNMatrix, "dot",		(METHOD)nm_multiply,		1);
-	rb_define_method(cNMatrix, "factorize_lu", (METHOD)nm_factorize_lu, 0);
-
 
 	rb_define_method(cNMatrix, "symmetric?", (METHOD)nm_symmetric, 0);
 	rb_define_method(cNMatrix, "hermitian?", (METHOD)nm_hermitian, 0);
@@ -534,6 +539,7 @@ void Init_nmatrix() {
 	/////////////
 
 	rb_define_alias(cNMatrix, "dim", "dimensions");
+	rb_define_alias(cNMatrix, "effective_dim", "effective_dimensions");
 	rb_define_alias(cNMatrix, "equal?", "eql?");
 
 	///////////////////////
@@ -558,6 +564,11 @@ void Init_nmatrix() {
 	// IO module //
 	///////////////
 	nm_init_io();
+
+	/////////////////////////////////////////////////
+	// Force compilation of necessary constructors //
+	/////////////////////////////////////////////////
+	nm_init_data();
 }
 
 
@@ -581,9 +592,9 @@ static SLICE* alloc_slice(size_t dim) {
  * Slice destructor.
  */
 static void free_slice(SLICE* slice) {
-  free(slice->coords);
-  free(slice->lengths);
-  free(slice);
+  xfree(slice->coords);
+  xfree(slice->lengths);
+  xfree(slice);
 }
 
 
@@ -605,13 +616,16 @@ static VALUE nm_alloc(VALUE klass) {
  * Find the capacity of an NMatrix. The capacity only differs from the size for
  * Yale matrices, which occasionally allocate more space than they need. For
  * list and dense, capacity gives the number of elements in the matrix.
+ *
+ * If you call this on a slice, it may behave unpredictably. Most likely it'll
+ * just return the original matrix's capacity.
  */
 static VALUE nm_capacity(VALUE self) {
   VALUE cap;
 
   switch(NM_STYPE(self)) {
   case nm::YALE_STORE:
-    cap = UINT2NUM(((YALE_STORAGE*)(NM_STORAGE(self)))->capacity);
+    cap = UINT2NUM(reinterpret_cast<YALE_STORAGE*>(NM_STORAGE_YALE(self)->src)->capacity);
     break;
 
   case nm::DENSE_STORE:
@@ -640,7 +654,7 @@ void nm_delete(NMATRIX* mat) {
   };
   ttable[mat->stype](mat->storage);
 
-  free(mat);
+  xfree(mat);
 }
 
 /*
@@ -650,11 +664,11 @@ void nm_delete_ref(NMATRIX* mat) {
   static void (*ttable[nm::NUM_STYPES])(STORAGE*) = {
     nm_dense_storage_delete_ref,
     nm_list_storage_delete_ref,
-    nm_yale_storage_delete
+    nm_yale_storage_delete_ref
   };
   ttable[mat->stype](mat->storage);
 
-  free(mat);
+  xfree(mat);
 }
 
 /*
@@ -844,9 +858,11 @@ static VALUE nm_hermitian(VALUE self) {
   return is_symmetric(self, true);
 }
 
+
+
 /*
  * call-seq:
- * complex_conjugate -> NMatrix
+ *     complex_conjugate -> NMatrix
  *
  * Transform the matrix (in-place) to its complex conjugate. Only works on complex matrices.
  *
@@ -1381,8 +1397,6 @@ static VALUE nm_read(int argc, VALUE* argv, VALUE self) {
   size_t* shape = ALLOC_N(size_t, dim);
   read_padded_shape(f, dim, shape, itype);
 
-  VALUE klass = dim == 1 ? cNVector : cNMatrix;
-
   STORAGE* s;
   if (stype == nm::DENSE_STORE) {
     s = nm_dense_storage_create(dtype, shape, dim, NULL, 0);
@@ -1406,11 +1420,13 @@ static VALUE nm_read(int argc, VALUE* argv, VALUE self) {
   NMATRIX* nm = nm_create(stype, s);
 
   // Return the appropriate matrix object (Ruby VALUE)
+  // FIXME: This should probably return CLASS_OF(self) instead of cNMatrix, but I don't know how that works for
+  // FIXME: class methods.
   switch(stype) {
   case nm::DENSE_STORE:
-    return Data_Wrap_Struct(klass, nm_dense_storage_mark, nm_delete, nm);
+    return Data_Wrap_Struct(cNMatrix, nm_dense_storage_mark, nm_delete, nm);
   case nm::YALE_STORE:
-    return Data_Wrap_Struct(klass, nm_yale_storage_mark, nm_delete, nm);
+    return Data_Wrap_Struct(cNMatrix, nm_yale_storage_mark, nm_delete, nm);
   default:
     return Qnil;
   }
@@ -1447,16 +1463,8 @@ static VALUE nm_init_yale_from_old_yale(VALUE shape, VALUE dtype, VALUE ia, VALU
  * Check to determine whether matrix is a reference to another matrix.
  */
 static VALUE nm_is_ref(VALUE self) {
-	// Refs only allowed for dense and list matrices.
-  if (NM_STYPE(self) == nm::DENSE_STORE) {
-    return (NM_DENSE_SRC(self) == NM_STORAGE(self)) ? Qfalse : Qtrue;
-  }
-
-  if (NM_STYPE(self) == nm::LIST_STORE) {
-    return (NM_LIST_SRC(self) == NM_STORAGE(self)) ? Qfalse : Qtrue;
-  }
-
-  return Qfalse;
+  if (NM_SRC(self) == NM_STORAGE(self)) return Qfalse;
+  else                                  return Qtrue;
 }
 
 /*
@@ -1475,7 +1483,6 @@ static VALUE nm_mget(int argc, VALUE* argv, VALUE self) {
     nm_list_storage_get,
     nm_yale_storage_get
   };
-
   return nm_xslice(argc, argv, ttable[NM_STYPE(self)], nm_delete, self);
 }
 
@@ -1508,30 +1515,28 @@ static VALUE nm_mref(int argc, VALUE* argv, VALUE self) {
  *     n[3,3] = n[2,3] = 5.0
  */
 static VALUE nm_mset(int argc, VALUE* argv, VALUE self) {
-  size_t dim = argc - 1; // last arg is the value
+  size_t dim = NM_DIM(self); // last arg is the value
 
-  if (argc <= 1) {
-    rb_raise(rb_eArgError, "Expected coordinates and r-value");
-
-  } else if (NM_DIM(self) == dim) {
-
-    SLICE* slice = get_slice(dim, argv, self);
+  if ((size_t)(argc) > NM_DIM(self)+1) {
+    rb_raise(rb_eArgError, "wrong number of arguments (%d for %u)", argc, effective_dim(NM_STORAGE(self))+1);
+  } else {
+    SLICE* slice = get_slice(dim, argc-1, argv, NM_STORAGE(self)->shape);
 
-    void* value = rubyobj_to_cval(argv[dim], NM_DTYPE(self));
+    void* value = rubyobj_to_cval(argv[argc-1], NM_DTYPE(self));
 
     // FIXME: Can't use a function pointer table here currently because these functions have different
     // signatures (namely the return type).
     switch(NM_STYPE(self)) {
     case nm::DENSE_STORE:
       nm_dense_storage_set(NM_STORAGE(self), slice, value);
-      free(value);
+      xfree(value);
       break;
     case nm::LIST_STORE:
       // Remove if it's a zero, insert otherwise
       if (!std::memcmp(value, NM_STORAGE_LIST(self)->default_val, DTYPE_SIZES[NM_DTYPE(self)])) {
-        free(value);
+        xfree(value);
         value = nm_list_storage_remove(NM_STORAGE(self), slice);
-        free(value);
+        xfree(value);
       } else {
         nm_list_storage_insert(NM_STORAGE(self), slice, value);
         // no need to free value here since it was inserted directly into the list.
@@ -1539,17 +1544,12 @@ static VALUE nm_mset(int argc, VALUE* argv, VALUE self) {
       break;
     case nm::YALE_STORE:
       nm_yale_storage_set(NM_STORAGE(self), slice, value);
-      free(value);
+      xfree(value);
       break;
     }
     free_slice(slice);
 
-    return argv[dim];
-
-  } else if (NM_DIM(self) < dim) {
-    rb_raise(rb_eArgError, "Coordinates given exceed number of matrix dimensions");
-  } else {
-    rb_raise(rb_eNotImpError, "Slicing not supported yet");
+    return argv[argc-1];
   }
   return Qnil;
 }
@@ -1564,19 +1564,15 @@ static VALUE nm_mset(int argc, VALUE* argv, VALUE self) {
 static VALUE nm_multiply(VALUE left_v, VALUE right_v) {
   NMATRIX *left, *right;
 
-  // left has to be of type NMatrix.
-  CheckNMatrixType(left_v);
-
   UnwrapNMatrix( left_v, left );
 
   if (NM_RUBYVAL_IS_NUMERIC(right_v))
     return matrix_multiply_scalar(left, right_v);
 
   else if (TYPE(right_v) == T_ARRAY)
-    rb_raise(rb_eNotImpError, "for matrix-vector multiplication, please use an NVector instead of an Array for now");
+    rb_raise(rb_eNotImpError, "please convert array to nx1 or 1xn NMatrix first");
 
-  //if (RDATA(right_v)->dfree != (RUBY_DATA_FUNC)nm_delete) {
-  else { // both are matrices
+  else { // both are matrices (probably)
     CheckNMatrixType(right_v);
     UnwrapNMatrix( right_v, right );
 
@@ -1593,50 +1589,6 @@ static VALUE nm_multiply(VALUE left_v, VALUE right_v) {
   return Qnil;
 }
 
-/*
- * call-seq:
- *     matrix.factorize_lu -> ...
- *
- * LU factorization of a matrix.
- *
- * FIXME: For some reason, getrf seems to require that the matrix be transposed first -- and then you have to transpose the
- * FIXME: result again. Ideally, this would be an in-place factorize instead, and would be called nm_factorize_lu_bang.
- */
-static VALUE nm_factorize_lu(VALUE self) {
-  if (NM_STYPE(self) != nm::DENSE_STORE) {
-    rb_raise(rb_eNotImpError, "only implemented for dense storage");
-  }
-
-  if (NM_DIM(self) != 2) {
-    rb_raise(rb_eNotImpError, "matrix is not 2-dimensional");
-  }
-
-  VALUE copy = nm_init_transposed(self);
-
-  static int (*ttable[nm::NUM_DTYPES])(const enum CBLAS_ORDER, const int m, const int n, void* a, const int lda, int* ipiv) = {
-      NULL, NULL, NULL, NULL, NULL, // integers not allowed due to division
-      nm::math::clapack_getrf<float>,
-      nm::math::clapack_getrf<double>,
-#ifdef HAVE_CLAPACK_H
-      clapack_cgetrf, clapack_zgetrf, // call directly, same function signature!
-#else
-      nm::math::clapack_getrf<nm::Complex64>,
-      nm::math::clapack_getrf<nm::Complex128>,
-#endif
-      nm::math::clapack_getrf<nm::Rational32>,
-      nm::math::clapack_getrf<nm::Rational64>,
-      nm::math::clapack_getrf<nm::Rational128>,
-      nm::math::clapack_getrf<nm::RubyObject>
-  };
-
-  int* ipiv = ALLOCA_N(int, std::min(NM_SHAPE0(copy), NM_SHAPE1(copy)));
-
-  // In-place factorize
-  ttable[NM_DTYPE(copy)](CblasRowMajor, NM_SHAPE0(copy), NM_SHAPE1(copy), NM_STORAGE_DENSE(copy)->elements, NM_SHAPE1(copy), ipiv);
-
-  // Transpose the result
-  return nm_init_transposed(copy);
-}
 
 /*
  * call-seq:
@@ -1647,8 +1599,7 @@ static VALUE nm_factorize_lu(VALUE self) {
  * In other words, if you set your matrix to be 3x4, the dim is 2. If the
  * matrix was initialized as 3x4x3, the dim is 3.
  *
- * This function may lie slightly for NVectors, which are internally stored as
- * dim 2 (and have an orientation), but act as if they're dim 1.
+ * Use #effective_dim to get the dimension of an NMatrix which acts as a vector (e.g., a column or row).
  */
 static VALUE nm_dim(VALUE self) {
   return INT2FIX(NM_STORAGE(self)->dim);
@@ -1662,11 +1613,57 @@ static VALUE nm_dim(VALUE self) {
  */
 static VALUE nm_shape(VALUE self) {
   STORAGE* s   = NM_STORAGE(self);
-  size_t index;
 
   // Copy elements into a VALUE array and then use those to create a Ruby array with rb_ary_new4.
   VALUE* shape = ALLOCA_N(VALUE, s->dim);
-  for (index = 0; index < s->dim; ++index)
+  for (size_t index = 0; index < s->dim; ++index)
+    shape[index] = INT2FIX(s->shape[index]);
+
+  return rb_ary_new4(s->dim, shape);
+}
+
+
+/*
+ * call-seq:
+ *     offset -> Array
+ *
+ * Get the offset (slice position) of a matrix. Typically all zeros, unless you have a reference slice.
+ */
+static VALUE nm_offset(VALUE self) {
+  STORAGE* s   = NM_STORAGE(self);
+
+  // Copy elements into a VALUE array and then use those to create a Ruby array with rb_ary_new4.
+  VALUE* offset = ALLOCA_N(VALUE, s->dim);
+  for (size_t index = 0; index < s->dim; ++index)
+    offset[index] = INT2FIX(s->offset[index]);
+
+  return rb_ary_new4(s->dim, offset);
+}
+
+
+/*
+ * call-seq:
+ *     supershape(n) -> Array
+ *     supershape -> Array
+ *
+ * Get the shape of a slice's nth-order parent. If the slice doesn't have n orders, returns the shape
+ * of the original ancestor.
+ */
+static VALUE nm_supershape(int argc, VALUE* argv, VALUE self) {
+  VALUE n; rb_scan_args(argc, argv, "01", &n);
+
+  STORAGE* s   = NM_STORAGE(self);
+  if (s->src == s) return nm_shape(self); // easy case (not a slice)
+  int order = n == Qnil ? 1 : FIX2INT(n);
+
+  if (order <= 0) rb_raise(rb_eRangeError, "expected argument to be positive");
+
+  for (; order > 0; --order) {
+    s = s->src; // proceed to next parent
+  }
+
+  VALUE* shape = ALLOCA_N(VALUE, s->dim);
+  for (size_t index = 0; index < s->dim; ++index)
     shape[index] = INT2FIX(s->shape[index]);
 
   return rb_ary_new4(s->dim, shape);
@@ -1693,14 +1690,41 @@ static VALUE nm_symmetric(VALUE self) {
   return is_symmetric(self, false);
 }
 
+
+/*
+ * Gets the dimension of a matrix which might be a vector (have one or more shape components of size 1).
+ */
+static size_t effective_dim(STORAGE* s) {
+  size_t d = 0;
+  for (size_t i = 0; i < s->dim; ++i) {
+    if (s->shape[i] != 1) d++;
+  }
+  return d;
+}
+
+
+/*
+ * call-seq:
+ *     effective_dim -> Fixnum
+ *
+ * Returns the number of dimensions that don't have length 1. Guaranteed to be less than or equal to #dim.
+ */
+static VALUE nm_effective_dim(VALUE self) {
+  return INT2FIX(effective_dim(NM_STORAGE(self)));
+}
+
+
 /*
  * Get a slice of an NMatrix.
  */
 static VALUE nm_xslice(int argc, VALUE* argv, void* (*slice_func)(STORAGE*, SLICE*), void (*delete_func)(NMATRIX*), VALUE self) {
   VALUE result = Qnil;
+  STORAGE* s = NM_STORAGE(self);
 
-  if (NM_DIM(self) == (size_t)(argc)) {
-    SLICE* slice = get_slice((size_t)(argc), argv, self);
+  if (NM_DIM(self) < (size_t)(argc)) {
+    rb_raise(rb_eArgError, "wrong number of arguments (%d for %u)", argc, effective_dim(s));
+  } else {
+    SLICE* slice = get_slice(NM_DIM(self), argc, argv, s->shape);
 
     if (slice->single) {
       static void* (*ttable[nm::NUM_STYPES])(STORAGE*, SLICE*) = {
@@ -1709,30 +1733,20 @@ static VALUE nm_xslice(int argc, VALUE* argv, void* (*slice_func)(STORAGE*, SLIC
         nm_yale_storage_ref
       };
 
-      if (NM_DTYPE(self) == nm::RUBYOBJ)  result = *reinterpret_cast<VALUE*>( ttable[NM_STYPE(self)](NM_STORAGE(self), slice) );
-      else                                result = rubyobj_from_cval( ttable[NM_STYPE(self)](NM_STORAGE(self), slice), NM_DTYPE(self) ).rval;
+      if (NM_DTYPE(self) == nm::RUBYOBJ)  result = *reinterpret_cast<VALUE*>( ttable[NM_STYPE(self)](s, slice) );
+      else                                result = rubyobj_from_cval( ttable[NM_STYPE(self)](s, slice), NM_DTYPE(self) ).rval;
 
     } else {
       STYPE_MARK_TABLE(mark_table);
 
-      NMATRIX* mat = ALLOC(NMATRIX);
-      mat->stype = NM_STYPE(self);
-      mat->storage = (STORAGE*)((*slice_func)( NM_STORAGE(self), slice ));
-
-      // Do we want an NVector instead of an NMatrix?
-      VALUE klass = cNMatrix, orient = Qnil;
-      // FIXME: Generalize for n dimensional slicing somehow
-      if (mat->storage->shape[0] == 1 || mat->storage->shape[1] == 1) klass  = cNVector;
+      NMATRIX* mat  = ALLOC(NMATRIX);
+      mat->stype    = NM_STYPE(self);
+      mat->storage  = (STORAGE*)((*slice_func)( s, slice ));
 
-      result = Data_Wrap_Struct(klass, mark_table[mat->stype], delete_func, mat);
+      result        = Data_Wrap_Struct(CLASS_OF(self), mark_table[mat->stype], delete_func, mat);
     }
 
     free_slice(slice);
-
-  } else if (NM_DIM(self) < (size_t)(argc)) {
-    rb_raise(rb_eArgError, "Coordinates given exceed number of matrix dimensions");
-  } else {
-    rb_raise(rb_eNotImpError, "This type of slicing not supported yet");
   }
 
   return result;
@@ -1814,12 +1828,7 @@ static VALUE elementwise_op(nm::ewop_t op, VALUE left_val, VALUE right_val) {
  * Check to determine whether matrix is a reference to another matrix.
  */
 bool is_ref(const NMATRIX* matrix) {
-  // FIXME: Needs to work for other types
-  if (matrix->stype != nm::DENSE_STORE) {
-    return false;
-  }
-
-  return ((DENSE_STORAGE*)(matrix->storage))->src != matrix->storage;
+  return matrix->storage->src != matrix->storage;
 }
 
 /*
@@ -2005,40 +2014,57 @@ nm::dtype_t nm_dtype_guess(VALUE v) {
 
 
 /*
- * Documentation goes here.
+ * Allocate and return a SLICE object, which will contain the appropriate coordinate and length information for
+ * accessing some part of a matrix.
  */
-static SLICE* get_slice(size_t dim, VALUE* c, VALUE self) {
-  size_t r;
+static SLICE* get_slice(size_t dim, int argc, VALUE* arg, size_t* shape) {
   VALUE beg, end;
-  int exl;
+  int excl;
 
   SLICE* slice = alloc_slice(dim);
   slice->single = true;
 
-  for (r = 0; r < dim; ++r) {
+  // r is the shape position; t is the slice position. They may differ when we're dealing with a
+  // matrix where the effective dimension is less than the dimension (e.g., a vector).
+  for (size_t r = 0, t = 0; r < dim; ++r) {
+    VALUE v = t == argc ? Qnil : arg[t];
+
+    // if the current shape indicates a vector and fewer args were supplied than necessary, just use 0
+    if (argc - t + r < dim && shape[r] == 1) {
+      slice->coords[r]  = 0;
+      slice->lengths[r] = 1;
 
-    if (FIXNUM_P(c[r])) { // this used CLASS_OF before, which is inefficient for fixnum
+    } else if (FIXNUM_P(v)) { // this used CLASS_OF before, which is inefficient for fixnum
 
-      slice->coords[r]  = FIX2UINT(c[r]);
+      slice->coords[r]  = FIX2UINT(v);
       slice->lengths[r] = 1;
+      t++;
 
-    } else if (CLASS_OF(c[r]) == rb_cRange) {
-        rb_range_values(c[r], &beg, &end, &exl);
-        slice->coords[r]  = FIX2UINT(beg);
-        slice->lengths[r] = FIX2UINT(end) - slice->coords[r] + 1;
+    } else if (TYPE(arg[t]) == T_HASH) { // 3:5 notation (inclusive)
+      VALUE begin_end   = rb_funcall(v, rb_intern("shift"), 0); // rb_hash_shift
+      slice->coords[r]  = FIX2UINT(rb_ary_entry(begin_end, 0));
+      slice->lengths[r] = FIX2UINT(rb_ary_entry(begin_end, 1)) - slice->coords[r];
 
-        // Exclude last element for a...b range
-        if (exl)
-          slice->lengths[r] -= 1;
+      if (RHASH_EMPTY_P(v)) t++; // go on to the next
 
-        slice->single     = false;
+      slice->single = false;
+
+    } else if (CLASS_OF(v) == rb_cRange) {
+      rb_range_values(arg[t], &beg, &end, &excl);
+      slice->coords[r]  = FIX2UINT(beg);
+      // Exclude last element for a...b range
+      slice->lengths[r] = FIX2UINT(end) - slice->coords[r] + (excl ? 0 : 1);
+
+      slice->single     = false;
+
+      t++;
 
     } else {
-      rb_raise(rb_eArgError, "cannot slice using class %s, needs a number or range or something", rb_obj_classname(c[r]));
+      rb_raise(rb_eArgError, "expected Fixnum, Range, or Hash for slice component instead of %s", rb_obj_classname(v));
     }
 
-    if (slice->coords[r] + slice->lengths[r] > NM_SHAPE(self,r))
-      rb_raise(rb_eArgError, "out of range");
+    if (slice->coords[r] > shape[r] || slice->coords[r] + slice->lengths[r] > shape[r])
+      rb_raise(rb_eRangeError, "slice is larger than matrix in dimension %u (slice component %u)", r, t);
   }
 
   return slice;
@@ -2264,24 +2290,23 @@ static VALUE nm_det_exact(VALUE self) {
  *
  * Returns a properly-wrapped Ruby object as a VALUE.
  *
+ * *** Note that this function is for API only. Please do not use it internally.
+ *
  * TODO: Add a column-major option for libraries that use column-major matrices.
  */
 VALUE rb_nmatrix_dense_create(nm::dtype_t dtype, size_t* shape, size_t dim, void* elements, size_t length) {
   NMATRIX* nm;
-  VALUE klass;
   size_t nm_dim;
   size_t* shape_copy;
 
-  // Do not allow a dim of 1; if dim == 1, this should probably be an NVector instead, but that still has dim 2.
+  // Do not allow a dim of 1. Treat it as a column or row matrix.
   if (dim == 1) {
-    klass					= cNVector;
     nm_dim				= 2;
     shape_copy		= ALLOC_N(size_t, nm_dim);
     shape_copy[0]	= shape[0];
     shape_copy[1]	= 1;
 
   } else {
-    klass				= cNMatrix;
     nm_dim			= dim;
     shape_copy	= ALLOC_N(size_t, nm_dim);
     memcpy(shape_copy, shape, sizeof(size_t)*nm_dim);
@@ -2295,7 +2320,7 @@ VALUE rb_nmatrix_dense_create(nm::dtype_t dtype, size_t* shape, size_t dim, void
   nm = nm_create(nm::DENSE_STORE, nm_dense_storage_create(dtype, shape_copy, dim, elements_copy, length));
 
   // tell Ruby about the matrix and its storage, particularly how to garbage collect it.
-  return Data_Wrap_Struct(klass, nm_dense_storage_mark, nm_dense_storage_delete, nm);
+  return Data_Wrap_Struct(cNMatrix, nm_dense_storage_mark, nm_dense_storage_delete, nm);
 }
 
 /*
@@ -2303,9 +2328,8 @@ VALUE rb_nmatrix_dense_create(nm::dtype_t dtype, size_t* shape, size_t dim, void
  *
  * Basically just a convenience wrapper for rb_nmatrix_dense_create().
  *
- * Returns a properly-wrapped Ruby NVector object as a VALUE.
- *
- * TODO: Add a transpose option for setting the orientation of the vector?
+ * Returns a properly-wrapped Ruby NMatrix object as a VALUE. Included for backwards compatibility
+ * for when NMatrix had an NVector class.
  */
 VALUE rb_nvector_dense_create(nm::dtype_t dtype, void* elements, size_t length) {
   size_t dim = 1, shape = length;