nmatrix-gemv 0.0.3

data/ext/nmatrix_gemv/math/gemv.h

@@ -0,0 +1,212 @@
+/////////////////////////////////////////////////////////////////////
+// = NMatrix
+//
+// A linear algebra library for scientific computation in Ruby.
+// NMatrix is part of SciRuby.
+//
+// NMatrix was originally inspired by and derived from NArray, by
+// Masahiro Tanaka: http://narray.rubyforge.org
+//
+// == Copyright Information
+//
+// SciRuby is Copyright (c) 2010 - 2014, Ruby Science Foundation
+// NMatrix is Copyright (c) 2012 - 2014, John Woods and the Ruby Science Foundation
+//
+// Please see LICENSE.txt for additional copyright notices.
+//
+// == Contributing
+//
+// By contributing source code to SciRuby, you agree to be bound by
+// our Contributor Agreement:
+//
+// * https://github.com/SciRuby/sciruby/wiki/Contributor-Agreement
+//
+// == gemv.h
+//
+// Header file for interface with ATLAS's CBLAS gemv functions and
+// native templated version of LAPACK's gemv function.
+//
+
+#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
+}
+
+
+namespace nm { namespace math {
+
+/*
+ * GEneral Matrix-Vector multiplication: based on dgemv.f from Netlib.
+ *
+ * This is an extremely inefficient algorithm. Recommend using ATLAS' version instead.
+ *
+ * Template parameters: LT -- long version of type T. Type T is the matrix dtype.
+ */
+template <typename DType>
+inline bool gemv(const enum CBLAS_TRANSPOSE Trans, const int M, const int N, const DType* alpha, const DType* A, const int lda,
+          const DType* X, const int incX, const DType* beta, DType* Y, const int incY) {
+  int lenX, lenY, i, j;
+  int kx, ky, iy, jx, jy, ix;
+
+  typename LongDType<DType>::type temp;
+
+  // Test the input parameters
+  if (Trans < 111 || Trans > 113) {
+    rb_raise(rb_eArgError, "GEMV: TransA must be CblasNoTrans, CblasTrans, or CblasConjTrans");
+    return false;
+  } else if (lda < std::max(1, N)) {
+    fprintf(stderr, "GEMV: N = %d; got lda=%d", N, lda);
+    rb_raise(rb_eArgError, "GEMV: Expected lda >= max(1, N)");
+    return false;
+  } else if (incX == 0) {
+    rb_raise(rb_eArgError, "GEMV: Expected incX != 0\n");
+    return false;
+  } else if (incY == 0) {
+    rb_raise(rb_eArgError, "GEMV: Expected incY != 0\n");
+    return false;
+  }
+
+  // Quick return if possible
+  if (!M or !N or (*alpha == 0 and *beta == 1)) return true;
+
+  if (Trans == CblasNoTrans) {
+    lenX = N;
+    lenY = M;
+  } else {
+    lenX = M;
+    lenY = N;
+  }
+
+  if (incX > 0) kx = 0;
+  else          kx = (lenX - 1) * -incX;
+
+  if (incY > 0) ky = 0;
+  else          ky =  (lenY - 1) * -incY;
+
+  // Start the operations. In this version, the elements of A are accessed sequentially with one pass through A.
+  if (*beta != 1) {
+    if (incY == 1) {
+      if (*beta == 0) {
+        for (i = 0; i < lenY; ++i) {
+          Y[i] = 0;
+        }
+      } else {
+        for (i = 0; i < lenY; ++i) {
+          Y[i] *= *beta;
+        }
+      }
+    } else {
+      iy = ky;
+      if (*beta == 0) {
+        for (i = 0; i < lenY; ++i) {
+          Y[iy] = 0;
+          iy += incY;
+        }
+      } else {
+        for (i = 0; i < lenY; ++i) {
+          Y[iy] *= *beta;
+          iy += incY;
+        }
+      }
+    }
+  }
+
+  if (*alpha == 0) return false;
+
+  if (Trans == CblasNoTrans) {
+
+    // Form  y := alpha*A*x + y.
+    jx = kx;
+    if (incY == 1) {
+      for (j = 0; j < N; ++j) {
+        if (X[jx] != 0) {
+          temp = *alpha * X[jx];
+          for (i = 0; i < M; ++i) {
+            Y[i] += A[j+i*lda] * temp;
+          }
+        }
+        jx += incX;
+      }
+    } else {
+      for (j = 0; j < N; ++j) {
+        if (X[jx] != 0) {
+          temp = *alpha * X[jx];
+          iy = ky;
+          for (i = 0; i < M; ++i) {
+            Y[iy] += A[j+i*lda] * temp;
+            iy += incY;
+          }
+        }
+        jx += incX;
+      }
+    }
+
+  } else { // TODO: Check that indices are correct! They're switched for C.
+
+    // Form  y := alpha*A**DType*x + y.
+    jy = ky;
+
+    if (incX == 1) {
+      for (j = 0; j < N; ++j) {
+        temp = 0;
+        for (i = 0; i < M; ++i) {
+          temp += A[j+i*lda]*X[j];
+        }
+        Y[jy] += *alpha * temp;
+        jy += incY;
+      }
+    } else {
+      for (j = 0; j < N; ++j) {
+        temp = 0;
+        ix = kx;
+        for (i = 0; i < M; ++i) {
+          temp += A[j+i*lda] * X[ix];
+          ix += incX;
+        }
+
+        Y[jy] += *alpha * temp;
+        jy += incY;
+      }
+    }
+  }
+
+  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
+
+#endif // GEMM_H

data/ext/nmatrix_gemv/math/ger.h

@@ -0,0 +1,96 @@
+/////////////////////////////////////////////////////////////////////
+// = NMatrix
+//
+// A linear algebra library for scientific computation in Ruby.
+// NMatrix is part of SciRuby.
+//
+// NMatrix was originally inspired by and derived from NArray, by
+// Masahiro Tanaka: http://narray.rubyforge.org
+//
+// == Copyright Information
+//
+// SciRuby is Copyright (c) 2010 - 2014, Ruby Science Foundation
+// NMatrix is Copyright (c) 2012 - 2014, John Woods and the Ruby Science Foundation
+//
+// Please see LICENSE.txt for additional copyright notices.
+//
+// == Contributing
+//
+// By contributing source code to SciRuby, you agree to be bound by
+// our Contributor Agreement:
+//
+// * https://github.com/SciRuby/sciruby/wiki/Contributor-Agreement
+//
+// == ger.h
+//
+// BLAS level-2 ger function in native C++.
+//
+
+#ifndef GER_H
+#define GER_H
+
+namespace nm { namespace math {
+
+template <typename DType>
+inline int ger(int m, int n, DType alpha, DType* x, int incx, DType* y, int incy, DType* a, int lda) {
+
+  // FIXME: Call BLAS ger if available
+
+  if (m < 0) {
+    return 1;
+  } else if (n < 0) {
+    return 2;
+  } else if (incx == 0) {
+    return 5;
+  } else if (incy == 0) {
+    return 7;
+  } else if (lda < std::max(1,m)) {
+    return 9;
+  }
+
+  if (m == 0 || n == 0 || alpha == 0) return 0; /* Quick return if possible. */
+
+  /*     Start the operations. In this version the elements of A are */
+  /*     accessed sequentially with one pass through A. */
+
+  // FIXME: These have been unrolled in a way that the compiler can handle. Collapse into a single case, or optimize
+  // FIXME: in a more modern way.
+
+  int jy = incy > 0 ? 0 :  -(n-1) * incy;
+
+  if (incx == 1) {
+
+	  for (size_t j = 0; j < n; ++j, jy += incy) {
+	    if (y[jy] != 0) {
+		    DType temp = alpha * y[jy];
+		    for (size_t i = 0; i < m; ++i) {
+		      a[i + j * lda] += x[i] * temp;
+		    }
+	    }
+	  }
+
+  } else {
+
+    int kx = incx > 0 ? 0 : -(m-1) * incx;
+
+	  for (size_t j = 0; j < n; ++j, jy += incy) {
+	    if (y[jy] != 0) {
+    		DType temp = alpha * y[jy];
+
+    		for (size_t i = 0, ix = kx; i < m; ++i, ix += incx) {
+          a[i + j * lda] += x[ix] * temp;
+    		}
+	    }
+	  }
+
+  }
+
+  return 0;
+
+/*     End of DGER  . */
+
+} /* dger_ */
+
+}} // end nm::math
+
+#endif // GER_H

data/ext/nmatrix_gemv/math/gesdd.h

@@ -0,0 +1,80 @@
+/////////////////////////////////////////////////////////////////////
+// = NMatrix
+//
+// A linear algebra library for scientific computation in Ruby.
+// NMatrix is part of SciRuby.
+//
+// NMatrix was originally inspired by and derived from NArray, by
+// Masahiro Tanaka: http://narray.rubyforge.org
+//
+// == Copyright Information
+//
+// SciRuby is Copyright (c) 2010 - 2014, Ruby Science Foundation
+// NMatrix is Copyright (c) 2012 - 2014, John Woods and the Ruby Science Foundation
+//
+// Please see LICENSE.txt for additional copyright notices.
+//
+// == Contributing
+//
+// By contributing source code to SciRuby, you agree to be bound by
+// our Contributor Agreement:
+//
+// * https://github.com/SciRuby/sciruby/wiki/Contributor-Agreement
+//
+// == gesdd.h
+//
+// Header file for interface with LAPACK's xGESDD functions.
+//
+
+#ifndef GESDD_H
+# define GESDD_H
+
+extern "C" {
+
+  void sgesdd_(char*, int*, int*, float*, int*, float*, float*, int*, float*, int*, float*, int*, int*, int*);
+  void dgesdd_(char*, int*, int*, double*, int*, double*, double*, int*, double*, int*, double*, int*, int*, int*);
+  void cgesdd_(char*, int*, int*, nm::Complex64*, int*, nm::Complex64*, nm::Complex64*, int*, nm::Complex64*, int*, nm::Complex64*, int*, float*, int*, int*);
+  void zgesdd_(char*, int*, int*, nm::Complex128*, int*, nm::Complex128*, nm::Complex128*, int*, nm::Complex128*, int*, nm::Complex128*, int*, double*, int*, int*);
+}
+
+namespace nm {
+  namespace math {
+
+    template <typename DType, typename CType>
+    inline int gesdd(char jobz, int m, int n, DType* a, int lda, DType* s, DType* u, int ldu, DType* vt, int ldvt, DType* work, int lwork, int* iwork, CType* rwork) {
+      rb_raise(rb_eNotImpError, "not yet implemented for non-BLAS dtypes");
+      return -1;
+    }
+
+    template <>
+    inline int gesdd(char jobz, int m, int n, float* a, int lda, float* s, float* u, int ldu, float* vt, int ldvt, float* work, int lwork, int* iwork, float* rwork) {
+      int info;
+      sgesdd_(&jobz, &m, &n, a, &lda, s, u, &ldu, vt, &ldvt, work, &lwork, iwork, &info);
+      return info;
+    }
+
+    template <>
+    inline int gesdd(char jobz, int m, int n, double* a, int lda, double* s, double* u, int ldu, double* vt, int ldvt, double* work, int lwork, int* iwork, double* rwork) {
+      int info;
+      dgesdd_(&jobz, &m, &n, a, &lda, s, u, &ldu, vt, &ldvt, work, &lwork, iwork, &info);
+      return info;
+    }
+
+    template <>
+    inline int gesdd(char jobz, int m, int n, nm::Complex64* a, int lda, nm::Complex64* s, nm::Complex64* u, int ldu, nm::Complex64* vt, int ldvt, nm::Complex64* work, int lwork, int* iwork, float* rwork) {
+      int info;
+      cgesdd_(&jobz, &m, &n, a, &lda, s, u, &ldu, vt, &ldvt, work, &lwork, rwork, iwork, &info);
+      return info;
+    }
+
+    template <>
+    inline int gesdd(char jobz, int m, int n, nm::Complex128* a, int lda, nm::Complex128* s, nm::Complex128* u, int ldu, nm::Complex128* vt, int ldvt, nm::Complex128* work, int lwork, int* iwork, double* rwork) {
+      int info;
+      zgesdd_(&jobz, &m, &n, a, &lda, s, u, &ldu, vt, &ldvt, work, &lwork, rwork, iwork, &info);
+      return info;
+    }
+
+  } // end of namespace math
+} // end of namespace nm
+
+#endif // GESDD_H

data/ext/nmatrix_gemv/math/gesvd.h

@@ -0,0 +1,78 @@
+/////////////////////////////////////////////////////////////////////
+// = NMatrix
+//
+// A linear algebra library for scientific computation in Ruby.
+// NMatrix is part of SciRuby.
+//
+// NMatrix was originally inspired by and derived from NArray, by
+// Masahiro Tanaka: http://narray.rubyforge.org
+//
+// == Copyright Information
+//
+// SciRuby is Copyright (c) 2010 - 2014, Ruby Science Foundation
+// NMatrix is Copyright (c) 2012 - 2014, John Woods and the Ruby Science Foundation
+//
+// Please see LICENSE.txt for additional copyright notices.
+//
+// == Contributing
+//
+// By contributing source code to SciRuby, you agree to be bound by
+// our Contributor Agreement:
+//
+// * https://github.com/SciRuby/sciruby/wiki/Contributor-Agreement
+//
+// == gesvd.h
+//
+// Header file for interface with LAPACK's xGESVD functions.
+//
+
+#ifndef GESVD_H
+# define GESVD_H
+
+extern "C" {
+  void sgesvd_(char*, char*, int*, int*, float*, int*, float*, float*, int*, float*, int*, float*, int*, int*);
+  void dgesvd_(char*, char*, int*, int*, double*, int*, double*, double*, int*, double*, int*, double*, int*, int*);
+  void cgesvd_(char*, char*, int*, int*, nm::Complex64*, int*, nm::Complex64*, nm::Complex64*, int*, nm::Complex64*, int*, nm::Complex64*, int*, float*, int*);
+  void zgesvd_(char*, char*, int*, int*, nm::Complex128*, int*, nm::Complex128*, nm::Complex128*, int*, nm::Complex128*, int*, nm::Complex128*, int*, double*, int*);
+}
+
+namespace nm {
+  namespace math {
+
+    template <typename DType, typename CType>
+    inline int gesvd(char jobu, char jobvt, int m, int n, DType* a, int lda, DType* s, DType* u, int ldu, DType* vt, int ldvt, DType* work, int lwork, CType* rwork) {
+      rb_raise(rb_eNotImpError, "not yet implemented for non-BLAS dtypes");
+      return -1;
+    }
+
+    template <>
+    inline int gesvd(char jobu, char jobvt, int m, int n, float* a, int lda, float* s, float* u, int ldu, float* vt, int ldvt, float* work, int lwork, float* rwork) {
+      int info;
+      sgesvd_(&jobu, &jobvt, &m, &n, a, &lda, s, u, &ldu, vt, &ldvt, work, &lwork, &info);
+      return info;
+    }
+
+    template <>
+    inline int gesvd(char jobu, char jobvt, int m, int n, double* a, int lda, double* s, double* u, int ldu, double* vt, int ldvt, double* work, int lwork, double* rwork) {
+      int info;
+      dgesvd_(&jobu, &jobvt, &m, &n, a, &lda, s, u, &ldu, vt, &ldvt, work, &lwork, &info);
+      return info;
+    }
+
+    template <>
+    inline int gesvd(char jobu, char jobvt, int m, int n, nm::Complex64* a, int lda, nm::Complex64* s, nm::Complex64* u, int ldu, nm::Complex64* vt, int ldvt, nm::Complex64* work, int lwork, float* rwork) {
+      int info;
+      cgesvd_(&jobu, &jobvt, &m, &n, a, &lda, s, u, &ldu, vt, &ldvt, work, &lwork, rwork, &info);
+      return info;
+    }
+
+    template <>
+    inline int gesvd(char jobu, char jobvt, int m, int n, nm::Complex128* a, int lda, nm::Complex128* s, nm::Complex128* u, int ldu, nm::Complex128* vt, int ldvt, nm::Complex128* work, int lwork, double* rwork) {
+      int info;
+      zgesvd_(&jobu, &jobvt, &m, &n, a, &lda, s, u, &ldu, vt, &ldvt, work, &lwork, rwork, &info);
+      return info;
+    }
+
+  } // end of namespace math
+} // end of namespace nm
+#endif // GESVD_H