nmatrix 0.0.8 → 0.0.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 29f34a19d63da6254ccd6557dc500391a6c766d2
-  data.tar.gz: e70dcc15d4d154d60dfdc12ffc28eaf05705b37a
+  metadata.gz: 3c50cbab8bbd44023c4e72abd2592b3412e47710
+  data.tar.gz: b5dafe0a32a6547e2b723b36f463c5eed8840293
 SHA512:
-  metadata.gz: 96ce3ba8f13ac7ee5f75a8e27cc3e878dc7d12aa98691c00082ceb342c86f9123e43a1e6593c87142c10bd119f571ad8ff4fb77f48b555b6dc4d86290de24778
-  data.tar.gz: 232b743d7b6272e4abcd15a82298d3179fa2f222dc16d754bc5f898bff98aab1c0d0a28d387527dce14b4e500d4d167e61d5636c0570303ffae2238f1b6dd825
+  metadata.gz: 1adaef4aaf34a6c24e3c3e815fc18305a174f781ec648b12942b54bc2ba40314558b4e900e6128af2fe13a921d4255e25dca2af278603a1e9b8c9d270c681061
+  data.tar.gz: ac48bdf4e1f3ff45386a02dc43a0ab2f379e39541f7eb60b6f304d7706d1829b15c8d282ead396a47d9644a6984dc64d8549534c8e1ceb150c9e422566643e42

data/.gitignore

@@ -20,13 +20,8 @@ spec/*.mtx
 *.log
 /tags
 *.gem
-
-ext/nmatrix/*.o
-ext/nmatrix/*.so
-ext/nmatrix/*.log
-ext/nmatrix/**/*.o
-ext/nmatrix/Makefile
-ext/nmatrix/**/Makefile
-ext/nmatrix/nmatrix_config.h
+html/
+doc/
+docs/
 pkg/
 .autotest

data/.rspec

@@ -1,2 +1,2 @@
 --color
---format nested
+--format RSpec::Longrun::Formatter

data/.travis.yml

@@ -0,0 +1,12 @@
+language: ruby
+env:
+  - CPLUS_INCLUDE_PATH=/usr/include/atlas C_INCLUDE_PATH=/usr/include/atlas
+rvm:
+  - "1.9.2"
+  - "1.9.3"
+  - "2.0.0"
+before_install:
+  - sudo apt-get update -qq
+  - sudo apt-get install -qq libatlas-base-dev
+script: bundle exec rake compile && bundle exec rake spec
+

data/CONTRIBUTING.md

@@ -1,4 +1,5 @@
-NMatrix is part of SciRuby, a collaborative effort to bring scientific computation to Ruby. If you want to help, please do so!
+NMatrix is part of SciRuby, a collaborative effort to bring scientific computation to Ruby. If you want to help, please
+ do so!
 
 This guide covers ways in which you can contribute to the development of SciRuby and, more specifically, NMatrix.
 
@@ -6,17 +7,26 @@ This guide covers ways in which you can contribute to the development of SciRuby
 
 There are various ways to help NMatrix: bug reports, coding and documentation. All of them are important.
 
