nmatrix 0.2.0 → 0.2.1

data/ext/nmatrix/storage/storage.h

@@ -34,6 +34,7 @@
  * Standard Includes
  */
 
+#include <ruby.h>
 #include <cstdlib>
 
 /*
@@ -53,10 +54,10 @@
  * Macros
  */
 
-#define NMATRIX_DTYPE_IS_COMPLEX(s)		((s->dtype == nm::COMPLEX64) or (s->dtype == nm::COMPLEX128))
-#define NMATRIX_DTYPE_IS_FLOAT(s)			((s->dtype == nm::FLOAT32) or (s->dtype == nm::FLOAT64))
-#define NMATRIX_DTYPE_IS_INTEGER(s)		(s->dtype <= nm::INT64)
-#define NMATRIX_DTYPE_IS_RUBYOBJ(s)		(s->dtype == nm::RUBYOBJ)
+#define NMATRIX_DTYPE_IS_COMPLEX(s)    ((s->dtype == nm::COMPLEX64) or (s->dtype == nm::COMPLEX128))
+#define NMATRIX_DTYPE_IS_FLOAT(s)      ((s->dtype == nm::FLOAT32) or (s->dtype == nm::FLOAT64))
+#define NMATRIX_DTYPE_IS_INTEGER(s)    (s->dtype <= nm::INT64)
+#define NMATRIX_DTYPE_IS_RUBYOBJ(s)    (s->dtype == nm::RUBYOBJ)
 
 
 /*
@@ -69,7 +70,7 @@
  */
 
 namespace nm {
-	const int NUM_STYPES = 3;
+  const int NUM_STYPES = 3;
 }
 
 extern "C" {
@@ -85,12 +86,12 @@ extern "C" {
   // Copying and Casting //
   /////////////////////////
 
-  STORAGE*	  nm_dense_storage_from_list(const STORAGE* right, nm::dtype_t l_dtype, void*);
-  STORAGE*	  nm_dense_storage_from_yale(const STORAGE* right, nm::dtype_t l_dtype, void*);
-  STORAGE*		nm_list_storage_from_dense(const STORAGE* right, nm::dtype_t l_dtype, void*);
-  STORAGE*		nm_list_storage_from_yale(const STORAGE* right,  nm::dtype_t l_dtype, void*);
-  STORAGE*		nm_yale_storage_from_list(const STORAGE* right,  nm::dtype_t l_dtype, void*);
-  STORAGE*		nm_yale_storage_from_dense(const STORAGE* right, nm::dtype_t l_dtype, void*);
+  STORAGE*    nm_dense_storage_from_list(const STORAGE* right, nm::dtype_t l_dtype, void*);
+  STORAGE*    nm_dense_storage_from_yale(const STORAGE* right, nm::dtype_t l_dtype, void*);
+  STORAGE*    nm_list_storage_from_dense(const STORAGE* right, nm::dtype_t l_dtype, void*);
+  STORAGE*    nm_list_storage_from_yale(const STORAGE* right,  nm::dtype_t l_dtype, void*);
+  STORAGE*    nm_yale_storage_from_list(const STORAGE* right,  nm::dtype_t l_dtype, void*);
+  STORAGE*    nm_yale_storage_from_dense(const STORAGE* right, nm::dtype_t l_dtype, void*);
 
 } // end of extern "C" block
 

data/ext/nmatrix/storage/yale/class.h

@@ -754,8 +754,8 @@ public:
       nm_yale_storage_register(lhs);
       for (size_t m = 0; m < size(); ++m) {
         if (Yield) {
-	  la[m] = rb_yield(nm::yale_storage::nm_rb_dereference(a(m)));
-	}
+    la[m] = rb_yield(nm::yale_storage::nm_rb_dereference(a(m)));
+  }
         else       la[m] = static_cast<E>(a(m));
       }
       nm_yale_storage_unregister(lhs);

data/ext/nmatrix/storage/yale/iterators/base.h

@@ -29,6 +29,7 @@
 #ifndef YALE_ITERATORS_BASE_H
 # define YALE_ITERATORS_BASE_H
 
