nmatrix-lapacke 0.2.3 → 0.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 24925aa4dcfc784adc3fd27fa05687c0779d57e4
-  data.tar.gz: e0d5107e1d0211a1d32429e05a32ae1eb309c3bc
+  metadata.gz: 133bcdfcd7277df201f721ea4a92aa9a37032c05
+  data.tar.gz: 667c5dd368cce4ad033ffc3f3222d58149703489
 SHA512:
-  metadata.gz: 4be4b9ae38fe6cc8a2817ac79bf55a4541dd70708d0e86737c3179bd25d177b8bfb178d69ddc2a95396eac5d992bf40ae6f8b47554877c6657d8136e6bbe93df
-  data.tar.gz: 3cd253933d42d5a32780f717269b63583c489469d0d29bd8476fef61e5ed3ebb65c24ba5be5db36a38845ec3d60dbc3d3138fc1c0762a2e70890ede43262c8d5
+  metadata.gz: b4c0c3a46acb0fa9bdca458652e65c518b281b3f907827303b1493c5fa25234d9a1ae3968868f7dada7e6ab91febdabe4ac6769cbe8b76be94f71996b7aaac01
+  data.tar.gz: 8779b713ad167d932efcc7fd79296191c7038f9e1719b05dfbd3bdef5ffb831ca41f1329315584b56f13f6861876f2b60b969742b0316e6aaafe01af3d921898

data/ext/nmatrix/data/ruby_object.h

@@ -110,7 +110,7 @@ class RubyObject {
   inline operator VALUE() const { return rval; }
   //inline operator uint32_t() const { return NUM2ULONG(this->rval);      }
   inline operator int64_t() const { RETURN_OBJ2NUM(NUM2LONG)        }
-  inline operator uint64_t() const { RETURN_OBJ2NUM(NUM2ULONG)      }
+  //inline operator uint64_t() const { RETURN_OBJ2NUM(NUM2ULONG)      }
   inline operator double()   const { RETURN_OBJ2NUM(NUM2DBL)        }
   inline operator float()  const { RETURN_OBJ2NUM(NUM2DBL)          }
 

data/ext/nmatrix/math/math.h

@@ -102,8 +102,14 @@ extern "C" {
   void nm_math_solve(VALUE lu, VALUE b, VALUE x, VALUE ipiv);
   void nm_math_inverse(const int M, void* A_elements, nm::dtype_t dtype);
   void nm_math_hessenberg(VALUE a);
-  void nm_math_det_exact(const int M, const void* elements, const int lda, nm::dtype_t dtype, void* result);
-  void nm_math_inverse_exact(const int M, const void* A_elements, const int lda, void* B_elements, const int ldb, nm::dtype_t dtype);
+  void nm_math_det_exact_from_dense(const int M, const void* elements, 
+      const int lda, nm::dtype_t dtype, void* result);
+  void nm_math_det_exact_from_yale(const int M, const YALE_STORAGE* storage, 
+      const int lda, nm::dtype_t dtype, void* result);
+  void nm_math_inverse_exact_from_dense(const int M, const void* A_elements, 
+      const int lda, void* B_elements, const int ldb, nm::dtype_t dtype);
+  void nm_math_inverse_exact_from_yale(const int M, const YALE_STORAGE* storage, 
+      const int lda, YALE_STORAGE* inverse, const int ldb, nm::dtype_t dtype);
 }
 
 

data/lib/nmatrix/lapacke.rb

@@ -303,7 +303,7 @@ class NMatrix
 
 
     #Default behaviour produces Q * I  = Q if c is not supplied.
-    result = c ? c : NMatrix.identity(self.shape[0], dtype: self.dtype)
+    result = c ? c.clone : 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
@@ -343,7 +343,7 @@ class NMatrix
     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)
+    result = c ? c.clone : 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

data/spec/00_nmatrix_spec.rb

@@ -41,8 +41,71 @@ describe NMatrix do
     expect { n[0] }.to raise_error(ArgumentError)
   end
 
-  it "calculates exact determinants on small square matrices" do
+  it "calculates exact determinants on small dense matrices" do
     expect(NMatrix.new(2, [1,2,3,4], stype: :dense, dtype: :int64).det_exact).to eq(-2)
