nmatrix 0.0.8 → 0.0.9

data/spec/{slice_spec.rb → 02_slice_spec.rb}

@@ -20,23 +20,34 @@
 #
 # * https://github.com/SciRuby/sciruby/wiki/Contributor-Agreement
 #
-# == slice_spec.rb
+# == 02_slice_spec.rb
 #
-# Test of slice operations.
+# Test of slice operations. High priority tests since reference
+# slicing is needed for pretty_print.
 #
+require 'pry'
 require File.dirname(__FILE__) + "/spec_helper.rb"
 
 describe "Slice operation" do
+  include RSpec::Longrun::DSL
 
   [:dense, :list, :yale].each do |stype|
     context "for #{stype}" do
       before :each do
+        GC.start # don't have to do this, but it helps to make sure we've cleaned up our pointers properly.
         @m = create_matrix(stype)
       end
 
+      it "should correctly return a row of a reference-slice" do
+        @n = create_rectangular_matrix(stype)
+        @m = @n[1..4,1..3]
+        @m.row(1, :copy).should == @m.row(1, :reference)
+        @m.row(1, :copy).to_flat_array.should == [12,13,0]
+      end
+
       if stype == :yale
         it "should binary search for the left boundary of a partial row of stored indices correctly" do
-          n = NMatrix.new(:yale, 10, :int32)
+          n = NMatrix.new(10, stype: :yale, dtype: :int32)
           n[3,0] = 1
           #n[3,2] = 2
           n[3,3] = 3
@@ -47,6 +58,7 @@ describe "Slice operation" do
           vs = []
           is = []
           js = []
+
           n[3,1..9].each_stored_with_indices do |v,i,j|
             vs << v
             is << i
@@ -108,27 +120,16 @@ describe "Slice operation" do
         end
       end
 
-      it "should return correct shape and 1st-order supershape" do
+      it "should return correct supershape" do
         x = NMatrix.random([10,12])
         y = x[0...8,5...12]
         y.shape.should == [8,7]
         y.supershape.should == [10,12]
       end
 
-      it "should return correct 1st- and 2nd-order supershape" do
-        pending "Not yet sure if we ever want to enable reference slices of reference slices"
-        x = NMatrix.random([10,12])
-        y = x[0...8,5...12]
-        z = y[0...3,0...4]
-        z.supershape(2).should == y.supershape(1)
-        z.supershape(1).should == [8,7]
-      end
-
       it "should have #is_ref? method" do
         a = @m[0..1, 0..1]
         b = @m.slice(0..1, 0..1)
-
-
         @m.is_ref?.should be_false
         a.is_ref?.should be_true
         b.is_ref?.should be_false
@@ -143,7 +144,7 @@ describe "Slice operation" do
       context "with copying" do
         it 'should return an NMatrix' do
           n = @m.slice(0..1,0..1)
-          nm_eql(n, NMatrix.new([2,2], [0,1,3,4], :int32)).should be_true
+          nm_eql(n, NMatrix.new([2,2], [0,1,3,4], dtype: :int32)).should be_true
         end
 
         it 'should return a copy of 2x2 matrix to self elements' do
@@ -155,22 +156,28 @@ describe "Slice operation" do
           @m[2,1].should eql(7)
         end
 
-        it 'should return a 1x2 matrix with refs to self elements' do
+        it 'should return a 1x2 matrix without refs to self elements' do
           n = @m.slice(0,1..2)
           n.shape.should eql([1,2])
 
           n[0].should == @m[0,1]
+          n[1].should == @m[0,2]
           n[0] = -9
           @m[0,1].should eql(1)
+          @m[0,2].should eql(2)
         end
 
-        it 'should return a 2x1 matrix with refs to self elements' do
+        it 'should return a 2x1 matrix without refs to self elements' do
+          @m.extend NMatrix::YaleFunctions
+
           n = @m.slice(0..1,1)
           n.shape.should eql([2,1])
 
           n[0].should == @m[0,1]
+          n[1].should == @m[1,1]
           n[0] = -9
           @m[0,1].should eql(1)
+          @m[1,1].should eql(4)
         end
 
         it 'should be correct slice for range 0..2 and 0...3' do
@@ -178,7 +185,7 @@ describe "Slice operation" do
         end
 
         [:dense, :list, :yale].each do |cast_type|
-          it "should cast from #{stype.upcase} to #{cast_type.upcase}" do
+          it "should cast copied slice from #{stype.upcase} to #{cast_type.upcase}" do
             nm_eql(@m.slice(1..2, 1..2).cast(cast_type, :int32), @m.slice(1..2,1..2)).should be_true
             nm_eql(@m.slice(0..1, 1..2).cast(cast_type, :int32), @m.slice(0..1,1..2)).should be_true
             nm_eql(@m.slice(1..2, 0..1).cast(cast_type, :int32), @m.slice(1..2,0..1)).should be_true
