nmatrix 0.0.5 → 0.0.6

data/ext/nmatrix/data/rational.h

@@ -91,6 +91,8 @@ class Rational {
 	  rb_raise(rb_eNotImpError, "cannot convert from complex to rational");
 	}
 
+	Rational(const RubyObject& other);
+
   /*
    * Rational inverse function -- creates a copy, but inverted.
    */

data/ext/nmatrix/data/ruby_object.h

@@ -96,6 +96,7 @@ class RubyObject {
 	inline RubyObject(int64_t other)  : rval(INT2FIX(other)) {}
 //	inline RubyObject(uint64_t other) : rval(INT2FIX(other)) {}
 
+
 	/*
 	 * Float constructor.
 	 *
@@ -103,7 +104,40 @@ class RubyObject {
 	 */
 	inline RubyObject(float other)   : rval(rb_float_new(other)) {}
 	inline RubyObject(double other)  : rval(rb_float_new(other)) {}
-	
+
+  /*
+   * Operators for converting RubyObjects to other C types.
+   */
+
+#define RETURN_OBJ2NUM(mac)   if (this->rval == Qtrue) return 1; else if (this->rval == Qfalse) return 0; else return mac(this->rval);
+
+  inline operator int8_t()  const { RETURN_OBJ2NUM(NUM2INT)         }
+  inline operator uint8_t() const { RETURN_OBJ2NUM(NUM2UINT)        }
+  inline operator int16_t() const { RETURN_OBJ2NUM(NUM2INT)         }
+  inline operator uint16_t() const { RETURN_OBJ2NUM(NUM2UINT)       }
+  inline operator int32_t() const { RETURN_OBJ2NUM(NUM2LONG)        }
+  inline operator VALUE() const { return rval; }
+  //inline operator uint32_t() const { return NUM2ULONG(this->rval);      }
+  inline operator int64_t() const { RETURN_OBJ2NUM(NUM2LONG)        }
+  inline operator uint64_t() const { RETURN_OBJ2NUM(NUM2ULONG)      }
+  inline operator double()   const { RETURN_OBJ2NUM(NUM2DBL)        }
+  inline operator float()  const { RETURN_OBJ2NUM(NUM2DBL)          }
+
+  //template <typename IntType>
+  //inline operator Rational<typename std::enable_if<std::is_integral<IntType>::value, IntType>::type>() const { return this->to<Rational<IntType> >(); }
+
+  //template <typename IntType>
+  //inline operator Rational<typename std::enable_if<std::is_integral<IntType>::value, IntType>::type>&() const { static Rational<IntType> x = this->to<Rational<IntType> >(); return x; }
+  //inline operator Rational32() const { return this->to<Rational32>();   }
+  //inline operator Rational64() const { return this->to<Rational64>();   }
+  //inline operator Rational128() const { return this->to<Rational128>(); }
+
+  //template <typename FloatType>
+  //inline operator Complex<typename std::enable_if<std::is_floating_point<FloatType>::value, FloatType>::type>() const { return this->to<Complex<FloatType> >();    }
+
+  //template <typename FloatType>
+  //inline operator Complex<typename std::enable_if<std::is_floating_point<FloatType>::value, FloatType>::type>&() const { static Complex<FloatType> x = this->to<Complex<FloatType> >(); return x;    }
+
   /*
 	 * Copy constructors.
 	 */
@@ -278,7 +312,7 @@ class RubyObject {
 	 * Convert a Ruby object to a complex number.
 	 */
 	template <typename ComplexType>
-	inline typename std::enable_if<made_from_same_template<ComplexType, Complex64>::value, ComplexType>::type to(void) {
+	inline typename std::enable_if<made_from_same_template<ComplexType, Complex64>::value, ComplexType>::type to(void) const {
 		if (FIXNUM_P(this->rval) or TYPE(this->rval) == T_FLOAT or TYPE(this->rval) == T_RATIONAL) {
 			return ComplexType(NUM2DBL(this->rval));
 			
@@ -294,7 +328,7 @@ class RubyObject {
 	 * Convert a Ruby object to a rational number.
 	 */
 	template <typename RationalType>
-	inline typename std::enable_if<made_from_same_template<RationalType, Rational32>::value, RationalType>::type to(void) {
+	inline typename std::enable_if<made_from_same_template<RationalType, Rational32>::value, RationalType>::type to(void) const {
 		if (FIXNUM_P(this->rval) or TYPE(this->rval) == T_FLOAT or TYPE(this->rval) == T_COMPLEX) {
 			return RationalType(NUM2INT(this->rval));
 			
@@ -305,11 +339,7 @@ class RubyObject {
 			rb_raise(rb_eTypeError, "Invalid conversion to Rational type.");
 		}
 	}
-	
-	template <typename OtherType>
-	inline operator OtherType () {
-		return to<OtherType>();
-	}
+
 };
 
 // Negative operator

data/ext/nmatrix/extconf.rb

@@ -164,10 +164,14 @@ $objs = %w{nmatrix ruby_constants data/data util/io util/math util/sl_list stora
 CONFIG['CXX'] = 'g++'
 
 def find_newer_gplusplus #:nodoc:
-  [8,7,6,5,4,3].each do |minor|
-    result = `which g++-4.#{minor}`
+  print "checking for apparent GNU g++ binary with C++0x/C++11 support... "
+  [9,8,7,6,5,4,3].each do |minor|
+    ver = "4.#{minor}"
+    gpp = "g++-#{ver}"
+    result = `which #{gpp}`
     next if result.empty?
-    CONFIG['CXX'] = "g++-4.#{minor}"
+    CONFIG['CXX'] = gpp
+    puts ver
     return CONFIG['CXX']
   end
   false
@@ -195,13 +199,15 @@ else
   else
     $CPP_STANDARD = 'c++11'
   end
+  puts "using C++ standard... #{$CPP_STANDARD}"
+  puts "g++ reports version... " + `#{CONFIG['CXX']} --version|head -n 1|cut -f 3 -d " "`
 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', '')

data/ext/nmatrix/nmatrix.cpp

@@ -50,6 +50,8 @@ extern "C" {
 #include "util/math.h"
 #include "util/io.h"
 #include "storage/storage.h"
+#include "storage/list.h"
+#include "storage/yale.h"
 
 #include "nmatrix.h"
 
@@ -329,21 +331,19 @@ extern "C" {
 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_init_cast_copy(VALUE self, VALUE new_stype_symbol, VALUE new_dtype_symbol);
+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_to_hash(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 void  nm_delete(NMATRIX* mat);
-static void  nm_delete_ref(NMATRIX* mat);
 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 VALUE nm_dim(VALUE self);
 static VALUE nm_shape(VALUE self);
 static VALUE nm_capacity(VALUE self);
-static VALUE nm_each(VALUE nmatrix);
+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);
@@ -355,6 +355,9 @@ 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.
  *
@@ -374,6 +377,8 @@ 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)
@@ -417,17 +422,17 @@ 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.
 	 */
@@ -436,7 +441,7 @@ void Init_nmatrix() {
 	///////////////////
 	// Class Methods //
 	///////////////////
-	
+
 	rb_define_alloc_func(cNMatrix, nm_alloc);
 
 	///////////////////////
@@ -445,6 +450,8 @@ void Init_nmatrix() {
 
 	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 //
@@ -462,7 +469,10 @@ void Init_nmatrix() {
 	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",  (METHOD)nm_init_cast_copy, 2);
+	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);
@@ -470,16 +480,21 @@ void Init_nmatrix() {
 	rb_define_method(cNMatrix, "is_ref?", (METHOD)nm_is_ref, 0);
 	rb_define_method(cNMatrix, "dimensions", (METHOD)nm_dim, 0);
 
-	rb_define_protected_method(cNMatrix, "to_hash_c", (METHOD)nm_to_hash, 0); // handles list and dense, which are n-dimensional
-	//rb_define_alias(cNMatrix,  "to_h",    "to_hash");
+	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, "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_method(cNMatrix, "each", (METHOD)nm_each, 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);
 
@@ -487,7 +502,8 @@ void Init_nmatrix() {
 	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_mod,			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);
@@ -496,6 +512,11 @@ void Init_nmatrix() {
 	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 //
 	/////////////////////////
@@ -507,18 +528,18 @@ void Init_nmatrix() {
 	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, "equal?", "eql?");
-	
+
 	///////////////////////
 	// Symbol Generation //
 	///////////////////////
-	
+
 	nm_init_ruby_constants();
 
 	//////////////////////////
@@ -611,7 +632,7 @@ static VALUE nm_capacity(VALUE self) {
 /*
  * Destructor.
  */
-static void nm_delete(NMATRIX* mat) {
+void nm_delete(NMATRIX* mat) {
   static void (*ttable[nm::NUM_STYPES])(STORAGE*) = {
     nm_dense_storage_delete,
     nm_list_storage_delete,
@@ -625,10 +646,10 @@ static void nm_delete(NMATRIX* mat) {
 /*
  * Slicing destructor.
  */
-static void nm_delete_ref(NMATRIX* mat) {
+void nm_delete_ref(NMATRIX* mat) {
   static void (*ttable[nm::NUM_STYPES])(STORAGE*) = {
     nm_dense_storage_delete_ref,
-    nm_list_storage_delete_ref, 
+    nm_list_storage_delete_ref,
     nm_yale_storage_delete
   };
   ttable[mat->stype](mat->storage);
@@ -679,7 +700,7 @@ static VALUE nm_itype_by_shape(VALUE self, VALUE shape_arg) {
 
 /*
  * call-seq:
- *     upcast(first_dtype, second_dtype) ->
+ *     upcast(first_dtype, second_dtype) -> Symbol
  *
  * Given a binary operation between types t1 and t2, what type will be returned?
  *
@@ -694,28 +715,52 @@ static VALUE nm_upcast(VALUE self, VALUE t1, VALUE t2) {
 }
 
 
-
 /*
  * call-seq:
- *     each -> Enumerator
+       default_value -> ...
  *
- * Iterate over the matrix as you would an Enumerable (e.g., Array).
+ * 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
  *
- * Currently only works for dense.
+ * Iterate over all entries of any matrix in standard storage order (as with #each), and include the indices.
  */
-static VALUE nm_each(VALUE nmatrix) {
-  volatile VALUE nm = nmatrix; // not sure why we do this, but it gets done in ruby's array.c.
+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(nm);
+    return nm_dense_each_with_indices(nm);
+  case nm::LIST_STORE:
+    return nm_list_each_with_indices(nm, false);
   default:
-    rb_raise(rb_eNotImpError, "only dense matrix's each method works right now");
+    rb_raise(nm_eDataTypeError, "Not a proper storage type");
   }
 }
 
 /*
- * Iterate over the sparse entries of any matrix. For dense and yale, this iterates over non-zero
+ * 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.
  */
@@ -728,14 +773,13 @@ static VALUE nm_each_stored_with_indices(VALUE nmatrix) {
   case nm::DENSE_STORE:
     return nm_dense_each_with_indices(nm);
   case nm::LIST_STORE:
-    return nm_list_each_stored_with_indices(nm);
+    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.
@@ -777,7 +821,8 @@ 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(MOD, mod)
+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)
@@ -927,7 +972,7 @@ static VALUE nm_init(int argc, VALUE* argv, VALUE nm) {
 
   if (!SYMBOL_P(argv[0]) && TYPE(argv[0]) != T_STRING) {
     stype = nm::DENSE_STORE;
-    
+
   } else {
   	// 0: String or Symbol
     stype  = interpret_stype(argv[0]);
@@ -938,12 +983,12 @@ static VALUE nm_init(int argc, VALUE* argv, VALUE nm) {
   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);
@@ -953,23 +998,23 @@ static VALUE nm_init(int argc, VALUE* argv, VALUE nm) {
 
   size_t init_cap = 0, init_val_len = 0;
   void* init_val  = NULL;
-  if (NM_RUBYVAL_IS_NUMERIC(argv[1+offset]) || TYPE(argv[1+offset]) == T_ARRAY) {
+  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) {
+
+    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
@@ -979,9 +1024,9 @@ static VALUE nm_init(int argc, VALUE* argv, VALUE nm) {
       	// Pretend [nil] was passed for RUBYOBJ.
       	init_val = ALLOC(VALUE);
         *(VALUE*)init_val = Qnil;
-        
+
         init_val_len = 1;
-        
+
       } else {
       	init_val = NULL;
       }
@@ -990,51 +1035,40 @@ static VALUE nm_init(int argc, VALUE* argv, VALUE nm) {
       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));
+  		nm_yale_storage_init((YALE_STORAGE*)(nmatrix->storage), NULL);
   		break;
   }
 
   return nm;
 }
 
+
 /*
  * call-seq:
- *     to_hash -> Hash
- * 
- * Create a Ruby Hash from an NMatrix.
+ *     cast(stype) -> NMatrix
+ *     cast(stype, dtype, sparse_basis) -> NMatrix
  *
- * This is an internal C function which handles list stype only.
- */
-static VALUE nm_to_hash(VALUE self) {
-  if (NM_STYPE(self) != nm::LIST_STORE) {
-    rb_raise(rb_eNotImpError, "please cast to :list first");
-  }
-
-  return nm_list_storage_to_hash(NM_STORAGE_LIST(self), NM_DTYPE(self));
-}
-
-/*
  * Copy constructor for changing dtypes and stypes.
  */
-static VALUE nm_init_cast_copy(VALUE self, VALUE new_stype_symbol, VALUE new_dtype_symbol) {
+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);
 
@@ -1046,9 +1080,12 @@ static VALUE nm_init_cast_copy(VALUE self, VALUE new_stype_symbol, VALUE new_dty
 
   UnwrapNMatrix( self, rhs );
 
+  void* init_ptr = ALLOCA_N(char, DTYPE_SIZES[new_dtype]);
+  rubyval_to_cval(init, new_dtype, init_ptr);
+
   // Copy the storage
-  STYPE_CAST_COPY_TABLE(cast_copy);
-  lhs->storage = cast_copy[lhs->stype][rhs->stype](rhs->storage, new_dtype);
+  CAST_TABLE(cast_copy);
+  lhs->storage = cast_copy[lhs->stype][rhs->stype](rhs->storage, new_dtype, init_ptr);
 
   STYPE_MARK_TABLE(mark);
 
@@ -1090,8 +1127,8 @@ static VALUE nm_init_copy(VALUE copy, VALUE original) {
   lhs->stype = rhs->stype;
 
   // Copy the storage
-  STYPE_CAST_COPY_TABLE(ttable);
-  lhs->storage = ttable[lhs->stype][rhs->stype](rhs->storage, rhs->storage->dtype);
+  CAST_TABLE(ttable);
+  lhs->storage = ttable[lhs->stype][rhs->stype](rhs->storage, rhs->storage->dtype, NULL);
 
   return copy;
 }
@@ -1299,7 +1336,7 @@ static VALUE nm_read(int argc, VALUE* argv, VALUE self) {
 
 
   if (!RB_FILE_EXISTS(file)) { // FIXME: Errno::ENOENT
-    rb_raise(rb_get_errno_exc("ENOENT"), RSTRING_PTR(file));
+    rb_raise(rb_get_errno_exc("ENOENT"), "%s", RSTRING_PTR(file));
   }
 
   // Open a file stream
@@ -1373,7 +1410,7 @@ static VALUE nm_read(int argc, VALUE* argv, VALUE self) {
   case nm::DENSE_STORE:
     return Data_Wrap_Struct(klass, nm_dense_storage_mark, nm_delete, nm);
   case nm::YALE_STORE:
-    return Data_Wrap_Struct(cNMatrix, nm_yale_storage_mark, nm_delete, nm);
+    return Data_Wrap_Struct(klass, nm_yale_storage_mark, nm_delete, nm);
   default:
     return Qnil;
   }
@@ -1438,7 +1475,7 @@ 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);
 }
 
@@ -1551,7 +1588,7 @@ static VALUE nm_multiply(VALUE left_v, VALUE right_v) {
 
     return matrix_multiply(left, right);
 
-  } 
+  }
 
   return Qnil;
 }
@@ -1708,26 +1745,29 @@ static VALUE nm_xslice(int argc, VALUE* argv, void* (*slice_func)(STORAGE*, SLIC
 static VALUE elementwise_op(nm::ewop_t op, VALUE left_val, VALUE right_val) {
 	STYPE_MARK_TABLE(mark);
 
-	static STORAGE* (*ew_op[nm::NUM_STYPES])(nm::ewop_t, const STORAGE*, const STORAGE*, VALUE scalar) = {
-		nm_dense_storage_ew_op,
-		nm_list_storage_ew_op,
-		nm_yale_storage_ew_op
-	};
-	
-	NMATRIX *result = ALLOC(NMATRIX), *left;
-	
+	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.
-
-    if (left->stype != nm::YALE_STORE) {
-      result->storage = ew_op[left->stype](op, reinterpret_cast<STORAGE*>(left->storage), NULL, right_val);
-      result->stype   = left->stype;
-    } else {
-      rb_raise(rb_eNotImpError, "Scalar element-wise operations not implemented for Yale storage yet");
+    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 {
 
@@ -1743,20 +1783,31 @@ static VALUE elementwise_op(nm::ewop_t op, VALUE left_val, VALUE right_val) {
 
     NMATRIX* right;
     UnwrapNMatrix(right_val, right);
-	
-    if (left->stype == right->stype) {
 
-      result->storage	= ew_op[left->stype](op, reinterpret_cast<STORAGE*>(left->storage), reinterpret_cast<STORAGE*>(right->storage), Qnil);
-      result->stype		= left->stype;
+    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.");
     }
   }
 
-	VALUE result_val = Data_Wrap_Struct(CLASS_OF(left_val), mark[result->stype], nm_delete, result);
-
-	return result_val;
+	return Data_Wrap_Struct(CLASS_OF(left_val), mark[result->stype], nm_delete, result);
 }
 
 /*
@@ -1767,7 +1818,7 @@ bool is_ref(const NMATRIX* matrix) {
   if (matrix->stype != nm::DENSE_STORE) {
     return false;
   }
-  
+
   return ((DENSE_STORAGE*)(matrix->storage))->src != matrix->storage;
 }
 
@@ -1782,11 +1833,11 @@ static VALUE is_symmetric(VALUE self, bool hermitian) {
 		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");
@@ -1801,6 +1852,84 @@ static VALUE is_symmetric(VALUE self, bool hermitian) {
 // 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.
  *
@@ -1810,35 +1939,30 @@ nm::dtype_t nm_dtype_guess(VALUE v) {
   switch(TYPE(v)) {
   case T_TRUE:
   case T_FALSE:
-    return nm::BYTE;
-    
+  case T_NIL:
+    return nm::RUBYOBJ;
   case T_STRING:
-    if (RSTRING_LEN(v) == 1) {
-    	return nm::BYTE;
-    	
-    } else {
-    	rb_raise(rb_eArgError, "Strings of length > 1 may not be stored in a matrix.");
-    }
+    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
@@ -1850,15 +1974,15 @@ nm::dtype_t nm_dtype_guess(VALUE v) {
 #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
@@ -1867,13 +1991,12 @@ nm::dtype_t nm_dtype_guess(VALUE v) {
   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]);
 
-  case T_NIL:
   default:
     rb_raise(rb_eArgError, "Unable to guess a data type from provided parameters; data type must be specified manually.");
   }
@@ -1928,9 +2051,9 @@ static SLICE* get_slice(size_t dim, VALUE* c, VALUE self) {
 static double get_time(void) {
   struct timeval t;
   struct timezone tzp;
-  
+
   gettimeofday(&t, &tzp);
-  
+
   return t.tv_sec + t.tv_usec*1e-6;
 }
 #endif
@@ -1942,16 +2065,16 @@ static double get_time(void) {
  */
 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;
@@ -1959,13 +2082,13 @@ static nm::dtype_t interpret_dtype(int argc, VALUE* argv, nm::stype_t stype) {
 
   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]);
   }
@@ -1977,18 +2100,18 @@ 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) {
   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);
   }
 
@@ -2007,18 +2130,18 @@ static size_t* interpret_shape(VALUE arg, size_t* dim) {
   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");
   }
@@ -2032,10 +2155,10 @@ static size_t* interpret_shape(VALUE arg, size_t* dim) {
 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");
   }
@@ -2049,8 +2172,8 @@ STORAGE* matrix_storage_cast_alloc(NMATRIX* matrix, nm::dtype_t new_dtype) {
   if (matrix->storage->dtype == new_dtype && !is_ref(matrix))
     return matrix->storage;
 
-  STYPE_CAST_COPY_TABLE(cast_copy_storage);
-  return cast_copy_storage[matrix->stype][matrix->stype](matrix->storage, new_dtype);
+  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) {
@@ -2156,7 +2279,7 @@ VALUE rb_nmatrix_dense_create(nm::dtype_t dtype, size_t* shape, size_t dim, void
     shape_copy		= ALLOC_N(size_t, nm_dim);
     shape_copy[0]	= shape[0];
     shape_copy[1]	= 1;
-    
+
   } else {
     klass				= cNMatrix;
     nm_dim			= dim;