+    expect(NMatrix.new(3, [1,2,3,0,5,6,7,8,0], stype: :dense, dtype: :int64)
+           .det_exact).to eq(-69)
+  end
+
+  it "calculates exact determinants on small yale square matrices" do
+    expect(NMatrix.new(2, [1,2,3,4], stype: :yale, dtype: :int64).det_exact).to eq(-2)
+    expect(NMatrix.new(3, [1,2,3,0,5,6,7,8,0], stype: :yale, dtype: :int64)
+           .det_exact).to eq(-69)
+  end
+
+  it "calculates exact determinants on small list square matrices" do
+    expect(NMatrix.new(2, [1,2,3,4], stype: :list, dtype: :int64).det_exact).to eq(-2)
+    expect(NMatrix.new(3, [1,2,3,0,5,6,7,8,0], stype: :list, dtype: :int64)
+           .det_exact).to eq(-69)
+  end
+
+  it "calculates inverse exact determinants on small dense matrices" do
+    pending("not yet implemented for NMatrix-JRuby") if jruby?
+    a = NMatrix.new(3, [1,2,3,0,1,4,5,6,0], stype: :dense, dtype: :int64)
+    inversed = a.method(:__inverse_exact__).call(a.clone, 3, 3)
+    b = NMatrix.new(3, [-24,18,5,20,-15,-4,-5,4,1], stype: :dense, dtype: :int64)
+    expect(inversed).to eq(b)
+
+    c = NMatrix.new(3, [1,0,3,0,0,1,0,6,0], stype: :dense, dtype: :int64)
+    inversed = c.method(:__inverse_exact__).call(c.clone, 3, 3)
+    d = NMatrix.new(3, [1,-3,0,0,0,0,0,1,0], stype: :dense, dtype: :int64)
+    expect(inversed).to eq(d)
+
+    e = NMatrix.new(2, [3,1,2,1], stype: :dense, dtype: :int64)
+    inversed = e.method(:__inverse_exact__).call(e.clone, 2, 2)
+    f = NMatrix.new(2, [1,-1,-2,3], stype: :dense, dtype: :int64)
+    expect(inversed).to eq(f)
+  end
+
+  it "calculates inverse exact determinants on small yale matrices" do
+    pending("not yet implemented for NMatrix-JRuby") if jruby?
+    a = NMatrix.new(3, [1,2,3,0,1,4,5,6,0], stype: :yale, dtype: :int64)
+    inversed = a.method(:__inverse_exact__).call(a.clone, 3, 3)
+    b = NMatrix.new(3, [-24,18,5,20,-15,-4,-5,4,1], stype: :yale, dtype: :int64)
+    expect(inversed).to eq(b)
+
+    c = NMatrix.new(3, [1,0,3,0,0,1,0,6,0], stype: :yale, dtype: :int64)
+    inversed = c.method(:__inverse_exact__).call(c.clone, 3, 3)
+    d = NMatrix.new(3, [1,-3,0,0,0,0,0,1,0], stype: :yale, dtype: :int64)
+    expect(inversed).to eq(d)
+
+    e = NMatrix.new(2, [3,1,2,1], stype: :yale, dtype: :int64)
+    inversed = e.method(:__inverse_exact__).call(e.clone, 2, 2)
+    f = NMatrix.new(2, [1,-1,-2,3], stype: :yale, dtype: :int64)
+    expect(inversed).to eq(f)
+  end
+
+  it "calculates inverse exact determinants on small list matrices" do
+    pending("not yet implemented for NMatrix-JRuby") if jruby?
+    a = NMatrix.new(3, [1,2,3,0,1,4,5,6,0], stype: :list, dtype: :int64)
+    inversed = a.method(:__inverse_exact__).call(a.clone, 3, 3)
+    b = NMatrix.new(3, [-24,18,5,20,-15,-4,-5,4,1], stype: :list, dtype: :int64)
+    expect(inversed).to eq(b)
+
+    c = NMatrix.new(2, [3,1,2,1], stype: :list, dtype: :int64)
+    inversed = c.method(:__inverse_exact__).call(c.clone, 2, 2)
+    d = NMatrix.new(2, [1,-1,-2,3], stype: :list, dtype: :int64)
+    expect(inversed).to eq(d)
   end
 
   it "calculates determinants" do
@@ -56,6 +119,7 @@ describe NMatrix do
   end
 
   it "allows casting from Ruby objects" do
+    pending("not yet implemented for NMatrix-JRuby") if jruby?
     m = NMatrix.new(:dense, [3,3], [0,0,1,0,2,0,3,4,5], :object)
     n = m.cast(:dense, :int64)
     expect(m).to eq(n)
