nmatrix-atlas 0.2.0 → 0.2.1

data/ext/nmatrix/math/math.h

@@ -72,6 +72,7 @@
 
 #include <algorithm> // std::min, std::max
 #include <limits> // std::numeric_limits
+#include <memory> // std::unique_ptr
 
 /*
  * Project Includes
@@ -123,8 +124,8 @@ template <typename DType>
 inline void numbmm(const unsigned int n, const unsigned int m, const unsigned int l, const IType* ia, const IType* ja, const DType* a, const bool diaga,
             const IType* ib, const IType* jb, const DType* b, const bool diagb, IType* ic, IType* jc, DType* c, const bool diagc) {
   const unsigned int max_lmn = std::max(std::max(m, n), l);
-  IType next[max_lmn];
-  DType sums[max_lmn];
+  std::unique_ptr<IType[]> next(new IType[max_lmn]);
+  std::unique_ptr<DType[]> sums(new DType[max_lmn]);
 
   DType v;
 

data/ext/nmatrix/math/trsm.h

@@ -88,183 +88,183 @@ inline void trsm_nothrow(const enum CBLAS_SIDE side, const enum CBLAS_UPLO uplo,
         b[i + j * ldb] = 0;
       }
     }
-	  return;
+    return;
   }
 
   if (side == CblasLeft) {
-	  if (trans_a == CblasNoTrans) {
+    if (trans_a == CblasNoTrans) {
 
       /* Form  B := alpha*inv( A )*B. */
