nmatrix-lapacke 0.2.1 → 0.2.3

data/ext/nmatrix_lapacke/math_lapacke/lapacke_templates.h

@@ -64,6 +64,82 @@ inline int lapacke_getrf(const enum CBLAS_ORDER order, const int m, const int n,
   return getrf<DType>(order, m, n, static_cast<DType*>(a), lda, ipiv);
 }
 
+//geqrf
+template <typename DType>
+inline int geqrf(const enum CBLAS_ORDER order, const int m, const int n, DType* a, const int lda, DType* tau) {
+  rb_raise(rb_eNotImpError, "lapacke_geqrf not implemented for non_BLAS dtypes.");
+  return 0;
+}
+
+template <>
+inline int geqrf(const enum CBLAS_ORDER order, const int m, const int n, float* a, const int lda, float* tau) {
+  return LAPACKE_sgeqrf(order, m, n, a, lda, tau);
+}
+
+template < > 
+inline int geqrf(const enum CBLAS_ORDER order, const int m, const int n, double* a, const int lda, double* tau) {
+  return LAPACKE_dgeqrf(order, m, n, a, lda, tau);
+}
+
+template <>
+inline int geqrf(const enum CBLAS_ORDER order, const int m, const int n, Complex64* a, const int lda, Complex64* tau) {
+  return LAPACKE_cgeqrf(order, m, n, a, lda, tau);
+}
+
+template <>
+inline int geqrf(const enum CBLAS_ORDER order, const int m, const int n, Complex128* a, const int lda, Complex128* tau) {
+  return LAPACKE_zgeqrf(order, m, n, a, lda, tau);
+}
+
+template <typename DType>
+inline int lapacke_geqrf(const enum CBLAS_ORDER order, const int m, const int n, void* a, const int lda, void* tau) {
+  return geqrf<DType>(order, m, n, static_cast<DType*>(a), lda, static_cast<DType*>(tau));
+}
+
+//ormqr
+template <typename DType>
+inline int ormqr(const enum CBLAS_ORDER order, char side, char trans, const int m, const int n, const int k, DType* a, const int lda, DType* tau, DType* c, const int ldc) {
+  rb_raise(rb_eNotImpError, "lapacke_ormqr not implemented for non_BLAS dtypes.");
+  return 0;
+}
+
+template <>
+inline int ormqr(const enum CBLAS_ORDER order, char side, char trans, const int m, const int n, const int k, float* a, const int lda, float* tau, float* c, const int ldc) {
+  return LAPACKE_sormqr(order, side, trans, m, n, k, a, lda, tau, c, ldc);
+}
+
+template <> 
+inline int ormqr(const enum CBLAS_ORDER order, char side, char trans, const int m, const int n, const int k, double* a, const int lda, double* tau, double* c, const int ldc) {
+  return LAPACKE_dormqr(order, side, trans, m, n, k, a, lda, tau, c, ldc);
+}
+
+template <typename DType>
+inline int lapacke_ormqr(const enum CBLAS_ORDER order, char side, char trans, const int m, const int n, const int k, void* a, const int lda, void* tau, void* c, const int ldc) {
+  return ormqr<DType>(order, side, trans, m, n, k, static_cast<DType*>(a), lda, static_cast<DType*>(tau), static_cast<DType*>(c), ldc);
+}
+
+//unmqr
+template <typename DType>
+inline int unmqr(const enum CBLAS_ORDER order, char side, char trans, const int m, const int n, const int k, DType* a, const int lda, DType* tau, DType* c, const int ldc) {
+  rb_raise(rb_eNotImpError, "lapacke_unmqr not implemented for non complex dtypes.");
+  return 0;
+}
+
+template <>
+inline int unmqr(const enum CBLAS_ORDER order, char side, char trans, const int m, const int n, const int k, Complex64* a, const int lda, Complex64* tau, Complex64* c, const int ldc) {
+  return LAPACKE_cunmqr(order, side, trans, m, n, k, a, lda, tau, c, ldc);
+}
+
+template <> 
+inline int unmqr(const enum CBLAS_ORDER order, char side, char trans, const int m, const int n, const int k, Complex128* a, const int lda, Complex128* tau, Complex128* c, const int ldc) {
+  return LAPACKE_zunmqr(order, side, trans, m, n, k, a, lda, tau, c, ldc);
+}
+
+template <typename DType>
+inline int lapacke_unmqr(const enum CBLAS_ORDER order, char side, char trans, const int m, const int n, const int k, void* a, const int lda, void* tau, void* c, const int ldc) {
+  return unmqr<DType>(order, side, trans, m, n, k, static_cast<DType*>(a), lda, static_cast<DType*>(tau), static_cast<DType*>(c), ldc);
+}
+
 //getri
 template <typename DType>
 inline int getri(const enum CBLAS_ORDER order, const int n, DType* a, const int lda, const int* ipiv) {

data/lib/nmatrix/lapacke.rb

@@ -232,4 +232,122 @@ class NMatrix
       raise(ArgumentError, "#{opts[:form]} is not a valid form option")
     end
   end
+
+  #
+  # call-seq:
+  #     geqrf! -> shape.min x 1 NMatrix 
+  #
+  # QR factorization of a general M-by-N matrix +A+. 
+  #
+  # The QR factorization is A = QR, where Q is orthogonal and R is Upper Triangular
+  # +A+ is overwritten with the elements of R and Q with Q being represented by the 
+  # elements below A's diagonal and an array of scalar factors in the output NMatrix. 
+  #
+  # The matrix Q is represented as a product of elementary reflectors
+  #     Q = H(1) H(2) . . . H(k), where k = min(m,n).
+  #
+  # Each H(i) has the form
+  #
+  #     H(i) = I - tau * v * v'
+  #
+  # http://www.netlib.org/lapack/explore-html/d3/d69/dgeqrf_8f.html
+  # 
+  # Only works for dense matrices.
+  #
+  # * *Returns* :
+  #   - Vector TAU. Q and R are stored in A. Q is represented by TAU and A
+  # * *Raises* :
+  #   - +StorageTypeError+ -> LAPACK functions only work on dense matrices.
+  #
+  def geqrf!
+    raise(StorageTypeError, "LAPACK functions only work on dense matrices") unless self.dense?
+    
+    tau = NMatrix.new([self.shape.min,1], dtype: self.dtype)
+    NMatrix::LAPACK::lapacke_geqrf(:row, self.shape[0], self.shape[1], self, self.shape[1], tau)
+    
+    tau
+  end
+  
+  #
+  # call-seq:
+  #     ormqr(tau) -> NMatrix
+  #     ormqr(tau, side, transpose, c) -> NMatrix
+  #
+  # Returns the product Q * c or c * Q after a call to geqrf! used in QR factorization. 
+  # +c+ is overwritten with the elements of the result NMatrix if supplied. Q is the orthogonal matrix 
+  # represented by tau and the calling NMatrix
+  # 
+  # Only works on float types, use unmqr for complex types.
+  #
+  # == Arguments
+  #
+  # * +tau+ - vector containing scalar factors of elementary reflectors
+  # * +side+ - direction of multiplication [:left, :right]
+  # * +transpose+ - apply Q with or without transpose [false, :transpose] 
+  # * +c+ - NMatrix multplication argument that is overwritten, no argument assumes c = identity
+  #
+  # * *Returns* :
+  #
+  #   - Q * c or c * Q Where Q may be transposed before multiplication. 
+  #    
+  #
+  # * *Raises* :
+  #   - +StorageTypeError+ -> LAPACK functions only work on dense matrices.
+  #   - +TypeError+ -> Works only on floating point matrices, use unmqr for complex types
+  #   - +TypeError+ -> c must have the same dtype as the calling NMatrix
+  #
+  def ormqr(tau, side=:left, transpose=false, c=nil)
+    raise(StorageTypeError, "LAPACK functions only work on dense matrices") unless self.dense?
+    raise(TypeError, "Works only on floating point matrices, use unmqr for complex types") if self.complex_dtype?
+    raise(TypeError, "c must have the same dtype as the calling NMatrix") if c and c.dtype != self.dtype
+
+
+    #Default behaviour produces Q * I  = Q if c is not supplied.
+    result = c ? c : NMatrix.identity(self.shape[0], dtype: self.dtype)
+    NMatrix::LAPACK::lapacke_ormqr(:row, side, transpose, result.shape[0], result.shape[1], tau.shape[0], self, self.shape[1], tau, result, result.shape[1])
+    
+    result
+  end
+
+  #
+  # call-seq:
+  #     unmqr(tau) -> NMatrix
+  #     unmqr(tau, side, transpose, c) -> NMatrix
+  #
+  # Returns the product Q * c or c * Q after a call to geqrf! used in QR factorization. 
+  # +c+ is overwritten with the elements of the result NMatrix if it is supplied. Q is the orthogonal matrix 
+  # represented by tau and the calling NMatrix
+  # 
+  # Only works on complex types, use ormqr for float types.
+  #
+  # == Arguments
+  #
+  # * +tau+ - vector containing scalar factors of elementary reflectors
+  # * +side+ - direction of multiplication [:left, :right]
+  # * +transpose+ - apply Q as Q or its complex conjugate [false, :complex_conjugate] 
+  # * +c+ - NMatrix multplication argument that is overwritten, no argument assumes c = identity
+  #
+  # * *Returns* :
+  #
+  #   - Q * c or c * Q Where Q may be transformed to its complex conjugate before multiplication. 
+  #    
+  #
+  # * *Raises* :
+  #   - +StorageTypeError+ -> LAPACK functions only work on dense matrices.
+  #   - +TypeError+ -> Works only on floating point matrices, use unmqr for complex types
+  #   - +TypeError+ -> c must have the same dtype as the calling NMatrix
+  #
+  def unmqr(tau, side=:left, transpose=false, c=nil)
+    raise(StorageTypeError, "ATLAS functions only work on dense matrices") unless self.dense?
+    raise(TypeError, "Works only on complex matrices, use ormqr for normal floating point matrices") unless self.complex_dtype?
+    raise(TypeError, "c must have the same dtype as the calling NMatrix") if c and c.dtype != self.dtype
+
+    #Default behaviour produces Q * I  = Q if c is not supplied.
+    result = c ? c : NMatrix.identity(self.shape[0], dtype: self.dtype)
+    NMatrix::LAPACK::lapacke_unmqr(:row, side, transpose, result.shape[0], result.shape[1], tau.shape[0], self, self.shape[1], tau, result, result.shape[1])
+    
+    result
+  end
+
+
 end

data/spec/00_nmatrix_spec.rb

@@ -424,6 +424,13 @@ describe 'NMatrix' do
       expect(n.reshape!([8,2]).eql?(n)).to eq(true) # because n itself changes
     end
 
+    it "should do the reshape operation in place, changing dimension" do
+      n = NMatrix.seq(4)
+      a = n.reshape!([4,2,2])
+      expect(n).to eq(NMatrix.seq([4,2,2]))
+      expect(a).to eq(NMatrix.seq([4,2,2]))
+    end
+
     it "reshape and reshape! must produce same result" do
       n = NMatrix.seq(4)+1
       a = NMatrix.seq(4)+1
@@ -432,7 +439,7 @@ describe 'NMatrix' do
 
     it "should prevent a resize in place" do
       n = NMatrix.seq(4)+1
-      expect { n.reshape([5,2]) }.to raise_error(ArgumentError)
+      expect { n.reshape!([5,2]) }.to raise_error(ArgumentError)
     end
   end
 
@@ -534,6 +541,26 @@ describe 'NMatrix' do
       n = NMatrix.new([1,3,1], [1,2,3])
       expect(n.dconcat(n)).to eq(NMatrix.new([1,3,2], [1,1,2,2,3,3]))
     end
+
+    it "should work on matrices with different size along concat dim" do
+      n = N[[1, 2, 3],
+            [4, 5, 6]]
+      m = N[[7],
+            [8]]
+
+      expect(n.hconcat(m)).to eq N[[1, 2, 3, 7], [4, 5, 6, 8]]
+      expect(m.hconcat(n)).to eq N[[7, 1, 2, 3], [8, 4, 5, 6]]
+    end
+
+    it "should work on matrices with different size along concat dim" do
+      n = N[[1, 2, 3],
+            [4, 5, 6]]
+
+      m = N[[7, 8, 9]]
+
+      expect(n.vconcat(m)).to eq N[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
+      expect(m.vconcat(n)).to eq N[[7, 8, 9], [1, 2, 3], [4, 5, 6]]
+    end
   end
 
   context "#[]" do
@@ -631,6 +658,23 @@ describe 'NMatrix' do
     end
   end
 
+  context "#last" do
+    it "returns the last element of a 1-dimensional NMatrix" do
+      n = NMatrix.new([1,4], [1,2,3,4])
+      expect(n.last).to eq(4)
+    end
+
+    it "returns the last element of a 2-dimensional NMatrix" do
+      n = NMatrix.new([2,2], [4,8,12,16])
+      expect(n.last).to eq(16)
+    end
+
+    it "returns the last element of a 3-dimensional NMatrix" do
+      n = NMatrix.new([2,2,2], [1,2,3,4,5,6,7,8])
+      expect(n.last).to eq(8)
+    end
+  end
+
   context "#diagonal" do
     ALL_DTYPES.each do |dtype|
       before do 
@@ -682,6 +726,11 @@ describe 'NMatrix' do
       expect(@sample_matrix.repeat(2, 0)).to eq(NMatrix.new([4, 2], [1, 2, 3, 4, 1, 2, 3, 4]))
       expect(@sample_matrix.repeat(2, 1)).to eq(NMatrix.new([2, 4], [1, 2, 1, 2, 3, 4, 3, 4]))
     end
+
+    it "preserves dtype" do
+      expect(@sample_matrix.repeat(2, 0).dtype).to eq(@sample_matrix.dtype)
+      expect(@sample_matrix.repeat(2, 1).dtype).to eq(@sample_matrix.dtype)
+    end
   end
 
   context "#meshgrid" do

data/spec/02_slice_spec.rb

@@ -127,9 +127,9 @@ describe "Slice operation" do
       it "should have #is_ref? method" do
         a = stype_matrix[0..1, 0..1]
         b = stype_matrix.slice(0..1, 0..1)
-        expect(stype_matrix.is_ref?).to be_false
-        expect(a.is_ref?).to be_true
-        expect(b.is_ref?).to be_false
+        expect(stype_matrix.is_ref?).to be false
+        expect(a.is_ref?).to be true
+        expect(b.is_ref?).to be false
       end
 
       it "reference should compare with non-reference" do
@@ -141,7 +141,7 @@ describe "Slice operation" do
       context "with copying" do
         it 'should return an NMatrix' do
           n = stype_matrix.slice(0..1,0..1)
-          expect(nm_eql(n, NMatrix.new([2,2], [0,1,3,4], dtype: :int32))).to be_true
+          expect(nm_eql(n, NMatrix.new([2,2], [0,1,3,4], dtype: :int32))).to be true
         end
 
         it 'should return a copy of 2x2 matrix to self elements' do
@@ -183,19 +183,19 @@ describe "Slice operation" do
 
         [:dense, :list, :yale].each do |cast_type|
           it "should cast copied slice from #{stype.upcase} to #{cast_type.upcase}" do
-            expect(nm_eql(stype_matrix.slice(1..2, 1..2).cast(cast_type, :int32), stype_matrix.slice(1..2,1..2))).to be_true
-            expect(nm_eql(stype_matrix.slice(0..1, 1..2).cast(cast_type, :int32), stype_matrix.slice(0..1,1..2))).to be_true
-            expect(nm_eql(stype_matrix.slice(1..2, 0..1).cast(cast_type, :int32), stype_matrix.slice(1..2,0..1))).to be_true
-            expect(nm_eql(stype_matrix.slice(0..1, 0..1).cast(cast_type, :int32), stype_matrix.slice(0..1,0..1))).to be_true
+            expect(nm_eql(stype_matrix.slice(1..2, 1..2).cast(cast_type, :int32), stype_matrix.slice(1..2,1..2))).to be true
+            expect(nm_eql(stype_matrix.slice(0..1, 1..2).cast(cast_type, :int32), stype_matrix.slice(0..1,1..2))).to be true
+            expect(nm_eql(stype_matrix.slice(1..2, 0..1).cast(cast_type, :int32), stype_matrix.slice(1..2,0..1))).to be true
+            expect(nm_eql(stype_matrix.slice(0..1, 0..1).cast(cast_type, :int32), stype_matrix.slice(0..1,0..1))).to be true
 
             # Non square
-            expect(nm_eql(stype_matrix.slice(0..2, 1..2).cast(cast_type, :int32), stype_matrix.slice(0..2,1..2))).to be_true
+            expect(nm_eql(stype_matrix.slice(0..2, 1..2).cast(cast_type, :int32), stype_matrix.slice(0..2,1..2))).to be true
             #require 'pry'
             #binding.pry if cast_type == :yale
-            expect(nm_eql(stype_matrix.slice(1..2, 0..2).cast(cast_type, :int32), stype_matrix.slice(1..2,0..2))).to be_true
+            expect(nm_eql(stype_matrix.slice(1..2, 0..2).cast(cast_type, :int32), stype_matrix.slice(1..2,0..2))).to be true
 
             # Full
-            expect(nm_eql(stype_matrix.slice(0..2, 0..2).cast(cast_type, :int32), stype_matrix)).to be_true
+            expect(nm_eql(stype_matrix.slice(0..2, 0..2).cast(cast_type, :int32), stype_matrix)).to be true
           end
         end
       end
@@ -214,7 +214,7 @@ describe "Slice operation" do
       context "by reference" do
         it 'should return an NMatrix' do
           n = stype_matrix[0..1,0..1]
-          expect(nm_eql(n, NMatrix.new([2,2], [0,1,3,4], dtype: :int32))).to be_true
+          expect(nm_eql(n, NMatrix.new([2,2], [0,1,3,4], dtype: :int32))).to be true
         end
 
         it 'should return a 2x2 matrix with refs to self elements' do
@@ -246,7 +246,7 @@ describe "Slice operation" do
 
         it 'should slice again' do
           n = stype_matrix[1..2, 1..2]
-          expect(nm_eql(n[1,0..1], NVector.new(2, [7,8], dtype: :int32).transpose)).to be_true
+          expect(nm_eql(n[1,0..1], NVector.new(2, [7,8], dtype: :int32).transpose)).to be true
         end
 
         it 'should be correct slice for range 0..2 and 0...3' do
@@ -320,7 +320,7 @@ describe "Slice operation" do
             end
 
             it "compares slices to scalars" do
-              (stype_matrix[1, 0..2] > 2).each { |e| expect(e != 0).to be_true }
+              (stype_matrix[1, 0..2] > 2).each { |e| expect(e != 0).to be true }
             end
 
             it "iterates only over elements in the slice" do
@@ -367,20 +367,20 @@ describe "Slice operation" do
 
         [:dense, :list, :yale].each do |cast_type|
           it "should cast a square reference-slice from #{stype.upcase} to #{cast_type.upcase}" do
-            expect(nm_eql(stype_matrix[1..2, 1..2].cast(cast_type), stype_matrix[1..2,1..2])).to be_true
-            expect(nm_eql(stype_matrix[0..1, 1..2].cast(cast_type), stype_matrix[0..1,1..2])).to be_true
-            expect(nm_eql(stype_matrix[1..2, 0..1].cast(cast_type), stype_matrix[1..2,0..1])).to be_true
-            expect(nm_eql(stype_matrix[0..1, 0..1].cast(cast_type), stype_matrix[0..1,0..1])).to be_true
+            expect(nm_eql(stype_matrix[1..2, 1..2].cast(cast_type), stype_matrix[1..2,1..2])).to be true
+            expect(nm_eql(stype_matrix[0..1, 1..2].cast(cast_type), stype_matrix[0..1,1..2])).to be true
+            expect(nm_eql(stype_matrix[1..2, 0..1].cast(cast_type), stype_matrix[1..2,0..1])).to be true
+            expect(nm_eql(stype_matrix[0..1, 0..1].cast(cast_type), stype_matrix[0..1,0..1])).to be true
           end
 
           it "should cast a rectangular reference-slice from #{stype.upcase} to #{cast_type.upcase}" do
             # Non square
-            expect(nm_eql(stype_matrix[0..2, 1..2].cast(cast_type), stype_matrix[0..2,1..2])).to be_true # FIXME: memory problem.
-            expect(nm_eql(stype_matrix[1..2, 0..2].cast(cast_type), stype_matrix[1..2,0..2])).to be_true # this one is fine
+            expect(nm_eql(stype_matrix[0..2, 1..2].cast(cast_type), stype_matrix[0..2,1..2])).to be true # FIXME: memory problem.
+            expect(nm_eql(stype_matrix[1..2, 0..2].cast(cast_type), stype_matrix[1..2,0..2])).to be true # this one is fine
           end
 
           it "should cast a square full-matrix reference-slice from #{stype.upcase} to #{cast_type.upcase}" do
-            expect(nm_eql(stype_matrix[0..2, 0..2].cast(cast_type), stype_matrix)).to be_true
+            expect(nm_eql(stype_matrix[0..2, 0..2].cast(cast_type), stype_matrix)).to be true
           end
         end
       end

data/spec/blas_spec.rb

@@ -69,6 +69,18 @@ describe NMatrix::BLAS do
         expect(b[0]).to eq(-15.0/2)
         expect(b[1]).to eq(5)
         expect(b[2]).to eq(-13)
+        
+        NMatrix::BLAS::cblas_trsm(:row, :left, :lower, :transpose, :nounit, 3, 1, 1.0, a, 3, b, 1)
+
+        expect(b[0]).to eq(307.0/8)
+        expect(b[1]).to eq(57.0/2)
+        expect(b[2]).to eq(26.0)
+        
+        NMatrix::BLAS::cblas_trsm(:row, :left, :upper, :transpose, :unit, 3, 1, 1.0, a, 3, b, 1)
+
+        expect(b[0]).to eq(307.0/8)
+        expect(b[1]).to eq(763.0/16)
+        expect(b[2]).to eq(4269.0/64)        
       end
 
       # trmm multiplies two matrices, where one of the two is required to be
@@ -174,9 +186,17 @@ describe NMatrix::BLAS do
 
       it "exposes nrm2" do
         pending("broken for :object") if dtype == :object
-        pending("Temporarily disable because the internal implementation of nrm2 is broken -WL 2015-05-17") if dtype == :complex64 || dtype == :complex128
 
-        x = NMatrix.new([4,1], [2,-4,3,5], dtype: dtype)
+        if dtype =~ /complex/
+          x = NMatrix.new([3,1], [Complex(1,2),Complex(3,4),Complex(0,6)], dtype: dtype)
+          y = NMatrix.new([3,1], [Complex(0,0),Complex(0,0),Complex(0,0)], dtype: dtype)
+          nrm2 = 8.12403840463596
+        else
+          x = NMatrix.new([4,1], [2,-4,3,5], dtype: dtype)
+          y = NMatrix.new([3,1], [0,0,0], dtype: dtype)
+          nrm2 = 5.385164807134504
+        end
+        
         err = case dtype
                 when :float32, :complex64
                   1e-6
@@ -185,7 +205,9 @@ describe NMatrix::BLAS do
                 else
                   1e-14
               end
-        expect(NMatrix::BLAS.nrm2(x, 1, 3)).to be_within(err).of(5.385164807134504)
+
+        expect(NMatrix::BLAS.nrm2(x, 1, 3)).to be_within(err).of(nrm2)
+        expect(NMatrix::BLAS.nrm2(y, 1, 3)).to be_within(err).of(0)
       end
 
     end

data/spec/math_spec.rb

@@ -285,6 +285,152 @@ describe "math" do
     end
   end
 
+  NON_INTEGER_DTYPES.each do |dtype|
+    next if dtype == :object
+    context dtype do
+      
+      it "calculates QR decomposition using factorize_qr for a square matrix" do
+
+        a = NMatrix.new(3, [12.0, -51.0,   4.0, 
+                             6.0, 167.0, -68.0, 
+                            -4.0,  24.0, -41.0] , dtype: dtype)
+        
+        q_solution = NMatrix.new([3,3], Q_SOLUTION_ARRAY_2, dtype: dtype)
+
+        r_solution = NMatrix.new([3,3], [-14.0, -21.0, 14, 
+                                           0.0,  -175, 70, 
+                                           0.0, 0.0,  -35] , dtype: dtype)
+
+        err = case dtype
+                when :float32, :complex64
+                  1e-4
+                when :float64, :complex128
+                  1e-13
+              end
+        
+        begin
+          q,r = a.factorize_qr
+          
+          expect(q).to be_within(err).of(q_solution)
+          expect(r).to be_within(err).of(r_solution)
+        
+        rescue NotImplementedError
+          pending "Suppressing a NotImplementedError when the lapacke plugin is not available"
+        end
+      end
+
+      it "calculates QR decomposition using factorize_qr for a tall and narrow rectangular matrix" do
+
+        a = NMatrix.new([4,2], [34.0, 21.0, 
+                                23.0, 53.0, 
+                                26.0, 346.0, 
+                                23.0, 121.0] , dtype: dtype)
+        
+        q_solution = NMatrix.new([4,4], Q_SOLUTION_ARRAY_1, dtype: dtype)
+
+        r_solution = NMatrix.new([4,2], [-53.75872022286244, -255.06559574252242, 
+                                                        0.0,  269.34836526051555, 
+                                                        0.0,                 0.0, 
+                                                        0.0,                 0.0] , dtype: dtype)
+
+        err = case dtype
+                when :float32, :complex64
+                  1e-4
+                when :float64, :complex128
+                  1e-13
+              end
+        
+        begin
+          q,r = a.factorize_qr
+          
+          expect(q).to be_within(err).of(q_solution)
+          expect(r).to be_within(err).of(r_solution)
+        
+        rescue NotImplementedError
+          pending "Suppressing a NotImplementedError when the lapacke plugin is not available"
+        end
+      end
+
+      it "calculates QR decomposition using factorize_qr for a short and wide rectangular matrix" do
+          
+        a = NMatrix.new([3,4], [123,31,57,81,92,14,17,36,42,34,11,28], dtype: dtype)
+        
+        q_solution = NMatrix.new([3,3], Q_SOLUTION_ARRAY_3, dtype: dtype)
+
+        r_solution = NMatrix.new([3,4], R_SOLUTION_ARRAY, dtype: dtype)
+
+        err = case dtype
+                when :float32, :complex64
+                  1e-4
+                when :float64, :complex128
+                  1e-13
+              end
+        
+        begin
+          q,r = a.factorize_qr
+          
+          expect(q).to be_within(err).of(q_solution)
+          expect(r).to be_within(err).of(r_solution)
+        
+        rescue NotImplementedError
+          pending "Suppressing a NotImplementedError when the lapacke plugin is not available"
+        end
+      end
+      
+      it "calculates QR decomposition such that A - QR ~ 0" do
+
+        a = NMatrix.new([3,3], [ 9.0,  0.0, 26.0, 
+                                12.0,  0.0, -7.0,  
+                                 0.0,  4.0,  0.0] , dtype: dtype)
+        
+        err = case dtype
+                when :float32, :complex64
+                  1e-4
+                when :float64, :complex128
+                  1e-13
+              end
+        
+        begin
+          q,r = a.factorize_qr
+          a_expected = q.dot(r)  
+          
+          expect(a_expected).to be_within(err).of(a)
+               
+        rescue NotImplementedError
+          pending "Suppressing a NotImplementedError when the lapacke plugin is not available"
+        end
+      end
+
+
+      it "calculates the orthogonal matrix Q in QR decomposition" do
+
+        a = N.new([2,2], [34.0, 21, 23, 53] , dtype: dtype)
+
+        err = case dtype
+                when :float32, :complex64
+                  1e-4
+                when :float64, :complex128
+                  1e-13
+              end
+        
+        begin
+          q,r = a.factorize_qr
+          
+          #Q is orthogonal if Q x Q.transpose = I
+          product = q.dot(q.transpose)
+
+          expect(product[0,0]).to be_within(err).of(1)
+          expect(product[1,0]).to be_within(err).of(0)
+          expect(product[0,1]).to be_within(err).of(0)
+          expect(product[1,1]).to be_within(err).of(1)
+
+        rescue NotImplementedError
+          pending "Suppressing a NotImplementedError when the lapacke plugin is not available"
+        end
+      end
+    end
+  end
+
   ALL_DTYPES.each do |dtype|
     next if dtype == :byte #doesn't work for unsigned types
     next if dtype == :object
@@ -332,6 +478,49 @@ describe "math" do
     end
   end
 
+  ALL_DTYPES.each do |dtype|
+    next if dtype == :byte #doesn't work for unsigned types
+    next if dtype == :object
+
+    context dtype do
+      err = case dtype
+              when :float32, :complex64
+                1e-4
+              else #integer matrices will return :float64
+                1e-13
+            end
+
+      it "should correctly find adjugate a matrix in place (bang)" do
+        a = NMatrix.new(:dense, 2, [2, 3, 3, 5], dtype)
+        b = NMatrix.new(:dense, 2, [5, -3, -3, 2], dtype)
+
+        if a.integer_dtype?
+          expect{a.adjugate!}.to raise_error(DataTypeError)
+        else
+          #should return adjugate as well as modifying a
+          r = a.adjugate!
+          expect(a).to be_within(err).of(b)
+          expect(r).to be_within(err).of(b)
+        end
+      end
+
+
+      it "should correctly find adjugate of a matrix out-of-place" do
+        a = NMatrix.new(:dense, 3, [-3, 2, -5, -1, 0, -2, 3, -4, 1], dtype)
+
+        if a.integer_dtype?
+          b = NMatrix.new(:dense, 3, [-8, 18, -4, -5, 12, -1, 4, -6, 2], :float64)
+        else
+          b = NMatrix.new(:dense, 3, [-8, 18, -4, -5, 12, -1, 4, -6, 2], dtype)
+        end
+
+        expect(a.adjoint).to be_within(err).of(b)
+        expect(a.adjugate).to be_within(err).of(b)
+      end
+
+    end
+  end
+
   # TODO: Get it working with ROBJ too
   [:byte,:int8,:int16,:int32,:int64,:float32,:float64].each do |left_dtype|
     [:byte,:int8,:int16,:int32,:int64,:float32,:float64].each do |right_dtype|
@@ -702,7 +891,7 @@ describe "math" do
                                                      360, 96, 51, -14,
                                                      448,-231,-24,-87,
                                                    -1168, 595,234, 523], 
-                                                   dtype: answer_dtype, 
+                                                   dtype: answer_dtype,
                                                    stype: stype))
         end
 