@@ -186,6 +193,8 @@ describe "Slice operation" do
 
             # Non square
             nm_eql(@m.slice(0..2, 1..2).cast(cast_type, :int32), @m.slice(0..2,1..2)).should be_true
+            #require 'pry'
+            #binding.pry if cast_type == :yale
             nm_eql(@m.slice(1..2, 0..2).cast(cast_type, :int32), @m.slice(1..2,0..2)).should be_true
 
             # Full
@@ -208,7 +217,7 @@ describe "Slice operation" do
       context "by reference" do
         it 'should return an NMatrix' do
           n = @m[0..1,0..1]
-          nm_eql(n, NMatrix.new([2,2], [0,1,3,4], :int32)).should be_true
+          nm_eql(n, NMatrix.new([2,2], [0,1,3,4], dtype: :int32)).should be_true
         end
 
         it 'should return a 2x2 matrix with refs to self elements' do
@@ -240,7 +249,7 @@ describe "Slice operation" do
 
         it 'should slice again' do
           n = @m[1..2, 1..2]
-          nm_eql(n[1,0..1], NVector.new(2, [7,8], :int32).transpose).should be_true
+          nm_eql(n[1,0..1], NVector.new(2, [7,8], dtype: :int32).transpose).should be_true
         end
 
         it 'should be correct slice for range 0..2 and 0...3' do
@@ -276,8 +285,8 @@ describe "Slice operation" do
                          MATRIX32A_ARRAY
                        end
 
-                n = NMatrix.new([4,3], nary, left_dtype)[1..3,1..2]
-                m = NMatrix.new([3,2], mary, right_dtype)[1..2,0..1]
+                n = NMatrix.new([4,3], nary, dtype: left_dtype)[1..3,1..2]
+                m = NMatrix.new([3,2], mary, dtype: right_dtype)[1..2,0..1]
 
                 r = n.dot m
                 r.shape.should eql([3,2])
@@ -333,34 +342,41 @@ describe "Slice operation" do
 
         end
 
-        it 'should be cleaned up by garbage collector without errors'  do
-          1.times do
-            n = @m[1..2,0..1]
+        example 'should be cleaned up by garbage collector without errors'  do
+          step "reference slice" do
+            1.times do
+              n = @m[1..2,0..1]
+            end
+            GC.start
           end
-          GC.start
-          @m.should == NMatrix.new(:dense, [3,3], (0..9).to_a, :int32).cast(stype, :int32)
-          n = nil
-          1.times do
-            m = NMatrix.new(:dense, [2,2], [1,2,3,4]).cast(stype, :int32)
-            n = m[0..1,0..1]
+
+          step "reference slice of casted-copy" do
+            @m.should == NMatrix.new([3,3], (0..9).to_a, dtype: :int32).cast(stype, :int32)
+            n = nil
+            1.times do
+              m = NMatrix.new([2,2], [1,2,3,4]).cast(stype, :int32)
+              n = m[0..1,0..1]
+            end
+            GC.start
+            n.should == NMatrix.new([2,2], [1,2,3,4]).cast(stype, :int32)
           end
-          GC.start
-          n.should == NMatrix.new(:dense, [2,2], [1,2,3,4]).cast(stype, :int32)
         end
 
         [:dense, :list, :yale].each do |cast_type|
-          it "should cast from #{stype.upcase} to #{cast_type.upcase}" do
-
+          it "should cast a square reference-slice from #{stype.upcase} to #{cast_type.upcase}" do
             nm_eql(@m[1..2, 1..2].cast(cast_type), @m[1..2,1..2]).should be_true
             nm_eql(@m[0..1, 1..2].cast(cast_type), @m[0..1,1..2]).should be_true
             nm_eql(@m[1..2, 0..1].cast(cast_type), @m[1..2,0..1]).should be_true
             nm_eql(@m[0..1, 0..1].cast(cast_type), @m[0..1,0..1]).should be_true
+          end
 
+          it "should cast a rectangular reference-slice from #{stype.upcase} to #{cast_type.upcase}" do
             # Non square
-            nm_eql(@m[0..2, 1..2].cast(cast_type), @m[0..2,1..2]).should be_true
-            nm_eql(@m[1..2, 0..2].cast(cast_type), @m[1..2,0..2]).should be_true
+            nm_eql(@m[0..2, 1..2].cast(cast_type), @m[0..2,1..2]).should be_true # FIXME: memory problem.
+            nm_eql(@m[1..2, 0..2].cast(cast_type), @m[1..2,0..2]).should be_true # this one is fine
+          end
 
