nmatrix 0.1.0 → 0.2.0

data/lib/nmatrix/monkeys.rb

@@ -44,13 +44,12 @@ class Array
   #   instead of :float64) -- optional.
   # <tt>stype</tt> :: Optional storage type (defaults to :dense)
   def to_nm(shape = nil, dtype = nil, stype = :dense)
-    elements = self
+    elements = self.dup
 
     guess_dtype = ->(type) {
       case type
       when Fixnum   then :int64
       when Float    then :float64
-      when Rational then :rational128
       when Complex  then :complex128
       end
     }
@@ -75,7 +74,7 @@ class Array
     }
 
     unless shape
-      shape = guess_shape.call(self)
+      shape = guess_shape.call(elements)
       elements.flatten!(shape.size - 1)
       if elements.flatten != elements
         dtype = :object

data/lib/nmatrix/nmatrix.rb

@@ -23,18 +23,33 @@
 #
 # == nmatrix.rb
 #
-# This file contains those core functionalities which can be
+# This file loads the C extension for NMatrix and all the ruby
+# files and contains those core functionalities which can be
 # implemented efficiently (or much more easily) in Ruby (e.g.,
 # inspect, pretty_print, element-wise operations).
 #++
 
-require_relative './lapack.rb'
+# 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"
+end
+
+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'
 require_relative './monkeys'
 
 # NMatrix is a matrix class that supports both multidimensional arrays
 # (`:dense` stype) and sparse storage (`:list` or `:yale` stypes) and 13 data
-# types, including complex and rational numbers, various integer and
+# types, including complex numbers, various integer and
 # floating-point sizes and ruby objects.
 class NMatrix
   # Read and write extensions for NMatrix.
@@ -90,6 +105,59 @@ class NMatrix
       shape = [shape,shape] unless shape.is_a?(Array)
       (0...shape.size).inject(1) { |x,i| x * shape[i] }
     end
+
+    # Make N-D coordinate arrays for vectorized evaluations of
+    # N-D scalar/vector fields over N-D grids, given N
+    # coordinate arrays arrs. N > 1.
+    #
+    # call-seq:
+    #     meshgrid(arrs) -> Array of NMatrix
+    #     meshgrid(arrs, options) -> Array of NMatrix
+    #
+    # * *Arguments* :
+    #   - +vectors+ -> Array of N coordinate arrays (Array or NMatrix), if any have more than one dimension they will be flatten
+    #   - +options+ -> Hash with options (:sparse Boolean, false by default; :indexing Symbol, may be :ij or :xy, :xy by default)
+    # * *Returns* :
+    #   - Array of N N-D NMatrixes
+    # * *Examples* :
+    #     x, y = NMatrix::meshgrid([[1, [2, 3]], [4, 5]])
+    #     x.to_a #<= [[1, 2, 3], [1, 2, 3]]
+    #     y.to_a #<= [[4, 4, 4], [5, 5, 5]]
+    #
+    # * *Using* *options* :
+    #
+    #     x, y = NMatrix::meshgrid([[[1, 2], 3], [4, 5]], sparse: true)
+    #     x.to_a #<= [[1, 2, 3]]
+    #     y.to_a #<= [[4], [5]]
+    #
+    #     x, y = NMatrix::meshgrid([[1, 2, 3], [[4], 5]], indexing: :ij)
+    #     x.to_a #<= [[1, 1], [2, 2], [3, 3]]
+    #     y.to_a #<= [[4, 5], [4, 5], [4, 5]]
+    def meshgrid(vectors, options = {})
+      raise(ArgumentError, 'Expected at least 2 arrays.') if vectors.size < 2
+      options[:indexing] ||= :xy
+      raise(ArgumentError, 'Indexing must be :xy of :ij') unless [:ij, :xy].include? options[:indexing]
+      mats = vectors.map { |arr| arr.respond_to?(:flatten) ? arr.flatten : arr.to_flat_array }
+      mats[0], mats[1] = mats[1], mats[0] if options[:indexing] == :xy
+      new_dim = mats.size
+      lengths = mats.map(&:size)
+      result = mats.map.with_index do |matrix, axis|
+        if options[:sparse]
+          new_shape = Array.new(new_dim, 1)
+          new_shape[axis] = lengths[axis]
+          new_elements = matrix
+        else
+          before_axis = lengths[0...axis].reduce(:*)
+          after_axis = lengths[(axis+1)..-1].reduce(:*)
+          new_shape = lengths
+          new_elements = after_axis ? matrix.map{ |el| [el] * after_axis }.flatten : matrix
+          new_elements *= before_axis if before_axis
+        end
+        NMatrix.new(new_shape, new_elements)
+      end
+      result[0], result[1] = result[1], result[0] if options[:indexing] == :xy
+      result
+    end
   end
 
   # TODO: Make this actually pretty.