@@ -78,6 +142,7 @@ describe NMatrix do
 
   it "fills dense Ruby object matrix with nil" do
     n = NMatrix.new([4,3], dtype: :object)
+    pending("not yet implemented for object dtype for NMatrix-JRuby") if jruby?
     expect(n[0,0]).to eq(nil)
   end
 
@@ -146,6 +211,7 @@ describe NMatrix do
 
   it "dense handles missing initialization value" do
     n = NMatrix.new(3, dtype: :int8)
+    pending("not yet implemented for int dtype for NMatrix-JRuby") if jruby?
     expect(n.stype).to eq(:dense)
     expect(n.dtype).to eq(:int8)
 
@@ -158,6 +224,8 @@ describe NMatrix do
     context storage_type do
     it "can be duplicated" do
         n = NMatrix.new([2,3], 1.1, stype: storage_type, dtype: :float64)
+        # FIXME
+        pending("not yet implemented for sparse matrices for NMatrix-JRuby") if jruby? #and storage_type != :dense
         expect(n.stype).to eq(storage_type)
 
         n[0,0] = 0.0
@@ -223,6 +291,7 @@ describe NMatrix do
           end
 
           it "allows storage-based iteration of matrices" do
+            pending("not yet implemented for sparse matrices for NMatrix-JRuby") if jruby? and storage_type != :dense
             STDERR.puts storage_type.inspect
             STDERR.puts dtype.inspect
             n = NMatrix.new([3,3], 0, stype: storage_type, dtype: dtype)
@@ -263,6 +332,7 @@ describe NMatrix do
     # dense and list, not yale
     context "(storage: #{storage_type})" do
       it "gets default value" do
+        pending("not yet implemented for sparse matrices for NMatrix-JRuby") if jruby?
         expect(NMatrix.new(3, 0, stype: storage_type)[1,1]).to eq(0)
         expect(NMatrix.new(3, 0.1, stype: storage_type)[1,1]).to eq(0.1)
         expect(NMatrix.new(3, 1, stype: storage_type)[1,1]).to eq(1)
@@ -321,12 +391,16 @@ describe NMatrix do
 
   context "dense" do
     it "should return the matrix being iterated over when each is called with a block" do
+      # FIXME
+      pending("not yet implemented for NMatrix-JRuby") if jruby?
       a = NMatrix.new(2, 1)
       val = (a.each { })
       expect(val).to eq(a)
     end
 
     it "should return the matrix being iterated over when each_stored_with_indices is called with a block" do
+      # FIXME
+      pending("not yet implemented for NMatrix-JRuby") if jruby?
       a = NMatrix.new(2,1)
       val = (a.each_stored_with_indices { })
       expect(val).to eq(a)
@@ -336,12 +410,14 @@ describe NMatrix do
   [:list, :yale].each do |storage_type|
     context storage_type do
       it "should return the matrix being iterated over when each_stored_with_indices is called with a block" do
+        pending("not yet implemented for Complex dtype for NMatrix-JRuby") if jruby?
         n = NMatrix.new([2,3], 1.1, stype: storage_type, dtype: :float64, default: 0)
         val = (n.each_stored_with_indices { })
         expect(val).to eq(n)
       end
 
       it "should return an enumerator when each_stored_with_indices is called without a block" do
+        pending("not yet implemented for Complex dtype for NMatrix-JRuby") if jruby?
         n = NMatrix.new([2,3], 1.1, stype: storage_type, dtype: :float64, default: 0)
         val = n.each_stored_with_indices
         expect(val).to be_a Enumerator
@@ -405,11 +481,15 @@ describe 'NMatrix' do
 
   context "#reshape" do
     it "should change the shape of a matrix without the contents changing" do
+      # FIXME
+      pending("not yet implemented for NMatrix-JRuby") if jruby?
       n = NMatrix.seq(4)+1
       expect(n.reshape([8,2]).to_flat_array).to eq(n.to_flat_array)
     end
 
     it "should permit a change of dimensionality" do
+      # FIXME
+      pending("not yet implemented for NMatrix-JRuby") if jruby?
       n = NMatrix.seq(4)+1
       expect(n.reshape([8,1,2]).to_flat_array).to eq(n.to_flat_array)
     end
