nmatrix 0.1.0 → 0.2.0

data/ext/nmatrix/math/gemm.h

@@ -30,14 +30,8 @@
 #ifndef GEMM_H
 # define GEMM_H
 
-extern "C" { // These need to be in an extern "C" block or you'll get all kinds of undefined symbol errors.
-#if defined HAVE_CBLAS_H
-  #include <cblas.h>
-#elif defined HAVE_ATLAS_CBLAS_H
-  #include <atlas/cblas.h>
-#endif
-}
-
+#include "cblas_enums.h"
+#include "math/long_dtype.h"
 
 namespace nm { namespace math {
 /*
@@ -242,30 +236,6 @@ inline void gemm(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA
 }
 
 
-template <>
-inline void gemm(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_TRANSPOSE TransB, const int M, const int N, const int K,
-          const float* alpha, const float* A, const int lda, const float* B, const int ldb, const float* beta, float* C, const int ldc) {
-  cblas_sgemm(Order, TransA, TransB, M, N, K, *alpha, A, lda, B, ldb, *beta, C, ldc);
-}
-
-template <>
-inline void gemm(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_TRANSPOSE TransB, const int M, const int N, const int K,
-          const double* alpha, const double* A, const int lda, const double* B, const int ldb, const double* beta, double* C, const int ldc) {
-  cblas_dgemm(Order, TransA, TransB, M, N, K, *alpha, A, lda, B, ldb, *beta, C, ldc);
-}
-
-template <>
-inline void gemm(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_TRANSPOSE TransB, const int M, const int N, const int K,
-          const Complex64* alpha, const Complex64* A, const int lda, const Complex64* B, const int ldb, const Complex64* beta, Complex64* C, const int ldc) {
-  cblas_cgemm(Order, TransA, TransB, M, N, K, alpha, A, lda, B, ldb, beta, C, ldc);
-}
-
-template <>
-inline void gemm(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_TRANSPOSE TransB, const int M, const int N, const int K,
-          const Complex128* alpha, const Complex128* A, const int lda, const Complex128* B, const int ldb, const Complex128* beta, Complex128* C, const int ldc) {
-  cblas_zgemm(Order, TransA, TransB, M, N, K, alpha, A, lda, B, ldb, beta, C, ldc);
-}
-
 }} // end of namespace nm::math
 
 #endif // GEMM_H

data/ext/nmatrix/math/gemv.h

@@ -30,14 +30,7 @@
 #ifndef GEMV_H
 # define GEMV_H
 
-extern "C" { // These need to be in an extern "C" block or you'll get all kinds of undefined symbol errors.
-#if defined HAVE_CBLAS_H
-  #include <cblas.h>
-#elif defined HAVE_ATLAS_CBLAS_H
-  #include <atlas/cblas.h>
-#endif
-}
-
+#include "math/long_dtype.h"
 
 namespace nm { namespace math {
 
@@ -179,33 +172,6 @@ inline bool gemv(const enum CBLAS_TRANSPOSE Trans, const int M, const int N, con
   return true;
 }  // end of GEMV
 
-template <>
-inline bool gemv(const enum CBLAS_TRANSPOSE Trans, const int M, const int N, const float* alpha, const float* A, const int lda,
-          const float* X, const int incX, const float* beta, float* Y, const int incY) {
-  cblas_sgemv(CblasRowMajor, Trans, M, N, *alpha, A, lda, X, incX, *beta, Y, incY);
-  return true;
-}
-
-template <>
-inline bool gemv(const enum CBLAS_TRANSPOSE Trans, const int M, const int N, const double* alpha, const double* A, const int lda,
-          const double* X, const int incX, const double* beta, double* Y, const int incY) {
-  cblas_dgemv(CblasRowMajor, Trans, M, N, *alpha, A, lda, X, incX, *beta, Y, incY);
-  return true;
-}
-
-template <>
-inline bool gemv(const enum CBLAS_TRANSPOSE Trans, const int M, const int N, const Complex64* alpha, const Complex64* A, const int lda,
-          const Complex64* X, const int incX, const Complex64* beta, Complex64* Y, const int incY) {
-  cblas_cgemv(CblasRowMajor, Trans, M, N, alpha, A, lda, X, incX, beta, Y, incY);
-  return true;
-}
-
-template <>
-inline bool gemv(const enum CBLAS_TRANSPOSE Trans, const int M, const int N, const Complex128* alpha, const Complex128* A, const int lda,
-          const Complex128* X, const int incX, const Complex128* beta, Complex128* Y, const int incY) {
-  cblas_zgemv(CblasRowMajor, Trans, M, N, alpha, A, lda, X, incX, beta, Y, incY);
-  return true;
-}
 
 }} // end of namespace nm::math
 

data/ext/nmatrix/math/getrf.h

@@ -59,6 +59,13 @@
 #ifndef GETRF_H
 #define GETRF_H
 
+#include "math/laswp.h"
+#include "math/math.h"
+#include "math/trsm.h"
+#include "math/gemm.h"
+#include "math/imax.h"
+#include "math/scal.h"
+
 namespace nm { namespace math {
 
 /* Numeric inverse -- usually just 1 / f, but a little more complicated for complex. */
@@ -69,8 +76,6 @@ inline DType numeric_inverse(const DType& n) {
 template <> inline float numeric_inverse(const float& n) { return 1 / n; }
 template <> inline double numeric_inverse(const double& n) { return 1 / n; }
 
-
-
 /*
  * Templated version of row-order and column-order getrf, derived from ATL_getrfR.c (from ATLAS 3.8.0).
  *
@@ -109,7 +114,12 @@ inline int getrf_nothrow(const int M, const int N, DType* A, const int lda, int*
     if (N_ul > NB) N_ul = ATL_MulByNB(ATL_DivByNB(N_ul));
 #endif
 
-    int N_dr = M - N_ul;
+    int N_dr;
+    if (RowMajor) {
+      N_dr = M - N_ul;
+    } else {
+      N_dr = N - N_ul;
+    }
 
     int i = RowMajor ? getrf_nothrow<true,DType>(N_ul, N, A, lda, ipiv) : getrf_nothrow<false,DType>(M, N_ul, A, lda, ipiv);
 
@@ -135,7 +145,7 @@ inline int getrf_nothrow(const int M, const int N, DType* A, const int lda, int*
       nm::math::laswp<DType>(N_dr, Ac, lda, 0, N_ul, ipiv, 1);
 
       nm::math::trsm<DType>(CblasColMajor, CblasLeft, CblasLower, CblasNoTrans, CblasUnit, N_ul, N_dr, one, A, lda, Ac, lda);
-      nm::math::gemm<DType>(CblasColMajor, CblasNoTrans, CblasNoTrans, M-N_ul, N_dr, N_ul, &neg_one, An, lda, Ac, lda, &one, An, lda);
+      nm::math::gemm<DType>(CblasColMajor, CblasNoTrans, CblasNoTrans, M-N_ul, N_dr, N_ul, &neg_one, &(A[N_ul]), lda, Ac, lda, &one, An, lda);
 
       i = getrf_nothrow<false,DType>(M-N_ul, N_dr, An, lda, ipiv+N_ul);
     }
@@ -148,9 +158,14 @@ inline int getrf_nothrow(const int M, const int N, DType* A, const int lda, int*
 
     nm::math::laswp<DType>(N_ul, A, lda, N_ul, MN, ipiv, 1);  /* apply pivots */
 
-  } else if (MN == 1) { // there's another case for the colmajor version, but i don't know that it's that critical. Calls ATLAS LU2, who knows what that does.
+  } else if (MN == 1) { // there's another case for the colmajor version, but it doesn't seem to be necessary.
 
-    int i = *ipiv = nm::math::imax<DType>(N, A, 1); // cblas_iamax(N, A, 1);
+    int i;
+    if (RowMajor) {
+      i = *ipiv = nm::math::imax<DType>(N, A, 1); // cblas_iamax(N, A, 1);
+    } else {
+      i = *ipiv = nm::math::imax<DType>(M, A, 1);
+    }
 
     DType tmp = A[i];
     if (tmp != 0) {

data/ext/nmatrix/math/getrs.h

@@ -59,14 +59,6 @@
 #ifndef GETRS_H
 #define GETRS_H
 
-extern "C" {
-#if defined HAVE_CBLAS_H
-  #include <cblas.h>
-#elif defined HAVE_ATLAS_CBLAS_H
-  #include <atlas/cblas.h>
-#endif
-}
-
 namespace nm { namespace math {
 
 

data/ext/nmatrix/math/imax.h

@@ -69,28 +69,6 @@ inline int imax(const int n, const DType *x, const int incx) {
   return imax;
 }
 
-#if defined HAVE_CBLAS_H || defined HAVE_ATLAS_CBLAS_H
-template<>
-inline int imax(const int n, const float* x, const int incx) {
-  return cblas_isamax(n, x, incx);
-}
-
-template<>
-inline int imax(const int n, const double* x, const int incx) {
-  return cblas_idamax(n, x, incx);
-}
-
-template<>
-inline int imax(const int n, const Complex64* x, const int incx) {
-  return cblas_icamax(n, x, incx);
-}
-
-template <>
-inline int imax(const int n, const Complex128* x, const int incx) {
-  return cblas_izamax(n, x, incx);
-}
-#endif
-
 template<typename DType>
 inline int cblas_imax(const int n, const void* x, const int incx) {
   return imax<DType>(n, reinterpret_cast<const DType*>(x), incx);

data/ext/nmatrix/math/long_dtype.h

@@ -42,9 +42,6 @@ namespace nm { namespace math {
   template <> struct LongDType<double> { typedef double type; };
   template <> struct LongDType<Complex64> { typedef Complex128 type; };
   template <> struct LongDType<Complex128> { typedef Complex128 type; };
-  template <> struct LongDType<Rational32> { typedef Rational128 type; };
-  template <> struct LongDType<Rational64> { typedef Rational128 type; };
-  template <> struct LongDType<Rational128> { typedef Rational128 type; };
   template <> struct LongDType<RubyObject> { typedef RubyObject type; };
 
 }} // end of namespace nm::math

data/ext/nmatrix/math/math.h

@@ -68,19 +68,7 @@
  * Standard Includes
  */
 
-extern "C" { // These need to be in an extern "C" block or you'll get all kinds of undefined symbol errors.
-#if defined HAVE_CBLAS_H
-  #include <cblas.h>
-#elif defined HAVE_ATLAS_CBLAS_H
-  #include <atlas/cblas.h>
-#endif
-
-#if defined HAVE_CLAPACK_H
-  #include <clapack.h>
-#elif defined HAVE_ATLAS_CLAPACK_H
-  #include <atlas/clapack.h>
-#endif
-}
+#include "cblas_enums.h"
 
 #include <algorithm> // std::min, std::max
 #include <limits> // std::numeric_limits
@@ -103,11 +91,18 @@ extern "C" {
   /*
    * C accessors.
    */
-  void nm_math_det_exact(const int M, const void* elements, const int lda, nm::dtype_t dtype, void* result);
-  void nm_math_inverse(const int M, void* A_elements, nm::dtype_t dtype);
-  void nm_math_inverse_exact(const int M, const void* A_elements, const int lda, void* B_elements, const int ldb, nm::dtype_t dtype);
+
   void nm_math_transpose_generic(const size_t M, const size_t N, const void* A, const int lda, void* B, const int ldb, size_t element_size);
   void nm_math_init_blas(void);
+
+  /*
+   * Pure math implementations.
+   */  
+  void nm_math_solve(VALUE lu, VALUE b, VALUE x, VALUE ipiv);
+  void nm_math_inverse(const int M, void* A_elements, nm::dtype_t dtype);
+  void nm_math_hessenberg(VALUE a);
+  void nm_math_det_exact(const int M, const void* elements, const int lda, nm::dtype_t dtype, void* result);
+  void nm_math_inverse_exact(const int M, const void* A_elements, const int lda, void* B_elements, const int ldb, nm::dtype_t dtype);
 }
 
 
@@ -123,94 +118,6 @@ namespace nm {
  * Functions
  */
 
-
-template <typename DType>
-inline void syrk(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE Trans, const int N,
-                 const int K, const DType* alpha, const DType* A, const int lda, const DType* beta, DType* C, const int ldc) {
-  rb_raise(rb_eNotImpError, "syrk not yet implemented for non-BLAS dtypes");
-}
-
-template <typename DType>
-inline void herk(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE Trans, const int N,
-                 const int K, const DType* alpha, const DType* A, const int lda, const DType* beta, DType* C, const int ldc) {
-  rb_raise(rb_eNotImpError, "herk not yet implemented for non-BLAS dtypes");
-}
-
-template <>
-inline void syrk(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE Trans, const int N,
-                 const int K, const float* alpha, const float* A, const int lda, const float* beta, float* C, const int ldc) {
-  cblas_ssyrk(Order, Uplo, Trans, N, K, *alpha, A, lda, *beta, C, ldc);
-}
-
-template <>
-inline void syrk(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE Trans, const int N,
-                 const int K, const double* alpha, const double* A, const int lda, const double* beta, double* C, const int ldc) {
-  cblas_dsyrk(Order, Uplo, Trans, N, K, *alpha, A, lda, *beta, C, ldc);
-}
-
-template <>
-inline void syrk(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE Trans, const int N,
-                 const int K, const Complex64* alpha, const Complex64* A, const int lda, const Complex64* beta, Complex64* C, const int ldc) {
-  cblas_csyrk(Order, Uplo, Trans, N, K, alpha, A, lda, beta, C, ldc);
-}
-
-template <>
-inline void syrk(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE Trans, const int N,
-                 const int K, const Complex128* alpha, const Complex128* A, const int lda, const Complex128* beta, Complex128* C, const int ldc) {
-  cblas_zsyrk(Order, Uplo, Trans, N, K, alpha, A, lda, beta, C, ldc);
-}
-
-
-template <>
-inline void herk(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE Trans, const int N,
-                 const int K, const Complex64* alpha, const Complex64* A, const int lda, const Complex64* beta, Complex64* C, const int ldc) {
-  cblas_cherk(Order, Uplo, Trans, N, K, alpha->r, A, lda, beta->r, C, ldc);
-}
-
-template <>
-inline void herk(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE Trans, const int N,
-                 const int K, const Complex128* alpha, const Complex128* A, const int lda, const Complex128* beta, Complex128* C, const int ldc) {
-  cblas_zherk(Order, Uplo, Trans, N, K, alpha->r, A, lda, beta->r, C, ldc);
-}
-
-
-template <typename DType>
-inline void 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 DType* alpha,
-                 const DType* A, const int lda, DType* B, const int ldb) {
-  rb_raise(rb_eNotImpError, "trmm not yet implemented for non-BLAS dtypes");
-}
-
-template <>
-inline void 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 float* alpha,
-                 const float* A, const int lda, float* B, const int ldb) {
-  cblas_strmm(order, side, uplo, ta, diag, m, n, *alpha, A, lda, B, ldb);
-}
-
-template <>
-inline void 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 double* alpha,
-                 const double* A, const int lda, double* B, const int ldb) {
-  cblas_dtrmm(order, side, uplo, ta, diag, m, n, *alpha, A, lda, B, ldb);
-}
-
-template <>
-inline void 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 Complex64* alpha,
-                 const Complex64* A, const int lda, Complex64* B, const int ldb) {
-  cblas_ctrmm(order, side, uplo, ta, diag, m, n, alpha, A, lda, B, ldb);
-}
-
-template <>
-inline void 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 Complex128* alpha,
-                 const Complex128* A, const int lda, Complex128* B, const int ldb) {
-  cblas_ztrmm(order, side, uplo, ta, diag, m, n, alpha, A, lda, B, ldb);
-}
-
-
-
 // Yale: numeric matrix multiply c=a*b
 template <typename DType>
 inline void numbmm(const unsigned int n, const unsigned int m, const unsigned int l, const IType* ia, const IType* ja, const DType* a, const bool diaga,
@@ -502,74 +409,6 @@ inline void smmp_sort_columns(const size_t n, const IType* ia, IType* ja, DType*
 }
 
 
-/*
- * From ATLAS 3.8.0:
- *
- * Computes one of two LU factorizations based on the setting of the Order
- * parameter, as follows:
- * ----------------------------------------------------------------------------
- *                       Order == CblasColMajor
- * Column-major factorization of form
- *   A = P * L * U
- * where P is a row-permutation matrix, L is lower triangular with unit
- * diagonal elements (lower trapazoidal if M > N), and U is upper triangular
- * (upper trapazoidal if M < N).
- *
- * ----------------------------------------------------------------------------
- *                       Order == CblasRowMajor
- * Row-major factorization of form
- *   A = P * L * U
- * where P is a column-permutation matrix, L is lower triangular (lower
- * trapazoidal if M > N), and U is upper triangular with unit diagonals (upper
- * trapazoidal if M < N).
- *
- * ============================================================================
- * Let IERR be the return value of the function:
- *    If IERR == 0, successful exit.
- *    If (IERR < 0) the -IERR argument had an illegal value
- *    If (IERR > 0 && Order == CblasColMajor)
- *       U(i-1,i-1) is exactly zero.  The factorization has been completed,
- *       but the factor U is exactly singular, and division by zero will
- *       occur if it is used to solve a system of equations.
- *    If (IERR > 0 && Order == CblasRowMajor)
- *       L(i-1,i-1) is exactly zero.  The factorization has been completed,
- *       but the factor L is exactly singular, and division by zero will
- *       occur if it is used to solve a system of equations.
- */
-template <typename DType>
-inline int potrf(const enum CBLAS_ORDER order, const enum CBLAS_UPLO uplo, const int N, DType* A, const int lda) {
-#if defined HAVE_CLAPACK_H || defined HAVE_ATLAS_CLAPACK_H
-  rb_raise(rb_eNotImpError, "not yet implemented for non-BLAS dtypes");
-#else
-  rb_raise(rb_eNotImpError, "only CLAPACK version implemented thus far");
-#endif
-  return 0;
-}
-
-#if defined HAVE_CLAPACK_H || defined HAVE_ATLAS_CLAPACK_H
-template <>
-inline int potrf(const enum CBLAS_ORDER order, const enum CBLAS_UPLO uplo, const int N, float* A, const int lda) {
-  return clapack_spotrf(order, uplo, N, A, lda);
-}
-
-template <>
-inline int potrf(const enum CBLAS_ORDER order, const enum CBLAS_UPLO uplo, const int N, double* A, const int lda) {
-  return clapack_dpotrf(order, uplo, N, A, lda);
-}
-
-template <>
-inline int potrf(const enum CBLAS_ORDER order, const enum CBLAS_UPLO uplo, const int N, Complex64* A, const int lda) {
-  return clapack_cpotrf(order, uplo, N, reinterpret_cast<void*>(A), lda);
-}
-
-template <>
-inline int potrf(const enum CBLAS_ORDER order, const enum CBLAS_UPLO uplo, const int N, Complex128* A, const int lda) {
-  return clapack_zpotrf(order, uplo, N, reinterpret_cast<void*>(A), lda);
-}
-#endif
-
-
-
 // Copies an upper row-major array from U, zeroing U; U is unit, so diagonal is not copied.
 //
 // From ATLAS 3.8.0.
@@ -875,110 +714,6 @@ int getri(const int N, DType* A, const int lda, const int* ipiv, DType* wrk, con
 }
 */
 
-
-
-template <bool is_complex, typename DType>
-inline void lauum(const enum CBLAS_ORDER order, const enum CBLAS_UPLO uplo, const int N, DType* A, const int lda) {
-
-  int Nleft, Nright;
-  const DType ONE = 1;
-  DType *G, *U0 = A, *U1;
-
-  if (N > 1) {
-    Nleft = N >> 1;
-    #ifdef NB
-      if (Nleft > NB) Nleft = ATL_MulByNB(ATL_DivByNB(Nleft));
-    #endif
-
-    Nright = N - Nleft;
-
-    // FIXME: There's a simpler way to write this next block, but I'm way too tired to work it out right now.
-    if (uplo == CblasUpper) {
-      if (order == CblasRowMajor) {
-        G = A + Nleft;
-        U1 = G + Nleft * lda;
-      } else {
-        G = A + Nleft * lda;
-        U1 = G + Nleft;
-      }
-    } else {
-      if (order == CblasRowMajor) {
-        G = A + Nleft * lda;
-        U1 = G + Nleft;
-      } else {
-        G = A + Nleft;
-        U1 = G + Nleft * lda;
-      }
-    }
-
-    lauum<is_complex, DType>(order, uplo, Nleft, U0, lda);
-
-    if (is_complex) {
-
-      nm::math::herk<DType>(order, uplo,
-                            uplo == CblasLower ? CblasConjTrans : CblasNoTrans,
-                            Nleft, Nright, &ONE, G, lda, &ONE, U0, lda);
-
-      nm::math::trmm<DType>(order, CblasLeft, uplo, CblasConjTrans, CblasNonUnit, Nright, Nleft, &ONE, U1, lda, G, lda);
-    } else {
-      nm::math::syrk<DType>(order, uplo,
-                            uplo == CblasLower ? CblasTrans : CblasNoTrans,
-                            Nleft, Nright, &ONE, G, lda, &ONE, U0, lda);
-
-      nm::math::trmm<DType>(order, CblasLeft, uplo, CblasTrans, CblasNonUnit, Nright, Nleft, &ONE, U1, lda, G, lda);
-    }
-    lauum<is_complex, DType>(order, uplo, Nright, U1, lda);
-
-  } else {
-    *A = *A * *A;
-  }
-}
-
-
-#if defined HAVE_CLAPACK_H || defined HAVE_ATLAS_CLAPACK_H
-template <bool is_complex>
-inline void lauum(const enum CBLAS_ORDER order, const enum CBLAS_UPLO uplo, const int N, float* A, const int lda) {
-  clapack_slauum(order, uplo, N, A, lda);
-}
-
-template <bool is_complex>
-inline void lauum(const enum CBLAS_ORDER order, const enum CBLAS_UPLO uplo, const int N, double* A, const int lda) {
-  clapack_dlauum(order, uplo, N, A, lda);
-}
-
-template <bool is_complex>
-inline void lauum(const enum CBLAS_ORDER order, const enum CBLAS_UPLO uplo, const int N, Complex64* A, const int lda) {
-  clapack_clauum(order, uplo, N, A, lda);
-}
-
-template <bool is_complex>
-inline void lauum(const enum CBLAS_ORDER order, const enum CBLAS_UPLO uplo, const int N, Complex128* A, const int lda) {
-  clapack_zlauum(order, uplo, N, A, lda);
-}
-#endif
-
-
-/*
-* Function signature conversion for calling LAPACK's lauum functions as directly as possible.
-*
-* For documentation: http://www.netlib.org/lapack/double/dlauum.f
-*
-* This function should normally go in math.cpp, but we need it to be available to nmatrix.cpp.
-*/
-template <bool is_complex, typename DType>
-inline int clapack_lauum(const enum CBLAS_ORDER order, const enum CBLAS_UPLO uplo, const int n, void* a, const int lda) {
-  if (n < 0)              rb_raise(rb_eArgError, "n cannot be less than zero, is set to %d", n);
-  if (lda < n || lda < 1) rb_raise(rb_eArgError, "lda must be >= max(n,1); lda=%d, n=%d\n", lda, n);
-
-  if (uplo == CblasUpper) lauum<is_complex, DType>(order, uplo, n, reinterpret_cast<DType*>(a), lda);
-  else                    lauum<is_complex, DType>(order, uplo, n, reinterpret_cast<DType*>(a), lda);
-
-  return 0;
-}
-
-
-
-
 /*
  * Macro for declaring LAPACK specializations of the getrf function.
  *
@@ -1003,67 +738,6 @@ LAPACK_GETRF(Complex64,  clapack_cgetrf, void)
 LAPACK_GETRF(Complex128, clapack_zgetrf, void)
 */
 
-
-
-/*
-* Function signature conversion for calling LAPACK's potrf functions as directly as possible.
-*
-* For documentation: http://www.netlib.org/lapack/double/dpotrf.f
-*
-* This function should normally go in math.cpp, but we need it to be available to nmatrix.cpp.
-*/
-template <typename DType>
-inline int clapack_potrf(const enum CBLAS_ORDER order, const enum CBLAS_UPLO uplo, const int n, void* a, const int lda) {
-  return potrf<DType>(order, uplo, n, reinterpret_cast<DType*>(a), lda);
-}
-
-
-
-template <typename DType>
-inline int potri(const enum CBLAS_ORDER order, const enum CBLAS_UPLO uplo, const int n, DType* a, const int lda) {
-  rb_raise(rb_eNotImpError, "potri not yet implemented for non-BLAS dtypes");
-  return 0;
-}
-
-
-#if defined HAVE_CLAPACK_H || defined HAVE_ATLAS_CLAPACK_H
-template <>
-inline int potri(const enum CBLAS_ORDER order, const enum CBLAS_UPLO uplo, const int n, float* a, const int lda) {
-  return clapack_spotri(order, uplo, n, a, lda);
-}
-
-template <>
-inline int potri(const enum CBLAS_ORDER order, const enum CBLAS_UPLO uplo, const int n, double* a, const int lda) {
-  return clapack_dpotri(order, uplo, n, a, lda);
-}
-
-template <>
-inline int potri(const enum CBLAS_ORDER order, const enum CBLAS_UPLO uplo, const int n, Complex64* a, const int lda) {
-  return clapack_cpotri(order, uplo, n, reinterpret_cast<void*>(a), lda);
-}
-
-template <>
-inline int potri(const enum CBLAS_ORDER order, const enum CBLAS_UPLO uplo, const int n, Complex128* a, const int lda) {
-  return clapack_zpotri(order, uplo, n, reinterpret_cast<void*>(a), lda);
-}
-#endif
-
-
-/*
- * Function signature conversion for calling LAPACK's potri functions as directly as possible.
- *
- * For documentation: http://www.netlib.org/lapack/double/dpotri.f
- *
- * This function should normally go in math.cpp, but we need it to be available to nmatrix.cpp.
- */
-template <typename DType>
-inline int clapack_potri(const enum CBLAS_ORDER order, const enum CBLAS_UPLO uplo, const int n, void* a, const int lda) {
-  return potri<DType>(order, uplo, n, reinterpret_cast<DType*>(a), lda);
-}
-
-
-
-
 }} // end namespace nm::math