nmatrix 0.1.0.rc1 → 0.1.0.rc2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fbe2c20e1a86c29f525cda90fd74b6e916b8e406
-  data.tar.gz: 0f50913f5df2579d6d7acb8986f5c5321bdf3bec
+  metadata.gz: 4052431a5f81ea9304f96fe293f6f22a47dacf3d
+  data.tar.gz: 777b0fd050d7f0726ea97f337d5f4ce3cf850f8b
 SHA512:
-  metadata.gz: 0aa8a2a396a4c88b0ed73a7674d95ccafd63fe8394cad06319531e0465a12628851dfb796454c6c41b52d102d5688b413f114b4b3a8560de566ea69089da32e7
-  data.tar.gz: 44ec7c62e47ccd107e584500124019a0847ab67a8f88495d376416e491745d7f8550f0aba10d9f5dea6bc90ecd3e8adc23eba5a28fea42b05c22d061a1e103a2
+  metadata.gz: daabd9cebbe93674079728f254cf5429bb1d0cadfb2ddbb56061da9181508852bd919844baf7e63615237fe6f2fc864dd27515b97153ea7704185001417a2f27
+  data.tar.gz: b36dcd576afedd2ddc1fa57af569823fb72f98d0e11cd0e1d7ea751553e1b2de39fe32a197d0a731a308ec28a6e96aedcc0687b73853f88ab0002c6145e53e7b

data/.travis.yml

@@ -1,12 +1,15 @@
 language: ruby
+cache: bundler
 env:
   - CPLUS_INCLUDE_PATH=/usr/include/atlas C_INCLUDE_PATH=/usr/include/atlas
 rvm:
   - "1.9.2"
   - "1.9.3"
   - "2.0.0"
+  - "2.1.0"
 before_install:
   - sudo apt-get update -qq
   - sudo apt-get install -qq libatlas-base-dev
 script: bundle exec rake compile && bundle exec rake spec
-
+notifications:
+  irc: "chat.freenode.net#sciruby"

data/Gemfile

@@ -1,12 +1,9 @@
-# Gemfile
-source 'http://rubygems.org'
+source 'https://rubygems.org'
 gemspec
 
 gem 'packable', ">= 1.3.5"  # for Matlab IO
 
 group :development do
-  gem 'pry'
-  gem 'rspec-longrun'
   #gem 'narray', :path => "../narray"
   #gem 'pry-debugger'
 end

data/History.txt

@@ -428,7 +428,7 @@
   * Casting from dense to Yale now properly accepts the default
     value option
 
-=== 0.1.0.rc1 / 2014-12-28
+=== 0.1.0.rc1 / 2013-12-28
 
 * 4 major enhancements:
 
@@ -520,4 +520,66 @@
     lazy symbol binding
 
   * Improved LAPACK and BLAS header selection for Ubuntu/Debian
-    systems with ATLAS (by @mvz)
+    systems with ATLAS (by @mvz)
+
+=== 0.1.0.rc2 / 2014-03-12
+
+* No major enhancements.
+
+* 14 minor enhancements:
+
+  * Implemented negative-index slicing (by @rajatkapoor)
+
+  * Added reader for Point Cloud Library's PCD format
+
+  * Added Ruby 2.1 support (including Travis CI testing)
+
+  * Implemented LAPACK-independent exact inverse calculation for
+    dense matrices of size 2x2 and 3x3, as well as
+
+  * Added NMatrix::has_clapack? method to determine whether CLAPACK
+    support has been compiled in
+
+  * Improved conformance of specs to RSpec best practices (by 
+    @duggiefresh)
+
+  * Travis CI now updates the IRC channel when a check passes (by
+    @agarie)
+
+  * Added NMatrix#data_pointer, which returns the memory address of
+    the stored elements in a matrix (generally for use with FFI and
+    other libraries that need pointers)
+
+  * Made NMatrix#clone_structure a public method (was protected)
+
+  * Added :scale option for NMatrix::random to handle non-floating
+    point forms
+
+  * Added complex support to NMatrix::random
+
+  * Aliased NMatrix::random to NMatrix::rand
+
+  * Added NMatrix#reshape! for in-place reshape of dense matrices (by
+    @rajatkapoor)
+
+  * Implemented unary negation of matrices
+
+* 6 bug fixes:
+
+  * Fixed dot product operation on 1-dimensional matrices (by @rve
+    and @cjfuller)
+
+  * Fixed segfault on 1-dimensional matrix transpose (by @cjfuller)
+
+  * Fixed compile error with Ruby 2.1 (by @diminish7)
+
+  * Fixed regression which wasn't causing any problems but was
+    counter to design: stride was declared prior to data storage for
+    dense matrix storage
+
+  * Fixed Rakefile problem which was causing specs to run twice in a
+    row with each call to rake spec
+
+  * NMatrix::random now raises an exception when rational matrices
+    are requested
+