+#include <ruby.h>
 #include <type_traits>
 #include <typeinfo>
 #include <stdexcept>
@@ -139,4 +140,4 @@ public:
 
 } } // end of namespace nm::yale_storage
 
-#endif // YALE_ITERATORS_BASE_H
+#endif // YALE_ITERATORS_BASE_H

data/ext/nmatrix/storage/yale/iterators/iterator.h

@@ -29,6 +29,7 @@
 #ifndef YALE_ITERATORS_ITERATOR_H
 # define YALE_ITERATORS_ITERATOR_H
 
+#include <ruby.h>
 #include <type_traits>
 #include <typeinfo>
 
@@ -127,4 +128,4 @@ public:
 
 } } // end of namespace nm::yale_storage
 
-#endif // YALE_ITERATORS_ITERATOR_H
+#endif // YALE_ITERATORS_ITERATOR_H

data/ext/nmatrix/storage/yale/iterators/row.h

@@ -31,6 +31,7 @@
 #ifndef YALE_ITERATORS_ROW_H
 # define YALE_ITERATORS_ROW_H
 
+#include <ruby.h>
 #include <stdexcept>
 
 namespace nm { namespace yale_storage {
@@ -446,4 +447,4 @@ public:
 
 } } // end of nm::yale_storage namespace
 
-#endif // YALE_ITERATORS_ROW_H
+#endif // YALE_ITERATORS_ROW_H

data/ext/nmatrix/storage/yale/iterators/row_stored.h

@@ -34,6 +34,7 @@
 #ifndef YALE_ITERATORS_ROW_STORED_H
 # define YALE_ITERATORS_ROW_STORED_H
 
+#include <ruby.h>
 #include <stdexcept>
 
 namespace nm { namespace yale_storage {
@@ -136,4 +137,4 @@ public:
 
 }} // end of namespace nm::yale_storage
 
-#endif // YALE_ITERATORS_ROW_STORED_H
+#endif // YALE_ITERATORS_ROW_STORED_H

data/ext/nmatrix/storage/yale/iterators/row_stored_nd.h

@@ -29,6 +29,7 @@
 #ifndef YALE_ITERATORS_ROW_STORED_ND_H
 # define YALE_ITERATORS_ROW_STORED_ND_H
 
+#include <ruby.h>
 #include <type_traits>
 #include <typeinfo>
 #include <stdexcept>

data/ext/nmatrix/storage/yale/iterators/stored_diagonal.h

@@ -29,6 +29,7 @@
 #ifndef YALE_ITERATORS_STORED_DIAGONAL_H
 # define YALE_ITERATORS_STORED_DIAGONAL_H
 
+#include <ruby.h>
 #include <type_traits>
 #include <typeinfo>
 
@@ -120,4 +121,4 @@ public:
 
 } } // end of namespace nm::yale_storage
 
-#endif // YALE_ITERATORS_STORED_DIAGONAL_H
+#endif // YALE_ITERATORS_STORED_DIAGONAL_H

data/ext/nmatrix/storage/yale/yale.cpp

