nmatrix 0.1.0.rc2 → 0.1.0.rc3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4052431a5f81ea9304f96fe293f6f22a47dacf3d
-  data.tar.gz: 777b0fd050d7f0726ea97f337d5f4ce3cf850f8b
+  metadata.gz: 9bccc178bd2c4a0ee318f3a0808e7f3c52cfbc3f
+  data.tar.gz: eec9ec0890b8ab958c123452f98064883de0ea33
 SHA512:
-  metadata.gz: daabd9cebbe93674079728f254cf5429bb1d0cadfb2ddbb56061da9181508852bd919844baf7e63615237fe6f2fc864dd27515b97153ea7704185001417a2f27
-  data.tar.gz: b36dcd576afedd2ddc1fa57af569823fb72f98d0e11cd0e1d7ea751553e1b2de39fe32a197d0a731a308ec28a6e96aedcc0687b73853f88ab0002c6145e53e7b
+  metadata.gz: ab789cf265f5461e75e0425ce126c45e52ff627b69bfa0a5a94018260254708ec11c9e0e67a9f94e7dab0696fe1171c56d8043304b59848bfede52761e33924f
+  data.tar.gz: b8f8cfe0c81c7ce46306afcd9b5e469e84856aae990b6e42e52ca299234fe03801bd7f0c4ba585f14786909f1dbe88b10e5b12b3ef16c37935b8efa06e58b7ed

data/.travis.yml

@@ -7,6 +7,7 @@ rvm:
   - "1.9.3"
   - "2.0.0"
   - "2.1.0"
+  - "2.1.1"
 before_install:
   - sudo apt-get update -qq
   - sudo apt-get install -qq libatlas-base-dev

data/History.txt

@@ -583,3 +583,19 @@
   * NMatrix::random now raises an exception when rational matrices
     are requested
 
+=== 0.1.0.rc3 / 2014-03-27
+
+* No major enhancements.
+
+* 2 minor enhancements:
+
+  * Exposed NMatrix::LAPACK::geev for LAPACK's xGEEV
+
+  * Added out-of-place complex conjugate for dense and yale storage 
+    (by @rve)
+
+* 1 bug fixes:
+
+  * Fixed critical bug with transposing a matrix reference slice (by
+    @rajatkapoor)
+

data/README.rdoc

@@ -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.rc2.gem
+    gem install pkg/nmatrix-0.1.0.rc3.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

data/ext/nmatrix/ruby_nmatrix.c

@@ -154,6 +154,7 @@ 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_complex_conjugate(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);
@@ -260,6 +261,7 @@ void Init_nmatrix() {
 	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_method(cNMatrix, "complex_conjugate", (METHOD)nm_complex_conjugate, 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);
@@ -975,11 +977,10 @@ static VALUE nm_hermitian(VALUE self) {
 
 /*
  * call-seq:
- *     complex_conjugate -> NMatrix
+ *     complex_conjugate_bang -> NMatrix
  *
  * Transform the matrix (in-place) to its complex conjugate. Only works on complex matrices.
  *
- * FIXME: For non-complex matrices, someone needs to implement a non-in-place complex conjugate (which doesn't use a bang).
  * Bang should imply that no copy is being made, even temporarily.
  */
 static VALUE nm_complex_conjugate_bang(VALUE self) {
@@ -1017,13 +1018,22 @@ static VALUE nm_complex_conjugate_bang(VALUE self) {
       reinterpret_cast<nm::Complex128*>(elem)[p].i = -reinterpret_cast<nm::Complex128*>(elem)[p].i;
     }
 
-  } else {
-    rb_raise(nm_eDataTypeError, "can only calculate in-place complex conjugate on matrices of type :complex64 or :complex128");
-  }
-
+  } 
   return self;
 }
 