-First, you can help implement new features or bug fixes. To do that, visit our [roadmap](https://github.com/SciRuby/nmatrix/wiki/Roadmap) or our [issue tracker][2]. If you find something that you can tackle, post it in the issue or on our [mailing list][1].
+First, you can help implement new features or bug fixes. To do that, visit our
+ [roadmap](https://github.com/SciRuby/nmatrix/wiki/Roadmap) or our [issue tracker][2]. If you find something that you
+ want to work on, post it in the issue or on our [mailing list][1].
 
-You need to send tests together with your code. No exceptions. You can ask what's our opinion, but we won't accept patches without a good spec coverage.
+You need to send tests together with your code. No exceptions. You can ask for our opinion, but we won't accept patches
+ without good spec coverage.
 
-We use RSpec for testing. If you aren't familiar with it, there's a good [guide to better specs with RSpec](http://betterspecs.org/) that shows a bit of the syntax and how to use it properly. However, the best resource is probably the specs that already exist - so just read them.
+We use RSpec for testing. If you aren't familiar with it, there's a good
+ [guide to better specs with RSpec](http://betterspecs.org/) that shows a bit of the syntax and how to use it properly.
+ However, the best resource is probably the specs that already exist -- so just read them.
 
-And don't forget to write documentation. It's necessary to allow others to know what's available in the library. There's a section on it later in this guide. Ah, we use RDoc.
+And don't forget to write documentation (we use RDoc). It's necessary to allow others to know what's available in the
+ library. There's a section on it later in this guide.
 
-We only accept bug reports and pull requests in GitHub. You'll need to create a new (free) account if you don't have one already. To learn how to create a pull request, please see the [this guide on collaborating](https://help.github.com/categories/63/articles).
+We only accept bug reports and pull requests in GitHub. You'll need to create a new (free) account if you don't have one
+ already. To learn how to create a pull request, please see
+ [this guide on collaborating](https://help.github.com/categories/63/articles).
 
-If you have a question about how to use NMatrix or SciRuby in general or a feature/change in mind, please ask the [sciruby-dev mailing list][1].
+If you have a question about how to use NMatrix or SciRuby in general or a feature/change in mind, please ask the
+ [sciruby-dev mailing list][1].
 
 Thanks!
 
@@ -40,7 +50,8 @@ Now, you need to clone the git repository:
 
 This will install all dependencies, compile the extension and run the specs. 
 
-As of now (12/31/2012), there should be 25 specs failing, in elementwise\_spec, lapack\_spec and math\_spec. If you see more than 25 or from different specs, please report on the [mailing list][1] or on the [issue tracker][2].
+As of now (12/31/2012), there should be 25 specs failing, in elementwise\_spec, lapack\_spec and math\_spec. If you see
+more than 25 or from different specs, please report on the [mailing list][1] or on the [issue tracker][2].
 
 If everything's fine until now, you can create a new branch to work on your feature:
 
@@ -52,15 +63,19 @@ Before commiting any code, please read our
 
 ## Documentation
 
-There are two ways in which NMatrix is being documented: guides and comments, which are converted with RDoc into the documentation seen in [sciruby.com](http://sciruby.com).
+There are two ways in which NMatrix is being documented: guides and comments, which are converted with RDoc into the
+documentation seen in [sciruby.com](http://sciruby.com).
 
-If you want to write a guide on how to use NMatrix to solve some problem or simply showing how to use one of its features, write it as a wiki page and send an e-mail on the [mailing list][1]. We're working to improve this process.
+If you want to write a guide on how to use NMatrix to solve some problem or simply showing how to use one of its
+features, write it as a wiki page and send an e-mail on the [mailing list][1]. We're working to improve this process.
 
-If you aren't familiar with RDoc syntax, [this is the official documentation](http://docs.seattlerb.org/rdoc/RDoc/Markup.html).
+If you aren't familiar with RDoc syntax,
+[this is the official documentation](http://docs.seattlerb.org/rdoc/RDoc/Markup.html).
 
 ## Conclusion
 
-This guide was heavily based on the [Contributing to Ruby on Rails guide](http://edgeguides.rubyonrails.org/contributing_to_ruby_on_rails.html).
+This guide was heavily based on the
+[Contributing to Ruby on Rails guide](http://edgeguides.rubyonrails.org/contributing_to_ruby_on_rails.html).
 
 [1]: https://groups.google.com/forum/?fromgroups#!forum/sciruby-dev
 [2]: https://github.com/sciruby/nmatrix/issues?sort=created&state=open

data/Gemfile

@@ -6,5 +6,6 @@ gem 'packable', ">= 1.3.5"  # for Matlab IO
 
 group :development do
   gem 'pry'
+  gem 'rspec-longrun'
   #gem 'pry-debugger'
 end

data/History.txt

@@ -389,3 +389,41 @@
   * Fixed pry version error which manifests on some systems but not
     others
 
+=== 0.0.9 / 2013-09-18
+
+* 5 major enhancements:
+
+  * Re-factored NMatrix constructor
+
+  * Improved usability of NMatrix shortcut constructor options
+    (e.g., #zeros, #ones, #random, etc.) using new NMatrix
+    constructor
+
+  * Left-assignment of slices for all matrix storage types (uses a
+    dense cast, or accepts an array or single value)
+
+  * Re-factored Yale into a more object-oriented and less confusing
+    set of header files
+
+  * Enabled Travis CI (by @cjfuller)
+
+* 4 minor enhancements:
+
+  * Renamed some specs in order to change their test order, so that
+    critical tests fail first (particularly in the case of
+    segmentation faults)
+
+  * Default dtype is now :object when no initial values are
+    specified
+
+  * Deprecated NVector#initialize and a number of other unnecessary
+    NVector functionality
+
+  * Made Ubuntu compilation significantly easier (by @cjfuller)
+
+* 2 bug fixes:
+
+  * nil values in matrices are now pretty printed as "nil"
+
+  * Casting from dense to Yale now properly accepts the default
+     value option

data/Manifest.txt

@@ -7,19 +7,7 @@ Rakefile
 Gemfile
 Guardfile
 nmatrix.gemspec
-spec/blas_spec.rb
-spec/elementwise_spec.rb
-spec/io_spec.rb
-spec/lapack_spec.rb
-spec/math_spec.rb
-spec/nmatrix_list_spec.rb
-spec/nmatrix_spec.rb
-spec/nmatrix_yale_spec.rb
-spec/nvector_spec.rb
-spec/rspec_spec.rb
-spec/shortcuts_spec.rb
-spec/slice_spec.rb
-spec/spec_helper.rb
+.travis.yml
 lib/nmatrix.rb
 lib/nmatrix/rspec.rb
 lib/nmatrix/io/market.rb
@@ -39,6 +27,7 @@ lib/nmatrix/yale_functions.rb
 ext/nmatrix/data/complex.h
 ext/nmatrix/data/data.cpp
 ext/nmatrix/data/data.h
+ext/nmatrix/data/meta.h
 ext/nmatrix/data/rational.h
 ext/nmatrix/data/ruby_object.h
 ext/nmatrix/storage/common.cpp
@@ -49,8 +38,18 @@ ext/nmatrix/storage/list.cpp
 ext/nmatrix/storage/list.h
 ext/nmatrix/storage/storage.cpp
 ext/nmatrix/storage/storage.h
-ext/nmatrix/storage/yale.cpp
-ext/nmatrix/storage/yale.h
+ext/nmatrix/storage/yale/yale.cpp
+ext/nmatrix/storage/yale/yale.h
+ext/nmatrix/storage/yale/class.h
+ext/nmatrix/storage/yale/iterators/base.h
+ext/nmatrix/storage/yale/iterators/iterator.h
+ext/nmatrix/storage/yale/iterators/row.h
+ext/nmatrix/storage/yale/iterators/row_stored.h
+ext/nmatrix/storage/yale/iterators/row_stored_nd.h
+ext/nmatrix/storage/yale/iterators/stored_diagonal.h
+ext/nmatrix/storage/yale/math/transpose.h
+ext/nmatrix/util/io.cpp
+ext/nmatrix/util/io.h
 ext/nmatrix/util/sl_list.cpp
 ext/nmatrix/util/sl_list.h
 ext/nmatrix/util/util.h
@@ -82,6 +81,7 @@ ext/nmatrix/nmatrix.cpp
 ext/nmatrix/nmatrix.h
 ext/nmatrix/ruby_constants.cpp
 ext/nmatrix/ruby_constants.h
+ext/nmatrix/ruby_nmatrix.c
 ext/nmatrix/types.h
 ext/nmatrix/extconf.rb
 

data/README.rdoc

@@ -27,7 +27,7 @@ However, you will need to install {ATLAS}[http://math-atlas.sourceforge.net/] wi
 * ATLAS
 * 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+
+* Ruby 1.9.3+
 * {packable}[http://github.com/marcandre/packable] 1.3.5 (used for I/O)
 
 If you want to obtain the latest (development) code, you should generally do:
@@ -37,7 +37,7 @@ If you want to obtain the latest (development) code, you should generally do:
     bundle install
     bundle exec rake compile
     bundle exec rake repackage
-    gem install pkg/nmatrix-0.0.8.gem
+    gem install pkg/nmatrix-0.1.0.gem
 
 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].
 
@@ -50,12 +50,12 @@ Carlos Agarie (@agarie) is currently working to improve the documentation. The b
 
 You can find the complete API documentation {on our website}[http://sciruby.com/nmatrix/docs/].
 
-== EXAMPLES
+== Examples
 
 Create a new NMatrix from a ruby array: 
 
     >> require 'nmatrix'
-    >> NMatrix.new([2, 3], [0, 1, 2, 3, 4, 5], :int64).pp
+    >> NMatrix.new([2, 3], [0, 1, 2, 3, 4, 5], dtype: :int64).pp
       [0, 1, 2]
       [3, 4, 5]
     => nil
@@ -113,7 +113,7 @@ The following features exist in the current version of NMatrix (0.0.8):
 * Matrix inversions (requires LAPACK; BLAS dtypes only)
 * Determinant calculation for BLAS dtypes
 * Vector 2-norms
-* Ruby/GSL interoperability (requires [SciRuby's fork of rb-gsl](http://github.com/SciRuby/rb-gsl))
+* Ruby/GSL interoperability (requires {SciRuby's fork of rb-gsl}(http://github.com/SciRuby/rb-gsl))
 
 === Planned Features (Short-to-Medium Term)
 
@@ -121,7 +121,8 @@ We are nearly the release of NMatrix 0.1.0, our first beta.
 
 These are features planned for NMatrix 0.2.0:
 
-* slice assignments (`x[1..3,0..4] = some_other_matrix`)
+* slice assignments, e.g.,
+    x[1..3,0..4] = some_other_matrix
 * LAPACK-free calculation of determinant, trace, and eigenvalues (characteristic polynomial)
 * LAPACK-free matrix inversions
 * tensor products

data/Rakefile

@@ -1,6 +1,7 @@
 # -*- ruby -*-
 
 require 'rubygems'
+require 'rubygems/package_task'
 require 'bundler'
 begin
   Bundler.setup(:default, :development)
@@ -21,8 +22,7 @@ end
 
 gemspec = eval(IO.read("nmatrix.gemspec"))
 
-require "rake/gempackagetask"
-Rake::GemPackageTask.new(gemspec).define
+Gem::PackageTask.new(gemspec).define
 
 desc "install the gem locally"
 task :install => [:package] do
@@ -33,10 +33,10 @@ require 'rspec/core/rake_task'
 require 'rspec/core'
 require 'rspec/core/rake_task'
 RSpec::Core::RakeTask.new(:spec) do |spec|
-  # Load nmatrix_spec first.
-  spec.pattern = FileList['spec/nmatrix_spec.rb', 'spec/**/*_spec.rb'].uniq
+  spec.pattern = FileList['spec/**/*_spec.rb'].uniq
 end
 
+
 BASEDIR = Pathname( __FILE__ ).dirname.relative_path_from( Pathname.pwd )
 SPECDIR = BASEDIR + 'spec'
 
@@ -107,7 +107,7 @@ namespace :spec do
   # spurious (and eminently ignorable) warnings from the ruby
   # interpreter
 
-  RSPEC_CMD = [ 'ruby', '-S', 'rspec', '-Ilib:ext', "#{SPECDIR}/nmatrix_spec.rb #{SPECDIR}" ]
+  RSPEC_CMD = [ 'ruby', '-S', 'rspec', '-Ilib:ext', SPECDIR.to_s ]
 
   #desc "Run the spec for generator.rb"
   #task :generator do |task|
@@ -163,4 +163,39 @@ namespace :clean do
   end
 end
 
+
+desc "Check the manifest for correctness"
+task :check_manifest do |task|
+  manifest_files  = File.read("Manifest.txt").split
+
+  git_files       = `git ls-files |grep -v 'spec/'`.split
+  ignore_files    = %w{.gitignore .rspec ext/nmatrix/binary_format.txt ext/nmatrix/ttable_helper.rb scripts/mac-brew-gcc.sh}
+
+  possible_files  = git_files - ignore_files
+
+  missing_files   = possible_files - manifest_files
+  extra_files     = manifest_files - possible_files
+
+  unless missing_files.empty?
+    STDERR.puts "The following files are in the git repo but not the Manifest:"
+    missing_files.each { |f| STDERR.puts " -- #{f}"}
+  end
+
+  unless extra_files.empty?
+    STDERR.puts "The following files are in the Manifest but may not be necessary:"
+    extra_files.each { |f| STDERR.puts " -- #{f}"}
+  end
+
+  if extra_files.empty? && missing_files.empty?
+    STDERR.puts "Manifest looks good!"
+  end
+
+end
+
+require "rdoc/task"
+RDoc::Task.new do |rdoc|
+  rdoc.main = "README.rdoc"
+  rdoc.rdoc_files.include(%w{README.rdoc History.txt LICENSE.txt CONTRIBUTING.md ext/nmatrix/binary_format.txt lib/nmatrix/**/*.rb ext/nmatrix/**/*.cpp ext/nmatrix/**/*.c ext/nmatrix/**/*.h})
+end
+
 # vim: syntax=ruby

data/ext/nmatrix/data/data.cpp

@@ -115,6 +115,7 @@ namespace nm {
     }
   }
 
+
 } // end of namespace nm
 extern "C" {
 
@@ -134,13 +135,6 @@ const char* const DTYPE_NAMES[nm::NUM_DTYPES] = {
 	"object"
 };
 
-const char* const ITYPE_NAMES[nm::NUM_ITYPES] = {
-	"uint8",
-	"uint16",
-	"uint32",
-	"uint64"
-};
-
 
 const size_t DTYPE_SIZES[nm::NUM_DTYPES] = {
 	sizeof(uint8_t),
@@ -158,12 +152,6 @@ const size_t DTYPE_SIZES[nm::NUM_DTYPES] = {
 	sizeof(nm::RubyObject)
 };
 
-const size_t ITYPE_SIZES[nm::NUM_ITYPES] = {
-	sizeof(uint8_t),
-	sizeof(uint16_t),
-	sizeof(uint32_t),
-	sizeof(uint64_t),
-};
 
 const nm::dtype_t Upcast[nm::NUM_DTYPES][nm::NUM_DTYPES] = {
   { 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},
@@ -306,30 +294,6 @@ nm::RubyObject rubyobj_from_cval(void* val, nm::dtype_t dtype) {
 }
 
 
-/*
- * Convert from itype instead of dtype
- */
-nm::RubyObject rubyobj_from_cval_by_itype(void* val, nm::itype_t itype) {
-  using namespace nm;
-	switch (itype) {
-		case UINT8:
-			return RubyObject(*reinterpret_cast<uint8_t*>(val));
-
-		case UINT16:
-			return RubyObject((int16_t)(*reinterpret_cast<uint16_t*>(val)));
-
-		case UINT32:
-			return RubyObject((int32_t)(*reinterpret_cast<uint32_t*>(val)));
-
-		case UINT64:
-			return RubyObject((int64_t)(*reinterpret_cast<uint64_t*>(val)));
-
-	  default:
-	    rb_raise(nm_eDataTypeError, "Conversion to RubyObject requested from unknown data type");
-	}
-	return Qnil;
-}
-
 
 /*
  * Allocate and return a piece of data of the correct dtype, converted from a
@@ -344,6 +308,7 @@ void* rubyobj_to_cval(VALUE val, nm::dtype_t dtype) {
   return ret_val;
 }
 
+
 void nm_init_data() {
     nm::RubyObject obj(INT2FIX(1));
     nm::Rational32 x(obj);

data/ext/nmatrix/data/data.h

@@ -76,6 +76,7 @@ namespace nm {
   extern const char* const  EWOP_OPS[nm::NUM_EWOPS];
   extern const std::string  EWOP_NAMES[nm::NUM_EWOPS];
 
+
 } // end of namespace nm
 
 /*
@@ -83,7 +84,7 @@ namespace nm {
  */
 
 #define STYPE_MARK_TABLE(name)									\
-  static void (*(name)[nm::NUM_STYPES])(void*) = {	\
+  static void (*(name)[nm::NUM_STYPES])(STORAGE*) = {	\
     nm_dense_storage_mark,											\
     nm_list_storage_mark,												\
     nm_yale_storage_mark												\
@@ -119,6 +120,23 @@ namespace nm {
 		fun<nm::RubyObject>                                 \
 	};
 
+#define DTYPE_OBJECT_STATIC_TABLE(obj, fun, ret, ...)     \
+	static ret (*(ttable)[nm::NUM_DTYPES])(__VA_ARGS__) =	{ \
+		obj<uint8_t>::fun,																	\
+		obj<int8_t>::fun,																		\
+		obj<int16_t>::fun,																  \
+		obj<int32_t>::fun,																	\
+		obj<int64_t>::fun,																	\
+		obj<float32_t>::fun,																\
+		obj<float64_t>::fun,																\
+		obj<nm::Complex64>::fun,													  \
+		obj<nm::Complex128>::fun,														\
+		obj<nm::Rational32>::fun,														\
+		obj<nm::Rational64>::fun,														\
+		obj<nm::Rational128>::fun, 													\
+		obj<nm::RubyObject>::fun                            \
+	};
+
 #define NAMED_DTYPE_TEMPLATE_TABLE_NO_ROBJ(name, fun, ret, ...) \
 	static ret (*(name)[nm::NUM_DTYPES])(__VA_ARGS__) =	{			\
 		fun<uint8_t>,																				\
@@ -135,29 +153,6 @@ namespace nm {
 		fun<nm::Rational128>																\
 	};
 
-/*
- * Defines a static array that holds function pointers to itype templated
- * versions of the specified function.
- */
-#define ITYPE_TEMPLATE_TABLE(fun, ret, ...) NAMED_ITYPE_TEMPLATE_TABLE(ttable, fun, ret, __VA_ARGS__)
-
-#define NAMED_ITYPE_TEMPLATE_TABLE(name, fun, ret, ...)	\
-  static ret (*(name)[nm::NUM_ITYPES])(__VA_ARGS__) = {			\
-    fun<uint8_t>,																				\
-    fun<uint16_t>,																			\
-    fun<uint32_t>,																			\
-    fun<uint64_t>																				\
-  };
-
-#define ITYPE_TEMPLATE_TABLE(fun, ret, ...) NAMED_ITYPE_TEMPLATE_TABLE(ttable, fun, ret, __VA_ARGS__)
-
-#define NAMED_LR_ITYPE_TEMPLATE_TABLE(name, fun, ret, ...) \
-  static ret (*(name)[nm::NUM_ITYPES][nm::NUM_ITYPES])(__VA_ARGS__) = { \
-    { fun<uint8_t,uint8_t>, fun<uint8_t, uint16_t>, fun<uint8_t, uint32_t>, fun<uint8_t, uint64_t> }, \
-    { fun<uint16_t,uint8_t>, fun<uint16_t, uint16_t>, fun<uint16_t, uint32_t>, fun<uint16_t, uint64_t> }, \
-    { fun<uint32_t,uint8_t>, fun<uint32_t, uint16_t>, fun<uint32_t, uint32_t>, fun<uint32_t, uint64_t> }, \
-    { fun<uint64_t,uint8_t>, fun<uint64_t, uint16_t>, fun<uint64_t, uint32_t>, fun<uint64_t, uint64_t> } \
-  };
 
 /*
  * Same as DTYPE_TEMPLATE_TABLE but for functions that have two template
@@ -658,98 +653,6 @@ namespace nm {
 {fun<nm::EW_GEQ, uint64_t, uint8_t>,fun<nm::EW_GEQ, uint64_t, int8_t>,fun<nm::EW_GEQ, uint64_t, int16_t>,fun<nm::EW_GEQ, uint64_t, int32_t>,fun<nm::EW_GEQ, uint64_t, int64_t>,fun<nm::EW_GEQ, uint64_t, float32_t>,fun<nm::EW_GEQ, uint64_t, float64_t>,fun<nm::EW_GEQ, uint64_t, nm::Complex64>,fun<nm::EW_GEQ, uint64_t, nm::Complex128>,fun<nm::EW_GEQ, uint64_t, nm::Rational32>,fun<nm::EW_GEQ, uint64_t, nm::Rational64>,fun<nm::EW_GEQ, uint64_t, nm::Rational128>,fun<nm::EW_GEQ, uint64_t, nm::RubyObject>}}};
 
 
-
-/*
- * Defines a static array that holds function pointers to left dtype, right
- * dtype, and itype templated versions of the specified function.
- */
-#define LRI_DTYPE_TEMPLATE_TABLE(fun, ret, ...) NAMED_LRI_DTYPE_TEMPLATE_TABLE(ttable, fun, ret, __VA_ARGS__)
-
-#define NAMED_LRI_DTYPE_TEMPLATE_TABLE(name,  fun,  ret,  ...) \
-static ret (*(name)[nm::NUM_DTYPES][nm::NUM_DTYPES][nm::NUM_ITYPES])(__VA_ARGS__) = { \
-  { \
-    {fun<uint8_t, uint8_t, uint8_t>, fun<uint8_t, uint8_t, uint16_t>, fun<uint8_t, uint8_t, uint32_t>, fun<uint8_t, uint8_t, uint64_t> },  \
-    {fun<uint8_t, int8_t, uint8_t>, fun<uint8_t, int8_t, uint16_t>, fun<uint8_t, int8_t, uint32_t>, fun<uint8_t, int8_t, uint64_t> },  \
-    {fun<uint8_t, int16_t, uint8_t>, fun<uint8_t, int16_t, uint16_t>, fun<uint8_t, int16_t, uint32_t>, fun<uint8_t, int16_t, uint64_t> },  \
-    {fun<uint8_t, int32_t, uint8_t>, fun<uint8_t, int32_t, uint16_t>, fun<uint8_t, int32_t, uint32_t>, fun<uint8_t, int32_t, uint64_t> },  \
-    {fun<uint8_t, int64_t, uint8_t>, fun<uint8_t, int64_t, uint16_t>, fun<uint8_t, int64_t, uint32_t>, fun<uint8_t, int64_t, uint64_t> },  \
-    {fun<uint8_t, float32_t, uint8_t>, fun<uint8_t, float32_t, uint16_t>, fun<uint8_t, float32_t, uint32_t>, fun<uint8_t, float32_t, uint64_t> },  \
-    {fun<uint8_t, float64_t, uint8_t>, fun<uint8_t, float64_t, uint16_t>, fun<uint8_t, float64_t, uint32_t>, fun<uint8_t, float64_t, uint64_t> },  \
-    {fun<uint8_t, nm::Complex64, uint8_t>, fun<uint8_t, nm::Complex64, uint16_t>, fun<uint8_t, nm::Complex64, uint32_t>, fun<uint8_t, nm::Complex64, uint64_t> },  \
-    {fun<uint8_t, nm::Complex128, uint8_t>, fun<uint8_t, nm::Complex128, uint16_t>, fun<uint8_t, nm::Complex128, uint32_t>, fun<uint8_t, nm::Complex128, uint64_t> },  \
-    {fun<uint8_t, nm::Rational32, uint8_t>, fun<uint8_t, nm::Rational32, uint16_t>, fun<uint8_t, nm::Rational32, uint32_t>, fun<uint8_t, nm::Rational32, uint64_t> },  \
-    {fun<uint8_t, nm::Rational64, uint8_t>, fun<uint8_t, nm::Rational64, uint16_t>, fun<uint8_t, nm::Rational64, uint32_t>, fun<uint8_t, nm::Rational64, uint64_t> },  \
-    {fun<uint8_t, nm::Rational128, uint8_t>, fun<uint8_t, nm::Rational128, uint16_t>, fun<uint8_t, nm::Rational128, uint32_t>, fun<uint8_t, nm::Rational128, uint64_t> },  \
-    {fun<uint8_t, nm::RubyObject, uint8_t>, fun<uint8_t, nm::RubyObject, uint16_t>, fun<uint8_t, nm::RubyObject, uint32_t>, fun<uint8_t, nm::RubyObject, uint64_t> } \
-  },  \
-  {   \
-    {fun<int8_t, uint8_t, uint8_t>, fun<int8_t, uint8_t, uint16_t>, fun<int8_t, uint8_t, uint32_t>, fun<int8_t, uint8_t, uint64_t> },  \
-    {fun<int8_t, int8_t, uint8_t>, fun<int8_t, int8_t, uint16_t>, fun<int8_t, int8_t, uint32_t>, fun<int8_t, int8_t, uint64_t> },  \
-    {fun<int8_t, int16_t, uint8_t>, fun<int8_t, int16_t, uint16_t>, fun<int8_t, int16_t, uint32_t>, fun<int8_t, int16_t, uint64_t> },  \
-    {fun<int8_t, int32_t, uint8_t>, fun<int8_t, int32_t, uint16_t>, fun<int8_t, int32_t, uint32_t>, fun<int8_t, int32_t, uint64_t> },  \
-    {fun<int8_t, int64_t, uint8_t>, fun<int8_t, int64_t, uint16_t>, fun<int8_t, int64_t, uint32_t>, fun<int8_t, int64_t, uint64_t> },  \
-    {fun<int8_t, float32_t, uint8_t>, fun<int8_t, float32_t, uint16_t>, fun<int8_t, float32_t, uint32_t>, fun<int8_t, float32_t, uint64_t> },  \
-    {fun<int8_t, float64_t, uint8_t>, fun<int8_t, float64_t, uint16_t>, fun<int8_t, float64_t, uint32_t>, fun<int8_t, float64_t, uint64_t> },  \
-    {fun<int8_t, nm::Complex64, uint8_t>, fun<int8_t, nm::Complex64, uint16_t>, fun<int8_t, nm::Complex64, uint32_t>, fun<int8_t, nm::Complex64, uint64_t> },  \
-    {fun<int8_t, nm::Complex128, uint8_t>, fun<int8_t, nm::Complex128, uint16_t>, fun<int8_t, nm::Complex128, uint32_t>, fun<int8_t, nm::Complex128, uint64_t> },  \
-    {fun<int8_t, nm::Rational32, uint8_t>, fun<int8_t, nm::Rational32, uint16_t>, fun<int8_t, nm::Rational32, uint32_t>, fun<int8_t, nm::Rational32, uint64_t> },  \
-    {fun<int8_t, nm::Rational64, uint8_t>, fun<int8_t, nm::Rational64, uint16_t>, fun<int8_t, nm::Rational64, uint32_t>, fun<int8_t, nm::Rational64, uint64_t> },  \
-    {fun<int8_t, nm::Rational128, uint8_t>, fun<int8_t, nm::Rational128, uint16_t>, fun<int8_t, nm::Rational128, uint32_t>, fun<int8_t, nm::Rational128, uint64_t> },  \
-    {fun<int8_t, nm::RubyObject, uint8_t>, fun<int8_t, nm::RubyObject, uint16_t>, fun<int8_t, nm::RubyObject, uint32_t>, fun<int8_t, nm::RubyObject, uint64_t> } \
-  },  \
-  {{fun<int16_t, uint8_t, uint8_t>, fun<int16_t, uint8_t, uint16_t>, fun<int16_t, uint8_t, uint32_t>, fun<int16_t, uint8_t, uint64_t> }, {fun<int16_t, int8_t, uint8_t>, fun<int16_t, int8_t, uint16_t>, fun<int16_t, int8_t, uint32_t>, fun<int16_t, int8_t, uint64_t> }, {fun<int16_t, int16_t, uint8_t>, fun<int16_t, int16_t, uint16_t>, fun<int16_t, int16_t, uint32_t>, fun<int16_t, int16_t, uint64_t> }, {fun<int16_t, int32_t, uint8_t>, fun<int16_t, int32_t, uint16_t>, fun<int16_t, int32_t, uint32_t>, fun<int16_t, int32_t, uint64_t> }, {fun<int16_t, int64_t, uint8_t>, fun<int16_t, int64_t, uint16_t>, fun<int16_t, int64_t, uint32_t>, fun<int16_t, int64_t, uint64_t> }, {fun<int16_t, float32_t, uint8_t>, fun<int16_t, float32_t, uint16_t>, fun<int16_t, float32_t, uint32_t>, fun<int16_t, float32_t, uint64_t> }, {fun<int16_t, float64_t, uint8_t>, fun<int16_t, float64_t, uint16_t>, fun<int16_t, float64_t, uint32_t>, fun<int16_t, float64_t, uint64_t> }, {fun<int16_t, nm::Complex64, uint8_t>, fun<int16_t, nm::Complex64, uint16_t>, fun<int16_t, nm::Complex64, uint32_t>, fun<int16_t, nm::Complex64, uint64_t> }, {fun<int16_t, nm::Complex128, uint8_t>, fun<int16_t, nm::Complex128, uint16_t>, fun<int16_t, nm::Complex128, uint32_t>, fun<int16_t, nm::Complex128, uint64_t> }, {fun<int16_t, nm::Rational32, uint8_t>, fun<int16_t, nm::Rational32, uint16_t>, fun<int16_t, nm::Rational32, uint32_t>, fun<int16_t, nm::Rational32, uint64_t> }, {fun<int16_t, nm::Rational64, uint8_t>, fun<int16_t, nm::Rational64, uint16_t>, fun<int16_t, nm::Rational64, uint32_t>, fun<int16_t, nm::Rational64, uint64_t> }, {fun<int16_t, nm::Rational128, uint8_t>, fun<int16_t, nm::Rational128, uint16_t>, fun<int16_t, nm::Rational128, uint32_t>, fun<int16_t, nm::Rational128, uint64_t> }, {fun<int16_t, nm::RubyObject, uint8_t>, fun<int16_t, nm::RubyObject, uint16_t>, fun<int16_t, nm::RubyObject, uint32_t>, fun<int16_t, nm::RubyObject, uint64_t> }},  \
-  {{fun<int32_t, uint8_t, uint8_t>, fun<int32_t, uint8_t, uint16_t>, fun<int32_t, uint8_t, uint32_t>, fun<int32_t, uint8_t, uint64_t> }, {fun<int32_t, int8_t, uint8_t>, fun<int32_t, int8_t, uint16_t>, fun<int32_t, int8_t, uint32_t>, fun<int32_t, int8_t, uint64_t> }, {fun<int32_t, int16_t, uint8_t>, fun<int32_t, int16_t, uint16_t>, fun<int32_t, int16_t, uint32_t>, fun<int32_t, int16_t, uint64_t> }, {fun<int32_t, int32_t, uint8_t>, fun<int32_t, int32_t, uint16_t>, fun<int32_t, int32_t, uint32_t>, fun<int32_t, int32_t, uint64_t> }, {fun<int32_t, int64_t, uint8_t>, fun<int32_t, int64_t, uint16_t>, fun<int32_t, int64_t, uint32_t>, fun<int32_t, int64_t, uint64_t> }, {fun<int32_t, float32_t, uint8_t>, fun<int32_t, float32_t, uint16_t>, fun<int32_t, float32_t, uint32_t>, fun<int32_t, float32_t, uint64_t> }, {fun<int32_t, float64_t, uint8_t>, fun<int32_t, float64_t, uint16_t>, fun<int32_t, float64_t, uint32_t>, fun<int32_t, float64_t, uint64_t> }, {fun<int32_t, nm::Complex64, uint8_t>, fun<int32_t, nm::Complex64, uint16_t>, fun<int32_t, nm::Complex64, uint32_t>, fun<int32_t, nm::Complex64, uint64_t> }, {fun<int32_t, nm::Complex128, uint8_t>, fun<int32_t, nm::Complex128, uint16_t>, fun<int32_t, nm::Complex128, uint32_t>, fun<int32_t, nm::Complex128, uint64_t> }, {fun<int32_t, nm::Rational32, uint8_t>, fun<int32_t, nm::Rational32, uint16_t>, fun<int32_t, nm::Rational32, uint32_t>, fun<int32_t, nm::Rational32, uint64_t> }, {fun<int32_t, nm::Rational64, uint8_t>, fun<int32_t, nm::Rational64, uint16_t>, fun<int32_t, nm::Rational64, uint32_t>, fun<int32_t, nm::Rational64, uint64_t> }, {fun<int32_t, nm::Rational128, uint8_t>, fun<int32_t, nm::Rational128, uint16_t>, fun<int32_t, nm::Rational128, uint32_t>, fun<int32_t, nm::Rational128, uint64_t> }, {fun<int32_t, nm::RubyObject, uint8_t>, fun<int32_t, nm::RubyObject, uint16_t>, fun<int32_t, nm::RubyObject, uint32_t>, fun<int32_t, nm::RubyObject, uint64_t> }},  \
-  {{fun<int64_t, uint8_t, uint8_t>, fun<int64_t, uint8_t, uint16_t>, fun<int64_t, uint8_t, uint32_t>, fun<int64_t, uint8_t, uint64_t> }, {fun<int64_t, int8_t, uint8_t>, fun<int64_t, int8_t, uint16_t>, fun<int64_t, int8_t, uint32_t>, fun<int64_t, int8_t, uint64_t> }, {fun<int64_t, int16_t, uint8_t>, fun<int64_t, int16_t, uint16_t>, fun<int64_t, int16_t, uint32_t>, fun<int64_t, int16_t, uint64_t> }, {fun<int64_t, int32_t, uint8_t>, fun<int64_t, int32_t, uint16_t>, fun<int64_t, int32_t, uint32_t>, fun<int64_t, int32_t, uint64_t> }, {fun<int64_t, int64_t, uint8_t>, fun<int64_t, int64_t, uint16_t>, fun<int64_t, int64_t, uint32_t>, fun<int64_t, int64_t, uint64_t> }, {fun<int64_t, float32_t, uint8_t>, fun<int64_t, float32_t, uint16_t>, fun<int64_t, float32_t, uint32_t>, fun<int64_t, float32_t, uint64_t> }, {fun<int64_t, float64_t, uint8_t>, fun<int64_t, float64_t, uint16_t>, fun<int64_t, float64_t, uint32_t>, fun<int64_t, float64_t, uint64_t> }, {fun<int64_t, nm::Complex64, uint8_t>, fun<int64_t, nm::Complex64, uint16_t>, fun<int64_t, nm::Complex64, uint32_t>, fun<int64_t, nm::Complex64, uint64_t> }, {fun<int64_t, nm::Complex128, uint8_t>, fun<int64_t, nm::Complex128, uint16_t>, fun<int64_t, nm::Complex128, uint32_t>, fun<int64_t, nm::Complex128, uint64_t> }, {fun<int64_t, nm::Rational32, uint8_t>, fun<int64_t, nm::Rational32, uint16_t>, fun<int64_t, nm::Rational32, uint32_t>, fun<int64_t, nm::Rational32, uint64_t> }, {fun<int64_t, nm::Rational64, uint8_t>, fun<int64_t, nm::Rational64, uint16_t>, fun<int64_t, nm::Rational64, uint32_t>, fun<int64_t, nm::Rational64, uint64_t> }, {fun<int64_t, nm::Rational128, uint8_t>, fun<int64_t, nm::Rational128, uint16_t>, fun<int64_t, nm::Rational128, uint32_t>, fun<int64_t, nm::Rational128, uint64_t> }, {fun<int64_t, nm::RubyObject, uint8_t>, fun<int64_t, nm::RubyObject, uint16_t>, fun<int64_t, nm::RubyObject, uint32_t>, fun<int64_t, nm::RubyObject, uint64_t> }},  \
-  {{fun<float32_t, uint8_t, uint8_t>, fun<float32_t, uint8_t, uint16_t>, fun<float32_t, uint8_t, uint32_t>, fun<float32_t, uint8_t, uint64_t> }, {fun<float32_t, int8_t, uint8_t>, fun<float32_t, int8_t, uint16_t>, fun<float32_t, int8_t, uint32_t>, fun<float32_t, int8_t, uint64_t> }, {fun<float32_t, int16_t, uint8_t>, fun<float32_t, int16_t, uint16_t>, fun<float32_t, int16_t, uint32_t>, fun<float32_t, int16_t, uint64_t> }, {fun<float32_t, int32_t, uint8_t>, fun<float32_t, int32_t, uint16_t>, fun<float32_t, int32_t, uint32_t>, fun<float32_t, int32_t, uint64_t> }, {fun<float32_t, int64_t, uint8_t>, fun<float32_t, int64_t, uint16_t>, fun<float32_t, int64_t, uint32_t>, fun<float32_t, int64_t, uint64_t> }, {fun<float32_t, float32_t, uint8_t>, fun<float32_t, float32_t, uint16_t>, fun<float32_t, float32_t, uint32_t>, fun<float32_t, float32_t, uint64_t> }, {fun<float32_t, float64_t, uint8_t>, fun<float32_t, float64_t, uint16_t>, fun<float32_t, float64_t, uint32_t>, fun<float32_t, float64_t, uint64_t> }, {fun<float32_t, nm::Complex64, uint8_t>, fun<float32_t, nm::Complex64, uint16_t>, fun<float32_t, nm::Complex64, uint32_t>, fun<float32_t, nm::Complex64, uint64_t> }, {fun<float32_t, nm::Complex128, uint8_t>, fun<float32_t, nm::Complex128, uint16_t>, fun<float32_t, nm::Complex128, uint32_t>, fun<float32_t, nm::Complex128, uint64_t> }, {fun<float32_t, nm::Rational32, uint8_t>, fun<float32_t, nm::Rational32, uint16_t>, fun<float32_t, nm::Rational32, uint32_t>, fun<float32_t, nm::Rational32, uint64_t> }, {fun<float32_t, nm::Rational64, uint8_t>, fun<float32_t, nm::Rational64, uint16_t>, fun<float32_t, nm::Rational64, uint32_t>, fun<float32_t, nm::Rational64, uint64_t> }, {fun<float32_t, nm::Rational128, uint8_t>, fun<float32_t, nm::Rational128, uint16_t>, fun<float32_t, nm::Rational128, uint32_t>, fun<float32_t, nm::Rational128, uint64_t> }, {fun<float32_t, nm::RubyObject, uint8_t>, fun<float32_t, nm::RubyObject, uint16_t>, fun<float32_t, nm::RubyObject, uint32_t>, fun<float32_t, nm::RubyObject, uint64_t> }},  \
-  {{fun<float64_t, uint8_t, uint8_t>, fun<float64_t, uint8_t, uint16_t>, fun<float64_t, uint8_t, uint32_t>, fun<float64_t, uint8_t, uint64_t> }, {fun<float64_t, int8_t, uint8_t>, fun<float64_t, int8_t, uint16_t>, fun<float64_t, int8_t, uint32_t>, fun<float64_t, int8_t, uint64_t> }, {fun<float64_t, int16_t, uint8_t>, fun<float64_t, int16_t, uint16_t>, fun<float64_t, int16_t, uint32_t>, fun<float64_t, int16_t, uint64_t> }, {fun<float64_t, int32_t, uint8_t>, fun<float64_t, int32_t, uint16_t>, fun<float64_t, int32_t, uint32_t>, fun<float64_t, int32_t, uint64_t> }, {fun<float64_t, int64_t, uint8_t>, fun<float64_t, int64_t, uint16_t>, fun<float64_t, int64_t, uint32_t>, fun<float64_t, int64_t, uint64_t> }, {fun<float64_t, float32_t, uint8_t>, fun<float64_t, float32_t, uint16_t>, fun<float64_t, float32_t, uint32_t>, fun<float64_t, float32_t, uint64_t> }, {fun<float64_t, float64_t, uint8_t>, fun<float64_t, float64_t, uint16_t>, fun<float64_t, float64_t, uint32_t>, fun<float64_t, float64_t, uint64_t> }, {fun<float64_t, nm::Complex64, uint8_t>, fun<float64_t, nm::Complex64, uint16_t>, fun<float64_t, nm::Complex64, uint32_t>, fun<float64_t, nm::Complex64, uint64_t> }, {fun<float64_t, nm::Complex128, uint8_t>, fun<float64_t, nm::Complex128, uint16_t>, fun<float64_t, nm::Complex128, uint32_t>, fun<float64_t, nm::Complex128, uint64_t> }, {fun<float64_t, nm::Rational32, uint8_t>, fun<float64_t, nm::Rational32, uint16_t>, fun<float64_t, nm::Rational32, uint32_t>, fun<float64_t, nm::Rational32, uint64_t> }, {fun<float64_t, nm::Rational64, uint8_t>, fun<float64_t, nm::Rational64, uint16_t>, fun<float64_t, nm::Rational64, uint32_t>, fun<float64_t, nm::Rational64, uint64_t> }, {fun<float64_t, nm::Rational128, uint8_t>, fun<float64_t, nm::Rational128, uint16_t>, fun<float64_t, nm::Rational128, uint32_t>, fun<float64_t, nm::Rational128, uint64_t> }, {fun<float64_t, nm::RubyObject, uint8_t>, fun<float64_t, nm::RubyObject, uint16_t>, fun<float64_t, nm::RubyObject, uint32_t>, fun<float64_t, nm::RubyObject, uint64_t> }},  \
-  {{fun<nm::Complex64, uint8_t, uint8_t>, fun<nm::Complex64, uint8_t, uint16_t>, fun<nm::Complex64, uint8_t, uint32_t>, fun<nm::Complex64, uint8_t, uint64_t> }, {fun<nm::Complex64, int8_t, uint8_t>, fun<nm::Complex64, int8_t, uint16_t>, fun<nm::Complex64, int8_t, uint32_t>, fun<nm::Complex64, int8_t, uint64_t> }, {fun<nm::Complex64, int16_t, uint8_t>, fun<nm::Complex64, int16_t, uint16_t>, fun<nm::Complex64, int16_t, uint32_t>, fun<nm::Complex64, int16_t, uint64_t> }, {fun<nm::Complex64, int32_t, uint8_t>, fun<nm::Complex64, int32_t, uint16_t>, fun<nm::Complex64, int32_t, uint32_t>, fun<nm::Complex64, int32_t, uint64_t> }, {fun<nm::Complex64, int64_t, uint8_t>, fun<nm::Complex64, int64_t, uint16_t>, fun<nm::Complex64, int64_t, uint32_t>, fun<nm::Complex64, int64_t, uint64_t> }, {fun<nm::Complex64, float32_t, uint8_t>, fun<nm::Complex64, float32_t, uint16_t>, fun<nm::Complex64, float32_t, uint32_t>, fun<nm::Complex64, float32_t, uint64_t> }, {fun<nm::Complex64, float64_t, uint8_t>, fun<nm::Complex64, float64_t, uint16_t>, fun<nm::Complex64, float64_t, uint32_t>, fun<nm::Complex64, float64_t, uint64_t> }, {fun<nm::Complex64, nm::Complex64, uint8_t>, fun<nm::Complex64, nm::Complex64, uint16_t>, fun<nm::Complex64, nm::Complex64, uint32_t>, fun<nm::Complex64, nm::Complex64, uint64_t> }, {fun<nm::Complex64, nm::Complex128, uint8_t>, fun<nm::Complex64, nm::Complex128, uint16_t>, fun<nm::Complex64, nm::Complex128, uint32_t>, fun<nm::Complex64, nm::Complex128, uint64_t> }, {fun<nm::Complex64, nm::Rational32, uint8_t>, fun<nm::Complex64, nm::Rational32, uint16_t>, fun<nm::Complex64, nm::Rational32, uint32_t>, fun<nm::Complex64, nm::Rational32, uint64_t> }, {fun<nm::Complex64, nm::Rational64, uint8_t>, fun<nm::Complex64, nm::Rational64, uint16_t>, fun<nm::Complex64, nm::Rational64, uint32_t>, fun<nm::Complex64, nm::Rational64, uint64_t> }, {fun<nm::Complex64, nm::Rational128, uint8_t>, fun<nm::Complex64, nm::Rational128, uint16_t>, fun<nm::Complex64, nm::Rational128, uint32_t>, fun<nm::Complex64, nm::Rational128, uint64_t> }, {fun<nm::Complex64, nm::RubyObject, uint8_t>, fun<nm::Complex64, nm::RubyObject, uint16_t>, fun<nm::Complex64, nm::RubyObject, uint32_t>, fun<nm::Complex64, nm::RubyObject, uint64_t> }},  \
-  {{fun<nm::Complex128, uint8_t, uint8_t>, fun<nm::Complex128, uint8_t, uint16_t>, fun<nm::Complex128, uint8_t, uint32_t>, fun<nm::Complex128, uint8_t, uint64_t> }, {fun<nm::Complex128, int8_t, uint8_t>, fun<nm::Complex128, int8_t, uint16_t>, fun<nm::Complex128, int8_t, uint32_t>, fun<nm::Complex128, int8_t, uint64_t> }, {fun<nm::Complex128, int16_t, uint8_t>, fun<nm::Complex128, int16_t, uint16_t>, fun<nm::Complex128, int16_t, uint32_t>, fun<nm::Complex128, int16_t, uint64_t> }, {fun<nm::Complex128, int32_t, uint8_t>, fun<nm::Complex128, int32_t, uint16_t>, fun<nm::Complex128, int32_t, uint32_t>, fun<nm::Complex128, int32_t, uint64_t> }, {fun<nm::Complex128, int64_t, uint8_t>, fun<nm::Complex128, int64_t, uint16_t>, fun<nm::Complex128, int64_t, uint32_t>, fun<nm::Complex128, int64_t, uint64_t> }, {fun<nm::Complex128, float32_t, uint8_t>, fun<nm::Complex128, float32_t, uint16_t>, fun<nm::Complex128, float32_t, uint32_t>, fun<nm::Complex128, float32_t, uint64_t> }, {fun<nm::Complex128, float64_t, uint8_t>, fun<nm::Complex128, float64_t, uint16_t>, fun<nm::Complex128, float64_t, uint32_t>, fun<nm::Complex128, float64_t, uint64_t> }, {fun<nm::Complex128, nm::Complex64, uint8_t>, fun<nm::Complex128, nm::Complex64, uint16_t>, fun<nm::Complex128, nm::Complex64, uint32_t>, fun<nm::Complex128, nm::Complex64, uint64_t> }, {fun<nm::Complex128, nm::Complex128, uint8_t>, fun<nm::Complex128, nm::Complex128, uint16_t>, fun<nm::Complex128, nm::Complex128, uint32_t>, fun<nm::Complex128, nm::Complex128, uint64_t> }, {fun<nm::Complex128, nm::Rational32, uint8_t>, fun<nm::Complex128, nm::Rational32, uint16_t>, fun<nm::Complex128, nm::Rational32, uint32_t>, fun<nm::Complex128, nm::Rational32, uint64_t> }, {fun<nm::Complex128, nm::Rational64, uint8_t>, fun<nm::Complex128, nm::Rational64, uint16_t>, fun<nm::Complex128, nm::Rational64, uint32_t>, fun<nm::Complex128, nm::Rational64, uint64_t> }, {fun<nm::Complex128, nm::Rational128, uint8_t>, fun<nm::Complex128, nm::Rational128, uint16_t>, fun<nm::Complex128, nm::Rational128, uint32_t>, fun<nm::Complex128, nm::Rational128, uint64_t> }, {fun<nm::Complex128, nm::RubyObject, uint8_t>, fun<nm::Complex128, nm::RubyObject, uint16_t>, fun<nm::Complex128, nm::RubyObject, uint32_t>, fun<nm::Complex128, nm::RubyObject, uint64_t> }},  \
-  {{fun<nm::Rational32, uint8_t, uint8_t>, fun<nm::Rational32, uint8_t, uint16_t>, fun<nm::Rational32, uint8_t, uint32_t>, fun<nm::Rational32, uint8_t, uint64_t> }, {fun<nm::Rational32, int8_t, uint8_t>, fun<nm::Rational32, int8_t, uint16_t>, fun<nm::Rational32, int8_t, uint32_t>, fun<nm::Rational32, int8_t, uint64_t> }, {fun<nm::Rational32, int16_t, uint8_t>, fun<nm::Rational32, int16_t, uint16_t>, fun<nm::Rational32, int16_t, uint32_t>, fun<nm::Rational32, int16_t, uint64_t> }, {fun<nm::Rational32, int32_t, uint8_t>, fun<nm::Rational32, int32_t, uint16_t>, fun<nm::Rational32, int32_t, uint32_t>, fun<nm::Rational32, int32_t, uint64_t> }, {fun<nm::Rational32, int64_t, uint8_t>, fun<nm::Rational32, int64_t, uint16_t>, fun<nm::Rational32, int64_t, uint32_t>, fun<nm::Rational32, int64_t, uint64_t> }, {NULL, NULL, NULL, NULL }, {NULL, NULL, NULL, NULL }, {NULL, NULL, NULL, NULL }, {NULL, NULL, NULL, NULL }, {fun<nm::Rational32, nm::Rational32, uint8_t>, fun<nm::Rational32, nm::Rational32, uint16_t>, fun<nm::Rational32, nm::Rational32, uint32_t>, fun<nm::Rational32, nm::Rational32, uint64_t> }, {fun<nm::Rational32, nm::Rational64, uint8_t>, fun<nm::Rational32, nm::Rational64, uint16_t>, fun<nm::Rational32, nm::Rational64, uint32_t>, fun<nm::Rational32, nm::Rational64, uint64_t> }, {fun<nm::Rational32, nm::Rational128, uint8_t>, fun<nm::Rational32, nm::Rational128, uint16_t>, fun<nm::Rational32, nm::Rational128, uint32_t>, fun<nm::Rational32, nm::Rational128, uint64_t> }, {fun<nm::Rational32, nm::RubyObject, uint8_t>, fun<nm::Rational32, nm::RubyObject, uint16_t>, fun<nm::Rational32, nm::RubyObject, uint32_t>, fun<nm::Rational32, nm::RubyObject, uint64_t>}},  \
-  {{fun<nm::Rational64, uint8_t, uint8_t>, fun<nm::Rational64, uint8_t, uint16_t>, fun<nm::Rational64, uint8_t, uint32_t>, fun<nm::Rational64, uint8_t, uint64_t> }, {fun<nm::Rational64, int8_t, uint8_t>, fun<nm::Rational64, int8_t, uint16_t>, fun<nm::Rational64, int8_t, uint32_t>, fun<nm::Rational64, int8_t, uint64_t> }, {fun<nm::Rational64, int16_t, uint8_t>, fun<nm::Rational64, int16_t, uint16_t>, fun<nm::Rational64, int16_t, uint32_t>, fun<nm::Rational64, int16_t, uint64_t> }, {fun<nm::Rational64, int32_t, uint8_t>, fun<nm::Rational64, int32_t, uint16_t>, fun<nm::Rational64, int32_t, uint32_t>, fun<nm::Rational64, int32_t, uint64_t> }, {fun<nm::Rational64, int64_t, uint8_t>, fun<nm::Rational64, int64_t, uint16_t>, fun<nm::Rational64, int64_t, uint32_t>, fun<nm::Rational64, int64_t, uint64_t> }, {NULL, NULL, NULL, NULL }, {NULL, NULL, NULL, NULL }, {NULL, NULL, NULL, NULL }, {NULL, NULL, NULL, NULL }, {fun<nm::Rational64, nm::Rational32, uint8_t>, fun<nm::Rational64, nm::Rational32, uint16_t>, fun<nm::Rational64, nm::Rational32, uint32_t>, fun<nm::Rational64, nm::Rational32, uint64_t> }, {fun<nm::Rational64, nm::Rational64, uint8_t>, fun<nm::Rational64, nm::Rational64, uint16_t>, fun<nm::Rational64, nm::Rational64, uint32_t>, fun<nm::Rational64, nm::Rational64, uint64_t> }, {fun<nm::Rational64, nm::Rational128, uint8_t>, fun<nm::Rational64, nm::Rational128, uint16_t>, fun<nm::Rational64, nm::Rational128, uint32_t>, fun<nm::Rational64, nm::Rational128, uint64_t> }, {fun<nm::Rational64, nm::RubyObject, uint8_t>, fun<nm::Rational64, nm::RubyObject, uint16_t>, fun<nm::Rational64, nm::RubyObject, uint32_t>, fun<nm::Rational64, nm::RubyObject, uint64_t>}},  \
-  {{fun<nm::Rational128, uint8_t, uint8_t>, fun<nm::Rational128, uint8_t, uint16_t>, fun<nm::Rational128, uint8_t, uint32_t>, fun<nm::Rational128, uint8_t, uint64_t> }, {fun<nm::Rational128, int8_t, uint8_t>, fun<nm::Rational128, int8_t, uint16_t>, fun<nm::Rational128, int8_t, uint32_t>, fun<nm::Rational128, int8_t, uint64_t> }, {fun<nm::Rational128, int16_t, uint8_t>, fun<nm::Rational128, int16_t, uint16_t>, fun<nm::Rational128, int16_t, uint32_t>, fun<nm::Rational128, int16_t, uint64_t> }, {fun<nm::Rational128, int32_t, uint8_t>, fun<nm::Rational128, int32_t, uint16_t>, fun<nm::Rational128, int32_t, uint32_t>, fun<nm::Rational128, int32_t, uint64_t> }, {fun<nm::Rational128, int64_t, uint8_t>, fun<nm::Rational128, int64_t, uint16_t>, fun<nm::Rational128, int64_t, uint32_t>, fun<nm::Rational128, int64_t, uint64_t> }, {fun<nm::Rational128, float32_t, uint8_t>, fun<nm::Rational128, float32_t, uint16_t>, fun<nm::Rational128, float32_t, uint32_t>, fun<nm::Rational128, float32_t, uint64_t> }, {NULL, NULL, NULL, NULL }, {NULL, NULL, NULL, NULL }, {NULL, NULL, NULL, NULL }, {fun<nm::Rational128, nm::Rational32, uint8_t>, fun<nm::Rational128, nm::Rational32, uint16_t>, fun<nm::Rational128, nm::Rational32, uint32_t>, fun<nm::Rational128, nm::Rational32, uint64_t> }, {fun<nm::Rational128, nm::Rational64, uint8_t>, fun<nm::Rational128, nm::Rational64, uint16_t>, fun<nm::Rational128, nm::Rational64, uint32_t>, fun<nm::Rational128, nm::Rational64, uint64_t> }, {fun<nm::Rational128, nm::Rational128, uint8_t>, fun<nm::Rational128, nm::Rational128, uint16_t>, fun<nm::Rational128, nm::Rational128, uint32_t>, fun<nm::Rational128, nm::Rational128, uint64_t> }, {fun<nm::Rational128, nm::RubyObject, uint8_t>, fun<nm::Rational128, nm::RubyObject, uint16_t>, fun<nm::Rational128, nm::RubyObject, uint32_t>, fun<nm::Rational128, nm::RubyObject, uint64_t>}},  \
-  {{fun<nm::RubyObject, uint8_t, uint8_t>, fun<nm::RubyObject, uint8_t, uint16_t>, fun<nm::RubyObject, uint8_t, uint32_t>, fun<nm::RubyObject, uint8_t, uint64_t> }, {fun<nm::RubyObject, int8_t, uint8_t>, fun<nm::RubyObject, int8_t, uint16_t>, fun<nm::RubyObject, int8_t, uint32_t>, fun<nm::RubyObject, int8_t, uint64_t> }, {fun<nm::RubyObject, int16_t, uint8_t>, fun<nm::RubyObject, int16_t, uint16_t>, fun<nm::RubyObject, int16_t, uint32_t>, fun<nm::RubyObject, int16_t, uint64_t> }, {fun<nm::RubyObject, int32_t, uint8_t>, fun<nm::RubyObject, int32_t, uint16_t>, fun<nm::RubyObject, int32_t, uint32_t>, fun<nm::RubyObject, int32_t, uint64_t> }, {fun<nm::RubyObject, int64_t, uint8_t>, fun<nm::RubyObject, int64_t, uint16_t>, fun<nm::RubyObject, int64_t, uint32_t>, fun<nm::RubyObject, int64_t, uint64_t> }, {fun<nm::RubyObject, float32_t, uint8_t>, fun<nm::RubyObject, float32_t, uint16_t>, fun<nm::RubyObject, float32_t, uint32_t>, fun<nm::RubyObject, float32_t, uint64_t> }, {fun<nm::RubyObject, float64_t, uint8_t>, fun<nm::RubyObject, float64_t, uint16_t>, fun<nm::RubyObject, float64_t, uint32_t>, fun<nm::RubyObject, float64_t, uint64_t> }, {fun<nm::RubyObject, nm::Complex64, uint8_t>, fun<nm::RubyObject, nm::Complex64, uint16_t>, fun<nm::RubyObject, nm::Complex64, uint32_t>, fun<nm::RubyObject, nm::Complex64, uint64_t> }, {fun<nm::RubyObject, nm::Complex128, uint8_t>, fun<nm::RubyObject, nm::Complex128, uint16_t>, fun<nm::RubyObject, nm::Complex128, uint32_t>, fun<nm::RubyObject, nm::Complex128, uint64_t> }, {fun<nm::RubyObject, nm::Rational32, uint8_t>, fun<nm::RubyObject, nm::Rational32, uint16_t>, fun<nm::RubyObject, nm::Rational32, uint32_t>, fun<nm::RubyObject, nm::Rational32, uint64_t> }, {fun<nm::RubyObject, nm::Rational64, uint8_t>, fun<nm::RubyObject, nm::Rational64, uint16_t>, fun<nm::RubyObject, nm::Rational64, uint32_t>, fun<nm::RubyObject, nm::Rational64, uint64_t> }, {fun<nm::RubyObject, nm::Rational128, uint8_t>, fun<nm::RubyObject, nm::Rational128, uint16_t>, fun<nm::RubyObject, nm::Rational128, uint32_t>, fun<nm::RubyObject, nm::Rational128, uint64_t> }, {fun<nm::RubyObject, nm::RubyObject, uint8_t>, fun<nm::RubyObject, nm::RubyObject, uint16_t>, fun<nm::RubyObject, nm::RubyObject, uint32_t>, fun<nm::RubyObject, nm::RubyObject, uint64_t>}} \
-};
-
-/*
- * Defines a static array that holds function pointers to left dtype and itype
- * templated versions of the specified function.
- */
-#define LI_DTYPE_TEMPLATE_TABLE(fun, ret, ...) NAMED_LI_DTYPE_TEMPLATE_TABLE(ttable, fun, ret, __VA_ARGS__)
-
-#define NAMED_LI_DTYPE_TEMPLATE_TABLE(name, fun, ret, ...) 																																			\
-	static ret (*(name)[nm::NUM_DTYPES][nm::NUM_ITYPES])(__VA_ARGS__) = {																																	\
-		{ fun<uint8_t,uint8_t>,fun<uint8_t,uint16_t>,fun<uint8_t,uint32_t>,fun<uint8_t,uint64_t> },																	\
-		{ fun<int8_t,uint8_t>,fun<int8_t,uint16_t>,fun<int8_t,uint32_t>,fun<int8_t,uint64_t> },																			\
-		{ fun<int16_t,uint8_t>,fun<int16_t,uint16_t>,fun<int16_t,uint32_t>,fun<int16_t,uint64_t> },																	\
-		{ fun<int32_t,uint8_t>,fun<int32_t,uint16_t>,fun<int32_t,uint32_t>,fun<int32_t,uint64_t> },																	\
-		{ fun<int64_t,uint8_t>,fun<int64_t,uint16_t>,fun<int64_t,uint32_t>,fun<int64_t,uint64_t> },																	\
-		{ fun<float32_t,uint8_t>,fun<float32_t,uint16_t>,fun<float32_t,uint32_t>,fun<float32_t,uint64_t> },													\
-		{ fun<float64_t,uint8_t>,fun<float64_t,uint16_t>,fun<float64_t,uint32_t>,fun<float64_t,uint64_t> },													\
-		{ fun<nm::Complex64,uint8_t>,fun<nm::Complex64,uint16_t>,fun<nm::Complex64,uint32_t>,fun<nm::Complex64,uint64_t> },					\
-		{ fun<nm::Complex128,uint8_t>,fun<nm::Complex128,uint16_t>,fun<nm::Complex128,uint32_t>,fun<nm::Complex128,uint64_t> },			\
-		{ fun<nm::Rational32,uint8_t>,fun<nm::Rational32,uint16_t>,fun<nm::Rational32,uint32_t>,fun<nm::Rational32,uint64_t> },			\
-		{ fun<nm::Rational64,uint8_t>,fun<nm::Rational64,uint16_t>,fun<nm::Rational64,uint32_t>,fun<nm::Rational64,uint64_t> },			\
-		{ fun<nm::Rational128,uint8_t>,fun<nm::Rational128,uint16_t>,fun<nm::Rational128,uint32_t>,fun<nm::Rational128,uint64_t> },	\
-		{ fun<nm::RubyObject,uint8_t>,fun<nm::RubyObject,uint16_t>,fun<nm::RubyObject,uint32_t>,fun<nm::RubyObject,uint64_t>}				\
-	};
-
-	#define NAMED_LI_DTYPE_TEMPLATE_TABLE_NO_ROBJ(name, fun, ret, ...) 																																			\
-  	static ret (*(name)[nm::NUM_DTYPES][nm::NUM_ITYPES])(__VA_ARGS__) = {																																	\
-  		{ fun<uint8_t,uint8_t>,fun<uint8_t,uint16_t>,fun<uint8_t,uint32_t>,fun<uint8_t,uint64_t> },																	\
-  		{ fun<int8_t,uint8_t>,fun<int8_t,uint16_t>,fun<int8_t,uint32_t>,fun<int8_t,uint64_t> },																			\
-  		{ fun<int16_t,uint8_t>,fun<int16_t,uint16_t>,fun<int16_t,uint32_t>,fun<int16_t,uint64_t> },																	\
-  		{ fun<int32_t,uint8_t>,fun<int32_t,uint16_t>,fun<int32_t,uint32_t>,fun<int32_t,uint64_t> },																	\
-  		{ fun<int64_t,uint8_t>,fun<int64_t,uint16_t>,fun<int64_t,uint32_t>,fun<int64_t,uint64_t> },																	\
-  		{ fun<float32_t,uint8_t>,fun<float32_t,uint16_t>,fun<float32_t,uint32_t>,fun<float32_t,uint64_t> },													\
-  		{ fun<float64_t,uint8_t>,fun<float64_t,uint16_t>,fun<float64_t,uint32_t>,fun<float64_t,uint64_t> },													\
-  		{ fun<nm::Complex64,uint8_t>,fun<nm::Complex64,uint16_t>,fun<nm::Complex64,uint32_t>,fun<nm::Complex64,uint64_t> },					\
-  		{ fun<nm::Complex128,uint8_t>,fun<nm::Complex128,uint16_t>,fun<nm::Complex128,uint32_t>,fun<nm::Complex128,uint64_t> },			\
-  		{ fun<nm::Rational32,uint8_t>,fun<nm::Rational32,uint16_t>,fun<nm::Rational32,uint32_t>,fun<nm::Rational32,uint64_t> },			\
-  		{ fun<nm::Rational64,uint8_t>,fun<nm::Rational64,uint16_t>,fun<nm::Rational64,uint32_t>,fun<nm::Rational64,uint64_t> },			\
-  		{ fun<nm::Rational128,uint8_t>,fun<nm::Rational128,uint16_t>,fun<nm::Rational128,uint32_t>,fun<nm::Rational128,uint64_t> }	\
-  	};
-
-
 extern "C" {
 
 
@@ -761,10 +664,6 @@ extern "C" {
 extern const char* const	DTYPE_NAMES[nm::NUM_DTYPES];
 extern const size_t 			DTYPE_SIZES[nm::NUM_DTYPES];
 
-// index data types
-extern const char* const  ITYPE_NAMES[nm::NUM_ITYPES];
-extern const size_t 			ITYPE_SIZES[nm::NUM_ITYPES];
-
 extern const nm::dtype_t Upcast[nm::NUM_DTYPES][nm::NUM_DTYPES];
 
 
@@ -776,7 +675,6 @@ extern const nm::dtype_t Upcast[nm::NUM_DTYPES][nm::NUM_DTYPES];
 void*	    			rubyobj_to_cval(VALUE val, nm::dtype_t dtype);
 void  		  		rubyval_to_cval(VALUE val, nm::dtype_t dtype, void* loc);
 nm::RubyObject	rubyobj_from_cval(void* val, nm::dtype_t dtype);
-nm::RubyObject  rubyobj_from_cval_by_itype(void* val, nm::itype_t itype);
 
 void nm_init_data();