@@ -153,7 +221,7 @@ class NMatrix
   # one. You can actually call this function with no arguments, in which case it functions like #clone.
   #
   # If your dtype is :object and you are converting from :dense to a sparse type, it is recommended that you
-  # provide a :default, as 0 may behave differently from its Float, Rational, or Complex equivalent. If no option
+  # provide a :default, as 0 may behave differently from its Float or Complex equivalent. If no option
   # is given, Fixnum 0 will be used.
   def cast(*params)
     if (params.size > 0 && params[0].is_a?(Hash))
@@ -200,6 +268,35 @@ class NMatrix
     shape[1]
   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 
+  #   antidiagonal of the matrix.
+  # 
+  # == References
+  # 
+  # * http://en.wikipedia.org/wiki/Main_diagonal
+  def diagonal main_diagonal=true
+    diag_size = [cols, rows].min
+    diag = NMatrix.new [diag_size], dtype: dtype
+
+    if main_diagonal
+      0.upto(diag_size-1) do |i|
+        diag[i] = self[i,i]
+      end
+    else
+      row = 0
+      (diag_size-1).downto(0) do |col|
+        diag[row] = self[row,col]
+        row += 1
+      end
+    end
+
+    diag
+  end
+
   #
   # call-seq:
   #     to_hash -> Hash
@@ -249,6 +346,15 @@ class NMatrix
     [:byte, :int8, :int16, :int32, :int64].include?(self.dtype)
   end
 
+  # call-seq:
+  #   float_dtype?() -> Boolean
+  #
+  # Checks if dtype is a floating point type
+  #
+  def float_dtype?
+    [:float32, :float64].include?(dtype)
+  end
+
   ##
   # call-seq:
   #   complex_dtype?() -> Boolean
@@ -261,12 +367,12 @@ class NMatrix
 
   ##
   # call-seq:
-  #   complex_dtype?() -> Boolean
-  #
-  # Checks if dtype is a rational type
-  #
-  def rational_dtype?
-    [:rational32, :rational64, :rational128].include?(self.dtype)
+  # 
+  # object_dtype?() -> Boolean
+  # 
+  # Checks if dtype is a ruby object
+  def object_dtype?
+    dtype == :object
   end
 
 
@@ -832,13 +938,13 @@ class NMatrix
   end
 
 
-  def respond_to?(method) #:nodoc:
+  def respond_to?(method, include_all = false) #:nodoc:
     if [:shuffle, :shuffle!, :each_with_index, :sorted_indices, :binned_sorted_indices, :nrm2, :asum].include?(method.intern) # vector-only methods
       return vector?
     elsif [:each_layer, :layer].include?(method.intern) # 3-or-more dimensions only
       return dim > 2
     else
-      super(method)
+      super
     end
   end
 
@@ -854,6 +960,22 @@ class NMatrix
     return self.map_stored.inject(sym)
   end
 
+  # 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
+
+    self.each_with_indices do |yields|
+      if yields.first == value
+        yields.shift
+        index = yields
+        break
+      end
+    end 
+
+    index
+  end
 
   #
   # call-seq:
@@ -870,6 +992,33 @@ class NMatrix
     NMatrix.new(self.shape, opts)
   end
 
+  #
+  # 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
+  # * *Returns* :
+  #   - NMatrix created by repeating the existing one along an axis
+  # * *Examples* :
+  #     m = NMatrix.new([2, 2], [1, 2, 3, 4])
+  #     m.repeat(2, 0).to_a #<= [[1, 2], [3, 4], [1, 2], [3, 4]]
+  #     m.repeat(2, 1).to_a #<= [[1, 2, 1, 2], [3, 4, 3, 4]]
+  def repeat(count, axis)
+    raise(ArgumentError, 'Matrix should be repeated at least 2 times.') if count < 2
+    new_shape = shape
+    new_shape[axis] *= count
+    new_matrix = NMatrix.new(new_shape)
+    slice = new_shape.map { |axis_size| 0...axis_size }
+    start = 0
+    count.times do
+      slice[axis] = start...(start += shape[axis])
+      new_matrix[*slice] = self
+    end
+    new_matrix
+  end
+
   # This is how you write an individual element-wise operation function:
   #def __list_elementwise_add__ rhs
   #  self.__list_map_merged_stored__(rhs){ |l,r| l+r }.cast(self.stype, NMatrix.upcast(self.dtype, rhs.dtype))