-            # Full
+          it "should cast a square full-matrix reference-slice from #{stype.upcase} to #{cast_type.upcase}" do
             nm_eql(@m[0..2, 0..2].cast(cast_type), @m).should be_true
           end
         end

data/spec/blas_spec.rb

@@ -29,14 +29,15 @@
 require File.join(File.dirname(__FILE__), "spec_helper.rb")
 
 describe NMatrix::BLAS do
+
   [:rational32, :rational64, :rational128, :float32, :float64, :complex64, :complex128].each do |dtype|
     context dtype do
       # This is not the same as "exposes cblas trsm", which would be for a version defined in blas.rb (which
       # would greatly simplify the calling of cblas_trsm in terms of arguments, and which would be accessible
       # as NMatrix::BLAS::trsm)
       it "exposes unfriendly cblas_trsm" do
-        a     = NMatrix.new(:dense, 3, [4,-1.quo(2), -3.quo(4), -2, 2, -1.quo(4), -4, -2, -1.quo(2)], dtype)
-        b     = NVector.new(3, [-1, 17, -9], dtype)
+        a     = NMatrix.new(3, [4,-1.quo(2), -3.quo(4), -2, 2, -1.quo(4), -4, -2, -1.quo(2)], dtype: dtype)
+        b     = NMatrix.new([3,1], [-1, 17, -9], dtype: dtype)
         NMatrix::BLAS::cblas_trsm(:row, :right, :lower, :transpose, :nonunit, 1, 3, 1.0, a, 3, b, 3)
 
         # These test results all come from actually running a matrix through BLAS. We use them to ensure that NMatrix's
@@ -69,21 +70,17 @@ describe NMatrix::BLAS do
     context dtype do
 
       it "exposes cblas rot" do
-        x = NVector.new(5, [1,2,3,4,5], dtype)
-        y = NVector.new(5, [-5,-4,-3,-2,-1], dtype)
+        x = NMatrix.new([5,1], [1,2,3,4,5], dtype: dtype)
+        y = NMatrix.new([5,1], [-5,-4,-3,-2,-1], dtype: dtype)
         x, y = NMatrix::BLAS::rot(x, y, 1.quo(2), Math.sqrt(3).quo(2), -1)
 
-        x[0].should be_within(1e-4).of(-0.3660254037844386)
-        x[1].should be_within(1e-4).of(-0.7320508075688772)
-        x[2].should be_within(1e-4).of(-1.098076211353316)
-        x[3].should be_within(1e-4).of(-1.4641016151377544)
-        x[4].should be_within(1e-4).of(-1.8301270189221928)
-
-        y[0].should be_within(1e-4).of(-6.830127018922193)
-        y[1].should be_within(1e-4).of(-5.464101615137754)
-        y[2].should be_within(1e-4).of(-4.098076211353316)
-        y[3].should be_within(1e-4).of(-2.732050807568877)
-        y[4].should be_within(1e-4).of(-1.3660254037844386)
+        x.should be_within(1e-4).of(
+                   NMatrix.new([5,1], [-0.3660254037844386, -0.7320508075688772, -1.098076211353316, -1.4641016151377544, -1.8301270189221928], dtype: dtype)
+                 )
+
+        y.should be_within(1e-4).of(
+                   NMatrix.new([5,1], [-6.830127018922193, -5.464101615137754, -4.098076211353316, -2.732050807568877, -1.3660254037844386], dtype: dtype)
+                 )
       end
 
     end
@@ -94,7 +91,8 @@ describe NMatrix::BLAS do
 
       it "exposes cblas rotg" do
         pending("broken for :object") if dtype == :object
-        ab = NVector.new(2, [6,-8], dtype)
+
+        ab = NMatrix.new([2,1], [6,-8], dtype: dtype)
         c,s = NMatrix::BLAS::rotg(ab)
 
         if [:float32, :float64].include?(dtype)
@@ -102,6 +100,7 @@ describe NMatrix::BLAS do
           ab[1].should be_within(1e-6).of(-5.quo(3))
           c.should be_within(1e-6).of(-3.quo(5))
         else
+          pending "need correct test cases"
           ab[0].should be_within(1e-6).of(10)
           ab[1].should be_within(1e-6).of(5.quo(3))
           c.should be_within(1e-6).of(3.quo(5))
@@ -111,63 +110,32 @@ describe NMatrix::BLAS do
 
       # Note: this exposes gemm, not cblas_gemm (which is the unfriendly CBLAS no-error-checking version)
       it "exposes gemm" do
