nmatrix 0.1.0 → 0.2.0

data/ext/nmatrix/math/nrm2.h

@@ -59,6 +59,8 @@
 #ifndef NRM2_H
 # define NRM2_H
 
+#include "math/long_dtype.h"
+
 
 namespace nm { namespace math {
 
@@ -71,7 +73,6 @@ namespace nm { namespace math {
  *    double -> double
  *    complex64 -> float or double
  *    complex128 -> double
- *    rational -> rational
  */
 template <typename ReturnDType, typename DType>
 ReturnDType nrm2(const int N, const DType* X, const int incX) {
@@ -98,27 +99,6 @@ ReturnDType nrm2(const int N, const DType* X, const int incX) {
 }
 
 
-#if defined HAVE_CBLAS_H || defined HAVE_ATLAS_CBLAS_H
-template <>
-inline float nrm2(const int N, const float* X, const int incX) {
-  return cblas_snrm2(N, X, incX);
-}
-
-template <>
-inline double nrm2(const int N, const double* X, const int incX) {
-  return cblas_dnrm2(N, X, incX);
-}
-
-template <>
-inline float nrm2(const int N, const Complex64* X, const int incX) {
-  return cblas_scnrm2(N, X, incX);
-}
-
-template <>
-inline double nrm2(const int N, const Complex128* X, const int incX) {
-  return cblas_dznrm2(N, X, incX);
-}
-#else
 template <typename FloatDType>
 static inline void nrm2_complex_helper(const FloatDType& xr, const FloatDType& xi, double& scale, double& ssq) {
   double absx = std::abs(xr);
@@ -167,7 +147,6 @@ double nrm2(const int N, const Complex128* X, const int incX) {
 
   return scale * std::sqrt( ssq );
 }
-#endif
 
 template <typename ReturnDType, typename DType>
 inline void cblas_nrm2(const int N, const void* X, const int incX, void* result) {

data/ext/nmatrix/math/rot.h

@@ -61,9 +61,6 @@
 
 namespace nm { namespace math {
 
-// FIXME: This is not working properly for rational numbers. Do we need some kind of symbolic
-// type to handle square roots?
-
 
 // TODO: Test this to see if it works properly on complex. ATLAS has a separate algorithm for complex, which looks like
 // TODO: it may actually be the same one.
@@ -108,27 +105,6 @@ inline void rot(const int N, DType* X, const int incX, DType* Y, const int incY,
   }
 }
 
-template <>
-inline void rot(const int N, float* X, const int incX, float* Y, const int incY, const float c, const float s) {
-  cblas_srot(N, X, incX, Y, incY, (float)c, (float)s);
-}
-
-template <>
-inline void rot(const int N, double* X, const int incX, double* Y, const int incY, const double c, const double s) {
-  cblas_drot(N, X, incX, Y, incY, c, s);
-}
-
-template <>
-inline void rot(const int N, Complex64* X, const int incX, Complex64* Y, const int incY, const float c, const float s) {
-  cblas_csrot(N, X, incX, Y, incY, c, s);
-}
-
-template <>
-inline void rot(const int N, Complex128* X, const int incX, Complex128* Y, const int incY, const double c, const double s) {
-  cblas_zdrot(N, X, incX, Y, incY, c, s);
-}
-
-
 template <typename DType, typename CSDType>
 inline void cblas_rot(const int N, void* X, const int incX, void* Y, const int incY, const void* c, const void* s) {
   rot<DType,CSDType>(N, reinterpret_cast<DType*>(X), incX, reinterpret_cast<DType*>(Y), incY,
@@ -138,4 +114,4 @@ inline void cblas_rot(const int N, void* X, const int incX, void* Y, const int i
 
 } } //nm::math
 
-#endif // ROT_H
+#endif // ROT_H

data/ext/nmatrix/math/rotg.h

@@ -84,26 +84,17 @@ inline void rotg(DType* a, DType* b, DType* c, DType* s) {
   }
 }
 
-template <>
-inline void rotg(float* a, float* b, float* c, float* s) {
-  cblas_srotg(a, b, c, s);
-}
-
-template <>
-inline void rotg(double* a, double* b, double* c, double* s) {
-  cblas_drotg(a, b, c, s);
-}
-
 template <>
 inline void rotg(Complex64* a, Complex64* b, Complex64* c, Complex64* s) {
-  cblas_crotg(reinterpret_cast<void*>(a), reinterpret_cast<void*>(b), reinterpret_cast<void*>(c), reinterpret_cast<void*>(s));
+  rb_raise(rb_eNotImpError, "BLAS not available, and existing template requires modification for complex");
 }
 
 template <>
 inline void rotg(Complex128* a, Complex128* b, Complex128* c, Complex128* s) {
-  cblas_zrotg(reinterpret_cast<void*>(a), reinterpret_cast<void*>(b), reinterpret_cast<void*>(c), reinterpret_cast<void*>(s));
+  rb_raise(rb_eNotImpError, "BLAS not available, and existing template requires modification for complex");
 }
 
+
 template <typename DType>
 inline void cblas_rotg(void* a, void* b, void* c, void* s) {
   rotg<DType>(reinterpret_cast<DType*>(a), reinterpret_cast<DType*>(b), reinterpret_cast<DType*>(c), reinterpret_cast<DType*>(s));
@@ -112,4 +103,4 @@ inline void cblas_rotg(void* a, void* b, void* c, void* s) {
 
 } } //nm::math
 
-#endif // ROTG_H
+#endif // ROTG_H

data/ext/nmatrix/math/scal.h

@@ -58,28 +58,6 @@ inline void scal(const int n, const DType scalar, DType* x, const int incx) {
   }
 }
 
-#if defined HAVE_CBLAS_H || defined HAVE_ATLAS_CBLAS_H
-template <>
-inline void scal(const int n, const float scalar, float* x, const int incx) {
-  cblas_sscal(n, scalar, x, incx);
-}
-
-template <>
-inline void scal(const int n, const double scalar, double* x, const int incx) {
-  cblas_dscal(n, scalar, x, incx);
-}
-
-template <>
-inline void scal(const int n, const Complex64 scalar, Complex64* x, const int incx) {
-  cblas_cscal(n, (const void*)(&scalar), (void*)(x), incx);
-}
-
-template <>
-inline void scal(const int n, const Complex128 scalar, Complex128* x, const int incx) {
-  cblas_zscal(n, (const void*)(&scalar), (void*)(x), incx);
-}
-#endif
-
 /*
  * Function signature conversion for LAPACK's scal function.
  */

data/ext/nmatrix/math/trsm.h

@@ -59,14 +59,6 @@
 #define TRSM_H
 
 
-extern "C" {
-#if defined HAVE_CBLAS_H
-  #include <cblas.h>
-#elif defined HAVE_ATLAS_CBLAS_H
-  #include <atlas/cblas.h>
-#endif
-}
-
 namespace nm { namespace math {
 
 
@@ -336,52 +328,5 @@ inline void trsm(const enum CBLAS_ORDER order,
 
 }
 
-
-template <>
-inline void trsm(const enum CBLAS_ORDER order, const enum CBLAS_SIDE side, const enum CBLAS_UPLO uplo,
-                 const enum CBLAS_TRANSPOSE trans_a, const enum CBLAS_DIAG diag,
-                 const int m, const int n, const float alpha, const float* a,
-                 const int lda, float* b, const int ldb)
-{
-  cblas_strsm(order, side, uplo, trans_a, diag, m, n, alpha, a, lda, b, ldb);
-}
-
-template <>
-inline void trsm(const enum CBLAS_ORDER order, const enum CBLAS_SIDE side, const enum CBLAS_UPLO uplo,
-                 const enum CBLAS_TRANSPOSE trans_a, const enum CBLAS_DIAG diag,
-                 const int m, const int n, const double alpha, const double* a,
-                 const int lda, double* b, const int ldb)
-{
-/*  using std::cerr;
-  using std::endl;
-  cerr << "(row-major) dtrsm: " << (side == CblasLeft ? "left " : "right ")
-       << (uplo == CblasUpper ? "upper " : "lower ")
-       << (trans_a == CblasTrans ? "trans " : "notrans ")
-       << (diag == CblasNonUnit ? "nonunit " : "unit ")
-       << m << " " << n << " " << alpha << " a " << lda << " b " << ldb << endl;
-*/
-  cblas_dtrsm(order, side, uplo, trans_a, diag, m, n, alpha, a, lda, b, ldb);
-}
-
-
-template <>
-inline void trsm(const enum CBLAS_ORDER order, const enum CBLAS_SIDE side, const enum CBLAS_UPLO uplo,
-                 const enum CBLAS_TRANSPOSE trans_a, const enum CBLAS_DIAG diag,
-                 const int m, const int n, const Complex64 alpha, const Complex64* a,
-                 const int lda, Complex64* b, const int ldb)
-{
-  cblas_ctrsm(order, side, uplo, trans_a, diag, m, n, (const void*)(&alpha), (const void*)(a), lda, (void*)(b), ldb);
-}
-
-template <>
-inline void trsm(const enum CBLAS_ORDER order, const enum CBLAS_SIDE side, const enum CBLAS_UPLO uplo,
-                 const enum CBLAS_TRANSPOSE trans_a, const enum CBLAS_DIAG diag,
-                 const int m, const int n, const Complex128 alpha, const Complex128* a,
-                 const int lda, Complex128* b, const int ldb)
-{
-  cblas_ztrsm(order, side, uplo, trans_a, diag, m, n, (const void*)(&alpha), (const void*)(a), lda, (void*)(b), ldb);
-}
-
-
 } }  // namespace nm::math
 #endif // TRSM_H

data/ext/nmatrix/math/util.h

@@ -0,0 +1,148 @@
+/////////////////////////////////////////////////////////////////////
+// = NMatrix
+//
+// A linear algebra library for scientific computation in Ruby.
+// NMatrix is part of SciRuby.
+//
+// NMatrix was originally inspired by and derived from NArray, by
+// Masahiro Tanaka: http://narray.rubyforge.org
+//
+// == Copyright Information
+//
+// SciRuby is Copyright (c) 2010 - 2014, Ruby Science Foundation
+// NMatrix is Copyright (c) 2012 - 2014, John Woods and the Ruby Science Foundation
+//
+// Please see LICENSE.txt for additional copyright notices.
+//
+// == Contributing
+//
+// By contributing source code to SciRuby, you agree to be bound by
+// our Contributor Agreement:
+//
+// * https://github.com/SciRuby/sciruby/wiki/Contributor-Agreement
+//
+// == util.h
+//
+// Collect a few utility functions which convert ruby symbols into arguments
+// that CBLAS or LAPACK can understand: either enum's for CBLAS or char's
+// for LAPACK.
+//
+
+#ifndef UTIL_H
+#define UTIL_H
+
+/* Interprets cblas argument which could be any of false/:no_transpose, :transpose, or :complex_conjugate,
+ * into an enum recognized by cblas.
+ *
+ * Called by nm_cblas_gemm -- basically inline.
+ *
+ */
+static inline enum CBLAS_TRANSPOSE blas_transpose_sym(VALUE op) {
+  if (op == Qfalse || rb_to_id(op) == nm_rb_no_transpose) return CblasNoTrans;
+  else if (rb_to_id(op) == nm_rb_transpose) return CblasTrans;
+  else if (rb_to_id(op) == nm_rb_complex_conjugate) return CblasConjTrans;
+  else rb_raise(rb_eArgError, "Expected false, :transpose, or :complex_conjugate");
+  return CblasNoTrans;
+}
+
+/* Interprets transpose argument which could be any of false/:no_transpose, :transpose, or :complex_conjugate,
+ * into an character recognized by LAPACKE. LAPACKE uses a different system than CBLAS for this.
+ *
+ */
+static inline char lapacke_transpose_sym(VALUE op) {
+  if (op == Qfalse || rb_to_id(op) == nm_rb_no_transpose) return 'N';
+  else if (rb_to_id(op) == nm_rb_transpose) return 'T';
+  else if (rb_to_id(op) == nm_rb_complex_conjugate) return 'C';
+  else rb_raise(rb_eArgError, "Expected false, :transpose, or :complex_conjugate");
+  return 'N';
+}
+
+/*
+ * Interprets cblas argument which could be :left or :right
+ *
+ * Called by nm_cblas_trsm -- basically inline
+ */
+static inline enum CBLAS_SIDE blas_side_sym(VALUE op) {
+  ID op_id = rb_to_id(op);
+  if (op_id == nm_rb_left)  return CblasLeft;
+  if (op_id == nm_rb_right) return CblasRight;
+  rb_raise(rb_eArgError, "Expected :left or :right for side argument");
+  return CblasLeft;
+}
+
+/*
+ * Interprets cblas argument which could be :upper or :lower
+ *
+ * Called by nm_cblas_trsm -- basically inline
+ */
+static inline enum CBLAS_UPLO blas_uplo_sym(VALUE op) {
+  ID op_id = rb_to_id(op);
+  if (op_id == nm_rb_upper) return CblasUpper;
+  if (op_id == nm_rb_lower) return CblasLower;
+  rb_raise(rb_eArgError, "Expected :upper or :lower for uplo argument");
+  return CblasUpper;
+}
+
+/*
+ * Interprets argument which could be :upper or :lower for LAPACKE
+ *
+ * Called by nm_cblas_trsm -- basically inline
+ */
+static inline char lapacke_uplo_sym(VALUE op) {
+  ID op_id = rb_to_id(op);
+  if (op_id == nm_rb_upper) return 'U';
+  if (op_id == nm_rb_lower) return 'L';
+  rb_raise(rb_eArgError, "Expected :upper or :lower for uplo argument");
+  return 'U';
+}
+
+/*
+ * Interprets cblas argument which could be :unit (true) or :nonunit (false or anything other than true/:unit)
+ *
+ * Called by nm_cblas_trsm -- basically inline
+ */
+static inline enum CBLAS_DIAG blas_diag_sym(VALUE op) {
+  if (rb_to_id(op) == nm_rb_unit || op == Qtrue) return CblasUnit;
+  return CblasNonUnit;
+}
+
+/*
+ * Interprets cblas argument which could be :row or :col
+ * 
+ * This function, unlike the other ones, works for LAPACKE as well as for CBLAS/CLAPACK.
+ * Although LAPACKE calls this an int instead of a enum, the magic values are the same
+ * (101 for row-major, 102 for column-major).
+ */
+static inline enum CBLAS_ORDER blas_order_sym(VALUE op) {
+  if (rb_to_id(op) == rb_intern("row") || rb_to_id(op) == rb_intern("row_major")) return CblasRowMajor;
+  else if (rb_to_id(op) == rb_intern("col") || rb_to_id(op) == rb_intern("col_major") ||
+           rb_to_id(op) == rb_intern("column") || rb_to_id(op) == rb_intern("column_major")) return CblasColMajor;
+  rb_raise(rb_eArgError, "Expected :row or :col for order argument");
+  return CblasRowMajor;
+}
+
+/*
+ * Interprets lapack jobu and jobvt arguments, for which LAPACK needs character values A, S, O, or N.
+ *
+ * Called by lapack_gesvd -- basically inline. svd stands for singular value decomposition.
+ */
+static inline char lapack_svd_job_sym(VALUE op) {
+  if (rb_to_id(op) == rb_intern("all") || rb_to_id(op) == rb_intern("a")) return 'A';
+  else if (rb_to_id(op) == rb_intern("return") || rb_to_id(op) == rb_intern("s")) return 'S';
+  else if (rb_to_id(op) == rb_intern("overwrite") || rb_to_id(op) == rb_intern("o")) return 'O';
+  else if (rb_to_id(op) == rb_intern("none") || rb_to_id(op) == rb_intern("n")) return 'N';
+  else rb_raise(rb_eArgError, "Expected :all, :return, :overwrite, :none (or :a, :s, :o, :n, respectively)");
+  return 'a';
+}
+
+/*
+ * Interprets lapack jobvl and jobvr arguments, for which LAPACK needs character values N or V.
+ *
+ * Called by lapack_geev -- basically inline. evd stands for eigenvalue decomposition.
+ */
+static inline char lapack_evd_job_sym(VALUE op) {
+  if (op == Qfalse || op == Qnil || rb_to_id(op) == rb_intern("n")) return 'N';
+  else return 'V';
+}
+
+#endif

data/ext/nmatrix/nmatrix.cpp

@@ -31,20 +31,6 @@
  * Standard Includes
  */
 
-extern "C" {
-#if defined HAVE_CBLAS_H
-  #include <cblas.h>
-#elif defined HAVE_ATLAS_CBLAS_H
-  #include <atlas/cblas.h>
-#endif
-
-#if defined HAVE_CLAPACK_H
-  #include <clapack.h>
-#elif defined HAVE_ATLAS_CLAPACK_H
-  #include <atlas/clapack.h>
-#endif
-}
-
 #include <ruby.h>
 #include <algorithm> // std::min
 #include <fstream>

data/ext/nmatrix/nmatrix.h

@@ -43,14 +43,14 @@
 #endif
 
 #ifdef BENCHMARK
-	// SOURCE: http://stackoverflow.com/questions/2349776/how-can-i-benchmark-a-c-program-easily
+  // SOURCE: http://stackoverflow.com/questions/2349776/how-can-i-benchmark-a-c-program-easily
   #ifdef __cplusplus
     #include <sys/ctime>
     #include <sys/cresource>
   #else
     #include <sys/time.h>
     #include <sys/resource.h>
-	#endif
+  #endif
 #endif
 
 #ifdef __cplusplus
@@ -64,24 +64,24 @@
 #define RUBY_ZERO INT2FIX(0)
 
 #ifndef SIZEOF_INT
- #error SIZEOF_INT undefined
+  #error SIZEOF_INT undefined
 #else
- #if SIZEOF_INT == 8
-	#define DEFAULT_DTYPE  INT64
-	#define SIZE_T         INT64
- #else
-	#if SIZEOF_INT == 4
-		#define DEFAULT_DTYPE INT32
-		#define SIZE_T        INT32
-	#else
-	 #if SIZEOF_INT == 2
-		#define DEFAULT_DTYPE INT16
-		#define SIZE_T        INT16
-	 #else
-	  #error Unhandled SIZEOF_INT -- please #define SIZE_T and DEFAULT_DTYPE manually.
-	 #endif
-	#endif
- #endif
+  #if SIZEOF_INT == 8
+    #define DEFAULT_DTYPE  INT64
+    #define SIZE_T         INT64
+  #else
+    #if SIZEOF_INT == 4
+      #define DEFAULT_DTYPE INT32
+      #define SIZE_T        INT32
+    #else
+      #if SIZEOF_INT == 2
+        #define DEFAULT_DTYPE INT16
+        #define SIZE_T        INT16
+      #else
+        #error Unhandled SIZEOF_INT -- please #define SIZE_T and DEFAULT_DTYPE manually.
+      #endif
+    #endif
+  #endif
 #endif
 
 /*
@@ -119,27 +119,27 @@
    */
 
 //opening portion -- this allows unregistering any objects in use before returning
- #define RETURN_SIZED_ENUMERATOR_PRE do { \
-   if (!rb_block_given_p()) {
+  #define RETURN_SIZED_ENUMERATOR_PRE do { \
+    if (!rb_block_given_p()) {
 
 //remaining portion
- #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) \
+  #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) \
         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) \
-        return rb_enumeratorize((obj), ID2SYM(rb_frame_this_func()), (argc), (argv));	\
+    #endif
+  #else
+    #undef RETURN_SIZED_ENUMERATOR
+    #define RETURN_SIZED_ENUMERATOR(obj, argc, argv, size_fn) \
+      return rb_enumeratorize((obj), ID2SYM(rb_frame_this_func()), (argc), (argv));   \
       } \
     } while (0)
- #endif
+  #endif
 
   #define NM_DECL_ENUM(enum_type, name)   nm::enum_type name
   #define NM_DECL_STRUCT(type, name)      type          name;
@@ -149,8 +149,8 @@
     size_t      dim;                 \
     size_t*     shape;               \
     size_t*     offset;              \
-	  int			    count;               \
-	  STORAGE*		src;
+    int         count;               \
+    STORAGE*    src;
 
   #define NM_DEF_STORAGE_CHILD_STRUCT_PRE(name)    struct name : STORAGE {
   #define NM_DEF_STORAGE_STRUCT_POST(name)         };
@@ -180,10 +180,10 @@
     size_t      dim;                \
     size_t*     shape;              \
     size_t*     offset;             \
-	  int			    count;              \
-	  STORAGE*		src;
+    int         count;              \
+    NM_DECL_STRUCT(STORAGE*, src);
   #define NM_DEF_STORAGE_CHILD_STRUCT_PRE(name)  typedef struct NM_ ## name { \
-                                                    NM_DEF_STORAGE_ELEMENTS;
+                                                   NM_DEF_STORAGE_ELEMENTS;
 
   #define NM_DEF_STORAGE_STRUCT_POST(name)       } NM_ ## name;
 
@@ -207,7 +207,7 @@
  * Types
  */
 
-#define NM_NUM_DTYPES 13  // data/data.h
+#define NM_NUM_DTYPES 10  // data/data.h
 #define NM_NUM_STYPES 3   // storage/storage.h
 
 //#ifdef __cplusplus
@@ -220,19 +220,16 @@ NM_DEF_ENUM(stype_t,  DENSE_STORE = 0,
                       YALE_STORE = 2);
 
 /* Data Type */
-NM_DEF_ENUM(dtype_t,	BYTE				=  0,  // unsigned char
-                    	INT8				=  1,  // char
-                    	INT16				=  2,  // short
-                    	INT32				=  3,  // int
-                    	INT64				=  4,  // long
-                    	FLOAT32			=  5,  // float
-                    	FLOAT64			=  6,  // double
-                    	COMPLEX64		=  7,  // Complex64 class
-                    	COMPLEX128	=  8,  // Complex128 class
-                    	RATIONAL32	=  9,  // Rational32 class
-                    	RATIONAL64	= 10,  // Rational64 class
-                    	RATIONAL128	= 11,  // Rational128 class
-                    	RUBYOBJ			= 12);  // Ruby VALUE type
+NM_DEF_ENUM(dtype_t,    BYTE                =  0,  // unsigned char
+                        INT8                =  1,  // char
+                        INT16               =  2,  // short
+                        INT32               =  3,  // int
+                        INT64               =  4,  // long
+                        FLOAT32         =  5,  // float
+                        FLOAT64         =  6,  // double
+                        COMPLEX64       =  7,  // Complex64 class
+                        COMPLEX128  =  8,  // Complex128 class
+                        RUBYOBJ         = 9);  // Ruby VALUE type
 
 NM_DEF_ENUM(symm_t,   NONSYMM   = 0,
                       SYMM      = 1,
@@ -250,16 +247,16 @@ NM_DEF_STORAGE_STRUCT;
 
 /* Dense Storage */
 NM_DEF_STORAGE_CHILD_STRUCT_PRE(DENSE_STORAGE); // struct DENSE_STORAGE : STORAGE {
-	void*		elements; // should go first to align with void* a in yale and NODE* first in list.
-  size_t*	stride;
+  void*     elements; // should go first to align with void* a in yale and NODE* first in list.
+  size_t*   stride;
 NM_DEF_STORAGE_STRUCT_POST(DENSE_STORAGE);     // };
 
 /* Yale Storage */
 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;
-	size_t* ija;
+  void*   a;      // should go first
+  size_t  ndnz; // Strictly non-diagonal non-zero count!
+  size_t  capacity;
+  size_t* ija;
 NM_DEF_STORAGE_STRUCT_POST(YALE_STORAGE);
 
 // FIXME: NODE and LIST should be put in some kind of namespace or something, at least in C++.
@@ -275,9 +272,9 @@ NM_DEF_STRUCT_POST(LIST); // };
 
 /* List-of-Lists Storage */
 NM_DEF_STORAGE_CHILD_STRUCT_PRE(LIST_STORAGE); // struct LIST_STORAGE : STORAGE {
-	// List storage specific elements.
-	void* default_val;
-	NM_DECL_STRUCT(LIST*, rows); // LIST* rows;
+  // List storage specific elements.
+  void* default_val;
+  NM_DECL_STRUCT(LIST*, rows); // LIST* rows;
 NM_DEF_STORAGE_STRUCT_POST(LIST_STORAGE);      // };
 
 
@@ -329,7 +326,7 @@ NM_DEF_STRUCT_POST(NM_GC_HOLDER);       // };
 #define NM_DENSE_COUNT(val)     (nm_storage_count_max_elements(NM_STORAGE_DENSE(val)))
 #define NM_DENSE_ELEMENTS(val)  (NM_STORAGE_DENSE(val)->elements)
 #define NM_SIZEOF_DTYPE(val)    (DTYPE_SIZES[NM_DTYPE(val)])
-#define NM_REF(val,slice)      (RefFuncs[NM_STYPE(val)]( NM_STORAGE(val), slice, NM_SIZEOF_DTYPE(val) ))
+#define NM_REF(val,slice)       (RefFuncs[NM_STYPE(val)]( NM_STORAGE(val), slice, NM_SIZEOF_DTYPE(val) ))
 
 #define NM_MAX(a,b) (((a)>(b))?(a):(b))
 #define NM_MIN(a,b) (((a)>(b))?(b):(a))
@@ -348,8 +345,8 @@ NM_DEF_STRUCT_POST(NM_GC_HOLDER);       // };
   (rb_obj_is_kind_of(obj, cNVector) == Qtrue)
 
 #define RB_P(OBJ) \
-	rb_funcall(rb_stderr, rb_intern("print"), 1, rb_funcall(OBJ, rb_intern("object_id"), 0)); \
-	rb_funcall(rb_stderr, rb_intern("puts"), 1, rb_funcall(OBJ, rb_intern("inspect"), 0));
+  rb_funcall(rb_stderr, rb_intern("print"), 1, rb_funcall(OBJ, rb_intern("object_id"), 0)); \
+  rb_funcall(rb_stderr, rb_intern("puts"), 1, rb_funcall(OBJ, rb_intern("inspect"), 0));
 
 
 #ifdef __cplusplus
@@ -358,43 +355,54 @@ typedef VALUE (*METHOD)(...);
 //}; // end of namespace nm
 #endif
 
+// In the init code below, we need to use NMATRIX for c++ and NM_NMATRIX for c
+// this macro chooses the correct one:
+#ifdef __cplusplus
+  #define _NMATRIX NMATRIX
+  #define _STORAGE STORAGE
+#else
+  #define _NMATRIX NM_NMATRIX
+  #define _STORAGE NM_STORAGE
+#endif
+
 /*
  * 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);
+  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)
-	NM_DECL_ENUM(dtype_t, nm_dtype_min(VALUE));
+  NM_DECL_ENUM(dtype_t, nm_dtype_guess(VALUE));   // (This is a function)
+  NM_DECL_ENUM(dtype_t, nm_dtype_min(VALUE));
 
   // Non-API functions needed by other cpp files.
-	NMATRIX* nm_create(NM_DECL_ENUM(stype_t, stype), STORAGE* storage);
-  NMATRIX* nm_cast_with_ctype_args(NMATRIX* self, NM_DECL_ENUM(stype_t, new_stype), NM_DECL_ENUM(dtype_t, new_dtype), void* init_ptr);
-	VALUE    nm_cast(VALUE self, VALUE new_stype_symbol, VALUE new_dtype_symbol, VALUE init);
-	void     nm_mark(NMATRIX* mat);
-	void     nm_delete(NMATRIX* mat);
-	void     nm_delete_ref(NMATRIX* mat);
+  _NMATRIX* nm_create(NM_DECL_ENUM(stype_t, stype), _STORAGE* storage);
+  _NMATRIX* nm_cast_with_ctype_args(_NMATRIX* self, NM_DECL_ENUM(stype_t, new_stype), NM_DECL_ENUM(dtype_t, new_dtype), void* init_ptr);
+  VALUE    nm_cast(VALUE self, VALUE new_stype_symbol, VALUE new_dtype_symbol, VALUE init);
+  void     nm_mark(_NMATRIX* mat);
+  void     nm_delete(_NMATRIX* mat);
+  void     nm_delete_ref(_NMATRIX* mat);
   void     nm_register_values(VALUE* vals, size_t n);
   void     nm_register_value(VALUE* val);
   void     nm_unregister_value(VALUE* val);
   void     nm_unregister_values(VALUE* vals, size_t n);
-  void     nm_register_storage(NM_DECL_ENUM(stype_t, stype), const STORAGE* storage);
-  void     nm_unregister_storage(NM_DECL_ENUM(stype_t, stype), const STORAGE* storage);
-  void     nm_register_nmatrix(NMATRIX* nmatrix);
-  void     nm_unregister_nmatrix(NMATRIX* nmatrix);
-  void	   nm_completely_unregister_value(VALUE* val);
+  void     nm_register_storage(NM_DECL_ENUM(stype_t, stype), const _STORAGE* storage);
+  void     nm_unregister_storage(NM_DECL_ENUM(stype_t, stype), const _STORAGE* storage);
+  void     nm_register_nmatrix(_NMATRIX* nmatrix);
+  void     nm_unregister_nmatrix(_NMATRIX* nmatrix);
+  void     nm_completely_unregister_value(VALUE* val);
+
 #ifdef __cplusplus
 }
-
 #endif
 
+#undef _NMATRIX
+#undef _STORAGE
+
 #endif // NMATRIX_H