nmatrix 0.2.3 → 0.2.4

data/lib/nmatrix/mkmf.rb

@@ -91,13 +91,10 @@ $CFLAGS += " -O3 "
 $CXXFLAGS += " -O3 -std=#{$CXX_STANDARD} " #-fmax-errors=10 -save-temps
 #$CXXFLAGS += " -static -O0 -g -std=#{$CXX_STANDARD} "
 
-CONFIG['warnflags'].gsub!('-Wshorten-64-to-32', '') # doesn't work except in Mac-patched gcc (4.2)
-CONFIG['warnflags'].gsub!('-Wdeclaration-after-statement', '')
-CONFIG['warnflags'].gsub!('-Wimplicit-function-declaration', '')
-
+if CONFIG.has_key?('warnflags')
+  CONFIG['warnflags'].gsub!('-Wshorten-64-to-32', '') # doesn't work except in Mac-patched gcc (4.2)
+  CONFIG['warnflags'].gsub!('-Wdeclaration-after-statement', '')
+  CONFIG['warnflags'].gsub!('-Wimplicit-function-declaration', '')
+end
+  
 have_func("rb_array_const_ptr", "ruby.h")
-have_macro("FIX_CONST_VALUE_PTR", "ruby.h")
-have_macro("RARRAY_CONST_PTR", "ruby.h")
-have_macro("RARRAY_AREF", "ruby.h")
-
-

data/lib/nmatrix/monkeys.rb

@@ -26,8 +26,6 @@
 # Ruby core extensions for NMatrix.
 #++
 
-require 'nmatrix/math'
-
 #######################
 # Classes and Modules #
 #######################
@@ -38,9 +36,9 @@ class Array
   # You must provide a shape for the matrix as the first argument.
   #
   # == Arguments:
-  # <tt>shape</tt> :: Array describing matrix dimensions (or Fixnum for square). 
+  # <tt>shape</tt> :: Array describing matrix dimensions (or Fixnum for square).
   #   If not provided, will be intuited through #shape.
-  # <tt>dtype</tt> :: Override data type (e.g., to store a Float as :float32 
+  # <tt>dtype</tt> :: Override data type (e.g., to store a Float as :float32
   #   instead of :float64) -- optional.
   # <tt>stype</tt> :: Optional storage type (defaults to :dense)
   def to_nm(shape = nil, dtype = nil, stype = :dense)

data/lib/nmatrix/nmatrix.rb

@@ -30,21 +30,32 @@
 #++
 
 # For some reason nmatrix.so ends up in a different place during gem build.
-if File.exist?("lib/nmatrix/nmatrix.so") #|| File.exist?("lib/nmatrix/nmatrix.bundle")
-  # Development
-  require "nmatrix/nmatrix.so"
-else
-  # Gem
-  require "nmatrix.so"
+
+# Detect java
+def jruby?
+  /java/ === RUBY_PLATFORM
 end
 
-require_relative './io/mat_reader'
-require_relative './io/mat5_reader'
-require_relative './io/market'
-require_relative './io/point_cloud'
+if jruby?
+  require_relative 'jruby/nmatrix_java'
+else
+  if File.exist?("lib/nmatrix/nmatrix.so") #|| File.exist?("lib/nmatrix/nmatrix.bundle")
+    # Development
+    require_relative "nmatrix/nmatrix.so"
+  else
+    # Gem
+    require_relative "../nmatrix.so"
+    require_relative './io/mat_reader'
+    require_relative './io/mat5_reader'
+    require_relative './io/market'
+    require_relative './io/point_cloud'
+
+    require_relative './lapack_core.rb'
+    require_relative './yale_functions.rb'
+  end
+end
 
-require_relative './lapack_core.rb'
-require_relative './yale_functions.rb'
+require_relative './math.rb'
 require_relative './monkeys'
 
 # NMatrix is a matrix class that supports both multidimensional arrays
@@ -86,7 +97,7 @@ class NMatrix
     # * *Returns* :
     #   - A Mat5Reader object.
     def load_matlab_file(file_path)
-      NMatrix::IO::Mat5Reader.new(File.open(file_path, 'rb')).to_ruby
+      NMatrix::IO::Matlab::Mat5Reader.new(File.open(file_path, 'rb')).to_ruby
     end
 
     # call-seq:
@@ -189,12 +200,14 @@ class NMatrix
           end
         end
       else # dim 2
-        q.group(0, "\n[\n", "]") do
-          self.each_row.with_index do |row,i|
-            q.group(1, "  [", "]") do
-              q.seplist(self.dim > 2 ? row.to_a[0] : row.to_a, lambda { q.text ", " }, :each_with_index) { |v,j| q.text v.inspect.rjust(longest[j]) }
+        q.group(0, "\n[\n ", "]") do
+          self.each_row.with_index do |row, i|
+            q.group(1, " [", "]\n") do
+              q.seplist(row.to_a, -> { q.text ", " }, :each_with_index) do |v,j|
+                q.text v.inspect.rjust(longest[j])
+              end
             end