-        #STDERR.puts "dtype=#{dtype.to_s}"
-        #STDERR.puts "1"
-        n = NMatrix.new([4,3], dtype)
-        n[0,0] = 14.0
-        n[0,1] = 9.0
-        n[0,2] = 3.0
-        n[1,0] = 2.0
-        n[1,1] = 11.0
-        n[1,2] = 15.0
-        n[2,0] = 0.0
-        n[2,1] = 12.0
-        n[2,2] = 17.0
-        n[3,0] = 5.0
-        n[3,1] = 2.0
-        n[3,2] = 3.0
-
-        m = NMatrix.new([3,2], dtype)
-
-        m[0,0] = 12.0
-        m[0,1] = 25.0
-        m[1,0] = 9.0
-        m[1,1] = 10.0
-        m[2,0] = 8.0
-        m[2,1] = 5.0
+        n = NMatrix.new([4,3], [14.0,9.0,3.0, 2.0,11.0,15.0, 0.0,12.0,17.0, 5.0,2.0,3.0], dtype: dtype)
+        m = NMatrix.new([3,2], [12.0,25.0, 9.0,10.0, 8.0,5.0], dtype: dtype)
 
         #c = NMatrix.new([4,2], dtype)
         r = NMatrix::BLAS.gemm(n, m) #, c)
         #c.should equal(r) # check that both are same memory address
 
-        r[0,0].should == 273.0
-        r[0,1].should == 455.0
-        r[1,0].should == 243.0
-        r[1,1].should == 235.0
-        r[2,0].should == 244.0
-        r[2,1].should == 205.0
-        r[3,0].should == 102.0
-        r[3,1].should == 160.0
+        r.should == NMatrix.new([4,2], [273,455,243,235,244,205,102,160], dtype: dtype)
       end
 
 
       it "exposes gemv" do
-        #a = NMatrix.random(3)
-        #x = NVector.random(3)
-        a = NMatrix.new([4,3], [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0], :float64)
-        x = NVector.new(3, [2.0, 1.0, 0.0], :float64)
+        a = NMatrix.new([4,3], [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0], dtype: :float64)
+        x = NMatrix.new([3,1], [2.0, 1.0, 0.0], dtype: :float64)
 
         NMatrix::BLAS.gemv(a, x)
       end
 
       it "exposes asum" do
-        x = NVector.new(4, [1,2,3,4], :float64)
+        x = NMatrix.new([4,1], [1,2,3,4], dtype: :float64)
         NMatrix::BLAS.asum(x).should == 10.0
       end
 
 
       it "exposes nrm2" do
-        x = NVector.new(4, [2,-4,3,5], :float64)
+        x = NMatrix.new([4,1], [2,-4,3,5], dtype: :float64)
         NMatrix::BLAS.nrm2(x, 1, 3).should be_within(1e-10).of(5.385164807134504)
       end
 

data/spec/elementwise_spec.rb

@@ -32,8 +32,9 @@ describe NMatrix do
 
   context "yale" do
     before :each do
-      @n = NMatrix.new(:yale, 3, :int64)
-      @m = NMatrix.new(:yale, 3, :int64)
+      @n = NMatrix.new(3, stype: :yale, dtype: :int64)
+      @n.extend NMatrix::YaleFunctions
+      @m = NMatrix.new(3, stype: :yale, dtype: :int64)
       @n[0,0] = 52
       @n[0,2] = 5
       @n[1,1] = 40
@@ -52,13 +53,13 @@ describe NMatrix do
       x[1,1].should == 40 * 3
       x[2,0].should == 6 * 3
 
-      r = NMatrix.new(:yale, 3, :int64)
+      r = NMatrix.new(3, stype: :yale, dtype: :int64)
       y = r + 3
       y[0,0].should == 3
     end
 
     it "should refuse to perform a dot operation on a yale with non-zero default" do
-      r = NMatrix.new(:yale, 3, :int64)
+      r = NMatrix.new(3, stype: :yale, dtype: :int64)
       y = r + 3
       expect { y.dot(r) }.to raise_error
       expect { r.dot(y) }.to raise_error
@@ -74,7 +75,7 @@ describe NMatrix do
 
     it "should perform element-wise multiplication" do
       r = NMatrix.new(:dense, 3, [0,0,-25,0,-1920,0,0,0,0], :int64).cast(:yale, :int64)
-      m = NMatrix.new(:yale, 2, :int64)
+      m = NMatrix.new(2, stype: :yale, dtype: :int64)
       (@n*@m).should == r
     end
 
@@ -84,7 +85,7 @@ describe NMatrix do
     end
 
     it "should perform element-wise modulo" do
-      m = NMatrix.new(:yale, 3, :int64) + 5
+      m = NMatrix.new(3, stype: :yale, dtype: :int64, default: 0) + 5
       (@n % m).should == NMatrix.new(:dense, 3, [2,0,0,0,0,0,1,0,0], :int64).cast(:yale, :int64)
     end
 
