nmatrix 0.1.0 → 0.2.0

data/ext/nmatrix/data/meta.h

@@ -44,9 +44,6 @@ namespace nm {
   template <> struct ctype_to_dtype_enum<double>  { static const nm::dtype_t value_type = nm::FLOAT64; };
   template <> struct ctype_to_dtype_enum<Complex64>   { static const nm::dtype_t value_type = nm::COMPLEX64; };
   template <> struct ctype_to_dtype_enum<Complex128>  { static const nm::dtype_t value_type = nm::COMPLEX128; };
-  template <> struct ctype_to_dtype_enum<Rational32>   { static const nm::dtype_t value_type = nm::RATIONAL32; };
-  template <> struct ctype_to_dtype_enum<Rational64>  { static const nm::dtype_t value_type = nm::RATIONAL64; };
-  template <> struct ctype_to_dtype_enum<Rational128>  { static const nm::dtype_t value_type = nm::RATIONAL128; };
   template <> struct ctype_to_dtype_enum<RubyObject>  { static const nm::dtype_t value_type = nm::RUBYOBJ; };
 
 
@@ -60,11 +57,8 @@ namespace nm {
   template <> struct dtype_enum_T<nm::FLOAT64> { typedef double type; };
   template <> struct dtype_enum_T<nm::COMPLEX64> { typedef nm::Complex64 type; };
   template <> struct dtype_enum_T<nm::COMPLEX128> { typedef nm::Complex128 type; };
-  template <> struct dtype_enum_T<nm::RATIONAL32> { typedef nm::Rational32 type; };
-  template <> struct dtype_enum_T<nm::RATIONAL64> { typedef nm::Rational64 type; };
-  template <> struct dtype_enum_T<nm::RATIONAL128> { typedef nm::Rational128 type; };
   template <> struct dtype_enum_T<nm::RUBYOBJ> { typedef nm::RubyObject type; };
 
 } // end namespace nm
 
-#endif
+#endif

data/ext/nmatrix/data/ruby_object.h

@@ -45,7 +45,7 @@
 /*
  * Macros
  */
-#define NM_RUBYVAL_IS_NUMERIC(val)                (FIXNUM_P(val) or (TYPE(val) == T_FLOAT) or (TYPE(val) == T_COMPLEX) or (TYPE(val) == T_RATIONAL))
+#define NM_RUBYVAL_IS_NUMERIC(val)                (FIXNUM_P(val) or (TYPE(val) == T_FLOAT) or (TYPE(val) == T_COMPLEX))
 #define NMATRIX_CHECK_TYPE(val) \
 	if (TYPE(val) != T_DATA || (RDATA(val)->dfree != (RUBY_DATA_FUNC)nm_delete && RDATA(val)->dfree != (RUBY_DATA_FUNC)nm_delete_ref)) \
 		rb_raise(rb_eTypeError, "Expected NMatrix on left-hand side of operation.");
@@ -76,12 +76,6 @@ class RubyObject {
 	template <typename FloatType, typename = typename std::enable_if<std::is_floating_point<FloatType>::value>::type>
 	inline RubyObject(const Complex<FloatType>& other) : rval(rb_complex_new(rb_float_new(other.r), rb_float_new(other.i))) {}
 	
-	/*
-	 * Rational number constructor.
-	 */
-	template <typename IntType, typename = typename std::enable_if<std::is_integral<IntType>::value>::type>
-	inline RubyObject(const Rational<IntType>& other) : rval(rb_rational_new(INT2FIX(other.n), INT2FIX(other.d))) {}
-	
 	/*
 	 * Integer constructor.
 	 *
@@ -123,10 +117,6 @@ class RubyObject {
   inline operator double()   const { RETURN_OBJ2NUM(NUM2DBL)        }
   inline operator float()  const { RETURN_OBJ2NUM(NUM2DBL)          }
 
-  inline operator Rational32() const { return this->to<Rational32>();   }
-  inline operator Rational64() const { return this->to<Rational64>();   }
-  inline operator Rational128() const { return this->to<Rational128>(); }
-
   inline operator Complex64() const { return this->to<Complex64>(); }
   inline operator Complex128() const { return this->to<Complex128>(); }
   /*
@@ -255,20 +245,6 @@ class RubyObject {
 		return *this != RubyObject(other);
 	}
 */
-	//////////////////////////////
-	// RUBY-RATIONAL OPERATIONS //
-	//////////////////////////////
-
-	template <typename IntType, typename = typename std::enable_if<std::is_integral<IntType>::value>::type>
-	inline bool operator==(const Rational<IntType>& other) const {
-		return *this == RubyObject(other);
-	}
-
-  template <typename IntType, typename = typename std::enable_if<std::is_integral<IntType>::value>::type>
-	inline bool operator!=(const Rational<IntType>& other) const {
-		return *this != RubyObject(other);
-	}
-
 	//////////////////////////////
 	// RUBY-COMPLEX OPERATIONS //
 	//////////////////////////////
@@ -304,7 +280,7 @@ class RubyObject {
 	 */
 	template <typename ComplexType>
 	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) {
+		if (FIXNUM_P(this->rval) or TYPE(this->rval) == T_FLOAT) {
 			return ComplexType(NUM2DBL(this->rval));
 			
 		} else if (TYPE(this->rval) == T_COMPLEX) {
@@ -314,25 +290,8 @@ class RubyObject {
 			rb_raise(rb_eTypeError, "Invalid conversion to Complex type.");
 		}
 	}
-	
-	/*
-	 * 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) const {
-		if (FIXNUM_P(this->rval) or TYPE(this->rval) == T_FLOAT or TYPE(this->rval) == T_COMPLEX) {
-			return RationalType(NUM2INT(this->rval));
-			
-		} else if (TYPE(this->rval) == T_RATIONAL) {
-			return RationalType(NUM2INT(rb_funcall(this->rval, nm_rb_numer, 0)), NUM2INT(rb_funcall(this->rval, nm_rb_denom, 0)));
-			
-		} else {
-			rb_raise(rb_eTypeError, "Invalid conversion to Rational type.");
-		}
-	}
-
 };
-
+	
 // Negative operator
 inline RubyObject operator-(const RubyObject& rhs) {
   return RubyObject(rb_funcall(rhs.rval, nm_rb_negate, 0));
@@ -413,47 +372,6 @@ inline bool operator>(const Complex<FloatType>& left, const RubyObject& right) {
 	return RubyObject(left) > right;
 }
 
-
-
-//////////////////////////////
-// RATIONAL-RUBY OPERATIONS //
-//////////////////////////////
-
-template <typename IntType, typename = typename std::enable_if<std::is_integral<IntType>::value>::type>
-inline bool operator==(const Rational<IntType>& left, const RubyObject& right) {
-	return RubyObject(left) == right;
-}
-
-template <typename IntType, typename = typename std::enable_if<std::is_integral<IntType>::value>::type>
-inline bool operator!=(const Rational<IntType>& left, const RubyObject& right) {
-	return RubyObject(left) != right;
-}
-
-template <typename IntType, typename = typename std::enable_if<std::is_integral<IntType>::value>::type>
-inline bool operator>=(const Rational<IntType>& left, const RubyObject& right) {
-	return RubyObject(left) >= right;
-}
-
-template <typename IntType, typename = typename std::enable_if<std::is_integral<IntType>::value>::type>
-inline bool operator<=(const Rational<IntType>& left, const RubyObject& right) {
-	return RubyObject(left) <= right;
-}
-
-template <typename IntType, typename = typename std::enable_if<std::is_integral<IntType>::value>::type>
-inline bool operator<(const Rational<IntType>& left, const RubyObject& right) {
-	return RubyObject(left) < right;
-}
-
-template <typename IntType, typename = typename std::enable_if<std::is_integral<IntType>::value>::type>
-inline bool operator>(const Rational<IntType>& left, const RubyObject& right) {
-	return RubyObject(left) > right;
-}
-
-inline std::ostream& operator<<(std::ostream& out, const RubyObject& rhs) {
-  out << "RUBYOBJECT" << std::flush; // FIXME: Try calling inspect or something on the Ruby object if we really need to debug it.
-  return out;
-}
-
 } // end of namespace nm
 
 namespace std {

data/ext/nmatrix/extconf.rb

@@ -155,83 +155,12 @@ else
   puts "g++ reports version... " + `#{CONFIG['CXX']} --version|head -n 1|cut -f 3 -d " "`
 end
 
-# add smmp in to get generic transp; remove smmp2 to eliminate funcptr transp
-
-# The next line allows the user to supply --with-atlas-dir=/usr/local/atlas,
-# --with-atlas-lib or --with-atlas-include and tell the compiler where to look
-# for ATLAS. The same for all the others
-#
-#dir_config("clapack", ["/usr/local/atlas/include"], [])
-#
-#
-
-# Is g++ having trouble finding your header files?
-# Try this:
-#   export C_INCLUDE_PATH=/usr/local/atlas/include
-#   export CPLUS_INCLUDE_PATH=/usr/local/atlas/include
-# (substituting in the path of your cblas.h and clapack.h for the path I used). -- JW 8/27/12
-
-idefaults = {lapack: ["/usr/include/atlas"],
-             cblas: ["/usr/local/atlas/include", "/usr/include/atlas"],
-             atlas: ["/usr/local/atlas/include", "/usr/include/atlas"]}
-
-# For some reason, if we try to look for /usr/lib64/atlas on a Mac OS X Mavericks system, and the directory does not
-# exist, it will give a linker error -- even if the lib dir is already correctly included with -L. So we need to check
-# that Dir.exists?(d) for each.
-ldefaults = {lapack: ["/usr/local/lib", "/usr/local/atlas/lib", "/usr/lib64/atlas"].delete_if { |d| !Dir.exists?(d) },
-             cblas: ["/usr/local/lib", "/usr/local/atlas/lib", "/usr/lib64/atlas"].delete_if { |d| !Dir.exists?(d) },
-             atlas: ["/usr/local/lib", "/usr/local/atlas/lib", "/usr/lib", "/usr/lib64/atlas"].delete_if { |d| !Dir.exists?(d) }}
-
-if have_library("clapack") # Usually only applies for Mac OS X
-  $libs += " -lclapack "
-end
-
-unless have_library("lapack")
-  dir_config("lapack", idefaults[:lapack], ldefaults[:lapack])
-end
-
-unless have_library("cblas")
-  dir_config("cblas", idefaults[:cblas], ldefaults[:cblas])
-end
-
-unless have_library("atlas")
-  dir_config("atlas", idefaults[:atlas], ldefaults[:atlas])
-end
-
-# If BLAS and LAPACK headers are in an atlas directory, prefer those. Otherwise,
-# we try our luck with the default location.
-if have_header("atlas/cblas.h")
-  have_header("atlas/clapack.h")
-else
-  have_header("cblas.h")
-  have_header("clapack.h")
-end
-
-
-# Although have_func is supposed to take a list as its second argument, I find that it simply
-# applies a :to_s to the second arg and doesn't actually check each one. We may want to put
-# have_func calls inside an :each block which checks atlas/clapack.h, cblas.h, clapack.h, and
-# lastly lapack.h. On Ubuntu, it only works if I use atlas/clapack.h. --@mohawkjohn 8/20/14
-have_func("clapack_dgetrf", "atlas/clapack.h")
-have_func("clapack_dgetri", "atlas/clapack.h")
-have_func("dgesvd_", "clapack.h") # This may not do anything. dgesvd_ seems to be in LAPACK, not CLAPACK.
-
-have_func("cblas_dgemm", "cblas.h")
-
-#have_func("rb_scan_args", "ruby.h")
-
-#find_library("lapack", "clapack_dgetrf")
-#find_library("cblas", "cblas_dgemm")
-#find_library("atlas", "ATL_dgemmNN")
-# Order matters here: ATLAS has to go after LAPACK: http://mail.scipy.org/pipermail/scipy-user/2007-January/010717.html
-$libs += " -llapack -lcblas -latlas "
 #$libs += " -lprofiler "
 
-
 # For release, these next two should both be changed to -O3.
-$CFLAGS += " -O3" #" -O0 -g "
+$CFLAGS += " -O3 "
 #$CFLAGS += " -static -O0 -g "
-$CPPFLAGS += " -O3 -std=#{$CPP_STANDARD}" #" -O0 -g -std=#{$CPP_STANDARD} " #-fmax-errors=10 -save-temps
+$CPPFLAGS += " -O3 -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)

data/ext/nmatrix/math.cpp

@@ -23,90 +23,103 @@
 //
 // == math.cpp
 //
-// Ruby-exposed BLAS functions.
+// Ruby-exposed CBLAS and LAPACK functions that are available without
+// an external library.
 //
-// === Procedure for adding LAPACK or CBLAS functions to math.cpp/math.h:
+// === Procedure for adding CBLAS functions to math.cpp/math.h:
 //
 // This procedure is written as if for a fictional function with double
-// version dbacon, which we'll say is from LAPACK.
+// version dbacon, which we'll say is from CBLAS.
 //
 // 1. Write a default templated version which probably returns a boolean.
 //    Call it bacon, and put it in math.h.
 //
-//    Order will always be row-major, so we don't need to pass that.
-//    CBLAS_TRANSPOSE-type arguments, however, should be passed.
-//
-//    Otherwise, arguments should look like those in cblas.h or clapack.h:
-//
 //    template <typename DType>
 //    bool bacon(const CBLAS_TRANSPOSE trans, const int M, const int N, DType* A, ...) {
 //      rb_raise(rb_eNotImpError, "only implemented for ATLAS types (float32, float64, complex64, complex128)");
 //    }
 //
+//    Make sure this is in namespace nm::math
+//
 // 2. In math.cpp, add a templated inline static version of the function which takes
-//    only void* pointers and uses reinterpret_cast to convert them to the
-//    proper dtype.
+//    only void* pointers and uses static_cast to convert them to the
+//    proper dtype. This should also be in namespace nm::math
 //
 //    This function may also need to switch m and n if these arguments are given.
 //
 //    For an example, see cblas_gemm. This function should do nothing other than cast
-//    appropriately. If clapack_dbacon, clapack_sbacon, clapack_cbacon, and clapack_zbacon
+//    appropriately. If cblas_dbacon, cblas_sbacon, cblas_cbacon, and cblas_zbacon
 //    all take void* only, and no other pointers that vary between functions, you can skip
 //    this particular step -- as we can call them directly using a custom function pointer
 //    array (same function signature!).
 //
-//    This version of the function will be the one exposed through NMatrix::LAPACK. We
-//    want it to be as close to the actual LAPACK version of the function as possible,
+//    This version of the function will be the one exposed through NMatrix::BLAS. We
+//    want it to be as close to the actual BLAS version of the function as possible,
 //    and with as few checks as possible.
 //
 //    You will probably need a forward declaration in the extern "C" block.
 //
 //    Note: In that case, the function you wrote in Step 1 should also take exactly the
-//    same arguments as clapack_xbacon. Otherwise Bad Things will happen.
+//    same arguments as cblas_xbacon. Otherwise Bad Things will happen.
 //
-// 3. In math.cpp, add inline specialized versions of bacon for the different ATLAS types.
+// 3. In cblas_templates_core.h, add a default template like in step 1 (which will just
+//    call nm::math::bacon()) and also
+//    inline specialized versions of bacon for the different BLAS types.
+//    This will allow both nmatrix-atlas and nmatrix-lapacke to use the optimized version
+//    of bacon from whatever external library is available, as well as the internal version
+//    if an external version is not available. These functions will end up in a namsespace
+//    like nm::math::atlas, but don't explicitly put them in a namespace, they will get
+//    put in the appropriate namespace when cblas_templates_core.h is included.
 //
-//    You could do this with a macro, if the arguments are all similar (see #define LAPACK_GETRF).
-//    Or you may prefer to do it by hand:
+//    template <typename DType>
+//    inline bool bacon(const CBLAS_TRANSPOSE trans, const int M, const int N, DType* A, ...) {
+//      nm::math::bacon(trans, M, N, A, ...);
+//    }
 //
 //    template <>
 //    inline bool bacon(const CBLAS_TRANSPOSE trans, const int M, const int N, float* A, ...) {
-//      clapack_sbacon(trans, M, N, A, ...);
+//      cblas_sbacon(trans, M, N, A, ...);
 //      return true;
 //    }
 //
-//    Make sure these functions are in the namespace nm::math.
-//
 //    Note that you should do everything in your power here to parse any return values
-//    clapack_sbacon may give you. We're not trying very hard in this example, but you might
+//    cblas_sbacon may give you. We're not trying very hard in this example, but you might
 //    look at getrf to see how it might be done.
 //
-// 4. Expose the function in nm_math_init_blas(), in math.cpp:
+// 4. Write the C function nm_cblas_bacon, which is what Ruby will call. Use the example
+//    of nm_cblas_gemm below. Also you must add a similar function in math_atlas.cpp
+//    and math_lapacke.cpp
 //
-//    rb_define_singleton_method(cNMatrix_LAPACK, "clapack_bacon", (METHOD)nm_lapack_bacon, 5);
+// 5. Expose the function in nm_math_init_blas(), in math.cpp:
 //
-//    Here, we're telling Ruby that nm_lapack_bacon takes five arguments as a Ruby function.
+//    rb_define_singleton_method(cNMatrix_Internal_BLAS, "cblas_bacon", (METHOD)nm_cblas_bacon, 5);
 //
-// 5. In blas.rb, write a bacon function which accesses clapack_bacon, but does all the
+//    Do something similar in math_atlas.cpp and math_lapacke.cpp to add the function
+//    to the plugin gems.
+//
+//    Here, we're telling Ruby that nm_cblas_bacon takes five arguments as a Ruby function.
+//
+// 6. In blas.rb, write a bacon function which accesses cblas_bacon, but does all the
 //    sanity checks we left out in step 2.
 //
-// 6. Write tests for NMatrix::LAPACK::getrf, confirming that it works for the ATLAS dtypes.
+// 7. Write tests for NMatrix::BLAS::bacon, confirming that it works for the ATLAS dtypes.
 //
-// 7. After you get it working properly with ATLAS, download dbacon.f from NETLIB, and use
+// 8. After you get it working properly with CBLAS, download dbacon.f from NETLIB, and use
 //    f2c to convert it to C. Clean it up so it's readable. Remove the extra indices -- f2c
 //    inserts a lot of unnecessary stuff.
 //
 //    Copy and paste the output into the default templated function you wrote in Step 1.
 //    Fix it so it works as a template instead of just for doubles.
 //
-// 8. Write tests to confirm that it works for integers, rationals, and Ruby objects.
+//    Because of step 3, this will automatically also work for the nmatrix-atlas
+//    and nmatrix-lapacke implementations.
+//
+// 9. Write tests to confirm that it works for all data types.
 //
-// 9. See about adding a Ruby-like interface, such as matrix_matrix_multiply for cblas_gemm,
+// 10. See about adding a Ruby-like interface, such as matrix_matrix_multiply for cblas_gemm,
 //    or matrix_vector_multiply for cblas_gemv. This step is not mandatory.
 //
-// 10. Pull request!
-
-
+// 11. Pull request!
 
 /*
  * Project Includes
@@ -117,30 +130,23 @@
 #include <limits>
 #include <cmath>
 
-#include "math/inc.h"
+#include "math/cblas_enums.h"
+
 #include "data/data.h"
-#include "math/gesdd.h"
-#include "math/gesvd.h"
-#include "math/geev.h"
-#include "math/swap.h"
 #include "math/imax.h"
 #include "math/scal.h"
-#include "math/ger.h"
-#include "math/getf2.h"
 #include "math/laswp.h"
 #include "math/trsm.h"
-#include "math/long_dtype.h" // for gemm.h
 #include "math/gemm.h"
 #include "math/gemv.h"
 #include "math/asum.h"
 #include "math/nrm2.h"
 #include "math/getrf.h"
-#include "math/getri.h"
 #include "math/getrs.h"
-#include "math/potrs.h"
 #include "math/rot.h"
 #include "math/rotg.h"
 #include "math/math.h"
+#include "math/util.h"
 #include "storage/dense/dense.h"
 
 #include "nmatrix.h"
@@ -151,12 +157,6 @@
  */
 
 extern "C" {
-#if defined HAVE_CLAPACK_H
-  #include <clapack.h>
-#elif defined HAVE_ATLAS_CLAPACK_H
-  #include <atlas/clapack.h>
-#endif
-
   /* BLAS Level 1. */
   static VALUE nm_cblas_scal(VALUE self, VALUE n, VALUE scale, VALUE vector, VALUE incx);
   static VALUE nm_cblas_nrm2(VALUE self, VALUE n, VALUE x, VALUE incx);
@@ -166,34 +166,20 @@ extern "C" {
   static VALUE nm_cblas_imax(VALUE self, VALUE n, VALUE x, VALUE incx);
 
   /* BLAS Level 2. */
+  static VALUE nm_cblas_gemv(VALUE self, VALUE trans_a, VALUE m, VALUE n, VALUE vAlpha, VALUE a, VALUE lda,
+                             VALUE x, VALUE incx, VALUE vBeta, VALUE y, VALUE incy);
+
   /* BLAS Level 3. */
   static VALUE nm_cblas_gemm(VALUE self, VALUE order, VALUE trans_a, VALUE trans_b, VALUE m, VALUE n, VALUE k, VALUE vAlpha,
                              VALUE a, VALUE lda, VALUE b, VALUE ldb, VALUE vBeta, VALUE c, VALUE ldc);
-  static VALUE nm_cblas_gemv(VALUE self, VALUE trans_a, VALUE m, VALUE n, VALUE vAlpha, VALUE a, VALUE lda,
-                             VALUE x, VALUE incx, VALUE vBeta, VALUE y, VALUE incy);
   static VALUE nm_cblas_trsm(VALUE self, VALUE order, VALUE side, VALUE uplo, VALUE trans_a, VALUE diag, VALUE m, VALUE n,
                              VALUE vAlpha, VALUE a, VALUE lda, VALUE b, VALUE ldb);
-  static VALUE nm_cblas_trmm(VALUE self, VALUE order, VALUE side, VALUE uplo, VALUE trans_a, VALUE diag, VALUE m, VALUE n,
-                             VALUE alpha, VALUE a, VALUE lda, VALUE b, VALUE ldb);
-  static VALUE nm_cblas_herk(VALUE self, VALUE order, VALUE uplo, VALUE trans, VALUE n, VALUE k, VALUE alpha, VALUE a,
-                             VALUE lda, VALUE beta, VALUE c, VALUE ldc);
-  static VALUE nm_cblas_syrk(VALUE self, VALUE order, VALUE uplo, VALUE trans, VALUE n, VALUE k, VALUE alpha, VALUE a,
-                             VALUE lda, VALUE beta, VALUE c, VALUE ldc);
 
   /* LAPACK. */
   static VALUE nm_has_clapack(VALUE self);
   static VALUE nm_clapack_getrf(VALUE self, VALUE order, VALUE m, VALUE n, VALUE a, VALUE lda);
-  static VALUE nm_clapack_potrf(VALUE self, VALUE order, VALUE uplo, VALUE n, VALUE a, VALUE lda);
   static VALUE nm_clapack_getrs(VALUE self, VALUE order, VALUE trans, VALUE n, VALUE nrhs, VALUE a, VALUE lda, VALUE ipiv, VALUE b, VALUE ldb);
-  static VALUE nm_clapack_potrs(VALUE self, VALUE order, VALUE uplo, VALUE n, VALUE nrhs, VALUE a, VALUE lda, VALUE b, VALUE ldb);
-  static VALUE nm_clapack_getri(VALUE self, VALUE order, VALUE n, VALUE a, VALUE lda, VALUE ipiv);
-  static VALUE nm_clapack_potri(VALUE self, VALUE order, VALUE uplo, VALUE n, VALUE a, VALUE lda);
   static VALUE nm_clapack_laswp(VALUE self, VALUE n, VALUE a, VALUE lda, VALUE k1, VALUE k2, VALUE ipiv, VALUE incx);
-  static VALUE nm_clapack_lauum(VALUE self, VALUE order, VALUE uplo, VALUE n, VALUE a, VALUE lda);
-
-  static VALUE nm_lapack_gesvd(VALUE self, VALUE jobu, VALUE jobvt, VALUE m, VALUE n, VALUE a, VALUE lda, VALUE s, VALUE u, VALUE ldu, VALUE vt, VALUE ldvt, VALUE lworkspace_size);
-  static VALUE nm_lapack_gesdd(VALUE self, VALUE jobz, VALUE m, VALUE n, VALUE a, VALUE lda, VALUE s, VALUE u, VALUE ldu, VALUE vt, VALUE ldvt, VALUE lworkspace_size);
-  static VALUE nm_lapack_geev(VALUE self, VALUE compute_left, VALUE compute_right, VALUE n, VALUE a, VALUE lda, VALUE w, VALUE wi, VALUE vl, VALUE ldvl, VALUE vr, VALUE ldvr, VALUE lwork);
 } // end of extern "C" block
 
 ////////////////////
@@ -230,6 +216,11 @@ namespace nm {
       }
     }
 
+    //we can't do det_exact on byte, because it will want to return a byte (unsigned), but determinants can be negative, even if all elements of the matrix are positive
+    template <>
+    void det_exact<uint8_t>(const int M, const void* A_elements, const int lda, void* result_arg) {
+      rb_raise(nm_eDataTypeError, "cannot call det_exact on unsigned type");
+    }
 
     /*
      * Calculates in-place inverse of A_elements. Uses Gauss-Jordan elimination technique.
@@ -308,6 +299,80 @@ namespace nm {
       delete[] col_index;
     }
 
+    /*
+     * Reduce a square matrix to hessenberg form with householder transforms
+     *
+     * == Arguments
+     *
+     * nrows - The number of rows present in matrix a.
+     * a_elements - Elements of the matrix to be reduced in 1D array form.
+     *
+     * == References
+     *
+     * http://www.mymathlib.com/c_source/matrices/eigen/hessenberg_orthog.c
+     * This code has been included by permission of the author.
+     */
+    template <typename DType>
+    void hessenberg(const int nrows, void* a_elements) {
+      DType* a = reinterpret_cast<DType*>(a_elements);
+      DType* u = new DType[nrows]; // auxillary storage for the chosen vector
+      DType sum_of_squares, *p_row, *psubdiag, *p_a, scale, innerproduct;
+      int i, k, col;
+
+      // For each column use a Householder transformation to zero all entries 
+      // below the subdiagonal.
+      for (psubdiag = a + nrows, col = 0; col < nrows - 2; psubdiag += nrows + 1, 
+        col++) {
+        // Calculate the signed square root of the sum of squares of the
+        // elements below the diagonal.
+
+        for (p_a = psubdiag, sum_of_squares = 0.0, i = col + 1; i < nrows; 
+          p_a += nrows, i++) {
+          sum_of_squares += *p_a * *p_a;
+        }
+        if (sum_of_squares == 0.0) { continue; }
+        sum_of_squares = std::sqrt(sum_of_squares);
+
+        if ( *psubdiag >= 0.0 ) { sum_of_squares = -sum_of_squares; }
+
+        // Calculate the Householder transformation Q = I - 2uu'/u'u.
+        u[col + 1] = *psubdiag - sum_of_squares;
+        *psubdiag = sum_of_squares;
+
+        for (p_a = psubdiag + nrows, i = col + 2; i < nrows; p_a += nrows, i++) {
+          u[i] = *p_a;
+          *p_a = 0.0;
+        }
+
+        // Premultiply A by Q
+        scale = -1.0 / (sum_of_squares * u[col+1]);
+        for (p_row = psubdiag - col, i = col + 1; i < nrows; i++) {
+          p_a = a + nrows * (col + 1) + i;
+          for (innerproduct = 0.0, k = col + 1; k < nrows; p_a += nrows, k++) {
+            innerproduct += u[k] * *p_a;
+          }
+          innerproduct *= scale;
+          for (p_a = p_row + i, k = col + 1; k < nrows; p_a += nrows, k++) {
+            *p_a -= u[k] * innerproduct;
+          }
+        }
+           
+        // Postmultiply QA by Q
+        for (p_row = a, i = 0; i < nrows; p_row += nrows, i++) {
+          for (innerproduct = 0.0, k = col + 1; k < nrows; k++) {
+            innerproduct += u[k] * *(p_row + k);
+          }
+          innerproduct *= scale;
+
+          for (k = col + 1; k < nrows; k++) {
+            *(p_row + k) -= u[k] * innerproduct;
+          }
+        }
+      }
+
+      delete[] u;
+    }
+
     /*
      * Calculate the exact inverse for a dense matrix (A [elements]) of size 2 or 3. Places the result in B_elements.
      */
@@ -318,6 +383,10 @@ namespace nm {
 
       if (M == 2) {
         DType det = A[0] * A[lda+1] - A[1] * A[lda];
+        if (det == 0) {
+          rb_raise(nm_eNotInvertibleError, 
+              "matrix must have non-zero determinant to be invertible (not getting this error does not mean matrix is invertible if you're dealing with floating points)");
+        }
         B[0] = A[lda+1] / det;
         B[1] = -A[1] / det;
         B[ldb] = -A[lda] / det;
@@ -328,7 +397,8 @@ namespace nm {
         DType det;
         det_exact<DType>(M, A_elements, lda, reinterpret_cast<void*>(&det));
         if (det == 0) {
-          rb_raise(nm_eNotInvertibleError, "matrix must have non-zero determinant to be invertible (not getting this error does not mean matrix is invertible if you're dealing with floating points)");
+          rb_raise(nm_eNotInvertibleError, 
+              "matrix must have non-zero determinant to be invertible (not getting this error does not mean matrix is invertible if you're dealing with floating points)");
         }
 
         B[0]      = (  A[lda+1] * A[2*lda+2] - A[lda+2] * A[2*lda+1]) / det; // A = ei - fh
@@ -347,22 +417,6 @@ namespace nm {
       }
     }
 
-    /*
-     * Function signature conversion for calling CBLAS' gesvd functions as directly as possible.
-     */
-    template <typename DType, typename CType>
-    inline static int lapack_gesvd(char jobu, char jobvt, int m, int n, void* a, int lda, void* s, void* u, int ldu, void* vt, int ldvt, void* work, int lwork, void* rwork) {
-      return gesvd<DType,CType>(jobu, jobvt, m, n, reinterpret_cast<DType*>(a), lda, reinterpret_cast<DType*>(s), reinterpret_cast<DType*>(u), ldu, reinterpret_cast<DType*>(vt), ldvt, reinterpret_cast<DType*>(work), lwork, reinterpret_cast<CType*>(rwork));
-    }
-
-    /*
-     * Function signature conversion for calling CBLAS' gesvd functions as directly as possible.
-     */
-    template <typename DType, typename CType>
-    inline static int lapack_gesdd(char jobz, int m, int n, void* a, int lda, void* s, void* u, int ldu, void* vt, int ldvt, void* work, int lwork, int* iwork, void* rwork) {
-      return gesdd<DType,CType>(jobz, m, n, reinterpret_cast<DType*>(a), lda, reinterpret_cast<DType*>(s), reinterpret_cast<DType*>(u), ldu, reinterpret_cast<DType*>(vt), ldvt, reinterpret_cast<DType*>(work), lwork, iwork, reinterpret_cast<CType*>(rwork));
-    }
-
     /*
      * Function signature conversion for calling CBLAS' gemm functions as directly as possible.
      *
@@ -422,39 +476,6 @@ namespace nm {
                   reinterpret_cast<const DType*>(a), lda, reinterpret_cast<DType*>(b), ldb);
     }
 
-
-    /*
-     * Function signature conversion for calling CBLAS' trmm functions as directly as possible.
-     *
-     * For documentation: http://www.netlib.org/blas/dtrmm.f
-     */
-    template <typename DType>
-    inline static void cblas_trmm(const enum CBLAS_ORDER order, const enum CBLAS_SIDE side, const enum CBLAS_UPLO uplo,
-                                  const enum CBLAS_TRANSPOSE ta, const enum CBLAS_DIAG diag, const int m, const int n, const void* alpha,
-                                  const void* A, const int lda, void* B, const int ldb)
-    {
-      trmm<DType>(order, side, uplo, ta, diag, m, n, reinterpret_cast<const DType*>(alpha),
-                  reinterpret_cast<const DType*>(A), lda, reinterpret_cast<DType*>(B), ldb);
-    }
-
-
-    /*
-     * Function signature conversion for calling CBLAS' syrk functions as directly as possible.
-     *
-     * For documentation: http://www.netlib.org/blas/dsyrk.f
-     */
-    template <typename DType>
-    inline static void cblas_syrk(const enum CBLAS_ORDER order, const enum CBLAS_UPLO uplo, const enum CBLAS_TRANSPOSE trans,
-                                  const int n, const int k, const void* alpha,
-                                  const void* A, const int lda, const void* beta, void* C, const int ldc)
-    {
-      syrk<DType>(order, uplo, trans, n, k, reinterpret_cast<const DType*>(alpha),
-                  reinterpret_cast<const DType*>(A), lda, reinterpret_cast<const DType*>(beta), reinterpret_cast<DType*>(C), ldc);
-    }
-
-
-
-
   }
 } // end of namespace nm::math
 
@@ -466,80 +487,29 @@ extern "C" {
 ///////////////////
 
 void nm_math_init_blas() {
-	cNMatrix_LAPACK = rb_define_module_under(cNMatrix, "LAPACK");
+  VALUE cNMatrix_Internal = rb_define_module_under(cNMatrix, "Internal");
 
   rb_define_singleton_method(cNMatrix, "has_clapack?", (METHOD)nm_has_clapack, 0);
 
-  /* ATLAS-CLAPACK Functions */
-  rb_define_singleton_method(cNMatrix_LAPACK, "clapack_getrf", (METHOD)nm_clapack_getrf, 5);
-  rb_define_singleton_method(cNMatrix_LAPACK, "clapack_potrf", (METHOD)nm_clapack_potrf, 5);
-  rb_define_singleton_method(cNMatrix_LAPACK, "clapack_getrs", (METHOD)nm_clapack_getrs, 9);
-  rb_define_singleton_method(cNMatrix_LAPACK, "clapack_potrs", (METHOD)nm_clapack_potrs, 8);
-  rb_define_singleton_method(cNMatrix_LAPACK, "clapack_getri", (METHOD)nm_clapack_getri, 5);
-  rb_define_singleton_method(cNMatrix_LAPACK, "clapack_potri", (METHOD)nm_clapack_potri, 5);
-  rb_define_singleton_method(cNMatrix_LAPACK, "clapack_laswp", (METHOD)nm_clapack_laswp, 7);
-  rb_define_singleton_method(cNMatrix_LAPACK, "clapack_lauum", (METHOD)nm_clapack_lauum, 5);
-
-  /* Non-ATLAS regular LAPACK Functions called via Fortran interface */
-  rb_define_singleton_method(cNMatrix_LAPACK, "lapack_gesvd", (METHOD)nm_lapack_gesvd, 12);
-  rb_define_singleton_method(cNMatrix_LAPACK, "lapack_gesdd", (METHOD)nm_lapack_gesdd, 11);
-  rb_define_singleton_method(cNMatrix_LAPACK, "lapack_geev",  (METHOD)nm_lapack_geev,  12);
-
-  cNMatrix_BLAS = rb_define_module_under(cNMatrix, "BLAS");
-
-  rb_define_singleton_method(cNMatrix_BLAS, "cblas_scal", (METHOD)nm_cblas_scal, 4);
-  rb_define_singleton_method(cNMatrix_BLAS, "cblas_nrm2", (METHOD)nm_cblas_nrm2, 3);
-  rb_define_singleton_method(cNMatrix_BLAS, "cblas_asum", (METHOD)nm_cblas_asum, 3);
-  rb_define_singleton_method(cNMatrix_BLAS, "cblas_rot",  (METHOD)nm_cblas_rot,  7);
-  rb_define_singleton_method(cNMatrix_BLAS, "cblas_rotg", (METHOD)nm_cblas_rotg, 1);
-  rb_define_singleton_method(cNMatrix_BLAS, "cblas_imax", (METHOD)nm_cblas_imax, 3);
-
-	rb_define_singleton_method(cNMatrix_BLAS, "cblas_gemm", (METHOD)nm_cblas_gemm, 14);
-	rb_define_singleton_method(cNMatrix_BLAS, "cblas_gemv", (METHOD)nm_cblas_gemv, 11);
-	rb_define_singleton_method(cNMatrix_BLAS, "cblas_trsm", (METHOD)nm_cblas_trsm, 12);
-	rb_define_singleton_method(cNMatrix_BLAS, "cblas_trmm", (METHOD)nm_cblas_trmm, 12);
-	rb_define_singleton_method(cNMatrix_BLAS, "cblas_syrk", (METHOD)nm_cblas_syrk, 11);
-	rb_define_singleton_method(cNMatrix_BLAS, "cblas_herk", (METHOD)nm_cblas_herk, 11);
-}
-
-/*
- * Interprets lapack jobu and jobvt arguments, for which LAPACK needs character values A, S, O, or N.
- *
- * Called by lapack_gesvd -- basically inline. svd stands for singular value decomposition.
- */
-static inline char lapack_svd_job_sym(VALUE op) {
-  if (rb_to_id(op) == rb_intern("all") || rb_to_id(op) == rb_intern("a")) return 'A';
-  else if (rb_to_id(op) == rb_intern("return") || rb_to_id(op) == rb_intern("s")) return 'S';
-  else if (rb_to_id(op) == rb_intern("overwrite") || rb_to_id(op) == rb_intern("o")) return 'O';
-  else if (rb_to_id(op) == rb_intern("none") || rb_to_id(op) == rb_intern("n")) return 'N';
-  else rb_raise(rb_eArgError, "Expected :all, :return, :overwrite, :none (or :a, :s, :o, :n, respectively)");
-  return 'a';
-}
+  VALUE cNMatrix_Internal_LAPACK = rb_define_module_under(cNMatrix_Internal, "LAPACK");
 
+  /* ATLAS-CLAPACK Functions that are implemented internally */
+  rb_define_singleton_method(cNMatrix_Internal_LAPACK, "clapack_getrf", (METHOD)nm_clapack_getrf, 5);
+  rb_define_singleton_method(cNMatrix_Internal_LAPACK, "clapack_getrs", (METHOD)nm_clapack_getrs, 9);
+  rb_define_singleton_method(cNMatrix_Internal_LAPACK, "clapack_laswp", (METHOD)nm_clapack_laswp, 7);
 
-/*
- * Interprets lapack jobvl and jobvr arguments, for which LAPACK needs character values N or V.
- *
- * Called by lapack_geev -- basically inline. evd stands for eigenvalue decomposition.
- */
-static inline char lapack_evd_job_sym(VALUE op) {
-  if (op == Qfalse || op == Qnil || rb_to_id(op) == rb_intern("n")) return 'N';
-  else return 'V';
-}
+  VALUE cNMatrix_Internal_BLAS = rb_define_module_under(cNMatrix_Internal, "BLAS");
 
+  rb_define_singleton_method(cNMatrix_Internal_BLAS, "cblas_scal", (METHOD)nm_cblas_scal, 4);
+  rb_define_singleton_method(cNMatrix_Internal_BLAS, "cblas_nrm2", (METHOD)nm_cblas_nrm2, 3);
+  rb_define_singleton_method(cNMatrix_Internal_BLAS, "cblas_asum", (METHOD)nm_cblas_asum, 3);
+  rb_define_singleton_method(cNMatrix_Internal_BLAS, "cblas_rot",  (METHOD)nm_cblas_rot,  7);
+  rb_define_singleton_method(cNMatrix_Internal_BLAS, "cblas_rotg", (METHOD)nm_cblas_rotg, 1);
+  rb_define_singleton_method(cNMatrix_Internal_BLAS, "cblas_imax", (METHOD)nm_cblas_imax, 3);
 
-/* Interprets cblas argument which could be any of false/:no_transpose, :transpose, or :complex_conjugate,
- * into an enum recognized by cblas.
- *
- * Called by nm_cblas_gemm -- basically inline.
- *
- */
-static inline enum CBLAS_TRANSPOSE blas_transpose_sym(VALUE op) {
-  if (op == Qfalse || rb_to_id(op) == nm_rb_no_transpose) return CblasNoTrans;
-  else if (rb_to_id(op) == nm_rb_transpose) return CblasTrans;
-  else if (rb_to_id(op) == nm_rb_complex_conjugate) return CblasConjTrans;
-  else rb_raise(rb_eArgError, "Expected false, :transpose, or :complex_conjugate");
-  return CblasNoTrans;
+  rb_define_singleton_method(cNMatrix_Internal_BLAS, "cblas_gemm", (METHOD)nm_cblas_gemm, 14);
+  rb_define_singleton_method(cNMatrix_Internal_BLAS, "cblas_gemv", (METHOD)nm_cblas_gemv, 11);
+  rb_define_singleton_method(cNMatrix_Internal_BLAS, "cblas_trsm", (METHOD)nm_cblas_trsm, 12);
 }
 
 /*
@@ -572,55 +542,6 @@ static VALUE nm_cblas_scal(VALUE self, VALUE n, VALUE alpha, VALUE vector, VALUE
   return vector;
 }
 
-/*
- * Interprets cblas argument which could be :left or :right
- *
- * Called by nm_cblas_trsm -- basically inline
- */
-static inline enum CBLAS_SIDE blas_side_sym(VALUE op) {
-  ID op_id = rb_to_id(op);
-  if (op_id == nm_rb_left)  return CblasLeft;
-  if (op_id == nm_rb_right) return CblasRight;
-  rb_raise(rb_eArgError, "Expected :left or :right for side argument");
-  return CblasLeft;
-}
-
-/*
- * Interprets cblas argument which could be :upper or :lower
- *
- * Called by nm_cblas_trsm -- basically inline
- */
-static inline enum CBLAS_UPLO blas_uplo_sym(VALUE op) {
-  ID op_id = rb_to_id(op);
-  if (op_id == nm_rb_upper) return CblasUpper;
-  if (op_id == nm_rb_lower) return CblasLower;
-  rb_raise(rb_eArgError, "Expected :upper or :lower for uplo argument");
-  return CblasUpper;
-}
-
-
-/*
- * Interprets cblas argument which could be :unit (true) or :nonunit (false or anything other than true/:unit)
- *
- * Called by nm_cblas_trsm -- basically inline
- */
-static inline enum CBLAS_DIAG blas_diag_sym(VALUE op) {
-  if (rb_to_id(op) == nm_rb_unit || op == Qtrue) return CblasUnit;
-  return CblasNonUnit;
-}
-
-/*
- * Interprets cblas argument which could be :row or :col
- */
-static inline enum CBLAS_ORDER blas_order_sym(VALUE op) {
-  if (rb_to_id(op) == rb_intern("row") || rb_to_id(op) == rb_intern("row_major")) return CblasRowMajor;
-  else if (rb_to_id(op) == rb_intern("col") || rb_to_id(op) == rb_intern("col_major") ||
-           rb_to_id(op) == rb_intern("column") || rb_to_id(op) == rb_intern("column_major")) return CblasColMajor;
-  rb_raise(rb_eArgError, "Expected :row or :col for order argument");
-  return CblasRowMajor;
-}
-
-
 /*
  * Call any of the cblas_xrotg functions as directly as possible.
  *
@@ -641,10 +562,6 @@ static inline enum CBLAS_ORDER blas_order_sym(VALUE op) {
  * The outputs [c,s] will be returned in a Ruby Array at the end; the input
  * NMatrix will also be modified in-place.
  *
- * If you provide rationals, be aware that there's a high probability of an
- * error, since rotg includes a square root -- and most rationals' square roots
- * are irrational. You're better off converting to Float first.
- *
  * This function, like the other cblas_ functions, does minimal type-checking.
  */
 static VALUE nm_cblas_rotg(VALUE self, VALUE ab) {
@@ -654,14 +571,13 @@ static VALUE nm_cblas_rotg(VALUE self, VALUE ab) {
       nm::math::cblas_rotg<double>,
       nm::math::cblas_rotg<nm::Complex64>,
       nm::math::cblas_rotg<nm::Complex128>,
-      NULL, NULL, NULL, // no rationals
       NULL //nm::math::cblas_rotg<nm::RubyObject>
   };
 
   nm::dtype_t dtype = NM_DTYPE(ab);
 
   if (!ttable[dtype]) {
-    rb_raise(nm_eDataTypeError, "this operation undefined for integer and rational vectors");
+    rb_raise(nm_eDataTypeError, "this operation undefined for integer vectors");
     return Qnil;
 
   } else {
@@ -723,9 +639,6 @@ static VALUE nm_cblas_rot(VALUE self, VALUE n, VALUE x, VALUE incx, VALUE y, VAL
       nm::math::cblas_rot<double,double>,
       nm::math::cblas_rot<nm::Complex64,float>,
       nm::math::cblas_rot<nm::Complex128,double>,
-      nm::math::cblas_rot<nm::Rational32,nm::Rational32>,
-      nm::math::cblas_rot<nm::Rational64,nm::Rational64>,
-      nm::math::cblas_rot<nm::Rational128,nm::Rational128>,
       nm::math::cblas_rot<nm::RubyObject,nm::RubyObject>
   };
 
@@ -792,17 +705,13 @@ static VALUE nm_cblas_nrm2(VALUE self, VALUE n, VALUE x, VALUE incx) {
       nm::math::cblas_nrm2<float64_t,float64_t>,
       nm::math::cblas_nrm2<float32_t,nm::Complex64>,
       nm::math::cblas_nrm2<float64_t,nm::Complex128>,
-      //nm::math::cblas_nrm2<nm::Rational32,nm::Rational32>,
-      //nm::math::cblas_nrm2<nm::Rational64,nm::Rational64>,
-      //nm::math::cblas_nrm2<nm::Rational128,nm::Rational128>,
-      NULL, NULL, NULL,
       nm::math::cblas_nrm2<nm::RubyObject,nm::RubyObject>
   };
 
   nm::dtype_t dtype  = NM_DTYPE(x);
 
   if (!ttable[dtype]) {
-    rb_raise(nm_eDataTypeError, "this operation undefined for integer and rational vectors");
+    rb_raise(nm_eDataTypeError, "this operation undefined for integer vectors");
     return Qnil;
 
   } else {
@@ -850,9 +759,6 @@ static VALUE nm_cblas_asum(VALUE self, VALUE n, VALUE x, VALUE incx) {
       nm::math::cblas_asum<float64_t,float64_t>,
       nm::math::cblas_asum<float32_t,nm::Complex64>,
       nm::math::cblas_asum<float64_t,nm::Complex128>,
-      nm::math::cblas_asum<nm::Rational32,nm::Rational32>,
-      nm::math::cblas_asum<nm::Rational64,nm::Rational64>,
-      nm::math::cblas_asum<nm::Rational128,nm::Rational128>,
       nm::math::cblas_asum<nm::RubyObject,nm::RubyObject>
   };
 
@@ -1000,10 +906,8 @@ static VALUE nm_cblas_trsm(VALUE self,
       NULL, NULL, NULL, NULL, NULL, // integers not allowed due to division
       nm::math::cblas_trsm<float>,
       nm::math::cblas_trsm<double>,
-      cblas_ctrsm, cblas_ztrsm, // call directly, same function signature!
-      nm::math::cblas_trsm<nm::Rational32>,
-      nm::math::cblas_trsm<nm::Rational64>,
-      nm::math::cblas_trsm<nm::Rational128>,
+      nm::math::cblas_trsm<nm::Complex64>,
+      nm::math::cblas_trsm<nm::Complex128>,
       nm::math::cblas_trsm<nm::RubyObject>
   };
 
@@ -1021,358 +925,6 @@ static VALUE nm_cblas_trsm(VALUE self,
   return Qtrue;
 }
 
-
-static VALUE nm_cblas_trmm(VALUE self,
-                           VALUE order,
-                           VALUE side, VALUE uplo,
-                           VALUE trans_a, VALUE diag,
-                           VALUE m, VALUE n,
-                           VALUE alpha,
-                           VALUE a, VALUE lda,
-                           VALUE b, VALUE ldb)
-{
-  static void (*ttable[nm::NUM_DTYPES])(const enum CBLAS_ORDER,
-                                        const enum CBLAS_SIDE, const enum CBLAS_UPLO,
-                                        const enum CBLAS_TRANSPOSE, const enum CBLAS_DIAG,
-                                        const int m, const int n, const void* alpha, const void* a,
-                                        const int lda, void* b, const int ldb) = {
-      NULL, NULL, NULL, NULL, NULL, // integers not allowed due to division
-      nm::math::cblas_trmm<float>,
-      nm::math::cblas_trmm<double>,
-      cblas_ctrmm, cblas_ztrmm // call directly, same function signature!
-      /*
-      nm::math::cblas_trmm<nm::Rational32>,
-      nm::math::cblas_trmm<nm::Rational64>,
-      nm::math::cblas_trmm<nm::Rational128>,
-      nm::math::cblas_trmm<nm::RubyObject>*/
-  };
-
-  nm::dtype_t dtype = NM_DTYPE(a);
-
-  if (!ttable[dtype]) {
-    rb_raise(nm_eDataTypeError, "this matrix operation not yet defined for non-BLAS dtypes");
-  } else {
-    void *pAlpha = NM_ALLOCA_N(char, DTYPE_SIZES[dtype]);
-    rubyval_to_cval(alpha, dtype, pAlpha);
-
-    ttable[dtype](blas_order_sym(order), blas_side_sym(side), blas_uplo_sym(uplo), blas_transpose_sym(trans_a), blas_diag_sym(diag), FIX2INT(m), FIX2INT(n), pAlpha, NM_STORAGE_DENSE(a)->elements, FIX2INT(lda), NM_STORAGE_DENSE(b)->elements, FIX2INT(ldb));
-  }
-
-  return b;
-}
-
-
-static VALUE nm_cblas_syrk(VALUE self,
-                           VALUE order,
-                           VALUE uplo,
-                           VALUE trans,
-                           VALUE n, VALUE k,
-                           VALUE alpha,
-                           VALUE a, VALUE lda,
-                           VALUE beta,
-                           VALUE c, VALUE ldc)
-{
-  static void (*ttable[nm::NUM_DTYPES])(const enum CBLAS_ORDER, const enum CBLAS_UPLO, const enum CBLAS_TRANSPOSE,
-                                        const int n, const int k, const void* alpha, const void* a,
-                                        const int lda, const void* beta, void* c, const int ldc) = {
-      NULL, NULL, NULL, NULL, NULL, // integers not allowed due to division
-      nm::math::cblas_syrk<float>,
-      nm::math::cblas_syrk<double>,
-      cblas_csyrk, cblas_zsyrk// call directly, same function signature!
-      /*nm::math::cblas_trsm<nm::Rational32>,
-      nm::math::cblas_trsm<nm::Rational64>,
-      nm::math::cblas_trsm<nm::Rational128>,
-      nm::math::cblas_trsm<nm::RubyObject>*/
-  };
-
-  nm::dtype_t dtype = NM_DTYPE(a);
-
-  if (!ttable[dtype]) {
-    rb_raise(nm_eDataTypeError, "this matrix operation undefined for integer matrices");
-  } else {
-    void *pAlpha = NM_ALLOCA_N(char, DTYPE_SIZES[dtype]),
-         *pBeta = NM_ALLOCA_N(char, DTYPE_SIZES[dtype]);
-    rubyval_to_cval(alpha, dtype, pAlpha);
-    rubyval_to_cval(beta, dtype, pBeta);
-
-    ttable[dtype](blas_order_sym(order), blas_uplo_sym(uplo), blas_transpose_sym(trans), FIX2INT(n), FIX2INT(k), pAlpha, NM_STORAGE_DENSE(a)->elements, FIX2INT(lda), pBeta, NM_STORAGE_DENSE(c)->elements, FIX2INT(ldc));
-  }
-
-  return Qtrue;
-}
-
-
-static VALUE nm_cblas_herk(VALUE self,
-                           VALUE order,
-                           VALUE uplo,
-                           VALUE trans,
-                           VALUE n, VALUE k,
-                           VALUE alpha,
-                           VALUE a, VALUE lda,
-                           VALUE beta,
-                           VALUE c, VALUE ldc)
-{
-
-  nm::dtype_t dtype = NM_DTYPE(a);
-
-  if (dtype == nm::COMPLEX64) {
-    cblas_cherk(blas_order_sym(order), blas_uplo_sym(uplo), blas_transpose_sym(trans), FIX2INT(n), FIX2INT(k), NUM2DBL(alpha), NM_STORAGE_DENSE(a)->elements, FIX2INT(lda), NUM2DBL(beta), NM_STORAGE_DENSE(c)->elements, FIX2INT(ldc));
-  } else if (dtype == nm::COMPLEX128) {
-    cblas_zherk(blas_order_sym(order), blas_uplo_sym(uplo), blas_transpose_sym(trans), FIX2INT(n), FIX2INT(k), NUM2DBL(alpha), NM_STORAGE_DENSE(a)->elements, FIX2INT(lda), NUM2DBL(beta), NM_STORAGE_DENSE(c)->elements, FIX2INT(ldc));
-  } else
-    rb_raise(rb_eNotImpError, "this matrix operation undefined for non-complex dtypes");
-  return Qtrue;
-}
-
-
-/*
- * Function signature conversion for calling CBLAS' gesvd functions as directly as possible.
- *
- * xGESVD computes the singular value decomposition (SVD) of a real
- * M-by-N matrix A, optionally computing the left and/or right singular
- * vectors. The SVD is written
- *
- *      A = U * SIGMA * transpose(V)
- *
- * where SIGMA is an M-by-N matrix which is zero except for its
- * min(m,n) diagonal elements, U is an M-by-M orthogonal matrix, and
- * V is an N-by-N orthogonal matrix.  The diagonal elements of SIGMA
- * are the singular values of A; they are real and non-negative, and
- * are returned in descending order.  The first min(m,n) columns of
- * U and V are the left and right singular vectors of A.
- *
- * Note that the routine returns V**T, not V.
- */
-static VALUE nm_lapack_gesvd(VALUE self, VALUE jobu, VALUE jobvt, VALUE m, VALUE n, VALUE a, VALUE lda, VALUE s, VALUE u, VALUE ldu, VALUE vt, VALUE ldvt, VALUE lwork) {
-  static int (*gesvd_table[nm::NUM_DTYPES])(char, char, int, int, void* a, int, void* s, void* u, int, void* vt, int, void* work, int, void* rwork) = {
-    NULL, NULL, NULL, NULL, NULL, // no integer ops
-    nm::math::lapack_gesvd<float,float>,
-    nm::math::lapack_gesvd<double,double>,
-    nm::math::lapack_gesvd<nm::Complex64,float>,
-    nm::math::lapack_gesvd<nm::Complex128,double>,
-    NULL, NULL, NULL, NULL // no rationals or Ruby objects
-  };
-
-  nm::dtype_t dtype = NM_DTYPE(a);
-
-
-  if (!gesvd_table[dtype]) {
-    rb_raise(rb_eNotImpError, "this operation not yet implemented for non-BLAS dtypes");
-    return Qfalse;
-  } else {
-    int M = FIX2INT(m),
-        N = FIX2INT(n);
-
-    int min_mn  = NM_MIN(M,N);
-    int max_mn  = NM_MAX(M,N);
-
-    char JOBU = lapack_svd_job_sym(jobu),
-         JOBVT = lapack_svd_job_sym(jobvt);
-
-    // only need rwork for complex matrices
-    int rwork_size  = (dtype == nm::COMPLEX64 || dtype == nm::COMPLEX128) ? 5 * min_mn : 0;
-    void* rwork     = rwork_size > 0 ? NM_ALLOCA_N(char, DTYPE_SIZES[dtype] * rwork_size) : NULL;
-    int work_size   = FIX2INT(lwork);
-
-    // ignore user argument for lwork if it's too small.
-    work_size       = NM_MAX((dtype == nm::COMPLEX64 || dtype == nm::COMPLEX128 ? 2 * min_mn + max_mn : NM_MAX(3*min_mn + max_mn, 5*min_mn)), work_size);
-    void* work      = NM_ALLOCA_N(char, DTYPE_SIZES[dtype] * work_size);
-
-    int info = gesvd_table[dtype](JOBU, JOBVT, M, N, NM_STORAGE_DENSE(a)->elements, FIX2INT(lda),
-      NM_STORAGE_DENSE(s)->elements, NM_STORAGE_DENSE(u)->elements, FIX2INT(ldu), NM_STORAGE_DENSE(vt)->elements, FIX2INT(ldvt),
-      work, work_size, rwork);
-    return INT2FIX(info);
-  }
-}
-
-/*
- * Function signature conversion for calling CBLAS' gesdd functions as directly as possible.
- *
- * xGESDD uses a divide-and-conquer strategy to compute the singular value decomposition (SVD) of a real
- * M-by-N matrix A, optionally computing the left and/or right singular
- * vectors. The SVD is written
- *
- *      A = U * SIGMA * transpose(V)
- *
- * where SIGMA is an M-by-N matrix which is zero except for its
- * min(m,n) diagonal elements, U is an M-by-M orthogonal matrix, and
- * V is an N-by-N orthogonal matrix.  The diagonal elements of SIGMA
- * are the singular values of A; they are real and non-negative, and
- * are returned in descending order.  The first min(m,n) columns of
- * U and V are the left and right singular vectors of A.
- *
- * Note that the routine returns V**T, not V.
- */
-static VALUE nm_lapack_gesdd(VALUE self, VALUE jobz, VALUE m, VALUE n, VALUE a, VALUE lda, VALUE s, VALUE u, VALUE ldu, VALUE vt, VALUE ldvt, VALUE lwork) {
-  static int (*gesdd_table[nm::NUM_DTYPES])(char, int, int, void* a, int, void* s, void* u, int, void* vt, int, void* work, int, int* iwork, void* rwork) = {
-    NULL, NULL, NULL, NULL, NULL, // no integer ops
-    nm::math::lapack_gesdd<float,float>,
-    nm::math::lapack_gesdd<double,double>,
-    nm::math::lapack_gesdd<nm::Complex64,float>,
-    nm::math::lapack_gesdd<nm::Complex128,double>,
-    NULL, NULL, NULL, NULL // no rationals or Ruby objects
-  };
-
-  nm::dtype_t dtype = NM_DTYPE(a);
-
-  if (!gesdd_table[dtype]) {
-    rb_raise(rb_eNotImpError, "this operation not yet implemented for non-BLAS dtypes");
-    return Qfalse;
-  } else {
-    int M = FIX2INT(m),
-        N = FIX2INT(n);
-
-    int min_mn  = NM_MIN(M,N);
-    int max_mn  = NM_MAX(M,N);
-
-    char JOBZ = lapack_svd_job_sym(jobz);
-
-    // only need rwork for complex matrices
-    void* rwork = NULL;
-
-    int work_size = FIX2INT(lwork); // Make sure we allocate enough work, regardless of the user request.
-    if (dtype == nm::COMPLEX64 || dtype == nm::COMPLEX128) {
-      int rwork_size = min_mn * (JOBZ == 'N' ? 5 : NM_MAX(5*min_mn + 7, 2*max_mn + 2*min_mn + 1));
-      rwork = NM_ALLOCA_N(char, DTYPE_SIZES[dtype] * rwork_size);
-
-      if (JOBZ == 'N')      work_size = NM_MAX(work_size, 3*min_mn + NM_MAX(max_mn, 6*min_mn));
-      else if (JOBZ == 'O') work_size = NM_MAX(work_size, 3*min_mn*min_mn + NM_MAX(max_mn, 5*min_mn*min_mn + 4*min_mn));
-      else                  work_size = NM_MAX(work_size, 3*min_mn*min_mn + NM_MAX(max_mn, 4*min_mn*min_mn + 4*min_mn));
-    } else {
-      if (JOBZ == 'N')      work_size = NM_MAX(work_size, 2*min_mn + max_mn);
-      else if (JOBZ == 'O') work_size = NM_MAX(work_size, 2*min_mn*min_mn + max_mn + 2*min_mn);
-      else                  work_size = NM_MAX(work_size, min_mn*min_mn + max_mn + 2*min_mn);
-    }
-    void* work  = NM_ALLOCA_N(char, DTYPE_SIZES[dtype] * work_size);
-    int* iwork  = NM_ALLOCA_N(int, 8*min_mn);
-
-    int info = gesdd_table[dtype](JOBZ, M, N, NM_STORAGE_DENSE(a)->elements, FIX2INT(lda),
-      NM_STORAGE_DENSE(s)->elements, NM_STORAGE_DENSE(u)->elements, FIX2INT(ldu), NM_STORAGE_DENSE(vt)->elements, FIX2INT(ldvt),
-      work, work_size, iwork, rwork);
-    return INT2FIX(info);
-  }
-}
-
-
-/*
- * Function signature conversion for calling CBLAS' geev functions as directly as possible.
- *
- * GEEV computes for an N-by-N real nonsymmetric matrix A, the
- * eigenvalues and, optionally, the left and/or right eigenvectors.
- *
- * The right eigenvector v(j) of A satisfies
- *                    A * v(j) = lambda(j) * v(j)
- * where lambda(j) is its eigenvalue.
- *
- * The left eigenvector u(j) of A satisfies
- *                 u(j)**H * A = lambda(j) * u(j)**H
- * where u(j)**H denotes the conjugate transpose of u(j).
- *
- * The computed eigenvectors are normalized to have Euclidean norm
- * equal to 1 and largest component real.
- */
-static VALUE nm_lapack_geev(VALUE self, VALUE compute_left, VALUE compute_right, VALUE n, VALUE a, VALUE lda, VALUE w, VALUE wi, VALUE vl, VALUE ldvl, VALUE vr, VALUE ldvr, VALUE lwork) {
-  static int (*geev_table[nm::NUM_DTYPES])(char, char, int, void* a, int, void* w, void* wi, void* vl, int, void* vr, int, void* work, int, void* rwork) = {
-    NULL, NULL, NULL, NULL, NULL, // no integer ops
-    nm::math::lapack_geev<float,float>,
-    nm::math::lapack_geev<double,double>,
-    nm::math::lapack_geev<nm::Complex64,float>,
-    nm::math::lapack_geev<nm::Complex128,double>,
-    NULL, NULL, NULL, NULL // no rationals or Ruby objects
-  };
-
-  nm::dtype_t dtype = NM_DTYPE(a);
-
-
-  if (!geev_table[dtype]) {
-    rb_raise(rb_eNotImpError, "this operation not yet implemented for non-BLAS dtypes");
-    return Qfalse;
-  } else {
-    int N = FIX2INT(n);
-
-    char JOBVL = lapack_evd_job_sym(compute_left),
-         JOBVR = lapack_evd_job_sym(compute_right);
-
-    void* A  = NM_STORAGE_DENSE(a)->elements;
-    void* WR = NM_STORAGE_DENSE(w)->elements;
-    void* WI = wi == Qnil ? NULL : NM_STORAGE_DENSE(wi)->elements;
-    void* VL = NM_STORAGE_DENSE(vl)->elements;
-    void* VR = NM_STORAGE_DENSE(vr)->elements;
-
-    // only need rwork for complex matrices (wi == Qnil for complex)
-    int rwork_size  = dtype == nm::COMPLEX64 || dtype == nm::COMPLEX128 ? N * DTYPE_SIZES[dtype] : 0; // 2*N*floattype for complex only, otherwise 0
-    void* rwork     = rwork_size > 0 ? NM_ALLOCA_N(char, rwork_size) : NULL;
-    int work_size   = FIX2INT(lwork);
-    void* work;
-
-    int info;
-
-    // if work size is 0 or -1, query.
-    if (work_size <= 0) {
-      work_size = -1;
-      work = NM_ALLOC_N(char, DTYPE_SIZES[dtype]); //2*N * DTYPE_SIZES[dtype]);
-      info = geev_table[dtype](JOBVL, JOBVR, N, A, FIX2INT(lda), WR, WI, VL, FIX2INT(ldvl), VR, FIX2INT(ldvr), work, work_size, rwork);
-      work_size = (int)(dtype == nm::COMPLEX64 || dtype == nm::FLOAT32 ? reinterpret_cast<float*>(work)[0] : reinterpret_cast<double*>(work)[0]);
-      // line above is basically: work_size = (int)(work[0]); // now have new work_size
-      NM_FREE(work);
-      if (info == 0)
-        rb_warn("geev: calculated optimal lwork of %d; to eliminate this message, use a positive value for lwork (at least 2*shape[i])", work_size);
-      else return INT2FIX(info); // error of some kind on query!
-    }
-
-    // if work size is < 2*N, just set it to 2*N
-    if (work_size < 2*N) work_size = 2*N;
-    if (work_size < 3*N && (dtype == nm::FLOAT32 || dtype == nm::FLOAT64)) {
-      work_size = JOBVL == 'V' || JOBVR == 'V' ? 4*N : 3*N;
-    }
-
-    // Allocate work array for actual run
-    work = NM_ALLOCA_N(char, work_size * DTYPE_SIZES[dtype]);
-
-    // Perform the actual calculation.
-    info = geev_table[dtype](JOBVL, JOBVR, N, A, FIX2INT(lda), WR, WI, VL, FIX2INT(ldvl), VR, FIX2INT(ldvr), work, work_size, rwork);
-
-    return INT2FIX(info);
-  }
-}
-
-
-static VALUE nm_clapack_lauum(VALUE self, VALUE order, VALUE uplo, VALUE n, VALUE a, VALUE lda) {
-  static int (*ttable[nm::NUM_DTYPES])(const enum CBLAS_ORDER, const enum CBLAS_UPLO, const int n, void* a, const int lda) = {
-      /*nm::math::clapack_lauum<uint8_t, false>,
-      nm::math::clapack_lauum<int8_t, false>,
-      nm::math::clapack_lauum<int16_t, false>,
-      nm::math::clapack_lauum<uint32_t, false>,
-      nm::math::clapack_lauum<uint64_t, false>,*/
-      NULL, NULL, NULL, NULL, NULL,
-      nm::math::clapack_lauum<false, float>,
-      nm::math::clapack_lauum<false, double>,
-#if defined (HAVE_CLAPACK_H) || defined (HAVE_ATLAS_CLAPACK_H)
-      clapack_clauum, clapack_zlauum, // call directly, same function signature!
-#else // Especially important for Mac OS, which doesn't seem to include the ATLAS clapack interface.
-      nm::math::clapack_lauum<true, nm::Complex64>,
-      nm::math::clapack_lauum<true, nm::Complex128>,
-#endif
-/*
-      nm::math::clapack_lauum<nm::Rational32, false>,
-      nm::math::clapack_lauum<nm::Rational64, false>,
-      nm::math::clapack_lauum<nm::Rational128, false>,
-      nm::math::clapack_lauum<nm::RubyObject, false>
-
-*/
-  };
-
-  if (!ttable[NM_DTYPE(a)]) {
-    rb_raise(rb_eNotImpError, "does not yet work for non-BLAS dtypes (needs herk, syrk, trmm)");
-  } else {
-    // Call either our version of lauum or the LAPACK version.
-    ttable[NM_DTYPE(a)](blas_order_sym(order), blas_uplo_sym(uplo), FIX2INT(n), NM_STORAGE_DENSE(a)->elements, FIX2INT(lda));
-  }
-
-  return a;
-}
-
-
 /* Call any of the clapack_xgetrf functions as directly as possible.
  *
  * The clapack_getrf functions (dgetrf, sgetrf, cgetrf, and zgetrf) compute an LU factorization of a general M-by-N
@@ -1402,15 +954,8 @@ static VALUE nm_clapack_getrf(VALUE self, VALUE order, VALUE m, VALUE n, VALUE a
       NULL, NULL, NULL, NULL, NULL, // integers not allowed due to division
       nm::math::clapack_getrf<float>,
       nm::math::clapack_getrf<double>,
-#if defined (HAVE_CLAPACK_H) || defined (HAVE_ATLAS_CLAPACK_H)
-      clapack_cgetrf, clapack_zgetrf, // call directly, same function signature!
-#else // Especially important for Mac OS, which doesn't seem to include the ATLAS clapack interface.
       nm::math::clapack_getrf<nm::Complex64>,
       nm::math::clapack_getrf<nm::Complex128>,
-#endif
-      nm::math::clapack_getrf<nm::Rational32>,
-      nm::math::clapack_getrf<nm::Rational64>,
-      nm::math::clapack_getrf<nm::Rational128>,
       nm::math::clapack_getrf<nm::RubyObject>
   };
 
@@ -1438,51 +983,6 @@ static VALUE nm_clapack_getrf(VALUE self, VALUE order, VALUE m, VALUE n, VALUE a
 }
 
 
-/* Call any of the clapack_xpotrf functions as directly as possible.
- *
- * You probably don't want to call this function. Instead, why don't you try clapack_potrf, which is more flexible
- * with its arguments?
- *
- * This function does almost no type checking. Seriously, be really careful when you call it! There's no exception
- * handling, so you can easily crash Ruby!
- *
- * Returns an array giving the pivot indices (normally these are argument #5).
- */
-static VALUE nm_clapack_potrf(VALUE self, VALUE order, VALUE uplo, VALUE n, VALUE a, VALUE lda) {
-#if !defined(HAVE_CLAPACK_H) && !defined(HAVE_ATLAS_CLAPACK_H)
-  rb_raise(rb_eNotImpError, "potrf currently requires CLAPACK");
-#endif
-
-  static int (*ttable[nm::NUM_DTYPES])(const enum CBLAS_ORDER, const enum CBLAS_UPLO, const int n, void* a, const int lda) = {
-      NULL, NULL, NULL, NULL, NULL, // integers not allowed due to division
-      nm::math::clapack_potrf<float>,
-      nm::math::clapack_potrf<double>,
-#if defined (HAVE_CLAPACK_H) || defined (HAVE_ATLAS_CLAPACK_H)
-      clapack_cpotrf, clapack_zpotrf, // call directly, same function signature!
-#else // Especially important for Mac OS, which doesn't seem to include the ATLAS clapack interface.
-      nm::math::clapack_potrf<nm::Complex64>,
-      nm::math::clapack_potrf<nm::Complex128>,
-#endif
-      NULL, NULL, NULL, NULL /*
-      nm::math::clapack_potrf<nm::Rational32>,
-      nm::math::clapack_potrf<nm::Rational64>,
-      nm::math::clapack_potrf<nm::Rational128>,
-      nm::math::clapack_potrf<nm::RubyObject> */
-  };
-
-  if (!ttable[NM_DTYPE(a)]) {
-    rb_raise(rb_eNotImpError, "this operation not yet implemented for non-BLAS dtypes");
-    // FIXME: Once BLAS dtypes are implemented, replace error above with the error below.
-    //rb_raise(nm_eDataTypeError, "this matrix operation undefined for integer matrices");
-  } else {
-    // Call either our version of potrf or the LAPACK version.
-    ttable[NM_DTYPE(a)](blas_order_sym(order), blas_uplo_sym(uplo), FIX2INT(n), NM_STORAGE_DENSE(a)->elements, FIX2INT(lda));
-  }
-
-  return a;
-}
-
-
 /*
  * Call any of the clapack_xgetrs functions as directly as possible.
  */
@@ -1493,15 +993,8 @@ static VALUE nm_clapack_getrs(VALUE self, VALUE order, VALUE trans, VALUE n, VAL
       NULL, NULL, NULL, NULL, NULL, // integers not allowed due to division
       nm::math::clapack_getrs<float>,
       nm::math::clapack_getrs<double>,
-#if defined (HAVE_CLAPACK_H) || defined (HAVE_ATLAS_CLAPACK_H)
-      clapack_cgetrs, clapack_zgetrs, // call directly, same function signature!
-#else // Especially important for Mac OS, which doesn't seem to include the ATLAS clapack interface.
       nm::math::clapack_getrs<nm::Complex64>,
       nm::math::clapack_getrs<nm::Complex128>,
-#endif
-      nm::math::clapack_getrs<nm::Rational32>,
-      nm::math::clapack_getrs<nm::Rational64>,
-      nm::math::clapack_getrs<nm::Rational128>,
       nm::math::clapack_getrs<nm::RubyObject>
   };
 
@@ -1529,157 +1022,14 @@ static VALUE nm_clapack_getrs(VALUE self, VALUE order, VALUE trans, VALUE n, VAL
   return b;
 }
 
-
-/*
- * Call any of the clapack_xpotrs functions as directly as possible.
- */
-static VALUE nm_clapack_potrs(VALUE self, VALUE order, VALUE uplo, VALUE n, VALUE nrhs, VALUE a, VALUE lda, VALUE b, VALUE ldb) {
-  static int (*ttable[nm::NUM_DTYPES])(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const int N,
-                                       const int NRHS, const void* A, const int lda, void* B, const int ldb) = {
-      NULL, NULL, NULL, NULL, NULL, // integers not allowed due to division
-      nm::math::clapack_potrs<float,false>,
-      nm::math::clapack_potrs<double,false>,
-#if defined (HAVE_CLAPACK_H) || defined (HAVE_ATLAS_CLAPACK_H)
-      clapack_cpotrs, clapack_zpotrs, // call directly, same function signature!
-#else // Especially important for Mac OS, which doesn't seem to include the ATLAS clapack interface.
-      nm::math::clapack_potrs<nm::Complex64,true>,
-      nm::math::clapack_potrs<nm::Complex128,true>,
-#endif
-      nm::math::clapack_potrs<nm::Rational32,false>,
-      nm::math::clapack_potrs<nm::Rational64,false>,
-      nm::math::clapack_potrs<nm::Rational128,false>,
-      nm::math::clapack_potrs<nm::RubyObject,false>
-  };
-
-
-  if (!ttable[NM_DTYPE(a)]) {
-    rb_raise(nm_eDataTypeError, "this matrix operation undefined for integer matrices");
-  } else {
-
-    // Call either our version of potrs or the LAPACK version.
-    ttable[NM_DTYPE(a)](blas_order_sym(order), blas_uplo_sym(uplo), FIX2INT(n), FIX2INT(nrhs), NM_STORAGE_DENSE(a)->elements, FIX2INT(lda),
-                        NM_STORAGE_DENSE(b)->elements, FIX2INT(ldb));
-  }
-
-  // b is both returned and modified directly in the argument list.
-  return b;
-}
-
-
 /*
  * Simple way to check from within Ruby code if clapack functions are available, without
  * having to wait around for an exception to be thrown.
  */
 static VALUE nm_has_clapack(VALUE self) {
-#if defined (HAVE_CLAPACK_H) || defined (HAVE_ATLAS_CLAPACK_H)
   return Qfalse;
-#else
-  return Qtrue;
-#endif
 }
 
-
-/* Call any of the clapack_xgetri functions as directly as possible.
- *
- * You probably don't want to call this function. Instead, why don't you try clapack_getri, which is more flexible
- * with its arguments?
- *
- * This function does almost no type checking. Seriously, be really careful when you call it! There's no exception
- * handling, so you can easily crash Ruby!
- *
- * Returns an array giving the pivot indices (normally these are argument #5).
- */
-static VALUE nm_clapack_getri(VALUE self, VALUE order, VALUE n, VALUE a, VALUE lda, VALUE ipiv) {
-#if !defined (HAVE_CLAPACK_H) && !defined (HAVE_ATLAS_CLAPACK_H)
-  rb_raise(rb_eNotImpError, "getri currently requires CLAPACK");
-#endif
-
-  static int (*ttable[nm::NUM_DTYPES])(const enum CBLAS_ORDER, const int n, void* a, const int lda, const int* ipiv) = {
-      NULL, NULL, NULL, NULL, NULL, // integers not allowed due to division
-      nm::math::clapack_getri<float>,
-      nm::math::clapack_getri<double>,
-#if defined (HAVE_CLAPACK_H) || defined (HAVE_ATLAS_CLAPACK_H)
-      clapack_cgetri, clapack_zgetri, // call directly, same function signature!
-#else // Especially important for Mac OS, which doesn't seem to include the ATLAS clapack interface.
-      nm::math::clapack_getri<nm::Complex64>,
-      nm::math::clapack_getri<nm::Complex128>,
-#endif
-      NULL, NULL, NULL, NULL /*
-      nm::math::clapack_getri<nm::Rational32>,
-      nm::math::clapack_getri<nm::Rational64>,
-      nm::math::clapack_getri<nm::Rational128>,
-      nm::math::clapack_getri<nm::RubyObject> */
-  };
-
-  // Allocate the C version of the pivot index array
-  int* ipiv_;
-  if (TYPE(ipiv) != T_ARRAY) {
-    rb_raise(rb_eArgError, "ipiv must be of type Array");
-  } else {
-    ipiv_ = NM_ALLOCA_N(int, RARRAY_LEN(ipiv));
-    for (int index = 0; index < RARRAY_LEN(ipiv); ++index) {
-      ipiv_[index] = FIX2INT( RARRAY_PTR(ipiv)[index] );
-    }
-  }
-
-  if (!ttable[NM_DTYPE(a)]) {
-    rb_raise(rb_eNotImpError, "this operation not yet implemented for non-BLAS dtypes");
-    // FIXME: Once non-BLAS dtypes are implemented, replace error above with the error below.
-    //rb_raise(nm_eDataTypeError, "this matrix operation undefined for integer matrices");
-  } else {
-    // Call either our version of getri or the LAPACK version.
-    ttable[NM_DTYPE(a)](blas_order_sym(order), FIX2INT(n), NM_STORAGE_DENSE(a)->elements, FIX2INT(lda), ipiv_);
-  }
-
-  return a;
-}
-
-
-/* Call any of the clapack_xpotri functions as directly as possible.
- *
- * You probably don't want to call this function. Instead, why don't you try clapack_potri, which is more flexible
- * with its arguments?
- *
- * This function does almost no type checking. Seriously, be really careful when you call it! There's no exception
- * handling, so you can easily crash Ruby!
- *
- * Returns an array giving the pivot indices (normally these are argument #5).
- */
-static VALUE nm_clapack_potri(VALUE self, VALUE order, VALUE uplo, VALUE n, VALUE a, VALUE lda) {
-#if !defined (HAVE_CLAPACK_H) && !defined (HAVE_ATLAS_CLAPACK_H)
-  rb_raise(rb_eNotImpError, "getri currently requires CLAPACK");
-#endif
-
-  static int (*ttable[nm::NUM_DTYPES])(const enum CBLAS_ORDER, const enum CBLAS_UPLO, const int n, void* a, const int lda) = {
-      NULL, NULL, NULL, NULL, NULL, // integers not allowed due to division
-      nm::math::clapack_potri<float>,
-      nm::math::clapack_potri<double>,
-#if defined (HAVE_CLAPACK_H) || defined (HAVE_ATLAS_CLAPACK_H)
-      clapack_cpotri, clapack_zpotri, // call directly, same function signature!
-#else // Especially important for Mac OS, which doesn't seem to include the ATLAS clapack interface.
-      nm::math::clapack_potri<nm::Complex64>,
-      nm::math::clapack_potri<nm::Complex128>,
-#endif
-      NULL, NULL, NULL, NULL /*
-      nm::math::clapack_getri<nm::Rational32>,
-      nm::math::clapack_getri<nm::Rational64>,
-      nm::math::clapack_getri<nm::Rational128>,
-      nm::math::clapack_getri<nm::RubyObject> */
-  };
-
-  if (!ttable[NM_DTYPE(a)]) {
-    rb_raise(rb_eNotImpError, "this operation not yet implemented for non-BLAS dtypes");
-    // FIXME: Once BLAS dtypes are implemented, replace error above with the error below.
-    //rb_raise(nm_eDataTypeError, "this matrix operation undefined for integer matrices");
-  } else {
-    // Call either our version of getri or the LAPACK version.
-    ttable[NM_DTYPE(a)](blas_order_sym(order), blas_uplo_sym(uplo), FIX2INT(n), NM_STORAGE_DENSE(a)->elements, FIX2INT(lda));
-  }
-
-  return a;
-}
-
-
 /*
  * Call any of the clapack_xlaswp functions as directly as possible.
  *
@@ -1695,15 +1045,8 @@ static VALUE nm_clapack_laswp(VALUE self, VALUE n, VALUE a, VALUE lda, VALUE k1,
       nm::math::clapack_laswp<int64_t>,
       nm::math::clapack_laswp<float>,
       nm::math::clapack_laswp<double>,
-//#ifdef HAVE_CLAPACK_H // laswp doesn't actually exist in clapack.h!
-//      clapack_claswp, clapack_zlaswp, // call directly, same function signature!
-//#else // Especially important for Mac OS, which doesn't seem to include the ATLAS clapack interface.
       nm::math::clapack_laswp<nm::Complex64>,
       nm::math::clapack_laswp<nm::Complex128>,
-//#endif
-      nm::math::clapack_laswp<nm::Rational32>,
-      nm::math::clapack_laswp<nm::Rational64>,
-      nm::math::clapack_laswp<nm::Rational128>,
       nm::math::clapack_laswp<nm::RubyObject>
   };
 
@@ -1735,6 +1078,20 @@ void nm_math_det_exact(const int M, const void* elements, const int lda, nm::dty
   ttable[dtype](M, elements, lda, result);
 }
 
+/*
+ * C accessor for reducing a matrix to hessenberg form.
+ */
+void nm_math_hessenberg(VALUE a) {
+  static void (*ttable[nm::NUM_DTYPES])(const int, void*) = {
+      NULL, NULL, NULL, NULL, NULL, // does not support ints
+      nm::math::hessenberg<float>,
+      nm::math::hessenberg<double>,
+      NULL, NULL, // does not support Complex
+      NULL // no support for Ruby Object
+  };
+    
+  ttable[NM_DTYPE(a)](NM_SHAPE0(a), NM_STORAGE_DENSE(a)->elements);
+}
 /*
  * C accessor for calculating an in-place inverse.
  */