data/Manifest.txt

@@ -13,6 +13,7 @@ lib/nmatrix/rspec.rb
 lib/nmatrix/io/market.rb
 lib/nmatrix/io/mat5_reader.rb
 lib/nmatrix/io/mat_reader.rb
+lib/nmatrix/io/point_cloud.rb
 lib/nmatrix/blas.rb
 lib/nmatrix/enumerate.rb
 lib/nmatrix/lapack.rb
@@ -32,12 +33,12 @@ ext/nmatrix/data/rational.h
 ext/nmatrix/data/ruby_object.h
 ext/nmatrix/storage/common.cpp
 ext/nmatrix/storage/common.h
-ext/nmatrix/storage/dense.cpp
-ext/nmatrix/storage/dense.h
-ext/nmatrix/storage/list.cpp
-ext/nmatrix/storage/list.h
 ext/nmatrix/storage/storage.cpp
 ext/nmatrix/storage/storage.h
+ext/nmatrix/storage/dense/dense.cpp
+ext/nmatrix/storage/dense/dense.h
+ext/nmatrix/storage/list/list.cpp
+ext/nmatrix/storage/list/list.h
 ext/nmatrix/storage/yale/yale.cpp
 ext/nmatrix/storage/yale/yale.h
 ext/nmatrix/storage/yale/class.h
@@ -83,6 +84,7 @@ ext/nmatrix/ruby_constants.cpp
 ext/nmatrix/ruby_constants.h
 ext/nmatrix/ruby_nmatrix.c
 ext/nmatrix/types.h
+ext/nmatrix/nm_memory.h
 ext/nmatrix/extconf.rb
 
 

data/README.rdoc

