nmatrix 0.0.8 → 0.0.9

data/ext/nmatrix/data/meta.h

@@ -0,0 +1,70 @@
+/////////////////////////////////////////////////////////////////////
+// = NMatrix
+//
+// A linear algebra library for scientific computation in Ruby.
+// NMatrix is part of SciRuby.
+//
+// NMatrix was originally inspired by and derived from NArray, by
+// Masahiro Tanaka: http://narray.rubyforge.org
+//
+// == Copyright Information
+//
+// 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.
+//
+// == Contributing
+//
+// By contributing source code to SciRuby, you agree to be bound by
+// our Contributor Agreement:
+//
+// * https://github.com/SciRuby/sciruby/wiki/Contributor-Agreement
+//
+// == meta.h
+//
+// Header file for dealing with template metaprogramming.
+
+#ifndef META_H
+# define META_H
+
+namespace nm {
+  /*
+   * Template Metaprogramming
+   */
+  template <typename T> struct ctype_to_dtype_enum {
+    static const nm::dtype_t value_type = nm::BYTE;
+  };
+  template <> struct ctype_to_dtype_enum<uint8_t> { static const nm::dtype_t value_type = nm::BYTE; };
+  template <> struct ctype_to_dtype_enum<int8_t>  { static const nm::dtype_t value_type = nm::INT8; };
+  template <> struct ctype_to_dtype_enum<int16_t> { static const nm::dtype_t value_type = nm::INT16; };
+  template <> struct ctype_to_dtype_enum<int32_t> { static const nm::dtype_t value_type = nm::INT32; };
+  template <> struct ctype_to_dtype_enum<int64_t> { static const nm::dtype_t value_type = nm::INT64; };
+  template <> struct ctype_to_dtype_enum<float>   { static const nm::dtype_t value_type = nm::FLOAT32; };
+  template <> struct ctype_to_dtype_enum<double>  { static const nm::dtype_t value_type = nm::FLOAT64; };
+  template <> struct ctype_to_dtype_enum<Complex64>   { static const nm::dtype_t value_type = nm::COMPLEX64; };
+  template <> struct ctype_to_dtype_enum<Complex128>  { static const nm::dtype_t value_type = nm::COMPLEX128; };
+  template <> struct ctype_to_dtype_enum<Rational32>   { static const nm::dtype_t value_type = nm::RATIONAL32; };
+  template <> struct ctype_to_dtype_enum<Rational64>  { static const nm::dtype_t value_type = nm::RATIONAL64; };
+  template <> struct ctype_to_dtype_enum<Rational128>  { static const nm::dtype_t value_type = nm::RATIONAL128; };
+  template <> struct ctype_to_dtype_enum<RubyObject>  { static const nm::dtype_t value_type = nm::RUBYOBJ; };
+
+
+  template <nm::dtype_t Enum> struct dtype_enum_T;
+  template <> struct dtype_enum_T<nm::BYTE> { typedef uint8_t type; };
+  template <> struct dtype_enum_T<nm::INT8>  { typedef int8_t type;  };
+  template <> struct dtype_enum_T<nm::INT16> { typedef int16_t type; };
+  template <> struct dtype_enum_T<nm::INT32> { typedef int32_t type; };
+  template <> struct dtype_enum_T<nm::INT64> { typedef int64_t type; };
+  template <> struct dtype_enum_T<nm::FLOAT32> { typedef float type; };
+  template <> struct dtype_enum_T<nm::FLOAT64> { typedef double type; };
+  template <> struct dtype_enum_T<nm::COMPLEX64> { typedef nm::Complex64 type; };
+  template <> struct dtype_enum_T<nm::COMPLEX128> { typedef nm::Complex128 type; };
+  template <> struct dtype_enum_T<nm::RATIONAL32> { typedef nm::Rational32 type; };
+  template <> struct dtype_enum_T<nm::RATIONAL64> { typedef nm::Rational64 type; };
+  template <> struct dtype_enum_T<nm::RATIONAL128> { typedef nm::Rational128 type; };
+  template <> struct dtype_enum_T<nm::RUBYOBJ> { typedef nm::RubyObject type; };
+
+} // end namespace nm
+
+#endif

data/ext/nmatrix/extconf.rb

@@ -74,6 +74,10 @@ def create_conf_h(file) #:nodoc:
       hfile.puts "#define RUBY_2 1"
     end
 
+    if RUBY_VERSION < '1.9.3'
+      hfile.puts "#define OLD_RB_SCAN_ARGS"
+    end
+
     for line in $defs
       line =~ /^-D(.*)/
       hfile.printf "#define %s 1\n", $1
@@ -111,7 +115,7 @@ $srcs = [
          'storage/common.cpp',
          'storage/storage.cpp',
          'storage/dense.cpp',
-         'storage/yale.cpp',
+         'storage/yale/yale.cpp',
          'storage/list.cpp'
         ]
 # add smmp in to get generic transp; remove smmp2 to eliminate funcptr transp
