pnmatrix 1.2.4 → 2.0.1

data/lib/nmatrix/shortcuts.rb

@@ -196,11 +196,8 @@ class NMatrix
         i += 1
       end
 
-      # A row vector should be stored as 1xN, not N
-      #shape.unshift(1) if shape.size == 1
-
       # Then flatten the array.
-      NMatrix.new(shape, params.flatten, options)
+      NMatrix.new(shape, params.flatten, **options)
     end
 
     #
@@ -230,7 +227,7 @@ class NMatrix
     #   NMatrix.zeros([1, 5], dtype: :int32) # =>  0  0  0  0  0
     #
     def zeros(shape, opts = {})
-      NMatrix.new(shape, 0, {:dtype => :float64}.merge(opts))
+      NMatrix.new(shape, 0, **{:dtype => :float64}.merge(opts))
     end
     alias :zeroes :zeros
 
@@ -255,7 +252,7 @@ class NMatrix
     #                                             1  1  1
     #
     def ones(shape, opts={})
-      NMatrix.new(shape, 1, {:dtype => :float64, :default => 1}.merge(opts))
+      NMatrix.new(shape, 1, **{:dtype => :float64}.merge(opts))
     end
 
     # call-seq:
@@ -268,7 +265,7 @@ class NMatrix
     # @return [NMatrix] a new nmatrix filled with ones.
     #
     def ones_like(nm)
-      NMatrix.ones(nm.shape, dtype: nm.dtype, stype: nm.stype, capacity: nm.capacity, default: 1)
+      NMatrix.ones(nm.shape, dtype: nm.dtype, stype: nm.stype, capacity: nm.capacity)
     end
 
     # call-seq:
@@ -281,7 +278,7 @@ class NMatrix
     # @return [NMatrix] a new nmatrix filled with zeros.
     #
     def zeros_like(nm)
-      NMatrix.zeros(nm.shape, dtype: nm.dtype, stype: nm.stype, capacity: nm.capacity, default: 0)
+      NMatrix.zeros(nm.shape, dtype: nm.dtype, stype: nm.stype, capacity: nm.capacity)
     end
 
     #
@@ -345,7 +342,7 @@ class NMatrix
     #            0.3333333333333333          0.25                  0.2
     #
     def hilbert(shape, opts={})
-      m = NMatrix.new([shape,shape], {:dtype => :float64}.merge(opts))
+      m = NMatrix.new([shape,shape], **{:dtype => :float64}.merge(opts))
       0.upto(shape - 1) do |i|
         0.upto(i) do |j|
           m[i,j] = 1.0 / (j + i + 1)
@@ -378,8 +375,8 @@ class NMatrix
     #
     def inv_hilbert(shape, opts={})
       opts = {:dtype => :float64}.merge(opts)
-      m = NMatrix.new([shape,shape],opts)
-      combination = NMatrix.new([2*shape,2*shape],opts)
+      m = NMatrix.new([shape,shape], **opts)
+      combination = NMatrix.new([2*shape,2*shape], **opts)
       #combinations refers to the combination of n things taken k at a time
       0.upto(2*shape-1) do |i|
         0.upto(i) do |j|
@@ -553,7 +550,7 @@ class NMatrix
         NMatrix.size(shape).times { |i| random_values << rng.rand(scale) }
       end
 
-      NMatrix.new(shape, random_values, {:dtype => :float64, :stype => :dense}.merge(opts))
+      NMatrix.new(shape, random_values, **{:dtype => :float64, :stype => :dense}.merge(opts))
     end
     alias :rand :random
     
@@ -595,7 +592,7 @@ class NMatrix
     #
     def magic(shape, opts={})
       raise(ArgumentError, "shape of two is not allowed") if shape == 2