+/*
+ * call-seq:
+ *     complex_conjugate -> NMatrix
+ *
+ * Transform the matrix (non-in-place) to its complex conjugate. Only works on complex matrices.
+ *
+ */
+static VALUE nm_complex_conjugate(VALUE self) {
+  VALUE copy;
+  return nm_complex_conjugate_bang(nm_init_copy(copy,self));
+}
+
 
 /*
  * call-seq:

data/ext/nmatrix/storage/dense/dense.cpp

@@ -742,7 +742,6 @@ void nm_dense_storage_coords(const DENSE_STORAGE* s, const size_t slice_pos, siz
     coords_out[i] = (temp_pos - temp_pos % s->stride[i])/s->stride[i] - s->offset[i];
     temp_pos = temp_pos % s->stride[i];
   }
-
 }
 
 /*
@@ -834,16 +833,13 @@ STORAGE* nm_dense_storage_copy_transposed(const STORAGE* rhs_base) {
   DENSE_STORAGE* rhs = (DENSE_STORAGE*)rhs_base;
 
   nm_dense_storage_register(rhs);
-
   size_t *shape = NM_ALLOC_N(size_t, rhs->dim);
 
-  // swap shape and offset
+  // swap shape
   shape[0] = rhs->shape[1];
   shape[1] = rhs->shape[0];
 
   DENSE_STORAGE *lhs = nm_dense_storage_create(rhs->dtype, shape, rhs->dim, NULL, 0);
-  lhs->offset[0] = rhs->offset[1];
-  lhs->offset[1] = rhs->offset[0];
 
   nm_dense_storage_register(lhs);
 
@@ -916,8 +912,7 @@ void ref_slice_copy_transposed(const DENSE_STORAGE* rhs, DENSE_STORAGE* lhs) {
 
   LDType* lhs_els = reinterpret_cast<LDType*>(lhs->elements);
   RDType* rhs_els = reinterpret_cast<RDType*>(rhs->elements);
-
-  size_t count = nm_storage_count_max_elements(lhs);
+  size_t count = nm_storage_count_max_elements(lhs);;
   size_t* temp_coords = NM_ALLOCA_N(size_t, lhs->dim);
   size_t coord_swap_temp;
 

data/lib/nmatrix/lapack.rb

@@ -140,10 +140,11 @@ class NMatrix
         ]
       end
 
+
       #
       # call-seq:
-      #     gesvd -> [u, sigma, v_transpose]
-      #     gesvd -> [u, sigma, v_conjugate_transpose] # complex
+      #     gesvd(matrix) -> [u, sigma, v_transpose]
+      #     gesvd(matrix) -> [u, sigma, v_conjugate_transpose] # complex
       #
       # Compute the singular value decomposition of a matrix using LAPACK's GESVD function.
       #
@@ -158,8 +159,8 @@ class NMatrix
 
       #
       # call-seq:
-      #     gesdd -> [u, sigma, v_transpose]
-      #     gesdd -> [u, sigma, v_conjugate_transpose] # complex
+      #     gesdd(matrix) -> [u, sigma, v_transpose]
+      #     gesdd(matrix) -> [u, sigma, v_conjugate_transpose] # complex
       #
       # Compute the singular value decomposition of a matrix using LAPACK's GESDD function. This uses a divide-and-conquer
       # strategy. See also #gesvd.
@@ -173,6 +174,66 @@ class NMatrix
         result
       end
 
+      def alloc_evd_result(matrix)
+        [
+          NMatrix.new(matrix.shape[0], dtype: matrix.dtype),
+          NMatrix.new(matrix.shape[0], dtype: matrix.dtype),
+          NMatrix.new([matrix.shape[0],1], dtype: matrix.dtype),
+          NMatrix.new([matrix.shape[0],1], dtype: matrix.dtype),
+        ]
+      end
+
+
+      #
+      # call-seq:
+      #     geev(matrix) -> [eigenvalues, left_eigenvectors, right_eigenvectors]
+      #     geev(matrix, :left) -> [eigenvalues, left_eigenvectors]
+      #     geev(matrix, :right) -> [eigenvalues, right_eigenvectors]
+      #
+      # Perform eigenvalue decomposition on a matrix using LAPACK's xGEEV function.
+      #
+      def geev(matrix, which=:both)
+        result = alloc_evd_result(matrix)
+        jobvl = (which == :both || which == :left) ? :left : false
+        jobvr = (which == :both || which == :right) ? :right : false
+
+        # Copy the matrix so it doesn't get overwritten.
+        temporary_matrix = matrix.clone
+
+        # Outputs
+        real_eigenvalues = NMatrix.new([matrix.shape[0], 1], dtype: matrix.dtype)
+        imag_eigenvalues = NMatrix.new([matrix.shape[0], 1], dtype: matrix.dtype)
+
+        left_output      = jobvl == :left ? matrix.clone_structure : NMatrix.new(1, dtype: matrix.dtype)
+        right_output     = jobvr == :right ? matrix.clone_structure : NMatrix.new(1, dtype: matrix.dtype)
+
+        NMatrix::LAPACK::lapack_geev(jobvl, # compute left eigenvectors of A?
+                                     jobvr, # compute right eigenvectors of A? (left eigenvectors of A**T)
+                                     matrix.shape[0], # order of the matrix
+                                     temporary_matrix,# input matrix (used as work)
+                                     matrix.shape[0], # leading dimension of matrix
+                                     real_eigenvalues,# real part of computed eigenvalues
+                                     imag_eigenvalues,# imag part of computed eigenvalues
+                                     left_output,     # left eigenvectors, if applicable
+                                     left_output.shape[0], # leading dimension of left_output
+                                     right_output,    # right eigenvectors, if applicable
+                                     right_output.shape[0], # leading dimension of right_output
+                                     2*matrix.shape[0])
+
+        # Put the real and imaginary parts together
+        eigenvalues = real_eigenvalues.to_a.flatten.map.with_index do |real,i|
+          imag_eigenvalues[i] != 0 ? Complex(real, imag_eigenvalues[i]) : real
+        end
+
+        if which == :both
+          return [eigenvalues, left_output.transpose, right_output.transpose]
+        elsif which == :left
+          return [eigenvalues, left_output.transpose]
+        else
+          return [eigenvalues, right_output]
+        end
+      end
+
     end
   end
 end

data/lib/nmatrix/version.rb

@@ -31,7 +31,7 @@ class NMatrix
     MAJOR = 0
     MINOR = 1
     TINY = 0
-    PRE = "rc2"
+    PRE = "rc3"
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
   end

data/spec/00_nmatrix_spec.rb

@@ -291,12 +291,6 @@ describe NMatrix do
     expect(lambda { NMatrix.new(3,dtype: :int8)[1,1] }).to_not raise_error
   end
 
-  it "calculates the complex conjugate in-place" do
-    n = NMatrix.new(:dense, 3, [1,2,3,4,5,6,7,8,9], :complex128)
-    n.complex_conjugate!
-    # FIXME: Actually test that values are correct.
-  end
-
   it "converts from list to yale properly" do
     m = NMatrix.new(3, 0, stype: :list)
     m[0,2] = 333
@@ -519,4 +513,46 @@ describe 'NMatrix' do
       expect(n[0,0..-2]).to eq(NMatrix.new([1,4],[1,2,3,4]))
     end
   end
+
+  context "#complex_conjugate!" do
+    [:dense, :yale, :list].each do |stype|
+      context(stype) do
+        it "should work in-place for complex dtypes" do
+          pending("not yet implemented for list stype") if stype == :list
+          n = NMatrix.new([2,3], [Complex(2,3)], stype: stype, dtype: :complex128)
+          n.complex_conjugate!
+          expect(n).to eq(NMatrix.new([2,3], [Complex(2,-3)], stype: stype, dtype: :complex128))
+        end
+
+        [:object, :int64].each do |dtype|
+          it "should work in-place for non-complex dtypes" do
+            pending("not yet implemented for list stype") if stype == :list
+            n = NMatrix.new([2,3], 1, stype: stype, dtype: dtype)
+            n.complex_conjugate!
+            expect(n).to eq(NMatrix.new([2,3], [1], stype: stype, dtype: dtype))
+          end
+        end
+      end
+    end
+  end
+
+  context "#complex_conjugate" do
+    [:dense, :yale, :list].each do |stype|
+      context(stype) do
+        it "should work out-of-place for complex dtypes" do
+          pending("not yet implemented for list stype") if stype == :list
+          n = NMatrix.new([2,3], [Complex(2,3)], stype: stype, dtype: :complex128)
+          expect(n.complex_conjugate).to eq(NMatrix.new([2,3], [Complex(2,-3)], stype: stype, dtype: :complex128))
+        end
+
+        [:object, :int64].each do |dtype|
+          it "should work out-of-place for non-complex dtypes" do
+            pending("not yet implemented for list stype") if stype == :list
+            n = NMatrix.new([2,3], 1, stype: stype, dtype: dtype)
+            expect(n.complex_conjugate).to eq(NMatrix.new([2,3], [1], stype: stype, dtype: dtype))
+          end
+        end
+      end
+    end
+  end
 end

data/spec/02_slice_spec.rb

@@ -314,6 +314,12 @@ describe "Slice operation" do
 
             it "correctly transposes slices" do
               expect(@m[0...3,0].transpose).to eq NMatrix[[0, 3, 6]]
+              expect(@m[0...3,1].transpose).to eq NMatrix[[1, 4, 7]]
+              expect(@m[0...3,2].transpose).to eq NMatrix[[2, 5, 8]]
+              expect(@m[0,0...3].transpose).to eq NMatrix[[0], [1], [2]]
+              expect(@m[1,0...3].transpose).to eq NMatrix[[3], [4], [5]]
+              expect(@m[2,0...3].transpose).to eq NMatrix[[6], [7], [8]]
+              expect(@m[1..2,1..2].transpose).to eq NMatrix[[4, 7], [5, 8]]
             end
 
             it "adds slices" do

data/spec/shortcuts_spec.rb

@@ -89,7 +89,7 @@ describe NMatrix do
     it "correctly accepts :scale parameter" do
       m = NMatrix.random([2,2], dtype: :byte, scale: 255)
       m.each do |v|
-        expect(v).to be > 0
+        expect(v).to be >= 0
         expect(v).to be < 255
       end
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: nmatrix
 version: !ruby/object:Gem::Version
-  version: 0.1.0.rc2
+  version: 0.1.0.rc3
 platform: ruby
 authors:
 - John Woods
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-12 00:00:00.000000000 Z
+date: 2014-03-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rdoc