nmatrix 0.1.0.rc3 → 0.1.0.rc4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9bccc178bd2c4a0ee318f3a0808e7f3c52cfbc3f
-  data.tar.gz: eec9ec0890b8ab958c123452f98064883de0ea33
+  metadata.gz: 7aab05ad51eae5a3ccba6312f79d75b624ccb6a2
+  data.tar.gz: d8a2d31cdf2290857458256724102588c4ef8da6
 SHA512:
-  metadata.gz: ab789cf265f5461e75e0425ce126c45e52ff627b69bfa0a5a94018260254708ec11c9e0e67a9f94e7dab0696fe1171c56d8043304b59848bfede52761e33924f
-  data.tar.gz: b8f8cfe0c81c7ce46306afcd9b5e469e84856aae990b6e42e52ca299234fe03801bd7f0c4ba585f14786909f1dbe88b10e5b12b3ef16c37935b8efa06e58b7ed
+  metadata.gz: b242f8f8603d5ff19c525c4f1ced681bf7766bff43d273e61de7497dc724867d74613da98fabe444dda4360d05bc4973d296422af62fe6013c75feec0f3c8f3c
+  data.tar.gz: ca9c9ac8ef252a35fcff3c3e9a405090711c47ecbc3ffe387e3e18861e6f1ddbf85654350e2c09616c11356705e8a2c234dd512fc9fb9780c60acb9dd08dd317

data/CONTRIBUTING.md

@@ -1,5 +1,5 @@
 NMatrix is part of SciRuby, a collaborative effort to bring scientific computation to Ruby. If you want to help, please
- do so!
+do so!
 
 This guide covers ways in which you can contribute to the development of SciRuby and, more specifically, NMatrix.
 
@@ -8,25 +8,25 @@ This guide covers ways in which you can contribute to the development of SciRuby
 There are various ways to help NMatrix: bug reports, coding and documentation. All of them are important.
 
 First, you can help implement new features or bug fixes. To do that, visit our