@@ -425,6 +505,8 @@ describe 'NMatrix' do
     end
 
     it "should do the reshape operation in place, changing dimension" do
+      # FIXME
+      pending("not yet implemented for NMatrix-JRuby") if jruby?
       n = NMatrix.seq(4)
       a = n.reshape!([4,2,2])
       expect(n).to eq(NMatrix.seq([4,2,2]))
@@ -432,6 +514,8 @@ describe 'NMatrix' do
     end
 
     it "reshape and reshape! must produce same result" do
+      # FIXME
+      pending("not yet implemented for NMatrix-JRuby") if jruby?
       n = NMatrix.seq(4)+1
       a = NMatrix.seq(4)+1
       expect(n.reshape!([8,2])==a.reshape(8,2)).to eq(true) # because n itself changes
@@ -481,6 +565,8 @@ describe 'NMatrix' do
     [:dense].each do |stype| # list storage transpose not yet implemented
       context(stype) do # yale support only 2-dim matrix
         it "should work like vector product on a #{stype} (1-dimensional)" do
+          # FIXME
+          pending("not yet implemented for NMatrix-JRuby") if jruby?
           m = NMatrix.new([3], [1,2,3], stype: stype)
           expect(m.dot(m)).to eq (NMatrix.new([1],[14]))
         end
@@ -538,6 +624,8 @@ describe 'NMatrix' do
     end
 
     it "should permit depth concatenation on tensors" do
+      # FIXME
+      pending("not yet implemented for NMatrix-JRuby") if jruby?
       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
@@ -548,6 +636,8 @@ describe 'NMatrix' do
       m = N[[7],
             [8]]
 
+      # FIXME
+      pending("not yet implemented for NMatrix-JRuby") if jruby?
       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
@@ -558,6 +648,8 @@ describe 'NMatrix' do
 
       m = N[[7, 8, 9]]
 
+      # FIXME
+      pending("not yet implemented for NMatrix-JRuby") if jruby?
       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
@@ -582,6 +674,7 @@ describe 'NMatrix' do
       context(stype) do
         it "should work in-place for complex dtypes" do
           pending("not yet implemented for list stype") if stype == :list
+          pending("not yet implemented for Complex dtype for NMatrix-JRuby") if jruby?
           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))
@@ -590,6 +683,7 @@ describe 'NMatrix' do
         [: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
+            pending("not yet implemented for Complex dtype for NMatrix-JRuby") if jruby?
             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))
@@ -604,6 +698,7 @@ describe 'NMatrix' do
       context(stype) do
         it "should work out-of-place for complex dtypes" do
           pending("not yet implemented for list stype") if stype == :list
+          pending("not yet implemented for Complex dtype for NMatrix-JRuby") if jruby?
           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
