nmatrix-lapacke 0.2.0 → 0.2.1

data/ext/nmatrix/storage/common.h

@@ -32,6 +32,7 @@
  * Standard Includes
  */
 
+#include <ruby.h>
 #include <cmath> // pow().
 
 /*
@@ -57,9 +58,9 @@ struct STORAGE_PAIR {
 };
 
 struct SLICE {
-  size_t*	coords; // Coordinate of first element
-  size_t*	lengths; // Lengths of slice
-  bool  	single; // true if all lengths equal to 1 (represents single matrix element)
+  size_t*  coords; // Coordinate of first element
+  size_t*  lengths; // Lengths of slice
+  bool    single; // true if all lengths equal to 1 (represents single matrix element)
 };
 
 /*

data/ext/nmatrix/storage/dense/dense.h

@@ -32,7 +32,8 @@
  * Standard Includes
  */
 
-#include <stdlib.h>
+#include <ruby.h>
+#include <cstdlib>
 
 /*
  * Project Includes
@@ -69,10 +70,10 @@ extern "C" {
 // Lifecycle //
 ///////////////
 
-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(STORAGE*);
+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(STORAGE*);
 void            nm_dense_storage_register(const STORAGE* s);
 void            nm_dense_storage_unregister(const STORAGE* s);
 
@@ -86,8 +87,8 @@ VALUE nm_dense_map_pair(VALUE self, VALUE right);
 VALUE nm_dense_map(VALUE self);
 VALUE nm_dense_each(VALUE nmatrix);
 VALUE nm_dense_each_with_indices(VALUE nmatrix);
-void*	nm_dense_storage_get(const STORAGE* s, SLICE* slice);
-void*	nm_dense_storage_ref(const STORAGE* s, SLICE* slice);
+void*  nm_dense_storage_get(const STORAGE* s, SLICE* slice);
+void*  nm_dense_storage_ref(const STORAGE* s, SLICE* slice);
 void  nm_dense_storage_set(VALUE left, SLICE* slice, VALUE right);
 
 ///////////

data/ext/nmatrix/storage/list/list.h

@@ -33,7 +33,8 @@
  * Standard Includes
  */
 
-#include <stdlib.h>
+#include <ruby.h>
+#include <cstdlib>
 #include <list>
 /*
  * Project Includes
@@ -69,17 +70,17 @@ extern "C" {
   // Lifecycle //
   ///////////////
 
-  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(STORAGE*);
+  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(STORAGE*);
   void          nm_list_storage_register(const STORAGE* s);
   void          nm_list_storage_unregister(const STORAGE* s);
   void          nm_list_storage_register_list(const LIST* l, size_t recursions);
   void          nm_list_storage_unregister_list(const LIST* l, size_t recursions);
   void          nm_list_storage_register_node(const NODE* n);
   void          nm_list_storage_unregister_node(const NODE* n);
-  void		      nm_list_storage_completely_unregister_node(const NODE* curr);
+  void          nm_list_storage_completely_unregister_node(const NODE* curr);
   ///////////////
   // Accessors //
   ///////////////

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.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/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/sl_list.h

@@ -33,6 +33,7 @@
  * Standard Includes
  */
 
+#include <ruby.h>
 #include <type_traits>
 #include <cstdlib>
 