@@ -20,7 +20,7 @@ NMatrix was inspired by {NArray}[http://narray.rubyforge.org], by Masahiro Tanak
 
 To install the latest stable version:
 
-    gem install nmatrix
+    gem install nmatrix --pre
 
 However, you will need to install {ATLAS}[http://math-atlas.sourceforge.net/] with CBLAS (C interface to
 {BLAS}[http://en.wikipedia.org/wiki/Basic_Linear_Algebra_Subprograms]) first. Detailed directions can be found
@@ -28,7 +28,7 @@ However, you will need to install {ATLAS}[http://math-atlas.sourceforge.net/] wi
 
 * ATLAS, preferably with CLAPACK ({see here for details}[https://github.com/SciRuby/nmatrix/wiki/Installation])
 * a version of GCC or clang which supports C++0x or C++11
-* Ruby 1.9.3+
+* Ruby 1.9.2+
 * {packable}[http://github.com/marcandre/packable] 1.3.5 (used for I/O)
 
 If you want to obtain the latest (development) code, you should generally do:
@@ -38,7 +38,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-rc1.gem
+    gem install pkg/nmatrix-0.1.0.rc2.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
@@ -101,7 +101,10 @@ The following features exist in the current version of NMatrix (0.1.0.rc1):
 * Matrix slicing by copy and reference (for dense, yale, and list)
 * Native reading and writing of dense and yale matrices
   * Optional compression for dense matrices with symmetry or triangularity: symmetric, skew, hermitian, upper, lower
-* Matlab .MAT v5 file input
+* Input/output:
+  * Matlab .MAT v5 file input
+  * MatrixMarket file input/output
+  * 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
@@ -128,7 +131,7 @@ The following features exist in the current version of NMatrix (0.1.0.rc1):
 
 === Planned Features (Short-to-Medium Term)
 
-We are nearly the release of NMatrix 0.1.0, our first beta.
+We are nearing the release of NMatrix 0.1.0, our first beta.
 
 These are features planned for NMatrix 0.2.0:
 

data/Rakefile

@@ -66,8 +66,6 @@ VALGRIND_MEMORYFILL_OPTIONS = [
 GDB_OPTIONS = []
 
 
-RSpec::Core::RakeTask.new(:spec)
-
 task :console do |task|
   cmd = [ 'irb', "-r './lib/nmatrix.rb'" ]
   run *cmd

data/ext/nmatrix/data/data.cpp

@@ -86,7 +86,8 @@ namespace nm {
     "asinh", "acosh", "atanh",
     "exp", "log2", 
     "log10", "sqrt", "erf", 
-    "erfc", "cbrt", "gamma"
+    "erfc", "cbrt", "gamma",
+    "negate"
   };
 
 } // end of namespace nm

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 = 21;
+	const int NUM_UNARYOPS = 22;
 	const int NUM_NONCOM_EWOPS = 3;
 
   enum ewop_t {
@@ -99,7 +99,8 @@ namespace nm {
     UNARY_ERF,
     UNARY_ERFC,
     UNARY_CBRT,
-    UNARY_GAMMA
+    UNARY_GAMMA,
+    UNARY_NEGATE
   };
 
   // element-wise and scalar operators

data/ext/nmatrix/extconf.rb

@@ -70,13 +70,8 @@ def create_conf_h(file) #:nodoc:
     hfile.puts
 
     # FIXME: Find a better way to do this:
-    if RUBY_VERSION >= '2.0'
-      hfile.puts "#define RUBY_2 1"
-    end
-
-    if RUBY_VERSION < '1.9.3'
-      hfile.puts "#define OLD_RB_SCAN_ARGS"
-    end
+    hfile.puts "#define RUBY_2 1" if RUBY_VERSION >= '2.0'
+    hfile.puts "#define OLD_RB_SCAN_ARGS" if RUBY_VERSION < '1.9.3'
 
     for line in $defs
       line =~ /^-D(.*)/
@@ -231,9 +226,9 @@ $libs += " -llapack -lcblas -latlas "
 
 
 # For release, these next two should both be changed to -O3.
-$CFLAGS += " -O3 -g" #" -O0 -g "
+$CFLAGS += " -O3" #" -O0 -g "
 #$CFLAGS += " -static -O0 -g "
-$CPPFLAGS += " -O3 -std=#{$CPP_STANDARD} -g" #" -O0 -g -std=#{$CPP_STANDARD} " #-fmax-errors=10 -save-temps
+$CPPFLAGS += " -O3 -std=#{$CPP_STANDARD}" #" -O0 -g -std=#{$CPP_STANDARD} " #-fmax-errors=10 -save-temps
 #$CPPFLAGS += " -static -O0 -g -std=#{$CPP_STANDARD} "
 
 CONFIG['warnflags'].gsub!('-Wshorten-64-to-32', '') # doesn't work except in Mac-patched gcc (4.2)

data/ext/nmatrix/math.cpp

@@ -174,6 +174,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);
 
+  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);
   static VALUE nm_clapack_getrs(VALUE self, VALUE order, VALUE trans, VALUE n, VALUE nrhs, VALUE a, VALUE lda, VALUE ipiv, VALUE b, VALUE ldb);
@@ -223,6 +224,46 @@ void det_exact(const int M, const void* A_elements, const int lda, void* result_
 }
 
 
+/*
+ * Calculate the inverse for a dense matrix (A [elements]) of size 2 or 3. Places the result in B_elements.
+ */
+template <typename DType>
+void inverse_exact(const int M, const void* A_elements, const int lda, void* B_elements, const int ldb) {
+  const DType* A = reinterpret_cast<const DType*>(A_elements);
+  DType* B       = reinterpret_cast<DType*>(B_elements);
+
+  if (M == 2) {
+    DType det = A[0] * A[lda+1] - A[1] * A[lda];
+    B[0] = A[lda+1] / det;
+    B[1] = -A[1] / det;
+    B[ldb] = -A[lda] / det;
+    B[ldb+1] = -A[0] / det;
+
+  } else if (M == 3) {
+    // Calculate the exact determinant.
+    DType det;
+    det_exact<DType>(M, A_elements, lda, reinterpret_cast<void*>(&det));
+    if (det == 0) {
+      rb_raise(nm_eNotInvertibleError, "matrix must have non-zero determinant to be invertible (not getting this error does not mean matrix is invertible if you're dealing with floating points)");
+    }
+
+    B[0]      = (  A[lda+1] * A[2*lda+2] - A[lda+2] * A[2*lda+1]) / det; // A = ei - fh
+    B[1]      = (- A[1]     * A[2*lda+2] + A[2]     * A[2*lda+1]) / det; // D = -bi + ch
+    B[2]      = (  A[1]     * A[lda+2]   - A[2]     * A[lda+1])   / det; // G = bf - ce
+    B[ldb]    = (- A[lda]   * A[2*lda+2] + A[lda+2] * A[2*lda])   / det; // B = -di + fg
+    B[ldb+1]  = (  A[0]     * A[2*lda+2] - A[2]     * A[2*lda])   / det; // E = ai - cg
+    B[ldb+2]  = (- A[0]     * A[lda+2]   + A[2]     * A[lda])     / det; // H = -af + cd
+    B[2*ldb]  = (  A[lda]   * A[2*lda+1] - A[lda+1] * A[2*lda])   / det; // C = dh - eg
+    B[2*ldb+1]= ( -A[0]     * A[2*lda+1] + A[1]     * A[2*lda])   / det; // F = -ah + bg
+    B[2*ldb+2]= (  A[0]     * A[lda+1]   - A[1]     * A[lda])     / det; // I = ae - bd
+  } else if (M == 1) {
+    B[0] = 1 / A[0];
+  } else {
+    rb_raise(rb_eNotImpError, "exact inverse calculation needed for matrices larger than 3x3");
+  }
+}
+
+
 /*
  * Function signature conversion for calling CBLAS' gesvd functions as directly as possible.
  */
@@ -343,6 +384,8 @@ extern "C" {
 void nm_math_init_blas() {
 	cNMatrix_LAPACK = rb_define_module_under(cNMatrix, "LAPACK");
 
+  rb_define_singleton_method(cNMatrix, "has_clapack?", (METHOD)nm_has_clapack, 0);
+
   /* ATLAS-CLAPACK Functions */
   rb_define_singleton_method(cNMatrix_LAPACK, "clapack_getrf", (METHOD)nm_clapack_getrf, 5);
   rb_define_singleton_method(cNMatrix_LAPACK, "clapack_potrf", (METHOD)nm_clapack_potrf, 5);
@@ -1404,6 +1447,19 @@ static VALUE nm_clapack_potrs(VALUE self, VALUE order, VALUE uplo, VALUE n, VALU
 }
 
 
+/*
+ * Simple way to check from within Ruby code if clapack functions are available, without
+ * having to wait around for an exception to be thrown.
+ */
+static VALUE nm_has_clapack(VALUE self) {
+#ifndef HAVE_CLAPACK_H
+  return Qfalse;
+#else
+  return Qtrue;
+#endif
+}
+
+
 /* Call any of the clapack_xgetri functions as directly as possible.
  *
  * You probably don't want to call this function. Instead, why don't you try clapack_getri, which is more flexible
@@ -1562,6 +1618,15 @@ void nm_math_det_exact(const int M, const void* elements, const int lda, nm::dty
   ttable[dtype](M, elements, lda, result);
 }
 
+/*
+ * C accessor for calculating an exact inverse.
+ */
+void nm_math_inverse_exact(const int M, const void* A_elements, const int lda, void* B_elements, const int ldb, nm::dtype_t dtype) {
+  NAMED_DTYPE_TEMPLATE_TABLE(ttable, nm::math::inverse_exact, void, const int, const void*, const int, void*, const int);
+
+  ttable[dtype](M, A_elements, lda, B_elements, ldb);
+}
+
 
 /*
  * Transpose an array of elements that represent a row-major dense matrix. Does not allocate anything, only does an memcpy.

data/ext/nmatrix/math/math.h

@@ -104,6 +104,7 @@ extern "C" {
    * C accessors.
    */
   void nm_math_det_exact(const int M, const void* elements, const int lda, nm::dtype_t dtype, void* result);
+  void nm_math_inverse_exact(const int M, const void* A_elements, const int lda, void* B_elements, const int ldb, nm::dtype_t dtype);
   void nm_math_transpose_generic(const size_t M, const size_t N, const void* A, const int lda, void* B, const int ldb, size_t element_size);
   void nm_math_init_blas(void);
 

data/ext/nmatrix/nmatrix.h

@@ -248,8 +248,8 @@ NM_DEF_STORAGE_STRUCT;
 
 /* Dense Storage */
 NM_DEF_STORAGE_CHILD_STRUCT_PRE(DENSE_STORAGE); // struct DENSE_STORAGE : STORAGE {
-	size_t*	stride;
-	void*		elements;
+	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 */

data/ext/nmatrix/ruby_constants.cpp

@@ -94,7 +94,9 @@ VALUE cNMatrix,
 			
 			nm_eDataTypeError,
       nm_eConvergenceError,
-			nm_eStorageTypeError;
+			nm_eStorageTypeError,
+      nm_eShapeError,
+      nm_eNotInvertibleError;
 
 /*
  * Functions

data/ext/nmatrix/ruby_constants.h

@@ -96,7 +96,9 @@ extern VALUE	cNMatrix,
 			
 							nm_eDataTypeError,
               nm_eConvergenceError,
-							nm_eStorageTypeError;
+							nm_eStorageTypeError,
+							nm_eShapeError,
+							nm_eNotInvertibleError;
 
 /*
  * Functions

data/ext/nmatrix/ruby_nmatrix.c

@@ -65,6 +65,8 @@ static VALUE is_symmetric(VALUE self, bool hermitian);
 static VALUE nm_guess_dtype(VALUE self, VALUE v);
 static VALUE nm_min_dtype(VALUE self, VALUE v);
 
+static VALUE nm_data_pointer(VALUE self);
+
 /*
  * Macro defines an element-wise accessor function for some operation.
  *
@@ -129,6 +131,7 @@ DECL_UNARY_RUBY_ACCESSOR(erf)
 DECL_UNARY_RUBY_ACCESSOR(erfc)
 DECL_UNARY_RUBY_ACCESSOR(cbrt)
 DECL_UNARY_RUBY_ACCESSOR(gamma)
+DECL_UNARY_RUBY_ACCESSOR(negate)
 DECL_NONCOM_ELEMENTWISE_RUBY_ACCESSOR(atan2)
 DECL_NONCOM_ELEMENTWISE_RUBY_ACCESSOR(ldexp)
 DECL_NONCOM_ELEMENTWISE_RUBY_ACCESSOR(hypot)
@@ -149,7 +152,9 @@ static VALUE matrix_multiply_scalar(NMATRIX* left, VALUE scalar);
 static VALUE matrix_multiply(NMATRIX* left, NMATRIX* right);
 static VALUE nm_multiply(VALUE left_v, VALUE right_v);
 static VALUE nm_det_exact(VALUE self);
+static VALUE nm_inverse_exact(VALUE self, VALUE inverse);
 static VALUE nm_complex_conjugate_bang(VALUE self);
+static VALUE nm_reshape_bang(VALUE self, VALUE arg);
 
 static nm::dtype_t	interpret_dtype(int argc, VALUE* argv, nm::stype_t stype);
 static void*		interpret_initial_value(VALUE arg, nm::dtype_t dtype);
@@ -190,6 +195,16 @@ void Init_nmatrix() {
 	 */
 	nm_eStorageTypeError = rb_define_class("StorageTypeError", rb_eStandardError);
 
+	/*
+	 * Exception raise when the matrix shape is not appropriate for a given operation.
+	 */
+	nm_eShapeError = rb_define_class("ShapeError", rb_eStandardError);
+
+  /*
+   * Exception raise when an inverse is requested but the matrix is not invertible.
+   */
+  nm_eNotInvertibleError = rb_define_class("NotInvertibleError", rb_eStandardError);
+
   /*
    * Class that holds values in use by the C code.
    */
@@ -243,7 +258,9 @@ void Init_nmatrix() {
 	rb_define_method(cNMatrix, "supershape", (METHOD)nm_supershape, 0);
 	rb_define_method(cNMatrix, "offset", (METHOD)nm_offset, 0);
 	rb_define_method(cNMatrix, "det_exact", (METHOD)nm_det_exact, 0);
+	rb_define_protected_method(cNMatrix, "__inverse_exact__", (METHOD)nm_inverse_exact, 1);
 	rb_define_method(cNMatrix, "complex_conjugate!", (METHOD)nm_complex_conjugate_bang, 0);
+	rb_define_protected_method(cNMatrix, "reshape_bang", (METHOD)nm_reshape_bang, 1);
 
 	rb_define_protected_method(cNMatrix, "__dense_each__", (METHOD)nm_dense_each, 0);
 	rb_define_protected_method(cNMatrix, "__dense_map__", (METHOD)nm_dense_map, 0);
@@ -293,6 +310,7 @@ void Init_nmatrix() {
   rb_define_method(cNMatrix, "cbrt",  (METHOD)nm_unary_cbrt,  0);
   rb_define_method(cNMatrix, "gamma", (METHOD)nm_unary_gamma, 0);
   rb_define_method(cNMatrix, "log",   (METHOD)nm_unary_log,  -1);
+  rb_define_method(cNMatrix, "-@",    (METHOD)nm_unary_negate,0);
 
 	rb_define_method(cNMatrix, "=~", (METHOD)nm_ew_eqeq, 1);
 	rb_define_method(cNMatrix, "!~", (METHOD)nm_ew_neq, 1);
@@ -316,6 +334,11 @@ void Init_nmatrix() {
 
 	rb_define_method(cNMatrix, "capacity", (METHOD)nm_capacity, 0);
 
+	/////////////////
+	// FFI Methods //
+	/////////////////
+	rb_define_method(cNMatrix, "data_pointer", (METHOD)nm_data_pointer, 0);
+
 	/////////////
 	// Aliases //
 	/////////////
@@ -900,6 +923,7 @@ DEF_UNARY_RUBY_ACCESSOR(ERF, erf)
 DEF_UNARY_RUBY_ACCESSOR(ERFC, erfc)
 DEF_UNARY_RUBY_ACCESSOR(CBRT, cbrt)
 DEF_UNARY_RUBY_ACCESSOR(GAMMA, gamma)
+DEF_UNARY_RUBY_ACCESSOR(NEGATE, negate)
 
 DEF_NONCOM_ELEMENTWISE_RUBY_ACCESSOR(ATAN2, atan2)
 DEF_NONCOM_ELEMENTWISE_RUBY_ACCESSOR(LDEXP, ldexp)
@@ -1000,6 +1024,51 @@ static VALUE nm_complex_conjugate_bang(VALUE self) {
   return self;
 }
 
+
+/*
+ * call-seq:
+ *     __reshape!__ -> NMatrix
+ *
+ * Reshapes the matrix (in-place) to the desired shape. Note that this function does not do a resize; the product of
+ * the new and old shapes' components must be equal.
+ *
+ */
+static VALUE nm_reshape_bang(VALUE self, VALUE arg){
+  NMATRIX* m;
+  UnwrapNMatrix(self, m); 
+  if(m->stype == nm::DENSE_STORE){
+    DENSE_STORAGE* s   = NM_STORAGE_DENSE(self);
+    VALUE shape_ary = arg;
+    size_t dim;
+    size_t size = nm_storage_count_max_elements(s);
+    size_t new_size = 1;
+    size_t* shape = interpret_shape(shape_ary, &dim);
+    void* elem = s->elements;
+    for (size_t index = 0; index < dim; ++index){
+      new_size *= shape[index];}
+ 
+    if (size == new_size){
+      s->shape = shape; 
+      s->dim = dim;
+      size_t i, j;
+      size_t* stride = NM_ALLOC_N(size_t, dim);
+      for (i = 0; i < dim; ++i) {
+        stride[i] = 1;
+        for (j = i+1; j < dim; ++j) {
+          stride[i] *= shape[j];
+        }
+        s->stride = stride;
+      }
+      return self;
+     }
+     else
+       rb_raise(rb_eArgError, "reshape cannot resize; size of new and old matrices must match");  
+  }
+  else {
+    rb_raise(rb_eNotImpError, "reshape in place only for dense stype");
+  }
+}
+
 /*
  * Helper function for creating a matrix. You have to create the storage and pass it in, but you don't
  * need to worry about deleting it.
@@ -1958,6 +2027,21 @@ static VALUE nm_multiply(VALUE left_v, VALUE right_v) {
     CheckNMatrixType(right_v);
     UnwrapNMatrix( right_v, right );
 
+    // work like vector dot product for 1dim
+    if (left->storage->dim == 1 && right->storage->dim == 1) {
+      if (left->storage->shape[0] != right->storage->shape[0]) {
+        NM_CONSERVATIVE(nm_unregister_value(left_v));
+        NM_CONSERVATIVE(nm_unregister_value(right_v));
+        rb_raise(rb_eArgError, "The left- and right-hand sides of the operation must have the same dimensionality.");
+      } else {
+        VALUE result = elementwise_op(nm::EW_MUL, left_v, right_v);
+        VALUE to_return = rb_funcall(result, rb_intern("sum"),0);
+        NM_CONSERVATIVE(nm_unregister_value(left_v));
+        NM_CONSERVATIVE(nm_unregister_value(right_v));
+        return to_return;
+      }
+    }
+
     if (left->storage->shape[1] != right->storage->shape[0]) {
       NM_CONSERVATIVE(nm_unregister_value(left_v));
       NM_CONSERVATIVE(nm_unregister_value(right_v));
@@ -2569,8 +2653,11 @@ static SLICE* get_slice(size_t dim, int argc, VALUE* arg, size_t* shape) {
       slice->lengths[r] = 1;
 
     } else if (FIXNUM_P(v)) { // this used CLASS_OF before, which is inefficient for fixnum
-
-      slice->coords[r]  = FIX2UINT(v);
+      int v_ = FIX2INT(v);
+      if (v_ < 0) // checking for negative indexes
+        slice->coords[r]  = shape[r]+v_;
+      else
+        slice->coords[r]  = v_;
       slice->lengths[r] = 1;
       t++;
 
@@ -2584,8 +2671,15 @@ static SLICE* get_slice(size_t dim, int argc, VALUE* arg, size_t* shape) {
     } else if (TYPE(arg[t]) == T_HASH) { // 3:5 notation (inclusive)
       VALUE begin_end   = rb_funcall(v, rb_intern("shift"), 0); // rb_hash_shift
       nm_register_value(begin_end);
-      slice->coords[r]  = FIX2UINT(rb_ary_entry(begin_end, 0));
-      slice->lengths[r] = FIX2UINT(rb_ary_entry(begin_end, 1)) - slice->coords[r];
+
+      if (rb_ary_entry(begin_end, 0) >= 0)
+        slice->coords[r]  = FIX2INT(rb_ary_entry(begin_end, 0));
+      else 
+        slice->coords[r]  = shape[r] + FIX2INT(rb_ary_entry(begin_end, 0));
+      if (rb_ary_entry(begin_end, 1) >= 0)
+        slice->lengths[r] = FIX2INT(rb_ary_entry(begin_end, 1)) - slice->coords[r];
+      else 
+        slice->lengths[r] = shape[r] + FIX2INT(rb_ary_entry(begin_end, 1)) - slice->coords[r];
 
       if (RHASH_EMPTY_P(v)) t++; // go on to the next
       slice->single = false;
@@ -2593,12 +2687,19 @@ static SLICE* get_slice(size_t dim, int argc, VALUE* arg, size_t* shape) {
 
     } else if (CLASS_OF(v) == rb_cRange) {
       rb_range_values(arg[t], &beg, &end, &excl);
-      slice->coords[r]  = FIX2UINT(beg);
+
+      int begin_ = FIX2INT(beg);
+      int end_   = FIX2INT(end);
+
+      slice->coords[r] = (begin_ < 0) ? shape[r] + begin_ : begin_;
+
       // Exclude last element for a...b range
-      slice->lengths[r] = FIX2UINT(end) - slice->coords[r] + (excl ? 0 : 1);
+      if (end_ < 0)
+        slice->lengths[r] = shape[r] + end_ - slice->coords[r] + (excl ? 0 : 1);
+      else
+        slice->lengths[r] = end_ - slice->coords[r] + (excl ? 0 : 1);
 
       slice->single     = false;
-
       t++;
 
     } else {
@@ -2829,6 +2930,30 @@ static VALUE matrix_multiply(NMATRIX* left, NMATRIX* right) {
   return to_return;
 }
 
+
+/*
+ * Calculate the exact inverse of a 2x2 or 3x3 matrix.
+ *
+ * Does not test for invertibility!
+ */
+static VALUE nm_inverse_exact(VALUE self, VALUE inverse) {
+
+  if (NM_STYPE(self) != nm::DENSE_STORE) {
+    rb_raise(rb_eNotImpError, "needs exact determinant implementation for this matrix stype");
+    return Qnil;
+  }
+
+  if (NM_DIM(self) != 2 || NM_SHAPE0(self) != NM_SHAPE1(self)) {
+    rb_raise(nm_eShapeError, "matrices must be square to have an inverse defined");
+    return Qnil;
+  }
+
+  // Calculate the exact inverse.
+  nm_math_inverse_exact(NM_SHAPE0(self), NM_STORAGE_DENSE(self)->elements, NM_SHAPE0(self), NM_STORAGE_DENSE(inverse)->elements, NM_SHAPE0(inverse), NM_DTYPE(self));
+
+  return inverse;
+}
+
 /*
  * Calculate the exact determinant of a dense matrix.
  *
@@ -2839,9 +2964,11 @@ static VALUE matrix_multiply(NMATRIX* left, NMATRIX* right) {
 static VALUE nm_det_exact(VALUE self) {
 
   if (NM_STYPE(self) != nm::DENSE_STORE) {
-    rb_raise(nm_eStorageTypeError, "can only calculate exact determinant for dense matrices");
+    rb_raise(rb_eNotImpError, "can only calculate exact determinant for dense matrices");
+    return Qnil;
   }
   if (NM_DIM(self) != 2 || NM_SHAPE0(self) != NM_SHAPE1(self)) {
+    rb_raise(nm_eShapeError, "matrices must be square to have a determinant defined");
     return Qnil;
   }
 
@@ -2864,6 +2991,24 @@ static VALUE nm_det_exact(VALUE self) {
   return to_return;
 }
 
+
+
+/*
+ * Returns the pointer to the matrix storage's data. This is useful primarily when you are using FFI with NMatrix --
+ * say, for example, you want to pass a float* to some function, and your NMatrix is a :float32 :dense matrix. Then you
+ * can call this function and get that pointer directly instead of copying the data.
+ */
+static VALUE nm_data_pointer(VALUE self) {
+  //if (NM_DTYPE(self) == nm::LIST_STORE)
+  //  rb_warn("pointer requested for list storage, which may be meaningless");
+
+  // This is actually pretty easy, since all of the storage types have their elements positioned in the same place
+  // relative to one another. So yes, believe it or not, this should work just as well for Yale or list storage as for
+  // dense.
+  return INT2FIX(NM_STORAGE_DENSE(self)->elements);
+}
+
+
 /////////////////
 // Exposed API //
 /////////////////