nmatrix 0.2.1 → 0.2.3

data/ext/nmatrix/math/getrf.h

@@ -9,8 +9,8 @@
 //
 // == Copyright Information
 //
-// SciRuby is Copyright (c) 2010 - 2014, Ruby Science Foundation
-// NMatrix is Copyright (c) 2012 - 2014, John Woods and the Ruby Science Foundation
+// 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.
 //

data/ext/nmatrix/math/imax.h

@@ -9,8 +9,8 @@
 //
 // == Copyright Information
 //
-// SciRuby is Copyright (c) 2010 - 2014, Ruby Science Foundation
-// NMatrix is Copyright (c) 2012 - 2014, John Woods and the Ruby Science Foundation
+// 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.
 //
@@ -29,8 +29,11 @@
 #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) {
 
@@ -41,28 +44,28 @@ inline int imax(const int n, const DType *x, const int incx) {
     return 0;
   }
 
-  DType dmax;
+  typename MagnitudeDType<DType>::type dmax;
   int imax = 0;
 
   if (incx == 1) { // if incrementing by 1
 
-    dmax = abs(x[0]);
+    dmax = magnitude(x[0]);
 
     for (int i = 1; i < n; ++i) {
-      if (std::abs(x[i]) > dmax) {
+      if (magnitude(x[i]) > dmax) {
         imax = i;
-        dmax = std::abs(x[i]);
+        dmax = magnitude(x[i]);
       }
     }
 
   } else { // if incrementing by more than 1
 
-    dmax = std::abs(x[0]);
+    dmax = magnitude(x[0]);
 
     for (int i = 1, ix = incx; i < n; ++i, ix += incx) {
-      if (std::abs(x[ix]) > dmax) {
+      if (magnitude(x[ix]) > dmax) {
         imax = i;
-        dmax = std::abs(x[ix]);
+        dmax = magnitude(x[ix]);
       }
     }
   }

data/ext/nmatrix/math/laswp.h

@@ -102,7 +102,7 @@ inline void laswp(const int N, DType* A, const int lda, const int K1, const int
           DType *a0 = &(A[i]),
                 *a1 = &(A[ip]);
 
-          for (register int h = 32; h; h--) {
+          for (int h = 32; h; h--) {
             DType r   = *a0;
             *a0       = *a1;
             *a1       = r;
@@ -131,7 +131,7 @@ inline void laswp(const int N, DType* A, const int lda, const int K1, const int
         DType *a0 = &(A[i]),
               *a1 = &(A[ip]);
 
-        for (register int h = mr; h; h--) {
+        for (int h = mr; h; h--) {
           DType r   = *a0;
           *a0       = *a1;
           *a1       = r;
@@ -162,4 +162,4 @@ inline void clapack_laswp(const int n, void* a, const int lda, const int k1, con
 }
 
 } }  // namespace nm::math
-#endif // LASWP_H
+#endif // LASWP_H

data/ext/nmatrix/math/long_dtype.h

@@ -9,8 +9,8 @@
 //
 // == Copyright Information
 //
-// SciRuby is Copyright (c) 2010 - 2014, Ruby Science Foundation
-// NMatrix is Copyright (c) 2012 - 2014, John Woods and the Ruby Science Foundation
+// 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.
 //
@@ -23,7 +23,8 @@
 //
 // == long_dtype.h
 //
-// Declarations necessary for the native versions of GEMM and GEMV.
+// Declarations necessary for the native versions of GEMM and GEMV,
+// as well as for IMAX.
 //
 
 #ifndef LONG_DTYPE_H
@@ -44,6 +45,18 @@ namespace nm { namespace math {
   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

data/ext/nmatrix/math/nrm2.h

@@ -9,8 +9,8 @@
 //
 // == Copyright Information
 //
-// SciRuby is Copyright (c) 2010 - 2014, Ruby Science Foundation
-// NMatrix is Copyright (c) 2012 - 2014, John Woods and the Ruby Science Foundation
+// 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.
 //
@@ -74,8 +74,8 @@ namespace nm { namespace math {
  *    complex64 -> float or double
  *    complex128 -> double
  */
-template <typename ReturnDType, typename DType>
-ReturnDType nrm2(const int N, const DType* X, const int incX) {
+template <typename DType, typename MDType = typename MagnitudeDType<DType>::type>
+MDType nrm2(const int N, const DType* X, const int incX) {
   const DType ONE = 1, ZERO = 0;
   typename LongDType<DType>::type scale = 0, ssq = 1, absxi, temp;
 
@@ -89,13 +89,14 @@ ReturnDType nrm2(const int N, const DType* X, const int incX) {
       temp  = scale / absxi;
       scale = absxi;
       ssq   = ONE + ssq * (temp * temp);
-    } else {
+    }
+    else if(scale != 0) {
       temp = absxi / scale;
       ssq += temp * temp;
     }
   }
 
-  return scale * std::sqrt( ssq );
+  return (MDType)(scale * std::sqrt( ssq ));
 }
 
 
@@ -106,7 +107,8 @@ static inline void nrm2_complex_helper(const FloatDType& xr, const FloatDType& x
     double temp  = scale / absx;
     scale = absx;
     ssq   = 1.0 + ssq * (temp * temp);
-  } else {
+  }
+  else if(scale != 0)  {
     double temp = absx / scale;
     ssq += temp * temp;
   }
@@ -116,7 +118,8 @@ static inline void nrm2_complex_helper(const FloatDType& xr, const FloatDType& x
     double temp  = scale / absx;
     scale = absx;
     ssq   = 1.0 + ssq * (temp * temp);
-  } else {
+  }
+  else if(scale != 0)  {
     double temp = absx / scale;
     ssq += temp * temp;
   }
@@ -124,33 +127,35 @@ static inline void nrm2_complex_helper(const FloatDType& xr, const FloatDType& x
 
 template <>
 float nrm2(const int N, const Complex64* X, const int incX) {
-  double scale = 0, ssq = 1, temp;
+  double scale = 0, ssq = 1;
 
   if ((N < 1) || (incX < 1))    return 0.0;
 
   for (int i = 0; i < N; ++i) {
-    nrm2_complex_helper<float>(X[i*incX].r, X[i*incX].i, scale, temp);
+    nrm2_complex_helper<float>(X[i*incX].r, X[i*incX].i, scale, ssq);
   }
 
   return scale * std::sqrt( ssq );
 }
 
+// FIXME: Function above is duplicated here, should be writeable as a template using
+// FIXME: xMagnitudeDType.
 template <>
 double nrm2(const int N, const Complex128* X, const int incX) {
-  double scale = 0, ssq = 1, temp;
+  double scale = 0, ssq = 1;
 
   if ((N < 1) || (incX < 1))    return 0.0;
 
   for (int i = 0; i < N; ++i) {
-    nrm2_complex_helper<double>(X[i*incX].r, X[i*incX].i, scale, temp);
+    nrm2_complex_helper<double>(X[i*incX].r, X[i*incX].i, scale, ssq);
   }
 
   return scale * std::sqrt( ssq );
 }
 
-template <typename ReturnDType, typename DType>
+template <typename DType, typename MDType = typename MagnitudeDType<DType>::type>
 inline void cblas_nrm2(const int N, const void* X, const int incX, void* result) {
-  *reinterpret_cast<ReturnDType*>( result ) = nrm2<ReturnDType, DType>( N, reinterpret_cast<const DType*>(X), incX );
+  *reinterpret_cast<MDType*>( result ) = nrm2<DType, MDType>( N, reinterpret_cast<const DType*>(X), incX );
 }
 
 

data/ext/nmatrix/math/trsm.h

@@ -81,10 +81,14 @@ inline void trsm_nothrow(const enum CBLAS_SIDE side, const enum CBLAS_UPLO uplo,
   // (row-major) trsm: left upper trans nonunit m=3 n=1 1/1 a 3 b 3
 
   if (m == 0 || n == 0) return; /* Quick return if possible. */
+  
+  // Apply necessary offset
+  a -= 1 + lda;
+  b -= 1 + ldb;
 
   if (alpha == 0) { // Handle alpha == 0
-    for (int j = 0; j < n; ++j) {
-      for (int i = 0; i < m; ++i) {
+    for (int j = 1; j <= n; ++j) {
+      for (int i = 1; i <= m; ++i) {
         b[i + j * ldb] = 0;
       }
     }
@@ -96,37 +100,37 @@ inline void trsm_nothrow(const enum CBLAS_SIDE side, const enum CBLAS_UPLO uplo,
 
       /* Form  B := alpha*inv( A )*B. */
       if (uplo == CblasUpper) {
-        for (int j = 0; j < n; ++j) {
+        for (int j = 1; j <= n; ++j) {
           if (alpha != 1) {
-            for (int i = 0; i < m; ++i) {
+            for (int i = 1; i <= m; ++i) {
               b[i + j * ldb] = alpha * b[i + j * ldb];
             }
           }
-          for (int k = m-1; k >= 0; --k) {
+          for (int k = m; k >= 1; --k) {
             if (b[k + j * ldb] != 0) {
               if (diag == CblasNonUnit) {
                 b[k + j * ldb] /= a[k + k * lda];
               }
 
-              for (int i = 0; i < k-1; ++i) {
+              for (int i = 1; i <= k-1; ++i) {
                 b[i + j * ldb] -= b[k + j * ldb] * a[i + k * lda];
               }
             }
           }
         }
       } else {
-        for (int j = 0; j < n; ++j) {
+        for (int j = 1; j <= n; ++j) {
           if (alpha != 1) {
-            for (int i = 0; i < m; ++i) {
+            for (int i = 1; i <= m; ++i) {
               b[i + j * ldb] = alpha * b[i + j * ldb];
             }
           }
-          for (int k = 0; k < m; ++k) {
+          for (int k = 1; k <= m; ++k) {
             if (b[k + j * ldb] != 0.) {
               if (diag == CblasNonUnit) {
                 b[k + j * ldb] /= a[k + k * lda];
               }
-              for (int i = k+1; i < m; ++i) {
+              for (int i = k+1; i <= m; ++i) {
                 b[i + j * ldb] -= b[k + j * ldb] * a[i + k * lda];
               }
             }
@@ -137,10 +141,10 @@ inline void trsm_nothrow(const enum CBLAS_SIDE side, const enum CBLAS_UPLO uplo,
 
       /*           Form  B := alpha*inv( A**T )*B. */
       if (uplo == CblasUpper) {
-        for (int j = 0; j < n; ++j) {
-          for (int i = 0; i < m; ++i) {
+        for (int j = 1; j <= n; ++j) {
+          for (int i = 1; i <= m; ++i) {
             DType temp = alpha * b[i + j * ldb];
-            for (int k = 0; k < i; ++k) { // limit was i-1. Lots of similar bugs in this code, probably.
+            for (int k = 1; k <= i-1; ++k) { // limit was i-1. Lots of similar bugs in this code, probably.
               temp -= a[k + i * lda] * b[k + j * ldb];
             }
             if (diag == CblasNonUnit) {
@@ -150,10 +154,10 @@ inline void trsm_nothrow(const enum CBLAS_SIDE side, const enum CBLAS_UPLO uplo,
           }
         }
       } else {
-        for (int j = 0; j < n; ++j) {
-          for (int i = m-1; i >= 0; --i) {
+        for (int j = 1; j <= n; ++j) {
+          for (int i = m; i >= 1; --i) {
             DType temp= alpha * b[i + j * ldb];
-            for (int k = i+1; k < m; ++k) {
+            for (int k = i+1; k <= m; ++k) {
               temp -= a[k + i * lda] * b[k + j * ldb];
             }
             if (diag == CblasNonUnit) {
@@ -171,37 +175,37 @@ inline void trsm_nothrow(const enum CBLAS_SIDE side, const enum CBLAS_UPLO uplo,
       /*           Form  B := alpha*B*inv( A ). */
 
       if (uplo == CblasUpper) {
-        for (int j = 0; j < n; ++j) {
+        for (int j = 1; j <= n; ++j) {
           if (alpha != 1) {
-            for (int i = 0; i < m; ++i) {
+            for (int i = 1; i <= m; ++i) {
               b[i + j * ldb] = alpha * b[i + j * ldb];
             }
           }
-          for (int k = 0; k < j-1; ++k) {
+          for (int k = 1; k <= j-1; ++k) {
             if (a[k + j * lda] != 0) {
-              for (int i = 0; i < m; ++i) {
+              for (int i = 1; i <= m; ++i) {
                 b[i + j * ldb] -= a[k + j * lda] * b[i + k * ldb];
               }
             }
           }
           if (diag == CblasNonUnit) {
             DType temp = 1 / a[j + j * lda];
-            for (int i = 0; i < m; ++i) {
+            for (int i = 1; i <= m; ++i) {
               b[i + j * ldb] = temp * b[i + j * ldb];
             }
           }
         }
       } else {
-        for (int j = n-1; j >= 0; --j) {
+        for (int j = n; j >= 1; --j) {
           if (alpha != 1) {
-            for (int i = 0; i < m; ++i) {
+            for (int i = 1; i <= m; ++i) {
               b[i + j * ldb] = alpha * b[i + j * ldb];
             }
           }
 
-          for (int k = j+1; k < n; ++k) {
+          for (int k = j+1; k <= n; ++k) {
             if (a[k + j * lda] != 0.) {
-              for (int i = 0; i < m; ++i) {
+              for (int i = 1; i <= m; ++i) {
                 b[i + j * ldb] -= a[k + j * lda] * b[i + k * ldb];
               }
             }
@@ -209,7 +213,7 @@ inline void trsm_nothrow(const enum CBLAS_SIDE side, const enum CBLAS_UPLO uplo,
           if (diag == CblasNonUnit) {
             DType temp = 1 / a[j + j * lda];
 
-            for (int i = 0; i < m; ++i) {
+            for (int i = 1; i <= m; ++i) {
               b[i + j * ldb] = temp * b[i + j * ldb];
             }
           }
@@ -220,45 +224,45 @@ inline void trsm_nothrow(const enum CBLAS_SIDE side, const enum CBLAS_UPLO uplo,
       /*           Form  B := alpha*B*inv( A**T ). */
 
       if (uplo == CblasUpper) {
-        for (int k = n-1; k >= 0; --k) {
+        for (int k = n; k >= 1; --k) {
           if (diag == CblasNonUnit) {
             DType temp= 1 / a[k + k * lda];
-            for (int i = 0; i < m; ++i) {
+            for (int i = 1; i <= m; ++i) {
               b[i + k * ldb] = temp * b[i + k * ldb];
             }
           }
-          for (int j = 0; j < k-1; ++j) {
+          for (int j = 1; j <= k-1; ++j) {
             if (a[j + k * lda] != 0.) {
               DType temp= a[j + k * lda];
-              for (int i = 0; i < m; ++i) {
+              for (int i = 1; i <= m; ++i) {
                 b[i + j * ldb] -= temp * b[i + k *  ldb];
               }
             }
           }
           if (alpha != 1) {
-            for (int i = 0; i < m; ++i) {
+            for (int i = 1; i <= m; ++i) {
               b[i + k * ldb] = alpha * b[i + k * ldb];
             }
           }
         }
       } else {
-        for (int k = 0; k < n; ++k) {
+        for (int k = 1; k <= n; ++k) {
           if (diag == CblasNonUnit) {
             DType temp = 1 / a[k + k * lda];
-            for (int i = 0; i < m; ++i) {
+            for (int i = 1; i <= m; ++i) {
               b[i + k * ldb] = temp * b[i + k * ldb];
             }
           }
-          for (int j = k+1; j < n; ++j) {
+          for (int j = k+1; j <= n; ++j) {
             if (a[j + k * lda] != 0.) {
               DType temp = a[j + k * lda];
-              for (int i = 0; i < m; ++i) {
+              for (int i = 1; i <= m; ++i) {
                 b[i + j * ldb] -= temp * b[i + k * ldb];
               }
             }
           }
           if (alpha != 1) {
-            for (int i = 0; i < m; ++i) {
+            for (int i = 1; i <= m; ++i) {
               b[i + k * ldb] = alpha * b[i + k * ldb];
             }
           }