pnmatrix 1.2.4

data/ext/nmatrix/math/getrs.h

@@ -0,0 +1,121 @@
+/////////////////////////////////////////////////////////////////////
+// = 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
+//
+// == getrs.h
+//
+// getrs function in native C++.
+//
+
+/*
+ *             Automatically Tuned Linear Algebra Software v3.8.4
+ *                    (C) Copyright 1999 R. Clint Whaley
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *   1. Redistributions of source code must retain the above copyright
+ *      notice, this list of conditions and the following disclaimer.
+ *   2. Redistributions in binary form must reproduce the above copyright
+ *      notice, this list of conditions, and the following disclaimer in the
+ *      documentation and/or other materials provided with the distribution.
+ *   3. The name of the ATLAS group or the names of its contributers may
+ *      not be used to endorse or promote products derived from this
+ *      software without specific written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE ATLAS GROUP OR ITS CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef GETRS_H
+#define GETRS_H
+
+namespace nm { namespace math {
+
+
+/*
+ * Solves a system of linear equations A*X = B with a general NxN matrix A using the LU factorization computed by GETRF.
+ *
+ * From ATLAS 3.8.0.
+ */
+template <typename DType>
+int getrs(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE Trans, const int N, const int NRHS, const DType* A,
+           const int lda, const int* ipiv, DType* B, const int ldb)
+{
+  // enum CBLAS_DIAG Lunit, Uunit; // These aren't used. Not sure why they're declared in ATLAS' src.
+
+  if (!N || !NRHS) return 0;
+
+  const DType ONE = 1;
+
+  if (Order == CblasColMajor) {
+    if (Trans == CblasNoTrans) {
+      nm::math::laswp<DType>(NRHS, B, ldb, 0, N, ipiv, 1);
+      nm::math::trsm<DType>(Order, CblasLeft, CblasLower, CblasNoTrans, CblasUnit, N, NRHS, ONE, A, lda, B, ldb);
+      nm::math::trsm<DType>(Order, CblasLeft, CblasUpper, CblasNoTrans, CblasNonUnit, N, NRHS, ONE, A, lda, B, ldb);
+    } else {
+      nm::math::trsm<DType>(Order, CblasLeft, CblasUpper, Trans, CblasNonUnit, N, NRHS, ONE, A, lda, B, ldb);
+      nm::math::trsm<DType>(Order, CblasLeft, CblasLower, Trans, CblasUnit, N, NRHS, ONE, A, lda, B, ldb);
+      nm::math::laswp<DType>(NRHS, B, ldb, 0, N, ipiv, -1);
+    }
+  } else {
+    if (Trans == CblasNoTrans) {
+      nm::math::trsm<DType>(Order, CblasRight, CblasLower, CblasTrans, CblasNonUnit, NRHS, N, ONE, A, lda, B, ldb);
+      nm::math::trsm<DType>(Order, CblasRight, CblasUpper, CblasTrans, CblasUnit, NRHS, N, ONE, A, lda, B, ldb);
+      nm::math::laswp<DType>(NRHS, B, ldb, 0, N, ipiv, -1);
+    } else {
+      nm::math::laswp<DType>(NRHS, B, ldb, 0, N, ipiv, 1);
+      nm::math::trsm<DType>(Order, CblasRight, CblasUpper, CblasNoTrans, CblasUnit, NRHS, N, ONE, A, lda, B, ldb);
+      nm::math::trsm<DType>(Order, CblasRight, CblasLower, CblasNoTrans, CblasNonUnit, NRHS, N, ONE, A, lda, B, ldb);
+    }
+  }
+  return 0;
+}
+
+
+/*
+* Function signature conversion for calling LAPACK's getrs functions as directly as possible.
+*
+* For documentation: http://www.netlib.org/lapack/double/dgetrs.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_getrs(const enum CBLAS_ORDER order, const enum CBLAS_TRANSPOSE trans, const int n, const int nrhs,
+                         const void* a, const int lda, const int* ipiv, void* b, const int ldb) {
+  return getrs<DType>(order, trans, n, nrhs, reinterpret_cast<const DType*>(a), lda, ipiv, reinterpret_cast<DType*>(b), ldb);
+}
+
+
+} } // end nm::math
+
+#endif // GETRS_H

data/ext/nmatrix/math/imax.h

@@ -0,0 +1,82 @@
+/////////////////////////////////////////////////////////////////////
+// = 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 - present, Ruby Science Foundation
+// NMatrix is Copyright (c) 2012 - present, 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
+//
+// == imax.h
+//
+// BLAS level 1 function imax.
+//
+
+#ifndef IMAX_H
+#define IMAX_H
+
+#include "math/magnitude.h"
+
+namespace nm { namespace math {
+
+
+template<typename DType>
+inline int imax(const int n, const DType *x, const int incx) {
+
+  if (n < 1 || incx <= 0) {
+    return -1;
+  }
+  if (n == 1) {
+    return 0;
+  }
+
+  typename MagnitudeDType<DType>::type dmax;
+  int imax = 0;
+
+  if (incx == 1) { // if incrementing by 1
+
+    dmax = magnitude(x[0]);
+
+    for (int i = 1; i < n; ++i) {
+      if (magnitude(x[i]) > dmax) {
+        imax = i;
+        dmax = magnitude(x[i]);
+      }
+    }
+
+  } else { // if incrementing by more than 1
+
+    dmax = magnitude(x[0]);
+
+    for (int i = 1, ix = incx; i < n; ++i, ix += incx) {
+      if (magnitude(x[ix]) > dmax) {
+        imax = i;
+        dmax = magnitude(x[ix]);
+      }
+    }
+  }
+  return imax;
+}
+
+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);
+}
+
+}} // end of namespace nm::math
+
+#endif /* IMAX_H */