@@ -757,7 +946,6 @@ describe "math" do
 
   context "determinants" do
     ALL_DTYPES.each do |dtype|
-      next if dtype == :object
       context dtype do
         before do
           @a = NMatrix.new([2,2], [1,2,
@@ -779,13 +967,19 @@ describe "math" do
                 end
         end
         it "computes the determinant of 2x2 matrix" do
-          expect(@a.det).to be_within(@err).of(-2)
+          if dtype != :object
+            expect(@a.det).to be_within(@err).of(-2)
+          end
         end
         it "computes the determinant of 3x3 matrix" do
-          expect(@b.det).to be_within(@err).of(-8)
+          if dtype != :object
+            expect(@b.det).to be_within(@err).of(-8)
+          end
         end
         it "computes the determinant of 4x4 matrix" do
-          expect(@c.det).to be_within(@err).of(-18)
+          if dtype != :object
+            expect(@c.det).to be_within(@err).of(-18)
+          end
         end
         it "computes the exact determinant of 2x2 matrix" do
           if dtype == :byte
@@ -804,4 +998,38 @@ describe "math" do
       end
     end
   end
+
+  context "#scale and #scale!" do
+    [:dense,:list,:yale].each do |stype|
+      ALL_DTYPES.each do |dtype|
+        next if dtype == :object
+        context "for #{dtype}" do
+          before do
+            @m = NMatrix.new([3, 3], [0, 1, 2,
+                                      3, 4, 5,
+                                      6, 7, 8], stype: stype, dtype: dtype)
+          end
+          it "scales the matrix by a given factor and return the result" do
+            if integer_dtype? dtype
+              expect{@m.scale 2.0}.to raise_error(DataTypeError)
+            else
+              expect(@m.scale 2.0).to eq(NMatrix.new([3, 3], [0,  2,  4,
+                                                             6,  8,  10,
+                                                             12, 14, 16], stype: stype, dtype: dtype))
+            end
+          end
+          it "scales the matrix in place by a given factor" do
+              if dtype == :int8
+                expect{@m.scale! 2}.to raise_error(DataTypeError)
+              else
+                @m.scale! 2
+                expect(@m).to eq(NMatrix.new([3, 3], [0,  2,  4,
+                                                      6,  8,  10,
+                                                      12, 14, 16], stype: stype, dtype: dtype))
+              end
+          end
+        end
+      end
+    end
+  end
 end