nmatrix 0.0.6 → 0.0.7

data/spec/blas_spec.rb

@@ -55,7 +55,7 @@ describe NMatrix::BLAS do
     end
   end
 
-  [:rational32,:rational64,:rational128,:complex64,:complex128].each do |dtype|
+  [:rational32,:rational64,:rational128].each do |dtype|
     context dtype do
       it "exposes cblas rot"
     end
@@ -65,13 +65,13 @@ describe NMatrix::BLAS do
     end
   end
 
-  [:float32, :float64].each do |dtype|
+  [:float32, :float64, :complex64, :complex128, :object].each do |dtype|
     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, y = NMatrix::BLAS::rot(x, y, 0.5, Math.sqrt(3)/2, -1)
+        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)
@@ -86,21 +86,29 @@ describe NMatrix::BLAS do
         y[4].should be_within(1e-4).of(-1.3660254037844386)
       end
 
+    end
+  end
+
+  [:float32, :float64, :complex64, :complex128, :object].each do |dtype|
+    context dtype do
+
       it "exposes cblas rotg" do
+        pending("broken for :object") if dtype == :object
         ab = NVector.new(2, [6,-8], dtype)
         c,s = NMatrix::BLAS::rotg(ab)
-        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))
+
+        if [:float32, :float64].include?(dtype)
+          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))
+        else
+          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))
+        end
         s.should be_within(1e-6).of(4.quo(5))
       end
 
-    end
-  end
-
-  [:float32, :float64, :complex64, :complex128].each do |dtype|
-    context dtype 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}"

data/spec/elementwise_spec.rb

@@ -65,11 +65,7 @@ describe NMatrix do
     end
 
     it "should perform element-wise addition" do
-      r = NMatrix.new(:dense, 3, [52,30,0,0,-8,0,6,0,0], :int64).cast(:yale, :int64)
-      r[0,0] = 52
-      r[1,1] = -8
-      q = @n + @m
-      q.should == r
+      (@n+@m).should == NMatrix.new(:dense, 3, [52,30,0,0,-8,0,6,0,0], :int64).cast(:yale, :int64)
     end
 
     it "should perform element-wise subtraction" do
@@ -213,6 +209,21 @@ describe NMatrix do
   end
 
   context "dense" do
+    context "scalar arithmetic" do
+      before :each do
+        @n = NMatrix.new(:dense, 2, [1,2,3,4], :int64)
+      end
+
+      it "works for integers" do
+        (@n+1).should == NMatrix.new(:dense, 2, [2,3,4,5], :int64)
+      end
+
+      #it "works for complex64" do
+      #  n = @n.cast(:dtype => :complex64)
+      #  (n + 10.0).to_a.should == [Complex(11.0), Complex(12.0), Complex(13.0), Complex(14.0)]
+      #end
+    end
+
     context "elementwise arithmetic" do
       before :each do
         @n = NMatrix.new(:dense, 2, [1,2,3,4], :int64)
@@ -241,16 +252,14 @@ describe NMatrix do
         r.should == NMatrix.new(:dense, [2,2], [-1, -2, 1, 0], :int64)
       end
 
-      #it "exponentiates" do
-      #  r = @n ** 2
-      #  # TODO: We might have problems with the dtype.
-      #  r.should == NMatrix.new(:dense, [2,2], [1, 4, 9, 16], :int64)
-      #end
+      it "exponentiates" do
+        r = @n ** 2
+        # TODO: We might have problems with the dtype.
+        r.should == NMatrix.new(:dense, [2,2], [1, 4, 9, 16], :int64)
+      end
 
       it "modulo" do
-        pending "% operator not yet implemented"
-        r = @n % @m
-        r.should == NMatrix.new(:dense, [2,2], [0, 1, 2, 3], :int64)
+        (@n % (@m + 2)).should == NMatrix.new(:dense, [2,2], [-1, 0, 1, 4], :int64)
       end
     end
 

data/spec/io_spec.rb

@@ -65,6 +65,7 @@ describe NMatrix::IO do
   end
 
   it "loads and saves MatrixMarket .mtx file containing a single large sparse double matrix" do
+    pending "spec disabled because it's so slow"
     n = NMatrix::IO::Market.load("spec/utm5940.mtx")
     NMatrix::IO::Market.save(n, "spec/utm5940.saved.mtx")
     `wc -l spec/utm5940.mtx`.split[0].should == `wc -l spec/utm5940.saved.mtx`.split[0]

data/spec/lapack_spec.rb