data/ext/nmatrix/math/laswp.h

@@ -0,0 +1,165 @@
+/////////////////////////////////////////////////////////////////////
+// = 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
+//
+// == laswp.h
+//
+// laswp function in native C++.
+//
+/*
+ *             Automatically Tuned Linear Algebra Software v3.8.4
+ *                    (C) Copyright 1999 R. Clint Whaley
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *   1. Redistributions of source code must retain the above copyright
+ *      notice, this list of conditions and the following disclaimer.
+ *   2. Redistributions in binary form must reproduce the above copyright
+ *      notice, this list of conditions, and the following disclaimer in the
+ *      documentation and/or other materials provided with the distribution.
+ *   3. The name of the ATLAS group or the names of its contributers may
+ *      not be used to endorse or promote products derived from this
+ *      software without specific written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE ATLAS GROUP OR ITS CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef LASWP_H
+#define LASWP_H
+
+namespace nm { namespace math {
+
+
+/*
+ * ATLAS function which performs row interchanges on a general rectangular matrix. Modeled after the LAPACK LASWP function.
+ *
+ * This version is templated for use by template <> getrf().
+ */
+template <typename DType>
+inline void laswp(const int N, DType* A, const int lda, const int K1, const int K2, const int *piv, const int inci) {
+  //const int n = K2 - K1; // not sure why this is declared. commented it out because it's unused.
+
+  int nb = N >> 5;
+
+  const int mr = N - (nb<<5);
+  const int incA = lda << 5;
+
+  if (K2 < K1) return;
+
+  int i1, i2;
+  if (inci < 0) {
+    piv -= (K2-1) * inci;
+    i1 = K2 - 1;
+    i2 = K1;
+  } else {
+    piv += K1 * inci;
+    i1 = K1;
+    i2 = K2-1;
+  }
+
+  if (nb) {
+
+    do {
+      const int* ipiv = piv;
+      int i           = i1;
+      int KeepOn;
+
+      do {
+        int ip = *ipiv; ipiv += inci;
+
+        if (ip != i) {
+          DType *a0 = &(A[i]),
+                *a1 = &(A[ip]);
+
+          for (int h = 32; h; h--) {
+            DType r   = *a0;
+            *a0       = *a1;
+            *a1       = r;
+
+            a0 += lda;
+            a1 += lda;
+          }
+
+        }
+        if (inci > 0) KeepOn = (++i <= i2);
+        else          KeepOn = (--i >= i2);
+
+      } while (KeepOn);
+      A += incA;
+    } while (--nb);
+  }
+
+  if (mr) {
+    const int* ipiv = piv;
+    int i           = i1;
+    int KeepOn;
+
+    do {
+      int ip = *ipiv; ipiv += inci;
+      if (ip != i) {
+        DType *a0 = &(A[i]),
+              *a1 = &(A[ip]);
+
+        for (int h = mr; h; h--) {
+          DType r   = *a0;
+          *a0       = *a1;
+          *a1       = r;
+
+          a0 += lda;
+          a1 += lda;
+        }
+      }
+
+      if (inci > 0) KeepOn = (++i <= i2);
+      else          KeepOn = (--i >= i2);
+
+    } while (KeepOn);
+  }
+}
+
+
+/*
+* Function signature conversion for calling LAPACK's laswp functions as directly as possible.
+*
+* For documentation: http://www.netlib.org/lapack/double/dlaswp.f
+*
+* This function should normally go in math.cpp, but we need it to be available to nmatrix.cpp.
+*/
+template <typename DType>
+inline void clapack_laswp(const int n, void* a, const int lda, const int k1, const int k2, const int* ipiv, const int incx) {
+  laswp<DType>(n, reinterpret_cast<DType*>(a), lda, k1, k2, ipiv, incx);
+}
+
+} }  // namespace nm::math
+#endif // LASWP_H