@@ -130,21 +134,37 @@ $srcs = [
 #   export CPLUS_INCLUDE_PATH=/usr/local/atlas/include
 # (substituting in the path of your cblas.h and clapack.h for the path I used). -- JW 8/27/12
 
+idefaults = {lapack: ["/usr/include/atlas"],
+             cblas: ["/usr/local/atlas/include", "/usr/include/atlas"],
+             atlas: ["/usr/local/atlas/include", "/usr/include/atlas"]}
+
+ldefaults = {lapack: ["/usr/local/lib", "/usr/local/atlas/lib"],
+             cblas: ["/usr/local/lib", "/usr/local/atlas/lib"],
+             atlas: ["/usr/local/atlas/lib", "/usr/local/lib", "/usr/lib"]}
 
-unless have_library("lapack") # && have_header("clapack.h")
-  dir_config("lapack", ["/usr/include/atlas"], ["/usr/local/lib", "/usr/local/atlas/lib"])
+unless have_library("lapack")
+  dir_config("lapack", idefaults[:lapack], ldefaults[:lapack])
 end
 
-unless have_library("cblas") # && have_header("cblas.h")
-  dir_config("cblas", ["/usr/local/atlas/include", "/usr/include/atlas"], ["/usr/local/lib", "/usr/local/atlas/lib"])
+unless have_library("cblas")
+  dir_config("cblas", idefaults[:cblas], ldefaults[:cblas])
 end
 
 unless have_library("atlas")
-  dir_config("atlas", ["/usr/local/atlas/include", "/usr/include/atlas"], ["/usr/local/atlas/lib", "/usr/local/lib", "/usr/lib"])
+  dir_config("atlas", idefaults[:atlas], ldefaults[:atlas])
 end
 
-#find_library("lapack", "clapack_dgetrf")
+# this needs to go before cblas.h checks -- on Ubuntu, the clapack in the
+# include path found for cblas.h doesn't seem to contain all the necessary 
+# functions
 have_header("clapack.h")
+
+# this ensures that we find the header on Ubuntu, where by default the library 
+# can be found but not the header
+unless have_header("cblas.h")
+  find_header("cblas.h", *idefaults[:cblas])
+end
+
 have_header("cblas.h")
 
 have_func("clapack_dgetrf", ["cblas.h", "clapack.h"])
@@ -153,14 +173,16 @@ have_func("dgesvd_", "clapack.h")
 
 have_func("cblas_dgemm", "cblas.h")
 
+#have_func("rb_scan_args", "ruby.h")
 
+#find_library("lapack", "clapack_dgetrf")
 #find_library("cblas", "cblas_dgemm")
 #find_library("atlas", "ATL_dgemmNN")
 
 # Order matters here: ATLAS has to go after LAPACK: http://mail.scipy.org/pipermail/scipy-user/2007-January/010717.html
 $libs += " -llapack -lcblas -latlas "
 
-$objs = %w{nmatrix ruby_constants data/data util/io math util/sl_list storage/common storage/storage storage/dense storage/yale storage/list}.map { |i| i + ".o" }
+$objs = %w{nmatrix ruby_constants data/data util/io math util/sl_list storage/common storage/storage storage/dense storage/yale/yale storage/list}.map { |i| i + ".o" }
 
 #CONFIG['CXX'] = 'clang++'
 CONFIG['CXX'] = 'g++'
@@ -206,10 +228,10 @@ else
 end
 
 # For release, these next two should both be changed to -O3.
-#$CFLAGS += " -O3 " #" -O0 -g "
-$CFLAGS += " -static -O0 -g "
-#$CPPFLAGS += " -O3 -std=#{$CPP_STANDARD} " #" -O0 -g -std=#{$CPP_STANDARD} " #-fmax-errors=10 -save-temps
-$CPPFLAGS += " -static -O0 -g -std=#{$CPP_STANDARD} "
+$CFLAGS += " -O3 " #" -O0 -g "
+#$CFLAGS += " -static -O0 -g "
+$CPPFLAGS += " -O3 -std=#{$CPP_STANDARD} " #" -O0 -g -std=#{$CPP_STANDARD} " #-fmax-errors=10 -save-temps
+#$CPPFLAGS += " -static -O0 -g -std=#{$CPP_STANDARD} "
 
 CONFIG['warnflags'].gsub!('-Wshorten-64-to-32', '') # doesn't work except in Mac-patched gcc (4.2)
 CONFIG['warnflags'].gsub!('-Wdeclaration-after-statement', '')
@@ -221,6 +243,12 @@ create_makefile("nmatrix")
 Dir.mkdir("data") unless Dir.exists?("data")
 Dir.mkdir("util") unless Dir.exists?("util")
 Dir.mkdir("storage") unless Dir.exists?("storage")
+Dir.chdir("storage") do
+  Dir.mkdir("yale") unless Dir.exists?("yale")
+  Dir.chdir("yale") do
+    Dir.mkdir("iterators") unless Dir.exists?("iterators")
+  end
+end
 
 # to clean up object files in subdirectories:
 open('Makefile', 'a') do |f|

data/ext/nmatrix/math/math.h

@@ -205,7 +205,7 @@ inline void trmm(const enum CBLAS_ORDER order, const enum CBLAS_SIDE side, const
 
 
 // Yale: numeric matrix multiply c=a*b
-template <typename DType, typename IType>
+template <typename DType>
 inline void numbmm(const unsigned int n, const unsigned int m, const unsigned int l, const IType* ia, const IType* ja, const DType* a, const bool diaga,
             const IType* ib, const IType* jb, const DType* b, const bool diagb, IType* ic, IType* jc, DType* c, const bool diagc) {
   const unsigned int max_lmn = std::max(std::max(m, n), l);
@@ -323,7 +323,6 @@ inline void new_yale_matrix_multiply(const unsigned int m, const IType* ija, con
 */
 
 // Yale: Symbolic matrix multiply c=a*b
-template <typename IType>
 inline size_t symbmm(const unsigned int n, const unsigned int m, const unsigned int l, const IType* ia, const IType* ja, const bool diaga,
             const IType* ib, const IType* jb, const bool diagb, IType* ic, const bool diagc) {
   unsigned int max_lmn = std::max(std::max(m,n), l);
@@ -378,7 +377,7 @@ inline size_t symbmm(const unsigned int n, const unsigned int m, const unsigned
 namespace smmp_sort {
   const size_t THRESHOLD = 4;  // switch to insertion sort for 4 elements or fewer
 
-  template <typename DType, typename IType>
+  template <typename DType>
   void print_array(DType* vals, IType* array, IType left, IType right) {
     for (IType i = left; i <= right; ++i) {
       std::cerr << array[i] << ":" << vals[i] << "  ";
@@ -386,7 +385,7 @@ namespace smmp_sort {
     std::cerr << std::endl;
   }
 
-  template <typename DType, typename IType>
+  template <typename DType>
   IType partition(DType* vals, IType* array, IType left, IType right, IType pivot) {
     IType pivotJ = array[pivot];
     DType pivotV = vals[pivot];
@@ -414,8 +413,8 @@ namespace smmp_sort {
   }
 
   // Recommended to use the median of left, right, and mid for the pivot.
-  template <typename IType>
-  IType median(IType a, IType b, IType c) {
+  template <typename I>
+  inline I median(I a, I b, I c) {
     if (a < b) {
       if (b < c) return b; // a b c
       if (a < c) return c; // a c b
@@ -430,7 +429,7 @@ namespace smmp_sort {
 
 
   // Insertion sort is more efficient than quicksort for small N
-  template <typename DType, typename IType>
+  template <typename DType>
   void insertion_sort(DType* vals, IType* array, IType left, IType right) {
     for (IType idx = left; idx <= right; ++idx) {
       IType col_to_insert = array[idx];
@@ -448,7 +447,7 @@ namespace smmp_sort {
   }
 
 
-  template <typename DType, typename IType>
+  template <typename DType>
   void quicksort(DType* vals, IType* array, IType left, IType right) {
 
     if (left < right) {
@@ -456,14 +455,14 @@ namespace smmp_sort {
         insertion_sort(vals, array, left, right);
       } else {
         // choose any pivot such that left < pivot < right
-        IType pivot = median(left, right, (IType)(((unsigned long)left + (unsigned long)right) / 2));
+        IType pivot = median<IType>(left, right, (IType)(((unsigned long)left + (unsigned long)right) / 2));
         pivot = partition(vals, array, left, right, pivot);
 
         // recursively sort elements smaller than the pivot
-        quicksort<DType,IType>(vals, array, left, pivot-1);
+        quicksort<DType>(vals, array, left, pivot-1);
 
         // recursively sort elements at least as big as the pivot
-        quicksort<DType,IType>(vals, array, pivot+1, right);
+        quicksort<DType>(vals, array, pivot+1, right);
       }
     }
   }
@@ -483,108 +482,19 @@ namespace smmp_sort {
  * ordering. If someone is doing a lot of Yale matrix multiplication, it might benefit them to consider even insertion
  * sort.
  */
-template <typename DType, typename IType>
+template <typename DType>
 inline void smmp_sort_columns(const size_t n, const IType* ia, IType* ja, DType* a) {
   for (size_t i = 0; i < n; ++i) {
     if (ia[i+1] - ia[i] < 2) continue; // no need to sort rows containing only one or two elements.
     else if (ia[i+1] - ia[i] <= smmp_sort::THRESHOLD) {
-      smmp_sort::insertion_sort<DType, IType>(a, ja, ia[i], ia[i+1]-1); // faster for small rows
+      smmp_sort::insertion_sort<DType>(a, ja, ia[i], ia[i+1]-1); // faster for small rows
     } else {
-      smmp_sort::quicksort<DType, IType>(a, ja, ia[i], ia[i+1]-1);      // faster for large rows (and may call insertion_sort as well)
+      smmp_sort::quicksort<DType>(a, ja, ia[i], ia[i+1]-1);      // faster for large rows (and may call insertion_sort as well)
     }
   }
 }
 
 
-
-/*
- * Transposes a generic Yale matrix (old or new). Specify new by setting diaga = true.
- *
- * Based on transp from SMMP (same as symbmm and numbmm).
- *
- * This is not named in the same way as most yale_storage functions because it does not act on a YALE_STORAGE
- * object.
- */
-template <typename DType, typename IType>
-void transpose_yale(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)
-{
-  const IType *ia = reinterpret_cast<const IType*>(ia_),
-              *ja = reinterpret_cast<const IType*>(ja_);
-  const DType *a  = reinterpret_cast<const DType*>(a_);
-
-  IType *ib = reinterpret_cast<IType*>(ib_),
-        *jb = reinterpret_cast<IType*>(jb_);
-  DType *b  = reinterpret_cast<DType*>(b_);
-
-
-
-  size_t index;
-
-  // Clear B
-  for (size_t i = 0; i < m+1; ++i) ib[i] = 0;
-
-  if (move)
-    for (size_t i = 0; i < m+1; ++i) b[i] = 0;
-
-  if (diaga) ib[0] = m + 1;
-  else       ib[0] = 0;
-
-  /* count indices for each column */
-
-  for (size_t i = 0; i < n; ++i) {
-    for (size_t j = ia[i]; j < ia[i+1]; ++j) {
-      ++(ib[ja[j]+1]);
-    }
-  }
-
-  for (size_t i = 0; i < m; ++i) {
-    ib[i+1] = ib[i] + ib[i+1];
-  }
-
-  /* now make jb */
-
-  for (size_t i = 0; i < n; ++i) {
-
-    for (size_t j = ia[i]; j < ia[i+1]; ++j) {
-      index = ja[j];
-      jb[ib[index]] = i;
-
-      if (move)
-        b[ib[index]] = a[j];
-
-      ++(ib[index]);
-    }
-  }
-
-  /* now fixup ib */
-
-  for (size_t i = m; i >= 1; --i) {
-    ib[i] = ib[i-1];
-  }
-
-
-  if (diaga) {
-    if (move) {
-      size_t j = std::min(n,m);
-
-      for (size_t i = 0; i < j; ++i) {
-        b[i] = a[i];
-      }
-    }
-    ib[0] = m + 1;
-
-  } else {
-    ib[0] = 0;
-  }
-}
-
-
-
-
-
-
-
 /*
  * From ATLAS 3.8.0:
  *

data/ext/nmatrix/nmatrix.cpp

@@ -45,6 +45,7 @@ extern "C" {
 /*
  * Project Includes
  */
+#include "nmatrix_config.h"
 
 #include "types.h"
 #include "data/data.h"
@@ -52,12 +53,17 @@ extern "C" {
 #include "util/io.h"
 #include "storage/storage.h"
 #include "storage/list.h"
-#include "storage/yale.h"
+#include "storage/yale/yale.h"
 
 #include "nmatrix.h"
 
 #include "ruby_constants.h"
 
+/*
+ * Ruby internals
+ */
+
+
 /*
  * Macros
  */
@@ -74,7 +80,6 @@ namespace nm {
    *
    * shape should already be allocated before calling this.
    */
-  template <typename IType>
   void read_padded_shape(std::ifstream& f, size_t dim, size_t* shape) {
     size_t bytes_read = 0;
 
@@ -91,7 +96,6 @@ namespace nm {
     f.ignore(bytes_read % 8);
   }
 
-  template <typename IType>
   void write_padded_shape(std::ofstream& f, size_t dim, size_t* shape) {
     size_t bytes_written = 0;
 
@@ -246,7 +250,7 @@ namespace nm {
     if (bytes_read % 8) f.ignore(bytes_read % 8);
   }
 
-  template <typename DType, typename IType>
+  template <typename DType>
   void write_padded_yale_elements(std::ofstream& f, YALE_STORAGE* storage, size_t length, nm::symm_t symm) {
     if (symm != nm::NONSYMM) rb_raise(rb_eNotImpError, "Yale matrices can only be read/written in full form");
 
@@ -268,7 +272,7 @@ namespace nm {
   }
 
 
-  template <typename DType, typename IType>
+  template <typename DType>
   void read_padded_yale_elements(std::ifstream& f, YALE_STORAGE* storage, size_t length, nm::symm_t symm) {
     if (symm != NONSYMM) rb_raise(rb_eNotImpError, "Yale matrices can only be read/written in full form");
 
@@ -324,2017 +328,5 @@ namespace nm {
 } // end of namespace nm
 
 extern "C" {
-
-/*
- * Forward Declarations
- */
-
-static VALUE nm_init(int argc, VALUE* argv, VALUE nm);
-static VALUE nm_init_copy(VALUE copy, VALUE original);
-static VALUE nm_init_transposed(VALUE self);
-static VALUE nm_cast(VALUE self, VALUE new_stype_symbol, VALUE new_dtype_symbol, VALUE init);
-static VALUE nm_read(int argc, VALUE* argv, VALUE self);
-static VALUE nm_write(int argc, VALUE* argv, VALUE self);
-static VALUE nm_init_yale_from_old_yale(VALUE shape, VALUE dtype, VALUE ia, VALUE ja, VALUE a, VALUE from_dtype, VALUE nm);
-static VALUE nm_alloc(VALUE klass);
-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, 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);
-static VALUE nm_mref(int argc, VALUE* argv, VALUE self);
-static VALUE nm_is_ref(VALUE self);
-
-static VALUE is_symmetric(VALUE self, bool hermitian);
-
-static VALUE nm_guess_dtype(VALUE self, VALUE v);
-static VALUE nm_min_dtype(VALUE self, VALUE v);
-
-/*
- * Macro defines an element-wise accessor function for some operation.
- *
- * This is only responsible for the Ruby accessor! You still have to write the actual functions, obviously.
- */
-#define DEF_ELEMENTWISE_RUBY_ACCESSOR(oper, name)                 \
-static VALUE nm_ew_##name(VALUE left_val, VALUE right_val) {  \
-  return elementwise_op(nm::EW_##oper, left_val, right_val);  \
-}
-
-/*
- * Macro declares a corresponding accessor function prototype for some element-wise operation.
- */
-#define DECL_ELEMENTWISE_RUBY_ACCESSOR(name)    static VALUE nm_ew_##name(VALUE left_val, VALUE right_val);
-
-DECL_ELEMENTWISE_RUBY_ACCESSOR(add)
-DECL_ELEMENTWISE_RUBY_ACCESSOR(subtract)
-DECL_ELEMENTWISE_RUBY_ACCESSOR(multiply)
-DECL_ELEMENTWISE_RUBY_ACCESSOR(divide)
-DECL_ELEMENTWISE_RUBY_ACCESSOR(power)
-DECL_ELEMENTWISE_RUBY_ACCESSOR(mod)
-DECL_ELEMENTWISE_RUBY_ACCESSOR(eqeq)
-DECL_ELEMENTWISE_RUBY_ACCESSOR(neq)
-DECL_ELEMENTWISE_RUBY_ACCESSOR(lt)
-DECL_ELEMENTWISE_RUBY_ACCESSOR(gt)
-DECL_ELEMENTWISE_RUBY_ACCESSOR(leq)
-DECL_ELEMENTWISE_RUBY_ACCESSOR(geq)
-
-static VALUE elementwise_op(nm::ewop_t op, VALUE left_val, VALUE right_val);
-
-static VALUE nm_symmetric(VALUE self);
-static VALUE nm_hermitian(VALUE self);
-
-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_det_exact(VALUE self);
-static VALUE nm_complex_conjugate_bang(VALUE self);
-
-static nm::dtype_t	interpret_dtype(int argc, VALUE* argv, nm::stype_t stype);
-static void*		interpret_initial_value(VALUE arg, nm::dtype_t dtype);
-static size_t*	interpret_shape(VALUE arg, size_t* dim);
-static nm::stype_t	interpret_stype(VALUE arg);
-
-/* Singleton methods */
-static VALUE nm_itype_by_shape(VALUE self, VALUE shape_arg);
-static VALUE nm_upcast(VALUE self, VALUE t1, VALUE t2);
-
-
-#ifdef BENCHMARK
-static double get_time(void);
-#endif
-
-///////////////////
-// Ruby Bindings //
-///////////////////
-
-void Init_nmatrix() {
-
-
-	///////////////////////
-	// Class Definitions //
-	///////////////////////
-
-	cNMatrix = rb_define_class("NMatrix", rb_cObject);
-	//cNVector = rb_define_class("NVector", cNMatrix);
-
-	// Special exceptions
-
-	/*
-	 * Exception raised when there's a problem with data.
-	 */
-	nm_eDataTypeError    = rb_define_class("DataTypeError", rb_eStandardError);
-
-	/*
-	 * Exception raised when something goes wrong with the storage of a matrix.
-	 */
-	nm_eStorageTypeError = rb_define_class("StorageTypeError", rb_eStandardError);
-
-	///////////////////
-	// Class Methods //
-	///////////////////
-
-	rb_define_alloc_func(cNMatrix, nm_alloc);
-
-	///////////////////////
-  // Singleton Methods //
-  ///////////////////////
-
-	rb_define_singleton_method(cNMatrix, "upcast", (METHOD)nm_upcast, 2);
-	rb_define_singleton_method(cNMatrix, "itype_by_shape", (METHOD)nm_itype_by_shape, 1);
-	rb_define_singleton_method(cNMatrix, "guess_dtype", (METHOD)nm_guess_dtype, 1);
-	rb_define_singleton_method(cNMatrix, "min_dtype", (METHOD)nm_min_dtype, 1);
-
-	//////////////////////
-	// Instance Methods //
-	//////////////////////
-
-	rb_define_method(cNMatrix, "initialize", (METHOD)nm_init, -1);
-	rb_define_method(cNMatrix, "initialize_copy", (METHOD)nm_init_copy, 1);
-	rb_define_singleton_method(cNMatrix, "read", (METHOD)nm_read, -1);
-
-	rb_define_method(cNMatrix, "write", (METHOD)nm_write, -1);
-
-	// Technically, the following function is a copy constructor.
-	rb_define_method(cNMatrix, "transpose", (METHOD)nm_init_transposed, 0);
-
-	rb_define_method(cNMatrix, "dtype", (METHOD)nm_dtype, 0);
-	rb_define_method(cNMatrix, "itype", (METHOD)nm_itype, 0);
-	rb_define_method(cNMatrix, "stype", (METHOD)nm_stype, 0);
-	rb_define_method(cNMatrix, "cast_full",  (METHOD)nm_cast, 3);
-	rb_define_method(cNMatrix, "default_value", (METHOD)nm_default_value, 0);
-	rb_define_protected_method(cNMatrix, "__list_default_value__", (METHOD)nm_list_default_value, 0);
-	rb_define_protected_method(cNMatrix, "__yale_default_value__", (METHOD)nm_yale_default_value, 0);
-
-	rb_define_method(cNMatrix, "[]", (METHOD)nm_mref, -1);
-	rb_define_method(cNMatrix, "slice", (METHOD)nm_mget, -1);
-	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, "complex_conjugate!", (METHOD)nm_complex_conjugate_bang, 0);
-
-	rb_define_protected_method(cNMatrix, "__dense_each__", (METHOD)nm_dense_each, 0);
-	rb_define_protected_method(cNMatrix, "__dense_map__", (METHOD)nm_dense_map, 0);
-	rb_define_protected_method(cNMatrix, "__dense_map_pair__", (METHOD)nm_dense_map_pair, 1);
-	rb_define_method(cNMatrix, "each_with_indices", (METHOD)nm_each_with_indices, 0);
-	rb_define_method(cNMatrix, "each_stored_with_indices", (METHOD)nm_each_stored_with_indices, 0);
-	rb_define_protected_method(cNMatrix, "__list_map_merged_stored__", (METHOD)nm_list_map_merged_stored, 2);
-	rb_define_protected_method(cNMatrix, "__yale_map_merged_stored__", (METHOD)nm_yale_map_merged_stored, 2);
-	rb_define_protected_method(cNMatrix, "__yale_map_stored__", (METHOD)nm_yale_map_stored, 0);
-
-	rb_define_method(cNMatrix, "==",	  (METHOD)nm_eqeq,				1);
-
-	rb_define_method(cNMatrix, "+",			(METHOD)nm_ew_add,			1);
-	rb_define_method(cNMatrix, "-",			(METHOD)nm_ew_subtract,	1);
-  rb_define_method(cNMatrix, "*",			(METHOD)nm_ew_multiply,	1);
-	rb_define_method(cNMatrix, "/",			(METHOD)nm_ew_divide,		1);
-  rb_define_method(cNMatrix, "**",    (METHOD)nm_ew_power,    1);
-  rb_define_method(cNMatrix, "%",     (METHOD)nm_ew_mod,      1);
-
-	rb_define_method(cNMatrix, "=~", (METHOD)nm_ew_eqeq, 1);
-	rb_define_method(cNMatrix, "!~", (METHOD)nm_ew_neq, 1);
-	rb_define_method(cNMatrix, "<=", (METHOD)nm_ew_leq, 1);
-	rb_define_method(cNMatrix, ">=", (METHOD)nm_ew_geq, 1);
-	rb_define_method(cNMatrix, "<", (METHOD)nm_ew_lt, 1);
-	rb_define_method(cNMatrix, ">", (METHOD)nm_ew_gt, 1);
-
-	/////////////////////////////
-	// Helper Instance Methods //
-	/////////////////////////////
-	rb_define_protected_method(cNMatrix, "__yale_vector_set__", (METHOD)nm_vector_set, -1);
-
-	/////////////////////////
-	// Matrix Math Methods //
-	/////////////////////////
-	rb_define_method(cNMatrix, "dot",		(METHOD)nm_multiply,		1);
-
-	rb_define_method(cNMatrix, "symmetric?", (METHOD)nm_symmetric, 0);
-	rb_define_method(cNMatrix, "hermitian?", (METHOD)nm_hermitian, 0);
-
-	rb_define_method(cNMatrix, "capacity", (METHOD)nm_capacity, 0);
-
-	/////////////
-	// Aliases //
-	/////////////
-
-	rb_define_alias(cNMatrix, "dim", "dimensions");
-	rb_define_alias(cNMatrix, "effective_dim", "effective_dimensions");
-	rb_define_alias(cNMatrix, "equal?", "eql?");
-
-	///////////////////////
-	// Symbol Generation //
-	///////////////////////
-
-	nm_init_ruby_constants();
-
-	//////////////////////////
-	// YaleFunctions module //
-	//////////////////////////
-
-	nm_init_yale_functions();
-
-	/////////////////
-	// BLAS module //
-	/////////////////
-
-	nm_math_init_blas();
-
-	///////////////
-	// IO module //
-	///////////////
-	nm_init_io();
-
-	/////////////////////////////////////////////////
-	// Force compilation of necessary constructors //
-	/////////////////////////////////////////////////
-	nm_init_data();
-}
-
-
-//////////////////
-// Ruby Methods //
-//////////////////
-
-
-/*
- * Slice constructor.
- */
-static SLICE* alloc_slice(size_t dim) {
-  SLICE* slice = ALLOC(SLICE);
-  slice->coords = ALLOC_N(size_t, dim);
-  slice->lengths = ALLOC_N(size_t, dim);
-  return slice;
-}
-
-
-/*
- * Slice destructor.
- */
-static void free_slice(SLICE* slice) {
-  xfree(slice->coords);
-  xfree(slice->lengths);
-  xfree(slice);
-}
-
-
-/*
- * Allocator.
- */
-static VALUE nm_alloc(VALUE klass) {
-  NMATRIX* mat = ALLOC(NMATRIX);
-  mat->storage = NULL;
-  // FIXME: mark_table[mat->stype] should be passed to Data_Wrap_Struct, but can't be done without stype. Also, nm_delete depends on this.
-  // mat->stype   = nm::NUM_STYPES;
-
-  //STYPE_MARK_TABLE(mark_table);
-
-  return Data_Wrap_Struct(klass, NULL, nm_delete, mat);
-}
-
-/*
- * 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(reinterpret_cast<YALE_STORAGE*>(NM_STORAGE_YALE(self)->src)->capacity);
-    break;
-
-  case nm::DENSE_STORE:
-    cap = UINT2NUM(nm_storage_count_max_elements( NM_STORAGE_DENSE(self) ));
-    break;
-
-  case nm::LIST_STORE:
-    cap = UINT2NUM(nm_list_storage_count_elements( NM_STORAGE_LIST(self) ));
-    break;
-
-  default:
-    rb_raise(nm_eStorageTypeError, "unrecognized stype in nm_capacity()");
-  }
-
-  return cap;
-}
-
-/*
- * Destructor.
- */
-void nm_delete(NMATRIX* mat) {
-  static void (*ttable[nm::NUM_STYPES])(STORAGE*) = {
-    nm_dense_storage_delete,
-    nm_list_storage_delete,
-    nm_yale_storage_delete
-  };
-  ttable[mat->stype](mat->storage);
-
-  xfree(mat);
-}
-
-/*
- * Slicing destructor.
- */
-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_ref
-  };
-  ttable[mat->stype](mat->storage);
-
-  xfree(mat);
-}
-
-/*
- * call-seq:
- *     dtype -> Symbol
- *
- * Get the data type (dtype) of a matrix, e.g., :byte, :int8, :int16, :int32,
- * :int64, :float32, :float64, :complex64, :complex128, :rational32,
- * :rational64, :rational128, or :object (the last is a Ruby object).
- */
-static VALUE nm_dtype(VALUE self) {
-  ID dtype = rb_intern(DTYPE_NAMES[NM_DTYPE(self)]);
-  return ID2SYM(dtype);
-}
-
-/*
- * call-seq:
- *     itype -> Symbol or nil
- *
- * Get the index data type (dtype) of a matrix. Defined only for yale; others return nil.
- */
-static VALUE nm_itype(VALUE self) {
-  if (NM_STYPE(self) == nm::YALE_STORE) {
-    ID itype = rb_intern(ITYPE_NAMES[NM_ITYPE(self)]);
-    return ID2SYM(itype);
-  }
-  return Qnil;
-}
-
-/*
- * Get the index data type (dtype) of a matrix. Defined only for yale; others return nil.
- */
-static VALUE nm_itype_by_shape(VALUE self, VALUE shape_arg) {
-
-  size_t dim;
-  size_t* shape = interpret_shape(shape_arg, &dim);
-
-  nm::itype_t itype = nm_yale_storage_itype_by_shape(shape);
-  ID itype_id       = rb_intern(ITYPE_NAMES[itype]);
-
-  return ID2SYM(itype_id);
-}
-
-/*
- * call-seq:
- *     upcast(first_dtype, second_dtype) -> Symbol
- *
- * Given a binary operation between types t1 and t2, what type will be returned?
- *
- * This is a singleton method on NMatrix, e.g., NMatrix.upcast(:int32, :int64)
- */
-static VALUE nm_upcast(VALUE self, VALUE t1, VALUE t2) {
-
-  nm::dtype_t d1    = nm_dtype_from_rbsymbol(t1),
-              d2    = nm_dtype_from_rbsymbol(t2);
-
-  return ID2SYM(rb_intern( DTYPE_NAMES[ Upcast[d1][d2] ] ));
-}
-
-
-/*
- * call-seq:
-       default_value -> ...
- *
- * Get the default value for the matrix. For dense, this is undefined and will return Qnil. For list, it is user-defined.
- * For yale, it's going to be some variation on zero, but may be Qfalse or Qnil.
- */
-static VALUE nm_default_value(VALUE self) {
-  switch(NM_STYPE(self)) {
-  case nm::YALE_STORE:
-    return nm_yale_default_value(self);
-  case nm::LIST_STORE:
-    return nm_list_default_value(self);
-  case nm::DENSE_STORE:
-  default:
-    return Qnil;
-  }
-}
-
-
-/*
- * call-seq:
- *     each_with_indices -> Enumerator
- *
- * Iterate over all entries of any matrix in standard storage order (as with #each), and include the indices.
- */
-static VALUE nm_each_with_indices(VALUE nmatrix) {
-  volatile VALUE nm = nmatrix;
-
-  switch(NM_STYPE(nm)) {
-  case nm::YALE_STORE:
-    return nm_yale_each_with_indices(nm);
-  case nm::DENSE_STORE:
-    return nm_dense_each_with_indices(nm);
-  case nm::LIST_STORE:
-    return nm_list_each_with_indices(nm, false);
-  default:
-    rb_raise(nm_eDataTypeError, "Not a proper storage type");
-  }
-}
-
-/*
- * call-seq:
- *     each_stored_with_indices -> Enumerator
- *
- * Iterate over the stored entries of any matrix. For dense and yale, this iterates over non-zero
- * entries; for list, this iterates over non-default entries. Yields dim+1 values for each entry:
- * i, j, ..., and the entry itself.
- */
-static VALUE nm_each_stored_with_indices(VALUE nmatrix) {
-  volatile VALUE nm = nmatrix;
-
-  switch(NM_STYPE(nm)) {
-  case nm::YALE_STORE:
-    return nm_yale_each_stored_with_indices(nm);
-  case nm::DENSE_STORE:
-    return nm_dense_each_with_indices(nm);
-  case nm::LIST_STORE:
-    return nm_list_each_with_indices(nm, true);
-  default:
-    rb_raise(nm_eDataTypeError, "Not a proper storage type");
-  }
-}
-
-
-/*
- * Equality operator. Returns a single true or false value indicating whether
- * the matrices are equivalent.
- *
- * For elementwise, use =~ instead.
- *
- * This method will raise an exception if dimensions do not match.
- */
-static VALUE nm_eqeq(VALUE left, VALUE right) {
-  NMATRIX *l, *r;
-
-  CheckNMatrixType(left);
-  CheckNMatrixType(right);
-
-  UnwrapNMatrix(left, l);
-  UnwrapNMatrix(right, r);
-
-  if (l->stype != r->stype)
-    rb_raise(rb_eNotImpError, "comparison between different matrix stypes not yet implemented");
-
-  bool result = false;
-
-  switch(l->stype) {
-  case nm::DENSE_STORE:
-    result = nm_dense_storage_eqeq(l->storage, r->storage);
-    break;
-  case nm::LIST_STORE:
-    result = nm_list_storage_eqeq(l->storage, r->storage);
-    break;
-  case nm::YALE_STORE:
-    result = nm_yale_storage_eqeq(l->storage, r->storage);
-    break;
-  }
-
-  return result ? Qtrue : Qfalse;
-}
-
-DEF_ELEMENTWISE_RUBY_ACCESSOR(ADD, add)
-DEF_ELEMENTWISE_RUBY_ACCESSOR(SUB, subtract)
-DEF_ELEMENTWISE_RUBY_ACCESSOR(MUL, multiply)
-DEF_ELEMENTWISE_RUBY_ACCESSOR(DIV, divide)
-DEF_ELEMENTWISE_RUBY_ACCESSOR(POW, power)
-DEF_ELEMENTWISE_RUBY_ACCESSOR(MOD, mod)
-DEF_ELEMENTWISE_RUBY_ACCESSOR(EQEQ, eqeq)
-DEF_ELEMENTWISE_RUBY_ACCESSOR(NEQ, neq)
-DEF_ELEMENTWISE_RUBY_ACCESSOR(LEQ, leq)
-DEF_ELEMENTWISE_RUBY_ACCESSOR(GEQ, geq)
-DEF_ELEMENTWISE_RUBY_ACCESSOR(LT, lt)
-DEF_ELEMENTWISE_RUBY_ACCESSOR(GT, gt)
-
-/*
- * call-seq:
- *     hermitian? -> Boolean
- *
- * Is this matrix hermitian?
- *
- * Definition: http://en.wikipedia.org/wiki/Hermitian_matrix
- *
- * For non-complex matrices, this function should return the same result as symmetric?.
- */
-static VALUE nm_hermitian(VALUE self) {
-  return is_symmetric(self, true);
-}
-
-
-
-/*
- * call-seq:
- *     complex_conjugate -> NMatrix
- *
- * Transform the matrix (in-place) to its complex conjugate. Only works on complex matrices.
- *
- * FIXME: For non-complex matrices, someone needs to implement a non-in-place complex conjugate (which doesn't use a bang).
- * Bang should imply that no copy is being made, even temporarily.
- */
-static VALUE nm_complex_conjugate_bang(VALUE self) {
-  NMATRIX* m;
-  void* elem;
-  size_t size, p;
-
-  UnwrapNMatrix(self, m);
-
-  if (m->stype == nm::DENSE_STORE) {
-
-    size = nm_storage_count_max_elements(NM_STORAGE(self));
-    elem = NM_STORAGE_DENSE(self)->elements;
-
-  } else if (m->stype == nm::YALE_STORE) {
-
-    size = nm_yale_storage_get_size(NM_STORAGE_YALE(self));
-    elem = NM_STORAGE_YALE(self)->a;
-
-  } else {
-    rb_raise(rb_eNotImpError, "please cast to yale or dense (complex) first");
-  }
-
-  // Walk through and negate the imaginary component
-  if (NM_DTYPE(self) == nm::COMPLEX64) {
-
-    for (p = 0; p < size; ++p) {
-      reinterpret_cast<nm::Complex64*>(elem)[p].i = -reinterpret_cast<nm::Complex64*>(elem)[p].i;
-    }
-
-  } else if (NM_DTYPE(self) == nm::COMPLEX128) {
-
-    for (p = 0; p < size; ++p) {
-      reinterpret_cast<nm::Complex128*>(elem)[p].i = -reinterpret_cast<nm::Complex128*>(elem)[p].i;
-    }
-
-  } else {
-    rb_raise(nm_eDataTypeError, "can only calculate in-place complex conjugate on matrices of type :complex64 or :complex128");
-  }
-
-  return self;
-}
-
-/*
- * Helper function for creating a matrix. You have to create the storage and pass it in, but you don't
- * need to worry about deleting it.
- */
-NMATRIX* nm_create(nm::stype_t stype, STORAGE* storage) {
-  NMATRIX* mat = ALLOC(NMATRIX);
-
-  mat->stype   = stype;
-  mat->storage = storage;
-
-  return mat;
-}
-
-/*
- * call-seq:
- *     new -> NMatrix
- *
- * Create a new NMatrix.
- *
- * There are several ways to do this. In every case, the constructor needs to know the dtype, the dimensions, the stype,
- * and either an initial capacity (:yale) or some number of initial values (:list needs exactly one initial value, but
- * :dense can accept an array). In many cases, the parameters can be guessed from other parameters.
- *
- * Here is the full form for a :dense 3x4 :float64 matrix initialized to alternate the values 0.0, 1.0, and 2.0:
- *
- *     NMatrix.new(:dense, [3,4], [0.0, 1.0, 2.0], :float64)
- *
- * Since :dense is the default, we can actually leave that out. Additionally, the constructor will parse 0.0 and
- * interpret that to be a :float64. So we can actually short-hand this as follows:
- *
- *     NMatrix.new([3,4], [0.0,1,2])
- *
- * Note that :list and :yale matrices will not accept a default value array. For list storage, a single default value
- * is permissible, which will be treated as the background for the sparse matrix and defaults to 0:
- *
- *     NMatrix.new(:list, [3,4], 0)     # standard :int64 sparse matrix
- *     NMatrix.new(:list, [2,3], 1.0)   # :float64 sparse matrix: [[1,1,1],[1,1,1]] (no storage used)
- *     NMatrix.new(:list, [3,4], [0,1]) # undefined behavior, will probably fill matrix with 0. Avoid this.
- *
- * For Yale storage, the default value must always be 0. Thus, if you provide an initial value, it will be interpreted
- * as the initial matrix capacity.
- *
- *     NMatrix.new(:yale, [4,3], :rational128) # Use default initial capacity. Most common.
- *     NMatrix.new(:yale, [3,4], 1000) # Error! Needs a dtype!
- *     NMatrix.new(:yale, [3,4], 1000, :int64) # Silly! Why would a 3x4 sparse matrix need storage space of 1,000?
- *     NMatrix.new(:yale, [3,4], 0.0, :float64) # Totally ignores non-sensical 3rd arg and creates 7 storage instead.
- *     NMatrix.new(:yale, [3,4], 8, :rational128) # Initial capacity of 8 rationals.
- *
- * That leaves only two other notes. First of all, if your matrix is square, you don't need to type [3,3] for 3x3.
- * Instead, just do 3:
- *
- *     NMatrix.new(3, [0,1,2], :rational128)  # dense 3x3 rational matrix consisting of columns of 0s, 1s, and 2s
- *
- * Secondly, if you create a dense matrix without initial values, you may see unpredictable results! It'll fill the
- * matrix with whatever is already in memory, not with zeros.
- *
- *     NMatrix.new(:dense, 4, :int64)
- *        # => [8, 140486578196280, 0, 0]  [0, 0, 0, 0]  [0, 0, 0, 140486608794928]  [140486577962496, -4294967280, 1, 140734734392208]
- *
- * There is one additional constructor for advanced users, which takes seven arguments and is only for creating Yale
- * matrices with known IA, JA, and A arrays. This is used primarily internally for IO, e.g., reading Matlab matrices,
- * which are stored in old Yale (not our Yale) format. But be careful; there are no overflow warnings. All of these
- * constructors are defined for power-users. Everyone else should probably resort to the shortcut functions defined in
- * shortcuts.rb.
- */
-static VALUE nm_init(int argc, VALUE* argv, VALUE nm) {
-
-  if (argc < 2) {
-  	rb_raise(rb_eArgError, "Expected 2-4 arguments (or 7 for internal Yale creation)");
-  	return Qnil;
-  }
-
-  /* First, determine stype (dense by default) */
-  nm::stype_t stype;
-  size_t  offset = 0;
-
-  if (!SYMBOL_P(argv[0]) && TYPE(argv[0]) != T_STRING) {
-    stype = nm::DENSE_STORE;
-
-  } else {
-  	// 0: String or Symbol
-    stype  = interpret_stype(argv[0]);
-    offset = 1;
-  }
-
-  // If there are 7 arguments and Yale, refer to a different init function with fewer sanity checks.
-  if (argc == 7) {
-  	if (stype == nm::YALE_STORE) {
-			return nm_init_yale_from_old_yale(argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], nm);
-
-		} else {
-			rb_raise(rb_eArgError, "Expected 2-4 arguments (or 7 for internal Yale creation)");
-		}
-  }
-
-	// 1: Array or Fixnum
-	size_t dim;
-  size_t* shape = interpret_shape(argv[offset], &dim);
-
-  // 2-3: dtype
-  nm::dtype_t dtype = interpret_dtype(argc-1-offset, argv+offset+1, stype);
-
-  size_t init_cap = 0, init_val_len = 0;
-  void* init_val  = NULL;
-  if (!SYMBOL_P(argv[1+offset]) || TYPE(argv[1+offset]) == T_ARRAY) {
-  	// Initial value provided (could also be initial capacity, if yale).
-
-    if (stype == nm::YALE_STORE && NM_RUBYVAL_IS_NUMERIC(argv[1+offset])) {
-      init_cap = FIX2UINT(argv[1+offset]);
-
-    } else {
-    	// 4: initial value / dtype
-      init_val = interpret_initial_value(argv[1+offset], dtype);
-
-      if (TYPE(argv[1+offset]) == T_ARRAY) 	init_val_len = RARRAY_LEN(argv[1+offset]);
-      else                                  init_val_len = 1;
-    }
-
-  } else {
-  	// DType is RUBYOBJ.
-
-    if (stype == nm::DENSE_STORE) {
-    	/*
-    	 * No need to initialize dense with any kind of default value unless it's
-    	 * an RUBYOBJ matrix.
-    	 */
-      if (dtype == nm::RUBYOBJ) {
-      	// Pretend [nil] was passed for RUBYOBJ.
-      	init_val = ALLOC(VALUE);
-        *(VALUE*)init_val = Qnil;
-
-        init_val_len = 1;
-
-      } else {
-      	init_val = NULL;
-      }
-    } else if (stype == nm::LIST_STORE) {
-    	init_val = ALLOC_N(char, DTYPE_SIZES[dtype]);
-      std::memset(init_val, 0, DTYPE_SIZES[dtype]);
-    }
-  }
-
-  // TODO: Update to allow an array as the initial value.
-	NMATRIX* nmatrix;
-  UnwrapNMatrix(nm, nmatrix);
-
-  nmatrix->stype = stype;
-
-  switch (stype) {
-  	case nm::DENSE_STORE:
-  		nmatrix->storage = (STORAGE*)nm_dense_storage_create(dtype, shape, dim, init_val, init_val_len);
-  		break;
-
-  	case nm::LIST_STORE:
-  		nmatrix->storage = (STORAGE*)nm_list_storage_create(dtype, shape, dim, init_val);
-  		break;
-
-  	case nm::YALE_STORE:
-  		nmatrix->storage = (STORAGE*)nm_yale_storage_create(dtype, shape, dim, init_cap, nm::UINT8);
-  		nm_yale_storage_init((YALE_STORAGE*)(nmatrix->storage), NULL);
-  		break;
-  }
-
-  return nm;
-}
-
-
-/*
- * call-seq:
- *     cast(stype) -> NMatrix
- *     cast(stype, dtype, sparse_basis) -> NMatrix
- *
- * Copy constructor for changing dtypes and stypes.
- */
-static VALUE nm_cast(VALUE self, VALUE new_stype_symbol, VALUE new_dtype_symbol, VALUE init) {
-  nm::dtype_t new_dtype = nm_dtype_from_rbsymbol(new_dtype_symbol);
-  nm::stype_t new_stype = nm_stype_from_rbsymbol(new_stype_symbol);
-
-  CheckNMatrixType(self);
-
-  NMATRIX *lhs = ALLOC(NMATRIX),
-          *rhs;
-  lhs->stype = new_stype;
-
-  UnwrapNMatrix( self, rhs );
-
-  void* init_ptr = ALLOCA_N(char, DTYPE_SIZES[new_dtype]);
-  rubyval_to_cval(init, new_dtype, init_ptr);
-
-  // Copy the storage
-  CAST_TABLE(cast_copy);
-  lhs->storage = cast_copy[lhs->stype][rhs->stype](rhs->storage, new_dtype, init_ptr);
-
-  STYPE_MARK_TABLE(mark);
-
-  return Data_Wrap_Struct(CLASS_OF(self), mark[lhs->stype], nm_delete, lhs);
-}
-
-/*
- * Copy constructor for transposing.
- */
-static VALUE nm_init_transposed(VALUE self) {
-  static STORAGE* (*storage_copy_transposed[nm::NUM_STYPES])(const STORAGE* rhs_base) = {
-    nm_dense_storage_copy_transposed,
-    nm_list_storage_copy_transposed,
-    nm_yale_storage_copy_transposed
-  };
-
-  NMATRIX* lhs = nm_create( NM_STYPE(self),
-                            storage_copy_transposed[NM_STYPE(self)]( NM_STORAGE(self) )
-                          );
-
-  STYPE_MARK_TABLE(mark);
-
-  return Data_Wrap_Struct(CLASS_OF(self), mark[lhs->stype], nm_delete, lhs);
-}
-
-/*
- * Copy constructor for no change of dtype or stype (used for #initialize_copy hook).
- */
-static VALUE nm_init_copy(VALUE copy, VALUE original) {
-  NMATRIX *lhs, *rhs;
-
-  CheckNMatrixType(original);
-
-  if (copy == original) return copy;
-
-  UnwrapNMatrix( original, rhs );
-  UnwrapNMatrix( copy,     lhs );
-
-  lhs->stype = rhs->stype;
-
-  // Copy the storage
-  CAST_TABLE(ttable);
-  lhs->storage = ttable[lhs->stype][rhs->stype](rhs->storage, rhs->storage->dtype, NULL);
-
-  return copy;
-}
-
-/*
- * Get major, minor, and release components of NMatrix::VERSION. Store in function parameters.
- */
-static void get_version_info(uint16_t& major, uint16_t& minor, uint16_t& release) {
-  // Get VERSION and split it on periods. Result is an Array.
-  VALUE version = rb_funcall(rb_const_get(cNMatrix, rb_intern("VERSION")), rb_intern("split"), 1, rb_str_new_cstr("."));
-  VALUE* ary    = RARRAY_PTR(version); // major, minor, and release
-
-  // Convert each to an integer
-  VALUE  maj    = rb_funcall(ary[0], rb_intern("to_i"), 0);
-  VALUE  min    = rb_funcall(ary[1], rb_intern("to_i"), 0);
-  VALUE  rel    = rb_funcall(ary[2], rb_intern("to_i"), 0);
-
-  major   = static_cast<uint16_t>(nm::RubyObject(maj));
-  minor   = static_cast<uint16_t>(nm::RubyObject(min));
-  release = static_cast<uint16_t>(nm::RubyObject(rel));
-}
-
-
-/*
- * Interpret the NMatrix::write symmetry argument (which should be nil or a symbol). Return a symm_t (enum).
- */
-static nm::symm_t interpret_symm(VALUE symm) {
-  if (symm == Qnil) return nm::NONSYMM;
-
-  ID rb_symm = rb_intern("symmetric"),
-     rb_skew = rb_intern("skew"),
-     rb_herm = rb_intern("hermitian");
-     // nm_rb_upper, nm_rb_lower already set
-
-  ID symm_id = rb_to_id(symm);
-
-  if (symm_id == rb_symm)            return nm::SYMM;
-  else if (symm_id == rb_skew)       return nm::SKEW;
-  else if (symm_id == rb_herm)       return nm::HERM;
-  else if (symm_id == nm_rb_upper)   return nm::UPPER;
-  else if (symm_id == nm_rb_lower)   return nm::LOWER;
-  else                            rb_raise(rb_eArgError, "unrecognized symmetry argument");
-
-  return nm::NONSYMM;
-}
-
-
-
-void read_padded_shape(std::ifstream& f, size_t dim, size_t* shape, nm::itype_t itype) {
-  NAMED_ITYPE_TEMPLATE_TABLE(ttable, nm::read_padded_shape, void, std::ifstream&, size_t, size_t*)
-
-  ttable[itype](f, dim, shape);
-}
-
-
-void write_padded_shape(std::ofstream& f, size_t dim, size_t* shape, nm::itype_t itype) {
-  NAMED_ITYPE_TEMPLATE_TABLE(ttable, nm::write_padded_shape, void, std::ofstream&, size_t, size_t*)
-
-  ttable[itype](f, dim, shape);
-}
-
-
-void read_padded_yale_elements(std::ifstream& f, YALE_STORAGE* storage, size_t length, nm::symm_t symm, nm::dtype_t dtype, nm::itype_t itype) {
-  NAMED_LI_DTYPE_TEMPLATE_TABLE_NO_ROBJ(ttable, nm::read_padded_yale_elements, void, std::ifstream&, YALE_STORAGE*, size_t, nm::symm_t)
-
-  ttable[dtype][itype](f, storage, length, symm);
-}
-
-
-void write_padded_yale_elements(std::ofstream& f, YALE_STORAGE* storage, size_t length, nm::symm_t symm, nm::dtype_t dtype, nm::itype_t itype) {
-  NAMED_LI_DTYPE_TEMPLATE_TABLE_NO_ROBJ(ttable, nm::write_padded_yale_elements, void, std::ofstream& f, YALE_STORAGE*, size_t, nm::symm_t)
-
-  ttable[dtype][itype](f, storage, length, symm);
-}
-
-
-void read_padded_dense_elements(std::ifstream& f, DENSE_STORAGE* storage, nm::symm_t symm, nm::dtype_t dtype) {
-  NAMED_DTYPE_TEMPLATE_TABLE_NO_ROBJ(ttable, nm::read_padded_dense_elements, void, std::ifstream&, DENSE_STORAGE*, nm::symm_t)
-
-  ttable[dtype](f, storage, symm);
-}
-
-
-void write_padded_dense_elements(std::ofstream& f, DENSE_STORAGE* storage, nm::symm_t symm, nm::dtype_t dtype) {
-  NAMED_DTYPE_TEMPLATE_TABLE_NO_ROBJ(ttable, nm::write_padded_dense_elements, void, std::ofstream& f, DENSE_STORAGE*, nm::symm_t)
-
-  ttable[dtype](f, storage, symm);
-}
-
-
-/*
- * Helper function to get exceptions in the module Errno (e.g., ENOENT). Example:
- *
- *     rb_raise(rb_get_errno_exc("ENOENT"), RSTRING_PTR(filename));
- */
-static VALUE rb_get_errno_exc(const char* which) {
-  return rb_const_get(rb_const_get(rb_cObject, rb_intern("Errno")), rb_intern(which));
-}
-
-
-
-/*
- * Binary file writer for NMatrix standard format. file should be a path, which we aren't going to
- * check very carefully (in other words, this function should generally be called from a Ruby
- * helper method). Function also takes a symmetry argument, which allows us to specify that we only want to
- * save the upper triangular portion of the matrix (or if the matrix is a lower triangular matrix, only
- * the lower triangular portion). nil means regular storage.
- */
-static VALUE nm_write(int argc, VALUE* argv, VALUE self) {
-  using std::ofstream;
-
-  if (argc < 1 || argc > 2) {
-    rb_raise(rb_eArgError, "Expected one or two arguments");
-  }
-  VALUE file = argv[0],
-        symm = argc == 1 ? Qnil : argv[1];
-
-  NMATRIX* nmatrix;
-  UnwrapNMatrix( self, nmatrix );
-
-  nm::symm_t symm_ = interpret_symm(symm);
-  nm::itype_t itype = (nmatrix->stype == nm::YALE_STORE) ? reinterpret_cast<YALE_STORAGE*>(nmatrix->storage)->itype : nm::UINT32;
-
-  if (nmatrix->storage->dtype == nm::RUBYOBJ) {
-    rb_raise(rb_eNotImpError, "Ruby Object writing is not implemented yet");
-  }
-
-  // Get the dtype, stype, itype, and symm and ensure they're the correct number of bytes.
-  uint8_t st = static_cast<uint8_t>(nmatrix->stype),
-          dt = static_cast<uint8_t>(nmatrix->storage->dtype),
-          sm = static_cast<uint8_t>(symm_),
-          it = static_cast<uint8_t>(itype);
-  uint16_t dim = nmatrix->storage->dim;
-
-  // Check arguments before starting to write.
-  if (nmatrix->stype == nm::LIST_STORE) rb_raise(nm_eStorageTypeError, "cannot save list matrix; cast to yale or dense first");
-  if (symm_ != nm::NONSYMM) {
-    if (dim != 2) rb_raise(rb_eArgError, "symmetry/triangularity not defined for a non-2D matrix");
-    if (nmatrix->storage->shape[0] != nmatrix->storage->shape[1])
-      rb_raise(rb_eArgError, "symmetry/triangularity not defined for a non-square matrix");
-    if (symm_ == nm::HERM &&
-          dt != static_cast<uint8_t>(nm::COMPLEX64) && dt != static_cast<uint8_t>(nm::COMPLEX128) && dt != static_cast<uint8_t>(nm::RUBYOBJ))
-      rb_raise(rb_eArgError, "cannot save a non-complex matrix as hermitian");
-  }
-
-  ofstream f(RSTRING_PTR(file), std::ios::out | std::ios::binary);
-
-  // Get the NMatrix version information.
-  uint16_t major, minor, release, null16 = 0;
-  get_version_info(major, minor, release);
-
-  // WRITE FIRST 64-BIT BLOCK
-  f.write(reinterpret_cast<const char*>(&major),   sizeof(uint16_t));
-  f.write(reinterpret_cast<const char*>(&minor),   sizeof(uint16_t));
-  f.write(reinterpret_cast<const char*>(&release), sizeof(uint16_t));
-  f.write(reinterpret_cast<const char*>(&null16),  sizeof(uint16_t));
-
-  // WRITE SECOND 64-BIT BLOCK
-  f.write(reinterpret_cast<const char*>(&dt), sizeof(uint8_t));
-  f.write(reinterpret_cast<const char*>(&st), sizeof(uint8_t));
-  f.write(reinterpret_cast<const char*>(&it), sizeof(uint8_t));
-  f.write(reinterpret_cast<const char*>(&sm), sizeof(uint8_t));
-  f.write(reinterpret_cast<const char*>(&null16), sizeof(uint16_t));
-  f.write(reinterpret_cast<const char*>(&dim), sizeof(uint16_t));
-
-  // Write shape (in 64-bit blocks)
-  write_padded_shape(f, nmatrix->storage->dim, nmatrix->storage->shape, itype);
-
-  if (nmatrix->stype == nm::DENSE_STORE) {
-    write_padded_dense_elements(f, reinterpret_cast<DENSE_STORAGE*>(nmatrix->storage), symm_, nmatrix->storage->dtype);
-  } else if (nmatrix->stype == nm::YALE_STORE) {
-    YALE_STORAGE* s = reinterpret_cast<YALE_STORAGE*>(nmatrix->storage);
-    uint32_t ndnz   = s->ndnz,
-             length = nm_yale_storage_get_size(s);
-    f.write(reinterpret_cast<const char*>(&ndnz),   sizeof(uint32_t));
-    f.write(reinterpret_cast<const char*>(&length), sizeof(uint32_t));
-
-    write_padded_yale_elements(f, s, length, symm_, s->dtype, itype);
-  }
-
-  f.close();
-
-  return Qtrue;
-}
-
-
-/*
- * Binary file reader for NMatrix standard format. file should be a path, which we aren't going to
- * check very carefully (in other words, this function should generally be called from a Ruby
- * helper method).
- *
- * Note that currently, this function will by default refuse to read files that are newer than
- * your version of NMatrix. To force an override, set the second argument to anything other than nil.
- *
- * Returns an NMatrix Ruby object.
- */
-static VALUE nm_read(int argc, VALUE* argv, VALUE self) {
-  using std::ifstream;
-
-  VALUE file, force_;
-
-  // Read the arguments
-  rb_scan_args(argc, argv, "11", &file, &force_);
-  bool force   = (force_ != Qnil && force_ != Qfalse);
-
-
-  if (!RB_FILE_EXISTS(file)) { // FIXME: Errno::ENOENT
-    rb_raise(rb_get_errno_exc("ENOENT"), "%s", RSTRING_PTR(file));
-  }
-
-  // Open a file stream
-  ifstream f(RSTRING_PTR(file), std::ios::in | std::ios::binary);
-
-  uint16_t major, minor, release;
-  get_version_info(major, minor, release); // compare to NMatrix version
-
-  uint16_t fmajor, fminor, frelease, null16;
-
-  // READ FIRST 64-BIT BLOCK
-  f.read(reinterpret_cast<char*>(&fmajor),   sizeof(uint16_t));
-  f.read(reinterpret_cast<char*>(&fminor),   sizeof(uint16_t));
-  f.read(reinterpret_cast<char*>(&frelease), sizeof(uint16_t));
-  f.read(reinterpret_cast<char*>(&null16),   sizeof(uint16_t));
-
-  int ver  = major * 10000 + minor * 100 + release,
-      fver = fmajor * 10000 + fminor * 100 + release;
-  if (fver > ver && force == false) {
-    rb_raise(rb_eIOError, "File was created in newer version of NMatrix than current");
-  }
-  if (null16 != 0) fprintf(stderr, "Warning: Expected zero padding was not zero\n");
-
-  uint8_t dt, st, it, sm;
-  uint16_t dim;
-
-  // READ SECOND 64-BIT BLOCK
-  f.read(reinterpret_cast<char*>(&dt), sizeof(uint8_t));
-  f.read(reinterpret_cast<char*>(&st), sizeof(uint8_t));
-  f.read(reinterpret_cast<char*>(&it), sizeof(uint8_t));
-  f.read(reinterpret_cast<char*>(&sm), sizeof(uint8_t));
-  f.read(reinterpret_cast<char*>(&null16), sizeof(uint16_t));
-  f.read(reinterpret_cast<char*>(&dim), sizeof(uint16_t));
-
-  if (null16 != 0) fprintf(stderr, "Warning: Expected zero padding was not zero\n");
-  nm::stype_t stype = static_cast<nm::stype_t>(st);
-  nm::dtype_t dtype = static_cast<nm::dtype_t>(dt);
-  nm::symm_t  symm  = static_cast<nm::symm_t>(sm);
-  nm::itype_t itype = static_cast<nm::itype_t>(it);
-
-  // READ NEXT FEW 64-BIT BLOCKS
-  size_t* shape = ALLOC_N(size_t, dim);
-  read_padded_shape(f, dim, shape, itype);
-
-  STORAGE* s;
-  if (stype == nm::DENSE_STORE) {
-    s = nm_dense_storage_create(dtype, shape, dim, NULL, 0);
-
-    read_padded_dense_elements(f, reinterpret_cast<DENSE_STORAGE*>(s), symm, dtype);
-
-  } else if (stype == nm::YALE_STORE) {
-    uint32_t ndnz, length;
-
-    // READ YALE-SPECIFIC 64-BIT BLOCK
-    f.read(reinterpret_cast<char*>(&ndnz),     sizeof(uint32_t));
-    f.read(reinterpret_cast<char*>(&length),   sizeof(uint32_t));
-
-    s = nm_yale_storage_create(dtype, shape, dim, length, itype); // set length as init capacity
-
-    read_padded_yale_elements(f, reinterpret_cast<YALE_STORAGE*>(s), length, symm, dtype, itype);
-  } else {
-    rb_raise(nm_eStorageTypeError, "please convert to yale or dense before saving");
-  }
-
-  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(cNMatrix, nm_dense_storage_mark, nm_delete, nm);
-  case nm::YALE_STORE:
-    return Data_Wrap_Struct(cNMatrix, nm_yale_storage_mark, nm_delete, nm);
-  default:
-    return Qnil;
-  }
-
-}
-
-
-
-/*
- * Create a new NMatrix helper for handling internal ia, ja, and a arguments.
- *
- * This constructor is only called by Ruby code, so we can skip most of the
- * checks.
- */
-static VALUE nm_init_yale_from_old_yale(VALUE shape, VALUE dtype, VALUE ia, VALUE ja, VALUE a, VALUE from_dtype, VALUE nm) {
-  size_t dim     = 2;
-  size_t* shape_  = interpret_shape(shape, &dim);
-  nm::dtype_t dtype_  = nm_dtype_from_rbsymbol(dtype);
-  char *ia_       = RSTRING_PTR(ia),
-       *ja_       = RSTRING_PTR(ja),
-       *a_        = RSTRING_PTR(a);
-  nm::dtype_t from_dtype_ = nm_dtype_from_rbsymbol(from_dtype);
-  NMATRIX* nmatrix;
-
-  UnwrapNMatrix( nm, nmatrix );
-
-  nmatrix->stype   = nm::YALE_STORE;
-  nmatrix->storage = (STORAGE*)nm_yale_storage_create_from_old_yale(dtype_, shape_, ia_, ja_, a_, from_dtype_);
-
-  return nm;
-}
-
-/*
- * Check to determine whether matrix is a reference to another matrix.
- */
-static VALUE nm_is_ref(VALUE self) {
-  if (NM_SRC(self) == NM_STORAGE(self)) return Qfalse;
-  else                                  return Qtrue;
-}
-
-/*
- * call-seq:
- *     slice -> ...
- *
- * Access the contents of an NMatrix at given coordinates, using copying.
- *
- *     n.slice(3,3)  # => 5.0
- *     n.slice(0..1,0..1) #=> matrix [2,2]
- *
- */
-static VALUE nm_mget(int argc, VALUE* argv, VALUE self) {
-  static void* (*ttable[nm::NUM_STYPES])(STORAGE*, SLICE*) = {
-    nm_dense_storage_get,
-    nm_list_storage_get,
-    nm_yale_storage_get
-  };
-  return nm_xslice(argc, argv, ttable[NM_STYPE(self)], nm_delete, self);
-}
-
-/*
- * call-seq:
- *     matrix[indices] -> ...
- *
- * Access the contents of an NMatrix at given coordinates by reference.
- *
- *     n[3,3]  # => 5.0
- *     n[0..1,0..1] #=> matrix [2,2]
- *
- */
-static VALUE nm_mref(int argc, VALUE* argv, VALUE self) {
-  static void* (*ttable[nm::NUM_STYPES])(STORAGE*, SLICE*) = {
-    nm_dense_storage_ref,
-    nm_list_storage_ref,
-    nm_yale_storage_ref
-  };
-  return nm_xslice(argc, argv, ttable[NM_STYPE(self)], nm_delete_ref, self);
-}
-
-/*
- * Modify the contents of an NMatrix in the given cell
- *
- *     n[3,3] = 5.0
- *
- * Also returns the new contents, so you can chain:
- *
- *     n[3,3] = n[2,3] = 5.0
- */
-static VALUE nm_mset(int argc, VALUE* argv, VALUE self) {
-  size_t dim = NM_DIM(self); // last arg is the value
-
-  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[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);
-      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)])) {
-        xfree(value);
-        value = nm_list_storage_remove(NM_STORAGE(self), slice);
-        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.
-      }
-      break;
-    case nm::YALE_STORE:
-      nm_yale_storage_set(NM_STORAGE(self), slice, value);
-      xfree(value);
-      break;
-    }
-    free_slice(slice);
-
-    return argv[argc-1];
-  }
-  return Qnil;
-}
-
-/*
- * Matrix multiply (dot product): against another matrix or a vector.
- *
- * For elementwise, use * instead.
- *
- * The two matrices must be of the same stype (for now). If dtype differs, an upcast will occur.
- */
-static VALUE nm_multiply(VALUE left_v, VALUE right_v) {
-  NMATRIX *left, *right;
-
-  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, "please convert array to nx1 or 1xn NMatrix first");
-
-  else { // both are matrices (probably)
-    CheckNMatrixType(right_v);
-    UnwrapNMatrix( right_v, right );
-
-    if (left->storage->shape[1] != right->storage->shape[0])
-      rb_raise(rb_eArgError, "incompatible dimensions");
-
-    if (left->stype != right->stype)
-      rb_raise(rb_eNotImpError, "matrices must have same stype");
-
-    return matrix_multiply(left, right);
-
-  }
-
-  return Qnil;
-}
-
-
-/*
- * call-seq:
- *     dim -> Integer
- *
- * Get the number of dimensions of a matrix.
- *
- * 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.
- *
- * 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);
-}
-
-/*
- * call-seq:
- *     shape -> Array
- *
- * Get the shape (dimensions) of a matrix.
- */
-static VALUE nm_shape(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* 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);
-}
-
-
-/*
- * 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);
-}
-
-/*
- * call-seq:
- *     stype -> Symbol
- *
- * Get the storage type (stype) of a matrix, e.g., :yale, :dense, or :list.
- */
-static VALUE nm_stype(VALUE self) {
-  ID stype = rb_intern(STYPE_NAMES[NM_STYPE(self)]);
-  return ID2SYM(stype);
-}
-
-/*
- * call-seq:
- *     symmetric? -> Boolean
- *
- * Is this matrix symmetric?
- */
-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)) {
-    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*) = {
-        nm_dense_storage_ref,
-        nm_list_storage_ref,
-        nm_yale_storage_ref
-      };
-
-      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)( s, slice ));
-
-      result        = Data_Wrap_Struct(CLASS_OF(self), mark_table[mat->stype], delete_func, mat);
-    }
-
-    free_slice(slice);
-  }
-
-  return result;
-}
-
-//////////////////////
-// Helper Functions //
-//////////////////////
-
-static VALUE elementwise_op(nm::ewop_t op, VALUE left_val, VALUE right_val) {
-	STYPE_MARK_TABLE(mark);
-
-	NMATRIX* left;
-	NMATRIX* result;
-
-	CheckNMatrixType(left_val);
-	UnwrapNMatrix(left_val, left);
-
-  if (TYPE(right_val) != T_DATA || (RDATA(right_val)->dfree != (RUBY_DATA_FUNC)nm_delete && RDATA(right_val)->dfree != (RUBY_DATA_FUNC)nm_delete_ref)) {
-    // This is a matrix-scalar element-wise operation.
-    std::string sym;
-    switch(left->stype) {
-    case nm::DENSE_STORE:
-      sym = "__dense_scalar_" + nm::EWOP_NAMES[op] + "__";
-      break;
-    case nm::YALE_STORE:
-      sym = "__yale_scalar_" + nm::EWOP_NAMES[op] + "__";
-      break;
-    case nm::LIST_STORE:
-      sym = "__list_scalar_" + nm::EWOP_NAMES[op] + "__";
-      break;
-    default:
-      rb_raise(rb_eNotImpError, "unknown storage type requested scalar element-wise operation");
-    }
-    return rb_funcall(left_val, rb_intern(sym.c_str()), 1, right_val);
-
-  } else {
-
-    // Check that the left- and right-hand sides have the same dimensionality.
-    if (NM_DIM(left_val) != NM_DIM(right_val)) {
-      rb_raise(rb_eArgError, "The left- and right-hand sides of the operation must have the same dimensionality.");
-    }
-
-    // Check that the left- and right-hand sides have the same shape.
-    if (memcmp(&NM_SHAPE(left_val, 0), &NM_SHAPE(right_val, 0), sizeof(size_t) * NM_DIM(left_val)) != 0) {
-      rb_raise(rb_eArgError, "The left- and right-hand sides of the operation must have the same shape.");
-    }
-
-    NMATRIX* right;
-    UnwrapNMatrix(right_val, right);
-
-    if (left->stype == right->stype) {
-      std::string sym;
-
-      switch(left->stype) {
-      case nm::DENSE_STORE:
-        sym = "__dense_elementwise_" + nm::EWOP_NAMES[op] + "__";
-        break;
-      case nm::YALE_STORE:
-        sym = "__yale_elementwise_" + nm::EWOP_NAMES[op] + "__";
-        break;
-      case nm::LIST_STORE:
-        sym = "__list_elementwise_" + nm::EWOP_NAMES[op] + "__";
-        break;
-      default:
-        rb_raise(rb_eNotImpError, "unknown storage type requested element-wise operation");
-      }
-      return rb_funcall(left_val, rb_intern(sym.c_str()), 1, right_val);
-
-    } else {
-      rb_raise(rb_eArgError, "Element-wise operations are not currently supported between matrices with differing stypes.");
-    }
-  }
-
-	return Data_Wrap_Struct(CLASS_OF(left_val), mark[result->stype], nm_delete, result);
-}
-
-/*
- * Check to determine whether matrix is a reference to another matrix.
- */
-bool is_ref(const NMATRIX* matrix) {
-  return matrix->storage->src != matrix->storage;
-}
-
-/*
- * Helper function for nm_symmetric and nm_hermitian.
- */
-static VALUE is_symmetric(VALUE self, bool hermitian) {
-  NMATRIX* m;
-  UnwrapNMatrix(self, m);
-
-  if (m->storage->shape[0] == m->storage->shape[1] and m->storage->dim == 2) {
-		if (NM_STYPE(self) == nm::DENSE_STORE) {
-      if (hermitian) {
-        nm_dense_storage_is_hermitian((DENSE_STORAGE*)(m->storage), m->storage->shape[0]);
-
-      } else {
-      	nm_dense_storage_is_symmetric((DENSE_STORAGE*)(m->storage), m->storage->shape[0]);
-      }
-
-    } else {
-      // TODO: Implement, at the very least, yale_is_symmetric. Model it after yale/transp.template.c.
-      rb_raise(rb_eNotImpError, "symmetric? and hermitian? only implemented for dense currently");
-    }
-
-  }
-
-  return Qfalse;
-}
-
-///////////////////////
-// Utility Functions //
-///////////////////////
-
-/*
- * Guess the dtype given a Ruby VALUE and return it as a symbol.
- *
- * Not to be confused with nm_dtype_guess, which returns an nm::dtype_t. (This calls that.)
- */
-static VALUE nm_guess_dtype(VALUE self, VALUE v) {
-  return ID2SYM(rb_intern(DTYPE_NAMES[nm_dtype_guess(v)]));
-}
-
-/*
- * Get the minimum allowable dtype for a Ruby VALUE and return it as a symbol.
- */
-static VALUE nm_min_dtype(VALUE self, VALUE v) {
-  return ID2SYM(rb_intern(DTYPE_NAMES[nm_dtype_min(v)]));
-}
-
-/*
- * Helper for nm_dtype_min(), handling integers.
- */
-nm::dtype_t nm_dtype_min_fixnum(int64_t v) {
-  if (v >= 0 && v <= UCHAR_MAX) return nm::BYTE;
-  else {
-    v = std::abs(v);
-    if (v <= CHAR_MAX) return nm::INT8;
-    else if (v <= SHRT_MAX) return nm::INT16;
-    else if (v <= INT_MAX) return nm::INT32;
-    else return nm::INT64;
-  }
-}
-
-/*
- * Helper for nm_dtype_min(), handling rationals.
- */
-nm::dtype_t nm_dtype_min_rational(VALUE vv) {
-  nm::Rational128* v = ALLOCA_N(nm::Rational128, 1);
-  rubyval_to_cval(vv, nm::RATIONAL128, v);
-
-  int64_t i = std::max(std::abs(v->n), v->d);
-  if (i <= SHRT_MAX) return nm::INT16;
-  else if (i <= INT_MAX) return nm::INT32;
-  else return nm::INT64;
-}
-
-/*
- * Return the minimum dtype required to store a given value.
- *
- * This is kind of arbitrary. For Float, it always returns :float32 for example, since in some cases neither :float64
- * not :float32 are sufficient.
- *
- * This function is used in upcasting for scalar math. We want to ensure that :int8 + 1 does not return an :int64, basically.
- *
- * FIXME: Eventually, this function should actually look at the value stored in Fixnums (for example), so that it knows
- * whether to return :int64 or :int32.
- */
-nm::dtype_t nm_dtype_min(VALUE v) {
-
-  switch(TYPE(v)) {
-  case T_FIXNUM:
-    return nm_dtype_min_fixnum(FIX2LONG(v));
-  case T_BIGNUM:
-    return nm::INT64;
-  case T_FLOAT:
-    return nm::FLOAT32;
-  case T_COMPLEX:
-    return nm::COMPLEX64;
-  case T_RATIONAL:
-    return nm_dtype_min_rational(v);
-  case T_STRING:
-    return RSTRING_LEN(v) == 1 ? nm::BYTE : nm::RUBYOBJ;
-  case T_TRUE:
-  case T_FALSE:
-  case T_NIL:
-  default:
-    return nm::RUBYOBJ;
-  }
-}
-
-
-/*
- * Guess the data type given a value.
- *
- * TODO: Probably needs some work for Bignum.
- */
-nm::dtype_t nm_dtype_guess(VALUE v) {
-  switch(TYPE(v)) {
-  case T_TRUE:
-  case T_FALSE:
-  case T_NIL:
-    return nm::RUBYOBJ;
-  case T_STRING:
-    return RSTRING_LEN(v) == 1 ? nm::BYTE : nm::RUBYOBJ;
-
-#if SIZEOF_INT == 8
-  case T_FIXNUM:
-    return nm::INT64;
-
-  case T_RATIONAL:
-    return nm::RATIONAL128;
-
-#else
-# if SIZEOF_INT == 4
-  case T_FIXNUM:
-    return nm::INT32;
-
-  case T_RATIONAL:
-    return nm::RATIONAL64;
-
-#else
-  case T_FIXNUM:
-    return nm::INT16;
-
-  case T_RATIONAL:
-    return nm::RATIONAL32;
-# endif
-#endif
-
-  case T_BIGNUM:
-    return nm::INT64;
-
-#if SIZEOF_FLOAT == 4
-  case T_COMPLEX:
-    return nm::COMPLEX128;
-
-  case T_FLOAT:
-    return nm::FLOAT64;
-
-#else
-# if SIZEOF_FLOAT == 2
-  case T_COMPLEX:
-    return nm::COMPLEX64;
-
-  case T_FLOAT:
-    return nm::FLOAT32;
-# endif
-#endif
-
-  case T_ARRAY:
-  	/*
-  	 * May be passed for dense -- for now, just look at the first element.
-     *
-  	 * TODO: Look at entire array for most specific type.
-  	 */
-
-    return nm_dtype_guess(RARRAY_PTR(v)[0]);
-
-  default:
-    rb_raise(rb_eArgError, "Unable to guess a data type from provided parameters; data type must be specified manually.");
-  }
-}
-
-
-
-/*
- * 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, int argc, VALUE* arg, size_t* shape) {
-  VALUE beg, end;
-  int excl;
-
-  SLICE* slice = alloc_slice(dim);
-  slice->single = true;
-
-  // 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;
-
-    } else if (FIXNUM_P(v)) { // this used CLASS_OF before, which is inefficient for fixnum
-
-      slice->coords[r]  = FIX2UINT(v);
-      slice->lengths[r] = 1;
-      t++;
-
-    } 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];
-
-      if (RHASH_EMPTY_P(v)) t++; // go on to the next
-
-      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, "expected Fixnum, Range, or Hash for slice component instead of %s", rb_obj_classname(v));
-    }
-
-    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;
-}
-
-#ifdef BENCHMARK
-/*
- * A simple function used when benchmarking NMatrix.
- */
-static double get_time(void) {
-  struct timeval t;
-  struct timezone tzp;
-
-  gettimeofday(&t, &tzp);
-
-  return t.tv_sec + t.tv_usec*1e-6;
-}
-#endif
-
-/*
- * The argv parameter will be either 1 or 2 elements.  If 1, could be either
- * initial or dtype.  If 2, is initial and dtype. This function returns the
- * dtype.
- */
-static nm::dtype_t interpret_dtype(int argc, VALUE* argv, nm::stype_t stype) {
-  int offset;
-
-  switch (argc) {
-  	case 1:
-  		offset = 0;
-  		break;
-
-  	case 2:
-  		offset = 1;
-  		break;
-
-  	default:
-  		rb_raise(rb_eArgError, "Need an initial value or a dtype.");
-  		break;
-  }
-
-  if (SYMBOL_P(argv[offset])) {
-  	return nm_dtype_from_rbsymbol(argv[offset]);
-
-  } else if (TYPE(argv[offset]) == T_STRING) {
-  	return nm_dtype_from_rbstring(StringValue(argv[offset]));
-
-  } else if (stype == nm::YALE_STORE) {
-  	rb_raise(rb_eArgError, "Yale storage class requires a dtype.");
-
-  } else {
-  	return nm_dtype_guess(argv[0]);
-  }
-}
-
-/*
- * Convert an Ruby value or an array of Ruby values into initial C values.
- */
-static void* interpret_initial_value(VALUE arg, nm::dtype_t dtype) {
-  unsigned int index;
-  void* init_val;
-
-  if (TYPE(arg) == T_ARRAY) {
-  	// Array
-
-    init_val = ALLOC_N(int8_t, DTYPE_SIZES[dtype] * RARRAY_LEN(arg));
-    for (index = 0; index < RARRAY_LEN(arg); ++index) {
-    	rubyval_to_cval(RARRAY_PTR(arg)[index], dtype, (char*)init_val + (index * DTYPE_SIZES[dtype]));
-    }
-
-  } else {
-  	// Single value
-
-    init_val = rubyobj_to_cval(arg, dtype);
-  }
-
-  return init_val;
-}
-
-/*
- * Convert the shape argument, which may be either a Ruby value or an array of
- * Ruby values, into C values.  The second argument is where the dimensionality
- * of the matrix will be stored.  The function itself returns a pointer to the
- * array describing the shape, which must be freed manually.
- */
-static size_t* interpret_shape(VALUE arg, size_t* dim) {
-  size_t* shape;
-
-  if (TYPE(arg) == T_ARRAY) {
-    *dim = RARRAY_LEN(arg);
-    shape = ALLOC_N(size_t, *dim);
-
-    for (size_t index = 0; index < *dim; ++index) {
-      shape[index] = FIX2UINT( RARRAY_PTR(arg)[index] );
-    }
-
-  } else if (FIXNUM_P(arg)) {
-    *dim = 2;
-    shape = ALLOC_N(size_t, *dim);
-
-    shape[0] = FIX2UINT(arg);
-    shape[1] = FIX2UINT(arg);
-
-  } else {
-    rb_raise(rb_eArgError, "Expected an array of numbers or a single Fixnum for matrix shape");
-  }
-
-  return shape;
-}
-
-/*
- * Convert a Ruby symbol or string into an storage type.
- */
-static nm::stype_t interpret_stype(VALUE arg) {
-  if (SYMBOL_P(arg)) {
-  	return nm_stype_from_rbsymbol(arg);
-
-  } else if (TYPE(arg) == T_STRING) {
-  	return nm_stype_from_rbstring(StringValue(arg));
-
-  } else {
-  	rb_raise(rb_eArgError, "Expected storage type");
-  }
-}
-
-//////////////////
-// Math Helpers //
-//////////////////
-
-STORAGE* matrix_storage_cast_alloc(NMATRIX* matrix, nm::dtype_t new_dtype) {
-  if (matrix->storage->dtype == new_dtype && !is_ref(matrix))
-    return matrix->storage;
-
-  CAST_TABLE(cast_copy_storage);
-  return cast_copy_storage[matrix->stype][matrix->stype](matrix->storage, new_dtype, NULL);
-}
-
-STORAGE_PAIR binary_storage_cast_alloc(NMATRIX* left_matrix, NMATRIX* right_matrix) {
-  STORAGE_PAIR casted;
-  nm::dtype_t new_dtype = Upcast[left_matrix->storage->dtype][right_matrix->storage->dtype];
-
-  casted.left  = matrix_storage_cast_alloc(left_matrix, new_dtype);
-  casted.right = matrix_storage_cast_alloc(right_matrix, new_dtype);
-
-  return casted;
-}
-
-static VALUE matrix_multiply_scalar(NMATRIX* left, VALUE scalar) {
-  rb_raise(rb_eNotImpError, "matrix-scalar multiplication not implemented yet");
-  return Qnil;
-}
-
-static VALUE matrix_multiply(NMATRIX* left, NMATRIX* right) {
-  ///TODO: multiplication for non-dense and/or non-decimal matrices
-
-  // Make sure both of our matrices are of the correct type.
-  STORAGE_PAIR casted = binary_storage_cast_alloc(left, right);
-
-  size_t*  resulting_shape   = ALLOC_N(size_t, 2);
-  resulting_shape[0] = left->storage->shape[0];
-  resulting_shape[1] = right->storage->shape[1];
-
-  // Sometimes we only need to use matrix-vector multiplication (e.g., GEMM versus GEMV). Find out.
-  bool vector = false;
-  if (resulting_shape[1] == 1) vector = true;
-
-  static STORAGE* (*storage_matrix_multiply[nm::NUM_STYPES])(const STORAGE_PAIR&, size_t*, bool) = {
-    nm_dense_storage_matrix_multiply,
-    nm_list_storage_matrix_multiply,
-    nm_yale_storage_matrix_multiply
-  };
-
-  STORAGE* resulting_storage = storage_matrix_multiply[left->stype](casted, resulting_shape, vector);
-  NMATRIX* result = nm_create(left->stype, resulting_storage);
-
-  // Free any casted-storage we created for the multiplication.
-  // TODO: Can we make the Ruby GC take care of this stuff now that we're using it?
-  // If we did that, we night not have to re-create these every time, right? Or wrong? Need to do
-  // more research.
-  static void (*free_storage[nm::NUM_STYPES])(STORAGE*) = {
-    nm_dense_storage_delete,
-    nm_list_storage_delete,
-    nm_yale_storage_delete
-  };
-
-  if (left->storage != casted.left)   free_storage[result->stype](casted.left);
-  if (right->storage != casted.right) free_storage[result->stype](casted.right);
-
-
-  STYPE_MARK_TABLE(mark_table);
-
-  if (result) return Data_Wrap_Struct(cNMatrix, mark_table[result->stype], nm_delete, result);
-  return Qnil; // Only if we try to multiply list matrices should we return Qnil.
-}
-
-/*
- * Calculate the exact determinant of a dense matrix.
- *
- * Returns nil for dense matrices which are not square or number of dimensions other than 2.
- *
- * Note: Currently only implemented for 2x2 and 3x3 matrices.
- */
-static VALUE nm_det_exact(VALUE self) {
-  if (NM_STYPE(self) != nm::DENSE_STORE) rb_raise(nm_eStorageTypeError, "can only calculate exact determinant for dense matrices");
-
-  if (NM_DIM(self) != 2 || NM_SHAPE0(self) != NM_SHAPE1(self)) return Qnil;
-
-  // Calculate the determinant and then assign it to the return value
-  void* result = ALLOCA_N(char, DTYPE_SIZES[NM_DTYPE(self)]);
-  nm_math_det_exact(NM_SHAPE0(self), NM_STORAGE_DENSE(self)->elements, NM_SHAPE0(self), NM_DTYPE(self), result);
-
-  return rubyobj_from_cval(result, NM_DTYPE(self)).rval;
-}
-
-/////////////////
-// Exposed API //
-/////////////////
-
-/*
- * Create a dense matrix. Used by the NMatrix GSL fork. Unlike nm_create, this one copies all of the
- * arrays and such passed in -- so you don't have to allocate and pass a new shape object for every
- * matrix you want to create, for example. Same goes for elements.
- *
- * 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;
-  size_t nm_dim;
-  size_t* shape_copy;
-
-  // Do not allow a dim of 1. Treat it as a column or row matrix.
-  if (dim == 1) {
-    nm_dim				= 2;
-    shape_copy		= ALLOC_N(size_t, nm_dim);
-    shape_copy[0]	= shape[0];
-    shape_copy[1]	= 1;
-
-  } else {
-    nm_dim			= dim;
-    shape_copy	= ALLOC_N(size_t, nm_dim);
-    memcpy(shape_copy, shape, sizeof(size_t)*nm_dim);
-  }
-
-  // Copy elements
-  void* elements_copy = ALLOC_N(char, DTYPE_SIZES[dtype]*length);
-  memcpy(elements_copy, elements, DTYPE_SIZES[dtype]*length);
-
-  // allocate and create the matrix and its storage
-  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(cNMatrix, nm_dense_storage_mark, nm_dense_storage_delete, nm);
-}
-
-/*
- * Create a dense vector. Used by the NMatrix GSL fork.
- *
- * Basically just a convenience wrapper for rb_nmatrix_dense_create().
- *
- * 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;
-  return rb_nmatrix_dense_create(dtype, &shape, dim, elements, length);
-}
-
+  #include "ruby_nmatrix.c"
 } // end of extern "C"