nmatrix 0.2.1 → 0.2.3

data/ext/nmatrix/math/util.h

@@ -70,6 +70,20 @@ static inline enum CBLAS_SIDE blas_side_sym(VALUE op) {
   return CblasLeft;
 }
 
+/*
+ * Interprets the LAPACK side argument which could be :left or :right
+ * 
+ * Related to obtaining Q in QR factorization after calling lapack_geqrf
+ */
+
+static inline char lapacke_side_sym(VALUE op) {
+  ID op_id = rb_to_id(op);
+  if (op_id == nm_rb_left)  return 'L';
+  if (op_id == nm_rb_right) return 'R';
+  else rb_raise(rb_eArgError, "Expected :left or :right for side argument");
+  return 'L';
+}
+
 /*
  * Interprets cblas argument which could be :upper or :lower
  *

data/ext/nmatrix/nmatrix.h

@@ -33,6 +33,7 @@
  */
 
 #include <ruby.h>
+#include "ruby_constants.h"
 
 #ifdef __cplusplus
   #include <cmath>
@@ -57,6 +58,28 @@
   #include "nm_memory.h"
 #endif
 
+#ifndef RB_BUILTIN_TYPE
+# define RB_BUILTIN_TYPE(obj) BUILTIN_TYPE(obj)
+#endif
+
+#ifndef RB_FLOAT_TYPE_P
+/* NOTE: assume flonum doesn't exist */
+# define RB_FLOAT_TYPE_P(obj) ( \
+    (!SPECIAL_CONST_P(obj) && BUILTIN_TYPE(obj) == T_FLOAT))
+#endif
+
+#ifndef RB_TYPE_P
+# define RB_TYPE_P(obj, type) ( \
+    ((type) == T_FIXNUM) ? FIXNUM_P(obj) : \
+    ((type) == T_TRUE) ? ((obj) == Qtrue) : \
+    ((type) == T_FALSE) ? ((obj) == Qfalse) : \
+    ((type) == T_NIL) ? ((obj) == Qnil) : \
+    ((type) == T_UNDEF) ? ((obj) == Qundef) : \
+    ((type) == T_SYMBOL) ? SYMBOL_P(obj) : \
+    ((type) == T_FLOAT) ? RB_FLOAT_TYPE_P(obj) : \
+    (!SPECIAL_CONST_P(obj) && BUILTIN_TYPE(obj) == (type)))
+#endif
+
 #ifndef FIX_CONST_VALUE_PTR
 # if defined(__fcc__) || defined(__fcc_version) || \
     defined(__FCC__) || defined(__FCC_VERSION)
@@ -343,11 +366,25 @@ NM_DEF_STRUCT_POST(NM_GC_HOLDER);       // };
 
 #define NM_SRC(val)             (NM_STORAGE(val)->src)
 #define NM_DIM(val)             (NM_STORAGE(val)->dim)
+
+// Returns an int corresponding the data type of the nmatrix. See the dtype_t
+// enum for a list of possible data types.
 #define NM_DTYPE(val)           (NM_STORAGE(val)->dtype)
+
+// Returns a number corresponding the storage type of the nmatrix. See the stype_t
+// enum for a list of possible storage types.
 #define NM_STYPE(val)           (NM_STRUCT(val)->stype)
+
+// Get the shape of the ith dimension (int)
 #define NM_SHAPE(val,i)         (NM_STORAGE(val)->shape[(i)])
+
+// Get the shape of the 0th dimension (int)
 #define NM_SHAPE0(val)          (NM_STORAGE(val)->shape[0])
+
+// Get the shape of the 1st dimenension (int)
 #define NM_SHAPE1(val)          (NM_STORAGE(val)->shape[1])
+
+// Get the default value assigned to the nmatrix.
 #define NM_DEFAULT_VAL(val)     (NM_STORAGE_LIST(val)->default_val)
 
 // Number of elements in a dense nmatrix.