@@ -130,13 +131,13 @@ describe NMatrix do
       x[1,1].should == 40 * 3
       x[0,1].should == 0
 
-      r = NMatrix.new(:list, 3, 1)
+      r = NMatrix.new(3, stype: :list, default: 1)
       y = r + 3
       y[0,0].should == 4
     end
 
     it "should perform element-wise addition" do
-      r = NMatrix.new(:list, 2, 0, :int64)
+      r = NMatrix.new(2, stype: :list, dtype: :int64, default: 0)
       r[0,0] = 52
       r[1,1] = -8
       q = @n + @m

data/spec/io_spec.rb

@@ -28,11 +28,13 @@ require "./lib/nmatrix"
 
 describe NMatrix::IO do
   it "repacks a string" do
-    NMatrix::IO::Matlab.repack("hello", :miUINT8, :dtype => :byte).should == "hello"
+    NMatrix::IO::Matlab.repack("hello", :miUINT8, :byte).should == "hello"
   end
 
   it "creates yale from internal byte-string function" do
-    n = NMatrix.new(:yale, [4,4], :byte, "\0\1\3\3\4", "\0\1\3\0\0\0\0\0\0\0\0", "\2\3\5\4", :byte)
+    ia = NMatrix::IO::Matlab.repack("\0\1\3\3\4", :miUINT8, :itype)
+    ja = NMatrix::IO::Matlab.repack("\0\1\3\0\0\0\0\0\0\0\0", :miUINT8, :itype)
+    n = NMatrix.new(:yale, [4,4], :byte, ia, ja, "\2\3\5\4", :byte)
     n[0,0].should == 2
     n[1,1].should == 3
     n[1,3].should == 5
@@ -54,13 +56,13 @@ describe NMatrix::IO do
 
   it "reads MATLAB .mat file containing a single dense integer matrix" do
     n = NMatrix::IO::Matlab.load_mat("spec/4x5_dense.mat")
-    m = NMatrix.new(:dense, [4,5], [16,17,18,19,20,15,14,13,12,11,6,7,8,9,10,5,4,3,2,1])
+    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])
     n.should == m
   end
 
   it "reads MATLAB .mat file containing a single dense double matrix" do
     n = NMatrix::IO::Matlab.load_mat("spec/2x2_dense_double.mat")
-    m = NMatrix.new(:dense, 2, [1.1, 2.0, 3.0, 4.0], :float64)
+    m = NMatrix.new(2, [1.1, 2.0, 3.0, 4.0], dtype: :float64)
     n.should == m
   end
 

data/spec/lapack_spec.rb

@@ -56,7 +56,7 @@ describe NMatrix::LAPACK do
   [:rational32, :rational64, :rational128, :float32, :float64, :complex64, :complex128].each do |dtype|
     context dtype do
       it "exposes clapack getrf" do
-        a = NMatrix.new(:dense, 3, [4,9,2,3,5,7,8,1,6], dtype)
+        a = NMatrix.new(3, [4,9,2,3,5,7,8,1,6], dtype: dtype)
         NMatrix::LAPACK::clapack_getrf(:row, 3, 3, a, 3)
 
         # delta varies for different dtypes
@@ -100,9 +100,9 @@ describe NMatrix::LAPACK do
 
       # Together, these calls are basically xGESV from LAPACK: http://www.netlib.org/lapack/double/dgesv.f
       it "exposes clapack getrs" do
-        a     = NMatrix.new(:dense, 3, [-2,4,-3,3,-2,1,0,-4,3], dtype)
+        a     = NMatrix.new(3, [-2,4,-3,3,-2,1,0,-4,3], dtype: dtype)
         ipiv  = NMatrix::LAPACK::clapack_getrf(:row, 3, 3, a, 3)
-        b     = NVector.new(3, [-1, 17, -9], dtype)
+        b     = NMatrix.new([3,1], [-1, 17, -9], dtype: dtype)
 
         NMatrix::LAPACK::clapack_getrs(:row, false, 3, 1, a, 3, ipiv, b, 3)
 
@@ -132,9 +132,9 @@ describe NMatrix::LAPACK do
                                     -9.15 -7.93 4.86 4.85 3.01
                                     9.57 1.64 8.83 0.74 5.80
                                     -3.49 4.02 9.80 10.00 4.27