@@ -928,7 +1077,8 @@ protected
   end
 
 
-  # Function assumes the dimensions and such have already been tested.
+  # This function assumes that the shapes of the two matrices have already
+  # been tested and are the same.
   #
   # Called from inside NMatrix: nm_eqeq
   #
@@ -973,3 +1123,6 @@ end
 require_relative './shortcuts.rb'
 require_relative './math.rb'
 require_relative './enumerate.rb'
+
+require_relative './version.rb'
+require_relative './blas.rb'

data/lib/nmatrix/shortcuts.rb

@@ -59,7 +59,6 @@ class NMatrix
     #
     # The default value for +dtype+ is guessed from the first parameter. For example:
     #   NMatrix[1.0, 2.0].dtype # => :float64
-    #   NMatrix[1r, 2r].dtype   # => :rational64
     #
     # But this is just a *guess*. If the other values can't be converted to
     # this dtype, a +TypeError+ will be raised.
@@ -275,6 +274,76 @@ class NMatrix
     alias :diag :diagonal
     alias :diagonals :diagonal
 
+    # Generate a block-diagonal NMatrix from the supplied 2D square matrices.
+    #
+    # * *Arguments*
+    #   - +*params+ -> An array that collects all arguments passed to the method. The method
+    #                  can receive any number of arguments. Optionally, the last entry of +params+ is 
+    #                  a hash of options from NMatrix#initialize. All other entries of +params+ are 
+    #                  the blocks of the desired block-diagonal matrix. Each such matrix block can be 
+    #                  supplied as a square 2D NMatrix object, or alternatively as an array of arrays 
+    #                  (with dimensions corresponding to a square matrix), or alternatively as a number.
+    # * *Returns*
+    #   - NMatrix of block-diagonal form filled with specified matrices
+    #     as the blocks along the diagonal.
+    #
+    # * *Example* 
+    #
+    #  a = NMatrix.new([2,2], [1,2,3,4])
+    #  b = NMatrix.new([1,1], [123], dtype: :float64)
+    #  c = Array.new(2) { [[10,10], [10,10]] }
+    #  d = Array[[1,2,3], [4,5,6], [7,8,9]]
+    #  m = NMatrix.block_diagonal(a, b, *c, d, 10.0, 11, dtype: :int64, stype: :yale)
+    #        => 
+    #        [
+    #          [1, 2,   0,  0,  0,  0,  0, 0, 0, 0,  0,  0]
+    #          [3, 4,   0,  0,  0,  0,  0, 0, 0, 0,  0,  0]
+    #          [0, 0, 123,  0,  0,  0,  0, 0, 0, 0,  0,  0]
+    #          [0, 0,   0, 10, 10,  0,  0, 0, 0, 0,  0,  0]
+    #          [0, 0,   0, 10, 10,  0,  0, 0, 0, 0,  0,  0]
+    #          [0, 0,   0,  0,  0, 10, 10, 0, 0, 0,  0,  0]
+    #          [0, 0,   0,  0,  0, 10, 10, 0, 0, 0,  0,  0]
+    #          [0, 0,   0,  0,  0,  0,  0, 1, 2, 3,  0,  0]
+    #          [0, 0,   0,  0,  0,  0,  0, 4, 5, 6,  0,  0]
+    #          [0, 0,   0,  0,  0,  0,  0, 7, 8, 9,  0,  0]
+    #          [0, 0,   0,  0,  0,  0,  0, 0, 0, 0, 10,  0]
+    #          [0, 0,   0,  0,  0,  0,  0, 0, 0, 0,  0, 11]
+    #        ]
+    #
+    def block_diagonal(*params)
+      options = params.last.is_a?(Hash) ? params.pop : {}
+
+      params.each_index do |i|
+        params[i] = params[i].to_nm if params[i].is_a?(Array) # Convert Array to NMatrix
+        params[i] = NMatrix.new([1,1], [params[i]]) if params[i].is_a?(Numeric) # Convert number to NMatrix
+      end
+
+      block_sizes = [] #holds the size of each matrix block
+      params.each do |b|
+        unless b.is_a?(NMatrix)
+          raise(ArgumentError, "Only NMatrix or appropriate Array objects or single numbers allowed")
+        end
+        raise(ArgumentError, "Only 2D matrices or 2D arrays allowed") unless b.shape.size == 2
+        raise(ArgumentError, "Only square-shaped blocks allowed") unless b.shape[0] == b.shape[1]
+        block_sizes << b.shape[0]
+      end
+
+      block_diag_mat = NMatrix.zeros(block_sizes.sum, 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
+        # populate the n'th block in the block-diagonal matrix
+        (0...block_size).each do |i|
+          (0...block_size).each do |j|
+            block_diag_mat[block_pos+i,block_pos+j] = params[n][i,j]
+          end
+        end
+      end
+
+      return block_diag_mat
+    end
+    alias :block_diag :block_diagonal
 
     #
     # call-seq:
@@ -284,8 +353,7 @@ class NMatrix
     # by +Random::rand+. The parameter is the dimension of the matrix.
     #
     # If you use an integer dtype, make sure to specify :scale as a parameter, or you'll
-    # only get a matrix of 0s. You may not currently generate random numbers for
-    # a rational matrix.
+    # only get a matrix of 0s.
     #
     # * *Arguments* :
     #   - +shape+ -> Array (or integer for square matrix) specifying the dimensions.
@@ -302,8 +370,6 @@ class NMatrix
     def random(shape, opts={})
       scale = opts.delete(:scale) || 1.0
 
-      raise(NotImplementedError, "does not support rational random number generation") if opts[:dtype].to_s =~ /^rational/
-
       rng = Random.new
 
       random_values = []
@@ -330,7 +396,6 @@ class NMatrix
     #     dindgen(shape) -> NMatrix of :float64
     #     cindgen(shape) -> NMatrix of :complex64
     #     zindgen(shape) -> NMatrix of :complex128
-    #     rindgen(shape) -> NMatrix of :rational128
     #     rbindgen(shape) -> NMatrix of :object
     #
     # Creates a matrix filled with a sequence of integers starting at zero.
@@ -361,7 +426,7 @@ class NMatrix
 
     {:bindgen => :byte, :indgen => :int64, :findgen => :float32, :dindgen => :float64,
      :cindgen => :complex64, :zindgen => :complex128,
-     :rindgen => :rational128, :rbindgen => :object}.each_pair do |meth, dtype|
+     :rbindgen => :object}.each_pair do |meth, dtype|
       define_method(meth) { |shape| NMatrix.seq(shape, :dtype => dtype) }
     end
   end

