nmatrix 0.0.3 → 0.0.4

data/ext/nmatrix/nmatrix.h

@@ -9,8 +9,8 @@
 //
 // == Copyright Information
 //
-// SciRuby is Copyright (c) 2010 - 2012, Ruby Science Foundation
-// NMatrix is Copyright (c) 2012, Ruby Science Foundation
+// SciRuby is Copyright (c) 2010 - 2013, Ruby Science Foundation
+// NMatrix is Copyright (c) 2013, Ruby Science Foundation
 //
 // Please see LICENSE.txt for additional copyright notices.
 //
@@ -42,8 +42,6 @@
   #include <string.h>
 #endif
 
-
-
 #ifdef BENCHMARK
 	// SOURCE: http://stackoverflow.com/questions/2349776/how-can-i-benchmark-a-c-program-easily
   #ifdef __cplusplus
@@ -55,16 +53,10 @@
 	#endif
 #endif
 
-/*
- * Project Includes
- */
-
-
 /*
  * Macros
  */
 
-
 #define RUBY_ZERO INT2FIX(0)
 
 #ifndef SIZEOF_INT
@@ -112,6 +104,33 @@
 
 #ifdef __cplusplus /* These are the C++ versions of the macros. */
 
+  /*
+   * If no block is given, return an enumerator. This copied straight out of ruby's include/ruby/intern.h.
+   *
+   * rb_enumeratorize is located in enumerator.c.
+   *
+   *    VALUE rb_enumeratorize(VALUE obj, VALUE meth, int argc, VALUE *argv) {
+   *      return enumerator_init(enumerator_allocate(rb_cEnumerator), obj, meth, argc, argv);
+   *    }
+   */
+ #ifdef RUBY_2
+  #ifndef RETURN_SIZED_ENUMERATOR
+   #undef RETURN_SIZED_ENUMERATOR
+   // Ruby 2.0 and higher has rb_enumeratorize_with_size instead of rb_enumeratorize.
+   // We want to support both in the simplest way possible.
+   #define RETURN_SIZED_ENUMERATOR(obj, argc, argv, size_fn) do {   \
+    if (!rb_block_given_p())                                        \
+      return rb_enumeratorize_with_size((obj), ID2SYM(rb_frame_this_func()), (argc), (argv), (size_fn));  \
+    } while (0)
+  #endif
+ #else
+   #undef RETURN_SIZED_ENUMERATOR
+   #define RETURN_SIZED_ENUMERATOR(obj, argc, argv, size_fn) do {				            \
+    if (!rb_block_given_p())					                                              \
+      return rb_enumeratorize((obj), ID2SYM(rb_frame_this_func()), (argc), (argv));	\
+    } while (0)
+ #endif
+
   #define NM_DECL_ENUM(enum_type, name)   nm::enum_type name
   #define NM_DECL_STRUCT(type, name)      type          name;
 
@@ -144,7 +163,7 @@
 #else   /* These are the C versions of the macros. */
 
   #define NM_DECL_ENUM(enum_type, name)   nm_ ## enum_type name
-  #define NM_DECL_STRUCT(type, name)      NM_ ## type      name;
+  #define NM_DECL_STRUCT(type, name)      struct NM_ ## type      name;
 
   #define NM_DEF_STORAGE_ELEMENTS   \
     NM_DECL_ENUM(dtype_t, dtype);   \
@@ -313,28 +332,30 @@ NM_DEF_STRUCT_POST(NMATRIX);  // };
   (rb_obj_is_kind_of(obj, cNVector) == Qtrue)
 
 
+#ifdef __cplusplus
 typedef VALUE (*METHOD)(...);
 
-#ifdef __cplusplus
 //}; // end of namespace nm
 #endif
 
-/*
- * Data
- */
-
 /*
  * Functions
  */
 
+#ifdef __cplusplus
 extern "C" {
+#endif
+
 	void Init_nmatrix();
-	
+
 	// External API
 	VALUE rb_nmatrix_dense_create(NM_DECL_ENUM(dtype_t, dtype), size_t* shape, size_t dim, void* elements, size_t length);
 	VALUE rb_nvector_dense_create(NM_DECL_ENUM(dtype_t, dtype), void* elements, size_t length);
 
 	NM_DECL_ENUM(dtype_t, nm_dtype_guess(VALUE));   // (This is a function)
+
+#ifdef __cplusplus
 }