-                                    9.84 0.15 -8.99 -6.02 -5.31|.map(&:to_f), dtype)
-          s_true = NMatrix.new([1,5], [27.468732418221848, 22.643185009774697, 8.558388228482576, 5.985723201512133, 2.014899658715756], dtype)
-          right_true = NMatrix.new([5,6], [0.5911423764124365, 0.2631678147140568, 0.35543017386282716, 0.3142643627269275, 0.2299383153647484, 0.0, 0.39756679420242547, 0.24379902792633046, -0.22239000068544604, -0.7534661509534584, -0.36358968669749664, 0.0, 0.03347896906244727, -0.6002725806935828, -0.45083926892230763, 0.23344965724471425, -0.3054757327479317, 0.0, 0.4297069031370182, 0.23616680628112555, -0.6858628638738117, 0.3318600182003095, 0.1649276348845103, 0.0, 0.4697479215666587, -0.350891398883702, 0.38744460309967327, 0.15873555958215635, -0.5182574373535355, 0.0, -0.29335875846440357, 0.57626211913389, -0.020852917980871258, 0.3790776670601607, -0.6525516005923976, 0.0], dtype)
+                                    9.84 0.15 -8.99 -6.02 -5.31|.map(&:to_f), dtype: dtype)
+          s_true = NMatrix.new([1,5], [27.468732418221848, 22.643185009774697, 8.558388228482576, 5.985723201512133, 2.014899658715756], dtype: dtype)
+          right_true = NMatrix.new([5,6], [0.5911423764124365, 0.2631678147140568, 0.35543017386282716, 0.3142643627269275, 0.2299383153647484, 0.0, 0.39756679420242547, 0.24379902792633046, -0.22239000068544604, -0.7534661509534584, -0.36358968669749664, 0.0, 0.03347896906244727, -0.6002725806935828, -0.45083926892230763, 0.23344965724471425, -0.3054757327479317, 0.0, 0.4297069031370182, 0.23616680628112555, -0.6858628638738117, 0.3318600182003095, 0.1649276348845103, 0.0, 0.4697479215666587, -0.350891398883702, 0.38744460309967327, 0.15873555958215635, -0.5182574373535355, 0.0, -0.29335875846440357, 0.57626211913389, -0.020852917980871258, 0.3790776670601607, -0.6525516005923976, 0.0], dtype: dtype)
           #right_true = NMatrix.new([5,6],
           # %w|-0.59 0.26   0.36   0.31   0.23
           #   -0.40   0.24  -0.22  -0.75  -0.36
@@ -143,7 +143,7 @@ describe NMatrix::LAPACK do
           #   -0.47  -0.35   0.39   0.16  -0.52
           #    0.29   0.58  -0.02   0.38  -0.65|.map(&:to_f),
           #  dtype)
-          left_true = NMatrix.new([5,5], [0.25138279272049635, 0.3968455517769292, 0.6921510074703637, 0.3661704447722309, 0.4076352386533525, 0.814836686086339, 0.3586615001880027, -0.24888801115928438, -0.3685935379446176, -0.09796256926688672, -0.2606185055842211, 0.7007682094072526, -0.22081144672043734, 0.38593848318854174, -0.49325014285102375, 0.3967237771305971, -0.4507112412166429, 0.2513211496937535, 0.4342486014366711, -0.6226840720358049, -0.21802776368654594, 0.14020994987112056, 0.5891194492399431, -0.6265282503648172, -0.4395516923423326], dtype)
+          left_true = NMatrix.new([5,5], [0.25138279272049635, 0.3968455517769292, 0.6921510074703637, 0.3661704447722309, 0.4076352386533525, 0.814836686086339, 0.3586615001880027, -0.24888801115928438, -0.3685935379446176, -0.09796256926688672, -0.2606185055842211, 0.7007682094072526, -0.22081144672043734, 0.38593848318854174, -0.49325014285102375, 0.3967237771305971, -0.4507112412166429, 0.2513211496937535, 0.4342486014366711, -0.6226840720358049, -0.21802776368654594, 0.14020994987112056, 0.5891194492399431, -0.6265282503648172, -0.4395516923423326], dtype: dtype)
           #left_true = NMatrix.new([5,5],
           #  %w|-0.25  -0.40  -0.69  -0.37  -0.41
           #    0.81   0.36  -0.25  -0.37  -0.10
@@ -151,16 +151,16 @@ describe NMatrix::LAPACK do
           #    0.40  -0.45   0.25   0.43  -0.62
           #   -0.22   0.14   0.59  -0.63  -0.44|.map(&:to_f),
           # dtype)
-          s   = NMatrix.new([5,1], 0, dtype)
-          u   = NMatrix.new([5,5], 0, dtype)
+          s   = NMatrix.new([5,1], 0, dtype: dtype)
+          u   = NMatrix.new([5,5], 0, dtype: dtype)
           ldu = 5