data/lib/nmatrix/version.rb

@@ -28,9 +28,9 @@ class NMatrix
   # IO can still understand NMatrix::VERSION.
   module VERSION #:nodoc:
     MAJOR = 0
-    MINOR = 1
+    MINOR = 2
     TINY = 0
-    # PRE = "rc5"
+    #PRE = "a"
 
     STRING = [MAJOR, MINOR, TINY].compact.join(".")
     #STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")

data/spec/00_nmatrix_spec.rb

@@ -478,13 +478,36 @@ describe 'NMatrix' do
   context "#==" do
     [:dense, :list, :yale].each do |left|
       [:dense, :list, :yale].each do |right|
-        next if left == right
         context ("#{left}?#{right}") do
-          it "should compare two matrices of differing stypes" do
-            n = NMatrix.new([3,4], [0,0,1,2,0,0,3,4,0,0,0,0,5,6,7,0], stype: left)
-            m = NMatrix.new([3,4], [0,0,1,2,0,0,3,4,0,0,0,0,5,6,7,0], stype: right)
-            expect(n).to eq(m)
+          it "tests equality of two equal matrices" do
+            n = NMatrix.new([3,4], [0,0,1,2,0,0,3,4,0,0,0,0], stype: left)
+            m = NMatrix.new([3,4], [0,0,1,2,0,0,3,4,0,0,0,0], stype: right)
+
+            expect(n==m).to eq(true)
+          end
+
+          it "tests equality of two unequal matrices" do
+            n = NMatrix.new([3,4], [0,0,1,2,0,0,3,4,0,0,0,1], stype: left)
+            m = NMatrix.new([3,4], [0,0,1,2,0,0,3,4,0,0,0,0], stype: right)
+
+            expect(n==m).to eq(false)
+          end
+
+          it "tests equality of matrices with different shapes" do
+            n = NMatrix.new([2,2], [1,2, 3,4], stype: left)
+            m = NMatrix.new([2,3], [1,2, 3,4, 5,6], stype: right)
+            x = NMatrix.new([1,4], [1,2, 3,4], stype: right)
+
+            expect{n==m}.to raise_error(ShapeError)
+            expect{n==x}.to raise_error(ShapeError)
           end