-            q.breakable
+            q.breakable unless i + 1 == self.shape[0]
           end
         end
       end
@@ -269,14 +282,14 @@ class NMatrix
   end
 
   # Return the main diagonal or antidiagonal a matrix. Only works with 2D matrices.
-  # 
+  #
   # == Arguments
-  # 
-  # * +main_diagonal+ - Defaults to true. If passed 'false', then will return the 
+  #
+  # * +main_diagonal+ - Defaults to true. If passed 'false', then will return the
   #   antidiagonal of the matrix.
-  # 
+  #
   # == References
-  # 
+  #
   # * http://en.wikipedia.org/wiki/Main_diagonal
   def diagonal main_diagonal=true
     diag_size = [cols, rows].min
@@ -367,9 +380,9 @@ class NMatrix
 
   ##
   # call-seq:
-  # 
+  #
   # object_dtype?() -> Boolean
-  # 
+  #
   # Checks if dtype is a ruby object
   def object_dtype?
     dtype == :object
@@ -645,7 +658,15 @@ class NMatrix
       t
     else
       # Call C versions of Yale and List transpose, which do their own copies
-      self.clone_transpose
+      if jruby?
+        nmatrix = NMatrix.new :copy
+        nmatrix.shape = [@shape[1],@shape[0]]
+        twoDMat = self.twoDMat.transpose
+        nmatrix.s = ArrayRealVector.new(ArrayGenerator.getArrayDouble(twoDMat.getData(), shape[1],shape[0]))
+        return nmatrix
+      else
+        self.clone_transpose
+      end
     end
   end
 
@@ -867,7 +888,17 @@ class NMatrix
   #   - A NMatrix representing the requested layer as a layer vector.
   #
   def layer(layer_number, get_by = :copy)
-    rank(2, layer_number, get_by)
+    layer = rank(2, layer_number, get_by)
+
+    if jruby?
+      nmatrix = NMatrix.new :copy
+      nmatrix.shape = layer.shape
+      nmatrix.s = layer.s
+      return nmatrix
+    else
+      layer
+    end
+
   end
 
 
@@ -976,9 +1007,9 @@ class NMatrix
     return self.map_stored.inject(sym)
   end
 
-  # Returns the index of the first occurence of the specified value. Returns 
+  # Returns the index of the first occurence of the specified value. Returns
   # an array containing the position of the value, nil in case the value is not found.
-  # 
+  #
   def index(value)
     index = nil
 
@@ -988,7 +1019,7 @@ class NMatrix
         index = yields
         break
       end
-    end 
+    end
 
     index
   end
@@ -1011,7 +1042,7 @@ class NMatrix
   #
   # call-seq:
   #     repeat(count, axis) -> NMatrix
-  # 
+  #
   # * *Arguments* :
   #   - +count+ -> how many times NMatrix should be repeated
   #   - +axis+ -> index of axis along which NMatrix should be repeated
@@ -1137,7 +1168,6 @@ protected
 end
 
 require_relative './shortcuts.rb'
-require_relative './math.rb'
 require_relative './enumerate.rb'
 
 require_relative './version.rb'

data/lib/nmatrix/shortcuts.rb

@@ -494,11 +494,11 @@ class NMatrix
         block_sizes << b.shape[0]
       end
 
-      block_diag_mat = NMatrix.zeros(block_sizes.sum, options)
+      block_diag_mat = NMatrix.zeros(block_sizes.inject(0,:+), options)
       (0...params.length).each do |n|
         # First determine the size and position of the n'th block in the block-diagonal matrix
         block_size = block_sizes[n]
-        block_pos = block_sizes[0...n].sum
+        block_pos = block_sizes[0...n].inject(0,:+)
         # populate the n'th block in the block-diagonal matrix
         (0...block_size).each do |i|
           (0...block_size).each do |j|
@@ -536,7 +536,12 @@ class NMatrix
     def random(shape, opts={})
       scale = opts.delete(:scale) || 1.0
 
-      rng = Random.new
+      if opts[:seed].nil?
+        rng = Random.new
+      else
+        rng = Random.new(opts[:seed])
+      end
+      
 
       random_values = []
 

data/lib/nmatrix/version.rb

@@ -29,7 +29,7 @@ class NMatrix
   module VERSION #:nodoc:
     MAJOR = 0
     MINOR = 2
-    TINY = 3
+    TINY = 4
     #PRE = "a"
 
     STRING = [MAJOR, MINOR, TINY].compact.join(".")

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