-          vt  = NMatrix.new([6,6], 0, dtype)
+          vt  = NMatrix.new([6,6], 0, dtype: dtype)
           ldvt= 6
         elsif [:complex64, :complex128].include? dtype
           #http://software.intel.com/sites/products/documentation/doclib/mkl_sa/11/mkl_lapack_examples/cgesvd_ex.c.htm
           pending "Example may be wrong"
         else
-          a = NMatrix.new([4,3], dtype)
+          a = NMatrix.new([4,3], dtype: dtype)
         end
         err = case dtype
               when :float32, :complex64
@@ -194,9 +194,9 @@ describe NMatrix::LAPACK do
                                     -9.15 -7.93 4.86 4.85 3.01
                                     9.57 1.64 8.83 0.74 5.80
                                     -3.49 4.02 9.80 10.00 4.27
-                                    9.84 0.15 -8.99 -6.02 -5.31|.map(&:to_f), dtype)
-          s_true = NMatrix.new([1,5], [27.468732418221848, 22.643185009774697, 8.558388228482576, 5.985723201512133, 2.014899658715756], dtype)
-          right_true = NMatrix.new([5,6], [0.5911423764124365, 0.2631678147140568, 0.35543017386282716, 0.3142643627269275, 0.2299383153647484, 0.0, 0.39756679420242547, 0.24379902792633046, -0.22239000068544604, -0.7534661509534584, -0.36358968669749664, 0.0, 0.03347896906244727, -0.6002725806935828, -0.45083926892230763, 0.23344965724471425, -0.3054757327479317, 0.0, 0.4297069031370182, 0.23616680628112555, -0.6858628638738117, 0.3318600182003095, 0.1649276348845103, 0.0, 0.4697479215666587, -0.350891398883702, 0.38744460309967327, 0.15873555958215635, -0.5182574373535355, 0.0, -0.29335875846440357, 0.57626211913389, -0.020852917980871258, 0.3790776670601607, -0.6525516005923976, 0.0], dtype)
+                                    9.84 0.15 -8.99 -6.02 -5.31|.map(&:to_f), dtype: dtype)
+          s_true = NMatrix.new([1,5], [27.468732418221848, 22.643185009774697, 8.558388228482576, 5.985723201512133, 2.014899658715756], dtype: dtype)
+          right_true = NMatrix.new([5,6], [0.5911423764124365, 0.2631678147140568, 0.35543017386282716, 0.3142643627269275, 0.2299383153647484, 0.0, 0.39756679420242547, 0.24379902792633046, -0.22239000068544604, -0.7534661509534584, -0.36358968669749664, 0.0, 0.03347896906244727, -0.6002725806935828, -0.45083926892230763, 0.23344965724471425, -0.3054757327479317, 0.0, 0.4297069031370182, 0.23616680628112555, -0.6858628638738117, 0.3318600182003095, 0.1649276348845103, 0.0, 0.4697479215666587, -0.350891398883702, 0.38744460309967327, 0.15873555958215635, -0.5182574373535355, 0.0, -0.29335875846440357, 0.57626211913389, -0.020852917980871258, 0.3790776670601607, -0.6525516005923976, 0.0], dtype: dtype)
           #right_true = NMatrix.new([5,6],
           # %w|-0.59 0.26   0.36   0.31   0.23
           #   -0.40   0.24  -0.22  -0.75  -0.36
@@ -205,7 +205,7 @@ describe NMatrix::LAPACK do
           #   -0.47  -0.35   0.39   0.16  -0.52
           #    0.29   0.58  -0.02   0.38  -0.65|.map(&:to_f),
           #  dtype)
-          left_true = NMatrix.new([5,5], [0.25138279272049635, 0.3968455517769292, 0.6921510074703637, 0.3661704447722309, 0.4076352386533525, 0.814836686086339, 0.3586615001880027, -0.24888801115928438, -0.3685935379446176, -0.09796256926688672, -0.2606185055842211, 0.7007682094072526, -0.22081144672043734, 0.38593848318854174, -0.49325014285102375, 0.3967237771305971, -0.4507112412166429, 0.2513211496937535, 0.4342486014366711, -0.6226840720358049, -0.21802776368654594, 0.14020994987112056, 0.5891194492399431, -0.6265282503648172, -0.4395516923423326], dtype)
+          left_true = NMatrix.new([5,5], [0.25138279272049635, 0.3968455517769292, 0.6921510074703637, 0.3661704447722309, 0.4076352386533525, 0.814836686086339, 0.3586615001880027, -0.24888801115928438, -0.3685935379446176, -0.09796256926688672, -0.2606185055842211, 0.7007682094072526, -0.22081144672043734, 0.38593848318854174, -0.49325014285102375, 0.3967237771305971, -0.4507112412166429, 0.2513211496937535, 0.4342486014366711, -0.6226840720358049, -0.21802776368654594, 0.14020994987112056, 0.5891194492399431, -0.6265282503648172, -0.4395516923423326], dtype: dtype)
           #left_true = NMatrix.new([5,5],
           #  %w|-0.25  -0.40  -0.69  -0.37  -0.41
           #    0.81   0.36  -0.25  -0.37  -0.10
