nmatrix-atlas 0.2.3 → 0.2.4

data/spec/rspec_spec.rb

@@ -28,6 +28,7 @@ require 'spec_helper'
 
 describe "RSpec" do
   it "should permit #be_within to be used on a dense NMatrix" do
+    pending("not yet implemented for NMatrix-JRuby") if jruby?
     expect(NMatrix.new([4,1], 1.0, dtype: :complex128, stype: :dense) / 10000.0).to be_within(0.00000001).of(NMatrix.new([4,1], 0.0001, dtype: :float64, stype: :dense))
     expect(NMatrix.new([4,1], 1.0, dtype: :complex128, stype: :dense) / 10000.0).not_to be_within(0.00000001).of(NMatrix.new([4,1], 1.0, dtype: :float64, stype: :dense))
   end

data/spec/shortcuts_spec.rb

@@ -104,13 +104,14 @@ describe NMatrix do
     [:dense, :yale, :list].each do |stype|
       context "#block_diagonal #{dtype} #{stype}" do
         it "block_diagonal() creates a block-diagonal NMatrix" do
+          pending("not yet implemented for NMatrix-JRuby") if jruby? and dtype == :object
           a = NMatrix.new([2,2], [1,2,
                                   3,4])
           b = NMatrix.new([1,1], [123.0])
           c = NMatrix.new([3,3], [1,2,3,
                                   1,2,3,
                                   1,2,3])