+#endif
 
 #endif // NMATRIX_H

data/ext/nmatrix/ruby_constants.cpp

@@ -9,8 +9,8 @@
 //
 // == Copyright Information
 //
-// SciRuby is Copyright (c) 2010 - 2012, Ruby Science Foundation
-// NMatrix is Copyright (c) 2012, Ruby Science Foundation
+// SciRuby is Copyright (c) 2010 - 2013, Ruby Science Foundation
+// NMatrix is Copyright (c) 2013, Ruby Science Foundation
 //
 // Please see LICENSE.txt for additional copyright notices.
 //
@@ -31,14 +31,6 @@
 
 #include <ruby.h>
 
-/*
- * Project Includes
- */
-
-/*
- * Macros
- */
-
 /*
  * Global Variables
  */
@@ -89,10 +81,6 @@ VALUE cNMatrix,
 			nm_eDataTypeError,
 			nm_eStorageTypeError;
 
-/*
- * Forward Declarations
- */
-
 /*
  * Functions
  */
@@ -135,4 +123,3 @@ void nm_init_ruby_constants(void) {
 	nm_rb_unit              = rb_intern("unit");
 	nm_rb_nonunit           = rb_intern("nonunit");
 }
-

data/ext/nmatrix/ruby_constants.h

@@ -9,8 +9,8 @@
 //
 // == Copyright Information
 //
-// SciRuby is Copyright (c) 2010 - 2012, Ruby Science Foundation
-// NMatrix is Copyright (c) 2012, Ruby Science Foundation
+// SciRuby is Copyright (c) 2010 - 2013, Ruby Science Foundation
+// NMatrix is Copyright (c) 2013, Ruby Science Foundation
 //
 // Please see LICENSE.txt for additional copyright notices.
 //
@@ -34,18 +34,6 @@
 
 #include <ruby.h>
 
-/*
- * Project Includes
- */
-
-/*
- * Macros
- */
-
-/*
- * Types
- */
-
 /*
  * Data
  */

data/ext/nmatrix/storage/common.cpp

@@ -9,8 +9,8 @@
 //
 // == Copyright Information
 //
-// SciRuby is Copyright (c) 2010 - 2012, Ruby Science Foundation
-// NMatrix is Copyright (c) 2012, Ruby Science Foundation
+// SciRuby is Copyright (c) 2010 - 2013, Ruby Science Foundation
+// NMatrix is Copyright (c) 2013, Ruby Science Foundation
 //
 // Please see LICENSE.txt for additional copyright notices.
 //

data/ext/nmatrix/storage/common.h

@@ -9,8 +9,8 @@
 //
 // == Copyright Information
 //
-// SciRuby is Copyright (c) 2010 - 2012, Ruby Science Foundation
-// NMatrix is Copyright (c) 2012, Ruby Science Foundation
+// SciRuby is Copyright (c) 2010 - 2013, Ruby Science Foundation
+// NMatrix is Copyright (c) 2013, Ruby Science Foundation
 //
 // Please see LICENSE.txt for additional copyright notices.
 //

data/ext/nmatrix/storage/dense.cpp

@@ -9,8 +9,8 @@
 //
 // == Copyright Information
 //
-// SciRuby is Copyright (c) 2010 - 2012, Ruby Science Foundation
-// NMatrix is Copyright (c) 2012, Ruby Science Foundation
+// SciRuby is Copyright (c) 2010 - 2013, Ruby Science Foundation
+// NMatrix is Copyright (c) 2013, Ruby Science Foundation
 //
 // Please see LICENSE.txt for additional copyright notices.
 //