-      nm = NMatrix.new([shape,shape], 0, {:dtype => :float64}.merge(opts))
+      nm = NMatrix.new([shape,shape], 0, **{:dtype => :float64}.merge(opts))
       if shape % 2 != 0
         MagicHelpers.odd_magic nm, shape
       elsif shape % 4 == 0
@@ -841,7 +838,7 @@ class NMatrix
       values = (0 ... NMatrix.size(shape)).to_a
 
       # It'll produce :int32, except if a dtype is provided.
-      NMatrix.new(shape, values, {:stype => :dense}.merge(options))
+      NMatrix.new(shape, values, **{:stype => :dense}.merge(options))
     end
 
     {:bindgen => :byte, :indgen => :int64, :findgen => :float32, :dindgen => :float64,
@@ -969,7 +966,7 @@ module NVector #:nodoc:
       random_values = []
       size.times { |i| random_values << rng.rand }
 
-      NMatrix.new([size,1], random_values, opts)
+      NMatrix.new([size,1], random_values, **opts)
     end
 
     #

data/lib/nmatrix/version.rb

@@ -27,13 +27,12 @@ class NMatrix
   # native IO. If you change the format, please make sure that native
   # IO can still understand NMatrix::VERSION.
   module VERSION #:nodoc:
-    MAJOR = 1
-    MINOR = 2
-    TINY = 4
+    MAJOR = 2
+    MINOR = 0
+    TINY = 1
     #PRE = "a"
 
     STRING = [MAJOR, MINOR, TINY].compact.join(".")
     #STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
   end
 end
-

data/spec/io_spec.rb

@@ -51,6 +51,7 @@ describe NMatrix::IO do
   end
 
   it "reads MATLAB .mat file containing a single square sparse matrix" do
+    skip "Mat5Reader was removed from pnmatrix" unless defined?(NMatrix::IO::Matlab::Mat5Reader)
     pending("not yet implemented for NMatrix-JRuby") if jruby?
     n = NMatrix::IO::Matlab.load_mat("spec/4x4_sparse.mat")
     expect(n[0,0]).to eq(2)
@@ -62,19 +63,20 @@ describe NMatrix::IO do
   end
 
   it "reads MATLAB .mat file containing a single dense integer matrix" do
+    skip "Mat5Reader was removed from pnmatrix" unless defined?(NMatrix::IO::Matlab::Mat5Reader)
     n = NMatrix::IO::Matlab.load_mat("spec/4x5_dense.mat")
     m = NMatrix.new([4,5], [16,17,18,19,20,15,14,13,12,11,6,7,8,9,10,5,4,3,2,1])
     expect(n).to eq(m)
   end
 
   it "reads MATLAB .mat file containing a single dense double matrix" do
+    skip "Mat5Reader was removed from pnmatrix" unless defined?(NMatrix::IO::Matlab::Mat5Reader)
     n = NMatrix::IO::Matlab.load_mat("spec/2x2_dense_double.mat")
     m = NMatrix.new(2, [1.1, 2.0, 3.0, 4.0], dtype: :float64)
     expect(n).to eq(m)
   end
 
   it "loads and saves MatrixMarket .mtx file containing a single large sparse double matrix" do
-    pending "spec disabled because it's so slow"
     n = NMatrix::IO::Market.load("spec/utm5940.mtx")
     NMatrix::IO::Market.save(n, "spec/utm5940.saved.mtx")
     expect(`wc -l spec/utm5940.mtx`.split[0]).to eq(`wc -l spec/utm5940.saved.mtx`.split[0])

data/spec/lapack_core_spec.rb

@@ -273,8 +273,9 @@ describe "NMatrix::LAPACK functions with internal implementations" do
               end
 
         expect(s).to be_within(err).of(s_true)
-        expect(u).to be_within(err).of(u_true)
-        expect(vt).to be_within(err).of(vt_true)
+        # Singular vectors are only defined up to sign (or complex phase).
+        expect(u.abs).to be_within(err).of(u_true.abs)
+        expect(vt.abs).to be_within(err).of(vt_true.abs)
 
         expect(s.dtype).to eq(a.abs_dtype)
         expect(u.dtype).to eq(dtype)
@@ -306,8 +307,9 @@ describe "NMatrix::LAPACK functions with internal implementations" do
               end
 
         expect(s).to be_within(err).of(s_true)
-        expect(u).to be_within(err).of(u_true)
-        expect(vt).to be_within(err).of(vt_true)
+        # Singular vectors are only defined up to sign (or complex phase).
+        expect(u.abs).to be_within(err).of(u_true.abs)
+        expect(vt.abs).to be_within(err).of(vt_true.abs)
       end
 
 
@@ -337,8 +339,9 @@ describe "NMatrix::LAPACK functions with internal implementations" do
               end
 
         expect(eigenvalues).to be_within(err).of(eigenvalues_true)
-        expect(vr).to be_within(err).of(vr_true)
-        expect(vl).to be_within(err).of(vl_true)
+        # Eigenvectors are only defined up to sign (or complex phase).
+        expect(vr.abs).to be_within(err).of(vr_true.abs)
+        expect(vl.abs).to be_within(err).of(vl_true.abs)
 
         expect(eigenvalues.dtype).to eq(NMatrix.upcast(dtype, :complex64))
         expect(vr.dtype).to eq(NMatrix.upcast(dtype, :complex64))
@@ -384,7 +387,8 @@ describe "NMatrix::LAPACK functions with internal implementations" do
               end
 
         expect(eigenvalues).to be_within(err).of(eigenvalues_true)
-        expect(vr).to be_within(err).of(vr_true)
+        # Eigenvectors are only defined up to sign (or complex phase).
+        expect(vr.abs).to be_within(err).of(vr_true.abs)
         expect(vl).to be_within(err).of(vl_true)
 
         expect(eigenvalues.dtype).to eq(dtype)
@@ -441,7 +445,8 @@ describe "NMatrix::LAPACK functions with internal implementations" do
               end
 
         expect(eigenvalues).to be_within(err).of(eigenvalues_true)
-        expect(vr).to be_within(err).of(vr_true)
+        # Eigenvectors are only defined up to sign (or complex phase).
+        expect(vr.abs).to be_within(err).of(vr_true.abs)
       end
     end
   end

data/spec/math_spec.rb

@@ -82,8 +82,10 @@ describe "math" do
             end
 
             it "should correctly apply elementwise natural log" do
-              expect(@m.log).to eq N.new(@size, [0, Math.log(2), Math.log(3), Math.log(4)],
-                                        dtype: :float64, stype: stype)
+              expect(@m.log).to be_within(1e-14).of(
+                N.new(@size, [0, Math.log(2), Math.log(3), Math.log(4)],
+                      dtype: :float64, stype: stype)
+              )
             end
 
             it "should correctly apply elementwise log with arbitrary base" do
@@ -264,6 +266,7 @@ describe "math" do
           expect(r).to eq(b)
         rescue NotImplementedError
           pending "potrf! not implemented without plugins"
+          raise
         end
       end
 
@@ -280,6 +283,7 @@ describe "math" do
           expect(r).to eq(b)
         rescue NotImplementedError
           pending "potrf! not implemented without plugins"
+          raise
         end
       end
 
@@ -295,6 +299,7 @@ describe "math" do
           expect(l).to eq(l_true)
         rescue NotImplementedError
           pending "potrf! not implemented without plugins"
+          raise
         end
       end
     end
@@ -325,11 +330,13 @@ describe "math" do
         begin
           q,r = a.factorize_qr
 
-          expect(q).to be_within(err).of(q_solution)
-          expect(r).to be_within(err).of(r_solution)
+          # QR factors are only defined up to matched column/row signs.
+          expect(q.abs).to be_within(err).of(q_solution.abs)
+          expect(r.abs).to be_within(err).of(r_solution.abs)
 
         rescue NotImplementedError
           pending "Suppressing a NotImplementedError when the lapacke plugin is not available"
+          raise
         end
       end
 
@@ -359,11 +366,13 @@ describe "math" do
         begin
           q,r = a.factorize_qr
 
-          expect(q).to be_within(err).of(q_solution)
-          expect(r).to be_within(err).of(r_solution)
+          # QR factors are only defined up to matched column/row signs.
+          expect(q.abs).to be_within(err).of(q_solution.abs)
+          expect(r.abs).to be_within(err).of(r_solution.abs)
 
         rescue NotImplementedError
           pending "Suppressing a NotImplementedError when the lapacke plugin is not available"
+          raise
         end
       end
 
@@ -387,11 +396,13 @@ describe "math" do
         begin
           q,r = a.factorize_qr
 
-          expect(q).to be_within(err).of(q_solution)
-          expect(r).to be_within(err).of(r_solution)
+          # QR factors are only defined up to matched column/row signs.
+          expect(q.abs).to be_within(err).of(q_solution.abs)
+          expect(r.abs).to be_within(err).of(r_solution.abs)
 
         rescue NotImplementedError
           pending "Suppressing a NotImplementedError when the lapacke plugin is not available"
+          raise
         end
       end
 
@@ -416,6 +427,7 @@ describe "math" do
 
         rescue NotImplementedError
           pending "Suppressing a NotImplementedError when the lapacke plugin is not available"
+          raise
         end
       end
 
@@ -444,6 +456,7 @@ describe "math" do
 
         rescue NotImplementedError
           pending "Suppressing a NotImplementedError when the lapacke plugin is not available"
+          raise
         end
       end
     end
@@ -461,7 +474,7 @@ describe "math" do
             end
 
       it "should correctly invert a matrix in place (bang)" do
-        pending("not yet implemented for :object dtype") if dtype == :object
+        pending("not yet implemented for :object dtype") if dtype == :object && defined?(NMatrix::LAPACKE)
         a = NMatrix.new(:dense, 5, [1, 8,-9, 7, 5,
                                     0, 1, 0, 4, 4,
                                     0, 0, 1, 2, 5,
@@ -529,6 +542,7 @@ describe "math" do
             expect(a.dot(a.pinv)).to be_within(err).of(b)
           rescue NotImplementedError
             pending "Suppressing a NotImplementedError when the atlas plugin is not available"
+            raise
           end
 
         else
@@ -539,6 +553,7 @@ describe "math" do
             expect(a.dot(a.pinv)).to be_within(err).of(b)
           rescue NotImplementedError
             pending "Suppressing a NotImplementedError when the atlas plugin is not available"
+            raise
           end
         end
       end
@@ -556,6 +571,7 @@ describe "math" do
             expect(b.dot(a.dot(b))).to be_within(err).of(b)
           rescue NotImplementedError
             pending "Suppressing a NotImplementedError when the atlas plugin is not available"
+            raise
           end
 
         else
@@ -567,6 +583,7 @@ describe "math" do
             expect(b.dot(a.dot(b))).to be_within(err).of(b)
           rescue NotImplementedError
             pending "Suppressing a NotImplementedError when the atlas plugin is not available"
+            raise
           end
         end
       end
@@ -1134,7 +1151,6 @@ describe "math" do
           expect(@c.det).to be_within(@err).of(-18)
         end
         it "computes the exact determinant of 2x2 matrix" do
-          pending("not yet implemented for :object dtype") if dtype == :object
           if dtype == :byte
             expect{@a.det_exact}.to raise_error(DataTypeError)
           else
@@ -1166,7 +1182,6 @@ describe "math" do
           end
 
           it "scales the matrix by a given factor and return the result" do
-            pending("not yet implemented for :object dtype") if dtype == :object
             if integer_dtype? dtype
               expect{@m.scale 2.0}.to raise_error(DataTypeError)
             else
@@ -1178,7 +1193,6 @@ describe "math" do
           end
 
           it "scales the matrix in place by a given factor" do
-            pending("not yet implemented for :object dtype") if dtype == :object
             if dtype == :int8
               expect{@m.scale! 2}.to raise_error(DataTypeError)
             else
@@ -1196,7 +1210,6 @@ describe "math" do
   context "matrix_norm" do
     ALL_DTYPES.each do |dtype|
       context dtype do
-        pending("not yet implemented for :object dtype") if dtype == :object
         before do
           @n = NMatrix.new([3,3], [-4,-3,-2,
                                    -1, 0, 1,
@@ -1215,6 +1228,7 @@ describe "math" do
 
               rescue NotImplementedError
                 pending "Suppressing a NotImplementedError when the lapacke plugin is not available"
+                raise
             end
           end
         end
@@ -1240,6 +1254,7 @@ describe "math" do
               expect(@n.matrix_norm(-2)).to be_within(@matrix_norm_TOLERANCE).of(0.0)
               rescue NotImplementedError
                 pending "Suppressing a NotImplementedError when the lapacke plugin is not available"
+                raise
             end
             expect(@n.matrix_norm(-1)).to eq(6)
           end
@@ -1293,6 +1308,7 @@ describe "math" do
 
           rescue NotImplementedError
             pending "Suppressing a NotImplementedError when the lapacke plugin is not available" 
+            raise
           end         
         end
 
@@ -1308,6 +1324,7 @@ describe "math" do
 
           rescue NotImplementedError
              pending "Suppressing a NotImplementedError when the lapacke plugin is not available" 
+             raise
           end
         end
 
@@ -1323,6 +1340,7 @@ describe "math" do
 
           rescue NotImplementedError
              pending "Suppressing a NotImplementedError when the lapacke plugin is not available" 
+             raise
           end
         end
 
@@ -1338,6 +1356,7 @@ describe "math" do
 
           rescue NotImplementedError
              pending "Suppressing a NotImplementedError when the lapacke plugin is not available" 
+             raise
           end
         end
 
@@ -1353,6 +1372,7 @@ describe "math" do
 
           rescue NotImplementedError
              pending "Suppressing a NotImplementedError when the lapacke plugin is not available" 
+             raise
           end
         end
 

data/spec/stress_test_spec.rb

@@ -0,0 +1,181 @@
+require 'spec_helper'
+
+describe NMatrix do
+  def force_gc
+    20.times do
+      Array.new(1_000) { |i| "gc-pressure-#{i}" }
+      GC.start
+    end
+  end
+
+  def build_dense_object_reference
+    values = Array.new(64 * 64) { |i| "dense-object-#{i}" }
+    matrix = NMatrix.new([64, 64], values, stype: :dense, dtype: :object)
+
+    matrix[50...64, 45...64]
+  end
+
+  def build_yale_object_reference
+    rng = Random.new(5678)
+    matrix = NMatrix.new([35, 35], nil, stype: :yale, dtype: :object, capacity: 1)
+
+    700.times do |i|
+      matrix[rng.rand(35), rng.rand(35)] = "yale-object-#{i}"
+    end
+
+    matrix[3...30, 4...32]
+  end
+
+  def build_nested_yale_object_reference
+    rng = Random.new(6789)
+    matrix = NMatrix.new([45, 45], nil, stype: :yale, dtype: :object, capacity: 1)
+
+    1_000.times do |i|
+      matrix[rng.rand(45), rng.rand(45)] = "nested-yale-object-#{i}"
+    end
+
+    matrix[5...40, 6...39][7...28, 8...30]
+  end
+
+  def build_list_object_reference
+    matrix = NMatrix.new([30, 30], nil, stype: :list, dtype: :object)
+
+    30.times do |i|
+      matrix[i, (i * 7) % 30] = "list-object-#{i}"
+    end
+
+    matrix[4...28, 2...29]
+  end
+
+  def mutate_dense_object_matrix_without_external_references
+    rng = Random.new(555)
+    matrix = NMatrix.new([80, 80], nil, stype: :dense, dtype: :object)
+
+    5_000.times do |i|
+      matrix[rng.rand(80), rng.rand(80)] = "mut-dense-#{i}"
+      GC.start if (i % 25).zero?
+    end
+
+    matrix
+  end
+
+  def mutate_yale_object_matrix_without_external_references
+    rng = Random.new(333)
+    matrix = NMatrix.new([80, 80], nil, stype: :yale, dtype: :object, capacity: 1)
+
+    5_000.times do |i|
+      matrix[rng.rand(80), rng.rand(80)] = "mut-yale-#{i}"
+      GC.start if (i % 25).zero?
+    end
+
+    matrix
+  end
+
+  def mutate_list_object_matrix_without_external_references
+    rng = Random.new(888)
+    matrix = NMatrix.new([30, 30], nil, stype: :list, dtype: :object)
+
+    500.times do |i|
+      matrix[rng.rand(30), rng.rand(30)] = "mut-list-#{i}"
+      GC.start if (i % 10).zero?
+    end
+
+    matrix
+  end
+
+  def touch_reference(reference)
+    reference.each_stored_with_indices do |value, _i, _j|
+      value.to_s.hash
+    end
+  end
+
+  specify do
+    200.times do |i|
+      size = rand(500..1000)
+      m1 = NMatrix.new([size, size], 0, stype: :yale, dtype: :int32)
+      m2 = m1.clone
+
+      rand(1000).times do |j|
+        m1[rand(size), rand(size)] = 1
+        m2[rand(size), rand(size)] = 1
+      end
+
+      (m1*m2).det
+    end
+  end
+
+  specify "does not segfault when iterating a GC-stressed object Yale reference" do
+    reference = build_yale_object_reference
+
+    force_gc
+
+    touch_reference(reference)
+  end
+
+  specify "does not segfault when iterating a GC-stressed nested object Yale reference" do
+    reference = build_nested_yale_object_reference
+
+    force_gc
+
+    touch_reference(reference)
+  end
+
+  specify "does not segfault when iterating a GC-stressed object dense reference" do
+    reference = build_dense_object_reference
+
+    force_gc
+
+    reference.each_with_indices do |value, _i, _j|
+      value.to_s.hash
+    end
+  end
+
+  specify "does not segfault when iterating a GC-stressed object list reference" do
+    reference = build_list_object_reference
+
+    force_gc
+
+    touch_reference(reference)
+  end
+
+  specify "does not segfault after GC-stressed object dense mutation" do
+    matrix = mutate_dense_object_matrix_without_external_references
+
+    force_gc
+
+    matrix.each do |value|
+      value.to_s.hash
+    end
+  end
+
+  specify "does not segfault after GC-stressed object Yale mutation" do
+    matrix = mutate_yale_object_matrix_without_external_references
+
+    force_gc
+
+    touch_reference(matrix)
+  end
+
+  specify "does not segfault after GC-stressed object list mutation" do
+    matrix = mutate_list_object_matrix_without_external_references
+
+    force_gc
+
+    touch_reference(matrix)
+  end
+
+  specify "does not expose partially built Yale object storage during a cast" do
+    previous_gc_stress = GC.stress
+    GC.stress = true
+
+    current_stock = NMatrix.new([30, 1], 0, stype: :yale, dtype: :float64)
+    current_stock[3] = -4
+    current_stock[7] = 10
+    current_stock[11] = 50
+
+    quantity_made = (current_stock < 0).cast(dtype: :int32) * current_stock * -1
+    expect(quantity_made[3]).to eq(4)
+  ensure
+    GC.stress = previous_gc_stress
+  end
+end