@@ -366,7 +403,8 @@ NM_DEF_STRUCT_POST(NM_GC_HOLDER);       // };
 
 #define RB_FILE_EXISTS(fn)   (rb_funcall(rb_const_get(rb_cObject, rb_intern("File")), rb_intern("exists?"), 1, (fn)) == Qtrue)
 
-#define CheckNMatrixType(v)   if (TYPE(v) != T_DATA || (RDATA(v)->dfree != (RUBY_DATA_FUNC)nm_delete && RDATA(v)->dfree != (RUBY_DATA_FUNC)nm_delete_ref)) rb_raise(rb_eTypeError, "expected NMatrix on left-hand side of operation");
+#define IsNMatrixType(v)  (RB_TYPE_P(v, T_DATA) && (RDATA(v)->dfree == (RUBY_DATA_FUNC)nm_delete || RDATA(v)->dfree == (RUBY_DATA_FUNC)nm_delete_ref))
+#define CheckNMatrixType(v)   if (!IsNMatrixType(v)) rb_raise(rb_eTypeError, "expected NMatrix on left-hand side of operation");
 
 #define NM_IsNMatrix(obj) \
   (rb_obj_is_kind_of(obj, cNMatrix) == Qtrue)

data/ext/nmatrix/ruby_nmatrix.c