@@ -55,6 +55,9 @@
 
 namespace nm { namespace dense_storage {
 
+  template<typename LDType, typename RDType>
+  void ref_slice_copy_transposed(const DENSE_STORAGE* rhs, DENSE_STORAGE* lhs);
+
   template <typename LDType, typename RDType>
   DENSE_STORAGE* cast_copy(const DENSE_STORAGE* rhs, nm::dtype_t new_dtype);
 	
@@ -89,13 +92,14 @@ static void slice_copy(DENSE_STORAGE *dest, const DENSE_STORAGE *src, size_t* le
 // Lifecycle //
 ///////////////
 
+
 /*
- * Note that elements and elements_length are for initial value(s) passed in.
- * If they are the correct length, they will be used directly. If not, they
- * will be concatenated over and over again into a new elements array. If
- * elements is NULL, the new elements array will not be initialized.
+ * This creates a dummy with all the properties of dense storage, but no actual elements allocation.
+ *
+ * elements will be NULL when this function finishes. You can clean up with nm_dense_storage_delete, which will
+ * check for that NULL pointer before freeing elements.
  */
-DENSE_STORAGE* nm_dense_storage_create(nm::dtype_t dtype, size_t* shape, size_t dim, void* elements, size_t elements_length) {
+static DENSE_STORAGE* nm_dense_storage_create_dummy(nm::dtype_t dtype, size_t* shape, size_t dim) {
   DENSE_STORAGE* s = ALLOC( DENSE_STORAGE );
 
   s->dim        = dim;
@@ -108,12 +112,27 @@ DENSE_STORAGE* nm_dense_storage_create(nm::dtype_t dtype, size_t* shape, size_t
   s->stride     = stride(shape, dim);
   s->count      = 1;
   s->src        = s;
-	
-	size_t count  = nm_storage_count_max_elements(s);
+
+	s->elements   = NULL;
+
+  return s;
+}
+
+
+/*
+ * Note that elements and elements_length are for initial value(s) passed in.
+ * If they are the correct length, they will be used directly. If not, they
+ * will be concatenated over and over again into a new elements array. If
+ * elements is NULL, the new elements array will not be initialized.
+ */
+DENSE_STORAGE* nm_dense_storage_create(nm::dtype_t dtype, size_t* shape, size_t dim, void* elements, size_t elements_length) {
+
+  DENSE_STORAGE* s = nm_dense_storage_create_dummy(dtype, shape, dim);
+  size_t count  = nm_storage_count_max_elements(s);
 
   if (elements_length == count) {
   	s->elements = elements;
-  	
+    
   } else {
     s->elements = ALLOC_N(char, DTYPE_SIZES[dtype]*count);
 
@@ -138,8 +157,9 @@ DENSE_STORAGE* nm_dense_storage_create(nm::dtype_t dtype, size_t* shape, size_t
   return s;
 }
 
+
 /*
- * Destructor for dense storage
+ * Destructor for dense storage. Make sure when you update this you also update nm_dense_storage_delete_dummy.
  */
 void nm_dense_storage_delete(STORAGE* s) {
   // Sometimes Ruby passes in NULL storage for some reason (probably on copy construction failure).
@@ -149,7 +169,8 @@ void nm_dense_storage_delete(STORAGE* s) {
       free(storage->shape);
       free(storage->offset);
       free(storage->stride);
-      free(storage->elements);
+      if (storage->elements != NULL) // happens with dummy objects
+        free(storage->elements);
       free(storage);
     }
   }
@@ -188,6 +209,101 @@ void nm_dense_storage_mark(void* storage_base) {
 // Accessors //
 ///////////////
 
+
+// Helper function used only for the RETURN_SIZED_ENUMERATOR macro. Returns the length of
+// the matrix's storage.
+static VALUE nm_dense_enumerator_length(VALUE nmatrix) {
+  long len = nm_storage_count_max_elements(NM_STORAGE_DENSE(nmatrix));
+  return LONG2NUM(len);
+}
+
+
+VALUE nm_dense_each_with_indices(VALUE nmatrix) {
+  volatile VALUE nm = nmatrix;
+
+  DENSE_STORAGE* s = NM_STORAGE_DENSE(nm);
+
+  RETURN_SIZED_ENUMERATOR(nm, 0, 0, nm_dense_enumerator_length); // fourth argument only used by Ruby2+
+
+  // Create indices and initialize them to zero
+  size_t* coords = ALLOCA_N(size_t, s->dim);
+  memset(coords, 0, sizeof(size_t) * s->dim);
+
+  size_t slice_index;
+  size_t* shape_copy = ALLOC_N(size_t, s->dim);
+  memcpy(shape_copy, s->shape, sizeof(size_t) * s->dim);
+
+  DENSE_STORAGE* sliced_dummy = nm_dense_storage_create_dummy(s->dtype, shape_copy, s->dim);
+
+  for (size_t k = 0; k < nm_storage_count_max_elements(s); ++k) {
+    nm_dense_storage_coords(sliced_dummy, k, coords);
+    slice_index = nm_dense_storage_pos(s, coords);
+    VALUE ary = rb_ary_new();
+    if (NM_DTYPE(nm) == nm::RUBYOBJ) rb_ary_push(ary, reinterpret_cast<VALUE*>(s->elements)[slice_index]);
+    else rb_ary_push(ary, rubyobj_from_cval((char*)(s->elements) + slice_index*DTYPE_SIZES[NM_DTYPE(nm)], NM_DTYPE(nm)).rval);
+
+    for (size_t p = 0; p < s->dim; ++p) {
+      rb_ary_push(ary, INT2FIX(coords[p]));
+    }
+
+    // yield the array which now consists of the value and the indices
+    rb_yield(ary);
+
+  }
+
+  nm_dense_storage_delete(sliced_dummy);
+
+  return Qnil;
+
+}
+
+
+/*
+ * Borrowed this function from NArray. Handles 'each' iteration on a dense
+ * matrix.
+ *
+ * Additionally, handles separately matrices containing VALUEs and matrices
+ * containing other types of data.
+ */
+VALUE nm_dense_each(VALUE nmatrix) {
+  volatile VALUE nm = nmatrix; // Not sure this actually does anything.
+  DENSE_STORAGE* s = NM_STORAGE_DENSE(nm);
+
+  RETURN_SIZED_ENUMERATOR(nm, 0, 0, nm_storage_count_max_elements(s));
+
+  size_t* temp_coords = ALLOCA_N(size_t, s->dim);
+  size_t sliced_index;
+  size_t* shape_copy = ALLOC_N(size_t, s->dim);
+  memcpy(shape_copy, s->shape, sizeof(size_t) * s->dim);
+  DENSE_STORAGE* sliced_dummy = nm_dense_storage_create_dummy(s->dtype, shape_copy, s->dim);
+
+  if (NM_DTYPE(nm) == nm::RUBYOBJ) {
+
+    // matrix of Ruby objects -- yield those objects directly
+    for (size_t i = 0; i < nm_storage_count_max_elements(s); ++i)
+      nm_dense_storage_coords(sliced_dummy, i, temp_coords);
+      sliced_index = nm_dense_storage_pos(s, temp_coords);
+      rb_yield( reinterpret_cast<VALUE*>(s->elements)[sliced_index] );
+
+  } else {
+
+    // We're going to copy the matrix element into a Ruby VALUE and then operate on it. This way user can't accidentally
+    // modify it and cause a seg fault.
+    for (size_t i = 0; i < nm_storage_count_max_elements(s); ++i) {
+      nm_dense_storage_coords(sliced_dummy, i, temp_coords);
+      sliced_index = nm_dense_storage_pos(s, temp_coords);
+      VALUE v = rubyobj_from_cval((char*)(s->elements) + sliced_index*DTYPE_SIZES[NM_DTYPE(nm)], NM_DTYPE(nm)).rval;
+      rb_yield( v ); // yield to the copy we made
+    }
+  }
+
+  nm_dense_storage_delete(sliced_dummy);
+
+  return Qnil;
+  
+}
+
+
 /*
  * Get a slice or one element, using copying.
  *
@@ -348,6 +464,25 @@ size_t nm_dense_storage_pos(const DENSE_STORAGE* s, const size_t* coords) {
     pos += (coords[i] + s->offset[i]) * s->stride[i];
 
   return pos;
+
+}
+
+/*
+ * Determine the a set of slice coordinates from linear array position (in elements 
+ * of s) of some set of coordinates (given by slice).  (Inverse of
+ * nm_dense_storage_pos).  
+ *
+ * The parameter coords_out should be a pre-allocated array of size equal to s->dim.
+ */
+void nm_dense_storage_coords(const DENSE_STORAGE* s, const size_t slice_pos, size_t* coords_out) {
+
+  size_t temp_pos = slice_pos;
+
+  for (size_t i = 0; i < s->dim; ++i) {
+    coords_out[i] = (temp_pos - temp_pos % s->stride[i])/s->stride[i] - s->offset[i];
+    temp_pos = temp_pos % s->stride[i];
+  }
+
 }
 
 /*
@@ -454,7 +589,12 @@ STORAGE* nm_dense_storage_copy_transposed(const STORAGE* rhs_base) {
   lhs->offset[0] = rhs->offset[1];
   lhs->offset[1] = rhs->offset[0];
 
-  nm_math_transpose_generic(rhs->shape[0], rhs->shape[1], rhs->elements, rhs->shape[1], lhs->elements, lhs->shape[1], DTYPE_SIZES[rhs->dtype]);
+  if (rhs_base->src == rhs_base) {
+    nm_math_transpose_generic(rhs->shape[0], rhs->shape[1], rhs->elements, rhs->shape[1], lhs->elements, lhs->shape[1], DTYPE_SIZES[rhs->dtype]);
+  } else {
+    NAMED_LR_DTYPE_TEMPLATE_TABLE(ttable, nm::dense_storage::ref_slice_copy_transposed, void, const DENSE_STORAGE* rhs, DENSE_STORAGE* lhs);
+    ttable[lhs->dtype][rhs->dtype](rhs, lhs);
+  }
 
   return (STORAGE*)lhs;
 }
@@ -467,6 +607,25 @@ namespace nm { namespace dense_storage {
 // Templated Functions //
 /////////////////////////
 
+template<typename LDType, typename RDType>
+void ref_slice_copy_transposed(const DENSE_STORAGE* rhs, DENSE_STORAGE* lhs) {
+
+  LDType* lhs_els = reinterpret_cast<LDType*>(lhs->elements);
+  RDType* rhs_els = reinterpret_cast<RDType*>(rhs->elements);
+
+  size_t count = nm_storage_count_max_elements(lhs);
+  size_t* temp_coords = ALLOCA_N(size_t, lhs->dim);
+  size_t coord_swap_temp;
+
+  while (count-- > 0) {
+    nm_dense_storage_coords(lhs, count, temp_coords);
+    NM_SWAP(temp_coords[0], temp_coords[1], coord_swap_temp);
+    size_t r_coord = nm_dense_storage_pos(rhs, temp_coords);
+    lhs_els[count] = rhs_els[r_coord];
+  }
+
+}
+
 template <typename LDType, typename RDType>
 DENSE_STORAGE* cast_copy(const DENSE_STORAGE* rhs, dtype_t new_dtype) {
   size_t  count = nm_storage_count_max_elements(rhs);
@@ -584,8 +743,12 @@ bool is_symmetric(const DENSE_STORAGE* mat, int lda) {
 template <ewop_t op, typename LDType, typename RDType>
 static DENSE_STORAGE* ew_op(const DENSE_STORAGE* left, const DENSE_STORAGE* right, const void* rscalar) {
 	unsigned int count;
-	
-	size_t* new_shape = (size_t*)calloc(left->dim, sizeof(size_t));
+  size_t l_count;
+  size_t r_count;
+
+	size_t* temp_coords = ALLOCA_N(size_t, left->dim);
+
+	size_t* new_shape = ALLOC_N(size_t, left->dim);
 	memcpy(new_shape, left->shape, sizeof(size_t) * left->dim);
 
   // Determine the return dtype. This depends on the type of operation we're doing. Usually, it's going to be
@@ -602,36 +765,44 @@ static DENSE_STORAGE* ew_op(const DENSE_STORAGE* left, const DENSE_STORAGE* righ
     if (static_cast<uint8_t>(op) < NUM_NONCOMP_EWOPS) { // use left-dtype
 
       for (count = nm_storage_count_max_elements(result); count-- > 0;) {
-        reinterpret_cast<LDType*>(result->elements)[count] = ew_op_switch<op,LDType,RDType>(l_elems[count], r_elems[count]);
+        nm_dense_storage_coords(result, count, temp_coords);
+        l_count = nm_dense_storage_pos(left, temp_coords);
+        r_count = nm_dense_storage_pos(right, temp_coords);
+        
+        reinterpret_cast<LDType*>(result->elements)[count] = ew_op_switch<op,LDType,RDType>(l_elems[l_count], r_elems[r_count]);
       }
 
     } else { // new_dtype is BYTE: comparison operators
       uint8_t* res_elems = reinterpret_cast<uint8_t*>(result->elements);
 
       for (count = nm_storage_count_max_elements(result); count-- > 0;) {
+        nm_dense_storage_coords(result, count, temp_coords);
+        l_count = nm_dense_storage_pos(left, temp_coords);
+        r_count = nm_dense_storage_pos(right, temp_coords);
+
         switch (op) {
           case EW_EQEQ:
-            res_elems[count] = l_elems[count] == r_elems[count];
+            res_elems[count] = l_elems[l_count] == r_elems[r_count];
             break;
 
           case EW_NEQ:
-            res_elems[count] = l_elems[count] != r_elems[count];
+            res_elems[count] = l_elems[l_count] != r_elems[r_count];
             break;
 
           case EW_LT:
-            res_elems[count] = l_elems[count] < r_elems[count];
+            res_elems[count] = l_elems[l_count] < r_elems[r_count];
             break;
 
           case EW_GT:
-            res_elems[count] = l_elems[count] > r_elems[count];
+            res_elems[count] = l_elems[l_count] > r_elems[r_count];
             break;
 
           case EW_LEQ:
-            res_elems[count] = l_elems[count] <= r_elems[count];
+            res_elems[count] = l_elems[l_count] <= r_elems[r_count];
             break;
 
           case EW_GEQ:
-            res_elems[count] = l_elems[count] >= r_elems[count];
+            res_elems[count] = l_elems[l_count] >= r_elems[r_count];
             break;
 
           default:
@@ -646,36 +817,42 @@ static DENSE_STORAGE* ew_op(const DENSE_STORAGE* left, const DENSE_STORAGE* righ
     if (static_cast<uint8_t>(op) < NUM_NONCOMP_EWOPS) { // use left-dtype
 
       for (count = nm_storage_count_max_elements(result); count-- > 0;) {
-        reinterpret_cast<LDType*>(result->elements)[count] = ew_op_switch<op,LDType,RDType>(l_elems[count], *r_elem);
+        nm_dense_storage_coords(result, count, temp_coords);
+        l_count = nm_dense_storage_pos(left, temp_coords);
+
+        reinterpret_cast<LDType*>(result->elements)[count] = ew_op_switch<op,LDType,RDType>(l_elems[l_count], *r_elem);
       }
 
     } else {
       uint8_t* res_elems = reinterpret_cast<uint8_t*>(result->elements);
 
       for (count = nm_storage_count_max_elements(result); count-- > 0;) {
+        nm_dense_storage_coords(result, count, temp_coords);
+        l_count = nm_dense_storage_pos(left, temp_coords);
+        
         switch (op) {
           case EW_EQEQ:
-            res_elems[count] = l_elems[count] == *r_elem;
+            res_elems[count] = l_elems[l_count] == *r_elem;
             break;
 
           case EW_NEQ:
-            res_elems[count] = l_elems[count] != *r_elem;
+            res_elems[count] = l_elems[l_count] != *r_elem;
             break;
 
           case EW_LT:
-            res_elems[count] = l_elems[count] < *r_elem;
+            res_elems[count] = l_elems[l_count] < *r_elem;
             break;
 
           case EW_GT:
-            res_elems[count] = l_elems[count] > *r_elem;
+            res_elems[count] = l_elems[l_count] > *r_elem;
             break;
 
           case EW_LEQ:
-            res_elems[count] = l_elems[count] <= *r_elem;
+            res_elems[count] = l_elems[l_count] <= *r_elem;
             break;
 
           case EW_GEQ:
-            res_elems[count] = l_elems[count] >= *r_elem;
+            res_elems[count] = l_elems[l_count] >= *r_elem;
             break;
 
           default:
@@ -685,7 +862,6 @@ static DENSE_STORAGE* ew_op(const DENSE_STORAGE* left, const DENSE_STORAGE* righ
 
     }
   }
-	
 	return result;
 }
 
@@ -707,7 +883,6 @@ static DENSE_STORAGE* matrix_multiply(const STORAGE_PAIR& casted_storage, size_t
   *pAlpha = 1;
   *pBeta = 0;
   // Do the multiplication
-
   if (vector) nm::math::gemv<DType>(CblasNoTrans, left->shape[0], left->shape[1], pAlpha,
                                     reinterpret_cast<DType*>(left->elements), left->shape[1],
                                     reinterpret_cast<DType*>(right->elements), 1, pBeta,