@@ -1,3 +1,4 @@
+        require 'pry'
 # = NMatrix
 #
 # A linear algebra library for scientific computation in Ruby.
@@ -38,6 +39,17 @@ describe NMatrix::LAPACK do
         b = NMatrix.new(:dense, [3,4], [3,2,4,1,7,6,8,5,11,10,12,9], dtype)
         a.should == b
       end
+
+      it "exposes NMatrix#permute_columns and #permute_columns! (user-friendly laswp)" do
+        a = NMatrix.new(:dense, [3,4], [1,2,3,4,5,6,7,8,9,10,11,12], dtype)
+        b = NMatrix.new(:dense, [3,4], [3,2,4,1,7,6,8,5,11,10,12,9], dtype)
+        piv = [2,1,3,0]
+        r = a.permute_columns(piv)
+        r.should_not == a
+        r.should == b
+        a.permute_columns!(piv)
+        a.should == b
+      end
     end
   end
 
@@ -114,7 +126,192 @@ describe NMatrix::LAPACK do
         end
       end
 
+      it "exposes gesdd" do
+        if [:float32, :float64].include? dtype
+          a = NMatrix.new([5,6], %w|8.79 9.93 9.83 5.45 3.16
+                                    6.11 6.91 5.04 -0.27 7.98
+                                    -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)
+          #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
+          #   -0.03  -0.60  -0.45   0.23  -0.31
+          #   -0.43   0.24  -0.69   0.33   0.16
+          #   -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],
+          #  %w|-0.25  -0.40  -0.69  -0.37  -0.41
+          #    0.81   0.36  -0.25  -0.37  -0.10
+          #   -0.26   0.70  -0.22   0.39  -0.49
+          #    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)
+          ldu = 5
+          vt  = NMatrix.new([6,6], 0, 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)
+        end
+        err = case dtype
+              when :float32, :complex64
+                1e-6
+              when :float64, :complex128
+                1e-15
+              else
+                1e-64 # FIXME: should be 0, but be_within(0) does not work.
+              end
+        err = err *5e1
+        begin
 