data/ext/nmatrix/math/long_dtype.h

@@ -0,0 +1,62 @@
+/////////////////////////////////////////////////////////////////////
+// = 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 - present, Ruby Science Foundation
+// NMatrix is Copyright (c) 2012 - present, 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
+//
+// == long_dtype.h
+//
+// Declarations necessary for the native versions of GEMM and GEMV,
+// as well as for IMAX.
+//
+
+#ifndef LONG_DTYPE_H
+#define LONG_DTYPE_H
+
+namespace nm { namespace math {
+  // These allow an increase in precision for intermediate values of gemm and gemv.
+  // See also: http://stackoverflow.com/questions/11873694/how-does-one-increase-precision-in-c-templates-in-a-template-typename-dependen
+  template <typename DType> struct LongDType;
+  template <> struct LongDType<uint8_t> { typedef int16_t type; };
+  template <> struct LongDType<int8_t> { typedef int16_t type; };
+  template <> struct LongDType<int16_t> { typedef int32_t type; };
+  template <> struct LongDType<int32_t> { typedef int64_t type; };
+  template <> struct LongDType<int64_t> { typedef int64_t type; };
+  template <> struct LongDType<float> { typedef double type; };
+  template <> struct LongDType<double> { typedef double type; };
+  template <> struct LongDType<Complex64> { typedef Complex128 type; };
+  template <> struct LongDType<Complex128> { typedef Complex128 type; };
+  template <> struct LongDType<RubyObject> { typedef RubyObject type; };
+
+  template <typename DType> struct MagnitudeDType;
+  template <> struct MagnitudeDType<uint8_t> { typedef uint8_t type; };
+  template <> struct MagnitudeDType<int8_t> { typedef int8_t type; };
+  template <> struct MagnitudeDType<int16_t> { typedef int16_t type; };
+  template <> struct MagnitudeDType<int32_t> { typedef int32_t type; };
+  template <> struct MagnitudeDType<int64_t> { typedef int64_t type; };
+  template <> struct MagnitudeDType<float> { typedef float type; };
+  template <> struct MagnitudeDType<double> { typedef double type; };
+  template <> struct MagnitudeDType<Complex64> { typedef float type; };
+  template <> struct MagnitudeDType<Complex128> { typedef double type; };
+  template <> struct MagnitudeDType<RubyObject> { typedef RubyObject type; };
+  
+}} // end of namespace nm::math
+
+#endif

data/ext/nmatrix/math/magnitude.h

@@ -0,0 +1,54 @@
+/////////////////////////////////////////////////////////////////////
+// = 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 - present, Ruby Science Foundation
+// NMatrix is Copyright (c) 2012 - present, 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
+//
+// == math/magnitude.h
+//
+// Takes the absolute value (meaning magnitude) of each DType.
+// Needed for a variety of BLAS/LAPACK functions.
+//
+
+#ifndef MAGNITUDE_H
+#define MAGNITUDE_H
+
+#include "math/long_dtype.h"
+
+namespace nm { namespace math {
+
+/* Magnitude -- may be complicated for unsigned types, and need to call the correct STL abs for floats/doubles */ 
+template <typename DType, typename MDType = typename MagnitudeDType<DType>::type>
+inline MDType magnitude(const DType& v) {
+  return v.abs();
+}
+template <> inline float magnitude(const float& v) { return std::abs(v); }
+template <> inline double magnitude(const double& v) { return std::abs(v); }
+template <> inline uint8_t magnitude(const uint8_t& v) { return v; }
+template <> inline int8_t magnitude(const int8_t& v) { return std::abs(v); }
+template <> inline int16_t magnitude(const int16_t& v) { return std::abs(v); }
+template <> inline int32_t magnitude(const int32_t& v) { return std::abs(v); }
+template <> inline int64_t magnitude(const int64_t& v) { return std::abs(v); }
+template <> inline float magnitude(const nm::Complex64& v) { return std::sqrt(v.r * v.r + v.i * v.i); }
+template <> inline double magnitude(const nm::Complex128& v) { return std::sqrt(v.r * v.r + v.i * v.i); } 
+    
+}}
+
+#endif // MAGNITUDE_H