nmatrix 0.0.2 → 0.0.3

data/ext/nmatrix/nmatrix.h

@@ -112,8 +112,8 @@
 
 #ifdef __cplusplus /* These are the C++ versions of the macros. */
 
-  #define NM_DECL_ENUM(enum_type, name)   enum_type name;
-  #define NM_DECL_STRUCT(type, name)      type      name;
+  #define NM_DECL_ENUM(enum_type, name)   nm::enum_type name
+  #define NM_DECL_STRUCT(type, name)      type          name;
 
   #define NM_DEF_STORAGE_ELEMENTS    \
     NM_DECL_ENUM(dtype_t, dtype);    \
@@ -135,13 +135,15 @@
   #define NM_DEF_STRUCT_POST(name) };
 
   #define NM_DEF_ENUM(name, ...)          \
-    enum name {                           \
-      __VA_ARGS__                         \
-    };
+    namespace nm {                        \
+      enum name {                         \
+        __VA_ARGS__                       \
+      };                                  \
+    } // end of namespace nm
 
 #else   /* These are the C versions of the macros. */
 
-  #define NM_DECL_ENUM(enum_type, name)   nm_ ## enum_type name;
+  #define NM_DECL_ENUM(enum_type, name)   nm_ ## enum_type name
   #define NM_DECL_STRUCT(type, name)      NM_ ## type      name;
 
   #define NM_DEF_STORAGE_ELEMENTS   \
@@ -160,7 +162,6 @@
   typedef struct NM_STORAGE {        \
     NM_DEF_STORAGE_ELEMENTS;         \
   } NM_STORAGE;
->>>>>>> compile_point
 
   #define NM_DEF_STRUCT_PRE(name)                typedef struct NM_ ## name {
   #define NM_DEF_STRUCT_POST(name)               } NM_ ## name;
@@ -181,11 +182,9 @@
 #define NM_NUM_ITYPES 4   // data/data.h
 #define NM_NUM_STYPES 3   // storage/storage.h
 
-#ifndef __cplusplus
+//#ifdef __cplusplus
 //namespace nm {
-#else
-
-#endif
+//#endif
 
 /* Storage Type -- Dense or Sparse */
 NM_DEF_ENUM(stype_t,  DENSE_STORE = 0,
@@ -213,6 +212,17 @@ NM_DEF_ENUM(itype_t,  UINT8  = 0,
                       UINT32 = 2,
                       UINT64 = 3);
 
+NM_DEF_ENUM(symm_t,   NONSYMM   = 0,
+                      SYMM      = 1,
+                      SKEW      = 2,
+                      HERM      = 3,
+                      UPPER     = 4,
+                      LOWER     = 5);
+
+//#ifdef __cplusplus
+//}; // end of namespace nm
+//#endif
+
 /* struct STORAGE */
 NM_DEF_STORAGE_STRUCT;
 
@@ -227,7 +237,7 @@ NM_DEF_STORAGE_CHILD_STRUCT_PRE(YALE_STORAGE);
 	void* a;      // should go first
 	size_t ndnz; // Strictly non-diagonal non-zero count!
 	size_t	capacity;
-	itype_t	itype;
+	NM_DECL_ENUM(itype_t, itype);
 	void*		ija;
 NM_DEF_STORAGE_STRUCT_POST(YALE_STORAGE);
 
@@ -321,8 +331,10 @@ extern "C" {
 	void Init_nmatrix();
 	
 	// External API
-	VALUE rb_nmatrix_dense_create(dtype_t dtype, size_t* shape, size_t dim, void* elements, size_t length);
-	VALUE rb_nvector_dense_create(dtype_t dtype, void* elements, size_t length);
+	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)
 }
 
 #endif // NMATRIX_H

data/ext/nmatrix/ruby_constants.cpp

@@ -68,6 +68,8 @@ ID	nm_rb_real,
 		nm_rb_mul,
 		nm_rb_div,
 
+		nm_rb_negate,
+
 		nm_rb_percent,
 		nm_rb_gt,
 		nm_rb_lt,
