nmatrix 0.0.5 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 80c122ef6be8531eccdf14ff07426f8302660a14
-  data.tar.gz: 74335afd35279bcb817691e94c3017883ae3fed5
+  metadata.gz: 884e6aa70e17f383f0b979f94a911ad68960b48d
+  data.tar.gz: 4f1194649cfc46eb2af3fb94808c09b05837fcc4
 SHA512:
-  metadata.gz: 2d1573ca2c204fb33897870fc350779db8800c0ce41b263c3ae0628647ebd85e31ff5080e7a02bdf76f043a184274c5d197384d6322827250583d68c743d0ca6
-  data.tar.gz: 07446f0f43a91fed625330975a6f9d443b9b497ddc694bd6d7b54cb5e54da191a98444fb8d4c6097d594862e57e76c24d84133daac84eda68688699428920c7d
+  metadata.gz: aa28bc42bbfd037d04e18797076547860cf15d4f4c48203a60ac410d4c9102652d12ed22f980d7edaf854ed876d517a72311a924c7c16ecb3796aec118726ea4
+  data.tar.gz: 9d7132d3582dda04ea68afc8a93a3d2362f10d23519e00d65fe0af4a9b199ea74f990b43c2f5593131c02ed448534d86039cbc1da0c43d1cb1828dd0aa05181f

data/History.txt

@@ -75,8 +75,8 @@
 
   * Yale-to-list casting
 
-  * Now requires packable-1.3.5 or higher, fixing a problem with MATLAB
-    .mat v5 file I/O (specific to doubles)
+  * Now requires packable-1.3.5 or higher, fixing a problem with
+    MATLAB .mat v5 file I/O (specific to doubles)
 
 === 0.0.4 / 2013-05-17
 
@@ -96,8 +96,8 @@
   * Made it possible to request a different itype internally for Yale
     matrices
 
-  * Improved space usage of Yale slice-by-copying, which was requesting
-    more space than needed
+  * Improved space usage of Yale slice-by-copying, which was
+    requesting more space than needed
 
   * Improved compile-time Mac OS X and Ubuntu library searching
 
@@ -109,22 +109,23 @@
     (which are based on shape) differ, and a separate problem where
     incorrect IJA and A entries were written.
 
-  * NVector-scalar operations and NVector-NVector element-wise options
-    now return an NVector instead of an NMatrix
+  * NVector-scalar operations and NVector-NVector element-wise
+    options now return an NVector instead of an NMatrix
 
   * Addressed problems with segmentation faults during iteration (by
     @cjfuller)
 
-  * Addressed Ubuntu/Debian installation problems (incompatibility with
-    apt-supplied atlas)
+  * Addressed Ubuntu/Debian installation problems (incompatibility
+    with apt-supplied atlas)
 
-  * Fixed transpose behavior following slice-by-reference (by @cjfuller)
+  * Fixed transpose behavior following slice-by-reference (by
+    @cjfuller)
 
   * Fixed gem install command in Rakefile (by @jpmckinney)
 
   * Fixed Spanish language compile issue (by @imcsk8 and @agarie)
 
-=== 0.0.5 / 2013-??-??
+=== 0.0.5 / 2013-07-09
 
 * 4 major enhancements
 
@@ -189,3 +190,94 @@
 
   * NMatrix::read() now raises an exception when asked to read a file 
     that does not exist