-          d = Array[ [1,1,1], [2,2,2], [3,3,3] ] 
+          d = Array[ [1,1,1], [2,2,2], [3,3,3] ]
           e = 12
           m = NMatrix.block_diagonal(a, b, c, d, e, dtype: dtype, stype: stype)
           expect(m).to eq(NMatrix.new([10,10], [1, 2,   0, 0, 0, 0, 0, 0, 0,  0,
@@ -136,6 +137,17 @@ describe NMatrix do
       expect(m.dtype).to eq(:float64)
     end
 
+    it "creates a matrix of random numbers with defined seed value" do
+      m1 = NMatrix.random(2,:seed => 62)
+      m2 = NMatrix.random(2,:seed => 62)
+      m3 = NMatrix.random(2,:seed => 65)
+
+
+      expect(m1).to eq(m2)
+      expect(m1).not_to eq(m3)
+
+    end
+
     it "creates a complex matrix of random numbers" do
       m = NMatrix.random(2, :dtype => :complex128)
     end
@@ -158,42 +170,44 @@ describe NMatrix do
       expect { NMatrix.random("not an array or integer") }.to raise_error
     end
   end
-  
+
   context "::magic" do
-    
+
     ALL_DTYPES.each do |dtype|
       context dtype do
         it "creates a matrix with numbers from 1 to n^n(n squared)" do
+          pending("not yet implemented for NMatrix-JRuby") if jruby?
           a = NMatrix.magic(3, dtype: dtype)
-          magic3 = NMatrix.new([3,3], [4, 9, 2, 3, 5, 7, 8, 1, 6], dtype: dtype)	
+          magic3 = NMatrix.new([3,3], [4, 9, 2, 3, 5, 7, 8, 1, 6], dtype: dtype)
           expect(a).to eq magic3
-      
+
           b = NMatrix.magic(4, dtype: dtype)
           magic4 = NMatrix.new([4,4], [1, 15, 14,  4, 12,  6,  7, 9, 8, 10, 11, 5, 13, 3, 2, 16], dtype: dtype)
           expect(b).to eq magic4
-      
+
           c = NMatrix.magic(6, dtype: dtype)
           magic6 = NMatrix.new([6,6], [31, 9, 2, 22, 27, 20, 3, 32, 7, 21, 23, 25, 35, 1, 6, 26, 19, 24, 4, 36, 29, 13, 18, 11, 30, 5, 34, 12, 14, 16, 8, 28, 33, 17, 10, 15], dtype: dtype)
-          expect(c).to eq magic6  
+          expect(c).to eq magic6
         end
       end
     end
-    
+
     it "shape of two is not allowed" do
       expect { NMatrix.magic(2) }.to raise_error(ArgumentError)
     end
-    
-    it "Only accepts an integer as dimension" do 
+
+    it "Only accepts an integer as dimension" do
       expect { NMatrix.magic(3.0) }.to raise_error(ArgumentError)
     end
   end
-  
+
   context "::linspace" do
     it "creates a row vector when given only one shape parameter" do
+      pending("not yet implemented for NMatrix-JRuby") if jruby?
       v = NMatrix.linspace(1, 10, 4)
       #Expect a row vector only
       expect(v.shape.length).to eq(1)
-      
+
       ans = [1.0,4.0,7.0,10.0]
 
       expect(v[0]).to be_within(0.000001).of(ans[0])
@@ -201,13 +215,14 @@ describe NMatrix do
       expect(v[2]).to be_within(0.000001).of(ans[2])
       expect(v[3]).to be_within(0.000001).of(ans[3])
     end
-    
+
     it "creates a matrix of input shape with each entry linearly spaced in row major order" do
+      pending("not yet implemented for NMatrix-JRuby") if jruby?
       v = NMatrix.linspace(1, Math::PI, [2,2])
       expect(v.dtype).to eq(:float64)
 
       ans = [1.0, 1.7138642072677612, 2.4277284145355225, 3.1415927410125732]
-      
+
       expect(v[0,0]).to be_within(0.000001).of(ans[0])
       expect(v[0,1]).to be_within(0.000001).of(ans[1])
       expect(v[1,0]).to be_within(0.000001).of(ans[2])
@@ -217,13 +232,14 @@ describe NMatrix do
 
   context "::logspace" do
     it "creates a logarithmically spaced vector" do
+      pending("not yet implemented for NMatrix-JRuby") if jruby?
       v = NMatrix.logspace(1, 2, 10)
-      
+
       expect(v.shape.length).to eq(1)
-      
+
       #Unit test taken from Matlab R2015b output of logspace(1,2,10)
       ans = [10.0000, 12.9155, 16.6810, 21.5443, 27.8256, 35.9381, 46.4159, 59.9484, 77.4264, 100.0000]
-      
+
       expect(v[0].round(4)).to be_within(0.000001).of(ans[0])
       expect(v[1].round(4)).to be_within(0.000001).of(ans[1])
       expect(v[2].round(4)).to be_within(0.000001).of(ans[2])
@@ -235,13 +251,14 @@ describe NMatrix do
       expect(v[8].round(4)).to be_within(0.000001).of(ans[8])
       expect(v[9].round(4)).to be_within(0.000001).of(ans[9])
     end
-    
+
     it "creates a logarithmically spaced vector bounded by Math::PI if :pi is pre-supplied" do
+      pending("not yet implemented for NMatrix-JRuby") if jruby?
       v = NMatrix.logspace(1, :pi, 7)
-                 
+
       #Unit test taken from Matlab R2015b output of logspace(1,pi,10)
       ans = [10.0000, 8.2450, 6.7980, 5.6050, 4.6213, 3.8103, 3.1416]
-      
+
       expect(v[0].round(4)).to be_within(0.000001).of(ans[0])
       expect(v[1].round(4)).to be_within(0.000001).of(ans[1])
       expect(v[2].round(4)).to be_within(0.000001).of(ans[2])
@@ -249,13 +266,14 @@ describe NMatrix do
       expect(v[4].round(4)).to be_within(0.000001).of(ans[4])
       expect(v[5].round(4)).to be_within(0.000001).of(ans[5])
       expect(v[6].round(4)).to be_within(0.000001).of(ans[6])
-    end    
+    end
 
     it "creates a matrix of input shape with each entry logarithmically spaced in row major order" do
+      pending("not yet implemented for NMatrix-JRuby") if jruby?
       v = NMatrix.logspace(1, 2, [3,2])
-      
+
       ans = [10.0, 15.8489, 25.1189, 39.8107, 63.0957, 100.0]
-      
+
       expect(v[0,0].round(4)).to be_within(0.000001).of(ans[0])
       expect(v[0,1].round(4)).to be_within(0.000001).of(ans[1])
       expect(v[1,0].round(4)).to be_within(0.000001).of(ans[2])
@@ -360,6 +378,7 @@ describe NMatrix do
     end
 
     it "should create an nmatrix of ones with dimensions and type the same as its argument" do
+      pending("not yet implemented for NMatrix-JRuby") if jruby?
       expect(NMatrix.ones_like(@nm_1d)).to eq NMatrix[1.0, 1.0, 1.0, 1.0, 1.0]
       expect(NMatrix.ones_like(@nm_2d)).to eq NMatrix[[1.0, 1.0], [1.0, 1.0]]
     end
@@ -383,6 +402,7 @@ describe "NVector" do
   end
 
   it "ones() creates a vector of ones" do
+    pending("not yet implemented for NMatrix-JRuby") if jruby?
     v = NVector.ones(3)
 
     3.times do |i|
@@ -391,6 +411,7 @@ describe "NVector" do
   end
 
   it "random() creates a vector of random numbers" do
+    pending("not yet implemented for NMatrix-JRuby") if jruby?
     v = NVector.random(4)
     expect(v.dtype).to eq(:float64)
     expect(v.stype).to eq(:dense)
@@ -424,16 +445,19 @@ describe "NVector" do
   end
 
   it "cindgen() creates a vector of complexes, sequentially" do
+    pending("not yet implemented for NMatrix-JRuby") if jruby?
     v = NVector.cindgen(2)
     expect(v).to eq(NMatrix.new([2,1], [Complex(0.0, 0.0), Complex(1.0, 0.0)], dtype: :complex64))
   end
 
   it "linspace() creates a vector with n values equally spaced between a and b" do
+    pending("not yet implemented for NMatrix-JRuby") if jruby?
     v = NVector.linspace(0, 2, 5)
     expect(v).to eq(NMatrix.new([5,1], [0.0, 0.5, 1.0, 1.5, 2.0]))
   end
 
   it "logspace() creates a vector with n values logarithmically spaced between decades 10^a and 10^b" do
+    pending("not yet implemented for NMatrix-JRuby") if jruby?
     v = NVector.logspace(0, 3, 4)
     expect(v).to eq(NMatrix.new([4,1], [1.0, 10.0, 100.0, 1000.0]))
   end

data/spec/slice_set_spec.rb

@@ -40,8 +40,12 @@ describe "Set slice operation" do
 
         if stype == :yale
           step "verify correct arrangement of Yale IJA and A arrays" do
-            @m.extend NMatrix::YaleFunctions
-            expect(@m.yale_ija).to eq([4,6,8,10,1,2,0,2,0,1])
+            @m.extend NMatrix::YaleFunctions unless jruby?
+            if jruby?
+              pending("not yet implemented for NMatrix-JRuby")
+            else
+              expect(@m.yale_ija).to eq([4,6,8,10,1,2,0,2,0,1])
+            end
             expect(@m.yale_a).to   eq([0,4,8,0, 1,2,3,5,6,7])
           end
         end
@@ -145,6 +149,7 @@ describe "Set slice operation" do
       end
 
       example "set a range of values to a matrix's contents" do
+        pending("not yet implemented for int dtype for NMatrix-JRuby") if jruby?
         x = NMatrix.new(4, stype: :yale, dtype: :int16)
         x.extend NMatrix::YaleFunctions if stype == :yale
         x[1..3,1..3] = @m

data/spec/stat_spec.rb

@@ -41,6 +41,7 @@ describe "Statistical functions" do
         end
 
         it "should calculate the mean along the specified dimension" do
+          pending("not yet implemented for NMatrix-JRuby") if jruby?
           unless stype == :yale then
             puts nm_1d.mean
             expect(nm_1d.mean).to eq NMatrix.new([1], [2.2], stype: stype, dtype: :float64)
@@ -50,27 +51,32 @@ describe "Statistical functions" do
         end
 
         it "should calculate the minimum along the specified dimension" do
+          pending("not yet implemented for NMatrix-JRuby") if jruby?
           expect(nm_1d.min).to eq 0.0 unless stype == :yale
           expect(nm_2d.min).to eq NMatrix[[0.0, 1.0], stype: stype]
           expect(nm_2d.min(1)).to eq NMatrix[[0.0], [2.0], stype: stype]
         end
 
         it "should calculate the maximum along the specified dimension" do
+          pending("not yet implemented for NMatrix-JRuby") if jruby?
           expect(nm_1d.max).to eq 5.0  unless stype == :yale
           expect(nm_2d.max).to eq NMatrix[[2.0, 3.0], stype: stype]
         end
 
         it "should calculate the variance along the specified dimension" do
+          pending("not yet implemented for NMatrix-JRuby") if jruby?
           expect(nm_1d.variance).to eq NMatrix[3.7, stype: stype] unless stype == :yale
           expect(nm_2d.variance(1)).to eq NMatrix[[0.5], [0.5], stype: stype]
         end
 
         it "should calculate the sum along the specified dimension" do
+          pending("not yet implemented for NMatrix-JRuby") if jruby?
           expect(nm_1d.sum).to eq NMatrix[11.0, stype: stype] unless stype == :yale
           expect(nm_2d.sum).to eq NMatrix[[2.0, 4.0], stype: stype]
         end
 
         it "should calculate the standard deviation along the specified dimension" do
+          pending("not yet implemented for NMatrix-JRuby") if jruby?
           expect(nm_1d.std).to eq NMatrix[Math.sqrt(3.7), stype: stype] unless stype == :yale
           expect(nm_2d.std(1)).to eq NMatrix[[Math.sqrt(0.5)], [Math.sqrt(0.5)], stype: stype]
         end
@@ -128,6 +134,7 @@ describe "Statistical functions" do
         end
 
         it "should iterate correctly for reduce without a block" do
+          pending("not yet implemented for NMatrix-JRuby") if jruby?
           unless stype == :yale then
             en = nm_1d.reduce_along_dim(0, 1.0)
             expect(en.each { |a, e| a+e }.to_f).to eq 12
@@ -170,6 +177,7 @@ describe "Statistical functions" do
         end
 
         it "should allow overriding the dtype for reduce_along_dim" do
+          pending("not yet implemented for NMatrix-JRuby") if jruby?
           m = NMatrix[[1,2,3], [3,4,5], dtype: :complex128]
           m.reduce_along_dim(1, 0.0, :float64) do |acc, sub_m|
             expect(acc.dtype).to eq :float64
@@ -184,16 +192,19 @@ describe "Statistical functions" do
         end
 
         it "should convert integer dtypes to float when calculating mean" do
+          pending("not yet implemented for NMatrix-JRuby") if jruby?
           m = NMatrix[[1,2,3], [3,4,5], dtype: :int32, stype: stype]
           expect(m.mean(0).dtype).to eq :float64
         end
 
         it "should convert integer dtypes to float when calculating variance" do
+          pending("not yet implemented for NMatrix-JRuby") if jruby?
           m = NMatrix[[1,2,3], [3,4,5], dtype: :int32, stype: stype]
           expect(m.variance(0).dtype).to eq :float64
         end
 
         it "should convert integer dtypes to float when calculating standard deviation" do
+          pending("not yet implemented for NMatrix-JRuby") if jruby?
           m = NMatrix[[1,2,3], [3,4,5], dtype: :int32, stype: stype]
           expect(m.std(0).dtype).to eq :float64
         end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: nmatrix-atlas
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.2.4
 platform: ruby
 authors:
 - Will Levine
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-07-25 00:00:00.000000000 Z
+date: 2017-12-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nmatrix
@@ -17,14 +17,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.2.3
+        version: 0.2.4
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.2.3
+        version: 0.2.4
 description: For using linear algebra fuctions provided by ATLAS
 email:
 - john.o.woods@gmail.com
@@ -134,7 +134,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.6.13
 signing_key: 
 specification_version: 4
 summary: ATLAS backend for nmatrix
@@ -143,27 +143,17 @@ test_files:
 - spec/01_enum_spec.rb
 - spec/02_slice_spec.rb
 - spec/03_nmatrix_monkeys_spec.rb
-- spec/2x2_dense_double.mat
-- spec/4x4_sparse.mat
-- spec/4x5_dense.mat
 - spec/blas_spec.rb
 - spec/elementwise_spec.rb
 - spec/homogeneous_spec.rb
 - spec/io/fortran_format_spec.rb
 - spec/io/harwell_boeing_spec.rb
-- spec/io/test.rua
 - spec/io_spec.rb
 - spec/lapack_core_spec.rb
-- spec/leakcheck.rb
 - spec/math_spec.rb
-- spec/nmatrix_yale_resize_test_associations.yaml
 - spec/nmatrix_yale_spec.rb
-- spec/rspec_monkeys.rb
 - spec/rspec_spec.rb
 - spec/shortcuts_spec.rb
 - spec/slice_set_spec.rb
-- spec/spec_helper.rb
 - spec/stat_spec.rb
-- spec/test.pcd
-- spec/utm5940.mtx
 - spec/plugins/atlas/atlas_spec.rb