nmatrix 0.1.0.rc3 → 0.1.0.rc4

data/ext/nmatrix/math/getf2.h

@@ -46,7 +46,7 @@ inline int getf2(const int m, const int n, DType* a, const int lda, int *ipiv) {
 
     /* Find pivot and test for singularity. */
 
-    int jp = j - 1 + idamax<DType>(m-j+1, &a[j + j * lda], 1);
+    int jp = j - 1 + imax<DType>(m-j+1, &a[j + j * lda], 1);
 
     ipiv[j] = jp;
 
@@ -83,4 +83,4 @@ inline int getf2(const int m, const int n, DType* a, const int lda, int *ipiv) {
 
 }} // end of namespace nm::math
 
-#endif // GETF2
+#endif // GETF2

data/ext/nmatrix/math/getrf.h

@@ -150,7 +150,7 @@ inline int getrf_nothrow(const int M, const int N, DType* A, const int lda, int*
 
   } 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.
 
-    int i = *ipiv = nm::math::idamax<DType>(N, A, 1); // cblas_iamax(N, A, 1);
+    int i = *ipiv = nm::math::imax<DType>(N, A, 1); // cblas_iamax(N, A, 1);
 
     DType tmp = A[i];
     if (tmp != 0) {
@@ -237,4 +237,4 @@ inline int clapack_getrf(const enum CBLAS_ORDER order, const int m, const int n,
 
 } } // end nm::math
 
-#endif
+#endif

data/ext/nmatrix/math/imax.h

@@ -0,0 +1,101 @@
+/////////////////////////////////////////////////////////////////////
+// = 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
+//
+// == imax.h
+//
+// BLAS level 1 function imax.
+//
+
+#ifndef IMAX_H
+#define IMAX_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;
+  }
+
+  DType dmax;
+  int imax = 0;
+
+  if (incx == 1) { // if incrementing by 1
+
+    dmax = abs(x[0]);
+
+    for (int i = 1; i < n; ++i) {
+      if (std::abs(x[i]) > dmax) {
+        imax = i;
+        dmax = std::abs(x[i]);
+      }
+    }
+
+  } else { // if incrementing by more than 1
+
+    dmax = std::abs(x[0]);
+
+    for (int i = 1, ix = incx; i < n; ++i, ix += incx) {
+      if (std::abs(x[ix]) > dmax) {
+        imax = i;
+        dmax = std::abs(x[ix]);
+      }
+    }
+  }
+  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);
+}
+
+}} // end of namespace nm::math
+
+#endif /* IMAX_H */

data/ext/nmatrix/math/scal.h

@@ -23,7 +23,7 @@
 //
 // == scal.h
 //
-// LAPACK scal function in native C.
+// BLAS scal function.
 //
 
 #ifndef SCAL_H