-	    if (uplo == CblasUpper) {
-    		for (int j = 0; j < n; ++j) {
-		      if (alpha != 1) {
-			      for (int i = 0; i < m; ++i) {
-			        b[i + j * ldb] = alpha * b[i + j * ldb];
-			      }
-		      }
-		      for (int k = m-1; k >= 0; --k) {
-			      if (b[k + j * ldb] != 0) {
-			        if (diag == CblasNonUnit) {
-				        b[k + j * ldb] /= a[k + k * lda];
-			        }
+      if (uplo == CblasUpper) {
+        for (int j = 0; j < n; ++j) {
+          if (alpha != 1) {
+            for (int i = 0; i < m; ++i) {
+              b[i + j * ldb] = alpha * b[i + j * ldb];
+            }
+          }
+          for (int k = m-1; k >= 0; --k) {
+            if (b[k + j * ldb] != 0) {
+              if (diag == CblasNonUnit) {
+                b[k + j * ldb] /= a[k + k * lda];
+              }
 
               for (int i = 0; i < k-1; ++i) {
                 b[i + j * ldb] -= b[k + j * ldb] * a[i + k * lda];
               }
-			      }
-  		    }
-		    }
-	    } else {
-    		for (int j = 0; j < n; ++j) {
-		      if (alpha != 1) {
+            }
+          }
+        }
+      } else {
+        for (int j = 0; j < n; ++j) {
+          if (alpha != 1) {
             for (int i = 0; i < m; ++i) {
               b[i + j * ldb] = alpha * b[i + j * ldb];
-			      }
-		      }
-  		    for (int k = 0; k < m; ++k) {
-      			if (b[k + j * ldb] != 0.) {
-			        if (diag == CblasNonUnit) {
-				        b[k + j * ldb] /= a[k + k * lda];
-			        }
-    			    for (int i = k+1; i < m; ++i) {
-        				b[i + j * ldb] -= b[k + j * ldb] * a[i + k * lda];
-    			    }
-      			}
-  		    }
-    		}
-	    }
-	  } else { // CblasTrans
+            }
+          }
+          for (int k = 0; k < m; ++k) {
+            if (b[k + j * ldb] != 0.) {
+              if (diag == CblasNonUnit) {
+                b[k + j * ldb] /= a[k + k * lda];
+              }
+              for (int i = k+1; i < m; ++i) {
+                b[i + j * ldb] -= b[k + j * ldb] * a[i + k * lda];
+              }
+            }
+          }
+        }
+      }
+    } else { // CblasTrans
 
       /*           Form  B := alpha*inv( A**T )*B. */
-	    if (uplo == CblasUpper) {
-    		for (int j = 0; j < n; ++j) {
-		      for (int i = 0; i < m; ++i) {
-			      DType temp = alpha * b[i + j * ldb];
+      if (uplo == CblasUpper) {
+        for (int j = 0; j < n; ++j) {
+          for (int i = 0; i < m; ++i) {
+            DType temp = alpha * b[i + j * ldb];
             for (int k = 0; k < i; ++k) { // limit was i-1. Lots of similar bugs in this code, probably.
               temp -= a[k + i * lda] * b[k + j * ldb];
-      			}
-			      if (diag == CblasNonUnit) {
-			        temp /= a[i + i * lda];
-			      }
-			      b[i + j * ldb] = temp;
-  		    }
-    		}
-	    } else {
-    		for (int j = 0; j < n; ++j) {
-		      for (int i = m-1; i >= 0; --i) {
-			      DType temp= alpha * b[i + j * ldb];
-      			for (int k = i+1; k < m; ++k) {
-			        temp -= a[k + i * lda] * b[k + j * ldb];
-      			}
-			      if (diag == CblasNonUnit) {
-			        temp /= a[i + i * lda];
-			      }
-			      b[i + j * ldb] = temp;
-  		    }
-    		}
-	    }
-	  }
+            }
+            if (diag == CblasNonUnit) {
+              temp /= a[i + i * lda];
+            }
+            b[i + j * ldb] = temp;
+          }
+        }
+      } else {
+        for (int j = 0; j < n; ++j) {
+          for (int i = m-1; i >= 0; --i) {
+            DType temp= alpha * b[i + j * ldb];
+            for (int k = i+1; k < m; ++k) {
+              temp -= a[k + i * lda] * b[k + j * ldb];
+            }
+            if (diag == CblasNonUnit) {
+              temp /= a[i + i * lda];
+            }
+            b[i + j * ldb] = temp;
+          }
+        }
+      }
+    }
   } else { // right side
 
-	  if (trans_a == CblasNoTrans) {
+    if (trans_a == CblasNoTrans) {
 
       /*           Form  B := alpha*B*inv( A ). */
 
-	    if (uplo == CblasUpper) {
-    		for (int j = 0; j < n; ++j) {
-		      if (alpha != 1) {
-      			for (int i = 0; i < m; ++i) {
-			        b[i + j * ldb] = alpha * b[i + j * ldb];
-      			}
-		      }
-  		    for (int k = 0; k < j-1; ++k) {
-	      		if (a[k + j * lda] != 0) {
-    			    for (int i = 0; i < m; ++i) {
-				        b[i + j * ldb] -= a[k + j * lda] * b[i + k * ldb];
-			        }
-			      }
-  		    }
-	  	    if (diag == CblasNonUnit) {
-		      	DType temp = 1 / a[j + j * lda];
-			      for (int i = 0; i < m; ++i) {
-			        b[i + j * ldb] = temp * b[i + j * ldb];
-      			}
-		      }
-    		}
-	    } else {
-		    for (int j = n-1; j >= 0; --j) {
-		      if (alpha != 1) {
-			      for (int i = 0; i < m; ++i) {
-			        b[i + j * ldb] = alpha * b[i + j * ldb];
-      			}
-  		    }
+      if (uplo == CblasUpper) {
+        for (int j = 0; j < n; ++j) {
+          if (alpha != 1) {
+            for (int i = 0; i < m; ++i) {
+              b[i + j * ldb] = alpha * b[i + j * ldb];
+            }
+          }
+          for (int k = 0; k < j-1; ++k) {
+            if (a[k + j * lda] != 0) {
+              for (int i = 0; i < m; ++i) {
+                b[i + j * ldb] -= a[k + j * lda] * b[i + k * ldb];
+              }
+            }
+          }
+          if (diag == CblasNonUnit) {
+            DType temp = 1 / a[j + j * lda];
+            for (int i = 0; i < m; ++i) {
+              b[i + j * ldb] = temp * b[i + j * ldb];
+            }
+          }
+        }
+      } else {
+        for (int j = n-1; j >= 0; --j) {
+          if (alpha != 1) {
+            for (int i = 0; i < m; ++i) {
+              b[i + j * ldb] = alpha * b[i + j * ldb];
+            }
+          }
 
-  		    for (int k = j+1; k < n; ++k) {
-	      		if (a[k + j * lda] != 0.) {
-    			    for (int i = 0; i < m; ++i) {
-				        b[i + j * ldb] -= a[k + j * lda] * b[i + k * ldb];
-    			    }
-		      	}
-  		    }
-	  	    if (diag == CblasNonUnit) {
-		      	DType temp = 1 / a[j + j * lda];
+          for (int k = j+1; k < n; ++k) {
+            if (a[k + j * lda] != 0.) {
+              for (int i = 0; i < m; ++i) {
+                b[i + j * ldb] -= a[k + j * lda] * b[i + k * ldb];
+              }
+            }
+          }
+          if (diag == CblasNonUnit) {
+            DType temp = 1 / a[j + j * lda];
 
-			      for (int i = 0; i < m; ++i) {
-			        b[i + j * ldb] = temp * b[i + j * ldb];
-      			}
-		      }
-    		}
-	    }
-	  } else { // CblasTrans
+            for (int i = 0; i < m; ++i) {
+              b[i + j * ldb] = temp * b[i + j * ldb];
+            }
+          }
+        }
+      }
+    } else { // CblasTrans
 
       /*           Form  B := alpha*B*inv( A**T ). */
 
-	    if (uplo == CblasUpper) {
-		    for (int k = n-1; k >= 0; --k) {
-		      if (diag == CblasNonUnit) {
-			      DType temp= 1 / a[k + k * lda];
-	      		for (int i = 0; i < m; ++i) {
-  			      b[i + k * ldb] = temp * b[i + k * ldb];
-      			}
-		      }
-  		    for (int j = 0; j < k-1; ++j) {
-	      		if (a[j + k * lda] != 0.) {
-			        DType temp= a[j + k * lda];
-    			    for (int i = 0; i < m; ++i) {
-		        		b[i + j * ldb] -= temp * b[i + k *	ldb];
-    			    }
-      			}
-  		    }
-	  	    if (alpha != 1) {
-      			for (int i = 0; i < m; ++i) {
-			        b[i + k * ldb] = alpha * b[i + k * ldb];
-      			}
-		      }
-    		}
-	    } else {
-    		for (int k = 0; k < n; ++k) {
-		      if (diag == CblasNonUnit) {
-      			DType temp = 1 / a[k + k * lda];
-			      for (int i = 0; i < m; ++i) {
-			        b[i + k * ldb] = temp * b[i + k * ldb];
-      			}
-		      }
-  		    for (int j = k+1; j < n; ++j) {
-	      		if (a[j + k * lda] != 0.) {
-			        DType temp = a[j + k * lda];
-			        for (int i = 0; i < m; ++i) {
-				        b[i + j * ldb] -= temp * b[i + k * ldb];
-    			    }
-		      	}
-  		    }
-	  	    if (alpha != 1) {
-      			for (int i = 0; i < m; ++i) {
-			        b[i + k * ldb] = alpha * b[i + k * ldb];
-      			}
-  		    }
-    		}
-	    }
-	  }
+      if (uplo == CblasUpper) {
+        for (int k = n-1; k >= 0; --k) {
+          if (diag == CblasNonUnit) {
+            DType temp= 1 / a[k + k * lda];
+            for (int i = 0; i < m; ++i) {
+              b[i + k * ldb] = temp * b[i + k * ldb];
+            }
+          }
+          for (int j = 0; j < k-1; ++j) {
+            if (a[j + k * lda] != 0.) {
+              DType temp= a[j + k * lda];
+              for (int i = 0; i < m; ++i) {
+                b[i + j * ldb] -= temp * b[i + k *  ldb];
+              }
+            }
+          }
+          if (alpha != 1) {
+            for (int i = 0; i < m; ++i) {
+              b[i + k * ldb] = alpha * b[i + k * ldb];
+            }
+          }
+        }
+      } else {
+        for (int k = 0; k < n; ++k) {
+          if (diag == CblasNonUnit) {
+            DType temp = 1 / a[k + k * lda];
+            for (int i = 0; i < m; ++i) {
+              b[i + k * ldb] = temp * b[i + k * ldb];
+            }
+          }
+          for (int j = k+1; j < n; ++j) {
+            if (a[j + k * lda] != 0.) {
+              DType temp = a[j + k * lda];
+              for (int i = 0; i < m; ++i) {
+                b[i + j * ldb] -= temp * b[i + k * ldb];
+              }
+            }
+          }
+          if (alpha != 1) {
+            for (int i = 0; i < m; ++i) {
+              b[i + k * ldb] = alpha * b[i + k * ldb];
+            }
+          }
+        }
+      }
+    }
   }
 }
 