+
+          it "tests equality of matrices with different dimension" do
+            n = NMatrix.new([2,1], [1,2], stype: left)
+            m = NMatrix.new([2], [1,2], stype: right)
+
+            expect{n==m}.to raise_error(ShapeError)
+          end if left != :yale && right != :yale # yale must have dimension 2
         end
       end
     end
@@ -578,4 +601,130 @@ describe 'NMatrix' do
     end
   end
 
+  context "#index" do
+    it "returns index of first occurence of an element for a vector" do
+      n = NMatrix.new([5], [0,22,22,11,11])
+
+      expect(n.index(22)).to eq([1])
+    end
+
+    it "returns index of first occurence of an element for 2-D matrix" do
+      n = NMatrix.new([3,3], [23,11,23,
+                              44, 2, 0,
+                              33, 0, 32])
+
+      expect(n.index(0)).to eq([1,2])
+    end
+
+    it "returns index of first occerence of an element for N-D matrix" do
+      n = NMatrix.new([3,3,3], [23,11,23, 44, 2, 0, 33, 0, 32,
+                                23,11,23, 44, 2, 0, 33, 0, 32,
+                                23,11,23, 44, 2, 0, 33, 0, 32])
+
+      expect(n.index(44)).to eq([0,1,0])
+    end
+  end
+
+  context "#diagonal" do
+    ALL_DTYPES.each do |dtype|
+      before do 
+        @square_matrix =  NMatrix.new([3,3], [
+          23,11,23,
+          44, 2, 0,
+          33, 0, 32
+          ], dtype: dtype
+        )
+
+        @rect_matrix = NMatrix.new([4,3], [
+          23,11,23,
+          44, 2, 0,
+          33, 0,32,
+          11,22,33
+          ], dtype: dtype
+        )
+      end
+
+      it "returns main diagonal for square matrix" do
+        expect(@square_matrix.diagonal).to eq(NMatrix.new [3], [23,2,32])
+      end
+
+      it "returns main diagonal for rectangular matrix" do
+        expect(@rect_matrix.diagonal).to eq(NMatrix.new [3], [23,2,32])
+      end
+
+      it "returns anti-diagonal for square matrix" do
+        expect(@square_matrix.diagonal(false)).to eq(NMatrix.new [3], [23,2,33])
+      end
+
+      it "returns anti-diagonal for rectangular matrix" do
+        expect(@square_matrix.diagonal(false)).to eq(NMatrix.new [3], [23,2,33])
+      end
+    end
+  end
+
+  context "#repeat" do
+    before do
+      @sample_matrix = NMatrix.new([2, 2], [1, 2, 3, 4])
+    end
+
+    it "checks count argument" do
+      expect{@sample_matrix.repeat(1, 0)}.to raise_error(ArgumentError)
+      expect{@sample_matrix.repeat(-2, 0)}.to raise_error(ArgumentError)
+    end
+
+    it "returns repeated matrix" do
+      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
+  end
+
+  context "#meshgrid" do
+    before do
+      @x, @y, @z = [1, 2, 3], NMatrix.new([2, 1], [4, 5]), [6, 7]
+      @two_dim = NMatrix.new([2, 2], [1, 2, 3, 4])
+      @two_dim_array = [[4], [5]]
+      @expected_result = [NMatrix.new([2, 3], [1, 2, 3, 1, 2, 3]), NMatrix.new([2, 3], [4, 4, 4, 5, 5, 5])]
+      @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])]
+      @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)]
+      @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
+      expect{NMatrix.meshgrid([@x])}.to raise_error(ArgumentError)
+      expect{NMatrix.meshgrid([])}.to raise_error(ArgumentError)
+    end
+
+    it "flattens input arrays before use" do
+      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
+      expect(NMatrix.meshgrid([@x, @y])).to eq(@expected_result)
+    end
+
+    it "has option :sparse" do
+      expect(NMatrix.meshgrid([@x, @y], sparse: true)).to eq(@expected_for_sparse)
+    end
+
+    it "has option :indexing" do
+      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
+      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
+      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
+  end
 end