@@ -47,25 +47,45 @@ namespace nm { namespace math {
 /*  ===================================================================== */
 
 template <typename DType>
-inline void scal(const int n, const DType da, DType* dx,	const int incx) {
+inline void scal(const int n, const DType scalar, DType* x, const int incx) {
 
-  // This used to have unrolled loops, like dswap. They were in the way.
-
-  if (n <= 0 || incx <= 0) return;
+  if (n <= 0 || incx <= 0) {
+    return;
+  }
 
   for (int i = 0; incx < 0 ? i > n*incx : i < n*incx; i += incx) {
-    dx[i] = da * dx[i];
+    x[i] = scalar * x[i];
   }
-} /* scal */
+}
 
+#if defined HAVE_CBLAS_H || defined HAVE_ATLAS_CBLAS_H
+template <>
+inline void scal(const int n, const float scalar, float* x, const int incx) {
+  cblas_sscal(n, scalar, x, incx);
+}
+
+template <>
+inline void scal(const int n, const double scalar, double* x, const int incx) {
+  cblas_dscal(n, scalar, x, incx);
+}
+
+template <>
+inline void scal(const int n, const Complex64 scalar, Complex64* x, const int incx) {
+  cblas_cscal(n, (const void*)(&scalar), (void*)(x), incx);
+}
+
+template <>
+inline void scal(const int n, const Complex128 scalar, Complex128* x, const int incx) {
+  cblas_zscal(n, (const void*)(&scalar), (void*)(x), incx);
+}
+#endif
 
 /*
  * Function signature conversion for LAPACK's scal function.
  */
 template <typename DType>
-inline void clapack_scal(const int n, const void* da, void* dx, const int incx) {
-  // FIXME: See if we can call the clapack version instead of our C++ version.
-  scal<DType>(n, *reinterpret_cast<const DType*>(da), reinterpret_cast<DType*>(dx), incx);
+inline void cblas_scal(const int n, const void* scalar, void* x, const int incx) {
+  scal<DType>(n, *reinterpret_cast<const DType*>(scalar), reinterpret_cast<DType*>(x), incx);
 }
 
 }} // end of nm::math

data/ext/nmatrix/math/swap.h

@@ -30,27 +30,6 @@
 #define SWAP_H
 
 namespace nm { namespace math {
-/*
-template <typename DType>
-inline void swap(int n, DType *dx, int incx, DType *dy, int incy) {
-
-  if (n <= 0) return;
-
-  // For negative increments, start at the end of the array.
-  int ix = incx < 0 ? (-n+1)*incx : 0,
-      iy = incy < 0 ? (-n+1)*incy : 0;
-
-  if (incx < 0) ix = (-n + 1) * incx;
-  if (incy < 0) iy = (-n + 1) * incy;
-
-  for (size_t i = 0; i < n; ++i, ix += incx, iy += incy) {
-    DType dtemp = dx[ix];
-    dx[ix]      = dy[iy];
-    dy[iy]      = dtemp;
-  }
-  return;
-} /* dswap */
-
 // This is the old BLAS version of this function. ATLAS has an optimized version, but
 // it's going to be tough to translate.
 template <typename DType>
@@ -70,4 +49,4 @@ static void swap(const int N, DType* X, const int incX, DType* Y, const int incY
 
 }} // end nm::math
 
-#endif
+#endif

data/ext/nmatrix/nm_memory.h

@@ -26,7 +26,7 @@
 // Macros for memory allocation and freeing
 
 /**
- * We define these macros, which just call the ruby ones, as this makes 
+ * We define these macros, which just call the ruby ones, as this makes
  * debugging memory issues (particularly those involving interaction with
  * the ruby GC) easier, as it's posssible to add debugging code temporarily.
  */

data/ext/nmatrix/nmatrix.h

@@ -179,7 +179,7 @@
     size_t*     shape;              \
     size_t*     offset;             \
 	  int			    count;              \
-	  STORAGE*		src;              
+	  STORAGE*		src;
   #define NM_DEF_STORAGE_CHILD_STRUCT_PRE(name)  typedef struct NM_ ## name { \
                                                     NM_DEF_STORAGE_ELEMENTS;
 
@@ -328,7 +328,7 @@ typedef struct __NM_GC_HOLDER {
 #define NM_DENSE_ELEMENTS(val)  (NM_STORAGE_DENSE(val)->elements)
 #define NM_SIZEOF_DTYPE(val)    (DTYPE_SIZES[NM_DTYPE(val)])
 #define NM_REF(val,slice)      (RefFuncs[NM_STYPE(val)]( NM_STORAGE(val), slice, NM_SIZEOF_DTYPE(val) ))
-    
+
 #define NM_MAX(a,b) (((a)>(b))?(a):(b))
 #define NM_MIN(a,b) (((a)>(b))?(b):(a))
 #define NM_SWAP(a,b,tmp) {(tmp)=(a);(a)=(b);(b)=(tmp);}

data/ext/nmatrix/ruby_constants.cpp

@@ -85,13 +85,12 @@ ID	nm_rb_dtype,
 VALUE cNMatrix,
       cNMatrix_IO,
       cNMatrix_IO_Matlab,
-			cNVector,
 			cNMatrix_YaleFunctions,
 			cNMatrix_BLAS,
 			cNMatrix_LAPACK,
 
       cNMatrix_GC_holder,
-			
+
 			nm_eDataTypeError,
       nm_eConvergenceError,
 			nm_eStorageTypeError,

data/ext/nmatrix/ruby_constants.h

@@ -46,10 +46,10 @@ extern ID nm_rb_dtype,
 
           nm_rb_real,
 					nm_rb_imag,
-		
+
 					nm_rb_numer,
 					nm_rb_denom,
-		
+
 					nm_rb_complex_conjugate,
 					nm_rb_transpose,
 					nm_rb_no_transpose,
@@ -59,21 +59,21 @@ extern ID nm_rb_dtype,
 					nm_rb_lower,
 					nm_rb_unit,
 					nm_rb_nonunit,
-		
+
 					nm_rb_dense,
 					nm_rb_list,
 					nm_rb_yale,
 
           nm_rb_row,
           nm_rb_column,
-		
+
 					nm_rb_add,
 					nm_rb_sub,
 					nm_rb_mul,
 					nm_rb_div,
 
 					nm_rb_negate,
-		
+
 					nm_rb_percent,
 					nm_rb_gt,
 					nm_rb_lt,
@@ -87,13 +87,12 @@ extern ID nm_rb_dtype,
 extern VALUE	cNMatrix,
               cNMatrix_IO,
               cNMatrix_IO_Matlab,
-							cNVector,
 							cNMatrix_YaleFunctions,
 							cNMatrix_BLAS,
 							cNMatrix_LAPACK,
 
 							cNMatrix_GC_holder,
-			
+
 							nm_eDataTypeError,
               nm_eConvergenceError,
 							nm_eStorageTypeError,

data/ext/nmatrix/ruby_nmatrix.c

@@ -132,6 +132,8 @@ DECL_UNARY_RUBY_ACCESSOR(erfc)
 DECL_UNARY_RUBY_ACCESSOR(cbrt)
 DECL_UNARY_RUBY_ACCESSOR(gamma)
 DECL_UNARY_RUBY_ACCESSOR(negate)
+DECL_UNARY_RUBY_ACCESSOR(floor)
+DECL_UNARY_RUBY_ACCESSOR(ceil)
 DECL_NONCOM_ELEMENTWISE_RUBY_ACCESSOR(atan2)
 DECL_NONCOM_ELEMENTWISE_RUBY_ACCESSOR(ldexp)
 DECL_NONCOM_ELEMENTWISE_RUBY_ACCESSOR(hypot)
@@ -182,7 +184,6 @@ void Init_nmatrix() {
 	///////////////////////
 
 	cNMatrix = rb_define_class("NMatrix", rb_cObject);
-	//cNVector = rb_define_class("NVector", cNMatrix);
 
 	// Special exceptions
 
@@ -313,6 +314,8 @@ void Init_nmatrix() {
   rb_define_method(cNMatrix, "gamma", (METHOD)nm_unary_gamma, 0);
   rb_define_method(cNMatrix, "log",   (METHOD)nm_unary_log,  -1);
   rb_define_method(cNMatrix, "-@",    (METHOD)nm_unary_negate,0);
+  rb_define_method(cNMatrix, "floor", (METHOD)nm_unary_floor, 0);
+  rb_define_method(cNMatrix, "ceil", (METHOD)nm_unary_ceil, 0);
 
 	rb_define_method(cNMatrix, "=~", (METHOD)nm_ew_eqeq, 1);
 	rb_define_method(cNMatrix, "!~", (METHOD)nm_ew_neq, 1);
@@ -522,7 +525,7 @@ static void __nm_initialize_value_container() {
     gc_value_holder_struct->start = NULL;
     allocated_pool->start = NULL;
     *gc_value_holder = Data_Wrap_Struct(cNMatrix_GC_holder, __nm_mark_value_container, NULL, gc_value_holder_struct);
-    rb_global_variable(gc_value_holder); 
+    rb_global_variable(gc_value_holder);
   }
 }
 
@@ -926,6 +929,8 @@ DEF_UNARY_RUBY_ACCESSOR(ERFC, erfc)
 DEF_UNARY_RUBY_ACCESSOR(CBRT, cbrt)
 DEF_UNARY_RUBY_ACCESSOR(GAMMA, gamma)
 DEF_UNARY_RUBY_ACCESSOR(NEGATE, negate)
+DEF_UNARY_RUBY_ACCESSOR(FLOOR, floor)
+DEF_UNARY_RUBY_ACCESSOR(CEIL, ceil)
 
 DEF_NONCOM_ELEMENTWISE_RUBY_ACCESSOR(ATAN2, atan2)
 DEF_NONCOM_ELEMENTWISE_RUBY_ACCESSOR(LDEXP, ldexp)
@@ -1018,7 +1023,7 @@ static VALUE nm_complex_conjugate_bang(VALUE self) {
       reinterpret_cast<nm::Complex128*>(elem)[p].i = -reinterpret_cast<nm::Complex128*>(elem)[p].i;
     }
 
-  } 
+  }
   return self;
 }
 
@@ -1045,7 +1050,7 @@ static VALUE nm_complex_conjugate(VALUE self) {
  */
 static VALUE nm_reshape_bang(VALUE self, VALUE arg){
   NMATRIX* m;
-  UnwrapNMatrix(self, m); 
+  UnwrapNMatrix(self, m);
   if(m->stype == nm::DENSE_STORE){
     DENSE_STORAGE* s   = NM_STORAGE_DENSE(self);
     VALUE shape_ary = arg;
@@ -1056,9 +1061,9 @@ static VALUE nm_reshape_bang(VALUE self, VALUE arg){
     void* elem = s->elements;
     for (size_t index = 0; index < dim; ++index){
       new_size *= shape[index];}
- 
+
     if (size == new_size){
-      s->shape = shape; 
+      s->shape = shape;
       s->dim = dim;
       size_t i, j;
       size_t* stride = NM_ALLOC_N(size_t, dim);
@@ -1072,7 +1077,7 @@ static VALUE nm_reshape_bang(VALUE self, VALUE arg){
       return self;
      }
      else
-       rb_raise(rb_eArgError, "reshape cannot resize; size of new and old matrices must match");  
+       rb_raise(rb_eArgError, "reshape cannot resize; size of new and old matrices must match");
   }
   else {
     rb_raise(rb_eNotImpError, "reshape in place only for dense stype");
@@ -1173,7 +1178,7 @@ static VALUE nm_init_new_version(int argc, VALUE* argv, VALUE self) {
       init = RARRAY_LEN(initial_ary) == 1 ? rubyobj_to_cval(rb_ary_entry(initial_ary, 0), dtype) : NULL;
     else
       init = rubyobj_to_cval(initial_ary, dtype);
-    
+
     if (dtype == nm::RUBYOBJ) {
       nm_register_values(reinterpret_cast<VALUE*>(init), 1);
     }
@@ -1185,7 +1190,7 @@ static VALUE nm_init_new_version(int argc, VALUE* argv, VALUE self) {
   }
 
   if (!NIL_P(initial_ary)) {
-    
+
     if (TYPE(initial_ary) == T_ARRAY) 	v_size = RARRAY_LEN(initial_ary);
     else                                v_size = 1;
 
@@ -1324,7 +1329,7 @@ static VALUE nm_init_new_version(int argc, VALUE* argv, VALUE self) {
 static VALUE nm_init(int argc, VALUE* argv, VALUE nm) {
   NM_CONSERVATIVE(nm_register_value(nm));
   NM_CONSERVATIVE(nm_register_values(argv, argc));
-  
+
   if (argc <= 3) { // Call the new constructor unless all four arguments are given (or the 7-arg version is given)
     NM_CONSERVATIVE(nm_unregister_values(argv, argc));
     NM_CONSERVATIVE(nm_unregister_value(nm));
@@ -1487,7 +1492,7 @@ VALUE nm_cast(VALUE self, VALUE new_stype_symbol, VALUE new_dtype_symbol, VALUE
   nm_register_nmatrix(m);
 
   VALUE to_return = Data_Wrap_Struct(CLASS_OF(self), nm_mark, nm_delete, m);
-  
+
   nm_unregister_nmatrix(m);
   NM_CONSERVATIVE(nm_unregister_value(self));
   NM_CONSERVATIVE(nm_unregister_value(init));
@@ -1974,7 +1979,7 @@ static VALUE nm_mref(int argc, VALUE* argv, VALUE self) {
  *     n[3,3] = n[2,3] = 5.0
  */
 static VALUE nm_mset(int argc, VALUE* argv, VALUE self) {
-  
+
   size_t dim = NM_DIM(self); // last arg is the value
 
   VALUE to_return = Qnil;
@@ -2107,7 +2112,7 @@ static VALUE nm_shape(VALUE self) {
   nm_register_values(shape, s->dim);
   for (size_t index = 0; index < s->dim; ++index)
     shape[index] = INT2FIX(s->shape[index]);
-  
+
   nm_unregister_values(shape, s->dim);
   NM_CONSERVATIVE(nm_unregister_value(self));
   return rb_ary_new4(s->dim, shape);
@@ -2147,11 +2152,11 @@ static VALUE nm_supershape(VALUE self) {
   STORAGE* s   = NM_STORAGE(self);
   if (s->src == s) {
     return nm_shape(self); // easy case (not a slice)
-  } 
+  }
   else s = s->src;
 
   NM_CONSERVATIVE(nm_register_value(self));
-  
+
   VALUE* shape = NM_ALLOCA_N(VALUE, s->dim);
   nm_register_values(shape, s->dim);
   for (size_t index = 0; index < s->dim; ++index)
@@ -2655,7 +2660,7 @@ static SLICE* get_slice(size_t dim, int argc, VALUE* arg, size_t* shape) {
   // r is the shape position; t is the slice position. They may differ when we're dealing with a
   // matrix where the effective dimension is less than the dimension (e.g., a vector).
   for (size_t r = 0, t = 0; r < dim; ++r) {
-    VALUE v = t == argc ? Qnil : arg[t];
+    VALUE v = t == (unsigned int)argc ? Qnil : arg[t];
 
     // if the current shape indicates a vector and fewer args were supplied than necessary, just use 0
     if (argc - t + r < dim && shape[r] == 1) {
@@ -2684,11 +2689,11 @@ static SLICE* get_slice(size_t dim, int argc, VALUE* arg, size_t* shape) {
 
       if (rb_ary_entry(begin_end, 0) >= 0)
         slice->coords[r]  = FIX2INT(rb_ary_entry(begin_end, 0));
-      else 
+      else
         slice->coords[r]  = shape[r] + FIX2INT(rb_ary_entry(begin_end, 0));
       if (rb_ary_entry(begin_end, 1) >= 0)
         slice->lengths[r] = FIX2INT(rb_ary_entry(begin_end, 1)) - slice->coords[r];
-      else 
+      else
         slice->lengths[r] = shape[r] + FIX2INT(rb_ary_entry(begin_end, 1)) - slice->coords[r];
 
       if (RHASH_EMPTY_P(v)) t++; // go on to the next