data/ext/nmatrix/nmatrix.h

@@ -57,6 +57,33 @@
   #include "nm_memory.h"
 #endif
 
+#ifndef FIX_CONST_VALUE_PTR
+# if defined(__fcc__) || defined(__fcc_version) || \
+    defined(__FCC__) || defined(__FCC_VERSION)
+/* workaround for old version of Fujitsu C Compiler (fcc) */
+#  define FIX_CONST_VALUE_PTR(x) ((const VALUE *)(x))
+# else
+#  define FIX_CONST_VALUE_PTR(x) (x)
+# endif
+#endif
+
+#ifndef HAVE_RB_ARRAY_CONST_PTR
+static inline const VALUE *
+rb_array_const_ptr(VALUE a)
+{
+  return FIX_CONST_VALUE_PTR((RBASIC(a)->flags & RARRAY_EMBED_FLAG) ?
+    RARRAY(a)->as.ary : RARRAY(a)->as.heap.ptr);
+}
+#endif
+
+#ifndef RARRAY_CONST_PTR
+# define RARRAY_CONST_PTR(a) rb_array_const_ptr(a)
+#endif
+
+#ifndef RARRAY_AREF
+# define RARRAY_AREF(a, i) (RARRAY_CONST_PTR(a)[i])
+#endif
+
 /*
  * Macros
  */