@@ -213,26 +213,26 @@ describe NMatrix::LAPACK do
           #    0.40  -0.45   0.25   0.43  -0.62
           #   -0.22   0.14   0.59  -0.63  -0.44|.map(&:to_f),
           # dtype)
-          s   = NMatrix.new([5,1], 0, dtype)
-          u   = NMatrix.new([5,5], 0, dtype)
+          s   = NMatrix.new([5,1], 0, dtype: dtype)
+          u   = NMatrix.new([5,5], 0, dtype: dtype)
           ldu = 5
-          vt  = NMatrix.new([6,6], 0, dtype)
+          vt  = NMatrix.new([6,6], 0, dtype: dtype)
           ldvt= 6
         elsif [:complex64, :complex128].include? dtype
           #http://software.intel.com/sites/products/documentation/doclib/mkl_sa/11/mkl_lapack_examples/cgesvd_ex.c.htm
           pending "Example may be wrong"
-          a = NMatrix.new([4,3], [[  5.91, -5.69], [  7.09,  2.72], [  7.78, -4.06], [ -0.79, -7.21], [ -3.15, -4.08], [ -1.89,  3.27], [  4.57, -2.07], [ -3.88, -3.30], [ -4.89,  4.20], [  4.10, -6.70], [  3.28, -3.84], [  3.84,  1.19]].map {|e| Complex(*e) } , dtype)
-          s_true = NMatrix.new([3,1], [17.63, 11.61, 6.78], dtype)
-          left_true = NMatrix.new([4,4], [[-0.86, 0.0], [0.4, 0.0], [0.32, 0.0], [-0.35, 0.13], [-0.24, -0.21], [-0.63, 0.6], [0.15, 0.32], [0.61, 0.61], [-0.36, 0.1]].map {|e| Complex(*e)}, dtype)
-          right_true = NMatrix.new([4,3], [[ -0.22, 0.51], [ -0.37, -0.32], [ -0.53, 0.11], [ 0.15, 0.38], [ 0.31, 0.31], [ 0.09, -0.57], [ 0.18, -0.39], [ 0.38, -0.39], [ 0.53, 0.24], [ 0.49, 0.28], [ -0.47, -0.25], [ -0.15, 0.19]].map {|e| Complex *e} , dtype)
+          a = NMatrix.new([4,3], [[  5.91, -5.69], [  7.09,  2.72], [  7.78, -4.06], [ -0.79, -7.21], [ -3.15, -4.08], [ -1.89,  3.27], [  4.57, -2.07], [ -3.88, -3.30], [ -4.89,  4.20], [  4.10, -6.70], [  3.28, -3.84], [  3.84,  1.19]].map {|e| Complex(*e) } , dtype: dtype)
+          s_true = NMatrix.new([3,1], [17.63, 11.61, 6.78], dtype: dtype)
+          left_true = NMatrix.new([4,4], [[-0.86, 0.0], [0.4, 0.0], [0.32, 0.0], [-0.35, 0.13], [-0.24, -0.21], [-0.63, 0.6], [0.15, 0.32], [0.61, 0.61], [-0.36, 0.1]].map {|e| Complex(*e)}, dtype: dtype)
+          right_true = NMatrix.new([4,3], [[ -0.22, 0.51], [ -0.37, -0.32], [ -0.53, 0.11], [ 0.15, 0.38], [ 0.31, 0.31], [ 0.09, -0.57], [ 0.18, -0.39], [ 0.38, -0.39], [ 0.53, 0.24], [ 0.49, 0.28], [ -0.47, -0.25], [ -0.15, 0.19]].map {|e| Complex *e} , dtype: dtype)
 
-          s   = NMatrix.new([3,1], 0, dtype)
-          u   = NMatrix.new([4,4], 0, dtype)
+          s   = NMatrix.new([3,1], 0, dtype: dtype)
+          u   = NMatrix.new([4,4], 0, dtype: dtype)
           ldu = 4
-          vt  = NMatrix.new([3,3], 0, dtype)
+          vt  = NMatrix.new([3,3], 0, dtype: dtype)
           ldvt= 3
         else 
-          a = NMatrix.new([4,3], dtype)
+          a = NMatrix.new([4,3], dtype: dtype)
         end
         err = case dtype
               when :float32, :complex64