nmatrix-lapacke 0.2.0 → 0.2.1

data/lib/nmatrix/lapacke.rb

@@ -195,19 +195,41 @@ class NMatrix
     NMatrix::LAPACK::lapacke_potrf(:row, which, self.shape[0], self, self.shape[1])
   end
 
-  def solve b
+  def solve(b, opts = {})
     raise(ShapeError, "Must be called on square matrix") unless self.dim == 2 && self.shape[0] == self.shape[1]
     raise(ShapeError, "number of rows of b must equal number of cols of self") if 
       self.shape[1] != b.shape[0]
-    raise ArgumentError, "only works with dense matrices" if self.stype != :dense
-    raise ArgumentError, "only works for non-integer, non-object dtypes" if 
+    raise(ArgumentError, "only works with dense matrices") if self.stype != :dense
+    raise(ArgumentError, "only works for non-integer, non-object dtypes") if 
       integer_dtype? or object_dtype? or b.integer_dtype? or b.object_dtype?
 
-    x     = b.clone
-    clone = self.clone
-    n = self.shape[0]
-    ipiv = NMatrix::LAPACK.lapacke_getrf(:row, n, n, clone, n)
-    NMatrix::LAPACK.lapacke_getrs(:row, :no_transpose, n, b.shape[1], clone, n, ipiv, x, b.shape[1])
-    x
+    opts = { form: :general }.merge(opts)
+    x    = b.clone
+    n    = self.shape[0]
+    nrhs = b.shape[1]
+
+    case opts[:form] 
+    when :general
+      clone = self.clone
+      ipiv = NMatrix::LAPACK.lapacke_getrf(:row, n, n, clone, n)
+      NMatrix::LAPACK.lapacke_getrs(:row, :no_transpose, n, nrhs, clone, n, ipiv, x, nrhs)
+      x
+    when :upper_tri, :upper_triangular
+      raise(ArgumentError, "upper triangular solver does not work with complex dtypes") if
+        complex_dtype? or b.complex_dtype?
+      NMatrix::BLAS::cblas_trsm(:row, :left, :upper, false, :nounit, n, nrhs, 1.0, self, n, x, nrhs)
+      x
+    when :lower_tri, :lower_triangular
+      raise(ArgumentError, "lower triangular solver does not work with complex dtypes") if
+        complex_dtype? or b.complex_dtype?
+      NMatrix::BLAS::cblas_trsm(:row, :left, :lower, false, :nounit, n, nrhs, 1.0, self, n, x, nrhs)
+      x
+    when :pos_def, :positive_definite
+      u, l = self.factorize_cholesky
+      z = l.solve(b, form: :lower_tri)
+      u.solve(z, form: :upper_tri)
+    else
+      raise(ArgumentError, "#{opts[:form]} is not a valid form option")
+    end
   end
 end

data/spec/00_nmatrix_spec.rb

@@ -461,6 +461,12 @@ describe 'NMatrix' do
         expect(n.transpose).to eq n
         expect(n.transpose).not_to be n
       end
+
+      it "should check permute argument if supplied for #{stype} matrix" do
+        n = NMatrix.new([2,2], [1,2,3,4], stype: stype)
+        expect{n.transpose *4 }.to raise_error(ArgumentError)
+        expect{n.transpose [1,1,2] }.to raise_error(ArgumentError)
+      end
     end
   end
 

data/spec/math_spec.rb

@@ -553,6 +553,7 @@ describe "math" do
   context "#solve" do
     NON_INTEGER_DTYPES.each do |dtype|
       next if dtype == :object # LU factorization doesnt work for :object yet
+
       it "solves linear equation for dtype #{dtype}" do
         a = NMatrix.new [2,2], [3,1,1,2], dtype: dtype
         b = NMatrix.new [2,1], [9,8], dtype: dtype
@@ -581,6 +582,82 @@ describe "math" do
         expect(a.solve(b)).to eq(NMatrix.new [3,2], [1,0, 0,0, 2,2], dtype: dtype)
       end
     end