- [roadmap](https://github.com/SciRuby/nmatrix/wiki/Roadmap) or our [issue tracker][2]. If you find something that you
- want to work on, post it in the issue or on our [mailing list][1].
+[roadmap](https://github.com/SciRuby/nmatrix/wiki/Roadmap) or our [issue tracker][2]. If you find something that you
+want to work on, post it in the issue or on our [mailing list][1].
 
 You need to send tests together with your code. No exceptions. You can ask for our opinion, but we won't accept patches
- without good spec coverage.
+without good spec coverage.
 
 We use RSpec for testing. If you aren't familiar with it, there's a good
- [guide to better specs with RSpec](http://betterspecs.org/) that shows a bit of the syntax and how to use it properly.
- However, the best resource is probably the specs that already exist -- so just read them.
+[guide to better specs with RSpec](http://betterspecs.org/) that shows a bit of the syntax and how to use it properly.
+However, the best resource is probably the specs that already exist -- so just read them.
 
 And don't forget to write documentation (we use RDoc). It's necessary to allow others to know what's available in the
- library. There's a section on it later in this guide.
+library. There's a section on it later in this guide.
 
 We only accept bug reports and pull requests in GitHub. You'll need to create a new (free) account if you don't have one
- already. To learn how to create a pull request, please see
- [this guide on collaborating](https://help.github.com/categories/63/articles).
+already. To learn how to create a pull request, please see
+[this guide on collaborating](https://help.github.com/categories/63/articles).
 
 If you have a question about how to use NMatrix or SciRuby in general or a feature/change in mind, please ask the
- [sciruby-dev mailing list][1].
+[sciruby-dev mailing list][1].
 
 Thanks!
 
@@ -42,21 +42,22 @@ To start helping with the code, you need to have all the dependencies in place:
 
 Now, you need to clone the git repository:
 
-    git clone git://github.com/SciRuby/nmatrix.git
-		cd nmatrix
-		bundle install
-		rake compile
-		rake spec
+```bash
+$ git clone git://github.com/SciRuby/nmatrix.git
+$ cd nmatrix
+$ bundle install
+$ rake compile
+$ rake spec
+```
 
-This will install all dependencies, compile the extension and run the specs. 
-
-As of now (12/31/2012), there should be 25 specs failing, in elementwise\_spec, lapack\_spec and math\_spec. If you see
-more than 25 or from different specs, please report on the [mailing list][1] or on the [issue tracker][2].
+This will install all dependencies, compile the extension and run the specs.
 
 If everything's fine until now, you can create a new branch to work on your feature:
 
-    git branch new-feature
-    git checkout new-feature
+```bash
+$ git branch new-feature
+$ git checkout new-feature
+```
 
 Before commiting any code, please read our
 [Contributor Agreement](http://github.com/SciRuby/sciruby/wiki/Contributor-Agreement).

data/History.txt

@@ -599,3 +599,16 @@
   * Fixed critical bug with transposing a matrix reference slice (by
     @rajatkapoor)
 
+=== 0.1.0.rc4 / 2014-07-24
+
+* No major enhancements.
+
+* 1 minor enhancements:
+
+  * NMatrix#floor and #ceil implemented (by @v0dro)
+
+* 2 bug fixes:
+
+  * Disallowed out-of-bounds rank calls (by @andrewcsmith)
+
+  * Fixed rspec 3.0 conflict with rspec-longrun 1.0.1

data/Manifest.txt

@@ -20,7 +20,6 @@ lib/nmatrix/lapack.rb
 lib/nmatrix/math.rb
 lib/nmatrix/monkeys.rb
 lib/nmatrix/nmatrix.rb
-lib/nmatrix/nvector.rb
 lib/nmatrix/rspec.rb
 lib/nmatrix/shortcuts.rb
 lib/nmatrix/version.rb
@@ -66,7 +65,7 @@ ext/nmatrix/math/getf2.h
 ext/nmatrix/math/getrf.h
 ext/nmatrix/math/getri.h
 ext/nmatrix/math/getrs.h
-ext/nmatrix/math/idamax.h
+ext/nmatrix/math/imax.h
 ext/nmatrix/math/inc.h
 ext/nmatrix/math/laswp.h
 ext/nmatrix/math/long_dtype.h

data/README.rdoc

@@ -4,11 +4,14 @@ Fast Numerical Linear Algebra Library for Ruby
 
 * {sciruby.com}[http://sciruby.com]
 * {Google+}[https://plus.google.com/109304769076178160953/posts]
+* {Google Group - Mailing List}[https://groups.google.com/forum/#!forum/sciruby-dev]
 * {NMatrix Installation wiki}[https://github.com/SciRuby/nmatrix/wiki/Installation]
 * {SciRuby Installation guide}[http://sciruby.com/docs#installation]
 
 {<img src=https://travis-ci.org/SciRuby/nmatrix.png>}[https://travis-ci.org/SciRuby/nmatrix]
 
+{<img src="https://codeclimate.com/github/SciRuby/nmatrix.png" />}[https://codeclimate.com/github/SciRuby/nmatrix]
+
 == Description
 
 NMatrix is a fast numerical linear algebra library for Ruby, with dense and sparse matrices, written mostly in C and
@@ -38,7 +41,7 @@ If you want to obtain the latest (development) code, you should generally do:
     bundle install
     bundle exec rake compile
     bundle exec rake repackage
-    gem install pkg/nmatrix-0.1.0.rc3.gem
+    gem install pkg/nmatrix-0.1.0.rc4.gem
 
 Detailed instructions are available for {Mac}[https://github.com/SciRuby/nmatrix/wiki/Installation#mac-os-x] and {Linux}[https://github.com/SciRuby/nmatrix/wiki/Installation#linux].
 We are currently working on Mavericks (Mac OS X) installation instructions, but in general, you'll need Homebrew and should
@@ -46,16 +49,13 @@ probably use +brew install gcc48+ instead of using the install script.
 
 == Documentation
 
-Carlos Agarie (@agarie) is currently working to improve the documentation. The best way to get help is by posting
-{issues}[https://github.com/SciRuby/nmatrix/issues] or sending e-mails to our
-{mailing list}[https://groups.google.com/forum/?fromgroups#!forum/sciruby-dev]. You may also email @agarie, or look for
-`agarie` on #sciruby at chat.freenode.net if you want to ask questions or offer suggestions.
+If you have a suggestion or want to add documentation for any class or method in NMatrix, please open an issue or send a pull request with the changes.
 
 You can find the complete API documentation {on our website}[http://sciruby.com/nmatrix/docs/].
 
 == Examples
 
-Create a new NMatrix from a ruby Array: 
+Create a new NMatrix from a ruby Array:
 
     >> require 'nmatrix'
     >> NMatrix.new([2, 3], [0, 1, 2, 3, 4, 5], dtype: :int64)
@@ -107,7 +107,7 @@ The following features exist in the current version of NMatrix (0.1.0.rc1):
   * Point Cloud Library PCD file input
 * C and C++ API
 * BLAS internal implementations (no library) and ATLAS (with library) access:
-  * Level 1: xROT, xROTG (BLAS dtypes only), xASUM, xNRM2
+  * Level 1: xROT, xROTG (BLAS dtypes only), xASUM, xNRM2, IxAMAX
   * Level 2: xGEMV
   * Level 3: xGEMM, xTRSM
 * LAPACK ATLAS access:
@@ -125,7 +125,7 @@ The following features exist in the current version of NMatrix (0.1.0.rc1):
 * Matrix inversions (requires LAPACK; BLAS dtypes only)
 * Determinant calculation for BLAS dtypes
 * Vector 2-norms
-* Ruby/GSL interoperability (requires {SciRuby's fork of rb-gsl}(http://github.com/SciRuby/rb-gsl))
+* Ruby/GSL interoperability (requires {SciRuby's fork of rb-gsl}[http://github.com/SciRuby/rb-gsl])
 * slice assignments, e.g.,
     x[1..3,0..4] = some_other_matrix
 

data/ext/nmatrix/binary_format.txt

@@ -50,4 +50,4 @@ The latter will serve as the capacity when we read a Yale matrix.
 
 Then we store the a array, again padding with zeros so it's a multiple of 8 bytes.
 
-Then we store the ija array, padding with zeros so it's a multiple of 8 bytes.
+Then we store the ija array, padding with zeros so it's a multiple of 8 bytes.

data/ext/nmatrix/data/complex.h

@@ -61,7 +61,7 @@ typedef Complex<float64_t> Complex128;
 /*
  * Data
  */
- 
+
 /*
  * Classes and Functions
  */
@@ -72,12 +72,12 @@ class Complex {
 	// The real and immaginary parts of the complex number.
 	Type r;
 	Type i;
-	
+
 	/*
 	 * Default constructor.
 	 */
 	inline Complex(Type real = 0, Type imaginary = 0) : r(real), i(imaginary) {}
-	
+
 	/*
 	 * Copy constructors.
 	 */
@@ -112,11 +112,11 @@ class Complex {
 	/*
 	 * Binary operator definitions for various types.
 	 */
-	
+
 	////////////////////////////////
 	// Complex-Complex Operations //
 	////////////////////////////////
-	
+
 	template <typename OtherType>
 	inline Complex<Type> operator+(const Complex<OtherType>& other) const {
 		return Complex<Type>(this->r + other.r, this->i + other.i);
@@ -133,7 +133,7 @@ class Complex {
 	inline Complex<Type> operator-(const Complex<OtherType>& other) const {
 		return Complex<Type>(this->r - other.r, this->i - other.i);
 	}
-	
+
 	template <typename OtherType>
 	inline Complex<Type> operator*(const Complex<OtherType>& other) const {
 		return Complex<Type>(this->r * other.r - this->i * other.i, this->r * other.i + this->i * other.r);
@@ -150,43 +150,43 @@ class Complex {
 	inline Complex<Type> operator/(const Complex<OtherType>& other) const {
 		Type new_r, new_i;
 		Type denom = other.i * other.i + other.r * other.r;
-		
+
 		new_r = (this->r * other.r + this->i * other.i) / denom;
 		new_i = (this->i * other.r - this->r * other.i) / denom;
-		
+
 		return Complex<Type>(new_r, new_i);
 	}
-	
+
 	template <typename OtherType>
 	inline bool operator<(const Complex<OtherType>& other) const {
 		return (this->r < other.r) || ((this->r <= other.r) && (this->i < other.i));
 	}
-	
+
 	template <typename OtherType>
 	inline bool operator>(const Complex<OtherType>& other) const {
 		return (this->r > other.r) || ((this->r >= other.r) && (this->i > other.i));
 	}
-	
+
 	template <typename OtherType>
 	inline bool operator==(const Complex<OtherType>& other) const {
 		return FP_EQUAL(this->r, other.r) && FP_EQUAL(this->i, other.i);
 	}
-	
+
 	template <typename OtherType>
 	inline bool operator!=(const Complex<OtherType>& other) const {
 		return !(*this == other);
 	}
-	
+
 	template <typename OtherType>
 	inline bool operator<=(const Complex<OtherType>& other) const {
 		return (*this < other) || (*this == other);
 	}
-	
+
 	template <typename OtherType>
 	inline bool operator>=(const Complex<OtherType>& other) const {
 		return (*this > other) || (*this == other);
 	}
-	
+
 	template <typename OtherType>
 	inline operator Complex<OtherType> () const {
 		return Complex<OtherType>((OtherType)this->r, (OtherType)this->i);
@@ -195,27 +195,27 @@ class Complex {
 	/////////////////////////////////
 	// Complex-Rational Operations //
 	/////////////////////////////////
-	
+
 	template <typename RationalType>
 	inline Complex<Type> operator+(const Rational<RationalType>& other) const {
 		return *this + Complex<Type>(other);
 	}
-	
+
 	template <typename RationalType>
 	inline Complex<Type> operator-(const Rational<RationalType>& other) const {
 		return *this - Complex<Type>(other);
 	}
-	
+
 	template <typename RationalType>
 	inline Complex<Type> operator*(const Rational<RationalType>& other) const {
 		return *this * Complex<Type>(other);
 	}
-	
+
 	template <typename RationalType>
 	inline Complex<Type> operator/(const Rational<RationalType>& other) const {
 		return *this / Complex<Type>(other);
 	}
-	
+
 	template <typename RationalType, typename = typename std::enable_if<std::is_integral<RationalType>::value>::type>
 	inline bool operator!=(const Rational<RationalType>& other) const {
 	  return *this != Complex<Type>(other);
@@ -229,7 +229,7 @@ class Complex {
 	///////////////////////////////
 	// Complex-Native Operations //
 	///////////////////////////////
-	
+
 	template <typename NativeType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
 	inline Complex<Type> operator+(const NativeType& other) const {
 		return *this + Complex<Type>(other);

data/ext/nmatrix/data/data.cpp

@@ -30,6 +30,7 @@
  */
 
 #include <ruby.h>
+#include <stdexcept>
 
 /*
  * Project Includes
@@ -87,7 +88,7 @@ namespace nm {
     "exp", "log2", 
     "log10", "sqrt", "erf", 
     "erfc", "cbrt", "gamma",
-    "negate"
+    "negate", "floor", "ceil"
   };
 
 } // end of namespace nm
@@ -262,7 +263,13 @@ nm::RubyObject rubyobj_from_cval(void* val, nm::dtype_t dtype) {
 			return RubyObject(*reinterpret_cast<Rational128*>(val));
 
 	  default:
-	    throw;
+	  	try {
+	  		throw std::logic_error("Cannot create ruby object");
+	  	}
+	  	catch (std::logic_error err) {
+	  		printf("%s\n", err.what());
+	  	}
+
 	    rb_raise(nm_eDataTypeError, "Conversion to RubyObject requested from unknown/invalid data type (did you try to convert from a VALUE?)");
 	}
 	return Qnil;

data/ext/nmatrix/data/data.h

@@ -55,7 +55,7 @@ namespace nm {
 	const int NUM_DTYPES = 13;
 	const int NUM_ITYPES = 4;
 	const int NUM_EWOPS = 12;
-	const int NUM_UNARYOPS = 22;
+	const int NUM_UNARYOPS = 24;
 	const int NUM_NONCOM_EWOPS = 3;
 
   enum ewop_t {
@@ -100,7 +100,9 @@ namespace nm {
     UNARY_ERFC,
     UNARY_CBRT,
     UNARY_GAMMA,
-    UNARY_NEGATE
+    UNARY_NEGATE,
+    UNARY_FLOOR,
+    UNARY_CEIL
   };
 
   // element-wise and scalar operators

data/ext/nmatrix/math.cpp

@@ -122,7 +122,7 @@
 #include "math/gesvd.h"
 #include "math/geev.h"
 #include "math/swap.h"
-#include "math/idamax.h"
+#include "math/imax.h"
 #include "math/scal.h"
 #include "math/ger.h"
 #include "math/getf2.h"
@@ -156,11 +156,16 @@ extern "C" {
   #include <atlas/clapack.h>
 #endif
 
+  /* BLAS Level 1. */
+  static VALUE nm_cblas_scal(VALUE self, VALUE n, VALUE scale, VALUE vector, VALUE incx);
   static VALUE nm_cblas_nrm2(VALUE self, VALUE n, VALUE x, VALUE incx);
   static VALUE nm_cblas_asum(VALUE self, VALUE n, VALUE x, VALUE incx);
   static VALUE nm_cblas_rot(VALUE self, VALUE n, VALUE x, VALUE incx, VALUE y, VALUE incy, VALUE c, VALUE s);
   static VALUE nm_cblas_rotg(VALUE self, VALUE ab);
+  static VALUE nm_cblas_imax(VALUE self, VALUE n, VALUE x, VALUE incx);
 
+  /* BLAS Level 2. */
+  /* BLAS Level 3. */
   static VALUE nm_cblas_gemm(VALUE self, VALUE order, VALUE trans_a, VALUE trans_b, VALUE m, VALUE n, VALUE k, VALUE vAlpha,
                              VALUE a, VALUE lda, VALUE b, VALUE ldb, VALUE vBeta, VALUE c, VALUE ldc);
   static VALUE nm_cblas_gemv(VALUE self, VALUE trans_a, VALUE m, VALUE n, VALUE vAlpha, VALUE a, VALUE lda,
@@ -174,6 +179,7 @@ extern "C" {
   static VALUE nm_cblas_syrk(VALUE self, VALUE order, VALUE uplo, VALUE trans, VALUE n, VALUE k, VALUE alpha, VALUE a,
                              VALUE lda, VALUE beta, VALUE c, VALUE ldc);
 
+  /* LAPACK. */
   static VALUE nm_has_clapack(VALUE self);
   static VALUE nm_clapack_getrf(VALUE self, VALUE order, VALUE m, VALUE n, VALUE a, VALUE lda);
   static VALUE nm_clapack_potrf(VALUE self, VALUE order, VALUE uplo, VALUE n, VALUE a, VALUE lda);
@@ -182,7 +188,6 @@ extern "C" {
   static VALUE nm_clapack_getri(VALUE self, VALUE order, VALUE n, VALUE a, VALUE lda, VALUE ipiv);
   static VALUE nm_clapack_potri(VALUE self, VALUE order, VALUE uplo, VALUE n, VALUE a, VALUE lda);
   static VALUE nm_clapack_laswp(VALUE self, VALUE n, VALUE a, VALUE lda, VALUE k1, VALUE k2, VALUE ipiv, VALUE incx);
-  static VALUE nm_clapack_scal(VALUE self, VALUE n, VALUE scale, VALUE vector, VALUE incx);
   static VALUE nm_clapack_lauum(VALUE self, VALUE order, VALUE uplo, VALUE n, VALUE a, VALUE lda);
 
   static VALUE nm_lapack_gesvd(VALUE self, VALUE jobu, VALUE jobvt, VALUE m, VALUE n, VALUE a, VALUE lda, VALUE s, VALUE u, VALUE ldu, VALUE vt, VALUE ldvt, VALUE lworkspace_size);
@@ -394,7 +399,6 @@ void nm_math_init_blas() {
   rb_define_singleton_method(cNMatrix_LAPACK, "clapack_getri", (METHOD)nm_clapack_getri, 5);
   rb_define_singleton_method(cNMatrix_LAPACK, "clapack_potri", (METHOD)nm_clapack_potri, 5);
   rb_define_singleton_method(cNMatrix_LAPACK, "clapack_laswp", (METHOD)nm_clapack_laswp, 7);
-  rb_define_singleton_method(cNMatrix_LAPACK, "clapack_scal",  (METHOD)nm_clapack_scal,  4);
   rb_define_singleton_method(cNMatrix_LAPACK, "clapack_lauum", (METHOD)nm_clapack_lauum, 5);
 
   /* Non-ATLAS regular LAPACK Functions called via Fortran interface */
@@ -404,10 +408,12 @@ void nm_math_init_blas() {
 
   cNMatrix_BLAS = rb_define_module_under(cNMatrix, "BLAS");
 
+  rb_define_singleton_method(cNMatrix_BLAS, "cblas_scal", (METHOD)nm_cblas_scal, 4);
   rb_define_singleton_method(cNMatrix_BLAS, "cblas_nrm2", (METHOD)nm_cblas_nrm2, 3);
   rb_define_singleton_method(cNMatrix_BLAS, "cblas_asum", (METHOD)nm_cblas_asum, 3);
   rb_define_singleton_method(cNMatrix_BLAS, "cblas_rot",  (METHOD)nm_cblas_rot,  7);
   rb_define_singleton_method(cNMatrix_BLAS, "cblas_rotg", (METHOD)nm_cblas_rotg, 1);
+  rb_define_singleton_method(cNMatrix_BLAS, "cblas_imax", (METHOD)nm_cblas_imax, 3);
 
 	rb_define_singleton_method(cNMatrix_BLAS, "cblas_gemm", (METHOD)nm_cblas_gemm, 14);
 	rb_define_singleton_method(cNMatrix_BLAS, "cblas_gemv", (METHOD)nm_cblas_gemv, 11);
@@ -457,6 +463,35 @@ static inline enum CBLAS_TRANSPOSE blas_transpose_sym(VALUE op) {
   return CblasNoTrans;
 }
 
+/*
+ * call-seq:
+ *     NMatrix::BLAS.cblas_scal(n, alpha, vector, inc) -> NMatrix
+ *
+ * BLAS level 1 function +scal+. Works with all dtypes.
+ *
+ * Scale +vector+ in-place by +alpha+ and also return it. The operation is as
+ * follows:
+ *  x <- alpha * x
+ *
+ * - +n+ -> Number of elements of +vector+.
+ * - +alpha+ -> Scalar value used in the operation.
+ * - +vector+ -> NMatrix of shape [n,1] or [1,n]. Modified in-place.
+ * - +inc+ -> Increment used in the scaling function. Should generally be 1.
+ */
+static VALUE nm_cblas_scal(VALUE self, VALUE n, VALUE alpha, VALUE vector, VALUE incx) {
+  nm::dtype_t dtype = NM_DTYPE(vector);
+
+  void* scalar = NM_ALLOCA_N(char, DTYPE_SIZES[dtype]);
+  rubyval_to_cval(alpha, dtype, scalar);
+
+  NAMED_DTYPE_TEMPLATE_TABLE(ttable, nm::math::cblas_scal, void, const int n,
+      const void* scalar, void* x, const int incx);
+
+  ttable[dtype](FIX2INT(n), scalar, NM_STORAGE_DENSE(vector)->elements,
+      FIX2INT(incx));
+
+  return vector;
+}
 
 /*
  * Interprets cblas argument which could be :left or :right
@@ -519,14 +554,17 @@ static inline enum CBLAS_ORDER blas_order_sym(VALUE op) {
  *
  * The Givens plane rotation can be used to introduce zero elements into a matrix selectively.
  *
- * This function differs from most of the other raw BLAS accessors. Instead of providing a, b, c, s as arguments, you
- * should only provide a and b (the inputs), and you should provide them as a single NVector (or the first two elements
- * of any dense NMatrix or NVector type, specifically).
+ * This function differs from most of the other raw BLAS accessors. Instead of
+ * providing a, b, c, s as arguments, you should only provide a and b (the
+ * inputs), and you should provide them as the first two elements of any dense
+ * NMatrix type.
  *
- * The outputs [c,s] will be returned in a Ruby Array at the end; the input NVector will also be modified in-place.
+ * The outputs [c,s] will be returned in a Ruby Array at the end; the input
+ * NMatrix will also be modified in-place.
  *
- * If you provide rationals, be aware that there's a high probability of an error, since rotg includes a square root --
- * and most rationals' square roots are irrational. You're better off converting to Float first.
+ * If you provide rationals, be aware that there's a high probability of an
+ * error, since rotg includes a square root -- and most rationals' square roots
+ * are irrational. You're better off converting to Float first.
  *
  * This function, like the other cblas_ functions, does minimal type-checking.
  */
@@ -753,7 +791,29 @@ static VALUE nm_cblas_asum(VALUE self, VALUE n, VALUE x, VALUE incx) {
   return rubyobj_from_cval(Result, rdtype).rval;
 }
 
+/*
+ * call-seq:
+ *    NMatrix::BLAS.cblas_imax(n, vector, inc) -> Fixnum
+ *
+ * BLAS level 1 routine.
+ *
+ * Return the index of the largest element of +vector+.
+ *
+ * - +n+ -> Vector's size. Generally, you can use NMatrix#rows or NMatrix#cols.
+ * - +vector+ -> A NMatrix of shape [n,1] or [1,n] with any dtype.
+ * - +inc+ -> It's the increment used when searching. Use 1 except if you know
+ *   what you're doing.
+ */
+static VALUE nm_cblas_imax(VALUE self, VALUE n, VALUE x, VALUE incx) {
+  NAMED_DTYPE_TEMPLATE_TABLE(ttable, nm::math::cblas_imax, int, const int n, const void* x, const int incx);
 
+  nm::dtype_t dtype = NM_DTYPE(x);
+
+  int index = ttable[dtype](FIX2INT(n), NM_STORAGE_DENSE(x)->elements, FIX2INT(incx));
+
+  // Convert to Ruby's Int value.
+  return INT2FIX(index);
+}
 
 
 /* Call any of the cblas_xgemm functions as directly as possible.
@@ -1198,25 +1258,6 @@ static VALUE nm_lapack_geev(VALUE self, VALUE compute_left, VALUE compute_right,
 }
 
 
-/*
- * Based on LAPACK's dscal function, but for any dtype.
- *
- * In-place modification; returns the modified vector as well.
- */
-static VALUE nm_clapack_scal(VALUE self, VALUE n, VALUE scale, VALUE vector, VALUE incx) {
-  nm::dtype_t dtype = NM_DTYPE(vector);
-
-  void* da      = NM_ALLOCA_N(char, DTYPE_SIZES[dtype]);
-  rubyval_to_cval(scale, dtype, da);
-
-  NAMED_DTYPE_TEMPLATE_TABLE(ttable, nm::math::clapack_scal, void, const int n, const void* da, void* dx, const int incx);
-
-  ttable[dtype](FIX2INT(n), da, NM_STORAGE_DENSE(vector)->elements, FIX2INT(incx));
-
-  return vector;
-}
-
-
 static VALUE nm_clapack_lauum(VALUE self, VALUE order, VALUE uplo, VALUE n, VALUE a, VALUE lda) {
   static int (*ttable[nm::NUM_DTYPES])(const enum CBLAS_ORDER, const enum CBLAS_UPLO, const int n, void* a, const int lda) = {
       /*nm::math::clapack_lauum<uint8_t, false>,
@@ -1386,7 +1427,6 @@ static VALUE nm_clapack_getrs(VALUE self, VALUE order, VALUE trans, VALUE n, VAL
   };
 
   // Allocate the C version of the pivot index array
-  // TODO: Allow for an NVector here also, maybe?
   int* ipiv_;
   if (TYPE(ipiv) != T_ARRAY) {
     rb_raise(rb_eArgError, "ipiv must be of type Array");
@@ -1493,7 +1533,6 @@ static VALUE nm_clapack_getri(VALUE self, VALUE order, VALUE n, VALUE a, VALUE l
   };
 
   // Allocate the C version of the pivot index array
-  // TODO: Allow for an NVector here also, maybe?
   int* ipiv_;
   if (TYPE(ipiv) != T_ARRAY) {
     rb_raise(rb_eArgError, "ipiv must be of type Array");
@@ -1590,7 +1629,6 @@ static VALUE nm_clapack_laswp(VALUE self, VALUE n, VALUE a, VALUE lda, VALUE k1,
   };
 
   // Allocate the C version of the pivot index array
-  // TODO: Allow for an NVector here also, maybe?
   int* ipiv_;
   if (TYPE(ipiv) != T_ARRAY) {
     rb_raise(rb_eArgError, "ipiv must be of type Array");