+          info = NMatrix::LAPACK::lapack_gesvd(:a, :a, a.shape[0], a.shape[1], a, a.shape[0], s, u, ldu, vt, ldvt, 500)
+
+        rescue NotImplementedError => e
+          pending e.to_s
+        end
+
+        u.should be_within(err).of(left_true)
+        #FIXME: Is the next line correct?
+        vt[0...right_true.shape[0], 0...right_true.shape[1]-1].should be_within(err).of(right_true[0...right_true.shape[0],0...right_true.shape[1]-1])
+        s.transpose.should be_within(err).of(s_true.row(0))
+      end
+
+
+      it "exposes gesvd" do
+        # http://software.intel.com/sites/products/documentation/doclib/mkl_sa/11/mkl_lapack_examples/dgesvd_ex.c.htm
+        if [:float32, :float64].include? dtype
+          a = NMatrix.new([5,6], %w|8.79 9.93 9.83 5.45 3.16
+                                    6.11 6.91 5.04 -0.27 7.98
+                                    -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)
+          #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
+          #   -0.03  -0.60  -0.45   0.23  -0.31
+          #   -0.43   0.24  -0.69   0.33   0.16
+          #   -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],
+          #  %w|-0.25  -0.40  -0.69  -0.37  -0.41
+          #    0.81   0.36  -0.25  -0.37  -0.10
+          #   -0.26   0.70  -0.22   0.39  -0.49
+          #    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)
+          ldu = 5
+          vt  = NMatrix.new([6,6], 0, 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)
+
+          s   = NMatrix.new([3,1], 0, dtype)
+          u   = NMatrix.new([4,4], 0, dtype)
+          ldu = 4
+          vt  = NMatrix.new([3,3], 0, dtype)
+          ldvt= 3
+        else 
+          a = NMatrix.new([4,3], dtype)
+        end
+        err = case dtype
+              when :float32, :complex64
+                1e-6
+              when :float64, :complex128
+                1e-15
+              else
+                1e-64 # FIXME: should be 0, but be_within(0) does not work.
+              end
+        err = err *5e1
+        begin
+
+          info = NMatrix::LAPACK::lapack_gesvd(:a, :a, a.shape[0], a.shape[1], a, a.shape[0], s, u, ldu, vt, ldvt, 500)
+
+        rescue NotImplementedError => e
+          pending e.to_s
+        end
+
+        u.should be_within(err).of(left_true)
+        #FIXME: Is the next line correct?
+        vt[0...right_true.shape[0], 0...right_true.shape[1]-1].should be_within(err).of(right_true[0...right_true.shape[0],0...right_true.shape[1]-1])
+        s.transpose.should be_within(err).of(s_true.row(0))
+
+      end
+
+
+      it "exposes geev" do
+        pending("needs rational implementation") if dtype.to_s =~ /rational/
+        ary = %w|-1.01 0.86 -4.60 3.31 -4.81
+                     3.98 0.53 -7.04 5.29 3.55
+                     3.30 8.26 -3.89 8.20 -1.51
+                     4.43 4.96 -7.66 -7.33 6.18
+                     7.31 -6.43 -6.16 2.47 5.58|
+        ary = dtype.to_s =~ /complex/ ? ary.map(&:to_c) : ary.map(&:to_f)
+
+        a   = NMatrix.new(:dense, 5, ary, dtype).transpose
+        lda = 5
+        n   = 5
+
+        wr  = NMatrix.new(:dense, [n,1], 0, dtype)
+        wi  = dtype.to_s =~ /complex/ ? nil : NMatrix.new(:dense, [n,1], 0, dtype)
+        vl  = NMatrix.new(:dense, n, 0, dtype)
+        vr  = NMatrix.new(:dense, n, 0, dtype)
+        ldvr = n
+        ldvl = n
+
+        info = NMatrix::LAPACK::lapack_geev(:left, :right, n, a.clone, lda, wr.clone, wi.nil? ? nil : wi.clone, vl.clone, ldvl, vr.clone, ldvr, -1)
+        info.should == 0
+
+        info = NMatrix::LAPACK::lapack_geev(:left, :right, n, a, lda, wr, wi, vl, ldvl, vr, ldvr, 2*n)
+
+        # Negate these and we get a correct result:
+        vr = vr.transpose
+        vl = vl.transpose
+
+        pending("Need complex example") if dtype.to_s =~ /complex/
+        vl_true = NMatrix.new(:dense, 5, [0.04,  0.29,  0.13,  0.33, -0.04,
+                                          0.62,  0.0,  -0.69,  0.0,  -0.56,
+                                         -0.04, -0.58,  0.39,  0.07,  0.13,
+                                          0.28,  0.01,  0.02,  0.19,  0.80,
+                                         -0.04,  0.34,  0.40, -0.22, -0.18 ], :float64)
+
+        vl.abs.should be_within(1e-2).of(vl_true.abs)
+        # Not checking vr_true.
+        # Example from:
+        # http://software.intel.com/sites/products/documentation/doclib/mkl_sa/11/mkl_lapack_examples/lapacke_dgeev_row.c.htm
+        #
+        # This is what the result should look like:
+        # [
+        #  [0.10806497186422348,  0.16864821314811707,   0.7322341203689575,                  0.0, -0.46064677834510803]
+        #  [0.40631288290023804, -0.25900983810424805, -0.02646319754421711, -0.01694658398628235, -0.33770373463630676]
+        #  [0.10235744714736938,  -0.5088024139404297,  0.19164878129959106, -0.29256555438041687,  -0.3087439239025116]
+        #  [0.39863115549087524,  -0.0913335531949997, -0.07901126891374588, -0.07807594537734985,   0.7438457012176514]
+        #  [ 0.5395349860191345,                  0.0, -0.29160499572753906, -0.49310219287872314, -0.15852922201156616]
+        # ]
+        #
+
+      end
     end
   end
 end

data/spec/nmatrix_spec.rb

@@ -29,6 +29,12 @@ require File.dirname(__FILE__) + "/spec_helper.rb"
 
 describe NMatrix do
 
+  it "adequately requires information to access a single entry of a dense matrix" do
+    n = NMatrix.new(:dense, 4, [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15], :float64)
+    n[0,0].should == 0
+    expect { n[0] }.should raise_error(ArgumentError)
+  end
+
   it "calculates exact determinants on small square matrices" do
     a = NMatrix.new(:dense, 2, [1,2,3,4], :int64)
     a.det_exact.should == -2
@@ -145,11 +151,6 @@ describe NMatrix do
     m.dtype.should == :float64
   end
 
-  it "dense pretty_prints complex values" do
-    n = NMatrix.new([4,3], COMPLEX_MATRIX43A_ARRAY, :complex128)
-    n.pretty_print
-  end
-
 
   [:dense, :list, :yale].each do |storage_type|
     context storage_type do
@@ -172,9 +173,9 @@ describe NMatrix do
       end
 
       it "enforces shape boundaries" do