@@ -116,6 +118,8 @@ void nm_init_ruby_constants(void) {
 	nm_rb_mul								= rb_intern("*");
 	nm_rb_div								= rb_intern("/");
 
+	nm_rb_negate            = rb_intern("-@");
+
 	nm_rb_percent						= rb_intern("%");
 	nm_rb_gt								= rb_intern(">");
 	nm_rb_lt								= rb_intern("<");

data/ext/nmatrix/ruby_constants.h

@@ -74,6 +74,8 @@ extern ID nm_rb_real,
 					nm_rb_sub,
 					nm_rb_mul,
 					nm_rb_div,
+
+					nm_rb_negate,
 		
 					nm_rb_percent,
 					nm_rb_gt,

data/ext/nmatrix/storage/dense.cpp

@@ -56,13 +56,13 @@
 namespace nm { namespace dense_storage {
 
   template <typename LDType, typename RDType>
-  DENSE_STORAGE* cast_copy(const DENSE_STORAGE* rhs, dtype_t new_dtype);
+  DENSE_STORAGE* cast_copy(const DENSE_STORAGE* rhs, nm::dtype_t new_dtype);
 	
 	template <typename LDType, typename RDType>
 	bool eqeq(const DENSE_STORAGE* left, const DENSE_STORAGE* right);
 	
 	template <ewop_t op, typename LDType, typename RDType>
-	static DENSE_STORAGE* ew_op(const DENSE_STORAGE* left, const DENSE_STORAGE* right);
+	static DENSE_STORAGE* ew_op(const DENSE_STORAGE* left, const DENSE_STORAGE* right, const void* rscalar);
 
   template <typename DType>
   static DENSE_STORAGE* matrix_multiply(const STORAGE_PAIR& casted_storage, size_t* resulting_shape, bool vector);
@@ -95,7 +95,7 @@ static void slice_copy(DENSE_STORAGE *dest, const DENSE_STORAGE *src, size_t* le
  * 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(dtype_t dtype, size_t* shape, size_t dim, void* elements, size_t elements_length) {
+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 = ALLOC( DENSE_STORAGE );
 
   s->dim        = dim;
@@ -175,7 +175,7 @@ void nm_dense_storage_delete_ref(STORAGE* s) {
 void nm_dense_storage_mark(void* storage_base) {
   DENSE_STORAGE* storage = (DENSE_STORAGE*)storage_base;
 
-  if (storage && storage->dtype == RUBYOBJ) {
+  if (storage && storage->dtype == nm::RUBYOBJ) {
     VALUE* els = reinterpret_cast<VALUE*>(storage->elements);
 
   	for (size_t index = nm_storage_count_max_elements(storage); index-- > 0;) {
@@ -281,10 +281,10 @@ bool nm_dense_storage_eqeq(const STORAGE* left, const STORAGE* right) {
  * dtype of Complex64 or Complex128 this is the same as testing for symmetry.
  */
 bool nm_dense_storage_is_hermitian(const DENSE_STORAGE* mat, int lda) {
-	if (mat->dtype == COMPLEX64) {
+	if (mat->dtype == nm::COMPLEX64) {
 		return nm::dense_storage::is_hermitian<nm::Complex64>(mat, lda);
 		
-	} else if (mat->dtype == COMPLEX128) {
+	} else if (mat->dtype == nm::COMPLEX128) {
 		return nm::dense_storage::is_hermitian<nm::Complex128>(mat, lda);
 		
 	} else {
@@ -306,12 +306,22 @@ bool nm_dense_storage_is_symmetric(const DENSE_STORAGE* mat, int lda) {
 //////////
 
 /*
- * Dense element-wise operations.
+ * Dense matrix-matrix and matrix-scalar element-wise operations.
+ *
+ * right or rscalar should be NULL; they should not both be initialized. If right is NULL, it'll use the scalar value instead.
  */
-STORAGE* nm_dense_storage_ew_op(nm::ewop_t op, const STORAGE* left, const STORAGE* right) {
-	OP_LR_DTYPE_TEMPLATE_TABLE(nm::dense_storage::ew_op, DENSE_STORAGE*, const DENSE_STORAGE* left, const DENSE_STORAGE* right);
+STORAGE* nm_dense_storage_ew_op(nm::ewop_t op, const STORAGE* left, const STORAGE* right, VALUE scalar) {
+	OP_LR_DTYPE_TEMPLATE_TABLE(nm::dense_storage::ew_op, DENSE_STORAGE*, const DENSE_STORAGE* left, const DENSE_STORAGE* right, const void*);
+
+	if (right)
+	  return ttable[op][left->dtype][right->dtype](reinterpret_cast<const DENSE_STORAGE*>(left), reinterpret_cast<const DENSE_STORAGE*>(right), NULL);
+	else {
+	  nm::dtype_t r_dtype = nm_dtype_guess(scalar);
+	  void* r_scalar  = ALLOCA_N(char, DTYPE_SIZES[r_dtype]);
+	  rubyval_to_cval(scalar, r_dtype, r_scalar);
 
-	return ttable[op][left->dtype][right->dtype](reinterpret_cast<const DENSE_STORAGE*>(left), reinterpret_cast<const DENSE_STORAGE*>(right));
+    return ttable[op][left->dtype][r_dtype](reinterpret_cast<const DENSE_STORAGE*>(left), NULL, r_scalar);
+	}
 }
 
 /*
@@ -383,8 +393,8 @@ static void slice_copy(DENSE_STORAGE *dest, const DENSE_STORAGE *src, size_t* le
 /*
  * Copy dense storage, changing dtype if necessary.
  */
-STORAGE* nm_dense_storage_cast_copy(const STORAGE* rhs, dtype_t new_dtype) {
-	NAMED_LR_DTYPE_TEMPLATE_TABLE(ttable, nm::dense_storage::cast_copy, DENSE_STORAGE*, const DENSE_STORAGE* rhs, dtype_t new_dtype);
+STORAGE* nm_dense_storage_cast_copy(const STORAGE* rhs, nm::dtype_t new_dtype) {
+	NAMED_LR_DTYPE_TEMPLATE_TABLE(ttable, nm::dense_storage::cast_copy, DENSE_STORAGE*, const DENSE_STORAGE* rhs, nm::dtype_t new_dtype);
 
 	return (STORAGE*)ttable[new_dtype][rhs->dtype]((DENSE_STORAGE*)rhs, new_dtype);
 }
@@ -572,7 +582,7 @@ bool is_symmetric(const DENSE_STORAGE* mat, int lda) {
  * Templated dense storage element-wise operations which return the same DType.
  */
 template <ewop_t op, typename LDType, typename RDType>
-static DENSE_STORAGE* ew_op(const DENSE_STORAGE* left, const DENSE_STORAGE* right) {
+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));
@@ -585,46 +595,94 @@ static DENSE_STORAGE* ew_op(const DENSE_STORAGE* left, const DENSE_STORAGE* righ
 	DENSE_STORAGE* result = nm_dense_storage_create(new_dtype, new_shape, left->dim, NULL, 0);
 	
 	LDType* l_elems = reinterpret_cast<LDType*>(left->elements);
-	RDType* r_elems = reinterpret_cast<RDType*>(right->elements);
 
-	if (static_cast<uint8_t>(op) < NUM_NONCOMP_EWOPS) { // use left-dtype
+	if (right) { // matrix-matrix operation
+	  RDType* r_elems = reinterpret_cast<RDType*>(right->elements);
+
+    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]);
+      }
+
+    } 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;) {
+        switch (op) {
+          case EW_EQEQ:
+            res_elems[count] = l_elems[count] == r_elems[count];
+            break;
+
+          case EW_NEQ:
+            res_elems[count] = l_elems[count] != r_elems[count];
+            break;
+
+          case EW_LT:
+            res_elems[count] = l_elems[count] < r_elems[count];
+            break;
+
+          case EW_GT:
+            res_elems[count] = l_elems[count] > r_elems[count];
+            break;
 
-    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]);
+          case EW_LEQ:
+            res_elems[count] = l_elems[count] <= r_elems[count];
+            break;
+
+          case EW_GEQ:
+            res_elems[count] = l_elems[count] >= r_elems[count];
+            break;
+
+          default:
+            rb_raise(rb_eStandardError, "this should not happen");
+        }
+      }
     }
 
-  } else { // new_dtype is BYTE: comparison operators
-    uint8_t* res_elems = reinterpret_cast<uint8_t*>(result->elements);
+  } else { // matrix-scalar operation
+    const RDType* r_elem = reinterpret_cast<const RDType*>(rscalar);
 
-    for (count = nm_storage_count_max_elements(result); count-- > 0;) {
-      switch (op) {
-        case EW_EQEQ:
-          res_elems[count] = l_elems[count] == r_elems[count];
-          break;
+    if (static_cast<uint8_t>(op) < NUM_NONCOMP_EWOPS) { // use left-dtype
 
-        case EW_NEQ:
-          res_elems[count] = l_elems[count] != r_elems[count];
-          break;
+      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);
+      }
 
-        case EW_LT:
-          res_elems[count] = l_elems[count] < r_elems[count];
-          break;
+    } else {
+      uint8_t* res_elems = reinterpret_cast<uint8_t*>(result->elements);
 
-        case EW_GT:
-          res_elems[count] = l_elems[count] > r_elems[count];
-          break;
+      for (count = nm_storage_count_max_elements(result); count-- > 0;) {
+        switch (op) {
+          case EW_EQEQ:
+            res_elems[count] = l_elems[count] == *r_elem;
+            break;
 
-        case EW_LEQ:
-          res_elems[count] = l_elems[count] <= r_elems[count];
-          break;
+          case EW_NEQ:
+            res_elems[count] = l_elems[count] != *r_elem;
+            break;
 
-        case EW_GEQ:
-          res_elems[count] = l_elems[count] >= r_elems[count];
-          break;
+          case EW_LT:
+            res_elems[count] = l_elems[count] < *r_elem;
+            break;
 
-        default:
-          rb_raise(rb_eStandardError, "this should not happen");
+          case EW_GT:
+            res_elems[count] = l_elems[count] > *r_elem;
+            break;
+
+          case EW_LEQ:
+            res_elems[count] = l_elems[count] <= *r_elem;
+            break;
+
+          case EW_GEQ:
+            res_elems[count] = l_elems[count] >= *r_elem;
+            break;
+
+          default:
+            rb_raise(rb_eStandardError, "this should not happen");
+        }
       }
+
     }
   }
 	

data/ext/nmatrix/storage/dense.h

@@ -69,7 +69,7 @@ extern "C" {
 // Lifecycle //
 ///////////////
 
-DENSE_STORAGE*	nm_dense_storage_create(dtype_t dtype, size_t* shape, size_t dim, void* elements, size_t elements_length);
+DENSE_STORAGE*	nm_dense_storage_create(nm::dtype_t dtype, size_t* shape, size_t dim, void* elements, size_t elements_length);
 void						nm_dense_storage_delete(STORAGE* s);
 void						nm_dense_storage_delete_ref(STORAGE* s);
 void						nm_dense_storage_mark(void*);
@@ -94,7 +94,7 @@ bool nm_dense_storage_is_hermitian(const DENSE_STORAGE* mat, int lda);
 // Math //
 //////////
 
-STORAGE* nm_dense_storage_ew_op(nm::ewop_t op, const STORAGE* left, const STORAGE* right);
+STORAGE* nm_dense_storage_ew_op(nm::ewop_t op, const STORAGE* left, const STORAGE* right, VALUE scalar);
 STORAGE* nm_dense_storage_matrix_multiply(const STORAGE_PAIR& casted_storage, size_t* resulting_shape, bool vector);
 
 /////////////
@@ -109,7 +109,7 @@ size_t nm_dense_storage_pos(const DENSE_STORAGE* s, const size_t* coords);
 
 DENSE_STORAGE*  nm_dense_storage_copy(const DENSE_STORAGE* rhs);
 STORAGE*        nm_dense_storage_copy_transposed(const STORAGE* rhs_base);
-STORAGE*        nm_dense_storage_cast_copy(const STORAGE* rhs, dtype_t new_dtype);
+STORAGE*        nm_dense_storage_cast_copy(const STORAGE* rhs, nm::dtype_t new_dtype);
 
 } // end of extern "C" block
 

data/ext/nmatrix/storage/list.cpp

@@ -340,27 +340,44 @@ bool nm_list_storage_eqeq(const STORAGE* left, const STORAGE* right) {
 
 /*
  * Element-wise operations for list storage.
+ *
+ * If a scalar is given, a temporary matrix is created with that scalar as a default value.
  */
-STORAGE* nm_list_storage_ew_op(nm::ewop_t op, const STORAGE* left, const STORAGE* right) {
-  rb_raise(rb_eNotImpError, "elementwise operations for list storage currently broken");
+STORAGE* nm_list_storage_ew_op(nm::ewop_t op, const STORAGE* left, const STORAGE* right, VALUE scalar) {
+  // rb_raise(rb_eNotImpError, "elementwise operations for list storage currently broken");
 
-	OP_LR_DTYPE_TEMPLATE_TABLE(nm::list_storage::ew_op, void*, LIST* dest, const LIST* left, const void* l_default, const LIST* right, const void* r_default, const size_t* shape, size_t dim);
+  bool cleanup = false;
+  LIST_STORAGE *r, *new_l;
+  const LIST_STORAGE* l = reinterpret_cast<const LIST_STORAGE*>(left);
+
+  if (!right) { // need to build a right-hand matrix temporarily, with default value of 'scalar'
+
+    dtype_t scalar_dtype  = nm_dtype_guess(scalar);
+    void* scalar_init     = rubyobj_to_cval(scalar, scalar_dtype);
+
+    size_t* shape         = ALLOC_N(size_t, l->dim);
+    memcpy(shape, left->shape, sizeof(size_t) * l->dim);
+
+    r = nm_list_storage_create(scalar_dtype, shape, l->dim, scalar_init);
+
+    cleanup = true;
+
+  } else {
+
+    r = reinterpret_cast<LIST_STORAGE*>(const_cast<STORAGE*>(right));
+
+  }
 
   // We may need to upcast our arguments to the same type.
-  dtype_t new_dtype = Upcast[left->dtype][right->dtype];
+  dtype_t new_dtype = Upcast[left->dtype][r->dtype];
 
 	// Make sure we allocate a byte-storing matrix for comparison operations; otherwise, use the argument dtype (new_dtype)
 	dtype_t result_dtype = static_cast<uint8_t>(op) < NUM_NONCOMP_EWOPS ? new_dtype : BYTE;
 
-
-	
-	const LIST_STORAGE* l = reinterpret_cast<const LIST_STORAGE*>(left),
-										* r = reinterpret_cast<const LIST_STORAGE*>(right);
-	
-	LIST_STORAGE* new_l = NULL;
+	OP_LR_DTYPE_TEMPLATE_TABLE(nm::list_storage::ew_op, void*, LIST* dest, const LIST* left, const void* l_default, const LIST* right, const void* r_default, const size_t* shape, size_t dim);
 	
 	// Allocate a new shape array for the resulting matrix.
-	size_t* new_shape = (size_t*)calloc(l->dim, sizeof(size_t));
+	size_t* new_shape = ALLOC_N(size_t, l->dim);
 	memcpy(new_shape, left->shape, sizeof(size_t) * l->dim);
 	
 	// Create the result matrix.
@@ -375,14 +392,19 @@ STORAGE* nm_list_storage_ew_op(nm::ewop_t op, const STORAGE* left, const STORAGE
 		new_l = reinterpret_cast<LIST_STORAGE*>(nm_list_storage_cast_copy(l, new_dtype));
 		
 		result->default_val =
-			ttable[op][new_l->dtype][right->dtype](result->rows, new_l->rows, new_l->default_val, r->rows, r->default_val, result->shape, result->dim);
+			ttable[op][new_l->dtype][r->dtype](result->rows, new_l->rows, new_l->default_val, r->rows, r->default_val, result->shape, result->dim);
 		
 		// Delete the temporary left-hand side matrix.
 		nm_list_storage_delete(reinterpret_cast<STORAGE*>(new_l));
-			
+
 	} else {
 		result->default_val =
-			ttable[op][left->dtype][right->dtype](result->rows, l->rows, l->default_val, r->rows, r->default_val, result->shape, result->dim);
+			ttable[op][left->dtype][r->dtype](result->rows, l->rows, l->default_val, r->rows, r->default_val, result->shape, result->dim);
+	}
+
+  // If we created a temporary scalar matrix (for matrix-scalar operations), we now need to delete it.
+	if (cleanup) {
+	  nm_list_storage_delete(reinterpret_cast<STORAGE*>(r));
 	}
 	
 	return result;

data/ext/nmatrix/storage/list.h

@@ -73,7 +73,7 @@ extern "C" {
   // Lifecycle //
   ///////////////
 
-  LIST_STORAGE*	nm_list_storage_create(dtype_t dtype, size_t* shape, size_t dim, void* init_val);
+  LIST_STORAGE*	nm_list_storage_create(nm::dtype_t dtype, size_t* shape, size_t dim, void* init_val);
   void					nm_list_storage_delete(STORAGE* s);
   void					nm_list_storage_delete_ref(STORAGE* s);
   void					nm_list_storage_mark(void*);
@@ -97,7 +97,7 @@ extern "C" {
   // Math //
   //////////
 
-  STORAGE* nm_list_storage_ew_op(nm::ewop_t op, const STORAGE* left, const STORAGE* right);
+  STORAGE* nm_list_storage_ew_op(nm::ewop_t op, const STORAGE* left, const STORAGE* right, VALUE scalar);
   STORAGE* nm_list_storage_matrix_multiply(const STORAGE_PAIR& casted_storage, size_t* resulting_shape, bool vector);
 
 
@@ -121,8 +121,8 @@ extern "C" {
 
   LIST_STORAGE* nm_list_storage_copy(const LIST_STORAGE* rhs);
   STORAGE*      nm_list_storage_copy_transposed(const STORAGE* rhs_base);
-  STORAGE*      nm_list_storage_cast_copy(const STORAGE* rhs, dtype_t new_dtype);
-  VALUE         nm_list_storage_to_hash(const LIST_STORAGE* s, const dtype_t dtype);
+  STORAGE*      nm_list_storage_cast_copy(const STORAGE* rhs, nm::dtype_t new_dtype);
+  VALUE         nm_list_storage_to_hash(const LIST_STORAGE* s, const nm::dtype_t dtype);
 
 } // end of extern "C" block