nmatrix-lapacke 0.2.1 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: eb2bd35041ab2a318db38bc9d91fb399ed239a78
-  data.tar.gz: 847ccaae732e318cdf5bbf04a6419532bf5244b9
+  metadata.gz: 24925aa4dcfc784adc3fd27fa05687c0779d57e4
+  data.tar.gz: e0d5107e1d0211a1d32429e05a32ae1eb309c3bc
 SHA512:
-  metadata.gz: a3835ad07419160226e85b9c5e2b47946ea4243d0b4a75a248e8334697969ac556a31c54dd6a4650ede2c6e9a301108c2ab7543c428eded3383e8e19c220460b
-  data.tar.gz: cfb08870d965f5ef7cbbc83522ca6aed084992c1f828931a93600ebc6af53d432e61d8a3ffaf7a25461a29c6e7bc8efdd15ed7de9ce79efea53d72f867db8949
+  metadata.gz: 4be4b9ae38fe6cc8a2817ac79bf55a4541dd70708d0e86737c3179bd25d177b8bfb178d69ddc2a95396eac5d992bf40ae6f8b47554877c6657d8136e6bbe93df
+  data.tar.gz: 3cd253933d42d5a32780f717269b63583c489469d0d29bd8476fef61e5ed3ebb65c24ba5be5db36a38845ec3d60dbc3d3138fc1c0762a2e70890ede43262c8d5

data/ext/nmatrix/data/data.h

@@ -121,18 +121,17 @@ namespace nm {
 
   template <typename Type>
   Complex<Type>& Complex<Type>::operator=(const RubyObject& other) {
-    switch(TYPE(other.rval)) {
-    case T_COMPLEX:
+    if (RB_TYPE_P(other.rval, T_COMPLEX)) {
       this->r = NUM2DBL(rb_funcall(other.rval, rb_intern("real"), 0));
       this->i = NUM2DBL(rb_funcall(other.rval, rb_intern("imag"), 0));
-      break;
-    case T_FLOAT:
-    case T_FIXNUM:
-    case T_BIGNUM:
+    }
+    else if (RB_TYPE_P(other.rval, T_FLOAT) ||
+             RB_TYPE_P(other.rval, T_FIXNUM) ||
+             RB_TYPE_P(other.rval, T_BIGNUM)) {
       this->r = NUM2DBL(other.rval);
       this->i = 0.0;
-      break;
-    default:
+    }
+    else {
       rb_raise(rb_eTypeError, "not sure how to convert this type of VALUE to a complex");
     }
     return *this;

data/ext/nmatrix/data/ruby_object.h

@@ -45,10 +45,7 @@
 /*
  * Macros
  */
-#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.");
+#define NM_RUBYVAL_IS_NUMERIC(val)                (FIXNUM_P(val) or RB_FLOAT_TYPE_P(val) or RB_TYPE_P(val, T_COMPLEX))
 
 /*
  * Classes and Functions

data/ext/nmatrix/math/asum.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.
 //
@@ -60,6 +60,8 @@
 #define ASUM_H
 
 
+#include "math/magnitude.h"
+
 namespace nm { namespace math {
 
 /*
@@ -73,44 +75,21 @@ namespace nm { namespace math {
  *    complex64 -> float or double
  *    complex128 -> double
  */
-template <typename ReturnDType, typename DType>
-inline ReturnDType asum(const int N, const DType* X, const int incX) {
-  ReturnDType sum = 0;
-  if ((N > 0) && (incX > 0)) {
-    for (int i = 0; i < N; ++i) {
-      sum += std::abs(X[i*incX]);
-    }
-  }
-  return sum;
-}
-
-
-template <>
-inline float asum(const int N, const Complex64* X, const int incX) {
-  float sum = 0;
-  if ((N > 0) && (incX > 0)) {
-    for (int i = 0; i < N; ++i) {
-      sum += std::abs(X[i*incX].r) + std::abs(X[i*incX].i);
-    }
-  }
-  return sum;
-}
-
-template <>
-inline double asum(const int N, const Complex128* X, const int incX) {
-  double sum = 0;
+template <typename DType, typename MDType = typename MagnitudeDType<DType>::type>
+inline MDType asum(const int N, const DType* X, const int incX) {
+  MDType sum = 0;
   if ((N > 0) && (incX > 0)) {
     for (int i = 0; i < N; ++i) {
-      sum += std::abs(X[i*incX].r) + std::abs(X[i*incX].i);
+      sum += magnitude(X[i*incX]);
     }
   }
   return sum;
 }
 
 
-template <typename ReturnDType, typename DType>
+template <typename DType, typename MDType = typename MagnitudeDType<DType>::type>
 inline void cblas_asum(const int N, const void* X, const int incX, void* sum) {
-  *reinterpret_cast<ReturnDType*>( sum ) = asum<ReturnDType, DType>( N, reinterpret_cast<const DType*>(X), incX );
+  *reinterpret_cast<MDType*>( sum ) = asum<DType,MDType>( N, reinterpret_cast<const DType*>(X), incX );
 }
 
 

data/ext/nmatrix/math/cblas_templates_core.h

@@ -107,9 +107,9 @@ inline void cblas_rot(const int N, void* X, const int incX, void* Y, const int i
  *    complex64 -> float or double
  *    complex128 -> double
  */
-template <typename ReturnDType, typename DType>
-inline ReturnDType asum(const int N, const DType* X, const int incX) {
-  return nm::math::asum<ReturnDType,DType>(N,X,incX);
+template <typename DType, typename MDType = typename MagnitudeDType<DType>::type>
+inline MDType asum(const int N, const DType* X, const int incX) {
+  return nm::math::asum<DType,MDType>(N,X,incX);
 }
 
 
@@ -134,9 +134,9 @@ inline double asum(const int N, const Complex128* X, const int incX) {
 }
 
 
-template <typename ReturnDType, typename DType>
+template <typename DType, typename MDType = typename MagnitudeDType<DType>::type>
 inline void cblas_asum(const int N, const void* X, const int incX, void* sum) {
-  *static_cast<ReturnDType*>( sum ) = asum<ReturnDType, DType>( N, static_cast<const DType*>(X), incX );
+  *static_cast<MDType*>( sum ) = asum<DType, MDType>( N, static_cast<const DType*>(X), incX );
 }
 
 /*
@@ -149,9 +149,9 @@ inline void cblas_asum(const int N, const void* X, const int incX, void* sum) {
  *    complex64 -> float or double
  *    complex128 -> double
  */
-template <typename ReturnDType, typename DType>
-inline ReturnDType nrm2(const int N, const DType* X, const int incX) {
-  return nm::math::nrm2<ReturnDType,DType>(N, X, incX);
+template <typename DType, typename MDType = typename MagnitudeDType<DType>::type>
+inline MDType nrm2(const int N, const DType* X, const int incX) {
+  return nm::math::nrm2<DType,MDType>(N, X, incX);
 }
 
 
@@ -175,9 +175,9 @@ inline double nrm2(const int N, const Complex128* X, const int incX) {
   return cblas_dznrm2(N, X, incX);
 }
 
-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) {
-  *static_cast<ReturnDType*>( result ) = nrm2<ReturnDType, DType>( N, static_cast<const DType*>(X), incX );
+  *static_cast<MDType*>( result ) = nrm2<DType, MDType>( N, static_cast<const DType*>(X), incX );
 }
 
 //imax

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 );
 }