@@ -611,6 +706,7 @@ describe 'NMatrix' do
         [: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
+            pending("not yet implemented for Complex dtype for NMatrix-JRuby") if jruby?
             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
@@ -677,7 +773,7 @@ describe 'NMatrix' do
 
   context "#diagonal" do
     ALL_DTYPES.each do |dtype|
-      before do 
+      before do
         @square_matrix =  NMatrix.new([3,3], [
           23,11,23,
           44, 2, 0,
@@ -723,11 +819,14 @@ describe 'NMatrix' do
     end
 
     it "returns repeated matrix" do
+      pending("Not yet implemented for NMatrix JRuby") if jruby?
       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
+      # FIXME
+      pending("not yet implemented for NMatrix-JRuby") if jruby?
       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
@@ -742,42 +841,50 @@ describe 'NMatrix' do
       @expected_for_ij = [NMatrix.new([3, 2], [1, 1, 2, 2, 3, 3]), NMatrix.new([3, 2], [4, 5, 4, 5, 4, 5])]
       @expected_for_sparse = [NMatrix.new([1, 3], [1, 2, 3]), NMatrix.new([2, 1], [4, 5])]
       @expected_for_sparse_ij = [NMatrix.new([3, 1], [1, 2, 3]), NMatrix.new([1, 2], [4, 5])]
+      # FIXME
       @expected_3dim = [NMatrix.new([1, 3, 1], [1, 2, 3]).repeat(2, 0).repeat(2, 2),
                         NMatrix.new([2, 1, 1], [4, 5]).repeat(3, 1).repeat(2, 2),
-                        NMatrix.new([1, 1, 2], [6, 7]).repeat(2, 0).repeat(3, 1)]
+                        NMatrix.new([1, 1, 2], [6, 7]).repeat(2, 0).repeat(3, 1)] unless jruby?
       @expected_3dim_sparse_ij = [NMatrix.new([3, 1, 1], [1, 2, 3]),
                                   NMatrix.new([1, 2, 1], [4, 5]),
                                   NMatrix.new([1, 1, 2], [6, 7])]
     end
 
     it "checks arrays count" do
+      pending("Not yet implemented for NMatrix JRuby") if jruby?
       expect{NMatrix.meshgrid([@x])}.to raise_error(ArgumentError)
       expect{NMatrix.meshgrid([])}.to raise_error(ArgumentError)
     end
 
     it "flattens input arrays before use" do
+      pending("Not yet implemented for NMatrix JRuby") if jruby?
       expect(NMatrix.meshgrid([@two_dim, @two_dim_array])).to eq(NMatrix.meshgrid([@two_dim.to_flat_array, @two_dim_array.flatten]))
     end
 
     it "returns new NMatrixes" do
+      pending("Not yet implemented for NMatrix JRuby") if jruby?
       expect(NMatrix.meshgrid([@x, @y])).to eq(@expected_result)
     end
 
     it "has option :sparse" do
+      pending("Not yet implemented for NMatrix JRuby") if jruby?
       expect(NMatrix.meshgrid([@x, @y], sparse: true)).to eq(@expected_for_sparse)
     end
 
     it "has option :indexing" do
+      pending("Not yet implemented for NMatrix JRuby") if jruby?
       expect(NMatrix.meshgrid([@x, @y], indexing: :ij)).to eq(@expected_for_ij)
       expect(NMatrix.meshgrid([@x, @y], indexing: :xy)).to eq(@expected_result)
       expect{NMatrix.meshgrid([@x, @y], indexing: :not_ij_not_xy)}.to raise_error(ArgumentError)
     end
 
     it "works well with both options set" do
+      pending("Not yet implemented for NMatrix JRuby") if jruby?
       expect(NMatrix.meshgrid([@x, @y], sparse: true, indexing: :ij)).to eq(@expected_for_sparse_ij)
     end
 
     it "is able to take more than two arrays as arguments and works well with options" do
+      pending("Not yet implemented for NMatrix JRuby") if jruby?
       expect(NMatrix.meshgrid([@x, @y, @z])).to eq(@expected_3dim)
       expect(NMatrix.meshgrid([@x, @y, @z], sparse: true, indexing: :ij)).to eq(@expected_3dim_sparse_ij)
     end

data/spec/01_enum_spec.rb

@@ -35,6 +35,7 @@ describe "NMatrix enumeration for" do
 
       if stype == :yale
         it "should iterate properly along each row of a slice" do
+          pending("not yet implemented for sparse matrices for NMatrix-JRuby") if jruby?
           vv = []
           ii = []
           jj = []
@@ -53,6 +54,7 @@ describe "NMatrix enumeration for" do
         end
 
         it "should iterate along diagonal portion of A array" do
+          pending("not yet implemented for sparse matrices for NMatrix-JRuby") if jruby?
           vv = []
           ii = []
           jj = []
@@ -67,6 +69,7 @@ describe "NMatrix enumeration for" do
         end
 
         it "should iterate along non-diagonal portion of A array" do
+          pending("not yet implemented for sparse matrices for NMatrix-JRuby") if jruby?
           vv = []
           ii = []
           jj = []
@@ -82,6 +85,7 @@ describe "NMatrix enumeration for" do
         end
 
         it "should iterate along a sliced diagonal portion of an A array" do
+          pending("not yet implemented for sparse matrices for NMatrix-JRuby") if jruby?
           m = n[0..3,1..3]
           vv = []
           ii = []
@@ -97,6 +101,7 @@ describe "NMatrix enumeration for" do
         end
 
         it "should iterate along a sliced non-diagonal portion of a sliced A array" do
+          pending("not yet implemented for sparse matrices for NMatrix-JRuby") if jruby?
           vv = []
           ii = []
           jj = []
@@ -114,6 +119,7 @@ describe "NMatrix enumeration for" do
         end
 
         it "should visit each stored element of the matrix in order by indices" do
+          pending("not yet implemented for sparse matrices for NMatrix-JRuby") if jruby?
           vv = []
           ii = []
           jj = []
@@ -129,7 +135,7 @@ describe "NMatrix enumeration for" do
         end
 
         it "should visit each stored element of the slice in order by indices" do
-
+          pending("not yet implemented for sparse matrices for NMatrix-JRuby") if jruby?
           vv = []
           ii = []
           jj = []

data/spec/02_slice_spec.rb

@@ -44,6 +44,8 @@ describe "Slice operation" do
 
       if stype == :yale
         it "should binary search for the left boundary of a partial row of stored indices correctly" do
+          #FIXME
+          pending("not yet implemented for sparse matrices for NMatrix-JRuby") if jruby?
           n = NMatrix.new(10, stype: :yale, dtype: :int32)
           n[3,0] = 1
           #n[3,2] = 2
@@ -87,7 +89,8 @@ describe "Slice operation" do
 
       unless stype == :dense
         it "should iterate across a row of stored indices" do
-
+          #FIXME
+          pending("not yet implemented for sparse matrices for NMatrix-JRuby") if jruby?
           vs = []
           is = []
           js = []
@@ -102,6 +105,8 @@ describe "Slice operation" do
         end
 
         it "should iterate across a submatrix of stored indices" do
+          #FIXME
+          pending("not yet implemented for sparse matrices for NMatrix-JRuby") if jruby?
           vs = []
           is = []
           js = []
@@ -118,6 +123,7 @@ describe "Slice operation" do
       end
 
       it "should return correct supershape" do
+        pending("not yet implemented for sparse matrices for NMatrix-JRuby") if jruby?
         x = NMatrix.random([10,12])
         y = x[0...8,5...12]
         expect(y.shape).to eq([8,7])
@@ -125,6 +131,7 @@ describe "Slice operation" do
       end
 
       it "should have #is_ref? method" do
+        pending("not yet implemented for sparse matrices for NMatrix-JRuby") if jruby?
         a = stype_matrix[0..1, 0..1]
         b = stype_matrix.slice(0..1, 0..1)
         expect(stype_matrix.is_ref?).to be false
@@ -145,6 +152,7 @@ describe "Slice operation" do
         end
 
         it 'should return a copy of 2x2 matrix to self elements' do
+          pending("not yet implemented for sparse matrices for NMatrix-JRuby") if jruby?
           n = stype_matrix.slice(1..2,0..1)
           expect(n.shape).to eql([2,2])
 
@@ -154,6 +162,8 @@ describe "Slice operation" do
         end
 
         it 'should return a 1x2 matrix without refs to self elements' do
+          #FIXME
+          pending("not yet implemented for sparse matrices for NMatrix-JRuby") if jruby?
           n = stype_matrix.slice(0,1..2)
           expect(n.shape).to eql([1,2])
 
@@ -165,6 +175,7 @@ describe "Slice operation" do
         end
 
         it 'should return a 2x1 matrix without refs to self elements' do
+          pending("not yet implemented for sparse matrices for NMatrix-JRuby") if jruby?
           stype_matrix.extend NMatrix::YaleFunctions
 
           n = stype_matrix.slice(0..1,1)
@@ -218,6 +229,8 @@ describe "Slice operation" do
         end
 
         it 'should return a 2x2 matrix with refs to self elements' do
+          #FIXME
+          pending("not yet implemented for sparse matrices for NMatrix-JRuby") if jruby? # and :cast_type != :dense
           n = stype_matrix[1..2,0..1]
           expect(n.shape).to eql([2,2])
 
@@ -227,6 +240,8 @@ describe "Slice operation" do
         end
 
         it 'should return a 1x2 vector with refs to self elements' do
+          #FIXME
+          pending("not yet implemented for sparse matrices for NMatrix-JRuby") if jruby? # and :cast_type != :dense
           n = stype_matrix[0,1..2]
           expect(n.shape).to eql([1,2])
 
@@ -236,6 +251,7 @@ describe "Slice operation" do
         end
 
         it 'should return a 2x1 vector with refs to self elements' do
+          pending("not yet implemented for sparse matrices for NMatrix-JRuby") if jruby?
           n = stype_matrix[0..1,1]
           expect(n.shape).to eql([2,1])
 
@@ -320,6 +336,8 @@ describe "Slice operation" do
             end
 
             it "compares slices to scalars" do
+              #FIXME
+              pending("not yet implemented for sparse matrices for NMatrix-JRuby") if jruby?
               (stype_matrix[1, 0..2] > 2).each { |e| expect(e != 0).to be true }
             end