+
+=== 0.0.6 / 2013-08-09
+
+* 8 major enhancements:
+
+  * Refactored iteration, so that each storage type now has each of:
+    #each, #each_with_indices, #each_stored_with_indices
+
+  * Added element-wise power function (**) for dense matrices (by
+    @agarie)
+
+  * Dramatically improved matrix element-wise and scalar functions so
+    C++ templates are no longer necessary; element-wise operations
+    may now be written in protected Ruby methods that look like
+    NMatrix#__list_elementwise_op__ and NMatrix#__list_scalar_op__
+
+  * Element-wise and scalar operations that might return a true or
+    false now return Ruby matrices
+
+  * Yale element-wise and scalar operations have been added
+
+  * Yale is now allowed to have a non-zero default (specifically to
+    permit true-false matrices and nil sparse bases)
+
+  * Dramatically improved NMatrix#cast to allow for hashed options
+    including a :default for list and yale casts
+
+  * Dramatically improved speed of compilation
+
+* 14 minor enhancements:
+
+  * Improved documentation for exposed BLAS and LAPACK functions
+
+  * Allowed for use of BLAS::rot without cloning x and y (in-place
+    plane rotation); removed unnecessary test of unfriendly version
+
+  * Added more user-friendly cblas_xrotg implementation: BLAS::rotg
+
+  * Moved NMatrix::YaleFunctions::yale_vector_insert to
+    NMatrix#__yale_vector_set__, which is more consistent with
+    behavior
+
+  * Changed notations for protected stype-specific functions, which
+    now look like __stype_method_name__, e.g., __yale_vector_set__
+
+  * Added NMatrix#__list_default_value__ protected function to get
+    the initial (sparse) value for list matrices
+
+  * Changed behavior and names of NMatrix::YaleFunctions methods
+    which get column indices and cell contents by row, so that they
+    now expect the :keys option (like Hash#keys) instead of :array,
+    which doesn't make sense; name changes are as follows:
+      yale_row_as_sorted_set -> yale_ja_d_keys_sorted_set_at
+      yale_row_as_set -> yale_ja_d_keys_set_at
+      yale_row_as_array -> yale_ja_d_keys_at
+      yale_nd_row_as_sorted_set -> yale_ja_sorted_set_at
+      yale_nd_row_as_set -> yale_ja_set_at
+      yale_nd_row_as_array -> yale_ja_at
+    Aliases are included but will be removed without notice.
+
+  * Added NVector#sorted_indices and #binned_sorted_indices for use
+    when running k-nearest neighbor searches on a distance matrix
+
+  * Added NVector::logspace shortcut function (analogous to
+    NVector::linspace)
+
+  * Cleaned up code by removing monkey patches that we stopped using
+    circa v0.0.2 (Array#min, Array#max, String#constantize,
+    String#camelize, String#underscore)
+
+  * Re-enabled element-wise mod (%) method
+
+  * Added NMatrix::guess_dtype class method, which allows you to
+    figure out what dtype (roughly) should be used for any given
+    Ruby value (e.g., 3)
+
+  * String and nil objects in NMatrix cells are no longer outlawed
+    (but are not supported), provided they are of the :object dtype
+
+  * NMatrix#diag shortcut for specifying sparse matrix with a user-
+    specified diagonal array (by @ryanmt)
+
+* 3 bug fixes:
+
+  * Corrected BLAS::rot bounds checking on optional n argument
+
+  * Removed BLAS::rotg and BLAS::nrm2 code for rational numbers, as
+    both involve a square root
+
+  * Repaired list matrix element-wise functions
+

data/README.rdoc

@@ -4,7 +4,8 @@ Fast Numerical Linear Algebra Library for Ruby
 
 * {sciruby.com}[http://sciruby.com]
 * {Google+}[https://plus.google.com/109304769076178160953/posts]
-* {Installation guide}[http://sciruby.com/docs#installation]
+* {NMatrix Installation wiki}[https://github.com/SciRuby/nmatrix/wiki/Installation]
+* {SciRuby Installation guide}[http://sciruby.com/docs#installation]
 
 == Description
 
@@ -19,36 +20,26 @@ To install the latest stable version:
 
     gem install nmatrix
 
-However, you will need to install {ATLAS}[http://math-atlas.sourceforge.net/] with CBLAS (C interface
-to {BLAS}[http://en.wikipedia.org/wiki/Basic_Linear_Algebra_Subprograms]) first. Those directions can be
-found {here}[https://github.com/SciRuby/nmatrix/wiki/Installation]. The requirements for NMatrix are:
+However, you will need to install {ATLAS}[http://math-atlas.sourceforge.net/] with CBLAS (C interface to
+{BLAS}[http://en.wikipedia.org/wiki/Basic_Linear_Algebra_Subprograms]) first. Detailed directions can be found
+{here}[https://github.com/SciRuby/nmatrix/wiki/Installation]. The requirements for NMatrix are:
 
 * ATLAS
-* LAPACK, probably
+* LAPACK, probably ({see here for details}[https://github.com/SciRuby/nmatrix/wiki/Installation])
 * a version of GCC or clang which supports C++0x or C++11
 * Ruby 1.9+
 * {packable}[http://github.com/marcandre/packable] 1.3.5 (used for I/O)
 
-If you want to obtain the latest (development)code, you should do:
+If you want to obtain the latest (development) code, you should generally do:
 
     git clone https://github.com/SciRuby/nmatrix.git
     cd nmatrix/
-    rake compile
-    rake repackage
-    gem install pkg/nmatrix-0.0.5.gem
+    bundle install
+    bundle exec rake compile
+    bundle exec rake repackage
+    gem install pkg/nmatrix-0.0.7.gem
 
-If you get errors about clapack.h or cblas.h, determine where your ATLAS headers are using:
-
-    locate clapack.h
-
-If you're a Mac user, we recommend you search for cblas.h instead.
-
-Then, tell your system:
-
-    export C_INCLUDE_PATH=/usr/local/atlas/include
-    export CPLUS_INCLUDE_PATH=/usr/local/atlas/include
-
-Finally, try compiling again.
+Detailed instructions are available for {Mac}[https://github.com/SciRuby/nmatrix/wiki/Installation#mac-os-x] and {Linux}[https://github.com/SciRuby/nmatrix/wiki/Installation#linux].
 
 == Documentation
 
@@ -63,6 +54,7 @@ You can find the complete API documentation {on our website}[http://sciruby.com/
 
 Create a new NMatrix from a ruby array: 
 
+    >> require 'nmatrix'
     >> NMatrix.new([2, 3], [0, 1, 2, 3, 4, 5], :int64).pp
       [0, 1, 2]
       [3, 4, 5]
@@ -87,16 +79,17 @@ Read the instructions in +CONTRIBUTING.md+ if you want to help NMatrix.
 
 == Features
 
-The following features exist in the current version of NMatrix (0.0.4):
+The following features exist in the current version of NMatrix (0.0.6):
 
 * Matrix and vector storage containers: dense, yale, list (more to come)
-* Data types: uint8, int8, int16, int32, int64, float32, float64, complex64, complex128, rational64, rational128
-  (incomplete)
+* Data types: byte (uint8), int8, int16, int32, int64, float32, float64, complex64, complex128, rational64, rational128,
+  Ruby object
 * Conversion between storage and data types (except from-complex, and from-float-to-rational)
-* Element-wise operations and comparisons for dense and yale
-* Matrix-matrix multiplication for dense (using ATLAS) and yale
-* Matrix-vector multiplication for dense (using ATLAS)
-* Dense and list matrix slicing and referencing
+* Element-wise and right-hand-scalar operations and comparisons for all matrix types
+* Matrix-matrix multiplication for dense (with and without ATLAS) and yale
+* Matrix-vector multiplication for dense (with and without ATLAS)
+* Dense and list matrix slicing by copy and reference
+* Yale matrix slicing by copy
 * Native reading and writing of dense and yale matrices
   * Optional compression for dense matrices with symmetry or triangularity: symmetric, skew, hermitian, upper, lower
 * Matlab .MAT v5 file input
@@ -121,8 +114,9 @@ The following features exist in the current version of NMatrix (0.0.4):
 
 === Planned Features (Short-to-Medium Term)
 
-These are features planned for NMatrix 0.1.0, our first beta.
+These are features planned for NMatrix 0.1.0, our first beta:
 
+* Yale matrix slicing
 * calculation of determinant (LAPACK-free), trace, and eigenvalues (characteristic polynomial)
 * exponentials and square roots
 * matrix inversions (LAPACK-free)
@@ -144,9 +138,7 @@ now.
 
 You should also be aware that NMatrix and NArray are incompatible with one another; you should not try to require both
 at the same time. Unfortunately, that causes problems with Ruby/GSL, which currently depends upon NArray. As such, we
-are working on a {patch for Ruby/GSL}[https://github.com/SciRuby/rb-gsl]. You can find the most recent version in
-{the work branch of Masaomi's fork}[https://github.com/masaomi/rb-gsl/tree/work] (not currently compiling as of this
-writing).
+have a {fork of Ruby/GSL}[https://github.com/SciRuby/rb-gsl].
 
 == License
 

data/Rakefile

@@ -41,7 +41,7 @@ SPECDIR = BASEDIR + 'spec'
 
 VALGRIND_OPTIONS = [
         "--tool=memcheck",
-        "--leak-check=yes",
+        #"--leak-check=yes",
         "--num-callers=15",
         #"--error-limit=no",
         "--partial-loads-ok=yes",

data/ext/nmatrix/data/complex.h

@@ -51,6 +51,7 @@
  */
 namespace nm {
 
+class RubyObject;
 template <typename IntType> class Rational;
 template <typename Type> class Complex;
 
@@ -86,6 +87,8 @@ class Complex {
 	template <typename IntType, typename = typename std::enable_if<std::is_integral<IntType>::value>::type>
 	inline Complex(const Rational<IntType>& other) : r(Type(other.n) / Type(other.d)), i(0) {}
 
+  Complex(const RubyObject& other);
+
   /*
    * Complex conjugate function -- creates a copy, but inverted.
    */
@@ -360,6 +363,12 @@ inline std::ostream& operator<<(std::ostream& out, const Complex<Type>& rhs) {
   return out;
 }
 
+// Negative operator
+template <typename IntType, typename = typename std::enable_if<std::is_integral<IntType>::value>::type>
+inline Complex<IntType> operator-(const Complex<IntType>& rhs) {
+  return Complex<IntType>(-rhs.r, -rhs.i);
+}
+
 } // end of namespace nm
 
 namespace std {

data/ext/nmatrix/data/data.cpp

@@ -42,6 +42,76 @@
  * Global Variables
  */
 
+namespace nm {
+  const char* const EWOP_OPS[nm::NUM_EWOPS] = {
+    "+",
+    "-",
+    "*",
+    "/",
+    "**",
+    "%",
+    "==",
+    "!=",
+    "<",
+    ">",
+    "<=",
+    ">="
+  };
+
+  const std::string EWOP_NAMES[nm::NUM_EWOPS] = {
+    "add",
+    "sub",
+    "mul",
+    "div",
+    "pow",
+    "mod",
+    "eqeq",
+    "neq",
+    "lt",
+    "gt",
+    "leq",
+    "geq"
+  };
+
+
+  template <typename Type>
+  Complex<Type>::Complex(const RubyObject& other) {
+    switch(TYPE(other.rval)) {
+    case T_COMPLEX:
+      r = NUM2DBL(rb_funcall(other.rval, rb_intern("real"), 0));
+      i = NUM2DBL(rb_funcall(other.rval, rb_intern("imag"), 0));
+      break;
+    case T_FLOAT:
+    case T_RATIONAL:
+      r = NUM2DBL(other.rval);
+      i = 0.0;
+      break;
+    default:
+      rb_raise(rb_eTypeError, "not sure how to convert this type of VALUE to a complex");
+    }
+  }
+
+  template <typename Type>
+  Rational<Type>::Rational(const RubyObject& other) {
+    switch (TYPE(other.rval)) {
+    case T_RATIONAL:
+      n = NUM2LONG(rb_funcall(this->rval, rb_intern("numerator"), 0));
+      d = NUM2LONG(rb_funcall(this->rval, rb_intern("denominator"), 0));
+      break;
+    case T_FIXNUM:
+      n = NUM2LONG(other.rval);
+      d = 1;
+      break;
+    case T_COMPLEX:
+    case T_FLOAT:
+      rb_raise(rb_eTypeError, "cannot convert float to a rational");
+      break;
+    default:
+      rb_raise(rb_eTypeError, "not sure how to convert this type of VALUE to a rational");
+    }
+  }
+
+} // end of namespace nm
 extern "C" {
 
 const char* const DTYPE_NAMES[nm::NUM_DTYPES] = {
@@ -67,6 +137,7 @@ const char* const ITYPE_NAMES[nm::NUM_ITYPES] = {
 	"uint64"
 };
 
+
 const size_t DTYPE_SIZES[nm::NUM_DTYPES] = {
 	sizeof(uint8_t),
 	sizeof(int8_t),
@@ -91,8 +162,8 @@ const size_t ITYPE_SIZES[nm::NUM_ITYPES] = {
 };
 
 const nm::dtype_t Upcast[nm::NUM_DTYPES][nm::NUM_DTYPES] = {
-  { nm::BYTE, nm::INT8, nm::INT16, nm::INT32, nm::INT64, nm::FLOAT32, nm::FLOAT64, nm::COMPLEX64, nm::COMPLEX128, nm::RATIONAL32, nm::RATIONAL64, nm::RATIONAL128, nm::RUBYOBJ},
-  { nm::INT8, nm::INT8, nm::INT16, nm::INT32, nm::INT64, nm::FLOAT32, nm::FLOAT64, nm::COMPLEX64, nm::COMPLEX128, nm::RATIONAL32, nm::RATIONAL64, nm::RATIONAL128, nm::RUBYOBJ},
+  { nm::BYTE, nm::INT16, nm::INT16, nm::INT32, nm::INT64, nm::FLOAT32, nm::FLOAT64, nm::COMPLEX64, nm::COMPLEX128, nm::RATIONAL32, nm::RATIONAL64, nm::RATIONAL128, nm::RUBYOBJ},
+  { nm::INT16, nm::INT8, nm::INT16, nm::INT32, nm::INT64, nm::FLOAT32, nm::FLOAT64, nm::COMPLEX64, nm::COMPLEX128, nm::RATIONAL32, nm::RATIONAL64, nm::RATIONAL128, nm::RUBYOBJ},
   { nm::INT16, nm::INT16, nm::INT16, nm::INT32, nm::INT64, nm::FLOAT32, nm::FLOAT64, nm::COMPLEX64, nm::COMPLEX128, nm::RATIONAL32, nm::RATIONAL64, nm::RATIONAL128, nm::RUBYOBJ},
   { nm::INT32, nm::INT32, nm::INT32, nm::INT32, nm::INT64, nm::FLOAT32, nm::FLOAT64, nm::COMPLEX64, nm::COMPLEX128, nm::RATIONAL32, nm::RATIONAL64, nm::RATIONAL128, nm::RUBYOBJ},
   { nm::INT64, nm::INT64, nm::INT64, nm::INT64, nm::INT64, nm::FLOAT32, nm::FLOAT64, nm::COMPLEX64, nm::COMPLEX128, nm::RATIONAL32, nm::RATIONAL64, nm::RATIONAL128, nm::RUBYOBJ},
@@ -170,12 +241,12 @@ void rubyval_to_cval(VALUE val, nm::dtype_t dtype, void* loc) {
 			break;
 
 		case RUBYOBJ:
-		  *reinterpret_cast<VALUE*>(loc)        = RubyObject(val).rval;
+		  *reinterpret_cast<VALUE*>(loc)        = val;
 			//rb_raise(rb_eTypeError, "Attempting a bad conversion from a Ruby value.");
 			break;
 
 	  default:
-	    rb_raise(rb_eTypeError, "Attempting a bad conversion from a Ruby value.");
+	    rb_raise(rb_eTypeError, "Attempting a bad conversion.");
 	    break;
 	}
 }
@@ -224,6 +295,7 @@ nm::RubyObject rubyobj_from_cval(void* val, nm::dtype_t dtype) {
 			return RubyObject(*reinterpret_cast<Rational128*>(val));
 
 	  default:
+	    throw;
 	    rb_raise(nm_eDataTypeError, "Conversion to RubyObject requested from unknown/invalid data type (did you try to convert from a VALUE?)");
 	}
 	return Qnil;
@@ -254,6 +326,7 @@ nm::RubyObject rubyobj_from_cval_by_itype(void* val, nm::itype_t itype) {
 	return Qnil;
 }
 
+
 /*
  * Allocate and return a piece of data of the correct dtype, converted from a
  * given RubyObject.
@@ -267,4 +340,5 @@ void* rubyobj_to_cval(VALUE val, nm::dtype_t dtype) {
   return ret_val;
 }
 
+
 } // end of extern "C" block

data/ext/nmatrix/data/data.h

@@ -31,6 +31,7 @@
 /*
  * Standard Includes
  */
+#include <string>
 
 /*
  * Project Includes
@@ -48,17 +49,18 @@ namespace nm {
   /*
    * Constants
    */
-	
+
 	const int NUM_DTYPES = 13;
 	const int NUM_ITYPES = 4;
-	const int NUM_EWOPS = 11;
-	const int NUM_NONCOMP_EWOPS = 5;
-	
+	const int NUM_EWOPS = 12;
+	const int NUM_NONCOMP_EWOPS = 6;
+
   enum ewop_t {
     EW_ADD,
     EW_SUB,
     EW_MUL,
     EW_DIV,
+    EW_POW,
     EW_MOD,
     EW_EQEQ,
     EW_NEQ,
@@ -67,7 +69,11 @@ namespace nm {
     EW_LEQ,
     EW_GEQ
   };
-  
+
+  // element-wise and scalar operators
+  extern const char* const  EWOP_OPS[nm::NUM_EWOPS];
+  extern const std::string  EWOP_NAMES[nm::NUM_EWOPS];
+
 } // end of namespace nm
 
 /*
@@ -81,8 +87,8 @@ namespace nm {
     nm_yale_storage_mark												\
   };
 
-#define STYPE_CAST_COPY_TABLE(name)                                                   \
-  static STORAGE* (*(name)[nm::NUM_STYPES][nm::NUM_STYPES])(const STORAGE*, nm::dtype_t) = {      \
+#define CAST_TABLE(name)                                                   \
+  static STORAGE* (*(name)[nm::NUM_STYPES][nm::NUM_STYPES])(const STORAGE*, nm::dtype_t, void*) = {      \
     { nm_dense_storage_cast_copy,  nm_dense_storage_from_list,  nm_dense_storage_from_yale },  \
     { nm_list_storage_from_dense,  nm_list_storage_cast_copy,   nm_list_storage_from_yale  },  \
     { nm_yale_storage_from_dense,  nm_yale_storage_from_list,   nm_yale_storage_cast_copy  }   \
@@ -162,50 +168,21 @@ namespace nm {
 #define LR_DTYPE_TEMPLATE_TABLE(fun, ret, ...) NAMED_LR_DTYPE_TEMPLATE_TABLE(ttable, fun, ret, __VA_ARGS__)
 
 #define NAMED_LR_DTYPE_TEMPLATE_TABLE(name, fun, ret, ...)																																																								\
-	static ret (*(name)[nm::NUM_DTYPES][nm::NUM_DTYPES])(__VA_ARGS__) = {																																																						\
-		{fun<uint8_t, uint8_t>, fun<uint8_t, int8_t>, fun<uint8_t, int16_t>, fun<uint8_t, int32_t>, fun<uint8_t, int64_t>, fun<uint8_t, float32_t>, fun<uint8_t, float64_t>,	\
-			fun<uint8_t, nm::Complex64>, fun<uint8_t, nm::Complex128>, fun<uint8_t, nm::Rational32>, fun<uint8_t, nm::Rational64>,																							\
-			fun<uint8_t, nm::Rational128>, NULL},																																																																\
-																																																																																					\
-		{fun<int8_t, uint8_t>, fun<int8_t, int8_t>, fun<int8_t, int16_t>, fun<int8_t, int32_t>, fun<int8_t, int64_t>, fun<int8_t, float32_t>, fun<int8_t, float64_t>,					\
-			fun<int8_t, nm::Complex64>, fun<int8_t, nm::Complex128>, fun<int8_t, nm::Rational32>, fun<int8_t, nm::Rational64>, fun<int8_t, nm::Rational128>, NULL},							\
-																																																																																					\
-		{fun<int16_t, uint8_t>, fun<int16_t, int8_t>, fun<int16_t, int16_t>, fun<int16_t, int32_t>, fun<int16_t, int64_t>, fun<int16_t, float32_t>, fun<int16_t, float64_t>,	\
-			fun<int16_t, nm::Complex64>, fun<int16_t, nm::Complex128>, fun<int16_t, nm::Rational32>, fun<int16_t, nm::Rational64>, fun<int16_t, nm::Rational128>, NULL},				\
-																																																																																					\
-		{fun<int32_t, uint8_t>, fun<int32_t, int8_t>, fun<int32_t, int16_t>, fun<int32_t, int32_t>, fun<int32_t, int64_t>, fun<int32_t, float32_t>, fun<int32_t, float64_t>,	\
-			fun<int32_t, nm::Complex64>, fun<int32_t, nm::Complex128>, fun<int32_t, nm::Rational32>, fun<int32_t, nm::Rational64>, fun<int32_t, nm::Rational128>, NULL},				\
-																																																																																					\
-		{fun<int64_t, uint8_t>, fun<int64_t, int8_t>, fun<int64_t, int16_t>, fun<int64_t, int32_t>, fun<int64_t, int64_t>, fun<int64_t, float32_t>, fun<int64_t, float64_t>,	\
-			fun<int64_t, nm::Complex64>, fun<int64_t, nm::Complex128>, fun<int64_t, nm::Rational32>, fun<int64_t, nm::Rational64>, fun<int64_t, nm::Rational128>, NULL},				\
-																																																																																					\
-		{fun<float32_t, uint8_t>, fun<float32_t, int8_t>, fun<float32_t, int16_t>, fun<float32_t, int32_t>, fun<float32_t, int64_t>,																					\
-			fun<float32_t, float32_t>, fun<float32_t, float64_t>, fun<float32_t, nm::Complex64>, fun<float32_t, nm::Complex128>,  fun<float32_t, nm::Rational32>,								\
-			fun<float32_t, nm::Rational64>, fun<float32_t, nm::Rational128>, NULL},																																															\
-                                                                                                                                                                          \
-		{fun<float64_t, uint8_t>, fun<float64_t, int8_t>, fun<float64_t, int16_t>, fun<float64_t, int32_t>, fun<float64_t, int64_t>,																					\
-			fun<float64_t, float32_t>, fun<float64_t, float64_t>, fun<float64_t, nm::Complex64>, fun<float64_t, nm::Complex128>, fun<float64_t, nm::Rational32>,                \
-			fun<float64_t, nm::Rational64>, fun<float64_t, nm::Rational128>, NULL},																																															\
-                                                                                                                                                                          \
-		{fun<nm::Complex64, uint8_t>, fun<nm::Complex64, int8_t>, fun<nm::Complex64, int16_t>, fun<nm::Complex64, int32_t>, fun<nm::Complex64, int64_t>,											\
-			fun<nm::Complex64, float32_t>, fun<nm::Complex64, float64_t>, fun<nm::Complex64, nm::Complex64>, fun<nm::Complex64, nm::Complex128>,																\
-			fun<nm::Complex64, nm::Rational32>, fun<nm::Complex64, nm::Rational64>, fun<nm::Complex64, nm::Rational128>, NULL},																									\
-																																																																																					\
-		{fun<nm::Complex128, uint8_t>, fun<nm::Complex128, int8_t>, fun<nm::Complex128, int16_t>, fun<nm::Complex128, int32_t>, fun<nm::Complex128, int64_t>,									\
-			fun<nm::Complex128, float32_t>, fun<nm::Complex128, float64_t>, fun<nm::Complex128, nm::Complex64>, fun<nm::Complex128, nm::Complex128>,														\
-			fun<nm::Complex128, nm::Rational32>, fun<nm::Complex128, nm::Rational64>, fun<nm::Complex128, nm::Rational128>, NULL},																							\
-																																																																																					\
-		{fun<nm::Rational32, uint8_t>, fun<nm::Rational32, int8_t>, fun<nm::Rational32, int16_t>, fun<nm::Rational32, int32_t>, fun<nm::Rational32, int64_t>, NULL, NULL,			\
-			NULL, NULL, fun<nm::Rational32, nm::Rational32>, fun<nm::Rational32, nm::Rational64>, fun<nm::Rational32, nm::Rational128>, NULL},																	\
-																																																																																					\
-		{fun<nm::Rational64, uint8_t>, fun<nm::Rational64, int8_t>, fun<nm::Rational64, int16_t>, fun<nm::Rational64, int32_t>, fun<nm::Rational64, int64_t>, NULL, NULL,			\
-			NULL, NULL, fun<nm::Rational64, nm::Rational32>, fun<nm::Rational64, nm::Rational64>, fun<nm::Rational64, nm::Rational128>, NULL},																	\
-																																																																																					\
-		{fun<nm::Rational128, uint8_t>, fun<nm::Rational128, int8_t>, fun<nm::Rational128, int16_t>, fun<nm::Rational128, int32_t>, fun<nm::Rational128, int64_t>, NULL,			\
-			NULL, NULL, NULL, fun<nm::Rational128, nm::Rational32>, fun<nm::Rational128, nm::Rational64>, fun<nm::Rational128, nm::Rational128>, NULL},													\
-																																																																																					\
-		{NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, fun<nm::RubyObject, nm::RubyObject>}																													\
-	};
+	static ret (*(name)[nm::NUM_DTYPES][nm::NUM_DTYPES])(__VA_ARGS__) = {  \
+	  {fun<uint8_t, uint8_t>, fun<uint8_t, int8_t>, fun<uint8_t, int16_t>, fun<uint8_t, int32_t>, fun<uint8_t, int64_t>, fun<uint8_t, float32_t>, fun<uint8_t, float64_t>, fun<uint8_t, nm::Complex64>, fun<uint8_t, nm::Complex128>, fun<uint8_t, nm::Rational32>, fun<uint8_t, nm::Rational64>, fun<uint8_t, nm::Rational128>, fun<uint8_t, nm::RubyObject>}, \
+    {fun<int8_t, uint8_t>, fun<int8_t, int8_t>, fun<int8_t, int16_t>, fun<int8_t, int32_t>, fun<int8_t, int64_t>, fun<int8_t, float32_t>, fun<int8_t, float64_t>, fun<int8_t, nm::Complex64>, fun<int8_t, nm::Complex128>, fun<int8_t, nm::Rational32>, fun<int8_t, nm::Rational64>, fun<int8_t, nm::Rational128>, fun<int8_t, nm::RubyObject>},               \
+    {fun<int16_t, uint8_t>, fun<int16_t, int8_t>, fun<int16_t, int16_t>, fun<int16_t, int32_t>, fun<int16_t, int64_t>, fun<int16_t, float32_t>, fun<int16_t, float64_t>, fun<int16_t, nm::Complex64>, fun<int16_t, nm::Complex128>, fun<int16_t, nm::Rational32>, fun<int16_t, nm::Rational64>, fun<int16_t, nm::Rational128>, fun<int16_t, nm::RubyObject>},  \
+    {fun<int32_t, uint8_t>, fun<int32_t, int8_t>, fun<int32_t, int16_t>, fun<int32_t, int32_t>, fun<int32_t, int64_t>, fun<int32_t, float32_t>, fun<int32_t, float64_t>, fun<int32_t, nm::Complex64>, fun<int32_t, nm::Complex128>, fun<int32_t, nm::Rational32>, fun<int32_t, nm::Rational64>, fun<int32_t, nm::Rational128>, fun<int32_t, nm::RubyObject>},  \
+    {fun<int64_t, uint8_t>, fun<int64_t, int8_t>, fun<int64_t, int16_t>, fun<int64_t, int32_t>, fun<int64_t, int64_t>, fun<int64_t, float32_t>, fun<int64_t, float64_t>, fun<int64_t, nm::Complex64>, fun<int64_t, nm::Complex128>, fun<int64_t, nm::Rational32>, fun<int64_t, nm::Rational64>, fun<int64_t, nm::Rational128>, fun<int64_t, nm::RubyObject>},  \
+    {fun<float32_t, uint8_t>, fun<float32_t, int8_t>, fun<float32_t, int16_t>, fun<float32_t, int32_t>, fun<float32_t, int64_t>, fun<float32_t, float32_t>, fun<float32_t, float64_t>, fun<float32_t, nm::Complex64>, fun<float32_t, nm::Complex128>, fun<float32_t, nm::Rational32>, fun<float32_t, nm::Rational64>, fun<float32_t, nm::Rational128>, fun<float32_t, nm::RubyObject>},  \
+    {fun<float64_t, uint8_t>, fun<float64_t, int8_t>, fun<float64_t, int16_t>, fun<float64_t, int32_t>, fun<float64_t, int64_t>, fun<float64_t, float32_t>, fun<float64_t, float64_t>, fun<float64_t, nm::Complex64>, fun<float64_t, nm::Complex128>, fun<float64_t, nm::Rational32>, fun<float64_t, nm::Rational64>, fun<float64_t, nm::Rational128>, fun<float64_t, nm::RubyObject>},  \
+    {fun<nm::Complex64, uint8_t>, fun<nm::Complex64, int8_t>, fun<nm::Complex64, int16_t>, fun<nm::Complex64, int32_t>, fun<nm::Complex64, int64_t>, fun<nm::Complex64, float32_t>, fun<nm::Complex64, float64_t>, fun<nm::Complex64, nm::Complex64>, fun<nm::Complex64, nm::Complex128>, fun<nm::Complex64, nm::Rational32>, fun<nm::Complex64, nm::Rational64>, fun<nm::Complex64, nm::Rational128>, fun<nm::Complex64, nm::RubyObject>},               \
+    {fun<nm::Complex128, uint8_t>, fun<nm::Complex128, int8_t>, fun<nm::Complex128, int16_t>, fun<nm::Complex128, int32_t>, fun<nm::Complex128, int64_t>, fun<nm::Complex128, float32_t>, fun<nm::Complex128, float64_t>, fun<nm::Complex128, nm::Complex64>, fun<nm::Complex128, nm::Complex128>, fun<nm::Complex128, nm::Rational32>, fun<nm::Complex128, nm::Rational64>, fun<nm::Complex128, nm::Rational128>, fun<nm::Complex128, nm::RubyObject>},  \
+    {fun<nm::Rational32, uint8_t>, fun<nm::Rational32, int8_t>, fun<nm::Rational32, int16_t>, fun<nm::Rational32, int32_t>, fun<nm::Rational32, int64_t>, NULL, NULL, NULL, NULL, fun<nm::Rational32, nm::Rational32>, fun<nm::Rational32, nm::Rational64>, fun<nm::Rational32, nm::Rational128>, fun<nm::Rational32, nm::RubyObject>},             \
+    {fun<nm::Rational64, uint8_t>, fun<nm::Rational64, int8_t>, fun<nm::Rational64, int16_t>, fun<nm::Rational64, int32_t>, fun<nm::Rational64, int64_t>, NULL, NULL, NULL, NULL, fun<nm::Rational64, nm::Rational32>, fun<nm::Rational64, nm::Rational64>, fun<nm::Rational64, nm::Rational128>, fun<nm::Rational64, nm::RubyObject>},             \
+    {fun<nm::Rational128, uint8_t>, fun<nm::Rational128, int8_t>, fun<nm::Rational128, int16_t>, fun<nm::Rational128, int32_t>, fun<nm::Rational128, int64_t>, NULL, NULL, NULL, NULL, fun<nm::Rational128, nm::Rational32>, fun<nm::Rational128, nm::Rational64>, fun<nm::Rational128, nm::Rational128>, fun<nm::Rational128, nm::RubyObject>},    \
+    {fun<nm::RubyObject, uint8_t>, fun<nm::RubyObject, int8_t>, fun<nm::RubyObject, int16_t>, fun<nm::RubyObject, int32_t>, fun<nm::RubyObject, int64_t>, fun<nm::RubyObject, float32_t>, fun<nm::RubyObject, float64_t>, fun<nm::RubyObject, nm::Complex64>, fun<nm::RubyObject, nm::Complex128>, fun<nm::RubyObject, nm::Rational32>, fun<nm::RubyObject, nm::Rational64>, fun<nm::RubyObject, nm::Rational128>, fun<nm::RubyObject, nm::RubyObject>}   \
+  };
 
 /*
  * Defines a static array that holds function pointers to operation, and left-
@@ -427,10 +404,64 @@ namespace nm {
 			{fun<nm::EW_DIV, nm::Rational128, uint8_t>, fun<nm::EW_DIV, nm::Rational128, int8_t>, fun<nm::EW_DIV, nm::Rational128, int16_t>, fun<nm::EW_DIV, nm::Rational128, int32_t>,						\
 				fun<nm::EW_DIV, nm::Rational128, int64_t>, NULL, NULL, NULL, NULL, fun<nm::EW_DIV, nm::Rational128, nm::Rational32>, fun<nm::EW_DIV, nm::Rational128, nm::Rational64>,					\
 				fun<nm::EW_DIV, nm::Rational128, nm::Rational128>, NULL},																																																								\
-																																																																																						\
+\
 			{NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, fun<nm::EW_DIV, nm::RubyObject, nm::RubyObject>}																									\
 		},																																																																																			\
-																																																																																						\
+		  \
+    { \
+      {fun<nm::EW_POW, uint8_t, uint8_t>, fun<nm::EW_POW, uint8_t, int8_t>, fun<nm::EW_POW, uint8_t, int16_t>, fun<nm::EW_POW, uint8_t, int32_t>, fun<nm::EW_POW, uint8_t, int64_t>,						\
+        fun<nm::EW_POW, uint8_t, float32_t>, fun<nm::EW_POW, uint8_t, float64_t>, fun<nm::EW_POW, uint8_t, nm::Complex64>, fun<nm::EW_POW, uint8_t, nm::Complex128>,												\
+        fun<nm::EW_POW, uint8_t, nm::Rational32>, fun<nm::EW_POW, uint8_t, nm::Rational64>, fun<nm::EW_POW, uint8_t, nm::Rational128>, NULL},																						\
+\
+      {fun<nm::EW_POW, int8_t, uint8_t>, fun<nm::EW_POW, int8_t, int8_t>, fun<nm::EW_POW, int8_t, int16_t>, fun<nm::EW_POW, int8_t, int32_t>, fun<nm::EW_POW, int8_t, int64_t>,									\
+        fun<nm::EW_POW, int8_t, float32_t>, fun<nm::EW_POW, int8_t, float64_t>, fun<nm::EW_POW, int8_t, nm::Complex64>, fun<nm::EW_POW, int8_t, nm::Complex128>,														\
+        fun<nm::EW_POW, int8_t, nm::Rational32>, fun<nm::EW_POW, int8_t, nm::Rational64>, fun<nm::EW_POW, int8_t, nm::Rational128>, NULL},																							\
+\
+      {fun<nm::EW_POW, int16_t, uint8_t>, fun<nm::EW_POW, int16_t, int8_t>, fun<nm::EW_POW, int16_t, int16_t>, fun<nm::EW_POW, int16_t, int32_t>, fun<nm::EW_POW, int16_t, int64_t>,						\
+        fun<nm::EW_POW, int16_t, float32_t>, fun<nm::EW_POW, int16_t, float64_t>, fun<nm::EW_POW, int16_t, nm::Complex64>, fun<nm::EW_POW, int16_t, nm::Complex128>,												\
+        fun<nm::EW_POW, int16_t, nm::Rational32>, fun<nm::EW_POW, int16_t, nm::Rational64>, fun<nm::EW_POW, int16_t, nm::Rational128>, NULL},																						\
+\
+      {fun<nm::EW_POW, int32_t, uint8_t>, fun<nm::EW_POW, int32_t, int8_t>, fun<nm::EW_POW, int32_t, int16_t>, fun<nm::EW_POW, int32_t, int32_t>, fun<nm::EW_POW, int32_t, int64_t>,						\
+        fun<nm::EW_POW, int32_t, float32_t>, fun<nm::EW_POW, int32_t, float64_t>, fun<nm::EW_POW, int32_t, nm::Complex64>, fun<nm::EW_POW, int32_t, nm::Complex128>,												\
+        fun<nm::EW_POW, int32_t, nm::Rational32>, fun<nm::EW_POW, int32_t, nm::Rational64>, fun<nm::EW_POW, int32_t, nm::Rational128>, NULL},																						\
+\
+      {fun<nm::EW_POW, int64_t, uint8_t>, fun<nm::EW_POW, int64_t, int8_t>, fun<nm::EW_POW, int64_t, int16_t>, fun<nm::EW_POW, int64_t, int32_t>, fun<nm::EW_POW, int64_t, int64_t>,						\
+        fun<nm::EW_POW, int64_t, float32_t>, fun<nm::EW_POW, int64_t, float64_t>, fun<nm::EW_POW, int64_t, nm::Complex64>, fun<nm::EW_POW, int64_t, nm::Complex128>,												\
+        fun<nm::EW_POW, int64_t, nm::Rational32>, fun<nm::EW_POW, int64_t, nm::Rational64>, fun<nm::EW_POW, int64_t, nm::Rational128>, NULL}, 																					\
+\
+      {fun<nm::EW_POW, float32_t, uint8_t>, fun<nm::EW_POW, float32_t, int8_t>, fun<nm::EW_POW, float32_t, int16_t>, fun<nm::EW_POW, float32_t, int32_t>, fun<nm::EW_POW, float32_t, int64_t>,	\
+        fun<nm::EW_POW, float32_t, float32_t>, fun<nm::EW_POW, float32_t, float64_t>, fun<nm::EW_POW, float32_t, nm::Complex64>, fun<nm::EW_POW, float32_t, nm::Complex128>,								\
+        fun<nm::EW_POW, float32_t, nm::Rational32>, fun<nm::EW_POW, float32_t, nm::Rational64>, fun<nm::EW_POW, float32_t, nm::Rational128>, NULL},																			\
+\
+      {fun<nm::EW_POW, float64_t, uint8_t>, fun<nm::EW_POW, float64_t, int8_t>, fun<nm::EW_POW, float64_t, int16_t>, fun<nm::EW_POW, float64_t, int32_t>, fun<nm::EW_POW, float64_t, int64_t>,	\
+        fun<nm::EW_POW, float64_t, float32_t>, fun<nm::EW_POW, float64_t, float64_t>, fun<nm::EW_POW, float64_t, nm::Complex64>, fun<nm::EW_POW, float64_t, nm::Complex128>,								\
+        fun<nm::EW_POW, float64_t, nm::Rational32>, fun<nm::EW_POW, float64_t, nm::Rational64>, fun<nm::EW_POW, float64_t, nm::Rational128>, NULL},																			\
+\
+      {fun<nm::EW_POW, nm::Complex64, uint8_t>, fun<nm::EW_POW, nm::Complex64, int8_t>, fun<nm::EW_POW, nm::Complex64, int16_t>, fun<nm::EW_POW, nm::Complex64, int32_t>,										\
+        fun<nm::EW_POW, nm::Complex64, int64_t>, fun<nm::EW_POW, nm::Complex64, float32_t>, fun<nm::EW_POW, nm::Complex64, float64_t>, fun<nm::EW_POW, nm::Complex64, nm::Complex64>,				\
+        fun<nm::EW_POW, nm::Complex64, nm::Complex128>, fun<nm::EW_POW, nm::Complex64, nm::Rational32>, fun<nm::EW_POW, nm::Complex64, nm::Rational64>,																	\
+        fun<nm::EW_POW, nm::Complex64, nm::Rational128>, NULL},																																																									\
+\
+      {fun<nm::EW_POW, nm::Complex128, uint8_t>, fun<nm::EW_POW, nm::Complex128, int8_t>, fun<nm::EW_POW, nm::Complex128, int16_t>, fun<nm::EW_POW, nm::Complex128, int32_t>,								\
+        fun<nm::EW_POW, nm::Complex128, int64_t>, fun<nm::EW_POW, nm::Complex128, float32_t>, fun<nm::EW_POW, nm::Complex128, float64_t>, fun<nm::EW_POW, nm::Complex128, nm::Complex64>,		\
+        fun<nm::EW_POW, nm::Complex128, nm::Complex128>,	fun<nm::EW_POW, nm::Complex128, nm::Rational32>, fun<nm::EW_POW, nm::Complex128, nm::Rational64>,															\
+        fun<nm::EW_POW, nm::Complex128, nm::Rational128>, NULL},																																																								\
+\
+      {fun<nm::EW_POW, nm::Rational32, uint8_t>, fun<nm::EW_POW, nm::Rational32, int8_t>, fun<nm::EW_POW, nm::Rational32, int16_t>, fun<nm::EW_POW, nm::Rational32, int32_t>,								\
+        fun<nm::EW_POW, nm::Rational32, int64_t>, NULL, NULL, NULL, NULL, fun<nm::EW_POW, nm::Rational32, nm::Rational32>, fun<nm::EW_POW, nm::Rational32, nm::Rational64>,							\
+        fun<nm::EW_POW, nm::Rational32, nm::Rational128>, NULL},																																																								\
+\
+      {fun<nm::EW_POW, nm::Rational64, uint8_t>, fun<nm::EW_POW, nm::Rational64, int8_t>, fun<nm::EW_POW, nm::Rational64, int16_t>, fun<nm::EW_POW, nm::Rational64, int32_t>,								\
+        fun<nm::EW_POW, nm::Rational64, int64_t>, NULL, NULL, NULL, NULL, fun<nm::EW_POW, nm::Rational64, nm::Rational32>, fun<nm::EW_POW, nm::Rational64, nm::Rational64>,							\
+        fun<nm::EW_POW, nm::Rational64, nm::Rational128>, NULL},																																																								\
+\
+      {fun<nm::EW_POW, nm::Rational128, uint8_t>, fun<nm::EW_POW, nm::Rational128, int8_t>, fun<nm::EW_POW, nm::Rational128, int16_t>, fun<nm::EW_POW, nm::Rational128, int32_t>,						\
+        fun<nm::EW_POW, nm::Rational128, int64_t>, NULL, NULL, NULL, NULL, fun<nm::EW_POW, nm::Rational128, nm::Rational32>, fun<nm::EW_POW, nm::Rational128, nm::Rational64>,					\
+        fun<nm::EW_POW, nm::Rational128, nm::Rational128>, NULL},																																																								\
+\
+      {NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, fun<nm::EW_POW, nm::RubyObject, nm::RubyObject>}																									\
+    },  \
+\
 		{																																																																																				\
 			{fun<nm::EW_MOD, uint8_t, uint8_t>, fun<nm::EW_MOD, uint8_t, int8_t>, fun<nm::EW_MOD, uint8_t, int16_t>, fun<nm::EW_MOD, uint8_t, int32_t>, fun<nm::EW_MOD, uint8_t, int64_t>,						\
 				fun<nm::EW_MOD, uint8_t, float32_t>, fun<nm::EW_MOD, uint8_t, float64_t>, fun<nm::EW_MOD, uint8_t, nm::Complex64>, fun<nm::EW_MOD, uint8_t, nm::Complex128>,												\
@@ -481,7 +512,7 @@ namespace nm {
 			{fun<nm::EW_MOD, nm::Rational128, uint8_t>, fun<nm::EW_MOD, nm::Rational128, int8_t>, fun<nm::EW_MOD, nm::Rational128, int16_t>, fun<nm::EW_MOD, nm::Rational128, int32_t>,						\
 				fun<nm::EW_MOD, nm::Rational128, int64_t>, NULL, NULL, NULL, NULL, fun<nm::EW_MOD, nm::Rational128, nm::Rational32>, fun<nm::EW_MOD, nm::Rational128, nm::Rational64>,					\
 				fun<nm::EW_MOD, nm::Rational128, nm::Rational128>, NULL},																																																								\
-																																																																																						\
+\
 			{NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, fun<nm::EW_MOD, nm::RubyObject, nm::RubyObject>}																									\
 		},																																																																																			\
       																																																																																			\
@@ -734,6 +765,7 @@ extern const size_t 			ITYPE_SIZES[nm::NUM_ITYPES];
 
 extern const nm::dtype_t Upcast[nm::NUM_DTYPES][nm::NUM_DTYPES];
 
+
 /*
  * Functions
  */