+
+    FLOAT_DTYPES.each do |dtype|
+      context "when form: :lower_tri" do
+        let(:a) { NMatrix.new([3,3], [1, 0, 0, 2, 0.5, 0, 3, 3, 9], dtype: dtype) }
+
+        it "solves a lower triangular linear system A * x = b with vector b" do
+          b = NMatrix.new([3,1], [1,2,3], dtype: dtype)
+          x = a.solve(b, form: :lower_tri)
+          r = a.dot(x) - b
+          expect(r.abs.max).to be_within(1e-6).of(0.0)
+        end
+
+        it "solves a lower triangular linear system A * X = B with narrow B" do
+          b = NMatrix.new([3,2], [1,2,3,4,5,6], dtype: dtype)
+          x = a.solve(b, form: :lower_tri)
+          r = (a.dot(x) - b).abs.to_flat_a
+          expect(r.max).to be_within(1e-6).of(0.0)
+        end
+
+        it "solves a lower triangular linear system A * X = B with wide B" do
+          b = NMatrix.new([3,5], (1..15).to_a, dtype: dtype)
+          x = a.solve(b, form: :lower_tri)
+          r = (a.dot(x) - b).abs.to_flat_a
+          expect(r.max).to be_within(1e-6).of(0.0)
+        end
+      end
+
+      context "when form: :upper_tri" do
+        let(:a) { NMatrix.new([3,3], [3, 2, 1, 0, 2, 0.5, 0, 0, 9], dtype: dtype) }
+
+        it "solves an upper triangular linear system A * x = b with vector b" do
+          b = NMatrix.new([3,1], [1,2,3], dtype: dtype)
+          x = a.solve(b, form: :upper_tri)
+          r = a.dot(x) - b
+          expect(r.abs.max).to be_within(1e-6).of(0.0)
+        end
+
+        it "solves an upper triangular linear system A * X = B with narrow B" do
+          b = NMatrix.new([3,2], [1,2,3,4,5,6], dtype: dtype)
+          x = a.solve(b, form: :upper_tri)
+          r = (a.dot(x) - b).abs.to_flat_a
+          expect(r.max).to be_within(1e-6).of(0.0)
+        end
+
+        it "solves an upper triangular linear system A * X = B with a wide B" do
+          b = NMatrix.new([3,5], (1..15).to_a, dtype: dtype)
+          x = a.solve(b, form: :upper_tri)
+          r = (a.dot(x) - b).abs.to_flat_a
+          expect(r.max).to be_within(1e-6).of(0.0)
+        end
+      end
+
+      context "when form: :pos_def" do
+        let(:a) { NMatrix.new([3,3], [4, 1, 2, 1, 5, 3, 2, 3, 6], dtype: dtype) }
+
+        it "solves a linear system A * X = b with positive definite A and vector b" do
+          b = NMatrix.new([3,1], [6,4,8], dtype: dtype)
+          begin
+            x = a.solve(b, form: :pos_def)
+            expect(x).to be_within(1e-6).of(NMatrix.new([3,1], [1,0,1], dtype: dtype))
+          rescue NotImplementedError
+            "Suppressing a NotImplementedError when the lapacke or atlas plugin is not available"
+          end
+        end
+      
+        it "solves a linear system A * X = B with positive definite A and matrix B" do
+          b = NMatrix.new([3,2], [8,3,14,13,14,19], dtype: dtype)
+          begin
+            x = a.solve(b, form: :pos_def)
+            expect(x).to be_within(1e-6).of(NMatrix.new([3,2], [1,-1,2,1,1,3], dtype: dtype))
+          rescue NotImplementedError
+            "Suppressing a NotImplementedError when the lapacke or atlas plugin is not available"
+          end
+        end
+      end
+    end
   end
 
   context "#hessenberg" do

data/spec/spec_helper.rb

@@ -138,3 +138,12 @@ end
 def integer_dtype? dtype
   [:byte,:int8,:int16,:int32,:int64].include?(dtype)
 end
+
+# If a focus: true option is supplied to any test, running `rake spec focus=true`
+# will run only the focused tests and nothing else.
+if ENV["focus"] == "true"
+  RSpec.configure do |c|
+    c.filter_run :focus => true
+  end
+end
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: nmatrix-lapacke
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - John Woods
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-08-25 00:00:00.000000000 Z
+date: 2016-01-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nmatrix
@@ -18,14 +18,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.2.0
+        version: 0.2.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.2.0
+        version: 0.2.1
 description: For using linear algebra fuctions provided by LAPACK and BLAS
 email:
 - john.o.woods@gmail.com