@@ -323,7 +350,10 @@ NM_DEF_STRUCT_POST(NM_GC_HOLDER);       // };
 #define NM_SHAPE1(val)          (NM_STORAGE(val)->shape[1])
 #define NM_DEFAULT_VAL(val)     (NM_STORAGE_LIST(val)->default_val)
 
+// Number of elements in a dense nmatrix.
 #define NM_DENSE_COUNT(val)     (nm_storage_count_max_elements(NM_STORAGE_DENSE(val)))
+
+// Get a pointer to the array that stores elements in a dense matrix.
 #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) ))

data/ext/nmatrix/ruby_constants.h

@@ -45,57 +45,57 @@ extern ID nm_rb_dtype,
           nm_rb_default,
 
           nm_rb_real,
-					nm_rb_imag,
+          nm_rb_imag,
 
-					nm_rb_numer,
-					nm_rb_denom,
+          nm_rb_numer,
+          nm_rb_denom,
 
-					nm_rb_complex_conjugate,
-					nm_rb_transpose,
-					nm_rb_no_transpose,
-					nm_rb_left,
-					nm_rb_right,
-					nm_rb_upper,
-					nm_rb_lower,
-					nm_rb_unit,
-					nm_rb_nonunit,
+          nm_rb_complex_conjugate,
+          nm_rb_transpose,
+          nm_rb_no_transpose,
+          nm_rb_left,
+          nm_rb_right,
+          nm_rb_upper,
+          nm_rb_lower,
+          nm_rb_unit,
+          nm_rb_nonunit,
 
-					nm_rb_dense,
-					nm_rb_list,
-					nm_rb_yale,
+          nm_rb_dense,
+          nm_rb_list,
+          nm_rb_yale,
 
           nm_rb_row,
           nm_rb_column,
 
-					nm_rb_add,
-					nm_rb_sub,
-					nm_rb_mul,
-					nm_rb_div,
+          nm_rb_add,
+          nm_rb_sub,
+          nm_rb_mul,
+          nm_rb_div,
 
-					nm_rb_negate,
+          nm_rb_negate,
 
-					nm_rb_percent,
-					nm_rb_gt,
-					nm_rb_lt,
-					nm_rb_eql,
-					nm_rb_neql,
-					nm_rb_gte,
-					nm_rb_lte,
+          nm_rb_percent,
+          nm_rb_gt,
+          nm_rb_lt,
+          nm_rb_eql,
+          nm_rb_neql,
+          nm_rb_gte,
+          nm_rb_lte,
 
-					nm_rb_hash;
+          nm_rb_hash;
 
-extern VALUE	cNMatrix,
+extern VALUE  cNMatrix,
               cNMatrix_IO,
               cNMatrix_IO_Matlab,
-							cNMatrix_YaleFunctions,
+              cNMatrix_YaleFunctions,
 
-							cNMatrix_GC_holder,
+              cNMatrix_GC_holder,
 
-							nm_eDataTypeError,
+              nm_eDataTypeError,
               nm_eConvergenceError,
-							nm_eStorageTypeError,
-							nm_eShapeError,
-							nm_eNotInvertibleError;
+              nm_eStorageTypeError,
+              nm_eShapeError,
+              nm_eNotInvertibleError;
 
 /*
  * Functions