-        lambda { NMatrix.new(storage_type, [1,10], storage_type == :yale ? :int8 : 0)[-1,0] }.should raise_error
-        lambda { NMatrix.new(storage_type, [1,10], storage_type == :yale ? :int8 : 0)[1,0]  }.should raise_error(ArgumentError, "out of range")
-        lambda { NMatrix.new(storage_type, [1,10], storage_type == :yale ? :int8 : 0)[0,10] }.should raise_error(ArgumentError, "out of range")
+        expect { NMatrix.new(storage_type, [1,10], storage_type == :yale ? :int8 : 0)[-1,0] }.should raise_error
+        expect { NMatrix.new(storage_type, [1,10], storage_type == :yale ? :int8 : 0)[1,0]  }.should raise_error(RangeError)
+        expect { NMatrix.new(storage_type, [1,10], storage_type == :yale ? :int8 : 0)[0,10] }.should raise_error(RangeError)
       end
 
       it "sets and gets" do
@@ -359,53 +360,53 @@ describe NMatrix do
   context "mapping and reduction related functions" do
 
     before :each do
-      @nm_1d = N[5.0,0.0,1.0,2.0,3.0]
-      @nm_2d = N[[0.0,1.0],[2.0,3.0]]
+      @nm_1d = NMatrix[5.0,0.0,1.0,2.0,3.0]
+      @nm_2d = NMatrix[[0.0,1.0],[2.0,3.0]]
     end
 
     it "behaves like Enumerable#reduce with no argument to reduce" do
       @nm_1d.reduce_along_dim(0) { |acc, el| acc + el }.to_f.should eq 11
-      @nm_2d.reduce_along_dim(1) { |acc, el| acc + el }.should eq N[[1, 5]]
+      @nm_2d.reduce_along_dim(1) { |acc, el| acc + el }.should eq NMatrix[[1, 5]]
     end
 
     it "should calculate the mean along the specified dimension" do
-      @nm_1d.mean.should eq N[2.2]
-      @nm_2d.mean.should eq N[[1.0,2.0]]
+      @nm_1d.mean.should eq NMatrix[2.2]
+      @nm_2d.mean.should eq NMatrix[[1.0,2.0]]
     end
 
     it "should calculate the minimum along the specified dimension" do
       @nm_1d.min.should eq 0.0
-      @nm_2d.min.should eq N[[0.0, 1.0]]
-      @nm_2d.min(1).should eq N[[0.0], [2.0]]
+      @nm_2d.min.should eq NMatrix[[0.0, 1.0]]
+      @nm_2d.min(1).should eq NMatrix[[0.0], [2.0]]
     end
 
     it "should calculate the maximum along the specified dimension" do
       @nm_1d.max.should eq 5.0
-      @nm_2d.max.should eq N[[2.0, 3.0]]
+      @nm_2d.max.should eq NMatrix[[2.0, 3.0]]
     end
 
     it "should calculate the variance along the specified dimension" do
-      @nm_1d.variance.should eq N[3.7]
-      @nm_2d.variance(1).should eq N[[0.5], [0.5]]
+      @nm_1d.variance.should eq NMatrix[3.7]
+      @nm_2d.variance(1).should eq NMatrix[[0.5], [0.5]]
     end
 
     it "should calculate the sum along the specified dimension" do
-      @nm_1d.sum.should eq N[11]
-      @nm_2d.sum.should eq N[[2], [4]]
+      @nm_1d.sum.should eq NMatrix[11]
+      @nm_2d.sum.should eq NMatrix[[2], [4]]
     end
 
     it "should calculate the standard deviation along the specified dimension" do
-      @nm_1d.std.should eq N[Math.sqrt(3.7)]
-      @nm_2d.std(1).should eq N[[Math.sqrt(0.5)], [Math.sqrt(0.5)]]
+      @nm_1d.std.should eq NMatrix[Math.sqrt(3.7)]
+      @nm_2d.std(1).should eq NMatrix[[Math.sqrt(0.5)], [Math.sqrt(0.5)]]
     end
 
     it "should raise an ArgumentError when any invalid dimension is provided" do
-      expect { @nm_1d.mean(3) }.to raise_exception(ArgumentError)
+      expect { @nm_1d.mean(3) }.to raise_exception(RangeError)
     end
 
     it "should convert to float if it contains only a single element" do
-      N[4.0].to_f.should eq 4.0
-      N[[[[4.0]]]].to_f.should eq 4.0
+      NMatrix[4.0].to_f.should eq 4.0
+      NMatrix[[[[4.0]]]].to_f.should eq 4.0
     end
 
     it "should raise an index error if it contains more than a single element" do