@@ -69,9 +70,9 @@ namespace nm { namespace list {
 // Lifecycle //
 ///////////////
 
-LIST*	create(void);
-void	del(LIST* list, size_t recursions);
-void	mark(LIST* list, size_t recursions);
+LIST*  create(void);
+void  del(LIST* list, size_t recursions);
+void  mark(LIST* list, size_t recursions);
 
 ///////////////
 // Accessors //
@@ -90,25 +91,25 @@ bool node_is_within_slice(NODE* n, size_t coord, size_t len);
 
 template <typename Type>
 inline NODE* insert_helper(LIST* list, NODE* node, size_t key, Type val) {
-	Type* val_mem = NM_ALLOC(Type);
-	*val_mem = val;
-	
-	if (node == NULL) {
-		return insert(list, false, key, val_mem);
-		
-	} else {
-		return insert_after(node, key, val_mem);
-	}
+  Type* val_mem = NM_ALLOC(Type);
+  *val_mem = val;
+  
+  if (node == NULL) {
+    return insert(list, false, key, val_mem);
+    
+  } else {
+    return insert_after(node, key, val_mem);
+  }
 }
 
 template <typename Type>
 inline NODE* insert_helper(LIST* list, NODE* node, size_t key, Type* ptr) {
-	if (node == NULL) {
-		return insert(list, false, key, ptr);
-		
-	} else {
-		return insert_after(node, key, ptr);
-	}
+  if (node == NULL) {
+    return insert(list, false, key, ptr);
+    
+  } else {
+    return insert_after(node, key, ptr);
+  }
 }
 
 ///////////

data/ext/nmatrix_lapacke/extconf.rb

@@ -107,9 +107,6 @@ basenames = %w{nmatrix_lapacke math_lapacke lapacke}
 $objs = basenames.map { |b| "#{b}.o"   }
 $srcs = basenames.map { |b| "#{b}.cpp" }
 
-#CONFIG['CXX'] = 'clang++'
-CONFIG['CXX'] = 'g++'
-
 def find_newer_gplusplus #:nodoc:
   print "checking for apparent GNU g++ binary with C++0x/C++11 support... "
   [9,8,7,6,5,4,3].each do |minor|
@@ -137,7 +134,7 @@ end
 
 
 if CONFIG['CXX'] == 'clang++'
-  $CPP_STANDARD = 'c++11'
+  $CXX_STANDARD = 'c++11'
 
 else
   version = gplusplus_version
@@ -149,11 +146,11 @@ else
   end
 
   if version < '4.7.0'
-    $CPP_STANDARD = 'c++0x'
+    $CXX_STANDARD = 'c++0x'
   else
-    $CPP_STANDARD = 'c++11'
+    $CXX_STANDARD = 'c++11'
   end
-  puts "using C++ standard... #{$CPP_STANDARD}"
+  puts "using C++ standard... #{$CXX_STANDARD}"
   puts "g++ reports version... " + `#{CONFIG['CXX']} --version|head -n 1|cut -f 3 -d " "`
 end
 
@@ -165,6 +162,10 @@ end
 # that Dir.exists?(d) for each.
 ldefaults = {lapack: ["/usr/local/lib"].delete_if { |d| !Dir.exists?(d) } }
 
+# It is not clear how this variable should be defined, or if it is necessary at all. 
+# See issue https://github.com/SciRuby/nmatrix/issues/403
+idefaults = {lapack: [] }
+
 unless have_library("lapack")
   dir_config("lapack", idefaults[:lapack], ldefaults[:lapack])
 end
@@ -183,13 +184,18 @@ $libs += " -llapack "
 # For release, these next two should both be changed to -O3.
 $CFLAGS += " -O3" #" -O0 -g "
 #$CFLAGS += " -static -O0 -g "
-$CPPFLAGS += " -O3 -std=#{$CPP_STANDARD}" #" -O0 -g -std=#{$CPP_STANDARD} " #-fmax-errors=10 -save-temps
-#$CPPFLAGS += " -static -O0 -g -std=#{$CPP_STANDARD} "
+$CXXFLAGS += " -O3 -std=#{$CXX_STANDARD}" #" -O0 -g -std=#{$CXX_STANDARD} " #-fmax-errors=10 -save-temps
+#$CPPFLAGS += " -static -O0 -g -std=#{$CXX_STANDARD} "
 
 CONFIG['warnflags'].gsub!('-Wshorten-64-to-32', '') # doesn't work except in Mac-patched gcc (4.2)
 CONFIG['warnflags'].gsub!('-Wdeclaration-after-statement', '')
 CONFIG['warnflags'].gsub!('-Wimplicit-function-declaration', '')
 
+have_func("rb_array_const_ptr", "ruby.h")
+have_macro("FIX_CONST_VALUE_PTR", "ruby.h")
+have_macro("RARRAY_CONST_PTR", "ruby.h")
+have_macro("RARRAY_AREF", "ruby.h")
+
 create_conf_h("nmatrix_lapacke_config.h")
 create_makefile("nmatrix_lapacke")
 

data/ext/nmatrix_lapacke/math_lapacke.cpp

@@ -213,8 +213,8 @@ static VALUE nm_lapacke_cblas_rotg(VALUE self, VALUE ab) {
       rb_ary_store(result, 0, *reinterpret_cast<VALUE*>(pC));
       rb_ary_store(result, 1, *reinterpret_cast<VALUE*>(pS));
     } else {
-      rb_ary_store(result, 0, rubyobj_from_cval(pC, dtype).rval);
-      rb_ary_store(result, 1, rubyobj_from_cval(pS, dtype).rval);
+      rb_ary_store(result, 0, nm::rubyobj_from_cval(pC, dtype).rval);
+      rb_ary_store(result, 1, nm::rubyobj_from_cval(pS, dtype).rval);
     }
     NM_CONSERVATIVE(nm_unregister_value(&ab));
     NM_CONSERVATIVE(nm_unregister_value(&self));
@@ -334,7 +334,7 @@ static VALUE nm_lapacke_cblas_nrm2(VALUE self, VALUE n, VALUE x, VALUE incx) {
 
     ttable[dtype](FIX2INT(n), NM_STORAGE_DENSE(x)->elements, FIX2INT(incx), Result);
 
-    return rubyobj_from_cval(Result, rdtype).rval;
+    return nm::rubyobj_from_cval(Result, rdtype).rval;
   }
 }
 
@@ -383,7 +383,7 @@ static VALUE nm_lapacke_cblas_asum(VALUE self, VALUE n, VALUE x, VALUE incx) {
 
   ttable[dtype](FIX2INT(n), NM_STORAGE_DENSE(x)->elements, FIX2INT(incx), Result);
 
-  return rubyobj_from_cval(Result, rdtype).rval;
+  return nm::rubyobj_from_cval(Result, rdtype).rval;
 }
 
 /*
@@ -652,7 +652,7 @@ static VALUE nm_lapacke_lapacke_getri(VALUE self, VALUE order, VALUE n, VALUE a,
   } else {
     ipiv_ = NM_ALLOCA_N(int, RARRAY_LEN(ipiv));
     for (int index = 0; index < RARRAY_LEN(ipiv); ++index) {
-      ipiv_[index] = FIX2INT( RARRAY_PTR(ipiv)[index] );
+      ipiv_[index] = FIX2INT( RARRAY_AREF(ipiv, index) );
     }
   }
 
@@ -744,7 +744,7 @@ static VALUE nm_lapacke_lapacke_getrs(VALUE self, VALUE order, VALUE trans, VALU
   } else {
     ipiv_ = NM_ALLOCA_N(int, RARRAY_LEN(ipiv));
     for (int index = 0; index < RARRAY_LEN(ipiv); ++index) {
-      ipiv_[index] = FIX2INT( RARRAY_PTR(ipiv)[index] );
+      ipiv_[index] = FIX2INT( RARRAY_AREF(ipiv, index) );
     }
   }