@@ -85,7 +85,7 @@
  */
 
 extern "C" {
-  static YALE_STORAGE*	alloc(nm::dtype_t dtype, size_t* shape, size_t dim);
+  static YALE_STORAGE*  alloc(nm::dtype_t dtype, size_t* shape, size_t dim);
 
   static size_t yale_count_slice_copy_ndnz(const YALE_STORAGE* s, size_t*, size_t*);
 
@@ -117,10 +117,10 @@ template <typename LD, typename RD>
 static VALUE map_merged_stored(VALUE left, VALUE right, VALUE init);
 
 template <typename DType>
-static bool						ndrow_is_empty(const YALE_STORAGE* s, IType ija, const IType ija_next);
+static bool            ndrow_is_empty(const YALE_STORAGE* s, IType ija, const IType ija_next);
 
 template <typename LDType, typename RDType>
-static bool						ndrow_eqeq_ndrow(const YALE_STORAGE* l, const YALE_STORAGE* r, IType l_ija, const IType l_ija_next, IType r_ija, const IType r_ija_next);
+static bool            ndrow_eqeq_ndrow(const YALE_STORAGE* l, const YALE_STORAGE* r, IType l_ija, const IType l_ija_next, IType r_ija, const IType r_ija_next);
 
 template <typename LDType, typename RDType>
 static bool           eqeq(const YALE_STORAGE* left, const YALE_STORAGE* right);
@@ -128,9 +128,9 @@ static bool           eqeq(const YALE_STORAGE* left, const YALE_STORAGE* right);
 template <typename LDType, typename RDType>
 static bool eqeq_different_defaults(const YALE_STORAGE* s, const LDType& s_init, const YALE_STORAGE* t, const RDType& t_init);
 
-static void						increment_ia_after(YALE_STORAGE* s, IType ija_size, IType i, long n);
+static void            increment_ia_after(YALE_STORAGE* s, IType ija_size, IType i, long n);
 
-static IType				  insert_search(YALE_STORAGE* s, IType left, IType right, IType key, bool& found);
+static IType          insert_search(YALE_STORAGE* s, IType left, IType right, IType key, bool& found);
 
 template <typename DType>
 static char           vector_insert(YALE_STORAGE* s, size_t pos, size_t* j, void* val_, size_t n, bool struct_only);
@@ -436,13 +436,13 @@ int binary_search(YALE_STORAGE* s, IType left, IType right, IType key) {
   IType mid_j = ija[mid];
 
   if (mid_j == key)
-  	return mid;
+    return mid;
 
   else if (mid_j > key)
-  	return binary_search(s, left, mid - 1, key);
+    return binary_search(s, left, mid - 1, key);
 
   else
-  	return binary_search(s, mid + 1, right, key);
+    return binary_search(s, mid + 1, right, key);
 }
 
 
@@ -503,7 +503,7 @@ static char vector_insert_resize(YALE_STORAGE* s, size_t current_size, size_t po
   }
 
   if (new_capacity < current_size + n)
-  	new_capacity = current_size + n;
+    new_capacity = current_size + n;
 
   nm_yale_storage_register(s);
 
@@ -564,8 +564,8 @@ static char vector_insert_resize(YALE_STORAGE* s, size_t current_size, size_t po
  * diag). Does not free anything; you are responsible!
  *
  * TODO: Improve this so it can handle non-contiguous element insertions
- *	efficiently. For now, we can just sort the elements in the row in
- *	question.)
+ *  efficiently. For now, we can just sort the elements in the row in
+ *  question.)
  */
 template <typename DType>
 static char vector_insert(YALE_STORAGE* s, size_t pos, size_t* j, void* val_, size_t n, bool struct_only) {
@@ -585,7 +585,7 @@ static char vector_insert(YALE_STORAGE* s, size_t pos, size_t* j, void* val_, si
     vector_insert_resize<DType>(s, size, pos, j, n, struct_only);
 
     // Need to get the new locations for ija and a.
-  	ija = s->ija;
+    ija = s->ija;
     a   = reinterpret_cast<DType*>(s->a);
   } else {
     /*
@@ -594,7 +594,7 @@ static char vector_insert(YALE_STORAGE* s, size_t pos, size_t* j, void* val_, si
      * the end, one element at a time.
      *
      * TODO: This can be made slightly more efficient, but only after the tests
-     *	are written.
+     *  are written.
      */
 
     if (struct_only) {
@@ -655,10 +655,10 @@ static IType insert_search(YALE_STORAGE* s, IType left, IType right, IType key,
     return mid;
 
   } else if (mid_j > key) {
-  	return insert_search(s, left, mid-1, key, found);
+    return insert_search(s, left, mid-1, key, found);
 
   } else {
-  	return insert_search(s, mid+1, right, key, found);
+    return insert_search(s, mid+1, right, key, found);
   }
 }
 
@@ -1119,10 +1119,10 @@ static bool is_pos_default_value(YALE_STORAGE* s, size_t apos) {
 extern "C" {
 
 void nm_init_yale_functions() {
-	/*
-	 * This module stores methods that are useful for debugging Yale matrices,
-	 * i.e. the ones with +:yale+ stype.
-	 */
+  /*
+   * This module stores methods that are useful for debugging Yale matrices,
+   * i.e. the ones with +:yale+ stype.
+   */
   cNMatrix_YaleFunctions = rb_define_module_under(cNMatrix, "YaleFunctions");
 
   // Expert recommendation. Eventually this should go in a separate gem, or at least a separate module.
@@ -1336,7 +1336,7 @@ static void* default_value_ptr(const YALE_STORAGE* s) {
  */
 static VALUE obj_at(YALE_STORAGE* s, size_t k) {
   if (s->dtype == nm::RUBYOBJ)  return reinterpret_cast<VALUE*>(((YALE_STORAGE*)(s->src))->a)[k];
-  else  return rubyobj_from_cval(reinterpret_cast<void*>(reinterpret_cast<char*>(((YALE_STORAGE*)(s->src))->a) + k * DTYPE_SIZES[s->dtype]), s->dtype).rval;
+  else  return nm::rubyobj_from_cval(reinterpret_cast<void*>(reinterpret_cast<char*>(((YALE_STORAGE*)(s->src))->a) + k * DTYPE_SIZES[s->dtype]), s->dtype).rval;
 }
 
 
@@ -1345,7 +1345,7 @@ static VALUE obj_at(YALE_STORAGE* s, size_t k) {
  */
 static VALUE default_value(const YALE_STORAGE* s) {
   if (s->dtype == nm::RUBYOBJ) return *reinterpret_cast<VALUE*>(default_value_ptr(s));
-  else return rubyobj_from_cval(default_value_ptr(s), s->dtype).rval;
+  else return nm::rubyobj_from_cval(default_value_ptr(s), s->dtype).rval;
 }
 
 
@@ -1664,7 +1664,7 @@ static VALUE nm_a(int argc, VALUE* argv, VALUE self) {
       }
     } else {
       for (size_t i = 0; i < size; ++i) {
-        vals[i] = rubyobj_from_cval((char*)(s->a) + DTYPE_SIZES[s->dtype]*i, s->dtype).rval;
+        vals[i] = nm::rubyobj_from_cval((char*)(s->a) + DTYPE_SIZES[s->dtype]*i, s->dtype).rval;
       }
     }
     VALUE ary = rb_ary_new4(size, vals);
@@ -1681,7 +1681,7 @@ static VALUE nm_a(int argc, VALUE* argv, VALUE self) {
     NM_CONSERVATIVE(nm_unregister_value(&idx));
     NM_CONSERVATIVE(nm_unregister_value(&self));
     if (index >= size) rb_raise(rb_eRangeError, "out of range");
-    return rubyobj_from_cval((char*)(s->a) + DTYPE_SIZES[s->dtype] * index, s->dtype).rval;
+    return nm::rubyobj_from_cval((char*)(s->a) + DTYPE_SIZES[s->dtype] * index, s->dtype).rval;
   }
 }
 
@@ -1712,7 +1712,7 @@ static VALUE nm_d(int argc, VALUE* argv, VALUE self) {
       }
     } else {
       for (size_t i = 0; i < s->shape[0]; ++i) {
-        vals[i] = rubyobj_from_cval((char*)(s->a) + DTYPE_SIZES[s->dtype]*i, s->dtype).rval;
+        vals[i] = nm::rubyobj_from_cval((char*)(s->a) + DTYPE_SIZES[s->dtype]*i, s->dtype).rval;
       }
     }
     nm_unregister_values(vals, s->shape[0]);
@@ -1725,7 +1725,7 @@ static VALUE nm_d(int argc, VALUE* argv, VALUE self) {
     NM_CONSERVATIVE(nm_unregister_value(&idx));
     NM_CONSERVATIVE(nm_unregister_value(&self));
     if (index >= s->shape[0]) rb_raise(rb_eRangeError, "out of range");
-    return rubyobj_from_cval((char*)(s->a) + DTYPE_SIZES[s->dtype] * index, s->dtype).rval;
+    return nm::rubyobj_from_cval((char*)(s->a) + DTYPE_SIZES[s->dtype] * index, s->dtype).rval;
   }
 }
 
@@ -1752,7 +1752,7 @@ static VALUE nm_lu(VALUE self) {
     }
   } else {
     for (size_t i = 0; i < size - s->shape[0] - 1; ++i) {
-      vals[i] = rubyobj_from_cval((char*)(s->a) + DTYPE_SIZES[s->dtype]*(s->shape[0] + 1 + i), s->dtype).rval;
+      vals[i] = nm::rubyobj_from_cval((char*)(s->a) + DTYPE_SIZES[s->dtype]*(s->shape[0] + 1 + i), s->dtype).rval;
     }
   }
 
@@ -1927,7 +1927,7 @@ static VALUE nm_nd_row(int argc, VALUE* argv, VALUE self) {
     ret = rb_hash_new();
 
     for (size_t idx = pos; idx < nextpos; ++idx) {
-      rb_hash_aset(ret, INT2FIX(s->ija[idx]), rubyobj_from_cval((char*)(s->a) + DTYPE_SIZES[s->dtype]*idx, s->dtype).rval);
+      rb_hash_aset(ret, INT2FIX(s->ija[idx]), nm::rubyobj_from_cval((char*)(s->a) + DTYPE_SIZES[s->dtype]*idx, s->dtype).rval);
     }
   }
   NM_CONSERVATIVE(nm_unregister_value(&as));

data/ext/nmatrix/storage/yale/yale.h

@@ -42,6 +42,7 @@
  * Standard Includes
  */
 
+#include <ruby.h>
 #include <limits> // for std::numeric_limits<T>::max()
 #include <stdexcept>
 
@@ -84,15 +85,15 @@ extern "C" {
 
   YALE_STORAGE* nm_yale_storage_create(nm::dtype_t dtype, size_t* shape, size_t dim, size_t init_capacity);
   YALE_STORAGE* nm_yale_storage_create_from_old_yale(nm::dtype_t dtype, size_t* shape, char* ia, char* ja, char* a, nm::dtype_t from_dtype);
-  YALE_STORAGE*	nm_yale_storage_create_merged(const YALE_STORAGE* merge_template, const YALE_STORAGE* other);
+  YALE_STORAGE*  nm_yale_storage_create_merged(const YALE_STORAGE* merge_template, const YALE_STORAGE* other);
   void          nm_yale_storage_delete(STORAGE* s);
   void          nm_yale_storage_delete_ref(STORAGE* s);
-  void					nm_yale_storage_init(YALE_STORAGE* s, void* default_val);
-  void					nm_yale_storage_mark(STORAGE*);
+  void          nm_yale_storage_init(YALE_STORAGE* s, void* default_val);
+  void          nm_yale_storage_mark(STORAGE*);
   void          nm_yale_storage_register(const STORAGE* s);
   void          nm_yale_storage_unregister(const STORAGE* s);
-  void		nm_yale_storage_register_a(void* a, size_t size);
-  void		nm_yale_storage_unregister_a(void* a, size_t size); 
+  void    nm_yale_storage_register_a(void* a, size_t size);
+  void    nm_yale_storage_unregister_a(void* a, size_t size); 
     
   ///////////////
   // Accessors //
@@ -104,7 +105,7 @@ extern "C" {
   VALUE nm_yale_stored_nondiagonal_each_with_indices(VALUE nmatrix);
   VALUE nm_yale_each_ordered_stored_with_indices(VALUE nmatrix);
   void* nm_yale_storage_get(const STORAGE* s, SLICE* slice);
-  void*	nm_yale_storage_ref(const STORAGE* s, SLICE* slice);
+  void*  nm_yale_storage_ref(const STORAGE* s, SLICE* slice);
   void  nm_yale_storage_set(VALUE left, SLICE* slice, VALUE right);
 
   //char  nm_yale_storage_vector_insert(YALE_STORAGE* s, size_t pos, size_t* js, void* vals, size_t n, bool struct_only, nm::dtype_t dtype, nm::itype_t itype);

data/ext/nmatrix/ttable_helper.rb

@@ -42,16 +42,16 @@ EWOPS = [
         ]
 
 LR_ALLOWED = {
-  :uint8_t	 		=> DTYPES,
-  :int8_t				=> DTYPES,
-  :int16_t			=> DTYPES,
-  :int32_t			=> DTYPES,
-  :int64_t			=> DTYPES,
-  :float32_t		=> DTYPES,
-  :float64_t		=> DTYPES,
-  :'nm::Complex64'		=> DTYPES,
-  :'nm::Complex128'		=> DTYPES,
-  :'nm::RubyObject'		=> DTYPES
+  :uint8_t       => DTYPES,
+  :int8_t        => DTYPES,
+  :int16_t      => DTYPES,
+  :int32_t      => DTYPES,
+  :int64_t      => DTYPES,
+  :float32_t    => DTYPES,
+  :float64_t    => DTYPES,
+  :'nm::Complex64'    => DTYPES,
+  :'nm::Complex128'    => DTYPES,
+  :'nm::RubyObject'    => DTYPES
 }
 
 lines =

data/ext/nmatrix/types.h

@@ -32,6 +32,7 @@
  * Standard Includes
  */
 
+#include <ruby.h>
 #include <cstdint>
 
 /*
@@ -46,8 +47,8 @@
  * Types
  */
 
-typedef float		float32_t;
-typedef double	float64_t;
+typedef float    float32_t;
+typedef double  float64_t;
 
 typedef size_t  IType;
 

data/ext/nmatrix/util/io.cpp

@@ -104,9 +104,9 @@ extern "C" {
 nm::dtype_t nm_dtype_from_rbstring(VALUE str) {
 
   for (size_t index = 0; index < NM_NUM_DTYPES; ++index) {
-  	if (!std::strncmp(RSTRING_PTR(str), DTYPE_NAMES[index], RSTRING_LEN(str))) {
-  		return static_cast<nm::dtype_t>(index);
-  	}
+    if (!std::strncmp(RSTRING_PTR(str), DTYPE_NAMES[index], RSTRING_LEN(str))) {
+      return static_cast<nm::dtype_t>(index);
+    }
   }
 
   rb_raise(rb_eArgError, "invalid data type string (%s) specified", RSTRING_PTR(str));
@@ -121,7 +121,7 @@ nm::dtype_t nm_dtype_from_rbsymbol(VALUE sym) {
 
   for (size_t index = 0; index < NM_NUM_DTYPES; ++index) {
     if (sym_id == rb_intern(DTYPE_NAMES[index])) {
-    	return static_cast<nm::dtype_t>(index);
+      return static_cast<nm::dtype_t>(index);
     }
   }
 
@@ -138,7 +138,7 @@ nm::stype_t nm_stype_from_rbstring(VALUE str) {
 
   for (size_t index = 0; index < NM_NUM_STYPES; ++index) {
     if (!std::strncmp(RSTRING_PTR(str), STYPE_NAMES[index], 3)) {
-    	return static_cast<nm::stype_t>(index);
+      return static_cast<nm::stype_t>(index);
     }
   }
 
@@ -153,7 +153,7 @@ nm::stype_t nm_stype_from_rbsymbol(VALUE sym) {
 
   for (size_t index = 0; index < NM_NUM_STYPES; ++index) {
     if (SYM2ID(sym) == rb_intern(STYPE_NAMES[index])) {
-    	return static_cast<nm::stype_t>(index);
+      return static_cast<nm::stype_t>(index);
     }
   }
 
@@ -169,7 +169,7 @@ nm::stype_t nm_stype_from_rbsymbol(VALUE sym) {
 static nm::io::matlab_dtype_t matlab_dtype_from_rbsymbol(VALUE sym) {
   for (size_t index = 0; index < nm::io::NUM_MATLAB_DTYPES; ++index) {
     if (SYM2ID(sym) == rb_intern(nm::io::MATLAB_DTYPE_NAMES[index])) {
-    	return static_cast<nm::io::matlab_dtype_t>(index);
+      return static_cast<nm::io::matlab_dtype_t>(index);
     }
   }