@@ -413,8 +414,8 @@ describe NMatrix do
     end
 
     it "should map a block to all elements" do
-      @nm_1d.map { |e| e ** 2 }.should eq N[25.0,0.0,1.0,4.0,9.0]
-      @nm_2d.map { |e| e ** 2 }.should eq N[[0.0,1.0],[4.0,9.0]]
+      @nm_1d.map { |e| e ** 2 }.should eq NMatrix[25.0,0.0,1.0,4.0,9.0]
+      @nm_2d.map { |e| e ** 2 }.should eq NMatrix[[0.0,1.0],[4.0,9.0]]
     end
 
     it "should map! a block to all elements in place" do
@@ -450,7 +451,7 @@ describe NMatrix do
       en = @nm_1d.reduce_along_dim(0, 1.0)
       en.each { |a, e| a+e }.to_f.should eq 12
       en = @nm_2d.reduce_along_dim(1, 1.0)
-      en.each { |a, e| a+e }.should eq N[[2.0],[6.0]]
+      en.each { |a, e| a+e }.should eq NMatrix[[2.0],[6.0]]
     end
 
     it "should iterate correctly for each_along_dim without a block" do
@@ -462,7 +463,7 @@ describe NMatrix do
       res = NMatrix.zeros_like (@nm_2d[0...2, 0])
       en = @nm_2d.each_along_dim(1)
       en.each { |e| res += e }
-      res.should eq N[[1.0], [5.0]]
+      res.should eq NMatrix[[1.0], [5.0]]
     end
 
     it "should yield matrices of matching dtype for each_along_dim" do
@@ -487,13 +488,13 @@ describe NMatrix do
     end
 
     it "should allow overriding the dtype for reduce_along_dim" do
-      m = N[[1,2,3], [3,4,5], :complex128]
+      m = NMatrix[[1,2,3], [3,4,5], :complex128]
       m.reduce_along_dim(1, 0.0, :float64) do |acc, sub_m|
         acc.dtype.should eq :float64
         acc
       end
 
-      m = N[[1,2,3], [3,4,5], :complex128]
+      m = NMatrix[[1,2,3], [3,4,5], :complex128]
       m.reduce_along_dim(1, nil, :float64) do |acc, sub_m|
         acc.dtype.should eq :float64
         acc
@@ -501,30 +502,30 @@ describe NMatrix do
     end
 
     it "should convert integer dtypes to float when calculating mean" do
-      m = N[[1,2,3], [3,4,5], :int32]
+      m = NMatrix[[1,2,3], [3,4,5], :int32]
       m.mean(0).dtype.should eq :float64
     end
 
     it "should convert integer dtypes to float when calculating variance" do
-      m = N[[1,2,3], [3,4,5], :int32]
+      m = NMatrix[[1,2,3], [3,4,5], :int32]
       m.variance(0).dtype.should eq :float64
     end
 
     it "should convert integer dtypes to float when calculating standard deviation" do
-      m = N[[1,2,3], [3,4,5], :int32]
+      m = NMatrix[[1,2,3], [3,4,5], :int32]
       m.std(0).dtype.should eq :float64
     end
 
     context "_like constructors" do
 
       it "should create an nmatrix of ones with dimensions and type the same as its argument" do
-        NMatrix.ones_like(@nm_1d).should eq N[1.0, 1.0, 1.0, 1.0, 1.0]
-        NMatrix.ones_like(@nm_2d).should eq N[[1.0, 1.0], [1.0, 1.0]]
+        NMatrix.ones_like(@nm_1d).should eq NMatrix[1.0, 1.0, 1.0, 1.0, 1.0]
+        NMatrix.ones_like(@nm_2d).should eq NMatrix[[1.0, 1.0], [1.0, 1.0]]
       end
 
       it "should create an nmatrix of zeros with dimensions and type the same as its argument" do
-        NMatrix.zeros_like(@nm_1d).should eq N[0.0, 0.0, 0.0, 0.0, 0.0]
-        NMatrix.zeros_like(@nm_2d).should eq N[[0.0, 0.0], [0.0, 0.0]]
+        NMatrix.zeros_like(@nm_1d).should eq NMatrix[0.0, 0.0, 0.0, 0.0, 0.0]
+        NMatrix.zeros_like(@nm_2d).should eq NMatrix[[0.0, 0.0], [0.0, 0.0]]
       end
     end
   end