@@ -1099,13 +1099,15 @@ static VALUE nm_reshape_bang(VALUE self, VALUE arg){
     size_t size = nm_storage_count_max_elements(s);
     size_t new_size = 1;
     size_t* shape = interpret_shape(shape_ary, &dim);
-    void* elem = s->elements;
     for (size_t index = 0; index < dim; ++index){
       new_size *= shape[index];}
 
     if (size == new_size){
       s->shape = shape;
       s->dim = dim;
+      NM_FREE(s->offset);
+      s->offset = NM_ALLOC_N(size_t, dim);
+      memset(s->offset, 0, sizeof(size_t)*dim);
       size_t i, j;
       size_t* stride = NM_ALLOC_N(size_t, dim);
       for (i = 0; i < dim; ++i) {
@@ -1113,8 +1115,9 @@ static VALUE nm_reshape_bang(VALUE self, VALUE arg){
         for (j = i+1; j < dim; ++j) {
           stride[i] *= shape[j];
         }
-        s->stride = stride;
       }
+      NM_FREE(s->stride);
+      s->stride = stride;
       return self;
      }
      else
@@ -1199,7 +1202,7 @@ static VALUE nm_init_new_version(int argc, VALUE* argv, VALUE self) {
       init = rubyobj_to_cval(default_val_num, dtype);
     else if (NIL_P(initial_ary))
       init = NULL;
-    else if (TYPE(initial_ary) == T_ARRAY)
+    else if (RB_TYPE_P(initial_ary, T_ARRAY))
       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);
@@ -1216,8 +1219,8 @@ 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;
+    if (RB_TYPE_P(initial_ary, T_ARRAY)) v_size = RARRAY_LEN(initial_ary);
+    else                                 v_size = 1;
 
     v = interpret_initial_value(initial_ary, dtype);
 
@@ -1365,7 +1368,7 @@ static VALUE nm_init(int argc, VALUE* argv, VALUE nm) {
   nm::stype_t stype;
   size_t  offset = 0;
 
-  if (!SYMBOL_P(argv[0]) && TYPE(argv[0]) != T_STRING) {
+  if (!SYMBOL_P(argv[0]) && !RB_TYPE_P(argv[0], T_STRING)) {
     stype = nm::DENSE_STORE;
 
   } else {
@@ -1397,7 +1400,7 @@ static VALUE nm_init(int argc, VALUE* argv, VALUE nm) {
 
   size_t init_cap = 0, init_val_len = 0;
   void* init_val  = NULL;
-  if (!SYMBOL_P(argv[1+offset]) || TYPE(argv[1+offset]) == T_ARRAY) {
+  if (!SYMBOL_P(argv[1+offset]) || RB_TYPE_P(argv[1+offset], T_ARRAY)) {
     // Initial value provided (could also be initial capacity, if yale).
 
     if (stype == nm::YALE_STORE && NM_RUBYVAL_IS_NUMERIC(argv[1+offset])) {
@@ -1407,8 +1410,8 @@ static VALUE nm_init(int argc, VALUE* argv, VALUE nm) {
       // 4: initial value / dtype
       init_val = interpret_initial_value(argv[1+offset], dtype);
 
-      if (TYPE(argv[1+offset]) == T_ARRAY)   init_val_len = RARRAY_LEN(argv[1+offset]);
-      else                                  init_val_len = 1;
+      if (RB_TYPE_P(argv[1+offset], T_ARRAY)) init_val_len = RARRAY_LEN(argv[1+offset]);
+      else                                    init_val_len = 1;
     }
 
   } else {
@@ -2057,7 +2060,7 @@ static VALUE nm_multiply(VALUE left_v, VALUE right_v) {
     return matrix_multiply_scalar(left, right_v);
   }
 
-  else if (TYPE(right_v) == T_ARRAY) {
+  else if (RB_TYPE_P(right_v, T_ARRAY)) {
     NM_CONSERVATIVE(nm_unregister_value(&left_v));
     NM_CONSERVATIVE(nm_unregister_value(&right_v));
     rb_raise(rb_eNotImpError, "please convert array to nx1 or 1xn NMatrix first");
@@ -2336,7 +2339,7 @@ static VALUE elementwise_op(nm::ewop_t op, VALUE left_val, VALUE right_val) {
   CheckNMatrixType(left_val);
   UnwrapNMatrix(left_val, left);
 
-  if (TYPE(right_val) != T_DATA || (RDATA(right_val)->dfree != (RUBY_DATA_FUNC)nm_delete && RDATA(right_val)->dfree != (RUBY_DATA_FUNC)nm_delete_ref)) {
+  if (!IsNMatrixType(right_val)) {
     // This is a matrix-scalar element-wise operation.
     std::string sym;
     switch(left->stype) {
@@ -2413,7 +2416,7 @@ static VALUE noncom_elementwise_op(nm::noncom_ewop_t op, VALUE self, VALUE other
   CheckNMatrixType(self);
   UnwrapNMatrix(self, self_nm);
 
-  if (TYPE(other) != T_DATA || (RDATA(other)->dfree != (RUBY_DATA_FUNC)nm_delete && RDATA(other)->dfree != (RUBY_DATA_FUNC)nm_delete_ref)) {
+  if (!IsNMatrixType(other)) {
     // This is a matrix-scalar element-wise operation.
     std::string sym;
     switch(self_nm->stype) {
@@ -2559,23 +2562,20 @@ nm::dtype_t nm_dtype_min_fixnum(int64_t v) {
  */
 nm::dtype_t nm_dtype_min(VALUE v) {
 
-  switch(TYPE(v)) {
-  case T_FIXNUM:
+  if (RB_TYPE_P(v, T_FIXNUM))
     return nm_dtype_min_fixnum(FIX2LONG(v));
-  case T_BIGNUM:
+  else if (RB_TYPE_P(v, T_BIGNUM))
     return nm::INT64;
-  case T_FLOAT:
+  else if (RB_TYPE_P(v, T_FLOAT))
     return nm::FLOAT32;
-  case T_COMPLEX:
+  else if (RB_TYPE_P(v, T_COMPLEX))
     return nm::COMPLEX64;
-  case T_STRING:
+  else if (RB_TYPE_P(v, T_STRING))
     return RSTRING_LEN(v) == 1 ? nm::BYTE : nm::RUBYOBJ;
-  case T_TRUE:
-  case T_FALSE:
-  case T_NIL:
-  default:
+  else if (RB_TYPE_P(v, T_TRUE) || RB_TYPE_P(v, T_FALSE) || RB_TYPE_P(v, T_NIL))
+    return nm::RUBYOBJ;
+  else
     return nm::RUBYOBJ;
-  }
 }
 
 
@@ -2585,60 +2585,39 @@ nm::dtype_t nm_dtype_min(VALUE v) {
  * TODO: Probably needs some work for Bignum.
  */
 nm::dtype_t nm_dtype_guess(VALUE v) {
-  switch(TYPE(v)) {
-  case T_TRUE:
-  case T_FALSE:
-  case T_NIL:
+  if (RB_TYPE_P(v, T_TRUE) || RB_TYPE_P(v, T_FALSE) || RB_TYPE_P(v, T_NIL))
     return nm::RUBYOBJ;
-  case T_STRING:
+  else if (RB_TYPE_P(v, T_STRING))
     return RSTRING_LEN(v) == 1 ? nm::BYTE : nm::RUBYOBJ;
-
+  else if (RB_TYPE_P(v, T_FIXNUM))
 #if SIZEOF_INT == 8
-  case T_FIXNUM:
     return nm::INT64;
-
-#else
-# if SIZEOF_INT == 4
-  case T_FIXNUM:
+#elif SIZEOF_INT == 4
     return nm::INT32;
-
 #else
-  case T_FIXNUM:
     return nm::INT16;
-
-# endif
 #endif
-
-  case T_BIGNUM:
+  else if (RB_TYPE_P(v, T_BIGNUM))
     return nm::INT64;
-
 #if SIZEOF_FLOAT == 4
-  case T_COMPLEX:
+  else if (RB_TYPE_P(v, T_COMPLEX))
     return nm::COMPLEX128;
-
-  case T_FLOAT:
+  else if (RB_TYPE_P(v, T_FLOAT))
     return nm::FLOAT64;
-
-#else
-# if SIZEOF_FLOAT == 2
-  case T_COMPLEX:
+#elif SIZEOF_FLOAT == 2
+  else if (RB_TYPE_P(v, T_COMPLEX))
     return nm::COMPLEX64;
-
-  case T_FLOAT:
+  else if (RB_TYPE_P(v, T_FLOAT))
     return nm::FLOAT32;
-# endif
 #endif
-
-  case T_ARRAY:
+  else if (RB_TYPE_P(v, T_ARRAY))
     /*
      * May be passed for dense -- for now, just look at the first element.
      *
      * TODO: Look at entire array for most specific type.
      */
-
     return nm_dtype_guess(RARRAY_AREF(v, 0));
-
-  default:
+  else {
     RB_P(v);
     rb_raise(rb_eArgError, "Unable to guess a data type from provided parameters; data type must be specified manually.");
   }
@@ -2685,23 +2664,6 @@ static SLICE* get_slice(size_t dim, int argc, VALUE* arg, size_t* shape) {
       slice->single     = false;
       t++;
 
-    } else if (TYPE(arg[t]) == T_HASH) { // 3:5 notation (inclusive)
-      VALUE begin_end   = rb_funcall(v, rb_intern("shift"), 0); // rb_hash_shift
-      nm_register_value(&begin_end);
-
-      if (rb_ary_entry(begin_end, 0) >= 0)
-        slice->coords[r]  = FIX2INT(rb_ary_entry(begin_end, 0));
-      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
-        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
-      slice->single = false;
-      nm_unregister_value(&begin_end);
-
     } else if (CLASS_OF(v) == rb_cRange) {
       rb_range_values(arg[t], &beg, &end, &excl);
 
@@ -2721,7 +2683,7 @@ static SLICE* get_slice(size_t dim, int argc, VALUE* arg, size_t* shape) {
 
     } else {
       NM_CONSERVATIVE(nm_unregister_values(arg, argc));
-      rb_raise(rb_eArgError, "expected Fixnum, Range, or Hash for slice component instead of %s", rb_obj_classname(v));
+      rb_raise(rb_eArgError, "expected Fixnum or Range for slice component instead of %s", rb_obj_classname(v));
     }
 
     if (slice->coords[r] > shape[r] || slice->coords[r] + slice->lengths[r] > shape[r]) {
@@ -2773,7 +2735,7 @@ static nm::dtype_t interpret_dtype(int argc, VALUE* argv, nm::stype_t stype) {
   if (SYMBOL_P(argv[offset])) {
     return nm_dtype_from_rbsymbol(argv[offset]);
 
-  } else if (TYPE(argv[offset]) == T_STRING) {
+  } else if (RB_TYPE_P(argv[offset], T_STRING)) {
     return nm_dtype_from_rbstring(StringValue(argv[offset]));
 
   } else if (stype == nm::YALE_STORE) {
@@ -2793,7 +2755,7 @@ static void* interpret_initial_value(VALUE arg, nm::dtype_t dtype) {
   unsigned int index;
   void* init_val;
 
-  if (TYPE(arg) == T_ARRAY) {
+  if (RB_TYPE_P(arg, T_ARRAY)) {
     // Array
     init_val = NM_ALLOC_N(char, DTYPE_SIZES[dtype] * RARRAY_LEN(arg));
     NM_CHECK_ALLOC(init_val);
@@ -2820,7 +2782,7 @@ static size_t* interpret_shape(VALUE arg, size_t* dim) {
   NM_CONSERVATIVE(nm_register_value(&arg));
   size_t* shape;
 
-  if (TYPE(arg) == T_ARRAY) {
+  if (RB_TYPE_P(arg, T_ARRAY)) {
     *dim = RARRAY_LEN(arg);
     shape = NM_ALLOC_N(size_t, *dim);
 
@@ -2851,7 +2813,7 @@ static nm::stype_t interpret_stype(VALUE arg) {
   if (SYMBOL_P(arg)) {
     return nm_stype_from_rbsymbol(arg);
 
-  } else if (TYPE(arg) == T_STRING) {
+  } else if (RB_TYPE_P(arg, T_STRING)) {
     return nm_stype_from_rbstring(StringValue(arg));
 
   } else {
@@ -3044,12 +3006,12 @@ static VALUE nm_det_exact(VALUE self) {
   nm::dtype_t dtype = NM_DTYPE(self);
   nm_math_det_exact(NM_SHAPE0(self), NM_STORAGE_DENSE(self)->elements, NM_SHAPE0(self), NM_DTYPE(self), result);
 
+  VALUE to_return;
   if (dtype == nm::RUBYOBJ) {
-    nm_register_values(reinterpret_cast<VALUE*>(result), 1);
-  }
-  VALUE to_return = nm::rubyobj_from_cval(result, NM_DTYPE(self)).rval;
-  if (dtype == nm::RUBYOBJ) {
-    nm_unregister_values(reinterpret_cast<VALUE*>(result), 1);
+    to_return = *reinterpret_cast<VALUE*>(result);
+
+  } else {
+    to_return = nm::rubyobj_from_cval(result, NM_DTYPE(self)).rval;
   }
   NM_CONSERVATIVE(nm_unregister_value(&self));
 

data/ext/nmatrix/storage/common.h

@@ -34,6 +34,7 @@
 
 #include <ruby.h>
 #include <cmath> // pow().
+#include <type_traits>
 
 /*
  * Project Includes
@@ -45,6 +46,11 @@
  * Macros
  */
 
+#define u_int8_t static_assert(false, "Please use uint8_t for cross-platform support and consistency."); uint8_t
+#define u_int16_t static_assert(false, "Please use uint16_t for cross-platform support and consistency."); uint16_t
+#define u_int32_t static_assert(false, "Please use uint32_t for cross-platform support and consistency."); uint32_t
+#define u_int64_t static_assert(false, "Please use uint64_t for cross-platform support and consistency."); uint64_t
+
 extern "C" {
 
 /*
@@ -152,7 +158,7 @@ namespace nm {
   EWOP_INT_INT_DIV(int16_t, int32_t)
   EWOP_INT_INT_DIV(int16_t, int64_t)
   EWOP_INT_INT_DIV(int8_t, int8_t)
-  EWOP_INT_UINT_DIV(int8_t, u_int8_t)
+  EWOP_INT_UINT_DIV(int8_t, uint8_t)
   EWOP_INT_INT_DIV(int8_t, int16_t)
   EWOP_INT_INT_DIV(int8_t, int32_t)
   EWOP_INT_INT_DIV(int8_t, int64_t)
@@ -162,12 +168,12 @@ namespace nm {
   EWOP_UINT_INT_DIV(uint8_t, int32_t)
   EWOP_UINT_INT_DIV(uint8_t, int64_t)
   EWOP_FLOAT_INT_DIV(float, int8_t)
-  EWOP_FLOAT_INT_DIV(float, u_int8_t)
+  EWOP_FLOAT_INT_DIV(float, uint8_t)
   EWOP_FLOAT_INT_DIV(float, int16_t)
   EWOP_FLOAT_INT_DIV(float, int32_t)
   EWOP_FLOAT_INT_DIV(float, int64_t)
   EWOP_FLOAT_INT_DIV(double, int8_t)
-  EWOP_FLOAT_INT_DIV(double, u_int8_t)
+  EWOP_FLOAT_INT_DIV(double, uint8_t)
   EWOP_FLOAT_INT_DIV(double, int16_t)
   EWOP_FLOAT_INT_DIV(double, int32_t)
   EWOP_FLOAT_INT_DIV(double, int64_t)

data/ext/nmatrix/storage/dense/dense.cpp

@@ -140,7 +140,7 @@ namespace nm { namespace dense_storage {
       v                = reinterpret_cast<D*>(t->elements);
       v_size           = nm_storage_count_max_elements(t);
 
-    } else if (TYPE(right) == T_ARRAY) {
+    } else if (RB_TYPE_P(right, T_ARRAY)) {
       
       v_size = RARRAY_LEN(right);
       v      = NM_ALLOC_N(D, v_size);
@@ -875,7 +875,7 @@ namespace nm {
  */
 std::pair<NMATRIX*,bool> interpret_arg_as_dense_nmatrix(VALUE right, nm::dtype_t dtype) {
   NM_CONSERVATIVE(nm_register_value(&right));
-  if (TYPE(right) == T_DATA && (RDATA(right)->dfree == (RUBY_DATA_FUNC)nm_delete || RDATA(right)->dfree == (RUBY_DATA_FUNC)nm_delete_ref)) {
+  if (IsNMatrixType(right)) {
     NMATRIX *r;
     if (NM_STYPE(right) != DENSE_STORE || NM_DTYPE(right) != dtype || NM_SRC(right) != NM_STORAGE(right)) {
       UnwrapNMatrix( right, r );
@@ -888,7 +888,7 @@ std::pair<NMATRIX*,bool> interpret_arg_as_dense_nmatrix(VALUE right, nm::dtype_t
       return std::make_pair(r, false);
     }
     // Do not set v_alloc = true for either of these. It is the responsibility of r/ldtype_r
-  } else if (TYPE(right) == T_DATA) {
+  } else if (RB_TYPE_P(right, T_DATA)) {
     NM_CONSERVATIVE(nm_unregister_value(&right));
     rb_raise(rb_eTypeError, "unrecognized type for slice assignment");
   }
@@ -1018,7 +1018,7 @@ bool eqeq(const DENSE_STORAGE* left, const DENSE_STORAGE* right) {
 template <typename DType>
 bool is_hermitian(const DENSE_STORAGE* mat, int lda) {
   unsigned int i, j;
-  register DType complex_conj;
+  DType complex_conj;
 
   const DType* els = (DType*) mat->elements;